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.
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.
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.
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.
Haga clic en TasmotizeHaga clic en Enviar configuraciónEscriba el nombre y el pase de WiFi.Notificación de configuración enviada.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.
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.
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.
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:
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.
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.
Versatilidad: Las pantallas LCD pueden ser utilizadas en una amplia variedad de proyectos, desde monitoreo de sensores hasta juegos y aplicaciones de tiempo real.
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.
Fácil conexión: La conexión de una pantalla LCD con una placa Arduino es generalmente sencilla y requiere pocos componentes adicionales.
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:
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 «<«:
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:
ESP8266 ESP-01 WiFi módulo
FTDI Breakout Board + Mini cable USB
ESP8266 ESP-01 Breakout Board (opcional)
Módulo relé de 1 canal
DHT11 Sensor de humedad y temperatura
Sensor de sonido
Breadboards (utilizaré breadboards pequeños 2)
5V a 3.3V paso descendente módulo de Buck (opcional)
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)
El modulo 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).
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.
En la siguiente imagen, vemos el módulo FTDI configurado para 3.3V mediante su puente correspondiente:
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)
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.
ESP8266 Tableros – para obtener instrucciones paso a paso, por favor véase la sección siguiente.
SimpleDHT bibliotecas – bibliotecas de SimpleDHT pueden ser descargado aquí.
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:
Ahora, vaya a Herramientas > Placas > Gestor de placas.
En Administrador de tablas, buscar esp8266e instalar el esp8266 por ESP8266 comunidad versión x.x.x. Cierre la ventana del administrador de tablas.
Ir a Herramientas > Placa Desplácese por la lista hasta encontrar Módulo genérico de ESP8266.
Agregar las bibliotecas requeridas
Ir al link proporcionado arriba para las bibliotecas necesarias 2 dos (SimpleDHT y SimpleTimer.
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:
Guarde el archivo ZIP para cada biblioteca.
En el IDE de Arduino, vaya a Sketch > Biblioteca incluyen > Agregar. Cierre biblioteca.
Busque y agregue a cada biblioteca (uno a la vez).
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:
En el IDE de Arduino, vaya a Sketch > Biblioteca incluyen. Haga clic en administrar bibliotecas.
En la ventana que aparecerá, escriba Cayenneen 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 deCayenney CayenneMQTT ).
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.
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:
¡Eso es todo! Ahora estamos listos para configurar nuestra consola y subir los bocetos:
Crear el tablero de mandos de Cayenne
Inicie sesión en su cuenta de Cayenne (registro gratis si usted no tiene uno pero al Cayenne registro página):
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: , Seleccione ESP8266 genérico en microcontroladores: Si tiene añadidos previamente en los dispositivos existentes, necesitará agregar un dispositivo haciendo clic en el menú de añadir dispositivos/Widget:
A continuación, elija ESP8266 ya que esta es nuestra tabla de desarrollo:
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.
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.
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
Ahora, vuelve al IDE de Arduino. Pegue los valores en la sección resaltada en la captura de pantalla siguiente:
También, proveer el nombre de Wi-Fi (SSID) y la contraseña en esta sección del código:
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():
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)
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)
Subir el boceto a la Placa de ESP8266 ESP-01. Asegúrese de que el elegido es Genérico módulo ESP8266:
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:
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:
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:
¡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í):
Añadir los widgets iniciales que se muestra arriba, haga clic en el icono «+» en la esquina superior derecha de cada widget inicial:
Una vez añadido, ahora personalizaremos cada widget. Esto es cómo se ve como cuando se agregan estos widgets iniciales:
Para personalizar cada widget, haga clic en el icono de la derecha, luego seleccione Ajustes. Consulte captura de pantalla siguiente:
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:
Aquí es cómo verá después:
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:
Desplácese hacia abajo más abajo y buscar Widgets personalizados. Seleccione el botón:
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:
El tablero final ahora este aspecto:
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.
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:
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.
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/Salida
3.3V DC
Frecuencia de reloj
80MHz / 160MHz
Instrucción RAM
32kB
Datos RAM
96kB
UART
2
Pines digitales GPIO
17 (configurable como PWM a 3,3V)
Pin analógico ADC
1 (el rango de voltaje es: 0 – 1V)
Memoria flash externa
4MB
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.
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:
Abra el software Arduino IDE
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 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.
Para conectarse a la red WiFi local se requiere WiFi SSID y contraseña.
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.
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.
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».
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);}
}
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.
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/Salida
3.3V DC
Frecuencia de reloj
80MHz / 160MHz
Instrucción RAM
32kB
Datos RAM
96kB
UART
2
Pines digitales GPIO
17 (configurable como PWM a 3,3V)
Pin analógico ADC
1 (el rango de voltaje es: 0 – 1V)
Memoria flash externa
4MB
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€)
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:
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:
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 crearemosuna nube Arduino IoT. Estos son los pasos a seguir:
Ingrese todos los detalles requeridos que quiere. Luego haga clic en Siguiente.
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.
Ahora haga clic en el botón Registrarse.
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.
Luego regrese a Arduino IoT Cloud y actualice la página.
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:
Haga clic en seleccionar dispositivo.
Luego haga clic en configurar un dispositivo de terceros.
Ahora seleccione el dispositivo (ESP8266) y seleccione el modelo (NodeMCU 1.0).
Allí puede ver todas las placas compatibles con Arduino Cloud en el menú.
Haga clic en Continuar.
Ingrese un nombre para su dispositivo y haga clic en Siguiente.
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.
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:
Haga clic en Agregar variables.
Asigne un nombre a la variable y seleccione el tipo como interruptor compatible con Alexa.
Haga clic en Permiso variable como Lectura y escritura y actualice la política como Al cambiar
Haga clic en Agregar variables.
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 :
Al principio, haga clic en Tablero y luego en ‘Crear tablero‘.
Haga clic en el botón editar. Luego haga clic en Agregar y allí puede seleccionar el widget de cambio.
Luego asigne un nombre al interruptor y haga clic en el botón Vincular variable que está visible a la derecha.
Como ya creamos una variable en el paso anterior, enlaze este con el widget.
Ahora haga clic en Vincular variable. Luego haga clic en Listo.
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:
En este paso, vamos a instalar todas las bibliotecas y otras dependencias. En este proyecto, necesitamos una biblioteca para ESP8266.
Al principio, ve al botón de boceto.
Luego haga clic en incluir bibliotecas.
Haga clic en administrar bibliotecas en Arduino IDE.
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.
Luego instale la placa ESP8266 desde el administrador de la placa.
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:
Al principio, haga clic en Más en la aplicación Amazon Alexa.
Luego seleccione Habilidades y juegos.
En la opción de búsqueda, puede encontrar Arduino.
Haga clic en Habilitar para usar.
Ahora necesitemos agregar un dispositivo en la aplicación Alexa
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.
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 tiene que decir «Alexa, enciende la luz». La luz esta encendida. Con este comando de voz, puede controlar los electrodomésticos con su voz.
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.
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.
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.
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.
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.
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();
}
}
Hemos hablado o en este blog deNode 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
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
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.
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
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 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
}
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:
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 :
Descargue e instale el Arduino IDE en su ordenador.
Abre el Arduino IDE y ve a «Archivo» -> «Preferencias».
Cierre la ventana de preferencias y ve a «Herramientas» -> «Placa» -> «Gestor de tarjetas».
Busque «esp8266» en el gestor de tarjetas y selecciónalo. Haga clic en «Instalar» para instalar el soporte para la placa NodeMCU.
Descargue la última versión de Tasmota desde el sitio web oficial.
Descomprima el archivo .zip descargado y copie el contenido en una carpeta en su ordenador.
Abra el Arduino IDE y selecciona «Archivo» -> «Abrir» para abrir el archivo «tasmota.ino» que se encuentra en la carpeta de Tasmota.
Conecte la placa NodeMCU a tu ordenador a través del cable USB.
Vaya a «Herramientas» -> «Placa» y selecciona «NodeMCU 1.0 (ESP-12E Module)».
Vaya a «Herramientas» -> «Puerto» y seleccione el puerto al que está conectada la placa NodeMCU.
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:
Nos pedirá confirmación antes de borrar el dispositivo:
Tardara un rato en completar la instalación, que ira apareciendo conforme se vaya instalando:
En unos segundos debería aparece el mensaje de concluida la instalación:
Concluida la instalación tenemos la opción de acceder al interfaz del propio Tasmota o abandonar:
Si todo va bien nos aparece el interfaz de Tasmota con todas las opciones disponibles
Antes de nada debemos acceder al menú configuración, para configurar los parámetros de red:
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:
Descargar el firmware Tasmota y guárdelo en su ordenador.
Conecte el dispositivo IoT a su ordenador utilizando un cable de programación, como un cable USB-TTL o un cable FTDI.
Abra el Puente de Servicio de Firmware (FSP) o el monitor de puerto serie.
Seleccione el puerto correcto en el Puente de Servicio de Firmware o el monitor de puerto serie.
Cargue el firmware Tasmota en el dispositivo siguiendo las instrucciones del fabricante.
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.
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.
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
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.
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
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
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
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.
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).
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.
// 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.
Establezca la variable tmp102Address para que coincida con ADD0. ADD0 conectado a GND corresponde a una dirección de 0x48.
Establezca la variable del token para que coincida con el token de Arduino desde el Tablero.
Compile y cargue este boceto.
Una vez que el Arduino se conecta al Tablero, debe actualizar automáticamente el widget TMP102 con datos.
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:
Para la documentación de API y SDK , visite la referencia para desarrolladores enArduino IoT Cloud API.
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 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
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.
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
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 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.
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€
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.
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.
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.
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!
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.
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.
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.
«Dispositivos»
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.
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.
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.
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.
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.
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.
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.
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.
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 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 )
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:
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).
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.
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.
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.
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.
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 .
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.0podemos 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)
* 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 .
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:
NO
FUNCIÓN
CABEZA
DATOS1- DATOS5
SUMA
1a
Requerimiento de voltaje
B0
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor del voltaje)
1A
1b
Respuesta de voltaje
A0
00 E6 02 00 00 (Respuesta del medidor, el valor del voltaje es 230,2 V)
88
2a
Requerimiento actual
B1
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor actual)
1B
2b
Representante actual
A1
00 11 20 00 00 (Respuesta del medidor, el valor actual es 17.32A)
D2
3a
Requerimiento de potencia activa
B2
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de potencia activa)
1C
3b
Potencia activa Resp.
A2
08 98 00 00 00 (Respuesta del medidor, el valor de potencia activa es 2200w)
42
4a
Leer energía Req
B3
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de energía)
1D
4b
Leer energía Resp.
A3
01 86 9f 00 00 (Respuesta del medidor, el valor de energía es 99999wh)
C9
5a
Establecer la dirección del módulo Req
B4
C0 A8 01 01 00 (La computadora envía una solicitud para configurar la dirección, la dirección es 192.168.1.1)
1E
5b
Establecer la dirección del módulo resp.
A4
00 00 00 00 00 (Respuesta del medidor, la dirección se estableció correctamente)
A4
6a
Establecer el umbral de alarma de potencia Req
B5
C0 A8 01 01 14 (la computadora envía una solicitud para establecer un umbral de alarma de energía)
33
6b
Establecer el umbral de alarma de potencia Resp
A5
00 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 yPZEM-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)
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:
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).
Vaya a Mi perfil / Perfil de usuario en el menú de la izquierda
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
Abrir búsqueda
Ir a Dispositivos
Seleccione varios dispositivos
Pase el cursor sobre el menú Acciones […]
Haga clic en Configuración de notificaciones
En el cajón abierto, seleccione los eventos deseados para editar
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
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.
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.
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
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:
El sensor CT y la resistencia de carga
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:
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);
}
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.
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
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.
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ásica o Trifá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)
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).
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):
La versión personalizada de EmonESP y la biblioteca Arduino ATM90E32
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
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
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
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
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
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.
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
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.
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.
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:
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:
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:
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.0podemos 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)
* 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 .
Compatibilidad con Arduino
A continuación mostramos la compatibilidad con diferentes microcontroladores:
SW Serial no es realmente necesario ya que ESP32 tiene 3 seriales HW con pines configurables
STM32
X
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:
No
Función
Cabeza
Datos1- Datos5
Suma
1a
Requerimiento de voltaje
B0
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor del voltaje)
1A
1b
Respuesta de voltaje
A0
00 E6 02 00 00 (Respuesta del medidor, el valor del voltaje es 230,2 V)
88
2a
Requerimiento actual
B1
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor actual)
1B
2b
Representante actual
A1
00 11 20 00 00 (Respuesta del medidor, el valor actual es 17.32A)
D2
3a
Requerimiento de potencia activa
B2
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de potencia activa)
1C
3b
Potencia activa Resp.
A2
08 98 00 00 00 (Respuesta del medidor, el valor de potencia activa es 2200w)
42
4a
Leer energía Req
B3
C0 A8 01 01 00 (La computadora envía una solicitud para leer el valor de energía)
1D
4b
Leer energía Resp.
A3
01 86 9f 00 00 (Respuesta del medidor, el valor de energía es 99999wh)
C9
5a
Establecer la dirección del módulo Req
B4
C0 A8 01 01 00 (La computadora envía una solicitud para configurar la dirección, la dirección es 192.168.1.1)
1E
5b
Establecer la dirección del módulo resp.
A4
00 00 00 00 00 (Respuesta del medidor, la dirección se estableció correctamente)
A4
6a
Establecer el umbral de alarma de potencia Req
B5
C0 A8 01 01 14 (la computadora envía una solicitud para establecer un umbral de alarma de energía)
33
6b
Establecer el umbral de alarma de potencia Resp
A5
00 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 yPZEM-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)
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
De vez en cuando se encontrará con una idea en la que mantener el tiempo es una preocupación principal. Por ejemplo, imagine un relé que debe activarse en un momento determinado o un registrador de datos que debe almacenar valores en intervalos precisos.
Lo primero que se te viene a la mente es usar un chip RTC (Real Time Clock). Pero estos chips no son perfectamente precisos, por lo que debe realizar ajustes manuales una y otra vez para mantenerlos sincronizados.
La solución aquí es usar Network Time Protocol (NTP). Si su proyecto ESP32 tiene acceso a Internet, puede obtener la fecha y la hora (con una precisión de unos pocos milisegundos de UTC) GRATIS . No necesita ningún hardware adicional.
¿Qué es un NTP?
Un NTP significa Network Time Protocol . Es un Protocolo de Internet (IP) estándar para sincronizar los relojes de la computadora con alguna referencia a través de una red.
El protocolo se puede usar para sincronizar todos los dispositivos en red con el tiempo universal coordinado (UTC) en unos pocos milisegundos (50 milisegundos en la Internet pública y menos de 5 milisegundos en un entorno LAN).
El tiempo universal coordinado (UTC) es un estándar de tiempo mundial, estrechamente relacionado con GMT (hora del meridiano de Greenwich). UTC no varía, es el mismo en todo el mundo.
NTP establece los relojes de las computadoras en UTC, el cliente aplica cualquier compensación de zona horaria local o compensación de horario de verano. De esta manera, los clientes pueden sincronizarse con los servidores independientemente de las diferencias de ubicación y zona horaria.
Arquitectura NTP
NTP utiliza una arquitectura jerárquica. Cada nivel de la jerarquía se conoce como estrato .
En la parte superior se encuentran los dispositivos de cronometraje de alta precisión, como relojes atómicos, GPS o relojes de radio, conocidos como relojes de hardware de estrato
Los servidores Stratum 1 tienen una conexión directa a un reloj de hardware stratum 0 y, por lo tanto, tienen la hora más precisa.
Cada estrato en la jerarquía se sincroniza con el estrato superior y actúa como servidor para las computadoras del estrato inferior.
¿Cómo funciona NTP?
NTP puede funcionar de varias maneras. La configuración más habitual es la de operar en modo cliente-servidor . El principio básico de funcionamiento es el siguiente:
El dispositivo cliente, como ESP32, se conecta al servidor mediante el Protocolo de datagramas de usuario (UDP) en el puerto 123.
Luego, un cliente transmite un paquete de solicitud a un servidor NTP.
En respuesta a esta solicitud, el servidor NTP envía un paquete de marca de tiempo.
Un paquete de marca de tiempo contiene información múltiple, como la marca de tiempo UNIX, la precisión, el retraso o la zona horaria.
Luego, un cliente puede analizar los valores de fecha y hora actuales.
Obtener fecha y hora del servidor NTP
El siguiente esquema le brindará una comprensión completa de cómo obtener la fecha y la hora del servidor NTP.
Antes de subir el boceto, debe realizar algunos cambios para que funcione para usted.
Debe modificar las siguientes dos variables con sus credenciales de red, para que ESP32 pueda establecer una conexión con la red existente.const char* ssid = "YOUR_SSID"; const char* password = "YOUR_PASS";
Debe ajustar el desplazamiento UTC para su zona horaria en milisegundos. Consulte la lista de compensaciones de tiempo UTC . Aquí hay algunos ejemplos para diferentes zonas horarias:
Para UTC -5.00 : -5 * 60 * 60 : -18000
Para UTC +1.00 : 1 * 60 * 60 : 3600
Para UTC +0.00 : 0 * 60 * 60 : 0
const long gmtOffset_sec = 3600;
Cambie la compensación de la luz del día en milisegundos. Si su país observa el horario de verano , configúrelo en 3600. De lo contrario, configúrelo en 0.const int daylightOffset_sec = 3600;
Una vez que haya terminado, continúe y pruebe el boceto.
#include <WiFi.h>
#include "time.h"
const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASS";
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 3600;
const int daylightOffset_sec = 3600;
void printLocalTime()
{
struct tm timeinfo;
if(!getLocalTime(&timeinfo)){
Serial.println("Failed to obtain time");
return;
}
Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
}
void setup()
{
Serial.begin(115200);
//connect to WiFi
Serial.printf("Connecting to %s ", ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(" CONNECTED");
//init and get the time
configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
printLocalTime();
//disconnect WiFi as it's no longer needed
WiFi.disconnect(true);
WiFi.mode(WIFI_OFF);
}
void loop()
{
delay(1000);
printLocalTime();
}
Después de cargar el boceto, presione el botón EN en su ESP32 y debería obtener la fecha y la hora cada segundo, como se muestra a continuación.
Código Explicación
Echemos un vistazo rápido al código para ver cómo funciona. Primero, incluimos las bibliotecas necesarias para este proyecto.
La biblioteca WiFi.h proporciona métodos WiFi específicos de ESP32 que llamamos para conectarse a la red.
time.h es la biblioteca de tiempo nativo de ESP32 que realiza una sincronización elegante del servidor NTP.
#include <WiFi.h>
#include "time.h"
A continuación, configuramos algunas constantes como SSID, contraseña WiFi, UTC Offset y Daylight offset que ya conoce.
Junto con eso, debemos especificar la dirección del servidor NTP que deseamos usar. pool.ntp.org es un proyecto NTP abierto ideal para cosas como esta.
const char* ntpServer = "pool.ntp.org";
El pool.ntp.org selecciona automáticamente los servidores de tiempo que están geográficamente cerca de usted. Pero si desea elegir explícitamente, use una de las subzonas de pool.ntp.org.
Área
Nombre de host
En todo el mundo
piscina.ntp.org
Asia
asia.pool.ntp.org
Europa
europa.pool.ntp.org
América del norte
norteamerica.pool.ntp.org
Oceanía
oceania.pool.ntp.org
Sudamerica
sudamerica.pool.ntp.org
En la sección de configuración, primero inicializamos la comunicación en serie con la PC y nos unimos a la red WiFi usando la WiFi.begin()función.
Serial.begin(115200);
//connect to WiFi
Serial.printf("Connecting to %s ", ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(" CONNECTED");
Una vez que ESP32 está conectado a la red, inicializamos el cliente NTP usando la configTime()función para obtener la fecha y la hora de un servidor NTP.
//init and get the time
configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
Ahora podemos simplemente llamar a la printLocalTime()función personalizada cada vez que queramos imprimir la fecha y hora actuales.
getLocalTime()La función se utiliza para transmitir un paquete de solicitud a un servidor NTP y analizar el paquete de marca de tiempo recibido en un formato legible. Toma la estructura del tiempo como parámetro.
Puede acceder a la información de fecha y hora accediendo a los miembros de esta estructura de tiempo.
La compañia Wildernesss Labs tras comprar en 2016 Netduino y trabajar en secreto dos años en 2018, sacaron vía crowfounding (en Kickstarter) su proyecto estrella: Meadow , una plataforma IoT estándar de .NET de pila completa que intenta combinar lo mejor de todos los mundos, pues tiene el poder de RaspberryPi, el factor de computación de un Arduino y la capacidad de administración de una aplicación móvil. ¿Y la mejor parte? funciona con .NET Standard completo en hardware de IoT real
Existe una brecha cada vez mayor entre los desarrolladores y las empresas que desean construir hardware conectado y la capacidad de hacerlo. Meadow intenta cerrar esa brecha y permite a los diez millones de desarrolladores de .NET crear experiencias de hardware realmente interesantes con la misma facilidad con la que crean aplicaciones web o móviles en la actualidad.
Meadow permite a los desarrolladores ejecutar aplicaciones completas de .NET Standard 2.x en un microcontrolador e incluye un conjunto de controladores de hardware y API en la parte superior que hace que el desarrollo de hardware sea plug and play. Sin embargo, Meadow no se limita a los desarrolladores .Net, intentando abrir el desarrollo de hardware a desarrolladores de todo tipo, poniendo especialmente foco en el ambiente empresarial .
Microordenador vs Microcontrolador: las Raspberry Pis son ordenadores completos y los Ardunios son pequeños dispositivos (en su mayoría) de una sola tarea. Es quizás una exageración tener Ubuntu en un ordenador solo para encender un dispositivo así que por lo general, es deseable que los dispositivos de IoT ocupen desde el punto de vista del hardware como del sw lo menos posible a si que puede ser una buena idea que nuestro core de IoT corra un sistema operativo mas estable en cuanto a cortes o interrupciones ( como lo haría en un microcontrolador pero con muchísima mas potencia del calculo).
Meadow en principio ha sido diseñado para ejecutarse en una variedad de microcontroladores, y la primera placa se basa en la MCU STM32F7 (insignia de STMicroelectronics) con coprocesador ESP-32 e implementando. WiFi, BLE, 32 MB de RAM, 32 MB de Flash. 25 puertos GPIO, PWM, I2C, SPI, CAN, UART y cargador de batería LiPo integrado, todo ello en el factor de forma Adafruit Feather.
Lo interesante pues es que el factor de forma Feather sirva como placa de desarrollo o incrustarlo. Es realmente un gran diseño basada en MCU STM32F7 en un bajísimo factor de forma y con casi tantos puertos GPIO (25) tanto analógicos como digitales como estamos acostumbrados en Arduino o Netduino.
En el sitio de Meadow Kickstarter dicen que se está ejecutando en Mono Runtime y admite la API .NET Standard 2.0 lo cual significa que probablemente ya sepa cómo programarlo pues la mayoría de las bibliotecas de NuGet son compatibles con .NET Standard, por lo que una gran cantidad de software de código abierto debería «simplemente funcionar» en cualquier solución que admita .NET Standard.
En términos de NanoFramework y TinyCLR; si bien esos son grandes esfuerzos, son significativamente diferentes a Meadow. Ambos esfuerzos se basan en .NET MicroFramework. Como tal, no son compatibles con .NET completo. No hay genéricos en ninguno de ellos, por ejemplo, ni hay soporte para las bibliotecas estándar .NET.
Funciones empresariales
Meadow incluye soporte para actualizaciones seguras por aire (OTA), lo que permite que las instalaciones de campo de IoT se gestionen de forma remota; una característica clave para las implementaciones empresariales de IoT.
Meadow abrirá todo un nuevo conjunto de posibilidades para el desarrollo de cosas conectadas. Y como funciona con un dispositivo de ultrabaja energía, podrá colocarlo en todas partes. Las instalaciones de baterías, energía solar e incluso energía a través de Ethernet (POE) se convertirán en algo común, lo que significa que para muchos de estos dispositivos, el acceso físico será limitado, por lo que la administración centralizada es un requisito absoluto.
Además de las actualizaciones de OTA, Wilderness Labs tiene planes para el monitoreo de campo básico, informes de fallas y análisis para asegurarse de que los dispositivos Meadow funcionen in situ.
Y debido a que Meadow usa .NET, las empresas pueden usar equipos existentes e inversiones de código para construir IoT, en lugar de tener que contratar nuevos desarrolladores que se especialicen en hardware. Es una propuesta de valor similar a la que sus creadores hicieron en Xamarin; había desarrolladores existentes que querían hacer dispositivos móviles, así como muchas inversiones existentes en código empresarial los cuales fueron habilitados en una plataforma completamente nueva ( Microsoft adquirió Xamarin por más de 400 millones de dólares, en gran parte por su valor en el mercado empresarial).
Seguridad
Otro aspecto importante del aspecto Meadow se intenta centrar en la seguridad. Meadow presenta consideraciones de seguridad básicas, desde la seguridad a nivel de hardware y las actualizaciones seguras, pero Wilderness Labs también se compromete a enviar componentes de software destinados a facilitar la seguridad desde una perspectiva de UX. No es suficiente tener actualizaciones seguras por aire (OTA ) , firmware firmado, revocación de certificados terciarios, etc., pueso la seguridad debe llegar hasta el final.
El pirateo del bot Mirai funcionó porque muchas de estas cámaras de seguridad conectadas tenían nombres de usuario y contraseñas predeterminados, asi que no es una cuestión banal.
En este nuevo enfoque enviaran componentes que puede ingresar y brindar una experiencia de usuario fantástica y fácil para cambiar esas cosas, así como orientación y educación para el desarrollador para ayudar a la gente a comprender cómo aprovechar las funciones de seguridad en la pila Meadow.
Inteligencia artificial en IoT
Recientemente, Pete Warden, director de TensorFlow en Google, escribió que la mayor parte de la inteligencia artificial se realizará en microcontroladores , y Meadow es la primera plataforma de desarrollo de microcontroladores que cumple con esa promesa, permitiendo ejecutar visión artificial a través de TensorFlow y otros paquetes de inteligencia artificial de alto nivel localmente en chip.
Se espera que la IA desempeñe un papel clave en IoT con la visión artificial y otros algoritmos de aprendizaje profundo que se ejecutan en imágenes y otros datos de sensores en la fuente para agilizar la recopilación de datos y permitir que los dispositivos tomen decisiones en el campo. Sin embargo, Meadow es la primera plataforma de microcontroladores de IoT que se enfoca específicamente en casos de uso de IA.
Mercado emergente
Se espera que el mercado global de IoT supere los USD $ 1 billón / año para 2025 , y se prevé que gran parte de ese dinero se gaste en herramientas, plataformas y servicios para desarrolladores. Y ese mercado está listo para la disrupción, mientras que los microcontroladores están preparados para convertirse en la forma dominante de computación , con un estimado de 75B de ellos in situ y conectados para 2025, casi todo el desarrollo de microcontroladores hoy en día se realiza en lenguajes de bajo nivel como C / C ++ , y las herramientas no han cambiado mucho desde la década de 1980.
Una de las cosas que ha frenado a IoT hasta ahora es la barrera de entrada; existe una variedad fantástica de nuevos dispositivos informáticos que pueden hacer todo lo que puede hacer una computadora en miniatura y más; sólo cuestan unos pocos dólares, pueden funcionar con una batería de tipo botón durante años y, sin embargo, programarlos es un trabajo duro durante los años 80 ”, comentó Bryan.
Diferencias con Neduino
Hardware
Si bien Meadow está diseñado para ejecutarse en una variedad de microcontroladores de 32 bits, su primera placa se basa en el chip STM32F7 de STMicroelectronic con 32 MB de almacenamiento flash y 16 MB de RAM , el sucesor del chip STM32F4 muy popular que se encuentra en varias placas de desarrollo de microcontroladores, incluido Netduino. La serie F7 es dos veces más poderosa pero usa la mitad de la energía de los chips F4 e incluye una serie de características interesantes, como un códec JPEG integrado para manejar transmisiones de video y cámara, así como un acelerador de gráficos 2D para proporcionar UX en un variedad de pantallas.
También están trabajando en una placa basada en ESP32 que traerá características y conectividad de alta gama a un mercado de bajo precio. Esperaremos con ansias el día en que pueda incorporar una placa Meadow basada en ESP32 en productos por menos de $ 10.
Una gran diferencia con Netduino es que la placa Meadow F7 está diseñada para ser compatible con el factor de forma Adafruit Feather ( claramente diferente a Natduino que se diseño para tener el mismo factor de forma que Arduino ). Además incluye un conector de batería y un cargador integrado, por lo que puede funcionar fácilmente con una batería o conectarse a un panel solar para uso indefinido mediante recarga solar. Aisimismo por diseño, el F7 también está destinado a ser integrable por defecto.
Lo interesante pues es que el factor de forma Feather sirva como placa de desarrollo o incrustarlo. Es realmente un gran diseño basada en MCU STM32F7 con coprocesador ESP-32 e implementando. WiFi, BLE, 32 MB de RAM, 32 MB de Flash. 25 puertos GPIO, PWM, I2C, SPI, CAN, UART y cargador de batería LiPo integrado en un bajísimo factor de forma y con casi tantos puertos GPIO (25) tanto analógicos como digitales como estamos acostumbrados en Arduino o Netduino.
Software
Meadow ejecuta un puerto personalizado de Mono sobre un NuttX muy modificado (un µRTOS). De ahí proviene el soporte estándar .NET. No se basa en Netduino de ninguna manera. Es una pieza de tecnología completamente nueva que han desarrollando desde cero durante los últimos dos años. Existe alguna relación con el proyecto Netduino.Foundation pues han portado Netduino.Foundationa Meadow, y obteniendo todo el atractivo de la última versión de C # y .NET completo para crear una API aún mejor para todos esos controladores.
El proyecto se inició porque .NETMF había desaparecido y no había ningún progreso real allí ni la comunidad pudo participar realmente en él. Es cierto que se inició como un spin-off de .NETMF pero, aparte del motor de ejecución y una buena parte de mscorlib, todo el código se escribió desde cero.
Han mejorado muchas cosas, actualizándolo en lo que respecta al sistema de compilación, Wilderness Labs lo ha hecho verdaderamente portátil para los RTOS de CMSIS, han reelaborado el motor de depuración y han agregado varios objetivos de referencia para MCU con diferentes conjuntos de funciones.
TODO el código es completamente de código abierto ( como el de Netduino ) . Desde el código nativo, a las bibliotecas de clases hasta la extensión de Visual Studio. Dos años de trabajo pueden parecer que el proyecto todavía está en él ‘Es una infancia, pero están orgullosos de que esto se ejecute en SoC SMT32 (de la serie L0 a H7) y, sí, también en ESP32. Hay NuGets funcionales y totalmente utilizables para GPIO, I2C, SPI, Serial, ADC, PWM, Wi-Fi, Networking (con soporte SSL / TLS) y otros.
Es cierto que no admiten bibliotecas .NET completas. En su lugar, han seguido prácticamente la API de .NET UWP para que se pueda reutilizar una gran cantidad de código sin demasiado trabajo pues en el mundo del IOT cada línea de código importa, se debe considerar cada ciclo de CPU, cada mA que el sistema drena de la batería y así sucesivamente: es decir todo lo que podamos hacer más eficiente es importante.
Conclusión
Tras dos años en el mercado Meadow es una plataforma con mucho futuro pero con mucho recorrido para crecer
Es como vemos bastante interesante, pero hay algunas cosas nos impiden retroceder:
PROS
La placa Meadow F7 está diseñada para ser compatible con el factor de forma Adafruit Feather e incluye un conector de batería y un cargador integrado, por lo que puede funcionar fácilmente con una batería o conectarse a un panel solar para uso indefinido mediante recarga solar .Ademas por diseño, el F7 también está destinado a ser integrable por defecto. Lo interesantes pues es que el factor de forma Feather sirva como placa de desarrollo o incrustarlo. .
Hay muchas variables en este sistema. Si podemos elegir entre tener genéricos o código en C # usando una herramienta increíble como Visual Studio, no lo deberíamos pensar dos veces y lo ideal seria optar por lo último. En general, es genial que haya más opciones disponibles que permitan a los desarrolladores de .NET codificar para IoT y sistemas integrados utilizando su lenguaje favorito;NET para codificar para IoT y sistemas integrados utilizando su lenguaje favorito;NET para codificar para IoT y sistemas integrados utilizando su lenguaje favorito
También hay cierta fragmentación en el espacio de .NET IoT, lo que significa que tenemos varias soluciones pequeñas, pero ninguna que sea utilizada por muchos desarrolladores. Un esfuerzo común, dirigido por .NET Foundation, habría sido un mejor enfoque. Nano Framework está en el camino correcto, pero todavía está en su infancia. Al final, el no compromiso de Microsoft con IoT / .NET Micro Framework es ahora un gran problema, ya que habría sido la plataforma perfecta y natural para el desarrollo de IoT basado en Azure ;
CONTRAS
Con 50$ al cambio , es extremadamente cara en comparación con Arduino, Raspberry Pi y otras ofertas similares.
Hay un esfuerzo para portar .NET a varios chips SDT y ESP32: https://nanoframework.net/ . pues no olvidemos que se puede obtener una placa de desarrollo ESP32 por menos de 10 $ ( y menos)
Es bueno recordar el fracaso del AGent smartwatch también en quickstarter patrocinada por Secret Labs ( los fundadores de Netduino). La idea era muy buena pues ya en 2013 este reloj pretendía ser un reloj inteligente con tinta electronica y con el soporte .Net. Este proyecto desgraciadamente precipito la caída de Secrets LAbs y con ello la de Netduino que fue comprado por Wilderness Labs.
Fundada en 2016, Wilderness Labs es el fabricante de placas Netduino y el creador de Meadow. Para obtener más información, puede encontrar su blog en blog.wildernesslabs.co .
Hoy en día muchos dispositivos que usamos día a día se conectan a internet como la televisión, altavoces inteligentes, refrigeradores, Aires Acondicionados , etc …, dispositivos que extienden sus funciones primarias permitiéndoles interactuar con otros dispositivos en internet siendo de este modo posible controlar estos remotamente.
Como podemos ver en este blog en numeras entradas que hablamos de dispositivos de IoT, es relativamente sencillo construir nuestros propios dispositivos de IoT con algunos sensores y microcontroladores como Arduino, NodeMCU, Raspberry Pi, etcétera , lo cual le permitirán automatizar su hogar apoyándose en estos dispositivos como por ejemplo usando el servicio de Cayenne .
Como ejemplo de lo sencillo que puede ser la construcción de dispositivos IoT desde un punto de vista más empírico , vamos a ver como usando NodeMCU ESP-12E podemos acceder a Firebase para encender y apagar un LED remoto.
NodeMCU ESP-12Ees muy barato (unos 6€) , y al tener wifi incorporado para conectarse a internet, ya tenemos los elementos suficientes para conectarnos a bases de datos avanzadas gracias a un hardware tan eficiente y por supuesto los servicios de Firebase.
En esta ocasión aunque NodeMCU ESP-12E cuenta con un puerto analogico denominado A0 y 13 pines digitales numerados del D0 al D12, vamos a usar un puerto interno al que esta conectado el led interno denominado LED_BUILTIN y de este modo no hace falta usar ningún componte externo
NodeMCU
ESP12E está basado en Arduino pero cuenta también conectividad wifi integrando la propia antena en la placa de circuito impreso en unas dimensiones de 25.6mm x 34.2mm . Además, por motivos de reducción de espacio . las versiones más antiguas de esta placa no integraban conexión usb ( para lo cual necesitaremos un USB FTDI para programarlo o un controlador Setup CH340g).
Las características principales son las siguientes:
Incorpora una MCU de 32-bit de bajo consumo (Tensilica L106)
Módulo WiFi de 2.4 GHz
RAM de unos 50 kB
1 entrada analógica de 10-bit (ADC)
17 pines de entrada y salida GPIO (de propósito general)
Dentro de los diferentes módulos del ESP8266,(ESP01,ESP03,ESP04,ESP05,…ESP12) destaca el ESP-12 o el ESP-12E, módulo que utiliza usando NodeMCU ESP-12E para procesar la información.
Básicamente estos módulos incorpora la memoria Flash para almacenar los programas o sketchs y la antena estando internamente los pines del ESP8266 cableados hasta los pines del módulo ESP-12 siendo así más fácil su acceso.
En todo caso, esta familia de placas todas cuentan con 11 pines digitales de entrada / salida, todos los pines tienen interruptor / pwm / I2C / 1-wire siendo su chip principal el ESP8266 CH340G , siendo una gran diferencia con una placa Arduino es que sólo cuenta con 1 entrada analógica (entrada máxima de 3,3 V)
Respecto al firmware necesitará subir el código a NodeMCU, pera el cual debería programar el NodeMCU con el IDE de Arduino,
Veamos con mas detalles como conseguimos configurar entorno de desarrollo tanto de Arduino como Firebase para que ambos puedan interaccionar entre si
Configuracion IDE de Arduino
1. Vamos a usar Arduino IDE para escribir el código . Si no lo tiene instalado puede descargar la última versión del IDE aquí.
2. Puesto que estamos usando NodeMCU que no es oficialmente compatible con IDE de Arduino, tenemos que agregar el archivo JSON del dispositivo. En el IDE de Arduino añadir esta URL en :
4. Para utilizar la base de datos bases avanzadas en NodeMCU puede descargar la biblioteca de bases avanzadas-arduino que abstrae la API REST de las bases avanzadas por los qeu necesitamos descargar la librería de Firebase desde github aquí.
5. Incluir el archivo zip descargado (firebase-arduino-master.zip) en el IDE de Arduino.
Programa > Incluir Libreria > Añadir .zip > Seleccionar archivo .zip descargado en el paso anterior
6. También necesitará instalar la biblioteca de ArduinoJson que puede descargarse desde el IDE de Arduino así mismo. Tenga en cuenta que la versión de la biblioteca no debe 6.x.x por lo que debe utilizar la última 5.x.x
Programa > Incluir Libreria > Añadir biblioteca .zip >Buscar ArduinoJson por Benoit Blanchon
Creación de una base de datos Firebase
7. Cree un nuevo proyecto de Firebase desde la consola (necesitará tener cuenta de google para crear proyecto de FireBase) y diríjase hacia la sección de base de datos. Seleccione la base de datos en tiempo real de bases avanzadas (firebase real-time database).
8. Necesitamos copiarnos el código secreto de la base de datos para la autenticación desde el Panel de configuración > Cuentas de servicio.>Mostrar
Una vez copiado la clave secreta ( que colocaremos en el código de arduino en #define FIREBASE_AUTH «XXXXXXXXXXX»), nos iremos a la opción de DataBase, y Realtime Database
9.Ahora debemos agregar un nodo asociado a la base de datos de firebase. Tenemos que seleccionar Realtime Database y pulsar el botón de + añadiendo el campo led . POsteriormente como veremos mas adelante, el valor de este campo decidirá si activar o desactivar el LED.
El tipo de dato es booleano ya que según lo pongamos a true o false esto accionará el led en el NodeMCU ESP-12E
Debemos actualizar la configuración de uso compartido de datos del proyecto NodeMCU.
Usar la configuración predeterminada para compartir datos de Google Analytics for Firebase , lo cual tendrá las siguientes consecuencias :
Compartir tus datos de Analytics con todas las funciones de Firebase
Comparte tus datos de Analytics con nosotros para ayudarnos a mejorar nuestros productos y servicios.
Comparte tus datos de Analytics con nosotros para habilitar el servicio de asistencia técnica.
Comparte tus datos de Analytics con nosotros para habilitar las comparativas.
Comparte tus datos de Analytics con los especialistas en cuentas de Google.
Asimismo tenemos dos opciones de modo de uso de la BBDD:en modo bloqueo o en modo de prueba para el caso que nos corresponde para probar la funcionalidad
Por último apuntaremos la instancia de firebase de acceso que luego insertamos en el código de Arduino en #define FIREBASE_HOST «xxxxxxxxxx.firebaseio.com/»
Configurar el IDE de Arduino y base de datos de Firebase a trabajar juntos
Ahora que hemos realizado todos los procedimientos de configuración, vamos a comenzar la codificación del código que ejecutaremos en nuestro módulo NodeMCU
Para simplificar, vamos a escribir un código sencillo para encender y apagar el LED interno del NodeMCU aunque realmente seria exactamente el mismo código si decidimos usar alguno de los 17 pines de entrada y salida GPIO (de propósito general), pues simplemente tendremos que conectar un led entre masa y uno de los pines , cambiando la constante LED_BUILTIN por un valor entero del 0 al 16 correspondiente al número del puerto al que hayamos conectado el led.
Serial.begin(115200); //inicializa el puerto de salida a 115200
pinMode(LED_BUILTIN, OUTPUT); //configurar el puerto interno como salida digitalWrite(LED_BUILTIN, HIGH); //enciende el led interno
// conectando a la red wifi.
WiFi.begin(WIFI_SSID, WIFI_PASSWORD); //conexión a la red wifi
delay(2000); //espera la conexión
Serial.println(«Conectando…»);
while (WiFi.status() != WL_CONNECTED) //bucle para esperar la conexión
{
Serial.println(«.»); //mientras pintamos un puntito que sacamos por consola
delay(3000);
}
Serial.println(«Conectado»); // ya hemos conseguido conectar por wifi
Serial.println(WiFi.localIP()); // pintamos la ip asignada
// Configurando conexión a firebase
Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH); //intentamos conectarnos a la base de datos Firebase con nuestras credenciales
//fin configuración
}
void loop() //bucle principal
{
//leer estado en Firebase el valor del registro led y observar que el valor recuperado al ser booleano se asigna directamente a la variables es booleana
bool isLedOn = Firebase.getBool(«led»); // recuperamos el valor del objeto led de la sesión firebase
if (isLedOn) // condicional para decidir en función del valor recuperado de firebase si se enciende o no el led
{
digitalWrite(LED_BUILTIN, HIGH); //encendemos el led Serial.println(«LED ON «); delay(2000);
}
else
{
digitalWrite(LED_BUILTIN, LOW); //apagamos el led Serial.println(«LED OFF»); delay(2000);
}
}
En el código anterior en primer lugar se incluyen las librerías necesarias para hacer toda gestión de conexión con Fireabase, así como las comunes de arduino para gestionar json y las propias del ESP8266
#include <ArduinoJson.h>
#include <ESP8266WiFi.h>
#include <FirebaseArduino.h>
Después se definen cuatro variables de tipo constante para almacenar:
#define WIFI_SSID «Nombre de Router Wifi» Cambiaremos en esa a línea la red del router WiFi al que nos vayamos a conectar
#define WIFI_PASSWORD «Contraseña del Router» Cambiaremos en esa línea contraseña de su router WiFi
#define FIREBASE_HOST «xxxxxxxxx.firebaseio.com» Insertaremos quie elnombre de la instancia de Firebase asociada a su usuario, para ello haremos clic en base de datos ahora se verá el nombre de host .Pulsamos Mostrar en imagen.Copiar el nombre sin el http en el código de Arduino
#define FIREBASE_AUTH «xxxxxxxxxxxxxxxxxxxxxxxxxxx»Insertaremos la palabra secreta de Forebase ,para ello iremos a Configuración > configuración del proyecto > cuentas de servicio > base de datos secreta .Copiar y pegar la palabra secreta en el código
Ahora toca inicializa el puerto de salida a 115200, ,configurar el puerto interno como salida enciende el led interno
Asimismo es necesario conectar la red wifi, que hacemos con un bucle para esperar la conexión mientras pintamos un puntito que sacamos por consola
La última parte del bloque de configuración es la conexión a firebase donde intentamos conectarnos a la base de datos Firebase con nuestras credenciales
LLegamos ahora al cuerpo principal (loop ) donde leeremos el estado en Firebase el valor del objeto led y actuaremos según su valor en el estado lógico de un pin del GPIO donde es interesante observar que el valor recuperado al ser booleano se asigna directamente a la variables que también es booleana.
La magia se hace justo con esta línea «bool isLedOn = Firebase.getBool(«led»); « donde recuperamos el valor del objeto led de la sesión firebase
Finalmente mediante condicional decidiremos en función del valor recuperado de firebase si se enciende o no el led
Este código , donde incluiremos nuestras credenciales del Firebase y de nuestra red wifi, lo subiremos desde el IDE de Arduino Programas > Subir y en seguida deberíamos ver el led interno luciendo o apagado en función del estado del objeto led en su base de datos Febase
Ahora intente cambiar el valor del objeto led en la base de datos a verdadero y falso. El led debería encenderse o apagarse en función del valor que hayamos seleccionado en el objeto led en Firebase .
Por supuesto puede ampliar este proyecto si decidimos cualquiera de los 17 pines de entrada y salida GPIO (de propósito general) asi como manejar estos mediante la creación de una aplicación web o móvil que accionará los puertos en lugar de cambiar manualmente el valor de la base de datos Firebase.
Además en este articulo hemos hablado de leer un objeto de Firebase desde un NodeMCU pero también es posible enviar datos desde la placa para salvarlos en Firebase y luego leer estos mediante una aplicación móvil o web, Sin duda el limite esta en nuestra imaginación …
Un enchufe inteligente puede ser el primer camino sencillo para empezar la automatización del hogar ,objetivo que sin duda esta muy pronto por llegar (en cuanto bajen aun mas los precios del hardware , pero sobre todo se mejore el software respecto a la seguridad) . Como hemos visto en este blog en numerosas ocasiones, existen muchos tipos de enchufes inteligentes disponibles en el mercado , pero aunque su precio empieza a ser razonable, desgraciadamente son soluciones cerradas y por tanto no son personalizables estando unidos a una solución sw que es muy difícil de cambiar.
En general, un enchufe inteligente es un dispositivo compacto que se conecta a tomas de corriente tradicionales pudiendo actualizarse con control remoto (normalmente por wifi) y por programación mediante diversas aplicaciones a medida ejecutadas desde un smartphone ( o desde un pagina web).
Hoy, día de año nuevo, vamos a ver lo sencillo que es construir un enchufe inteligente mediante la plataforma Cayenne y utilizando el económico módulo wifi ESP8266
Con esta solución se consiguen varios objetivos:
Control local y remoto – el dispositivo basado en Cayenne puede ser fácilmente encendido/apagado usando la aplicación para smartphone Cayenne o desde la página web de Cayenne.
Motion Control – puede automáticamente encender o apagar con su presencia así como activar o desactivar esta opción por medio de la propia app de Cayenne.
Control por voz – puede activar o apagado el enchufe usando el Asistente de voz de Alexa
Poder de programación – se puede crear fácilmente horarios de encendido/apagado para sus dispositivos .También fácilmente puede configurar el temporizador de Cayenne directamente desde la aplicación.
Protección térmica – gracias a un sensor de temperatura incorporado automáticamente se puede apagar aparatos por sobrecalentamiento y notificar esta condicion a través de SMS o correo electrónico.
Monitorización remota – Por medio de la aplicación de Cayenne se puede monitorear el voltaje, corriente, temperatura y estado del enchufe (o está activado o desactivado).
Estadísticas de uso de energía – se puede controlar el consumo de energía de los dispositivos conectados y obtener notificaciones.
El circuito
Para este proyecto se usa la siguiente lista de componentes:
El circuito no es demasiado complejo pues básicamente consiste en conectar los sensores al ESP8266 , sin olvidar la alimentación de 3.3v obtenida a partir de una fuente standard conmutada de 5v DC y un reductor de 5v y 3.3v DC . Puede usar un viejo cargador de teléfono móvil y realizar la conversión de 5V a 3.3V con un circuito regulador integrado como el AMS1117 . También puede alimentar con 5v el circuito usando directamente un micro-usb.
Usaremos el sensor digital de temperatura DS18B20 con bus de hilo de Maxim IC , componente muy usado por cierto en muchos proyectos de registro de datos y control de temperatura
Este chip envia al bus I2C la información de la temperatura exterior en grados C con precisión 9-12 bits, -55C a 125C (+/- 0.5C).a.
Cada sensor tiene un número de serie único de 64 bits grabado en él lo cual permite un gran número de sensores que se utilizarán en un bus de datos.
Para medir el interior temperatura del enchufe se usa el sensor de temperatura DS18B20 que alimentaremos con 5v DC desde el propio ESP8266 .Respecto a la salida digital del sensor de temperatura lo conectaremos a la una entrada digital por el pin 13.
Como vemos en el esquema anterior , el sensor de proximidad lo conectaremos al pin 4 digital y también a la alimentación de 5v DC de la placa.
Respecto al sensor de consumo , éste esta basado en el AC712 el cual conectaremos en derivación ( es decir en serie ) con la carga AC y a su vez con el modulo sharp S108T02 (que es un relé de estado solido ) que a su vez llevaremos al enchufe para conectar la carga que deseamos controlar.
El modulo sharp S108T02 (que es un relé de estado solido ) lo comandaremos directamente con una salida digital por medio del pin 5 ( al pin+) y masa . No debemos confundir los pines de control (+-) con lo pines de la carga AC controlar rotulados con el signo de ca .
Respecto al sensor de consumo eléctrico, nos basaremos en el modulo ACS712 , el cual asimismo también debe conectarse a la carga en serie como ya comentábamos . Para evitar precisamente problemas en las conexiones , el modulo ACS712 cuenta con dos terminales atornillables para conectar aquí la carga en serie y justo en el lado opuesto tres pines donde conectaremos la alimentación y el pin de datos (OUT) que soldaremos al pin analógico (ADC) del ESP8266
El modulo ACS712 puede medir hasta 30 amperios gracias a su tamaño compacto fácil de usar basándose en el Chip IC de producto: ACS712ELC 30 A . Su tensión de alimentación es de 5V y la tensión de salida con corrientes de hasta 30A es de185 mV/A siendo el rango de temperatura de funcionamiento entre -40 °C a 85 °C
El modelo HC-SR501HC-SR501 es un Sensor infrarrojo de bajo coste (menos de 2€ por modulo en Amazon) con placa de circuito de control donde se pueden ajustar la sensibilidad y el tiempo de retención gracias a dos resistencias ajustables que dispone en un lateral.
La gama de voltaje de trabajo es DC 5V-20V con un consumo de corriente de menos de 60uA. La salida es binaria digital siendo el voltaje de salida de 3,3 V para un nivel alto o “1” logico y 0V para el cero lógico (no detección de movimiento).
Lo primero que hacemos es conocer el pinout del HC-SR501, pero rápidamente al ver la serigrafía de la placa, queda perfectamente claro :GND para la masa , VCC para la alimentación (que tomaremos desde la Orange Pi ) y un pin de salida (OUT) que será el que nos indique si ha detectado algún movimiento.
Luego lleva un par de resistencia variables o potenciómetros que nos permiten ajustar los parámetros de sensibilidad y duración de la señal, es decir, durante cuanto tiempo vamos a querer que en pin OUT tener la salida informada.
El primer potenciómetro hacia la derecha sirve para ajustar la distancia de modo que el , rango de detección aumenta (unos 7 metros), por el contrario, la gama de detección disminuye (unos 3 metros).El otro potenciómetro rotándolo a la derecha sirve para retrasar el retardo de sensor a tiempos más largos (sobre 300s).Si se gira la contrario el retardo sera corto (sobre 5).
Plataforma Cayenne
Gracias a la plataforma de Cayenne , de la que hemos hablado en este blog en numerosas ocasiones es bastante sencillo monitorizar cualquier variable física de un modo realmente sencillo simplemente haciendo drug &drop desde el panel de control de Cayenne utilizando internet sin tener conocimientos de programación conseguiendo asi controlar o monitorizar una carga AC a en tan solo unos minutos .
En efecto, gracias a un framework genérico desarrollado por myDevices IO Project Builder llamado Cayenne , los desarrolladores , fabricantes y también aficionados pueden construir rápidamente prototipos y proyectos que requieran controlar o monitorizar cualquier cosa conectada a una placa con conectividad , permitiendo con una sóla cuenta gratuita de Cayenne, crear un número ilimitado de proyectos mediante una solución muy sencilla basada en arrastrar y soltar
Obviamente el punto fuerte de Cayenne son las capacidades de IO para que pueda controlar de forma remota sensores, motores, actuadores, incluidas los puertos de GPIO con almacenamiento ilimitado de datos recogidos por los componentes de hardware, triggers y alertas, que proporcionan las herramientas necesarias para la automatización y la capacidad de configurar alertas. Ademas también puede crear cuadros de mando personalizados para mostrar su proyecto con arrastrar y soltar widgets que también son totalmente personalizables.
Para probar Cayenne con el ESP12E necesitamos programar su ESP-12E para conectarse a su punto de acceso wifi (el código fuente a subir se puede descargar desde https://codebender.cc/embed/sketch:398516)
Como hemos hablado en muchas ocasiones de Cayenne pues en realidad está concebido para que su manejo sea realmente sencillo de configurar, de modo que nos iremos a su url : https://cayenne.mydevices.com/
Tras registrarnos nos iremos al panel de control ,pulsaremos en Add new y seleccionamos generic ESP8266
A continuación nos ofrece la API key que deberemos añadir al sw del ESP12E y tras reiniciarlo ya debería poderse comunicar con el node de Cayenne
Ahora la placa está configurada con el MQTT ( username /pwd) así como con conectividad wifi , de modo que ya debería de poder conectarse al framework de Cayenne y podemos seguir hacia adelante añadiendo sensores que deberán estar de acuerdo con el sw instalado en el ESP12E
Para visualizar los datos y controlar el dispositivo basta con añadir el widget apropiado usando arrastrar y soltar el método por lo que en primer lugar, es necesario determinar los parámetros que quieres monitorear.
Cayenne utilizar un canal separado para cada parámetro y necesita definir cuándo configurar un widget para cada funcionalidad
Estos son algunos de los widges que podemos usar para este circuito :
Como vemos ,en este caso , como se aprecia en la pantalla anterior se han añadido:
Dos valor pantalla Widgets para mostrar temperatura y corriente.
Un calibrador de pantalla Widget para mostrar el voltaje.
Un 2 Widget de pantalla de estado para monitorear el estado de la clavija
Tres botón controlador Widget para el torneado de encendido y apagado el enchufe, proximidad de activación/desactivación y activación/desactivación temporizador.
Un regulador controlador Widget para ajustar la hora.
Una línea gráfico pantalla Widget para mostrar el índice de consumo de energía.
Dos disparadores, uno por automático apagado si se sobrecalienta y otra para correo electrónico y notificación por SMS.
Básicamente el código a subir al ESP12E usa 5 librerías: tres de Cayenne donde tendremos que definir el SSID y la pwd de la red wifi así como las credenciales de Cayenne , una cuarta de temporización para enviar muestras a intervalos prefijados ( que obviamente podemos cambiar )
Es de destacar la creación de dos puertos virtuales para capturar los valores en tiempo real de la temperatura y la humedad tomadas ambas del DHTXX , lo cual nos van a permitir comunicarnos con el API de Cayenne.
Este es un ejemplo muy sencillo de utilización:
#include "CayenneDefines.h"#include "CayenneWiFi.h"#include "CayenneWiFiClient.h"#define CAYANNE_DEBUG#define CAYANNE_PRINT Serial// Cayenne authentication token. This should be obtained from the Cayenne Dashboard.// Change the value of token, ssid, and pwd to yourschar token[] = "xxxxxx";char ssid[] = "xxxxxx";char pwd[] = "xxxxx";DHT dht(DHTPIN, DHTTYPE);void setup() {// put your setup code here, to run once:Serial.begin(115200);Cayenne.begin(token, ssid, pwd);dht.begin();}CAYENNE_OUT(V0){float t = dht.readTemperature();Cayenne.virtualWrite(V0, t); //virtual pin}
......
......
void loop() {Cayenne.run();}
Como es obvio necesitaremos actualizar en el código anterior cambiando el valor de ssid, contraseña configurándola para la red wifi de su hogar y también no olvidar registrar el token de Cayenne que previamente habrá solicitado desde la propia web de cayenne.
Md Hairul ha compartido el código de su prototipo mediante licencia GPL, código, el cual para que sea mas legible hemos añadido unos breves lineas explicatorias.
// usado para enviar datos a la nube Cayenne #include "CayenneDefines.h" #include "CayenneWiFi.h" #include "CayenneWiFiClient.h"
// Incluye las bibliotecas para el sensor de temperatura DS18B20 #include <OneWire.h> #include <DallasTemperature.h>
// Habilitando la voz de Alexa
include "WemoSwitch.h" include "WemoManager.h" include "CallbackFunction.h"
// tipos de datos define TYPE_DIGITAL_SENSOR "digital_sensor" define TYPE_VOLTAGE "voltage" define TYPE_CURRENT "current"
// tipos de unidades define UNIT_DIGITAL "d" define UNIT_VOLTS "v" define UNIT_AMP "a"
// El pin e datos está conectado al puerto 2 del ESP8622 define ONE_WIRE_BUS 2
// Configurar una instancia de OneWire para comunicarse con cualquier dispositivo OneWire (no solo IC de temperatura Maxim / Dallas) OneWire oneWire(ONE_WIRE_BUS);
// Pasar la referencia oneWire al sensor de temperatura. DallasTemperature sensors(&oneWire); define PLUG 5 define pirPin 4
//variables int timer_flag = 0; int timer_time = 120; int pir_flag = 0; long timer_millis = 0; int calibrationTime = 30; long unsigned int lowIn; long unsigned int pause = 60000; boolean lockLow = true; boolean takeLowTime; int PIRValue = 0; unsigned long lastMillis = 0; int mVperAmp = 185; // usar 100 para el modulo de 20A y 66 para el módulo int RawValue= 0; int ACSoffset = 500; //solo para el modulo esp8266 double Voltage = 0; double current = 0; float temp = 0;
// Información de la red WiFi que debe personalizarse con lso datos de su red. const char ssid[] = "xxxxxxxx"; const char wifiPassword[] = "xxxxxxxxx";
// información de autentificación Cayenne que deben obtenerse desde el tablero de Cayenne. const char username[] = "xxxxxxxxxxxxxxxxxxxxxx"; const char password[] = "xxxxxxxxxxxxxxxxxxxxxx"; const char clientID[] = "xxxxxxxxxxxxxxxxxxxxxx";
// Poner en marcha la biblioteca de sensores de temperatura sensors.begin();
// iniciar wemo library wemoManager.begin();
// Formato: Alexa invocation name, local port no, on callback, off callback light = new WemoSwitch("Smart Plug", 80, plugOn, plugOff); wemoManager.addDevice(*light); delay(100); digitalWrite(PLUG, LOW); }
void loop() //aquí comienza el bucle infinito de lecturas y envios { Cayenne.loop(); wemoManager.serverLoop(); if(timer_flag){ check_time(); } if(pir_flag) { PIRSensor(); } read_temperature(); int voltage = 220; // definir voltaje standard read_current(); float energy = 0.7 * voltage * current * millis()/(1000 * 60); //en kWh, asumiendo un factor de potencia de 0.7
if (millis() - lastMillis > 10000) { lastMillis = millis(); // Enviar datos a Cayenne desde aquí. //Este ejemplo simplemente envía el tiempo de actividad actual en milisegundos. Cayenne.virtualWrite(1, voltage, TYPE_VOLTAGE, UNIT_VOLTS); Cayenne.virtualWrite(2, current, TYPE_CURRENT, UNIT_AMP); Cayenne.virtualWrite(3, temp, TYPE_TEMPERATURE, UNIT_CELSIUS); Cayenne.virtualWrite(4, energy, TYPE_ENERGY, UNIT_KW_PER_H); } }
CAYENNE_IN(5) // recepción de datos del canal 5 (encendido / apagado) { int value = getValue.asInt(); //aceptar y convertir valor a entero Serial.println(value); digitalWrite(PLUG, value); //cambiar el estado de Cayenne.virtualWrite(7, value, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL); }
CAYENNE_IN(6) // recepción de datos del canal 6 (encendido / apagado) { int value = getValue.asInt(); //aceptar y convertir valor a entero Serial.println(value); timer_time = value; }
CAYENNE_IN(8) //Datos recibidos desde el canal 6 de proximidad on / off { int value = getValue.asInt(); //accept and convert value to Int Serial.println(value); pir_flag = value; } CAYENNE_IN(10)
// recepción de datos del temporizador de activación / desactivación del canal 6 { int value = getValue.asInt();// aceptar y convertir valor a Int
Serial.println(value); timer_flag = value; timer_millis = millis(); } // Función predeterminada para procesar comandos del actuador desde el Tablero de Cayenne. //También puede usar funciones para canales específicos, por ejemplo, CAYENNE_IN (1) para los comandos del canal 1.
CAYENNE_IN_DEFAULT() { CAYENNE_LOG("CAYENNE_IN_DEFAULT(%u) - %s, %s", request.channel, getValue.getId(), getValue.asString()); //Procesar mensaje aquí. Si hay un error, establezca un mensaje de error utilizando getValue.setError (), //por ejemplo, getValue.setError ("Mensaje de error"); }
void read_temperature(){ // llamada a sensores.requestTemperaturas () para emitir una temperatura global // solicitud a todos los dispositivos en el bus Serial.print("Recuperando temperaturas…"); sensors.requestTemperatures(); // Envía el comando para obtener temperaturas.
Serial.println("HECHO"); // Después de que tengamos las temperaturas, podemos imprimirlas aquí.
// Usamos la función ByIndex, y como ejemplo obtenemos la temperatura solo del primer sensor. Serial.print("Temperatura para el dispositivo 1 (indice 0) es: "); temp = sensors.getTempCByIndex(0); Serial.println(temp); }
void read_current() { //1000 lecturas analógicas para promediar for(int i = 0; i < 1000; i++) { RawValue = RawValue + analogRead(A0); // agregar cada lectura A / D a un total } Voltage = ((RawValue / 1000) / 1023.0) * 1000; // Gets you mV, max is 1000mV current = ((Voltage - ACSoffset) / mVperAmp); }
, Seleccione ESP8266 genérico en microcontroladores:
Si tiene añadidos previamente en los dispositivos existentes, necesitará agregar un dispositivo haciendo clic en el menú de añadir dispositivos/Widget:
![interfaz-cayenne](https://soloelectronicos.files.wordpress.com/2017/12/addnew.png?w=520&h=246" alt="addnew.png)
.png)
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.