Week 10 – Output Devices

// ATtiny1624 LED Blink
// LED connected to PA5 — Active High (LED ON when pin is HIGH)

#define LED_PIN  PIN_PA5    // define PA5 as the LED pin
                            // PIN_PA5 is the Arduino-style name for PA5 on ATtiny1624

void setup() {
  pinMode(LED_PIN, OUTPUT);     // set PA5 as output — allows us to drive current through LED
  digitalWrite(LED_PIN, LOW);   // start with LED off — ensure known state at power up
}

void loop() {
  digitalWrite(LED_PIN, HIGH);  // set PA5 HIGH — LED turns ON (Active High)
  delay(500);                   // wait 500ms — LED stays ON for 0.5 seconds

  digitalWrite(LED_PIN, LOW);   // set PA5 LOW — LED turns OFF
  delay(500);                   // wait 500ms — LED stays OFF for 0.5 seconds
                                // loop repeats forever — continuous blink
}
  

// ATtiny1624 LED Blink
// LED connected to PA5 — Active High (LED ON when pin is HIGH)

#define LED_PIN  PIN_PA5    
// ── Charlieplexing 5x4 matrix on ATtiny1624 ───────────────────────────────────
// Pins used: PA1, PA2, PA3, PA6, PA7
// LEDs named LED[row][col] — e.g. LED23 = row 2, col 3
// Charlieplex rule: only ANODE pin = OUTPUT HIGH
//                        CATHODE pin = OUTPUT LOW
//                        ALL other pins = INPUT (floating / Hi-Z)
// ─────────────────────────────────────────────────────────────────────────────

// ── Array of all 5 Charlieplex pins — used to reset all pins to Hi-Z ─────────
const uint8_t CHARLIE_PINS[] = { PIN_PA1, PIN_PA2, PIN_PA3, PIN_PA6, PIN_PA7 };
const uint8_t NUM_PINS = 5;  // total number of Charlieplex pins

// ── allOff — sets ALL pins to INPUT (Hi-Z / floating) ────────────────────────
// MUST be called before driving any LED
// prevents phantom lighting of adjacent LEDs through shared traces
void allOff() {
  for (uint8_t i = 0; i < NUM_PINS; i++) {
    pinMode(CHARLIE_PINS[i], INPUT);   // INPUT = Hi-Z = effectively disconnected
  }
}

// ── lightLED — drives one LED by setting anode HIGH and cathode LOW ───────────
// all other pins are set to INPUT (Hi-Z) by allOff() first
// anode  : the pin connected to the + side of the LED
// cathode: the pin connected to the - side of the LED
void lightLED(uint8_t anode, uint8_t cathode) {
  allOff();                            // first float ALL pins — prevents ghosting

  pinMode(anode,   OUTPUT);            // set anode pin as output
  pinMode(cathode, OUTPUT);            // set cathode pin as output

  digitalWrite(anode,   HIGH);         // drive anode HIGH — current source
  digitalWrite(cathode, LOW);          // drive cathode LOW — current sink
                                       // current flows anode → LED → cathode → LED lights up
}

// ── Individual LED functions ──────────────────────────────────────────────────
// Row 1 (PIN_PA3 = cathode for all row 1 LEDs)
void LED11() { lightLED(PIN_PA2, PIN_PA3); }  // anode=PA2, cathode=PA3
void LED12() { lightLED(PIN_PA1, PIN_PA3); }  // anode=PA1, cathode=PA3
void LED13() { lightLED(PIN_PA7, PIN_PA3); }  // anode=PA7, cathode=PA3
void LED14() { lightLED(PIN_PA6, PIN_PA3); }  // anode=PA6, cathode=PA3

// Row 2 (PIN_PA2 = cathode for all row 2 LEDs)
void LED21() { lightLED(PIN_PA3, PIN_PA2); }  // anode=PA3, cathode=PA2
void LED22() { lightLED(PIN_PA1, PIN_PA2); }  // anode=PA1, cathode=PA2
void LED23() { lightLED(PIN_PA7, PIN_PA2); }  // anode=PA7, cathode=PA2
void LED24() { lightLED(PIN_PA6, PIN_PA2); }  // anode=PA6, cathode=PA2

// Row 3 (PIN_PA1 = cathode for all row 3 LEDs)
void LED31() { lightLED(PIN_PA3, PIN_PA1); }  // anode=PA3, cathode=PA1
void LED32() { lightLED(PIN_PA2, PIN_PA1); }  // anode=PA2, cathode=PA1
void LED33() { lightLED(PIN_PA7, PIN_PA1); }  // anode=PA7, cathode=PA1
void LED34() { lightLED(PIN_PA6, PIN_PA1); }  // anode=PA6, cathode=PA1

// Row 4 (PIN_PA7 = cathode for all row 4 LEDs)
void LED41() { lightLED(PIN_PA3, PIN_PA7); }  // anode=PA3, cathode=PA7
void LED42() { lightLED(PIN_PA2, PIN_PA7); }  // anode=PA2, cathode=PA7
void LED43() { lightLED(PIN_PA1, PIN_PA7); }  // anode=PA1, cathode=PA7
void LED44() { lightLED(PIN_PA6, PIN_PA7); }  // anode=PA6, cathode=PA7

// Row 5 (PIN_PA6 = cathode for all row 5 LEDs)
void LED51() { lightLED(PIN_PA3, PIN_PA6); }  // anode=PA3, cathode=PA6
void LED52() { lightLED(PIN_PA2, PIN_PA6); }  // anode=PA2, cathode=PA6
void LED53() { lightLED(PIN_PA1, PIN_PA6); }  // anode=PA1, cathode=PA6
void LED54() { lightLED(PIN_PA7, PIN_PA6); }  // anode=PA7, cathode=PA6

// ── setup ─────────────────────────────────────────────────────────────────────
void setup() {
  allOff();                            // start with all pins floating — safe initial state
}

// ── loop — demo: light each LED one by one ────────────────────────────────────
void loop() {
  // Row 1
  LED11(); delay(300);
  LED12(); delay(300);
  LED13(); delay(300);
  LED14(); delay(300);

  // Row 2
  LED21(); delay(300);
  LED22(); delay(300);
  LED23(); delay(300);
  LED24(); delay(300);

  // Row 3
  LED31(); delay(300);
  LED32(); delay(300);
  LED33(); delay(300);
  LED34(); delay(300);

  // Row 4
  LED41(); delay(300);
  LED42(); delay(300);
  LED43(); delay(300);
  LED44(); delay(300);

  // Row 5
  LED51(); delay(300);
  LED52(); delay(300);
  LED53(); delay(300);
  LED54(); delay(300);

  allOff(); delay(500);                // brief pause with all LEDs off before repeating
}
  

// ── Charlieplexing 5x4 matrix on ATtiny1624 with multiplexing ────────────────
// Pins: PA1, PA2, PA3, PA6, PA7
// Multiplexing: cycles through active LEDs rapidly — eye sees all as ON together
// Each LED gets 500µs on-time per cycle — at 20 LEDs max = 10ms full cycle = 100Hz
// ─────────────────────────────────────────────────────────────────────────────

// ── Pin array — all 5 Charlieplex pins ───────────────────────────────────────
const uint8_t CHARLIE_PINS[] = { PIN_PA1, PIN_PA2, PIN_PA3, PIN_PA6, PIN_PA7 };
const uint8_t NUM_PINS = 5;            // total number of Charlieplex pins

// ── LED descriptor — stores anode and cathode pin for each LED ────────────────
struct LED {
  uint8_t anode;                       // pin to drive HIGH to light this LED
  uint8_t cathode;                     // pin to drive LOW to light this LED
};

// ── Full LED lookup table — all 20 LEDs defined by anode/cathode pair ─────────
const LED LED_TABLE[5][4] = {
  // Col1          Col2          Col3          Col4
  { {PIN_PA2, PIN_PA3}, {PIN_PA1, PIN_PA3}, {PIN_PA7, PIN_PA3}, {PIN_PA6, PIN_PA3} }, // Row 1
  { {PIN_PA3, PIN_PA2}, {PIN_PA1, PIN_PA2}, {PIN_PA7, PIN_PA2}, {PIN_PA6, PIN_PA2} }, // Row 2
  { {PIN_PA3, PIN_PA1}, {PIN_PA2, PIN_PA1}, {PIN_PA7, PIN_PA1}, {PIN_PA6, PIN_PA1} }, // Row 3
  { {PIN_PA3, PIN_PA7}, {PIN_PA2, PIN_PA7}, {PIN_PA1, PIN_PA7}, {PIN_PA6, PIN_PA7} }, // Row 4
  { {PIN_PA3, PIN_PA6}, {PIN_PA2, PIN_PA6}, {PIN_PA1, PIN_PA6}, {PIN_PA7, PIN_PA6} }, // Row 5
};

// ── Active LED buffer — stores which LEDs are currently ON ────────────────────
// each entry stores row(0-4) and col(0-3) of an active LED
struct ActiveLED {
  uint8_t row;                         // row index 0–4
  uint8_t col;                         // col index 0–3
};

ActiveLED activeBuffer[20];            // maximum 20 LEDs can be active at once
uint8_t   activeCount = 0;             // how many LEDs are currently in buffer

// ── allOff — float all pins to Hi-Z ──────────────────────────────────────────
void allOff() {
  for (uint8_t i = 0; i < NUM_PINS; i++) {
    pinMode(CHARLIE_PINS[i], INPUT);   // INPUT = Hi-Z = electrically disconnected
  }
}

// ── setLED — add or remove an LED from the active buffer ─────────────────────
// row: 1–5, col: 1–4, state: true=ON, false=OFF
void setLED(uint8_t row, uint8_t col, bool state) {
  uint8_t r = row - 1;                 // convert 1-based to 0-based index
  uint8_t c = col - 1;                 // convert 1-based to 0-based index

  if (state) {                         // turning LED ON — add to buffer
    for (uint8_t i = 0; i < activeCount; i++) {
      if (activeBuffer[i].row == r && activeBuffer[i].col == c) {
        return;                        // already in buffer — do not add duplicate
      }
    }
    if (activeCount < 20) {            // buffer not full
      activeBuffer[activeCount].row = r;   // store row index
      activeBuffer[activeCount].col = c;   // store col index
      activeCount++;                   // increment active LED count
    }
  } else {                             // turning LED OFF — remove from buffer
    for (uint8_t i = 0; i < activeCount; i++) {
      if (activeBuffer[i].row == r && activeBuffer[i].col == c) {
        // shift remaining entries down to fill the gap
        for (uint8_t j = i; j < activeCount - 1; j++) {
          activeBuffer[j] = activeBuffer[j + 1];
        }
        activeCount--;                 // reduce active count
        return;
      }
    }
  }
}

// ── clearAll — turn off all LEDs and empty the active buffer ─────────────────
void clearAll() {
  activeCount = 0;                     // empty the buffer — no LEDs active
  allOff();                            // float all pins immediately
}

// ── multiplex — call this repeatedly in loop — drives active LEDs ─────────────
// cycles through each active LED, lights it for 500µs, then moves to next
// at 500µs per LED, 20 LEDs = 10ms full cycle = 100Hz refresh — flicker free
void multiplex() {
  if (activeCount == 0) {              // no LEDs to show
    allOff();                          // make sure everything is off
    return;
  }

  for (uint8_t i = 0; i < activeCount; i++) {
    uint8_t r = activeBuffer[i].row;   // get row index of this LED
    uint8_t c = activeBuffer[i].col;   // get col index of this LED

    LED led = LED_TABLE[r][c];         // look up anode and cathode pins

    allOff();                          // float all pins before switching
    pinMode(led.anode,   OUTPUT);      // set anode pin as output
    pinMode(led.cathode, OUTPUT);      // set cathode pin as output
    digitalWrite(led.anode,   HIGH);   // drive anode HIGH — current source
    digitalWrite(led.cathode, LOW);    // drive cathode LOW — LED lights up

    delayMicroseconds(500);            // hold this LED on for 500µs
                                       // shorter = dimmer but smoother at high count
                                       // longer = brighter but may flicker with many LEDs
  }

  allOff();                            // float all pins at end of cycle
}

// ── setup ─────────────────────────────────────────────────────────────────────
void setup() {
  allOff();                            // start safe — all pins floating
}

// ── loop — demo showing multiplexing capability ───────────────────────────────
void loop() {

  // ── Demo 1 — light all 20 LEDs simultaneously ──────────────────────────────
  clearAll();                          // clear buffer
  for (uint8_t r = 1; r <= 5; r++) {  // loop through all rows
    for (uint8_t c = 1; c <= 4; c++) {// loop through all columns
      setLED(r, c, true);              // add every LED to active buffer
    }
  }
  unsigned long start = millis();      // record start time
  while (millis() - start < 3000) {   // run for 3 seconds
    multiplex();                       // keep multiplexing — all 20 LEDs appear ON
  }

  // ── Demo 2 — light only specific LEDs simultaneously ───────────────────────
  clearAll();                          // clear all LEDs
  setLED(1, 1, true);                  // LED11 ON
  setLED(2, 3, true);                  // LED23 ON
  setLED(3, 2, true);                  // LED32 ON
  setLED(4, 4, true);                  // LED44 ON
  setLED(5, 1, true);                  // LED51 ON
  start = millis();
  while (millis() - start < 3000) {   // show for 3 seconds
    multiplex();                       // multiplex — 5 LEDs appear simultaneously ON
  }

  // ── Demo 3 — chase pattern using multiplexing ───────────────────────────────
  clearAll();
  for (uint8_t r = 1; r <= 5; r++) {
    for (uint8_t c = 1; c <= 4; c++) {
      setLED(r, c, true);              // add LED to active set
      start = millis();
      while (millis() - start < 200) {// show current set for 200ms
        multiplex();                   // multiplex all currently active LEDs
      }
    }
  }

  // ── Demo 4 — row by row wipe ON then OFF ────────────────────────────────────
  clearAll();
  for (uint8_t r = 1; r <= 5; r++) {  // light one full row at a time
    for (uint8_t c = 1; c <= 4; c++) {
      setLED(r, c, true);              // turn on all 4 LEDs in this row
    }
    start = millis();
    while (millis() - start < 500) {  // hold each row for 500ms
      multiplex();
    }
  }
  start = millis();
  while (millis() - start < 1000) {   // show all rows on together for 1 sec
    multiplex();
  }
  clearAll();                          // wipe all off
  delay(500);                          // pause before repeating
}