Autor: Edison Del Rosario

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.

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.

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

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

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

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

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.");
    }
}