Caso práctico: Riego Zigbee con Arduino Uno, XBee y relés

Objetivo y caso de uso

Qué construirás: Una red de válvulas de riego Zigbee utilizando Arduino Uno y módulos XBee para controlar el riego de plantas de manera automática.

Para qué sirve

• Controlar válvulas de riego de forma remota mediante una red Zigbee.
• Monitorear la humedad del suelo y activar el riego automáticamente.
• Integrar sensores de temperatura y humedad para optimizar el riego.
• Implementar un sistema de alertas mediante MQTT para notificar el estado del riego.

Resultado esperado

• Reducción del consumo de agua en un 30% mediante riego controlado.
• Latencia de respuesta del sistema de riego menor a 2 segundos.
• Capacidad de controlar hasta 4 válvulas de riego simultáneamente.
• Mensajes de estado enviados cada 5 minutos a través de MQTT.

Público objetivo: Ingenieros en sistemas embebidos; Nivel: Avanzado

Arquitectura/flujo: Arduino Uno + XBee + relés + sensores de humedad + comunicación Zigbee.

Nivel: Avanzado

Prerrequisitos

Sistema operativo y utilidades

• Windows 11 23H2, Ubuntu 22.04.4 LTS o macOS 14.5 (Sonoma). Se muestra secuencia de comandos para Linux/macOS y equivalentes para Windows cuando aplique.
• Acceso administrador para instalar herramientas y drivers USB.
• Consola/terminal funcional (PowerShell en Windows, bash/zsh en Linux/macOS).

Toolchain exacta (versiones)

• Arduino CLI 0.35.3
• Núcleo AVR para Arduino Uno: arduino:avr@1.8.6
• avr-gcc 7.3.0-atmel3.6.1 (incluido en el core arduino:avr@1.8.6)
• avrdude 6.3-20190619 (incluido en el core arduino:avr@1.8.6)
• Librería estándar de Arduino incluida (SoftwareSerial 1.0)
• Digi XCTU 6.5.11 (configuración de módulos XBee)
• Python 3.10.12 + pyserial 3.5 (opcional, para pruebas de consola sobre el coordinador)

Notas:
– Se usa Arduino CLI (no el IDE GUI).
– Se compila y sube para FQBN arduino:avr:uno.

Materiales

• Dispositivo principal:
• Arduino Uno R3 + SparkFun XBee Shield + XBee S2C (Zigbee) + 4-Relay Board SRD-05VDC-SL-C.
• Cable USB A–B para Arduino Uno R3.
• Fuente de 5 V externa (2 A recomendados) para alimentar la placa de 4 relés cuando se accionen varias válvulas en simultáneo.
• Cableado Dupont macho–hembra.
• Carga de prueba: por ejemplo, leds con resistencias o una válvula de riego de baja tensión, pasando SIEMPRE por el relé (no conectar cargas de CA sin las protecciones y conocimientos adecuados).
• Herramientas para la red Zigbee:
• 1 módulo XBee S2C adicional + adaptador USB (Digi XBee USB Adapter o similar) para actuar como coordinador Zigbee durante las pruebas.
• Alternativamente, puede configurarse el único XBee como coordinador y trabajar en “red de un solo nodo”, pero para control remoto práctico se recomienda el coordinador USB.

Observación de coherencia:
– El único microcontrolador es el Arduino Uno R3, con su SparkFun XBee Shield y un XBee S2C (Zigbee), y la placa 4-Relay Board SRD-05VDC-SL-C. El coordinador se implementa con un XBee S2C en adaptador USB para pruebas y control, sin MCU adicional.

Preparación y conexión

Ajustes del SparkFun XBee Shield

• Ubique los selectores (switches) de ruta serie en el SparkFun XBee Shield:
• Coloque el selector en D2/D3 para usar SoftwareSerial en el Uno (evita interferir con el puerto serie hardware D0/D1).
• Verifique que el shield regula nivel a 3.3 V para el XBee (el shield de SparkFun ya incorpora regulación y adaptación).
• Inserte el XBee S2C (Zigbee) en el zócalo del shield, respetando la muesca de orientación.

Alimentación y relés (4-Relay Board SRD-05VDC-SL-C)

• Si su módulo de relés tiene jumper JD‑VCC:
• Retire el jumper para separar alimentación de opto/entrada (VCC) y bobinas (JD‑VCC).
• Conecte:
  • VCC del módulo de relés a 5 V del Arduino (alimenta la parte lógica/opto).
  • GND del módulo de relés a GND del Arduino (masa común).
  • JD‑VCC del módulo de relés a la fuente externa de 5 V.
  • GND de la fuente externa a GND del Arduino (masa común).
• Si su módulo no separa JD‑VCC, alimente desde 5 V del Arduino, pero limite cuántos relés activa a la vez y evalúe la corriente total (recomendado no activar los 4 a la vez sin fuente externa).

Asignación de pines

• Se trabajará con lógica activa en bajo (típico en módulos SRD-05VDC-SL-C con opto):
• Es decir, escribir LOW en la entrada del canal activa el relé; escribir HIGH lo desactiva.

Tabla de mapeo:

Contactos del relé hacia válvulas

• Cada canal tiene contactos COM, NO (normalmente abierto) y NC (normalmente cerrado).
• Para válvulas, típicamente use COM y NO, de forma que el relé “cierre” el circuito solo cuando se active el canal.
• NO conecte cargas de alta tensión si no domina los aislamientos, fusibles, supresores de transitorios y normativas. Para el caso didáctico, use cargas seguras de baja tensión.

Código completo (Arduino C++)

Objetivo del firmware:
– Recibir comandos Zigbee en modo transparente (AT) a 9600 bps desde el XBee.
– Protocolo de texto simple, línea terminada en LF:
– V,,ON|OFF[,duración_ms]
– S? (consulta de estado)
– Controlar 4 salidas con temporización no bloqueante (millis()).
– Confirmar con respuestas “OK …” o “ERR …”.
– Auto‑apagado por timeout si se especifica duración.

Explicación breve:
– Se usa SoftwareSerial en D2 (RX) y D3 (TX) por compatibilidad con el shield.
– Se definen estructuras para el estado de cada válvula, el tiempo restante y el tiempo de expiración.
– Se parsean líneas por caracteres con buffer circular, controlando overflow.
– La función setValve() aplica la lógica activa en LOW hacia el módulo de relés.

Código:

// zigbee-irrigation-valve-network.ino
// Toolchain: Arduino CLI 0.35.3, arduino:avr@1.8.6, avr-gcc 7.3.0-atmel3.6.1

#include <SoftwareSerial.h>

static const uint8_t XBEE_RX = 2; // XBee DOUT -> Arduino RX
static const uint8_t XBEE_TX = 3; // XBee DIN  -> Arduino TX
SoftwareSerial xbee(XBEE_RX, XBEE_TX); // RX, TX

// Mapeo de pines a canales de relé (activos en LOW)
static const uint8_t RELAY_PINS[4] = {4, 5, 6, 7};

struct Valve {
  bool on;                // estado actual
  unsigned long expires;  // timestamp de expiración en millis (0 = sin temporizador)
};

Valve valves[4];

static const unsigned long MAX_DURATION_MS = 6UL * 60UL * 60UL * 1000UL; // 6 horas
static const size_t RX_BUF_SIZE = 128;
char rxBuf[RX_BUF_SIZE];
size_t rxLen = 0;

// Helpers de E/S
void print(const char* s) { xbee.print(s); }
void println(const char* s) { xbee.println(s); }

void setValve(uint8_t idx, bool turnOn) {
  if (idx >= 4) return;
  valves[idx].on = turnOn;
  // Módulo activo en LOW
  digitalWrite(RELAY_PINS[idx], turnOn ? LOW : HIGH);
}

void allValvesOff() {
  for (uint8_t i = 0; i < 4; i++) {
    setValve(i, false);
    valves[i].expires = 0;
  }
}

void reportStatus() {
  // Formato: ST,<ch>,ON|OFF,<remaining_ms>
  for (uint8_t i = 0; i < 4; i++) {
    unsigned long remaining = 0;
    if (valves[i].on && valves[i].expires > 0) {
      unsigned long now = millis();
      remaining = (valves[i].expires > now) ? (valves[i].expires - now) : 0;
    }
    xbee.print("ST,");
    xbee.print(i + 1);
    xbee.print(",");
    xbee.print(valves[i].on ? "ON" : "OFF");
    xbee.print(",");
    xbee.println(remaining);
  }
}

bool parseUint(const char* s, unsigned long& out) {
  char* endp = nullptr;
  unsigned long v = strtoul(s, &endp, 10);
  if (endp == s || *endp != '\0') return false;
  out = v;
  return true;
}

void handleCommand(char* line) {
  // Trim CR/LF
  size_t n = strlen(line);
  while (n > 0 && (line[n-1] == '\r' || line[n-1] == '\n')) line[--n] = '\0';
  if (n == 0) return;

  // Comando S?
  if (strcmp(line, "S?") == 0) {
    reportStatus();
    return;
  }

  // Comando V,<ch>,ON|OFF[,duration_ms]
  // Tokenizar por comas
  // Nota: strtok modifica la cadena.
  char* saveptr = nullptr;
  char* tok = strtok_r(line, ",", &saveptr);
  if (!tok || strcmp(tok, "V") != 0) {
    println("ERR,UNKNOWN_CMD");
    return;
  }

  tok = strtok_r(nullptr, ",", &saveptr);
  if (!tok) { println("ERR,BAD_ARGS"); return; }
  unsigned long chNum;
  if (!parseUint(tok, chNum) || chNum < 1 || chNum > 4) {
    println("ERR,BAD_CH");
    return;
  }
  uint8_t idx = (uint8_t)(chNum - 1);

  tok = strtok_r(nullptr, ",", &saveptr);
  if (!tok) { println("ERR,BAD_ARGS"); return; }
  bool turnOn;
  if (strcmp(tok, "ON") == 0) turnOn = true;
  else if (strcmp(tok, "OFF") == 0) turnOn = false;
  else { println("ERR,BAD_STATE"); return; }

  // Opcional: duración en ms
  tok = strtok_r(nullptr, ",", &saveptr);
  unsigned long duration = 0;
  if (tok) {
    if (!parseUint(tok, duration)) {
      println("ERR,BAD_DURATION");
      return;
    }
    if (duration > MAX_DURATION_MS) duration = MAX_DURATION_MS;
  }

  // Aplicar
  setValve(idx, turnOn);
  if (turnOn && duration > 0) {
    valves[idx].expires = millis() + duration;
  } else {
    valves[idx].expires = 0;
  }

  xbee.print("OK,V,");
  xbee.print(chNum);
  xbee.print(",");
  xbee.print(turnOn ? "ON" : "OFF");
  xbee.print(",");
  xbee.println(duration);
}

void processInput() {
  while (xbee.available()) {
    char c = (char)xbee.read();
    if (c == '\n') {
      rxBuf[rxLen] = '\0';
      handleCommand(rxBuf);
      rxLen = 0;
    } else if (c != '\r') {
      if (rxLen < RX_BUF_SIZE - 1) {
        rxBuf[rxLen++] = c;
      } else {
        // Overflow: limpiar buffer
        rxLen = 0;
        println("ERR,OVERFLOW");
      }
    }
  }
}

void handleTimers() {
  unsigned long now = millis();
  for (uint8_t i = 0; i < 4; i++) {
    if (valves[i].on && valves[i].expires > 0 && now >= valves[i].expires) {
      setValve(i, false);
      valves[i].expires = 0;
      xbee.print("EVT,AUTO_OFF,");
      xbee.println(i + 1);
    }
  }
}

void setup() {
  // Configurar relés en estado seguro (apagados)
  for (uint8_t i = 0; i < 4; i++) {
    pinMode(RELAY_PINS[i], OUTPUT);
    digitalWrite(RELAY_PINS[i], HIGH); // inactivo (activo en LOW)
    valves[i].on = false;
    valves[i].expires = 0;
  }

  // Serial hardware a 115200 para debug local si se necesita
  Serial.begin(115200);
  // XBee a 9600 bps (BD=3 en XBee AT)
  xbee.begin(9600);
  delay(50);

  println("BOOT,zigbee-irrigation-valve-network");
  reportStatus();
}

void loop() {
  processInput();
  handleTimers();
}

Puntos clave:
– SoftwareSerial en D2/D3 para coexistir con la programación por USB.
– Lógica “activa en bajo” para el módulo SRD-05VDC-SL-C.
– Comandos de control y confirmaciones imprimen por el puerto del XBee (y se pueden monitorizar también por XCTU).

Compilación, flash y ejecución

Instalación de Arduino CLI 0.35.3

• Linux/macOS:
• Instale en $HOME/.local/bin (agregue esa carpeta a su PATH si no está).

# 1) Descargar e instalar Arduino CLI 0.35.3 en $HOME/.local/bin
curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | \
  sh -s -- -b $HOME/.local/bin 0.35.3

# 2) Inicializar configuración (genera ~/.arduino15/arduino-cli.yaml)
arduino-cli config init

# 3) Actualizar índices de cores y toolchains
arduino-cli core update-index

# 4) Instalar core AVR exacto
arduino-cli core install arduino:avr@1.8.6

# 5) Verificar versión
arduino-cli version
# Expected: arduino-cli Version: 0.35.3

• Windows 11:
• Descargue el binario 0.35.3 para Windows desde la página oficial y añada su carpeta al PATH.
• En PowerShell, ejecute los pasos 2–5 de arriba (reemplazando rutas según su instalación).

Estructura del proyecto

• Carpeta del sketch: zigbee-irrigation-valve-network
• Archivo: zigbee-irrigation-valve-network.ino (nombre de carpeta igual al nombre del .ino).
• Copie el código anterior en ese archivo.

Compilación y subida

1) Identifique el puerto serie del Arduino:
– Linux: /dev/ttyACM0 o /dev/ttyUSB0
– macOS: /dev/cu.usbmodemXXXX
– Windows: COM3, COM4, etc.

2) Compile y suba:

# Ajuste la ruta a su sketch
SKETCH_DIR="$HOME/proyectos/zigbee-irrigation-valve-network"

# 1) Compilar para Arduino Uno R3
arduino-cli compile --fqbn arduino:avr:uno "$SKETCH_DIR"

# 2) Lista de placas para identificar el puerto
arduino-cli board list

# 3) Subir (reemplazar por el puerto real)
PORT=/dev/ttyACM0
arduino-cli upload -p "$PORT" --fqbn arduino:avr:uno "$SKETCH_DIR"

# 4) Monitor serie de depuración (opcional, a 115200 bps)
arduino-cli monitor -p "$PORT" -c baudrate=115200

Notas:
– Mantenga el SparkFun XBee Shield configurado en D2/D3 para no interferir con D0/D1 durante la subida.
– Si el shield ofrece un selector “USB/XBee” o similar, déjelo en modo normal; no es necesario tocarlo para subir cuando se usa D2/D3.

Configuración Zigbee (XBee S2C) y validación paso a paso

La red de pruebas se compone de:
– Coordinador: XBee S2C en adaptador USB conectado al PC.
– Router/End Device: XBee S2C sobre el SparkFun XBee Shield del Arduino Uno R3.

Operaremos en modo AT (transparente) para simplificar; las tramas enviadas desde el coordinador llegarán como texto al Arduino y viceversa.

Configurar el Coordinador con Digi XCTU 6.5.11

1) Inserte el XBee S2C en el adaptador USB y conéctelo al PC.
2) Abra XCTU 6.5.11:
– Add radio module, seleccione el puerto COM/tty del adaptador y Test/Query.
3) Actualice/Instale firmware:
– Product family: XB24C (Zigbee S2C)
– Function set: Zigbee Coordinator AT
– Configure:
– ID (PAN ID): 0x7A69 (ejemplo; elija un PAN único)
– CE (Coordinator Enable): 1
– AP (API Enable): 0 (AT transparente)
– BD (Baud Rate): 3 (9600 bps)
– EE (Encryption Enable): 1 si desea cifrado (recomendado en producción); para demo puede 0
– KY (Link Key): establecer si EE=1
– CH (Channel): dejelo en 0 (auto) o fije uno si requiere control
– Write.

4) Anote la dirección 64-bit del coordinador:
– SH + SL (por ejemplo, 0013A200 41XXXXXX).

Configurar el Router (Arduino’s XBee) con XCTU 6.5.11

Puede configurarlo de dos maneras:

Opción A: Usando el mismo adaptador USB (recomendado)
– Extraiga el XBee del shield, insértelo en el adaptador USB, repita el proceso:
– Function set: Zigbee Router AT
– ID: igual al del coordinador (0x7A69)
– AP: 0 (AT)
– BD: 3 (9600 bps)
– JV (Channel Verification): 1
– CE: 0
– DH/DL: dirección 64-bit del coordinador (para que los datos salgan hacia él por defecto)
– Write.
– Anote la dirección 64-bit del router (SH+SL).

Opción B: Pasarela a través del Arduino Uno (avanzado)
– Coloque el selector del shield a D0/D1 (Hardware Serial).
– Mantenga el Arduino en reset (presionado) para liberar el puerto serie hacia el XBee.
– Conecte USB del Arduino al PC, abra XCTU en el puerto del Arduino.
– Configure igual que en la Opción A.
– Devuelva el selector del shield a D2/D3 al terminar.

Dirección de retorno (unicast)

Para que el coordinador reciba las respuestas del router:
– En el coordinador: configure DH/DL con la 64-bit del router (el del Arduino).
– Opcionalmente configure DH/DL del router hacia el coordinador (ya hecho en Opción A). Con ambas direcciones, el flujo AT será punto-a-punto.

Ensayo básico de enlace

• Conecte el shield (selector en D2/D3) al Arduino, alimente por USB.
• Abra XCTU en el puerto del coordinador, pestaña Console, a 9600 bps.
• Debería aparecer el banner del Arduino por el enlace Zigbee:
• BOOT,zigbee-irrigation-valve-network
• ST,1,OFF,0 … ST,4,OFF,0

Si no aparece automáticamente, envíe S? seguido de Enter:
– Respuesta esperada: 4 líneas ST,… con el estado OFF.

Validación de control de válvulas

Prueba 1: Encender válvula 1 durante 5 segundos
– Envíe: V,1,ON,5000
– Esperado:
– OK,V,1,ON,5000
– El relé 1 se activa (clic audible, LED de canal ON).
– A los ~5 segundos: EVT,AUTO_OFF,1 y el relé se desactiva.

Prueba 2: Encender manualmente y apagar
– Envíe: V,2,ON
– Esperado: OK,V,2,ON,0 y relé 2 activado.
– Envíe: S?
– Esperado: ST,2,ON, (sin temporizador).
– Envíe: V,2,OFF
– Esperado: OK,V,2,OFF,0 y relé 2 desactivado.

Prueba 3: Comando inválido
– Envíe: V,5,ON
– Esperado: ERR,BAD_CH

Prueba 4: Lectura periódica
– Envíe: S?
– Verifique coherencia con el estado de los LEDs de canal del módulo de relés.

Mediciones útiles:
– Tensión entre VCC y GND del módulo de relés: ~5.0 V.
– En reposo, entradas INx ~HIGH (~5 V); al activar, se fuerzan a LOW.
– Corriente total: depende del número de canales activos; cada SRD-05VDC puede requerir ~70–80 mA por bobina; use fuente externa si activa >2 canales.

Envío de comandos desde script (opcional, Python 3.10.12 + pyserial 3.5)

Este script abre el puerto serie del coordinador y envía comandos de prueba. Ajuste PORT según su sistema.

# test_zigbee_irrigation.py
# Python 3.10.12, pyserial 3.5
import sys
import time
import serial

PORT = sys.argv[1] if len(sys.argv) > 1 else "/dev/ttyUSB0"
BAUD = 9600

def send(ser, line):
    if not line.endswith("\n"):
        line += "\n"
    ser.write(line.encode("ascii"))
    ser.flush()
    print(f">>> {line.strip()}")

def read_all(ser, timeout=2.0):
    t0 = time.time()
    while time.time() - t0 < timeout:
        if ser.in_waiting:
            line = ser.readline().decode(errors="replace").strip()
            if line:
                print(f"<<< {line}")

def main():
    with serial.Serial(PORT, BAUD, timeout=0.2) as ser:
        time.sleep(0.5)
        send(ser, "S?")
        read_all(ser)
        send(ser, "V,1,ON,3000")
        read_all(ser, 4.0)
        send(ser, "V,2,ON")
        read_all(ser, 1.0)
        send(ser, "S?")
        read_all(ser, 1.0)
        send(ser, "V,2,OFF")
        read_all(ser, 1.0)

if __name__ == "__main__":
    main()

Ejecución:
– Linux/macOS:
– python3 -m pip install pyserial==3.5
– python3 test_zigbee_irrigation.py /dev/ttyUSB0
– Windows:
– py -3 -m pip install pyserial==3.5
– py -3 test_zigbee_irrigation.py COM5

Salida esperada en consola: líneas BOOT/ST/OK/EVT.

Troubleshooting (5–8 casos típicos)

1) No hay comunicación Zigbee (no llegan mensajes S?/BOOT en XCTU):
– Verifique que ambos XBee comparten PAN ID (ID) y canal (CH auto o fijo).
– Coordinar roles correctos: Coordinador AT (CE=1), Router AT (CE=0).
– Asegure BD=3 (9600 bps) en ambos módulos.
– Compruebe DH/DL: el coordinador debe tener DL/DH del router (para unicast); si no, use broadcast (DL=FFFF, DH=0000) para probar recepción.
– Distancia/antenas: acerque los módulos y retire obstáculos metálicos.

2) El Arduino no sube el sketch (error de avrdude):
– Asegúrese que el XBee Shield está en D2/D3 (no en D0/D1).
– Revise el puerto correcto con arduino-cli board list.
– Pulse reset del Arduino justo antes de subir si fuera necesario.
– Cierre cualquier monitor serie activo (XCTU, arduino-cli monitor).

3) LEDs de relé encendidos al arrancar o lógica invertida:
– El módulo es activo en LOW; el código ya inicializa HIGH (apagado).
– Si su módulo fuera activo en HIGH (raro), invierta la lógica en setValve().

4) Reinicios extraños o resets del Arduino al activar varios relés:
– Caída de tensión por consumo de bobinas; alimente bobinas con fuente externa (JD‑VCC), manteniendo GND común.
– Cableado GND flojo o demasiado delgado: refuércelo.

5) Mensajes ERR,OVERFLOW o comandos truncados:
– Envíe líneas terminadas en LF y no exceda 127 caracteres.
– Evite ráfagas sin pausas; añada 10–20 ms entre líneas o use el script Python.

6) No se pueden configurar los XBee por XCTU a través del Arduino:
– Debe rutear D0/D1 al XBee (colocar selector del shield a D0/D1).
– Mantenga el Uno en reset (RST a GND) durante la configuración para liberar el USB-serial.
– Alternativa robusta: use adaptador USB para XBee y configure fuera del Arduino.

7) Relé no conmuta la carga:
– Revise conexiones COM/NO y la polaridad de la fuente de la carga.
– Verifique que el canal se activa (LED del módulo y clic).
– Compruebe que su carga está dentro de las especificaciones del relé.

8) Seguridad y protección de cargas inductivas:
– Para válvulas/solenoides, coloque diodo flyback adecuado si usa relés DC externos o driver MOSFET (los módulos suelen traerlo para la bobina del relé, no para la carga).
– Para cargas AC, use varistores/snubbers y protecciones; ajustar calibre de conductores.

Mejoras y variantes

• API Mode 2 (escape characters):

• Configure AP=2 en XBee y utilice tramas 0x10 (Transmit Request) y 0x90 (Receive Packet) para direccionamiento múltiple, ACK y reintentos. En Arduino, puede migrar a una librería XBee o implementar un parser básico de API frames. Ventaja: mejor control de rutas y fiabilidad en redes con varios nodos.

• Seguridad:

• Active EE=1 y defina KY (Link Key). Fije NK si gestiona claves de red. Cambie el PAN ID por uno no trivial.

• Escalabilidad:

• Añada más nodos remotos (cada uno: Arduino Uno R3 + SparkFun XBee Shield + XBee S2C + 4-Relay Board SRD-05VDC-SL-C).

• Establezca el coordinador como “gateway” conectado a un backend (por ejemplo, un servicio Python que traduzca órdenes desde MQTT/HTTP a Zigbee).

• Feedback de sensores:

• Añada sensores de humedad de suelo (analógicos) en A0–A3, y amplíe el protocolo:

  • R? para leer la humedad.
  • Reportes periódicos: REP,H,,.

• Planificación y watchdog:

• Almacene un plan de riegos en EEPROM con ventanas temporales.

• Añada un watchdog por software para garantizar que cualquier válvula se apaga por seguridad ante fallos de comunicación.

• Modo “fail-safe”:

• Configure timeout global (por ejemplo, 30 minutos) incluso si no se especifica duración, para evitar dejar una válvula abierta indefinidamente.

• Telemetría y logs:

• Añada CRC simple a las líneas (ej., sufijo ;CRC16) para robustez en entornos ruidosos.
• Marque cada mensaje con timestamp relativo.

Checklist de verificación

• [ ] Arduino CLI 0.35.3 instalado y en PATH.
• [ ] Core arduino:avr@1.8.6 instalado sin errores.
• [ ] Proyecto zigbee-irrigation-valve-network compilado para arduino:avr:uno.
• [ ] SparkFun XBee Shield con selector en D2/D3.
• [ ] XBee del Arduino configurado como Router AT, BD=9600, PAN ID correcto.
• [ ] XBee del coordinador configurado como Coordinator AT, BD=9600, PAN ID correcto.
• [ ] DH/DL establecidos para comunicación unicast entre coordinador y router.
• [ ] Placa de relés correctamente alimentada:
• [ ] JD‑VCC separado y 5 V externa si se activan varios canales.
• [ ] GND común entre fuente externa, Arduino y módulo de relés.
• [ ] Comando S? devuelve estados de 4 canales.
• [ ] Comando V,1,ON,5000 activa y luego desactiva automáticamente el canal 1.
• [ ] LED de canal y clic del relé coinciden con la respuesta OK/EVT.
• [ ] Fuentes y cables no se calientan; tensión estable durante conmutaciones.
• [ ] Pruebas de error (canal inválido, estado inválido) devuelven ERR,***.
• [ ] Documentados PAN ID y direcciones 64-bit para futuras ampliaciones.

Con estos pasos, la red “zigbee-irrigation-valve-network” queda operativa con el dispositivo especificado: Arduino Uno R3 + SparkFun XBee Shield + XBee S2C (Zigbee) + 4-Relay Board SRD-05VDC-SL-C, utilizando la toolchain exacta indicada y manteniendo coherencia en materiales, conexión, código y comandos. La arquitectura permite extender el sistema a múltiples nodos de riego y robustecer la operación con seguridad, telemetría y modos avanzados de Zigbee.