LED Eyes

I was inspired by a great Adafruit tutorial by Phillip Burgess Animating Multiple LED backpacks. He was able to make an animated face with a voice changer for a Halloween costume with amazing results. After seeing his success I was interested in creating my own pair of electronic eyes.

The hardware

Using an Arduino Uno R3 and two 8×8 LED kits from Adafruit I was able to get up and running very quickly. The soldering was the easy part. Just make sure you get the matrix board aligned correctly with the driver board before you start.

The circuit itself is dead simple. I have to say I really like working with the I2C serial bus and the Adafruit_8x8matrix object. It makes it so simple that all that is required to connect all components is using a common clock and data line. Then you can send or receive data from each component using a unique address on the same line. By default the 8×8’s come with 0x70 as their address. Using some jumper solder you can increment the address to make them unique but in our case we want both eyes to have the same address which makes it even easier. The only feature we lose in this configuration is winking.

The driver

The “matrix8x8” example sketch (included with the Adafruit_LEDBackpack library) is written for a single LED matrix and makes the job very simple. Declare a single Adafruit_8x8matrix object:

Adafruit_8x8matrix matrix = Adafruit_8x8matrix();

Like the tutorial, the eyes are drawn using a series of stored bitmaps. We really only define one set of bitmaps and just copy the single eye as they should always look in the same direction anyway.

Bitmap data must be declared with the PROGMEM directive. This will store the data in the Arduino’s flash memory instead of using the limited RAM space where the actual program code is stored.

static uint8_t PROGMEM
eyes_center_large_bmp[] = { 
    B00111100,
    B01101110,
    B11000111,
    B10000011,
    B11000111,
    B11101111,
    B00111100,
    B01111110
  },

I defined a series of different eye positions as named bitmaps. Each bit corresponds to an associated LED. A 0 and the LED is off, a 1 and the LED is on. Each byte corresponds to an associated LED row. Very simple. To keep things neat we could use a simple function look_eyes to accept a bitmap as an argument along with a delay and draw it to the LED grid using the Adafruit_8x8matrix object.

void static look_eyes(uint8_t *bitmap, int d){
  u8p = bitmap;
  matrix.clear();
  matrix.drawBitmap(0, 0, bitmap, 8, 8, LED_ON);
  matrix.writeDisplay(); 
  delay(d);

}

Using this I then added a wrapper function for each bitmap, or combination of them to make the process a single function call for each eye position I want to support.

void static look_center_large(){
 look_eyes(eyes_center_large_bmp, 1000);
}

To animate blinking we just need to systematically turn each LED row off from the top and bottom at the same time. Then reverse this process so each row is turned back on from the center out to the top and bottom. The delay between each state controls how fast the eyes blink.

eyes_shut_1_bmp[] = {
    B00000000,
    B01111110,
    B11111111,
    B11100111,
    B11100111,
    B11111111,
    B01111110,
    B00000000,
},

eyes_shut_2_bmp[] = {
    B00000000,
    B00000000,
    B11111111,
    B11100111,
    B11100111,
    B11111111,
    B00000000,
    B00000000
},
eyes_shut_3_bmp[] = {
    B00000000,
    B00000000,
    B00000000,
    B11100111,
    B11100111,
    B00000000,
    B00000000,
    B00000000
},

eyes_shut_bmp[] = {
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000
},

One problem with this current solution is restoring each row on the return blink. The pupil returns to center with each blink because of this. My next challenge will be to come up with a better solution that gets around this problem and restores the pupil to the last position before the blink started. I want to be able to use an analog value to direct the eyes so I can use motion tracking and have the eyes follow you. To do this we need the blinking to work with the pupil in any position and maintain that position throughout the blink.

I have an idea I want to try where the center row is where the pupil is most of the time. If I make a discipline to only move left to right then I can make the pupil a separate variable we can pass around and use in the blink function. Something like this:

#define EYE_BALL_CENTER B11100111 
#define EYE_BALL_LEFT_1 B10011111 
#define EYE_BALL_RIGHT_1 B11110011 



eyes_center_small_bmp[] = { 
    B00111100,
    B01111110,
    B11111111,
    EYE_BALL_CENTER,
    EYE_BALL_CENTER,
    B11111111,
    B01111110,
    B00111100
  },

Stay tuned…

Download Git repo or pull from git@github.com:adestefa/arduino_eyes.git