Addendum: Of course any mention of building your own transistors would be remiss if it didn’t mention hacker-savant Jeri Ellsworth. She did an amazing job fabricating her own semiconductor devices, and in this video from Metalab, explains some of the basics.
While listening to the “This Week In Amateur Radio” podcast this morning, I heard reference to a new record setting non-line-of-sight one way contact that took place over optical wavelengths. A sucessful transmission over a distance of 288 kilometers was achieved by using an LED based transmitter. The report (PDF) provides many interesting details, such as their use of a GPS locked sound card to permit received signals to be resolved to just a milliHertz or so. Nice!
Here is some video of the transmitter in action. The floodlight that you see is generated by an array of 60 Luxeon LEDs, collimated by Fresnel lenses. Each LED is about 3.3 watts. Pretty cool.
Back in 2008, I blogged about a stupid program I wrote to implement a Morse Beacon on the Arduino. I couldn’t find that code, and it was stupid anyway, so I went ahead and implemented a new version, with an added improvement: it doesn’t hardcode dots and dashes, it has a built in table. Right now, the message is hardcoded into the program, but in the future, I’ll probably work up a trivial command language so you can change the message and speed, and store the message in the on-chip eprom. On the other hand, doing it by modifying the program source code isn’t really very much harder than getting a terminal to talk to your Arduino (it might even be easier) so this still might be the best way.
Basically, this just puts a logic high state on output pin #13 whenever the keydown should occur, and low when it is released. My Arduino is one of the older ones, so I needed to put an LED in myself, but I understand more modern ones have a built in LED. You could use whatever output pin you like though, with the obvious modification. To turn it into a full fledged keyer, you just need a transistor to handle the switching. On this model of Arduino, pin 13 has a 1K resistor in series to current limit, so you should just be able to put in any NPN transistor (base in pin 13, emitter to ground) and then use the collector/emitter to key the transmitter (I might also think about using an optoisolator, just to be safe).
This is overkill in a lot of ways: the program, sloppily as it is written only takes about 1/7 of the memory on my Arduino, and modern ones have double the space. We could do the same with a very small Atmel. But Arduinos are available and versatile, and have considerable potential. Worth playing with.
//
// Simple Arduino Morse Beacon
// Written by Mark VandeWettering K6HX
// Email: k6hx@arrl.net
//
// This code is so trivial that I'm releasing it completely without
// restrictions. If you find it useful, it would be nice if you dropped
// me an email, maybe plugged my blog @ https://brainwagon.org or included
// a brief acknowledgement in whatever derivative you create, but that's
// just a courtesy. Feel free to do whatever.
//
struct t_mtab { char c, pat; } ;
struct t_mtab morsetab[] = {
{'.', 106},
{',', 115},
{'?', 76},
{'/', 41},
{'A', 6},
{'B', 17},
{'C', 21},
{'D', 9},
{'E', 2},
{'F', 20},
{'G', 11},
{'H', 16},
{'I', 4},
{'J', 30},
{'K', 13},
{'L', 18},
{'M', 7},
{'N', 5},
{'O', 15},
{'P', 22},
{'Q', 27},
{'R', 10},
{'S', 8},
{'T', 3},
{'U', 12},
{'V', 24},
{'W', 14},
{'X', 25},
{'Y', 29},
{'Z', 19},
{'1', 62},
{'2', 60},
{'3', 56},
{'4', 48},
{'5', 32},
{'6', 33},
{'7', 35},
{'8', 39},
{'9', 47},
{'0', 63}
} ;
#define N_MORSE (sizeof(morsetab)/sizeof(morsetab[0]))
#define SPEED (12)
#define DOTLEN (1200/SPEED)
#define DASHLEN (3*(1200/SPEED))
int LEDpin = 13 ;
void
dash()
{
digitalWrite(LEDpin, HIGH) ;
delay(DASHLEN);
digitalWrite(LEDpin, LOW) ;
delay(DOTLEN) ;
}
void
dit()
{
digitalWrite(LEDpin, HIGH) ;
delay(DOTLEN);
digitalWrite(LEDpin, LOW) ;
delay(DOTLEN);
}
void
send(char c)
{
int i ;
if (c == ' ') {
Serial.print(c) ;
delay(7*DOTLEN) ;
return ;
}
for (i=0; i<N_MORSE; i++) {
if (morsetab[i].c == c) {
unsigned char p = morsetab[i].pat ;
Serial.print(morsetab[i].c) ;
while (p != 1) {
if (p & 1)
dash() ;
else
dit() ;
p = p / 2 ;
}
delay(2*DOTLEN) ;
return ;
}
}
/* if we drop off the end, then we send a space */
Serial.print("?") ;
}
void
sendmsg(char *str)
{
while (*str)
send(*str++) ;
Serial.println("");
}
void setup() {
pinMode(LEDpin, OUTPUT) ;
Serial.begin(9600) ;
Serial.println("Simple Arduino Morse Beacon v0.0") ;
Serial.println("Written by Mark VandeWettering <k6hx@arrl.net>") ;
Serial.println("Check out my blog @ https://brainwagon.org") ;
Serial.println("") ;
}
void loop() {
sendmsg("K6HX/B CM87") ;
delay(3000) ;
}
Addendum:
Addendum2:
Josh asked me how the morse code table works. It’s a little bit clever (a very little bit) but I guess it does require some explanation. Morse code characters are all length six or less, and each element is either a dot or a dash, so it would seem that we can store the pattern in six bits. Let’s say that dits are zero and dahs are one. Lets store them so the first element gets stored in the least significant bit, and the next in the second most, and so on. The only trick is knowing when there are no elements left, because otherwise we can’t tell (for example) K (-.-) from C (-.-.) To do that, we store a single extra one after all the other elements are taken care of. Then, when we are looping, we do the following. If the pattern is equal to one, we are done (that’s our guard bit). If not, we look at the least significant digit. If it is a zero, we have a dit, if we have a one, it’s a dah. We then get rid of that element (by dividing by two, or shifting right if that floats your boat) and repeat. Voila. Each character takes only a single byte to store its pattern, and decoding is just done in a few instructions.
Hope that helps.
Addendum3: Well, I couldn’t leave that alone, witness this…
There are many examples that people use to output sound, most of which seem to bang an output pin high or low, call delay to wait a given number of microseconds, then change its state. This seems odd to me, because the Arduino has some pretty good pulse width modulation. This can be used to make higher quality sound, but for me, it also proved to be easier. I just configured pin 9 to be an output pin, and then used analogWrite(9, 128) to turn on the sound, and analogWrite(9, 0) to turn the sound off. That’s it! You get about a 500hz tone, and it works really well.
Just flipping around the web tonight, found another interesting MEPT (Manned Experimental Propagation Transmitter) project that uses solar power an a small Atmel AVR processor. Very neat.
I was trying to remember where I had seen this excellent online book, and finally found the link that lead me to it. Archived here for posterity. Frank tries to never buy radios, but literally build his entire station. This isn’t to save money, it’s to foster an understanding of how things work in a way that a single individual can master. It’s a great way to think about amateur radio. Check it out, lots good inside.
I’m interested in short vertical antennas, so I keep collecting links to interesting article. K6MM has a nice description of his work with a 25 foot tall HWV antenna for 160M, built from three segments of PVC pipe, a capacitance “top hat” and 8 ground radials.
I think the idea of calling this “computerless” is a teensy bit misleading: he does use a PIC microcontroller to generate the necessary modulations. A PIC is still a computer, at least in my book.
This is just a brief note to myself to archive, well, what amounts to a single command that processes an audio file, but to stand as a placeholder for an interesting topic that I know virtually nothing about. 🙂
Here’s the basic idea: Amateur radio SSB communications are limited to narrow bandwidths (around 2.7khz is considered fairly typical). Unlike in conventional recording where fidelity might be desired, what is desired in amateur communications is to maximize the ability for you to understand the voice. Therefore, it’s fairly common for rigs to employ some kind of speech processing circuitry to modify the incoming voice signal to maximize its legibility. Often this is some hardware inside your rig, but it’s not unheard of for this functionality to be provided via software, either running on an embedded processor in your transceiver, or even as an external process running on your computer.
I was interested in trying to sort out what kind of processing was needed. It seemed to me that there were several components.
Resample the audio down to a lower sample rate (say around 8khz)
Bandpass filter the audio. My voice is fairly deep, but the frequencies below about 300hz aren’t very important for legibility. Wasting energy by sending them is probably misguided. Similarly for frequencies above 2700Hz or so, not for legibility, but because we don’t want our signals to be wide.
We want to have some kind of a “noise gate”. Background noise should drop out entirely.
Companding. We want lots of power to be placed in all the places where the noise gate isn’t on.
To prototype this idea, I recorded some audio (on my iPhone, it was convenient):
The command is a bit cryptic, but here’s the explanation. It specifies the input as being memo.wav, and the output will be compand.wav, resampled to 8khz and only one channel. The rest of the command specifies some processing to be done. The highpass and lowpass commands are there to trim the audio spectrum (I couldn’t remember how to specify bandpass filters with sox, but this works), followed by a “compand” function, which specifies attacks and decays at 0.1 seconds, followed by a list of gains. Each pair specifies an input power in db and an output power. Hence, -60db signals get mapped to -60db, but -40db signals get boosted to -10, -20 to -8, and so on. The overall signal is reduced by six db to avoid clipping. The polyphase command specifies a reasonably high quality rate converter to be used to downsample to 8khz.
The overall quality seems quite good, the legibility seems high and reasonably free of annoying artifacts. The only problem I see is in the pronunciation of “KAY” in my callsign, we lose most of the explosive sound at the beginning, and it sounds a lot like “AY”. I probably can adjust the attack/delay a bit to help that. I’ll muck with it some more in the future Ultimately my idea would be to implement a simple speech processor like this as a portable stand alone project. Using portaudio it should be very straightforward.
The Knightsqrss mailing list still intrigues me, although my own qrss beacon has been off the air for a while (I’m trying to get around to homebrewing its replacement, but have been distracted by other facets of life for a while). Recently, Eddie G3ZJO offered this rather interesting circuit which I scratched my head about for a while:
This “WSPR-ORGAN” is an interesting idea. It uses a 74HC86 Quad Exclusive NOR gate in a clever way. Two of the gates are configured as oscillators/inverters fed by a pair of identical crystals, one running with a fixed capacitance, the other with some capacitance switched in via a control signal. The output of these two oscillators is fed in to a third XNOR gate which serves as a mixer, producing sum and differences of the two signals. Eddie is interested in the difference, which is small (in the audible range) and which has little drift, since the two oscillators will likely have identical drift characteristics which will cancel out when using the signal to get the difference signal. What we essentially have is a very precise voltage controlled oscillator which puts out a signal in the audio range. Pretty neat.
The resulting discussion on the Knights was similarly interesting, and lead me to a series of interesting web pages. I hadn’t seen the 74HC86 used in this application before, but a little quick Googling lead me to Ian, VK3KRI’s page on using the 74HC86 as a crystal synthesizer. A diversion into the world of “subharmonic” mixers yielded a link to this interesting receiver design for QRSS which uses a common 5.0688Mhz oscillator which is tricked to operate at twice the frequency to provide good reception around the QRSS watering hole at 10.140Mhz. This page also links to LA8AK’s page which explains some of the interesting mixer ideas. Too much for me to absorb before coffee, but all cool stuff.
Addendum: Checking the prices of Digikey reveals that 5.0688Mhz crystals are in fact a very common item, and can be had for about $.40 a piece. Frankly, the 10.140 Mhz crystals offered by Expanded Spectrum Systems aren’t exactly burdensome, but it’s interesting to see other designs which make use of even more common crystal frequencies.
I missed out on last night’s Echolink QRP confab (Sundays, at 6:00PM Pacific time) but I did notice that Henry had posted a summary of topics and links (thanks again Henry) and included a link to Chuck Adam’s lab notebook. I’m just about to dash off to work, but it looks like it has lots of awesome tips and techniques on how to assemble homebrew circuits, and is 162 pages long. A nifty resource, and thanks to the Echolink QRP conference for bringing it to my attention.
While digging around for some information on crystal radios on the Internet (since i seemed to have misplaced the book on the subject I was looking for) I encountered some references to a book which happened to have been digitized and made available on archive.org. This book was published by the National Bureau of Standards, and no less of a luminary than Thomas Edison wrote:
This is the greatest book on this subject that I have ever read, and I want to congratulate you and your Bureau on its production.
Ben Tongue’s article on using a supercapacitor to hold energy harvested from an antenna tuned to strong local broadcast system got me thinking about supercapacitors again. Digging around uncovered a link to a DIY project (very simple) for creating your own electric screwdriver powered by supercaps. (I think they are a bit cavalier with the charging circuit, which basically just dumps the current from a USB port into the caps without any leveling or the like, but shrug….) One interesting thing that I found was that SparkFun apparently carries 10F (yes, 10 farad) 2.5 volt supercaps for around $5. Neat!
I subscribe to the very interesting QRP-L mailing list, and recently read an article by Michael Rainey, AA1TJ about an interesting radio and set of QSOs that he conducted. Michael’s experiments are amazing and cool, but I think his latest effort takes the cake: he had a number of QSOs using a transmitter powered entirely by the power of his own voice. He calls the project El Silbo and it is a transceiver which uses a loudspeaker as a generator that drives a very low power transmitter. I find it interesting because it is obvious that if you tried to yell, you might be heard over a distance of one or two kilometers, but Michael was able to use the same power to communicate over distances greater than a hundred kilometers. Very cool.
I don’t know why this percolated to the top of my consciousness today, but I thought I’d dump a link here so I can find it again. I recalled reading an article about the use of a particular special MOSFET device for use in crystal radios. It took me a tiny bit of time to find it, but here is a link to the Bob Cutler’s QST article A High Sensitivity Crystal Set. In conventional FET devices, the FET doesn’t conduct unless the gate voltage exceeds the threshold voltage. For a common power MOSFET like the IRF510, the threshold voltage might be 2 volts. For devices like the ALD110900A (datasheet here) the threshold is essentially zero. This makes a great variety of very lower power oscillators and amplifiers possible.
Cutler’s crystal set design is innovative because it doesn’t require an outdoor antenna or ground to function. It’s a zero power radio with enhanced performance provided by this MOSFET device. I’m not the only one who thinks so either: no less a radio luminary than Wes Hayward, W7ZOI found Cutler’s ideas thought provoking and interesting.
I was reviewing Stu’s articles on his “Ethergeist” blog again regarding his QRPp WSPR beacon, and was admiring his nice looking prototypes. I’ve goofed around with using tin snips to cut small pieces of copper clad and gluing them down to make solder pads, but Stu just uses a carbide tip scribing tool to cut straight lines into copper clad. The results look really nice, so I stopped and picked up a carbide tipped tool from Home Depot (about six bucks). Preliminary testing shows that it is necessary to use a straight edge and that it takes about ten passes to cut through the copper, but the resulting lines do look nice. I might use this on a future project.
