ESP8266 Conexión WiFi-MQTT

La conexión de un módulo ESP8266 a un «broker Mosquitto» se puede describir como una conversación en la que se habla (publish) y escucha (subscribe). En la conversación hay un intermediario (broker) que gestiona los mensajes, recibe mensajes de actualización de estados (publish) y los re-envía a los subscriptores.

Para la conexión a un broker MQTT, se supondrá que ya ha dispone de un servidor MQTT en forma básica, semejante a la descrita en la sección «Broker-MQTT Mosquitto instalar».

http://blog.espol.edu.ec/edelros/3-mqtt-mosquitto-instalar/

Adicionalmente, ya ha establecido la conexión a la red WiFi semejante al ejemplo del siquiente enlace.

http://blog.espol.edu.ec/edelros/esp8266-conexion-wifi/

Verificada la conexión a la red WiFi, se procede describir el proceso de conexión al broker MQTT,

Instrucciones en Arduino IDE

Se inicia con las librerias para la conexión WiFi, y comunicación MQTT.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

Datos MQTT- servidor

Para establecer la conexión con el broker, se requieren la dirección IP, usuario y contraseña MQTT.

Actualice los datos correspondientes a la configuración de su broker.

// MQTT: Servidor
char* MQTT_IP = "192.168.xxx.xxx";
uint16_t MQTT_puerto = 1883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";

Datos MQTT-dispositivo

Para cada dispositivo se asigna un identificador, tópico, instrucción de activación (command) y los valores de estado posibles. Ejemplo: ON, OFF.

// MQTT: Dispositivo Actuador Luz
char* MQTT_ID = "oficina_luz1";
char* MQTT_TOPIC = "oficina/luz1/estado";
char* MQTT_COMMAND = "oficina/luz1/cambia";
char MQTT_ActuadorEstado[10] = "OFF";

char* sensor_ON  = "ON";
char* sensor_OFF = "OFF";

Activar los clientes WiFi y MQTT

// Clientes WiFi y MQTT
WiFiClient wifiClient;
PubSubClient mqttclient(wifiClient);

Configuración de inicio

Para el bloque de configuración (setup) se verifica el estado de la conexión WiFi antes de intentar conectarse al broker MQTT-Mosquitto.

Para revisar el proceso por medio del monitor serie de Arduino IDE, se establece la variable serial_msg=true. Si los pines Tx-Rx se encuentran ocupados como entrada o salida, serial_msg=false para evitar conflictos entre mensajes y valores del proceso.

  // conexión WIFI y MQTT
  inicia_wifi(serial_msg);
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt(serial_msg);
    }

La subrutina de inicio se resume en establecer los valores de servidor, la conexión y la interpretación de instrucción recibida (callback). Al establecer la conexión se procede a publicar el estado del dispositivo.

void inicia_mqtt(boolean SerialMensajes){
  int intentos = 5;
  int cuenta = 0;
  
  if (SerialMensajes){
    Serial.print(" MQTT Conectando a ");
    Serial.println(MQTT_IP);
    }
    
  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
  mqttclient.setCallback(callback);
  
  while (!mqttclient.connected() && (cuenta<=intentos)) {
    if (SerialMensajes){
      Serial.print(".");
    }
    cuenta = cuenta + 1;
    // LED Monitor parpadeo MQTT, enciende LOW
    digitalWrite(LED_pin, LOW);
    delay(600);
    digitalWrite(LED_pin, HIGH);
    delay(400);
    }
  if (mqttclient.connected()){
      publica_estado();
  }
  if (SerialMensajes){
    //Fin de "...."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.println(mqttclient.connected());
    Serial.print(" MQTT Estado: ");
    Serial.println(mqttclient.state());
    }
  }

Publicación, subscripción y Recepción de intrucción

Estas operaciones se deben personalizar para cada caso. Las siguientes partes se presentan como ejemplo, donde se deben seleccionar los tópicos, valores, comándos y actualizarlos para la aplicación específica que se encuentre desarrollando.

Publicación o Subscripción de estados

La publicación de estados y subscripción se realiza como una función.

// Publicar el estado del dispositivo
void publica_estado() {
  if (actuador_estado){
    snprintf (MQTT_ActuadorEstado,10, sensor_ON);
  }else{
    snprintf (MQTT_ActuadorEstado,10, sensor_OFF);
  }
  mqttclient.publish(MQTT_TOPIC,MQTT_ActuadorEstado,true); 
  mqttclient.subscribe(MQTT_COMMAND);

Recibir una Instrucción (callback)

Para recibir una instrucción (command) se procesa mediante la función «callback», que consiste en analizar  la instrucción y el valor recibidos con los parámetros del dispositivo para establecer la acción a seguir en el dispositivo (actuador).

/ llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
  // procesa valor de cambio a texto
  String valor;
  for (uint8_t i = 0; i < p_length; i++) {
    valor.concat((char)p_payload[i]);
    }
  // compara mensaje recibido y actualiza estado
  if (String(MQTT_COMMAND).equals(p_topic)) {
    if (valor.equals(String(sensor_ON))) {
      if (actuador_estado != true) {
        actuador_estado = true;
        }
      }
    if (valor.equals(String(sensor_OFF))) {
      if (actuador_estado != false) {
          actuador_estado = false;
        }
      }
    LEDactivaestado();
    ACTUADORactivaestado();
    publica_estado();
    }
    if (serial_msg){
      Serial.println(" MQTT recibido ");
      Serial.print(MQTT_COMMAND);
      Serial.print(" ");
      Serial.println(valor);
    }
  }

ESP8266 Conexión WiFi

Prueba básica de conexión a WiFi, para el ejemplo se presenta con módulo ESP-01 y conexión con un USB-TTL. La conexión a otros módulos es semejante en el uso de los pines de configuración.

El ejemplo, el módulo en operación  realiza un parpadeo de un LED por un segundo (1000 ms). mientras que para el modo de conexión realiza parpadeos más rápido s(250ms).

Esquematico

La alimentación del circuito  mostrada sigue las indicaciones de la sección: Fuente de alimentación 3.3VDC

El control para el modo de «operación/Programación» y «reset» se implementa por medio de botoneras. El modo predeterminado de inicio es «operación»  por medio de  GPIO0 a estado +VCC (HIGH) con una resistencia (pullup), al  presionar la botonera se cambia el estado a GND (LOW).

Para programar se presiona la botonera «programar» y luego un pulso de «reset», el módulo está listo para «subir» instrucciones desde IDE Arduino.

Para referencia se muestran las conexiones usando un protoboard.

Instrucciones en Arduino IDE

Se usa la libreria < ESP8266WiFi.h> personalizada para los módulos ESP8266, permite obtener datos como MAC, IP, RSSI, y algunos valores de estado de conexión.

Las variables ssid y password se usan para el identificador de red y contraseña del router a conectarse, reemplace con el valor apropiado para la red a usar.

Una versión simplificada de instrucciones permite la conexión y observación por medio de los parpadeos del led del módulo.

/* ESP8266/ESP-01 WIFI Blink 
 *  edelros@espol.edu.ec 2019
 *  Ejemplo de conexión a WiFi
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router
*/
#include 

// WIFI: conexión a Router
char* ssid = "aaaaa";
char* password = "aaaaa";

// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
int LED_pin=1;

WiFiClient wifiClient;

void setup() {
  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi();
  }

void loop() {
  // revisa estado de WiFi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
    }

    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    
    // Tiempo para procesar señal WiFi
    delay(100);
}

void inicia_wifi(){
  int intentos = 20;
  int cuenta = 0;
     
  WiFi.begin(ssid, password);
  
  while((WiFi.status() != WL_CONNECTED)&&(cuenta<=intentos)){
    cuenta = cuenta+1;
    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(250);
    digitalWrite(LED_pin, HIGH);
    delay(250);
    }
  }

Instrucciones con mensajes a monitor Serial

El proceso se puede observar mediante desde el IDE Arduino para el módulo ESP-07. En la versión ESP-01 el LED interno se encuentra conectado al pin de TX usado para la comunicación Serial y causaría un conflicto.

En ésta versión se puede cambiar el led a otro pin configurado como salida GPIO2, lo que permite conectar Tx y Rx y observar los mensajes del proceso de conexión.

/* ESP8266/ESP-01 WIFI Blink 
 *  edelros@espol.edu.ec 2019
 *  Ejemplo de conexión a WiFi
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router
 *  ESP-01: desactive los Mensajes seriales
 *  ESP-07: Active los Mensajes por serial
 *  usando serial_msg = false o true
*/
#include <ESP8266WiFi.h>

// WIFI: conexión a Router
char* ssid = "aaaaa";
char* password = "aaaaa";

// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
int LED_pin=1;

// Mensajes por Puerto Serial
volatile boolean serial_msg = false;

WiFiClient wifiClient;

void setup() {
  if (serial_msg){
    // Conexion serial // ESP01 muestra reinicio en 74880
    Serial.begin(74880);//115200,74880
  }

  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi(serial_msg);
  }

void loop() {
  // revisa estado de WiFi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi(serial_msg);
    }

    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    
    // Tiempo para procesar señal WiFi
    delay(100);
}

void inicia_wifi(boolean SerialMensajes){
  int intentos = 20;
  int cuenta = 0;
  
  if (SerialMensajes){
    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);
    }
    
  WiFi.begin(ssid, password);
  
  while((WiFi.status() != WL_CONNECTED)&&(cuenta<=intentos)){
    if (SerialMensajes){
      Serial.print(".");
      }
    cuenta = cuenta+1;
    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(250);
    digitalWrite(LED_pin, HIGH);
    delay(250);
    }

  if (SerialMensajes){
    //Fin de "..."
    Serial.println();
    if (WiFi.status() == WL_CONNECTED){
      Serial.print(" Estado: ");
      Serial.println(WiFi.status());
      Serial.print(" MAC: ");
      Serial.println(WiFi.macAddress());
      Serial.print(" IP: ");
      Serial.println(WiFi.localIP());
      Serial.print(" RSSI: ");
      Serial.println(WiFi.RSSI());
      Serial.println();
      }
    if (WiFi.status() != WL_CONNECTED){
      WiFi.printDiag(Serial);
      Serial.println();
      }
    }
  }

Referencia: https://esp8266-arduino-spanish.readthedocs.io/es/latest/esp8266wifi/readme.html

ESP07 MQTT-TLS-LED

Se adjuntan las instrucciones básicas para controlar el led incorporado en el módulo ESP-07 usando MQTT con TLS. Revise la sección de Broker para MQTT-TLS

Se mantiene como punto de partida para usar TLS en los prototipos de Dispositivos.

/*  ESP8266 MQTT TLS 1.2 Ejemplo para estado LED
 *  Controlado desde broker MQTT-Mosquitto y Home Assistant
 *  Grupo IRNI-FIEC-ESPOL
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// WIFI datos para conexión a Router
const PROGMEM char* ssid = "xxxx";
const PROGMEM char* password = "xxxx";

// MQTT: Servidor MQTT 
const PROGMEM char* MQTT_SERVER_IP = "xxxx";
const PROGMEM uint16_t MQTT_SERVER_PORT = 8883;
const PROGMEM char* MQTT_USER = "usuarioprueba";
const PROGMEM char* MQTT_PASSWORD = "usuarioclave";

// MQTT: identificador de dispositivo y topics
const PROGMEM char* MQTT_CLIENT_ID = "Jardin01";
const char* MQTT_SENSOR_TOPIC =  "home/garden/fountain";
const char* MQTT_SENSOR_COMMAND_TOPIC = "home/garden/fountain";
// payloads by default (on/off)
const char* SENSOR_ON = "ON";
const char* SENSOR_OFF = "OFF";
char MQTT_SENSOR_STATE[10] = "OFF"; // inicializa

// Certificados TLS: Certificate Authority
const char caCert[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
MIID+TCCAuGgAwIBAgIUC9VemIObh1BEF0vR0d2lNDEbfZ0wDQYJKoZIhvcNAQEL
BQAwgYsxCzAJBgNVBAYTAkVDMQ8wDQYDVQQIDAZHdWF5YXMxEjAQBgNVBAcMCUd1
...
9vX0/zaZoHcIeJwX0X3Ej6d3f+v9dLUhh14veDhnXzNSAeHCoM2QuIH1LnEl2Xrl
JNQANSgsMMh0tXJQQqJd1E2nxOCv5kxmKd3p7VnrD2JajsqQ9LxepsyC9W4V6Gjw
MIXc4ndT9GV03KxCGA==
-----END CERTIFICATE-----
)EOF";

// MQTT: cert SHA1 fingerprint
const uint8_t mqttCertFingerprint[] = {0x79,0xCA,0x31,0x25,0x0A,0xCB,0x70,0x48,0xF9,0xAE,0xA7,0xDE,0xB2,0x6E,0xAB,0x8D,0x22,0x17,0x17,0x3A};

// X.509 parsed CA Cert 
X509List caCertX509(caCert);
// Secure client connection class
WiFiClientSecure espClient;
// MQTT: Client connection
PubSubClient mqttClient(espClient);
// MQTT: client ID (will add random hex suffix during setup
String clientId = "ESP8266Client-"; 

// LED monitor interno: ESP01-pin=1, 
// ESP07-pin=2, ESP32-PIN=5
const PROGMEM uint8_t LED_pin = 2;
volatile int SENSOR_estado = LOW;

// control de mensajes serial
volatile boolean serial_msg = true;

void setup() {
  if (serial_msg){
    // Conexion serial
    Serial.begin(74880);//115200,74880
    Serial.setTimeout(2000);
    // espera inicializar serial
    while(!Serial) { }
  }

    // LED monitor
    pinMode(LED_pin, OUTPUT);
    
    // conexión WIFI y MQTT
    inicia_wifi();
    if (WiFi.status() == WL_CONNECTED){
        inicia_mqtt();
    }
}

void loop() {
  LEDactivaestado();
  mensajes();
  // SENSORpublicaestado();

  if (WiFi.status() != WL_CONNECTED){
      inicia_wifi();
  }else{
      if (!mqttClient.connected()){
          inicia_mqtt();
      }else{
          mqttClient.loop();
        }
  }
  delay(1000);
}
// establece estado LED monitor en ESP8266
void LEDactivaestado(){
    if (SENSOR_estado){
        digitalWrite(LED_pin, LOW);
    }else{
        digitalWrite(LED_pin, HIGH);
    }
}

void mensajes(){
    if (serial_msg){
        Serial.println();
        Serial.print("\n Sensor: ");
        Serial.print(SENSOR_estado);
        Serial.print("   MQTT: ");
        Serial.print(MQTT_SENSOR_STATE);
        Serial.print("\n MAC: ");
        Serial.println(WiFi.macAddress());
        if (WiFi.status() == WL_CONNECTED){
            Serial.print(" WiFi IP: ");
            Serial.println(WiFi.localIP());
            if (mqttClient.connected()){
              Serial.print(" MQTT conectado, estado: ");
              Serial.println(String(mqttClient.state()));
            }
        }
    }
  }

// Publicar el estado del dispositivo
void SENSORpublicaestado() {
    if (SENSOR_estado) {
        mqttClient.publish(MQTT_SENSOR_TOPIC, SENSOR_ON, true);
    }else{
        mqttClient.publish(MQTT_SENSOR_TOPIC, SENSOR_OFF, true);
    }
}

void inicia_wifi() {
    int intentos = 20;
    int cuenta = 0;
    if (serial_msg){
        Serial.print(" WIFI Conectando a ");
        Serial.println(ssid);
    }
    
    WiFi.begin(ssid, password);
    while ((WiFi.status() != WL_CONNECTED) && (cuenta<=intentos)){
        if (serial_msg){
          Serial.print(".");
        }
        cuenta = cuenta+1;
        delay(250);
        }
    if (serial_msg){
      Serial.println();
      }
}

void inicia_mqtt(){
    int intentos = 2;
    int cuenta = 0;

    // Configura cliente TLS
    // añade CA cert en los sitios de confianza
    espClient.setTrustAnchors(&caCertX509);
    // Habilita self-signed cert       
    espClient.allowSelfSignedCerts(); 
    // añade fingerprint para validar conexión              
    espClient.setFingerprint(mqttCertFingerprint);  
    
    if (serial_msg){
        Serial.print(" MQTT Conectando a ");
        Serial.println(MQTT_SERVER_IP);
    }

    mqttClient.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);
    mqttClient.setCallback(callback);
    
    while (!mqttClient.connected() && (cuenta<=intentos)) {
        if (serial_msg){
            Serial.print(".");
        }
        mqttClient.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD);
        cuenta = cuenta + 1;
        delay(250);
    }
    if (serial_msg){
      Serial.println();
    }
    if (mqttClient.connected()){
      mqttClient.subscribe(MQTT_SENSOR_COMMAND_TOPIC);
      SENSORpublicaestado();
    }
}

// llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
    // convierte a cadena
    String payload;
    for (uint8_t i = 0; i < p_length; i++) {
        payload.concat((char)p_payload[i]);
        }
    if (serial_msg){
      Serial.println();
      Serial.print(" Llegó un mensaje: ");
      Serial.println(p_topic);
      Serial.println(payload);
    }
    // analiza mensaje por topico
    if (String(MQTT_SENSOR_COMMAND_TOPIC).equals(p_topic)) {
        if (payload.equals(String(SENSOR_ON))) {
            if (SENSOR_estado != true) {
                SENSOR_estado = true;
                LEDactivaestado();
                }
        } else if (payload.equals(String(SENSOR_OFF))) {
            if (SENSOR_estado != false) {
                SENSOR_estado = false;
                LEDactivaestado();
                }
        }
        if (SENSOR_estado){
          snprintf (MQTT_SENSOR_STATE,10, SENSOR_ON);
          }else{
            snprintf (MQTT_SENSOR_STATE,10, SENSOR_OFF);
          }
                
     }
}

Referencia: https://blog.thewalr.us/2019/03/27/using-esp8266-as-an-iot-endpoint-with-encrypted-mqtt-transport/

ESP07 IR Emisor

El circuito permite la emisión de una señal infraroja semejante a un control remoto usando el módulo ESP07-ESP8266. El código infrarojo emitido corresponde al obtenido en el ejemplo del receptor infrarojo.

Com emisor se usa un LED IR, complementado con un transistor para aumentar la cantidad de corriente. El el puerto GPIO05 no es suficiente para obtener distancias de transmisión de la señal muy lejanas.

El esquemático muestra lo sencillo de la conexión del emisor infrarojo:

Protoboard

Como referencia de la conexiones en también se adjunta la conexión usando un protoboard.

Instrucciones

Se usan las librerias Arduino IRremoteESP8266 como base para un dispositivo de control remoto con Home Assistant.

El pin del emisor infrarojo se lo toma de la hoja de datos para el ESP8266 donde se indica usar el pin 5 para receptor y el 14 para emisor. Sección 4.4.Interfaces, página 12.

https://www.mikrocontroller.net/attachment/338570/Ai-thinker_ESP-07_WIFI_Module-EN.pdf

4.8. IR Remote Control pag 16

https://www.espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf

#include <IRremoteESP8266.h>
#include <IRsend.h>
#include <IRrecv.h>

#define LED_pin 2
#define IR_LED 14
IRsend irsend(IR_LED);  // configura emisor
uint32_t enciendeapaga = 0xFF5AA5; // código de control

void setup() {
    Serial.begin(115200);
    pinMode(LED_pin, OUTPUT);
    
    irsend.begin();
}

void loop() {
    Serial.println("Enciende/Apaga control remoto Avanti");
    // Parpadeo LED interno
    digitalWrite(LED_pin, LOW);
    delay(1000); // Esperar un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000); // Esperar un segundo
  
    irsend.sendNEC(enciendeapaga ,32);
    delay(4000);// tiempo antes de apagar dispositivo
}

Las pruebas de funcionamiento se realizan de dos formas:

1. Usando una cámara digital del móvil celular, para verificar que el LED IR parpadea, se puede ver en la pantalla que el LED enciente.

2. apuntando el led al dispositivo que activa el control remoto y usado en el ejemplo del receptor.

El siguiente paso es integrar el receptor y el emisor para el control mediante el servidor MQTT-Mosquitto.

ESP07 IR detector/demodulador

El ejemplo realiza la detección de señal de un control remoto infrarojo con el módulo ESP07-ESP8266 y muestra el resultado Hexadecimal en el Monitor Serial.

Cada tecla del control remoto genera un código único que es detectado con el sensor.

Para el ejemplo se usa un HX1838, sin embargo también funciona  un TSOP382.., TSOP384, o alguna versión que incluya el circuito de demodulación.

La versión del sensor infrarojo con detección y demodulación simplifica el circuito a un pin digital configurado como entrada en el módulo a usar, además de Vcc y Gnd.

El esquemático muestra lo sencillo de la conexión del sensor infrarojo para su lectura.

Protoboard

Como referencia de la conexiones en también se adjunta la conexión usando un protoboard.

Lectura de datos

Para un control remoto dado, por ejemplo el básico para arduino, se obtienen los diferentes códigos en Hexadecimal de las teclas presionadas usando el monitor serial.

FF5AA5
FF5AA5

Si usa un ESP07 en versión 8285, puede ser necesario configurar los baudios a 74880 baudios, si los símbolos que llegan no son legibles.

Instrucciones

Se usan las librerias Arduino IRremoteESP8266 como base para un dispositivo de control remoto con Home Assistant.

/* IRremoteESP8266: Demo Receptor Infrarojo
 * Debe usar un sensor detector/demodulador conectado al Receptor_Pin.
 *  Based on Mark Szabo's Version 0.2 June, 2017 and
 *  Ken Shirriff's IrsendDemo Version 0.1 July, 2009
 *  https://github.com/markszabo/IRremoteESP8266
 */

#include <IRremoteESP8266.h>
#include <IRrecv.h>
#include <IRutils.h>

// Sensor IR en GPIO05
const uint16_t Receptor_Pin = 5;

IRrecv irrecv(Receptor_Pin);
decode_results lectura;

void setup() {
    Serial.begin(74880);//74880, 115200
    while (!Serial){delay(50);}
    
    // Inicia receptor
    irrecv.enableIRIn();
    
    Serial.println("\n Demo: Receptor de IR en espera de mensaje");
}

void loop() {
    if (irrecv.decode(&lectura)) {
        // print() & println() no maneja enteros largos(uint64_t)
        serialPrintUint64(lectura.value, HEX);
        Serial.println("");
        
        // Prepara próximo valor
        irrecv.resume();
    }
    delay(100);
}

Con los cógidos obtenidos, el siguiente paso consiste en generar los códigos usando un LED IR para activar el dispositivo o equipo que se controlaba con el control remoto. Observe y seleccione un código del ejercicio realizado con el control remoto que haya seleccionado, el dato sirve para el próximo ejemplo como IR_Emisor.

Referencia:
https://learn.sparkfun.com/tutorials/ir-communication/all#hardware-hookup
https://github.com/markszabo/IRremoteESP8266


Decodificando

Una versión para obtener más detalles de los códigos la presenta en el ejemplo version 2 de Mark Sabo en:

https://github.com/markszabo/IRremoteESP8266/blob/master/examples/IRrecvDumpV2/IRrecvDumpV2.ino

Solo se requiere hacer el ajuste en el pin de sensor al GIPO05, con lo que se obtiene para el ejemplo anterior:

Timestamp : 000446.026
Encoding  : NEC
Code      : FF5AA5 (32 bits)
Library   : v2.6.0

Raw Timing[71]:
   +  9024, -  4556,    +   548, -   594,    +   546, -   568,    +   544, -   594, 
   +   548, -   592,    +   548, -   568,    +   546, -   594,    +   548, -   592, 
   +   548, -   566,    +   546, -  1738,    +   548, -  1710,    +   550, -  1710, 
   +   544, -  1740,    +   548, -  1712,    +   546, -  1712,    +   546, -  1740, 
   +   546, -  1712,    +   548, -   592,    +   548, -  1710,    +   548, -   592, 
   +   548, -  1710,    +   548, -  1712,    +   546, -   594,    +   548, -  1712, 
   +   544, -   596,    +   548, -  1712,    +   546, -   596,    +   548, -  1710, 
   +   546, -   594,    +   548, -   594,    +   548, -  1712,    +   548, -   592, 
   +   548, -  1710,    +   548, - 40334,    +  9024, -  2294,    +   550

uint16_t rawData[71] = {9024, 4556,  548, 594,  546, 568,  544, 594,  548, 592,  548, 568,  546, 594,  548, 592,  548, 566,  546, 1738,  548, 1710,  550, 1710,  544, 1740,  548, 1712,  546, 1712,  546, 1740,  546, 1712,  548, 592,  548, 1710,  548, 592,  548, 1710,  548, 1712,  546, 594,  548, 1712,  544, 596,  548, 1712,  546, 596,  548, 1710,  546, 594,  548, 594,  548, 1712,  548, 592,  548, 1710,  548, 40334,  9024, 2294,  550};  // NEC FF5AA5
uint32_t address = 0x0;
uint32_t command = 0x5A;
uint64_t data = 0xFF5AA5;

La información de Code, «32 bits» Es necesaria si requiere reproducir la instrucción on irsend.sendNEC(codigo,32).

En el caso de usar otro control remoto se debe disponer del número de bits.

ESP32 Serial Bluetooth

Se puede realizar una comunicación Serial por medio de Bluetooth con la libreria básica de ESP32 para arduino.

En un ejercicio básico par controlar los estados de un LED es enviar un mensaje de ‘1’  para encender el Led incorporado del módulo y un mensaje  de ‘0’ para apagar el Led.

Por un lado se usa un módulo ESP32, y por el otro un móvil/tablet con una aplicación básica de terminal serial, para tener resultados semejantes al mostrado.

Las instrucciones usadas son:

// Controlador Binario LED
// ESP32-Serial Bluetooth

#include <BluetoothSerial.h>

BluetoothSerial ESP_BT;

int mensaje;

// LED monitor interno
// ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5; 

void setup() {
  Serial.begin(115200);
  ESP_BT.begin("ESP32_LED");
  Serial.println("Listo dispositivo Bluetooth");
  pinMode (LED_pin, OUTPUT);
}

void loop() {
  
  if (ESP_BT.available()){
    // mensaje recibido
    mensaje = ESP_BT.read(); 
    Serial.print("Recibido:"); 
    Serial.println(mensaje);

    if (mensaje == 49){
        digitalWrite(LED_pin, HIGH);
        ESP_BT.println("LED Encendido");
        }
        
    if (mensaje == 48){
        digitalWrite(LED_pin, LOW);
        ESP_BT.println("LED Apagado");
        }
  }
  delay(20);
}

Referencia:

https://github.com/espressif/arduino-esp32/tree/master/libraries/BluetoothSerial

https://create.arduino.cc/projecthub/mayooghgirish/arduino-bluetooth-basic-tutorial-d8b737

ESP32 SmartConfig-App

Para la configuración inicial de los dispositivos requiere una aplicación en un dispositivo tablet o móvil para configurar la conexión a la red WiFi con los datos de SSID y Password.

El concepto presentado por espressif con documentación actualizada al 2018.06.08 se encuentra en:

https://www.espressif.com/en/products/software/esp-touch/overview

https://www.espressif.com/sites/default/files/faq/screen_shot_2016-04-27_at_1.30.27_pm_0.png
Figura: Espressif https://www.espressif.com/sites/default/files/faq/screen_shot_2016-04-27_at_1.30.27_pm_0.png

La implementación de la aplicación que se usó para probar el ejercicio se encuentra en Google Play. Revisar el desarro de la aplicación realizará como otro tema.

https://play.google.com/store/apps/details?id=com.cmmakerclub.iot.esptouch

El procedimiento de conexión tiene dos partes:

  1. Modo configuración de WiFi, usando la aplición SmartConfig
  2. Modo normal de conexión WiFi, con los datos WiFi ya configurados

Para seleccionar los modos se usa una botonera «Configuración»  en un pin digital disponible con funcion y circuito semejante a RESET, en el ejemplo se usa GPIO14.

Modo configuración de WiFi

Para iniciar el modo configuración de la red se deben usar las botoneras «Configuración» y «RESET» con la secuencia:

1. pulsar Botonena GPIO14 y mantener pulsada
2. Luego pulsar y soltar reset
3. Mantener pulsado GPIO14 por 5 segundos después y soltar
4. Usar el móvil/tableta con la aplicación SmartConfig para configurar
5. Escribir SSID y password en móvil/tablet y «confirmar»
6. Esperar confirmación y estará conectado.

Modo normal de conexión WiFi

Es el modo predeterminado de operación, no requiere presionar el botón de «Configuración». Arranca con los valores almacenados de SSID y PASSWORD.

Monitor Serial

Los resultados del proceso de configuración y conexión a WiFi se muestran a continuación. Para fines de muestra, se ha demorado la activación con el móvil/tablet, note que la conexión a WiFI se realiza casi inmediatamente (tres puntos …)

....ets Jun  8 2016 00:22:57

rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
ets Jun  8 2016 00:22:57

rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1100
load:0x40078000,len:10088
load:0x40080400,len:6380
entry 0x400806a4
configurando WiFi
Esperando conexión SmartConfig móvil/tablet
........................................
 Esperando conexión SmartConfig móvil/tablet
...............
 Finalizado SmartConfig.

 Conectando a WiFi
...
 WiFi conectado , Dirección IP: iotirni19 , 192.168.10.102
conectado a:
iotirni19 , 192.168.10.102 , -56
conectado a:
iotirni19 , 192.168.10.102 , -53
conectado a:
iotirni19 , 192.168.10.102 , -54
conectado a:
iotirni19 , 192.168.10.102 , -55
conectado a:
iotirni19 , 192.168.10.102 , -55
conectado a:
iotirni19 , 192.168.10.102 , -55

Instrucciones Arduino

Las instrucciones se han dividido por bloques: configura_wifi() y conecta_wifi(). En ambas funciones se presentan mensajes y parpadeos de led.

Configura_wifi() espera a que se obtenga un valor afirmativo para WiFi.smartConfigDone() y finalizar.

Conecta_wifi() es muy semejante a la función inicia_wifi() usada en los primeros ejemplos que usaba variables para SSID y Password()

/* ESP32 Smart Config de Espressif
modificado a partir de:
https://www.espressif.com/en/products/software/esp-touch/overview
Usa el GPIO14 en estado LOW para entrar en modo configuración.
Usar BOTONERA "CONFIGURACION" en pin14, con pullup (HIGH)
Para configurar:
1. pulsar Botonena GPIO14 y mantener pulsada
2. Luego pulsar y soltar reset
3. Mantener pulsado GPIO14 por 5 segundos después y soltar
4. Usar el móvil/tableta con la aplicación SmartConfig para configurar
5. Escribir SSID y password en móvil/tablet y "confirmar"
6. Esperar confirmación y estará conectado.
*/
#include <WiFi.h>

// PIN configuración
const PROGMEM uint8_t CONFIG_pin = 14; 

// LED monitor interno
//ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5; 

void setup() {
    Serial.begin(115200);

    // PIN configuración
    pinMode(CONFIG_pin, INPUT);
    
    // LED monitor
    pinMode(LED_pin, OUTPUT);
    
    // Revisa si entra a modo configuración
    if (digitalRead(CONFIG_pin)==LOW){
        Serial.println("configurando WiFi");
        // configura con SmartConfig
        configura_wifi();
    }
    // Modo conexión a Router
    conecta_wifi();

}
void loop() {
    // Ejemplo de tarea a realizar.
    Serial.println("conectado a:");
    Serial.print(WiFi.SSID());
    Serial.print(" , ");
    Serial.print(WiFi.localIP());
    Serial.print(" , ");
    Serial.println(WiFi.RSSI());
    // LED interno enciende en LOW
    digitalWrite(LED_pin, HIGH);
    delay(100);
    digitalWrite(LED_pin, LOW);
    delay(100);
    digitalWrite(LED_pin, HIGH);
    delay(100);
    digitalWrite(LED_pin, LOW);
    delay(250);
    // termina ejemplo
    delay(1000);
}

void configura_wifi(){
    // inicia en modo estación
    WiFi.mode(WIFI_AP_STA);
    WiFi.beginSmartConfig();
    int cuenta = 0;
    // Espera por un paquete Smartconfig del móvil/tablet
    Serial.println("Esperando conexión SmartConfig móvil/tablet");
    while (!WiFi.smartConfigDone()) {
        delay(500);
        Serial.print(".");
        cuenta = cuenta+1;
        if (cuenta>=40){
            Serial.println("\n Esperando conexión SmartConfig móvil/tablet");
            cuenta = 0;}
        // LED interno enciende en LOW
        digitalWrite(LED_pin, HIGH);
        delay(50);
        digitalWrite(LED_pin, LOW);
        delay(50);
        }
    Serial.println("\n Finalizado SmartConfig.");
    }

void conecta_wifi() {
    // conexion WiFi
    Serial.println("\n Conectando a WiFi");
    
    WiFi.begin();//ssid, password);
    int cuenta = 0;
    while (WiFi.status() != WL_CONNECTED){
        Serial.print(".");
        cuenta = cuenta+1;
        if (cuenta>=40){
            Serial.println();
            cuenta = 0;}
        // LED interno enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(250);
        digitalWrite(LED_pin, HIGH);
        delay(250);
        }
    Serial.print("\n WiFi conectado , Dirección IP: ");
    Serial.print(WiFi.SSID());
    Serial.print(" , ");
    Serial.println(WiFi.localIP());
    delay(10);
}

Por desarrollar:
Personalizar la aplicación del móvil/tableta a partir del código básico de espressif.

Referencias:
https://www.espressif.com/en/products/software/esp-touch/overview

https://www.espressif.com/sites/default/files/documentation/esp-touch_user_guide_en.pdf

ESP32 BuscarRedes

Búsqueda de redes cercanas y sus respectivas potencias, la red marcada con rojo es el ESP32  revisado desde una laptop.

Busca redes WiFi cercanas
Busqueda completada 
29 redes encontradas
1: ESP_0A797B (-46) 
2: GUAIFAI (-62)*
3: Red Oculta
...

Instrucciones

Usando la libreria WiFi.h

/* Redes disponibles
 *  Realiza una búsqueda de redes Wifi cercanas
 */
#include <WiFi.h>

void setup()
{
    Serial.begin(115200);

    // Si estaba conectada como estación, se desconecta.
    WiFi.mode(WIFI_STA);
    WiFi.disconnect();
    delay(100);

    Serial.println("Configuración completada.");
}

void loop()
{
    Serial.println("Busca redes WiFi cercanas");

    //determina el número de redes cercanas
    int n = WiFi.scanNetworks();
    Serial.println("Busqueda completada ");
    
    if (n == 0) {
        Serial.println("NO se encontraron redes.");
    } else {
        Serial.print(n);
        Serial.println(" redes encontradas");
        for (int i = 0; i < n; ++i) {
            // Muestra el SSID y RSSI de cada red encontrada
            Serial.print(i + 1);
            Serial.print(": ");
            Serial.print(WiFi.SSID(i));
            Serial.print(" (");
            Serial.print(WiFi.RSSI(i));
            Serial.print(")");
            Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*");
            delay(10);
        }
    }
    Serial.println("");

    // Espera antes de la próxima búsqueda...
    delay(5000);
}

Referencia: https://github.com/espressif/arduino-esp32/blob/master/libraries/WiFi/examples/WiFiScan/WiFiScan.ino

ESP32 SoftAP

Para crear un Access Point se usa de la libreria la intrucción WIFI.softAP()

Como base se tiene el ejercicio de una página web para encender o apagar el LED incorporado.

En ésta ocasión no es necesario conectarse a un router, el AP aparece en la lista de dispositivos circundantes. Se selecciona y se ingresa con el nombre de red y la contraseña.

/* ESP32 Soft AP con web server para encender LED_Pin
forma básica con la función inicia_wifi
Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer  
*/
#include <WiFi.h>

const char* ssid     = "iotirni19_AP";
const char* password = "xxxxx";

// puerto de servidor web 80
const PROGMEM uint8_t puertoweb = 80;
WiFiServer server(puertoweb);

// LED monitor interno
//ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5; 
int LED_estado = 0;

void setup()
{
    // Conexion serial
    Serial.begin(115200);
    Serial.setTimeout(500);
    // espera inicializar serial
    while(!Serial) { }

    // LED monitor
    pinMode(LED_pin, OUTPUT);
    delay(10);

    // Convertir en AP
    WiFi.softAP(ssid, password);
    //inicia_wifi(); // no se conecta a un router
    server.begin();
}

void loop(){
    WiFiClient client = server.available();
    if (client){
        String linea = "";
        Serial.println();
        Serial.println("Nuevo cliente.");
        while (client.connected()) {
            if (client.available()) {
                char c = client.read();
                Serial.write(c);
                if (c == '\n') {
                    // Si recibe fin de linea y la linea es vacia,
                    // la peticion http finalizó, se responde:
                    if (linea.length() == 0) {
                        // HTTP headers inician con ésta secuencia:
                        client.println("HTTP/1.1 200 OK");
                        client.println("Content-type:text/html");
                        client.println();
                        // contenido despues de headers
                        client.print("LED estado: ");
                        client.print(String(LED_estado)+"
");
                        client.print("Click <a href=\"/H\">ENCIENDE LED</a><br>");
                        client.print("Click <a href=\"/L\">   APAGA LED</a><br>");
                        // finaliza contenido:
                        client.println();
                        // sale del lazo:
                        break;
                    } else {
                        linea = "";
                    }
                } else if (c != '\r') {
                    linea = linea + c;
                }
            // Revisa click del cliente "GET /H" or "GET /L":
            if (linea.endsWith("GET /H")) {
                digitalWrite(LED_pin, HIGH);
                LED_estado = 1;
            }
            if (linea.endsWith("GET /L")) {
                digitalWrite(LED_pin, LOW);
                LED_estado = 0;
            }
        }
    }
    delay(1); // espera que browser procese
    client.stop(); // cierra conexión:
    Serial.println("Cliente desconectado.");
    }
}

ESP32 WebServer Blink

Enciender y Apagar elLED incorporado (Pin 5) en el módulo ESP32 desde una página web.

https://learn.sparkfun.com/tutorials/esp32-thing-hookup-guide

El módulo se configura como un Web Server para responder a las petición desde un browser. La dirección mostrada en la figura es un ejemplo.

La librería  básica usada es WiFi.h con los valores de SSID y Password para acceder a la red existente, valores que se deben actualizar de acuerdo a la configuración de su red. El router asigna una dirección IP de forma automática, y su valor se muestra en el monitor serial, dirección usada en un brower para observar el resultado.

Monitor Serial

ets Jun 8 2016 00:22:57

rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1100
load:0x40078000,len:10088
load:0x40080400,len:6380
entry 0x400806a4

Conectando a RedWifi
..
WiFi conectado 
Dirección IP: 192.168.10.104

Para simplificar las instrucciones, la sección de conexión a la red WiFi se realiza en la función inicia_wifi().

Instrucciones:

Para iniciar el modo servidor web se requiere WifiServer server(puertoweb), el puerto web es el 80.

En el programa se revisa el estado del cliente (client): conectado, disponible, leyendo cada caracter enviado por el browser e interpretando las instrucciones por cada fin de línea (‘\n’).

Si la línea recibida finaliza con «GET /H» o «GET /L» se realiza el cambio de estado del LED.

Al final se cierra la conexión, y se continua monitoreando el estado del cliente.

/* ESP32 web server para encender LED_Pin
forma básica con la función inicia_wifi
Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer  
*/
#include <WiFi.h>

const char* ssid     = "";
const char* password = "";

// puerto de servidor web 80
const PROGMEM uint8_t puertoweb = 80;
WiFiServer server(puertoweb);


// LED monitor interno
//ESP01-pin=1, ESP07-pin=2; ESP32-pin=5
const PROGMEM uint8_t LED_pin = 5; 

void setup()
{
    // Conexion serial
    Serial.begin(115200);
    Serial.setTimeout(500);
    // espera inicializar serial
    while(!Serial) { }

    // LED monitor
    pinMode(LED_pin, OUTPUT);
    delay(10);

    inicia_wifi();
    server.begin();
}

void loop(){
    WiFiClient client = server.available();
    if (client){
        String linea = "";
        Serial.println();
        Serial.println("Nuevo cliente.");
        while (client.connected()) {
            if (client.available()) {
                char c = client.read();
                Serial.write(c);
                if (c == '\n') {
                    // Si recibe fin de linea y la linea es vacia,
                    // la peticion http finalizó, se responde:
                    if (linea.length() == 0) {
                        // HTTP headers inician con ésta secuencia:
                        client.println("HTTP/1.1 200 OK");
                        client.println("Content-type:text/html");
                        client.println();
                        // contenido despues de headers
                        client.print("Click <a href="\"/H\"">ENCIENDE LED</a>
");
                        client.print("Click <a href="\"/L\"">   APAGA LED</a>
");
                        // finaliza contenido:
                        client.println();
                        // sale del lazo:
                        break;
                    } else {
                        linea = "";
                    }
                } else if (c != '\r') {
                    linea = linea + c;
                }
            // Revisa click del cliente "GET /H" or "GET /L":
            if (linea.endsWith("GET /H")) {
                digitalWrite(LED_pin, HIGH);
            }
            if (linea.endsWith("GET /L")) {
                digitalWrite(LED_pin, LOW);
            }
        }
    }
    delay(1); // espera que browser procese
    client.stop(); // cierra conexión:
    Serial.println("Cliente desconectado.");
    }
}

void inicia_wifi() {
    // conexion WiFi
    Serial.print("\n Conectando a ");
    Serial.println(ssid);
    WiFi.begin(ssid, password);
    int cuenta = 0;
    while (WiFi.status() != WL_CONNECTED){
        Serial.print(".");
        cuenta = cuenta+1;
        if (cuenta>=40){
            Serial.println();
            cuenta = 0;}
        // LED interno enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(250);
        digitalWrite(LED_pin, HIGH);
        delay(250);
        }
    Serial.print("\n WiFi conectado \n Dirección IP: ");
    Serial.println(WiFi.localIP());
    delay(10);
}

Puntos por desarrollar

  • Añadir en la pagina el estado del LED. Sugerencia: aumentar una variable de estado para el led y usarla en la página html.
  • Conectar a un servidor MQTT e iniciar el estado del LED con el correspondiente en el Estado MQTT.

Referencia: https://www.arduino.cc/en/Tutorial/WiFiWebServer