Week 11 — Networking and communications

Individual assignment: UART hub + I²C display chain

Per Networking & Communications I had to connect wired or wireless nodes that each have a bus address and a local input or output, then show that the links work. I did not make a new PCB this week. I used the Week 8 JLCPCB hub from Week 6 rev. 2 (NanoStat UART pads were already in that revision), plus two commercial satellite boards (Pico NanoStat stack, Senlin WROOM + ST7789). Evidence is wiring, serial/I²C logs, and firmware in code/week11-network/ (trimmed from my Downloads bench trees).

1. Task

My final project splits plant impedance, room environment, and human-facing UI across MCUs so analog experiments and SPI/TFT work do not fight for the same pins. Week 11’s job is to make that split communicate on the bench:

• Node A: Pico + NanoStat input: measures impedance through the LMP91000 front-end, classifies nitrogen stress locally, and outputs one ASCII line per sample on UART TX (STAT,… at 115200 8N1).
• Node B: XIAO ESP32‑S3 on my Week 8 PCB: inputs DHT11 + light (Week 9) and UART RX from Pico; outputs I²C master writes to WROOM at address 0x55 (cmd 0x01 environment, cmd 0x07 plant status).
• Node C: ESP32‑S3 WROOM display: I²C slave 0x55, output ST7789 TFT — Environment page for RH / °C / light ( Week 10) and Plant info for level / N-index from Pico.

The data path I am proving matches my product README ( PICO上传程序 → S3上传程序 → WROOM上传程序 in Downloads):

PICO (STAT lines)  --UART 115200-->  XIAO S3 (parse + bridge)
XIAO S3            --I2C 0x55-->     WROOM (ST7789 UI)

System map: three nodes, two protocols

Final upload firmware notes

Instructor feedback asked for the actual sketch, clearer code explanation, bus addresses, TX/RX pins, and a connection diagram. The complete final upload firmware is archived in code/final-project-upload.zip, and the browsable source trees are s3-upload/, wroom-upload/, pico-upload/, and uno/. The excerpts below are copied from that final upload set. I pulled the excerpts below because they are the parts I used to check the communication paths.

flowchart LR
  Pico["Node A: ESP32 Pico + NanoStat
Plant impedance status"]
  Xiao["Node B: XIAO ESP32-S3 hub
DHT11 + light + bridge"]
  Wroom["Node C: ESP32-S3 WROOM UI
ST7789 + FT6336"]
  Tft["Local output: ST7789 TFT
SPI 26 MHz"]
  Touch["Local input: FT6336 touch
I2C addr 0x38"]
  Soil["Soil probe
UART Modbus addr 0x02"]
  Uno["Arduino UNO motion base
UART text protocol"]

  Pico -- "UART 115200 8N1
Pico GPIO1 TX to XIAO D7/GPIO44 RX
ASCII STAT lines" --> Xiao
  Xiao -- "I2C master 100 kHz
SDA D4/GPIO9, SCL D5/GPIO8
HostLink write to slave 0x55" --> Wroom
  Wroom -- "SPI
SCK18 MOSI8 MISO16 CS9 DC3 RST46 BL17" --> Tft
  Touch -- "I2C 100 kHz
SDA6 SCL15, addr 0x38" --> Wroom
  Soil -- "UART2 9600 8N1
sensor TX to G12 RX, sensor RX to G13 TX
Modbus RTU addr 0x02" --> Wroom
  Wroom -- "UART1 9600 8N1
WROOM G45 TX to UNO G9 RX
UNO G8 TX to WROOM G35 RX" --> Uno
            

Connection and address summary from the final code

Shared HostLink frame format

I used a small binary frame on the addressed I²C bus so the WROOM can reject broken packets instead of treating random bytes as plant data. Every fixed frame begins with magic 0xA5. The command byte selects the payload type: 0x01 for environment telemetry and 0x07 for plant status.

// code/final-project-upload/wroom-upload/src/i2c_env_link.h
namespace I2cEnvLink {
static constexpr uint8_t kMagic = 0xA5;
static constexpr uint8_t kCmdTelemetryV1 = 0x01;
static constexpr uint8_t kCmdPlantStatusV1 = 0x07;
static constexpr uint8_t kSlaveAddr7 = 0x55;
static constexpr uint32_t kBusHz = 100000;

struct TelemetryPacked {
  uint8_t magic{kMagic};       // lets receiver resync to frame start
  uint8_t cmd{kCmdTelemetryV1};
  uint8_t flags{};             // bit 0 = DHT reading is valid
  uint8_t rh_percent{};
  int16_t temp_c_x10{};        // temperature in 0.1 C
  uint16_t light_pct_x10{};    // light percentage in 0.1 %
} __attribute__((packed));     // exactly 8 bytes

struct PlantStatusPacked {
  uint8_t magic{kMagic};
  uint8_t cmd{kCmdPlantStatusV1};
  uint8_t flags{};             // valid / stale / contact / range / repeat
  uint8_t level{};             // 0 normal, 1 light, 2 medium, 3 heavy stress
  uint8_t nidx{};              // nitrogen index 0..100
  int8_t dz_x100{};            // relative impedance shift scaled by 100
  uint8_t reserved[2]{};
} __attribute__((packed));     // exactly 8 bytes
}

XIAO hub sketch: establish I²C and send frames

The XIAO hub is the I²C master. In setup() it opens the bus on D4/D5, then every 2.5 s it samples the local DHT/light input and writes one 8-byte telemetry frame to WROOM slave 0x55.

// code/final-project-upload/s3-upload/src/main.cpp
static constexpr uint8_t kI2cSda = 9;   // XIAO D4
static constexpr uint8_t kI2cScl = 8;   // XIAO D5
static constexpr uint32_t kSampleIntervalMs = 2500;

static void pushTelemetry(float humidity, float tempC, bool dhtOk, float lightPctFullscale) {
  I2cEnvLink::TelemetryPacked pkt{};
  pkt.magic = I2cEnvLink::kMagic;
  pkt.cmd = I2cEnvLink::kCmdTelemetryV1;
  pkt.flags = dhtOk ? I2cEnvLink::kFlagDhtOk : 0;
  if (dhtOk) {
    pkt.rh_percent = uint8_t(lroundf(constrain(humidity, 0.0f, 100.0f)));
    pkt.temp_c_x10 = int16_t(lroundf(constrain(tempC, -40.0f, 80.0f) * 10.0f));
  }
  pkt.light_pct_x10 = uint16_t(constrain(lightPctFullscale * 10.0f, 0.0f, 1000.0f));

  Wire.beginTransmission(I2cEnvLink::kSlaveAddr7);       // address 0x55
  Wire.write(reinterpret_cast<const uint8_t *>(&pkt), sizeof(pkt));
  Wire.endTransmission();                                // sends STOP, WROOM ACKs if present
}

void setup() {
  Wire.begin(kI2cSda, kI2cScl);                          // SDA D4/GPIO9, SCL D5/GPIO8
  Wire.setClock(I2cEnvLink::kBusHz);                     // 100 kHz standard-mode I2C
}

Pico UART bridge: parse ASCII, repack to I²C

The Pico side is line-oriented UART. It is easy to watch in Serial Monitor, but text is not ideal for the WROOM display node, so the XIAO bridge converts each STAT,... line into the compact PlantStatusPacked frame before forwarding it to 0x55.

// code/final-project-upload/s3-upload/src/pico_stat_bridge.h
#define S3_PICO_UART_RX_PIN 44  // XIAO D7 <- Pico TX GPIO1
#define S3_PICO_UART_TX_PIN 43  // XIAO D6, initialized but not required for this one-way link
#define S3_PICO_UART_BAUD 115200

// code/final-project-upload/s3-upload/src/pico_stat_bridge.cpp
void PicoStatBridge::begin(HardwareSerial &uart, int rxPin, int txPin, uint32_t baud) {
  uart_ = &uart;
  uart.begin(baud, SERIAL_8N1, rxPin, txPin);
}

bool PicoStatBridge::pushPlantToWroom(const I2cEnvLink::PlantStatusPacked &pkt) {
  Wire.beginTransmission(I2cEnvLink::kSlaveAddr7);       // WROOM I2C address 0x55
  Wire.write(reinterpret_cast<const uint8_t *>(&pkt), sizeof(pkt));
  return Wire.endTransmission() == 0;
}

WROOM sketch: receive at address 0x55 and decode

On the WROOM, HostLink uses Wire1 as an I²C slave. The receive interrupt only copies bytes into a ring buffer; the normal loop later checks magic, cmd, and value ranges. This keeps the interrupt short and makes bad frames visible in serial traces.

// code/final-project-upload/wroom-upload/src/board_pins.h
constexpr int HOST_LINK_SDA = 37;
constexpr int HOST_LINK_SCL = 36;

// code/final-project-upload/wroom-upload/src/env_i2c_slave.cpp
void envI2cSlaveBegin() {
  Wire1.setBufferSize(512);
  Wire1.begin(I2cEnvLink::kSlaveAddr7, Pins::HOST_LINK_SDA, Pins::HOST_LINK_SCL,
              I2cEnvLink::kBusHz);                       // slave 0x55 on GPIO37/36
  Wire1.onReceive(onReceiveStatic);
  Wire1.onRequest(onRequestStatic);
}

void envI2cSlavePump() {
  if (peekAt(0) != I2cEnvLink::kMagic) {
    ringDrop(1);                                         // resync if noise appears
    return;
  }
  const uint8_t cmd = peekAt(1);
  if (cmd == I2cEnvLink::kCmdPlantStatusV1) {
    I2cEnvLink::PlantStatusPacked pkt{};
    // copy 8 bytes, validate level <= 3 and nidx <= 100, then update the Plant page
  }
}

How the protocols work in this project

• UART: one sender and one receiver agree on baud rate, data bits, parity, and stop bits (115200 8N1 for Pico → XIAO, 9600 8N1 for soil/UNO). There is no shared clock, so both sides must use the same timing and share ground. TX always crosses to RX.
• I²C: one bus uses two wires, SDA and SCL. The master generates the clock and selects a slave by 7-bit address. In HostLink, XIAO writes to WROOM address 0x55; the touch controller is a separate WROOM-local I²C device at 0x38.
• SPI: the WROOM drives the ST7789 display with a clock plus MOSI/MISO and chip-select style control pins. SPI is fast and good for pixels, but it does not provide a shared bus address like I²C; the selected display is chosen by CS and command/data pins.

2. Learning

Group BLE and logic-analyzer I²C work reminded me that “communication” is two problems: link state, and the bytes on the wire. On my plant stack I spelled out the wired version. UART is asynchronous (baud and framing, no shared clock). I²C is synchronous on SDA/SCL with a 7-bit address. Pico and WROOM stay on separate boards so the NanoStat analog front-end does not share pins with TFT SPI; between them I only pass a small HostLink protocol.

On the Pico → XIAO hop, Pico prints STAT,ver=1,valid=…,level=…,nidx=…,dz10k=…,reason=… lines about every 2.5 s. XIAO’s PicoStatBridge parses those fields, packs an 8-byte binary frame, and keeps parsing out of ISR context, same idea as Week 10’s I²C slave ring buffer. On the XIAO → WROOM hop I reused HostLink from Week 10: TelemetryPacked (magic 0xA5, cmd 0x01) for environment, plus PlantStatusPacked (cmd 0x07) for level, N-index, and flags (valid / stale / contact / range / repeat).

I did not move Pico → XIAO to I²C. The NanoStat stack already speaks UART in its vendor workflow, and I did not want impedance samples on a shared bus next to DHT timing. Revision 2 of my carrier ( Week 6) routed NanoStat’s six programming pads, including two UART lines, toward the ESP32‑S3 hub so a future spin can solder this hop instead of rainbow wire.

3. Plan

1. Stage 1: UART only: Flash Pico phase1_uart_stat and XIAO pico_uart_echo; confirm STAT,… on Pico USB and matching lines on XIAO USB (D7 ← Pico TX).
2. Stage 2: I²C plant frame: XIAO pico_plant_hostlink pushes 0x07 to WROOM; WROOM shows Plant info bars without environment merge.
3. Stage 3: Full hub: S3上传程序 + PICO上传程序 + WROOM上传程序, with environment 0x01 and plant 0x07 in parallel.
4. Evidence: boot I²C scan lists 0x55; serial banners [PICO UART] / [PLANT TX] ok; TFT Environment + Plant info pages live; bench photos and USB serial captures in §4 (UART + I²C hops).

4. Build and wiring

Hop 1: UART (Pico → XIAO)

XIAO does not need Pico’s RX for this chain. Receive-only is enough. I power each board from its own USB during bring-up so a ground fault on one supply does not drag the other into brown-out; only signal + GND cross the harness.

Example line from Pico (documented in PICO上传程序/README.md):

STAT,ver=1,valid=1,level=2,nidx=58,zl=...,zm=...,zh=...,dz10k=0.240,reason=ok,ts=123456

XIAO maps that into HostLink PlantStatusPacked: level 0–3, nidx 0–100, dz_x100 from dz10k, and flags derived from valid and reason (ok, debounce, contact, range, repeat, …). If UART goes quiet for 10 s, the bridge clears kPlantFlagValid and sets kPlantFlagStale so the UI does not show frozen plant data.

Hop 2: I²C (XIAO → WROOM)

Unchanged from Week 10: XIAO D4/D5 (GPIO9/8) → WROOM GPIO37/36, 4.7 kΩ pull-ups to 3.3 V, slave 0x55, 100 kHz. Week 11 adds a second periodic write for plant status without changing the environment frame layout.

Firmware in the repo

Documented in code/week11-network/README.md (trimmed from Downloads PICO上传程序, S3上传程序, WROOM上传程序):

• Pico (UART out): week11-network/pico/ , LMP91000 measure, print STAT,… @ 115200.
• XIAO hub: week11-network/xiao/ , DHT/light → 0x01; pico_stat_bridge.cpp parses UART → 0x07.
• WROOM display: week11-network/wroom/ , env_i2c_slave.cpp + ST7789 Plant / Environment pages.
• Shared protocol: i2c_env_link.h (TelemetryPacked, PlantStatusPacked).

// XIAO — after parsing STAT,… (see pico_stat_bridge.cpp)
Wire.beginTransmission(0x55);
Wire.write((uint8_t*)&plantPkt, sizeof(plantPkt));  // cmd 0x07
Wire.endTransmission();

Bring-up checklist (from product README)

1. Pico USB: continuous STAT,… with valid field every line.
2. Disconnect electrodes: expect valid=0, reason=range or contact.
3. XIAO USB: [I2C SCAN] shows 0x55 when WROOM is powered.
4. With Pico running: [PICO UART] parse logs and periodic [PLANT TX] ok.
5. WROOM TFT: swipe to Plant info — N bar and level track Pico; Environment still updates from hub 0x01.

Serial monitor: both hops working

After the harness matched the tables above, I used two USB serial ports to close the loop: Pico USB for outgoing STAT,… lines and XIAO USB for bridge logs that show parsing and I²C writes. The screenshots are my check record for Fab’s “links work” requirement.

Problems I watch for

• Garbled UART: TX/RX swapped or missing GND. Parser never sees complete STAT,… lines; fix harness before touching I²C.
• No 0x55 on scan: same pull-up / power issues as Week 10. Plant bridge cannot display even if UART is perfect.
• Stale plant UI: intentional after 10 s UART silence. Check Pico reset or loose D7 wire, not WROOM graphics code first.
• Group lesson carry-over: noisy logic-analyzer traces still decode if address (0x55 / 0x3C on lab OLEDs) matches. I apply that patience to HostLink debug.

5. Conclusion

I used Cursor to code the three-role network stack in code/week11-network/ — Pico UART bridge, XIAO HostLink master, and WROOM TFT receiver. I still traced each bus with a logic analyzer and fixed flag packing in telemetry before the Environment and Plant pages showed trustworthy numbers.

Week 11 closes the loop I sketched on paper: Pico sends plant stats over UART, the Week 8 XIAO hub wraps HostLink frames at 0x55, and the WROOM TFT shows Environment and Plant info. Same three-role split as the final project, now with two buses I can re-test from saved firmware in code/week11-network/.

Design files: Week 6 electronics · Week 8 production. Prior serial / I²C: Week 9 inputs · Week 10 HostLink 0x01. Week 11 firmware: code/week11-network/. Full product trees: Downloads PICO上传程序, S3上传程序, WROOM上传程序. Group reflection: BLE + I²C captures below.