Week 11 – Networking and Communications

// ESP32C6

#include   

#define SUB_ADDR  0x08   // Address of ATtiny (must match slave)
#define BUTTON_PIN  D8      // D8 pin where button is connected

void setup() {

  Serial.begin(115200);  
  // Start serial monitor for debugging

  pinMode(BUTTON_PIN, INPUT);  
  // Configure button pin as INPUT (NO internal pull-up/pull-down)
  // External 10k pull-down handles default LOW state
  // Default = LOW, pressed = HIGH

  Wire.begin(22, 23);  
  // Initialize I2C (SDA=22, SCL=23)

  Serial.println("ESP32 Main Ready");
}

void loop() {

  int buttonState = digitalRead(BUTTON_PIN);  
  // Read button state

  Wire.beginTransmission(SUB_ADDR);  
  // Start communication with slave

  if (buttonState == HIGH) {
    // Button pressed

    Wire.write(1);  
    // Send value '1' → turn LED ON

    Serial.println("Button Pressed → LED ON");
  } 
  else {
    // Button released

    Wire.write(0);  
    // Send value '0' → turn LED OFF

    Serial.println("Button Released → LED OFF");
  }

  Wire.endTransmission();  
  // End I2C transmission

  delay(100);  
  // Small delay to avoid flooding I2C bus
}

  

// ATtiny1624

#include 

#define SUB_ADDR  0x08   // Must match Main
#define LED_PIN     PIN_PA5      // PA5

volatile uint8_t receivedData = 0;  
// Store incoming data (volatile because used in interrupt)

void receiveEvent(int howMany) {
  // This function runs automatically when data is received

  if (Wire.available()) {
    receivedData = Wire.read();  
    // Read incoming byte
  }
}

void setup() {

  pinMode(LED_PIN, OUTPUT);  
  // Set LED pin as output

  Wire.begin(SUB_ADDR);  
  // Initialize as I2C slave

  Wire.onReceive(receiveEvent);  
  // Register function to run when data arrives
}

void loop() {

  if (receivedData == 1) {
    digitalWrite(LED_PIN, HIGH);  
    // Turn LED ON
  } 
  else {
    digitalWrite(LED_PIN, LOW);  
    // Turn LED OFF
  }
}

  

#include   // Include I2C library
#define BUTTON_PIN D8   // Button connected to D8 (Active HIGH)
#define LED_PIN D7      // LED connected to D7
#define SUB1_ADDR 0x08  // I2C address of Subordinate 1 (ATtiny)
#define SUB2_ADDR 0x09  // I2C address of Subordinate 2 (ESP32)

unsigned long pressStart = 0;  // Stores time when button was pressed
bool prevState = LOW;  // Stores previous button state for edge detection


void setup() {

  pinMode(BUTTON_PIN, INPUT);  // Button uses external pull-down → no internal pull-up
  pinMode(LED_PIN, OUTPUT);  // LED pin set as output
  Wire.begin(22, 23);  // Initialize I2C as Main → SDA=22, SCL=23
  Serial.begin(115200);  // Serial monitor for debugging
  
}


void loop() {

  bool state = digitalRead(BUTTON_PIN);  // Read current button state
  // Detect button press (LOW → HIGH transition)

  if (state && !prevState) {
    pressStart = millis();  
    // Record time when button was pressed
  }

  // Detect button release (HIGH → LOW transition)
  if (!state && prevState) {

    unsigned long duration = millis() - pressStart;  // Calculate how long button was held

    if (duration < 500) {
      // SHORT PRESS (<500ms)

      sendCommand(SUB1_ADDR, 1);  // Send command 1 to Subordinate 1
      Serial.println("SHORT PRESS → Sub1");
    }
    else {
      // LONG PRESS (>500ms)

      sendCommand(SUB2_ADDR, 2);  // Send command 2 to Subordinate 2
      Serial.println("LONG PRESS → Sub2");
    }
  }

  prevState = state;  // Update previous state for next loop iteration
}


// ── Function to send I2C command ─────────────
void sendCommand(uint8_t addr, uint8_t cmd) {

  Serial.print("Sending to: ");
  Serial.println(addr);
  Wire.beginTransmission(addr);  // Start communication with given address
  Wire.write(cmd);  // Send command byte
  Wire.endTransmission();  // End transmission → actually sends data
}
  

#include   
#define LED_PIN PIN_PA5      // PA5 pin where LED is connected
#define I2C_ADDR 0x08  // I2C address for this device

volatile uint8_t command = 0;  // Stores received command (volatile → used in interrupt)


// ── I2C Receive Callback ───────────────────
void receiveEvent(int howMany) {

  if (Wire.available()) {
    command = Wire.read();  // Read incoming command byte
  }
}


void setup() {
  pinMode(LED_PIN, OUTPUT);  // Set LED pin as output
  Wire.begin(I2C_ADDR);  // Initialize as I2C Subordinate
  Wire.onReceive(receiveEvent);  // Register callback when data is received
}


void loop() {
  if (command == 1) {  
    // If command is 1 → blink LED

    blinkTwice();  // Call blink function
    command = 0;   // Reset command after execution
  }
}


// ── Blink LED twice ────────────────────────
void blinkTwice() {
  for (int i = 0; i < 2; i++) {

    digitalWrite(LED_PIN, HIGH);  // Turn LED ON
    delay(200);  // Keep it ON for 200ms
    digitalWrite(LED_PIN, LOW);  // Turn LED OFF
    delay(200); // Keep it OFF for 200ms
  }
}
  

#include   
#define LED_PIN D2      // LED connected to D0
#define I2C_ADDR 0x09  // I2C address for this device

volatile uint8_t command = 0;  // Stores received command

// ── I2C Receive Callback ───────────────────
void receiveEvent(int len) {

  Serial.println("Data received!");

  while (Wire.available()) {
    command = Wire.read();
    Serial.print("Command = ");
    Serial.println(command);
  }
}


void setup() {

  Serial.begin(115200);

  pinMode(LED_PIN, OUTPUT);  // Set LED pin as output
  
  Wire.begin((uint8_t)I2C_ADDR); // Initialize as I2C Subordinate // Wire.begin(I2C_ADDR, 22, 23); 
  Wire.setClock(100000);
  
  Wire.onReceive(receiveEvent);  // Register receive callback
  
}


void loop() {

  
  while (Wire.available()) {
    command = Wire.read();  // Read incoming command byte
    Serial.println(command);
  if (command == 2) {  
    // If command is 2 → blink LED
    blinkTwice();  
    command = 0;  // Reset after execution
    delay(10);  // allow system to stabilize
  }
  }

}


// ── Blink LED twice ────────────────────────
void blinkTwice() {

  for (int i = 0; i < 2; i++) {

    digitalWrite(LED_PIN, HIGH);  // LED ON
    delay(200);
    digitalWrite(LED_PIN, LOW);   // LED OFF
    delay(200);
  }
}
  

#include   
#define LED_PIN PIN_PA3      // PA5 pin where LED is connected
#define I2C_ADDR 0x09  // I2C address for this device

volatile uint8_t command = 0;  // Stores received command (volatile → used in interrupt)


// ── I2C Receive Callback ───────────────────
void receiveEvent(int howMany) {

  if (Wire.available()) {
    command = Wire.read();  // Read incoming command byte
  }
}


void setup() {
  pinMode(LED_PIN, OUTPUT);  // Set LED pin as output
  Wire.begin(I2C_ADDR);  // Initialize as I2C Subordinate
  Wire.onReceive(receiveEvent);  // Register callback when data is received
}


void loop() {
  if (command == 2) {  
    // If command is 2 → blink LED

    blinkTwice();  // Call blink function
    command = 0;   // Reset command after execution
  }
}


// ── Blink LED twice ────────────────────────
void blinkTwice() {
  for (int i = 0; i < 2; i++) {

    digitalWrite(LED_PIN, HIGH);  // Turn LED ON
    delay(200);  // Keep it ON for 200ms
    digitalWrite(LED_PIN, LOW);  // Turn LED OFF
    delay(200); // Keep it OFF for 200ms
  }
}
  

#include <Wire.h>
#define PulseSensorPin  0      // Analog input pin
#define I2C_ADDR        0x08   // Subordinate address

int Signal;

// Your observed range
#define MIN_SIGNAL 1550
#define MAX_SIGNAL 1670

void setup() {
  Serial.begin(115200);

  Wire.begin(22, 23);  
  // Initialize I2C as Main (SDA=22, SCL=23)

  Serial.println("ESP32 Main Ready");
}

void loop() {

  Signal = analogRead(PulseSensorPin);  
  // Read pulse signal

  Serial.println(Signal);

  // Map signal to 0–5 levels (bars)
  int level = map(Signal, MIN_SIGNAL, MAX_SIGNAL, 0, 5);

  // Constrain to safe range
  level = constrain(level, 0, 5);

  // Send level to subordinate
  Wire.beginTransmission(I2C_ADDR);
  Wire.write(level);  
  Wire.endTransmission();

  delay(30);  
}
        

#include <Wire.h>
#define I2C_ADDR 0x08
#define THRESHOLD 1640

// ── Charlieplex Pins ─────────────────────────
const uint8_t CHARLIE_PINS[] = { PIN_PA1, PIN_PA2, PIN_PA3, PIN_PA6, PIN_PA7 };
const uint8_t NUM_PINS = 5;

// ── LED Struct ───────────────────────────────
struct LED {
  uint8_t anode;
  uint8_t cathode;
};

// ── LED Mapping (your tested mapping) ───────
const LED LED_TABLE[5][4] = {
  { {PIN_PA2, PIN_PA3}, {PIN_PA1, PIN_PA3}, {PIN_PA7, PIN_PA3}, {PIN_PA6, PIN_PA3} },
  { {PIN_PA3, PIN_PA2}, {PIN_PA1, PIN_PA2}, {PIN_PA7, PIN_PA2}, {PIN_PA6, PIN_PA2} },
  { {PIN_PA3, PIN_PA1}, {PIN_PA2, PIN_PA1}, {PIN_PA7, PIN_PA1}, {PIN_PA6, PIN_PA1} },
  { {PIN_PA3, PIN_PA7}, {PIN_PA2, PIN_PA7}, {PIN_PA1, PIN_PA7}, {PIN_PA6, PIN_PA7} },
  { {PIN_PA3, PIN_PA6}, {PIN_PA2, PIN_PA6}, {PIN_PA1, PIN_PA6}, {PIN_PA7, PIN_PA6} },
};

// ── Active LED Buffer ───────────────────────
struct ActiveLED {
  uint8_t row;
  uint8_t col;
};

ActiveLED activeBuffer[20];
uint8_t activeCount = 0;

// ── Received signal ─────────────────────────
volatile uint16_t signalValue = 0;


// ── ALL OFF ─────────────────────────────────
void allOff() {
  for (uint8_t i = 0; i < NUM_PINS; i++) {
    pinMode(CHARLIE_PINS[i], INPUT);
  }
}


// ── CLEAR BUFFER ────────────────────────────
void clearAll() {
  activeCount = 0;
  allOff();
}


// ── ADD LED TO BUFFER ───────────────────────
void setLED(uint8_t row, uint8_t col, bool state) {

  uint8_t r = row - 1;
  uint8_t c = col - 1;

  if (state) {
    if (activeCount < 20) {
      activeBuffer[activeCount].row = r;
      activeBuffer[activeCount].col = c;
      activeCount++;
    }
  }
}


// ── MULTIPLEX ENGINE ────────────────────────
void multiplex() {

  if (activeCount == 0) {
    allOff();
    return;
  }

  for (uint8_t i = 0; i < activeCount; i++) {

    LED led = LED_TABLE[activeBuffer[i].row][activeBuffer[i].col];

    allOff();

    pinMode(led.anode, OUTPUT);
    pinMode(led.cathode, OUTPUT);

    digitalWrite(led.anode, HIGH);
    digitalWrite(led.cathode, LOW);

    delayMicroseconds(400);
  }
}


// ── RECEIVE I2C DATA ────────────────────────
void receiveEvent(int howMany) {

  if (Wire.available() >= 2) {

    uint8_t high = Wire.read();
    uint8_t low  = Wire.read();

    signalValue = (high << 8) | low;
  }
}


// ── TURN ON FULL MATRIX ─────────────────────
void turnAllOn() {

  clearAll();

  for (uint8_t r = 1; r <= 5; r++) {
    for (uint8_t c = 1; c <= 4; c++) {
      setLED(r, c, true);
    }
  }
}


// ── SETUP ───────────────────────────────────
void setup() {

  allOff();

  Wire.begin(I2C_ADDR);
  Wire.onReceive(receiveEvent);
}


// ── LOOP ────────────────────────────────────
void loop() {

  if (signalValue > THRESHOLD) {

    // FULL MATRIX ON
    turnAllOn();

    unsigned long start = millis();
    while (millis() - start < 300) {
      multiplex();
    }

    // OFF phase
    clearAll();

    start = millis();
    while (millis() - start < 200) {
      multiplex();
    }
  }
  else {
    clearAll();
    multiplex();
  }
}