Gestion de tarjetas SD con ESP32


Es obvio que las SD se han convertido en algo indispensable en nuestra vida digital , estando presentes en infinidad de dispositivos electrónicos como smartphones, cámaras digitales, cámaras de seguridad, reproductores multimedia, ordenadores, microcontroladores, y un larguísimo etcétera.

Por otro lado, de vez en cuando nos encontramos con proyectos basados en ESP32 ( y todas sus variantes) que necesitan una forma de almacenar una gran cantidad de datos de forma escalable y eficiente (es decir, necesitamos construir lo que viene a llamarse un registrador de datos o en ingle «datalogger»), siendo lo ideal por tanto usar con nuestro microntrolador precisamente estas tarjetas SD o micro SD, dada su gran capacidad para empaquetar GigaBytes de datos en un espacio más pequeño que una moneda.

SPI es un acrónimo que significa «Serial Peripheral Interface». Es un protocolo de comunicación serie que se utiliza para transferir datos entre dispositivos electrónicos, como microcontroladores, sensores, dispositivos de almacenamiento, etc. SPI permite a varios dispositivos compartir un canal de comunicación y cada dispositivo puede actuar como esclavo o maestro. El protocolo SPI es conocido por ser rápido y flexible, y por tener una arquitectura sencilla que permite una fácil integración en una amplia gama de aplicaciones electrónicas. Además, el protocolo SPI es compatible con una amplia gama de velocidades de transmisión de datos, lo que lo hace adecuado para una variedad de aplicaciones con diferentes requisitos de velocidad y capacidad de procesamiento.

Esp32

El ESP32 es un microcontrolador que incluye una interfaz de comunicación SPI, lo que significa que puede utilizar el protocolo SPI para comunicarse con otros dispositivos electrónicos. Aquí hay algunos de los usos más comunes de la interfaz SPI en el ESP32:

  1. Comunicación con sensores: El ESP32 puede utilizar la interfaz SPI para comunicarse con sensores, como acelerómetros, giroscopios, sensores de temperatura, etc.
  2. Comunicación con dispositivos de almacenamiento: El ESP32 puede utilizar la interfaz SPI para comunicarse con dispositivos de almacenamiento, como tarjetas SD o dispositivos Flash, para leer y escribir datos.
  3. Comunicación con pantallas táctiles: El ESP32 puede utilizar la interfaz SPI para comunicarse con pantallas táctiles y controlar la visualización y la entrada de datos.
  4. Comunicación con dispositivos de radiofrecuencia: El ESP32 puede utilizar la interfaz SPI para comunicarse con dispositivos de radiofrecuencia, como módulos Bluetooth o Wi-Fi, para transferir datos a larga distancia.

En resumen, la interfaz SPI en el ESP32 se puede utilizar para una amplia gama de aplicaciones, lo que lo hace una herramienta valiosa para desarrollar proyectos electrónicos y de Internet de las cosas.

En este post vamos a ver que en realidad leer o escribir datos en una SD ( o micro-sd) en el entorno de la familia Arduino es en realidad muy sencillo gracias a las librería SD y también al protocolo SPI para la comunicación con el lector de SD.

Descripción general del hardware.

Para este proyecto se ha probado el lector de sd de AZDelivery el cual nos proporciona una expansión fácil y económica del espacio de almacenamiento mediante la ranura SD. La comunicación es muy fácil con el microcontrolador a través del protocolo SPI (como vamos a ver ) y soporta tarjetas Micro SD (2G), tarjetas Micro SDHC (32G) (tarjeta de alta velocidad). Además el módulo lee todos los datos contenidos en la tarjeta SD y se puede conectar fácilmente a varios tipos de microcontroladores ( además si lo compramos a este fabricante incluye un E-Book que proporciona información útil sobre cómo comenzar su proyecto, ayuda con una configuración rápida y ahorra tiempo en el proceso de configuración proporcionándonos una serie de ejemplos de aplicación, guías de instalación completas y bibliotecas, etc.).

aspecto lector sd

El módulo de la tarjeta micro SD contiene dos componentes principales que, sin duda, hacen que sea fácil agregar el registro de datos a su próximo proyecto Arduino:

  • El voltaje de funcionamiento de cualquier tarjeta micro SD estándar es de 3,3 V. Por lo tanto, no podemos conectarlo directamente a circuitos que usan lógica de 5V. De hecho, cualquier voltaje que supere los 3,6 V dañará permanentemente la tarjeta micro SD. Es por eso; el módulo tiene un regulador de caída ultrabaja incorporado que convertirá los voltajes de 3,3 V a 6 V a ~3,3 V.
  • También hay un chip 74LVC125A en el módulo que convierte la lógica de la interfaz de 3,3 V-5 V a 3,3 V. Esto se llama cambio de nivel lógico. Eso significa que puede usar esta placa para interactuar con microcontroladores de 3,3 V y 5 V como Arduino.

En realidad, hay dos formas de interactuar con tarjetas micro SD: modo SPI y modo SDIO. El modo SDIO es mucho más rápido y se usa en teléfonos móviles, cámaras digitales, etc, pero desgraciadamente este modo es más complejo y requiere la firma de documentos de confidencialidad( por esa razón, es probable que los aficionados como nosotros nunca encuentren el código de interfaz del modo SDIO). En su lugar, cada módulo de tarjeta SD se basa en el modo SPI de «menor velocidad y menos sobrecarga» que es fácil de usar para cualquier microcontrolador (como Arduino).

Asignación de pines del módulo de la tarjeta Micro SD

El módulo de la tarjeta micro SD que vamos a usar es bastante simple de conectar. Tiene seis pines:

parte atras lector sd
  • VCC :El pin que suministra energía para el módulo y debe conectarse al pin de 5V en el Arduino.
  • GND (TIERRA): debe estar conectado a tierra de Arduino.
  • MISO (Master In Slave Out): es la salida SPI del módulo de tarjeta Micro SD.
  • MOSI (Salida maestra Entrada esclava): es la entrada SPI al módulo de tarjeta Micro SD.
  • SCK (reloj serie): pin acepta pulsos de reloj que sincronizan la transmisión de datos generada por Arduino.
  • CS (Selección de esclavo): es utilizado por Arduino (Master) para habilitar y deshabilitar dispositivos específicos en el bus SPI.

Preparación de la tarjeta micro SD

Antes de insertar la tarjeta micro SD en el módulo y conectarla al Arduino, debe formatear correctamente la tarjeta. Para la biblioteca Arduino que discutiremos, y casi todas las demás bibliotecas SD, la tarjeta debe estar formateada FAT16 o FAT32.

Si tiene una tarjeta SD nueva, es probable que ya esté formateada previamente con un sistema de archivos FAT. Sin embargo, es posible que tenga problemas con el formato de fábrica de la tarjeta o, si es una tarjeta antigua, debe reformatearse. De cualquier manera, siempre es una buena idea formatear la tarjeta antes de usarla, ¡incluso si es nueva!

Es recomendable utilizar la utilidad oficial de formateo de tarjetas SD : escrita por la asociación SD , ¡resuelve muchos problemas que surgen con un mal formateo! Descargue el formateador y ejecútelo en su ordenador, simplemente seleccione la unidad correcta y haga clic en FORMATEAR.

Captura de pantalla del formateador SD

Cableado: conexión del módulo de tarjeta Micro SD a Arduino

Ahora que su tarjeta está lista para usar, ¡podemos conectar la placa de conexión micro SD!

Para empezar, inserte el módulo de la tarjeta micro SD en una placa de pruebas. Conecte el pin VCC en el módulo a 5V en el pin Arduino y GND a tierra. Ahora nos quedamos con los pines que se usan para la comunicación SPI. Como las tarjetas micro SD requieren una gran cantidad de transferencia de datos, brindarán el mejor rendimiento cuando se conecten a los pines SPI del hardware en un microcontrolador. Los pines SPI del hardware son mucho más rápidos que «bit-banging» del código de la interfaz usando otro conjunto de pines.

Tenga en cuenta que cada placa Arduino tiene diferentes pines SPI que deben conectarse en consecuencia. Para placas ESP32 (En el ejemplo DOIT ESP32 DEVKIT1) esos pines son digitales 18 (SCK), 19 (MISO) y 23 (MOSI). También necesitará un cuarto pin para la línea ‘chip/slave select’ (SS). Por lo general, este es el pin 5, pero en realidad puede usar cualquier pin que desee (siempre que lo inicialize en el código).

Si tiene una placa Mega, ¡los pines son diferentes! Querrá usar digital 50 (MISO), 51 (MOSI), 52 (SCK) y 53 (SS). Consulte la siguiente tabla para una comprensión rápida.

MicroSD card moduleESP32
VCC+5v
CSGPIO 5
MOSIGPIO 23
CLKGPIO 18
MISOGPIO 19
GNDGND

En caso de que esté utilizando una placa Arduino diferente a la mencionada anteriormente, es recomendable consultar la documentación oficial de Arduino antes de continuar.

Para cablear el módulo de la tarjeta microSD a la placa ESP32, puede seguir el siguiente diagrama esquemático (para los pines SPI por defecto de ESP32):

esquema conexiones lector sd

Realmente dadas las poquísimas conexiones necesarias, el montaje se puede hacer directamente con un cable de cinta de 6 hilos como podemos ver en la imagen .

aspecto del montaje del lector de sd

Código Arduino: prueba del módulo de la tarjeta SD con CardInfo

Existen dos librerías diferentes para el ESP32 (incluidas en el núcleo de Arduino para el ESP32): la librería SD y la librería SDD_MMC.h.

Si utiliza la biblioteca SD, está utilizando el controlador SPI. Si usa la librería SDD_MMC estás usando el controlador SD/SDIO/MMC del ESP32.

Hay varios ejemplos en Arduino IDE que muestran cómo manejar archivos en la tarjeta microSD usando el ESP32. En el IDE de Arduino, vaya a Archivo > Ejemplos > SD(esp32) > SD_Test, o copie el siguiente código:


/*
    This sketch can be found at: Examples > SD(esp32) > SD_Test
*/

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
  Serial.printf("Listing directory: %s\n", dirname);

  File root = fs.open(dirname);
  if(!root){
    Serial.println("Failed to open directory");
    return;
  }
  if(!root.isDirectory()){
    Serial.println("Not a directory");
    return;
  }

  File file = root.openNextFile();
  while(file){
    if(file.isDirectory()){
      Serial.print("  DIR : ");
      Serial.println(file.name());
      if(levels){
        listDir(fs, file.name(), levels -1);
      }
    } else {
      Serial.print("  FILE: ");
      Serial.print(file.name());
      Serial.print("  SIZE: ");
      Serial.println(file.size());
    }
    file = root.openNextFile();
  }
}

void createDir(fs::FS &fs, const char * path){
  Serial.printf("Creating Dir: %s\n", path);
  if(fs.mkdir(path)){
    Serial.println("Dir created");
  } else {
    Serial.println("mkdir failed");
  }
}

void removeDir(fs::FS &fs, const char * path){
  Serial.printf("Removing Dir: %s\n", path);
  if(fs.rmdir(path)){
    Serial.println("Dir removed");
  } else {
    Serial.println("rmdir failed");
  }
}

void readFile(fs::FS &fs, const char * path){
  Serial.printf("Reading file: %s\n", path);

  File file = fs.open(path);
  if(!file){
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while(file.available()){
    Serial.write(file.read());
  }
  file.close();
}

void writeFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Writing file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)){
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

void appendFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file){
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)){
      Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void renameFile(fs::FS &fs, const char * path1, const char * path2){
  Serial.printf("Renaming file %s to %s\n", path1, path2);
  if (fs.rename(path1, path2)) {
    Serial.println("File renamed");
  } else {
    Serial.println("Rename failed");
  }
}

void deleteFile(fs::FS &fs, const char * path){
  Serial.printf("Deleting file: %s\n", path);
  if(fs.remove(path)){
    Serial.println("File deleted");
  } else {
    Serial.println("Delete failed");
  }
}

void testFileIO(fs::FS &fs, const char * path){
  File file = fs.open(path);
  static uint8_t buf[512];
  size_t len = 0;
  uint32_t start = millis();
  uint32_t end = start;
  if(file){
    len = file.size();
    size_t flen = len;
    start = millis();
    while(len){
      size_t toRead = len;
      if(toRead > 512){
        toRead = 512;
      }
      file.read(buf, toRead);
      len -= toRead;
    }
    end = millis() - start;
    Serial.printf("%u bytes read for %u ms\n", flen, end);
    file.close();
  } else {
    Serial.println("Failed to open file for reading");
  }


  file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }

  size_t i;
  start = millis();
  for(i=0; i<2048; i++){
    file.write(buf, 512);
  }
  end = millis() - start;
  Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
  file.close();
}

void setup(){
  Serial.begin(115200);
  if(!SD.begin(5)){
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();

  if(cardType == CARD_NONE){
    Serial.println("No SD card attached");
    return;
  }

  Serial.print("SD Card Type: ");
  if(cardType == CARD_MMC){
    Serial.println("MMC");
  } else if(cardType == CARD_SD){
    Serial.println("SDSC");
  } else if(cardType == CARD_SDHC){
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }

  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);

  listDir(SD, "/", 0);
  createDir(SD, "/mydir");
  listDir(SD, "/", 0);
  removeDir(SD, "/mydir");
  listDir(SD, "/", 2);
  writeFile(SD, "/hello.txt", "Hello ");
  appendFile(SD, "/hello.txt", "World!\n");
  readFile(SD, "/hello.txt");
  deleteFile(SD, "/foo.txt");
  renameFile(SD, "/hello.txt", "/foo.txt");
  readFile(SD, "/foo.txt");
  testFileIO(SD, "/test.txt");
  Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
  Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
}

void loop(){

}

Este ejemplo muestra cómo realizar casi cualquier tarea que pueda necesitar con la tarjeta microSD:

  • Listar un directorio;
  • Crear un directorio;
  • Eliminar un directorio;
  • Leer el contenido de un archivo;
  • Escribir contenido en un archivo
  • Añadir contenido a un archivo;
  • Renombrar un fichero;
  • Eliminar un archivo;
  • Inicializar tarjeta microSD;
  • Obtener tipo de tarjeta microSD;
  • Obtener el tamaño de la tarjeta microSD;


Alternativamente, puede utilizar los ejemplos SD_MMC – son similares a los ejemplos SD, pero utilizan el controlador SDMMC. Para el controlador SDMMC, necesita un módulo de tarjeta microSD compatible. El módulo que utilizamos en este post no es compatible con SDMMC.

Todos los ejemplos que vamos a a ver por tanto proporciona varias funciones para manejar archivos en la tarjeta microSD.

Listar un directorio


La función listDir() lista los directorios de la tarjeta SD. Esta función acepta como argumentos el sistema de archivos (SD), el nombre del directorio principal y los niveles para entrar en el directorio.

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
  Serial.printf("Listing directory: %s\n", dirname);

  File root = fs.open(dirname);
  if(!root){
    Serial.println("Failed to open directory");
    return;
  }
  if(!root.isDirectory()){
    Serial.println("Not a directory");
    return;
  }

  File file = root.openNextFile();
  while(file){
    if(file.isDirectory()){
      Serial.print("  DIR : ");
      Serial.println(file.name());
      if(levels){
        listDir(fs, file.name(), levels -1);
      }
    } else {
      Serial.print("  FILE: ");
      Serial.print(file.name());
      Serial.print("  SIZE: ");
      Serial.println(file.size());
    }
     file = root.openNextFile();
  }
}

He aquí un ejemplo de cómo llamar a esta función .

listDir(SD, "/", 0);

Obsérvese que es muy importante la barra invertida antes del directorio pues eso indica que el directorio esta en el directorio raiz .

Crear un directorio
La función createDir() crea un nuevo directorio. Pasa como argumento el sistema de ficheros SD y la ruta del nombre del directorio.

void createDir(fs::FS &fs, const char * path){
  Serial.printf("Creating Dir: %s\n", path);
  if(fs.mkdir(path)){
    Serial.println("Dir created");
  } else {
    Serial.println("mkdir failed");
  }
}

Por ejemplo, el siguiente comando crea un nuevo directorio en la raíz llamado mydir

createDir(SD, "/mydir");

Obsérvese que es muy importante la barra invertida antes del directorio pues eso indica que el directorio esta en el directorio raiz (y se llama mydir).

Eliminar un directorio
Para eliminar un directorio de la tarjeta microSD, utilice la función removeDir() y pase como argumento el sistema de archivos de la SD y la ruta del nombre del directorio.

void removeDir(fs::FS &fs, const char * path){
  Serial.printf("Removing Dir: %s\n", path);
  if(fs.rmdir(path)){
    Serial.println("Dir removed");
  } else {
    Serial.println("rmdir failed");
  }
}

He aquí un ejemplo:

removeDir(SD, "/mydir");

Obsérvese que es muy importante la barra invertida antes del directorio pues eso indica que el directorio esta en el directorio raiz (y se llama mydir).

Leer el contenido de un archivo
La función readFile() lee el contenido de un archivo e imprime el contenido en el Monitor Serial. Como en las funciones anteriores, pase como argumento el sistema de ficheros SD y la ruta del fichero.

void readFile(fs::FS &fs, const char * path){
  Serial.printf("Reading file: %s\n", path);

  File file = fs.open(path);
  if(!file){
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while(file.available()){
    Serial.write(file.read());
  }
  file.close();
}

Por ejemplo, la siguiente línea lee el contenido del archivo hello.txt.

readFile(SD, "/hello.txt")

Obsérvese que es muy importante la barra invertidas antes del fichero pues eso indica que el fichero esta en el directorio raiz (y se llama hello.txt).

Escribir contenido en un archivo
Para escribir contenido en un fichero, puede utilizar la función writeFile(). Pase como argumento el sistema de ficheros SD, la ruta del fichero y el mensaje.

void writeFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Writing file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)){
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

La siguiente línea escribe Hola en el archivo hola.txt.

writeFile(SD, "/hello.txt", "Hello ");

Obsérvese que es muy importante la barra invertidas antes del fichero pues eso indica que el fichero esta en el directorio raiz (y se llama hello.txt).

Añadir contenido a un archivo
Del mismo modo, puede añadir contenido a un archivo (sin sobrescribir el contenido anterior) utilizando la función appendFile().

void appendFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file){
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)){
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

La siguiente línea añade el mensaje ¡Mundo!\n en el archivo hola.txt. El \n significa que la próxima vez que escriba algo en el archivo, se escribirá en una nueva línea.

appendFile(SD, "/hello.txt", "World!\n");

Cambiar el nombre de un archivo
Puede renombrar un fichero utilizando la función renameFile(). Pasa como argumentos el sistema de ficheros SD, el nombre original del fichero y el nuevo nombre.

void renameFile(fs::FS &fs, const char * path1, const char * path2){
  Serial.printf("Renaming file %s to %s\n", path1, path2);
  if (fs.rename(path1, path2)) {
    Serial.println("File renamed");
  } else {
    Serial.println("Rename failed");
  }
}

La siguiente línea cambia el nombre del archivo hello.txt a foo.txt.

renameFile(SD, "/hello.txt", "/foo.txt");

Borrar un fichero
Utilice la función deleteFile() para borrar un fichero. Pase como argumento el sistema de ficheros SD y la ruta del fichero que desea borrar.

void deleteFile(fs::FS &fs, const char * path){
  Serial.printf("Deleting file: %s\n", path);
  if(fs.remove(path)){
    Serial.println("File deleted");
  } else {
    Serial.println("Delete failed");
  }
}

La siguiente línea borra el archivo foo.txt de la tarjeta microSD.

deleteFile(SD, "/foo.txt");

Probar un archivo
Por último la función testFileIO() muestra el tiempo que se tarda en leer el contenido de un fichero.

void testFileIO(fs::FS &fs, const char * path){
  File file = fs.open(path);
  static uint8_t buf[512];
  size_t len = 0;
  uint32_t start = millis();
  uint32_t end = start;
  if(file){
    len = file.size();
    size_t flen = len;
    start = millis();
    while(len){
      size_t toRead = len;
      if(toRead > 512){
        toRead = 512;
      }
      file.read(buf, toRead);
      len -= toRead;
    }
    end = millis() - start;
    Serial.printf("%u bytes read for %u ms\n", flen, end);
    file.close();
  } 
  else {
    Serial.println("Failed to open file for reading");
  }

  file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }

  size_t i;
  start = millis();
  for(i=0; i<2048; i++){
    file.write(buf, 512);
  }
  end = millis() - start;
  Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
  file.close();
}

La siguiente función comprueba el archivo test.txt.

testFileIO(SD, "/test.txt");

Inicializar la tarjeta microSD
En setup(), las siguientes líneas inicializan la tarjeta microSD con SD.begin().

Serial.begin(115200);
if(!SD.begin()){
  Serial.println("Card Mount Failed");
  return;
}
uint8_t cardType = SD.cardType();

if(cardType == CARD_NONE){
  Serial.println("No SD card attached");
  return;
}

Si no pasa ningún argumento a la función begin(), intentará inicializar la comunicación SPI con la tarjeta microSD en el pin por defecto de selección de chip (CS). Si desea utilizar otro pin CS, puede pasarlo como argumento a la función begin(). Por ejemplo, si quiere usar GPIO 17 como pin CS, debería usar las siguientes líneas de código:

Serial.begin(115200);
if(!SD.begin(17)){
  Serial.println("Card Mount Failed");
  return;
}
uint8_t cardType = SD.cardType();

Obtener el tipo de tarjeta microSD
Las siguientes líneas imprimen el tipo de tarjeta microSD en el Monitor Serial.

Serial.print("SD Card Type: ");
if(cardType == CARD_MMC){
  Serial.println("MMC");
} else if(cardType == CARD_SD){
  Serial.println("SDSC");
} else if(cardType == CARD_SDHC){
  Serial.println("SDHC");
} else {
  Serial.println("UNKNOWN");
}

Obtener el tamaño de la tarjeta microSD
Puedes obtener el tamaño de la tarjeta microSD llamando al método cardSize():

uint64_t cardSize = SD.cardSize() / (1024 * 1024);
Serial.printf("SD Card Size: %lluMB\n", cardSize);

Para probar las funciones de la tarjeta MicroSD,las siguientes líneas llaman a las funciones que hemos visto anteriormente:

listDir(SD, "/", 0);
createDir(SD, "/mydir");
listDir(SD, "/", 0);
removeDir(SD, "/mydir");
listDir(SD, "/", 2);
writeFile(SD, "/hello.txt", "Hello ");
appendFile(SD, "/hello.txt", "World!\n");
readFile(SD, "/hello.txt");
deleteFile(SD, "/foo.txt");
renameFile(SD, "/hello.txt", "/foo.txt");
readFile(SD, "/foo.txt");
testFileIO(SD, "/test.txt");
Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));


Suba el sketch anterior a tu placa ESP32. Después de eso, abra el Monitor Serie y pulse el botón RST de la placa ESP32. Si la inicialización tiene éxito, obtendrá mensajes similares a los siguientes en el Monitor Serie.

Funciones utilizadas con el objeto Archivo

Además, hay algunas funciones que puede usar con objetos de archivo :

  • Puede  usar seek()en un archivo. Esto moverá el cursor de lectura/escritura a una nueva ubicación. Por ejemplo seek(0) , lo llevará al principio del archivo, ¡lo cual puede ser muy útil!
  • Así mismo puedes llamar al position()que te indicará en qué parte del expediente te encuentras.
  • Si desea saber el tamaño de un archivo, llame size() para obtener la cantidad de bytes en el archivo.
  • Los directorios/carpetas son archivos especiales, puede determinar si un archivo es un directorio llamando isDirectory()
  • Una vez que tenga un directorio, puede comenzar a revisar todos los archivos en el directorio llamando openNextFile()
  • Puede terminar necesitando saber el nombre de un archivo, por ejemplo, si llamó openNextFile()a un directorio. En este caso, llame al name()que devolverá un puntero a la matriz de caracteres con formato 8.3 que puede hacer directamente Serial.print() si lo desea.
Por cierto , aunque pueda parecer extraño, es más económico comprar varios módulos que un único ( por unos 2€ en Amazon )

Anuncio publicitario

Sistema de automatización del hogar Tasmota usando ESP8266


En este proyecto, vamos a construir un sistema de automatización del hogar mediante el usop Tasmota con funciones controladas por Alexa. 

Tasmota es un firmware de código abierto que se utiliza para controlar dispositivos IoT (Internet de las cosas), como interruptores inteligentes, sensores, luces y otros dispositivos conectados. Permite a los usuarios controlar estos dispositivos a través de una conexión Wi-Fi y ofrece una interfaz web para configurar y personalizar su funcionamiento.

Tasmota también es compatible con muchos servicios y protocolos de terceros, como Amazon Alexa y Google Assistant, y permite la integración con sistemas de automatización del hogar como Home Assistant y Node-RED. Esto permite a los usuarios controlar y automatizar sus dispositivos de manera más eficiente y flexible.

En este ejemplo usaremos el módulo ESP8266 NodeMCU ya que es más económico que ESP32. Con la ayuda de este proyecto, podemos operar 4 electrodomésticos a través del tablero Tasmota, el dispositivo Alexa y también los interruptores físicos. También podemos operar este sistema controlando los relés desde la app de Alexa desde cualquier parte del mundo. El problema de Internet es común en las zonas rurales. Entonces, si no hay Internet, puede operar esos electrodomésticos con interruptores manuales.

Solo necesitamos seguir todos los pasos cuidadosamente. Después de esto, puede crear fácilmente un sistema de automatización del hogar inteligente Alexa usando Tasmota y Alexa para controlar los electrodomésticos usando solo sus comandos de voz.

foto del prototipo

El circuito

El circuito es bastante simple pues usa un modulo de relés conectados a los GPIO junto a 4 pulsadores normalmente abiertos para activar estos relés de forma manual.

Los relés 1, 2, 3, 4 están conectados a los pines D1, D2, D5 y D6 respectivamente y los interruptores están conectados a los pines SD3, D3, D7 y RX respectivamente.

El corazón del circuito (o mejor el «cerebro») es un económico ES8266 , porque como hemos comentado para esta aplicación donde únicamente hay señales de E/S binarias no necesitamos usar nada mas potente.

Este es el esquema de del circuito, donde como vemos no hay nada complejo.

esquema electrico

Estos son los componentes involucrados:

  • Tablero NodeMCU ESP8266
  • Optoacoplador PC817C (x4)
  • Módulo de relé de 5 voltios (x4)
  • Resistencia 1K (x4)
  • 1N4007 Diodo (x4)
  • LED (x4)
  • Pulsadores (x4)
  • Fuente de alimentación de 5 voltios
  • Veroboard

Instalando Tasmota

Tasmota es un firmware personalizado de código abierto que se puede ejecutar en placas de desarrollo ESP8266 y ESP32. Podemos conectar dispositivos como control local a través de MQTT, HTTP, etc. Al principio, Tasmota está hecho para dispositivos inteligentes Sonoff, pero en la actualidad se ha modificado para proyectos de código libre. Ahora es un software muy efectivo y fácil para controlar los chips ESP. Podemos controlar muchos sensores con solo usarlos. La principal ventaja de Tasmota es que puede agregar o eliminar dispositivos en cualquier momento que no aparezcan en la lista de dispositivos integrados.

Hay dos formas de flashear Tasmota. El primer proceso es OTA (Over the Air) y el segundo es FTDI o Arduino IDE. En este proyecto, usamos Arduino IDE para flashear Tasmota en la placa de desarrollo ESP8266.

Ahora comenzamos con la conexión de todos los componentes utilizados en este proyecto. Puede conectar ESP8266-01 con Arduino Uno como se muestra en el diagrama.

Ahora conecte VCC y GND de ESP-01 a 3.3V y GND de Arduino. Luego conecte CH_PD a 3.3V. Conecte el pin GPIO_0 al GND de Arduino.

Ahora conecte RX y TX del ESP-01 al RX y TX del Arduino UNO. Después de conectar ESP8266-01, conecte el pin de reinicio de Arduino a GND para omitirlo. Esta técnica deshabilitó Arduino y el firmware se cargó directamente en la placa ESP8266. Cuando el LED azul se ilumina, puede quitar el pin RST del pin GND.

¿Cómo descargar e instalar el firmware de Tasmota?

Ahora la pregunta es cómo descargar el firmware de Tasmota. Puede hacer clic en este enlace: http://ota.tasmota.com/tasmota/release/. En este enlace, puede ver una lista de archivos de firmware. Todos los archivos tienen diferentes controladores integrados para diferentes sensores. Puedes usar ‘tasmota.bin’. Este archivo tiene todas las características del hardware compatible. Después de visitar el enlace, solo necesita desplazarse hacia abajo y hacer clic en la primera opción y luego hacer clic en Tasmotizer-1.2.exe.

descargar tasmotizador

tasmotizador

El Tasmotizer es una herramienta para flashear Tasmota. Tienes que descargar la “última versión de Tasmota” en tu plataforma. Ahora simplemente haga doble clic en él y se iniciará.

Proceso para Flashear Tasmota

Ahora estamos en la parte final para flashear Tasmota. Seleccione el puerto donde está conectado Arduino UNO. Explore el binario de firmware de Tasmota que descargó. Luego haz clic en Tasmotizar. Después de un par de veces, se hará.

¿Cómo configurar Wi-Fi?

Después de flashear Tasmota, tenemos que configurar WiFi para controlar los dispositivos mediante la aplicación Amazon Alexa. Después de parpadear, puede ver un botón ‘enviar configuración’. Haz click en eso. Ahora ingrese su nombre y contraseña de WiFi y guárdelo y ahora haga clic en Aceptar. Guardar el proceso puede llevar algún tiempo.

Después de 5 a 10 segundos más tarde, puede continuar con el siguiente paso. Ahora haga clic en ‘obtener IP‘. Aquí puede ver la dirección IP del WiFi. Cópialo y pégalo en Google o en cualquier navegador. Allí puede ver el tablero donde puede editar su proyecto.

Tasmota Sistema de domótica Tasmotizer
Haga clic en Tasmotize
Configuración de envío de Tasmotizer
Haga clic en Enviar configuración
Tasmotizer wifi nombre y contraseña
Escriba el nombre y el pase de WiFi.
Tasmotizer envía notificación de configuración
Notificación de configuración enviada.
Dirección IP de Tasmotizer
Dirección IP mostrada

Configurar relés e interruptores para el sistema de automatización del hogar Tasmota

Ahora haga clic en ‘Configuración‘ y luego haga clic en ‘Configurar módulo’. Ahora seleccione el ‘Genérico (0)’ y guárdelo. Luego regrese al menú principal y haga clic en ‘Configuración’. Aquí puede ver que está seleccionado ‘Genérico (0)’. Tiene que configurar todos los pines GPIO conectados a los relés.

Configuración del sistema de automatización del hogar Tasmota

Los relés 1, 2, 3, 4 están conectados a los pines D1, D2, D5 y D6 respectivamente y los interruptores están conectados a los pines SD3, D3, D7 y RX respectivamente. Luego abra el navegador y seleccione el relé 1 en el GPIO5 para el relé 1. Luego haga lo mismo para GPIO4 y seleccione el relé 2. El mismo proceso es para los relés 3 y 4 respectivamente.

Ahora es el momento de conectar los interruptores. Al principio, podemos ver que el pin SD3 o GPIO10 está conectado al interruptor 1. Ahora, como le muestro en la técnica de selección anterior, seleccione el interruptor para el GPIO10 si usa interruptores manuales o seleccione botones si usa botones pulsadores. Mediante este proceso, seleccione los cuatro interruptores respectivamente.

Ahora guárdalo y vuelve al menú principal. En el tablero, puede ver cuatro botones. Con estos botones, puede controlar estos cuatro relés.

Configurar Amazon Alexa para el sistema de automatización del hogar Tasmota

Para configurar la aplicación Alexa, debe volver al menú principal. Seleccione ‘Configuración‘ y luego ‘Configurar otros‘. Ahora nombre este proyecto y nombre los cuatro canales. Por estos nombres, Alexa identificará este dispositivo. Por último, seleccione ‘Hue bridge multi device‘ y guárdelo.

Paso para configurar la aplicación móvil Amazon Alexa

  • En la aplicación Alexa, inicie sesión con el correo electrónico y la contraseña.
  • Luego ciérralo.
  • Haga clic en Descubrir dispositivos. El nombre de su dispositivo es visible allí en unos segundos.
  • Luego haga clic en su dispositivo. A continuación, seleccione todos los interruptores.
  • Si ESP8266 está conectado con su WiFi, puede controlar todos los dispositivos desde la aplicación Alexa.
  • Ahora solo tienes que decir «Alexa, enciende la luz». La luz esta encendida. Con este comando de voz, puede controlar los electrodomésticos usando su voz.
Configuración de la aplicación alexa del sistema de automatización del hogar Tasmota

El principio de funcionamiento es muy fácil para este proyecto. Solo necesita decir «Alexa enciende el interruptor 1» y el interruptor se enciende. Mediante este proceso, puede controlar cuatro interruptores. También puede controlarlo con la aplicación Alexa.

Cuando no tiene conexiones WiFi, este proyecto puede controlarse manualmente mediante interruptores. Cuando el WiFi esté conectado, la aplicación Alexa mostrará la notificación de tus electrodomésticos.

Como gestionar un LCD con Arduino


Tradicionalmente para visualizar información con microcontroladores se han usado leds, displays de leds de 7segmentos, «tubos nixie!,LCD , pantallas OLED, etc

Hay varias ventajas para usar pantallas LCD frente a otros medios:

  1. Fácil visualización de datos: La pantalla LCD permite una fácil visualización de los datos generados o recibidos por el Arduino, lo que simplifica la tarea de monitoreo y análisis.
  2. Interfaz de usuario: Las pantallas LCD pueden ser utilizadas para crear interfaces de usuario amigables para proyectos con Arduino, lo que hace más fácil para los usuarios interactuar con el sistema.
  3. Versatilidad: Las pantallas LCD pueden ser utilizadas en una amplia variedad de proyectos, desde monitoreo de sensores hasta juegos y aplicaciones de tiempo real.
  4. Ahorro de espacio: Las pantallas LCD son más compactas y requieren menos espacio que otras opciones de visualización, lo que las hace ideales para proyectos con restricciones de espacio.
  5. Fácil conexión: La conexión de una pantalla LCD con una placa Arduino es generalmente sencilla y requiere pocos componentes adicionales.
  6. Bajo consumo de energía: Las pantallas LCD utilizan poca energía y son adecuadas para proyectos con restricciones de energía o con requisitos de larga duración.

El principio detrás de las pantallas LCD para Arduino es el uso de la tecnología de cristal líquido para desplegar información en una pantalla. Una pantalla LCD para Arduino funciona mediante la aplicación de una tensión a los cristales líquidos en la pantalla, lo que los hace inclinarse y permitir o bloquear la luz detrás de ellos. De esta manera, se pueden crear diferentes patrones de luz y oscuridad en la pantalla para formar caracteres o gráficos.

Una placa Arduino (o cualquier variante) controla la tensión aplicada a los cristales líquidos a través de un controlador LCD específico, que envía señales a los pines de la pantalla LCD. El controlador recibe y procesa los datos enviados por el Arduino y los convierte en una señal que controla la tensión aplicada a los cristales líquidos. De esta manera, se puede desplegar información en tiempo real en la pantalla LCD.

Una pantalla LCD con una placa Arduino puede ser utilizada para desplegar información o datos en tiempo real que sean generados o recibidos por el Arduino. Esto permite una visualización más clara y accesible de los datos y puede ser utilizado en una amplia variedad de proyectos, como monitoreo de sensores, interfaces de usuario, juegos, entre otros.

La placa GeekPi ( LCD1602)

Para que sirva de ejemplo, vamos a estudiar la placa GeekPi que puede comprarse en Amazon por unos 5€/unidad aqui. Esta placa utiliza el protocolo I2C para reducir la ocupación de los puertos de E / S , lo que facilita la adición al proyecto y menos cableado lo cual es fantástico ya que tradicionalmente se usaban en función del bus de 4 o 8 bits al menos 7 pines de E/S. Esta placa es comúnmente utilizado en IoT, proyectos de bricolaje, animación doméstica, construcción inteligente, proyecto de bricolaje del fabricante, etc.

Asimismo esta placa es compatible con todas las placas de desarrollo actuales, como Arduino (y todas sus variantes incluyendo ESP32, ESP8266, ECT ) , Raspberry pi, Tinkerboard, Nano pi, Banana pi, stm32, etc.

Respecto a ajustes, tan solo necesita un potenciómetro que hay detrás del lcd donde podemos ajustar la retroiluminación (color: azul) y el contraste.

La alimentación: 5v y la dirección I2C es: 0x27 y sus dimensiones son : 80 mm x 35 mm x 11 mm

En caso de conectar este lcd a una placa Arduino (o similares como ESP32, ESP8266, etc. ), las conexiones son las siguientes

Para otras placas como la Raspberry, como vemos en la imagen la conexión es similar:

Como vemos el LCD1602 usa I²C utilizando sólo dos líneas bidireccionales open-drain, Serial Data Line (SDA) y Serial Clock Line (SCL),con resistencias. Los voltajes típicos utilizados son +5 V o +3,3 V, aunque se permiten sistemas con otros voltajes. Puede funcionar siempre que sea compatible con la placa de desarrollo I2C como ya se ha comentado (las comunes Arduino, Raspberry pi, Stm32, etc.).

Este es un resumen de sus características:

  • Ocupa menos puertos de E/S.
  • Soporta el protocolo IIC.
  • La biblioteca I2C LCD1602 es fácil de conseguir
  • Con un potenciómetro para ajustar la retroiluminación y el contraste
  • Retroiluminación azul
  • uente de alimentación 5v
  • La dirección I2C es: la nueva versión es 0x3F, la versión antigua es 0x27

Cómo conectarlo a Arduino


Conecte el módulo LCD1602 a la placa Arduino Uno como se muestra en la siguiente imagen:
I2C LCD1602 placa Arduino Uno
GND GND
VCC 5V
SDA A4 /pin 20 mega2560
SCL A5 /pin 21 mega2560

Cómo programarlo en Arduino


1.Descarga la librería LiquidCrystal_I2C
2.Abre el IDE de Arduino,Selecciona Sketch -> Include Library -> Add ZIP Library
3.Encuentra el archivo LiquidCrystal_I2C que acabas de descargar.
4.Haga clic en abrir y, a continuación, se le pedirá por «Biblioteca añadido a sus bibliotecas.
5.Marque ‘Importar bibliotecas'».
6.Abra el archivo ->Sketch->Include Library->LiquidCrystal_I2C.
7.Copia el siguiente código en el IDE de Arduino, haz click en el icono upload para subir el código a la placa de control:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27, if new version please use 0x3F instead.

void setup()
{
  lcd.init();  //initialize the lcd
  lcd.backlight();  //open the backlight
}

void loop()
{
  lcd.setCursor(3, 0); // set the cursor to column 3, line 0
  lcd.print("Hello GeeekPi");  // Print a message to the LCD
  
  lcd.setCursor(2, 1); // set the cursor to column 2, line 1
  lcd.print("hello world");  // Print a message to the LCD.
}

POSICIONAR EL TEXTO
La función mylcd.lcd_display_string() imprime texto en la pantalla y también permite elegir dónde posicionarlo.
La función se usa como mylcd.lcd_display_string(«TEXTO A IMPRIMIR», FILA, COLUMNA).
El siguiente código imprime «¡Hola Mundo!» en la fila 2, columna 3:
En un LCD de 16×2, las filas están numeradas del 1 al 2, mientras que las columnas están numeradas del 0 al 15. Por lo tanto, para imprimir «¡Hola Mundo!
Así que para imprimir «¡Hola Mundo!» en la primera columna de la fila superior, usted usaría

mylcd.lcd_display_string(“Hello World!”, 1, 0)

BORRAR LA PANTALLA
La función mylcd.lcd_clear() borra la pantalla

import I2C_LCD_driver
from time import *
mylcd = I2C_LCD_driver.lcd()
mylcd.lcd_display_string("This is how you", 1)
sleep(1)
mylcd.lcd_clear()
mylcd.lcd_display_string("clear the screen", 1)
sleep(1)
mylcd.lcd_clear()

TEXTO PARPADEANTE
Podemos utilizar un simple bucle while con las funciones mylcd.lcd_display_string() y mylcd.lcd_clear() para crear un efecto de texto parpadeante continuo:

import time
import I2C_LCD_driver
mylcd = I2C_LCD_driver.lcd()

while True:
    mylcd.lcd_display_string(u"Hello world!")
    time.sleep(1)
    mylcd.lcd_clear()
    time.sleep(1)


Puede usar la función time.sleep() en la línea 7 para cambiar el tiempo (en segundos) que el texto permanece encendido.
El tiempo que el texto permanece apagado se puede cambiar en la función time.sleep() en la línea 9.
Para finalizar el programa, pulse Ctrl-C.

IMPRIMIR LA FECHA Y LA HORA
El siguiente programa imprime la fecha y hora actual en la pantalla LCD:

import I2C_LCD_driver
import time
mylcd = I2C_LCD_driver.lcd()


while True:
    mylcd.lcd_display_string("Time: %s" %time.strftime("%H:%M:%S"), 1)
    
    mylcd.lcd_display_string("Date: %s" %time.strftime("%m/%d/%Y"), 2)

IMPRIME TU DIRECCIÓN IP
Este código imprime la dirección IP de tu conexión ethernet (eth0).
Para imprimir la IP de tu conexión WiFi, cambia eth0 por wlan0 en la línea 18:

import I2C_LCD_driver
import socket
import fcntl
import struct

mylcd = I2C_LCD_driver.lcd()

def get_ip_address(ifname):
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    return socket.inet_ntoa(fcntl.ioctl(
        s.fileno(),
        0x8915, 
        struct.pack('256s', ifname[:15])
    )[20:24])

mylcd.lcd_display_string("IP Address:", 1) 

mylcd.lcd_display_string(get_ip_address('eth0'), 2)

DESPLAZAR TEXTO DE DERECHA A IZQUIERDA CONTINUAMENTE
Este programa desplazará una cadena de texto desde el lado derecho de la pantalla LCD hacia el lado izquierdo y hará un bucle continuo:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

str_pad = " " * 16
my_long_string = "This is a string that needs to scroll"
my_long_string = str_pad + my_long_string

while True:
    for i in range (0, len(my_long_string)):
        lcd_text = my_long_string[i:(i+16)]
        mylcd.lcd_display_string(lcd_text,1)
        sleep(0.4)
        mylcd.lcd_display_string(str_pad,1)

DESPLAZAR TEXTO DE DERECHA A IZQUIERDA UNA VEZ


El siguiente código desliza texto en la pantalla de derecha a izquierda una vez, luego se detiene y deja una pantalla limpia.

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

str_pad = " " * 16
my_long_string = "This is a string that needs to scroll"
my_long_string = str_pad + my_long_string

for i in range (0, len(my_long_string)):
    lcd_text = my_long_string[i:(i+16)]
    mylcd.lcd_display_string(lcd_text,1)
    sleep(0.4)
    mylcd.lcd_display_string(str_pad,1)

DESPLAZAR TEXTO DE IZQUIERDA A DERECHA UNA VEZ
Este programa desliza texto en la pantalla de izquierda a derecha una vez, luego se detiene y deja los primeros 16 caracteres de la cadena de texto en la pantalla.

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

padding = " " * 16
my_long_string = "This is a string that needs to scroll"
padded_string = my_long_string + padding

for i in range (0, len(my_long_string)):
   lcd_text = padded_string[((len(my_long_string)-1)-i):-i]
   mylcd.lcd_display_string(lcd_text,1)
   sleep(0.4)
   mylcd.lcd_display_string(padding[(15+i):i], 1)

CARACTERES PERSONALIZADOS
Puede crear cualquier patrón que desee e imprimirlo en la pantalla como un carácter personalizado.
Cada carácter es una matriz de 5 x 8 píxeles.
Hasta 8 caracteres personalizados pueden ser definidos y almacenados en la memoria del LCD.
Este generador de caracteres personalizados le ayudará a crear la matriz de bits necesaria para definir los caracteres en la memoria de la LCD.
enlace: [ https://omerk.github.io/lcdchargen/ |generador de caracteres personalizados ]


IMPRIMIENDO UN CARACTER PERSONALIZADO
El siguiente código genera un caracter «<«:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

fontdata1 = [      
        [ 0b00010, 
          0b00100, 
          0b01000, 
          0b10000, 
          0b01000, 
          0b00100, 
          0b00010, 
          0b00000 ],
]

mylcd.lcd_load_custom_chars(fontdata1)
mylcd.lcd_write(0x80)
mylcd.lcd_write_char(0)

IMPRIMIR VARIOS CARACTERES PERSONALIZADOS
Este programa imprime una flecha grande hacia la derecha (→) en la pantalla:

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

fontdata1 = [
        # char(0) - Upper-left character
        [ 0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b11111, 
          0b11111 ],

        # char(1) - Upper-middle character
        [ 0b00000, 
          0b00000, 
          0b00100, 
          0b00110, 
          0b00111, 
          0b00111, 
          0b11111, 
          0b11111 ],
        
        # char(2) - Upper-right character
        [ 0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b10000, 
          0b11000 ],
        
        # char(3) - Lower-left character
        [ 0b11111, 
          0b11111, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000 ],
       
        # char(4) - Lower-middle character
        [ 0b11111, 
          0b11111, 
          0b00111, 
          0b00111, 
          0b00110, 
          0b00100, 
          0b00000, 
          0b00000 ],
        
        # char(5) - Lower-right character
        [ 0b11000, 
          0b10000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000, 
          0b00000 ],
]

mylcd.lcd_load_custom_chars(fontdata1)

mylcd.lcd_write(0x80)
mylcd.lcd_write_char(0)
mylcd.lcd_write_char(1)
mylcd.lcd_write_char(2)

mylcd.lcd_write(0xC0)
mylcd.lcd_write_char(3)
mylcd.lcd_write_char(4)
mylcd.lcd_write_char(5)

Fuente https://wiki.52pi.com/index.php?title=Z-0234

Detector de sonido con sensor de humedad y temperatura con IoT


Una vez vamos a ver como hacer un  simple proyecto de IOT a  traves de la nube de Cayenne, pero esta vez vamos a mostrar como usar un microcontrolador algo menos habitual: el ESP8266 ESP-01.

Es necesario antes de empezar dado la actual tendencia de usar el ESP32 como solución ideal para proyectos de IoT, es necesario  hablar del  ESP01  de ESP32 y ESP8266 , dos dispositivos basados en chips de Espressif Systems que se utilizan comúnmente en proyectos de IoT (Internet de las cosas) y automatización. Ambos dispositivos son populares debido a su bajo costo, baja potencia y alto rendimiento. Sin embargo, hay algunas diferencias importantes entre ellos:.

  • El ESP8266 es un chip WiFi de baja potencia que se utiliza principalmente para aplicaciones de control remoto y automatización. Tiene una interfaz de comunicación serie y solo unos pocos pines disponibles para conectarse a otros dispositivos. Es una opción popular para proyectos pequeños debido a su tamaño y bajo costo.
  • El ESP32, por otro lado, es un chip WiFi y Bluetooth de baja potencia que se utiliza para aplicaciones de IoT y automatización. Tiene una interfaz de comunicación serie y una serie de pines disponibles para conectarse a otros dispositivos y sensores. Además, cuenta con un microcontrolador integrado, una memoria flash y una interfaz USB. También cuenta con una serie de periféricos adicionales como sensores de movimiento, micrófonos, cámaras, etc. Es una opción popular para proyectos más grandes y complejos debido a su mayor flexibilidad y características adicionales.

En resumen, el ESP8266 es un chip WiFi de baja potencia para proyectos pequeños y económicos, mientras que el ESP32 es un chip WiFi y Bluetooth de baja potencia con características adicionales para proyectos más grandes y complejos.

Por otro lados ESP8266 ESP-01 y ESP8266 NodeMCU son dos dispositivos basados en el chip ESP8266 de Espressif Systems. Ambos dispositivos utilizan el mismo chip y tienen muchas características similares, pero también hay algunas diferencias importantes entre ellos:

  • El ESP8266 ESP-01 es un módulo WiFi con un solo chip que se utiliza principalmente para aplicaciones de control remoto y automatización. Tiene una interfaz de comunicación serie y solo unos pocos pines disponibles para conectarse a otros dispositivos, siendo por tanto  una opción popular para proyectos pequeños debido a su tamaño y bajo costo.
  • El ESP8266 NodeMCU, por otro lado, es una placa de desarrollo basada en el chip ESP8266. Tiene una interfaz de comunicación serie y una serie de pines disponibles para conectarse a otros dispositivos y sensores. Además, cuenta con una serie de características adicionales como un microcontrolador integrado, una memoria flash y una interfaz USB. Es una opción popular para proyectos más grandes y complejos debido a su mayor flexibilidad y características adicionales.

En resumen, el ESP8266 ESP-01 es un módulo WiFi pequeño y barato para proyectos pequeños, mientras que el ESP8266 NodeMCU es una placa de desarrollo más completa con características adicionales para proyectos más grandes y complejos.

Por otro lado Cayenne es una plataforma de Internet de las cosas (IoT) desarrollada por MyDevices. Permite a los usuarios conectar y controlar dispositivos IoT mediante una interfaz web fácil de usar. Con Cayenne, los usuarios pueden crear reglas y automatizaciones para sus dispositivos, visualizar datos en tiempo real y recibir alertas cuando ocurra algo inusual. También permite a los desarrolladores crear aplicaciones IoT personalizadas mediante una API.

Esta es la lista de componente usados en este proyecto:

  1. ESP8266 ESP-01 WiFi módulo
  2. FTDI Breakout Board + Mini cable USB
  3. ESP8266 ESP-01 Breakout Board (opcional)
  4. Módulo relé de 1 canal
  5. DHT11 Sensor de humedad y temperatura
  6. Sensor de sonido
  7. Breadboards (utilizaré breadboards pequeños 2)
  8. 5V a 3.3V paso descendente módulo de Buck (opcional)
  9. Un montón de cables de puente

En primer lugar, debemos estudiar las conexiones de estos componentes. Aquí están los módulos principales que vamos a utilizar para este proyecto (es posible que tenga una variante diferente de los componentes, así que por favor tome nota de las etiquetas de pin)

img_4629

El modulo ESP8266 ESP-01

ESP8266 ESP-01

Tenemos que tener cuidado ya que esta placa funciona en un 3, 3V lógica. El pin VCC (aunque intente alimentar con 5V y no pase nada) debe conectarse a 3.3V. Lo mismo ocurre con el pin que  va a CH_PD. El pin RX debe conectarse a TX de la placa de arranque FTDI, a través de un divisor de tensión. Puede establecer el puente en su módulo FTDI de 3.3V si lo tiene (hay módulos FTDI que  dan la opción de elegir entre 5V y 3.3V). En caso de que la fuente de alimentación sólo proporcione 5V, consulte el divisor de tensión a continuación (usted deberá elegir las resistencias correctas para proporcionar energía suficiente a su módulo de ESP8266).img_4636-1

Módulo relé de 1 canal

El módulo de relé habitual tiene tres pines diferentes para la energía y señal. Para la energía, pin etiquetas son VCC y GND. Para activar o desactivar el relé, se utiliza el pin como IN. Muchos de estos módulos pueden funcionar muy bien con un 3,3 v, pero deberá asegurarse que lo tolera porque de lo contrario no responderá 

DHT11 Sensor de humedad y temperatura

Se trata de los sensores DHT11. Lee la temperatura y humedad del lugar donde está el sensor. Tiene dos pines para alimentación («-» para la tierra, el pin central es VCC). El pin con la etiqueta «S» es la entrada de pin. Las lecturas se reciben a través de este pin.

Sensor de sonido

Los sensores de los sonidos suelen también tener 3 pines: VCC, GND y OUT. El pin de salida envía el nivel de sonido en el lugar donde el sensor. También puede controlar su sensibilidad girando el potenciómetro en él (cuadro azul con blanco del «engranaje» dentro).

FTDI USB a TTL convertidor de serie

En la imagen vemos  un típico  convertidor de USB a TTL serie. Utilizamos esta placa para cargar nuestros bocetos en el módulo de WiFi de ESP8266 ESP-01. También puede utilizarse para programar microcontroladores diferentes. La placa generalmente tiene 6 pines (aunque se puede soldar más pins de encabezado en ambos lados de la placa): DTR, RX, TX, VCC, CTS y GND. CTS generalmente no se utiliza. Para nuestra actividad, son necesarios solamente 4 pines: VCC, RX, TX y GND.

FTDI USB to TTL Serial ConverterEn la siguiente imagen, vemos  el módulo FTDI configurado para 3.3V mediante  su puente correspondiente:

img_4767

Cuando están conectados los pines 1 y 2, el módulo FTDI proporciona una potencia de 5 voltios (mismo va con el pin de TX también). Cuando se conectan los pines 2 y 3, proporcionará energía 3.3-vols (lo mismo con el pin de TX también).

Conversor de 5V a 3.3V  (opcional)

5V to 3.3V Stepdown Power Supply Buck Module
Esto  placa es opcional a menos que la placa breakout FTDI no de la opción de cambiar el voltaje (generalmente entre estos dos: 3.3V y 5V). La fuente Buck módulo de alimentación de paso descendente 5V a 3.3V  se utiliza para «convertir» 5V a 3.3V. Como su nombre lo indica este modulo es muy útil para los módulos que  usan lógica de  3.3V.

El código

Antes de proceder con la codificación, necesitamos tener la siguiente configuración en el IDE de Arduino. Para las bibliotecas, descargarlos desde el enlace proporcionado para cada biblioteca (véase abajo) en Github.

  1. ESP8266 Tableros – para obtener instrucciones paso a paso, por favor véase la sección siguiente.
  2. SimpleDHT bibliotecas – bibliotecas de SimpleDHT pueden ser descargado aquí.
  3. SimpleTimer bibliotecas – bibliotecas Simple pueden ser descargado aquí.

Creación de las placas de ESP8266 es muy fácil. Por favor siga los siguientes pasos:

  1. Abra el IDE de Arduino.
  2. Ir a archivo > Preferencias.
    ArduinoIDE_File_Preference
  3. De las URLs de Gerente tableros adicionales texto de campo, colocar esta URL: http://arduino.esp8266.com/stable/package_esp8266com_index.json. Haga clic en aceptar luego.
    ArduinoIDE_PreferencesWindow
  4. Ahora, vaya a Herramientas > Placas > Gestor de placas.
    ArduinoIDE_File_Tools_Board_BoardManager
  5. En Administrador de tablas, buscar esp8266 e instalar el esp8266 por ESP8266 comunidad versión x.x.x. Cierre la ventana del administrador de tablas.
    ArduinoIDE_BoardsManager
  6. Ir a Herramientas > Placa Desplácese por la lista hasta encontrar Módulo genérico de ESP8266.
    ArduinoIDE_Select_BoardsManager

Agregar las bibliotecas requeridas

  1. Ir al link proporcionado arriba para las bibliotecas necesarias 2 dos (SimpleDHT y SimpleTimer.
  2. Para cada vínculo, haga clic en clonar o descargar. Aparece una pequeña ventana, haga clic en Descargar Zip. Se refieren a las imágenes que se muestra a continuación:SimpleDHTLibraryDownload.pngSimpleTimerLibraryDownload
  3. Guarde el archivo ZIP para cada biblioteca.
  4. En el IDE de Arduino, vaya a Sketch > Biblioteca incluyen > Agregar. Cierre biblioteca.
  5. Busque y agregue a cada biblioteca (uno a la vez).
    ArduinoIDE_SelectLibs

Agregar las bibliotecas de Cayenne

Bibliotecas de Cayenne se puede instalar el IDE de Arduino mediante el administrador de biblioteca. Para ello, siga los siguientes pasos:

  1. En el IDE de Arduino, vaya a Sketch > Biblioteca incluyen. Haga clic en administrar bibliotecas.
    ArduinoIDE_Goto_LibraryManager
  2. En la ventana que aparecerá, escriba Cayenne en el campo de búsqueda. Instale el Cayenne por myDevices versión x.x.x y CayenneMQTTpor myDevices versión x.x.x. Cierre la ventana después. Estas bibliotecas están también disponibles en Github (bibliotecas deCayenne y CayenneMQTT ).ArduinoIDE_LibraryManager

Modo de programación

Inicialmente, tenemos que configurar nuestro ESP8266 ESP-01 al modo de programación. No necesitamos conectar nuestros componentes, sin embargo, como conectar les pueden causar la carga de los bocetos al fracaso. La siguiente tabla detalla qué pines están conectados uno al otro entre el módulo de ESP8266 ESP-01 WiFi y el convertidor serie FTDI  USB a TTL.

Program Mode Connections

Es necesario establecer el puente del módulo FTDI para 3.3V. Esta manera, nosotros no necesitando cualquier divisor del voltaje o el paso hacia abajo módulo de buck. El convertidor USB a Serial podría tener asignaciones de pines diferentes. La descripción anterior se demuestra en el siguiente esquema:

ESP8266 Project 3v3 Program Mode_bb

¡Eso es todo! Ahora estamos listos para configurar nuestra consola y subir los bocetos:
Upload the sketch

Crear el tablero de mandos de Cayenne

  1. Inicie sesión en su cuenta de Cayenne (registro gratis si usted no tiene uno pero al Cayenne registro página):
    Cayenne USB Serial - 01 Logon
  2. Una vez identificado, el siguiente paso sería elegir el dispositivo que vamos a usar . Si este es el primer dispositivo en tu panel de control, elija todos los dispositivos:
    1 - All Devices , Seleccione ESP8266 genérico en microcontroladores:
    2 - ESP8266               Si tiene añadidos previamente en los dispositivos existentes, necesitará agregar un dispositivo haciendo clic en el menú de añadir dispositivos/Widget:
    Cayenne USB Serial - 02 Add New Device
    A continuación, elija ESP8266 ya que esta es nuestra tabla de desarrollo:
    ESP8266MQTT
  3. En la página siguiente, se muestra con el nombre de usuario de MQTT, MQTT contraseña e ID de cliente. Necesitamos estos datos en el código más adelante. También aparecerá en la parte inferior de la página que está esperando el dispositivo a conectar.
    CayenneCredentials
  4. Ahora, procedemos con el código. Abra el IDE de Arduino. Ir a archivo > ejemplos > Cayenne-MQTT-ESP8266 > ESP8266. Este esbozo será nuestro boceto base.MQTT Sketch
  5. Volver al Portal de Cayenne. Tomar nota de lo siguiente, porque vamos a utilizarlo en nuestro código:
    • MQTT USERNAME
    • MQTT CONTRASEÑA
    • ID DE CLIENTE
  6. Ahora, vuelve al IDE de Arduino. Pegue los valores en la sección resaltada en la captura de pantalla siguiente:
    MQTT Creds Section
  7. También, proveer el nombre de Wi-Fi (SSID) y la contraseña en esta sección del código:
    Wifi creds
  8. Por cierto, tenemos que incluir las librerías necesarias: SimpleDHT y SimpleTimer. La SimpleDHT nos permite usar la temperatura de la DHT. El SimpleTimer nos permitirá ejecutar métodos fuera el método loop():
    Additional Libraries
  9. Ahora tenemos que declarar las clavijas para ser usado por los sensores.
    • DHT11 Pin = Pin 2 (GPIO2 ESP8266 ESP-01)
    • Pin de sonido = Pin 3 (GPIO3 ESP8266 ESP-01)
    • Pin de relé = Pin 1 (GPIO1 ESP8266 ESP-01)
      Sensor declaration
  10. Puesto que vamos a enviar datos a la plataforma del Cayenne IoT usando MQTT API, tenemos que pasar el valor de sensores a los pines virtuales. Los pines virtuales se utilizará por los widgets en nuestro escritorio. No vamos a utilizar V1, porque establecimos esto como una salida (para controlar el relé – usado en los widgets de dashboard de Cayenne):
    • V2 – humedad (datos de DHT11)
    • V3 – temperatura (datos de DHT11)
    • V4 – sonido (datos del Sensor de sonido)
  11. Subir el boceto a la Placa de ESP8266 ESP-01. Asegúrese de que el elegido es Genérico módulo ESP8266:ESp8266 board on board

Código completo

// This example shows how to connect to Cayenne using an ESP8266 and send/receive sample data.
// Make sure you install the ESP8266 Board Package via the Arduino IDE Board Manager and select the correct ESP8266 board before compiling.

//#define CAYENNE_DEBUG
#define CAYENNE_PRINT Serial
#include <CayenneMQTTESP8266.h>

#include <SimpleTimer.h> // Download from https://github.com/jfturcot/SimpleTimer
#include <SimpleDHT.h> // Download from https://github.com/adafruit/DHT-sensor-library

// WiFi network info.
char ssid[] = "<your ssid/wifi name>";
char wifiPassword[] = ""<your ssid/wifi password>"";

// Cayenne authentication info. This should be obtained from the Cayenne Dashboard.
char username[] = "<your MQTT Username>";
char password[] = "<your MQTT Password>";
char clientID[] = "<your client id>";

// DHT11 Pin
int pinDHT11 = 2;
SimpleDHT11 dht11;

// Sound Pin
int soundPin = 3;

// Relay Pin
int relayPin = 1;

// Timer
SimpleTimer timer;

void setup() {
 Serial.begin(9600);
 Cayenne.begin(username, password, clientID, ssid, wifiPassword);
 pinMode(relayPin, OUTPUT); // Relay
 digitalWrite(relayPin, HIGH);
 pinMode(soundPin, INPUT); // Sound
 timer.setInterval(200L, transmitData); // Method to execute every 200ms
}

void loop() {
 Cayenne.loop();
 timer.run();
}

CAYENNE_IN(relayPin) {
 if (getValue.asInt() == 1) { // NOTE: Channel = Virtual Pin
 digitalWrite(relayPin, LOW);
 }
 else {
 digitalWrite(relayPin, HIGH);
 }
}

void transmitData()
{
 byte temperature = 0;
 byte humidity = 0;
 int err = SimpleDHTErrSuccess;

if ((err = dht11.read(pinDHT11, &temperature, &humidity, NULL)) != SimpleDHTErrSuccess) {
 Cayenne.virtualWrite(V4, 0);
 Cayenne.virtualWrite(V2, 0);
 }
 else {
 Cayenne.virtualWrite(V4, (int)temperature);
 Cayenne.virtualWrite(V2, (int)humidity);
 }

if (digitalRead(soundPin) == HIGH) {
 Cayenne.virtualWrite(V3, HIGH);
 }
 else {
 Cayenne.virtualWrite(V3, LOW);
 }
}


Conexión de los sensores y módulos

En esta etapa, debería poder subir tu dibujo con éxito. Ahora, saque la placa de potencia. También, eliminar la conexión GND de GPIO0. No necesitamos GPIO0 conectado a la tierra, a menos que vamos a actualizar el código. Refiérase a las tablas para cada sensor y el módulo siguiente:

Sensor and Modules Connections

Fuentes de alimentación de todos estos componentes están conectadas a la tensión de salida del paso por módulo, lo que significa que están alimentados a través de 3, 3V. La fuente de alimentación principal es la tabla de desglose FTDI. El esquema a continuación muestra las conexiones completas, después de cargar exitosamente el código:

ESP8266 Project 3v3_ no rx and tx connection

Nota: Los pines RX y TX del módulo FTDI no están conectados a los pines TX y RX del módulo wifi, y es tan GPIO0 (de tierra).

La imagen de abajo es el conjunto real de los esquemas que se muestra arriba:
img_4805img_4807

¡Eso es todo! Hemos terminado con estas configuraciones: placas, las bibliotecas y componentes. Ahora estamos listos para configurar nuestro proyecto con pimienta usando MQTT. Por cierto, MQTT está parado para el transporte de telemetría de MQ. Simplemente hablando, es un protocolo de mensajes entre las máquinas y la Internet de las cosas! Más sobre este tema en Docs de Cayenne.

La energía de las placas una vez más: el módulo de Wifi ESP8266 ESP-01 debe ser capaz de conectarse a su Wifi. Ahora, vuelve al portal de Cayenne. Usted debe ser capaz de ver el tablero de instrumentos widgets inicial rellena previamente que puede Agregar a la consola. Ahora puede personalizar el tablero de instrumentos.

Inicialmente, esto es como el tablero de instrumentos cuando el módulo de ESP8266 ESP-01 WiFi comienza a enviar datos a la consola de Cayenne (bajo el dispositivo configurado allí):

Initial Dashboard - Cayenne

Añadir los widgets iniciales que se muestra arriba, haga clic en el icono «+» en la esquina superior derecha de cada widget inicial:
Add widgets

Una vez añadido, ahora personalizaremos cada widget. Esto es cómo se ve como cuando se agregan estos widgets iniciales:
added widgets

Para personalizar cada widget, haga clic en el icono de la derecha, luego seleccione Ajustes. Consulte captura de pantalla siguiente:
Customize Widget

Una ventana emergente aparece y nos permitirá cambiar el nombre del Widget, canal, Widget icono y número de lugares decimales. Dejaremos el canal como es. No cambie el valor de la canal, puesto que el valor es el Virtual Pin (V0, V1, V2…) utilizados en el código de este widget. Virtual Pin 4 (V4) es la temperatura Virtual Pin 2 (V2) es la humedad y Virtual Pin 3 (V3) es el valor del sensor de sonido (0/1).

A continuación se muestran la configuración de cada widget inicial:

Config - HumidityConfig - Sound DetectedConfig - Temperature

Aquí es cómo verá después:
Config - Finished Initial

Ahora, todavía tenemos que añadir un widget más. Este widget es para que el relé para activar/desactivar. En la parte izquierda del tablero de instrumentos (superior izquierda), haga clic en Agregar nuevoy, a continuación, haz clic en el Dispositivo/Widget:
Cayenne USB Serial - 02 Add New Device

Desplácese hacia abajo más abajo y buscar Widgets personalizados. Seleccione el botón:
Custom Widgets - Button

Tenemos que cambiar la configuración del widget de botón:

  • Nombre = interruptor de relé
  • Dispositivo = ESP8266 genéricos (o el dispositivo llamado si ya tienes)
  • Datos = actuador Digital
  • Unidad = Digital (0/1)
  • Canal = 1 (esto es GPIO1 del módulo WiFi ESP8266 ESP-01 – código de revisión)
  • Elija el icono = botón (puede elegir qué icono que desee)

Abajo se encuentra la captura de pantalla de los ajustes del botón. Haga clic en agregar Widget luego:
Add Button Widget

El tablero final ahora este aspecto:
Final Dashboard

Y hemos terminado! Ahora, pruebe a activar/desactivar el relé del interruptor. El relé conectado a la ESP8266 ESP-01 WiFi módulo se activar o desactivar, oirá sonidos de clic. Trate de hacer algo de ruido. El widget de sonido registrará 1 (si se detecta ruido, 0 si no). Trate de observando los widgets de temperatura y humedad – estos valores el cambio según lo que se «intuye» de donde es el módulo DHT11.

Sólo hemos utilizado la API de Cayenne MQTT para conectar nuestro dispositivo con componentes conectados a él.

https://mydevices.com/article/cayenne-mqtt-standalone-esp8266-esp-01/

Sistema de domótica con módulo WiFi ESP8266 y Cayenee


La domótica se vuelve cada vez muy popular pues proporciona comodidad y confort en los hogares permitiendo por ejemplo controles centralizados de calefacción, ventilación, aire acondicionado e iluminación, etc. contribuyendo con todo ello a una reducción general de costos por el ahorro energía (el tema principal en la actualidad) y con ello una reducción de emisión de gases de efecto invernadero dada la procedencia en su mayor parte de combustibles fósiles .

Los sistemas existentes y bien establecidos se basan en la comunicación por cable (alámbrico): este sistema no ha enfrentado ningún problema siempre que se planifique antes de la construcción física de estos en las viviendas . Pero en un edificio completo cuando hay un requisito de extensión, el sistema de cableado requiere mucho esfuerzo y costo así que tenemos que buscar sistemas inalámbricos o de automatización. En los últimos años, los sistemas inalámbricos alcanzaron su gran avance utilizándose en todas partes como por ejemplo cámaras de seguridad inalámbricas, alarmas inalámbricas, electrodomésticos inalámbricos, etc.

En este post vamos a ver un sistema domótico utilizando Arduino y nuevamente el módulo ESP8266 NodeMCU, el cual es algo más económico que el ESP32, y es mas que suficiente para esta aplicación que únicamente trata de operar 4 electrodomésticos, aunque pueden modificarse según sus necesidades. Para los relés de control, utilizamos interruptores manuales y teléfonos inteligentes. El circuito puede detectar la luz solar y la temperatura ambiente para encender y apagar luces y ventiladores automáticamente usando el middleware del que hemos hablado en numerosas veces en este blog de Cayenne

Este proyecto tiene las siguientes características:

pruebas previas con cayenne

Principio del proyecto de automatización del hogar utilizando Cayenee

Este sistema tiene dos partes principales. La primera parte es el servidor, que presenta el núcleo del sistema. Administra, controla y monitorea los hogares de los usuarios.

La segunda parte es el módulo de hardware, que proporciona una interfaz adecuada para los sensores y actuadores del sistema domótico. Pero la mayor parte del sistema de automatización disponible en el mercado es escalable en el sentido de que un servidor puede administrar muchos módulos de hardware. Porque existen en la cobertura de la red WiFi.

esp8266 por arriba

Como corazón del circuito, tenemos la placa AZDelivery NodeMCU Amica V2 es la clásica placa de desarrollo ESP caracterizándose por su sencillo uso (se maneja fácilmente desde el IDE de Arduino) contando con un potente procesador ESP8266-12F de Espressif y una WLAN integrada, por lo que este controlador ofrece una sencilla introducción al desarrollo del IoT. Hay disponibles varias versiones de firmware del fabricante, que se pueden flashear cómodamente a través del puerto micro-USB.A diferencia de modelos anteriores, si usa el chipset CP2102 modificado (por ejemplo la azdelivery) se permite una mayor velocidad de transferencia. Además, este modulo cuenta con una relativa gran memoria y también con una reserva de potencia del procesador.

Este es el resumen de las características mas significativos:

Voltaje de alimentación (USB)5V DC
Voltaje de Entrada/Salida3.3V DC
Frecuencia de reloj80MHz / 160MHz
Instrucción RAM32kB
Datos RAM96kB
UART2
Pines digitales GPIO17 (configurable como PWM a 3,3V)
Pin analógico ADC(el rango de voltaje es: 0 – 1V)
Memoria flash externa4MB

Un sistema IoT se construye con algunos componentes básicos. Los componentes son sensores, actuadores, sistemas integrados, redes, interfaces de usuario y almacenamiento de datos.

Sensores

En este proyecto se utilizan dos tipos de sensores. El primero es un LDR o resistencia dependiente de la luz para detectar la intensidad de la luz. El segundo es DHT11 para detectar temperatura y humedad.

Actuadores

Los pines de salida están conectados a los relés y se utilizan como actuadores. Las cargas eléctricas como luces y ventiladores están conectadas a los contactos de los relés. Estos relés se controlan de forma remota a través de una aplicación móvil.

Sistema Integrado

El módulo Wifi ESP8266 se utiliza aquí como un controlador integrado programado por Arduino. El Arduino se utiliza para manejar datos analógicos o digitales recibidos de sensores y para transmitir a través de la web. En este momento acepta comandos de la web y activa los dispositivos o actuadores conectados.

Red

Internet se utiliza como enlace para conectar el sistema integrado a los demás.

Interfaz de usuario

Para la comunicación, la plataforma Cayenne es compatible con MQTT o el protocolo de transporte de telemetría de cola de mensajes. Este protocolo es un protocolo de mensajería ligero para el uso del protocolo IP. Está diseñado para dispositivos de bajo consumo y bajo ancho de banda.

La plataforma de Cayenne es muy simple de usar. Esto ahorra tiempo y esfuerzo en la programación de la interfaz de usuario.

Almacenamiento de datos

El almacenamiento de datos también lo crea la plataforma Cayenne. El almacenamiento de big data es básicamente una gran cantidad de datos que se recopilan de todos los dispositivos. Este tipo de datos varía de dispositivo a dispositivo y la velocidad de flujo de datos es muy alta. 

Este el resumen de los componentes usados:

  • Módulo ESP8266 NodeMCU
  • Acoplador óptico 4N33 (x2)
  • Sensor de temperatura y humedad DHT11
  • Resistencia dependiente de la luz (LDR)
  • Relé de cambio único de 12 V (x2)
  • Transistor BC547 npn (x2)
  • LED de 5 mm (x2)
  • Diodos IN4007 (x2)
  • Condensador 100uF/25V
  • Condensador de 0.1uF
  • Resistencia 1K (x5)
  • Resistencias de 10k, 3.3K, 4.7K
  • Encender / apagar)
  • conector de 4 pines
  • Conector terminal de 2 pines para batería

Principio de funcionamiento del sistema de automatización del hogar con Cayenee

El sistema de automatización del hogar basado en ESP8266 se basa en el módulo Wifi ESP8266, LDR, sensor DHT11, optoacopladores 4N33 y dos relés.

Este circuito tiene dos partes. La primera parte es una entrada analógica para medir la intensidad de la luz a través de LDR1. La segunda parte es una entrada digital para leer valores de temperatura y humedad a través de DHT11. Para medir una amplia gama de temperatura y humedad, puede usar DHT22 como reemplazo de DHT11.

Para alimentar este circuito necesitamos un suministro de 12 V CC, ya que necesita controlar los relés. Luego tenemos que alimentar el módulo ESP8266, pero requiere 5V. IC 7805 proporciona los 5V al módulo.

NodeMCU V1.0 o ESP8266 tiene 11 pines GPIO y un pin ADC con resolución de 10 bits. En la figura, explicamos la configuración de pines de esp8266. Este módulo tiene un regulador de voltaje incorporado de 3.3V. También tiene un convertidor de USB a serie basado en CP2102 que brinda una interfaz fácil con la PC para cargar el código Arduino en el módulo.

ESP8266 tiene un cabezal macho de 30 pines. Componentes soldados en la PCB.

El LDR se usa aquí para detectar la intensidad de la luz a su alrededor. Se muestra como un formulario de porcentaje en el panel de Cayenne. Está conectado al pin A0 del módulo ESP8266 para leer el voltaje analógico según la luz ambiental.

esquema del circuito

El sensor DHT11 se usa aquí para leer la temperatura y la humedad a través del pin de entrada digital D4. Los datos dados se dividen en temperatura y humedad por DHT11 a través del mismo pin de entrada.

Dos transistores BC547 conducen esos relés a través del optoacoplador 4N33. Cada relé puede impulsar la carga de CA/CC a través de los cabezales de terminales conectados a él.

Software

Esta comunicación entre la plataforma cayenne y el dispositivo, es construida por este cuando se conecta a la red.

Usando este software Arduino IDE:

  1. Abra el software Arduino IDE
  2. Vaya a Archivo y seleccione Preferencias y pegue el enlace » https://arduino.esp8266.com/stable/package_esp8266com_index.json » en las URL de Administrador de placa adicional para agregar la placa ESp8266. Abra Boards Manager desde el menú Herramientas y escriba esp8266 para instalar la plataforma esp8266.
  3. Para programar el módulo ESP8266, se requieren tres identidades únicas del sitio web de cayenne. Estos son nombre, nombre de usuario de MQTT, contraseña de MQTT e ID de cliente. Después de conectarse a una red, estas ID ayudan a comunicar el dispositivo con ella.
  4. Para conectarse a la red WiFi local se requiere WiFi SSID y contraseña.
  5. Antes de compilar y cargar el código en este módulo, debemos instalar la biblioteca de sensores Adafruit, la biblioteca Cayenne -MQTT-ESP8266 y la biblioteca DHT .

Para agregar estas bibliotecas al IDE de Arduino, vaya a Sketch – Incluir biblioteca – Agregar biblioteca .zip – busque e instale archivos.

Biblioteca Cayenne-MQTT-ESP8266

Esto permite la comunicación de los dispositivos en la plataforma Cayenne.

biblioteca DHT

Esta biblioteca se utiliza para el sensor DHT11. Esta biblioteca comunica el módulo ESP8266 al sensor. Para usarlo, busque unificado en Library Manager e instale Adafruit Unified Sensor.

Creación del tablero del sistema de automatización del hogar con Cayenne IoT

Abra el sitio web oficial de Cayenne y cree una cuenta para usted. Haga clic en Trae tu propia cosa.

Sistema de domótica mediante software cayenee

La página siguiente mostrará tres opciones: Nombre de usuario de MQTT, Contraseña de MQTT e ID de cliente. Copie estas cadenas y péguelas en los campos apropiados del código Arduino ESP8266. Después de eso, cargue el código IDE de Arduino en el módulo NodeMCU y espere un tiempo para conectarse con el dispositivo en la red.

Sistema de domótica utilizando el software cayenee 2

Una vez que el módulo NodeMCU esté en el WiFi, la página web avanzará a la siguiente pantalla donde su dispositivo necesita un nombre que se puede cambiar después.

Ahora haga clic en el botón (+) en el ícono de cada canal para agregar el canal deseado al tablero. Obtendrá los canales agregados a la izquierda en Agregar nueva página.

Haga clic en la configuración de cada canal uno tras otro y cambie el nombre de su widget a su nombre deseado.

Primero configure el nombre del «Canal 0» en Luminosidad y haga clic en Elegir icono y seleccione Luminosidad y haga clic en Guardar. Esta función muestra la luz alrededor de LDR en porcentaje.

De manera similar, cambie los nombres de «Canal 1» y «Canal 2» a Temperatura y Humedad respectivamente. Cambie la configuración requerida como se establece en «Channel 0».

Ahora tenemos que configurar el «Canal 3» y el «Canal 4» para controlar ambos relés. Para eso, haga clic en Agregar nuevo widget de dispositivo y luego seleccione el botón Widgets personalizados. Complete el campo requerido para el «Canal 3» para la carga. Haga clic nuevamente en Agregar widget y repita de manera similar la configuración para el «Canal 4».

Sistema de domótica utilizando el software cayenee 3

Finalmente, el tablero se muestra en la figura anterior. Ahora está listo para controlar el «Canal 3» y el «Canal 4» y también el nivel de Luminosidad, Temperatura y Humedad de un lugar determinado.

A continuación, debemos descargar la aplicación Cayenne e iniciar sesión con la misma identificación de credencial para iniciar el sistema de automatización del hogar desde cualquier parte del mundo a través de Internet.

Código NodeMCU

A continuación podemos ver u posible código para desplegar en el ESP8266. No olvide que este código deberá personalizarlo con el nombre de su red wifi, la password de acceso dicha red así como las credenciales de Cayenne ( usuario MQTT, identidad de cliente y contraseña de Cayenne).

#include <Adafruit_Sensor.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiAP.h>
#include <ESP8266WiFiGeneric.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266WiFiScan.h>
#include <ESP8266WiFiSTA.h>
#include <ESP8266WiFiType.h>
#include <WiFiClient.h>
#include <WiFiClientSecure.h>
#include <WiFiServer.h>
#include <WiFiUdp.h>
#define CAYENNE_PRINT Serial
#include <CayenneMQTTESP8266.h>
char ssid[] = "Wifi Name";
char wifiPassword[] = "Password";
char username[] = "e2g58968-d026-11eb-8779-7d56e82df461";
      //Replace by your MQTT user name
char password[] = "3f2b61c76836fc5t489605346e4b110f80785ca";  //Replace by your MQTT password
char clientID[] = "73f369dr-d4f5-39da-8779-7d56e82df461";      //Replace by your Client ID
unsigned long lastMillis = 0;
#include "DHT.h"
#define DHTPIN D4     
#define DHTTYPE DHT11  
DHT dht(DHTPIN, DHTTYPE);
float h,t,f,hic,hif;
void setup()
{
dht.begin();
Serial.begin(9600);
Cayenne.begin(username, password, clientID, ssid, wifiPassword);
pinMode(D0,OUTPUT);
pinMode(D1,OUTPUT);
pinMode(D2,OUTPUT);
pinMode(D3,OUTPUT);
}
void loop()
{
Cayenne.loop();
if (millis() - lastMillis > 10000)
{
lastMillis = millis();
Cayenne.virtualWrite(0, h);
Cayenne.virtualWrite(1, t);
Cayenne.virtualWrite(2, hic);
}
h = dht.readHumidity();
t = dht.readTemperature();
f = dht.readTemperature(true);
if (isnan(h) || isnan(t) || isnan(f))
{
Serial.println("Failed to read from DHT sensor!");
return;
}
hif = dht.computeHeatIndex(f, h);
hic = dht.computeHeatIndex(t, h, false);
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" *C ");
Serial.print(f);
Serial.print(" *F\t");
Serial.print("Heat index: ");
Serial.print(hic);
Serial.print(" *C ");
Serial.print(hif);
Serial.println(" *F");
}
CAYENNE_IN(3)
{
int currentValue=getValue.asInt();
if(currentValue==1){digitalWrite(D0,LOW);}
else{digitalWrite(D0,HIGH);}
}
CAYENNE_IN(4)
{
int currentValue=getValue.asInt();
if(currentValue==1){digitalWrite(D1,LOW);}
else{digitalWrite(D1,HIGH);}
}
CAYENNE_IN(5)
{
int currentValue=getValue.asInt();
if(currentValue==1){digitalWrite(D2,LOW);}
else{digitalWrite(D2,HIGH);}
}
CAYENNE_IN(6)
{
int currentValue=getValue.asInt();
if(currentValue==1){digitalWrite(D3,LOW);}
else{digitalWrite(D3,HIGH);}
}





Fuente https://circuitdiagrams.in/home-automation-system-using-esp8266/

Sistema de domótica Alexa con Arduino IoT y ESP8266


En este post vamos a ver un sistema de automatización del hogar Alexa con la nube Arduino IoT.  Esta vez usaremos, una vez más, el famoso módulo ESP8266 NodeMCU, el cual es algo más económico que el ESP32, y es mas que suficiente para esta aplicación que únicamente trata de operar 4 electrodomésticos, aunque pueden modificarse según sus necesidades, todo ello a través del panel de Arduino IoT Cloud, Alexa e interruptores mecánicos. 

esp8266 por arriba

La placa AZDelivery NodeMCU Amica V2 es la clásica placa de desarrollo ESP caracterizándose por su sencillo uso (se maneja fácilmente desde el IDE de Arduino) contando con un potente procesador ESP8266-12F de Espressif y una WLAN integrada, por lo que este controlador ofrece una sencilla introducción al desarrollo del IoT. Hay disponibles varias versiones de firmware del fabricante, que se pueden flashear cómodamente a través del puerto micro-USB.A diferencia de modelos anteriores, si usa el chipset CP2102 modificado (por ejemplo la azdelivery) se permite una mayor velocidad de transferencia. Además, este modulo cuenta con una relativa gran memoria y también con una reserva de potencia del procesador.

Este es el resumen de las características mas significativos:

Voltaje de alimentación (USB)5V DC
Voltaje de Entrada/Salida3.3V DC
Frecuencia de reloj80MHz / 160MHz
Instrucción RAM32kB
Datos RAM96kB
UART2
Pines digitales GPIO17 (configurable como PWM a 3,3V)
Pin analógico ADC1 (el rango de voltaje es: 0 – 1V)
Memoria flash externa4MB

Es interesante destacar que gracias a la interactividad con la nube de Amazon, también podemos operar este sistema controlando los relés desde la app de Alexa desde cualquier lugar del mundo siempre que haya conectividad a Internet (aun así, también se ha previsto para esos casos, operar esos electrodomésticos con interruptores manuales).

En efecto en este diseño , puede controlar los aparatos con pulsadores de modo que si no tiene WiFi o conexión a Internet, puede controlarlo manualmente usando este método. Estas son resumidamente algunas características de este circuito:

  • Puede encender/apagar interruptores y enchufes inteligentes usando su voz.
  • Aumente o disminuya el brillo de las luces de su habitación.
  • También puede cambiar el color de las luces.
  • Puede comprobar la temperatura ambiente mediante sensores.
  • Vea la actividad de movimiento de los sensores en su habitación.

El circuito

El circuito propuesto es bastante sencillo utilizando los pines GPIO digitales D1, D2, D5 y D6 para controlar el módulo de relé de 4 canales. El SD3, D3, D7 y RX están conectados con los botones para controlar este proyecto manualmente. Obviamente el modulo de relés se puede realizar por ejemplo con una placa de puntos siguiendo el esquema de mas bajo o bien comprarlo ya montado.( por unos 11€)

modulo de reles

Los relés los conectamos al GPiO4, GPIO 5, GPIO 14 y GPIO 12 . En caso de realizar nosotros mismos el circuito usaremos cuatro transistores típicos de pequeña señal BC547B con sus correspondientes resistencias de base y diodos de protección en las bobinas de los relés. Además el circuito de los relés se puede complementar con sendos leds indicadores de estado, así como de leds de presencia de energía con sus respectivas resistencias limitadoras de 100 ohmios.

La función INPUT_PULLUP en Arduino IDE se usa aquí en lugar de usar resistencias pull-up con cada interruptor. Desde el código fuente, cuando los pines de control de los módulos de relé reciben una señal BAJA, el relé se encenderá y para la señal ALTA se apagará.

Por último el suministro de alimentación para el circuito es de de 5V 2Amp bien mediante el propio conector micro-usb del ESP32 o bien mediante alimentación común.

Este es el simple diagrama de circuito:

Sistema de domótica 4 reles , esp8266 con Alexa

Este el listado de componentes:

  • ESP8266 NodeMCU
  • Relé de 5V (x4)
  • Transistores BC547 (x4)
  • Diodo 1N4007 PN (x4)
  • LED verde (x4)
  • LED rojo (x4)
  • Resistencia 1K (x4)
  • Resistencia de 100 ohmios (x8)
  • Pulsador (x4)
  • Fuente de 5 V CC

Esta es la imagen del circuito completo donde el circuito completo se han montado sobre una PCB a medida:

Foto del montaje

Configuración y software

En resumen estos son los pasos para construir el sistema de automatización del hogar Alexa

  • Al principio, cree una cuenta en Arduino IoT Cloud.
  • Configure todo para Dashboard.
  • Configure Arduino IoT Cloud para ESP8266.
  • Programa NodeMCU con Arduino IDE.
  • Conexión de la aplicación IoT Cloud y Alexa.

A continuación veamos en mas detalle los pasos anteriormente enunciados:

1-Regístrese para obtener una cuenta gratuita de Arduino IoT Cloud

Para este proyecto de domótica, tenemos que configurar una cuenta gratuita de Arduino IoT Cloud. Gracias a esta configuración conecta ESP8266 para controlar dispositivos con Alexa de modo que crearemos una nube Arduino IoT. Estos son los pasos a seguir:

  1.  Al principio, debe hacer clic en el siguiente enlace
    https://create.arduino.cc/iot/things .
  2. Haga clic en Crear uno.
  3. Ingrese todos los detalles requeridos que quiere. Luego haga clic en Siguiente.
  4. En la página siguiente, requiere correo electrónico, nombre de usuario y contraseña para su
    cuenta Arduino IoT Cloud. Después de completar todos estos, debe aceptar todos los términos y condiciones.
  5. Ahora haga clic en el botón Registrarse.
  6. Luego revise su correo electrónico. El correo electrónico de verificación será enviado a su cuenta. Haga clic en el enlace del correo electrónico y verifíquelo.
  7. Luego regrese a Arduino IoT Cloud y actualice la página.
  8. Por último, haga clic en IoT Cloud.

2-Agregar un dispositivo

Estos son los pasos a seguir para agregar un dispositivo a la nube de Arduino:

  1. Haga clic en seleccionar dispositivo.
  2. Luego haga clic en configurar un dispositivo de terceros.
  3. Ahora seleccione el dispositivo (ESP8266) y seleccione el modelo (NodeMCU 1.0).
  4. Allí puede ver todas las placas compatibles con Arduino Cloud en el menú.
  5. Haga clic en Continuar.
  6. Ingrese un nombre para su dispositivo y haga clic en Siguiente.
  7. Después de eso, obtiene la identificación y la clave secreta de su dispositivo. Puede guardar los detalles haciendo clic en descargar el PDF.
  8. Por último, haga clic en Continuar y se agregará su dispositivo.

3- Agregar variables en proyectos Arduino IoT Cloud

Para controlar sensores o relés, debe obtener datos de estos. Estos datos pueden ser capturados por variables. En este proyecto, necesitamos cuatro variables. Para un plan gratuito, puede agregar hasta cinco variables. Estos son los pasos a seguir:

  1. Haga clic en Agregar variables.
  2. Asigne un nombre a la variable y seleccione el tipo como interruptor compatible con Alexa.
  3. Haga clic en Permiso variable como Lectura y escritura y actualice la política como Al cambiar
  4. Haga clic en Agregar variables.
  5. En este proceso puede agregar todo tipo de Variables.

4-Creación de un panel web para Arduino IoT Cloud

Estos son los pasos a seguir para crear un panel web en la nube de Arduino :

  1. Al principio, haga clic en Tablero y luego en ‘Crear tablero‘.
  2. Haga clic en el botón editar. Luego haga clic en Agregar y allí puede seleccionar el widget de cambio.
  3. Luego asigne un nombre al interruptor y haga clic en el botón Vincular variable que está visible a la derecha.
  4. Como ya creamos una variable en el paso anterior, enlaze este con el widget.
  5. Ahora haga clic en Vincular variable. Luego haga clic en Listo.
  6. Ahora puede agregar todos los widgets necesarios. En este proyecto, necesitamos cuatro widgets Switch. Después de agregar esto, haga clic en Cosas para salir del tablero.

5-Instalar boceto para Arduino IoT Cloud

Después de agregar cualquier variable en esto, se guardará automáticamente en la pestaña de boceto. Si desea editar esto pulse en más donde puede abrir un editor completo. Desde allí puede descargar el boceto del programa para el microcontrolador. Para este proyecto, el boceto descargado se abre en Arduino IDE.

Instalación de bibliotecas

Estos son los pasos a seguir en caso desde que no tenga instaladas las bibliotecas del ESP8266:

  1. En este paso, vamos a instalar todas las bibliotecas y otras dependencias. En este proyecto, necesitamos una biblioteca para ESP8266.
  2. Al principio, ve al botón de boceto.
  3. Luego haga clic en incluir bibliotecas.
  4. Haga clic en administrar bibliotecas en Arduino IDE.
  5. Allí pedirá instalar todas las dependencias. Haga clic en Instalar todo.

Actualizar el boceto del proyecto

Para actualizar Sketch, abra el archivo .ino en el IDE de Arduino. Allí puede ingresar la ID de la cosa, la ID del dispositivo, las credenciales de WiFi y la clave secreta.

Puede copiar el Thing ID desde la esquina inferior derecha de esta ventana. Ahora pegue la ID de la cosa y la ID del dispositivo en el archivo thingProperties.h en el IDE de Arduino. Luego pegue las credenciales de WiFi y la clave secreta en el archivo arduino_secrets.h .
Ahora cargue el código para ESP8266 en Arduino IDE.

Cómo usar el control remoto en la nube de Arduino

Primero, instale ‘Arduino IoT Cloud Remote‘ desde Google Play Store. Luego inicie sesión en la aplicación con el correo electrónico que usa en la cuenta de Arduino IoT Cloud. Introduzca el nombre de la cosa para abrir el panel.

Programar ESP8266 NodeMCU

  1. Al principio, actualice las preferencias -> URL del administrador de tableros adicionales: https://dl.espressif.com/dl/package_esp32_index.json y http://arduino.esp8266.com/stable/package_esp8266com_index.json
  2. Luego instale la placa ESP8266 desde el administrador de la placa.
  3. Luego instale todas las bibliotecas y dependencias requeridas.

Código para NodeMCU

Cuando cargue el código a ESP8266, puede conectar la aplicación Alexa con él. Los pasos para conectar la cuenta de Arduino IoT Cloud con la aplicación Amazon Alexa los veremos mas abajo.

#include "thingProperties.h"
 
// define the GPIO connected pins with relays and switches
#define RelayPin1 5  //D1
#define RelayPin2 4  //D2
#define RelayPin3 14 //D5
#define RelayPin4 12 //D6
 
#define SwitchPin1 10  //SD3
#define SwitchPin2 0   //D3 
#define SwitchPin3 13  //D7
#define SwitchPin4 3   //RX
 
#define wifiLed   16   //D0
 
int toggleState_1 = 0; //Define integer to remember the toggle state for relay 1
int toggleState_2 = 0; //Define integer to remember the toggle state for relay 2
int toggleState_3 = 0; //Define integer to remember the toggle state for relay 3
int toggleState_4 = 0; //Define integer to remember the toggle state for relay 4
 
void relayOnOff(int relay) {
 
  switch (relay) {
    case 1:
      if (toggleState_1 == 0) {
        digitalWrite(RelayPin1, LOW); // Turn on relay 1
        toggleState_1 = 1;
        Serial.println("Device1 ON");
      }
      else {
        digitalWrite(RelayPin1, HIGH); // Turn off relay 1
        toggleState_1 = 0;
        Serial.println("Device1 OFF");
      }
      delay(100);
      break;
    case 2:
      if (toggleState_2 == 0) {
        digitalWrite(RelayPin2, LOW); // Turn on relay 2
        toggleState_2 = 1;
        Serial.println("Device2 ON");
      }
      else {
        digitalWrite(RelayPin2, HIGH); // Turn off relay 2
        toggleState_2 = 0;
        Serial.println("Device2 OFF");
      }
      delay(100);
      break;
    case 3:
      if (toggleState_3 == 0) {
        digitalWrite(RelayPin3, LOW); // Turn on relay 3
        toggleState_3 = 1;
        Serial.println("Device3 ON");
      } else {
        digitalWrite(RelayPin3, HIGH); // Turn off relay 3
        toggleState_3 = 0;
        Serial.println("Device3 OFF");
      }
      delay(100);
      break;
    case 4:
      if (toggleState_4 == 0) {
        digitalWrite(RelayPin4, LOW); // Turn on relay 4
        toggleState_4 = 1;
        Serial.println("Device4 ON");
      }
      else {
        digitalWrite(RelayPin4, HIGH); // Turn off relay 4
        toggleState_4 = 0;
        Serial.println("Device4 OFF");
      }
      delay(100);
      break;
    default : break;
  }
}
 
void manual_control() {
  //Manual Switch Control
  if (digitalRead(SwitchPin1) == LOW) {
    delay(200);
    relayOnOff(1);
  }
  else if (digitalRead(SwitchPin2) == LOW) {
    delay(200);
    relayOnOff(2);
  }
  else if (digitalRead(SwitchPin3) == LOW) {
    delay(200);
    relayOnOff(3);
  }
  else if (digitalRead(SwitchPin4) == LOW) {
    delay(200);
    relayOnOff(4);
  }
}
 
void setup() {
  // Initialize serial and wait for port to open:
  Serial.begin(9600);
 
  delay(1500);
 
  // Define thingProperties.h
  initProperties();
 
  // Connect to Arduino IoT Cloud
  
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
 
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
 
  pinMode(RelayPin1, OUTPUT);
  pinMode(RelayPin2, OUTPUT);
  pinMode(RelayPin3, OUTPUT);
  pinMode(RelayPin4, OUTPUT);
 
  pinMode(wifiLed, OUTPUT);
 
  pinMode(SwitchPin1, INPUT_PULLUP);
  pinMode(SwitchPin2, INPUT_PULLUP);
  pinMode(SwitchPin3, INPUT_PULLUP);
  pinMode(SwitchPin4, INPUT_PULLUP);
 
  //During Starting all Relays should TURN OFF
  digitalWrite(RelayPin1, HIGH);
  digitalWrite(RelayPin2, HIGH);
  digitalWrite(RelayPin3, HIGH);
  digitalWrite(RelayPin4, HIGH);
 
  digitalWrite(wifiLed, HIGH);  //Turn OFF WiFi LED
}
 
void loop() {
  ArduinoCloud.update();
  
  manual_control(); //Control relays manually
 
  if (WiFi.status() != WL_CONNECTED)
  {
    digitalWrite(wifiLed, HIGH); //Turn OFF WiFi LED
  }
  else{
    digitalWrite(wifiLed, LOW); //Turn ON WiFi LED
  }
}
 
void onSwitch1Change() {
  if (switch1 == 1)
  {
    digitalWrite(RelayPin1, LOW);
    Serial.println("Device1 ON");
    toggleState_1 = 1;
  }
  else
  {
    digitalWrite(RelayPin1, HIGH);
    Serial.println("Device1 OFF");
    toggleState_1 = 0;
  }
}
 
void onSwitch2Change() {
  if (switch2 == 1)
  {
    digitalWrite(RelayPin2, LOW);
    Serial.println("Device2 ON");
    toggleState_2 = 1;
  }
  else
  {
    digitalWrite(RelayPin2, HIGH);
    Serial.println("Device2 OFF");
    toggleState_2 = 0;
  }
}
 
void onSwitch3Change() {
  if (switch3 == 1)
  {
    digitalWrite(RelayPin3, LOW);
    Serial.println("Device2 ON");
    toggleState_3 = 1;
  }
  else
  {
    digitalWrite(RelayPin3, HIGH);
    Serial.println("Device3 OFF");
    toggleState_3 = 0;
  }
}
 
void onSwitch4Change() {
  if (switch4 == 1)
  {
    digitalWrite(RelayPin4, LOW);
    Serial.println("Device4 ON");
    toggleState_4 = 1;
  }
  else
  {
    digitalWrite(RelayPin4, HIGH);
    Serial.println("Device4 OFF");
    toggleState_4 = 0;
  }
}

6-Conectar la aplicación Amazon Alexa con ESP8266

Para conectar nuestro circuito con la aplicación Alexa, en la app móvil Amazon Alexa realizaremos los siguientes pasos:

  1. Al principio, haga clic en Más en la aplicación Amazon Alexa.
  2. Luego seleccione Habilidades y juegos.
  3. En la opción de búsqueda, puede encontrar Arduino.
  4. Haga clic en Habilitar para usar.

Ahora necesitemos agregar un dispositivo en la aplicación Alexa

  1. En la aplicación Alexa, inicie sesión con el correo electrónico y la contraseña que utilizó para iniciar sesión en la cuenta Arduino IoT Cloud.
  2. Luego ciérralo.
  3. Haga clic en Descubrir dispositivos. El nombre de su dispositivo es visible allí en unos segundos.
  4. Luego haga clic en su dispositivo. A continuación, seleccione todos los interruptores.
  5. Si ESP8266 está conectado con su WiFi, puede controlar todos los dispositivos desde la aplicación Alexa.
  6. Ahora solo tiene que decir «Alexa, enciende la luz». La luz esta encendida. Con este comando de voz, puede controlar los electrodomésticos con su voz.

Fuente https://circuitdiagrams.in/alexa-home-automation-system/

Automatización del hogar inteligente con control de humedad mediante Blynk


Para el control de dispositivos electrónicos, gracias a las redes inalámbricas se potencia aún más el concepto de “Smart Home Automation” entendiendo la automatización del hogar como una red de hardware que funciona para comunicar los dispositivos cotidianos entre sí a través del servicio de Internet (IoT). Por ello conecta todos los dispositivos con una «única unidad de control central común» que depende de la entrada del usuario. Estos dispositivos pueden tener conectividad wifi para interactuar con teléfonos inteligentes o tabletas, ya sea que los usuarios estén en casa o en cualquier parte del mundo.

Por otro lado, tenemos a Blynk, una plataforma de Internet de las cosas que permite a los desarrolladores conectar sus dispositivos IoT (Internet de las cosas) a una variedad de servicios en la nube. La plataforma ofrece una aplicación móvil y un servidor de nube que se pueden utilizar para controlar y monitorear dispositivos conectados. Los desarrolladores pueden utilizar una variedad de lenguajes de programación para crear aplicaciones que se comuniquen con el servidor de Blynk y controlen sus dispositivos IoT.

En este post mostraremos un sistema de automatización del hogar inteligente con funciones de LDR, temperatura y humedad.  Además, cuenta con pulsador externo y funciones de interruptor táctil. Este sistema funciona a través del software Blynk, que como vamos a ver es fácil de controlar.

Automatización del hogar inteligente con control de humedad mediante Blynk

Este proyecto incluye dos partes principales: primero está el hardware, que nos permite controlar los sensores y actuadores del sistema de automatización del hogar inteligente, el segundo es el servidor, que gestiona, controla y monitoriza el domicilio del usuario.

Un sistema IoT se construye con sensores básicos, actuadores, sistema integrado, red, interfaz de usuario y almacenamiento de datos. Estos se discuten en detalle a continuación.

Sensores

Hay tres tipos de sensores que usamos para construir este sistema usando el software Blynk. El primero es el sensor DHT11 que puede detectar tanto la temperatura como la humedad, el cual hemos visto en este blog en numerosas aplicaciones. 

El DHT11 es un sensor de humedad y temperatura que se utiliza comúnmente en proyectos de IoT (Internet de las cosas) y automatización del hogar. Este sensor utiliza un chip capacitivo para medir la humedad y un termistor para medir la temperatura. El DHT11 es un sensor de bajo costo y bajo consumo de energía que es fácil de usar y se comunica con un microcontrolador a través de un protocolo de comunicación digital. Es un sensor bastante simple, pero es bastante preciso en las mediciones de humedad y temperatura en un rango de 0 a 50 grados Celsius y de 20 a 90% de humedad relativa.

dht11

El segundo es un simple LDR, que controla las funciones de encendido/apagado automático del sistema. Y el tercer sensor es un sensor táctil, que se utiliza para controlar los actuadores manualmente a través del tacto.

Actuadores

El módulo de relé de dos canales de 5 V se utiliza aquí como actuador. Básicamente, los pines de salida que están conectados directamente a la entrada del relé se denominan actuadores. Las cargas eléctricas como luces de CA, ventiladores, etc. están conectadas a los terminales comunes y normalmente abiertos de los relés. Este módulo de relé es controlado por la aplicación Blynk a través de teléfonos inteligentes.

Sistema Integrado

Cada dispositivo inteligente de automatización del hogar necesita un sistema integrado adecuado que pueda manejar todo el proceso. ESP8266 NodeMCU juega el papel aquí como un controlador integrado. Es programable por el software Arduino IDE. El NodeMCU controla los datos digitales y analógicos del receptor y los transmite a través de un servidor web. Al mismo tiempo, sus comandos de proceso son dados por sensores y actuadores.

Red

Para vincular todos los dispositivos con el sistema integrado, necesitamos una red adecuada para comunicarnos entre nosotros.

Interfaz de usuario

Para enviar datos del receptor al transmisor, necesitamos una interfaz de usuario para controlar los dispositivos desde cualquier lugar. En este proyecto, presentamos la plataforma Blynk para hacer este sistema inteligente de automatización del hogar. Es demasiado simple de usar. También proporciona botones no programables para ahorrar tiempo y esfuerzos de programación.

Almacenamiento de datos

El almacenamiento de datos utilizado aquí también lo proporciona la plataforma en la nube Blynk. El almacenamiento de big data es básicamente una gran cantidad de datos que se recopilan de todos los dispositivos. Este tipo de datos siempre varía de un dispositivo a otro. Al ser un servidor en la nube, la velocidad de datos es muy alta.

Diagrama de circuito

El circuito es realmente sencillo como podemos ver en el siguiente esquema siendo el «corazón» el ESP8266. En el circuito el DHT11 esta conectado al GPI10 mediante el protocolo one-wire. También tenemos cuatro pulsadores, tres conectados al GPIO16, GPIO13 y GPIO15 ( pueden usarse en su lugar también sensores táctiles ) y un cuarto al pin de reset. Asimismo no podemos olvidar el LDR conectado a la único puerto analógico disponible en el ESP8266 ( el ADCO).

Para terminar tenemos dos relés conectados al GPiO14 y GPIO12 mediante dos transistores de pequeña señal BC547B con sus correspondientes resistencias de base y diodos de protección en las bobinas de los relés.

esquema circuito para blynk

Esta es la lista de componentes del circuito:

  • ESP8266 NodeMCU
  • Sensor de humedad DHT11
  • Sensor LDR
  • Sensor táctil (x3)
  • Relé de 5V (x2)
  • Acoplador óptico 817 (x2)
  • Transistor BC547 NPN (x2)
  • Pulsador (x3)
  • LED rojo (x2)
  • LED verde (x2)
  • 1N4007 PN Diodo (x2)
  • Terminal de tornillo (x2)
  • Resistencia de 330Ω (x2)
  • Resistencia de 1KΩ (2)
  • alambres

Diseño de circuitos con software de PCB para la automatización del hogar inteligente

Para hacer el circuito compacto y darle un aspecto profesional, podemos usar una a PCB después de probar todas las características del proyecto de domótica inteligente utilizando el módulo wifi ESP8266 en la placa de pruebas. 

Automatización del hogar inteligente con PCB Blynk

Para el archivo Gerber, consulte este enlace Automatización inteligente del hogar usando ESP8266 y Blynk .

Software necesario para la automatización del hogar inteligente

La comunicación entre los dispositivos y la plataforma Blynk IoT se establecerá cuando haya una conexión de red presente.

Para cargar el código a ESP8266 NodeMCU, necesitamos el software Arduino IDE.

  • Primer software Arduino IDE abierto
  • Vaya a Archivo y seleccione Preferencias y pegue el enlace » https://arduino.esp8266.com/stable/package_esp8266com_index.json » en las URL de Administrador de placa adicional para agregar la placa ESP8266. Abra Boards Manager desde el menú Herramientas y escriba ESP8266 para instalar la plataforma ESP8266.
  • Para programar el módulo ESP8266, se requiere una identidad única del software Blynk. Ese es el código de autenticación. Después de conectarse a una red, esta identificación ayuda a comunicarse con el dispositivo.
  • Para conectarse a la red WiFi local se requiere WiFi SSID y contraseña.
  • Antes de compilar y cargar el código en este módulo, debemos instalar la  biblioteca de sensores de Adafruit , la biblioteca Blynk , la biblioteca DHT11 y la biblioteca OLED .

Para agregar estas bibliotecas al IDE de Arduino, vaya a Sketch – Incluir biblioteca – Agregar biblioteca .zip – busque e instale archivos.

Preparación del panel de control de automatización del hogar inteligente con Blynk

Abra la aplicación oficial de Blynk y cree una cuenta para usted. Después de crear un nuevo proyecto, recibirá el token de autenticación a través de su correo electrónico.

    Copie este token de autenticación y péguelo en los campos correspondientes del código Arduino ESP8266. Después de eso, cargue el código IDE de Arduino en NodeMCU y espere a que se conecte con el dispositivo en la red.

    La página siguiente mostrará un espacio en blanco para agregar botones para el sistema. Toque el espacio en blanco y elija la opción de botón y agregue esto. Nuevamente haga clic en esto y elija un pin virtual y seleccione el pin deseado que incluye en su código Arduino. Luego haga clic en Aceptar y presione Atrás.

    Continuar con el mismo proceso con el otro. Después de eso, elija el botón de indicador de temperatura y humedad y elija sus pines virtuales. Finalmente, regrese a la página de inicio y haga clic en el botón de reproducción en la parte superior derecha. Puede controlar sus dispositivos a través de esta aplicación Blynk.

    Principio de funcionamiento del sistema de automatización del hogar inteligente

    El sistema de automatización del hogar inteligente basado en ESP8266 se basa en el módulo wifi ESP8266, LDR, sensor DHT11, tres sensores táctiles, pantalla OLED y dos relés.

    Este circuito tiene dos partes de sensores:

    •  La primera parte es una entrada analógica para medir la intensidad de la luz a través del sensor LDR
    •  La segunda parte es una entrada digital para leer valores de temperatura y humedad a través del sensor de humedad DHT11. Para medir una amplia gama de temperatura y humedad, puede usar DHT22 como reemplazo de DHT11.

    Necesitamos un suministro de 5 V CC para encender este circuito, ya que necesita controlar los relés. Luego, también tenemos que alimentar el ESP8266 NodeMCU. ESP8266 NodeMCU V1.0 tiene 11 pines GPIO y un pin ADC con resolución de 10 bits. En la figura, explicamos la configuración de pines de ESP8266. Este módulo tiene un regulador de voltaje incorporado de 3.3V. También tiene un convertidor de USB a serie basado en CP2102 que brinda una interfaz fácil con el PC para cargar el código Arduino en el módulo.

    El sensor LDR se usa aquí para detectar la intensidad de la luz a su alrededor. Puede controlar el encendido o apagado de las luces según la intensidad de la luz. Esto está conectado al pin A0 del ESP8266 NodeMCU para leer el voltaje analógico según la luz ambiental. Se puede cambiar manualmente a través del botón CMOD en el sistema.

    El sensor DHT11 se usa aquí para leer la temperatura y la humedad a través del pin de entrada digital SD3. Los datos dados se dividen en temperatura y humedad por DHT11 a través del mismo pin de entrada. Los pines digitales D5 y D6 están conectados a las entradas del relé que actúan como actuadores. Estos pines controlan los dispositivos de CA a través de la aplicación. Tres sensores táctiles se conectan a través de tres botones y luego se conectan a los pines digitales D0, D7 y D8 respectivamente. Cuando el sistema se desconecta, estos funcionarán como interruptores normales. Entonces, podríamos usar este proyecto de automatización del hogar inteligente tanto en modo en línea como fuera de línea.

    Por último, necesitamos conectar la pantalla OLED con el sistema a través de los pines I2C de la pantalla NodeMCU y OLED. Esta pantalla OLED es opcional.

    Código NodeMCU

    //ESP8266 Based Smart Home Automation System Using Blynk
    #define BLYNK_PRINT Serial            
    #include <BlynkSimpleEsp8266.h>  
    #include <DHT.h>
    #include <SH1106Wire.h> 
    void checkPhysicalButton();
    int toggleState_1 = 0;
    int pushButton1State = LOW;
    int toggleState_2 = 0;
    int pushButton2State = LOW;
    float temperature1 = 0;
    float humidity1   = 0;
    int   ldrVal;
    int   switchMode = 0;
    //Set values for Auto Control Mode
    const float maxTemp = 34.10;
    const float minTemp = 33.8;
    const int maxLight = 1000;
    const int minLight = 200;
    #define AUTH "4w8iA4UCRADMzqEt60NoviM3Ntno0oHP"                 // You should get Auth Token in the Blynk App.  
    #define WIFI_SSID "CyBorg"             //Enter Wifi Name
    #define WIFI_PASS "Tanmoy#[email protected]"         //Enter wifi Password
    #define PUSH_BUTTON_CMODE  15 //D8
    #define LDR_PIN            A0 //A0
    #define DHTPIN             10 //SD3  pin connected with DHT
    #define RELAY_PIN_1      14   //D5
    #define RELAY_PIN_2      12   //D6
    #define PUSH_BUTTON_1    16   //D0
    #define PUSH_BUTTON_2    13   //D7
    #define VPIN_BUTTON_1    V1 
    #define VPIN_BUTTON_2    V2
    #define VPIN_BUTTON_C    V3
    #define VPIN_HUMIDITY    V5
    #define VPIN_TEMPERATURE V6
    // Declaration for an SH1106 display connected to I2C (SDA, SCL pins)
    SH1106Wire display(0x3c, D2, D1);
    // Uncomment whatever type you're using!
    #define DHTTYPE DHT11     // DHT 11
    //#define DHTTYPE DHT22   // DHT 22, AM2302, AM2321
    //#define DHTTYPE DHT21   // DHT 21, AM2301
    DHT dht(DHTPIN, DHTTYPE);
    BlynkTimer timer;
    void changeMode(){      
      delay(200);
      if (switchMode == 0){
        switchMode = 1;
      }
      else if (switchMode == 1) {
        switchMode = 0;
      }
      display.clear();
      display.setFont(ArialMT_Plain_24);
      display.drawString(10, 5, "Set Mode: ");
      display.setFont(ArialMT_Plain_24);
      display.drawString(20, 35, String(modeDecode(switchMode)));    
      display.display();
      delay(500);
      Blynk.virtualWrite(VPIN_BUTTON_C, switchMode);
      //display.clear();
    }
    void relayOnOff(int relay){
        switch(relay){
          case 1: 
                 if(toggleState_1 == 0){
                  digitalWrite(RELAY_PIN_1, HIGH); // turn on relay 1
                  toggleState_1 = 1;
                  }
                 else{
                  digitalWrite(RELAY_PIN_1, LOW); // turn off relay 1
                  toggleState_1 = 0;
                  }
                 delay(100);
          break;
          case 2: 
                 if(toggleState_2 == 0){
                  digitalWrite(RELAY_PIN_2, HIGH); // turn on relay 2
                  toggleState_2 = 1;
                  }
                 else{
                  digitalWrite(RELAY_PIN_2, LOW); // turn off relay 2
                  toggleState_2 = 0;
                  }
                 delay(100);
          break;
          default : break;      
          }
      
    }
    String modeDecode(int count){
      if (count == 0){
        return " Manual ";
      }
      else if (count == 1){
        return " Auto ";
      }
    }
    void displayData(){
      display.clear();
      display.setFont(ArialMT_Plain_24);
      display.drawString(20, 0, String(temperature1) + " 'C");
      display.drawString(20, 25, String(humidity1) + " %");
      display.setFont(ArialMT_Plain_16);
      display.drawString(10, 48, "Mode -> ");
      display.drawString(68, 48, String(modeDecode(switchMode)));
      display.display();
      Serial.print(F("Temperature: "));
      Serial.print(temperature1);
      Serial.print("   ");
      Serial.print(F("humidity: "));
      Serial.print(humidity1);
      Serial.print("   ");
      Serial.println(ldrVal); 
      Serial.println("");
    }
    void readSensor(){
        
      ldrVal = analogRead(LDR_PIN);
      
      float h = dht.readHumidity();
      float t = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit
      
      if (isnan(h) || isnan(t)) {
        Serial.println("Failed to read from DHT sensor!");
        return;
      }
      else {
        humidity1 = h;
        temperature1 = t;
      }  
    }
    void sendSensor()
    {
      readSensor();
      // You can send any value at any time.
      // Please don't send more that 10 values per second.
      Blynk.virtualWrite(VPIN_HUMIDITY, humidity1);
      Blynk.virtualWrite(VPIN_TEMPERATURE, temperature1);
    }
    BLYNK_CONNECTED() {
      // Request the latest state from the server
      Blynk.syncVirtual(VPIN_BUTTON_1);
      Blynk.syncVirtual(VPIN_BUTTON_2);
      Blynk.syncVirtual(VPIN_BUTTON_C);
    }
    // When App button is pushed - switch the state
    BLYNK_WRITE(VPIN_BUTTON_1) {
      toggleState_1 = param.asInt();
      digitalWrite(RELAY_PIN_1, toggleState_1);
    }
    BLYNK_WRITE(VPIN_BUTTON_2) {
      toggleState_2 = param.asInt();
      digitalWrite(RELAY_PIN_2, toggleState_2);
    }
    BLYNK_WRITE(VPIN_BUTTON_C) {
      switchMode = param.asInt();
    }
    void checkPhysicalButton()
    {
      if (digitalRead(PUSH_BUTTON_1) == HIGH) {
          relayOnOff(1);
          // Update Button Widget
          Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
        }
      if (digitalRead(PUSH_BUTTON_2) == HIGH) {
          relayOnOff(2);
          // Update Button Widget
          Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
        }
    }
    void setup()
    {
      Serial.begin(9600);
      
      // Initialising the UI will init the display too.
      display.init();
      display.flipScreenVertically();
      display.setFont(ArialMT_Plain_16);
      display.setTextAlignment(TEXT_ALIGN_LEFT);
      delay(1000);  
      display.setColor(WHITE);
      display.clear();
      pinMode(RELAY_PIN_1, OUTPUT);
      pinMode(PUSH_BUTTON_1, INPUT);
      digitalWrite(RELAY_PIN_1, toggleState_1);
      pinMode(RELAY_PIN_2, OUTPUT);
      pinMode(PUSH_BUTTON_2, INPUT);
      digitalWrite(RELAY_PIN_2, toggleState_2);
      Blynk.begin(AUTH, WIFI_SSID, WIFI_PASS);  
      // Setup a function to be called every 500 ms
      timer.setInterval(500L, checkPhysicalButton);
      
      dht.begin();
      // Setup a function to be called every second
      timer.setInterval(1000L, sendSensor);
      // Setup a function to be called every 2 second
      timer.setInterval(2000L, displayData);
    }
    void loop()
    {
      if (digitalRead(PUSH_BUTTON_CMODE) == HIGH){
        changeMode();
      }   
      else{    
        if(switchMode == 1){ //if Auto Mode
          //DHT11 control Relay 1
          if(temperature1 > maxTemp){
            if(toggleState_1 == 0){
              digitalWrite(RELAY_PIN_1, HIGH); // turn ON relay 1
              toggleState_1 = 1;
              // Update Button Widget
              Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
            }
          }
          else if (temperature1 < minTemp){
            if(toggleState_1 == 1){
               digitalWrite(RELAY_PIN_1, LOW); // turn OFF relay 1
               toggleState_1 = 0;
               // Update Button Widget
               Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
              }
          }
          //LDR control Relay 2
          if( ldrVal < minLight){
            if(toggleState_2 == 0){
              digitalWrite(RELAY_PIN_2, HIGH); // turn ON relay 2
              toggleState_2 = 1;
              // Update Button Widget
              Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
            }
          }
          else if (ldrVal > maxLight){
            if(toggleState_2 == 1){
               digitalWrite(RELAY_PIN_2, LOW); // turn OFF relay 2
               toggleState_2 = 0;
               // Update Button Widget
               Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
              }
          } 
        }
        timer.run();
        Blynk.run();
      }
    }

    Fuente https://circuitdiagrams.in/smart-home-automation-using-blynk/

    Introducción a Tasmota con NodeMCU


    Hemos hablado o en este blog de Node MCU, una plataforma de prototipado rápido para el desarrollo de proyectos IoT que esta basada en el chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  que pueden además  pueden   involucrar el IoT . Viene con conectividad WiFi integrada ( gracias al chip ESP8266) y puede ser programada a través de una conexión USB utilizando un lenguaje de programación como Arduino o Lua. Además, la placa NodeMCU cuenta con una serie de pines de entrada/salida (GPIO) que se pueden utilizar para conectar y controlar dispositivos externos ( sin embargo, sólo posee una entrada/salida analógica pero para eso podemos optar por el ESP32). Es una opción popular para proyectos de Internet de las cosas (IoT) debido a su bajo costo, facilidad de uso y porque integra capacidades de comunicación via WiFi , conteniendo en su interior  un microprocesador que puede ser programado fácilmente. Obviamente, ante todo, no podemos perder de vista su bajisimo precio (menos de 10€ ) comparados con otras opciones, pues no debemos olvidar  que incluye  el modulo wifi integrado  y un bus GPIO para conectar dispositivos de E/S

    node-mcu

    Por otro lado, Tasmota es un firmware alternativo para dispositivos de Internet de las cosas (IoT, por sus siglas en inglés). Se utiliza principalmente para dar soporte a dispositivos domésticos inteligentes, como interruptores y enchufes inteligentes, luces y termóstatos.

    Como amigo lector se puede imaginar, Tasmota es una opción popular entre los usuarios de IoT debido a su flexibilidad y facilidad de uso, y también porque es open source y puede ser modificado y mejorado por cualquier persona.

    Tasmota es soportado por muchísimos fabricantes que ofrecen soluciones de IoT a medida, en este post vamos a ver como es bastante fácil instalar Tasmota en una placa node-mcu y de este modo simplificar mucho su uso.

    Configuración inicial de Node-MCU

    Antes de configurar Tasmota, si empezamos por primera vez debemos realizar los típicos pasos de preparar el entorno de desarrollo, instalar los drivers y probar la placa.

    Estos pasos  a seguir   para conectar un ESP8266 son los siguientes:

    •  Instalación del IDE de Arduino .Si aun no lo tiene instalado, se puede hacer  desde aqui
    • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino
    driver-arduino-esp8266
    • Instalación de los controladores USB

    Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de su ordenador.

    El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, un módulo de comunicación inalámbrico que se utiliza para conectar dispositivos a través de una conexión USB. Este módulo es compatible con una amplia variedad de protocolos de comunicación, incluyendo Bluetooth, Zigbee y Thread, lo que lo hace ideal para aplicaciones de Internet de las cosas (IoT). Además, el módulo CP2012 viene con una placa de desarrollo de hardware que se puede utilizar para probar y desarrollar aplicaciones que utilicen el módulo. Es una opción popular para aquellos que quieren conectar dispositivos de manera inalámbrica de manera fácil y económica.

    Antes de nada generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico. Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador.

    Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de su ordenador y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

    Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

    Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema).


    Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

    Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.

    configuracion-aruduino-esp8266
    • En el IDE de Arduino, vaya al menú de herramientas, seleccionada su placa y elija el  puerto al que está conectado su ESP8266.En el ejemplo  es el COM11
    seleccion-puerto-para-esp8266-en-arduino
    • Ahora  copie el siguiente código  para probar que puede subir y que el node-mcu funciona . Copie desde el entorno de arduino las siguintes lineas y ejecute el código en la placa :

    /*ESP8266 Led Parapadeante*/


    void setup()
    {
    pinMode(LED_BUILTIN, OUTPUT);// Initializa el&nbsp; pin de LED_BUILTIN como salida

    }


    void loop() {// la función de bucle se repite una y otra vez para siempre

    digitalWrite(LED_BUILTIN, LOW);// encienda el LED&nbsp;

    delay(1000); //Espera de 1 segundo

    digitalWrite(LED_BUILTIN, HIGH);// Apague el LED haciendo que el voltaje sea ALTO

    delay(2000); //Espere dos segundos&nbsp; para dejar apagado&nbsp; LED&nbsp;

    }

    Como puede apreciar , el código ejecuta un bucle infinito en el que pone el estado bajo  un segundo (encendiendo el led)    para posteriormente forzar a nivel alto  dos segundos(apagando el led  )  y así   indefinidamente gracias al bucle  que se repite indefinidamente.

    El LED azul en el módulo ESP – 01 está conectado a GPIO 1, (que también es el pin TXD, por lo que no podemos usar Serial.print () al mismo tiempo), si todo va bien debería parpadear el led interno. Tenga en cuenta que el nivel de voltaje es BAJO  pero en realidad el LED está encendido, porque es bajo en el ESP. En este código se usa  LED_BUILTIN para encontrar el pin con el LED interno  de modo.

    INSTALACION SW DE TASMOTA

    Tasmota es un firmware especial para los microcontroladores fabricados por la empresa Espressif con los micros ESP8266,  ESP32, ESP32-S o ESP32-C3.

    Si ha trabajado alguna vez con el IDE de Arduino, después de elegir la placa con la que va a trabajar y escribir su código, lo ha subido a una placa ESP8266, en ese momento hemos creado un firmware, (bueno en realidad es el IDE Arduino quien junta todas las piezas y crea el firmware para posteriormente subirlo a la memoria de la placa).

    Ahora que ya sabemos de qué se trata un firmware sigamos con Tasmota. Soporta una gran cantidad de dispositivos ya fabricados en el mercado, como los de SONOFF o TUYA, pero también los que podemos construir, por ejemplo, con un Wemos D1 Mini.

    Se integra vía MQTT (MQ Telemetry Transport) con cualquier controlador, por ejemplo, Home ssistant,  Jeedom,  openHab. MQTT que es un protocolo muy fácil de implementar que hace que las maquina hablen entre ellas y que es un estándar en el Internet de las Cosas (IoT).

    MQTT (Message Queuing Telemetry Transport) es un protocolo de red diseñado para la conectividad de dispositivos y redes de sensores de baja potencia y ancho de banda. Se utiliza a menudo en aplicaciones de Internet de las cosas (IoT) debido a su eficiencia y facilidad de uso.

    En MQTT, los dispositivos se conectan a un servidor central llamado «broker» y se suscriben a «temas» específicos. Los dispositivos también pueden publicar mensajes a estos temas. Cuando se publica un mensaje a un tema, todos los dispositivos suscritos al tema recibirán el mensaje. Esto permite que los dispositivos se comuniquen entre sí de manera eficiente y sin tener que estar constantemente conectados al servidor central.

    MQTT es un protocolo de red ligero y fácil de implementar, lo que lo hace ideal para aplicaciones en las que la potencia y la banda ancha son limitadas.

    Algunos ejemplos de controladores que soportan MQTT:

    • Domoticz
    • Home Assistant
    • HomeBridge
    • HomeSeer
    • Mozilla Project Things
    • NodeRed
    • OpenHAB
    • SmartThings
    • Yeti
    • Jeedom

    Una vez conectado el dispositivo de una de las dos opciones anteriores, solo nos queda subir el firmware de Tasmota. Estas son algunas opciones más útiles:

    • Tasmotizer: si solo utiliza Tasmota en tu entorno esta es la opción correcta
      • Backup Automático antes de subir el código, así poder restaurar el firmware original del fabricante.
      • Subir imágenes .bin al dispositivo, que se descargan automáticamente
      • Envío de configuración wifi, MQTT etc. Para no tener que conectarnos de nuevo al dispositivo.
      • Recoger la IP del dispositivo, Tasmota avisa que esta opción depende del estado del dispositivo y que puede no funcionar.
      • Para Windows existe un ejecutable, para MAC o Linux debe hacerse con Python y se instala desde el terminal.
    • ESP-Flasher: herramienta multiplataforma basada en esptool.py, disponible para MAC y Windows, la puede descargar en este enlace ESP-Flasher.

    Resumida pues para instalar Tasmota en una placa NodeMCU, necesitaremos seguir los siguientes pasos :

    1. Descargue e instale el Arduino IDE en su ordenador.
    2. Abre el Arduino IDE y ve a «Archivo» -> «Preferencias».
    3. En la ventana de preferencias, agregue la siguiente URL en el campo «Gestor de URLs adicionales de tarjetas»: http://arduino.esp8266.com/stable/package_esp8266com_index.json
    4. Cierre la ventana de preferencias y ve a «Herramientas» -> «Placa» -> «Gestor de tarjetas».
    5. Busque «esp8266» en el gestor de tarjetas y selecciónalo. Haga clic en «Instalar» para instalar el soporte para la placa NodeMCU.
    6. Descargue la última versión de Tasmota desde el sitio web oficial.
    7. Descomprima el archivo .zip descargado y copie el contenido en una carpeta en su ordenador.
    8. Abra el Arduino IDE y selecciona «Archivo» -> «Abrir» para abrir el archivo «tasmota.ino» que se encuentra en la carpeta de Tasmota.
    9. Conecte la placa NodeMCU a tu ordenador a través del cable USB.
    10. Vaya a «Herramientas» -> «Placa» y selecciona «NodeMCU 1.0 (ESP-12E Module)».
    11. Vaya a «Herramientas» -> «Puerto» y seleccione el puerto al que está conectada la placa NodeMCU.
    12. Haga clic en el botón «Cargar» para cargar Tasmota en la placa NodeMCU.

    Una vez que Tasmota se haya cargado correctamente en la placa NodeMCU, estará listo para configurar y utilizar la placa con el software Tasmota. Estos son los pasos a seguir para instalar Tasmota en su node-mcu .

    En cuanto ejecutemos el codigo tasmota.ino enos deberia aparecer la ventana siguinte:

    Podria haber problemas

    Una vez seleccionada la placa debemos borrar el fw existente:

    borrar-esp8266

    Nos pedirá confirmación antes de borrar el dispositivo:

    confirmacion-borradp-esp8266

    Tardara un rato en completar la instalación, que ira apareciendo conforme se vaya instalando:

    progreso-instalacion-tasmota

    En unos segundos debería aparece el mensaje de concluida la instalación:

    fin-instalacion-tasmota

    Concluida la instalación tenemos la opción de acceder al interfaz del propio Tasmota o abandonar:

    acceso-tasmota-al-final-instalacion

    Si todo va bien nos aparece el interfaz de Tasmota con todas las opciones disponibles

    menu-tasmota-esp8266

    Antes de nada debemos acceder al menú configuración, para configurar los parámetros de red:

    menu configuracion-tasmota

    Una vez configurado, podemos guardar , configuración o resetear y a partir de aqui disfrutar de todas la opciones posibles

    Resumen

    Para instalar Tasmota en un dispositivo IoT, primero deberemos descargar el firmware Tasmota y guardarlo en su ordenador. Luego, deberá conectárse al dispositivo IoT utilizando una herramienta de programación como el Puente de Servicio de Firmware (FSP) o el monitor de puerto serie. A continuación, deberá cargar el firmware Tasmota en el dispositivo siguiendo las instrucciones del fabricante.

    A continuación se presentan los pasos generales que debe seguir para instalar Tasmota:

    1. Descargar el firmware Tasmota y guárdelo en su ordenador.
    2. Conecte el dispositivo IoT a su ordenador utilizando un cable de programación, como un cable USB-TTL o un cable FTDI.
    3. Abra el Puente de Servicio de Firmware (FSP) o el monitor de puerto serie.
    4. Seleccione el puerto correcto en el Puente de Servicio de Firmware o el monitor de puerto serie.
    5. Cargue el firmware Tasmota en el dispositivo siguiendo las instrucciones del fabricante.
    6. Una vez que el proceso de carga del firmware haya finalizado, deberá configurar Tasmota siguiendo las instrucciones del fabricante. Esto puede incluir la conexión del dispositivo a tu red Wi-Fi y la configuración de parámetros adicionales.

    Recuerde que los pasos específicos para instalar Tasmota pueden variar según el dispositivo IoT que esté utilizando. Es importante seguir las instrucciones del fabricante para asegurarse de que el proceso de instalación se realice correctamente.

    Cree su propio dispositivo IoT muy barato


    Node MCU es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  que pueden ademas  pueden   involucrar el IoT. Esta placa  destaca  porque integra capacidades de comunicación via WiFi , conteniendo en su interior  un microprocesador que puede ser programado fácilmente usando el  conocido lenguaje de programación Lua o bien vía Arduino IDE.

    Obviamente ante todo no podemos perder de vista su bajisimo precio comparados con otras opciones mucho mas potentes como el ESP32 ( que es su sucesor y mejora en todo excepto en el precio a esta), pero en todo caso para muchos proyectos de IOT es mas qeu suficinete, pues no debemos olvidar  que incluye  el modulo wifi integrado  y un bus GPIO para conectar dispositivos de E/S. Ademas se puede programar con el sistema Arduino lo cual nos aporta un fantástico IDE y un sinfin de manuales y ejemplos de desarrollo.

    esp8266

    Este modulo es Ideal como una solución independiente en lugar de Arduino además de Wi-Fi  integrado siendo fácil de programar a través del IDE de Arduino (como vamos a ver ) , al igual que un Arduino.
    Todos los periféricos con bus I2C puede unirse,por ejemplo Pantallas OLED, pantallas LCD, temperatura, presión, sensores de humedad pueden ser conectados en paralelo. También se puede conectar múltiples DS18B20

    Sin embargo, sólo hay una entrada analógica y salida y por ejemplo algunas pantallas táctiles no se pueden conectar con ella.

    ¿Se pregunta cómo empezar a  desarrollar código  con  su económico ESP8266 ?

    Los pasos  a seguir   para conectar un ESP8266     son los siguientes:

    •  Instalación del IDE de Arduino.Si aun no lo tiene instalado ,se puede hacer  desde aqui
    • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino
    libreria-arduino-esp8266
    • Instalación de los controladores USB

    Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

    El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador

    Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

    Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

    Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
    Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

    Ahora que estamos listos para comunicarnos con nuestro ESP8266 a través del CP2102, podemos explorar algunas de las diferentes opciones de firmware disponibles.

    configuracion-arduino-ide-con-esp8266

    • En el IDE de Arduino, vaya al menú de herramientas, seleccionada su placa y elija el  puerto al que está conectado su ESP8266.En el ejemplo  es el COM11
    configuracuion-puerto-esp8266
    • Ahora  copie el siguiente código  para probar que puede subir y ejecutar código código  en la placa :

    /*
     ESP8266 Led Parapadeante
    */
    
    void setup(){
    
     pinMode(LED_BUILTIN, OUTPUT);// Initializa el  pin de  LED_BUILTIN como salida 
    
    }
    
    void loop() {       // la función de bucle se repite una y otra vez para siempre
    
    digitalWrite(LED_BUILTIN, LOW);// encienda el LED  
    
    delay(1000); //Espera de 1 segundo
    
    digitalWrite(LED_BUILTIN, HIGH);//  Apague el LED haciendo que el voltaje sea ALTO 
    
    delay(2000); // Espere dos segundos  para dejar apagado  LED 
    
    }

    El LED azul en el módulo ESP – 01 está conectado a GPIO 1, (que también es el pin TXD, por lo que no podemos usar Serial.print () al mismo tiempo)

    Tenga en cuenta que el nivel de voltaje es BAJO  pero en realidad el LED está encendido, porque es bajo en el ESP – 01

    En este código se usa  LED_BUILTIN para encontrar el pin con el LED interno  de modo

    Como puede apreciar , el código ejecuta un bucle infinito en el que pone el estado bajo  un segundo (encendiendo el led)    para posteriormente forzar a nivel alto  dos segundos(apagando el led  )  y así   indefinidamente gracias al bucle  que se repite indefinidamente

     

    Envio de datos a la nube de Cayenne

    • Agregue la biblioteca de Cayenne MQTT a Arduino IDE  desde aqui como un fuchero zip
    • Instale la biblioteca zip descargada en el paso anterior desde Programa -> Incluir biblioteca -> Añadir libreria ZIP. y seleccionar ahora el fichero descargado con anterioridad  Cayenne-MQTT-ESP-master.zip
    • Ya puede crear una cuenta Starter en cayenne ( si aun no la tiene  ya creada)
    • Una vez ya validado vaya a la esquina  superior  izquierda  y pulse sobre el botón verde  add new
    interfaz-cayenne
    • Ahora seleccione Generic ESP8266  como la placa y  tome nota  ahora  de los siguintes paraetros ofrecidos por la  pagina:
      •  MQTT USERNAME:
      • MQTT PASSWORD:
      • CLIENT ID:
      • MQTT SERVER:
      • MQTT PORT:
      • NAME YOUR DEVICE (optional):
         
    • Abra el boceto de ejemplo incluido desde Archivo -> Ejemplos -> Cayenne-MQTT-ESP. Modifique el boceto incluido con su información de red y la información de autenticación de Cayenne que recibió al agregar su dispositivo.

    Ejemplo de envio temperatura  TMP102

    Normalmente se adquiere un placa auxiliar  para el pequeño sensor de temperatura digital TMP102. El TMP102 es un sensor digital (también conocido como I2C TWI), tiene una resolución de 0,0625 ° C, y tiene una precisión de hasta 0,5 ° C, lo cual lo convierte  es un sensor muy práctico pues requiere una muy baja corriente.

    La comunicación con el TMP102 se logra a través de una interfaz serie de dos hilos. No existe regulador de tensión de a bordo, por lo que el voltaje suministrado debe estar entre 1,4 a 3.6VDC.

    En estas placas los condensadores de filtrado y resistencias de pull-up se incluyen.

    tmp102

    En el código  siguiente o  muestra cómo enviar datos de temperatura a un sensor TMP102 en Cayenne Dashboard.Obviamente se requiere la Biblioteca de Cayenne para ejecutar este programa (si aún no lo ha hecho, puede instalarlo desde Arduino IDE Library Manager).

    conexiones-tmp102-esp8266

    Las conexiones como vemos en la iamgen  del  TMP102  al  ESP8266 on la siguintes:

                TMP102         ESP8266

    • [VCC] ————- [3V3]
    • [GND] ————- [GND]
    • [ADD0] ———– [GND]
    • [SDA] ————- [Pin analógico 4] (El SDA puede ser diferente en algunos dispositivos, por ejemplo, para Arduino Mega, el pin SDA es Pin digital 20)
    • [SCL] ———— [Pin analógico 5] (El SCL puede ser diferente en algunos dispositivos, por ejemplo, para Arduino Mega, el pin SCL es Pin digital 21)

    Y este esl codigo que subiremos a nuestro ESP8266:

    #define CAYENNE_PRINT Serial // Comment this out to disable prints and save space
    #include <CayenneTMP102.h>
    #include <CayenneEthernet.h>  // Change this to use a different communication device. See Communications examples.

    // Cayenne authentication token. This should be obtained from the Cayenne Dashboard.
    char token[] = "AuthenticationToken";

    // Virtual Pin of the TMP102 widget.
    #define VIRTUAL_PIN V1

    // Address used to read from the TMP102. This is determined by the ADD0 pin on the TMP102.
    // Connecting it to ground means the sensor will use 0x48 for the address. See the TMP102 datasheet for more info.

    const int tmp102Address = 0x48;

    TMP102 tmpSensor(tmp102Address);

    void setup()
    {
    Serial.begin(9600);
    Wire.begin();
    Cayenne.begin(token);
    }

    void loop()
    {
    Cayenne.run();
    }

    // This function is called when the Cayenne widget requests data for the Virtual Pin.
    CAYENNE_OUT(VIRTUAL_PIN)
    {
    // This command writes the temperature in Celsius to the Virtual Pin.
    Cayenne.celsiusWrite(VIRTUAL_PIN, tmpSensor.getCelsius());
    // To send the temperature in Fahrenheit or Kelvin use the corresponding code below.
    //Cayenne.fahrenheitWrite(VIRTUAL_PIN, tmpSensor.getFahrenheit());
    //Cayenne.kelvinWrite(VIRTUAL_PIN, tmpSensor.getKelvin());
    }

    Estos son los pasos resumidos que haremos en el interfaz de Cayenne:


    1. En Cayenne Dashboard, agregue un nuevo widget TMP102.
    2. Configure el widget en Visualización de valor.
    3. Seleccione Virtual Pins y un número de pin virtual.
    4. Establezca VIRTUAL_PIN en el número de pin que seleccionó.
    5. Adjunte un TMP102 a su  ESP8266.

    1. Establezca la variable tmp102Address para que coincida con ADD0. ADD0 conectado a GND corresponde a una dirección de 0x48.
    2. Establezca la variable del token para que coincida con el token de Arduino desde el Tablero.
    3. Compile y cargue este boceto.
    4. Una vez que el Arduino se conecta al Tablero, debe actualizar automáticamente el widget TMP102 con datos.

    Primeros pasos con la nube de Arduino


    Los dispositivos conectados en todo el mundo aumentan en miles de millones cada año. Arduino IoT Cloud es una plataforma que permite a cualquier persona crear proyectos IoT, con una interfaz fácil de usar y una solución todo en uno para configuración, escritura de código, carga y visualización.

    En este post, veremos algunos componentes diferentes de Arduino IoT Cloud y brindaremos una descripción general porque además hay basta información en Arduino IoT Cloud, ya que tiene varias páginas de documentación disponibles. A continuación encontrará una lista de algunas páginas populares:

    A continuación se muestra una lista de las funciones de Arduino IoT Cloud.

    • Monitoreo de datos : aprenda cómo monitorear fácilmente los valores del sensor de su Arduino a través de un tablero.
    • Sincronización de variables: la sincronización de variables le permite sincronizar variables entre dispositivos, lo que permite la comunicación entre dispositivos con una codificación mínima.
    • Programador : programe trabajos para que se activen o desactiven durante un período de tiempo específico (segundos, minutos, horas).
    • Cargas por aire (OTA) : cargue el código en dispositivos que no estén conectados a su computadora.
    • Webhooks : integre su proyecto con otro servicio, como IFTTT.
    • Soporte de Amazon Alexa : haga que su proyecto sea controlado por voz con la integración de Amazon Alexa.
    • Uso compartido del panel : comparta sus datos con otras personas de todo el mundo.

    Hardware compatible

    Para usar Arduino IoT Cloud, se requiere una placa compatible con la nube . Se puede elegir entre utilizar una placa Arduino oficial, o una placa basada en el microcontrolador ESP32/ESP8266. Además Arduino IoT Cloud actualmente admite la conexión a través de Wi-Fi, LoRaWAN® (a través de The Things Network) y redes móviles.

    Todas las placas Arduino compatibles con la nube vienen con un elemento seguro de hardware (como el criptochip ECC508 ), donde puede almacenar sus claves de seguridad.

    Wifi

    Las placas Arduino oficiales solo admiten la banda de frecuencia de 2,4 GHz para transmitir datos. Las siguientes placas se conectan a Arduino IoT Cloud a través de Wi-Fi.

    • MKR 1000 Wi-Fi :Arduino MKR1000 ha sido diseñado para ofrecer una solución práctica y rentable para cualquiera que busque añadir conectividad WiFi a sus proyectos con una mínima experiencia en redes. El diseño incluye un circuito de carga Li-Po que permite al Arduino MKR1000 funcionar con alimentación de batería o 5V externos, cargando la batería Li-Po mientras funciona con alimentación externa. El cambio de una fuente a otra se realiza automáticamente. El MKR1000 tiene un procesador Arm Cortex-M0+ de 32 bits, el habitual rico conjunto de interfaces de E/S, y WiFi de bajo consumo con un chip criptográfico para una comunicación segura. Se puede programar utilizando el conocido y fácil de usar software Arduino (IDE). Todas estas características hacen de esta placa la opción preferida para los emergentes proyectos IoT alimentados por batería en un factor de forma compacto. Su precio ronda los 60€ en Amazon.
    MKR 1000 Wi-Fi :
    • MKR Wi-Fi 1010 :MKR 1010 simplifica la creación de prototipos de aplicaciones IoT basadas en WiFi, fácil de conectar y configurar a otros productos de Arduino. El módulo híbrido de conectividad WiFi / BLE tiene un modo de bajo consumo de energía, mejorando la vida útil de las baterías .Ideal para principiantes y profesionales en IoT para la construcción de redes de sensores inalámbricos en minutos o dispositivos de control remoto. La placa puede conectarse a cualquier tipo de red WiFi existente o puedes usarla para crear tu propio Punto de Acceso Arduino. También es posible conectar su placa a diferentes servicios de la Nube, ¡incluyendo Arduino IoT Cloud! Fácil de alimentar con un cable USB o una batería Li-Po externa de 3.7V. Recarga la batería a través del puerto USB. Cuesta unos 40€ en Amazon
    MKR 1010
    • Conexión Nano RP2040 : La placa Raspberry Pi Pico incorpora el chip microcontrolador RP2040 propio de Raspberry Pi, con procesador Arm Cortex M0+ de doble núcleo que funciona a 133 MHz, 264 KB de SRAM y 2 MB de memoria Flash integrados, así como 26 pines GPIO multifunción .Es una placa microcontroladora de bajo coste y alto rendimiento con interfaces digitales flexibles con Pre-Soldered Header, es más conveniente para los ingenieros a utilizar. Para el desarrollo de software, está disponible el SDK C/C++ de Raspberry Pi, o el MicroPython. También hay recursos completos de desarrollo y tutoriales para ayudarle a empezar fácilmente, e integrarlo en los productos finales rápidamente. Esta placa es mas económica rondando los 16€ en Amazon.
    Raspberry Pi Pico
    • Nano 33 Internet de las Cosas :Diseñado para interacciones de corta distancia de BT y proyectos de ahorro de energía. Esta placa es pequeña (48mm x 18mm) y robusta estando construida alrededor del módulo NINA B306, basado en el nRF 52840 nórdico y que contiene un poderoso Cortex M4F.La arquitectura de la placa es totalmente compatible con Arduino IDE Online y Offline; tiene un sensor inercial de 9 ejes (IMU) y un bajo consumo de energía en comparación con otras placas del mismo tamaño.Clock 64MHz, Flask 1MB, RAM 256KB.Dos conectores de 15 pines, uno a cada lado de la placa. Cuesta unos 28€ en Amazon

    nano-33
    • Portenta H7 : es una placa que permite ejecutar simultáneamente código de alto nivel junto con tareas en tiempo real. El diseño incluye dos procesadores que pueden ejecutar tareas en paralelo. Por ejemplo, es posible ejecutar código compilado de Arduino junto con uno de MicroPython, y tener ambos núcleos para comunicarse entre sí. La funcionalidad de Portenta es doble, puede ejecutarse como cualquier otra placa de microcontrolador integrada o como el procesador principal de una computadora integrada. Portenta puede ejecutar fácilmente procesos creados con TensorFlow™ Lite, podría tener uno de los núcleos que calcula un algoritmo de visión por computadora sobre la marcha, mientras que el otro podría realizar operaciones de bajo nivel como controlar un motor o actuar como una interfaz de usuario.Utilice Portenta cuando el rendimiento sea clave, entre otros casos, lo imaginamos como parte de:Maquinaria industrial de alta gama, Equipo de laboratorio,Visión por computador, PLC,Interfaces de usuario preparadas para la industria, Controlador de robótica , Dispositivos de misión crítica,Computadora estacionaria dedicada,Cálculo de arranque de alta velocidad (ms). Cuesta unso 100€ en la pagina oficial de Arduino
    portenta-h7
    • Portenta H7 Lite conectado :El Portenta H7 Lite Connected está diseñado para proporcionar la potencia computacional del Portenta H7 para aplicaciones de IA y soluciones de control de baja latencia, con un módulo que se vuelve más rentable al eliminar la función de interfaz de video de alta resolución. Llena la brecha entre las versiones H7 completa y H7 Lite al integrar conectividad inalámbrica, agregando otra opción para que los clientes de Arduino Pro construyan la solución perfecta con la combinación correcta de rendimiento y simplicidad. El Portenta H7 Lite Connected ejecuta simultáneamente código de alto nivel y tareas en tiempo real gracias a sus dos procesadores. Por ejemplo, puede ejecutar código compilado por Arduino y MicroPython al mismo tiempo, y hacer que los dos núcleos se comuniquen a través de un mecanismo de llamada de procedimiento remoto que permite llamar a funciones en el otro procesador sin problemas para realizar múltiples tareas reales. Sus algoritmos de aprendizaje automático ahora pueden ejecutarse simultáneamente junto con la interacción de sensor/actuador de baja latencia. Cuesta unos 89€ en la tienda oficial
    • Control de la máquina Portenta: Portenta Machine Control es una unidad de control industrial totalmente centralizada y de bajo consumo capaz de controlar equipos y maquinaria. Se puede programar utilizando el marco Arduino u otras plataformas de desarrollo integradas.Gracias a su poder de cómputo, Portenta Machine Control permite una amplia gama de casos de uso de inteligencia artificial y mantenimiento predictivo. Permite la recopilación de datos en tiempo real desde la planta de producción y admite el control remoto de equipos, incluso desde la nube, cuando se desee. Cuesta unos 300€ en la tienda de Arduino.
    portenta-induistrial
    • Nicla Visión : combina un potente procesador IC STM32H747AII6 Dual ARM® Cortex® M7/M4 con una cámara a color de 2 MP compatible con TinyML, así como un sensor de movimiento inteligente de 6 ejes, un micrófono integrado y un sensor de distancia. Puede incluirlo fácilmente en cualquier proyecto porque está diseñado para ser compatible con todos los productos Arduino Portenta y MKR, se integra completamente con OpenMV, es compatible con MicroPython y también ofrece conectividad WiFi y Bluetooth® Low Energy. Es tan compacto, con su factor de forma de 22,86 x 22,86 mm, que puede adaptarse físicamente a la mayoría de los escenarios y requiere tan poca energía que puede funcionar con batería para aplicaciones independientes.Todo esto convierte a Nicla Vision en la solución ideal para desarrollar o crear prototipos con procesamiento de imágenes en el dispositivo y visión artificial en el borde, para seguimiento de activos, reconocimiento de objetos, mantenimiento predictivo y más, más fácil y rápido que nunca. Entrénelo para detectar detalles, de modo que pueda concentrarse en el panorama general. Cuesta unos 95€

    nicla-vision
    • Opta .   Gracias a su poder de cómputo (STM32H747XI dual Cortex®-M7+M4 MCU Arm® de baja potencia de 32 bits: incluye un Cortex® M7 que funciona a 480 MHz y un Cortex® M4 que funciona a 240 MHz comunicandose los dos núcleos a través de un mecanismo de llamada a procedimiento remoto que permite llamar a funciones en el otro procesador sin problemas) Arduino Opta permite una amplia gama de aplicaciones de control, monitoreo y mantenimiento predictivo en tiempo real.Permite a los profesionales ampliar los proyectos de automatización mientras aprovechan el ecosistema abierto y ampliamente conocido de Arduino. Póngalo a trabajar rápidamente, aprovechando las numerosas bibliotecas de software disponibles. El elemento seguro integrado garantiza actualizaciones de firmware inalámbricas y control remoto a través de Arduino Cloud o servicios de terceros. Arduino Opta está disponible en tres variantes:Opta Lite: puertos Ethernet y USB-C® integrados, Opta RS485: puertos Ethernet y USB-C® integrados, además de conectividad RS485 y Opta WiFi: puertos Ethernet y USB-C® integrados, además de RS485 y Wi-Fi/Bluetooth® Low Energy.El Opta está programado para ser lanzado pronto, junto con la documentación sobre cómo usarlo.

    opta

    La conexión a través de Wi-Fi es una alternativa fácil y sus credenciales se pueden ingresar de manera segura durante la configuración de un proyecto. Este tipo de conexión es más adecuado para proyectos de bajo alcance, en los que conecta su placa a la nube a través del enrutador de su hogar/trabajo/escuela. Ahora veremos otros tipos de conectividad:

    LoRaWAN®

    Las siguientes placas se conectan a Arduino IoT Cloud a través de The Things Stack , un servidor de red LoRaWAN® conectado a miles de puertas de enlace LoRa® públicas.

    • MKR WAN 1300
    • MKR WAN 1310

    Se recomienda la conexión a través de LoRaWAN® para proyectos de bajo consumo tanto en áreas remotas como urbanas, donde Wi-Fi u otros tipos de conectividad populares no están disponibles. Las placas MKR WAN 1300/1310 están equipadas con un módulo de radio LoRa y tienen una ranura para una antena. Con la configuración adecuada de bajo consumo, la placa puede enviar datos a la nube durante meses con una sola batería.

    Placas GSM / NB-IoT

    El MKR GSM 1400 y el MKR NB 1500 requieren una tarjeta SIM para conectarse a la nube, ya que se comunican a través de las redes móviles.

    • MKR GSM 1400
    • MKR NB 1500

    La conexión a través de redes móviles se puede considerar en áreas remotas donde no hay Wi-Fi o en proyectos móviles (como el seguimiento de carga). Tenga en cuenta que una conexión segura es una operación que consume mucha memoria, por lo que no hay mucha memoria para la aplicación del usuario (por ejemplo, alrededor de 2,6 kB en el MKR GSM 1400). El uso de muchas variables de IoT Cloud puede hacer que el boceto se quede sin memoria en las placas que no descargan la pila SSL y hacen que se bloquee.

    ESP32 / ESP8266

    Arduino IoT Cloud es compatible con una amplia gama de placas de terceros basadas en los microcontroladores ESP32 y ESP8266 con soporte para Wi-Fi. Para configurarlos, simplemente elija la opción de terceros en la configuración del dispositivo.

    Configuración de placas de terceros.
    Configuración de placas de terceros.

    Ethernet

    Arduino IoT Cloud admite la conexión a través de Ethernet en varios dispositivos. Las opciones para conectarse vía Ethernet son las siguientes:

    • Conéctese con el Portenta H7 en combinación con un portador/escudo compatible con Ethernet .Para conectarse con la placa Portenta H7 , necesitará uno de los siguientes protectores/portadores :Escudo de visión Portenta Ethernet o Control de la máquina Portenta
    • Conéctese con la Opta . *

    Para habilitar la comunicación a través de Ethernet con el Portenta H7, mientras configura su dispositivo, debe seleccionar la opción «Ethernet». Si su dispositivo ya está configurado como un dispositivo Wi-Fi, debe quitarlo antes de configurarlo para la comunicación Ethernet.

    Elija la opción Ethernet.
    Elija la opción Ethernet.

    Tenga en cuenta que el hardware más antiguo, como Ethernet Shield Rev2 y MKR ETH Shield , actualmente no es compatible con Arduino IoT Cloud.

    Primeros pasos

    Configurar Arduino IoT Cloud y acceder a las diferentes funciones disponibles implica unos simples pasos. ¡Así que echemos un vistazo a cómo ir de principio a fin!

    1. Crear una cuenta de Arduino

    Para comenzar a usar la nube Arduino IoT, primero debemos iniciar sesión o registrarnos en Arduino .

    2. Vaya a la nube Arduino IoT

    Una vez que nos hayamos registrado, puede acceder a Arduino IoT Cloud desde cualquier página en arduino.cc haciendo clic en el menú de cuatro puntos en la esquina superior derecha. También puede ir directamente a Arduino IoT Cloud .

    Navegando a la nube.
    Navegando a la nube.

    3. Crear una cosa

    El viaje siempre comienza creando una Cosa nueva . En la descripción general de Thing, podemos elegir qué dispositivo usar, a qué red Wi-Fi queremos conectarnos y crear variables que podemos monitorear y controlar. Este es el espacio de configuración principal, donde todos los cambios que hacemos se generan automáticamente en un archivo de boceto especial .

    Resumen de la Cosa.
    Resumen de la Cosa.

    4. Configuración de un dispositivo

    Los dispositivos se pueden agregar y vincular fácilmente a una Cosa. Arduino IoT Cloud requiere que su ordenador tenga instalado Arduino Agent . El proceso de configuración es rápido y fácil, y se puede hacer haciendo clic en el botón «Seleccionar dispositivo» en la descripción general de Thing. Aquí podemos elegir entre cualquier placa que se haya configurado, o seleccionar la opción “Configurar nuevo dispositivo” .

    Configuración de un dispositivo.
    Configuración de un dispositivo.

    «Dispositivos»

    La pestaña del dispositivo.
    La pestaña del dispositivo.

    5. Creando Variables

    Las variables que creamos se generan automáticamente en un archivo de boceto. Hay varios tipos de datos entre los que podemos elegir, como int, float, boolean, long, char . También hay variables especiales, como Temperatura, Velocidad, Luminancia que se pueden usar. Al hacer clic en el botón «Agregar variable» , podemos elegir el nombre, el tipo de datos, la configuración de actualización y el modo de interacción.

    Creación de variables.
    Creación de variables.

    6. Conexión a una red

    Para conectarse a una red Wi-Fi, simplemente haga clic en el botón «Configurar» en la sección de red. Ingrese las credenciales y haga clic en «Guardar» . ¡Esta información también se genera en su archivo de boceto!

    Ingreso de credenciales de red.
    Ingreso de credenciales de red.

    5. Creando Variables

    Ahora que hemos configurado las variables, los dispositivos y los ajustes de red, ¡podemos comenzar a programar nuestros dispositivos!

    Un archivo de boceto generado automáticamente se puede encontrar en la pestaña «Bosquejo» . Tiene la misma estructura que un típico archivo *.ino , pero con algún código adicional para hacer la conexión a su red y a la nube.

    Un boceto que, por ejemplo, lee un sensor analógico y usa la variable de nube para almacenarlo. Cuando se haya cargado el boceto, funcionará como un boceto normal, ¡pero también actualizará las variables de la nube que usamos!

    Además, cada vez que creamos una variable que tiene habilitado el permiso de lectura y escritura , también se genera una función en la parte inferior de su archivo de boceto. ¡Cada vez que esta variable cambie, ejecutará el código dentro de esta función! Esto significa que podemos dejar la mayor parte del código fuera del loop() y solo ejecutar código cuando sea necesario.

    Para subir el programa a nuestra placa, simplemente haga clic en el botón «Subir» .

    Edición de un boceto en el editor de la nube.
    Edición de un boceto en el editor de la nube.

    El editor también tiene una herramienta Serial Monitor , que se puede abrir haciendo clic en la lupa en la barra de herramientas. Aquí puede ver información sobre su conexión o comandos impresos a través de

    Serial.print()

    .

    La herramienta de monitor en serie.
    La herramienta de monitor en serie.

    Una vez que hayamos cargado correctamente el código, podemos abrir la pestaña «Serial Monitor» para ver información sobre nuestra conexión. Si tiene éxito, imprimirá «conectado a network_name» y «conectado a la nube» . Si no se conecta, también imprimirá los errores aquí.

    El editor en la nube es una versión «mínima» reflejada del Editor web. Cualquier cambio que realice también se reflejará en el Editor web, que es más adecuado para desarrollar bocetos más avanzados.

    8. Creación de un panel

    Ahora que configuramos el dispositivo y la red, creamos variables, completamos el boceto y cargamos correctamente el código, podemos pasar a la parte divertida: ¡crear tableros!

    Los tableros son una interfaz de usuario visual para interactuar con sus tableros en la nube, y podemos configurar muchas configuraciones diferentes según lo que necesite su proyecto de IoT. Podemos acceder a nuestros tableros haciendo clic en la pestaña «Tableros» en la parte superior de la interfaz de Arduino IoT Cloud, donde podemos crear nuevos tableros y ver una lista de tableros creados para otras cosas.

    Navegación a los tableros.
    Navegación a los tableros.

    Si hacemos clic en “Crear nuevo tablero” , entramos en un editor de tableros. Aquí, podemos crear algo llamado widgets . Los widgets son la representación visual de nuestras variables que creamos, y hay muchos diferentes para elegir. A continuación se muestra un ejemplo que utiliza varios tipos de widgets.

    Los diferentes widgets disponibles.
    Los diferentes widgets disponibles.

    Cuando creamos widgets, también debemos vincularlos a nuestras variables . Esto se hace haciendo clic en un widget que creamos, seleccionando una cosa y seleccionando una variable que queremos vincular. Una vez que está vinculado, podemos interactuar con él, por ejemplo, un botón, o podemos monitorear un valor de un sensor. ¡Mientras nuestra placa esté conectada a la nube, los valores se actualizarán!

    Digamos que tenemos un widget de temperatura que queremos vincular a la variable de temperatura dentro del proyecto de la nube .

    Vincular una variable a un widget.
    Vincular una variable a un widget.

    Tenga en cuenta que no todos los widgets y variables son compatibles. Un interruptor y un número entero, por ejemplo, no se pueden vincular y no serán una opción al configurar su tablero.

    También podemos tener varias cosas funcionando a la vez, dependiendo de tu plan Arduino IoT Cloud, que podemos incluir en el mismo dashboard. Esta es una excelente característica para rastrear múltiples tableros en, por ejemplo, una red de sensores más grande, donde los tableros se pueden conectar a diferentes redes en todo el mundo, pero se pueden monitorear desde el mismo tablero.

    zz

    Contador inteligente basado en Home Assistant


    En efecto, es posible crear un contador de consumo de energía inteligente usando un mínimo hardware (en nuestro caso un node MCU con un modulo PZEM) y el software de Home Assistant (que, en nuestro caso, correrá en nuestro PC o en una Raspberry Pi). Para ello vamos a utilizar una pequeña solución, que es muy utilizada para hacer este tipo de mediciones, por lo que vamos a integrar con un modulo PZEM004 ( del que hemos hablado en numerosas ocasiones en este blog ) , y como controlador, una placa para redes inalámbricas basado en el chip ESP8266, y luego haremos la integración mediante el software de Home Assistant.

    Esta solución nos ofrecerá un medidor de corriente y de consumo muy útil ,ya que podemos medir no sólo el consumo general que tenemos de la red eléctrica, sino que también un sinfín de aplicaciones como por ejemplo para poder medir la producción de energia fotovoltaica, fluctuaciones de red, presencia de energia reactiva, etc.

    Además a diferencia de otros proyectos que hemos tratado en este blog que vuelcan los datos sobre nubes publica ( por ejemplo Cayenne), en esta ocasión las medidas de nuestro consumo eléctrico quedan en nuestra propia nube privada garantizada por el sw de Home Assistant.

    TASMOTA

    Tasmota es un firmware de código abierto para dispositivos ESP desarrollado por Theo Arends (de los Países Bajos). También es el webmaster de un blog de tecnología con buenos tutoriales. Tasmota no está escrito en «lenguaje Arduino», sin embargo, no necesitará codificar con Tasmota. Se trata principalmente de cargar el código, apenas cambiando 1-2 líneas para una configuración personalizada. Su arduo trabajo le dará un sistema listo para producción para controlar los relés que está listo para IoT (es un tema aparte sobre cómo configurarlo) y se puede configurar desde un dispositivo móvil como cualquier «enchufe inteligente» comercial. Como hemos dicho, Tasmota es un firmware preescrito para placas ESP. Muchos de los lectores suelen usar ESP32 con Arduino IDE y pueden temer usar Tasmota. En esta guía, explicaremos qué herramientas necesitará para cargar el firmware de Tasmota.

    Desde el repositorio de GitHub de Theo Arends ( https://github.com/arendst/Tasmota/tree/firmware/firmware/tasmota32 ) , obtendrá el archivo tasmota32.bin:

    Necesita descargar ese archivo  tasmota32.bin

    Desde techiesms.com ha creado un repositorio con todos los archivos necesarios (incluido el archivo anteriortasmota32.bin) que necesitará cargar. Lo podemos encontrar también en el repositorio de GitHub (aún no se he editado ningún archivo) de AbhishekGhosh (https://github.com/AbhishekGhosh/TASMOTA-on-ESP32 )

    Necesitará la herramienta flasher oficial del sitio web de Espressif https://www.espressif.com/en/support/download/other-tools

    Termite ayudará a agregar SSID y contraseña a la placa ESP: https://termite.software.informer.com/3.2/

    Las anteriores son las herramientas que necesitaremos. Sin embargo, puedes usar Tasmotizer en su lugar: https://github.com/tasmota/tasmotizer

    Inicie la herramienta intermitente de Espressif. Seleccione «Modo desarrollador». Luego haga clic en «Herramienta de descarga ESP32». Cuando se inicie el software flasher, deberá cargar:

    BootLoader.bin
    Parttion_Table.bin
    SPIFFS.bin
    tasmota32.bin

    Seleccione el puerto COM correcto, la tasa de baudios correcta y haga clic para comenzar. Una vez que se complete el flasheo, se detendrá y saldrá de la aplicación. Abra la herramienta Termitas. Seleccione el puerto COM correcto, la tasa de baudios correcta.

     Ingrese estos comandos uno por uno:

    SSID1 <name-of-hotspot># hit enter/command
    Password1 <password-here># hit enter/command
    ## do not use <  >

    En el resultado, obtendrá la dirección IP local del dispositivo.

     Puede abrir la dirección IP en un navegador y jugar con la configuración de GPIO (Configuración> Configurar módulo).

    Cómo trabajar con Tasmota en ESP32

    HOME ASSSITANT

    Home Assistant es un software de código abierto que le permite monitorear dispositivos IoT en su hogar. Además, puede crear automatización fácilmente. Por ejemplo, cuando la temperatura es inferior a 21 grados, puede enviar una notificación a su dispositivo móvil. Además, puede hacer funcionar su calentador si tiene un calentador conectado.

    En la mayoría de los casos, Home Assistant se instala en una Raspberry pi como se muestra en el documento oficial . Sin embargo, en este post explicará cómo instalar en su ordenador usando docker compose, lo cual hace la instalación muy sencilla.

    Comencemos por crear el directorio myproject. En este directorio, cree un subdirectorio llamado config. Debería tener un árbol que se parezca a:

    | myproject
    | -- docker-compose.yaml
    | -- config
    

    Ahora agregue el archivo docker-compose.yam a la carpeta  myproject.

    # docker-compose.yaml
    version: "3.5"
    services:
      homeassistant:
        container_name: home-assistant
        image: homeassistant/home-assistant:stable
        volumes:
          - ./config:/config
        environment:
          - TZ=Europe/Paris
        restart: always
        ports:
          - 8123:8123
        network_mode: host
    

    Ejecute el asistente de inicio:

    $ docker-compose up -d
    

    Asistente de configuración del hogar

    Enhorabuena, su Home Assistant ya se está ejecutando. Necesita configurarlo de la siguiente manera:

    • Vaya a http://localhost:8123
    • Cree su cuenta usando un nombre de usuario y contraseña
    • Agregue su ubicación si está interesado en ver datos meteorológicos
    • Luego haga clic en finalizar

    Debería aparecer una página de inicio.Página de inicio del asistente de inicio

    Configuración del asistente doméstico

    • Haga clic en Configuration, en la parte inferior izquierda.
    • Ir a Integrations
    • Haga clic en el +botón en la parte inferior derecha.
    • Aparecerá un modal con la lista de dispositivos compatibles, haga clic en esphome.
    • Agregue la dirección IP de su ESP32, deje el puerto en 6053.
    • Haga clic en finalizar.

    Ahora tiene un ESPhome configurado correctamente.Integración de esphome asistente de hogar

    Agregar datos a la página de inicio

    Una vez que haya configurado un dispositivo ESPhome, ahora puede agregar los datos que proporciona a su página de inicio. Por ejemplo si su dispositivo está conectado al termómetro Xiaomi Mijia, el objetivo sería ver los datos de temperatura y humedad.

    • Haga clic en Configuration, en la parte inferior izquierda.
    • Ir a Devices
    • Haga clic en su dispositivo
    • En la parte inferior Entidades, haga clic en Add to Lovelace.

    Finalmente, regrese a la página de inicio y controle la temperatura de su sala de estar desde la página de inicio.

    Temperatura del asistente del hogar

    Acceso a la temperatura desde el exterior

    Vigilar su casa cuando está adentro es importante, pero también lo es cuando está afuera.

    • En primer lugar, abra el puerto 8123 en su enrutador y reenvíelo al host del asistente doméstico.
    • Descargue la aplicación Home Assistant para Android o iOS .
    • Obtenga la IP pública de su puerta de enlace doméstica usando https://www.showmyipaddress.eu/
    • Abra la aplicación y agregue la url de conexión http://yourpublicip:8123/

    Felicitaciones por instalar Home Assistant con éxito.

    Configuración de contador de energia

    El Pzem004 es un módulo de prueba de monitorización eléctrica que incluye un transformador de corriente que viene además ya calibrado. El módulo puede usarse para medir la energía, el voltaje y la corriente, y luego mostrarlo en un PC u otros terminales ofreciendo una precisión del 1%. Existe una versión con display que incluye un botón de restablecimiento que puede restablecer los datos de energía simplemente pulsándolo. Además, puede almacenar datos cuando se apaga, y almacenar los datos de energía acumulados antes de apagarse, por lo que es muy conveniente usarlo.

    Gracias a que todas las versiones equipan un interfaz de comunicación de datos serie TTL, puede leer y configurar los parámetros relevantes a través del puerto serie que podemos capturar con un microcontrolador como por ejemplo un ESP32.

    En efecto usando la Biblioteca Arduino para Peacefair  en un ESP32 y un PZEM-004T-100A v3.0 podemos construir un Monitor de energía usando la interfaz ModBUS.

    Antes de empezar debemos saber que la versión 3.0 PZEM es una versión mejorada de la anterior PZEM-004T (para la que puede encontrar la biblioteca aquí aunque las bibliotecas son incompatibles entre las dos versiones de hw).

    Las principales características de este módulo son las siguientes;

    • Mide voltaje, corriente, potencia, energía, factor de potencia y frecuencia (nuevo en la versión 3.0)
    • 247 direcciones esclavas programables únicas
    • Contador de energía interna hasta 9999.99kWh
    • Alarma de sobrealimentación
    • Puesta a cero del contador de energía
    • Suma de comprobación CRC16
    • Mejor, pero no perfecto aislamiento de red

    Especificaciones del fabricante

    FUNCIÓNRANGO DE MEDICIÓNRESOLUCIÓNPRECISIÓN
    Voltaje80~260V0.1V0,5%
    Actual0~10A o 0~100A*0.01A o 0.02A*0,5%
    Poder activo0~2,3kW o 0~23kW*0.1W0,5%
    energía activa0~9999.99kWh1Wh0,5%
    Frecuencia45~65Hz0,1 Hz0,5%
    Factor de potencia0,00~1,000.011%

    * Uso del transformador de corriente externo en lugar del derivador incorporado

    Este módulo es una versión mejorada del PZEM-004T con funciones de medición de frecuencia y factor de potencia, disponible en los lugares habituales. Se comunica mediante una interfaz TTL a través de un protocolo de comunicación similar a Modbus-RTU, pero es incompatible con la biblioteca @olehs anterior que se encuentra aquí: https://github.com/olehs/PZEM004T&nbsp;. 

    Compatibilidad con Arduino

    A continuación mostramos la compatibilidad con diferentes microcontroladores:

    Comunicación en serie


    Este módulo está equipado con una interfaz de comunicación de datos en serie TTL, puede leer y configurar los parámetros relevantes a través del puerto en serie; pero si desea comunicarse con un dispositivo que use USB o RS232 (como un ordenador), debe estar equipado con un adaptador TTL diferente (la comunicación USB debe estar equipada con una placa adaptadora de conexiones TTL a USB y la comunicación RS232 debe estar equipada con un adaptador TTL a niveles RS232)

    En la siguiente tabla se encuentran los protocolos de comunicación de este módulo:

    NOFUNCIÓNCABEZADATOS1- DATOS5SUMA
    1aRequerimiento de voltajeB0C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor del voltaje)1A
    1bRespuesta de voltajeA000 E6 02 00 00 (Respuesta del medidor, el valor del voltaje es 230,2 V)88
    2aRequerimiento actualB1C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor actual)1B
    2bRepresentante actualA100 11 20 00 00 (Respuesta del medidor, el valor actual es 17.32A)D2
    3aRequerimiento de potencia activaB2C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de potencia activa)1C
    3bPotencia activa Resp.A208 98 00 00 00 (Respuesta del medidor, el valor de potencia activa es 2200w)42
    4aLeer energía ReqB3C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de energía)1D
    4bLeer energía Resp.A301 86 9f 00 00 (Respuesta del medidor, el valor de energía es 99999wh)C9
    5aEstablecer la dirección del módulo ReqB4C0 A8 01 01 00 (La computadora envía una solicitud para configurar la dirección, la dirección es 192.168.1.1)1E
    5bEstablecer la dirección del módulo resp.A400 00 00 00 00 (Respuesta del medidor, la dirección se estableció correctamente)A4
    6aEstablecer el umbral de alarma de potencia ReqB5C0 A8 01 01 14 (la computadora envía una solicitud para establecer un umbral de alarma de energía)33
    6bEstablecer el umbral de alarma de potencia RespA500 00 00 00 00 (El medidor responde que el umbral de alarma de energía se configuró correctamente)A5

    Veamos ahora un ejemplo de protocolo de comunicación:

    1-Configure la dirección de comunicación: 192.168.1.1 (el usuario puede configurar su propia dirección en función de sus preferencias y necesidades).

    Enviar comando: B4 C0 A8 01 01 00 1E –>Datos de respuesta: A4 00 00 00 00 00 A4 .

    Nota: El envío de comandos y la respuesta automática de datos son como se muestra arriba, los datos se expresan en hexadecimal; el último byte de los datos de envío y respuesta son 1E y A4, pertenecen a la suma acumulativa. En el envío de comandos: B4 + C0 + A8 + 01 + 01 + 00 = 21E (utilice la suma hexadecimal), los datos de suma acumulada son 21E, tome los dos últimos bytes 1E para utilizar los datos de suma acumulada en el envío de comandos; datos en respuesta: A4 + 00 + 00 + 00 + 00 + 00 = A4 (use la suma hexadecimal), la suma acumulada de datos es A4, que es la suma acumulada de datos en respuesta.

    2-Configure el umbral de alarma de potencia: 20 KW
    Comando de envío: B5 C0 A8 01 01 14 33–>Datos de respuesta: A5 00 00 00 00 00 A5
    Nota : 14 en el comando de envío es el valor de la alarma (14 es una representación de datos hexadecimales, que se convirtió a decimal es 20). Lo que debe tener en cuenta es que el valor de alarma de potencia de este módulo se basa en unidades KW, lo que significa que el valor mínimo de alarma es 1 KW, el valor máximo es 22 KW.

    3-Leer el voltaje actual
    Enviar comando: B0 C0 A8 01 01 00 1A–>Datos de respuesta: A0 00 E6 02 00 00 88
    Nota : Los datos de voltaje de respuesta son D1D2D3 = 00 E6 02, 00 E6 representa el bit entero del voltaje, 02 representa el decimal del voltaje, el decimal es un dígito, convierte 00 E6 en decimal es 230; convierte 02 a decimal es 2, por lo que el valor de voltaje actual es 230.2V.

    4-Leer el comando de envío actual actual

    Enviar comando: B1 C0 A8 01 01 00 1B–>Datos de respuesta: A1 00 11 20 00 00 D2
    Nota : Los datos actuales de respuesta son D2D3 = 11 20, 11 representan el bit entero de la corriente, 20 representan el decimal del actual, el decimal actual es de dos dígitos, convierte 11 en decimal es 17; convierte 20 a decimal es 32, por lo que el valor actual actual es 17,32 A.

    5-Leer el comando de envío de energía actual

    Enviar comando:: B2 C0 A8 01 01 00 1C–>Datos de respuesta: A2 08 98 00 00 00 42
    Nota : Los datos de energía de respuesta son D1D2 = 08 98, convierte 08 98 a decimal es 2200, por lo que el valor de voltaje actual es 2200W .

    6-Leer el comando de envío de energía:

    Enviar comando:B3 C0 A8 01 01 00 1D–>Datos de respuesta: A3 01 86 9F 00 00 C9
    Nota : los datos de energía de respuesta son D1D2D3 = 01 86 9F, convierte 01 86 9F a decimal es 99999, por lo que la energía acumulada es 99999Wh .

    Circuito Básico con ejemplo de código

    Gracias a la biblioteca PZEM-004T v3.0 para el monitor de energía Peacefair PZEM-004T-10A y PZEM-004T-100A v3.0 utilizando la interfaz ModBUS y una placa ESP32, podemos monitorizar el consumo eléctrico junto a otras variables eléctricas como la tensión , la frecuencia , el factor de potencia, etc.

    Es interesante destacar que debemos usar la ultima versión del modulo, pues la versión 3.0 PZEM es una versión mejorada del antiguo PZEM-004T 

    Respecto a las conexiones eléctricas debemos tener especialmente cuidado en el conexionado de las clemas de BT , las cuales viene claramente especificadas en la hoja de característica del modulo PZEM que usemos, pues una parte es para la medida del voltaje ( la medición se hace en paralelo ) y la parte contigua es la parte de la medida de la Intensidad (la medida se toma en serie en versiones de menos intensidad máxima admisible, pero para la versión de 100A se suele tomar con una bobina toroidal o con un pinza amperimétrica)

    ¡Asegúrese de que el dispositivo esté conectado a la alimentación de CA! Los 5V solo alimentan los optoacopladores, no el chip real. Además, tenga cuidado, ¡la corriente alterna es peligrosa! ¡Si no sabe lo que estás haciendo, puede morir ! Es usted responsable de su propia estupidez. Así que no sea estúpido

    Peor tanto ,debemos extremar el cuidado especialmente en estas conexiones (las que van con tornillo).

    Observe por ejemplo las conexiones del módulo de 100 Amp. usado para escribir este post:

    Esta versión PZEM tiene una UART Serial que funciona a 5V, por lo que se debe realizar una simple modificación soldando una resistencia de 1K a 1/4W para permitir que la comunicación funcione a 3.3v en los casos de placas como Raspberry Pi, ESP32 y esp8266, con esta modificación la UART funcionará a 5v o 3.3v.

    Nota: Esta es la manera más sencilla y económica si no tienen al alcance un convertidor TTL de 5 a 3.3v, pero no se garantiza que funcione en todos los casos y con todos los medidores (en el prototipo probado funciona sin problemas).

    Respecto a las conexiones del PZEM004 con una placa ESP32 , estas son las siguientes:

    • TX ->GPIO17 (pin 7)
    • RX ->GPIO16 (pin 6) (podemos conectar una resistencia de 1K entre este y GND ).
    • GND->GND DE SP32 (pin 2)
    • VCC->3.3 DE ESP32 (pin 1)


    Vamos a seguir un esquema bastante sencillo que puede ser adaptado a distintas necesidades y montajes. Por ahora, y para realizar las pruebas podemos usar el siguiente simple esquema:

    Por el interior del anillo tendremos que pasar el cable de Fase (Negro) sobre el que queramos realizar las mediciones, pudiendo ser el mismo, o no, que el que hemos usado para dar corriente al circuito.

    Nota: Algunos módulos ESP permiten la salida de corriente 5V por el pin, otros no. Si vas a alimentar el módulo ESP con un cable USB y desde sus pines 5V/VCC y GND alimentar el módulo PZEM-004T comprueba que estos pines ofrezcan la corriente deseada.

    Dado que realmente el módulo ESP funciona a 3,3V y si se desea alimentar el módulo PZEM-004T con este voltaje, se recomienda colocar una resistencia de 1K entre 5V y RX del propio PZEM-004T. La Web de Tasmota tiene mucha información al respecto.

    Para ciertamente este montaje no conlleve ningún peligro debemos aislar ambas placas (por ejemplo en una caja de conexiones) para asegurarnos de que no recibimos ninguna descarga eléctrica fortuita tal y como podemos ver en el prototipo de abajo donde se usa un Arduino uno en lugar de un ESp32.

    Compatibilidad

    PRINCIPALES CARACTERÍSTICAS
    • Mide voltaje, corriente, potencia, energía, factor de potencia y frecuencia (nuevo en la versión 3.0)
    • 247 direcciones esclavas programables únicas
    • Contador de energía interno hasta 9999,99kWh
    OTRAS CARACTERÍSTICAS
    • Alarma de sobrecarga
    • Reinicio del contador de energía
    • Suma de comprobación CRC16
    • Aislamiento de red mejor, pero no perfecto

    En la configuración que vamos a ver a continuación, usaremos un ESP8266 en el lugar del ESP32, pero los pasos de configuración del menú de Tasmota es idéntico y por supuesto con el Home Assistant.

    En el esquema se usan los puertos 5 y 6 ( eso son d5 y d6) conectados al modulo PZEM con sus respectivas masas . Entonces necesitamos luego suministrar 5 voltios para alimentar el nodemcu ( sirve por ejemplo un cargador de móvil que no usemos con salida micro-usb) y es tan simple como eso.

    En este punto si hemos seguido los pasos comentados mas arriba para instalar el sw de Tasmota en el NodeMcu (donde como se ha comentado no hará falta instalar nada desde el ide de Arduino ) , nos iremos a la url de acceso creada para dar acceso al nuevo equipo Tasmota :

    Deberemos configurar los pines que hayamos conectado al modulo PZEM pulsando sobre los desplegables de la derecha. Observe que el lado de transmisión es general para todos los PZEM y para el lados de RX deberemos seleccionar nuestro modulo especifico y por supuesto ambos en los GPIOS a los que estén conectados.

    Guardaremos la información para que empiece Tasmota a procesar las mediadas.

    Si to ha sido correcto. ya deberíamos ver en el menú de Tasmota los valores eléctricos referidos al módulo PZEM en tiempo real.

    Solo nos queda comunicar el equipo Tasmota que acabamos de configurar usando el ESP y el PZEM con el Home Assistant, lo cual lo haremos a traves del menú MQTT. Para ello consultaremos en nuestro Home Assistant los valores de usuario/contraseña y el tópico que añadiremos desde en esta pantalla.


    Una vez configurado el MQTT y tengamos arrancado el Home Assitant , ahora puede agregar los datos que proporciona a su página de inicio dado que ya se configurado un dispositivo ESPhome

    • Haga clic en Configuration, en la parte inferior izquierda.
    • Ir a Devices
    • Haga clic en su dispositivo
    • En la parte inferior Entidades, haga clic en Add to Lovelace.
    Finalmente, regrese a la página de inicio y compruebe sus medidas eléctricas desde la página de Home Assistant:


    En el siguiente video podemos ver todo el proceso completo:

    Creacion de un aplicacion movil para Iot


    A veces crear una APP móvil para nuestro proyecto de IOT puede ser una labor muy compleja dependiendo muchísimo de la tecnologia que usemos para desarrollarla. Para intentar simplificar todo esto en este blog hemos hablado del entorno Cayenne que dispone también de infraestructura en la nube y también está disponible tanto versión web como móvil, pero en esta ocasión vamos a tratar una solución mucho más sencilla conocida como Blynk.  Si es la primera vez que conoce Blynk, ¡bienvenido! Blynk está aquí para ayudar a todos aquellos desarrolladores y emprendedores con talento que buscan crear prototipos, desplegar y gestionar remotamente dispositivos electrónicos conectados a cualquier escala. Esta  nueva plataforma le permitirá conectar el hardware a la nube y utilizar módulos de aplicación preconfeccionados para construir aplicaciones iOS, Android y web listas para los usuarios finales.

    Obtención de la placa Arduino adecuada para el trabajo

    Si desea realizar un proyecto Arduino que está conectado a Internet a través de WiFi, necesita una placa a que puede conectarse a Wi-Fi. Es así de simple. El Arduino UNO, nano, micro, Mega … no se puede conectar a Wi-Fi sin la adición de escudos caros y obsoletos. Así mismo puede ahorrar mucho tiempo y dinero y no hacer para esto a menos que tenga una buena razón para hacerlo. Hay afortunadamente placas mucho más baratas con conectividad wifi como pueden ser  ESP8266  y su sucesor el ESP32 ( asi como todos sus derivados).

    Una placa muy barata es  Wemos D1 o Wemos mini tablero de www.wemos.cc. Los Wemos D1 es un clon de la Arduino UNO  que utiliza el chip esp8266, cuenta con capacidades WiFi completo fuera de la caja y cuesta sólo $ 4,00 (aunque hoy en dia una placa basada es ESP32 es mucho más potente y versatil por muy poco mas)  .Esa  placa que vemos abajo es muy barata contando con un microprocesador que se conecta a Wi-Fi. Cuenta con todas las cosas que sabe y gusta  como: pines digitales, pines analógicos, Vin, GND, 3,3 V de salida, conector de alimentación, salida de 5 V y un conector micro USB rápido y fácil de cargar sus bocetos.

    Si necesita una placa  más pequeña, un ejemplo es la  Wemos mini (basada también en el ESP8266). 

    Getting the Right Arduino Board for the Job

    EJEMPLO INICIAL

    Inscribirse

    ‍ Su primer paso será crear una cuenta. Puede hacerlo descargando  la app para iOS y Android o en Blynk.Console . El proceso de registro es bastante sencillo, pero aquí puede consultar una guía más detallada si es necesario

    Nota: Si es usuario de Blynk 1.0, deberá crear una nueva cuenta para acceder a la nueva plataforma.

    Habilitar el modo de desarrollador

    ‍ El desarrollador Por lo general, es alguien que construye el hardware, desarrolla el firmware y realiza todas las configuraciones del dispositivo.

    Habilitar el modo de desarrollador:
    1. En la aplicación Blynk o en Blynk.Console
    2. Vaya a Mi perfil / Perfil de usuario en el menú de la izquierda
    3. Verifique que el interruptor del modo de desarrollador esté en ON

    Nota: actualmente, solo se permite un desarrollador por organización para evitar problemas de sincronización. Este límite se puede cambiar más adelante.

    Configuración rápida de plantilla

    ‍ Una vez que esté en modo desarrollador, puede comenzar a trabajar en su primera plantilla de dispositivo. Plantilla de dispositivo es un conjunto de configuraciones heredadas por dispositivos de un tipo similar. Piense en los interruptores domésticos inteligentes. Todos realizan una función similar y es seguro asumir que deberían tener el mismo modelo de datos, GPIO, código de firmware, etc. Si necesitara introducir cambios en todos estos dispositivos, en lugar de editar cada uno de ellos, simplemente podría editar se actualizará una plantilla de dispositivo y todos los dispositivos.

    Active su primer dispositivo

    ‍ Ahora que ha creado una o más plantillas de dispositivos, puede comenzar a poner sus dispositivos en línea.

    Para comenzar a usar Blynk.Cloud, debe asignar un AuthToken único a cada dispositivo. El objetivo de AuthToken es identificar el dispositivo en Blynk Cloud. Hay algunas formas de obtener tokens de autenticación para su dispositivo y pueden variar según el hardware, la conectividad y el caso de uso de IoT en el que esté trabajando.

    Estas son las dos formas principales de poner AuthTokens en sus dispositivos:

    A. Aprovisionamiento de WiFi mediante Blynk.Edgent

    ‍ Para los dispositivos que pueden conectarse a Internet a través de WIFI, recomendamos utilizar el método de aprovisionamiento WiFi integrado en la aplicación Blynk. Este método también se denomina aprovisionamiento de tokens de autenticación dinámicos.

    La aplicación Blynk y Blynk.Edgent se encargarán de decirle a sus dispositivos cómo conectarse a la red WiFi de su hogar u oficina. El nuevo token de autenticación se generará y almacenará automáticamente en el dispositivo. No necesita especificar las credenciales de WiFi y el token de autenticación en el código de firmware.

    Recomendamos enfáticamente utilizar el aprovisionamiento WiFi si está trabajando en un producto WiFi comercial. Beneficios del método de aprovisionamiento WiFi para aplicaciones comerciales:

    • No puede predecir a qué red WiFi sus clientes conectarán sus productos.
    • Simplifica el proceso de fabricación a escala, ya que puede usar un código de firmware similar sin necesidad de agregar manualmente el token de autenticación a cada dispositivo al final de la línea de fabricación.
    B. Activación del dispositivo con un token de autenticación estático (para Ethernet, celular y otros tipos de conexión)

    ‍ Este método se recomienda para dispositivos que pueden conectarse a Internet mediante Ethernet, celular (2G, 3G, 4G, LTE) u otros tipos de conexión (que no requieren credenciales WiFi personalizadas, por ejemplo).

    La principal diferencia con el aprovisionamiento de WiFi es que AuthToken debe generarse manualmente y actualizarse en el dispositivo antes de que pueda usarse.

    El token de autenticación estático se usa a menudo durante la etapa de creación de prototipos. Sin embargo, Blynk también ofrece una solución completa para trabajar con tokens estáticos en las aplicaciones comerciales.

    Enviar datos del dispositivo a Blynk

    ‍ Para enviar mensajes desde la aplicación al código que se ejecuta en su placa (a través del servidor Blynk), utilizará pines virtuales.

    • Los pines virtuales son independientes del hardware. Esto significa que es mucho más fácil transferir su código de una plataforma de hardware a otra en el futuro (por ejemplo, puede darse cuenta de que NodeMCU es mejor que Arduino Uno + ESP-01 con el que comenzó).
    • Tienes mucho más control sobre lo que hace tu widget cuando usas pines virtuales. Por ejemplo, si desea que un solo botón de aplicación active o desactive varios relés al mismo tiempo, es muy fácil hacerlo con pines virtuales.
    • Los pines virtuales son más predecibles (estables si lo desea) que manipular pines digitales.
    Configurar notificaciones para un solo dispositivo o para una selección de dispositivos

    ‍ Nota : las notificaciones funcionan además de Eventos . Antes de continuar, asegúrese de que su producto tenga al menos un evento configurado en sus notificaciones de configuración de plantilla para una selección de dispositivos

    1. Abrir búsqueda
    2. Ir a Dispositivos
    3. Seleccione varios dispositivos
    4. Pase el cursor sobre el menú Acciones […]
    5. Haga clic en Configuración de notificaciones

    En el cajón abierto, seleccione los eventos deseados para editar

    1. Haga clic en Editar configuración

    En la ventana modal, active los canales deseados (Correo electrónico, Push o SMS), seleccione los destinatarios . Si el destinatario no está en la lista, puede buscar escribiendo el nombre o la dirección de correo electrónico.

    Tenga en cuenta que está la entrada «Todos los miembros». Significa que todos los usuarios de la organización a la que pertenece el dispositivo serán los destinatarios de una notificación.

    EJEMPLO  CON WEMOS

    1. Instale la última versión del IDE de Arduino www.arduino.cc

    2. Siga los pasos en el sitio Wemos para configurar el IDE de Arduino para apoyar la placa Wemos  http:? Id = //www.wemos.cc/wiki/doku.php en: arduino_g …

    3. Descargue los ejemplos de  Wemos D1 desde https: //github.com/wemos/D1_mini_Examples/archive / …

    4. Descomprima el archivo descargado  de https://github.com/wemos/D1_mini_Examples/archive/master.zip
    5. Copie todos los archivos en el directorio de ejemplos de Arduino: (normalmente C: \ Archivos de programa (x86) \ Arduino \ ejemplos)
    6. IDE Arduino abierto, seleccione Archivo – ejemplos – Mini ejemplos D1 – Bases – abrir y cerrar
    7. En Herramientas, seleccione su tablero Wemos y el puerto COM correcto (éste es el puerto USB que está utilizando, por lo general sólo una opción estará disponible)
    8. Suba su boceto. Si  su tarjeta está parpadeando, lo hizo bien, si no, se ha perdido uno de los pasos anteriores.

    Creación de su  aplicación con Blynk

    Para hacer  nuestra aplicación vamos a utilizar Blynk. Blynk es una sencilla herramienta que te permite crear aplicaciones en su teléfono y compartir esas aplicaciones con otras personas. Es un sistema de arrastrar y soltar lo que no requiere lenguaje de programación y toma el control directo de los pines del Arduino . Comenzó como un pedal de arranque en 2015, pero creció rápidamente para ser una herramienta profesional y de gran utilidad. la mejor parte: la aplicación se creará en sólo un minuto y estará totalmente adaptable! (Únase a los foros Blynk si necesita ayuda o quiere contribuir).

    1. Descargue la última biblioteca de Blynk http://www.blynk.cc/getting-started/,descomprimir y copiarlo en el directorio de la biblioteca Arduino (normalmente: C: \ Archivos de programa (x86) \ Arduino \ bibliotecas).

    2. Descargue la aplicación Blynk para Android o Iphone  y hacer su primera aplicación. Vaya a la configuración y elija Esp8266.

    3. En «configuración» en la aplicación que se encuentra «token de autenticación» por email a si mismo, que lo necesitará más adelante .

    4. Abra el IDE Arduino.
    5. Bajo el item  ejemplos, elija Blynk, «independiente esp8266»

    6. En el boceto, agregue el token de autenticación de la etapa 3, donde dice token de autenticación. SSID es el  nombre de la conexión Wi-Fi y la contraseña es la contraseña de su red wifi. Llene estos tres en el croquis en sus respectivos lugares . No hay necesidad de seguir elaborando el boceto. Sólo con este código tendrá un control total sobre todos los pasadores de su tarjeta a través de la app.

    Creating Your Android / Iphone App With Blynk

    Prueba de su aplicación Blynk!

    1. Añadir un LED a GND y el pin 13 en su tablero Wemos (Quiero mencionar que la forma correcta de hacer esto, es con una resistencia entre el pin 13 y el LED. Su LED no va a vivir una vida muy larga y sin)
    2. En la aplicación en su teléfono o tableta, agregue un control deslizante conectado al pin gpO14.(Nótese que las patas de la placa no son los mismos que los pasadores en la aplicación. Para una descripción completa, consulte el diagrama anterior, Observe también que pines I / O en Wemos tableros son de 3,3 voltios, no de 5 voltios al igual que en la Arduino UNO. no enviar 5 voltios a través de ellos!)
    3. En el IDE de Arduino pulsar  el botón de reproducción en la esquina superior derecha de la aplicación Blynk. FELICITACIONES !!!!

    Acabamos de realizar  un proyecto de electrónica TOTALMENTE CONTROLADO INTELIGENTE !!!!, para ello mueva el control deslizante hacia la derecha para hacer que el led ir más brillante, a la izquierda del atenuador de luminosidad.

    TEST Your Blynk App!

    Algunas observaciones importantes

    – Como se mencionado antes en el paso 4 los pines de la placa no coinciden con la aplicación, consulte el sitio Wemos para la disposición de las clavijas de la placa específica. Es probable que en un futuro próximo Blynk añadirá soporte Wemos por supuesto, a continuación, seleccione su tablero de aplicación y los pasadores coincidirán.

    – 3,3 v es todo el i / o pasadores de apoyo Wemos. Va a romper su tablero si envía más a través de él. Un circuito divisor de resistencia o tensión simple puede ayudar si usted fuera a ser pegado con 5v entrada que necesita convertir.

    – Los Wemos sólo tiene un pin analógico. Si necesita mucho más, necesitara usar otra placa como puede ser el ESP32

    Fuente aqui 

    Programación OTA en ESP32


    Una de las mejores cosas de ESP32 es que su firmware se puede actualizar de forma inalámbrica. Este tipo de programación se llama «Over-The-Air» (OTA) permitiendo actualizar/cargar un nuevo programa al ESP32 a través de Wi-Fi sin tener que conectar el ESP32 a un ordenador a través de USB.

    La funcionalidad OTA es útil cuando no hay acceso físico al módulo ESP pero además, reduce el tiempo necesario para actualizar cada módulo ESP durante el mantenimiento.

    Una ventaja clave de OTA es que una única ubicación central puede enviar una actualización a varios ESP en la misma red.

    La única desventaja es que debe incluir un código OTA con cada boceto que cargue para poder usar OTA en la próxima actualización.

    Hay dos formas de implementar la funcionalidad OTA en el ESP32:

    • OTA básico : las actualizaciones se envían mediante el IDE de Arduino.
    • Web Updater OTA : las actualizaciones se entregan a través de un navegador web.

    Cada uno tiene sus propios beneficios, por lo que puede usar el que funcione mejor para su proyecto.

    OTA Básico

    En este primer apartado veremos el proceso de implementación de OTA básico.  En resumen son 3 pasos simples para usar OTA básico con el ESP32

    1. Instalación de la serie Python 2.7.x: el primer paso es instalar la serie Python 2.7.x en su computadora.
    2. Carga de firmware OTA básico en serie: cargue el boceto que contiene el firmware OTA en serie. Este es un paso necesario para realizar las actualizaciones posteriores de forma inalámbrica.
    3. Carga de nuevos bocetos por aire: ahora puede cargar nuevos bocetos al ESP32 desde Arduino IDE por aire.

    1: Instalación de Python 2.7.x

    Para usar la funcionalidad OTA, primero debe instalar Python 2.7.x, si aún no está instalado en su máquina. Descargue Python 2.7.x para Windows (instalador MSI) desde el sitio web oficial de Python .

    Inicie el instalador y continúe con el asistente de instalación

    Asegúrese de que la opción «Agregar python.exe a la ruta» esté habilitada en la sección Personalizar Python 2.7.X.

    2: Carga del firmware OTA básico en serie

    Debido a que la imagen de fábrica del ESP32 carece de la capacidad de actualización OTA, primero debe cargar el firmware OTA en el ESP32 a través de la interfaz serial.

    Es necesario actualizar primero el firmware para poder realizar actualizaciones inalámbricas posteriores.

    El complemento ESP32 para Arduino IDE incluye una biblioteca OTA, así como un ejemplo de BasicOTA. Simplemente navegue a Archivo > Ejemplos > ArduinoOTA > BasicOTA .

    Antes de comenzar a cargar el boceto, debe modificar las siguientes dos variables con sus credenciales de red para que el ESP32 pueda conectarse a una red existente.

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

    Cuando haya terminado, siga adelante y cargue el boceto.

    #include <WiFi.h>
    #include <ESPmDNS.h>
    #include <WiFiUdp.h>
    #include <ArduinoOTA.h>
    
    const char* ssid = "..........";
    const char* password = "..........";
    
    void setup() {
      Serial.begin(115200);
      Serial.println("Booting");
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);
      while (WiFi.waitForConnectResult() != WL_CONNECTED) {
        Serial.println("Connection Failed! Rebooting...");
        delay(5000);
        ESP.restart();
      }
    
      // Port defaults to 3232
      // ArduinoOTA.setPort(3232);
    
      // Hostname defaults to esp3232-[MAC]
      // ArduinoOTA.setHostname("myesp32");
    
      // No authentication by default
      // ArduinoOTA.setPassword("admin");
    
      // Password can be set with it's md5 value as well
      // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
      // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
    
      ArduinoOTA
        .onStart([]() {
          String type;
          if (ArduinoOTA.getCommand() == U_FLASH)
            type = "sketch";
          else // U_SPIFFS
            type = "filesystem";
    
          // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
          Serial.println("Start updating " + type);
        })
        .onEnd([]() {
          Serial.println("\nEnd");
        })
        .onProgress([](unsigned int progress, unsigned int total) {
          Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
        })
        .onError([](ota_error_t error) {
          Serial.printf("Error[%u]: ", error);
          if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
          else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
          else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
          else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
          else if (error == OTA_END_ERROR) Serial.println("End Failed");
        });
    
      ArduinoOTA.begin();
    
      Serial.println("Ready");
      Serial.print("IP address: ");
      Serial.println(WiFi.localIP());
    }
    
    void loop() {
      ArduinoOTA.handle();
    }

    Ahora, abra el Serial Monitor a 115200 baudios y presione el botón EN en el ESP32. Si todo está bien, debería ver la dirección IP dinámica asignada por su enrutador. Tome nota de ello.

    Paso 3: Carga del nuevo boceto por aire

    Ahora, subamos un nuevo boceto por aire. Recuerde que debes incluir el código OTA en cada sketch que subas. De lo contrario, perderá la capacidad OTA y no podrá realizar la próxima carga inalámbrica. Por lo tanto, se recomienda que modifique el código anterior para incluir su nuevo código.

    Como ejemplo, incluiremos un boceto Blink simple en el código OTA básico. Recuerda modificar las variables SSID y contraseña con sus credenciales de red.

    Los cambios en el programa Basic OTA están resaltados con comentarios //******.

    #include <WiFi.h>
    #include <ESPmDNS.h>
    #include <WiFiUdp.h>
    #include <ArduinoOTA.h>
    
    const char* ssid = "..........";
    const char* password = "..........";
    
    
    //******codigo programa*******
    //variabls for blinking an LED with Millis
    const int led = 2; // ESP32 Pin to which onboard LED is connected
    unsigned long previousMillis = 0;  // will store last time LED was updated
    const long interval = 1000;  // interval at which to blink (milliseconds)
    int ledState = LOW;  // ledState used to set the LED
    
    //******fin codigo programa*******
    
    void setup() {
    
    //******codigo programa*******
    pinMode(led, OUTPUT);
    //******fin codigo programa*******
      
      Serial.begin(115200);
      Serial.println("Booting");
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, password);
      while (WiFi.waitForConnectResult() != WL_CONNECTED) {
        Serial.println("Connection Failed! Rebooting...");
        delay(5000);
        ESP.restart();
      }
    
      // Port defaults to 3232
      // ArduinoOTA.setPort(3232);
    
      // Hostname defaults to esp3232-[MAC]
      // ArduinoOTA.setHostname("myesp32");
    
      // No authentication by default
      // ArduinoOTA.setPassword("admin");
    
      // Password can be set with it's md5 value as well
      // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
      // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
    
      ArduinoOTA
        .onStart([]() {
          String type;
          if (ArduinoOTA.getCommand() == U_FLASH)
            type = "sketch";
          else // U_SPIFFS
            type = "filesystem";
    
          // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
          Serial.println("Start updating " + type);
        })
        .onEnd([]() {
          Serial.println("\nEnd");
        })
        .onProgress([](unsigned int progress, unsigned int total) {
          Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
        })
        .onError([](ota_error_t error) {
          Serial.printf("Error[%u]: ", error);
          if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
          else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
          else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
          else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
          else if (error == OTA_END_ERROR) Serial.println("End Failed");
        });
    
      ArduinoOTA.begin();
    
      Serial.println("Ready");
      Serial.print("IP address: ");
      Serial.println(WiFi.localIP());
    }
    
    void loop() {
      ArduinoOTA.handle();  
    
    //******codigo programa*******
    //loop to blink without delay
      unsigned long currentMillis = millis();
      if (currentMillis - previousMillis >= interval) {
      // save the last time you blinked the LED
      previousMillis = currentMillis;
      // if the LED is off turn it on and vice-versa:
      ledState = not(ledState);
      // set the LED with the ledState of the variable:
      digitalWrite(led,  ledState);
     //******fin codigo programa*******
      }
    
    }

    Tenga en cuenta que no hemos utilizado la delay()función para hacer que el LED parpadee. Esto se debe a que la delay()función pausa el programa. Si se genera la siguiente solicitud OTA mientras el ESP32 está en pausa esperando a delay()que se complete, su programa perderá esa solicitud.

    Después de copiar el boceto anterior en su IDE de Arduino, navegue hasta la opción Herramientas > Puerto . Busque algo como: esp32-xxxxxx en your_esp_ip_address . Si no puede localizarlo, es posible que deba reiniciar su IDE.

    Elija el puerto y presione el botón Cargar. El nuevo boceto se cargará en cuestión de segundos. El LED integrado debería comenzar a parpadear.

    Actualizador OTA via web

    La programación OTA es útil cuando necesita actualizar el código de las placas ESP32 a las que no se puede acceder fácilmente. El ejemplo que mostraremos aquí funciona cuando el ESP32 y su navegador están en su red local.

    La única desventaja de OTA Web Updater es que debe agregar el código para OTA en cada boceto que cargue, para que pueda usar OTA en el futuro.

    ¿Cómo funciona el Actualizador web OTA?

    • El primer boceto debe cargarse a través del puerto serie. Este boceto debe contener el código para crear el actualizador web OTA, de modo que pueda cargar el código más tarde con su navegador.
    • El boceto de OTA Web Updater crea un servidor web al que puede acceder para cargar un nuevo boceto a través del navegador web.
    • Luego, debe implementar rutinas OTA en cada boceto que cargue, de modo que pueda realizar las próximas actualizaciones/cargas por aire.
    • Si carga un código sin una rutina OTA, ya no podrá acceder al servidor web y cargar un nuevo boceto por aire.

    Antes de continuar , debe tener instalado el complemento ESP32 en su IDE de Arduino. Veamos los pasos a seguir

    1-Carga de OTAWebUpdater

    Cuando instala el complemento ESP32 para Arduino IDE, instalará automáticamente la biblioteca ArduinoOTA. Vaya a Archivo > Ejemplos > ArduinoOTA > OTAWebUpdater .

    otawebupdater-arduino-ide

    Debería cargarse el siguiente código.

    /*
     * OTAWebUpdater.ino Example from ArduinoOTA Library
     * Rui Santos 
     * Complete Project Details https://randomnerdtutorials.com
     */
    
    #include <WiFi.h>
    #include <WiFiClient.h>
    #include <WebServer.h>
    #include <ESPmDNS.h>
    #include <Update.h>
    
    const char* host = "esp32";
    const char* ssid = "REPLACE_WITH_YOUR_SSID";
    const char* password = "REPLACE_WITH_YOUR_PASSWORD";
    
    WebServer server(80);
    
    /*
     * Login page
     */
    const char* loginIndex = 
     "<form name='loginForm'>"
        "<table width='20%' bgcolor='A09F9F' align='center'>"
            "<tr>"
                "<td colspan=2>"
                    "<center><font size=4><b>ESP32 Login Page</b></font></center>"
                    "<br>"
                "</td>"
                "<br>"
                "<br>"
            "</tr>"
            "<td>Username:</td>"
            "<td><input type='text' size=25 name='userid'><br></td>"
            "</tr>"
            "<br>"
            "<br>"
            "<tr>"
                "<td>Password:</td>"
                "<td><input type='Password' size=25 name='pwd'><br></td>"
                "<br>"
                "<br>"
            "</tr>"
            "<tr>"
                "<td><input type='submit' onclick='check(this.form)' value='Login'></td>"
            "</tr>"
        "</table>"
    "</form>"
    "<script>"
        "function check(form)"
        "{"
        "if(form.userid.value=='admin' && form.pwd.value=='admin')"
        "{"
        "window.open('/serverIndex')"
        "}"
        "else"
        "{"
        " alert('Error Password or Username')/*displays error message*/"
        "}"
        "}"
    "</script>";
     
    /*
     * Server Index Page
     */
     
    const char* serverIndex = 
    "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"
    "<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
       "<input type='file' name='update'>"
            "<input type='submit' value='Update'>"
        "</form>"
     "<div id='prg'>progress: 0%</div>"
     "<script>"
      "$('form').submit(function(e){"
      "e.preventDefault();"
      "var form = $('#upload_form')[0];"
      "var data = new FormData(form);"
      " $.ajax({"
      "url: '/update',"
      "type: 'POST',"
      "data: data,"
      "contentType: false,"
      "processData:false,"
      "xhr: function() {"
      "var xhr = new window.XMLHttpRequest();"
      "xhr.upload.addEventListener('progress', function(evt) {"
      "if (evt.lengthComputable) {"
      "var per = evt.loaded / evt.total;"
      "$('#prg').html('progress: ' + Math.round(per*100) + '%');"
      "}"
      "}, false);"
      "return xhr;"
      "},"
      "success:function(d, s) {"
      "console.log('success!')" 
     "},"
     "error: function (a, b, c) {"
     "}"
     "});"
     "});"
     "</script>";
    
    /*
     * setup function
     */
    void setup(void) {
      Serial.begin(115200);
    
      // Connect to WiFi network
      WiFi.begin(ssid, password);
      Serial.println("");
    
      // Wait for connection
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
      Serial.println("");
      Serial.print("Connected to ");
      Serial.println(ssid);
      Serial.print("IP address: ");
      Serial.println(WiFi.localIP());
    
      /*use mdns for host name resolution*/
      if (!MDNS.begin(host)) { //http://esp32.local
        Serial.println("Error setting up MDNS responder!");
        while (1) {
          delay(1000);
        }
      }
      Serial.println("mDNS responder started");
      /*return index page which is stored in serverIndex */
      server.on("/", HTTP_GET, []() {
        server.sendHeader("Connection", "close");
        server.send(200, "text/html", loginIndex);
      });
      server.on("/serverIndex", HTTP_GET, []() {
        server.sendHeader("Connection", "close");
        server.send(200, "text/html", serverIndex);
      });
      /*handling uploading firmware file */
      server.on("/update", HTTP_POST, []() {
        server.sendHeader("Connection", "close");
        server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
        ESP.restart();
      }, []() {
        HTTPUpload& upload = server.upload();
        if (upload.status == UPLOAD_FILE_START) {
          Serial.printf("Update: %s\n", upload.filename.c_str());
          if (!Update.begin(UPDATE_SIZE_UNKNOWN)) { //start with max available size
            Update.printError(Serial);
          }
        } else if (upload.status == UPLOAD_FILE_WRITE) {
          /* flashing firmware to ESP*/
          if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
            Update.printError(Serial);
          }
        } else if (upload.status == UPLOAD_FILE_END) {
          if (Update.end(true)) { //true to set the size to the current progress
            Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
          } else {
            Update.printError(Serial);
          }
        }
      });
      server.begin();
    }
    
    void loop(void) {
      server.handleClient();
      delay(1);
    }
    

    Debe cambiar las siguientes líneas en el código para incluir sus propias credenciales de red:

    const char* ssid = "";
    const char* contraseña = "";

    El ejemplo de OTAWebUpdater para ESP32 crea un servidor web asíncrono donde puede cargar código nuevo en su placa sin necesidad de una conexión en serie.Suba el código anterior a tu placa ESP32. No olvide ingresar sus credenciales de red y seleccionar la placa y el puerto serial correctos.

    Después de cargar el código, abra el monitor serie a una velocidad de transmisión de 115200, presione el botón de activación de ESP32 y obtendrá la dirección IP de ESP32:

    Ahora, puede cargar el código a su ESP32 por aire usando un navegador en su red local.

    Para probar el Actualizador web OTA, puede desconectar el ESP32 de su computadora y encenderlo con un banco de energía, por ejemplo (esto es opcional, lo sugerimos para imitar una situación en la que el ESP32 no está conectado a su computadora).

    2-Actualización del nuevo código usando el actualizador web OTA

    Abra un navegador en su red e ingrese la dirección IP ESP32. Deberías obtener lo siguiente:

    otawebupdater-usuario-contraseña

    Introduzca el nombre de usuario y la contraseña:

    • Nombre de usuario : admin
    • contraseña : admin

    Puede cambiar el nombre de usuario y la contraseña en el código.

    Nota:  Después de ingresar el nombre de usuario y la contraseña, será redirigido a la URL /serverIndex . No necesita ingresar el nombre de usuario y la contraseña para acceder a la URL /serverIndex . Por lo tanto, si alguien conoce la URL para cargar el nuevo código, el nombre de usuario y la contraseña no protegen la página web para que otros no puedan acceder a ella.

    Debería abrirse una nueva pestaña en la URL /serverIndex . Esta página le permite cargar un nuevo código a su ESP32. Debería cargar archivos .bin (veremos cómo hacerlo en un momento).

    ota-web-updater-esp32

    3-Preparación del nuevo sketch

    Al cargar un nuevo boceto por aire, debe tener en cuenta que debe agregar código para OTA en su nuevo boceto, de modo que siempre pueda sobrescribir cualquier boceto con uno nuevo en el futuro. Por lo tanto, le recomendamos que modifique el boceto de OTAWebUpdater para incluir su propio código.

    Con fines de aprendizaje, subamos un nuevo código que parpadee un LED (sin demora). Copie el siguiente código en su IDE de Arduino.

    /*
     * Rui Santos 
     * Complete Project Details https://randomnerdtutorials.com
     */
    
    #include <WiFi.h>
    #include <WiFiClient.h>
    #include <WebServer.h>
    #include <ESPmDNS.h>
    #include <Update.h>
    
    const char* host = "esp32";
    const char* ssid = "REPLACE_WITH_YOUR_SSID";
    const char* password = "REPLACE_WITH_YOUR_PASSWORD";
    
    //variabls to blink without delay:
    const int led = 2;
    unsigned long previousMillis = 0;        // will store last time LED was updated
    const long interval = 1000;           // interval at which to blink (milliseconds)
    int ledState = LOW;             // ledState used to set the LED
    
    WebServer server(80);
    
    /*
     * Login page
     */
    
    const char* loginIndex = 
     "<form name='loginForm'>"
        "<table width='20%' bgcolor='A09F9F' align='center'>"
            "<tr>"
                "<td colspan=2>"
                    "<center><font size=4><b>ESP32 Login Page</b></font></center>"
                    "<br>"
                "</td>"
                "<br>"
                "<br>"
            "</tr>"
            "<td>Username:</td>"
            "<td><input type='text' size=25 name='userid'><br></td>"
            "</tr>"
            "<br>"
            "<br>"
            "<tr>"
                "<td>Password:</td>"
                "<td><input type='Password' size=25 name='pwd'><br></td>"
                "<br>"
                "<br>"
            "</tr>"
            "<tr>"
                "<td><input type='submit' onclick='check(this.form)' value='Login'></td>"
            "</tr>"
        "</table>"
    "</form>"
    "<script>"
        "function check(form)"
        "{"
        "if(form.userid.value=='admin' && form.pwd.value=='admin')"
        "{"
        "window.open('/serverIndex')"
        "}"
        "else"
        "{"
        " alert('Error Password or Username')/*displays error message*/"
        "}"
        "}"
    "</script>";
     
    /*
     * Server Index Page
     */
     
    const char* serverIndex = 
    "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"
    "<form method='POST' action='#' enctype='multipart/form-data' id='upload_form'>"
       "<input type='file' name='update'>"
            "<input type='submit' value='Update'>"
        "</form>"
     "<div id='prg'>progress: 0%</div>"
     "<script>"
      "$('form').submit(function(e){"
      "e.preventDefault();"
      "var form = $('#upload_form')[0];"
      "var data = new FormData(form);"
      " $.ajax({"
      "url: '/update',"
      "type: 'POST',"
      "data: data,"
      "contentType: false,"
      "processData:false,"
      "xhr: function() {"
      "var xhr = new window.XMLHttpRequest();"
      "xhr.upload.addEventListener('progress', function(evt) {"
      "if (evt.lengthComputable) {"
      "var per = evt.loaded / evt.total;"
      "$('#prg').html('progress: ' + Math.round(per*100) + '%');"
      "}"
      "}, false);"
      "return xhr;"
      "},"
      "success:function(d, s) {"
      "console.log('success!')" 
     "},"
     "error: function (a, b, c) {"
     "}"
     "});"
     "});"
     "</script>";
    
    /*
     * setup function
     */
    void setup(void) {
      pinMode(led, OUTPUT);
      
      Serial.begin(115200);
    
      // Connect to WiFi network
      WiFi.begin(ssid, password);
      Serial.println("");
    
      // Wait for connection
      while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
      }
      Serial.println("");
      Serial.print("Connected to ");
      Serial.println(ssid);
      Serial.print("IP address: ");
      Serial.println(WiFi.localIP());
    
      /*use mdns for host name resolution*/
      if (!MDNS.begin(host)) { //http://esp32.local
        Serial.println("Error setting up MDNS responder!");
        while (1) {
          delay(1000);
        }
      }
      Serial.println("mDNS responder started");
      /*return index page which is stored in serverIndex */
      server.on("/", HTTP_GET, []() {
        server.sendHeader("Connection", "close");
        server.send(200, "text/html", loginIndex);
      });
      server.on("/serverIndex", HTTP_GET, []() {
        server.sendHeader("Connection", "close");
        server.send(200, "text/html", serverIndex);
      });
      /*handling uploading firmware file */
      server.on("/update", HTTP_POST, []() {
        server.sendHeader("Connection", "close");
        server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
        ESP.restart();
      }, []() {
        HTTPUpload& upload = server.upload();
        if (upload.status == UPLOAD_FILE_START) {
          Serial.printf("Update: %s\n", upload.filename.c_str());
          if (!Update.begin(UPDATE_SIZE_UNKNOWN)) { //start with max available size
            Update.printError(Serial);
          }
        } else if (upload.status == UPLOAD_FILE_WRITE) {
          /* flashing firmware to ESP*/
          if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
            Update.printError(Serial);
          }
        } else if (upload.status == UPLOAD_FILE_END) {
          if (Update.end(true)) { //true to set the size to the current progress
            Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
          } else {
            Update.printError(Serial);
          }
        }
      });
      server.begin();
    }
    
    void loop(void) {
      server.handleClient();
      delay(1);
    
      //loop to blink without delay
      unsigned long currentMillis = millis();
    
      if (currentMillis - previousMillis >= interval) {
        // save the last time you blinked the LED
        previousMillis = currentMillis;
    
        // if the LED is off turn it on and vice-versa:
        ledState = not(ledState);
    
        // set the LED with the ledState of the variable:
        digitalWrite(led, ledState);
      }
    }
    

    Como puede ver, hemos agregado el código «parpadeo sin demora» al código OTAWebUpdater, para que podamos realizar actualizaciones más adelante.

    Después de copiar el código en su IDE de Arduino, debe generar un archivo .bin .

    4-Generación del archivo .bin en Arduino IDE

    Guarde su boceto como LED_Web_Updater .

    Para generar un archivo .bin a partir de su boceto, vaya a Boceto > Exportar binario compilado

    exportar-archivo-bin-arduino-ide

    Se debe crear un nuevo archivo en el boceto de la carpeta. Vaya a Bosquejo > Mostrar carpeta de bosquejo . Debe tener dos archivos en su carpeta Sketch: el archivo .ino y el archivo .bin . Debe cargar el archivo .bin mediante el actualizador web de OTA.

    5-Carga del nuevo sketch por aire al ESP32

    En su navegador, en la página ESP32 OTA Web Updater, haga clic en el botón Elegir archivo . Seleccione el archivo .bin generado anteriormente y luego haga clic en Actualizar .

    Después de unos segundos, el código debería cargarse correctamente.

    El LED incorporado ESP32 debe estar parpadeando.¡Felicidades! Ha subido un nuevo código a tu ESP32 por aire.

    Las actualizaciones inalámbricas hemos visto que son útiles para cargar un nuevo código en su placa ESP32 cuando no es fácilmente accesible. En este segundo caso hemos visto el código OTA Web Updater como crea un servidor web al que puede acceder para cargar un nuevo código en su placa ESP32 utilizando un navegador web en su red local.

    Fuentes

    https://lastminuteengineers.com/esp32-ota-updates-arduino-ide/

    ESP32 Over-the-air (OTA) Programming – Web Updater Arduino IDE

    Ejecutando código en paralelo con el ESP32


    El objetivo de esta post es en primer lugar comprender como se puede ejecutar la multitarea en el ESP32 para después ver como se implementa un algoritmo de cálculo de potencia simple en el ESP32 y probar la aceleración ejecutándolo en los dos núcleos del microcontrolador.

    El ESP32 viene con 2 microprocesadores Xtensa LX6 de 32 bits: core 0 y core 1. Entonces, es dual core. Cuando ejecutamos código en Arduino IDE, de forma predeterminada, se ejecuta en el núcleo 1. En esta publicación, le mostraremos cómo ejecutar código en el segundo núcleo ESP32 mediante la creación de tareas. Puede ejecutar piezas de código simultáneamente en ambos núcleos y hacer que su ESP32 sea multitarea. Como nota imporante  no necesariamente necesita ejecutar doble núcleo para lograr la multitarea.

    El ESP32 por tanto tiene dos núcleos Tensilica LX6 [1] que podemos usar para ejecutar código. Al momento de escribir, la forma más fácil de controlar la ejecución de código en los diferentes núcleos del ESP32 es usando FreeRTOS y asignar una tarea a cada CPU

    Aunque de forma genérica son muchos los beneficios de tener más de un núcleo disponible para ejecutar código, uno de los más importantes es aumentar el rendimiento de nuestros programas. Entonces, aunque veremos en este post cómo ejecutar código en los dos núcleos del ESP32, también comprobaremos el aumento de rendimiento que podemos obtener de eso mediante una aplicación simple que sea capaz de calcular una potencia de los números de una matriz. Lo ejecutaremos en un solo núcleo y luego dividiremos el procesamiento por los dos núcleos y verificaremos si hay una ganancia en el tiempo de ejecución. Finalmente, solo para comparar, también dividiremos la ejecución entre cuatro tareas (dos asignadas a cada núcleo) solo para verificar si hay alguna aceleración para generar más tareas que núcleos.

    Introducción

    El ESP32 viene con 2 microprocesadores Xtensa LX6 de 32 bits, por lo que es de doble núcleo:

    • Núcleo 0
    • Núcleo 1

    Cuando subimos el código al ESP32 usando el IDE de Arduino, simplemente se ejecuta; no tenemos que preocuparnos de qué núcleo ejecuta el código.

    Hay una función que puede usar para identificar en qué núcleo se está ejecutando el código:

    xPortGetCoreID()

    Si usa esa función en un boceto de Arduino, verá que tanto setup() para la configuración() como el loopo()se ejecutan en el núcleo 1. Pruébelo usted mismo cargando el siguiente boceto en su ESP32.

    
    void setup() {
      Serial.begin(115200);
      Serial.print("setup() running on core ");
      Serial.println(xPortGetCoreID());
    }
    
    void loop() {
      Serial.print("loop() running on core ");
      Serial.println(xPortGetCoreID());
    }
    

    Abra el Serial Monitor a una velocidad de transmisión de 115200 y verifique el núcleo en el que se ejecuta el boceto de Arduino.

    Crear tareas

    Arduino IDE es compatible con FreeRTOS para ESP32, que es un sistema operativo en tiempo real. Esto nos permite manejar varias tareas en paralelo que se ejecutan de forma independiente. Las tareas son fragmentos de código que ejecutan algo. Por ejemplo, puede hacer parpadear un LED, realizar una solicitud de red, medir lecturas de sensores, publicar lecturas de sensores, etc.

    Para asignar partes específicas de código a un núcleo específico, debe crear tareas. Al crear una tarea, puede elegir en qué núcleo se ejecutará, así como su prioridad. Los valores de prioridad comienzan en 0, en el que 0 es la prioridad más baja. El procesador ejecutará primero las tareas con mayor prioridad.

    Para crear tareas necesita seguir los siguientes pasos:

    1. Crear un identificador de tarea. Un ejemplo para Task1:

    TaskHandle_t Task1;

    2. En la configuración()crear una tarea asignada a un núcleo específico usando elxTaskCreatePinnedToCorefunción. Esa función toma varios argumentos, incluida la prioridad y el núcleo donde se debe ejecutar la tarea (el último parámetro).

    xTaskCreatePinnedToCore(
          Task1code, /* Function to implement the task */
          "Task1", /* Name of the task */
          10000,  /* Stack size in words */
          NULL,  /* Task input parameter */
          0,  /* Priority of the task */
          &Task1,  /* Task handle. */
          0); /* Core where the task should run */

    3. Después de crear la tarea, debe crear una función que contenga el código para la tarea creada. En este ejemplo, debe crear la tarea e1código()función. Así es como se ve la función de tarea:

    Void Task1code( void * parameter) {
      for(;;) {
        Code for task 1 - infinite loop
        (...)
      }
    }

    los for(;;)crean un bucle infinito. Por lo tanto, esta función se ejecuta de manera similar a la función loop(). Puede usarlo como un segundo ciclo en su código, por ejemplo.

    Si durante la ejecución de su código desea eliminar la tarea creada, puede utilizar la función vTareaEliminar(), que acepta el identificador de tareas (Tarea 1) como argumento:

    vTaskDelete(Task1);

    Veamos cómo funcionan estos conceptos con un ejemplo sencillo.

    Crear tareas en diferentes núcleos: ejemplo

    Para seguir este ejemplo usaremos las siguientes partes:

    Para crear diferentes tareas que se ejecuten en diferentes núcleos, crearemos dos tareas que parpadeen los LED con diferentes tiempos de retraso . Conectaremos mediante dos resistencias en serie de 330 ohmios el cátodo de un led rojo al puerto 4 (GPIO4) y el otro cátodo del led verde al GPIO2 uniendo ambas masas y conectando estas al ping GND del ESP32 .

    El plano resultante seria similar al siguiente diagrama:

    Crearemos dos tareas ejecutándose en diferentes núcleos:

    • Task1 se ejecuta en el núcleo 0;
    • Task2 se ejecuta en el núcleo 1;

    Cargue el siguiente boceto en su ESP32 para hacer parpadear cada LED en un núcleo diferente:

    
    
    TaskHandle_t Task1;
    TaskHandle_t Task2;
    
    // LED pins
    const int led1 = 2;
    const int led2 = 4;
    
    void setup() {
      Serial.begin(115200); 
      pinMode(led1, OUTPUT);
      pinMode(led2, OUTPUT);
    
      //create a task that will be executed in the Task1code() function, with priority 1 and executed on core 0
      xTaskCreatePinnedToCore(
                        Task1code,   /* Task function. */
                        "Task1",     /* name of task. */
                        10000,       /* Stack size of task */
                        NULL,        /* parameter of the task */
                        1,           /* priority of the task */
                        &Task1,      /* Task handle to keep track of created task */
                        0);          /* pin task to core 0 */                  
      delay(500); 
    
      //create a task that will be executed in the Task2code() function, with priority 1 and executed on core 1
      xTaskCreatePinnedToCore(
                        Task2code,   /* Task function. */
                        "Task2",     /* name of task. */
                        10000,       /* Stack size of task */
                        NULL,        /* parameter of the task */
                        1,           /* priority of the task */
                        &Task2,      /* Task handle to keep track of created task */
                        1);          /* pin task to core 1 */
        delay(500); 
    }
    
    //Task1code: blinks an LED every 1000 ms
    void Task1code( void * pvParameters ){
      Serial.print("Task1 running on core ");
      Serial.println(xPortGetCoreID());
    
      for(;;){
        digitalWrite(led1, HIGH);
        delay(1000);
        digitalWrite(led1, LOW);
        delay(1000);
      } 
    }
    
    //Task2code: blinks an LED every 700 ms
    void Task2code( void * pvParameters ){
      Serial.print("Task2 running on core ");
      Serial.println(xPortGetCoreID());
    
      for(;;){
        digitalWrite(led2, HIGH);
        delay(700);
        digitalWrite(led2, LOW);
        delay(700);
      }
    }
    
    void loop() {
      
    }
    

    Cómo funciona el código

    Nota: en el código creamos dos tareas y asignamos una tarea al núcleo 0 y otra al núcleo 1. Los bocetos de Arduino se ejecutan en el núcleo 1 de forma predeterminada. Por lo tanto, podría escribir el código para Task2 en el loop()(no hubo necesidad de crear otra tarea). En este caso, creamos dos tareas diferentes con fines de aprendizaje.

    Sin embargo, según los requisitos de su proyecto, puede ser más práctico organizar su código en tareas como se muestra en este ejemplo.

    El código comienza creando un identificador de tarea para Task1 y Task2 llamadoTarea 1yTarea 2.

    TaskHandle_t Task1;
    TaskHandle_t Task2;

    Asigne GPIO 2 y GPIO 4 a los LED:

    const int led1 = 2; 
    const int led2 = 4;

    En la configuración(), inicialice el monitor serie a una velocidad en baudios de 115200:

    Serial.begin(115200);

    Declare los LED como salidas:

    pinMode(led1, OUTPUT); 
    pinMode(led2, OUTPUT);

    Luego, cree Task1 usando la función  xTaskCreatePinnedToCore() :

    xTaskCreatePinnedToCore(
                 Task1code, /* Task function. */
                 "Task1",   /* name of task. */
                 10000,     /* Stack size of task */
                 NULL,      /* parameter of the task */
                 1,         /* priority of the task */
                 &Task1,    /* Task handle to keep track of created task */
                 0);        /* pin task to core 0 */

    Task1 se implementará con eltarea1código()función. Entonces, necesitamos crear esa función más adelante en el código. Le damos a la tarea la prioridad 1 y la anclamos al núcleo 0.

    Creamos Task2 usando el mismo método:

    xTaskCreatePinnedToCore(
                 Task2code,  /* Task function. */
                 "Task2",    /* name of task. */
                 10000,      /* Stack size of task */
                 NULL,       /* parameter of the task */
                 1,          /* priority of the task */
                 &Task2,     /* Task handle to keep track of created task */
                 1);         /* pin task to core 0 */

    Después de crear las tareas, necesitamos crear las funciones que ejecutarán esas tareas.

    void Task1code( void * pvParameters ){
      Serial.print("Task1 running on core ");
      Serial.println(xPortGetCoreID());
    
      for(;;){
        digitalWrite(led1, HIGH);
        delay(1000);
        digitalWrite(led1, LOW);
        delay(1000);
      }
    }

    La función para Task1 se llamatarea1código()(Puedes llamarlo como quieras). Para fines de depuración, primero imprimimos el núcleo en el que se ejecuta la tarea:

    Serial.print("Task1 running on core ");
    Serial.println(xPortGetCoreID());

    Entonces, tenemos un ciclo infinito similar alcírculo()en el boceto de Arduino. En ese ciclo, parpadeamos el LED1 cada segundo.

    Lo mismo sucede con Task2, pero parpadeamos el LED con un tiempo de retraso diferente.

    void Task2code( void * pvParameters ){
      Serial.print("Task2 running on core ");
      Serial.println(xPortGetCoreID());
    
      for(;;){
        digitalWrite(led2, HIGH);
        delay(700);
        digitalWrite(led2, LOW);
        delay(700);
      }
    }

    Finalmente, el bucle loop tiene ()la función está vacía:

    void loop() { }

    Nota: como se mencionó anteriormente, el bucle loop ()se ejecuta en el núcleo 1. Entonces, en lugar de crear una tarea para ejecutar en el núcleo 1, simplemente puede escribir su código dentro del loop().

    Demostración

    Suba el código a su ESP32. Asegúrese de tener la placa y el puerto COM correctos seleccionados.

    Abra el monitor serie a una velocidad en baudios de 115200. Debería recibir los siguientes mensajes:

    Como era de esperar, Task1 se ejecuta en el núcleo 0, mientras que Task2 se ejecuta en el núcleo 1.

    En su circuito, un LED debe parpadear cada 1 segundo y el otro debe parpadear cada 700 milisegundos.

    En resumen:

    • El ESP32 es de doble núcleo;
    • Los bocetos de Arduino se ejecutan en el núcleo 1 de forma predeterminada;
    • Para usar core 0 necesitas crear tareas;
    • Puede usar la función TaskCreatePinnedToCore() para fijar una tarea específica a un núcleo específico;
    • Con este método, puede ejecutar dos tareas diferentes de forma independiente y simultánea utilizando los dos núcleos.

    Hemos visto un ejemplo simple con LED. La idea es utilizar este método con proyectos más avanzados con aplicaciones del mundo real. Por ejemplo, puede ser útil usar un núcleo para tomar lecturas de sensores y otro para publicar esas lecturas en un sistema de automatización del hogar. Ahora a continuación usando la multitarea vamos a calcular como aumenta la aceleración usando ambos núcleos


    Cálculo de aceleración

    Básicamente, lo que queremos comprobar es cuánto aumenta la velocidad de ejecución de nuestro programa cuando pasamos de una ejecución de un solo núcleo a una ejecución de doble núcleo. Entonces, una de las formas más fáciles de hacerlo es calcular la relación entre el tiempo de ejecución del programa que se ejecuta en un solo núcleo y el que se ejecuta en los dos núcleos del ESP32 [2].

    Mediremos el tiempo de ejecución para cada enfoque utilizando la función Arduino micros , que devuelve la cantidad de microsegundos desde que la placa comenzó a ejecutar el programa [3].

    Entonces, para medir un bloque de ejecución de código, haremos algo similar a lo que se indica a continuación.

    start = micros();
    //Run code
    end = micros();
    execTime = end - start;
    
    

    Podríamos haber usado la función FreeRTOS xTaskGetTickCount  para una mayor precisión, pero la función micros será suficiente para lo que queremos mostrar y es una función muy conocida de Arduino.

    Variables globales

    Comenzaremos nuestro código declarando algunas variables globales auxiliares. No vamos a necesitar ningún include.

    Como vamos a comparar aceleraciones en diferentes situaciones, vamos a especificar una matriz con múltiples exponentes para probar. Además, vamos a tener una variable con el tamaño de la matriz, para que podamos iterarla. Primero vamos a probar valores pequeños para el exponente y luego comenzaremos a aumentarlos mucho.

    int n[10] = {2, 3, 4, 5, 10, 50, 100, 1000, 2000, 10000 };
    int nArraySize = 10;
    

    También vamos a tener algunas variables para almacenar el tiempo de ejecución del código en los diferentes casos de uso. Reutilizaremos las  variables de inicio y finalización  de la ejecución , pero usaremos una variable diferente para cada caso de uso: ejecución de una tarea, ejecución de dos tareas y ejecución de cuatro tareas. De esta forma, almacenaremos los valores para una última comparación.

    unsigned long start;
    unsigned long end;
    unsigned long execTimeOneTask, execTimeTwoTask, execTimeFourTask ;

    Luego, declararemos un semáforo de conteo para poder sincronizar la función de configuración (que se ejecuta en una tarea de FreeRTOS) con las tareas que vamos a ejecutar. Consulte esta publicación para obtener una explicación detallada sobre cómo lograr este tipo de sincronización.

    Tenga en cuenta que la función xSemaphoreCreateCounting recibe como entrada el recuento máximo y el recuento inicial del semáforo. Como tendremos como máximo 4 tareas para sincronizar, su valor máximo será 4.

    SemaphoreHandle_t barrierSemaphore = xSemaphoreCreateCounting( 4, 0 );
    

    Finalmente, declararemos dos arreglos: uno con los valores iniciales (llamado bigArray ) y otro para almacenar los resultados (llamado resultArray ). Haremos sus tallas grandes.

    int bigArray[10000], resultArray[10000];


    La tarea de FreeRTOS

    Definiremos la función que implementará nuestro algoritmo de cálculo de potencia, para ser lanzada como tarea. Si necesita ayuda con los detalles sobre cómo definir una tarea de FreeRTOS, consulte este tutorial anterior.

    Lo primero que debemos tener en cuenta es que nuestra función recibirá algunos parámetros de configuración. Dado que en algunos de los casos de uso vamos a dividir la ejecución del algoritmo en varias tareas, necesitamos controlar la parte de la matriz que cubrirá cada tarea.

    Para crear solo una tarea genérica que pueda responder a todos nuestros casos de uso, pasaremos como parámetro los índices de la matriz de la que será responsable la tarea. Además, vamos a pasar el exponente, así que ahora sabemos cuántas multiplicaciones necesitamos realizar. Puede consultar con más detalle cómo pasar un argumento a una tarea de FreeRTOS en este tutorial anterior.

    Entonces, primero definiremos una estructura con estos 3 parámetros, para poder pasarla a nuestra función. Puedes leer más sobre estructuras aquí . Tenga en cuenta que esta estructura se declara fuera de cualquier función. Entonces, el código se puede colocar cerca de la declaración de variables globales.

    struct argsStruct {
      int arrayStart;
      int arrayEnd;
      int n;
    };

    Como ya tenemos declarada nuestra estructura, dentro de la función declararemos una variable del tipo de esta estructura. Luego, asignaremos el parámetro de entrada de la función a esta variable. Recuerde que los parámetros se pasan a las funciones de FreeRTOS como un puntero a nulo ( void * ) y es nuestra responsabilidad devolverlo al tipo original.

    Tenga en cuenta también que le pasamos a la función un puntero a la variable original y no a la variable real, por lo que necesitamos usar el puntero para acceder al valor. 

    	
    argsStruct myArgs = *((argsStruct*)parameters);

    Ahora, implementaremos la función de cálculo de potencia. Tenga en cuenta que podríamos haber usado la función Arduino pow , pero luego explicaré por qué no lo hicimos. Entonces, implementaremos la función con un ciclo donde multiplicaremos un valor por sí mismo n veces.

    Comenzamos declarando una variable para contener el producto parcial. Luego, haremos un ciclo for para iterar todos los elementos de la matriz asignada a la tarea. Recuerda que este era nuestro objetivo inicial. Luego, para cada elemento, calcularemos su potencia y al final le asignaremos el valor a la matriz de resultados. Esto asegura que usaremos los mismos datos en todas nuestras pruebas y no cambiaremos la matriz original.

    Para un código más limpio, podríamos haber implementado el algoritmo pow en una función dedicada, pero se intenta minimizar las llamadas a funciones auxiliares para un código más compacto.

    Verifique el código a continuación. Dejo ahí comentada una línea de código para calcular la potencia usando la función pow , así que puedes probarlo si quieres. Tenga en cuenta que los resultados de aceleración serán considerablemente diferentes. Además, para acceder a un elemento de una variable de estructura, usamos el nombre de la variable punto («.») el nombre del elemento.

    int product;
    for (int i = myArgs.arrayStart; i < myArgs.arrayEnd; i++) {
     
        product = 1;
        for (int j = 0; j < myArgs.n; j++) {
          product =  product * bigArray[i];
        }
        resultArray[i]=product;
        //resultArray [i] = pow(bigArray[i], myArgs.n);
    }

    Compruebe el código de función completo a continuación. Tenga en cuenta que al final del código estamos aumentando el semáforo de conteo global en una unidad. Esto se hace para asegurar la sincronización con la función de configuración, ya que contaremos el tiempo de ejecución a partir de ahí.  Además, al final, estamos eliminando la tarea.

    void powerTask( void * parameters ) {
     
      argsStruct  myArgs = *((argsStruct*)parameters);
     
      int product;
      for (int i = myArgs.arrayStart; i < myArgs.arrayEnd; i++) {
     
        product = 1;
        for (int j = 0; j < myArgs.n; j++) {
          product =  product * bigArray[i];
        }
        resultArray[i]=product;
        //resultArray [i] = pow(bigArray[i], myArgs.n);
      }
     
      xSemaphoreGive(barrierSemaphore);
     
      vTaskDelete(NULL);
     
    }
    


    La función de configuración

    Vamos a hacer todo el código restante en la función de configuración, por lo que nuestro ciclo principal estará vacío. Comenzaremos abriendo una conexión en serie para generar los resultados de nuestras pruebas.

    Serial.begin(115200);
    Serial.println();

    Ahora, inicializaremos nuestra matriz con algunos valores para aplicar el cálculo. Tenga en cuenta que no nos preocupa el contenido de la matriz ni el resultao real, sino los tiempos de ejecución. Entonces, vamos a inicializar la matriz con valores aleatorios solo para mostrar esas funciones, ya que no vamos a imprimir la matriz que contendrá los resultados.

    Primero vamos a llamar a la función randomSeed , por lo que los valores aleatorios generados diferirán en diferentes ejecuciones del programa [4]. Si el pin analógico está desconectado, devolverá un valor correspondiente a ruido aleatorio, lo cual es ideal para pasar como entrada de la función randomSeed .

    Después de eso, podemos simplemente llamar a la función aleatoria  , pasando como argumentos los valores mínimo y máximo que se pueden devolver [4]. Nuevamente, estamos haciendo esto solo con fines ilustrativos, ya que no vamos a imprimir el contenido de las matrices.

    randomSeed(analogRead(0));
    for (int i = 0; i < 10000; i++) {
      bigArray[i] = random(1, 10);
    }

    Ahora, vamos a definir las variables que se utilizarán como argumentos para nuestras tareas. Recuerda la estructura declarada anteriormente, que contendrá los índices del arreglo que procesará cada tarea y el exponente.

    Entonces, el primer elemento de la estructura es el índice inicial, el segundo es el índice final y el tercero es el exponente. Declararemos estructuras para cada caso de uso (una tarea, dos tareas y cuatro tareas) como se puede ver en el código a continuación. Tenga en cuenta que en el último elemento de la estructura estamos pasando un elemento de la matriz global que declaramos con los exponentes. Entonces, como veremos en el código final, iteraremos toda la matriz, pero por ahora mantengamos las cosas simples.

    argsStruct oneTask = { 0 , 1000 , n[i] };
     
    argsStruct twoTasks1 = { 0 , 1000 / 2 , n[i] };
    argsStruct twoTasks2 = { 1000 / 2 , 1000 , n[i] };
     
    argsStruct fourTasks1 = { 0 , 1000 / 4 , n[i] };
    argsStruct fourTasks2 = { 1000 / 4 , 1000 / 4 * 2, n[i]};
    argsStruct fourTasks3 = { 1000 / 4 * 2, 1000 / 4 * 3, n[i]};
    argsStruct fourTasks4 = { 1000 / 4 * 3 , 1000, n[i]};

    Ahora, vamos a hacer la prueba usando una sola tarea. Empezamos por obtener el tiempo de ejecución con la función micros. Luego, usaremos la función  xTaskCreatePinnedToCore para crear una tarea de FreeRTOS anclada a uno de los núcleos. Elegiremos el núcleo 1.

    Vamos a pasar como parámetro la dirección de la variable de estructura oneTask , que contiene los argumentos necesarios para que se ejecute la función. No olvides el yeso al vacío* .

    Una cosa muy importante a tener en cuenta es que aún no hemos analizado qué tareas pueden haber sido lanzadas por el núcleo de Arduino y que pueden influir en el tiempo de ejecución. Entonces, para garantizar que nuestra tarea se ejecutará con mayor prioridad, le asignaremos un valor de 20. Recuerde, los números más altos significan una mayor prioridad de ejecución para el programador de FreeRTOS.

    Después de iniciar la tarea, solicitaremos una unidad del semáforo, asegurándonos de que la función de configuración se mantendrá hasta que la nueva tarea termine de ejecutarse. Finalmente, imprimiremos el tiempo de ejecución.

    Serial.println("");
    Serial.println("------One task-------");
     
    start = micros();
     
    xTaskCreatePinnedToCore(
      powerTask,               /* Function to implement the task */
      "powerTask",              /* Name of the task */
      10000,                   /* Stack size in words */
      (void*)&oneTask,         /* Task input parameter */
      20,                      /* Priority of the task */
      NULL,                    /* Task handle. */
      1);                      /* Core where the task should run */
     
    xSemaphoreTake(barrierSemaphore, portMAX_DELAY);
     
    end = micros();
    execTimeOneTask = end - start;
    Serial.print("Exec time: ");
    Serial.println(execTimeOneTask);
    Serial.print("Start: ");
    Serial.println(start);
    Serial.print("end: ");
    Serial.println(end);

    Esto es más o menos lo que vamos a hacer para el resto de los casos de uso. La única diferencia es que vamos a lanzar más tareas y vamos a intentar sacar más unidades del semáforo (tantas como tareas lanzadas para ese caso de uso).

    Consulte el código fuente completo a continuación, que ya incluye los casos de uso para ejecutar el código con dos tareas (una por núcleo ESP32) y cuatro tareas (dos por núcleo ESP32). Además, al final de la función de configuración, incluye la impresión de los resultados de aceleración para cada iteración.

    Tenga en cuenta que el parámetro extra de la función Serial.println indica el número de lugares decimales para el número de punto flotante.

    int n[10] = {2, 3, 4, 5, 10, 50, 100, 1000, 2000, 10000  };
    int nArraySize = 10;
     
    struct argsStruct {
      int arrayStart;
      int arrayEnd;
      int n;
    };
     
    unsigned long start;
    unsigned long end;
    unsigned long execTimeOneTask, execTimeTwoTask, execTimeFourTask ;
     
    SemaphoreHandle_t barrierSemaphore = xSemaphoreCreateCounting( 4, 0 );
     
    int bigArray[10000], resultArray[10000];
     
    void setup() {
     
      Serial.begin(115200);
      Serial.println();
     
      randomSeed(analogRead(0));
     
      for (int i = 0; i < 10000; i++) {
        bigArray[i] = random(1, 10);
      }
     
      for (int i = 0; i < nArraySize; i++) {
     
        Serial.println("#############################");
        Serial.print("Starting test for n= ");
        Serial.println(n[i]);
     
        argsStruct oneTask = { 0 , 1000 , n[i] };
     
        argsStruct twoTasks1 = { 0 , 1000 / 2 , n[i] };
        argsStruct twoTasks2 = { 1000 / 2 , 1000 , n[i] };
     
        argsStruct fourTasks1 = { 0 , 1000 / 4 , n[i] };
        argsStruct fourTasks2 = { 1000 / 4 , 1000 / 4 * 2,   n[i]};
        argsStruct fourTasks3 = { 1000 / 4 * 2, 1000 / 4 * 3, n[i]};
        argsStruct fourTasks4 = { 1000 / 4 * 3 , 1000,     n[i]};
     
        Serial.println("");
        Serial.println("------One task-------");
     
        start = micros();
     
        xTaskCreatePinnedToCore(
          powerTask,               /* Function to implement the task */
          "powerTask",              /* Name of the task */
          10000,                   /* Stack size in words */
          (void*)&oneTask,         /* Task input parameter */
          20,                      /* Priority of the task */
          NULL,                    /* Task handle. */
          1);                      /* Core where the task should run */
     
        xSemaphoreTake(barrierSemaphore, portMAX_DELAY);
     
        end = micros();
        execTimeOneTask = end - start;
        Serial.print("Exec time: ");
        Serial.println(execTimeOneTask);
        Serial.print("Start: ");
        Serial.println(start);
        Serial.print("end: ");
        Serial.println(end);
     
        Serial.println("");
        Serial.println("------Two tasks-------");
     
        start = micros();
     
        xTaskCreatePinnedToCore(
          powerTask,                /* Function to implement the task */
          "powerTask",              /* Name of the task */
          10000,                    /* Stack size in words */
          (void*)&twoTasks1,        /* Task input parameter */
          20,                       /* Priority of the task */
          NULL,                     /* Task handle. */
          0);                       /* Core where the task should run */
     
        xTaskCreatePinnedToCore(
          powerTask,               /* Function to implement the task */
          "coreTask",              /* Name of the task */
          10000,                   /* Stack size in words */
          (void*)&twoTasks2,       /* Task input parameter */
          20,                      /* Priority of the task */
          NULL,                    /* Task handle. */
          1);                      /* Core where the task should run */
     
        for (int i = 0; i < 2; i++) {
          xSemaphoreTake(barrierSemaphore, portMAX_DELAY);
        }
     
        end = micros();
        execTimeTwoTask = end - start;
        Serial.print("Exec time: ");
        Serial.println(execTimeTwoTask);
        Serial.print("Start: ");
        Serial.println(start);
        Serial.print("end: ");
        Serial.println(end);
     
        Serial.println("");
        Serial.println("------Four tasks-------");
     
        start = micros();
     
        xTaskCreatePinnedToCore(
          powerTask,                /* Function to implement the task */
          "powerTask",              /* Name of the task */
          10000,                    /* Stack size in words */
          (void*)&fourTasks1,       /* Task input parameter */
          20,                       /* Priority of the task */
          NULL,                     /* Task handle. */
          0);                       /* Core where the task should run */
     
        xTaskCreatePinnedToCore(
          powerTask,                /* Function to implement the task */
          "powerTask",              /* Name of the task */
          10000,                    /* Stack size in words */
          (void*)&fourTasks2,       /* Task input parameter */
          20,                       /* Priority of the task */
          NULL,                     /* Task handle. */
          0);                       /* Core where the task should run */
     
        xTaskCreatePinnedToCore(
          powerTask,                /* Function to implement the task */
          "powerTask",              /* Name of the task */
          10000,                    /* Stack size in words */
          (void*)&fourTasks3,       /* Task input parameter */
          20,                       /* Priority of the task */
          NULL,                     /* Task handle. */
          1);                       /* Core where the task should run */
     
        xTaskCreatePinnedToCore(
          powerTask,                /* Function to implement the task */
          "powerTask",              /* Name of the task */
          10000,                    /* Stack size in words */
          (void*)&fourTasks4,       /* Task input parameter */
          20,                       /* Priority of the task */
          NULL,                     /* Task handle. */
          1);                       /* Core where the task should run */
     
        for (int i = 0; i < 4; i++) {
          xSemaphoreTake(barrierSemaphore, portMAX_DELAY);
        }
     
        end = micros();
        execTimeFourTask = end - start;
        Serial.print("Exec time: ");
        Serial.println(execTimeFourTask);
        Serial.print("Start: ");
        Serial.println(start);
        Serial.print("end: ");
        Serial.println(end);
     
        Serial.println();
        Serial.println("------Results-------");
     
        Serial.print("Speedup two tasks: ");
        Serial.println((float) execTimeOneTask / execTimeTwoTask, 4 );
     
        Serial.print("Speedup four tasks: ");
        Serial.println((float)execTimeOneTask / execTimeFourTask, 4 );
     
        Serial.print("Speedup four tasks vs two tasks: ");
        Serial.println((float)execTimeTwoTask / execTimeFourTask, 4 );
     
        Serial.println("#############################");
        Serial.println();
      }
     
    }
     
    void loop() {
     
    }
     
    void powerTask( void * parameters ) {
     
      argsStruct  myArgs = *((argsStruct*)parameters);
     
      int product;
      for (int i = myArgs.arrayStart; i < myArgs.arrayEnd; i++) {
     
        product = 1;
        for (int j = 0; j < myArgs.n; j++) {
          product =  product * bigArray[i];
        }
     
        resultArray[i]=product;
        //resultArray [i] = pow(bigArray[i], myArgs.n);
      }
     
      xSemaphoreGive(barrierSemaphore);
     
      vTaskDelete(NULL);
     
    }


    Probando el código

    Para probar el código, simplemente cárguelo con el IDE de Arduino y abra el monitor serie. Debería obtener un resultado similar a la figura 1. Naturalmente, los tiempos de ejecución pueden variar.

    Análisis de aceleración de doble núcleo ESP32

    Figura 1 : Salida del programa de prueba de aceleración.

    Los resultados para cada exponente se muestran en la siguiente tabla, en la tabla 1.

    Exponente1 tarea [µs]2 tareas [µs]4 tareas [µs]Acelerar 1 tarea frente a 2 tareasAcelerar 1 tarea frente a 4 tareasAcelerar 2 tareas vs 4 tareas
    22291832961.25140.77360.6182
    32712073251.30920.83380.6369
    43122243401.39290.91760.6588
    53542493671.42170.96460.6785
    105563474511.60231.23280.7694
    502235118813051.88131.71260.9103
    1004331223423431.93871.84850.9535
    10004207221108212121.99321.98340.9951
    20008399242138421901.99331.99080.9988
    100004194002102832103101.99451.99420.9999

    Tabla 1 – Resultados de aceleración para los exponentes definidos en el código.


    Analizando los resultados

    Para comprender los resultados, primero debemos tener en cuenta que no se puede paralelizar completamente todo el programa. Entonces, siempre habrá partes del código que se ejecuten en un solo núcleo, como el lanzamiento de las tareas o los mecanismos de sincronización.

    Aunque no teníamos este caso de uso, muchos algoritmos de paralelización también tienen una parte en la que cada resultado parcial se agrega secuencialmente (por ejemplo, si tenemos varias tareas calculando el valor máximo de su parte de la matriz y luego la tarea principal calcula el valor máximo entre todos los resultados parciales).

    Entonces, hagamos lo que hagamos, teóricamente no podemos lograr una aceleración igual a la cantidad de núcleos (hay algunas excepciones en, por ejemplo, algoritmos que buscan un valor específico y salen cuando lo encuentran, pero no nos compliquemos).

    Entonces, mientras más cómputos ejecutemos en paralelo versus la porción que ejecutamos en secuencia, más aceleración tendremos. Y eso es precisamente lo que vemos en nuestros resultados. Si comenzamos con un exponente de 2 , nuestra aceleración de la ejecución de una tarea a dos tareas es solo de  1.2514 .

    Pero a medida que aumentamos el valor del exponente, hacemos más iteraciones del ciclo más interno y, por lo tanto, más cálculos podemos realizar en paralelo. Así, a medida que aumentamos el exponente, vemos un aumento de la aceleración. Por ejemplo, con un exponente de 1000 , nuestra aceleración es  1.9933 . Lo cual es un valor muy alto en comparación con el anterior.

    Entonces, esto significa que la parte secuencial se diluye y para grandes exponentes la paralelización compensa. Tenga en cuenta que podemos lograr este tipo de valores altos porque el algoritmo es muy simple y fácil de paralelizar. Además, debido a la forma en que FreeRTOS maneja las prioridades y los cambios de contexto de ejecución de tareas, no hay mucha sobrecarga después de que se ejecutan las tareas. Una computadora normal tiende a tener más cambios de contexto entre subprocesos y, por lo tanto, la sobrecarga secuencial es mayor.

    Tenga en cuenta que no usamos la función pow para mostrar esta progresión en los valores de aceleración. La función pow usa flotantes, lo que significa que su implementación es más intensiva en computación. Entonces, obtendríamos aceleraciones mucho mejores en exponentes más bajos porque la parte paralela sería mucho más relevante que la secuencial. Puede comentar nuestro algoritmo implementado y usar la función pow  para comparar los resultados.

    Además, es importante tener en cuenta que lanzar más tareas que la cantidad de núcleos no aumenta la velocidad. De hecho, tiene el efecto contrario. Como podemos ver en los resultados, la aceleración de ejecutar con 4 tareas siempre es menor que la de ejecutar con 2 tareas. De hecho, para exponentes bajos, en realidad es más lento ejecutar el código con 4 tareas (aunque estén divididas entre los dos núcleos del ESP32) que ejecutar con una tarea en un solo núcleo.

    Esto es normal porque cada CPU solo puede ejecutar una tarea en un momento dado y, por lo tanto, lanzar más tareas que CPU significa más tiempo secuencial para manejarlas y más sobrecarga en los puntos de sincronización.

    Sin embargo, tenga en cuenta que esto no siempre es blanco y negro. Si las tareas tuvieran algún tipo de punto de rendimiento en el que dejarían de esperar algo, entonces tener más tareas que núcleos podría ser beneficioso para usar los ciclos de CPU libres. Sin embargo, en nuestro caso, las CPU nunca rinden y siempre se están ejecutando, por lo que no hay ningún beneficio en lanzar más de 2 tareas, en cuanto a la aceleración.


    La ley de Amdhal

    Para complementar los resultados, veremos la ley de Amdahl . Entonces, vamos a aplicar algunas transformaciones a la fórmula de aceleración que estábamos usando. La fórmula inicial era que la aceleración es igual al tiempo de ejecución secuencial (lo llamaremos T ) dividido por el tiempo de ejecución en paralelo (lo llamaremos T Paralelo ).

    fórmula de aceleración

    Pero, como vimos, hay una parte del tiempo de ejecución que siempre es secuencial y otra que puede ser paralelizada. Llamemos p a la fracción del programa que podemos ejecutar en paralelo. Como es una fracción, su valor estará entre 0 y 1.

    Entonces, podemos representar el tiempo de ejecución secuencial T como la porción que puede ejecutarse en paralelo ( p*T ) más la porción que no puede (1-p)*T .

    ejecución secuencial

    Como solo podemos dividir la parte paralela entre los núcleos de nuestra máquina, el tiempo T Parallel es similar a la fórmula anterior, excepto que la parte paralela aparece dividida por la cantidad de núcleos que tenemos disponibles.

    ejecución en paralelo

    Entonces, nuestra fórmula de aceleración se convierte en:

    Fórmula modificada de aceleración

    Ahora tenemos la aceleración escrita en función de T , el tiempo de ejecución original sin mejoras. Entonces, podemos dividir cada término por T :

    acelerar la ley de amdahl

    Entonces, ahora tenemos la aceleración escrita en función de la parte que puede ejecutarse en paralelo y la cantidad de núcleos. Para terminar, supongamos que tenemos una cantidad infinita de núcleos disponibles para ejecutar (el caso de uso real sería un número muy grande, pero analizaremos matemáticamente la fórmula).

    Acelera un número infinito de núcleos

    Como una constante dividida por infinito es igual a 0, terminamos con:

    Acelerar un número infinito de núcleos expresión final

    Así que, aunque la aceleración aumenta con la cantidad de recursos disponibles para la paralelización (la cantidad de núcleos, en nuestro caso), lo cierto es que la máxima aceleración teórica posible está limitada por la parte no paralela, que no podemos optimizar.

    Esta es una conclusión interesante para que decidamos si vamos o no a la paralelización. Algunas veces, los algoritmos pueden paralelizarse fácilmente y tenemos una tremenda aceleración, otras el esfuerzo necesario no justifica la ganancia.

    Además, otra cosa importante a tener en cuenta es que el mejor algoritmo secuencial no siempre es el mejor después de la paralelización. Entonces, a veces, es mejor usar un algoritmo que tiene menos rendimiento en la ejecución secuencial, pero termina siendo mucho mejor que el mejor secuencial en la paralelización.


    Resumen

    Con este post, confirmamos que las funciones disponibles para la ejecución multinúcleo funcionan bien y podemos aprovecharlas para obtener beneficios de rendimiento.

    La última parte más teórica tenía el objetivo de mostrar que la paralelización no es un tema trivial, y uno no puede saltar directamente a un enfoque paralelo sin un análisis previo y esperar una aceleración igual a la cantidad de núcleos disponibles. Este razonamiento se extiende más allá del alcance del ESP32 y se aplica a la computación paralela en general.

    Entonces, para aquellos que van a comenzar con la computación paralela utilizando el ESP32 para mejorar el rendimiento, es un buen comienzo para aprender primero algunos de los conceptos más teóricos.

    Finalmente, tenga en cuenta que el código está orientado a mostrar los resultados, por lo que se podrían haber hecho muchas optimizaciones, como lanzar las tareas en un ciclo en lugar de repetir el código o condensar el algoritmo en una función.

    Además, no buscábamos los resultados de la ejecución para confirmar que la matriz de salida era la misma porque ese no era nuestro enfoque principal. Naturalmente, pasar de secuencial a paralelo requiere una implementación cuidadosa del código y la ejecución de muchas pruebas para garantizar que el resultado sea el mismo.

    Mas información en

    [1] https://espressif.com/en/products/hardware/esp32/overview

    [2] http://www.dcc.fc.up.pt/~fds/aulas/PPD/1112/metrics_en.pdf

    [3] https://www.arduino.cc/en/reference/micros

    [4] https://www.arduino.cc/en/reference/random

    [5] https://techtutorialsx.com/2017/05/16/esp32-dual-core-execution-speedup/

    Primeros pasos con ESP32


    El famoso fabricante aleman AZDelivery en efecto nos pone disponible el ESP32 ESP-WROOM-32 NodeMCU Modulo WiFi + Bluetooth Dev Kit C Placa de Desarrollo 2.4 GHz Dual Core con Chip CP2102 , lo cual para muchos expertos es el sucesor del ESP8266 a un precio muy parecido ( unos 10€ en Amazon)

    Este módulo AZ-Delivery , desarrollado por la empresa Espressif tiene el potente Microcontrolador ESP32 instalado siendo por tanto ideal para prototipos rápidos ya que esta placa de desarrollo ESP32 permite la dinámica creación de prototipos con una sencilla programación a través de un script Lua o en la construcción compatible con Arduino-IDE y Breadboard. Integra funciones Wi-Fi y Bluetooth.

    Destaca además el consumo ultra bajo de energía ideal para poderlo alimentarlo con baterías. Asimismo cuenta con chips Bluetooth Wi-Fi de modo dual de 2,4 GHz y TSMC, así como tecnología de bajo consumo de 40 nm.

    Esta versión tiene 38 pines y ofrece más funciones que un módulo de 30 pines y es más pequeño y más conveniente de usar.

    De igual manera que en el modelo predecesor ESP8266, la funcionalidad WLAN está implementada directamente en el SoC, pero con funcionalidad Bluetooth adicional (incl. BLE).


    El procesador ESP32 es mucho más potente que el ESP8266 pues combina una CPU con 2 núcleos Tensilica LX6, con una frecuencia de hasta 240 MHz, y 512 Kilobytes de SRAM en un único chip microcontrolador. Además, integra una unidad de radio para WLAN (según 802.11bgn) y Bluetooth (Classic y LE) , esta conectividad que por cierto no posee el ESP8266.

    La función WLAN soporta todos los métodos de encriptación habituales, como WPA2. También puede actuar en la WLAN como punto de acceso o Sniffer en modo pasivo.

    A través de los 32 pines están disponibles, entre otros, UART, I2C, SPI, DAC, ADC (12 bits) y todos los pines GPIO pueden utilizarse como entrada o salida.

    Información Técnica

    Voltaje de alimentación5V
    Voltaje de entrada / salida3.3V
    Corriente de Funcionamientomin. 500mA
    SoCESP32-WROOM 32
    Frecuencia de Reloj80MHz / 240MHz
    RAM512kB
    Memoria Flash externa4MB
    Pines I / O34
    InterfacesSPI, I2C, I2S, CAN, UART
    Protocolos Wi-Fi802.11 b/g/n (802.11n hasta 150 Mbps)
    Frecuencia Wi-Fi2.4 GHz – 2.5 GHz
    BluetoothV4.2 – BLE y Bluetooth clásico
    Antena inalámbricaPCB
    Dimensiones56x28x13mm


    Hay un complemento para el IDE de Arduino que le permite programar el ESP32 utilizando el IDE de Arduino y su lenguaje de programación. En este post, le mostraremos cómo instalar la placa ESP32 en Arduino IDE, ya sea que esté usando Windows, Mac OS X o Linux..

    Antes de comenzar este procedimiento de instalación, asegúrese de tener instalada la última versión del IDE de Arduino en su computadora. Si no lo hace, desinstálelo e instálelo de nuevo. De lo contrario, es posible que no funcione.

    Con el último software Arduino IDE instalado desde arduino.cc/en/Main/Software , continúe con este post.

    Para instalar la placa ESP32 en su Arduino IDE, siga las siguientes instrucciones:

    1. En tu IDE de Arduino, ve a Archivo > Preferencias Instalación del complemento ESP32 en Arduino IDE Preferencias abiertas de Windows, Mac OS X y Linux
    2. Ingrese lo siguiente en el campo «URL adicionales del administrador de la junta»:https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json .
    3. Luego, haga clic en el botón «Aceptar»:Instalación del complemento ESP32 en Arduino IDE Windows, Mac OS X, Linux ingrese las URLNota: si ya tiene la URL de los tableros ESP8266, puede separar las URL con una coma de la siguiente manera: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json, http://arduino.esp8266.com/stable/package_esp8266com_index.json
    4. Abra el Administrador de tableros. Vaya a Herramientas > Tablero > Administrador de tableros…Instalación del complemento ESP32 en Arduino IDE Windows, Mac OS X, administrador de tableros abiertos de Linux
    5. Busque ESP32 y presione el botón de instalación para » ESP32 by Espressif Systems «:Complemento ESP32 en Arduino IDE Windows, Mac OS X, Linux instalado
    6. Eso es todo. Debe instalarse después de unos segundos.

    Prueba de la instalación

    Conecte la placa ESP32 a su ordenador mediante un cable USB. Lo más sencillo seria probar a hacer parpadear el led interno , pero realmente si queremos probar la conectividad wifi es mejor probar esto con un codigo mas elaborado. Afortunadamente no tenemos que buscar mucho porque el propio IDE de Arduino incluye los ejemplos .

    Con su Arduino IDE abierto, siga estos pasos:

    1. Seleccione su placa en el   menú  Herramientas  >  Placa (en el ejemplo es un  DOIT ESP32 DEVKIT V1 pero si compra el AZDelivery ESP32 ESP-WROOM-32 NodeMCU Modulo WiFi + Bluetooth Dev Kit C Placa de Desarrollo 2.4 GHz Dual Core con Chip CP2102 deberemos poner ESP32Dev Module )

    Arduino IDE seleccione la placa ESP32 en el menú Herramientas

    2. Seleccione el puerto (si no ve el puerto COM en su IDE de Arduino, debe instalar los  controladores CP210x USB to UART Bridge VCP ):

    Arduino IDE seleccione el puerto ESP32 en el menú Herramientas

    3. Abra el siguiente ejemplo en Archivo > Ejemplos > WiFi (ESP32) > WiFiScan

    Ejemplo de Arduino IDE open WiFiScan para ESP32

    4. Se abre un nuevo boceto en su IDE de Arduino:

    Arduino IDE cargando WiFiScan ejemplo a ESP32

    5. Presione el  botón Cargar  en el IDE de Arduino. Espere unos segundos mientras el código se compila y carga en su placa.

    6. Si todo salió como se esperaba, debería ver un mensaje » Terminó de cargar». » mensaje.

    Arduino IDE terminó de cargar ESP32 WiFiScan sketch

    7. Abra el monitor serie Arduino IDE a una velocidad de transmisión de 115200:

    8. Presione el botón Habilitar integrado de ESP32   y debería ver las redes disponibles cerca de su ESP32:

    Instalación del complemento de prueba ESP32 en PC con Windows, Max OS X y computadora con Linux

    Solución de problemas más comunes

    Si intenta cargar un nuevo boceto a su ESP32 y recibe este mensaje de error » Se produjo un error fatal: no se pudo conectar a ESP32: se agotó el tiempo de espera… Conectando… «. Significa que su ESP32 no está en modo de carga/parpadeo.

    Con el nombre de la placa y el puerto COM seleccionados, siga estos pasos:

    • Mantenga presionado el botón » BOOT » en su tablero ESP32
    Resuelto Ocurrió un error fatal: No se pudo conectar a ESP32: Se agotó el tiempo de espera... Conectando...
    • Presione el botón » Cargar » en el IDE de Arduino para cargar su boceto:
    • Después de ver el mensaje “ Conectando…. ” en su IDE de Arduino, suelte el dedo del botón “ BOOT ”:
    Arduino IDE terminó de cargar ESP32 WiFiScan sketch
    • Después de eso, debería ver el mensaje » Terminó de cargar «.

    Eso es todo. Su ESP32 debería tener el nuevo boceto ejecutándose. Presione el botón » HABILITAR » para reiniciar el ESP32 y ejecutar el nuevo boceto cargado.

    Solución de otros problemas

    Los problemas de parpadeo pueden ser complicados de solucionar. Pruebe las sugerencias aquí si tiene problemas:

    El gestor de arranque no responde

    Si ve errores como «Error al conectar», es probable que su chip no esté ingresando correctamente al gestor de arranque:

    • Compruebe que está pasando el puerto serie correcto en la línea de comandos.
    • Verifique que tenga permisos para acceder al puerto serie y que otro software (como el administrador de módem en Linux) no esté tratando de interactuar con él. Un error común es dejar un terminal serial accediendo a este puerto abierto en otra ventana y olvidarse de él.
    • Compruebe que el chip esté recibiendo 3,3 V de una fuente de alimentación estable (consulte Alimentación insuficiente para obtener más detalles).
    • Verifique que todos los pines estén conectados como se describe en Selección del modo de inicio . Verifique los voltajes en cada pin con un multímetro, los pines «altos» deben estar cerca de 3.3V y los pines «bajos» deben estar cerca de 0V.
    • Si ha conectado otros dispositivos a los pines GPIO, intente eliminarlos y vea si esptool comienza a funcionar.
    • Intente usar una tasa de baudios más lenta ( es un valor muy lento que puede usar para verificar que no es un problema de tasa de baudios).-b 9600

    Escribir en Flash falla a mitad de camino

    Si el parpadeo falla con errores aleatorios en la mitad, vuelva a intentarlo con una velocidad en baudios más baja.

    Los problemas de estabilidad de energía también pueden causar esto (consulte Energía insuficiente ).

    La escritura en Flash se realiza correctamente, pero el programa no se ejecuta

    Si esptool puede actualizar su módulo write_flashpero su programa no se ejecuta, verifique lo siguiente:

    Modo de flash incorrecto

    Algunos dispositivos solo admiten el diomodo flash. Escribir en flash con qioel modo tendrá éxito, pero el chip no puede volver a leer el flash para ejecutarlo, por lo que no sucede nada en el arranque. Prueba a pasar la opción a .-fm diowrite_flash

    Consulte la página Modos de flash SPI para obtener una descripción completa de los modos de flash y cómo determinar cuáles son compatibles con su dispositivo.

    Poder insuficiente

    La fuente de alimentación de 3,3 V para el chip ESP tiene que suministrar grandes cantidades de corriente (hasta 70 mA continuos, pico de 200-300 mA, puede ser un poco más alto). También necesita suficiente capacitancia en el circuito de alimentación para satisfacer grandes picos de demanda de energía.

    Capacitancia insuficiente

    Si está utilizando una placa o módulo de desarrollo prefabricado, el regulador de potencia y los condensadores incorporados suelen ser lo suficientemente buenos, siempre que la fuente de alimentación de entrada sea adecuada.

    Nota

    Esto no es cierto para algunos módulos de ruptura de pines muy simples, similar a este . Estos desgloses no integran suficiente capacitancia para funcionar de manera confiable sin componentes adicionales. Los módulos OEM de montaje en superficie como ESP-WROOM02 y ESP-WROOM32 requieren un condensador volumétrico externo en la PCB para ser confiables, consulte la hoja de datos del módulo.

    Clasificación de la fuente de alimentación

    Es posible tener una fuente de alimentación que suministre suficiente corriente para la etapa del cargador de arranque en serie con esptool, pero no lo suficiente para el funcionamiento normal del firmware. Es posible que vea que el voltaje VCC de 3,3 V cae si lo mide con un multímetro, pero puede tener problemas incluso si esto no sucede.

    Intente cambiar un suministro de 3,3 V con una clasificación de corriente más alta, agregue condensadores a la línea de alimentación y/o acorte los cables de alimentación de 3,3 V.

    La salida de 3,3 V de los chips/adaptadores FTDI FT232R o las placas Arduino no suministran suficiente corriente para alimentar un chip ESP (a veces puede parecer que funciona, pero no funcionará de manera confiable). Otros adaptadores USB TTL/serie también pueden ser marginales.

    Falta el cargador de arranque

    ESP-IDF y utiliza un pequeño programa cargador de arranque de firmware. El cargador de arranque de hardware en ROM carga este cargador de arranque de firmware desde flash y luego ejecuta el programa. En ESP32, la imagen del cargador de arranque debe ser flasheada por ESP-IDF en el desplazamiento 0x1000.

    Consulte la documentación de ESP-IDF para obtener detalles sobre qué binarios deben actualizarse en qué compensaciones.

    Pines SPI que deben desconectarse

    En comparación con el cargador de arranque ROM con el que habla esptool, un firmware en ejecución usa más pines del chip para acceder al flash SPI.

    Si configura el modo «Quad I/O» ( , el valor predeterminado de esptool), los GPIO 7, 8, 9 y 10 se utilizan para leer el flash SPI y, de lo contrario, deben desconectarse.-fm qio

    Si configura el modo «Dual I/O» ( ), los GPIO 7 y 8 se utilizan para leer el flash SPI y, de lo contrario, deben desconectarse.-fm dio

    Intente desconectar cualquier cosa de esos pines (y/o cambie al modo de E/S dual si anteriormente estaba usando el modo de E/S cuádruple pero desea conectar cosas a los GPIO 9 y 10). Tenga en cuenta que si los GPIO 9 y 10 también están conectados a los pines de entrada en el chip flash SPI, aún pueden no ser adecuados para su uso como E/S de propósito general.

    Además de estos pines, los GPIO 6 y 11 también se utilizan para acceder al flash SPI (en todos los modos). Sin embargo, el parpadeo generalmente fallará por completo si estos pines están conectados incorrectamente.

    Accidente de etapa temprana

    Utilice cualquiera de los programas de terminal serie para ver el registro de arranque. (La tasa de baudios ESP32 es 115200bps). Vea si el programa se bloquea durante el inicio temprano o si muestra un mensaje de error.

    Programas de terminal serie

    Hay muchos programas de terminal en serie adecuados para la depuración y la interacción en serie. El módulo pySerial (que se requiere para esptool) incluye uno de esos programas de terminal de línea de comandos: miniterm.py. Para obtener más detalles, consulte la documentación relacionada con pySerial o ejecute . Para conocer los valores exactos de configuración del puerto serie, consulte Configuración del puerto serie .miniterm -h

    Seguimiento de las interacciones de Esptool

    La ejecución volcará todas las interacciones en serie a la salida estándar (esto es una gran cantidad de salida). Esto puede ser útil al depurar problemas con la conexión en serie o al proporcionar información para informes de errores.esptool.py --trace

    Errores comunes

    Esta es una lista no exhaustiva de los errores de esptool más comunes junto con explicaciones de posibles causas y soluciones. Antes de leer cualquier consejo específico de error, se recomienda encarecidamente que revise primero toda la sección de Solución de problemas.

    No se recibieron datos seriales.

    Esptool no recibió ningún byte de datos o un paquete de deslizamiento exitoso . Este error generalmente implica algún tipo de problema de hardware. Esto puede deberse a que el hardware no funciona correctamente, las líneas seriales RX/TX no están conectadas o porque hay algún problema al restablecer el modo de descarga .

    ¡Modo de arranque incorrecto detectado (0xXX)! El chip debe estar en modo de descarga.

    La comunicación con el chip funciona (se detecta el registro de arranque de la ROM), pero no se restablece automáticamente al modo de descarga.

    Para resolver esto, verifique el circuito de restablecimiento automático (si su placa lo tiene), o intente restablecer el modo de descarga manualmente. Consulte Cargador de arranque manual para obtener instrucciones.

    El modo de descarga se detectó correctamente, pero no se obtuvo respuesta de sincronización: la ruta de transmisión en serie parece estar inactiva.

    El chip se restablece con éxito en el modo de descarga y envía datos a la computadora host, pero no recibe ninguna respuesta enviada por correo electrónico esptool. Esto implica un problema con la línea TX que se ejecuta desde el host hasta el dispositivo ESP. Verifique dos veces su placa o circuito de placa de prueba para ver si hay algún problema.

    Encabezado de paquete no válido (0xXX): posible corrupción o ruido en serie.

    Este error suele ser causado por una de las siguientes razones:

    • Usando un cable USB de mala calidad.
    • A veces, las placas de prueba pueden acortar los pines flash SPI en la placa y causar este tipo de problema. Intente quitar su placa de desarrollo de la placa de pruebas.
    • El chip podría estar oscureciéndose durante el flasheo. El regulador interno de 3,3 V de los chips FTDI no es suficiente para alimentar un ESP, consulte Alimentación insuficiente .

    Otras cosas para probar:

    • Intente sincronizar y comunicarse a una velocidad en baudios mucho más baja, p .esptool.py --baud 9600 ...
    • Intente rastrear las interacciones en curso y vea si se recibe algo.esptool.py --trace ...
    • Intente omitir la detección automática de chips especificando el tipo de chip, ejecute .esptool.py --chip ESP32 ...

    Si ninguna de las soluciones mencionadas anteriormente ayuda y su problema persiste, abra un nuevo problema .

    Se produjo un error de excepción en serie

    esptool.pyutiliza el módulo pySerial Python para acceder al puerto serie. Si pySerial no puede funcionar normalmente, genera un error y finaliza. Algunas de las causas de error de pySerial más comunes son:

    • No tienes permiso para acceder al puerto.
    • El puerto ya está siendo utilizado por otro software.
    • El puerto no existe.
    • El dispositivo se desconecta inesperadamente.
    • Los controladores de puerto serie necesarios no están instalados o están defectuosos.

    Un ejemplo de un error pySerial:

    A serial exception error occurred: read failed: [Errno 6] Device not configured
    

    Los errores que se originan en pySerial, por lo tanto, no son un problema con esptool.py, pero generalmente son causados ​​por un problema con el hardware o los controladores.

    Mas información en https://docs.espressif.com/projects/esptool/en/latest/esp32/troubleshooting.html

    Por cierto, una forma rapida de conseguir el ESP32 es Amazon porque por unos 10€ podemos tenerlo en casa y empezar a experimentar porque además regalan un ebook

    Cálculo resistencia de carga para sensores no invasivos de tensión


    A la hora de medir con un controlador la intensidad de un circuito de ca, existen shunts , modernamente sensores hall, pero ambos adolecen de ser intrusivos porque requieren interrumpir el circuito para conectar estos. Modernamente han aparecido sensores no intrusivos basados en un núcleo partido que se puede abrir para intercalar el fase del circuito a medir. En este ámbito destacan los sensores de corriente alterna SCT-013 , los cuales podríamos clasificarlos en dos grupos: los que proporcionan una corriente o los que proporcionan un voltaje siendo la gran diferencia entre ellos que en los primeros no viene incluida una resistencia de carga y en los segundos sí (el nombre resistencia de carga o resistencia «burden» se refiere a la función que hace, no a como están fabricadas siendo su función convertir la corriente en un voltaje limitado que podamos medir, por ejemplo, con un microcontrolador).

    El sensor SCT-013-000 es el único que nos proporciona una corriente y por tanto no tiene resistencia de carga. Puede medir una corriente de entre 50 mA y 100 A. El resto de la familia de sensores SCT-013 sí que tienen incluida la resistencia de carga. Podemos encontrar varios modelos pero todos tienen un voltaje de salida entre 0V y 1V.

    Esta tabla nos describe las principales características de la familia de sensores SCT disponible :

    Elegir uno u otro sensor SCT-013 dependerá de las necesidades reales. Como vemos en la tabla anterior, deberá elegir la intensidad de corriente que mejor se acople a sus necesidades o bien seleccionar el modelo «personalizado» SCT-013-000.

    En post por tanto vamos a trabajar con el SCT-013-000 debido a que no tiene resistencia de carga lo cual nos va a permitir seleccionar la resistencia de carga más adecuada para medir con masa precisión el consumo eléctrico de un electrodoméstico en concreto como por ejemplo podria ser un frigorífico.

    Para conectar un sensor CT a un Arduino, la señal de salida del sensor CT debe acondicionarse para que cumpla con los requisitos de entrada de las entradas analógicas Arduino, es decir, un  voltaje positivo entre 0 V y el voltaje de referencia ADC.

    Este ejemplo vemos una placa Arduino que funciona a 5 V y el EmonTx que funciona a 3,3 V. Asegúrese de utilizar el voltaje de suministro y el voltaje de polarización correctos en sus cálculos que correspondan a su configuración.

    Esto se puede lograr con el siguiente circuito que consta de dos partes principales: 

    1. El sensor CT y la resistencia de carga
    2. El divisor de voltaje de polarización ( R1 y R2 )

    Basta con sumar 2,5V y estaría resuelto. Esto lo haremos a través de un circuito conocido como circuito offset en DC,lo cual básicamente consiste en poner un divisor de tensión y un condensador (el condensador tiene que ser de 10μF y unos pocos cientos de voltios lo cual hace que la reactancia sea baja y la corriente alterna evite la resistencia).

    El valor de las resistencias del divisor de tensión puede ser 10kΩ siempre y cuando lo alimentemos a través de la red eléctrica, pero si su dispositivo va a funcionar con baterías utilice unas resistencias de 470kΩ para que el consumo sea mínimo.

    Cálculo de un tamaño de resistencia de carga adecuado

    Si el sensor CT es del tipo de «salida de corriente» como el YHDC SCT-013-000 , la señal de corriente debe convertirse en una señal de voltaje con una resistencia de carga. Si se trata de un CT de salida de voltaje, puede omitir este paso y omitir la resistencia de carga, ya que la resistencia de carga está integrada en el CT.

    Este es el cálculo de la citada resistencia:

    1) Elija el rango actual que desea medir

    El YHDC SCT-013-000 CT tiene un rango de corriente de 0 a 100 A. Para este ejemplo, elijamos 100 A como nuestra corriente máxima.

    2) Convierta la corriente RMS máxima en corriente pico multiplicando por √2.

    Corriente máxima primaria = corriente RMS × √2 = 100 A × 1,414 = 141,4 A
    
    Resultado =141,4 Amp

    3) Divida el pico de corriente por el número de vueltas en el TC para obtener el pico de corriente en la bobina secundaria.

    El TC YHDC SCT-013-000 tiene 2000 vueltas, por lo que la corriente pico del secundario será:

    Pico de corriente secundario = Pico de corriente primario / no. de vueltas = 141.4 A / 2000 = 0.0707A
    
    Resultado 2= 0.07Amp

    4) Para maximizar la resolución de la medición, el voltaje a través de la resistencia de carga en el pico de corriente debe ser igual a la mitad del voltaje de referencia analógico de Arduino. (AREF / 2)

    Si está utilizando un Arduino que funciona a 5V: AREF / 2 será de 2,5 voltios. 

    Entonces la resistencia de carga ideal será:

    Resistencia de carga ideal = (AREF/2) / Pico de corriente secundario = 2,5 V / 0,0707 A = 35,4 Ω
    
    Resultado 3= 35,4 ohmios
    
    Es fácil adivinar que 35 Ω no es un valor de resistencia común. Los valores más cercanos a ambos lados de 35 Ω son 39 y 33 Ω. Elija siempre el valor más pequeño, o la corriente de carga máxima creará un voltaje más alto que AREF. Recomendamos una carga de 33 Ω ±1%. En algunos casos, el uso de 2 resistencias en serie estará más cerca del valor de carga ideal. Cuanto más lejos del ideal esté el valor, menor será la precisión.

    Aquí están los mismos cálculos que arriba en una forma más compacta:

    Resistencia de carga (ohmios) = (AREF * CT TURNS) / (2√2 * corriente primaria máx.)

    emonTx V2

    Si está utilizando un emonTx V2 alimentado por batería, AREF comenzará a 3,3 V y disminuirá lentamente a medida que el voltaje de la batería caiga a 2,7 V. Por lo tanto, la resistencia de carga ideal para el voltaje mínimo sería:

    Resistencia de carga ideal = (AREF/2) / Pico de corriente secundario = 1,35 V / 0,0707 A = 19,1 Ω

    19 Ω no es un valor común. Tenemos una opción de 18 o 22 Ω. Recomendamos utilizar una carga de 18 Ω ±1%.

    emonTx V3

    El emonTx V3 usa un regulador de 3.3V, por lo que es V CC y por lo tanto AREF, siempre será de 3.3V independientemente del voltaje de la batería. El emonTx V3 estándar usa resistencias de carga de 22 Ω para CT 1, 2 y 3, y una resistencia de 120 Ω para CT4, el canal de alta sensibilidad. 

    2) Agregar un sesgo de CC

    Si tuviera que conectar uno de los cables del TC a tierra y medir el voltaje del segundo cable, con respecto a tierra, el voltaje variaría de positivo a negativo con respecto a tierra. Sin embargo, las entradas analógicas de Arduino requieren un voltaje positivo. Al conectar el cable de CT que conectamos a tierra, a una fuente a la mitad del voltaje de suministro, el voltaje de salida de CT ahora oscilará por encima y por debajo de 2,5 V, por lo que permanecerá positivo.

    Las resistencias R1 y R2 en el diagrama de circuito anterior son un divisor de voltaje que proporciona la fuente de 2,5 V (1,65 V para el emonTx). El condensador electrolítico C1 tiene una reactancia baja de unos pocos cientos de ohmios, y proporciona un camino para que la corriente alterna evite la resistencia. Un valor de 10 μF es adecuado por ejemplo de 100v.

    Elegir un valor adecuado para las resistencias R1 y R2:

    Una mayor resistencia reduce el consumo de energía en reposo por lo que podemos usar resistencias de 10 kΩ para monitores alimentados por la red. El emonTx utiliza resistencias de 470 kΩ para mantener el consumo de energía al mínimo, ya que está diseñado para funcionar con baterías durante varios meses.

    Boceto de Arduino

    Para usar el circuito descrito para medir la corriente RMS, con un voltaje RMS fijo asumido (por ejemplo, 240 V) para indicar la potencia aparente aproximada, podemos usar el siguiente código en Arduino:

    // Include Emon Library
    #include "EmonLib.h"
     
    // Crear una instancia EnergyMonitor
    EnergyMonitor energyMonitor;
     
    // Voltaje de nuestra red eléctrica
    float voltajeRed = 220.0;
     
    void setup()
    {
      Serial.begin(9600);
     
      // Iniciamos la clase indicando
      // Número de pin: donde tenemos conectado el SCT-013
      // Valor de calibración: valor obtenido de la calibración teórica
      energyMonitor.current(0, 2.6);
    }
     
    void loop()
    {
      // Obtenemos el valor de la corriente eficaz
      // Pasamos el número de muestras que queremos tomar
      double Irms = energyMonitor.calcIrms(1484);
     
      // Calculamos la potencia aparente
      double potencia =  Irms * voltajeRed;
     
      // Mostramos la información por el monitor serie
      Serial.print("Potencia = ");
      Serial.print(potencia);
      Serial.print("    Irms = ");
      Serial.println(Irms);
    }
    
    

    Mas info en https://openenergymonitor.github.io/forum-archive/node/156.html

    Fácil monitorización energética


    IotaWatt es un proyecto que surgió de un esfuerzo informal para producir un medidor de energía eléctrica versátil que fuera más fácil de configurar y usar. Al emplear el popular y potente chip nodeMCU ESP8266, tiene un entorno operativo con un enfoque modular para la recopilación, almacenamiento y la generación de informes de datos junto con un servidor web WiFi integrado. El firmware resultante, después de más de un año de desarrollo, es por tanto muy robusto. Los primeros esfuerzos se concentraron en el uso de placas y escudos en forma de kit con un mínimo de hardware personalizado. Eventualmente, se hizo evidente que se necesitaba una sola placa personalizada para proporcionar la plataforma necesaria para que el software fuera útil ( de hecho el diseño actual de hardware abierto se produce comercialmente).

    Aunque los esquemas y el diseño de PCB están abiertos y disponibles en el proyecto Git, hay mucho más para hacer un producto comercial viable. IoTaWatt, Inc. es una entidad legal que se estableció en respuesta a la demanda de hardware de producción. El dispositivo básico, así como el equipo relacionado, se pueden comprar utilizando en su sitio web https://stuff.iotawatt.com/ ( ellos afirman que los costos para desarrollar y certificar el hardware fueron sustanciales y, con suerte, se compensarán con las ventas). Para ellos, los objetivos a corto plazo del proyecto son desarrollar más aplicaciones analíticas locales y desarrollar la infraestructura de soporte de la comunidad.

    Veamos un poco más en detalle esta interesante solución abierta para monitorización del consumo energético.

    Photo by Constantine Kim on Pexels.com

    Sistema abierto IotaWatt

    No es que otros monitores de energía sean malos, pero sí son diferentes en que en su mayoría son sistemas cerrados que brindan datos limitados y requieren que use sus plataformas de aplicaciones de teléfono y nube. IoTaWatt recopila muchas más métricas y almacena ese historial de uso localmente. Con su servidor web integrado, puede administrar la configuración, ver el estado en tiempo real o crear gráficos detallados usando el navegador en su computadora, tableta o teléfono. Son sus datos, en su propio hogar, y sujetos únicamente a su propia política de privacidad y retención.  Sin embargo, IoTaWatt puede cargar fácilmente datos de uso en cualquiera de varias bases de datos de terceros con aplicaciones asociadas y herramientas analíticas. Por ejemplo, PVoutput es un servicio gratuito que se conecta fácilmente con IoTaWatt y proporciona análisis de energía solar de clase mundial. Hay soporte completo para cargar a influxDB. También hay una interfaz API para aquellos que desean consultar datos para sus propias aplicaciones o para usar en hojas de cálculo, y hay integraciones disponibles para software de automatización del hogar como Home Assistant.

    IotaWatt tm es por tanto un monitor de energía eléctrica conectado WiFi de 14 canales de hardware abierto. Se basa en la plataforma IoT ESP8266 que utiliza ADC de 12 bits MCP3208 para muestrear el voltaje y la corriente de CA. Ademas puede registrar datos localmente en la tarjeta SD integrada y publicarlos directamente en Emoncms.org a través de WiFi.

    No hay planes para descontinuar el emonTx. Tanto IoTaWatt como emonTx tienen ventajas en áreas clave que se complementan entre sí.

    IoTaWatt es completamente de código abierto y ha sido desarrollado por Bob Lemaire @overeasy en asociación con OpenEnergy

    IoTaWatt se puede usar para monitorear cualquier sistema de energía estando en uso en más de 60 países en todo el mundo. La fase dividida de EE. UU. 120V/240V es fácil, pero también la monofásica de 230V como en Europa, la trifásica de 230V como en los hogares de Australia, Alemania y Noruega, por nombrar algunos. A la mayoría de las personas solo les importa si funcionará en su situación. La respuesta es un sí rotundo.

    También hay muchos usuarios comerciales/industriales que monitorean sistemas trifásicos de alto voltaje, incluidos los industriales de 277 V/480 V con un servicio de 600 amperios que usan varios megavatios-hora por día, más de lo que la mayoría de los hogares usan en un año. Luego hay un sitio en Uganda que mide el voltaje y la potencia que se usa para cargar motocicletas eléctricas de alquiler usando energía solar.

    Todo esto es posible porque IoTaWatt utiliza sensores externos simples que están disponibles para cualquier combinación de voltaje/potencia. Simplemente instálelo, conéctelo a IoTaWatt y seleccione el tipo de sensor en un menú desplegable en la aplicación de configuración.

    Cómo funciona

    IoTaWatt mide cada circuito usando un sensor pasivo que se engancha alrededor de uno de los cables aislados. La salida de cada uno de estos transformadores de corriente es de muy bajo voltaje y se conecta a cualquiera de las 14 entradas de IoTaWatt. 

    Un transformador de pared insertado en un receptáculo ordinario convierte el voltaje local en un voltaje de referencia estándar y permite que IoTaWatt determine el voltaje y la frecuencia de la línea.

    Desde la aplicación de configuración basada en navegador, simplemente seleccione el modelo de sensor que está conectado. IoTaWatt sabe cómo interpretar las señales para producir una medida muy precisa de la energía que se utiliza en cualquier momento.

    Los conectores estéreo estándar facilitan la conexión de los sensores de corriente. Cada una de las 14 entradas es típicamente un transformador de corriente que mide un circuito, pero se puede usar una sola entrada para monitorear varios circuitos y/o se pueden combinar varios CT en una sola entrada.

    Todas las entradas se enumeran con nombre, tipo de sensor y varias opciones. Para editar, haga clic en el número de entrada.

    Cambie el nombre o especifique un modelo de sensor diferente de la lista desplegable. Guarde e IoTaWatt comenzará a usar la nueva configuración de inmediato.

    El IoTaWatt se configura a través de una interfaz web servida directamente desde el IoTaWatt ESP8266. Visite IoTaWatt.com para ver una demostración en vivo de la interfaz.

    IoTaWatt admite actualizaciones de firmware automáticas por aire (OTA).

    El estado de las entradas y salidas se actualiza continuamente. Las salidas se pueden definir para que los detalles adicionales estén disponibles. El estado de las cargas del servidor y el contexto de los registros de datos están disponibles en las pestañas desplegables.

    Herramientas analíticas integradas

    Las herramientas analíticas integradas permiten ver el uso gráficamente. Muestre el uso de energía total junto con los circuitos individuales seleccionando de un menú.


    La aplicación Graph+ se ejecuta directamente desde el servidor web de IoTaWatt. Se puede usar desde una PC, teléfono o tableta.

    Cargas a influxDB y Emoncms

    Los usuarios más sofisticados pueden configurar la carga de datos en influxDB y usar Grafana o una de varias otras herramientas de visualización para crear impresionantes tableros.

    También hay una opción para cargar al sistema Emoncms con sus propias herramientas gráficas integradas.

    Panel de control de Emoncms

    Tablero de grafana con fuente de datos influxDB

    Ambas bases de datos externas son de software abierto y están disponibles como servicios comerciales o alojadas en varias plataformas personales, incluidas Windows y RaspberryPi.

    Pantalla de estado en vivo de salida PV

    Cargas a PVoutput

    PVOutput es un servicio en línea gratuito para compartir y comparar datos de salida de paneles solares fotovoltaicos. 
    Los datos de salida se pueden graficar, analizar y comparar con otros contribuyentes de pvoutput durante varios períodos de tiempo.

    Si bien pvoutput se enfoca principalmente en monitorear la generación de energía, también proporciona instalaciones igualmente capaces para cargar y monitorear datos de consumo de energía. Tanto la generación solar como los datos de consumo de energía se pueden combinar para proporcionar una vista ‘Neta’ de la energía que se genera o se consume en vivo.


    La «calculadora» es la interfaz simple de IoTaWatt para crear scripts para combinar y exportar datos. Especifique las unidades para calcular (amperios, vatios, voltios, etc.) y luego ingrese la función para calcular el valor. Es tan fácil como usar una calculadora básica de cuatro funciones.

    Capacidad trifásica

    IoTaWatt puede manejar energía trifásica de varias maneras. La forma fácil utiliza solo un transformador de referencia de tensión/fase enchufado en cualquiera de las tres fases. Las mediciones de potencia en las otras dos fases se realizan utilizando una señal de referencia trifásica «derivada».

    Para obtener la máxima precisión, se pueden conectar dos transformadores adicionales a las entradas para el voltaje «directo» y la referencia de fase de todas las fases.

    IoTaWatt ha sido probado para cumplir con los estándares regulatorios y de seguridad de América del Norte y Europa, que incluyen:

    • Cumplimiento con FCC parte B
    • Conformidad con CE, incluida la Directiva de emisiones de radio (RED) y la Directiva de bajo voltaje
    • Estándares de seguridad de bajo voltaje para EE. UU. (UL) y Canadá (CSA). Prueba y certificación por Intertek y lleva la marca de certificación ETL.
    • Los accesorios vendidos por IoTaWatt, Inc están listados por UL o reconocidos por UL y listados para su uso con IoTaWatt.

    Seguridad

    IoTaWatt admite la conexión cifrada de extremo a extremo a Emoncms mediante el nuevo cifrado de capa de transporte API de Emoncms . Debido a los recursos limitados del microcontrolador ESP8266, la conexión HTTPS no es posible. Sin embargo, Emoncms ofrece una solución de cifrado de capa de transporte integrada en la que la clave de acceso de emoncms se utiliza como clave precompartida para cifrar los datos con AES-128-CBC.

    Las actualizaciones automáticas de firmware OTA garantizan que IoTaWatt siempre esté ejecutando la última versión más segura, por ejemplo, se lanzó una actualización de firmware y se implementó automáticamente para corregir la vulnerabilidad KRACK WPA . Las actualizaciones de firmware están firmadas digitalmente.

    Comparación de emonTx vs. IoTaWattio

    No hay planes para descontinuar emonTx. El IoTaWatt no está diseñado para reemplazar el emonTx, sino para complementarlo. Cada unidad tiene ventajas en áreas clave:

    Ventajas de emonTx

    • Bajo consumo: energía de la batería/adaptador AC-AC único
    • No se requiere configuración
    • Admite múltiples sensores de temperatura DS18B20
    • Admite sensor de pulso óptico (entrada de interrupción) para interactuar directamente con medidores de servicios públicos
    • Trifásico aproximado con actualización de firmware
    • Múltiples emonTx pueden comunicarse con un solo emonPi / emonBase
    • No se requiere conexión WiFi

    Ventajas de IoTaWatt

    • Gran número de entradas de sensores CT
    • Configuración flexible (se admiten muchos tipos diferentes de CT)
    • Registro de tarjeta SD integrado
    • Actualizaciones de firmware OTA
    • Publicación directa a través de WiFi en Emoncms.org

    La ventaja obvia del IoTaWatt sobre el emonTx es la cantidad de entradas del sensor CT. Otra ventaja clave es la flexibilidad de IoTaWatt, cada canal de entrada (voltaje y corriente de CA) se puede configurar y calibrar individualmente. IoTaWatt es compatible con varios tamaños diferentes de sensores CT con preajustes de calibración para sensores CT, por ejemplo , 20A , 100A (estándar) y 200A .

    Es posible usar un IoTaWatt junto con un emonPi / emonBase, el IoTaWAtt puede publicar en cualquier servidor de Emoncms, incluido emonPi, a través de una red local.

    RESUMEN

    Es de destacar que en esencia este sistema de iotaWatt usa amplificadores operaciones de instrumentación para la medida de la corriente por medio de sensores magnéticos enviando las medidas por medio de un convertidor analógico digital con salida SPI, lo cual es muy similar a la propuesta que nos da lechacal.com ( en UK) pero en vez de usar un NodeMCU usa una Raspberry Pi ( aunque tienen una versión para una Orange Pi).

    Como detalle interesante sin duda es que tanto el hw como como el sw son abiertos lo cual lo hace muy atractivo para mejorar o incluso replicar esta solución, pero sin duda se echa de menos más rigor en la precisión de las medidas

    Más información en https://iotawatt.com/index.html

    Analizador de espectro con ESP32


    El analizador de espectro basado en IoT / web de Mark utiliza un único microcontrolador ESP32 para crear hasta 64 canales para visualizar diferentes bandas de audio. Sólo utiliza 6 componentes externos para funcionar, y no tiene Leds o pantallas LCD o TFT. En su lugar, utiliza una página web HTML para mostrar todas las barras de frecuencia. Otros aspecto interesante es dado que el ESP32 cuenta con dos cores, en esta implementación funcionan ambos núcleos del procesador; el núcleo 1 se utiliza para ejecutar el bucle principal del programa, mientras que el núcleo 0 se utiliza para actualizar constantemente los datos de la web. Aunque el programa en sí mismo hace posible que se ejecute en un solo núcleo, el uso de ambos núcleos dará lugar a un mejor rendimiento.

    ¡Esto es tan fácil de construir y programar, que tienes que probarlo! Ni siquiera necesitará instalar el software de Arduino; sólo tiene que usar el programador web para cargar el archivo binario precompilado.

    En efecto Mark nos presenta este gran proyecto que quiere compartir: un analizador de espectro de audio que no es complejo con un Hardware complicado, porque en la implementación solo vamos a usar un controlador esp32 con un puñado de componentes !y el resultado será absolutamente increíble!
    Así que si tiene curiosidad por saber cómo puede construir su propio analizador de espectro sin gastar más de unos pocos dólares, entonces este proyecto merece la pena sobre todo cuando comprueba en el esquema de más abajo como no ha usado más sólo 10 componentes o menos.


    Sobre el esquema veremos cómo programarlo y en cuanto a la programación veremos un truco especial bajo la manga, porque ni siquiera tendremos que instalar el entorno Arduino (a menos que quiera hacerlo
    primero).

    Antes de continuar veamos un poco sobre el audio y la transformación rápida de Fourier

    EXPLICACION DEL FUNCIONAMIENTO


    Para entender la forma en que escuchamos el audio simplificaremos las cosas mirando a un solo
    sonido, por ejemplo, una onda sinusoidal pura de 440Hz que la oiríamos como un tono simple aunque la mayoría de los sonidos se componen de una mezcla de frecuencias.
    SI agreguemos otra de 523 Hz usted puede escuchar claramente dos diferentes. Sin embargo, lo que realmente no son dos sonidos individuales, sino con dos sonidos procedentes del altavoz oirá la suma de ambos sonidos . Esto significa que a veces ambos sonidos se suman dando como resultado una mayor amplitud, mientras que otras veces los sonidos tienden a que el resultado sea una señal de aspecto casi aleatorio, aleatoria que no tiene ningún sentido y que incluso empeora en cuanto añadimos más frecuencias.

    Por ejemplo, agreguemos 587 Hertz, ahora puede escuchar tres sonidos individuales. Estos sonidos individuales de nuevo los está escuchando en una señal lejos de la onda sinusoidal pura. Si tomamos un vistazo recuerde que la música o la voz o la mayoría de los sonidos son en realidad una combinación de frecuencias que interactúan resultando el sonido que escucha.

    Ahora probablemente se esté preguntando cómo va a ayudarnos eso a construir un analizador de espectro. Pues bien, a la señal de audio, estamos viendo una mezcla de varias frecuencias individuales, estas frecuencias precisamente nos van a servir para construir un analizador de espectro ,pues no estamos interesados en esta mezcla, sino que queremos conocer todas las frecuencias que componen la señal, es decir queremos hacer ingeniería inversa de la mezcla para encontrar nuestras señales originales.

    Esto se puede hacer utilizando un complicado algoritmo llamado Transformación rápida de Fourier. La
    explicación de este algoritmo es compleja , así que para simplificar las cosas, una vez más sólo recuerde
    la transformación rápida de Fourier hace todos los cálculos.
    Para averiguar exactamente qué frecuencias están ocultas en su señal, ahora digamos digamos que el ancho de banda de nuestra señal de audio es de 20 Hz a 20 khz. Vamos a dividir el ancho de banda total en varias bandas individuales digamos siete y las llamaremos contenedores. Cada contenedor tiene un ancho de banda limitado y una diferente frecuencia central. Recordemos que nuestra señal de audio se compone de varios frecuencias individuales por lo que ahora el mencionado algoritmo clasificará qué frecuencia va donde y la pone en el contenedor correcto. Todo lo que queda por hacer es ver cuán lleno está cada contenedor y traducirlo a una lectura, que en nuestro caso es un gráfico de barras.

    El Hardware

    Para el hardware vamos a utilizar una placa de desarrollo esp32, cuatro resistencias un condensador y un interruptor y tal vez un conector de audio y eso es todo, así que con tan pocos componentes es muy fácil construir este proyecto usando una protoboard o un PCB estándar.

    El esquema es sencillo, , en el centro vemos la placa de placa de desarrollo ESP32 versión 1.0 .En el lado izquierdo tenemos nuestra entrada de audio el canal izquierdo y derecho y por supuesto la tierra. Ambos canales están unidos usando resistencias La señal de audio conjunta está conectada a un lado de un condensador mientras que el otro lado del condensador está conectado a nuestra entrada ADC y también a resistencias R3 y R4.

    Si echa un vistazo a la hoja de datos del esp32 verá que que la entrada del ADC sólo puede manejar un
    positivo mientras que nuestra señal de audio puede ser negativa y positiva: por eso estamos creando un offset de aproximadamente 1.6 voltios usando R3 y R4.

    Finalmente tenemos un botón S1 que podemos pulsar para cambiar el número de bandas o contenedores durante el tiempo de ejecución. Se puede cambiar a 8 16 24 32 o incluso 64 canales

    Para facilitar las cosas, vemos dos ejemplos de cómo podemos reconstruir este dispositivo. En el lado izquierdo puede ver una placa de pruebas con todos los componentes , simplemente siga el ejemplo y debería funcionar.
    También vemos el prototipo de placa de circuito impreso superior (el ejemplo está en el lado derecho)
    Mire bien el ejemplo y tome nota de los lugares donde se interrumpen los carriles de cobre o donde estan unidos
    Ahora que el hardware está hecho ¿está de acuerdo con lo que he dicho antes?..es realmente fácil de construir, ¿no?


    El software

    Ahora que el hardware está hecho vamos a pasar a la programación, para lo cual es necesario descargar el boceto de la comunidad de element 14. Puede descargar todos los archivos en la Comunidad element14! https://bit.ly/3fv0oqy

    Antes de que pueda usar un esp32 con el entorno Arduino, necesita instalar las bibliotecas adecuadas
    y para ello vamos al archivo hacemos clic en preferencias y luego buscamos la línea que dice
    administradores adicionales de la placa . Haga clic en el icono y asegúrese de añadir esta línea . Pulse OK y de nuevo pulse OK (esto significa que la librería el enlace a la librería está instalada)

    Ahora vamos a instalar la biblioteca, para ello vamos a herramientas, y hacemos clic en el gestor de placas y el gestor de placas manager. Primero tenemos que esperar hasta que se cargue y una vez cargado, (esto puede tomar algún tiempo dependiendo de la cantidad de biblioteca que tenga instalada), en la barra de búsqueda hacemos clic en esp32 y esp32 by expressive systems aparecerá). Asegúrese de instalarlo correctamente.

    Bien si ya lo he hecho, el botón se pondrá en gris. Una vez que se instala asegúrese de seleccionar la placa apropiada, (una conocida es la esp32 dev kit que se encuentra en esp32 Arduino boards, pero encontrará más abajo do it esp32 def kit version , que es una de las más usadas por su bajo precio,y es la que se usa en este analizador)

    El sketch se compone de dos archivos : uno de dos archivos es nuestro elemento de especificación web
    que es el archivo principal y nuestra configuración , y el otro es la gestión de la entrada de audio y su correspondiente gestión con la transformada rapida de Fourier

    Echemos un vistazo al elemento web primero básicamente porque no hay nada en este archivo que necesite ser cambiado a menos que quiera añadir funcionalidad o quiera hacer algunos cambios que tengan bastante impacto, pero básicamente no necesita cambiarlo. Por supuesto puede si quiere en la configuración, hay algunos parámetros que puede cambiar, puede cambiar el número de bandas, que ahora está fijado en 64 y básicamente este es el número de bandas en el arranque se puede cambiar a 8 16 24 32 o 64. Podemos definir el modo si tiene un hardware diferente o si usa un pin diferente puede cambiarlo. Asimismo hay amortiguación de ganancia y umbral de ruido, y esos dos parámetros que puede tener en cuenta, si usted ve una gran cantidad de estática, lo que significa que los gráficos de barras ya te están dando una lectura tremendamente cuando no hay señal que puede cambiar aquí, entonces tenemos la velocidad del filtro mientras que básicamente es un retraso tiempo para que las barras caigan y lo hace más suave si el número es demasiado alto entonces se convertirá en bastante
    nervioso, tenemos la frecuencia de muestreo y un bloque de muestreo que ( se recomienda que se deje igual, no los cambie). Asimismo tenemos por supuesto nuestras tablas de corte de banda para cada número de canales de modo que para cada grupo hay un parámetro diferente. Tomemos el de
    para ocho canales, primero se ve el en el color de la tabla y ahora es 100 Hertz, 250, 500, Etc .Usted
    puede cambiarlo, pero asegúrese de que el secuencial debe ser siempre más alto que el anterior y
    esta regal se mantiene sucesivamente. Asimismo tenemos las etiquetas, que por supuesto básicamente eso es lo que se mostrará en la pantalla, y lo mismo ocurre con la banda de 16, la de 24, la de 32 y 64.

    Básicamente eso es todo lo que hay, si quiere profundizar en el código, Mark ha puesto
    comentarios allí que nos pueden ayudar a entender un poco más los entresijos y puede leerlo.



    Bueno, puede ser un poco de molestia compilar : tenemos que instalar el Arduino IIDE, las librerías, tenemos que instalar el gestor de placas adecuado, abrir el boceto compilarlo y subirlo, así que muchas cosas pueden salir mal, ¿y si hubiese otra manera más fácil? Pues la hay, con una versión de Mark que ya lo he compilado para nosotros de modo que podemos usar nuestro navegador de internet para simplemente subirlo directamente a la esp32 ( sin embargo esto solo funciona si va usando el sketch sin modificar de modo que si piensa hacer modificaciones esto no funcionara) .

    En efecto para hacer modificaciones en el sketch tal vez quiera añadir una funcionalidad extra o
    cambiar el ruido o los parámetros de retardo… entonces, por supuesto, usted tendra que
    recompilarlo y subirlo usando el Arduino IDE pero para todos los demás, veamos la programación en el navegador web

    La forma más manera más fácil de programar esp32 que jamás hayas visto, es sencilla : sólo tiene que ir a la siguiente sitio web , pulse instalar, seleccione el puerto com apropiado y asegúrese de que su
    esp32 está conectado con el conector USB y presiona connect para que comience a programar.
    Programar es tan fácil como eso.. !sólo esperar hasta que llegue a 100% y ya está!, eso es todo lo que hay que hacer si utilizas el navegador web para programar su esp32 es seguro decir que la
    la programación fue incluso más fácil que el hardware y el hardware en sí no era difícil fue así es el momento para una demostración


    ¿No crees que vamos a ver lo que hemos construido ? tomemos nuestro esp32 que hemos programado y pongámoslo en la placa que acabamos de crear. Ahora todo lo que necesita hacer es encenderlo de modo que cuando lo arranque por primera vez el dispositivo, como no tiene memoria de sus redes, lo que se iniciará como un punto de acceso y tiene que conectarse al punto de acceso utilizando su teléfono móvil o cualquier otro dispositivo.En el momento en que se conecte se iniciará el gestor de Wi-Fi. Es justo ahi donde puede introducir sus credenciales como su red o contraseña y pulsar guardar. Después de un reinicio, ahora será parte de su red y podrá acceder a ella yendo a la dirección IP correspondiente

    Para terminar veamos el video que ha hecho Mark donde explica en ingles todo lo que hemos visto anteriormente:

    Sin duda es un proyecto muy interesante que además nos puede ayudar a comprender mucho mejor la programación con el ESP32 y por supuesto entender un poco mejor la ciencia que hay detrás del mundo del sonido.

    Fuente aqui

    Medidas eléctricas de +6canales ( software)


    Ya se trató en este blog el hardware de EmonESP/EmonCMS ,una placa medidora de energía que usa tambien un ESP32 proporcionado 6 canales expandibles pudiendo leer 6 canales de corriente y 2 canales de voltaje a la vez. Para ello utiliza transformadores de corriente y un transformador de CA para medir el voltaje y alimentar la(s) placa(s)/ESP32. 

    Estas son algunas de sus carastericticas

    • Muestras de 6 canales de corriente y 1 canal de voltaje (ampliable a 2 voltajes)
    • Las placas complementarias (hasta 6) pueden expandir el medidor hasta 42 canales de corriente y 8 canales de voltaje
    • Utiliza 2  Microchip ATM90E32AS – 3 canales de corriente y 1 voltaje por IC
    • Para cada canal, el medidor también puede calcular lo siguiente:
      • Poder activo
      • Poder reactivo
      • Poder aparente
      • Factor de potencia
      • Frecuencia
      • La temperatura
    • Utiliza abrazaderas de transformador de corriente estándar para probar la corriente
    • Resistencias de carga de 22 ohmios por canal de corriente
    • Incluye convertidor reductor incorporado para alimentar ESP32 y electrónica
    • 2 interrupciones IRQ y 1 salida de advertencia conectada a ESP32
    • Salidas de cruce por cero
    • Salidas de pulso de energía por IC (4 por IC x2)
    • Interfaz SPI
    • Error de medición IC: 0,1%
    • Rango dinámico IC: 6000:1
    • Selección de ganancia actual: hasta 4x
    • Deriva de referencia de voltaje típica (ppm/°C): 6
    • Resolución ADC (bits): 16

    La placa principal cuyas medidas pueden ser bien MonofásicaTrifásicas incluye un convertidor reductor para alimentar la electrónica y la placa de desarrollo ESP32, que se conecta directamente a la placa. Se pueden apilar hasta 6 placas adicionales encima de la placa principal para permitirle monitorear hasta 42 canales actuales en resolución de 16 bits, en tiempo real, ¡todo a la vez!

    La potencia se puede calcular en el software, pero el factor de potencia deberá estimarse ((voltaje*corriente)*power_factor)).

    A continuación destacamos los elementos hardware necesarios para completar la instalación:

    • Transformadores de corriente (cualquier combinación de los siguientes, o cualquier transformador de corriente que no supere los 720 mV RMS o la salida de 33 mA)
      • SCT-006 20A/25mA Micro (apertura de 6 mm – conectores de 3,5 mm)
      • SCT-010 80A/26.6mA Mini (apertura 10mm – conectores 3.5mm)
      • SCT-013-000 100A/50mA (apertura 13mm – conectores 3.5mm)
      • SCT-016 120A/40mA (apertura 16mm – conectores 3.5mm)
      • Magnelab SCT-0750-100 (conectores de tornillo: debe cortar la conexión de la resistencia de carga en la parte posterior de la placa, ya que tienen una resistencia de carga incorporada).
      • SCT-024 200A/100mA (apertura 24mm – salida terminal)
      • También se pueden usar otros, siempre que estén clasificados para la cantidad de energía que desea medir y tengan una salida de corriente de no más de 720 mV RMS, o 33 mA en la salida máxima.
    • Transformador de CA (NO CC):
      • América del Norte: Jameco Reliapro 120V a 9V AC-AC o 12v. El pin positivo debe ser de 2,5 mm (algunos son de 2,1)
      • Europa: 240 V a 9 V o 12 V CA-CA al menos 500 mA
    • ESP32 (elija uno):
      • NodoMCU 32s
      • Espressif DevKitC
      • DevKitC-32U si necesita una mejor recepción wifi (no olvide la antena )
      • Cualquier otra cosa con los mismos pines que el anterior, que generalmente son 19 pines por lado con 3v3 en la parte superior izquierda y CLK en la parte inferior derecha
    • Software (elija uno):
    Diagrama posterior del medidor de energía ESP32 de 6 canales expandible

    Conectando el ESP32

    El medidor de energía ESP32 de 6 canales expandible está hecho para que una placa de desarrollo ESP32 se pueda conectar directamente al medidor. Consulte la lista anterior para conocer las placas de desarrollo ESP32 compatibles. Siempre inserte el ESP32 con el pin 3V3 en la parte superior izquierda del medidor . Los pines inferiores se utilizan para conectar la señal de voltaje (del enchufe de alimentación) a las placas adicionales. Si el ESP32 se inserta en los pines inferiores, lo más probable es que haga un cortocircuito en el ESP32.

    El medidor de energía ESP32 de 6 canales expandible utiliza SPI para comunicarse con el ESP32. Cada placa utiliza 2 pines CS.

    La placa principal utiliza los siguientes pines SPI:

    • CLK – 18
    • miso – 19
    • MOSI – 23
    • CS1 – 5 (CT1-CT3 y voltaje 1)
    • CS2 – 4 (CT4-CT6 y voltaje 2)

    El software EmonESP/EmonCMS

    EmonESP se usa para enviar datos de medidores de energía a una instalación local de EmonCMS o emoncms.org . Los datos también se pueden enviar a un corredor MQTT a través de esto. EmonCMS tiene aplicaciones para Android e IOS. El software ESP32 para EmonESP se encuentra aquí , y se puede flashear a un ESP32 usando Arduino IDE o PlatformIO 

    ESPHome/Asistente de hogar

    ESPHome se puede cargar en un ESP32 para integrar sin problemas los datos de energía en Home Assistant . Los datos de energía se pueden guardar en InfluxDB y mostrar con Grafana. Al mismo tiempo, los datos de energía también se pueden usar para automatizaciones en Home Assistant.

    Una nueva característica en Home Assistant le permite monitorear el uso de electricidad directamente en Home Assistant . ¡También puede rastrear el uso de dispositivos individuales y/o energía solar usando el medidor de 6 canales!

    Intermitente ESPHome
    • Si tiene Home Assistant instalado, vaya a Supervisor en el menú de la izquierda, haga clic en Tienda de complementos en la parte superior, busque ESPHome – Haga clic en Instalar
    • Haga clic en Abrir interfaz de usuario web
    Complemento ESPHome
    • Haga clic en el círculo verde + en la parte inferior derecha para agregar un nuevo nodo
    • Complete el nombre (por ejemplo, ‘energy_meter’ y el tipo de dispositivo como NodeMCU-32S o Generic ESP32
    • Agregue los detalles de su wifi y haga clic en Enviar para crear el nodo
    • ESPHome se compilará; cuando esté completo, haga clic en Descargar binario
    ESPHome Descargar Binario
    • Descargue la herramienta intermitente ESPHome para su sistema operativo aquí
    • Conecte el ESP32 que pretende usar con su medidor a su computadora a través de USB (no es necesario que esté conectado al medidor en este punto, pero si lo está, no conecte el transformador de CA todavía para el medidor al mismo tiempo). vez que el ESP32 está conectado al USB)
    • En la luz intermitente de ESPHome, seleccione el puerto COM al que está conectado el ESP32
    • Seleccione el archivo .bin que acaba de descargar y haga clic en Flash ESP (si no se conecta, haga clic en ver registros para ver qué está pasando; probablemente tendrá que mantener presionado el botón de arranque derecho en el ESP32 después de hacer clic en Flash ESP)
    • ESPHome se cargará en el ESP32 con una configuración básica
    ESPInicio Flasher
    • Suponiendo que el ESP32 esté lo suficientemente cerca del AP al que desea conectarse para WiFi, ahora debería estar disponible en ESPHome dentro de Home Assistant
    • En Home Assistant, vaya a Configuración > Integraciones y Configure para ESPHome. Debe estar resaltado como Descubierto
    Cargando la configuración del medidor de energía
    • Elija una configuración de ejemplo que mejor se adapte a la configuración de su medidor de energía aquí en el sitio de ESPHome , y aquí para algunas configuraciones más avanzadas
    • En la interfaz de usuario web de Home Assistant/ESPHome, haga clic en Editar para el nodo Medidor de energía
    • Copie/pegue la configuración de ejemplo, cambie cualquier configuración aplicable, como las calibraciones actuales a los transformadores de corriente que utiliza, y haga clic en Guardar
    edición de configuración de yaml
    • En este punto, es una buena idea cerrar el cuadro de diálogo de edición y hacer clic en Validar en la pantalla principal para asegurarse de que su archivo .yaml sea válido. Corrige los errores que puedan surgir.
    • Haga clic en Cargar para guardar su configuración en el ESP32. Tenga en cuenta que si tiene 4 o más placas adicionales, puede recibir un error y quedarse sin memoria en su ESP32 si tiene muchos sensores. 
    nodo ESPHome
    • Para una mayor precisión, puede calibrar los sensores de corriente. 
    • Al actualizar los valores de los transformadores de corriente en la configuración de ESPHome, haga clic en Editar y luego en Cargar

    Obtener datos en InfluxDB

    • Si aún no lo ha hecho, instale el complemento InfluxDB en Home Assistant a través de Supervisor > Tienda de complementos
    • Abra la interfaz de usuario web y haga clic en la pestaña Administrador de InfluxDB , agregue un asistente de base de datos
    • Haga clic en la pestaña Usuarios (en Bases de datos en la misma pantalla) y cree un nuevo usuario homeassistant con Todos los permisos
    • Edite su configuración .yaml y agregue los parámetros de InfluxDB enumerados en Supervisor > InfluxDB > Documentación (menú superior) > Integración en Home Assistant
    • Reiniciar Asistente de inicio
    • Los datos ahora deberían estar disponibles en Home Assistant y disponibles en http://homeassistant.local:8086 o la IP de Home Assistant

    Obtener datos en el panel de energía de Home Assistant

    Configuración de energía de Home Assistant

    Para mostrar datos en el panel de energía de Home Assistant, debe usar ESPHome v1.20.4 o superior, y tener al menos una total_daily_energyplataforma configurada en su configuración de ESPHome. timetambién se necesita.

    Para consumo total de energía
    #Total kWh
      - platform: total_daily_energy
        name: ${disp_name} Total kWh
        power_id: totalWatts
        filters:
          - multiply: 0.001
        unit_of_measurement: kWh
    time:
      - platform: sntp
        id: sntp_time 

    ¿Dónde totalWattsestá la suma de todos los cálculos de vatios en el medidor? Vea un ejemplo de esto aquí. En el ejemplo, esto se hizo con una plantilla lambda .

    para paneles solares

    Se puede hacer lo mismo que arriba para rastrear el uso y la exportación de paneles solares. Los canales actuales en el medidor que rastrean el uso solar deben tener su propio cálculo de plantilla lambda.

    Vea este ejemplo para saber cómo puede configurar esto con el medidor de 6 canales.

    Para dispositivo individual/seguimiento de circuito

    Para hacer esto, debe tener la potencia calculada por el medidor, o una plantilla lambda que calcula los vatios por circuito. Luego puede usar una plataforma de kWh para cada uno de los canales actuales en el medidor de energía de 6 canales. Por ejemplo:

    #CT1 kWh
      - platform: total_daily_energy
        name: ${disp_name} CT1 Watts Daily
        power_id: ct1Watts
        filters:
          - multiply: 0.001
        unit_of_measurement: kWh

    ct1Wattshace referencia a la identificación del cálculo de vatios. En la configuración de ejemplo , esto es:

          power:
            name: ${disp_name} CT1 Watts
            id: ct1Watts
    Configuración en Home Assistant
    • Vaya a Configuración > Energía
    • Para la energía total, haga clic en Agregar consumo en Red eléctrica
    • El nombre de la plataforma total_daily_energy, como 6C Total kWh, debería estar disponible para elegir
    • También puede establecer un costo estático por kWh o elegir una entidad que rastree el costo de su electricidad
    • Para Dispositivos individuales, elija el nombre de los circuitos individuales, como 6C CT1 Watts Daily
    • Si monitorea sus paneles solares con un medidor de 6 canales, también puede configurar esto aquí, pero no se registrará a menos que su casa consuma energía o fluya hacia la red.

    Preguntas más frecuentes

     Obtengo una lectura baja o nada en absoluto para un CT. ¿Qué sucede? : A veces, el conector para el CT es un poco rígido y es posible que deba empujar el conector del CT en el conector de la placa hasta que haga clic. Si definitivamente está completamente adentro, es posible que el conector o algún otro lugar tenga una conexión suelta, y reemplazaremos el medidor de forma gratuita.

    ¿Funciona el medidor de energía de 6 canales en mi país?: ¡Sí! Hay una configuración para configurar el medidor a 50 Hz o 60 Hz de potencia. Deberá comprar un transformador de CA que reduzca el voltaje a entre 9 y 12 V CA. Los transformadores para EE. UU. están a la venta en la tienda circuitsetup.us.

     Obtengo un valor negativo en un canal actual. ¿Qué está pasando? Esto generalmente significa que el CT está en la parte posterior del cable, ¡simplemente gírelo!

     Obtengo un pequeño valor negativo cuando no hay ninguna carga, pero de lo contrario obtengo un valor positivo. ¿Qué está pasando?: Esto se debe a variaciones en las resistencias y los transformadores de corriente. Puede calibrar los transformadores de corriente al medidor o agregar esta sección lambda para permitir solo valores positivos para un canal de corriente:

      - platform: template
        name: ${disp_name} CT1 Watts Positive
        id: ct1WattsPositive
        lambda: |-
          if (id(ct1Watts).state < 0) {
            return 0;
          } else {
            return id(ct1Watts).state ;
          }
        accuracy_decimals: 2
        unit_of_measurement: W
        icon: "mdi:flash-circle"
        update_interval: ${update_time}

    Luego, para su cálculo de vatios totales, use ct1WattsPositive

     Los cables del CT no son lo suficientemente largos. ¿Puedo extenderlos? ¡Sí, absolutamente puedes! Se puede usar algo como una extensión de auriculares o incluso un cable de ethernet (si no le importa hacer algo de cableado). Se recomienda calibrar los TC después de añadir cualquier extensión particularmente larga.

     ¿Puedo usar este CT con el medidor de 6 canales?: ¡Lo más probable es que sí! Siempre que la salida tenga una potencia nominal inferior a 720 mV RMS o 33 mA.

     ¿Puedo usar CT SCT-024 200A con el medidor de 6 canales?: Si necesita medir hasta 200 A, no se recomienda. A 200A, el SCT-024 emitirá 100mA. Eso significa que el máximo que debe medir con el SCT-024 conectado al medidor de 6 canales es 66A . En un entorno residencial con un servicio de 200 A, es muy poco probable que utilice más de 66 A por fase sostenida. De hecho, a menos que tenga su propio transformador dedicado y una casa muy grande, es imposible.

     ¿Cómo sé si mi CT tiene una resistencia de carga?: Hay una resistencia de carga incorporada si la salida está clasificada en voltios. En este caso, se debe cortar el puente correspondiente en la parte posterior del medidor.

    Cuando se usan más de 3 tableros complementarios, ESPHome no funciona. ESPHome se quedará sin memoria de pila después de usar más de 15 sensores, más o menos. Deberá aumentar el tamaño de la memoria de pila antes de compilar. Ver detalles aquí.

    ACTUALIZACIÓN: Puede reemplazar la definición esphome: en su configuración de ESPHome para resolver este problema con lo siguiente:

    esphome:
      name: 6chan_energy_meter
      platformio_options:
        build_flags: 
          - -DCONFIG_ARDUINO_LOOP_STACK_SIZE=32768
    
    esp32:
      board: nodemcu-32s
      variant: esp32
      framework:
        type: arduino
        version: 2.0.2
        source: https://github.com/espressif/arduino-esp32.git#2.0.2
        platform_version: https://github.com/platformio/platform-espressif32.git#feature/arduino-upstream

    Fuente: https://github.com/CircuitSetup/Expandable-6-Channel-ESP32-Energy-Meter

    Conexión de un ESP32 a un PZEM004


    El Pzem004 es un módulo de prueba de monitorización eléctrica que incluye un transformador de corriente que viene además ya calibrado. El módulo puede usarse para medir la energía, el voltaje y la corriente, y luego mostrarlo en un PC u otros terminales ofreciendo una precisión del 1%.

    En la versión con display incluye un botón de restablecimiento que puede restablecer los datos de energía simplemente pulsándolo. Además, puede almacenar datos cuando se apaga, y almacenar los datos de energía acumulados antes de apagarse, por lo que es muy conveniente usarlo.

    Gracias a que todas las versiones equipan un interfaz de comunicación de datos serie TTL, puede leer y configurar los parámetros relevantes a través del puerto serie que podemos capturar con un microcontrolador como por ejemplo un ESP32.

    En efecto usando la Biblioteca Arduino para Peacefair  en un ESP32 y un PZEM-004T-100A v3.0 podemos construir un Monitor de energía usando la interfaz ModBUS.

    Antes de empezar debemos saber que la versión 3.0 PZEM es una versión mejorada de la anterior PZEM-004T (para la que puede encontrar la biblioteca aquí aunque las bibliotecas son incompatibles entre las dos versiones de hw).

    Las principales características de este módulo son las siguientes;

    • Mide voltaje, corriente, potencia, energía, factor de potencia y frecuencia (nuevo en la versión 3.0)
    • 247 direcciones esclavas programables únicas
    • Contador de energía interna hasta 9999.99kWh
    • Alarma de sobrealimentación
    • Puesta a cero del contador de energía
    • Suma de comprobación CRC16
    • Mejor, pero no perfecto aislamiento de red

    Especificaciones del fabricante

    FunciónRango de mediciónResoluciónPrecisión
    Voltaje80~260V0.1V0,5%
    Actual0~10A o 0~100A*0.01A o 0.02A*0,5%
    Poder activo0~2,3kW o 0~23kW*0.1W0,5%
    energía activa0~9999.99kWh1Wh0,5%
    Frecuencia45~65Hz0,1 Hz0,5%
    Factor de potencia0,00~1,000.011%

    * Uso del transformador de corriente externo en lugar del derivador incorporado

    Este módulo es una versión mejorada del PZEM-004T con funciones de medición de frecuencia y factor de potencia, disponible en los lugares habituales. Se comunica mediante una interfaz TTL a través de un protocolo de comunicación similar a Modbus-RTU, pero es incompatible con la biblioteca @olehs anterior que se encuentra aquí: https://github.com/olehs/PZEM004T&nbsp;. 

    Compatibilidad con Arduino

    A continuación mostramos la compatibilidad con diferentes microcontroladores:

    UCMSerie de hardwareSerie de softwareNo probadoEjemplosnotas
    ATmega168XHardware Serie Software Serie
    ATmega328 ( Arduino Uno)( ✅)✔️Hardware Serie Software SerieHW Serial entra en conflicto con la salida de depuración. Sin embargo, se puede usar sin tener ninguna salida de consola serie
    ATmega2560 ( Arduino Mega​​)✔️✔️Hardware Serie Software Serie
    ESP8266( ✅)✔️SoftwareSerialHW Serial entra en conflicto con la salida de depuración Serial
    ESP32✔️HardwareSerieSW Serial no es realmente necesario ya que ESP32 tiene 3 seriales HW con pines configurables
    STM32X

    Comunicación en serie


    Este módulo está equipado con una interfaz de comunicación de datos en serie TTL, puede leer y configurar los parámetros relevantes a través del puerto en serie; pero si desea comunicarse con un dispositivo que use USB o RS232 (como un ordenador), debe estar equipado con un adaptador TTL diferente (la comunicación USB debe estar equipada con una placa adaptadora de conexiones TTL a USB y la comunicación RS232 debe estar equipada con un adaptador TTL a niveles RS232)

    En la siguiente tabla se encuentran los protocolos de comunicación de este módulo:

    NoFunciónCabezaDatos1- Datos5Suma
    1aRequerimiento de voltajeB0C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor del voltaje)1A
    1bRespuesta de voltajeA000 E6 02 00 00 (Respuesta del medidor, el valor del voltaje es 230,2 V)88
    2aRequerimiento actualB1C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor actual)1B
    2bRepresentante actualA100 11 20 00 00 (Respuesta del medidor, el valor actual es 17.32A)D2
    3aRequerimiento de potencia activaB2C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de potencia activa)1C
    3bPotencia activa Resp.A208 98 00 00 00 (Respuesta del medidor, el valor de potencia activa es 2200w)42
    4aLeer energía ReqB3C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de energía)1D
    4bLeer energía Resp.A301 86 9f 00 00 (Respuesta del medidor, el valor de energía es 99999wh)C9
    5aEstablecer la dirección del módulo ReqB4C0 A8 01 01 00 (La computadora envía una solicitud para configurar la dirección, la dirección es 192.168.1.1)1E
    5bEstablecer la dirección del módulo resp.A400 00 00 00 00 (Respuesta del medidor, la dirección se estableció correctamente)A4
    6aEstablecer el umbral de alarma de potencia ReqB5C0 A8 01 01 14 (la computadora envía una solicitud para establecer un umbral de alarma de energía)33
    6bEstablecer el umbral de alarma de potencia RespA500 00 00 00 00 (El medidor responde que el umbral de alarma de energía se configuró correctamente)A5

    Veamos ahora un ejemplo de protocolo de comunicación:

    1-Configure la dirección de comunicación: 192.168.1.1 (el usuario puede configurar su propia dirección en función de sus preferencias y necesidades).

    Enviar comando: B4 C0 A8 01 01 00 1E –>Datos de respuesta: A4 00 00 00 00 00 A4 .

    Nota: El envío de comandos y la respuesta automática de datos son como se muestra arriba, los datos se expresan en hexadecimal; el último byte de los datos de envío y respuesta son 1E y A4, pertenecen a la suma acumulativa. En el envío de comandos: B4 + C0 + A8 + 01 + 01 + 00 = 21E (utilice la suma hexadecimal), los datos de suma acumulada son 21E, tome los dos últimos bytes 1E para utilizar los datos de suma acumulada en el envío de comandos; datos en respuesta: A4 + 00 + 00 + 00 + 00 + 00 = A4 (use la suma hexadecimal), la suma acumulada de datos es A4, que es la suma acumulada de datos en respuesta.

    2-Configure el umbral de alarma de potencia: 20 KW
    Comando de envío: B5 C0 A8 01 01 14 33–>Datos de respuesta: A5 00 00 00 00 00 A5
    Nota : 14 en el comando de envío es el valor de la alarma (14 es una representación de datos hexadecimales, que se convirtió a decimal es 20). Lo que debe tener en cuenta es que el valor de alarma de potencia de este módulo se basa en unidades KW, lo que significa que el valor mínimo de alarma es 1 KW, el valor máximo es 22 KW.

    3-Leer el voltaje actual
    Enviar comando: B0 C0 A8 01 01 00 1A–>Datos de respuesta: A0 00 E6 02 00 00 88
    Nota : Los datos de voltaje de respuesta son D1D2D3 = 00 E6 02, 00 E6 representa el bit entero del voltaje, 02 representa el decimal del voltaje, el decimal es un dígito, convierte 00 E6 en decimal es 230; convierte 02 a decimal es 2, por lo que el valor de voltaje actual es 230.2V.

    4-Leer el comando de envío actual actual

    Enviar comando: B1 C0 A8 01 01 00 1B–>Datos de respuesta: A1 00 11 20 00 00 D2
    Nota : Los datos actuales de respuesta son D2D3 = 11 20, 11 representan el bit entero de la corriente, 20 representan el decimal del actual, el decimal actual es de dos dígitos, convierte 11 en decimal es 17; convierte 20 a decimal es 32, por lo que el valor actual actual es 17,32 A.

    5-Leer el comando de envío de energía actual

    Enviar comando:: B2 C0 A8 01 01 00 1C–>Datos de respuesta: A2 08 98 00 00 00 42
    Nota : Los datos de energía de respuesta son D1D2 = 08 98, convierte 08 98 a decimal es 2200, por lo que el valor de voltaje actual es 2200W .

    6-Leer el comando de envío de energía:

    Enviar comando:B3 C0 A8 01 01 00 1D–>Datos de respuesta: A3 01 86 9F 00 00 C9
    Nota : los datos de energía de respuesta son D1D2D3 = 01 86 9F, convierte 01 86 9F a decimal es 99999, por lo que la energía acumulada es 99999Wh .

    Circuito Básico con ejemplo de código

    Gracias a la biblioteca PZEM-004T v3.0 para el monitor de energía Peacefair PZEM-004T-10A y PZEM-004T-100A v3.0 utilizando la interfaz ModBUS y una placa ESP32, podemos monitorizar el consumo eléctrico junto a otras variables eléctricas como la tensión , la frecuencia , el factor de potencia, etc.

    Es interesante destacar que debemos usar la ultima version del modulo, pues la versión 3.0 PZEM es una versión mejorada del antiguo PZEM-004T 

    Respecto a las conexiones eléctricas debemos tener especialmente cuidado en el conexionado de las clemas de BT , las cuales viene claramente especificadas en la hoja de característica del modulo PZEM que usemos, pues una parte es para la medida del voltaje ( la medición se hace en paralelo ) y la parte contigua es la parte de la medida de la Intensidad (la medida se toma en serie en versiones de menos intensidad maxima admisible, pero para la version de 100A se suele tomar con una bobina toroidal o con un pinza amperimétrica)

    ¡Asegúrese de que el dispositivo esté conectado a la alimentación de CA! Los 5V solo alimentan los optoacopladores, no el chip real. Además, tenga cuidado, ¡la corriente alterna es peligrosa! ¡Si no sabe lo que estás haciendo, puede morir ! Es usted responsable de su propia estupidez. Así que no sea estúpido

    Peor tanto ,debemos extremar el cuidado especialmente en estas conexiones (las que van con tornillo).

    Observe por ejemplo las conexiones del módulo de 100 Amp. usado para escribir este post:

    Esta versión PZEM tiene una UART Serial que funciona a 5V, por lo que se debe realizar una simple modificación soldando una resistencia de 1K a 1/4W para permitir que la comunicación funcione a 3.3v en los casos de placas como Raspberry Pi, ESP32 y esp8266, con esta modificación la UART funcionará a 5v o 3.3v.

    Nota: Esta es la manera más sencilla y económica si no tienen al alcance un convertidor TTL de 5 a 3.3v, pero no se garantiza que funcione en todos los casos y con todos los medidores (en el prototipo probado funciona sin problemas).

    Respecto a las conexiones del PZEM004 con una placa ESP32 , estas son las siguientes:

    • TX ->GPIO17 (pin 7)
    • RX ->GPIO16 (pin 6) (podemos conectar una resistencia de 1K entre este y GND ).
    • GND->GND DE SP32 (pin 2)
    • VCC->3.3 DE ESP32 (pin 1)


    Vamos a seguir un esquema bastante sencillo que puede ser adaptado a distintas necesidades y montajes. Por ahora, y para realizar las pruebas podemos usar el siguiente simple esquema:

    Por el interior del anillo tendremos que pasar el cable de Fase (Negro) sobre el que queramos realizar las mediciones, pudiendo ser el mismo, o no, que el que hemos usado para dar corriente al circuito.

    Nota: Algunos módulos ESP permiten la salida de corriente 5V por el pin, otros no. Si vas a alimentar el módulo ESP con un cable USB y desde sus pines 5V/VCC y GND alimentar el módulo PZEM-004T comprueba que estos pines ofrezcan la corriente deseada.

    Dado que realmente el módulo ESP funciona a 3,3V y si se desea alimentar el módulo PZEM-004T con este voltaje, se recomienda colocar una resistencia de 1K entre 5V y RX del propio PZEM-004T. La Web de Tasmota tiene mucha información al respecto.

    Para ciertamente este montaje no conlleve ningún peligro debemos aislar ambas placas (por ejemplo en una caja de conexiones) para asegurarnos de que no recibimos ninguna descarga eléctrica fortuita tal y como podemos ver en el prototipo de abajo donde se usa un Arduino uno en lugar de un ESp32.

    Compatibilidad

    PRINCIPALES CARACTERÍSTICAS
    • Mide voltaje, corriente, potencia, energía, factor de potencia y frecuencia (nuevo en la versión 3.0)
    • 247 direcciones esclavas programables únicas
    • Contador de energía interno hasta 9999,99kWh
    OTRAS CARACTERÍSTICAS
    • Alarma de sobrecarga
    • Reinicio del contador de energía
    • Suma de comprobación CRC16
    • Aislamiento de red mejor, pero no perfecto

    Código arduino:

    A continuación vemos un ejemplo básico de código Arduino para probar nuestro montaje mostrando a traves del puerto serie a 115200 las medidas de potencia, tensión , corriente, frecuencia y factor de potencia a intervalos de unos 20ms.

    #include <PZEM004Tv30.h>
    
    /* Hardware Serial2 is only available on certain boards.
     * For example the Arduino MEGA 2560
    */
    #if defined(ESP32)
    PZEM004Tv30 pzem(Serial2, 16, 17);
    #else
    PZEM004Tv30 pzem(Serial2);
    #endif
    
    void setup() {
        Serial.begin(115200);
    
        // Uncomment in order to reset the internal energy counter
        // pzem.resetEnergy()
    }
    
    void loop() {
            
        Serial.print("Custom Address:");
        Serial.println(pzem.readAddress(), HEX);
    
        // Read the data from the sensor
        float voltage = pzem.voltage();
        float current = pzem.current();
        float power = pzem.power();
        float energy = pzem.energy();
        float frequency = pzem.frequency();
        float pf = pzem.pf();
    
        // Check if the data is valid
        if(isnan(voltage)){
            Serial.println("Error reading voltage");
        } else if (isnan(current)) {
            Serial.println("Error reading current");
        } else if (isnan(power)) {
            Serial.println("Error reading power");
        } else if (isnan(energy)) {
            Serial.println("Error reading energy");
        } else if (isnan(frequency)) {
            Serial.println("Error reading frequency");
        } else if (isnan(pf)) {
            Serial.println("Error reading power factor");
        } else {
    
            // Print the values to the Serial console
            Serial.print("Voltage: ");      Serial.print(voltage);      Serial.println("V");
            Serial.print("Current: ");      Serial.print(current);      Serial.println("A");
            Serial.print("Power: ");        Serial.print(power);        Serial.println("W");
            Serial.print("Energy: ");       Serial.print(energy,3);     Serial.println("kWh");
            Serial.print("Frequency: ");    Serial.print(frequency, 1); Serial.println("Hz");
            Serial.print("PF: ");           Serial.println(pf);
    
        }
    
        Serial.println();
        delay(2000);
    }

    Por supuesto este código lo podemos mejorar salvando por ejemplo los datos en una SD, enviando los datos a un proveedor de IoT y un largo etc

    Mas información en https://github.com/mandulaj/PZEM-004T-v30