ESP-NOW: inalámbrico sin router

// mac_address.ino · Muestra la dirección MAC (modo estación) de la placa
// Cada placa ESP32 se identifica en ESP-NOW por esta dirección.
#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);          // ESP-NOW trabaja con la interfaz de estación
  delay(100);
  Serial.println();
  Serial.print("MAC de esta placa: ");
  Serial.println(WiFi.macAddress());
}

void loop() {
}

// receptor_muchos_a_1.ino · Receptor ESP-NOW (recibe de varios emisores)
#include <WiFi.h>
#include <esp_now.h>

// Estructura IDÉNTICA en emisores y receptor
typedef struct {
  uint8_t  id;           // número del emisor (1, 2, 3...)
  float    temperatura;  // °C
  float    humedad;      // %
  uint32_t contador;     // nº de mensaje
} Mensaje;

Mensaje datos;

void procesar(const uint8_t *mac, const uint8_t *entrada, int longitud) {
  if (longitud != sizeof(Mensaje)) {
    Serial.printf("Paquete ignorado (tamaño %d, se esperaban %d)\n", longitud, (int)sizeof(Mensaje));
    return;
  }
  memcpy(&datos, entrada, sizeof(Mensaje));
  Serial.printf("Emisor %u (%02X:%02X:%02X:%02X:%02X:%02X) | T=%.1f C | H=%.1f %% | msg #%lu\n",
                datos.id, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
                datos.temperatura, datos.humedad, (unsigned long)datos.contador);
}

// La firma del callback cambió en el núcleo 3.x del ESP32 para Arduino
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
void alRecibir(const esp_now_recv_info_t *info, const uint8_t *entrada, int longitud) {
  procesar(info->src_addr, entrada, longitud);
}
#else
void alRecibir(const uint8_t *mac, const uint8_t *entrada, int longitud) {
  procesar(mac, entrada, longitud);
}
#endif

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  delay(100);
  Serial.print("Receptor listo. Mi MAC: ");
  Serial.println(WiFi.macAddress());

  if (esp_now_init() != ESP_OK) {
    Serial.println("Error al iniciar ESP-NOW");
    return;
  }
  esp_now_register_recv_cb(alRecibir);
}

void loop() {
  // Todo ocurre en el callback alRecibir()
}

// emisor_muchos_a_1.ino · Emisor ESP-NOW (envía al receptor por su MAC)
#include <WiFi.h>
#include <esp_now.h>

// 1) Cambia por la MAC de TU receptor (la que mostró mac_address.ino)
uint8_t macReceptor[] = {0x24, 0x6F, 0x28, 0xAA, 0xBB, 0xCC};

// 2) Número de este emisor (1, 2, 3...). Cambia en cada placa emisora
#define ID_EMISOR 1

typedef struct {
  uint8_t  id;
  float    temperatura;
  float    humedad;
  uint32_t contador;
} Mensaje;

Mensaje datos;
unsigned long ultimoEnvio = 0;
const unsigned long INTERVALO = 2000;   // ms

void mostrarEstado(esp_now_send_status_t estado) {
  Serial.print("Estado del envío: ");
  Serial.println(estado == ESP_NOW_SEND_SUCCESS ? "ENTREGADO" : "FALLO");
}

// La firma del callback de envío depende de la versión del núcleo
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 3, 0)
void alEnviar(const wifi_tx_info_t *info, esp_now_send_status_t estado) {
  mostrarEstado(estado);
}
#else
void alEnviar(const uint8_t *mac, esp_now_send_status_t estado) {
  mostrarEstado(estado);
}
#endif

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  delay(100);
  Serial.print("Emisor ");
  Serial.print(ID_EMISOR);
  Serial.print(" listo. Mi MAC: ");
  Serial.println(WiFi.macAddress());

  if (esp_now_init() != ESP_OK) {
    Serial.println("Error al iniciar ESP-NOW");
    return;
  }
  esp_now_register_send_cb(alEnviar);

  // Registrar al receptor como "peer" (pareja)
  esp_now_peer_info_t peer;
  memset(&peer, 0, sizeof(peer));
  memcpy(peer.peer_addr, macReceptor, 6);
  peer.channel = 0;        // 0 = el canal actual de la placa
  peer.encrypt = false;    // sin cifrado en este ejemplo
  if (esp_now_add_peer(&peer) != ESP_OK) {
    Serial.println("No se pudo añadir el receptor");
  }
}

void loop() {
  if (millis() - ultimoEnvio >= INTERVALO) {
    ultimoEnvio = millis();

    datos.id = ID_EMISOR;
    datos.temperatura = 20.0 + random(0, 100) / 10.0;   // valor simulado (sustituir por el DHT22)
    datos.humedad     = 40.0 + random(0, 400) / 10.0;   // valor simulado
    datos.contador++;

    esp_err_t resultado = esp_now_send(macReceptor, (uint8_t *)&datos, sizeof(datos));
    Serial.printf("Enviando msg #%lu -> %s\n", (unsigned long)datos.contador,
                  resultado == ESP_OK ? "enviado a la cola" : "error de envío");
  }
}

// nodo_muchos_a_muchos.ino · Todos los nodos envían y reciben (broadcast)
// Sube EL MISMO programa a todas las placas cambiando solo ID_NODO.
#include <WiFi.h>
#include <esp_now.h>

#define ID_NODO 1   // Cambia en cada placa (1, 2, 3...)

// Dirección de difusión: la reciben todas las placas a la vez
uint8_t broadcastMAC[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

typedef struct {
  uint8_t  id;
  float    valor;
  uint32_t contador;
} Mensaje;

Mensaje enviado, recibido;
unsigned long ultimoEnvio = 0;

void procesar(const uint8_t *mac, const uint8_t *entrada, int longitud) {
  if (longitud != sizeof(Mensaje)) return;
  memcpy(&recibido, entrada, sizeof(Mensaje));
  Serial.printf("[Nodo %u] recibido de nodo %u (%02X:%02X:%02X:%02X:%02X:%02X): valor=%.1f msg #%lu\n",
                ID_NODO, recibido.id, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
                recibido.valor, (unsigned long)recibido.contador);
}

#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
void alRecibir(const esp_now_recv_info_t *info, const uint8_t *entrada, int longitud) {
  procesar(info->src_addr, entrada, longitud);
}
#else
void alRecibir(const uint8_t *mac, const uint8_t *entrada, int longitud) {
  procesar(mac, entrada, longitud);
}
#endif

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  delay(100);
  Serial.print("Nodo "); Serial.print(ID_NODO);
  Serial.print(" listo. MAC: "); Serial.println(WiFi.macAddress());

  if (esp_now_init() != ESP_OK) {
    Serial.println("Error al iniciar ESP-NOW");
    return;
  }
  esp_now_register_recv_cb(alRecibir);

  esp_now_peer_info_t peer;
  memset(&peer, 0, sizeof(peer));
  memcpy(peer.peer_addr, broadcastMAC, 6);
  peer.channel = 0;
  peer.encrypt = false;          // el broadcast no admite cifrado
  esp_now_add_peer(&peer);
}

void loop() {
  if (millis() - ultimoEnvio >= 3000) {
    ultimoEnvio = millis();
    enviado.id = ID_NODO;
    enviado.valor = 20.0 + random(0, 100) / 10.0;   // valor simulado
    enviado.contador++;
    esp_now_send(broadcastMAC, (uint8_t *)&enviado, sizeof(enviado));
  }
}