Flashy Morse Badge


At this date (8-Jun-2014), I haven't quite completed this document. You can download the software here. I still haven't gotten any photos, and likely won't for a couple of months, but decided to put this onto my website so you can play with it. Hopefully I'll be able to get this done in August.

You can also grab the list of parts (called a "bill of materials").


This project was inspired by the paper adhesive badges that say "Hello, my name is" and space for you to write in your name. I decided I wanted something a bit, well, more flashy. So I came up with the Flashy Morse Badge, which flashes a message in Morse code. Mine says "HELLO I AM CLARK KI7TU" — Morse code not having lower case. (By the way, KI7TU is my Ham Radio callsign.) You can change yours to whatever string you want, within the restrictions of what can be represented in Morse code. (Actually, I didn't encode any punctuation, so if you want it, you'll have to add it.)


Briefly, it has a tiny computer board, three controllable RGB LEDs, a light measurement device (to set the brightness of the RGB LEDs), a bar pin to attach it to clothing, and a battery holder. The battery holder provides power, an on-off switch, and serves as a structural foundation to hold the other parts of the Flashy Morse Badge.

The tiny computer board is (somewhat) Arduino compatible. It is programmed using the Arduino IDE, but it has far fewer I/O pins than a true Arduino. It also lacks the serial I/O and true USB interface. It does have a bootstrap program that allows it to fake the USB enough to load a program, but it can be a bit finnicky. The reduced feature set allow it to be both physically smaller than a normal Arduino, and significantly less expensive. Because it is a bit finnicky to program, though, it may help if you have some experience with a real Arduino.

A few details

The badge is built on a 3xAAA Battery holder (#727) from Adafruit Industries (adafruit.com). It provides the overall base for building the badge, as well as acting as a holder for the three AAA cells and has a convenient switch for turning the badge on or off. Eventually you'll need to amputate the JST connector, but more on that later.


Note: Before starting actual construction, please read though both this section and the one entitled "Theory of Operation" as it will explain some things that might seem a bit strange without that understanding. Also, please look at the Fritzing diagram below of the circuit. (I'm not a real expert with Fritzing yet, as this is my first attempt to use it, and the computer I'm using at the moment is not the ideal platform to be doing any sort of graphics on.) Note that it is NOT to scale!

Flashy Morse Badge - NOT to scale!

We'll start by assembling the three NeoPixels. If you examine them closely, you'll note that they each have four holes for soldering (or otherwise attaching) connecting wires. One of the holes is marked with a + sign, and the one opposite it is marked with a - sign, though that's harder to spot. One of the other two holes has an arrow pointing to the LED, and the hole opposite has a small arrow pointing away from the LED.

A Word about Wires

Wires for this project should be (about) 22 gauge stranded. You can get assortments (or individual spools) of 22 guage stranded wire from many sources, such as SparkFun or your local hardware store. Alternatively, you can cut up jumpers such as these from SparkFun or these from Adafruit. I recommend that if you do cut up jumpers, leave an inch or so on each pin – they can come in handy in the future to adapt things to solderless breadboards. I also strongly advise that you not use solid wire, such as comes with many solderless breadboards.

To wire up the NeoPixels, we start by wiring together the + holes on all three of them, using enough wire to space them so that there is about 1/4 inch (5 to 6mm) between the nearest edges, with the NeoPixels arranged so that the + holes are all on the top as you look at them. The overall length of the string of NeoPixels needs to be around 2.5 inches (about 65mm). It doesn't have to be really accurate, but the distances should be roughly even. (The common "standard" is to use red wire for the + lines, but if you don't have any red, use whatever color you have.) Be careful to not fill the hole on the one on the end where the arrow indicating "data-in" is located, as we'll need to solder an additional wire to this one. Do the same for the - holes on all three, making sure that the orientation of them is the same. (Black wire would be "standard" for this lead, but again, use what you've got.)

For convenience, let's call the NeoPixel that has the "data-in" away from the other two NeoPixels as LED 1, the one in the middle LED 2, and the last one LED 3.

The "data-out" connection (the one with the arrow pointing away from the LED) on LED 1 needs to be connected to "data-in" (the one with the arrow pointing towards the LED) on LED 2. Likewise the "data-out" on LED 2 needs to be connected to the "data-in" on LED 3. You should use some form of small gauge stranded wire for this. I tried using conductive thread, and did get it to work on my Flashy Morse Badge, but it doesn't take solder well (OK, it doesn't take it at all). I had it handy and wanted to try it. I'd suggest you use a stranded wire with a different color than the + or - wires, maybe blue.

Next wire the + on LED 1 to the Vcc connection on the Analog Light Sensor. Use a piece of wire about half an inch long, enough that you can make a graceful "U" with the Analog Light Sensor about a quarter of an inch to the + side of LED 1. A somewhat longer wire, about an inch long, should be used to connect the - on LED 1 with the GND on the Analog Light Sensor.

Now you need to solder wires on the Vcc and GND pads of the Analog Light Sensor that are long enough to reach around the battery holder to the Trinket's 5V pad (for Vcc) and the Trinket's Gnd pad (for GND). Remember when doing this that the front panel, where the NeoPixels and Analog Light Sensor will be mounted, will need to move about 1/8 inch in order to get to the batteries to change them. A wire needs to run from the "data-in" pad of LED 1 to the pin labeled #0 on the Trinket (I used blue for this one). One wire needs to go from the "OUT" pad on the Analog Light Sensor to the Trinket pad labeled #2 (I used orange for this one). Again, remember to leave enough slack to open the battery holder.

The last wiring task is to cut off the last few inches of wires from the battery holder (which also amputates the JST connector). Leave enough for the red wire to reach the Trinket's BAT connector and the black wire to reach the Trinket's Gnd connector. I think it's best to not put batteries into the battery holder until after you've programmed the Flashy Morse Badge. This guarantees that you don't have battery power applied when trying to program the Badge.

Loading the software

Once all of this soldering is done, I think it's best to use the Arduino IDE to load software into the Trinket computer before going on with the mechanical attachmens. That way, you can test the bits and pieces, and make any fixes without having to worry about melting the plastic case.

The Trinket has some differences from a normal Arduino that require some changes "under the hood" on the IDE. Fortunately, you can download a version of the Arduino IDE that has already had the modifications made. You can get it by cliking here, though you probably should check the document mentioned below to see if there's a more recent version. (You can find out more about the Trinket by reading Adafruit's Introducing Trinket document, as well as making sure that you have the latest version of the IDE.)

You'll also need to get the NeoPixel library from Adafruit. Please see the "Arduino Library" section of the Adafruit NeoPixel Uberguide for instructions on downloading and installing it. There are a few things you have to do, and there's no point in me replicating those directions here.

Once you've got the Arduino IDE up and running, please look under the Tools menu and find the Board submenu, and under that select "Adafruit Trinket 16MHz". Also make sure that the Programmer submenu (also under Tools) has "USBtinyISP" selected.

Open the morse_badge file, and find the line that looks like this:
const char send_string[] = "HELLO I AM CLARK KI7TU  ";
and change it to your name and call sign. (If you don't have a call sign, please delete mine. You can get info on getting an Amateur Radio license at www.arrl.org -- and by the way, you no longer have to learn Morse code to get one.) The two spaces after my call sign cause it to delay a little bit between repetitions of the code.

Once you've done that, use the Verify button (the one that looks like a check mark) to make sure the code will compile cleanly. Often times, running the compiler the first time takes a few more seconds than it takes to run it the second and subsequent times when you start up the Arduino IDE. If you get a bunch of error messages, scroll up in the error section to see the first one. If it says something like "morse_tables.h: file not found" please use Windows Explorer (or Command Prompt, if you're comfortable with that) to verify that the file is in the same folder as the actual morse_badge "sketch" (which, by the way, is stored with a file type of .ino). As a double-check, when you're looking at the morse_badge file in the Arduino IDE, you should also see a tab for the morse_tables.h file. If you don't find it there, please locate it (maybe download it again), and put it in the same folder (careful, don't get it one folder up!). If you have to move it, you'll have to exit the Arduino IDE and then go into it again to have the Arduino IDE find it. (Be sure to save the sketch before exiting the IDE, or you'll lose your changes to it.)

Now it's time to actually load the software into the Trinket. Due to some limitations of the Trinket hardware, this can take a few tries, especially if you have a rather slow computer, as you have to use the Trinket's RESET button to put it into bootload mode, and it drops out of that in a few seconds. You need to time releasing this button so that the Trinket is in the bootload mode when the IDE gets ready to load software to it. I suggest if you think that the software might have gotten loaded, observe the red LED on the Trinket -- after the Trinket drops out of bootload mode it will start flashing the Morse code message if the programming was successful. If you also managed to wire the NeoPixels and Analog Light Sensor correctly, the NeoPixels will start displaying the message too. Be aware that for a "dit" only the middle NeoPixel will turn on, but for a "dah" all three NeoPixels will turn on.

If, for some reason, you want to change some of the code, here's a trick to verify that you have actually loaded the new version to the Trinket. Go down to the section where it says
void loop()
which are down near the end (roughly line number 180), and then look for the lines that say
  switch ( color_cnt ) {
    case 0:
and change the "case" to 1 and also change the
    case 1:
a few lines further on to be 0. This will cause the Flashy Morse Badge to show red first, then white, rather than the other way around. For further changes to the code, change them back.

After you have the Trinket up and running, and flashing the NeoPixels, experiment a little bit to verify that the light sensor is working. Remember, it ONLY senses between repetitions of the message. If you put your finger over it, the NeoPixels should get a bit dimmer (assuming you're not in a fairly dark room already), and if you arrange for the sensor to see more light (for instance, by shining a flashlight on it), the NeoPixels should be brighter.

Final Assembly

Now that you've tested your Flashy Morse Badge, and it's working, it's time to do the final assembly. The bar pins usually have an adhesive foam strip already attached. Before you pull off the protective covering, take a moment to familiarize your self with the functioning of the pin. At one end they have a little rotating part that closes off the slot for the pin. Examine this closely as sometimes they need a little squeezing using a pair of pliers so that it doesn't come off. Be careful, though, to not get it so tight that it is hard to operate. Also, I've found it best to arrange the pin so that the rotating bit is in it's "closed" position when it's pointed down. This makes gravity your friend on keeping the badge in place.

OK -- lay the battery holder on the table with the switch on the side towards the ceiling. I like to have "Off" be down, so I selected the side towards "On" as the top edge of the badge. Peel the protective paper off the bar pin, and once you're sure of the orientation, and have aligned it with the top edge of the badge, maybe 1/16 inch (or 1mm) from the edge, press it on firmly.

Cut small pieces (roughly square) of the double stick foam tape, and put one on the back of each of the NewPixels and the light sensor. Leave the backer on for the moment. Cut a little bit larger piece, and put it on the back of the Trinket.

I'd do a "dry run" to see exactly how the Trinket is going to fit on the back of the battery holder. Place the Trinket in the lower right-hand corner of the battery holder, as viewed from the back (the side with the bar pin). It should be close enough to the edge that you can easily insert a USB micro connector if you ever need to reprogram it, but far enough back so that it's not visible when viewed straight on from the front. When you're satisfied with the position, peel off the protective paper from the double stick tape and adhere it to the battery holder.

Turn the battery holder over, so that the bar pin and Trinket are on the table side, with the bar pin away from you (so the "top" of the badge is away from you).

Now do a "dry run" with the light sensor and the three NeoPixel LEDs. The center line of the LEDs should be about 1/3 of the way down, and the center line of the light sensor will be about 1/3 of the way up from the bottom. Carefully remove the protective backer paper from the bits of double stick tape on the LEDs, and being careful to get them in a straight line, evenly spaced, and even from te top of the battery holder, stick them to the cover of the battery holder. Remove the backer from the light sensor, and adhere it to the lower left corner of the cover.

Examine your Flashy Morse Badge, and if you got any of the wires too long, make small bends in them to take up the slack and use tiny pieces of double stick tape to keep them from flopping around. (You could also use small dabs of hot-melt glue for this purpose, but when I built the prototype the tape was handy, and the glue gun was in the other room.)

Theory of Operation

Please don't be scared off by that big word "theory". It just means that this section explains the ideas behind how things work.


Before going further, let's talk a bit about how the NeoPixels work: the processor sends a series of pulses that have the one or zero encoded by where the falling edge of the pulse occurs. Basically this amounts to a Pulse Width Modulation (PWM) scheme. In this case, the pulses are sent at 800 kHz. Each of the NeoPixels presumes that the first 24 bits that it sees are for it (8 each for Red, Green, and Blue, though not in that order), and so gobbles them up, and then passes along any remaining bits that it sees. So in our case, the NeoPixel (electrically) closest to the Trinket will grab the first 24 bits, and pass the next 48 bits on. The middle NeoPixel will then grab the first group of 24 bits that it actually sees, which are the second group of 24 that the Trinket sends. Both the first and second NeoPixels will pass the third group of 24 bits from the Trinket on to the last NeoPixel. Once all of three NeoPixels have their data, they look for a period of no actiity for 50 microseconds, and then execute the change to the new color. With a processor with more memory, such as an Arduino Uno, they say you can control more than a hundred NeoPixels on a serial line without noticable flicker. To get the speed to keep up with that 800 kHz bit rate, you do need to have a processor operating at 16 MHz. The NeoPixels also need to operate on a 5V data line, so the 5V Trinket works fine. (I think you could use a 5V Arduino ProMini as an alternative, but it has more I/O and is thus physically larger, as well as costing a couple dollars more than the Trinket.)


The Trinket computer from Adafruit (part #1501) was designed to be both small and low cost. Their goal was to produce something that was low enough cost that you could easily afford to leave it in a project, rather than tearing apart one project to get parts for the next project. The Trinket is limited as to memory size, with only 8K of flash (some of which is taken up by the boot loader), and only has a total of 5 I/O pins (two of which are used by the boot loader to emulate a USB port).

There is no true USB port, unlike the true Arduino computers. When the Trinket is rebooted (or powered up) the boot loader is invoked and flashes the LED indicating that it is ready to load a new program. After a few seconds, if the boot loader program doesn't see anything that looks like a computer trying to load code to it, it drops out and executes whatever user program is in flash memory.

Since there's no real USB port, there also is no serial monitor capability like the regular Arduinos have.

Note that there are two "flavors" of Trinkets: the 3.3V version that can only run at 8MHz, and the 5V version that can run at either 8MHz or at 16MHz. The NeoPixels require 5 volts, as well as needing to be fed by a 16MHz processor, so the 5V Trinket is the one we want.

The Trinket lists for $7.95, as opposed to about $24.95 for the Arduino Uno. The Uno has 32K of flash memory, and 20 I/O pins, but for this project, the Trinket has plenty of capability.

Morse Code

The timing that is used for the Morse Code comes from a document from the American Radio Relay League (ARRL). The document actually is an article in QEX magazine from 1990, but it includes a box entitled "The ARRL Morse Tramsmission Timing Standard" which explains the actual timing. Although this latter document talks about using something called "Farnsworth timing" at speeds below 18 words per minute, I chose to stick with "Standard timing". (Farnsworth timing simply sends the actual characters at a higher speed, and increases the spacing between them to get slower speeds. It works well in training people to increase their speed when listening to code, but I think it can get confusing when used for optical transmission.)

This Screen Last Updated: 08-Jun-2014

Copyright © 2014 By Clark Jones