Ethernet and CSMA/CD

// ONE sketch, four protocols. This is the rig for blueprints 7 and 8, and the point is
// that ONLY the MODE constant changes between them -- same hardware, same frames, same
// backoff, so the throughput differences are the protocols and nothing else.
//
//   MODE_ALOHA_PURE     transmit whenever ready.                    expect ~18 %
//   MODE_ALOHA_SLOTTED  transmit only on a slot boundary.           expect ~37 %
//   MODE_CSMA           wait for the channel to go idle first.      expect much more
//   MODE_CSMA_CD        also listen WHILE sending, and abort.       expect more again
//
// Wiring: every station drives SHARED open-drain (output LOW, or input to release) with
// a single 4k7 pull-up on the whole bus. Anyone may pull it low; nobody can force it
// high. That is what makes two simultaneous transmitters produce garbage.
//   GPIO4  = SHARED bus       GPIO5 = slot clock in (slotted modes)
//   Set STATION to 0,1,2,3 on the four boards.

#define MODE_ALOHA_PURE     0
#define MODE_ALOHA_SLOTTED  1
#define MODE_CSMA           2
#define MODE_CSMA_CD        3

const int MODE    = MODE_ALOHA_PURE;   // <-- the only line that changes
const int STATION = 0;                 // <-- 0..3, different on each board

const int PIN_BUS  = 4;
const int PIN_SLOT = 5;

const unsigned BIT_US    = 200;        // one bit time
const int      FRAME_BITS = 40;        // 5 bytes
const unsigned SLOT_US   = BIT_US * FRAME_BITS;

inline void busDrive(int level) {
  if (level) pinMode(PIN_BUS, INPUT);          // release: the pull-up takes it high
  else       { pinMode(PIN_BUS, OUTPUT); digitalWrite(PIN_BUS, LOW); }
}
inline int busRead() { return digitalRead(PIN_BUS); }
inline bool busIdle() { pinMode(PIN_BUS, INPUT); return digitalRead(PIN_BUS) == HIGH; }

unsigned long sent = 0, delivered = 0, collisions = 0;

// Send one frame. Returns false if CSMA/CD detected a collision and aborted.
bool sendFrame(uint8_t *frame, int n) {
  for (int i = 0; i < n; i++) {
    for (int b = 7; b >= 0; b--) {
      int bit = (frame[i] >> b) & 1;
      busDrive(bit);
      delayMicroseconds(BIT_US / 2);
      if (MODE == MODE_CSMA_CD && busRead() != bit) {
        // What we hear is not what we are driving: somebody else is on the bus.
        busDrive(0);                              // JAM, so everyone agrees
        delayMicroseconds(BIT_US * 4);
        busDrive(1);
        collisions++;
        return false;                             // abort NOW, not at the end of the frame
      }
      delayMicroseconds(BIT_US / 2);
    }
  }
  busDrive(1);
  return true;
}

void waitSlot() {
  while (digitalRead(PIN_SLOT) == LOW)  ;
  while (digitalRead(PIN_SLOT) == HIGH) ;         // falling edge = slot boundary
}

void setup() {
  Serial.begin(115200);
  delay(300);
  pinMode(PIN_BUS, INPUT);
  pinMode(PIN_SLOT, INPUT_PULLUP);
  randomSeed(STATION * 7919 + micros());
  Serial.printf("# station %d, mode %d\n", STATION, MODE);
  Serial.println("# offered,delivered,collisions  -- sweep OFFER_PCT and plot the pair");
}

const int OFFER_PCT = 30;              // <-- sweep this from 5 to 100 and record each point

void loop() {
  static int tries = 0;
  if ((int)random(100) >= OFFER_PCT) { delayMicroseconds(SLOT_US); return; }

  uint8_t frame[5] = {0xAA, (uint8_t)STATION, (uint8_t)(sent & 0xFF), 0x00, 0x00};

  if (MODE >= MODE_CSMA)
    while (!busIdle()) ;                          // CARRIER SENSE: the one added line

  if (MODE == MODE_ALOHA_SLOTTED) waitSlot();

  sent++;
  bool ok = sendFrame(frame, 5);

  // Success is judged by the monitor station pulling the bus low as an acknowledgement
  // within one slot. No acknowledgement means the frame was destroyed.
  if (ok) {
    unsigned long t0 = micros();
    bool ack = false;
    while (micros() - t0 < SLOT_US) if (busRead() == LOW) { ack = true; break; }
    if (ack) { delivered++; tries = 0; }
    else     { collisions++; ok = false; }
  }

  if (!ok) {                                       // BINARY EXPONENTIAL BACKOFF
    tries++;
    unsigned long slots = random(0, 1L << (tries > 10 ? 10 : tries));
    delayMicroseconds(SLOT_US * slots);
  }

  if (sent % 200 == 0)
    Serial.printf("%lu,%lu,%lu\n", sent, delivered, collisions);
}