Category Archives: Production

Kakapo net+sd shield

Those of you who have been following my personal twitter account will have seen endless pictures of the shiny new net+sd shield for the Kakapo.


There’s plenty of shields with ethernet and SD card support, but there’s a few different things about this one compared to others:

  • The latest WizNet W5500 hardware TCP/IP chip
    • 32kB SRAM, 8 sockets
    • Automatic circular buffer management
    • Compact 48-pin LQFP chip
    • SPI support up to 80MHz
    • Variable length transfers to reduce overhead
    • 10/100 Full and Half Duplex support
  • Built-in I2C MAC address EEPROM
  • MicroSD card socket
  • W5500 chip is automatically reset by Kakapo reset sources
  • W5500 and SD card MISO shield pin is buffered; does not drive pin at all when deselected
  • Four status LEDs: Link, Activity, 100M and Full Duplex
  • Jumpers for easy disable/enable features; no soldering to free shield pins from features not required!
    • Jumpers for W5500 !CS line and !INT lines
    • Jumper for SD card !CS line
    • Jumper for I2C 4.7k pull-up resistors
    • Opening !CS jumpers enforces part remains deselected
  • MAC address sticker for easy identification
  • All pins used explained on the bottom side of the shield
  • Same pins used as the common Arduino Ethernet shield

The shield is going through some final testing, and will be available soon!

Kakapo roadmap

Now that the first batch of boards has been shipped off and are starting to make their way out to customers, I thought I’d post a bit of a roadmap on things that I plan to work on around Kakapo.

First up is to resolve some of the outstanding major tickets on libkakapo. The main one to sort out is the various problems with clock.c, namely that is takes control of hardware when it shouldn’t (breaking the philosophy that you should determine how it’s used, not the framework taking it away from you) and that RTC support needs to be broken out into it’s own code.

Less urgent is to expand the number of supported modules. I’d like to get watchdog, type 2, 4, and 5 timers, and a few other things with better support. Modules present on the XMEGA D4 will be highest priority, but given I use libkakapo myself on other projects, support for some of their modules is useful to me at least.

Anyway, if you’d like some idea what I think is on my to-do list for libkakapo, have a look over the issue tracking.

I also need to write up more tutorials which build on the examples provided in the libkakapo source. Those examples actually serve as test suites as well, since they provide a quick way to check the libkakapo driver works as I expect. But they should really have documentation associated with them here about what they’re doing and why they work.

On the hardware front, the next major addition to the family will be a W5500-based Ethernet+microSD shield. This is the latest revision of the Ethernet/IP chip commonly used on Arduino Ethernet shields. The first prototypes of the PCB go off to be made this weekend. You’ll see more updates on that soon, I hope!

Lastly, thanks to everyone who has expressed interest, committed code, and generally supported getting Kakapo out and about. I really appreciate the effort people have put in.

Quick shipping update

The first 16 Kakapo boards available to buy have been shipped to nicegear today. I still need to take proper product photos, but that doesn’t stop them working so it’s been down my priority list.

The next thing to work on is cleaning up libkakapo documentation inside the source and writing up more documentation here. I also need to submit a patch to avrdude to allow the avr109 programmer type to perform automatic reset. It’s not a huge patch, but I’m not sure when it’ll be merged.


First shipping batch almost complete!

A bit of a production update on the Kakapo. The first production batch of 16 boards has been completed, and are ready to pack and ship off to nicegear. There is also now a product page up so you can register to buy one before they arrive.

The next task is the final boxing. I had originally planned to use a set of black boxes with a sleeve, but they are quite large. They fit the boards plus the USB cable just fine, but I have been thinking about a more compact box.

BqsWn4YCEAAqwx1Playing around in Inkscape with a flat-box design and cutting from 160gsm card stock, I think I’ve come up with a nice compact box which is large enough for the board (in a bubble anti-static bag) and USB cable.

Now the question is, figuring out how to get lots of them made cheaply and easily. Hand-cut is fine for a prototype but it definitely won’t scale.

The pricing of things

The part about making electronics for people to buy that I really don’t do well is the price. Designing something, while it has some challenges, doesn’t stump me as hard as picking a price for the result.

Covering the obvious costs (ie, the components) is usually pretty easy. Covering my time is harder, since even for assembly time I don’t have a useful value for it. Not one I could reasonably apply.

There’s also some complexity in the cost of the components. I’m not making thousands or millions of these, so the prices for components are volatile and sensitive to quantity.

This then means the price for initial runs has to be just high enough to cover the big costs and a little more to help fund the next run, but not so high it won’t sell at all.

While I’d like to think I’m inventing new things, I am not and the market already has a price for many of these things. The heuristic of “cost times three” breaks down – I don’t have the same production capacity or immediate demand to make that viable against the market price.

A lot of the future is about getting better pricing on the parts I am using, and improving build processes so that it takes less time to do each build.

Funnily enough, I am working through the pricing for the Kakapo dev board, which is what prompted this post. Should be an announcement soon on what that looks like!

Kakapo production boards


The Kakapo production boards have arrived! These are a 2×2 panel (so a total of 4 boards within each panel) and the new silk has turned out fantastically well. Hackvana has supplied these boards and they have delivered very high quality PCBs again.

The new Kakapo logo was redone for this run, mostly to make it look better in white rather than the black I had originally planned. The drawing was redone in Inkscape, with cut-out lines for adding detail to the solid area. I think it’s turned out great, the picture doesn’t do justice to how fine the detail lines actually are.

I expect to start production on these at the weekend, starting with shipping the final configuration to Nicegear for feedback and then ramping up making the first run.

It’s also about time I worked out the pricing, I’m aiming for around the same as an Arduino Uno, at least as close as I can make it. It will depend on how much small runs (as it currently is being made) adds to the costs.

The design of BBPSU

My Breadboard Power Supply is designed to overcome a number of problems with other existing plug-in power supply designs. At a glance, it might not seem to make much difference how my supply board is designed compare to other solutions – they all get you a stable voltage from a wall wart – but read on for how those differences actually matter.

Most Breadboard power solutions provide a single output from a DC jack. This is fine if you know you’ll only ever need one power rail. But increasingly ICs and components are only available with 3.3V, and other components don’t run at their top speed unless being fed at 5V. Having both available at once is more of a necessity than it has been in the past.

For example, Microchip make one of the only Ethernet chips you can plug into a breadboard: the ENC28J60. A small, through-hole IC, which provides almost all the hardware needed to add Ethernet – just a jack, some magnetics, and terminaton is required. But this part is 3.3V only. Similarly, to get the maximum speed out of a AVR MCU you can plug into a breadboard, say the ATMEGA328P (like an Arduino uses), you need to run them at 5V.

So my breadboard supply board provides you both at once. You don’t have to switch between one or the other. Both 3.3V and 5V are available from the same input and the same board.

The second problem with most supply boards is the way they connect to the breadboard. A breadboard has down each side two power rails (usually marked red for positive and blue for ground), and it’s natural instinct to connect a supply board directly to these rails.

But there’s problems with connecting that way. Not all breadboards have the same width. The main area of a breadboard, the grid of holes, is always spaced the same, but the number of columns varies between breadboards, and the distance from the grid to the power rails varies as well. This means most supply boards will either only connect to a single side rail or if they do try to connect to both, they are only able to connect to a few specific breadboards.

Instead, I noticed there’s one area of a breadboard which is always consistent – the IC well. Breadboards are designed to accept all DIP packaged ICs, their pins are always spaced on a 0.1″ grid. So all breadboards have their grid spaced the same way. And to split the sides of a chip into separate lines, they have a well down the middle. That too is spaced on the same 0.1″ grid, to ensure any DIP chip will fit.

That’s the better, more reliable, place to connect a supply board – it’ll always be the same spacing on any breadboard. Since it’s also split between sides, it makes it easy to provide both 3.3V and 5V at once – they are just different sides of the IC well.

Most supply boards droop off the end of the breadboard, which is both sloppy and may damage the breadboard or pins in the supply board. My supply board uses additional pins to provide stability, so there is no droop and the board and pins are firmly held in place without bending.

The LEDs for each side are also placed nice and close to the pins where the output is present, so you can see easily that each side is live. I’ve also put more emphasis on limiting the number of components down to what you really need, and not things which aren’t critical to have. This means my supply board is much cheaper, about 30% cheaper than other boards with only a single output, and you get two outputs from my supply board.

It’s also been designed to be easier to install a small heatsink on to the regulators. Linear regulators do generate a significant amount of heat, but most boards try to cram too many components around the regulators, making it hard to use a small heatsink to improve how much current can be drawn from the supply board.

By keeping the space either side of the regulators clear, it’s very easy to glue down a small heatsink designed for DIP packages to both regulators. Very few supply boards can accept a heatsink this easily.

Lastly, buying locally means you get customisation options. The boards can be supplied with custom voltages, or without pins or DC jack loaded so you can solder it into a fixed installation.

In summary, the breadboard power supply:

  • Provides two outputs at once, instead of only one
  • Prevents damage to the breadboard by limiting droop from the power input
  • Fits to any breadboard
  • Provides a clearer indication power is on
  • Ensures you can easily install a heatsink if required
  • Is lower priced than most single-output boards
  • Can be customised to your specific needs

You can get the Breadboard PSU from nicegear here.


The second part of getting up to better production standards is testing. While I’ve always done testing, it’s usually a slow process of fiddling with sockets and checking each point with a multimeter by hand.

For v2.0 of the Breadboard PSU an important design decision was to include better support for being able to test the assembled boards quickly. The intention was to take advantage of one of these.. a pogopin:


Pogo pins are a spring-loaded conductive pin which can be soldered in like a header pin. They are small enough to fit standard holes boards already usually have for various kinds of headers, and come in a variety of tips, including ones which make solid contact with flat exposed pads.

The output sides of the board already have useful holes to connect a pin to, but the input side didn’t have anything. So v2.0 has two holes down by where the DC jack is soldered specifically for pogopins during testing.

The next part is making the testing frame. For this, I used the laser cutting services of Ponoko. These are the plastic cuts I designed and had cut:

The three pieces make up a bottom layer to hold a sacrificial PCB, and two top layers, one of which is just used to assist on placing the board. The small holes are to allow the pogopins to pass through, with bolt holes in each corner.

The sacrificial board is one of the boards from the panel with nothing soldered down to it. Pogo pins are soldered down on the existing holes, and additional wires are soldered to pads and holes which connect to the same signals.

The whole contraption, connected to a pair of multimeters and a DC jack, looks a bit like this:

From the side, you can see the way the pins are arranged to allow contact from a board under test:

This is probably not ideal, the pins are too high, but you get the general idea.

All that needs to be done now to test a board is press it down on the array of pins, and check the meters and LEDs are lit:

As you can see, the LEDs are lit confirming that they’ve been soldered down correctly (for once!), and the voltages of both sides of the output. This board was rejected after testing, as the 5V output is too low.

Testing is a critical part of making sure the products you make are working as the end user expects. By using a testing jig like this, I can test a board in about 5 seconds.

Using a small MCU, a more complete testing platform could be made, that automatically measures voltages, or flashes firmware images, or interrogates the target board to ensure it operates normally.

All you need is a bed of pogopins, and some imagination.


As part of expanding my production processes, I’ve taken the next step in production scale: panelised boards rather than separate boards. The idea behind this is rather than applying paste to one board, you apply it to a panel of boards which has multiple copies of the design. Once reflow is done, you can split these by hand into final boards you want.

For the newest revision of the Breadboard PSU, I got panels made by Hackvana, who do fantastic high quality PCB production ideal for hobbyists like myself. I worked with Mitch from Hackvana on the panel, providing a single design and then approving the panelised version he’d built. Only a few days later, the panels turned up, and they looked great.

To actually get them soldered up and ready to ship out to Nicegear, it’s almost the same process I normally would go through for a single board, but now it’s multiple copies at once.

The process begins with applying paste to the board. Here you can see the multiple copies making up the panel, and empty board around the outside. There are four holes in the corners which align with the holes in the metal plate below, and have 2.5mm pins in them. The stencil is taped down on top of the board, and also has holes where the pins are.

Applying paste is just like you would for any other board, smear solder paste on the stencil, and then scrape it off. Once you’ve removed the stencil and released the board from the pins, you get a panel with paste applied to the pads:

The grey paste can be clearly seen on the pads here.

Now we go through the process of dropping down our components. I use a vaccum pump with a fine tip I bought from AliExpress for this part. It makes it easier to lift the parts straight from the tape on to the board.

Once we’ve placed all the parts, the board looks like this:

Now we’re ready to cook the board. I have a “modified” toaster oven driven from an SSR by a PID controller called osPID. The reflow profile is loaded into the osPID controller and it pulses the mains into the toaster oven to hit the temperatures the profile needs. There is a thermocouple inside the oven so the osPID controller is getting closed-loop feedback of how the oven is performing.

This is the board being cooked in the toaster oven:

I try not to burn my fingers when removing the boards from the oven after the reflow process is done. You can see in the photo below the bright silver solder, showing it’s now all soldered down:

Now we just need to start breaking the panel apart into the separate boards. Hackvana have used a v-score cut along the dividing line between boards and the boards and rails, so they can be snapped apart by hand easily.

Finally we have all our boards separate and ready for testing!

Once all the through-hole soldering is done, we get our nice shiny finished product, ready to be sent out into the hands of eager users!


One of the reasons I picked the Breadboard PSU as the first project to attempt to ship and sell was its simple. At the same time, its representative of what would be required for any design to be seen though to actually being in people’s hands – other designs just have more parts.

Unexpectedly this week a bunch of the PSUs sold, and more needed to be built in a (relatively) short time. This is quite different as an experience to the prototyping phase, where every build is unique and new, and the timeline is as long or short as you feel like. I’m glad that I chose something simple to start with, because I’ve very quickly found the things I need to think about for larger and more complex designs going into production.

Inventory management is important

During the prototyping phase on all of the projects I have underway at the moment, I’ve built up quite a stack of parts. Some of these parts overlap with other designs, but most are design-specific. For example, every design will probably involve a ton of 100nF power supply decoupling caps scattered all around various ICs. But this is the exception, not the rule.

For a while, “inventory management” was a pile of parts in bags. It started out in small bins, when it was mostly PTH parts which really were easier to store in little bins, but as the number of parts escalated it fell off a little. I only knew if I could build one by actually finding all the parts at the time.

Inventory management is really critical if you need to know quickly how many you can build beyond just one. One is easy. Five or ten imposes more need to know how many you have of all your components. At least twice now I’ve been caught out by problems in inventory – one part important part wasn’t tracked at all, and a second wasn’t updated properly to reflect builds completed.

Some of this comes from the fact upstream part suppliers probably won’t sell you one of a part, but often if you want good prices you’ll need to buy 10, or 50, or 150 at a time anyway. And they’ll get used at different rates, so you need to track the build usage carefully as well.

Plastic stencils last; stencilling jig needs work

I’ve only ever used plastic stencils for assembling my mostly-SMD boards, and had some concerns about how long they would last. It turns out more than long enough, and now I have a cheap source to make them (Ponoko) I’m less worried about exactly how long they’ll last. Still, I’ve gotten sixteen builds out of the first stencil and they’ve effectively cost a buck for each stencil, so it’s a good run.

The more significant problem with the stenciling approach is the jig I use is .. primitive. I’ve just used spare boards I had from prior prototypes to form something to wedge the target board in place, and it does the job, but only just. It would be easier with something more purpose cut to surround the board as much as possible. One option is to get something laser cut by Ponoko but I’ll need to figure out how close their material thicknesses will get to a PCB thickness.

Frypan works, reflow oven nicer

Despite how primitive the frypan cooking method for board soldering is, it actually does work, and I can manage to get a few boards at a time being soldered up. The reliability has been reasonable so far, although we’ll see how these turn out in the field. The main problem is actually the need to watch it. A controlled oven I could put a set of boards on a tray, stick them in, and just run the cook profile.

This will mean I might have to step up efforts to work on building a reflow oven myself. A full commercial one is both far too large, too expensive, and probably not a lot better than a hacked up toaster oven, but something with control is better than none.

SMD parts are great for production

It feels very strange to be so in favour of surface mount parts, but they are so much easier to solder together a bunch of components than PTH by hand with a soldering iron. I had already come to the conclusion SMD parts made things easier in general, but it wasn’t until I realised I was spending 33% of the build time on just a single PTH component that it really hit home how much easier.

There are still some challenges, getting tiny parts orientated out of the tape they often come in is a pain, and tweezers are a bit prone to too much force causing the part to fly off and disappear to never be seen again .. but those are mostly going to come down to practice. I’ve also ordered a cheap vacuum pencil to see how that works for part pick-up and placement, as a sort of poor human pick-and-place machine.

Production is confidence-building

Lastly, production builds confidence in two ways. Being able to reproduce a build and have them pass basic QA tests first time, every time, gives you a lot more certainty about the way something has been designed. It works, so your understanding of how it works looks a bit better each time.

Having other people using your builds is also helps out a bit with motivation to build other things. It’s fun, no doubt about it I have enjoyed all the things I’ve built whether they worked or not, but it’s a very nice feeling having new devices you made, put for the first time into an anti-static bag, all clean and ready to be used by someone else.