Light-seeking robot on an Arduino Uno

// Light-seeking robot: two photoresistors, one on each front corner, and a
// steering rule so simple it looks like instinct.
//
//   Photoresistor modules: left AO on A0, right AO on A1 (VCC to 5V, GND to ground)
//   L298N: ENA pin 5, IN1 pin 6, IN2 pin 7 (left motor)   ENB pin 10, IN3 pin 8, IN4 pin 9 (right)
//   12V from the 7.4 V pack, GND to the Uno's GND
//
// # The sensors
//
// An LDR's resistance falls as the light rises. The module puts it under a
// 10k resistor, so its AO pin gets LOWER as the light gets brighter: about 1000
// in the dark and 100 in front of a lamp. The sketch flips that around, so
// brightness() is 0 in the dark and around 900 in front of a lamp.
//
// # The steering rule
//
// Whichever eye sees more light, the robot turns toward it, by a turn
// proportional to how much more. Both eyes equal and it drives straight. That
// is the whole idea behind many "behavior" robots: no map and no plan, only a
// reaction wired from the sensors to the wheels.
//
// # The three situations
//
//   bright   (both eyes above ARRIVED): it is at the lamp, so it stops
//   lit      steer toward the brighter eye and drive
//   dark     (both below DARK): nothing to steer by, so spin slowly until a
//            lamp swings into view
//
// The readings are averaged over a few samples because an analogRead of a cheap
// sensor is never quite the same twice.

const int LEFT_EYE = A0;
const int RIGHT_EYE = A1;

const int ENA = 5;
const int IN1 = 6;
const int IN2 = 7;
const int ENB = 10;
const int IN3 = 8;
const int IN4 = 9;

const int DARK = 90;
const int ARRIVED = 780;
const int CRUISE = 190;
const int CREEP = 150;
const int GAIN = 2;

const char *mood = "";

void side(int enable, int a, int b, int speed) {
  if (speed > 255) speed = 255;
  if (speed < -255) speed = -255;
  digitalWrite(a, speed > 0 ? HIGH : LOW);
  digitalWrite(b, speed < 0 ? HIGH : LOW);
  analogWrite(enable, speed < 0 ? -speed : speed);
}

void drive(int left, int right) {
  side(ENA, IN1, IN2, left);
  side(ENB, IN3, IN4, right);
}

int brightness(int pin) {
  long sum = 0;
  for (int i = 0; i < 8; i++) sum += analogRead(pin);
  return 1023 - sum / 8;
}

void say(const char *next) {
  if (next != mood) {
    mood = next;
    Serial.println(next);
  }
}

void setup() {
  const int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
  for (int i = 0; i < 6; i++) {
    pinMode(pins[i], OUTPUT);
    digitalWrite(pins[i], LOW);
  }
  Serial.begin(115200);
  Serial.println("Mokxi Arduino Uno: light-seeking robot");
  Serial.println("ready");
}

void loop() {
  int left = brightness(LEFT_EYE);
  int right = brightness(RIGHT_EYE);

  if (left > ARRIVED && right > ARRIVED) {
    drive(0, 0);
    say("reached the light: stopped");
  } else if (left < DARK && right < DARK) {
    // Too dark to steer by: turn slowly on the spot and look for a lamp.
    drive(CREEP, -CREEP);
    say("dark: searching");
  } else {
    // More light on the left means a left turn: slow the left wheel, speed up
    // the right.
    int turn = (left - right) * GAIN / 4;
    drive(CRUISE - turn, CRUISE + turn);
    say(turn > 15 ? "steering left" : turn < -15 ? "steering right" : "heading for the light");
  }
  delay(20);
}