Stampduino: Design, Build + Test

After the first couple of projects, I realized I was running low on Arduino boards I had on hand. Instead of buying more, I thought this was a good opportunity to design my own Arduino board. This will also be an excellent opportunity to try out my reflow oven on a board that’s not the Pocket Power Supply.

My design goals were: cheap, small and compatible with the Arduino IDE. Ease of use, that is ease of access to the pins, were not a priority. I made this decision because connectors that are easy to access and use are neither cheap nor small. I’m just going to have pads on the board that the user is expected to solder wires to in order to get an electrical connection. In this sense, my Arduino will be closer to a module than a development platform; its designed to be inserted into a system where you already know what pins you need, rather than an easy to use, easy to modify board that can be used for any application.

Fortunately, small and cheap go hand in hand for PCBs; smaller boards are substantially cheaper than larger ones. To further drive down cost, I decided the board should be a two layer board. The goal is to have a board approximately the same size as a postage stamp, hence the name Stampduino. The 1 inch by 1 inch, two layer board easily qualifies for the JLCPCB $2 prototype special offer (I’m not sponsored):

With the design goals established, I started looking for a microcontroller I wanted to use. The easiest way of making a board Arduino IDE compatible is to use the same microcontroller on the Stampduino as existing Arduino boards. I originally wanted to use the same microcontroller as the Arduino Uno since it’s probably the simplest, but I ultimately decided to use the microcontroller on the Arduino Micro:

One of the key distinctions between the Uno and Micro is the fact that the Uno actually has two microcontrollers: the ATMEGA328P and the ATMEGA16U2. The microcontroller you actually program through the Arduino IDE is the ATMEGA328P; the ATMEGA16U2 is there just to convert the USB interface to serial; in other words, it’s a USB transceiver. The Arduino Micro only has one microcontroller: the ATMEGA32U4. It can natively support USB, which means the Stampduino will only need one microcontroller and no transceivers. By reducing the number of parts and simplifying the design, I have a better shot of meeting the design goals I set out.

The rest of the circuitry is just support for the microcontroller:

1. USB connector: I decided to use a micro USB, since that’s what’s most commonly available
2. Power regulation: just like my Pocket Power Supply project, I have a power multiplexer that lets the circuit choose between USB power and externally supplied power. Both of the two power sources are fed into an LDO, which will generate either 3.3V or 5V, depending on the feedback resistors in place.
3. Crystal: I wanted my board to be able to do 3.3V or 5V operation. The maximum crystal frequency for 3.3V is 8 MHz, while the maximum crystal frequency is 16 MHz. The pads on the board for the crystal can accommodate crystals for both frequencies.
4. Misc: I decided to include a couple of pull-ups for the I2C bus as well as indicator LEDs for the sake of convenience to the user. Not a design goal, but improving quality of life wherever possible is always a good thing.

Feeding the USB’s 5V into an LDO to generate 5V is not a very good design, since the LDO will always output less than what is provided to it. This was done to simplify the circuit and reduce the number of parts needed for power regulation. I decided this was acceptable because (a) USB power is generally slightly above 5 volts, and (b) the Stampduino is intended to ONLY power itself and not provide power for other devices when powered by USB. If you want the Stampduino to output a regulated voltage through the LDO, you should provide external power besides just USB.

The board layout was a pain, but I managed to fit everything onto the tiny space with only two layers. I had to make a couple of sacrifices:

1. Despite my love for 0603 components, due to their ease of soldering and manipulation, I used 0402 size capacitors and resistors. I was curious how my reflow oven would handle 0402 components anyway, but it still makes assembly a lot harder.
2. The pads to connect wires to were smaller than I wanted. I envisioned 2 mm diameter pads, but as soon as I started the layout I realized I had to make them 1 mm instead. This makes soldering wires to them harder, but I think it’s okay since you’ll only need to solder wires to the board once if you know exactly what you need.
3. I had to put a lot of silkscreen on the bottom of the board. This makes finding components during debugging and assembly more difficult, but since the design files will be available online, it’s not too bad.

All in all, I’m very happy with the layout. I am especially happy with the mounting holes, which are 0.5 in part. I intentionally made sure they were apart in increments of 0.1 in so they can be attached to 0.1 in pitch perfboards easily by lining up the holes and then putting a 0-80 screw through both of them, though you’ll probably have to widen the hole on the perfboard (most have 0.032 in wide holes, and you’ll need 0.050 in wide holes for 0-80 screws). I am also very happy with the fact that no components are on the bottom; this makes mounting the board flush with the wall of an enclosure very easy.

After waiting breathlessly for the PCBs (got 30 for $5.10), stencil (got 1 for $7) and the parts (got enough parts to make 10 boards for about $40) to arrive, I got to work building the boards. It went pretty well when I used a microscope during the assembly process; I was able to complete 4 boards in 4 hours including set up, applying solder paste, assembling the boards, reflowing them, inspecting them, fixing defects and then testing them. The finished product is shown below:

Like I mentioned, this board is not well suited for development purposes. If I’m experimenting and don’t know exactly what I want to do with the board, then using the Stampduino will be extremely inconvenient. There are two workarounds for this issue:

1. Use the Arduino Micro, then port the code to the Stampduino once you’re done experimenting. This should work for most cases as long as you are cognizant of the differences between the two boards. This includes the indicator LEDs, the pin numbers used in the Arduino IDE, and making sure the crystal on the Stampduino is 16 MHz, since that’s what’s on the Micro.
2. Build a development board for the Stampduino. This is what I did and recommend; in order to minimize, hopefully eliminate, the porting effort, I decided to stick the Stampduino to a perfboard and run wires from the pads on the Stampduino to easily accessible headers.

After pinning the Stampduino to the perfboard using two pin headers and some double sided tape, I broke out all the pads to connectors one by one. Soldering wires becomes especially difficult if you plan to use every single pad, but it’s definitely doable. After that was done, I decided to slap on some helpful labels as a quality of life improvement.

Now the hardware is all done; the next task is sorting out the software. This will include burning Arduino IDE compatible bootloaders on the ATMEGA32U4 microcontrollers, and seeing how easy it is to develop code for this new board.