Robot 2 (under $10 version)

This was the second robot I made for collective motion research purposes. As you can see, it is vastly simpler, cheaper and easier to build. Of course it doesn't have nearly as many features or as much potential as robot 1, but I think it is much better for what I'm trying to do.
Here's a picture of the prototype without the battery.

Goals and requirements - 

• It should be as easy and cheap to make as possible so that I can make several of them.
• It needs to sense some aspect of its environment.
• It needs to be able to interact with other robots of its kind.
• It needs to move in a controllable and repeatable way.

The prototype satisfies almost all of these, but it can't yet interact with other bots. I still have a couple of IO pins to work with(if I disable the reset pin and lose control of the LED) and I'm trying to think of a good way to do this. The cost is roughly 530 yen, which is much less than $10 and about half as much as robot 1.

Although it is not my goal, at this point I basically have a line following robot much like dozens of others you can find on the internet, but it actually only follows an edge between light and dark because it only has two sensors, left and right. If you stuck it on a chess board, it would go around tracing the edges of the squares. Actually, I kind of want to try that.

Electronics - 
An ATtiny85 running at 8MHz controls everything here. It makes use of the libraries from MIT that are detailed here that allow me to easily program it with Arduino. Here are some other electronics details.

• The two pager motors are driven by 2N7002K N-channel mosfets which conveniently include protection diodes.
• The two clear LED looking things out front are phototransistors, and the red one is a red LED. They work together to determine the lightness of the surface and are also the front legs for the robot. They are spaced about 5mm apart giving the robot a left and right value.
• The battery is a 3.7V LIR2032 that I pulled out of a 100yen solar key chain light.

Here is a schematic of the current version. Notice I'm still using Paint to make these.

and here is a picture of the messy underside. Those black things are the mosfets. If you look closely, you can see the SMD resistors soldered between pins. Also, note that the LED and sensor leads run in a gap between the chip and the socket. They are the three solder points in the middle.

Hardware - 
As with robot 1, the pager motors were from ebay and I don't have much data on them. They are roughly 2cm long including shaft and 7mm in diameter. They are hot glued to a little piece of protoboard that makes up the chassis. The little red things on the shafts are bits of 22awg wire insulation that provide traction.
The battery connects via a homemade connector using 22awg wire and two short pin sockets. The battery just sticks on top of the chip with some tape. This was done because I have to take it off every time I reprogram the chip or recharge the battery. There is no power switch.
Well, there really isn't much more to say about the hardware.

It works -
There are, of course, some issues. Since the sensors are 5mm apart, it doesn't have a very tight "grip" on the edge between light and dark, so it tends to wobble left and right as the edge bounces between the sensors, occasionally going in just the right direction for a few centimeters. I think this would improve a little if I could place the sensors closer, but they are almost touching already. I have tried a few software adjustments, but the basic problem is still there.

Anyway, you probably want to see a video. Here is a short one.

Also, here are some more pictures.

 

 Since I had some requests, here is the code. It doesn't do much and I haven't really looked at it since I first wrote it. I hope some day I can get back to this project.

/*
Robot version 2
Simpler. ATtiny85, 2 motors, LED, two sensors

Sensor stuff:
    both white    :    no prior    :    random walk
                :    prior        :    turn in direction of last black
   
    one white    :    ideal situation, move straight
   
    both black    :    no prior    :    random walk
                :    prior        :    turn in direction of last white
Sorry if that was hard to understand
*/
#include "Arduino.h"

// the pin definitions
#define lmotorpin 1 // PB1 pin 6
#define rmotorpin 0 // PB0 pin 5
#define lsensepin 3 //ADC3 pin 2
#define rsensepin 1 //ADC1 pin 7
#define ledpin 4 //PB4 pin 3

// numbers for random walk and memory
#define steplength 300
#define smallturn 200
#define bigturn 500
#define memtime 1000

uint8_t lspd, rspd;
uint16_t lsenseval, rsenseval, lwhiteval, rwhiteval;

// functions
void testSensors();
void followEdge();
void moveTime(uint8_t lspeed, uint8_t rspeed, uint16_t time);
void move(uint8_t lspeed, uint8_t rspeed);
void stop();
void senseInit();
void flashLED(uint8_t flashes);

// just for convenience and simplicity (HIGH is off)
#define ledoff PORTB |= 0b00010000
#define ledon PORTB &= 0b11101111

void setup(){
    pinMode(lmotorpin, OUTPUT);
    pinMode(rmotorpin, OUTPUT);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    ledoff;
    pinMode(ledpin, OUTPUT);
    analogWrite(lmotorpin, 0);
    analogWrite(rmotorpin, 0);
   
    lspd = 17;
    rspd = 17;
   
    // give a 6 second pause to set the thing on a white surface
    lsenseval = 6;
    while(lsenseval){
        lsenseval--;
        flashLED(1);
        delay(989);
    }
    flashLED(4);
    delay(500);
    senseInit();
}

void loop(){
    followEdge();
}

void followEdge(){
    // now look for edge
    uint8_t lastMove = 1; //0=straight, 1=left, 2=right
    unsigned long moveEndTime = 0; // the millis at which to stop
    unsigned long randomBits = micros();
   
    unsigned long prior = 0; // after edge encounter set to millis + memtime
    uint8_t priorDir = 0; //0=left, 1=right, 2=both
    uint8_t lastSense = 1; //0=edge, 1=both white, 2=both black
    uint8_t i = 0; // iterator
   
    while(true){
        // only update about once every 20ms
        delay(18);
        // read the value 4 times and average
        ledon;
        delay(2);
        lsenseval = 0;
        rsenseval = 0;
        for(i=0; i<4; i++){
            lsenseval += analogRead(lsensepin);
            rsenseval += analogRead(rsensepin);
        }
        // don't divide by 4 because it is used below
        ledoff;
       
        if(randomBits == 0){ randomBits = micros(); }
       
        if((lsenseval > lwhiteval*3) && (rsenseval > rwhiteval*3)){
            // both white - if prior turn to black, else random walk
            if(lastSense == 2 || millis() < prior){
                // turn toward last black or left
                if(priorDir == 0){
                    moveEndTime = millis()+smallturn;
                    move(0, rspd); // turn left
                    lastMove = 1;
                }else if(priorDir == 1){
                    moveEndTime = millis()+smallturn;
                    move(lspd, 0); // turn right
                    lastMove = 2;
                }else{
                    moveEndTime = millis()+bigturn;
                    move(0, rspd); // turn left a lot
                    lastMove = 1;
                }
            }else{
                // random walk
                if(millis() < moveEndTime){
                    // just continue moving
                }else{
                    if(lastMove){
                        moveEndTime = millis()+steplength;
                        move(lspd, rspd); // go straight
                        lastMove = 0;
                    }else{
                        if(randomBits & 1){
                            moveEndTime = millis()+smallturn;
                            move(0, rspd); // turn left
                            lastMove = 1;
                        }else{
                            moveEndTime = millis()+smallturn;
                            move(lspd, 0); // turn right
                            lastMove = 2;
                        }
                        randomBits >>= 1;
                    }
                }
            }
            lastSense = 1;
           
        }else if((lsenseval > lwhiteval*3) || (rsenseval > rwhiteval*3)){
            // one white - this is the edge
            // just go straight
            moveEndTime = millis()+steplength;
            move(lspd, rspd); // go straight
            lastMove = 0;
            lastSense = 0;
            prior = millis()+memtime;
            if(lsenseval > lwhiteval*3){
                // the right one is black
                priorDir = 1;
            }else{
                // the left one is black
                priorDir = 0;
            }
           
        }else{
            // both black - if prior turn to white, else random walk
            if(lastSense == 1 || millis() < prior){
                // turn toward last white or left
                if(priorDir == 0){
                    moveEndTime = millis()+smallturn;
                    move(lspd, 0); // turn right
                    lastMove = 2;
                }else if(priorDir == 1){
                    moveEndTime = millis()+smallturn;
                    move(0, rspd); // turn left
                    lastMove = 1;
                }else{
                    moveEndTime = millis()+bigturn;
                    move(lspd, 0); // turn right a lot
                    lastMove = 2;
                }
            }else{
                // random walk
                if(millis() < moveEndTime){
                    // just continue moving
                }else{
                    if(lastMove){
                        moveEndTime = millis()+steplength;
                        move(lspd, rspd); // go straight
                        lastMove = 0;
                    }else{
                        if(randomBits & 1){
                            moveEndTime = millis()+smallturn;
                            move(0, rspd); // turn left
                            lastMove = 1;
                        }else{
                            moveEndTime = millis()+smallturn;
                            move(lspd, 0); // turn right
                            lastMove = 2;
                        }
                        randomBits >>= 1;
                    }
                }
            }
            lastSense = 2;
        }
    }
}

void moveTime(uint8_t lspeed, uint8_t rspeed, uint16_t time){
    analogWrite(lmotorpin, lspeed);
    analogWrite(rmotorpin, rspeed);
    delay(time);
    analogWrite(lmotorpin, 0);
    analogWrite(rmotorpin, 0);
}

void move(uint8_t lspeed, uint8_t rspeed){
    analogWrite(lmotorpin, lspeed);
    analogWrite(rmotorpin, rspeed);
}

void stop(){
    analogWrite(lmotorpin, 0);
    analogWrite(rmotorpin, 0);
}

// stores the average of 16 readings as a white value
void senseInit(){
    lwhiteval = 0;
    rwhiteval = 0;
    ledon;
    delay(2);
    for(uint8_t i=0; i<16; i++){
        lwhiteval += analogRead(lsensepin);
        delay(1);
        rwhiteval += analogRead(rsensepin);
        delay(9);
    }
    lwhiteval >>= 4;
    rwhiteval >>= 4;
    ledoff;
}

void flashLED(uint8_t flashes){
    while(flashes){
        flashes--;
        ledon;
        delay(200);
        ledoff;
        if(flashes){ delay(500); }
    }
}