Here are two brand new boards for faster prototyping. These are especially useful for these one-off projects that need to be more permanent than on a breadboard. And they save time as most of the standard components as reset button or ISP header are already on board. Only the custom part of the project has to be soldered on the proto area. They come in two flavors, one for ATtiny25 and one for ATtiny2313 Atmel microcontrollers.

Even a 3 AA cell battery holder with on/off switch is included in the kit. There also two new how-tos with detailed step-by-step instructions, Tiny25 Proto Board Howto and Tiny2313 Proto Board Howto.

You can grab a full kit at the Tinker Store, if you like.

Yay, here is my second article, this time published in the famous Elektor magazine. It’s about the synchronizing fireflies.

I met Jerry at last years HAR2009 and we chatted about the fireflies and all things electronics. He works for the Elektor magazine in the Netherlands and asked me, if I would like to publish an article about the fireflies. And here it is. Thanks Jerry, for making this possible!

A couple of months ago, some nice guys of the IFISC (Institute for Cross-Disciplinary Physics and Complex Systems) contacted me. They saw the Synchronizing Fireflies and wanted them to demonstrate how simple rules can make patterns emerge from chaos. The main research of the institute is in Nonlinear Physics and Complex Systems.

But why would they want electronic gimicks? Every year, there is a science fair, the “Fira de la ciència” in Palma de Mallorca. The fair is aimed at young students, to introduce them to science with many hands-on projects and experiments. The IFISC is part of this fair and decided to use my fireflies as a demonstration of self organizing systems for one of their projects.

It took a while to figure out how to present the fireflies best. Here are two pictures of the palm tree to which the fireflies are tied. Great idea and it came out really beautiful.

For the fair they built a small cubicle with the palm tree inside. The cubicle was neccessary because the fireflies need an almost pitch back environment to see each other flashes.

As the fair was at Palma de Mallorca, I couldn’t resist to see it in person. Last week my girlfriend and I took some days off and travelled to Mallorca. We visited the fair and met some really nice staff members of IFISC. And there it was, a tiny black cube with a palm tree and fireflies within. Wohoo!

After all I have to say thank you all so much for the warm welcome and showing and explaining all your projects. Thanks for the cool t-shirt, I feel almost as a IFISC member now
And especially thanks to Pep for pushing this project further and further and making it possible. It has been a fantastic experience. You guys rock.

Links

• 64 Synchronizing Fireflies
• Synchronizing Firefly Kit
• Some more videos of the test setup, done by Pep
• IFICS (Instituto de Física Interdisciplinar y Sistemas Complejos)
• Fira de la ciència

Last weekend, a small group of tinkerers of Palo Altona built a MakerBot Cupcake CNC. Simone and Christian from Good School bought the MakerBot and asked Palo Altona for assistance with the assembly. Of course we were happy to help out.

We startet on Saturday and made good progress. We assembled the CNC and the extruder and made the first tests with stinking hot ABS. Yeah!

Next day was for learning firmware and tools. We switched X, Y and Z directions of the stepper motors a couple of times and managed to drive the heated nozzle into the platform at first try. *sigh*

This is the very first print out. Although it is not tight enough to drink from it, I was really impressed by the result. What a cool machine!

Here are some more pictures:

• My Flickr set
• Good School on posterous
• Christian on posterous
• Palo Altona on posterous
• Marcus Flickr set

Thanks Simone and Christian for inviting us, it was a pleasure!

This is a Pong clock for your Android phone. It tells the time by playing Pong against itself.

Sander Muller came up first with the idea to have a Pong Clock. A really great idea and a fantastic device. Then lately Lady Ada designed a wonderful hackable clock platform, called MONOCHRON. The first implementation on the platform was, of course, a Pong Clock.

As I received my new Android phone, a Motorola Milestone, I was looking for a simple project to get my hands dirty. So what could be more obvious than writing a Pong Clock.

If you want to take a look at the source, check out my PongTime repo at github. The code is not pretty as can be, mostly because of optimizations to get rid of object creation and thus garbage collection.

If you are reading this with your Android phone, you can grab the Pong Time app directly in the Android Market. Otherwise search for “Pong Time”.

• Pong Time market://search?q=pname:com.tinkerlog.android.pongtime in the Adroid Market
• PongTime repository at github
• Original Pong Clock by Sander Muller
• MONOCHRON by Adafruit

It took a while since I first posted about the new ATmega header board but finally, here it is.

The board is great for prototyping on a solderless breadboard. It is compatible with the common 28-pin AVR controllers like ATmega48, ATmega88, ATmega168 and ATmega328. On plus it is Arduino compatible.

Some of the features:

• Space efficient, occupies only on more row than the controller itself
• Has no voltage regulator on board, so you choose, at which voltage you want to run it
• It has SMD resistors and LEDs (size 1206) to make it a great starting point to learn how to hand solder SMD
• Has a sticker to tell which pin is what. Thanks Tod!
• Blinks blue!

Check out the detailed howto page and grab a kit at the shop, if you like.

What is a remote accelerometer? It’s a tiny device that has a three axis accelerometer and transmit the acceleration values to a remote host. And what is it good for? There are various uses for it. One is you attach the sensor to someone and let him jump around. On your remote machine you can use the data to produce sound or modify music. Think of it as a simplified Wiimote.

Last year Jan of electronicperformers.org came to me with the idea to make the jumping of people on a trampoline audible. We thought about it and it seemed to be easy. I tinkered with some XBees and ADXL acceleration sensors. They worked quite ok, but we had some trouble with the transmission, which sometimes just stopped for a couple of seconds. Maybe some kind of resetting, I really don’t know. Here is a video of the installation.

After that I thought, nice, but can’t we get it smaller and cheaper? So I sat down and designed a tiny custom PCB.

Features

I had already two JeeNodes laying around. These boards are using a RFM12B transceiver board to communicate with each other. So I decided to use the RFM12B as XBee replacement. They are really cheap, around 3 to 4 Euros.
The device should be Arduino compatible. Mostly because of the ease of development and available libraries.

• ATmega328P, Arduino compatible microcontroller, running at 8 MHz
• ADXL335, 3 axis accelerometer, +/- 3g
• RFM12B radio transceiver, 868 MHz, range of up to 100 meters
• MCP1702 linear, low-drop voltage regulator for 3.3 V, 250 mA
• powered by a 3.7 V lipo cell, 100-300 mA
• 6 pin ISP header for programming the bootloader
• 6 pin serial header to attach an FTDI-cable
• voltage sensor to tell when the battery goes low

Assembly

This is my second try on SMD. Resistors and capacitors are sized 0805. The controller is TQFP and the ADXL335 is LFCSP. LFCSP has not even pins you can hand solder. A very tiny package. As I had no stencil to place the solder paste (because I still have no laser cutter) I had to place the paste by hand. Pressing hard on the syringe and trying to work precisely at the same time is not that easy. After placing a tiny bubble of paste on every pad and gently placing all components, I heated up my hot-air rework station. Soldering with the hot-air station was easy. Not all components are well aligned, maybe because I used not enough solder paste. Often mis-aligned parts slide into place as soon as the paste gets liquid.
Next were the headers, battery connector and the RFM12B module. These were soldered traditionally with an iron.

Here is a picture of the back with the RFM12B module. The red wire is the antenna.

Software

After having the thing assembled it’s time to test it out. First is to program the Arduino bootloader. For that you need an ISP programmer. I used the USBtinyISP from adafruit. Simply select the target (Arduino Pro Mini @ 8 MHz w/ ATmega328), programmer and the port in the Arduino IDE and select “burn bootloader”. Worked on the first try.
Next is a blink sketch to check if the serial connection and the LED works. It turns out that I used too little solder paste on the controller. After resoldering that pin the LED worked.
Next sketch was to check if the ADXL works correctly, which it did. All three axis seem to work great.
After that I had to get the transceiver working. I took the RFM12 lib from Jee Labs. You have to download the Ports lib as well to get it running. First I uploaded the RF12demo sketch, which allows to setup the RFM12 module and store the configuration in EEPROM. The module was recognized and configured with no problem at all.

Time to develop the actual firmware. Here is the sketch for the sensor.

// RF12B ADXL sensor
// config D i4 g212 @ 868 MHz

#include "Ports.h"
#include "RF12.h"

int xPin = 0;
int yPin = 1;
int zPin = 2;
int ledPin = 5;
byte buf[6];

void setup() {
  rf12_config();
  pinMode(ledPin, OUTPUT);
}

int x, y, z;
unsigned long time;
byte ledOn;

void loop() {
  rf12_recvDone();
  if (rf12_canSend()) {
    x = analogRead(xPin);
    y = analogRead(yPin);
    z = analogRead(zPin);
    buf[0] = x >> 8;
    buf[1] = x;
    buf[2] = y >> 8;
    buf[3] = y;
    buf[4] = z >> 8;
    buf[5] = z;
    rf12_sendStart(0, buf, 6);
  }
  if (time < millis()) {
    time = millis() + 200;
    if (ledOn) {
      digitalWrite(ledPin, HIGH);
    }
    else {
      digitalWrite(ledPin, LOW);
    }
    ledOn = !ledOn;
  }
}

It's really easy. You have to call the rfm12_recvDone() to make sure the driver is still working. You have to call it, even if you are not trying to receive anything. If rfm12_canSend() returns true, we can transmit our data. We read the 3 axis acceleration and pack it into a byte array. This byte array is then transmitted. No more, no less. No acknowledge, nothing.

The receiver part looks almost the same, it receives the data and prints it on the serial port. From here on, you can do almost anything: Processing, Pure Data, Python, what ever fits best. You only have to be able to read a serial port.

Demo

For the demo I used Processing to draw a graph of every acceleration value. The red one is a bit hard to see in the video. Then I used Python with pyglet to play short wave sounds.

Outlook

The picture above shows three generations of this device. On the left is the first implementation, using an XBee and an ADXL335, both on breakout boards, wired on a prototyping board. In the middle is the first custom PCB. As you can see, there are two air wires. That happens, when you get distracted while designing a PCB. On the right is the current version.

For the next design I would include an ON/OFF switch so you don't have to pull off the battery all the time. And maybe add a small tactile button to make more Wii-like projects possible.

Downloads and Links

• Eagle files and Arduino sketches, remote_accell.zip
• RFM12 lib at Jee Labs, great stuff!

If you’ve missed Marcus post, here is another on the same topic.

Nearly every other Thursday Marcus and I are hanging out together for having a beer and chatting about all things geek, especially electronics, CNC, 3D-printing, micrcontroller and Arduino. But there’s no limit, everyone interested in tinkering and making is welcome. It takes place at Saal II in Schanze. Try us, we’re kind

You can take a look at Marcus’ or mine twitterfeed to checkout when the next #palo_altona will be.

We already had guests sometimes but yesterday’s drinkup was great as we had two new guests. Feels as if there is something moving in Hamburg. Yeah!

Update 2010/02/16: Palo Altona is now scheduled biweekly. Every Thursday was a bit stressing for everybody.

Update 2010/03/20: Palo Altona has now a Posterous page for news and schedule.

It’s Advent season. And what do you do to let your geek shine? An LED Advent wreath of course.

The idea came to me after seeing Sprite’s minimalistic version of the Hackaday’s Flickering LED circuit. It’s a simple circuit that flickers LEDs and detects darkness. I thought that this could make a great little Advent wreath. My version should have 4 LEDs and should be support first, second, third and fourth Advent.

Parts and Schematic

The parts list is rather short:

• ATtiny13V, 8-bit microcontroller, 1k flash RAM, 64 bytes SRAM
• 4 * 3mm LEDs, yellow or orange, forward voltage ~ 2.0 V
• CR2032 coin cell, 3 V, 230 mAh
• Paperclip

There are no current limiting resistors in this circuit. Normally operating LEDs without them is not advisable because the LEDs will get damaged. But under certain conditions the resistors can be left out. For more on this topic, see Sprite’s computation or mine here.

How does it work

The nice thing about this circuit is, that it needs no special components to detect darkness. It uses an LED for that. An LED is also a photodiode that can detect light of the same wavelength it emits. See here for more details. Sprite used an available ADC of the ATtiny13 instead of the “Reverse Bias” method.

Software

The software is heavily based on Sprite’s version. Things I’ve changed:

• Added support for four LEDs.
• Removed calibration, replaced with hard wired values.
• Added a bit sampling to the light measurements, because the values were a bit erratic.
• Added a mode for first, second, third and fourth Advent, stored in EEPROM. Gets incremented at every reset.
• Modified the watchdog code a bit to keep it generating interrupts instead of resets.

After power up, the watchdog gets enabled to generate an interrupt every two seconds. Then the current mode (0-3) is read from EEPROM, incremented and stored back. Then the endless loop is entered, where random values are used to flicker the LEDs. The ISR checks the ambient lighting and if it is higher than a certain level, sets a sleep flag. This flag is monitored in the main loop. If set it sends the controller in to power down mode to save battery power. The next interrupt will wake up the main loop.

Assembly

This circuit is soldered in “free form”, so no PCBs. It takes some time to get it done but it’s worth it.
All cathodes of the LEDs are connected to form the ring. The anodes are bent inwards to be soldered to pin 2, 3, 6 and 7 of the ATtiny13. A short piece of wire is connected to the common cathode and soldered to the GND pin.

The microcontroller lies “dead bug” style on the coin cell. The GND pin is bent to the top, now connecting to GND of the battery. The VCC pin is bent to the bottom and soldered to the coin cell holder. The coin cell holder works as a clip, pressing the microcontroller onto the cell.

Some random notes:

• Be patient.
• Use as less solder as possible.
• Don’t heat the pins of the controller for too long.
• Be gentle while bending the controller pins. They come off easily. I added a tiny bit of solder.
• BE patient

The Result

If you make one, please let me know. Send me a picture or post it on the tinkerlog flickr pool.

Happy third Advent …

Downloads and Links

• Source advent.zip
• Minimalistic flickering LEDs at Spritesmods
• Flickering LED circuit at Hackaday
• LED Menorah, also free form at Evil Mad Science

A couple of weeks ago Jan came to me and asked me if I could build a special kind of twitter wall. At our company CoreMedia we do an Open Space every 3 months or so. This time we had a Hacking Day as well, so we needed something special. After throwing some ideas around, we came up with a twitter client that should print out tweets with an electric typewriter. A short google showed, that that has been done already (of course!). See it at oomlout.

But that couldn’t stop us. Jan scanned ebay for a nice electric typewriter and found a Commodore SQ 1000. It was in really good condition, probably rarely used. It worked as advertised.

Take it apart

First step is to take it apart. That reveals a small PCB and the connections of the keyboard. Later I realized that I hadn’t to open up the keyboard itself, because there is nothing of interest in there. It is a simple keyboard matrix.

The big chip on the right is a SEC microcontroller. The smaller chips should be there for driving the barrel etc. but I haven’t investigated that. The green foil in the middle is the connection to the keyboard. Actually there are two connections, each with 8 lines, one for the rows, one for the columns to form a matrix.

I decided, that the easiest way to simulate key presses was by shorting the switch of the desired key. I soldered two 8 line cables to the solder joints on the bottom side of the PCB. Actually there were 12 lines on one of the connectors, but 4 of these lines are used to drive LEDs for caps lock and power.

How does it work

Putting everything back in to place I tried to understand, how the keyboard matrix works. Very helpful was this tutorial, that connects a keypad to an AVR.

All 16 lines are directly connected to the controller, no external pull-up or pull-down resistors. As already said, the 16 lines are arranged to form a 8 by 8 matrix, giving 64 possible key codes. 8 lines are supplying 5V (called out) and the other 8 lines are low (called in). The controller then cycles through all out lines, pulling it down, one at a time. Then it checks if one of the in lines is pulled to low to identify the pressed key.
To simulate the key press I have to wait for low on a specific out line and then pull one of the in lines low. I used my oscilloscope to see what’s really going on. It turns out that the controller scans for key strokes with 87 Hz. Every line is low for about 150 us. I used the Arduino to record the sequence and calculate how wide the low phase is. When I would find a low on line 1 of the out line, I could use it as trigger and compute when the other lines would be pulled down. That way I would only use a single wire (and Arduino input) to detect the out line.
To set a specific in line to low I am using a 74HC595, a shift register with tristate output. The tristate is nice, because if it is disabled, the keyboard is fully functional as if the Arduino is not connected at all.

Here is everything connected on a breadboard. On the left is a standard Arduino with an Ethernet Shield.

On the right is the shift register. In the middle is a pull up resistor connected to line 1 of the out lines. That is used to be able to “see”, when the line goes down.

Reading twitter

The software part to connect to twitter is straight forward. I used the twitter search API to pull tweets that contained the word #cos09, which was the hashtag used at the CoreMedia Open Space. The query is executed every 60 seconds and the query string looks like this:

Parsing the json formatted response is a bit ugly, mostly because memory is very limited on the ATmega168. After fetching and parsing a complete response, the max_id is stored and used for the next query. That way only new tweets are printed.

Demo

So far everything worked well, except the hash sign (#), the @ and … umlauts (*sigh*). The hash sign is not available because it only accessible by pressing the code key simultaneously, which is not possible with the current setup. The @ is not available at all, I simulate it by the sequence O-backspace-a. Umlauts are missing because … I’m lazy.

Final twitter wall setup

This is the setup as twitter wall. On the right is a video camera, recording incoming tweets and displaying them via a projector on the wall. The notebook is only bridging WiFi to Ethernet.

After all, the retro twitter wall was fairly successful. People stood around with a smile, tweeting with their iPhone, waiting for an intense “rattatatat rattatat …”.

Here is another action shot, taken by Jörn.

Links and Downloads

• Source: twypper.zip
• Twitter Monitoring Typewriter at oomlout
• Connecting a keypad to an AVR
• Keyboard Matrix Help