Niklas did an amazing job, letting fireflies play some tunes. It’s almost as if they are alive.

Niklas, I owe you a beer (or Club-Mate or whatever), should we ever met. You made my day!

For my latest projects I used a lot of single cell lipo batteries. They are really nice. High power density, low self-discharge, no memory effect and they can deliver quite an amount of current.
But lipo battery handling is a bit more complicated as with other rechargeable batteries. You have to take care of under voltage and over charging as that may destroy the battery.

I used the Sparkfun LiPoly charger, based on MAX1555, for some time and it works really well. The only thing I missed was a way to control the current. After some research I decided to try another chip, the Microchip MCP73833.

Features of the MCP73833

Copied from the specs:

• High accuracy preset output voltage regulation
• Regulated output voltage options
• User-programmable charge current up to 1A
• Two open-drain Status outputs
• Preconditioning and end-of-charge ratio options
• Under-voltage lockout
• Power Good output

What I like is the ability to adjust the charging current and the status outputs, which should get really useful if integrated into a greater application.

The schematic

The schematic is mostly a copy of the reference design. It has three LEDs, one for power good, one for charging and one for charging complete. All pins of the chip itself are also available on two header rows. The idea was to enable easy integration on a breadboard. Actually I misplaced the rows, so they don’t fit (#fail).

The resistor R4 is used to control the charge current. I used a socket for that, so I am able to adapt the current for different batteries. The 10k resistor results in a charge current of 100 mA.

The result

All components were 0805 SMD parts, despite the MCP73833, which is 10-MSOP. This was my first attempt to do something useful with SMD. I used my brand new hot air reflow station, which turns out to work as expected. Only I had to be very precise at dosing the solder paste. Applying too much had to be removed with solder wick later on.

Issues

The next version should include a jack for a wall adapter. The two header pins are not really useful to connect to a power supply. And of course the two rows of header pins should be aligned correctly to fit on a breadboard.

As a sidenote: as you see, the board has a mini-USB connector to be able to connect the charger to a notebook.
I stronly recommend to use some kind of USB hub to test any newly build USB hardware.
I didn’t. And now I have a burned first prototype of my charger and only one USB port left on my MacBook. Although the OS warned me with “something is sucking too much, port gets shut down”, it wasn’t fast enough. So, you have been warned.

Links

• Microchip MCP73833

Again a Braitenberg vehicle. This one is even smaller, than the previous one and comes on a custom PCB. It weighs 17 gramms, is driven by two pager motors, powered by a small lipo cell and controlled by an 8-pin ATtiny25V.

Schematic and parts

This tiny robot has a very low component count. At least for a robot, based on a microcontroller. That has, of course, some implications. It can handle only two sensors and the motors run only in one direction. A full H-bridge for both motors would need 8 transistors and more lines to control it.

So I decided to just use a single transistor to drive the motor. That means it can only run forward. Not a big deal for a Braitenberg vehicle.

Here is the parts list. Most parts are very common.

• ATtiny25V, 2 kB flash RAM, ATTINY25V-10PU-ND
• MPC1700 3.3 voltage regulator, MCP1700-3302E/TO-ND
• 2 * light dependent resistors (LDR)
• 2 * 10 kOhm resistor
• 2 * 470 Ohm resistor
• 2 * 2n3904 transistor
• 2 * 1n4148 diode
• 100n capacitor
• 100u capacitor
• Lithium-polymer battery, 3.7 V, 100mAh, HobbyCity
• 2 * fuse holder
• 2 * pager motor
• heat shrink tubes
• rubber tube
• custom PCB
• 6-pin ISP header

A bit tricky was to find the right rubber tube to build the wheels. I found these, which are normally used to connect tiny motors to a model stern tube. Because the inner diameter is a bit to wide, I used short pieces of cable isolation as an adaptor.

If you have pager motors with an attached weight on their shaft, you may want to take a look at the RobotRoom for instruction on how to get rid of the weights. I had no locking pliers, maybe that’s the reason why I ruined at least three motors. Mostly by twisting the shaft while trying to pull off the weight.

Software and programming

The software is straigt forward. Reading two inputs, the light sensors, and driving two ouput lines accordingly with a PWM signal.

But it turns out, that the software needs a lot of adjustments. First you have to figure out in what range the light sensors report values. Next, check at what PWM level the robot starts to move. Maybe even adjust the directional stability.

Programming the robot in circuit via the 6-pin ISP header didn’t work out in the first place. The programmer was not able to set the lines to high that were driving the transistors. So I soldered a socket in place and can now pull off the two 470 Ohm resistors. After programming I can re-insert the resistors. Can be seen on the left critter on the picture above. A bit awkward, but it works.

Demo

You should have a very clean surface for them to run on. If you put them on a table, as I did, be sure to have very good reflexes or put a kind of fence around them. Mine dropped off the table a couple of times. Mostly no dramatic damage, but the sensors got twistet and the motors sprung out of their holders.

Depending on the ambient light, the light source itself and the nature of the surface you may have to adjust the light sensors. As an example, if the surface is white and diffuses the light, then you would have to bend the sensors away from the surface, because the surface looks bright, even if the robot turns away from the light source.

Issues and conclusion

There are still a couple of issues to resolve.

• Software improvements, use ADC in free running mode and use hardware PWM to drive the motors
• Place the skid in the middle of the PCB.
• There is no protection of deep discharging the battery, no idea how to solve this.
• Add a small power switch.

Someone wanting to volunteer for some private beta testing and helping with improvements?

Besides these issues, these two critters are fun. There was a lot of testing, reprogramming and re-adjustment needed, to get them doing, what I thought they should do. But hey, that’s the way to learn something.

Links and downloads

• Braitenberg vehicle with Arduino mini
• Arduino powered Braitenberg vehicle
• Formica, swarm bots
• Source code and Eagle CAD files, really BETA, tiny_braitenberg.zip

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

While we were at cheating, here is a new sticker for your notebook. It helps you to read and learn resistor values.

The first 10 direct messages to me will get one for free. And of course every next order at the Tinker Store will include one of these.

Last week I invested some time to solder 64 Firefly boards. Only 2.432 solder joints later I was ready for some videos.

Every firefly acts completely autonomously, it has its own tiny controller, eye and luminary. They are all connected for power supply only.

Here are some different configurations.

Links

• See how it’s done in the Synchronizing Firefly Howto
• Grab a Firefly kit at the Tinker Store

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.

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.