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.

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

Here is my very first article. It is published in c’t, one of the best known computer magazines in Germany. wOOt!

It shows some basic Arduino examples and how to build a Wiimote-like controller. The controller consists of an 3-axis accelerometer, a push button and an Arduino nano on a breadboard. This combination is used to control a Lunar Lander type of game, programmed in Processing.

• c’t article Shake, rattle ‘n’ roll, as full text
• wiki with more images, links and downloads

Often, when I am tinkering with a controller on a breadboard, I have to open up the according datasheet, only to look up the pinout. So I designed a simple page with all of of the pinouts that I use most. It has:

• 8-pin AVRs, ATtiny25/ATtiny45/ATtiny85
• 20-pin AVR, ATtiny2313
• 28-pin AVRs, ATmega48/ATmega88/ATmega168/ATmega328
• Arduino to ATmega mapping
• ISP header, 6-pin and 10-pin
• FTDI-cable

Maybe it’s helpful for others as well. You can download it as:

• micro-cheat-sheet.pdf
• micro-cheat-sheet.svg

If you like it, you will also like the Tod’s cool Arduino chip sticker.

Update 2010/01/24

The new version includes the pinout of the Bus Pirate. Thanks Philipp for the update.

Here is the second incarnation of a Braitenberg vehicle. This one is almost half of the size of the previous one and it is programmed to “love”. That means it sticks to the light source and does not try to overrun it, as the “aggressive” first one.

If it is dark, then the two motors run at full speed. If a sensor detects light, it slows down the motor on the same side. So, if the right sensor detects more light than the left sensor, the right motor turns slower than the left one. That makes the vehicle turn right to the light source. If it is bright enough, both sensors will stop both motors.

Parts

• Arduino Mini Pro from Sparkfun
• Mini breadboard with 170 tie points from Sparkfun
• 2 mini servos, HXT500 from Hobbycity
• 2 GM10 wheels from Solarbotics
• 3.7V LiPo cell with 800 mAh from Sparkfun
• 2 Light Dependant Resistors (LDR)
• 2 10 k resitors
• 2 3 pin headers

I picked the Arduino Mini Pro because of it’s size and because it runs at 3.3V, a good match with the 3.7V lipo cell. The lipo cell has about the same size as the mini breadboard. The two servos are hacked for continuous rotation and tied together, bottom to bottom with a piece of wire. Although most servos are rated for 5V, they work great with 3.7V. Maybe they run a bit slower.

Code

/*
 * Simple braitenberg vehicle
 */
#include "Servo.h"

Servo leftServo;
Servo rightServo;
int leftValue = 0;
int rightValue = 0;

void setup() {
  Serial.begin(9600);
  leftServo.attach(10);
  rightServo.attach(9);
} 

void loop() {
  // sensor values between 50..900
  leftValue = (880 - analogRead(1)) / 25;
  rightValue = (900 - analogRead(0)) / 30;
  leftServo.write(101 + rightValue);
  rightServo.write(101 - leftValue);
  delay(10);
}

The values are determined by experiments. Yours may vary.

Here is the mini next to his older brother. The space on the mini breadboard is really limited, but it just works out. Still no soldering required, if you don’t count the servo hacking.

What’s next? Hm, pager motors?

Links

• Arduino powered Braitenberg vehicle
• Valentino Braitenberg

This is another breadboard compatible header board, that I am working on. This one is for all 28-pin AVR devices, ATmega48, ATmega88, ATmega168 and the latest ATmega328. Component count is low and there is no voltage regulator on board. That makes it easy to power it from various sources.

As a bonus, this board is a hybrid of through hole and SMT components. It has two SMD LEDs under the hood. Great to learn how to solder surface mounted devices.

It has also an FTDI-connector and runs with a 16 MHz resonator, which makes it Arduino compatible. The jumper is used to select between different power sources.

Yikes, SMD soldering. This is my first attempt at hand soldering 1206 SMT components. 1206 is only 3.2 mm × 1.6 mm! But these are about the largest SMT components available. Most commonly used are way smaller, 0805, 0603 or 0402. My soldering still looks ugly, but with a bit of practice I think I can do much better.

The space on the board is a bit limitted, so there is no room to mark all pins. That’s why I have a little cheat sheet around, while wiring things up.

The Arduino can talk over a wide range of networks. Ethernet, Bluetooth, Wifi, XBEE and GPRS to name the most known. I had a Telit GM862-GPS module laying around, unused for some time already. It has GPRS and GPS capabilities, both accessible with AT commands. So I decided to port some of my code to the Arduino.

Schematic

Connecting the Arduino Mega to the GM862 is rather easy. Only four connections are needed.

• Tx3 – Tx
• Rx3 – Rx
• Pin 22 – On/Off
• GND – GND

The GM862 is accessed with a breadboard fiendly breakout board from Sparkfun.

The logic pins of the GM862 accept only CMOS 2.8 Volt. For that reason, a voltage divider is needed for the Tx line. Both, Rx and Tx are pulled up to the PWR_CTL line of the module because these pins don’t have an internal pull up resistor.
The on/off line is connected to ground with a transistor.

The bad thing for this setup is the power supply. The module is powered by a LiPo cell (3.7 V with 2000 mAh). The Arduino Mega is powered by the USB port. If I want to make this portable, I have to use two batteries. Or find a better solution. Maybe powering the Arduino with a step-up converter.

Software

First I wanted to use an Arduino Pro mini, that runs on 3.3 V. That would save me from having two different power supplies for the Arduino and the GM862. I tried to connect the Rx/Tx lines to two digital pins and use the NewSoftSerial library. This library enables a second serial port on the Arduino besides the hardware serial port. Unfortunately it wasn’t reliable enough. Sending to the module seems to work well, receiving sometimes did not. I tried it with different baud rates and different Arduinos, 8 MHz and 16 MHz, but that didn’t help. Maybe I did something wrong, but I couldn’t figure it out.
So I switched to my brand new Arduino Mega. I just connected Rx/Tx to one of the hardware serial ports and it worked immediatly.

The following features are implemented:

• Starting and stopping the module
• Initialization
• Sending of SMS
• Requesting GPS position and parsing the result
• Opening a socket, writing and reading (used to talk HTTP) over GPRS

The software is an really early stage. I focussed most on functionality and less on performance or compact code. The following todos are still open:

• Make debugging output configurable
• Use of PROGMEM to reduce RAM usage
• More compact structure for AT commands
• Parse more responses of AT commands. Some are simply issued, without looking at the response

Nevertheless, here is a small snippet, that shows features that are already working. To get it working, you have to replace XXXX with your PIN. For GPRS you have to dig into the module code and adapt the GPRS settings.

/*
 * GM862-GPS testing sketch
 * used with Arduino Mega
 * http://tinkerlog.com
 */

#include "GM862.h"

int onPin = 22;                      // pin to toggle the modem's on/off
char PIN[5] = "XXXX";                // replace this with your PIN
Position position;                   // stores the GPS position
GM862 modem(&Serial3, onPin, PIN);   // modem is connected to Serial3
char cmd;                            // command read from terminal

void setup() {
  delay(10000);
  Serial.begin(19200);
  Serial.println("GM862 monitor");
  modem.switchOn();                   // switch the modem on
  delay(4000);                        // wait for the modem to boot
  modem.init();                       // initialize the GM862
  modem.version();                    // request modem version info
  while (!modem.isRegistered()) {
    delay(1000);
    modem.checkNetwork();             // check the network availability
  }
  Serial.println("---------------------");
  Serial.println("ready");
}

void requestHTTP() {
  char buf[100];
  byte i = 0;
  modem.initGPRS();                   // setup of GPRS context
  modem.enableGPRS();                 // switch GPRS on
  modem.openHTTP("search.twitter.com");    // open a socket
  Serial.println("sending request ...");
  modem.send("GET /search.atom?q=gm862 HTTP/1.1\r\n"); // search twitter for gm862
  modem.send("HOST: search.twitter.com port\r\n");     // write on the socket
  modem.send("\r\n");
  Serial.println("receiving ...");
  while (i++ < 10) {                  // try to read for 10s
    modem.receive(buf);               // read from the socket, timeout 1s
    if (strlen(buf) > 0) {            // we received something
      Serial.print("buf:"); Serial.println(buf);
      i--;                            // reset the timeout
    }
  }
  Serial.println("done");
  modem.disableGPRS();                // switch GPRS off
}

void loop() {
  if (Serial.available()) {
    cmd = Serial.read();
    switch (cmd) {
    case 'o':
      modem.switchOff();              // switch the modem off
      break;
    case 's':                         // send a SMS. Replace with your number
      modem.sendSMS("6245", "your@email.com hello from arduino");
      break;
    case 'w':
      modem.warmStartGPS();           // issue a GPS warmstart
      break;
    case 'p':
      position = modem.requestGPS();  // request a GPS position
      if (position.fix == 0) {        // GPS position is not fixed
        Serial.println("no fix");
      }
      else {                          // print lat, lon, alt
        Serial.print("GPS position: ");
        Serial.print(position.lat_deg);  Serial.print(".");
        Serial.print(position.lat_min);  Serial.print(", ");
        Serial.print(position.lon_deg);  Serial.print(".");
        Serial.print(position.lon_min);  Serial.print(", ");
        Serial.println(position.alt);
      }
      break;
    case 'h':
      requestHTTP();                  // do a sample HTTP request
      break;
    default:
      Serial.println("command not recognized");
    }
  }
}

Log

Here is a log, that I recorded within the Arduino IDE. You can see, how

• the modem gets switched on
• the modem gets initialized
• the version info is requested
• it waits until the network is reachable
• a GPS position is requested
• a SMS gets send
• how a HTTP GET is issued over GPRS, it searches for gm862 on twitter

GM862 monitor
switching on
done
initializing modem ...
AT
->ok
AT+IPR=19200
->ok
AT+CMEE=2
->ok
AT+CPIN=XXXX
->ok
done
version info ...
AT+GMI
->buf: AT+GMI
Telit
OK
AT+GMM
->buf: AT+GMM
GM862-GPS
OK
AT+GMR
->buf: AT+GMR
07.02.403
OK
AT+CSQ
->buf: AT+CSQ
+CSQ: 0,0
OK
done

checking network ...
AT+CREG?
->buf: AT+CREG?
+CREG: 0,2
OK
done

checking network ...
AT+CREG?
->buf: AT+CREG?
+CREG: 0,2
OK
done

checking network ...
AT+CREG?
->buf: AT+CREG?
+CREG: 0,1
OK
done

---------------------
ready

requesting GPS position ...
AT$GPSACP
->buf: AT$GPSACP
$GPSACP: 110621.999,5333.9477N,00954.8735E,1.4,66.3,3,22.21,0.10,0.05,150509,08
OK
3
GPS position: 53.565794, 9.914568, 66

sending SMS ...
AT+CMGF=1
->ok
AT+CMGS="6245"
->not ok: AT+CMGS="6245"
>
your@email.com hello from arduino
done

initializing GPRS ...
AT+CGDCONT=1,"IP","internet","0.0.0.0",0,0
->buf:
+CMGS:  35
OK
AT+CGDCONT=1,"IP","internet","0.0.0.0",0,0
OK
AT#USERID=""
->buf: AT#USERID=""
OK
AT#PASSW=""
->buf: AT#PASSW=""
OK
done

switching GPRS on ...
AT#GPRS=1
->buf: AT#GPRS=1
+IP: 10.37.146.251
OK
done

opening socket ...
AT#SKTD=0,80,"search.twitter.com",0,0
->buf: AT#SKTD=0,80,"search.twitter.com",0,0
buf:
buf:
CONNECT
sending request ...
receiving ...
buf:HTTP/1.1 200 OK
Date: Fri, 15 May 2009 11:07:19 GMT
Server: hi
Status: 200 OK
Cache-Control: ma
buf:x-age=20, must-revalidate, max-age=1800
Content-Type: application/atom+xml; charset=utf-8
X-Serve
buf:d-By: searchweb005.twitter.com
Expires: Fri, 15 May 2009 11:37:18 GMT
Content-Length: 4757
Vary:
buf: Accept-Encoding
X-Varnish: 218274860
Age: 0
Via: 1.1 varnish
X-Cache-Svr: searchweb005.twitter
buf:.com
X-Cache: MISS
Connection: close

<?xml version="1.0" encoding="UTF-8"?>
[...]
    </author>
  </entry>
</feed>

NO CARRIER
done

switching GPRS off ...
AT#GPRS=0
->buf: AT#GPRS=0
OK
done

Outlook

Besides some software todos on the list, two things are still bugging me. One is the need of an Arduino Mega because of the hardware serial port. I will try the new version of NewSoftSerial, as soon as it is released. The other thing is the need of two power sources. But that could be solved with the Arduino Mini pro, when the software serial issue is fixed.

Everything else worked well. Now I only need a problem that could be solved with this .

Links and Downloads

• Source code: arduino-gm862.zip
• Interfacing an AVR controller to a GPS Mobile Phone
• GM862 breakout board from Sparkfun
• GM862 specs at Telit.
• roundsolutions, distributor for GM862 modules.

Jonathan asked me, if I would like to do a project with him on Braitenberg vehicles. After some research and reading the first couple of chapters in Vehicles: Experiments in Synthetic Psychology, I was hooked in. Here is the first version of a Braitenberg vehicle, powered with two RC-Servos and an Arduino as its brain.

Best of all, it needs no soldering, drilling or hot glue. And if you’ve played already with Arduinos, there is a good chance, that you have already most of the needed parts at home..

Braitenberg vehicles

Valentino Braitenberg developed a model of simple vehicles with sensors and actuators (motors) and interconnections between them. While the vehicles are extremely simple, the emerging behaviour is not. It is often interpreted as love, aggression or caution.

The easiest one is a light seeking vehicle. That’s like “hello world” in robotics. The sensors are affecting directly the motors. The right sensor affects the left motor and the left sensor affects the right motor. That means, if light shines on the right sensor, the left wheel turns. And if the light shines brighter on the right sensor, the left motor will turn faster than the left one and so the vehicle will turn towards the light source.

These kind of simple robots can be build with analog techniques alone, they don’t need a microcontroller. Think of two sensors feeding into two amplifiers that control the motors. The big advantage a controller brings in, is the possibility to rewire the connections between inputs and outputs in software. Even more complex functions for the interconnections can be reprogrammed easily.

Needed parts

• Arduino board
• small breadboard or prototyping Arduino shield
• 2 RC-servos, can be cheap
• 2 wheels, Solarbotics
• 2 light sensors, LDR (Light Dependent Resistor), e.g. CdS from Solarbotics, and 2 resistors
• 2 3-pin headers
• battery holder and 4 rechargeable batteries
• some rubber bands
• some wires
• paper clip

I am using a Boarduino here, that snaps nicely into the small breadboard. The two wheels are used for convenience. You could use any other type of wheels and attach them to the servos.

The two resistors have to match the LDRs to form a good voltage divider. Otherwise you get only a small range of values out of your sensors. Mine work great with a 10 k resistor.

The servos are hacked. Hacking servos means modifying them for continuous motion. A standard servo moves its tiny arm around from -90 to +90 degrees. But we want them to act as simple motors. There are quite a number of resources out there on how to hack a servo. One of the latest and very good documented one is from Tod. Check out his post about “Tiny Servos as Continuous Rotation Gearmotors”.

Tools

Nothing. Ha, no soldering iron, no drilling and no hot glue! Ok, you need a PC and an USB-cable.

Assembling

Attach the two servos to the breadboard by using 3-pin headers. Connect the red cable to VCC and the brown one to GND. The orange cable is used to send the control pulses to the servo motor. It is connected to Arduino pin 10 (left) and 9 (right).

The LDR and the resistor are forming a voltage divider. Connect the LDR to VCC and to a free socket on the breadboard. Now connect the resistor to GND and a free socket of the same row as the LDR. Next connect a wire from this row to the analog input pins of the Arduino (left to analog 0 and right to analog 1).

Now take the two servos, put them together and wrap a rubber band around them and the breadboard. Then attach the battery holder to the breadboard and fix it with another rubber band.

Use the paperclip or some other kind of wire to form a small hook. The hook should snap into place and holding the breadboard and the battery holder together. And it has a little notch that is used instead of a third wheel.

Now this tiny guy is complete.

Arduino Code

/*
 * Simple braitenberg vehicle
 * http://tinkerlog.com
 */

#include "Servo.h"

Servo leftServo;
Servo rightServo;
int leftValue = 0;
int rightValue = 0;

void setup() {
  leftServo.attach(10);
  rightServo.attach(9);
} 

void loop() {
  // sensor values between 50..900
  leftValue = (analogRead(0) - 50) / 50;
  rightValue = (analogRead(1) - 50) / 50;
  leftServo.write(89 + rightValue);
  rightServo.write(89 - leftValue);
  delay(10);
}

Yes, that’s all it needs. Only 25 lines of code. Including comments.

The analog values of the sensors are in a range between 50 and 900. So we take 50 as 0 and scale the value down.

The value you send to the servo is the degree it should turn to. From 0 to 180 degrees. At 90 degrees it is centered. For me, 89 is the value at which the left and the right servo stands still. If we add a value, the servo motors spins forward, if we subtract a value, it spins backward. The function for the right servo subtracts the values because it is attached on the opposite side.

You might have to write some simple sketches to evaluate the right values of the sensors and servo motors.

If you plug the USB cable into your PC, it may suck too much power because of the servo motors. You can power it with your external battery pack. Check your Arduino board, most have a jumper for external power supply. Or you unplug the servos for programming.

Play

Now switch him on and see if he finds some light sources. It works better, if the rest of the room is dark with only a single light source. I managed to tempt him with a flash light or a lighter. If he seems not to turn as much as he should, try to bend the light sensors more sideways.

This small bot is a bit shaky because of the rubber bands. But he is forgiving. And as he moves around underneath your table, you almost instantly think of him as something that has its own will. Even if you know, that it has only two sensors and two motors.

Links

• Wikipedia: Valentino Braitenberg
• Amazon: Vehicles: Experiments in Synthetic Psychology
• Video of Jonathan’s vehicles