Mosaico: Clase 15 - 18/11/2025 | IFTS 14 2025 TS SEIC Protocolo de IoT | DGHPEF

Página Principal

Clase 15 - 18/11/2025
- Cuestionario: Fundamentos de Internet de las Cosas (IoT)
  
  Abrió: martes, 24 de junio de 2025, 18:00
- Aquí tienes un ordenamiento lógico, temático y comentado de los recursos que compartiste, clasificados según su relevancia para el armado de una estación meteorológica inteligente basada en ESP32, con subdivisiones claras por temas clave del proyecto.
  
  🧠 1. Proyectos de referencia completos
  
  Estos son ideales como base conceptual y técnica. Incluyen sensores, conexiones, programación y visualización.
  
  🔹 The DIY Life - IoT Weather Station Using ESP32
  
  🔧 Relevancia alta. Proyecto integral con sensores de temperatura, humedad, presión y lluvia. Usa ESP32 y MQTT. Tiene diseño de carcasa 3D e interfaz web.
  
  Ideal como estructura base de todo el proyecto, incluye montaje, electrónica y software.
  
  🔹 Instructables - DIY Weather Station With ESP32
  
  🔧 Relevancia alta. Similar al anterior, incluye sensores comunes y uso de BME280. Enfocado a principiantes.
  
  Útil para complementar la estación con sensores económicos y código Arduino claro.
  
  🌬️ 2. Sensores y medición del viento
  
  Aquí se agrupan los recursos para integrar anemómetro y veleta, claves para una estación más avanzada.
  
  🔹 GitHub - Anemómetro IoT con MQTT y KNX
  
  🔧 Relevancia alta. Incluye diseño funcional de anemómetro, código fuente y uso de MQTT.
  
  Muy valioso para adaptar o integrar directamente en el sistema IoT.
  
  🔹 Thingiverse - Wind Sensor V2.0 (Veleta y Anemómetro)
  
  🧩 Relevancia alta. Modelo imprimible para sensores de viento.
  
  Compatible con sensores de efecto Hall y ópticos. Fácil integración con ESP32.
  
  🔹 Cults3D - Girouette capteur de vent
  
  🧩 Relevancia media-alta. Modelo de veleta. Compatible con proyectos personalizados.
  
  Puede adaptarse para usar con sensores Hall o interruptores magnéticos.
  
  ☀️ 3. Monitoreo solar y energía
  
  Complemento útil si se desea hacer la estación autosuficiente con energía solar.
  
  🔹 Instructables - DIY Solar PV Monitoring System V2.0
  
  🔋 Relevancia media. Orientado al monitoreo de un sistema solar, pero incluye sensores de corriente, tensión, y visualización.
  
  Útil si se alimenta la estación con paneles solares y se quiere monitorear su rendimiento.
  
  🌡️ 4. Referencias de datos y validación
  
  Para comparar o validar tus mediciones reales con datos públicos.
  
  🔹 Weather Underground - Clima en Buenos Aires
  
  📊 Relevancia media. Provee registros históricos diarios del clima en Argentina.
  
  Ideal para comparar y validar datos de tu estación.
  
  🧾 5. Documentación compartida
  
  Puede contener materiales de clase, esquemas o planificación complementaria.
  
  🔹 Google Docs - Documento compartido
  
  📄 Relevancia pendiente de análisis. Se requiere revisar el contenido exacto del documento.
  
  Puede contener material didáctico o técnico útil para planificar clases o informes del proyecto.
  
  🧱 6. Diseños 3D complementarios
  
  Modelos 3D diversos para imprimir componentes como cajas, soportes, carcasas.
  
  🔸 Thingiverse - Sensor Station with Stand (Thing: 3398980)
  
  📦 Relevancia media. Estación modular, adaptable para sensores múltiples.
  
  🔸 Thingiverse - Anemómetro impreso (Thing: 1416009)
  
  🌬️ Relevancia media. Anemómetro básico impreso. Alternativa simple al anterior.
  
  🔸 Thingiverse - Modular Weather Station (Thing: 3546977)
  
  🧩 Relevancia media. Estación modular compacta, buena base física.
  
  🔸 Thingiverse - Weather Station + Electronics Box (Thing: 4216504)
  
  🧰 Relevancia media. Diseño integral de caja para electrónica de estación meteorológica.
  
  🔸 Thingiverse - Solar Weather Station Case (Thing: 4355150)
  
  ☀️ Relevancia media. Diseño orientado a uso solar. Buena ventilación y soporte para sensores.
  
  🔸 Thingiverse - Weather Station Shield (Thing: 7020450)
  
  ⚙️ Relevancia baja-media. Carcasa para protección de sensores, adaptable.
  
  🔸 TurboSquid - Weather Station Model 3D
  
  💰 Relevancia baja. Modelo profesional 3D no imprimible, decorativo.
  
  Solo útil para renders o presentaciones, no para construcción real.
  
  🧭 Orden sugerido para desarrollo del proyecto
  
  Definición de objetivos funcionales
  
  Usar [The DIY Life] como base funcional.
  
  Complementar con sensores de viento del GitHub y Thingiverse.
  
  Diseño físico y mecánico
  
  Seleccionar modelos de impresión 3D: carcasa + sensores de viento.
  
  Código y conexión
  
  Unificar códigos de ESP32 para lectura de sensores y envío por MQTT.
  
  Monitoreo y validación
  
  Validar datos con fuentes como Weather Underground.
  
  Optimización y expansión
  
  Incluir energía solar.
  
  Monitor solar PV si se desea autonomía.
  
  Documentación final
  
  Usar el Google Docs o generar uno nuevo para armar el informe del proyecto.
- Una descripción detallada y completa de cómo configurar una conexión WiFi en un dispositivo ESP32 para establecer comunicación MQTT con un broker, incluyendo los pasos esenciales, código de ejemplo y consideraciones importantes.
  ### **1. Componentes Necesarios**
  - **ESP32**: Placa de desarrollo con conectividad WiFi integrada.
  - **Broker MQTT**: Servidor MQTT (ej: Mosquitto, CloudMQTT, HiveMQ, AWS IoT, etc.).
  - **Red WiFi**: Acceso a una red inalámbrica con SSID y contraseña.
  - **Bibliotecas**:
  - `WiFi.h` (para conexión WiFi, incluida en el core de Arduino-ESP32).
  - `PubSubClient.h` (cliente MQTT para publicar/suscribirse a temas).
  ---
  ### **2. Configuración de la Conexión WiFi**
  El ESP32 se conecta a una red WiFi local para acceder a Internet y comunicarse con el broker MQTT.
  #### **Pasos:**
  1. **Incluir bibliotecas**:
```cpp
#include <WiFi.h>
#include <PubSubClient.h>
2. **Definir credenciales WiFi**:
```cpp
  const char* ssid = "Nombre_de_tu_WiFi";
  const char* password = "Contraseña_de_tu_WiFi";
```
3. **Configurar cliente WiFi y MQTT**:
```cpp
  WiFiClient espClient;
  PubSubClient client(espClient);
```
4. **Función para conectar WiFi**:
```cpp
  void setupWiFi() {
  delay(10);
  Serial.println("Conectando a WiFi...");
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.println("Dirección IP: " + WiFi.localIP());
  }
  ---
  ### **3. Configuración del Cliente MQTT**
  El broker MQTT actúa como intermediario para enviar/recibir mensajes.
  
  #### **Pasos:**
  1. **Definir detalles del broker**:
```cpp
const char* mqtt_server = "broker.example.com"; // IP o dominio del broker
const int mqtt_port = 1883; // Puerto MQTT (1883 para no encriptado, 8883 para SSL)
const char* mqtt_user = "usuario"; // Opcional, si el broker requiere autenticación
const char* mqtt_password = "contraseña"; // Opcional
```
  2. **Función para reconectar al broker**:
```cpp
void reconnectMQTT() {
while (!client.connected()) {
Serial.print("Intentando conexión MQTT...");
String clientId = "ESP32-" + String(random(0xffff), HEX);

if (client.connect(clientId.c_str(), mqtt_user, mqtt_password)) {
Serial.println("Conectado al broker");
client.subscribe("topic/subscribe"); // Suscribirse a un tema
} else {
Serial.print("Error, rc=");
Serial.print(client.state());
Serial.println(" Reintentando en 5 segundos...");
delay(5000);
}
}
}
```
  3. **Callback para mensajes recibidos**:
```cpp
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Mensaje recibido en [" + String(topic) + "]: ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
}
```
  ---
  ### **4. Configuración Inicial (`setup`) y Bucle Principal (`loop`)**
```cpp
void setup() {
Serial.begin(115200);
setupWiFi();
client.setServer(mqtt_server, mqtt_port);
client.setCallback(callback); // Solo necesario si el ESP32 será suscriptor
}

void loop() {
if (!client.connected()) {
reconnectMQTT();
}
client.loop(); // Mantener la conexión activa

// Ejemplo: Publicar un mensaje cada 5 segundos
static unsigned long lastMsg = 0;
if (millis() - lastMsg > 5000) {
lastMsg = millis();
client.publish("topic/publish", "Hola desde ESP32");
}
}
```
  ---
  ### **5. Consideraciones Importantes**
  1. **Seguridad**:
  - Usa **MQTT sobre SSL/TLS** (puerto 8883) para conexiones seguras.
  - Evita hardcodear credenciales. Considera usar **EEPROM** o **entradas por serial**.
  2. **Estabilidad**:
  - Implementa manejo de errores (ej: reconexión automática si WiFi/MQTT falla).
  - Usa **"Last Will and Testament" (LWT)** para notificar si el dispositivo se desconecta abruptamente.
  3. **Broker Público vs. Local**:
  - Para pruebas: Usa brokers gratuitos como `test.mosquitto.org`.
  - Para producción: Configura un broker privado (ej: Mosquitto en Raspberry Pi).
  4. **Optimización**:
  - Reduce la frecuencia de publicaciones para ahorrar ancho de banda.
  - Usa QoS adecuado (0, 1, o 2) según la criticidad de los mensajes.
  ---
  ### **6. Ejemplo Completo**
```cpp
#include <WiFi.h>
#include <PubSubClient.h>
const char* ssid = "tu_SSID";
const char* password = "tu_CONTRASEÑA";
const char* mqtt_server = "broker.example.com";
WiFiClient espClient;
PubSubClient client(espClient);

void setupWiFi() {
delay(10);
Serial.println("Conectando a WiFi...");
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}

Serial.println("\nWiFi conectado");
Serial.println("IP: " + WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Mensaje en [" + String(topic) + "]: ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
}

void reconnectMQTT() {
while (!client.connected()) {
Serial.print("Intentando conexión MQTT...");
String clientId = "ESP32-" + String(random(0xffff), HEX);

if (client.connect(clientId.c_str())) {
Serial.println("Conectado");
client.subscribe("topic/subscribe");
} else {
Serial.print("Error, rc=");
Serial.print(client.state());
Serial.println(" Reintentando en 5 segundos...");
delay(5000);
}
}
}

void setup() {
Serial.begin(115200);
setupWiFi();
client.setServer(mqtt_server, 1883);
client.setCallback(callback);
}

void loop() {
if (!client.connected()) {
reconnectMQTT();
}
client.loop();

static unsigned long lastMsg = 0;
if (millis() - lastMsg > 5000) {
lastMsg = millis();
client.publish("topic/publish", "Hola desde ESP32");
}
}
```
  ---
  ### **7. Pruebas y Depuración**
  - **Verifica la conexión WiFi**: Usa `WiFi.status()`.
  - **Prueba el broker MQTT**: Usa clientes como **MQTT Explorer** o **MQTT.fx**.
  - **Monitor serial**: Revisa mensajes de error (ej: `client.state()` devuelve códigos como `-2` para timeout).
  
  ---
  Con esta configuración, tu ESP32 podrá comunicarse de manera robusta con un broker MQTT, enviando y recibiendo datos. ¡Espero que te sea útil!A continuación, te proporciono una descripción detallada y completa de cómo configurar una conexión WiFi en un dispositivo ESP32 para establecer comunicación MQTT con un broker, incluyendo los pasos esenciales, código de ejemplo y consideraciones importantes.
  ---
  ### **1. Componentes Necesarios**
  - **ESP32**: Placa de desarrollo con conectividad WiFi integrada.
  - **Broker MQTT**: Servidor MQTT (ej: Mosquitto, CloudMQTT, HiveMQ, AWS IoT, etc.).
  - **Red WiFi**: Acceso a una red inalámbrica con SSID y contraseña.
  - **Bibliotecas**:
  - `WiFi.h` (para conexión WiFi, incluida en el core de Arduino-ESP32).
  - `PubSubClient.h` (cliente MQTT para publicar/suscribirse a temas).
  ---
  ### **2. Configuración de la Conexión WiFi**
  El ESP32 se conecta a una red WiFi local para acceder a Internet y comunicarse con el broker MQTT.
  #### **Pasos:**
  1. **Incluir bibliotecas**:
```cpp
#include <WiFi.h>
#include <PubSubClient.h>
```
  2. **Definir credenciales WiFi**:
```cpp
const char* ssid = "Nombre_de_tu_WiFi";
const char* password = "Contraseña_de_tu_WiFi";
```
  3. **Configurar cliente WiFi y MQTT**:
```cpp
WiFiClient espClient;
PubSubClient client(espClient);
```
  4. **Función para conectar WiFi**:
```cpp
void setupWiFi() {
delay(10);
Serial.println("Conectando a WiFi...");
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}

Serial.println("");
Serial.println("WiFi conectado");
Serial.println("Dirección IP: " + WiFi.localIP());
}
```
  ---
  ### **3. Configuración del Cliente MQTT**
  El broker MQTT actúa como intermediario para enviar/recibir mensajes.
  
  #### **Pasos:**
  1. **Definir detalles del broker**:
```cpp
const char* mqtt_server = "broker.example.com"; // IP o dominio del broker
const int mqtt_port = 1883; // Puerto MQTT (1883 para no encriptado, 8883 para SSL)
const char* mqtt_user = "usuario"; // Opcional, si el broker requiere autenticación
const char* mqtt_password = "contraseña"; // Opcional
```
  2. **Función para reconectar al broker**:
```cpp
void reconnectMQTT() {
while (!client.connected()) {
Serial.print("Intentando conexión MQTT...");
String clientId = "ESP32-" + String(random(0xffff), HEX);
if (client.connect(clientId.c_str(), mqtt_user, mqtt_password)) {
Serial.println("Conectado al broker");
client.subscribe("topic/subscribe"); // Suscribirse a un tema
} else {
Serial.print("Error, rc=");
Serial.print(client.state());
Serial.println(" Reintentando en 5 segundos...");
delay(5000);
}
}
}
3. **Callback para mensajes recibidos**:
```cpp
  void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido en [" + String(topic) + "]: ");
  for (int i = 0; i < length; i++) {
  Serial.print((char)payload[i]);
  }
  Serial.println();
  }
  ---
  ### **4. Configuración Inicial (`setup`) y Bucle Principal (`loop`)**
```cpp
void setup() {
Serial.begin(115200);
setupWiFi();
client.setServer(mqtt_server, mqtt_port);
client.setCallback(callback); // Solo necesario si el ESP32 será suscriptor
}

void loop() {
if (!client.connected()) {
reconnectMQTT();
}
client.loop(); // Mantener la conexión activa
// Ejemplo: Publicar un mensaje cada 5 segundos
static unsigned long lastMsg = 0;
if (millis() - lastMsg > 5000) {
lastMsg = millis();
client.publish("topic/publish", "Hola desde ESP32");
}
}
---
### **5. Consideraciones Importantes**
1. **Seguridad**:
- Usa **MQTT sobre SSL/TLS** (puerto 8883) para conexiones seguras.
- Evita hardcodear credenciales. Considera usar **EEPROM** o **entradas por serial**.
2. **Estabilidad**:
- Implementa manejo de errores (ej: reconexión automática si WiFi/MQTT falla).
- Usa **"Last Will and Testament" (LWT)** para notificar si el dispositivo se desconecta abruptamente.
3. **Broker Público vs. Local**:
- Para pruebas: Usa brokers gratuitos como `test.mosquitto.org`.
- Para producción: Configura un broker privado (ej: Mosquitto en Raspberry Pi).
4. **Optimización**:
- Reduce la frecuencia de publicaciones para ahorrar ancho de banda.
- Usa QoS adecuado (0, 1, o 2) según la criticidad de los mensajes.
---
### **6. Ejemplo Completo**
```cpp
  #include <WiFi.h>
  #include <PubSubClient.h>
  const char* ssid = "tu_SSID";
  const char* password = "tu_CONTRASEÑA";
  const char* mqtt_server = "broker.example.com";
  WiFiClient espClient;
  PubSubClient client(espClient);
  
  void setupWiFi() {
  delay(10);
  Serial.println("Conectando a WiFi...");
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
  }
  
  Serial.println("\nWiFi conectado");
  Serial.println("IP: " + WiFi.localIP());
  }
  
  void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje en [" + String(topic) + "]: ");
  for (int i = 0; i < length; i++) {
  Serial.print((char)payload[i]);
  }
  Serial.println();
  }
  void reconnectMQTT() {
  while (!client.connected()) {
  Serial.print("Intentando conexión MQTT...");
  String clientId = "ESP32-" + String(random(0xffff), HEX);
  
  if (client.connect(clientId.c_str())) {
  Serial.println("Conectado");
  client.subscribe("topic/subscribe");
  } else {
  Serial.print("Error, rc=");
  Serial.print(client.state());
  Serial.println(" Reintentando en 5 segundos...");
  delay(5000);
  }
  }
  }
  void setup() {
  Serial.begin(115200);
  setupWiFi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  }
  
  void loop() {
  if (!client.connected()) {
  reconnectMQTT();
  }
  client.loop();
  static unsigned long lastMsg = 0;
  if (millis() - lastMsg > 5000) {
  lastMsg = millis();
  client.publish("topic/publish", "Hola desde ESP32");
  }
  }
  ---
  ### **7. Pruebas y Depuración**
  - **Verifica la conexión WiFi**: Usa `WiFi.status()`.
  - **Prueba el broker MQTT**: Usa clientes como **MQTT Explorer** o **MQTT.fx**.
  - **Monitor serial**: Revisa mensajes de error (ej: `client.state()` devuelve códigos como `-2` para timeout).
  ---
  Con esta configuración, tu ESP32 podrá comunicarse de manera robusta con un broker MQTT, enviando y recibiendo datos.
- ### **Descripción Detallada de una Trama WiFi a Nivel de Capa de Enlace (Capa 2 - MAC)**
  La comunicación WiFi se basa en el estándar **IEEE 802.11**, que define el funcionamiento de la **capa de enlace de datos** (Data Link Layer) en redes inalámbricas. Esta capa se divide en dos subcapas:
  1. **LLC (Logical Link Control)**: Gestiona el control de flujo y errores (común para Ethernet y WiFi).
  2. **MAC (Medium Access Control)**: Administra el acceso al medio inalámbrico y la formación de tramas.
  
  ---
  
  ## **1. Estructura de una Trama WiFi (802.11)**
  Una trama WiFi está compuesta por **campos fijos y variables**, dependiendo del tipo de trama (control, gestión o datos). La estructura general es:
  
  | **Campo** | **Tamaño (bytes)** | **Descripción** |
  |------------------------|--------------------|----------------|
  | **Frame Control** | 2 | Contiene subcampos que definen el tipo de trama y flags. |
  | **Duration/ID** | 2 | Indica duración de la transmisión o asociación (en µs). |
  | **Address 1** | 6 | Dirección MAC del receptor (Destino). |
  | **Address 2** | 6 | Dirección MAC del transmisor (Origen). |
  | **Address 3** | 6 | Dirección MAC del punto de acceso (BSSID) o filtro. |
  | **Sequence Control** | 2 | Número de secuencia y fragmentación. |
  | **Address 4** | 6 | Opcional (usado en redes ad-hoc o modo bridge). |
  | **Frame Body (Payload)** | 0–2312 | Datos encapsulados (ej: paquete IP). |
  | **FCS (Frame Check Sequence)** | 4 | Checksum CRC-32 para detección de errores. |
  
  ---
  
  ## **2. Análisis Detallado de los Campos**
  
  ### **A. Frame Control (2 bytes)**
  Es el campo más crítico. Su estructura es:
  
  | **Subcampo** | **Bits** | **Descripción** |
  |--------------------|----------|----------------|
  | **Protocol Version** | 2 | Versión 802.11 (normalmente `00`). |
  | **Type** | 2 | Tipo de trama: <br> - `00`: Gestión (Beacon, Probe Request). <br> - `01`: Control (RTS, CTS, ACK). <br> - `10`: Datos (transporta información útil). |
  | **Subtype** | 4 | Subtipo (ej: `1000` = Beacon, `0101` = ACK). |
  | **To DS** | 1 | `1` si la trama va a un Distribution System (ej: router). |
  | **From DS** | 1 | `1` si la trama viene de un Distribution System. |
  | **More Fragments** | 1 | `1` si hay más fragmentos. |
  | **Retry** | 1 | `1` si es una retransmisión. |
  | **Power Management** | 1 | Indica si el dispositivo entra en modo bajo consumo. |
  | **More Data** | 1 | `1` si el AP tiene más datos para el cliente. |
  | **Protected Frame** | 1 | `1` si la trama está cifrada (WEP, WPA2, etc.). |
  | **Order** | 1 | `1` si se requiere entrega ordenada. |
  
  ---
  
  ### **B. Direcciones MAC**
  - **Address 1**: MAC del dispositivo que debe procesar la trama (destino final o próximo salto).
  - **Address 2**: MAC del transmisor (origen).
  - **Address 3**: Depende del contexto:
  - En infraestructura (con AP): BSSID (MAC del AP).
  - En redes ad-hoc: filtro para control de tramas.
  - **Address 4**: Solo en modo **WDS** (Wireless Distribution System).
  
  ---
  
  ### **C. Sequence Control (2 bytes)**
  - **Fragment Number (4 bits)**: Número de fragmento (si el paquete está dividido).
  - **Sequence Number (12 bits)**: Identificador único para reensamblar paquetes.
  
  ---
  
  ### **D. Frame Body (Payload)**
  - Transporta datos de capas superiores (ej: paquetes IP, TCP, etc.).
  - Tamaño variable (hasta **2312 bytes** en 802.11n/ac).
  - Si la trama es de **gestión** (ej: Beacon), aquí van parámetros como SSID, canales soportados, etc.
  
  ---
  
  ### **E. FCS (Frame Check Sequence)**
  - **CRC-32** para detectar corrupción de datos.
  - Si el checksum falla, la trama se descarta.
  
  ---
  
  ## **3. Tipos de Tramas WiFi**
  ### **A. Tramas de Gestión (Type = 00)**
  - **Beacon**: Anuncia la presencia de una red (contiene SSID, canal, etc.).
  - **Probe Request/Response**: Usado por dispositivos para descubrir redes.
  - **Authentication/Deauthentication**: Gestiona la autenticación WiFi.
  - **Association Request/Response**: Solicita unirse a una red.
  
  ### **B. Tramas de Control (Type = 01)**
  - **RTS (Request to Send)**: Solicita acceso al medio.
  - **CTS (Clear to Send)**: Confirma que el medio está libre.
  - **ACK**: Confirma recepción de una trama.
  
  ### **C. Tramas de Datos (Type = 10)**
  - Transportan información útil (ej: paquetes HTTP, MQTT, etc.).
  - Pueden estar cifradas (WPA2, WPA3).
  
  ---
  
  ## **4. Ejemplo de Trama WiFi (Beacon Frame)**
  Un **Beacon** típico (capturado con Wireshark) tiene esta estructura:
```
Frame Control: 0x8000 (Type: Management, Subtype: Beacon)
Duration: 1024 µs
Address 1: FF:FF:FF:FF:FF:FF (Broadcast)
Address 2: 12:34:56:78:9A:BC (MAC del AP)
Address 3: 12:34:56:78:9A:BC (BSSID)
Sequence Control: 0x1234
Frame Body:
- Timestamp: 0xABCDEF12
- Beacon Interval: 100 ms
- Capabilities: 0x1234 (WPA2, ESS)
- SSID: "MiRedWiFi"
FCS: 0x1A2B3C4D
```
  
  ---
  
  ## **5. Consideraciones Clave**
  1. **CSMA/CA**: WiFi usa **Carrier Sense Multiple Access with Collision Avoidance** (no como Ethernet que usa CSMA/CD).
  2. **Modos de Operación**:
  - **Infraestructura**: Dispositivos se conectan a un AP.
  - **Ad-Hoc**: Dispositivos se comunican directamente.
  3. **Seguridad**: Las tramas pueden estar cifradas con **WEP, WPA2, o WPA3**.
  4. **Tasa de Transmisión**: Varía según 802.11a/b/g/n/ac/ax (WiFi 6).
  
  ---
  
  ### **Conclusión**
  La trama WiFi a nivel de capa de enlace es fundamental para garantizar una comunicación fiable en entornos inalámbricos. Su estructura varía según el tipo de trama, pero siempre incluye campos críticos como direcciones MAC, control de secuencia y detección de errores (FCS). Esta descripción es esencial para debuggear redes WiFi o desarrollar aplicaciones en dispositivos como el ESP32.
- ### **Comunicación WiFi entre Dispositivos en la Misma LAN (Red Local)**
  Cuando dos o más dispositivos están conectados a la misma red WiFi (LAN), pueden comunicarse directamente sin necesidad de pasar por Internet. Esto es útil para aplicaciones como:
  - Control de dispositivos IoT (ESP32, Raspberry Pi).
  - Compartir archivos entre computadoras.
  - Juegos en red local.
  - Sistemas de automatización del hogar (ej: Home Assistant).
  ---
  ## **1. Requisitos para la Comunicación en la Misma LAN**
  1. **Misma Red WiFi**: Todos los dispositivos deben estar conectados al mismo SSID.
  2. **Direcciones IP en el Mismo Rango**:
  - Ejemplo: Si el router asigna IPs como `192.168.1.x`, todos los dispositivos deben estar en ese rango (ej: `192.168.1.10`, `192.168.1.20`).
  3. **Sin Bloqueos de Firewall**: El firewall del router o de los dispositivos no debe bloquear los puertos usados.
  4. **Protocolos Compatibles**: Ambos dispositivos deben soportar el mismo protocolo (TCP, UDP, HTTP, MQTT, etc.).
  ---
  ## **2. Protocolos Comunes para Comunicación en LAN**
  ### **A. TCP/IP (Conexiones Confiables)**
  - **Uso**: Ideal para transferencia de datos que requiere confirmación (ej: enviar comandos a un ESP32).
  - **Ejemplo en ESP32 (Servidor TCP)**:
```cpp
#include <WiFi.h>
const char* ssid = "TuRedWiFi";
const char* password = "TuContraseña";
WiFiServer server(1234); // Servidor TCP en puerto 1234

void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) delay(500);
Serial.println("IP: " + WiFi.localIP());
server.begin();
}

void loop() {
WiFiClient client = server.available();
if (client) {
Serial.println("Cliente conectado");
while (client.connected()) {
if (client.available()) {
String data = client.readStringUntil('\n');
Serial.println("Dato recibido: " + data);
client.println("OK"); // Respuesta al cliente
}
}
client.stop();
}
}
```
  ### **B. UDP (Conexiones Rápidas sin Confirmación)**
  - **Uso**: Ideal para streaming de audio/video o mensajes broadcast.
  - **Ejemplo en ESP32 (Cliente UDP)**:
```cpp
#include <WiFi.h>
#include <WiFiUdp.h>
WiFiUDP udp;
const char* targetIP = "192.168.1.100"; // IP del dispositivo destino
void setup() {
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) delay(500);
udp.begin(1234); // Puerto local
}

void loop() {
udp.beginPacket(targetIP, 1234); // Enviar a puerto 1234
udp.print("Hola desde ESP32");
udp.endPacket();
delay(1000);
}
```
  ### **C. MQTT (Para IoT)**
  - **Uso**: Comunicación publish/subscribe (ej: sensor → servidor local).
  - **Ejemplo con Broker Mosquitto en Raspberry Pi**:
```cpp
#include <WiFi.h>
#include <PubSubClient.h>
WiFiClient espClient;
PubSubClient client(espClient);
const char* mqtt_server = "192.168.1.50"; // IP del broker MQTT local

void setup() {
client.setServer(mqtt_server, 1883);
client.subscribe("casa/sensor");
}

void loop() {
client.publish("casa/temperatura", "25.5°C");
delay(5000);
}
---
## **3. Descubrimiento de Dispositivos en la Red**
Para evitar configurar IPs fijas, se pueden usar técnicas como:
### **A. mDNS (Multicast DNS)**
- Permite resolver nombres como `esp32.local` en lugar de IPs.
- **Ejemplo en ESP32**:
```cpp
  #include <ESPmDNS.h>
  
  void setup() {
  MDNS.begin("esp32"); // Accesible como http://esp32.local
  }
  ### **B. Broadcast UDP**
  - Enviar un mensaje a `255.255.255.255` para descubrir dispositivos.
  - **Ejemplo**:
```cpp
udp.beginPacket("255.255.255.255", 1234);
udp.print("¿Quién está conectado?");
udp.endPacket();
---
## **4. Consideraciones de Seguridad**
1. **Aislamiento de AP (Client Isolation)**: Algunos routers impiden comunicación entre dispositivos WiFi (debes desactivarlo).
2. **Cifrado**: Usa **WPA2/WPA3** para evitar sniffing de tramas.
3. **IP Estática vs. DHCP**:
- Asigna IPs fijas para dispositivos críticos (ej: servidores).
- Usa DHCP para el resto.
---
## **5. Ejemplo Práctico: ESP32 ↔ Computadora en la Misma LAN**
### **Paso 1: Conectar ambos dispositivos al mismo WiFi**.
### **Paso 2: Obtener las IPs**:
- **ESP32**: Ver serial monitor (`WiFi.localIP()`).
- **Computadora**: Ejecutar `ipconfig` (Windows) o `ifconfig` (Linux/macOS).
### **Paso 3: Comunicación TCP**:
- **En Python (Computadora)**:
```python
  import socket
  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  s.connect(("192.168.1.10", 1234)) # IP del ESP32
  s.sendall(b"Hola ESP32")
  respuesta = s.recv(1024)
  print(respuesta.decode())
```
---
## **6. Solución de Problemas Comunes**
- **"No se encuentra el dispositivo"**:
- Verifica que estén en la misma red.
- Usa `ping` para comprobar conectividad.
- **Conexión rechazada**:
- Revisa firewalls (`sudo ufw disable` en Linux).
- Asegúrate de que el servidor esté escuchando (ej: `netstat -tulnp`).
---
### **Conclusión**
La comunicación WiFi en una LAN permite interconectar dispositivos de forma eficiente sin depender de Internet. Ya sea con TCP, UDP, MQTT o protocolos avanzados como mDNS, puedes crear redes locales robustas para IoT, automatización o transferencia de datos.