The ARPANET IMP

// A three-node store-and-forward network, which is what an IMP actually is.
//
// Flash the SAME sketch on three boards and set MY_ADDR to 1, 2 and 3. Wire them in a
// chain: node 1 TX -> node 2 RX, node 2 TX -> node 3 RX, and the return path likewise.
// Node 1 and node 3 have no direct link, so every packet between them must be RELAYED --
// and node 2 has to store the whole packet, verify it, and forward it.
//
// This is the IMP's whole job. What the hosts see is a network; what node 2 does is
// receive, check, look up, and re-transmit.
//
// PACKET: [SOF][dst][src][id][len][payload...][crc_hi][crc_lo]

const uint8_t MY_ADDR = 1;         // <-- 1, 2 or 3
const uint8_t SOF     = 0x7E;

const int PIN_TX_LEFT  = 17, PIN_RX_LEFT  = 16;   // toward the lower-numbered node
const int PIN_TX_RIGHT = 26, PIN_RX_RIGHT = 25;   // toward the higher-numbered node

HardwareSerial Left(1), Right(2);

uint16_t crc16(const uint8_t *d, int n) {          // blueprint 2, in eight lines
  uint16_t reg = 0xFFFF;
  for (int i = 0; i < n; i++) {
    reg ^= (uint16_t)d[i] << 8;
    for (int b = 0; b < 8; b++)
      reg = (reg & 0x8000) ? (reg << 1) ^ 0x1021 : reg << 1;
  }
  return reg;
}

void sendOn(HardwareSerial &port, uint8_t dst, uint8_t src, uint8_t id,
            const uint8_t *payload, uint8_t len) {
  uint8_t buf[64];
  int n = 0;
  buf[n++] = dst; buf[n++] = src; buf[n++] = id; buf[n++] = len;
  for (int i = 0; i < len; i++) buf[n++] = payload[i];
  uint16_t c = crc16(buf, n);
  port.write(SOF);
  port.write(buf, n);
  port.write(c >> 8); port.write(c & 0xFF);
}

// Receive one whole packet, or return false. STORE first, forward later: an IMP must
// have the entire packet before it can check it, and it must check it before it repeats
// it -- otherwise it launders corruption onward as if it were good.
bool recvFrom(HardwareSerial &port, uint8_t *dst, uint8_t *src, uint8_t *id,
              uint8_t *payload, uint8_t *len, unsigned long timeout_ms) {
  unsigned long t0 = millis();
  while (port.available() < 1) if (millis() - t0 > timeout_ms) return false;
  if (port.read() != SOF) return false;

  uint8_t hdr[4];
  for (int i = 0; i < 4; i++) {
    while (!port.available()) if (millis() - t0 > timeout_ms) return false;
    hdr[i] = port.read();
  }
  *dst = hdr[0]; *src = hdr[1]; *id = hdr[2]; *len = hdr[3];
  if (*len > 48) return false;

  uint8_t buf[64];
  int n = 0;
  for (int i = 0; i < 4; i++) buf[n++] = hdr[i];
  for (int i = 0; i < *len + 2; i++) {
    while (!port.available()) if (millis() - t0 > timeout_ms) return false;
    buf[n++] = port.read();
  }
  uint16_t got = (buf[n-2] << 8) | buf[n-1];
  if (crc16(buf, n - 2) != got) {
    Serial.println("# CRC FAIL -- dropped, NOT forwarded");
    return false;                                  // an IMP drops rather than propagates
  }
  for (int i = 0; i < *len; i++) payload[i] = buf[4 + i];
  return true;
}

void relayOrDeliver(uint8_t dst, uint8_t src, uint8_t id, uint8_t *pl, uint8_t len) {
  if (dst == MY_ADDR) {
    Serial.printf("DELIVERED from %u id %u: ", src, id);
    for (int i = 0; i < len; i++) Serial.write(pl[i]);
    Serial.println();
  } else {
    // The whole routing table, for a chain: go toward the destination.
    Serial.printf("# relaying %u->%u id %u\n", src, dst, id);
    if (dst > MY_ADDR) sendOn(Right, dst, src, id, pl, len);
    else               sendOn(Left,  dst, src, id, pl, len);
  }
}

void setup() {
  Serial.begin(115200);
  delay(300);
  Left.begin(9600, SERIAL_8N1, PIN_RX_LEFT, PIN_TX_LEFT);
  Right.begin(9600, SERIAL_8N1, PIN_RX_RIGHT, PIN_TX_RIGHT);
  Serial.printf("# IMP node %u ready\n", MY_ADDR);
}

uint8_t nextId = 0;

void loop() {
  uint8_t dst, src, id, pl[48], len;
  if (recvFrom(Left,  &dst, &src, &id, pl, &len, 5)) relayOrDeliver(dst, src, id, pl, len);
  if (recvFrom(Right, &dst, &src, &id, pl, &len, 5)) relayOrDeliver(dst, src, id, pl, len);

  // Node 1 sends to node 3 every two seconds. It has no link to node 3.
  static unsigned long last = 0;
  if (MY_ADDR == 1 && millis() - last > 2000) {
    last = millis();
    const char *msg = "LO";                        // what they actually got, 29 Oct 1969
    sendOn(Right, 3, MY_ADDR, nextId++, (const uint8_t*)msg, strlen(msg));
    Serial.printf("# sent to 3, id %u\n", nextId - 1);
  }
}