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.

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.

If you want to play some retro arcade games, you will install the amazing MAME and run your favorite ROM. One of my best-of-all-times is Bomb Jack.

But you have to play it with the keyboard. Bah!

Or an USB game pad. Better, but still — bah!

Nothing compares to real arcade controls. And with a bit of tinkering, you can get a tiny step closer to the real gaming experience.

USB HID

HID stands for Human Interface Device class. Common devices of this class are keyboards, mice and joysticks. The great thing, that this interface brings in, is, the devices don’t need a specific device driver. If they behave according to the USB HID spec, then they are automatically recognized by all OSs. Every device sends a report, in which it states, which kind of device it is and how it wants to report its data.

The next great part is the fantastic USB driver V-USB that is developed by Objective Development. This driver can be run on most of all Atmel AVR controllers, even on ATtinys. It does not require any other chip, only a couple of standard components. The library is licensed under GPL, a commercial license is available as well.

Needed components

I ordered my arcade controls at ArcadeShop.de, a german shop for Arcade parts. The joystick is great. Heavy and solid. And makes nice clicks.

The buttons, that I ordered are ok. They are working fine but seem to be a bit too small. They have a diameter of 27 mm. Next time I would take bigger ones.

Nothing special about the rest of the needed parts. A breadboard, an ATmega48 and a couple of resistors, capacitors and diodes. And of course a plastic box as enclosure. Keeps the electrons fresh. BTW, mine is not Tupperware, but super cheap IKEA.

The circuit

The circuit is almost one of the standard setups, that Obdev recommends. I used 47 Ohm instead of 68 Ohm for R2 and R3 because I had them laying around. The two 1N4148 diodes reduce the supply from 5 V to about 3.6 V. This is a “poor mans” voltage regulator. A better solution would be a low drop 3.3 V voltage regulator. But for prototyping the two diodes will do the job.

First I tried to run it with a 16 MHz crystal. I thought that it should be enough to change the F_CPU setting, but that didn’t work out. The device was not recognized. When I switched to the 12 MHz crystal it worked almost at once.

All controls, the stick and the buttons, are connected to the controller and to ground. Therefor the internal pull-up resistors have to be enabled.

Firmware

The firmware is based on the examples provided at the V-USB page. Two projects, that I played with are the HIDKeys example and the SNES-Joypad. The first one is used to build a simple keyboard. The second was made to play emulated SNES games with a SNES pad.

The biggest problem was to find a matching USB HID report descriptor. This descriptor is used to tell the PC, what kind of device is attached to the USB port and what kind of data it sends. At the moment I am using the “Game Pad” device class.

Conclusion

This is a work in progress. The plastic box works but is way too wobbly. It was more of a joke. The next version should have a more sturdy enclosure. And the circuit should be more permanent and not that place consuming.

I am planning to have a two player version (Gauntlet!). For that I am still unsure, if I should switch to the USB-HID keyboard class. Or maybe implement two gamepads with one controller. We will see.

Over all, it’s great to play some of the old games again. Even if this is nothing compared to a real cabinet.

Links and Downloads

• Firmware: mame_controller.zip
• MAME, Multi Arcade Machine Emulator
• V-USB (formerly know as AVR-USB) developed by Objective Development
• SNES-Joypad using V-USB (german)
• USB HID page at USB.org
• Arcade controls at ArcadeShop.de

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

Jonathan bought a 64pixels kit and modded it into a green version. The three solar cells, that he uses are rated with: 2.7 volts (open circuit) @ 15mA (short circuit). He writes, it works well in bright sun light. His desktop lamp shines with 60 Watts and that seems to work as well.

He also used a socket to be able to pop out the controller, whenever he wants to program new messages or animations.
Well done!

If you read about LEDs, you will notice that everyone tells you, that you need a current limiting resistor. But mostly they do not tell you why.

LED with current limiting resistor

If you look at a datasheet of an LED, you will notice that graphs shown are not linear. An LED is a diode, a semiconductor and behaves differently compared to a resistor.

If you apply a specific voltage to a resistor, you can compute the resulting current with:


I = V / R Example: I = 5 Volt / 100 Ohm = 50 mA


Obviously that does not work with LEDs because they don’t behave like a linear resistor. If you look at the graph above, you can rise the voltage from 0 Volt to 1.6 Volt without resulting in noticeable current. Apply a bit more voltage and there is current and the LED lights up. We have reached the Forward Voltage which is needed to open the pn-gate. Forward Voltage (VF) for a typical red LED is 1.7 to 2.2 Volt. Now small changes in the voltage produce large effects on the resulting forward current (IF). Datasheets normally state at least the absolute maximum ratings for IF, eg. 25 mA. If you apply a voltage that results in a larger current, the LED may be destroyed.

So it’s vital to stay within the limits of the LED. If you would attach an LED to a 5 Volt power supply directly, you would burn it instantly. The high current would destroy the pn-gate. That’s the point where the current limiting resistor comes in.

Assuming, we have a red LED with maximum rating of IF: 25 mA at VF: 2.1 Volt. Its VF related to IF is like the curve in the graph at the top. If we want to use it at 5 Volt, we have to use a resistor to dissipate the remaining 2.9 Volt. To compute the resitor, we use:


R = V / I = (5 Volt - 2.1 Volt) / 25 mA = 116 Ohm.


To be safe we use a 120, or better, 150 Ohm resistor. That way we don’t drive the LED near it’s maximum rating. We choose 20 mA, take a look at the curve and see a corresponding VF of 2 Volts. Now we recalculate the resistor.


R = V / I = (5 Volt - 2 Volt) / 20 mA = 150 Ohm.


Ok, 150 Ohm is fine. To be safe with the resistor, we have to take a look at the power dissipation. It calculates as:


P = V * I = 3 Volt * 20 mA = 60 mW


So it’s safe to choose a 150 Ohm resistor with 1/4 Watt rating.

Ok, so far the typical use of an LED with an current limitting resistor.

LED without current limitting resistor

First of all, why would you want to get rid of the resistor? There are two reasons. First is, it wastes energy. It converts electrical energy into heat. But we want to light up an LED. Not good. Second is, you can reduce the number of components. The circuit gets cheaper, because we saved a resistor and maybe space on a PCB.

There are two ways to bypass the resistor. One way is to lower the input voltage. If you are able to run your complete circuit with the same voltage as forward voltage of the LED, perfect. No resistor needed.

Another method is to use pulse width modulation (PWM). That means we are switching the LED on and off. If we are switching fast enough, the human eye can not tell the difference. It integrates the brightness over time, so to speak. Often there is a Peak Forward Current (IF(peak)) rating in the datasheet. As an example:

IF(peak) = 160 mA
Condition: Pulse Width <= 1 msec and Duty <= 1/10

Which means, it is safe to switch the LED with 1 kHz, where the LED is on for 1 msec and off for 9 msecs.

Most of the times there is no voltage given for IF(peak), so we can not be sure at what voltage we will reach the 160 mA in the example. Looking at the graph, I would assume that you could go up to 3 V, maybe 3.2 V, but I haven’t tested it out.

I used both methods for my 64pixels, where I attached an LED matrix directly to a microcontroller without any current limitting resistors.

The input voltage is 3 Volts, if used with 2 AA batteries or about 2.4 Volts with 2 AA rechargeables. That helps to get closer to VF of the LEDs.

The matrix lets you address only one row at a time. So you set all column bits for row one and enable row one. Then you disable row one, set all bits for row two and enable row two, and so on. So you are cycling through all rows. This is done so fast, that you wont see any flickering. Every row is updated with nearly 2 kHz and with a duty cycle of 1/8 (because of the 8 rows).

If you are using a microcontroller for driving an LED or LED matrix, you have to take care of the current ratings of the microcontroller as well. Every I/O pin can only deliver (source) or receive (sink) a specific amount of current. I used an ATtiny2313 and from the datasheet on page 181, I read

Absolute Maximum Ratings:
* DC Current per I/O pin: 40.0 mA

And on page 182 as a note:

4. Although each I/O port can sink more than the test conditions (10 mA at VCC = 5V, 5 mA at VCC = 3V) under steady state conditions (non-transient), the following must be observed: 1] The sum of all IOL, for all ports, should not exceed 60 mA. If IOL exceeds the test condition, VOL may exceed the related specification. Pins are not guaranteed to sink current greater than the listed test condition.

As I understand that, if you are trying to source or sink more than 10 mA, the voltage VOL (Output Low Voltage) or VOH (Output High-voltage) may drop or rise and exeed the specified values.

Looking at two graphs from the datasheet may help to clear things up.

This figure shows how the output voltage of a source pin is related to the current that it sources at 2.7 V input voltage. 2.7 is not 3 Volts as 2 AA cells can deliver, but close enough for now. What we see, is that the output voltage drops, if we demand more and more current. At 5 mA we have a voltage of 2.5 Volts, but at 15 mA the voltage drops to 2.1 Volts.

This figure shows how the output voltage of a sink pin is related to the current that it sinks. This time the ouput voltage rises, if we demand the pin to sink more current. At 5 mA the voltage is 0.15 Volts but rises to 0.5 Volts at 15 mA.

To check if we are using the ATtiny2313 and the matrix within their specifications, we have to do some math. For the matrix, there is no datasheet with nice graphs but some numbers.

Forward Voltage: 1.80 - 2.20 V
Maximum Rating: Forward Current: 25 mA

We assume the LED runs at 1.8 Volts with 5 mA. That looks reasonable when you take a look at other datasheets. Now, if we insert the 5 mA into the two figures above, we get: 2.5 Volt for the source pin and 0.15 V for the sink pin.


2.5 V - 0.15 V = 2.35 V


So we get that 2.35 V is left for the LED. That is more than we have assumed (1.8 V). Higher voltage for the LED means more current. So this time we will compute with 10 mA. Inserting that again, we get 2.3 V for the source pin and 0.3 V for the sink pin.


2.3 V - 0.3 V = 2.0 V


As you see, if the voltage over the LED rises, the current through it raises as well. But the rising current results in lower/higher output voltage from the source/sink pin. And that means lower current. It is, as if they are fighting each other.

2.0 V at 10 mA looks ok for the LED and the microcontroller.

That was one LED on two I/O pins. What, if we want to control a complete row of eight LEDs?

This time eight source pins, eight LEDs and one sink pin. From the example above, 10 mA per LED sums up to 80 mA (!). That’s a lot. Looking it up on the figure is not even possible. Lets assume, it all sums up to only 25 mA, that would be 3.125 mA per LED. That gives us 2.6 V at every source pin and 1.0 V for the single sink pin.


2.6 V - 1.0 V = 1.6 V


That means, 1.6 V is left for every LED, we are a bit beneath the forward voltage of the LED. So the LED may be a bit dimmer. Again, if the LEDs would suck more current, the microcontroller would deliver less output voltage for the LEDs.

If you look thoroughly at the 64 pixels display, you may notice, that the rows with few pixels lit are a bit brighter than the others.

After all this computing and datasheet staring I think it is safe to let out the current limiting resistor in some cases. You have to take a closer look at specs to get an idea on how it will work out.

If I get something wrong or mixed things up, please feel free to comment on this.

Links

• Datasheet for Atmel ATtiny2313
• Wikipedia: LED