Remote-controlled lamps on an Arduino Uno

// Remote-controlled lamps: an infrared receiver on pin 2, three lamps.
//
//   pin 2   the VS1838B's OUT
//   pin 5   red lamp     press 1 on the handset
//   pin 6   green lamp   press 2
//   pin 9   blue lamp    press 3
//   0 turns all three off; CH- and CH+ step the brightness of whichever is on
//
// The handset's IR pin is wired to the receiver's: in Mokxi two parts only meet
// on a net, so the beam is a wire. Everything else here is what happens on a
// real desk.
//
// # The receiver inverts
//
// OUT idles HIGH and goes LOW while a burst of light is arriving. So the 9 ms
// leader burst is 9 ms of LOW, and every timing in the decoder is written from
// that side. It is the first surprise and it catches everybody once.
//
// # NEC is widths, not levels
//
// One unit is 562.5 us, 21 cycles of the 38 kHz carrier, which is why it is
// not a round number. A leader is 16 units of burst and 8 of space; then
// thirty-two bits, each one unit of burst and either one unit of space (a
// nought) or three (a one); then a stop burst. The decoder measures the space
// after each burst and splits them at 1.1 ms.
//
// The thirty-two bits are address, address inverted, command, command inverted,
// **least significant bit first**. The two inversions are the whole of the
// error checking, and firmware/lib/mokxi_ir.h checks both, so a frame that
// arrived with somebody's headlights through it is thrown away rather than
// acted on.
//
// # The number every table prints
//
// Tutorials call the CH- button 0xFFA25D; this sketch calls it command 0x45.
// They are the same thirty-two bits. The bits arrive least significant first
// and the old Arduino decoder assembled them the other way round, so each byte
// came out bit-reversed: 0x45 reversed is 0xA2. The sketch prints both, so
// the two readings can be seen to be one thing.
//
// # Repeats
//
// Hold a button and the handset sends a whole frame once and then a short
// repeat every 110 ms. A sketch that treats a repeat as a fresh press is why
// volume buttons run away, so this one only acts on repeats for the two
// brightness keys, where running is the point.

#include "mokxi_ir.h"

const int IR_PIN = 2;
const int LAMPS[3] = {5, 6, 9};

IrReceiver ir(IR_PIN);

int lit = -1;          // which lamp is on, or -1
int brightness = 200;  // 0..255, on whichever lamp is lit
unsigned char lastCommand = 0;

void pick(int which);
void applyBrightness(int by);

void setup() {
  for (int i = 0; i < 3; i++) {
    pinMode(LAMPS[i], OUTPUT);
    analogWrite(LAMPS[i], 0);
  }
  Serial.begin(115200);
  Serial.println("Mokxi Uno: NEC remote, 1/2/3 pick a lamp, 0 is off");
  ir.begin();
}

void loop() {
  IrFrame frame = ir.receive(300);
  if (!frame.valid) {
    return;
  }

  if (frame.repeated) {
    // Only the two that should run while held.
    if (lastCommand == IR_CH_DOWN || lastCommand == IR_CH_UP) {
      applyBrightness(lastCommand == IR_CH_UP ? 25 : -25);
    }
    return;
  }

  lastCommand = frame.command;
  Serial.print("address 0x");
  Serial.print((long)frame.address, HEX);
  Serial.print("  command 0x");
  Serial.print((long)frame.command, HEX);
  Serial.print("  (tables call it 0x");
  Serial.print((long)frame.legacy(), HEX);
  Serial.println(")");

  switch (frame.command) {
    case IR_1:
      pick(0);
      break;
    case IR_2:
      pick(1);
      break;
    case IR_3:
      pick(2);
      break;
    case IR_0:
      pick(-1);
      break;
    case IR_CH_UP:
      applyBrightness(25);
      break;
    case IR_CH_DOWN:
      applyBrightness(-25);
      break;
    default:
      Serial.println("  no lamp on that button");
      break;
  }
}

// Light one lamp and put the other two out. -1 is all off.
void pick(int which) {
  lit = which;
  for (int i = 0; i < 3; i++) {
    analogWrite(LAMPS[i], i == which ? brightness : 0);
  }
  Serial.print("  lamp ");
  Serial.println(which < 0 ? -1 : which + 1);
}

void applyBrightness(int by) {
  brightness += by;
  if (brightness < 0) {
    brightness = 0;
  }
  if (brightness > 255) {
    brightness = 255;
  }
  if (lit >= 0) {
    analogWrite(LAMPS[lit], brightness);
  }
  Serial.print("  brightness ");
  Serial.println(brightness);
}