GIRNI

Grupo de Investigación de Redes de iNformación Inalámbricas

Autor: Edison Del Rosario

  • 2. IoT WiFi - Archivo.ino

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

    Las instrucciones se presentan paso a paso, en caso que realice por primera vez éste proceso, en los próximos ejemplos bloques y pasos básicos repetidos solo se mencionarán y/o se hará referencia a éste ejemplo.


    1. Bloque de inicio

    1.1 Librerías

    Las librerías contienen las instrucciones para los procesos como el de conexión, manejo de datos como direcciones IP, MAC,  o niveles de señal RSSI, valores de estado de conexión, etc.

    Las librerías podrían variar entre modelos de placas de desarrollo principalmente por tipo de módulo o microcontrolador, sin embargo las instrucciones son las mismas. La siguiente tabla muestra la librería usada en cada caso:

    Modelolibreria
    ESP8266<ESP8266WiFi.h>
    ESP32<WiFi.h>

    Para el resto de las instrucciones no hay diferencias, las instrucciones son  las mismas manteniendo el uso de pines de la placa.

    Esta selección de librerías se puede realizar con inclusión de condigo condicionado por la placa mediante la instrucción #ifdef #elif #endif. De esta manera se puede realizar un solo código general, al compilar en Arduino, dependiendo de la placa que se tiene conectada se selecciona la librería necesaria.

    // detectar placa al compilar
    # ifdef defined(ESP8266)
      #include <ESP8266WiFi.h>
    # elif defined(ESP32)
      #include <WiFi.h>
    # endif
    WiFiClient wificlient;
    

    Referencia: http://www.cplusplus.com/doc/tutorial/preprocessor/

    1.2 Parámetros y cliente de la red

    Como en toda conexión Wifi se require de: Un identificador de router 'ssid' y Una contraseña 'password'. En las instrucciones del ejemplo son valores de la red que se deben actualizar para poder conectarse en cada caso particular.

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

    Con los parámetros anteriores, se inicializa el proceso conectarse a la red.

    1.3 Pines a usar - Estado de conexión por parpadeo de LED

    Para una versión simplificada de prueba de estado de conexión,se usan el parpadeo del LED incorporado en la placa de desarrollo, dado por el pin del modelo de placa usado (Revisar la hoja de datos)-

    int LED_pin=2;

    En el bloque de inicio también se establecen valores para otros parámetros. Las placas de desarrollo facilitan esta opción al encontrarse conectadas por el cable USB, por lo que se añade la opción de activar mensajes en cada bloque con la bandera serial_msg = true.

    En el caso de que ya no se requieran, se descartan las instrucciones de mensajes usando el valor bandera serial_msg = false. También se usa esta opción con los módulos compactos como el ESP01, que no posible usar mensajes por USB por lo limitado de pines disponibles.


    2. Bloque de configuración - setup()

    El dispositivo se inicializa con el bloque setup(), primero indicando el modo uso como salida de pin LED_pin.

    void setup() {
      if (serial_msg){
        Serial.begin(115200); //115200,74880
      }
      
      // LED interno, Enciende en LOW
      pinMode(LED_pin, OUTPUT);
    
      // conexión WIFI
      inicia_wifi();
    }
    

    Luego sigue las instrucciones del procedimiento inicia_wifi(), dedicada a establecer la conexión con el router. En teoría se debería ejecutar solo una vez, sin embargo podría requerir conexión, por ejemplo ante una falla de energía eléctrica en el sector.


    3. Bucle o lazo de operación - loop()

    La operación del dispositivo se realiza siguiendo las instrucciones del bucle 'loop()'

    El primer paso es verificar si se ha logrado una conexión, de no ser el caso, se repite el procedimiento inicia_wifi()en el que se realizan varios intentos previo a retomar las instrucciones para no dejar sin atender el resto de la operación del dispositivo, por ejemplo la lectura periódica de sensores.

    Luego se tiene el bloque de parpadeo de LED como única operación del dispositivo.

    Para la versión de placa con ESP8266, se usa la instrucción yield() que cede tiempo de procesamiento al microcontrolador para procesar los detalles de la parte inalámbrica, pues el ESP8266 se tiene un solo núcleo y los procesos se realizan en tiempo compartido.

    En el caso de ESP32 que tiene dos núcleos, un núcleo se dedica a la parte del manejo inalámbrico, por lo que no es necesaria la instrucción anterior.

    4. Procedimientos y Funciones

    Los pasos para conexión al Router y reconexión se pueden requerir más de una vez, por lo que se separan en un procedimiento denominado inicia_wifi(){ }.

    En esta sección se define el modo como estación para la conexión del dispositivo y se procede a la llamada del proceso inicial de conexión de la librería WiFi.

      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);

    Se requiere de un intervalo de tiempo determinado por la variable espera para obtener el resultado del proceso y establecido en al menos 10.

    En éste proceso el parpadeo del LED se definide en la tabla para "NO conectado" en la pagina anterior como 300 ms encendido  y 200 ms apagado.

    Cuando se establece la conexión y se dispone de la bandera serial_msg = true, se puede mostrar los valores para algunos parámetros en la red como estado, MAC, IP, RSSI.

    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.print(" Canal: ");
          Serial.println(WiFi.channel());
          Serial.println();
          }

    5. Instrucciones en Arduino IDE

    Se compone de dos secciones separadas en pestañas: la sección principal y la de procedimiento de inicia_wifi().

    5.1 Sección principal

    /* WIFI Blink Ejemplo de conexión a WiFi con ESP8266/ESP32  
     * edelros@espol.edu.ec 2019
    */
    // detectar placa al compilar
    # ifdef defined(ESP8266)
      #include <ESP8266WiFi.h>
    # elif defined(ESP32)
      #include <WiFi.h>
    # endif
    WiFiClient wificlient;
    
    // WIFI: conexión a Router
    char* ssid = "miRouter";
    char* password = "miRouterClave";
    
    // LED interno, ESP01-pin=1, ESP07-pin=2
    int LED_pin = 2;
    
    // Mensajes por Puerto Serial. ESP01 usar false
    volatile boolean serial_msg = true;
    
    void setup() {
      if (serial_msg){
        Serial.begin(115200); //115200,74880
      }
      
      // LED interno, Enciende en LOW
      pinMode(LED_pin, OUTPUT);
    
      // conexión WIFI
      inicia_wifi();
    }
    
    void loop() {
      
      // Conectado, LED Parpadea, enciende en LOW
      if (WiFi.status() == WL_CONNECTED){
        digitalWrite(LED_pin, LOW);
        delay(1000); // un segundo
        
        #ifdef defined(ESP8266)
          yield();
        #endif
        
        digitalWrite(LED_pin, HIGH);
        delay(1000);
        }
        
      if (WiFi.status() != WL_CONNECTED){
        digitalWrite(LED_pin, LOW);
        delay(300);
        digitalWrite(LED_pin, HIGH);
        delay(200);
        
        #ifdef defined(ESP8266)
          yield();
        #endif
        }
    
      // WiFi reconectar si está inactivo
      if (WiFi.status() != WL_CONNECTED){
        inicia_wifi();
      }
    }

    5.2 Otras pestañas o procedimientos

    Proceso en otra pestaña: wifi_inicia a continuación de las instrucciones anteriores.

    Nota: Se ha usado el nombre de pestaña con las palabras intercambiadas para distinguir entre pestaña y procedimiento.

    void inicia_wifi(){
      int espera = 10; // >=10 para conectar
      int cuenta = 0;
    
      // mensajes por serial activado
      if (serial_msg){
        Serial.print(" WIFI Conectando a ");
        Serial.println(ssid);
        }
    
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);
      
      while ((WiFi.status()!=WL_CONNECTED)&&(cuenta<espera)){  
        cuenta = cuenta+1;
        
        // Parpadeo de Monitor enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(300);
        digitalWrite(LED_pin, HIGH);
        delay(200);
        
        if (serial_msg){
          Serial.print(".");
          }
        }
        
      //activado mensajes por serial
      if (serial_msg){
        //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();
          }
        }
      }

    6. Compilar y subir las instrucciones

    Una vez terminado el archivo de instrucciones, se graba en un directorio de trabajo, por ejemplo c:\IoT_Taller, con un nombre simple, sin espacios ni tildes, la extensión del archivo.ino se añade de forma automática.

    Antes de realizar el proceso de enviar el archivo compilado a la placa, verifique que se encuentra seleccionada la placa de desarrollo que está usando: ESP8266 o ESP32 en el menú de Herramientas/Placa.

    Verifique que se ha seleccionado el 'Puerto COM' donde se encuentra conectada la placa usando el menú de herramientas, puerto asignado, semejante a lo mostrado en la figura.

    Para pasar las instrucciones a la placa de desarrollo se usa el botón "subir", en el proceso primero se verifica que no existan errores o inconsistencias de sintaxis. De estar las instrucciones en orden, se transfieren al dispositivo.

    En el caso de la placa ESP32 se requiere que se presione también el botón BOOT de la placa de desarrollo. En la versión ESP8266 este paso no es necesario.

    En la parte inferior de la ventana se muestran mensajes del proceso de comunicación entre el computador y la placa de desarrollo,

    Al terminar se reinicia por si misma la placa de desarrollo y se muestra el resultado de las instrucciones.

    7. Estados de conexión con mensajes a puerto serial

    Durante el desarrollo es favorable disponer de mensajes en el computador que muestren los estados o valores de las variables para una revisión paso a paso de lo que sucede en el dispositivo.

    Las placas de desarrollo facilitan esta opción al encontrarse conectadas por el cable USB, por lo que se añade la opción de activar mensajes en cada bloque con la bandera serial_msg = true

    Al inicializar el dispositivo se indica la velocidad de comunicación entre el dispositivo y el computador por el puerto USB mediante la instrucción:

    Serial.begin(74880)

    en adelante lo que se usa es mostrar un mensaje o valor de variable con las instrucciones:

        Serial.print(" WIFI Conectando a ");
        Serial.println(ssid);

    obteniendo los resultados en la ventana del computador obtenida en el menú "Herramientas/Monitor Serie"

    3.2 Resultado de mensajes recibidos en "Monitor Serie" con Arduino IDE

    Se obtiene unos resultados semejantes a los mostrados en la ventana

    ..........
    Mode: STA
    PHY mode: N
    Channel: 6
    AP id: 0
    Status: 1
    Auto connect: 1
    SSID (15): miRouter
    Passphrase (10): miRouterClave
    BSSID set: 0
    
     WIFI Conectando a miRouter
    .........
     Estado: 3
     MAC: 2C:3A:E8:0A:98:66
     IP: 192.168.10.11
     RSSI: -74

    Hasta aquí el proceso de las instrucciones para conexión, detallada paso a paso la estructura de programación, librerías y parámetros usados.

    Las siguientes secciones amplían la funcionalidad del dispositivo conectándose con los otros componentes del esquema de IOT, añadiendo manejar mensajes hacia un broker y la gestión de los estados.

  • 1. IoT WiFi - Conceptos

    1. Conexión a un Router WiFi

    Se desarrolla el primer paso del proceso, que tiene como objetivo conectar el dispositivo a la red de datos WiFi.


    Las placas de desarrollo ESP8266/ESP32 tienen un LED incorporado que puede ser usado para el propósito de disponer de un medio de observación de estado de "conectado" o "NO conectado"en el ejercicio.

    1.1 Estado - Conectado / NO conectado

    El estado de Conectado a Wifi  se puede mostrar con un parpadeo LENTO del LED, encendido por un segundo  y apagado en el siguiente segundo, es decir un periodo total de 2 segundos.

    Para el proceso de Inicio de conexión  a Wifi, el parpadeo del LED puede ser más RAPIDO y actua como indicador de estado del dispositivo.

    En un microcontrolador el tiempo se marca en milisegundos, por lo que los valores a usar en cada estado del proceso se indican en ms en la siguiente tabla.

    EstadoConectadoNo conectado
    LED encendido1000 ms300 ms
    LEd Apagado1000 ms200 ms
     LENTORAPIDO

    El LED incorporado en la placa de desarrollo se direcciona o activa por medio de un PIN de la placa. El Pin predeterminado de la placa de desarrollo ESP8266 y ESP32 es el PIN 2, que como no requiere conexión adicional solamente se indica al inicio de las instrucciones.

    int LED_pin = 2;

    1.2 Parámetros de la red WiFi

    Como en toda conexión a WiFi realizada con el computador o el móvil, se require dos parámetros:

    parámetrovariablevalor ejemplo
    identificador de routerssid"miRouter"
    contraseñapassword"miRouterClave"

    Los valores mostrados son de ejemplo, en su caso particular debe sustituir con los valores de la red que requiera conectarse.

    2. Esquema de Instrucciones para el dispositivo

    Las instrucciones para un microcontrolador usan tres bloques principales: inicio, configuración setup(), bucle o lazo de operación loop().

    El bloque de inicio contiene las librerías de los procesos y funciones que se usaran en la operación del dispositivo, establecen  los parámetros de uso de los PINes de entrada y salida, parámetros de la red que se describieron en el numeral anterior. Adicionalmente contiene comentarios referentes al uso de las instrucciones, autor, etc.

    El bloque de configuración, también conocido como setup(), usa los parámetros del bloque de inicio para configurar el dispositivo al arrancar, cuando se energiza o reinicia. Establece el tipo de uso de cada PIN, como entrada o salida, inicia los procesos de operación que requieren ser llamados una sola vez.

    El bucle o lazo de operación, también conocido como loop(), es un lazo infinito que se encarga del comportamiento del dispositivo de acuerdo a las instrucciones dadas. Lo de lazo infinito se usa en el contexto que mientras el dispositivo tenga energía, esté conectado o no se reinicie.

    /* Bloque de inicio 
     *  donde van las librerias, parámetros
     *  variables globales
     */
    void setup() {
      // instrucciones de configuración inicial
      // funcionan una sola vez al encender el dispositivo
    
    }
    
    void loop() {
      // instrucciones de operación del dispositivo
    
    }
    
    void inicia_wifi(){
      // procedimientos o funciones que se repiten
      // en los bloques anteriores ej: conectar/reconectar
      // a WiFi, lectura de sensores, manejo de mensajes MQTT
      
    }

    Dado que durante el proceso de operación pueden ocurrir desconexiones a la red WiFI, podría ser necesario reiniciar el proceso de conexión. Los procesos que se repiten o se dedican a un propósito particular se realizan aparte.

    Ante una situación de desconexión, al inicio del bucle de operación se realiza la revisión del estado de conexión para de no tener estado de "conectado" se realice el proceso nuevamente con varios intentos antes de proceder a atender las actividades normales de operación como la lectura de sensores.

    La instrucción yield() cede tiempo de procesamiento del microcontrolador para procesar detalles de la parte inalámbrica. Esta operación se usa con ESP8266 pues se tiene un solo núcleo y las operaciones trabajan en tiempo compartido.

    En el caso de ESP32 que tiene dos núcleos, un núcleo se dedica a la parte del manejo inalámbrico, por lo que no es necesaria la instrucción yield().

    3. Instrucciones con uso de pestañas en Arduino IDE

    Cuando las instrucciones son numerosas, muchas líneas, existen varios bloques de procedimientos y funciones, se usan bloques que los agrupan en  pestañas. Esto simplifica la lectura de las instrucciones y permite enfocarse en sus partes en lugar de tener todas en una misma hoja.

    La parte principal del algoritmo se escribe en la primera pestaña, que tiene el mismo nombre que el archivo. Para añadir pestañas se dispone de un botón a la derecha de la barra, marcado en la figura con rojo.

  • 3. IoT IDE Arduino


    IDE:

    ESP32

    ESP8266


    1. IDE Arduino con ESP32

    Referencia: https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-ide/boards_manager.md

    La versión más actualizada de los módulos de Expressif es la ESP32. Semejante a la versión anterior, se puede usar el IDE Arduino incorporando la placa al Entorno de Desarrollo Integrado. La placa de desarrollo ESP32 se muestra en la figura:

    esp32 diagrama

    La mayor ventaja de ésta placa de desarrollo es la variedad de pines de diferentes tipo, por ejemplo la cantidad de ADC (convertidores analógicos digitales) que se incrementaron respecto a las versiones anteriores. También tiene un microcontrolador de doble núcleo y uno de ellos se dedica solamente a la parte del manejo inalámbrico.

    Existen otros módulos y placas de desarrollo que funcionan de forma semejante, variando algunas posiciones de pines. Se recomienda revisar su configuración antes de usar los pines en en protoboard.

    Observación: En algunos módulos, se incorpora un botón pulsador para el pin GPIO0 que debe ser presionado durante el proceso de carga de programa.

    Para la carga de instrucciones, el ESP 32 requiere tener presionado el botón "BOOT", que en la imagen es el botón en la parte inferior derecha.

    1.1 ESP32 –  Incluir entre las tarjetas del IDE

    Para incorporar la tarjeta el entorno de trabajo se procede de forma semejante a lo realizado para la versión ESP8266:

    menu archivo preferencias

    En el menú Archivo/Preferencias, se añade en la sección “Gestor de URL’s Adicionales de Tarjetas” la dirección:

    https://dl.espressif.com/dl/package_esp32_index.json

    en caso de existir otra dirección previa, se añade con una coma ','

    preferencias gestor de urls adicionales de tarjetas

    En el menú de Herramientas/Placas/Gestor de tarjetas, se añade “ESP32 by Espressif Systems”

    gestor de tarjetas

    Con lo que se habilita la opción se seleccionar como placa un ESP32, por ejemplo: “ESP32 Dev Module”

    menu herramientas placa selección

    Con lo que es posible usar los scripts presentados como ejemplo con la placa ESP32, usando las librerías respectivas.

    1.2 Librerías

    Para los módulos ESP32 se usa la librería <WiFi.h> que contiene entre las instrucciones el manejo de datos como MAC, IP, RSSI, valores de estado de conexión, etc.

    Las librerías se instalan en el menú "Programa/Incluir Liberia/ Administrar Bibliotecas".

    menu programa incluir libreria

    Puede buscar la librería usando las palabras "Wifi ESP". Asegúrese de tener instalada la librería WiFiManager mostrada en la imagen.

    gestor de librerias search

    con esta acción es posible usar la librería mediante la instrucción:

    #include <WiFi.h>

    pudiendo luego crear un cliente en la red y usar lo necesario para la operación del dispositivo de forma inalámbrica.

    WiFiClient wifiClient;

    IDE:

    ESP32

    ESP8266


    2. IoT IDE Arduino con ESP8266

    Referencia: https://github.com/esp8266/Arduino,
    https://www.espressif.com/en/products/socs/esp8266

    Las instrucciones para la operación del dispositivo que se transfieren a la placa de desarrollo o circuito implementado con microcontrolador usan: un cable USB y un IDE  (entorno de desarrollo integrado).

    Asegúrese de disponer de estos elementos para continuar a la siguiente sección.

    2.1 ESP8266 -  Incluir entre las tarjetas del IDE Arduino

    Para acceder a las placas de desarrollo de Expressif desde el IDE Arduino, se requiere añadir las librerías y especificaciones del módulo ESP8266 en el programa.

    En el menú Archivo/Preferencias, en la parte de "Gestor de URL's Adicionales de Tarjetas" se añade la dirección:

    http://arduino.esp8266.com/stable/package_esp8266com_index.json

    En menú de Herramientas/Placas/Gestor de tarjetas, se añade "ESP8266 Community". Para encontrarlo en la lista, se puede buscar y filtrar con las palabras esp8266.

    En el "Gestor de tarjetas" se selecciona la versión "ESP8266 Community" más actualizada, y se instala:

    La acción anterior habilita la opción para seleccionar como placa de trabajo: "Generic ESP8266 Module"

    Con lo que es posible usar los ejemplos que se presentan a continuación como ejemplo con el ESP8266 en cualquiera de sus versiones: ESP-01, ESP-07, etc.

    2.2. Librerías

    Para los módulos ESP8266 se usa la librería <ESP8266WiFi.h> que contiene entre las instrucciones el manejo de datos como MAC, IP, RSSI, valores de estado de conexión, etc.

    Las librerías se instalan en el menú "Programa/Incluir Liberia/ Administrar Bibliotecas".

    Puede buscar la librería usando las palabras "Wifi ESP". Asegúrese de tener instalada la librería WiFiManager mostrada en la imagen.

    con esta acción es posible usar la libreria mediante la instrucción:

    #include <ESP8266WiFi.h>

    pudiendo luego crear un cliente en la red y usar lo necesario para la operación del dispositivo.

    WiFiClient wifiClient;

    IDE:

    ESP32

    ESP8266


    3. Controlador USB CH340

    Normalmente Windows reconoce la placa de desarrollo conectada en el puerto USB como un dispositivo USB CH340. Sin embargo, en caso de requerir instalarse, puede usar el "driver" del siguient enlace de sparkfun:

    Referencia: https://learn.sparkfun.com/tutorials/how-to-install-ch340-drivers/all


    IDE:

    ESP32

    ESP8266


  • 2 IoT Dispositivo - Hardware/Software



    A partir del planteamiento del esquema abierto, se propone iniciar con los componentes más básicos para revisar los conceptos y su aplicación de forma simultanea.

    Un dispositivo conectado a una red inalámbrica de datos WiFi se implementa usando un hardware, de preferencia abierto (open hardware).

    Para darle las instrucciones de operación se usa también un software.

    Ambos componentes se describen a continuación.



    1. Hardware

    El hardware del dispositivo  se compone principalmente de un microcontrolador con otros componentes que añaden conectividad a un computador y/o una red de datos.

    Un elemento de desarrollo muy conocido es el Arduino, en la imagen se muestra la versión UNO.

    Para el caso de hardware con conexión a WiFi se encuentra muy difundido el uso de las placas de desarrollo basados en ESP8266 y ESP32 de Expressif.

    1.1 Hardware - Placa de desarrollo

    Las placas de desarrollo simplifican el aprendizaje al incorporar los componentes necesarios para conectarse por USB a un computador, para facilitar la programación de los dispositivos y la transmisión de los datos. Estas placas son un buen punto de partida para el desarrollo de prototipos.

    1.2 Hardware - Módulo

    Un módulo es la parte dedicada a un solo propósito como la conexión inalámbrica. En la figura se muestra el módulo ESP8266 versión ESP-07.

    Un módulo puede conectarse como complemento a varios tipos de microcontroladores, por ejemplo: la placa Arduino que usa el microcontrolador ATmega328P

    En el caso de ESP8266 y ESP32, el microcontrolador que maneja la parte inalámbrica puede también ser usado para las instrucciones de control de sensores, y funciones que realiza un dispositivo básico.



    2. Software / instrucciones

    El software corresponde a las instrucciones de operación del dispositivo que se pueden escribir en un editor del Entorno Integrado de Desarrollo o IDE (Integrated Development Environment).

    Las instrucciones se transfieren desde el computador a la placa de desarrollo mediante una conexión USB. Recuerde usar un cable USB apropiado para transferencia de datos, el cable es el que permite conectar su dispositivo móvil al computador y transferir archivos.

    Nota: El cable usado solo para cargar el móvil no es de utilidad en éstos casos.



    2.1 Arduino IDE

    Un software IDE (Integrated Development Environment) muy conocido es Arduino IDE que es abierto y principalmente gratuito.

    https://www.arduino.cc/en/software

    El Arduino IDE permite integrar otras placas de desarrollo de otros fabricantes como Espressif del tipo ESP8266 y ESP32.

    El IDE Arduino tiene una interface simple y fácil de usar, con elementos suficientes para escribir, depurar la instrucciones, seleccionar las placas a usar y observar los resultados en el computador.

    El proceso de instalación es simple, solo requiere ejecutar el archivo descargado de instalación.

    2.2 Micropython

    Otra forma de escribir instrucciones de operación en los dispositivos es Micropython, que es una implementación simplificada de Python 3 para trabajar con microcontroladores con entornos limitados.

    https://micropython.org

    Otras las placas como ESP32/ESP8266 también permiten configurarse para responder a instrucciones en Micropython, por lo que se vuelven una opción si ya es usuario de Python desde los cursos básicos.

    El IDE usado en Micropython es Thonny IDE, que viene instalado de forma predeterminada en Rasberry Pi OS, y puede ser incorporado al IDE básico de Python 3, o WinPython.

    https://thonny.org

    La función principal de Thonny IDE es que trae incorporado en el menú la selección de la placa de desarrollo conectada al puerto USB de la computadora. Soporta las placas Raspberry Pi Pico, ESP32 y ESP8266 entre otros.

    Instale la versión de software que usará como IDE para realizar los ejercicios que sea de mayor interés.


    Los conceptos se aprenden fácilmente al implementar algunos ejemplos de dispositivos IoT básicos, donde se vuelve a describir en mayor detalle cada componente del Esquema Abierto IoT.

    En las siguientes secciones se dan algunos ejemplos que integran teoría y práctica que se pueden seguir paso a paso.



  • 1. IoT Esquema abierto (Open) por capas



    Como una introducción para desarrollo IoT, Internet of Things,  se usa un esquema que agrupa los componentes en secciones y capas. Cada una de las secciones se encarga de una parte de todo el proceso, simplificando los pasos para tener componentes funcionales que interactúen como un todo.

    Esquema Capas 01

    El esquema básico presentado empieza con lo más tangible, las "cosas" ("Things" en inglés) presentado en el bloque inferior en color gris.

    El "usuario" observa, controla y se beneficia del estado de las cosas representando una sección importante en el esquema en los bloques en azul.


    1. Las cosas (Things)

    Cosas Estado 01

    Las "cosas" representan el artefacto que se desea conocer o controlar su estado.

    Para conocer el estado  por ejemplo abierto/cerrado, 0/1, se usan sensores.

    Para controlar el estado de las cosas, por ejemplo un foco, se usan actuadores.


    2. Usuario
    Teletrabajo 01

    El "usuario" observa, controla, se beneficia del estado de las cosas y accede a ellas en forma "presencial" o "virtual".

    Para que usuario llegue hasta las cosas, se crea un camino con algunos componentes tecnológicos intermedios que son los que se tratan en cada página del blog.


    3. Componentes o Capas

    FIEC03236 textmsg

    Cada componente añade una función específica a la infraestructura IoT.

    Algunos componentes son de uso cotidiano y los dispone en el hogar, la oficina, el aula.

    Por ejemplo, un teléfono móvil, tablets, PC, un «router Wifi», son componentes que se actualmente se encuentran muy difundidos.

    La extensa adopción de estos componentes facilita el despliegue del Internet de las cosas (IoT).


    4. Esquemas Abiertos de Hardware y Software

    La infraestructura IoT se conforma de  Hardware y Software, ambos se pueden desarrollar e implementar con herramientas de esquema abierto conocidos como,

    • Open Hardware
    • Open Software
    Open Hw Sw 01

    Para lo presentado en Girni IoT, se tiene preferencia en los esquemas abiertos.



    5. Explorando un poco de IoT

    Para explorar el esquema abierto IOT se revisa un ejemplo base, simplificado para incorporar un dispositivo sensor/actuador. El primer ejemplo a desarrollar es un  sensor de estado de Puerta-Ventana.

    D01 Puerta Ventana 01

    El estado de la "cosa", puerta o ventana es cerrado o abierto. El estado se representa por un 1 o 0, ON/OFF, es también conocido como un estado binario.

    Se usa un sensor tipo "interruptor magnético" con estados: abierto o cerrado, que permite determinar el estado de la puerta.

    Un dispositivo registra el estado o lectura del sensor magnético, y genera un mensaje  de estado de "ON/OFF" para enviarlo a un punto central de gestión de la información (servidor o broker).

    El dispositivo realiza las operaciones de revisión de sensor y envío de mensajes usando un "microcontrolador", como Arduino, ESP8266, ESP32, etc.

    El dispositivo usa una red de datos alámbrica o inalámbrica para enviar el mensaje al broker, por ejemplo WiFi.

    El broker registra, gestiona y muestra el estado de la "puerta" al usuario. El broker realiza las funciones de servidor de mensajes y de página web, semejante a Twitter, facebook, etc.

    El broker puede ser un servidor en la nube, o puede ser implementado  de forma local con una PC o Raspberry Pi, lo que se tenga disponible.

    Sensor Puerta 03 Abierta HA

    Para que el mensaje del estado de la puerta se gestione en el broker, es necesario enviarlo por medio de una red de datos disponible.

    La red de datos en la actualidad es muy común en su forma inalámbrica WiFi o cableada Ethernet, el uso de estas redes genera un escenario donde se facilita la implementación del internet de las cosas IoT.

    El usuario puede revisar el estado de la "puerta" desde una página web, como un texto o símbolo, mostrado en la figura anterior.


    Esquema por componentes y proceso por Bloques

    La implementación e integración de éstos componentes se desarrolla paso a paso, empezando por los componentes más elementales y luego incorporando otros elementos que hacen de IoT un tema fascinante.

    D01 Puerta Ventana 02

    Un dispositivo IoT con Wifi  puede ser implementado con una placa de desarrollo con ESP8266/ESP32, inicialmente el proceso varía en detalles con la placa de desarrollo que tenga disponible. Las placas en la actualidad ya no presentan una diferencia muy grande en costos, por lo que el modelo depende más de la placa que tenga disponible para un primer ejercicio.

    El proceso general para conectar un dispositivo IoT tiene varias fases o bloques:

    1. Conexión al router de una red WiFi.
    2. Envío de un mensaje de estado/acción de un sensor o actuador a un Gestor de mensajes (Broker) MQTT, por ejemplo Mosquitto.
    3. Registro el estado/acción de un sensor o actuador con un Gestor de dispositivos, entre ellos Home Assistant.

    Las siguientes secciones desarrollan estos pasos



  • WiFi - Puerta-Ventana: MQTT-HA

    Esta es la última sección a realizar, pues se supone que tiene listo el dispositivo, construido y operativas las partes: Dispositivo y Broker.

    El objetivo es incorporar dispositivo sensor puerta-ventana en el broker MQTT y observar los resultados.

    Se plantea observar los estados del dispositivo en dos formas:

    • Desde un navegador en la página local de Home-Assistant
    • Desde una consola conectando al servidor MQTT

    1. Incorporar el dispositivo en Home Assistant

    Se requiere modificar el archivo configuration.yaml en el raspberry.

    Se puede realizar en forma local desde el raspberry que tiene monitor, teclado y mouse conectado, y editar el archivo que se encuentra en el directorio:

     /home/homeassistant/.homeassistant/configuration.yaml

    La otra forma es conectarse via remota por medio de una sesión ssh. Requiere dirección, usuario y password. Los detalles se dan en la sección Raspberry.

    En el archivo se añade los datos del dispositivo sensor, que en el caso del sensor de puerta ventana se clasifica como un sensor de dos estados (binary sensor).

    El sensor trabaja con MQTT, se le asigna un nombre más sencillo de reconocer como "puerta oficina"y se complementa con la instrucción de identificación en el formato: lugar/cosa/estado.

    mqtt: 
      - binary_sensor:
          name: 'oficina_puerta1'
          state_topic: "oficina/puerta1/estado"
          expire_after: 10  # segundos, estado de NO disponible
    

    Se graba el archivo, y se pasa al procedimiento de prueba desde la página de Home-Assistant, sección de
    Herramientas para desarrolladores/Comprobar configuración

    Si obtiene el resultado de:

    ¡La configuración no impedirá que se inicie Home Assistant!

    caso contrario, revise nuevamente el archivo configuration.yaml

    procede a la Recarga la configuración YAML
    con el botón: ENTIDADES MQTT MANUALMENTE CONFIGURADAS

    Home assistant tarjeta boton

    El resultado se observa desde una página en un navegador como se muestra en las figuras: para las posiciones de puerta cerrada y abierta

    Home assistant tarjeta boton

       Observe el estado de la puerta y la gráfica mostrada en la pantalla del equipo.

    Home assistant tarjeta boton foto
    Home assistant tarjeta boton foto

      

    Referencia: https://www.home-assistant.io/components/binary_sensor.mqtt/

    1.2  Monitoreo desde MQTT

    Para monitorear señal desde consola Raspberry usando MQTT, usar la instrucción:

    mosquitto_sub -h 192.168.10.100 -t oficina/puerta1/estado

    Se observarán los valores de cambio de estado cada vez que se realice un cambio en el sensor.

  • WiFi - Puerta-Ventana: Archivo.ino

    1. Instrucciones en Arduino IDE

    Como la versión del ESP8266-01 no dispone de muchos pines de trabajo, se define el uso de los pines como:

    • monitor de operación del dispositivo: LED interno, GPIO1 (TXD)
    • lectura de sensor en GPIO3, pin 7, mismo que es configurado como RXD en modo PROG.

    Por el uso en operación de los pines de comunicación Serial (GPIO1 y GPIO3) se descartan las lineas Serial.print() convirtiéndolas en comentarios //. La instrucción para encender el LED de monitor también activa para TXD, por lo que de tener conectado la comunicación serial podría mostrar caracteres ilegibles.

    El diseño realizado permite conectar un módulo USB-TTL a la placa PCB. Revise la configuración de las botoneras Reset, PROG y los Jumpers para realizar la carga del archivo.ino. Si la subida del archivo.ino al módulo ESP01  se realiza fuera de la placa PCB revise nuevamente la configuración de PCB para que trabaje en modo "Ejecutar" luego de insertar el módulo ESP01.

    2. Funciones repetitivas

    Para las acciones repetitivas como la conexión a WIFI y comunicación por MQTT se realizan en funciones para simplificar las instrucciones en la configuración inicial (setup) y la ejecución principal (loop).

    Al inicio se definen las librerías y los valores para la conexión WIFI y los datos para comunicarse con el servidor MQTT-Mosquitto implementado en el Raspberry. Revisar de ser necesario al sección Broker.

    /* ESP8266 Sensor de Puerta. edelros@espol.edu.ec
     *  Para usar, actualice las secciones de:
     *  - WIFI:Router, MQTT:Servidor, MQTT:Dispositivo
     *  ESP-01 al usar GPIO1 y GPIO3,(Tx,Rx), NO USE Serial.print()
    */
    #include <ESP8266WiFi.h>
    #include <PubSubClient.h>
    
    // WIFI: conexión a Router
    char* ssid = "xxxx";
    char* password = "xxxx";
    
    // MQTT: Servidor
    char* MQTT_IP = "192.168.xx.xx";
    uint16_t MQTT_puerto = 1883;
    char* MQTT_usuario = "usuarioprueba";
    char* MQTT_contrasena = "usuarioclave";
    
    // MQTT: Dispositivo Interruptor
    char* MQTT_ID = "oficina_puerta1";
    char* MQTT_TOPIC = "oficina/puerta1/estado";
    char MQTT_SensorEstado[10] = "OFF";
    volatile boolean mqtt_desconectado = true;
    char* sensor_ON  = "ON";
    char* sensor_OFF = "OFF";
    
    // Sensor Interruptor
    const uint8_t sensor_pin = 1;
    volatile boolean sensor_estado = false;
    volatile boolean sensor_bandera = true;
    
    // Actuador LED
    volatile boolean actuador_estado = false;
    const uint8_t LED_actuador = 2;
    
    // LED monitor //interno: ESP01-pin=1, ESP07-pin=2
    const uint8_t LED_pin=0;
    
    // Clientes WiFi y MQTT
    WiFiClient wifiClient;
    PubSubClient mqttclient(wifiClient);
    
    void setup() {
      // SENSOR Interruptor
      pinMode(sensor_pin, INPUT);
      attachInterrupt(digitalPinToInterrupt(sensor_pin),sensorActivado,CHANGE);
      
      // ACTUADOR LED
      pinMode(LED_actuador, OUTPUT);
      // LED monitor, Enciende en LOW
      pinMode(LED_pin, OUTPUT);
    
      // conexión WIFI y MQTT
      inicia_wifi();
      if (WiFi.status() == WL_CONNECTED){
        inicia_mqtt();
        }
      }
    
    void loop() {
      // Revisa cambios en interruptor
      if (sensor_bandera){
          delay(10);
          sensor_estado = digitalRead(sensor_pin);
        if (sensor_estado==LOW){
          actuador_estado = true;
          }
        if (sensor_estado ==HIGH){
          actuador_estado = false;
          }
        ACTUADORactivaestado();
        publica_estado();
        sensor_bandera = false;
        }
      yield(); // procesa wifi
      
      if (WiFi.status() != WL_CONNECTED){
        inicia_wifi();
        }else{
        if (mqttclient.connected()==false){
            mqtt_desconectado = true;
            inicia_mqtt(); // reintento
          }
        if (mqttclient.connected()==true){
          if (mqtt_desconectado==true){
            publica_estado();
            mqtt_desconectado=false;
            }
          mqttclient.loop();
          }
        }
      yield(); // procesa wifi
    }
    
    // ISR interrupción activada
    ICACHE_RAM_ATTR void sensorActivado(){
      sensor_bandera = true;
      }
    
    // Actuador activar estado
    void ACTUADORactivaestado(){
      if (actuador_estado){
          // LED actuador ilumina en apagado
          digitalWrite(LED_actuador, HIGH);
        }else{
          digitalWrite(LED_actuador, LOW);
        }
    
      }
    
    // Publicar el estado del dispositivo
    void publica_estado() {
        if (actuador_estado){
          snprintf (MQTT_SensorEstado,10, sensor_ON);
        }else{
          snprintf (MQTT_SensorEstado,10, sensor_OFF);
        }
        if (mqttclient.connected()==true){
          mqttclient.publish(MQTT_TOPIC,MQTT_SensorEstado,true);
        }else{
          mqtt_desconectado = true;
        }
    }
    
    void inicia_wifi(){
      int intentos = 10;
      int cuenta = 0;
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);
      
      while ((WiFi.status() != WL_CONNECTED) && (cuenta<intentos)){
        cuenta = cuenta+1;
        // Parpadeo de Monitor enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(300);
        digitalWrite(LED_pin, HIGH);
        delay(200);
        }
      }
    
    void inicia_mqtt(){
      int intentos = 2;
      int cuenta = 0;
      
      mqttclient.setServer(MQTT_IP, MQTT_puerto);
      mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
      
      while (!mqttclient.connected() && (cuenta<intentos)) {
        cuenta = cuenta + 1;
        // Parpadeo de Monitor enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(200);
        digitalWrite(LED_pin, HIGH);
        delay(200);
        }
      publica_estado();
      }
    
  • WiFi - Puerta-Ventana: Esquemático

    WiFi Dispositivo Sensor Puerta-Ventana

    El dispositivo sensor de Puerta Ventana se implementa usando tres componentes principales:

    • Sensor magnético
    • Microcontrolador con Wifi

    El dispositivo inalámbrico se usa para registrar el estado abierto o cerrado de una puerta o ventana.

    Se conoce como sensor binario por determinar estados ON/OFF.

    El dispositivo es de tipo inalámbrico-WIFI, usa protocolo MQTT para la comunicación con el broker y se implementa con ESP8266, en modalidad DIY (Do It Yourself).


    En éste caso el diseño usa la versión ESP-01.

    implementación versión 1

    La versión 1 mostrada en la imagen se ha instalado en una puerta en una caja sobrepuesta plástica.

    El sensor es un interruptor magnético y la alimentación se realiza con una fuente 110VAC a 5VDC obtenida de un cargador de celular (económico). Se ha usado una placa perforada para ensamblar el prototipo, sin embargo al final se presenta el diseño de la placa de circuito.

    Una segunda versión en placa perforada, probando los espacios para el diseño de la PCB.

    Premisas para desarrollo en la versión 1

    • Diseño de dispositivos con conexión inalámbrica WIFI
    • Conoce los datos para conexión a la red a WIFI y broker MQTT
    • Dispone de acceso a un broker MQTT local
    • Dispone de Arduino IDE para cargar las instrucciones en el ESP8266
    • Emplea diseños abiertos tipo: Open Hardware y Open Software
    • Dispone de los componentes en el mercado local
    • Considera componentes alternos a los no disponibles en el mercado local
    • Identifica las etapas de desarrollo e inconvenientes en la implementación.

    Temas para desarrollo posterior

    • Otros dispositivos tipo actuadores
    • Ampliar la forma de carga de scripts en el tablero, de forma alámbrica o inalámbrica.
    • Analizar consumos de corriente para uso con baterías.
    • Revisar el uso de los canales WIFI para evitar desconexiones por saturación de canal.

    2. Esquemático con ESP01

    El esquemático se divide en varias secciones mostradas en la figura y descritas a continuación.

    2.1 Sensor

    El sensor es un interruptor magnético, de los que se usa en los sistemas de seguridad como sensor de puertas y ventanas.

    2.2 Controlador

    Centrado en ESP8266-01 con conector para sensor. La activación del módulo se realiza de acuerdo a lo descrito en el manual del módulo. Revisar en la sección "Módulos" ESP8266 versión ESP-01.

    El reinicio del dispositivo se controla con la botonera "Reset" al cambiar el pin a estado BAJO (GND). El estado predeterminado es ALTO por medio de R1 y C1 minimiza los rebotes del pulsador.

    2.2.1 Modo Ejecución

    La operación predeterminada es "Ejecutar Programa" por medio de R3 hacia estado ALTO (pullup HIGH) y un jumper entre los Pines Sensor-RX. El Jumper conecta el Pin RXD a la entrada del sensor magnético.

    Para tomar la lectura de estado del sensor, se usa el pin RX configurado como entrada y estado predeterminado en ALTO con R5. El capacitor C2 se usa para minimizar las señales de rebote que se presentan en los interruptores.

    2.2.2 Modo Cargar Programa

    La carga de las instrucciones en archivo.ino se la realiza fuera de la placa mostrada.

    La botonera Reset dispone de R1 hacia estado predeterminado ALTO y C1 se usa para minimizar los rebotes.

    La configuración se completa manteniendo el estado de GPIO2 en estado ALTO (pullup HIGH) con R2 y el pin de CH_PD a estado ALTO mediante R4.

    2.3 Fuente DC

    Conformada por el Regulador d 110VAC  a 5VDC, y el Regulador de 5VDC a 3.3VDC usando el módulo AMS1117.

    Los componentes usados o sus sus componentes alternos se describen en la sección de Fuentes de Alimentación para Módulos.


    3. Ensamble en Protoboard

    Para probar el circuito se ensambla en un protoboard teniendo como guía el diagrama del circuito del punto anterior.


    Considere que como guía se incluye la parte de conexión AC. Se recomienda realizarla separada y tomando las precauciones de aislamiento que correspondan.


    4. Circuito impreso - PCB

    El diseño se ha realizado en dos placas por flexibilidad de ensamble. La placa de fuente de alimentación se puede reemplazar por un cargador USB, conectando a la primera placa del dispositivo a los conectores +5VDC-.

    Para el archivo de producción de placa, escribir al email de contacto al final de la página.

    Alternativas durante el proceso de desarrollo:

    Durante el desarrollo del prototipo se usó una placas perforadas de circuito impreso de 4x6 cm.

    Luego de algunas pruebas, se presenta la versión 2 del circuito impreso.

  • 4. Home Assistant - actualizar Python

    Las actualizaciones de Home Assistant en algunos casos usa una versión superior a la instalada en Raspbian OS, por lo que será necesario actualizar Python a versión sugerida.

    Por ejemplo, la actualización Home Assistant 2020.12.1 indica que es necesario disponder de Python 3.8.6 o superior. Por lo que de no disponer de la vesión actualizada es necesario incorporar algunas instrucciones para cumplir con el requisito.

    Las instrucciones para la actualización se pueden encontrar en:

    https://blog.bram.co.nl/how-to-upgrade-python-venv-to-3-8-6/

    Las instrucciones han sido probadas el 2020/12/29, un nuevo cambio podría ser necesario luego de un año, por lo que esta sección es relevante solo cuando aparece la alerta.


    Procedimiento probado

    Algunos programas requieren una versión más actualizada de Python, por ejemplo HomeAssistant. La lista de actualización de programas con sudo apt-get upgrade, puede estar un poco desactualizada respecto a las últimas actualizaciones de Python, debido a la realización de pruebas de compatibilidad.

    Sin embargo se puede realizar una actualización intermedia para cumplir con requerimientos de otros programas siguiendo algunas instrucciones.

    1. Python versiones disponibles

    Verifique la versión a instalar disponible del sitio oficial de Python:

    https://www.python.org/downloads/

    seleccione la versión que requiere y siga las instrucciones de la guía de la referencia. Para el ejemplo usamos a la fecha la versión 3.9. 0en lugar de la 3.7.3 que estaba disponible en el raspberry pi en la actualización oficial.

    (la versión 3.9.2 mostró incompatibilidades con home-assistant al 2021-03-26, seguro en la próxima actualización será mejor)

    requests 2.25.1 requires idna<3,>=2.5, but you'll have idna 3.1 which is incompatible.

    2. Actualizar Rasberry Pi

    Antes de iniciar el proceso, asegurarse de tener actualizado Rasberry Pi OS, puede seguir las instrucciones de: Raspberry Pi OS - Actualizar

    3. Actualizar Python

    Seguir las instrucciones del enlace de la referencia a partir del punto 2, con la versión que desea instalar.

    https://forums.raspberrypi.com/viewtopic.php?t=291158

    https://installvirtual.com/how-to-install-python-3-8-on-raspberry-pi-raspbian/

  • 3. Home Assistant - Configurar MQTT/TLS

    Para conectar Home-Assistant al MQTT Mosquitto, se requiere configurar los parámetros  de dirección, puerto, identificador de cliente, usuario y contraseña.

    Los parámetros se ingresan en el archivo configuration.yaml con la instrucción:

    sudo nano /home/homeassistant/.homeassistant/configuration.yaml
    

    añadiendo los parámetros con los datos propuestos como referencia en el ejemplo de MQTT-TLS con Parpadeo LED.

    mqtt:
      broker: 192.168.10.40
      port: 8883 #1883
      client_id: 'mqtt-srv'
      username: 'usuarioprueba'
      password: 'usuarioclave'
      tls_insecure: true
      certificate:  '/etc/mosquitto/certs/mqtt-srv.crt'
    

    Al reiniciar Home-assistant, debería operar con la configuración propuesta. Revisar la sección de Configuración/Registros, para observar si presenta algún problema de conexión.