Here’s a little clock project with a twist – it displays the current time on a single large 7-segment LED display, by briefly showing each of the digits one after the other.

[youtube=http://www.youtube.com/watch?v=V6v_k74JX1s&hl=en&fs=1]

Note the transition from 12:20 to 12:21. The little red blinking light at the bottom is the actual DCF77 radio signal, one pulse each second, with a long/short duration to encode each bit.

This project uses a Boarduino as brains, a DCF77 radio receiver, a large Kingbright 7-segment display, a 2981 LED driver, a bunch of 470 Ω current limiting resistors (1K for the decimal point), and a 6..12V DC power supply:

On the left are the power plug and 5V regulator, on the right of the Boarduino you can see the reset button, 2×3-pin ICSP header, and 6-pin header used for programming with a USB-FTDI cable. On the far right is the 2981 chip used to drive the LED segments with 8..14V.

The radio print is soldered directly to the Boarduino (digital I/O pins 2..5) in such a way that the reception antenna with L/C circuit fits is snugly between the radio print and the display module. For simplicity, the radio’s +5V and ground are also provided by the Boarduino via digital I/O pins – they are fixed on startup as “1” and “0” outputs, respectively.

I used wire-wrap wire to make the connections because it’s so thin and solders very easily:

One nice software gimmick is that the clock starts by displaying a personalized greeting, since this project was made as birthday gift for a friend. Once the proper DCF77 radio signal has been decoded, the display switches to showing the current time; this usually takes two to three minutes after power-up. The clock will continue to run on its own with ≈ 0.5% accuracy in the absence of valid radio signals.

The C source code can be downloaded here. It decodes the DCF signal and encodes / drives the 7-segment display in a continuous loop.

The AVR Raven is an interesting successor to the AVR Butterfly. It has two ATmega processors on board, one drives an advanced transceiver for wireless use. This explains the double set of ICSP/JTAG headers:

Haven’t had much chance to play with it yet, other than to verify that the Ravens and the USB-stick base station work (current software requires a Windows server).

The Mini Pro Arduino (specs) is another way to embed an ATmega168 processor:

I added the pin headers, though one could also use this as a very flat embedded module by wiring directly to the circuit pads.

This one runs at 8 MHz and uses a 3.3V regulator (which means the I/O pins are also at that level). It’s not a kit, due to the use of SMD components.

The USBtinyISP is a kit for a USB-connected AVR compatible ICSP programmer:

On the left are two cables, with 6-pin and 10-pin ICSP plugs, respectively. Inside is a pre-programmed ATtiny chip plus some level converters for use with 3.3V hosts (do need to remove a jumper for that).

Built into avrdude by using the “-c usbtiny” option. No need to specify port or baudrate (unlike some other programmers). To make this the default programmer, I added this line to my ~/.avrduderc:

        default_programmer = “usbtiny”;

This little device works really well.

LiquidWare has a Lithium Backpack which goes underneath an Arduino:

It needs two wires to feed the regulated 5V power + ground lines directly into the Arduino (I could have also connected them to the ICSP header). The switch on the battery board which is just visible in the lower left corner let’s you select between using and charging the Li-Ion battery.

Which is good, given that Lithium batteries can be a bit, ehm, finecky to deal with…

[youtube=http://www.youtube.com/watch?v=dOMfdH76oi0&color1=0xb1b1b1&color2=0xcfcfcf&feature=player_embedded&fs=1]

Pololu produces the 3π robot, with two independently driven wheels plus ball caster, an ATmega 168 for smarts, and on-board power that allows it to autonomously move around. The 3pi comes pre-assembled, and is smaller and much more maneuverable than the Asuro kit I built recently.

There’s an impressive intro on the Pololu site:

The nice thing about the 3π is that it is fully Arduino-compatible and that it comes with two nice programs, for advanced line-following and maze searching, respectively.

So I set up a little track in a drawing program and printed it out, taping the 3 x 4 pages together to create a little track. Unfortunately, I couldn’t get 3π to successfully follow the line; perhaps the printed inkjet ink does not have sufficient contrast for its infrared eyes? The robot only barely follows the line, and goes off track into a spin all the time.

I will need to create a better track with black tape one day, as suggested on the Pololu site.

Still, this was very educational. I found out about proportional–integral–derivative (PID) controllers, and how they help create feedback-based control loops that push mechanical systems to their limits without overshoot or erratic behavior.

Update 2008-11-29 : indeed, with black masking tape 3π works just fine!

The Boarduino is an Arduino clone intended for use on a breadboard (the picture below is from another project):

There’s a DC version with an FTDI connector for programming (shown above), as well as a USB version (which powers and programs the board). Since there is an ICSP header, I decided to leave out the IC socket from this kit.

The Real Bare Bones Board (RBBB) is an even lower-end version. It’s smaller than the Boarduino and omits the ICSP header:

Due to its low cost as a kit, this would be a great option for permanent embedded use.

The AVR Butterfly is a cheap demo board for the ATmega169V with on board LCD, sensors / switches, and RS232 interface:

I added the RS232 and ICSP headers to be able to boot-load and re-program it, and successfully tried Forth on it.

Asuro is a simple robot, which I ordered as a kit from Conrad. The mechanical construction is entirely based on an epoxy board which also holds the electrical circuit. The brains consist of a C-programmable ATmega8, the older 8 Kb version of the 168 chip used by Arduino’s.

Here’s the result of a few hours of tinkering:

Another cost saving feature is the IR-link, which can be used to re-flash the program. It does require line-of-sight to function, and has a limited range of 1 to 2 meters as far as I can tell:

The above image shows the RS232 serial board that came with the kit. I must have made a mistake while building it – because it didn’t work. Luckily, I had also ordered the ready-made USB version, which works fine.

The test program pre-loaded into the Asuro activates all elements (LEDs, front switches, motors) as a way to test proper operation of each of them. It was most useful to chase down and resolve a few small build problems. There are photo-sensors which can be mounted underneath for line-following, but I chose to add some connectors for a prototype board instead. The reasoning being that these sensors could always be added back via such a prototype board.

So, does it work? I can’t really tell.

I couldn’t find any ready-made programs to make it do anything robot-like such as driving around and dealing with obstacles, or light-seeking/-evading behavior. And it’s clear that any form of intelligent control will require some serious programming and testing. Besides, the motors were very noisy and coarsely controlled, so I doubt it really can do things with any level of grace…

But I had a good time building this thing, and learned quite a bit about what it takes to make a little autonomous robot.