Thread Router (FTD) - ESP32-C6 - Documentación del Sistema

Descripción General

Thread_R es una implementación de Thread Router (Full Thread Device) para ESP32-C6 que actúa como extensor de red mesh Thread y relay para datos de sensores. El router recibe datos CoAP de dispositivos Thread Sleepy End Devices (SEDs) y los retransmite al Thread Border Router, el cual los envía a AWS IoT Core vía MQTT.

Este proyecto forma parte de una arquitectura IoT de tres capas donde el router proporciona extensión de red, distribución de carga y mayor cobertura física para dispositivos sensores de bajo consumo. El router opera como relay transparente, preservando el payload binario original sin modificaciones.

Arquitectura del Sistema

El sistema consta de tres componentes principales:

Thread Sleepy End Devices (SEDs): Nodos sensores alimentados por batería que envían datos vía CoAP
Thread Router FTD (ESTE PROYECTO): Extensor de red alimentado por fuente continua que relay datos
Thread Border Router: Gateway a internet que actúa como Thread Leader y publica a AWS IoT Core

┌──────────────────────────────────────────────────────────────┐
│                    RED MESH THREAD                            │
│                                                               │
│  ┌─────────┐         ┌──────────┐         ┌───────────────┐ │
│  │  SED 1  │────────>│ Router 1 │────────>│  Thread BR    │ │
│  │  SED 2  │────────>│  (FTD)   │         │  (Leader)     │ │
│  └─────────┘         │ ESTE     │         │               │ │
│                      │ PROYECTO │         │ ┌───────────┐ │ │
│  ┌─────────┐         └──────────┘         │ │CoAP Server│ │ │
│  │  SED 3  │─────────────┘                │ │/sensordata│ │ │
│  └─────────┘                               │ └─────┬─────┘ │ │
│                                            │       │       │ │
│                                            │   ┌───▼────┐  │ │
│                                            │   │  MQTT  │  │ │
│                                            └───┴────┬───┴──┘ │
└─────────────────────────────────────────────────────┼────────┘
                                                      │
                                               ┌──────▼──────┐
                                               │  AWS IoT    │
                                               │  Core       │
                                               └─────────────┘

Flujo de Datos:

[SED] --CoAP POST--> [Router] --CoAP POST--> [Thread BR] --MQTT--> [AWS IoT]
       /sensordata              /sensordata              thread/sensores
       52 bytes                 52 bytes                 JSON

Requisitos de Hardware

ESP32-C6: Microcontrolador con radio IEEE 802.15.4 nativo
Fuente de alimentación: USB-C o 5V externo (siempre encendido, consumo ~50mA continuo)
LED RGB WS2812B en GPIO 8 (opcional, para indicador de estado)
Thread Border Router: En dispositivo separado (ESP32-H2/C6 con conexión Ethernet/WiFi)
Thread SEDs: Uno o más dispositivos sensores que envían datos al router

Componentes Clave

1. Aplicación Principal (esp_ot_router.c)

El punto de entrada de la aplicación inicializa el stack OpenThread y lanza las tareas principales del sistema.

Configuración Principal:

Inicialización de almacenamiento NVS para persistencia de credenciales
Creación de event loop y network interface para OpenThread
Configuración de tareas FreeRTOS con prioridades específicas

Características:

Stack OpenThread con soporte nativo para radio IEEE 802.15.4 (ESP32-C6)
CLI de OpenThread habilitado para configuración y debugging
Auto-provisioning con dataset hardcodeado (opcional)
LED state indicator para visualización de estado del router

Flujo de operación:

app_main() inicializa NVS flash, event loop y network interface
Crea tarea principal ot_task_worker (prioridad 5, stack 10KB)
ot_task_worker() inicializa OpenThread y CLI
Lanza coap_relay_task (prioridad 6, stack 8KB)
Lanza router_monitor_task (prioridad 3, stack 4KB)
Entra en loop principal de OpenThread

Archivos:

main/esp_ot_router.c - Punto de entrada y gestión de tareas
main/esp_ot_config.h - Configuración de plataforma OpenThread
main/thread_dataset_config.h - Dataset hardcodeado para auto-provisioning

2. CoAP Relay (coap_relay.c)

COMPONENTE CRÍTICO: Implementa la funcionalidad dual de servidor CoAP (para SEDs) y cliente CoAP (hacia Border Router).

Configuración Principal:

URI Path CoAP: "sensordata" (línea 25) - DEBE coincidir con Thread BR y SEDs
Puerto CoAP: 5683 (estándar)
Content-Format: 42 (application/octet-stream)

Características:

Como Servidor CoAP (recibe de SEDs):

Escucha en puerto 5683
Recurso registrado: /sensordata
Recibe sensor_data_t (52 bytes binarios) de SEDs hijos
Envía ACK de confirmación al SED

Como Cliente CoAP (envía a Border Router):

Auto-descubre dirección IPv6 del BR (RLOC del Thread leader)
Construye mensaje POST confirmable (CON)
URI: coap://[BR_IPv6]/sensordata
Content-Format: 42 (octet-stream)
Payload: sensor_data_t sin modificar (relay transparente)
Maneja retransmisiones automáticas

Flujo de operación:

Espera a que router alcance rol "Router" (no solo "Child")
Inicia servidor CoAP y registra recurso /sensordata
Al recibir POST de SED:
- Parsea payload binario (52 bytes)
- Registra datos recibidos (device_id, temperatura)
- Envía ACK al SED
Auto-detecta dirección IPv6 del Border Router (Thread leader)
Construye mensaje CoAP POST hacia BR
Envía datos al BR y espera confirmación
Registra estadísticas de relay (éxito/fallo)

Archivos:

main/coap_relay.c - Servidor y cliente CoAP
main/coap_relay.h - Headers y definiciones

Funciones principales:

coap_relay_task() (línea 237): Loop principal del relay
coap_request_handler() (línea 169): Maneja CoAP entrante de SEDs
relay_to_border_router() (línea 89): Reenvía datos al BR
get_border_router_address() (línea 38): Auto-detecta dirección BR

3. Monitor de Router (router_monitor.c)

Tarea opcional de monitoreo que registra la salud del router cada 30 segundos.

Configuración Principal:

Intervalo de monitoreo: 30 segundos (ajustable)
Prioridad de tarea: 3 (baja, no crítica)
Stack size: 4096 bytes

Características:

Monitoreo de estado de red (rol Thread, canal, PAN ID)
Visualización de tabla de hijos (SEDs conectados)
Reporte de uso de memoria (heap disponible)
Logs automáticos para troubleshooting

Flujo de operación:

Espera inicialización de OpenThread
Cada 30 segundos consulta estado del router
Registra rol Thread actual
Enumera dispositivos hijos en child table
Reporta memoria disponible
Se suspende hasta el siguiente intervalo

Archivos:

main/router_monitor.c - Implementación del monitor
main/router_monitor.h - Headers y configuración

4. Estructura de Datos de Sensor (sensor_data.h)

COMPONENTE CRÍTICO: Define la estructura compartida de datos entre todos los dispositivos del sistema.

Configuración Principal:

typedef struct {
    char device_id[16];        // Identificador único del dispositivo
    float temperature;         // Temperatura en Celsius
    float pressure;            // Presión en hPa
    float humidity;            // Humedad (0-100%)
    float gas_concentration;   // Resistencia de gas en Ohms
} sensor_data_t;  // Total: 52 bytes

Características:

Estructura binaria de tamaño fijo (52 bytes)
Compatible con transmisión CoAP directa
DEBE coincidir exactamente en Thread BR, Router y SEDs
Sin serialización JSON (optimización de ancho de banda)

Detalles de memoria:

device_id[16]: 16 bytes (identificador ASCII)
temperature: 4 bytes (IEEE 754 float)
pressure: 4 bytes (IEEE 754 float)
humidity: 4 bytes (IEEE 754 float)
gas_concentration: 4 bytes (IEEE 754 float)
Total: 16 + 4×4 = 52 bytes

Archivos:

main/sensor_data.h - Definición de estructura compartida

⚠️ ADVERTENCIA: Modificar esta estructura rompe compatibilidad con Thread BR y SEDs. Cualquier cambio debe replicarse en los tres proyectos.

Configuración del Proyecto

Variables Críticas en sdkconfig.defaults

# Tipo de dispositivo: DEBE ser FTD (Full Thread Device)
CONFIG_OPENTHREAD_FTD=y
# CONFIG_OPENTHREAD_MTD is not set

# Power Management: DEBE estar deshabilitado (always-on)
# CONFIG_PM_ENABLE is not set

# Auto-start habilitado (requiere dataset pre-configurado)
CONFIG_OPENTHREAD_AUTO_START=y

# LED State Indicator (opcional)
CONFIG_OPENTHREAD_STATE_INDICATOR_ENABLE=y
CONFIG_OPENTHREAD_STATE_INDICATOR_GPIO=8

# CoAP habilitado para relay
CONFIG_OPENTHREAD_COAP=y
CONFIG_OPENTHREAD_COAP_BLOCK=y

# Logging
CONFIG_LOG_DEFAULT_LEVEL_INFO=y
CONFIG_LOG_MAXIMUM_LEVEL_VERBOSE=y

Dataset de Red Thread

El router soporta auto-provisioning con dataset hardcodeado en main/thread_dataset_config.h.

Obtener dataset del Border Router:

# En el Thread Border Router:
> dataset active -x
0e080000000000010000000300001035060004001fffe00208dead00beef00cafe...

Configuración en código:

Dataset hex: main/thread_dataset_config.h línea 11
Habilitar auto-provision: THREAD_AUTO_PROVISION_ENABLED línea 8

Formato del dataset:

#define THREAD_AUTO_PROVISION_ENABLED   1

#define THREAD_DATASET_HEX  \
    "0e080000000000010000000300001035060004001fffe0..." // Dataset completo del BR

⚠️ ADVERTENCIA: El dataset contiene credenciales de red Thread. Si el Border Router cambia su dataset, el router no podrá conectarse. Solución: ejecutar factoryreset en el router, actualizar THREAD_DATASET_HEX y reflashear.

Particiones Flash (partitions.csv)

# Name,     Type, SubType, Offset,  Size,     Flags
nvs,        data, nvs,     0x9000,  0x6000,   # 24KB - Almacenamiento no volátil
phy_init,   data, phy,     0xf000,  0x1000,   # 4KB - Datos de calibración PHY
factory,    app,  factory, 0x10000, 0x140000, # 1.28MB - Firmware principal

Propósito:

nvs (24KB): Almacena credenciales Thread, configuración OpenThread, y datos persistentes
phy_init (4KB): Calibración del radio IEEE 802.15.4
factory (1.28MB): Firmware del router (binario compilado)

Comandos de Compilación y Ejecución

Setup del Entorno

# Instalar ESP-IDF (si no está instalado)
# Seguir: https://docs.espressif.com/projects/esp-idf/en/latest/esp32c6/get-started/

# Activar entorno ESP-IDF
. $IDF_PATH/export.sh

Compilación

# Limpiar build previo (recomendado al cambiar configuración)
idf.py fullclean

# Configurar target (DEBE ser ESP32-C6)
idf.py set-target esp32c6

# Compilar proyecto
idf.py build

# Verificar tamaño del binario
idf.py size

Flasheo y Monitoreo

# Flash completo (bootloader + particiones + firmware)
idf.py -p /dev/ttyACM0 flash

# Monitorear salida serial
idf.py -p /dev/ttyACM0 monitor

# Flash y monitor en un solo comando
idf.py -p /dev/ttyACM0 flash monitor

# Borrar flash completamente (incluye NVS)
idf.py -p /dev/ttyACM0 erase-flash

# Salir del monitor: Ctrl + ]

Configuración Manual (CLI OpenThread)

Si THREAD_AUTO_PROVISION_ENABLED=0, provisionar manualmente:

# Resetear a factory defaults
> factoryreset

# Configurar dataset del Border Router
> dataset set active 0e080000000000010000000300001035...

# Activar interfaz de red
> ifconfig up

# Iniciar protocolo Thread
> thread start

# Verificar rol (debe ser "router" o "child" inicialmente)
> state

# Ver direcciones IPv6 asignadas
> ipaddr

# Ver dispositivos hijos conectados
> child table

Comandos de Debugging

# Ver información del parent (Border Router)
> parent

# Ver tabla de vecinos
> neighbor table

# Ver canal de radio
> channel

# Ver PAN ID
> panid

# Ver contadores de protocolo
> counters

# Ping a dirección IPv6
> ping <ipv6_addr>

# Ver dataset activo
> dataset active

# Ver dataset en formato hexadecimal
> dataset active -x

Dependencias Externas

Componentes ESP-IDF

El proyecto utiliza los siguientes componentes del ESP Component Registry:

espressif/esp_ot_cli_extension     - Extensiones CLI (TCP, UDP, Iperf)
espressif/led_strip                - Control de LED RGB WS2812B
espressif/iperf                    - Testing de rendimiento de red
esp-idf-lib/i2cdev                 - Abstracción de dispositivos I2C (futuro)
esp-idf-lib/bme680                 - Driver sensor BME680 (futuro)

Actualizar con:

idf.py reconfigure

Los componentes se descargan automáticamente durante el build según main/idf_component.yml.

Componentes del Sistema

Componentes internos de ESP-IDF requeridos:

openthread                         - Stack OpenThread
nvs_flash                          - Almacenamiento no volátil
esp_event                          - Event loop del sistema
esp_netif                          - Network interface abstraction
lwip                               - Stack TCP/IP con soporte IPv6
mbedtls                            - Seguridad TLS/DTLS para Thread
driver                             - Drivers de hardware (UART, GPIO, etc.)

Estos se incluyen automáticamente con ESP-IDF.

Estructura de Archivos Clave

Thread_R/
├── main/
│   ├── esp_ot_router.c              # Aplicación principal y gestión de tareas
│   ├── esp_ot_config.h              # Configuración de plataforma OpenThread
│   ├── coap_relay.c                 # Servidor CoAP + cliente relay (CRÍTICO)
│   ├── coap_relay.h                 # Headers del relay CoAP
│   ├── router_monitor.c             # Monitoreo de red (opcional)
│   ├── router_monitor.h             # Headers de monitoreo
│   ├── sensor_data.h                # Estructura de datos compartida (CRÍTICO)
│   ├── thread_dataset_config.h      # Configuración de dataset hardcodeado
│   ├── idf_component.yml            # Dependencias de componentes
│   └── CMakeLists.txt               # Configuración de build del main
├── sdkconfig.defaults               # Configuración FTD y OpenThread
├── partitions.csv                   # Layout de particiones flash
├── CMakeLists.txt                   # Build del proyecto
├── README.md                        # Este documento
├── CLAUDE.md                        # Instrucciones para Claude Code
├── INFO_CAMBIOS.md                  # Arquitectura del sistema completo
├── ROUTER_README.md                 # README específico del router
├── ROUTER_DEPLOYMENT.md             # Guía de deployment
└── SED_VS_ROUTER.md                 # Comparación SED vs Router

Troubleshooting

Problemas de Compilación

Problema	Solución
`Component not found` durante build	Ejecutar `idf.py reconfigure` para descargar dependencias de `idf_component.yml`
Error `esp_openthread/openthread/instance.h not found`	Asegurar ESP-IDF v5.4+ instalado, verificar `idf.py --version`
`partition table does not fit in configured flash size`	Verificar `partitions.csv`, reducir tamaño de factory app o aumentar flash size en menuconfig
`CONFIG_OPENTHREAD_FTD not defined`	Ejecutar `idf.py fullclean`, verificar `sdkconfig.defaults` está presente

Problemas de Conectividad Thread

Problema	Solución
Router en estado "Disabled" después de boot	Ejecutar manualmente `ifconfig up` y `thread start` en CLI. Verificar `CONFIG_OPENTHREAD_AUTO_START=y`
Router no alcanza rol "router", se queda en "child"	Esperar 30-60 segundos para promoción automática. Verificar que la red no tiene demasiados routers (máx 8-10)
Router no se conecta a red Thread	Verificar dataset hexadecimal es completo y correcto. Comparar con `dataset active -x` del BR. Ejecutar `factoryreset` y reprovisionar
LED no enciende	Verificar `CONFIG_OPENTHREAD_STATE_INDICATOR_GPIO=8` en sdkconfig. Verificar hardware tiene LED RGB en GPIO 8

Problemas de CoAP Relay

Problema	Solución
Router no recibe CoAP de SEDs	Verificar logs muestran `CoAP server listening on /sensordata`. Verificar `child table` muestra SEDs. Verificar URI path es exactamente `"sensordata"` en línea 25
Router no puede relay a Border Router	Verificar BR es Thread leader (`state` en BR). Verificar auto-detección de dirección BR en logs. Hardcodear dirección si falla auto-detección
Border Router no recibe datos del router	Verificar servidor CoAP del BR está corriendo. Verificar URI path `/sensordata` coincide en router y BR. Usar `tcpdump` en BR para verificar llegada de paquetes
Relay falla con error de timeout	Verificar conectividad con `ping` desde router a BR. Verificar BR responde a mensajes CoAP confirmables (CON)

Problemas de Hardware

Problema	Solución
No aparece puerto serial `/dev/ttyACM0`	En Linux: verificar permisos con `sudo usermod -a -G dialout $USER`, logout/login. Verificar cable USB soporta datos
Reset continuo en boot	Verificar fuente de alimentación proporciona suficiente corriente (mínimo 500mA). Verificar conexión estable de USB-C
Alto consumo de energía	Normal para FTD router (~50-100mA continuo). Requiere alimentación continua, no recomendado para batería

Notas de Desarrollo

Primera Configuración

Obtener dataset del Border Router en el BR (vía CLI o logs):
- Conectar al BR y ejecutar dataset active -x
- Copiar string hexadecimal completo
Configurar dataset en router en main/thread_dataset_config.h:
- Pegar string en THREAD_DATASET_HEX (línea 11)
- Verificar THREAD_AUTO_PROVISION_ENABLED=1 (línea 8)

Compilar y flashear:

idf.py fullclean
idf.py set-target esp32c6
idf.py build
idf.py -p /dev/ttyACM0 flash monitor

Primer Arranque

Cuando el router arranca por primera vez con auto-provisioning habilitado:

El sistema detecta NVS vacío y provisionará automáticamente:

I (290) ot_router: ========================================
I (290) ot_router: OpenThread Router (FTD) Starting...
I (290) ot_router: Target: ESP32-C6
I (290) ot_router: ========================================
I (350) ot_router: No existing dataset found in NVS
I (350) ot_router: Provisioning network with hardcoded dataset...
I (380) ot_router: Thread protocol started with new dataset

Router se unirá a la red Thread automáticamente (toma 10-30 segundos)
Verificar con state que alcanza rol "router" (puede tardar hasta 60 segundos)

Boots posteriores (dataset en NVS):

I (290) ot_router: Network already provisioned (dataset found in NVS)
I (290) ot_router: Starting Thread with existing dataset...
I (390) ot_router: Thread protocol started with existing dataset

Monitoreo y Debugging

Logs importantes a monitorear:

ot_router - Inicialización y estado del router
COAP_RELAY - Recepción de datos de SEDs y relay a BR
ROUTER_MONITOR - Estado de red y tabla de hijos

Comandos CLI útiles:

> state                    # Ver rol Thread actual
> parent                   # Ver información del parent (BR)
> child table              # Ver SEDs conectados
> ipaddr                   # Ver direcciones IPv6
> ipaddr mleid             # Ver Mesh-Local EID
> ping <ipv6>              # Test de conectividad
> counters                 # Ver estadísticas de protocolo
> factoryreset             # Reset completo (borra NVS)

Verificación de relay operacional:

Logs esperados durante relay exitoso:

I (15000) COAP_RELAY: Thread network operational as Router - Starting CoAP server
I (15010) COAP_RELAY: CoAP server listening on /sensordata
I (30000) COAP_RELAY: Received from child - Device: sensor_A1, T: 23.4°C
I (30050) COAP_RELAY: Relayed to BR - Device: sensor_A1

Modificación de Componentes

Cambiar URI Path CoAP

Archivo: main/coap_relay.c, línea 25

#define COAP_URI_PATH           "sensordata"  // Cambiar aquí

⚠️ DEBE actualizarse también en:

Thread BR: thread_coap_task.c línea 104
SEDs: coap_client.c línea 24

Cambiar Estructura sensor_data_t

Archivo: main/sensor_data.h

Modificar campos según necesidad
Recalcular tamaño total
⚠️ DEBE actualizarse también en Thread BR y SEDs
Actualizar logs en coap_relay.c que parsean los datos

Ajustar Tabla de Hijos

Archivo: sdkconfig (via menuconfig)

Component config → OpenThread → Maximum number of children

Valor por defecto: 32
Máximo: 511
Recomendado: 10-20 para rendimiento óptimo

Cambiar Prioridad de Tareas

Archivo: main/esp_ot_router.c

// CoAP relay task (línea 115)
xTaskCreate(coap_relay_task, "coap_relay", 8192, NULL, 6, NULL);  // Prioridad 6

// Router monitor task (línea 118)
xTaskCreate(router_monitor_task, "router_mon", 4096, NULL, 3, NULL);  // Prioridad 3

Mayor prioridad = más tiempo de CPU (rango 0-24, 24 es máxima en FreeRTOS)

Métricas de Rendimiento

Latencia End-to-End:

SED → Router: ~50-100ms (transmisión CoAP)
Router → BR: ~50-100ms (relay CoAP)
BR → AWS: ~100-200ms (publicación MQTT)
Total: ~200-400ms (depende de condiciones de red)

Capacidad de Red:

Máximo hijos teórico: 511 (límite Thread spec)
Máximo hijos práctico: 32 (configurable, valor por defecto)
Recomendado: 10-20 SEDs por router (rendimiento óptimo)
Throughput relay: ~10 mensajes/segundo (52 bytes cada uno)

Consumo de Energía:

Idle (sin tráfico): ~35-45mA @ 5V
Activo (routing datos): ~50-70mA @ 5V
Promedio continuo: ~50mA @ 5V
Consumo diario: ~6 Wh/día (250mW continuo)

⚠️ NO recomendado para operación con batería - El router DEBE estar siempre encendido para mantener la topología de red.

Uso de Memoria:

Flash: ~350KB (firmware compilado)
RAM: ~50KB (heap disponible después de inicialización)
NVS: ~8KB (dataset Thread y credenciales)

Rendimiento de Red:

Distancia máxima SED-Router: ~30-50m (línea de vista, interior)
Throughput máximo: ~250kbps (limitado por Thread, 802.15.4)
Latencia de promoción a Router: 30-60 segundos después de join

Escalado de Red

Red con Múltiples Routers

Para redes grandes, desplegar múltiples routers:

                    [Border Router]
                          │
        ┌─────────┬───────┼───────┬─────────┐
        │         │       │       │         │
       R1        R2      R3      R4        R5
        │         │       │       │         │
     10 SEDs   15 SEDs  12 SEDs  18 SEDs  8 SEDs

Recomendaciones de escalado:

1 BR + 5 Routers = ~50-100 SEDs
1 BR + 10 Routers = ~100-200 SEDs
Óptimo total: <100 dispositivos por red Thread
Para >200 dispositivos, considerar múltiples redes Thread

Consideraciones:

Cada router reduce la carga de hijos del BR
Distribución geográfica mejora cobertura
Routers pueden comunicarse entre sí (mesh)
Latencia aumenta con saltos (hop count)

Compatibilidad del Sistema

Configuraciones Críticas Compartidas

DEBEN coincidir en Thread BR, Router y SEDs:

Configuración	Valor	Ubicación
URI Path CoAP	`"sensordata"`	Router `coap_relay.c:25`, BR `thread_coap_task.c:104`, SED `coap_client.c:24`
Puerto CoAP	5683	Todos los componentes
sensor_data_t	52 bytes	Router `sensor_data.h`, BR `shared_data.h`, SED `sensor_data.h`
Content-Format	42 (octet-stream)	Router `coap_relay.c:27,115`
Thread Dataset	Mismo hex string	Todos los dispositivos

⚠️ ADVERTENCIA: Romper cualquiera de estas coincidencias causará falla del sistema. Verificar antes de desplegar.

LED State Indicator

El LED RGB WS2812B en GPIO 8 muestra el estado del router visualmente:

Color	Estado Thread	Descripción
🔵 Azul	ROUTER	Router operacional, puede aceptar hijos SEDs
🟢 Verde	CHILD	Conectado como hijo del BR, esperando promoción
🔴 Rojo	LEADER	Líder de red (no esperado, BR debería ser leader)
⚪ Gris	DETACHED	Tiene credenciales, buscando red Thread
⚫ Apagado	DISABLED	Thread no iniciado o error de hardware

Configuración de colores (GPIO 8, WS2812B):

ROUTER: RGB(0, 0, 40)
CHILD: RGB(0, 40, 0)
LEADER: RGB(40, 0, 0)
DETACHED: RGB(20, 20, 20)

Modificar colores en: Component config → OpenThread → State indicator LED

Consideraciones de Seguridad

Seguridad de Red Thread:

Thread usa autenticación ECJPAKE para commissioning (habilitado por defecto)
Cifrado AES-128 para todos los datos de red (automático)
Thread network key almacenado en NVS (partición encriptable)
Dataset contiene credenciales sensibles - proteger string hexadecimal

Consideraciones de Despliegue:

Routers tienen mayor privilegio que SEDs (pueden rutear tráfico de terceros)
Compromiso físico de router permite observación de tráfico de red
Acceso al puerto serial permite extraer credenciales Thread
Recomendado: Carcasa anti-manipulación para routers en campo
Monitorear logs para detección de anomalías de red

Hardening Recomendado:

Deshabilitar CLI OpenThread en producción (menuconfig)
Habilitar Secure Boot y Flash Encryption (ESP-IDF)
Cambiar Thread network key periódicamente
Limitar acceso físico a dispositivos
Implementar actualización OTA segura

Persistencia de Configuración

El dataset Thread y configuración de red se almacenan en partición NVS:

Datos persistentes:

Thread network key y credenciales
PAN ID, Extended PAN ID, canal
Mesh-Local Prefix
Direcciones IPv6 asignadas
Lista de child table (no persistente, se reconstruye)

Comportamiento:

✅ Sobreviven resets de hardware (botón reset)
✅ Sobreviven power cycles (apagar/encender)
✅ Sobreviven reflash de firmware (si no se ejecuta erase-flash)
❌ Se eliminan con comando CLI factoryreset
❌ Se eliminan con idf.py erase-flash

Auto-inicio:

CONFIG_OPENTHREAD_AUTO_START=y reinicia Thread automáticamente después de boot
No requiere comandos CLI manuales una vez provisionado

Créditos

Proyecto base:

ESP-IDF OpenThread examples - Espressif Systems
OpenThread Stack - Google Nest / Thread Group
ESP Thread Border Router examples - Espressif Systems

Desarrollado por:

Roberto Negrete Román y Jorge Ramírez Cárdenas
Como parte de proyecto Artemis para la materia Practicum II de la Universidad Anáhuac México

Referencias Técnicas

Documentación Oficial

Repositorios Relacionados

ESP-IDF: https://github.com/espressif/esp-idf
OpenThread: https://github.com/openthread/openthread
ESP Thread Border Router: https://github.com/espressif/esp-thread-br

Contacto y Soporte

Favor de contactarme creando un issue o mandandome un correo al correo roberto-ne-ro@hotmail.com

Name		Name	Last commit message	Last commit date
Latest commit History 1 Commit
main		main
managed_components		managed_components
.clangd		.clangd
.gitignore		.gitignore
CMakeLists.txt		CMakeLists.txt
README.md		README.md
dependencies.lock		dependencies.lock
partitions.csv		partitions.csv
sdkconfig		sdkconfig
sdkconfig.ci.disable_cli		sdkconfig.ci.disable_cli
sdkconfig.ci.ext_coex		sdkconfig.ci.ext_coex
sdkconfig.defaults		sdkconfig.defaults
sdkconfig.old		sdkconfig.old

Folders and files

Latest commit

History

Repository files navigation

Thread Router (FTD) - ESP32-C6 - Documentación del Sistema

Descripción General

Arquitectura del Sistema

Requisitos de Hardware

Componentes Clave

1. Aplicación Principal (esp_ot_router.c)

2. CoAP Relay (coap_relay.c)

3. Monitor de Router (router_monitor.c)

4. Estructura de Datos de Sensor (sensor_data.h)

Configuración del Proyecto

Variables Críticas en sdkconfig.defaults

Dataset de Red Thread

Particiones Flash (partitions.csv)

Comandos de Compilación y Ejecución

Setup del Entorno

Compilación

Flasheo y Monitoreo

Configuración Manual (CLI OpenThread)

Comandos de Debugging

Dependencias Externas

Componentes ESP-IDF

Componentes del Sistema

Estructura de Archivos Clave

Troubleshooting

Problemas de Compilación

Problemas de Conectividad Thread

Problemas de CoAP Relay

Problemas de Hardware

Notas de Desarrollo

Primera Configuración

Primer Arranque

Monitoreo y Debugging

Modificación de Componentes

Cambiar URI Path CoAP

Cambiar Estructura sensor_data_t

Ajustar Tabla de Hijos

Cambiar Prioridad de Tareas

Métricas de Rendimiento

Escalado de Red

Red con Múltiples Routers

Compatibilidad del Sistema

Configuraciones Críticas Compartidas

LED State Indicator

Consideraciones de Seguridad

Persistencia de Configuración

Créditos

Referencias Técnicas

Documentación Oficial

Repositorios Relacionados

Contacto y Soporte

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages