Deep Freeze Blog & Press

< Back to News

Programming BlueTipz

People don’t usually think about the engineering that goes into the products they purchase. It turns out that what they buy is only part of all the things that are designed to make a product. For consumer electronics, there are often many jigs and parts that are used in the assembly process. This article exposes one of them; the programmer.

BlueTipz transmitters have code running on them called firmware. In our assembly process we need to get the code onto our devices, otherwise they wouldn’t do anything. While there’s another post on how we manufacture BlueTipz, we wanted to talk specifically about our programmer in a separate post, because it’s pretty complex (and dare we say awesome).


We begin with a description of the requirements of the programmer.

  • Standalone. It had to be a box that we could set on the assembly line that was self contained and didn’t have a bunch of wires that could fall out.
  • Robust. We have to program thousands of devices on this. It can’t just fall apart, and it can’t break if there is a bad unit being programmed.
  • Easy to use. No buttons to press, no complex user interfaces. It just does one job and does it well.
  • Thorough. We wanted to test as many things as possible, while it’s programming the device.
  • Data driven. We wanted to keep metrics on how many boards successfully programmed vs. not, keep track of how long it took to program, collect data on each device programmed, etc.
  • Versatile. We have to be able to modify this in case we change designs.

Hardware Design

This is our final programmer:


Using tools we had available, we designed a case using laser cut material. For cool-factor, we used clear material so the internals were visible.


The enclosure was intentionally designed so that the 3D printed part (the white block) could be swapped out, meaning if we make any changes to the circuit board or start offering different products, we can easily make the programmer work for that new board.

We also tried to use as many off the shelf components as we could. The programmer itself was purchased from TI. The brains are a Raspberry Pi. There’s a simple USB hub and power supply. We also put a Wi-Fi dongle on the Pi so that we could connect to it without having to take it apart and even (if we wanted) upload our programming stats in real time somewhere.

Here are the guts spread out. We used superglue to seal much of the enclosure, but a few places have just a dot or two of hot glue so we can take it apart if necessary.


But a lot of custom work had to be done to make this work. Our final product is custom, so the interface with the programmer had to be custom as well. We designed a part and 3D printed it in plastic. Inside of that part we used something called Pogo Pins, which are electrical contacts that have tiny springs inside, ensuring that each pin contacted the pad on our circuit board when we pressed it down. The 3D printed part has alignment pins to make sure the board is placed in the correct spot every time. We wanted to display to the assembly user what the status was and how many devices had been programmed, so we used an LCD with 8×2 characters. But to make things even easier for them, we added LEDs that indicate status. White means it is ready, yellow means it is in progress programming, red means a failure of some sort, and green means a successful programming and test. There are two pogo pins that act as a switch, so we can detect when a board is placed on the programmer and automatically start the programming process.

We had to make a custom circuit board that connected to the Raspberry Pi and controlled the LEDs, LCD, and switch.


The Raspberry Pi is running some software as soon as it boots. That software controls the LEDs, LCD, switches, and programmer. When it is ready, it turns the white LED on. As soon as it detects that a board has been placed, it turns on the yellow LED, and tells the programmer to program the device with the correct firmware. It also collects some data about the device. When it is done, it lights either the red or green LED, increments a counter, and updates the LCD. Then it writes all the information to a database. This way we know about every device that gets programmed.

In Practice

To use our programmer, we plug it in, wait about a minute for the Pi to boot and start the software, and then begin the cycle. A cycle involves placing a PCB on the interface, the Pi detects the board and starts programming, when that is complete the correct LED is lit, and the board is removed.


Ready for programming. The board to program is on the right side. The white LED was super bright, so I rubbed a marker on it.


Programming. We just press the board onto the interface and it starts on its own. Programming takes about 5 seconds.


Successfully completed programming! This shows the green LED and our + Count has incremented. A bad board would increment the – count (showing zero)

We get a cycle time of about 7 seconds, which means that we can program and test about 500 units per hour. This is pretty impressive even for mass production quantities, so we’re very happy with this programmer. We don’t have any ergonomic issues, it’s easy to use, and has worked for a while. We have a failure rate of roughly 2%, but with minimal rework almost all of those go back through the process and are successful on the second try.