« Back to home

Updates on the Babyduino Project

The Babyduino project has been progressing well - I've managed to hit a number of minor milestones in the past couple of weeks ...

A More Permanent ISP Adaptor

Some of my AVR chips are already starting to show wear and tear on the pins from swapping from the programmer breadboard to the Babyduino breadboard during my bootloader testing so I decided it was well worth spending some time creating a more permanent version of the ISP programming adaptor.

Exploded View

I wound up building it up on some veroboard (it's a fairly simple circuit). The veroboard layout is shown to the left (in an 'exploded' view so you can see where tracks need to be cut. For my version I cut the tracks using a Dremel style tool with a cutting disc attached (you need to take a bit of care with this so you don't cut additional tracks unententionally).

I had a larger ZIF socket than was required in my component drawer so I used that rather than buying a new one. Ideally you should use a 28 pin ZIF socket but you can use a larger one as long as you orient the chip such that pin 1 is always at the top (closest to the handle) of the socket.

I printed a variation of my PCB holder to keep the board from short circuiting on my workbench and make it look a little bit more designed as opposed to 'thrown together'.

The entire process took about three hours - that included designed the Veroboard layout, preparing the Veroboard, soldering the components and printing the holder for it. Much to my gratification (and relief) it worked the first time I tried it. That doesn't always happen (even for simple circuits) so it was a bit of a pleasant surprise when it did.

Finished Product

The finished version can be seen in the image to the right. There were a number of new things I learned while doing this:

  1. Fritzing supports Veroboard layout. You go to the 'Breadboard View', delete the breadboard and then add a Veroboard from the 'core' component list (it's under the 'Breadboard' component group). Unfortunately you can't have both in the same project - if you need a Veroboard and a Breadboard layout your will need to make a copy of your project file and maintain them separately.
  2. Set the size of the Veroboard immediately before laying out components, changing it after you have already placed some components can lead to some unexpected side effects. This means you have to have a reasonable idea of how large a piece of Veroboard you will need before you start.
  3. To cut tracks simply right click between mounting holes. This will remove the trace between the mounting holes. Doing this again on an already cut trace will restore the trace.
  4. Be patient - Fritzing gets very, very slow while working with Veroboard layouts. It generally does what you asked it to - it can just take a while to do it. On my Mac I spent a lot of time looking at the spinning beachball before Fritzing did it's job and came back to me.
  5. Print out a copy of the Veroboard layout to work from (and move any larger components out of the way first - see the 'exploded' view above - so you can clearly see where tracks need to be cut). I use a permanent marker to mark both the top (where hookup wires need to go) and the bottom (where tracks need to be cut) before I start preparing the Veroboard.
  6. Something very simple but very important - always run a bit of fine grain sandpaper over the copper tracks of the Veroboard before you start soldering. This will ensure your solder will bind your components to the tracks with a clean connection.

    Overall, this has been a very successful project - I've put bootloaders on a number of chips using this and so far I've had no failures. The Fritzing project which contains the breadboard layout is now in the development branch for V0.1.X of the project - it will move to the master branch when I create the next release in the near future.

    A Babyduino Breadboard Module

    One of the problems I had with the 'real' Arduino (and all it's variants) is that it is not very breadboard friendly (especially if you need to use a lot of IO pins). If you have a version that does plug in to a breadboard you don't get a lot of space to run hookup wires, if you keep the Arduino separate you have a lot of wires running from the connectors on the Arduino itself to random places on your breadboard. This is fine if you are just interfacing a single chip or depend on shields to do most of the heavy lifting for you it's not that much of a problem. For more complex circuits you wind up with a rats nest of wires that are hard to debug and easy to get wrong.

    A Babyduino Board

    When it comes to breadboarding I'm a big fan of Single In-Line breakout modules. This frees up the maximum amount of space on the breadboard and makes routing signals much easier. I wound up designing a PCB layout in Fritzing (single layer) and sending it to the Seeed Studio PCB Fusion service to get some boards made up. The gerber files generated by Fritzing passed the validation test and now I'm waiting on delivery - we'll see how it turns out.

    This is my first ever board design so it's probably not the best, I figure I can fix it up after using some of them for a little while. The board is larger than I had hoped (7.5cm x 5cm) but that is mainly due to the single side limitation (I wanted to be sure it could be easily etched by hand or routed with a CNC machine).

    Adding Support for Externally Clocked Babyduinos

    I was making a list of simple sample projects to base around the Babyduino system and a number of them required the use of the V-USB library to provide a simple HID interface for use with a standard desktop. Unfortunately using V-USB requires a faster clock rate than the internal clock can provide so I had to accelerate support for an externally clocked version of the system.

    The PCB's I designed allow for an (optional) 3 pin ceramic resonator to provide the external clock. I've started adding definitions and bootloaders for the externally clocked Babyduinos in the GitHub repository for the project although these haven't been tested yet.

    Sample Projects

    Speaking of sample projects I've been trying to come up with a few non-trivial ones that show how using the Babyduino system makes it easy to go from original design (using a standard Arduino or the Babyduino breadboard module) to prototype (using the Babyduino breadboard layout) to a final implementation based around the Babyduino circuit and layed out on Veroboard or a PCB.

    An Old Favourite

    Some of the project ideas I came up with include:

  7. Turning the keyboard from an older (80's era) computer into a USB keyboard to make it easier to put a more modern motherboard into an older case (in this case I was looking at putting a Raspberry Pi into a Microbee case althought the techniques could be adapted to other systems.

  8. Creating an Arcade controller (combining an analog joystick and a few buttons) that could be used with different components to help make an arcade console using any system that supports USB and can run MAME.
  9. An emulator for an older machine (the ATMega generally has a lot more functionality than the CPU's used in systems created in the 70's but adds it's own set of limitations). This has been done before but there were a wider range of systems available then compared to todays mono-culture so there is no shortage of bizarre or unusual systems that could be targeted.
  10. A very simple project like an automatic light or remote sensor that can track when people arrive at your door. This seemed a bit simple though and could easily be accomplished with a PIC or ATTiny processor and doesn't really get a lot of assistance by having access to the Arduino IDE.

    As I mentioned in a previous post I'm looking at implementing a CHIP-8 virtual machine on an ATMega chip as an example for the internally clocked Babyduinos. For an externally clocked system I'll work on one of the projects above that require a USB interface.

    What Comes Next?

    I'm working on a V0.2 release that will include support for externally clocked systems as well as the current internally clocked systems and provide proven working breadboard modules for all systems. At the moment this is waiting on the delivery of the PCB boards I've ordered.

    Once this is done I'll do a few sample projects based around the system from design to completion before finally pushing out a V1.0 release. So far everything is going well (even if it is taking a bit longer than I had hoped for).