New arrivals from Adafruit, and minor updates…

I think Bill and Pete have been having way too much fun with the radio projects centered around the Arduino and the SI5351, so I decided to join them and ordered one of Adafruit’s SI5351 boards (I still have the kit from Jason’s Kickstarter which will almost certainly be better once I get up the nerve to do a little surface mount soldering). At the same time, I noticed that Adafruit had the new quad-core Raspberry Pi 2 boards in stock. It’s likely that my hummingbird cam may be resurrected onto this board to give me a little extra CPU oomph.


Oh, and the other items? I like to have plastic dinosaurs in my office, and the baseball was a ball I caught during an (otherwise completely forgettable) Oakland Athletics game.

I was informed by email that Pete was unable to achieve the same minor level of success that I had following my directions on how to get the Arduino 1.6.3 environment working with the I2C LCD display. For now, Pete seems content to use the 1.0.x versions, which I suppose is okay, but maybe we will revisit this sometime in the future. In the meantime Bill has had greater success in getting his Si5351 board working as a VFO/BFO, and has it mounted on some copper clad. Looks very nice. I should do a project like this.

Anywho… today’s aquisitions will likely show up in a future post/video. Stay tuned.

A (not entirely simple) LCD display for the Arduino…

I am a big fan of Bill Meara N2CQR and Pete Juliano N6QW, hosts of the really great Soldersmoke Podcast. Together, they chat about homebrewing ham radio equipment, and what they’ve learned in their lessons along the way. Their “tribal knowledge” is of terrific help to someone like me who keeps making small forays into the world of homebrew.

Warning: this post may be written at a level either below or above any readers experience, and either might find it boring. You’ve been warned. Additional warning: I probably made this more complicated than it should have been. Skip to the bottom to find the resolution.

During Soldersmoke 175, they expressed some disgruntlement with what I call “the Arduino Tower of Babel”. Despite the reputation of the Arduino being the easiest way to get into using microcontrollers in your own homebrew electronics project, it can be really daunting and fraught with frustration and peril. In particular, they seemed to be having problems with trying to get various “sketches” to compile and run properly, depending on what version of the Arduino IDE they were running. Via e-mail, I offered to try to help out, perhaps being as the Arduino Sherpa that could guide them to success. While I know there are lots of people out there who are more skilled, knowledgeable and experienced than I, I have enough general computer experience to often be able to sort out this kind of problem. I thought that instead of writing this all down as an email to them both, this might serve as a good bit of knowledge of general interest to those just getting started in using the Arduino and/or programming. A lot of this won’t come as much of a surprise to practitioners of the digital arts, but perhaps it might be of some use to someone (and hopefully Bill and Pete, although it appears that Bill has at least made some headway).

First of all, the way most people interact with the Arduino is through the Interactive Development Environment, commonly referred to as the IDE. It is a pretty simple looking program (well, as such things go, it can be daunting for beginners) which is actually a wrapper around several different components. What the user typically sees is a window where he can enter “sketches” (what most people would call “programs”), and a series of buttons that will allow you to load, save, compile and download code to the target Arduino board that is connected via the USB port.

Like most software that is popular, it’s being constantly revised: new versions are being created all the time. Because it is what is called an “open source” project, it isn’t a single company that is responsible for changes, it evolves by the contribution of many different contributors. Each “release” of the code is tagged with a version number. As of this date, the latest version of the Arduino that you can download from the primary site is 1.6.3. Because people hate to upgrade software though, many people are using older versions of the software, with some common versions being 1.0.5.

I mentioned that the Arduino IDE consisted of many different components: among these are a set of standardized “libraries” that encapsulate common functionality that lots of people find useful. When you use the Serial or Wire libraries, you are actually using code that is shipped with the Arduino IDE. These “standard” libraries usually work well right out of the box, and don’t change all that often. Thus, if you had a sketch which uses those libraries, or even more basic calls like digitalRead or digitalWrite, you probably won’t notice a lot of differences.

But some code is not part of the standard distribution. For instance, Pete was having difficulty getting an LCD display unit working properly with different versions of the Arduino IDE. I thought it might be a fun excuse to pick up an LCD panel to play with, so I asked him which one he used, and he emailed back this link, which seemed like a cool device. A mouse click, and two days via Amazon Prime, and I had one in my hand.



A pretty nice little unit, a little bigger than I expected. If you look at the back, you’ll see that it’s got a little board that looks a bit out of place connected to the back. It’s made by the company Sainsmart, and has four simple pins connected to the back. That board is an converter which turns the display board (which are fairly common, but require a lot more connections) to instead use what is called the “I2C bus”. To get this display working requires a lot less wiring: just +5v and ground, and then two data pins, called SDA and SCL (the “serial data” and “serial clock”, respectively). This makes hardware hookup a lot easier than the conventional (and somewhat cheaper) models.

If you had an ordinary LCD without this backpack, you could use the standard “LiquidCrystal” library that ships with the Arduino IDE (documented here.) If you read the manual page for the “constructor” (the statement which creates a “LiquidCrystal” object that you can interact with), you can see that there are a bunch of ways to create one, depending on how you wire it up. These standard LCD panels require somewhere between six and eleven connections (plus power and ground) which can be a headache.

By contrast, this panel requires only two lines. Awesome! What’s even more awesome is that you can attach other devices that use the I2C bus to the same two lines. Each peripheral has a unique “address”, so programs can talk to each device independently, without adding any more wiring.

But there is a seemingly small problem, one that is familiar to users of desktop computers. To use these special devices, you need a custom library (think of a custom Windows device driver) that knows how to talk to this device. And here begins the problems that Pete and Bill had.

The libraries that ship with the official IDE are usually pretty well thought out, checked to make sure that they work well with the IDE, and are compatible. But this requires a custom library, and those libraries are not always tested against all versions of the IDE. Sometimes they work. Sometimes, not so much.

And, what’s worse is that this code isn’t versioned or vetted. You can have different versions of the code with the same library name. It’s hard to know what versions are the best, which are later revisions and which are earlier, and which were created or modified by, shall we say, less good programmers?

Okay, back to our LCD display.

I did what I always do, I googled and found this this version of something called LiquidCrystal_I2C as the top response. That seemed promising. Version 2.0! I downloaded it and installed it (by the way, installing libraries can be annoying in the Arduino IDE, maybe I will rant about that some other day, but you can find out the “right” way to do it here), opened their “Hello World” program, compiled and downloaded and…


Screen glitched a little, and rows of black squares. Argh.

Double checked the wiring. Nothing seemed to be wrong. Hmmm.

Deleted that version of the library, and after some judicious surfing, uncovered this driver on the dfrobot website. They make a board which looks an awful lot like the sainsmart board. I thought I’d give it a whirl, even though it’s version 1.1 (and therefore presumably older).




It’s at times like this that I feel waves of, well, if not rage then annoyance. I haven’t had the chance to figure out what the issue is (I’m an hour into this already, and it’s supper time) and have no doubt that I’ll be able to figure out what’s going on, but it’s annoying to beginners and experts alike that we have to do this kind of spelunking. Until I sort out this issue, I’ll just make a few recommendations:

  • If you can use hardware supported by the standard libraries that ship with the Arduino, it’s probably worth doing.
  • If you can’t (or choose not to) then perhaps do some searches to find what other people are doing to get stuff working.
  • Document your success and failures as best you can on the web somewhere. Be specific as to which version and platform (Windows, Mac, Linux) you are using.
  • I actually recommend using the latest version of the IDE that’s available at, the official website. The older versions may “work just fine”, but you aren’t going to be able to take advantage of the many bug fixes and updates, and if you are interacting with other newbies, your code may not work. Best to get your own house in order, and then throw stones at whoever has code which doesn’t work properly with the latest official IDE.

To Bill and Pete: I feel your pain. I’d expect a device as common as this to work more or less out of the box. I’ll see if I can make a better suggestion soon. You might try using the code that worked for me, but that’s a poor solution really: I’m recommending using a modern IDE with old code. I’ll work on coming up with a better solution.

Addendum: Pete, in your email you indicated that the I2C address for your board was 0x3F. On mine, it actually turned out to be 0x27. I found this out by using an “I2C Bus Scanner”, a little sketch that runs on the Arduino and tries to find any devices by running through all 128 addresses. I was shocked to find that it’s not part of the standard examples, but if you google for “arduino i2c bus scanner” you can find code for many simple examples. It should be noted that this one I found screwed me up for a few minutes by printing the address in decimal, rather than hex.

Addendum2: Sigh. I may have been working too hard. Looking at the “official” distribution, it appears that the library does support I2C displays, although as near as I can tell, it’s completely undocumented, and none of the examples will work out of the box. I’ll figure out the right juju to get it to work soon, and will post it below.

Addendum3: In the words of Bill and Pete:


Giving up for a moment, it’s acting stupidly on one of my dev machines. Hopefully what I said was not entirely wrong above, but it might be.

Addendum4: I was confused, but the rabbit hole keeps getting deeper. The version installed with 1.6.3 does not support I2C LCD displays. I was misled by looking at my installation on my Mac, which is not the standard 1.6.3, but is based on a system called platformio. When it installs code for the Arduino, it installs this version of the LCD library. You can download the code for it here. It supports both the traditional 8 and 4 bit parallel interfaces, as well as the I2C based version, and seems to be well documented. One bummer: it’s thought of as a direct drop in replacement for the standard system library, so you basically have to delete the installed LiquidCrystal library, and replace it with this one. Read the instructions here. It all looks good, except for one thing:

It doesn’t seem to work properly with the Sainsmart interface either.


I know that part of this is that there are dozens of clones and near clones out there, and it’s hard for the library writers to know about all of them, but this is genuinely crazy.

Addendum5: Wow, this is totally crazy. If you go to the Sainsmart page for the “LCD2004”, you’ll find a rar file which includes the library to access this hardware. Except of course, that library is years old and will only work with versions 1.0 of the Arduino IDE.


That’s it Bill and Pete. I’m giving up on digital electronics, and am going to spend the rest of the evening looking for good deals on dual gate FETs and crystals for filters.

SSTV from the ISS…

Well, it’s not pretty, but I was just using a 17″ whip antenna on my VX-8GR, recorded it with Audacity, and then decoded it with MultiScan on my Macbook. The first bit of the recording is pretty rocky, so I had to start the sync myself. I’ve bean meaning to do some experiments with bad audio and sync recovery, now I have more data.

Oh, in case this was all gibberish to you, the Russians have been running “events” from the International Space Station to honor their cosmonauts by transmitting pictures via slow scan television (SSTV). I received this picture using what most people would call a walkie talkie, a whip antenna, and a laptop.

As decoded by Multiscan:


I thought a second image would have begun later in the pass, but didn’t hear it.

I think an antenna with a little more gain, and/or a preamplifier would help a lot. You really need pretty noise free audio to make a good picture. Still, a fun experiment. I might try the 12:30AM pass tonight.

Addendum: The second pass was also a little rocky. Got the tail end of one transmission fairly cleanly, but the three minute gap to the next one meant it was low. This is what I got.

second pass

More on hummingbirds…

I imagine that some of you are getting bored with this, so I won’t post another 20 minutes of hummingbird video. But I will post a couple of things. For instance, I cut a frame from the videos at the beginning of the day and at the end of the day. You can clearly see the level of nectar in the feeder drop. They don’t seem to eat a lot.


John wondered (quite rightly) whether I could get the camera positioned in a better position so I could get something other than the near silhouette images that I had yesterday. I’d have to move the camera outdoors, which means I’d have to make a better enclosure. But tonight the setting sun was fairly low and sidelit the birds in a couple of my late captures. Here is a late still frame…

Screen Shot 2015-04-10 at 8.15.45 PM

And some of the video shot late in the day…

Slow Scan Television from the ISS this weekend…

Note: This post was adapted by an email that I sent out to our ham radio club.

If anyone is interested in a fun little ham radio related activitytonight, you can try to receive slow scan television from the International Space Station this weekend. I haven’t done this in a while,but I think I’ll give it a try and see what I can come up with.

You can read about this event here:

AMSAT UK on the upcoming ISS event

They will be on 145.800Mhz (in the 2m band).

The way I usually “work” these is to use one of my HTs. A better antenna than the stock one is usually good (a longer whip, or even a yagi) but you might just see what you can here with the stock antenna. The ISS transmits with 25 watts of power, which is usually pretty easy to hear. I have a set of earphones that I hook with a splitter. One half goes to my earbuds, the other to a small digital audio recorder I have. Turn the squelch on your radio off so you can here the signal when it is weak. You may find that moving your antenna round will help a bit, so monitor with your earphones. Don’t be shocked if you don’t hear the ISS right at the rise time: it has 3 minutes of dead time between transmissions, which take about 3 minutes to send. It sounds a bit like a ticking of a clock, with a whistle in between, if you click this link, you can hear what it sounds like:

I like to record the audio, then play it back into my Windows PC and use the MMSSTV program, but you can actually go completely low tech and try an inexpensive iphone app, held up to the speaker of your HT. I use

Black Cat System’s SSTV program for the iPhone/Ipad

which works okay, not amazing. If you are out doors in a windy or noisy location, your image won’t be as good this way: the bg noise will cause interference.

To help out, I computed a set of rise/set/max elevation tables centered on San Francisco. If you live close, you can probably use these times. If you live in other parts of the country, you might try looking at the Heaven’s Above website. Select “Passes to include” to be all, and enter your location in the upper right. The table below was calculated by my own software.

Rise time           Azi    Max Elev Time        Elev  Set time             Azi
2015/04/11 16:24:33 178.90 2015/04/11 16:28:52   9.27 2015/04/11 16:33:10  74.10 (Local Time)
2015/04/11 23:24:34 178.90 2015/04/11 23:28:52   9.27 2015/04/11 23:33:11  74.10 (UTC)

2015/04/11 17:59:18 232.14 2015/04/11 18:04:47  76.70 2015/04/11 18:10:17  49.52 (Local Time) [1]
2015/04/12 00:59:18 232.14 2015/04/12 01:04:48  76.70 2015/04/12 01:10:17  49.52 (UTC)

2015/04/11 19:36:48 276.47 2015/04/11 19:41:38  13.93 2015/04/11 19:46:28  40.34 (Local Time)
2015/04/12 02:36:48 276.47 2015/04/12 02:41:38  13.93 2015/04/12 02:46:28  40.34 (UTC)

2015/04/11 21:15:06 309.66 2015/04/11 21:19:13   7.29 2015/04/11 21:23:21  47.92 (Local Time)
2015/04/12 04:15:06 309.66 2015/04/12 04:19:14   7.29 2015/04/12 04:23:21  47.92 (UTC)

2015/04/11 22:52:10 319.85 2015/04/11 22:56:52  12.34 2015/04/11 23:01:34  78.97 (Local Time) [2]
2015/04/12 05:52:10 319.85 2015/04/12 05:56:53  12.34 2015/04/12 06:01:35  78.97 (UTC)

2015/04/12 00:28:22 312.09 2015/04/12 00:33:48  58.58 2015/04/12 00:39:14 122.75 (Local Time) [3]
2015/04/12 07:28:22 312.09 2015/04/12 07:33:49  58.58 2015/04/12 07:39:15 122.75 (UTC)

2015/04/12 02:05:15 289.69 2015/04/12 02:09:49  11.95 2015/04/12 02:14:23 174.60 (Local Time)
2015/04/12 09:05:16 289.69 2015/04/12 09:09:50  11.95 2015/04/12 09:14:24 174.60 (UTC)

[1] Probably the easiest pass, the ISS passes almost straight overhead,
should be loud and easy.

[2] A low night time pass, but the ISS should be visible to the naked eye.

[3] Another night time pass, but too late for the ISS to catch any
sun. 58 degrees is a good pass, the second one.

If I get any good images, I’ll send them out next week.

Minor tweaks to Arduino Morse Sketch…

Commenter Andy wanted a version of my classic code that could generate a tone instead of just blinking an LED. I mentioned that I had done this before, but frankly couldn’t find the source code, so I modified my existing program to implement the simplest possible tone: a simple square wave.

Rather than using a speaker, I wired up a little piezo element which I had soldered a couple of leads onto my junk pile. These disks are terrible at reproducing low frequencies and have strong resonances, but for this purpose, it was convenient. You can substitute a speaker if you like. It’s probably a good idea to use a little drive transistor with an 8 ohm speaker to provide more drive: you can see the basic idea here. It is nominally targeted toward mbed microcontrollers, but nothing about it is specific to those. Anyway, I hooked the positive lead of the element up to pin 9, and the negative lead to ground.


I also hooked up my oscilloscope so I could verify that the tone was coming out at the proper frequency. Indeed, it appears that it works just fine.


Additionally, I made a few other small changes to my program. The prior version stored the static table in RAM, which is wasteful of a hundred or so bytes of RAM. It doesn’t sound like a lot, but there are only 2048 bytes of RAM available, so every little bit helps.

Addendum: If you want to generate nicer looking sine waves, you could do a lot worse than to use this circuit from Jason, NT7S which serves as a nice little oscillator. It’s a nice little Twin-T oscillator, followed by a very simple little amplifier. You could use an optocoupler in place of the key to drive it, or probably just key it with another 2N2222 or similar transistor.

Addendum2: If you want to go all out, a circuit like this one has a very pretty keying waveform.

// Simple Arduino Morse Beacon
// Written by Mark VandeWettering K6HX
// Email:
// 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 @ or included
// a brief acknowledgement in whatever derivative you create, but that's
// just a courtesy.  Feel free to do whatever.
// At the request of Andy, I added support to use the Arduino Tone library
// to generate an audio signal (really just a square wave) at 700hz on 
// pin 9 (can be any pin which supports PWM, on the Arduino Uno, those pins
// are 3, 5, 6, 9, 10 or 11, and are usually marked with a dash next to them).
// NOTE: the audio signals is just a square wave.  It's not got a great 
// tone, and may click or chirp at the end.  It's mostly useful as a 
// sidetone generator, and probably should not be fed into the mic input
// of a transmitter to send MCW.

// This defines the pin that will have the audio signal

const int sndPin = 9 ;        

// Sound frequency (in Hz)
#define SND_FREQ        (700)

// If you leave NOISY defined, the Arduino will print out each character
// as it is sent to the serial port.  You might want to comment this out
// (put // at the start of the line) if you are especially cramped for
// memory, otherwise it doesn't hurt to leave it in place, even if you
// don't hook the serial port to anything.
// If NOISY is defined, then the size of the program is...
//      Program:    4938 bytes (15.1% Full)
//      (.text + .data + .bootloader)
//      Data:        399 bytes (19.5% Full)
//      (.data + .bss + .noinit)
// If NOISY isn't defined
//      Program:    2964 bytes (9.0% Full)
//      (.text + .data + .bootloader)
//      Data:         48 bytes (2.3% Full)
//      (.data + .bss + .noinit)

#define NOISY

struct t_mtab { char c, pat; } ;

// Compared to my earlier version of this code, we can 
// save some precious RAM by storing this constant table
// in flash memory.  

const struct t_mtab morsetab[] PROGMEM = {
    {'.', 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))

const int LEDpin = 13 ;

  digitalWrite(LEDpin, HIGH) ;      // turn on the LED
  tone(sndPin, SND_FREQ) ;          // and the sound output..
  digitalWrite(LEDpin, LOW) ;       // then back off
  noTone(sndPin) ;                  // and silence...
  delay(DOTLEN) ;

  digitalWrite(LEDpin, HIGH) ;      // again, LED on...
  tone(sndPin, SND_FREQ);           // and sound...
  digitalWrite(LEDpin, LOW) ;       // off...
  noTone(sndPin) ;                  // quiet...

send(char c)
  unsigned int i ;
  if (c == ' ') {
#ifdef NOISY
    Serial.print(c) ;
    delay(7*DOTLEN) ;
    return ;
  for (i=0; i<N_MORSE; i++) {
    if (pgm_read_byte(&(morsetab[i].c)) == c) {
      unsigned char p = pgm_read_byte(&(morsetab[i].pat)) ;
#ifdef NOISY
      Serial.print(c) ;
      while (p != 1) {
          if (p & 1)
            dash() ;
            dit() ;
          p = p / 2 ;
      delay(2*DOTLEN) ;
      return ;
  /* if we drop off the end, then we send a space */
#ifdef NOISY
  Serial.print("?") ;

sendmsg(const char *str)
  while (*str)
    send(*str++) ;
#ifdef NOISY

void setup() {
  pinMode(LEDpin, OUTPUT) ;
  pinMode(sndPin, OUTPUT) ;
#ifdef NOISY
  Serial.begin(9600) ;
  Serial.println("Simple Arduino Morse Beacon v1.0") ;
  Serial.println("Written by Mark VandeWettering <>") ;
  Serial.println("Check out my blog @") ;
  Serial.print("LED will blink on pin ");
  Serial.print("Sound will be generated on pin ");
  Serial.println("") ;

void loop() {
  sendmsg("K6HX/B CM87") ;

  tone(sndPin, SND_FREQ) ;
  noTone(sndPin) ;
  delay(3000) ;

A 6M beacon using the NT7S’s Si5351 board…

This morning, the Tweeti-verse (I can’t believe I just used that word) informed me that Thomas, LA3PNA had constructed a VHF beacon using the Si5351, and I was tagged as somehow helping:

Sure enough, I’m getting lots of mileage out of the very simple Morse generating code that I posted a while back. But the real star of this was Jason Mildrum (NT7S) and his awesome little Si5351 breakout board that he designed and made available via Indiegogo, as well as a nice little Arduino library to control the board. For those of you who don’t follow this stuff, the Si5351 is a nifty little board that is capable of generating three frequencies at once under the control of a microcontroller like the Arduino. Guys like Jason and Pete Juliani, N6QW, have been experimenting using this device as the basis for frequency generation in a variety of experimental radios. I received my kit last week, and hope to get the board up and running this week. Stay tuned!

Old Radio Publications available online…

I like reading old books and old magazines. Luckily, the Internet is making a lot of that kind of material available online for free. A couple of quick links to some items I’ve found recently on the subject of amateur radio:

  • Radio News was published from 1919 to 1959. PDF scans of every issue are available.
  • 73 Magazine may be more familiar to many more hams. It was published from 1960 until 2003. Its founder Wayne Green, W2NSD often wrote editorials critical of the American Radio Relay League, and therefore provides an interesting contrast to the ARRL’s QST magazine.
  • QST is the publication of the ARRL. Their archives are also available, but only to members of the society (one of the primary reasons that I continue to be a member).

Lots of reading for the radio amateur.

The Si570 and the Si5351

Thomas’ talk about the Minima at Pacificon has got me thinking about building one of my own. I actually have quite a few of the necessary parts in my junk box, but lacked a few things, so I made a quick list and sent a quick order off to Tayda. Tayda has really good prices on many of the discretes, connectors, sockets, etc… and even carries the ATMega 328 and LCD panels. Oh, and I got 25 20 Mhz crystals at $.10 each.

But they don’t carry the Si570 (not surprising). I found I could order those from Digikey, but they have an unusual footprint, and didn’t seem the most easy thing to breadboard. Most of the homebrewers seem to build the Minima on perfboard, but they seem to sketch over the details as to how they mount/solder this part down. I’ve been considering making my own version of the digital board and getting a pcb manufactured from OSHpark, and still might do that: I am reasonably capable at surface mount soldering. It might also allow me to make a couple of other changes to the digital circuitry:

  • I think relying on the disabling of pull ups in the ATMega to keep from frying the Si570 is just a bit sloppy. Two resistors and a 2N7000 will implement a simple level converter, and cost about $.50 for both lines.
  • I’ve actually thought it might be good to make the entire digital board run on 3.3v.
  • Considering a change in the LCD as well. Might be good to have a graphical LCD, or one that runs on lower power.
  • I like the idea of using rotary encoders instead of a pot.
  • A basic keypad might also prove useful.

Anyway, I’m getting a bit astray. To experiment, I thought it might be good to see if I could get an Si570 on a tiny breakout board so I could breadboard this up before building it for real. While surfing around and also reading today’s mail from the Minima mailing list, I learned about the Si5351. There is some speculation on the mailing list as to whether it is a reasonable chip to use in place of the Si570. In particular, people are concerned about its noise performance. But it does at least have some intriguing features:

  • It’s cheaper.
  • It is a more conventional package (10-MSOP, still surface mount, but more conventional)
  • It can generate 3 different clocks simultaneously (it could potentially replace both the BFO and LO)
  • NT7S has already written the code to interface to it.
  • Adafruit already has a nice little breakout board for it that only costs 8 bucks. It’s also already got pads to add some SMA connectors, which could make it a nice little bit of test equipment.

I’m not sure how to evaluate its performance, but it is at least possible to use it as the building block for an SSB transciever, as demonstrated by Jason NT7S using it in this reciever based upon the SA602:

And another early test in a QSO with AA7EE:

Jason has clearly been on top of this chip for a while, surfing his blog for the si5351 tag gives a ton of cool information. He even has his own board, quite similar to the Adafruit board, but it includes isolation transformers for each channel. Very nifty, and probably better suited for RF work than Adafruit’s board. Jason says he might e kitting a batch of the boards for sale: I’m gonna stay tuned.

Nifty stuff.

A day at Pacificon…

Pacificon is the local yearly hamfest, which took place at the Santa Clara Marriot this weekend. I couldn’t go for the entire weekend, but I decided that spending at least part of my Saturday amongst my fellow hams would be good fun, so I set my alarm to an annoyingly early time (for the weekend) so that I would be able to drive down ahead of the first Saturday session (which began at 8:15) and went to sleep.

The drive south was uneventful, I arrived at about 8:00. By then, the swap meet had been underway for about 2 hours or more (I never understood the desire of people to either sell or buy things so early in the morning) but I did a quick scan. I did see a few things that seemed pretty nice: I’ve been meaning to pick a Variac, and saw a couple of fairly nice ones for $80, but for whatever reason, I didn’t bite. I also saw an old TRS-80 Color Computer, which I thought was cool, but also decided against it (I’m sure to the great pleasure of my wife). I got myself registered, and headed off to my first session.

The first session I attended was the session on FreeDV given by Mel Whitten, K0PFX. FreeDV is a digital voice program that uses David Rowe’s Codec2 low-bitrate voice codec. Like many presentations which concentrate on software, it was fairly mundane, but I did come away with something I didn’t know: The FreeDV QSO finder. I had tried to play with FreeDV before, but had some difficulty locating people using it. The QSO finder might help. I also heard some progress on the SM1000 Smart Mic which is basically a computer that manages the digital codec stuff transparently, essentially turning any SSB transceiver into a digital voice transceiver. It’s still a work-in-progress, but sounds really cool. I also learned that FlexRadio has started shipping software that automatically integrates FreeDV, courtesy of a new architecture change that allows third-party code to be loaded into their proprietary SDR software. A nifty merger of open and closed software.

The next session I attended was given by Patrick Bunsold, WA6MHZ, entitled “Restoring Antique Radios”. You can check out his website here. He has an amazing, even a maniacal, collection of radios of all sorts. His presentation consisted of a huge number of slides of an incredible number of radios that he had acquired and restored. His presentation didn’t go into restoring the electronics, instead it was mostly centered on cosmetic restoration. While I found that a tiny bit less informative, ti was nevertheless a nice presentation. I ended up texting my wife that she should appreciate that my own enjoyment of the hobby didn’t involve acquiring dozens of each type of radio (he had 27 Heathkit Two-ers, for instance).

The third session was for me the most enjoyable. Thomas Sarlandie, KK6AHT, gave a talk entitled Building Minima, an HF Transceiver. The Minima is an all-band SSB transceiver, designed by Ashar Farhan, VU2ESE, who is also the designer of the popular BitX transciever. The Minima is a particularly interesting design. It is simple, inexpensive, modular, and frequency agile. It uses an ATMega328 (the same processor used in the Arduino) and an Si570 programmable oscillator chip from Silicon Labs. The Si570 can be instructed over the I2C bus to generate a wide variety of frequencies, which the Minima uses as the local oscillator signal. Very nice. Thomas’ presentation was really good. Luckily, you don’t need to take my word for it, you can look at his materials, as well as an audio recording on his web page. It’s inspiring: I’ve ordered some parts to start my own. More on that some other time.

During the lunch break, I bumped into Bruce Perens, K6BP. I first met Bruce over two decades ago when he was working at Pixar, and bump into him from time to time. He was giving a pair of presentations on on Alogram, his “HT of the Future” concept. I’ll try to dig out some online references to it, but the Bruce’s vision is basically to make an HT which is an open platform, and will allow you to create a more app-like environment where new modes can be quickly implemented. Nifty…

I also attended Joel Wilhite, KD6W’s talk on Building Your Own Microwave Rig. I’ve been interested in microwave operation for quite some time, but haven’t done much. I mostly filed it under “for future consumption”.

I bumped into a few other people, had some lunch, and then realized that I was getting tired. I stopped by the ARRL booth to renew my membership, and then headed home, thinking about crystal filters and the like all the way home.

A nice Saturday.

An antenna for receiving ADS-B…and velocity factor of RG-6

Allright, last night’s experimentation with the RTL-SDR dongle on my Raspberry Pi Model B+ was pretty successful. Incidently, I forgot to mention that this worked fine with the dongle plugged directly into the Pi, I didn’t need a powered hub. That’s pretty cool. Previously, I had experimented with decoding ADS-B signals from airlines. I thought this might be a pretty good thing to do with the Pi. I ordered a little MCX->Female F pigtail off of Amazon for under $6 shipped, and then thought about doing a better antenna. I would have also ordered a little case for the Raspberry Pi, but all the ones I could find for the B+ seem to be back ordered. Sigh.


I know that Darren at Hak5 and whixr at had build colinear antennas out of coax for this purpose. I went to review what they had done before. It’s a pretty straightforward antenna to make. Darren has a nice video and writeup:

Darren’s How to Build An ADS-B Antenna

I was curious though: his discussion of velocity factor ended with… our velocity factor is 0.85. That might be true for his coax, but how do we know?

Well, we could trust the manufacturer. Or we could guess, based on the material that we think the dielectric is. But I think I’ll use my MFJ antenna analyzer to figure it out. The basic idea is to take a length of coax of length L. Sweep up from the low frequency and find the lowest frequency where the coax is resonant (where it is a pure resistance, which will also likely have the lowest SWR). Say that frequency is f. if you divide 300 by the frequency in megahertz, you should get the wavelength in free space in meters. But in the coax, four times the length of your coax is the wavelength in your coax. So, if you divide that length by the free space length, you should get the velocity factor of the coax.

When I get some coax, I’ll try this out. Getting this length right is probably pretty important. I might also try to run some simulations to find out how systematic changes in fabrication affect the performance.

I’ll probably do a 8 or 12 element colinear. I suspect that without an antenna analyzer that can go up that high, fabrication errors for more elements will lead to dimininishing returns and ultimately maybe even diminishing performance.

Addendum: A nice video showing good construction technique…

Hellschreiber Update…

Scott Haley mentioned my old Hellduino post on Facebook: a simple project that used an oscillator powered by an Arduino to send Hellschreiber, a kind of simple fax mode invented by Rudolf Hell in the 1920s. I did this mainly as a simple test, inspired by Steve Weber, KD1JV’s “temp2morse” project. But unfortunately, that page seems to be gone, so the schematic isn’t available. It’s not a huge deal: almost any Colpitt’s oscillator would do in its place, with the main power rail being powered by a digital output on the Arduino, but I thought I’d see if I could find one suitable. I’ve built this low power oscillator documented by Hans Summers before, it’s probably overkill (it’s meant to drive a 50ohm antenna, and actually radiate some single digits worth of milliwatts). K7MTG’s HF Thermometer project was the inspiration for Steve’s, so is probably a good place to start. If you look at his schematic, you’ll see it has no antenna, and no power amplifier. It is actually a bit more sophisticated than my first test circuit was: L1 and C3 form a tuned circuit, which probably makes the waveform a bit more sine-like (if you look at my video, you’ll see the waveform isn’t ideal). To convert this circuit to send Hellschreiber is just a question of software, since Hellschreiber is (like Morse) just sending dots at the right time.

Addendum: Jeff Kellem was nice enough to do some heavy lifting and find a copy of the original schematic for Weber’s temp2morse project:


He found it on LB3HC’s blog. The original article (without images) is archived via the Internet Wayback Machine: click here to enter time vortex.

Digital ATV resources…

I’ve been doing a bunch of reading about digital ATV operations lately. I was originally motivated by hearing about the HamTV project aboard the ISS. Back in 2007, I got re-energized into ham radio by learning that for the 50th anniversary of Sputnik, the amateur satellite AO-51 would broadcast a cool message that I heard with a simple HT. I’m wondering if I’m having that kind of a moment now: the idea of creating a station to broadcast digital television seems challenging but doable.

While reading up on the necessary bits for a HamTV downlink station, I found that this little satellite receiver which sells for less than twenty-five dollars could be used to decode signals from the ISS. It receives DVB-S signals, which are used by direct satellite broadcasters like Dish Network. But in thinking about how to go forward with the project, it seemed to me like trying to aim directly for a satellite downlink station was likely to be a frustrating endeavor. It requires a number of different subsystem to work together, but trying to receive the DVB-S from the ISS (given an intermittent schedule) would be difficult to test together. So, I started looking for resources that I could use to build a similar terrestrial station, including both a transmitter and receiver.

A couple of cool links:

The DATV-Express board is a $300 exciter board that is in limited production. It seems very cool. Reading the Tech Talks on this site yielded a lot of good information, I’m particularly pondering the information in this one, about designing a digital TV station.

Another similar project, but available more as a board/kit is the Digilite project. An interesting variation of this project is the DigiliteZL project, which makes for a compact and interesting setup.

I also like the CQ-DATV magazine. It’s got lots of cool information, published in a series of magazines available in a variety of e-book formats. They also have a broad collection of interesting articles on the Digilite project, which I’m currently reading over.

I’ll probably stick to more experimentation with SSTV, but this stuff fascinates me, and I may have the opportunity to do something interesting with it in the future.