Infrared remote rover on an Arduino Uno

// Infrared remote rover: drive a robot with the remote that came with the kit.
//
//   VS1838B receiver OUT on pin 2 (VCC to 5V, GND to ground)
//   MX1508: IN1 pin 5, IN2 pin 6 (left motor)   IN3 pin 9, IN4 pin 10 (right motor)
//
// The keys:
//
//   2  forward     8  back     4  turn left     6  turn right     5  stop
//   +  faster      -  slower   (three speeds: slow, medium, fast)
//
// # Hold to drive
//
// A remote sends one full frame when a button goes down and then a short
// "repeat" every 110 ms for as long as it stays down. The rover drives while
// frames keep arriving and stops 300 ms after the last one. That is a
// dead-man switch, or failsafe: if the remote's batteries die, or the robot
// drives out of range, or somebody walks in front of the receiver, the robot
// stops by itself instead of driving on until it hits a wall.
//
// # Frames and repeats
//
// IrReceiver::receive() waits up to 60 ms for a burst. A full frame carries a
// command byte, which the sketch acts on once. A repeat carries nothing but
// "still held", so it only refreshes the failsafe timer. The sketch has to tell
// them apart: treating every repeat as a new press is how volume buttons end
// up running away.
//
// The command bytes are the ones on the common 21-button handset (NEC
// protocol, address 0x00).

#include "mokxi_ir.h"

const int IR_PIN = 2;
const int A1_PIN = 5;
const int A2_PIN = 6;
const int B1_PIN = 9;
const int B2_PIN = 10;

const unsigned long FAILSAFE_MS = 300;

const uint8_t KEY_2 = 0x18;
const uint8_t KEY_8 = 0x52;
const uint8_t KEY_4 = 0x08;
const uint8_t KEY_6 = 0x5A;
const uint8_t KEY_5 = 0x1C;
const uint8_t KEY_PLUS = 0x15;
const uint8_t KEY_MINUS = 0x07;

const int SPEEDS[3] = {110, 170, 230};
const char *SPEED_NAMES[3] = {"slow", "medium", "fast"};

IrReceiver ir(IR_PIN);

int speedLevel = 1;
bool moving = false;
// What the left and right wheels are doing, as -1, 0 or 1.
int leftDir = 0;
int rightDir = 0;
unsigned long lastFrame = 0;

void motor(int p1, int p2, int speed) {
  if (speed >= 0) {
    analogWrite(p2, 0);
    analogWrite(p1, speed);
  } else {
    analogWrite(p1, 0);
    analogWrite(p2, -speed);
  }
}

void apply() {
  int speed = SPEEDS[speedLevel];
  motor(A1_PIN, A2_PIN, leftDir * speed);
  motor(B1_PIN, B2_PIN, rightDir * speed);
  moving = leftDir != 0 || rightDir != 0;
}

void go(const char *what, int left, int right) {
  leftDir = left;
  rightDir = right;
  Serial.print(what);
  Serial.print(" (");
  Serial.print(SPEED_NAMES[speedLevel]);
  Serial.println(")");
  apply();
}

void setSpeed(int level) {
  if (level < 0) level = 0;
  if (level > 2) level = 2;
  speedLevel = level;
  Serial.print("speed: ");
  Serial.println(SPEED_NAMES[speedLevel]);
  apply();
}

void setup() {
  pinMode(A1_PIN, OUTPUT);
  pinMode(A2_PIN, OUTPUT);
  pinMode(B1_PIN, OUTPUT);
  pinMode(B2_PIN, OUTPUT);
  Serial.begin(115200);
  ir.begin();
  Serial.println("Mokxi Arduino Uno: infrared remote rover");
  Serial.println("ready: hold 2 8 4 6 to drive, + and - for speed");
}

void loop() {
  IrFrame frame = ir.receive(60);
  if (frame.valid) {
    lastFrame = millis();
    if (!frame.repeated) {
      switch (frame.command) {
        case KEY_2: go("forward", 1, 1); break;
        case KEY_8: go("back", -1, -1); break;
        case KEY_4: go("turning left", -1, 1); break;
        case KEY_6: go("turning right", 1, -1); break;
        case KEY_5: go("stop", 0, 0); break;
        case KEY_PLUS: setSpeed(speedLevel + 1); break;
        case KEY_MINUS: setSpeed(speedLevel - 1); break;
        default: break;
      }
    }
  }

  // Quiet for too long: the button was let go, or the signal is lost.
  if (moving && millis() - lastFrame > FAILSAFE_MS) {
    leftDir = 0;
    rightDir = 0;
    apply();
    Serial.println("remote quiet: stopped");
  }
}