Meet the Babyduino!
This project describes a small Arduino compatible circuit that can be used as the basis for your own projects. It fully integrates into the Arduino IDE and gives you access to all the benefits entailed by that (access to libraries, an easy method of loading code and, of course, the IDE itself).
Given that there is such a wide range of Arduino compatible devices already available why on earth would you need (or want) another one? While I find that the Arduino is great for experimenting and for doing one off projects for a very specific purpose it does have some issues when it becomes time to make your project a bit more permanent (putting it on a PCB for example or making more than one).
The Babyduino is not meant to be an alternative to or replacement for existing Arduino boards - if you are experimenting you should probably stick with one of these. If you want to make a project that is a bit easier to replicate or uses circuits and components that are not available on existing shields you should find the Babyduino is a good starting point for your new circuits.
At the time of writing (Febuary 24th, 2013) this is still very much a work in progress. This page will be updated as things progress. All the source and assets needed for the project are available on the GitHub repository for this project.
Installation and Usage
If you are not interested in the details of the project and just want to get started this is the section for you. First you need to download the latest stable version of the project (or clone it from GitHub if you prefer).
If you are after a specific version here is what is available so far:
Version | Download | Browse | Changes --------|---------------------------------------------------------------------|---------------------------------------------------------------|-------- Stable |Stable |Stable |Changes Working |Working|Working |Changes V0.1.0 |V0.1.0 |V0.1.0|N/A
Download and extract (or clone) the version you want into a local directory. You will find two subdirectories - hardware which contains Fritzing projects for breadboard, veroboard and PCB layouts for the Babyduino variations and babyduino which provides integration with the Arduino IDE.
Adding Babyduino to the Arduino IDE
You need to copy the the babyduino sub-directory from the project into a location that Arduino will pick up. On a Mac or Windows machine this will be the Arduino/hardware directory inside your Documents directory. If you don't have a hardware directory in your Documents/Arduino directory you need to create it first.
Make sure that the Arduino IDE is not running and copy the babyduino directory into the Arduino/hardware directory. You should get a directory tree that looks something like the image to the right (ignore the LeoStick directories, they are for some additional hardware I have).
When you restart the Arduino IDE you should see Babyduino options available under the Tools -> Board menu (see the image to the left for an example). Select the board that suits your project and you are good to go.
Burning a Bootloader
I'll flesh out this section in the future. In the meantime I'll just point you to this post for an adaptor I made for programmers that have a 10 pin ISP cable. Once you have selected your board you should choose the programmer from the Tools -> Programmer menu in Arduino and then choose Tools -> Burn Bootloader to put initialise your chip.
After that you can plug it into your circuit and then use the standard Arduino upload operations to push your Sketch to the chip through an FTDI cable.
The bootloaders provided give you about 2 seconds to start your Sketch upload after you apply power (it doesn't automatically reset when you start the upload process) before it starts running whatever Sketch is already loaded on it. Depending on the speed of your development machine this may mean you shouldn't power up your device until after the compilation phase has started.
For the laptop I use I flick on the power switch when I see the 'Sketch Size' message appear in Arduino. This usually results in a successful upload (don't worry - the Arduino IDE will let you know if it didn't work, just try again and adjust your timing).
I started on this project while working on yet another project - in this case there was a fair bit of custom external circuitry that needed to be added around the core CPU (and I was building it myself, I didn't want to spend $30 to $50 on shields that didn't exactly match what I wanted or that I may not wind up using in the final project). Coming from a PIC background I'm used to doing pretty much everything by hand, changing to the AVR processor and having access to the wide range of source libraries available really simplified the development process.
Although this was a great benefit it did show up some deficiencies in the Arduino platform (or things that I consider deficiencies at least). These are the things I tried to address with the Babyduino project and I've outlined them below:
Suitable for Intermediate Hobbyiests
I wasn't sure how to define this goal. Let's say a beginner is someone who is comfortable using the basic Arduino and connecting up shields. An advanced hobbyiest is comfortable working with SMT (Surface Mount Technology) devices and has a high confidence that board designs they send off for manufacturing are correct.
An intermediate hobbyiest is somewhere between these two levels. Someone who is comfortable building up their own circuits and able to solder (or learning to solder) up through pin components on veroboard.
The Arduino ecosystem seems to favour the beginner level out of the box and is open to customisations by advanced level hobbyiests. There is a steep learning curve between those two and no clearly defined steps on how to progress from one to the other. Hopefully the Babyduino provides this stepping stone.
The Arduino is not very breadboard friendly - and certainly not for reasonably complex circuits. You can certainly hook it up to a breadboard, using a rats nest of hookup wires, and there are breadboard shields available but they only support mini breadboards (so, enough space for a simple OpAmp circuit and not much else). For more complex circuits it can get very messy - and hard to document.
The Babyduino is designed to be easy to assemble on a breadboard using a minimum of components. It can also be put onto a breadboard breakout board with a SIL (Single In Line) footprint freeing up the maximum number of breadboard pins.
Integration with Arduino IDE
There are a number of bare bones Arduino systems already available but getting them to work with the Arduino IDE can require hacks and fiddling with the IDE that can be hard to replicate if you have to do them again.
One of the goals of the Babyduino project is that it should be easy to provide support for projects based on the board - simply copy a directory into the hardware directory of your Arduino sketches directory and you will have support for any Babyduino based project you have built.
All the schematics for the project are provided in Fritzing format. I know that Eagle is a very popular schematic editor but Fritzing, as well as being free, provides a number of useful functions including breadboard layout support. The base circuits for the Babyduino circuits are very simple so it should be easy to translate the circuits from one to the other.
Integrating with the Arduino IDE
The repository contains a babyduino directory that you can simply copy into your Arduino sketches directory to provide full integration with the Arduino IDE. This adds board definitions for all the Babyduino variations so you simply need to choose the one you based your circuit on.
I've settled on optiboot as the preferred bootloader for Babyduino systems - it's small, it's fast and it seems to have been adopted by the Arduino project for new systems.
Although it seems that adding breadboard modules for the Babyduino negates the goal of not trying to provide a replacment or alternative for existing Arduino boards there is a good reason for it.
The base circuit has a minimal number of components so it's easy to put on to a piece of veroboard and provides some practice for those learning to solder. The breadboard modules are designed to be SIL components so they free up a lot of space on the breadboard compared to available Arduino boards. Finally, they are not required to work with the Babyduino - it's just another way to simplify the prototyping phase. These modules are not intended to be used in your final project - they are simply provided as a quick way to get a prototype up and running quickly.