Networking
& Communications

#include <ArduinoBLE.h>
const int BUTTON_PIN = D2;
const int LED_PIN    = D9;

BLEService buttonService("180C");
BLEByteCharacteristic buttonChar("2A56", BLERead | BLENotify);

byte lastButtonState = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  Serial.begin(9600);
  while (!Serial);
  if (!BLE.begin()) { Serial.println("BLE failed to start"); while (1); }
  BLE.setLocalName("XIAO_PERIPHERAL");
  BLE.setAdvertisedService(buttonService);
  buttonService.addCharacteristic(buttonChar);
  BLE.addService(buttonService);
  buttonChar.writeValue((byte)0);
  BLE.advertise();
  Serial.println("Peripheral advertising...");
}

void loop() {
  BLEDevice central = BLE.central();
  if (central) {
    Serial.print("Connected to central: ");
    Serial.println(central.address());
    while (central.connected()) {
      byte currentButtonState = (digitalRead(BUTTON_PIN) == LOW) ? 1 : 0;
      if (currentButtonState != lastButtonState) {
        buttonChar.writeValue(currentButtonState);
        if (currentButtonState == 1) {
          digitalWrite(LED_PIN, HIGH);
          Serial.println("Button pressed - sent 1");
        } else {
          digitalWrite(LED_PIN, LOW);
          Serial.println("Button released - sent 0");
        }
        lastButtonState = currentButtonState;
      }
      delay(20);
    }
    Serial.println("Central disconnected");
    digitalWrite(LED_PIN, LOW);
  }
}

#include <ArduinoBLE.h>
const int LED_PIN = D8;

BLEDevice peripheral;
BLECharacteristic buttonChar;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  Serial.begin(9600);
  while (!Serial);
  if (!BLE.begin()) { Serial.println("BLE failed to start"); while (1); }
  Serial.println("Central scanning for peripheral...");
  BLE.scan();
}

void loop() {
  peripheral = BLE.available();
  if (peripheral) {
    if (peripheral.localName() == "XIAO_PERIPHERAL") {
      BLE.stopScan();
      if (connectToPeripheral(peripheral)) {
        while (peripheral.connected()) {
          if (buttonChar.valueUpdated()) {
            byte value;
            buttonChar.readValue(value);
            if (value == 1) {
              digitalWrite(LED_PIN, HIGH);
              Serial.println("Received 1 - LED ON");
            } else {
              digitalWrite(LED_PIN, LOW);
              Serial.println("Received 0 - LED OFF");
            }
          }
          delay(20);
        }
        Serial.println("Peripheral disconnected");
        digitalWrite(LED_PIN, LOW);
      }
      BLE.scan();
    }
  }
}

bool connectToPeripheral(BLEDevice peripheral) {
  if (!peripheral.connect()) { return false; }
  if (!peripheral.discoverAttributes()) { peripheral.disconnect(); return false; }
  buttonChar = peripheral.characteristic("2A56");
  if (!buttonChar) { peripheral.disconnect(); return false; }
  if (!buttonChar.canSubscribe()) { peripheral.disconnect(); return false; }
  if (!buttonChar.subscribe()) { peripheral.disconnect(); return false; }
  Serial.println("Subscribed to characteristic");
  return true;
}

const int PIN_BOTON = 0;  
const int MOTOR_B1 = 10;  
const int MOTOR_B2 = 9;   

void setup() {
  pinMode(MOTOR_B1, OUTPUT);
  pinMode(MOTOR_B2, OUTPUT);
  pinMode(LED_RED, OUTPUT);
  pinMode(PIN_BOTON, INPUT); // Waits to receive 3.3V
  digitalWrite(MOTOR_B1, LOW);
  digitalWrite(MOTOR_B2, LOW);
  digitalWrite(LED_RED, HIGH); // Off
}

void loop() {
  if (digitalRead(PIN_BOTON) == HIGH) { 
    digitalWrite(MOTOR_B1, HIGH); 
    digitalWrite(MOTOR_B2, LOW);
    digitalWrite(LED_RED, LOW); // Red LED turns on
  } else {
    digitalWrite(MOTOR_B1, LOW); 
    digitalWrite(MOTOR_B2, LOW);
    digitalWrite(LED_RED, HIGH);
  }
}

from machine import Pin, I2C
import utime
import framebuf

i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
trig = Pin(2, Pin.OUT)
echo = Pin(1, Pin.IN)

class OLED:
    def __init__(self, i2c):
        self.i2c = i2c
        self.addr = 0x3C
        self.buffer = bytearray(1024)
        self.fb = framebuf.FrameBuffer(self.buffer, 128, 64, framebuf.MONO_VLSB)
        self.init_display()

    def write_cmd(self, cmd):
        try: self.i2c.writeto(self.addr, bytearray([0x00, cmd]))
        except: pass

    def init_display(self):
        for cmd in (0xAE, 0x20, 0x00, 0x21, 0, 127, 0x22, 0, 7, 0x8D, 0x14, 0xAF, 0xA4, 0xA6):
            self.write_cmd(cmd)
        self.clear_physical()

    def clear_physical(self):
        self.fb.fill(0)
        self.show()

    def show(self):
        self.write_cmd(0x21); self.write_cmd(0); self.write_cmd(127)
        self.write_cmd(0x22); self.write_cmd(0); self.write_cmd(7)
        try: self.i2c.writeto(self.addr, b'\x40' + self.buffer)
        except: pass

    def power_off(self):
        self.clear_physical()
        self.write_cmd(0xAE)

    def power_on(self):
        self.write_cmd(0xAF)

oled = OLED(i2c)
estado_anterior = False

def medir():
    trig.low(); utime.sleep_us(2); trig.high(); utime.sleep_us(10); trig.low()
    start = utime.ticks_us()
    while echo.value() == 0:
        if utime.ticks_diff(utime.ticks_us(), start) > 20000: return -1
    t1 = utime.ticks_us()
    while echo.value() == 1:
        if utime.ticks_diff(utime.ticks_us(), t1) > 20000: break
    t2 = utime.ticks_us()
    return (utime.ticks_diff(t2, t1) * 0.0343) / 2

while True:
    dist = medir()
    detectado = (0 < dist <= 20)
    if detectado:
        if not estado_anterior:
            oled.power_on()
        oled.fb.fill(0)
        oled.fb.rect(0, 0, 128, 64, 1)
        oled.fb.text("PROXIMIDAD", 25, 10)
        oled.fb.hline(10, 22, 108, 1)
        oled.fb.text("{:.1f} cm".format(dist), 35, 35)
        ancho_barra = int((dist / 20) * 100)
        oled.fb.rect(14, 50, 100, 7, 1)
        oled.fb.fill_rect(14, 50, 100 - ancho_barra, 7, 1)
        oled.show()
        estado_anterior = True
    else:
        if estado_anterior:
            oled.power_off()
            estado_anterior = False
    utime.sleep_ms(50)

#include <SoftwareSerial.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
SoftwareSerial miSerial(0, 6); 
const int BTN = 2;

int ultimoEstadoBtn = -1;
int ultimaDistanciaSubida = -1;
bool modoAlertaActivo = false;

void setup() {
  miSerial.begin(9600);
  pinMode(BTN, INPUT_PULLUP);
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) for(;;);
  Wire.setClock(400000); 
  display.clearDisplay();
  display.display();
}

void loop() {
  // 1. BUTTON (Edge detection — highest priority)
  int estadoActualBtn = digitalRead(BTN);
  if (estadoActualBtn != ultimoEstadoBtn) {
    if (estadoActualBtn == LOW) miSerial.write('F'); // Pressed -> Off
    else miSerial.write('N');                        // Released -> On
    ultimoEstadoBtn = estadoActualBtn;
  }
  // 2. DISPLAY (Only if data is available from Pico)
  if (miSerial.available() > 0) {
    int distLeida = miSerial.read();
    if (distLeida < 15 && distLeida > 0) {
      if (abs(distLeida - ultimaDistanciaSubida) >= 2 || !modoAlertaActivo) {
        display.clearDisplay();
        display.setTextSize(2);
        display.setTextColor(SSD1306_WHITE);
        display.setCursor(20, 10);
        display.print("ALERTA!");
        display.setCursor(20, 40);
        display.print(distLeida); display.print(" cm");
        display.display();
        ultimaDistanciaSubida = distLeida;
        modoAlertaActivo = true;
      }
    } else if (modoAlertaActivo) {
      display.clearDisplay();
      display.display();
      modoAlertaActivo = false;
      ultimaDistanciaSubida = -1;
    }
  }
}

from machine import Pin, UART
import utime

uart = UART(1, baudrate=9600, tx=Pin(4), rx=Pin(5))
led_pico = Pin(0, Pin.OUT, value=1)  # Starts on
trig = Pin(2, Pin.OUT)
echo = Pin(1, Pin.IN)

def medir():
    trig.low(); utime.sleep_us(2); trig.high(); utime.sleep_us(10); trig.low()
    start = utime.ticks_us()
    while echo.value() == 0:
        if utime.ticks_diff(utime.ticks_us(), start) > 10000: return 0
    t1 = utime.ticks_us()
    while echo.value() == 1:
        if utime.ticks_diff(utime.ticks_us(), t1) > 10000: break
    return int((utime.ticks_diff(utime.ticks_us(), t1) * 0.0343) / 2)

while True:
    # 1. Read button command (INSTANT)
    if uart.any():
        cmd = uart.read(1)
        if cmd == b'F': led_pico.off()
        elif cmd == b'N': led_pico.on()
    
    # 2. Measure and send distance (non-blocking)
    d = medir()
    if d > 0:
        uart.write(bytes([min(d, 255)]))
    
    utime.sleep_ms(10)  # Minimal delay for stability