Sistema de automatización del hogar Tasmota usando ESP8266


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

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

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

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

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

foto del prototipo

El circuito

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

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

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

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

esquema electrico

Estos son los componentes involucrados:

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

Instalando Tasmota

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

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

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

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

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

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

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

descargar tasmotizador

tasmotizador

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

Proceso para Flashear Tasmota

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

¿Cómo configurar Wi-Fi?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Anuncio publicitario

Como gestionar un LCD con Arduino


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

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

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

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

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

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

La placa GeekPi ( LCD1602)

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

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

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

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

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

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

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

Este es un resumen de sus características:

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

Cómo conectarlo a Arduino


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

Cómo programarlo en Arduino


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

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

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

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

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

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

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

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

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

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

import time
import I2C_LCD_driver
mylcd = I2C_LCD_driver.lcd()

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


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

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

import I2C_LCD_driver
import time
mylcd = I2C_LCD_driver.lcd()


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

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

import I2C_LCD_driver
import socket
import fcntl
import struct

mylcd = I2C_LCD_driver.lcd()

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

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

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

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

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

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

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

DESPLAZAR TEXTO DE DERECHA A IZQUIERDA UNA VEZ


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

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

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

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

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

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

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

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

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


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

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

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

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

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

import I2C_LCD_driver
from time import *

mylcd = I2C_LCD_driver.lcd()

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

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

mylcd.lcd_load_custom_chars(fontdata1)

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

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

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

Detector de sonido con sensor de humedad y temperatura con IoT


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

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

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

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

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

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

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

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

Esta es la lista de componente usados en este proyecto:

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

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

img_4629

El modulo ESP8266 ESP-01

ESP8266 ESP-01

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

Módulo relé de 1 canal

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

DHT11 Sensor de humedad y temperatura

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

Sensor de sonido

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

FTDI USB a TTL convertidor de serie

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

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

img_4767

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

Conversor de 5V a 3.3V  (opcional)

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

El código

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

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

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

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

Agregar las bibliotecas requeridas

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

Agregar las bibliotecas de Cayenne

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

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

Modo de programación

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

Program Mode Connections

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

ESP8266 Project 3v3 Program Mode_bb

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

Crear el tablero de mandos de Cayenne

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

Código completo

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

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

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

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

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

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

// Sound Pin
int soundPin = 3;

// Relay Pin
int relayPin = 1;

// Timer
SimpleTimer timer;

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

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

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

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

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

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


Conexión de los sensores y módulos

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

Sensor and Modules Connections

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

ESP8266 Project 3v3_ no rx and tx connection

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

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

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

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

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

Initial Dashboard - Cayenne

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

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

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

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

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

Config - HumidityConfig - Sound DetectedConfig - Temperature

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

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

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

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

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

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

El tablero final ahora este aspecto:
Final Dashboard

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

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

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

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


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

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

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

Este proyecto tiene las siguientes características:

pruebas previas con cayenne

Principio del proyecto de automatización del hogar utilizando Cayenee

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

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

esp8266 por arriba

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

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

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

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

Sensores

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

Actuadores

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

Sistema Integrado

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

Red

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

Interfaz de usuario

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

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

Almacenamiento de datos

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

Este el resumen de los componentes usados:

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

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

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

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

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

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

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

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

esquema del circuito

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

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

Software

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

Usando este software Arduino IDE:

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

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

Biblioteca Cayenne-MQTT-ESP8266

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

biblioteca DHT

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

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

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

Sistema de domótica mediante software cayenee

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

Sistema de domótica utilizando el software cayenee 2

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

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

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

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

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

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

Sistema de domótica utilizando el software cayenee 3

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

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

Código NodeMCU

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

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





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

Sistema de domótica Alexa con Arduino IoT y ESP8266


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

esp8266 por arriba

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

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

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

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

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

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

El circuito

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

modulo de reles

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

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

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

Este es el simple diagrama de circuito:

Sistema de domótica 4 reles , esp8266 con Alexa

Este el listado de componentes:

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

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

Foto del montaje

Configuración y software

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

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

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

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

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

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

2-Agregar un dispositivo

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

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

3- Agregar variables en proyectos Arduino IoT Cloud

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

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

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

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

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

5-Instalar boceto para Arduino IoT Cloud

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

Instalación de bibliotecas

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

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

Actualizar el boceto del proyecto

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

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

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

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

Programar ESP8266 NodeMCU

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

Código para NodeMCU

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

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

6-Conectar la aplicación Amazon Alexa con ESP8266

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

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

Ahora necesitemos agregar un dispositivo en la aplicación Alexa

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

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

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


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

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

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

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

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

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

Sensores

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

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

dht11

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

Actuadores

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

Sistema Integrado

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

Red

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

Interfaz de usuario

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

Almacenamiento de datos

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

Diagrama de circuito

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

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

esquema circuito para blynk

Esta es la lista de componentes del circuito:

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

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

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

Automatización del hogar inteligente con PCB Blynk

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

Software necesario para la automatización del hogar inteligente

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

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

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

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

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

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

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

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

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

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

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

    Este circuito tiene dos partes de sensores:

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

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

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

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

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

    Código NodeMCU

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

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

    Introducción a Tasmota con NodeMCU


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

    node-mcu

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

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

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

    Configuración inicial de Node-MCU

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

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

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

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

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

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

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

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

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


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

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

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

    /*ESP8266 Led Parapadeante*/


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

    }


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

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

    delay(1000); //Espera de 1 segundo

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

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

    }

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

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

    INSTALACION SW DE TASMOTA

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

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

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

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

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

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

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

    Algunos ejemplos de controladores que soportan MQTT:

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

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

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

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

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

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

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

    Podria haber problemas

    Una vez seleccionada la placa debemos borrar el fw existente:

    borrar-esp8266

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

    confirmacion-borradp-esp8266

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

    progreso-instalacion-tasmota

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

    fin-instalacion-tasmota

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

    acceso-tasmota-al-final-instalacion

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

    menu-tasmota-esp8266

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

    menu configuracion-tasmota

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

    Resumen

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

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

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

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

    Cree su propio dispositivo IoT muy barato


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

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

    esp8266

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

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

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

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

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

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

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

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

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

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

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

    configuracion-arduino-ide-con-esp8266

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

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

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

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

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

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

     

    Envio de datos a la nube de Cayenne

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

    Ejemplo de envio temperatura  TMP102

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

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

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

    tmp102

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

    conexiones-tmp102-esp8266

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

                TMP102         ESP8266

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

    Y este esl codigo que subiremos a nuestro ESP8266:

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

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

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

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

    const int tmp102Address = 0x48;

    TMP102 tmpSensor(tmp102Address);

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

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

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

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


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

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

    Primeros pasos con la nube de Arduino


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

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

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

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

    Hardware compatible

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

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

    Wifi

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

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

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

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

    opta

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

    LoRaWAN®

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

    • MKR WAN 1300
    • MKR WAN 1310

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

    Placas GSM / NB-IoT

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

    • MKR GSM 1400
    • MKR NB 1500

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

    ESP32 / ESP8266

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

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

    Ethernet

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

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

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

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

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

    Primeros pasos

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

    1. Crear una cuenta de Arduino

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

    2. Vaya a la nube Arduino IoT

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

    Navegando a la nube.
    Navegando a la nube.

    3. Crear una cosa

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

    Resumen de la Cosa.
    Resumen de la Cosa.

    4. Configuración de un dispositivo

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

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

    «Dispositivos»

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

    5. Creando Variables

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

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

    6. Conexión a una red

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

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

    5. Creando Variables

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

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

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

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

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

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

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

    Serial.print()

    .

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

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

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

    8. Creación de un panel

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

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

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

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

    Los diferentes widgets disponibles.
    Los diferentes widgets disponibles.

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

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

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

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

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

    zz

    Contador inteligente basado en Home Assistant


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

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

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

    TASMOTA

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

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

    Necesita descargar ese archivo  tasmota32.bin

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

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

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

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

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

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

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

     Ingrese estos comandos uno por uno:

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

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

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

    Cómo trabajar con Tasmota en ESP32

    HOME ASSSITANT

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

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

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

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

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

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

    Ejecute el asistente de inicio:

    $ docker-compose up -d
    

    Asistente de configuración del hogar

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

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

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

    Configuración del asistente doméstico

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

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

    Agregar datos a la página de inicio

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

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

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

    Temperatura del asistente del hogar

    Acceso a la temperatura desde el exterior

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

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

    Felicitaciones por instalar Home Assistant con éxito.

    Configuración de contador de energia

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

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

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

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

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

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

    Especificaciones del fabricante

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

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

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

    Compatibilidad con Arduino

    A continuación mostramos la compatibilidad con diferentes microcontroladores:

    Comunicación en serie


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

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

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

    Veamos ahora un ejemplo de protocolo de comunicación:

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

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

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

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

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

    4-Leer el comando de envío actual actual

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

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

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

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

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

    Circuito Básico con ejemplo de código

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

    Compatibilidad

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

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

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

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

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

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

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

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


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

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


    En el siguiente video podemos ver todo el proceso completo:

    Creacion de un aplicacion movil para Iot


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

    Obtención de la placa Arduino adecuada para el trabajo

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

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

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

    Getting the Right Arduino Board for the Job

    EJEMPLO INICIAL

    Inscribirse

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

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

    Habilitar el modo de desarrollador

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

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

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

    Configuración rápida de plantilla

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

    Active su primer dispositivo

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

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

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

    A. Aprovisionamiento de WiFi mediante Blynk.Edgent

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

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

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

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

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

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

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

    Enviar datos del dispositivo a Blynk

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

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

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

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

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

    1. Haga clic en Editar configuración

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

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

    EJEMPLO  CON WEMOS

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

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

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

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

    Creación de su  aplicación con Blynk

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

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

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

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

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

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

    Creating Your Android / Iphone App With Blynk

    Prueba de su aplicación Blynk!

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

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

    TEST Your Blynk App!

    Algunas observaciones importantes

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

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

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

    Fuente aqui 

    Cálculo resistencia de carga para sensores no invasivos de tensión


    A la hora de medir con un controlador la intensidad de un circuito de ca, existen shunts , modernamente sensores hall, pero ambos adolecen de ser intrusivos porque requieren interrumpir el circuito para conectar estos. Modernamente han aparecido sensores no intrusivos basados en un núcleo partido que se puede abrir para intercalar el fase del circuito a medir. En este ámbito destacan los sensores de corriente alterna SCT-013 , los cuales podríamos clasificarlos en dos grupos: los que proporcionan una corriente o los que proporcionan un voltaje siendo la gran diferencia entre ellos que en los primeros no viene incluida una resistencia de carga y en los segundos sí (el nombre resistencia de carga o resistencia «burden» se refiere a la función que hace, no a como están fabricadas siendo su función convertir la corriente en un voltaje limitado que podamos medir, por ejemplo, con un microcontrolador).

    El sensor SCT-013-000 es el único que nos proporciona una corriente y por tanto no tiene resistencia de carga. Puede medir una corriente de entre 50 mA y 100 A. El resto de la familia de sensores SCT-013 sí que tienen incluida la resistencia de carga. Podemos encontrar varios modelos pero todos tienen un voltaje de salida entre 0V y 1V.

    Esta tabla nos describe las principales características de la familia de sensores SCT disponible :

    Elegir uno u otro sensor SCT-013 dependerá de las necesidades reales. Como vemos en la tabla anterior, deberá elegir la intensidad de corriente que mejor se acople a sus necesidades o bien seleccionar el modelo «personalizado» SCT-013-000.

    En post por tanto vamos a trabajar con el SCT-013-000 debido a que no tiene resistencia de carga lo cual nos va a permitir seleccionar la resistencia de carga más adecuada para medir con masa precisión el consumo eléctrico de un electrodoméstico en concreto como por ejemplo podria ser un frigorífico.

    Para conectar un sensor CT a un Arduino, la señal de salida del sensor CT debe acondicionarse para que cumpla con los requisitos de entrada de las entradas analógicas Arduino, es decir, un  voltaje positivo entre 0 V y el voltaje de referencia ADC.

    Este ejemplo vemos una placa Arduino que funciona a 5 V y el EmonTx que funciona a 3,3 V. Asegúrese de utilizar el voltaje de suministro y el voltaje de polarización correctos en sus cálculos que correspondan a su configuración.

    Esto se puede lograr con el siguiente circuito que consta de dos partes principales: 

    1. El sensor CT y la resistencia de carga
    2. El divisor de voltaje de polarización ( R1 y R2 )

    Basta con sumar 2,5V y estaría resuelto. Esto lo haremos a través de un circuito conocido como circuito offset en DC,lo cual básicamente consiste en poner un divisor de tensión y un condensador (el condensador tiene que ser de 10μF y unos pocos cientos de voltios lo cual hace que la reactancia sea baja y la corriente alterna evite la resistencia).

    El valor de las resistencias del divisor de tensión puede ser 10kΩ siempre y cuando lo alimentemos a través de la red eléctrica, pero si su dispositivo va a funcionar con baterías utilice unas resistencias de 470kΩ para que el consumo sea mínimo.

    Cálculo de un tamaño de resistencia de carga adecuado

    Si el sensor CT es del tipo de «salida de corriente» como el YHDC SCT-013-000 , la señal de corriente debe convertirse en una señal de voltaje con una resistencia de carga. Si se trata de un CT de salida de voltaje, puede omitir este paso y omitir la resistencia de carga, ya que la resistencia de carga está integrada en el CT.

    Este es el cálculo de la citada resistencia:

    1) Elija el rango actual que desea medir

    El YHDC SCT-013-000 CT tiene un rango de corriente de 0 a 100 A. Para este ejemplo, elijamos 100 A como nuestra corriente máxima.

    2) Convierta la corriente RMS máxima en corriente pico multiplicando por √2.

    Corriente máxima primaria = corriente RMS × √2 = 100 A × 1,414 = 141,4 A
    
    Resultado =141,4 Amp

    3) Divida el pico de corriente por el número de vueltas en el TC para obtener el pico de corriente en la bobina secundaria.

    El TC YHDC SCT-013-000 tiene 2000 vueltas, por lo que la corriente pico del secundario será:

    Pico de corriente secundario = Pico de corriente primario / no. de vueltas = 141.4 A / 2000 = 0.0707A
    
    Resultado 2= 0.07Amp

    4) Para maximizar la resolución de la medición, el voltaje a través de la resistencia de carga en el pico de corriente debe ser igual a la mitad del voltaje de referencia analógico de Arduino. (AREF / 2)

    Si está utilizando un Arduino que funciona a 5V: AREF / 2 será de 2,5 voltios. 

    Entonces la resistencia de carga ideal será:

    Resistencia de carga ideal = (AREF/2) / Pico de corriente secundario = 2,5 V / 0,0707 A = 35,4 Ω
    
    Resultado 3= 35,4 ohmios
    
    Es fácil adivinar que 35 Ω no es un valor de resistencia común. Los valores más cercanos a ambos lados de 35 Ω son 39 y 33 Ω. Elija siempre el valor más pequeño, o la corriente de carga máxima creará un voltaje más alto que AREF. Recomendamos una carga de 33 Ω ±1%. En algunos casos, el uso de 2 resistencias en serie estará más cerca del valor de carga ideal. Cuanto más lejos del ideal esté el valor, menor será la precisión.

    Aquí están los mismos cálculos que arriba en una forma más compacta:

    Resistencia de carga (ohmios) = (AREF * CT TURNS) / (2√2 * corriente primaria máx.)

    emonTx V2

    Si está utilizando un emonTx V2 alimentado por batería, AREF comenzará a 3,3 V y disminuirá lentamente a medida que el voltaje de la batería caiga a 2,7 V. Por lo tanto, la resistencia de carga ideal para el voltaje mínimo sería:

    Resistencia de carga ideal = (AREF/2) / Pico de corriente secundario = 1,35 V / 0,0707 A = 19,1 Ω

    19 Ω no es un valor común. Tenemos una opción de 18 o 22 Ω. Recomendamos utilizar una carga de 18 Ω ±1%.

    emonTx V3

    El emonTx V3 usa un regulador de 3.3V, por lo que es V CC y por lo tanto AREF, siempre será de 3.3V independientemente del voltaje de la batería. El emonTx V3 estándar usa resistencias de carga de 22 Ω para CT 1, 2 y 3, y una resistencia de 120 Ω para CT4, el canal de alta sensibilidad. 

    2) Agregar un sesgo de CC

    Si tuviera que conectar uno de los cables del TC a tierra y medir el voltaje del segundo cable, con respecto a tierra, el voltaje variaría de positivo a negativo con respecto a tierra. Sin embargo, las entradas analógicas de Arduino requieren un voltaje positivo. Al conectar el cable de CT que conectamos a tierra, a una fuente a la mitad del voltaje de suministro, el voltaje de salida de CT ahora oscilará por encima y por debajo de 2,5 V, por lo que permanecerá positivo.

    Las resistencias R1 y R2 en el diagrama de circuito anterior son un divisor de voltaje que proporciona la fuente de 2,5 V (1,65 V para el emonTx). El condensador electrolítico C1 tiene una reactancia baja de unos pocos cientos de ohmios, y proporciona un camino para que la corriente alterna evite la resistencia. Un valor de 10 μF es adecuado por ejemplo de 100v.

    Elegir un valor adecuado para las resistencias R1 y R2:

    Una mayor resistencia reduce el consumo de energía en reposo por lo que podemos usar resistencias de 10 kΩ para monitores alimentados por la red. El emonTx utiliza resistencias de 470 kΩ para mantener el consumo de energía al mínimo, ya que está diseñado para funcionar con baterías durante varios meses.

    Boceto de Arduino

    Para usar el circuito descrito para medir la corriente RMS, con un voltaje RMS fijo asumido (por ejemplo, 240 V) para indicar la potencia aparente aproximada, podemos usar el siguiente código en Arduino:

    // Include Emon Library
    #include "EmonLib.h"
     
    // Crear una instancia EnergyMonitor
    EnergyMonitor energyMonitor;
     
    // Voltaje de nuestra red eléctrica
    float voltajeRed = 220.0;
     
    void setup()
    {
      Serial.begin(9600);
     
      // Iniciamos la clase indicando
      // Número de pin: donde tenemos conectado el SCT-013
      // Valor de calibración: valor obtenido de la calibración teórica
      energyMonitor.current(0, 2.6);
    }
     
    void loop()
    {
      // Obtenemos el valor de la corriente eficaz
      // Pasamos el número de muestras que queremos tomar
      double Irms = energyMonitor.calcIrms(1484);
     
      // Calculamos la potencia aparente
      double potencia =  Irms * voltajeRed;
     
      // Mostramos la información por el monitor serie
      Serial.print("Potencia = ");
      Serial.print(potencia);
      Serial.print("    Irms = ");
      Serial.println(Irms);
    }
    
    

    Mas info en https://openenergymonitor.github.io/forum-archive/node/156.html

    Fácil monitorización energética


    IotaWatt es un proyecto que surgió de un esfuerzo informal para producir un medidor de energía eléctrica versátil que fuera más fácil de configurar y usar. Al emplear el popular y potente chip nodeMCU ESP8266, tiene un entorno operativo con un enfoque modular para la recopilación, almacenamiento y la generación de informes de datos junto con un servidor web WiFi integrado. El firmware resultante, después de más de un año de desarrollo, es por tanto muy robusto. Los primeros esfuerzos se concentraron en el uso de placas y escudos en forma de kit con un mínimo de hardware personalizado. Eventualmente, se hizo evidente que se necesitaba una sola placa personalizada para proporcionar la plataforma necesaria para que el software fuera útil ( de hecho el diseño actual de hardware abierto se produce comercialmente).

    Aunque los esquemas y el diseño de PCB están abiertos y disponibles en el proyecto Git, hay mucho más para hacer un producto comercial viable. IoTaWatt, Inc. es una entidad legal que se estableció en respuesta a la demanda de hardware de producción. El dispositivo básico, así como el equipo relacionado, se pueden comprar utilizando en su sitio web https://stuff.iotawatt.com/ ( ellos afirman que los costos para desarrollar y certificar el hardware fueron sustanciales y, con suerte, se compensarán con las ventas). Para ellos, los objetivos a corto plazo del proyecto son desarrollar más aplicaciones analíticas locales y desarrollar la infraestructura de soporte de la comunidad.

    Veamos un poco más en detalle esta interesante solución abierta para monitorización del consumo energético.

    Photo by Constantine Kim on Pexels.com

    Sistema abierto IotaWatt

    No es que otros monitores de energía sean malos, pero sí son diferentes en que en su mayoría son sistemas cerrados que brindan datos limitados y requieren que use sus plataformas de aplicaciones de teléfono y nube. IoTaWatt recopila muchas más métricas y almacena ese historial de uso localmente. Con su servidor web integrado, puede administrar la configuración, ver el estado en tiempo real o crear gráficos detallados usando el navegador en su computadora, tableta o teléfono. Son sus datos, en su propio hogar, y sujetos únicamente a su propia política de privacidad y retención.  Sin embargo, IoTaWatt puede cargar fácilmente datos de uso en cualquiera de varias bases de datos de terceros con aplicaciones asociadas y herramientas analíticas. Por ejemplo, PVoutput es un servicio gratuito que se conecta fácilmente con IoTaWatt y proporciona análisis de energía solar de clase mundial. Hay soporte completo para cargar a influxDB. También hay una interfaz API para aquellos que desean consultar datos para sus propias aplicaciones o para usar en hojas de cálculo, y hay integraciones disponibles para software de automatización del hogar como Home Assistant.

    IotaWatt tm es por tanto un monitor de energía eléctrica conectado WiFi de 14 canales de hardware abierto. Se basa en la plataforma IoT ESP8266 que utiliza ADC de 12 bits MCP3208 para muestrear el voltaje y la corriente de CA. Ademas puede registrar datos localmente en la tarjeta SD integrada y publicarlos directamente en Emoncms.org a través de WiFi.

    No hay planes para descontinuar el emonTx. Tanto IoTaWatt como emonTx tienen ventajas en áreas clave que se complementan entre sí.

    IoTaWatt es completamente de código abierto y ha sido desarrollado por Bob Lemaire @overeasy en asociación con OpenEnergy

    IoTaWatt se puede usar para monitorear cualquier sistema de energía estando en uso en más de 60 países en todo el mundo. La fase dividida de EE. UU. 120V/240V es fácil, pero también la monofásica de 230V como en Europa, la trifásica de 230V como en los hogares de Australia, Alemania y Noruega, por nombrar algunos. A la mayoría de las personas solo les importa si funcionará en su situación. La respuesta es un sí rotundo.

    También hay muchos usuarios comerciales/industriales que monitorean sistemas trifásicos de alto voltaje, incluidos los industriales de 277 V/480 V con un servicio de 600 amperios que usan varios megavatios-hora por día, más de lo que la mayoría de los hogares usan en un año. Luego hay un sitio en Uganda que mide el voltaje y la potencia que se usa para cargar motocicletas eléctricas de alquiler usando energía solar.

    Todo esto es posible porque IoTaWatt utiliza sensores externos simples que están disponibles para cualquier combinación de voltaje/potencia. Simplemente instálelo, conéctelo a IoTaWatt y seleccione el tipo de sensor en un menú desplegable en la aplicación de configuración.

    Cómo funciona

    IoTaWatt mide cada circuito usando un sensor pasivo que se engancha alrededor de uno de los cables aislados. La salida de cada uno de estos transformadores de corriente es de muy bajo voltaje y se conecta a cualquiera de las 14 entradas de IoTaWatt. 

    Un transformador de pared insertado en un receptáculo ordinario convierte el voltaje local en un voltaje de referencia estándar y permite que IoTaWatt determine el voltaje y la frecuencia de la línea.

    Desde la aplicación de configuración basada en navegador, simplemente seleccione el modelo de sensor que está conectado. IoTaWatt sabe cómo interpretar las señales para producir una medida muy precisa de la energía que se utiliza en cualquier momento.

    Los conectores estéreo estándar facilitan la conexión de los sensores de corriente. Cada una de las 14 entradas es típicamente un transformador de corriente que mide un circuito, pero se puede usar una sola entrada para monitorear varios circuitos y/o se pueden combinar varios CT en una sola entrada.

    Todas las entradas se enumeran con nombre, tipo de sensor y varias opciones. Para editar, haga clic en el número de entrada.

    Cambie el nombre o especifique un modelo de sensor diferente de la lista desplegable. Guarde e IoTaWatt comenzará a usar la nueva configuración de inmediato.

    El IoTaWatt se configura a través de una interfaz web servida directamente desde el IoTaWatt ESP8266. Visite IoTaWatt.com para ver una demostración en vivo de la interfaz.

    IoTaWatt admite actualizaciones de firmware automáticas por aire (OTA).

    El estado de las entradas y salidas se actualiza continuamente. Las salidas se pueden definir para que los detalles adicionales estén disponibles. El estado de las cargas del servidor y el contexto de los registros de datos están disponibles en las pestañas desplegables.

    Herramientas analíticas integradas

    Las herramientas analíticas integradas permiten ver el uso gráficamente. Muestre el uso de energía total junto con los circuitos individuales seleccionando de un menú.


    La aplicación Graph+ se ejecuta directamente desde el servidor web de IoTaWatt. Se puede usar desde una PC, teléfono o tableta.

    Cargas a influxDB y Emoncms

    Los usuarios más sofisticados pueden configurar la carga de datos en influxDB y usar Grafana o una de varias otras herramientas de visualización para crear impresionantes tableros.

    También hay una opción para cargar al sistema Emoncms con sus propias herramientas gráficas integradas.

    Panel de control de Emoncms

    Tablero de grafana con fuente de datos influxDB

    Ambas bases de datos externas son de software abierto y están disponibles como servicios comerciales o alojadas en varias plataformas personales, incluidas Windows y RaspberryPi.

    Pantalla de estado en vivo de salida PV

    Cargas a PVoutput

    PVOutput es un servicio en línea gratuito para compartir y comparar datos de salida de paneles solares fotovoltaicos. 
    Los datos de salida se pueden graficar, analizar y comparar con otros contribuyentes de pvoutput durante varios períodos de tiempo.

    Si bien pvoutput se enfoca principalmente en monitorear la generación de energía, también proporciona instalaciones igualmente capaces para cargar y monitorear datos de consumo de energía. Tanto la generación solar como los datos de consumo de energía se pueden combinar para proporcionar una vista ‘Neta’ de la energía que se genera o se consume en vivo.


    La «calculadora» es la interfaz simple de IoTaWatt para crear scripts para combinar y exportar datos. Especifique las unidades para calcular (amperios, vatios, voltios, etc.) y luego ingrese la función para calcular el valor. Es tan fácil como usar una calculadora básica de cuatro funciones.

    Capacidad trifásica

    IoTaWatt puede manejar energía trifásica de varias maneras. La forma fácil utiliza solo un transformador de referencia de tensión/fase enchufado en cualquiera de las tres fases. Las mediciones de potencia en las otras dos fases se realizan utilizando una señal de referencia trifásica «derivada».

    Para obtener la máxima precisión, se pueden conectar dos transformadores adicionales a las entradas para el voltaje «directo» y la referencia de fase de todas las fases.

    IoTaWatt ha sido probado para cumplir con los estándares regulatorios y de seguridad de América del Norte y Europa, que incluyen:

    • Cumplimiento con FCC parte B
    • Conformidad con CE, incluida la Directiva de emisiones de radio (RED) y la Directiva de bajo voltaje
    • Estándares de seguridad de bajo voltaje para EE. UU. (UL) y Canadá (CSA). Prueba y certificación por Intertek y lleva la marca de certificación ETL.
    • Los accesorios vendidos por IoTaWatt, Inc están listados por UL o reconocidos por UL y listados para su uso con IoTaWatt.

    Seguridad

    IoTaWatt admite la conexión cifrada de extremo a extremo a Emoncms mediante el nuevo cifrado de capa de transporte API de Emoncms . Debido a los recursos limitados del microcontrolador ESP8266, la conexión HTTPS no es posible. Sin embargo, Emoncms ofrece una solución de cifrado de capa de transporte integrada en la que la clave de acceso de emoncms se utiliza como clave precompartida para cifrar los datos con AES-128-CBC.

    Las actualizaciones automáticas de firmware OTA garantizan que IoTaWatt siempre esté ejecutando la última versión más segura, por ejemplo, se lanzó una actualización de firmware y se implementó automáticamente para corregir la vulnerabilidad KRACK WPA . Las actualizaciones de firmware están firmadas digitalmente.

    Comparación de emonTx vs. IoTaWattio

    No hay planes para descontinuar emonTx. El IoTaWatt no está diseñado para reemplazar el emonTx, sino para complementarlo. Cada unidad tiene ventajas en áreas clave:

    Ventajas de emonTx

    • Bajo consumo: energía de la batería/adaptador AC-AC único
    • No se requiere configuración
    • Admite múltiples sensores de temperatura DS18B20
    • Admite sensor de pulso óptico (entrada de interrupción) para interactuar directamente con medidores de servicios públicos
    • Trifásico aproximado con actualización de firmware
    • Múltiples emonTx pueden comunicarse con un solo emonPi / emonBase
    • No se requiere conexión WiFi

    Ventajas de IoTaWatt

    • Gran número de entradas de sensores CT
    • Configuración flexible (se admiten muchos tipos diferentes de CT)
    • Registro de tarjeta SD integrado
    • Actualizaciones de firmware OTA
    • Publicación directa a través de WiFi en Emoncms.org

    La ventaja obvia del IoTaWatt sobre el emonTx es la cantidad de entradas del sensor CT. Otra ventaja clave es la flexibilidad de IoTaWatt, cada canal de entrada (voltaje y corriente de CA) se puede configurar y calibrar individualmente. IoTaWatt es compatible con varios tamaños diferentes de sensores CT con preajustes de calibración para sensores CT, por ejemplo , 20A , 100A (estándar) y 200A .

    Es posible usar un IoTaWatt junto con un emonPi / emonBase, el IoTaWAtt puede publicar en cualquier servidor de Emoncms, incluido emonPi, a través de una red local.

    RESUMEN

    Es de destacar que en esencia este sistema de iotaWatt usa amplificadores operaciones de instrumentación para la medida de la corriente por medio de sensores magnéticos enviando las medidas por medio de un convertidor analógico digital con salida SPI, lo cual es muy similar a la propuesta que nos da lechacal.com ( en UK) pero en vez de usar un NodeMCU usa una Raspberry Pi ( aunque tienen una versión para una Orange Pi).

    Como detalle interesante sin duda es que tanto el hw como como el sw son abiertos lo cual lo hace muy atractivo para mejorar o incluso replicar esta solución, pero sin duda se echa de menos más rigor en la precisión de las medidas

    Más información en https://iotawatt.com/index.html

    Analizador de espectro con ESP32


    El analizador de espectro basado en IoT / web de Mark utiliza un único microcontrolador ESP32 para crear hasta 64 canales para visualizar diferentes bandas de audio. Sólo utiliza 6 componentes externos para funcionar, y no tiene Leds o pantallas LCD o TFT. En su lugar, utiliza una página web HTML para mostrar todas las barras de frecuencia. Otros aspecto interesante es dado que el ESP32 cuenta con dos cores, en esta implementación funcionan ambos núcleos del procesador; el núcleo 1 se utiliza para ejecutar el bucle principal del programa, mientras que el núcleo 0 se utiliza para actualizar constantemente los datos de la web. Aunque el programa en sí mismo hace posible que se ejecute en un solo núcleo, el uso de ambos núcleos dará lugar a un mejor rendimiento.

    ¡Esto es tan fácil de construir y programar, que tienes que probarlo! Ni siquiera necesitará instalar el software de Arduino; sólo tiene que usar el programador web para cargar el archivo binario precompilado.

    En efecto Mark nos presenta este gran proyecto que quiere compartir: un analizador de espectro de audio que no es complejo con un Hardware complicado, porque en la implementación solo vamos a usar un controlador esp32 con un puñado de componentes !y el resultado será absolutamente increíble!
    Así que si tiene curiosidad por saber cómo puede construir su propio analizador de espectro sin gastar más de unos pocos dólares, entonces este proyecto merece la pena sobre todo cuando comprueba en el esquema de más abajo como no ha usado más sólo 10 componentes o menos.


    Sobre el esquema veremos cómo programarlo y en cuanto a la programación veremos un truco especial bajo la manga, porque ni siquiera tendremos que instalar el entorno Arduino (a menos que quiera hacerlo
    primero).

    Antes de continuar veamos un poco sobre el audio y la transformación rápida de Fourier

    EXPLICACION DEL FUNCIONAMIENTO


    Para entender la forma en que escuchamos el audio simplificaremos las cosas mirando a un solo
    sonido, por ejemplo, una onda sinusoidal pura de 440Hz que la oiríamos como un tono simple aunque la mayoría de los sonidos se componen de una mezcla de frecuencias.
    SI agreguemos otra de 523 Hz usted puede escuchar claramente dos diferentes. Sin embargo, lo que realmente no son dos sonidos individuales, sino con dos sonidos procedentes del altavoz oirá la suma de ambos sonidos . Esto significa que a veces ambos sonidos se suman dando como resultado una mayor amplitud, mientras que otras veces los sonidos tienden a que el resultado sea una señal de aspecto casi aleatorio, aleatoria que no tiene ningún sentido y que incluso empeora en cuanto añadimos más frecuencias.

    Por ejemplo, agreguemos 587 Hertz, ahora puede escuchar tres sonidos individuales. Estos sonidos individuales de nuevo los está escuchando en una señal lejos de la onda sinusoidal pura. Si tomamos un vistazo recuerde que la música o la voz o la mayoría de los sonidos son en realidad una combinación de frecuencias que interactúan resultando el sonido que escucha.

    Ahora probablemente se esté preguntando cómo va a ayudarnos eso a construir un analizador de espectro. Pues bien, a la señal de audio, estamos viendo una mezcla de varias frecuencias individuales, estas frecuencias precisamente nos van a servir para construir un analizador de espectro ,pues no estamos interesados en esta mezcla, sino que queremos conocer todas las frecuencias que componen la señal, es decir queremos hacer ingeniería inversa de la mezcla para encontrar nuestras señales originales.

    Esto se puede hacer utilizando un complicado algoritmo llamado Transformación rápida de Fourier. La
    explicación de este algoritmo es compleja , así que para simplificar las cosas, una vez más sólo recuerde
    la transformación rápida de Fourier hace todos los cálculos.
    Para averiguar exactamente qué frecuencias están ocultas en su señal, ahora digamos digamos que el ancho de banda de nuestra señal de audio es de 20 Hz a 20 khz. Vamos a dividir el ancho de banda total en varias bandas individuales digamos siete y las llamaremos contenedores. Cada contenedor tiene un ancho de banda limitado y una diferente frecuencia central. Recordemos que nuestra señal de audio se compone de varios frecuencias individuales por lo que ahora el mencionado algoritmo clasificará qué frecuencia va donde y la pone en el contenedor correcto. Todo lo que queda por hacer es ver cuán lleno está cada contenedor y traducirlo a una lectura, que en nuestro caso es un gráfico de barras.

    El Hardware

    Para el hardware vamos a utilizar una placa de desarrollo esp32, cuatro resistencias un condensador y un interruptor y tal vez un conector de audio y eso es todo, así que con tan pocos componentes es muy fácil construir este proyecto usando una protoboard o un PCB estándar.

    El esquema es sencillo, , en el centro vemos la placa de placa de desarrollo ESP32 versión 1.0 .En el lado izquierdo tenemos nuestra entrada de audio el canal izquierdo y derecho y por supuesto la tierra. Ambos canales están unidos usando resistencias La señal de audio conjunta está conectada a un lado de un condensador mientras que el otro lado del condensador está conectado a nuestra entrada ADC y también a resistencias R3 y R4.

    Si echa un vistazo a la hoja de datos del esp32 verá que que la entrada del ADC sólo puede manejar un
    positivo mientras que nuestra señal de audio puede ser negativa y positiva: por eso estamos creando un offset de aproximadamente 1.6 voltios usando R3 y R4.

    Finalmente tenemos un botón S1 que podemos pulsar para cambiar el número de bandas o contenedores durante el tiempo de ejecución. Se puede cambiar a 8 16 24 32 o incluso 64 canales

    Para facilitar las cosas, vemos dos ejemplos de cómo podemos reconstruir este dispositivo. En el lado izquierdo puede ver una placa de pruebas con todos los componentes , simplemente siga el ejemplo y debería funcionar.
    También vemos el prototipo de placa de circuito impreso superior (el ejemplo está en el lado derecho)
    Mire bien el ejemplo y tome nota de los lugares donde se interrumpen los carriles de cobre o donde estan unidos
    Ahora que el hardware está hecho ¿está de acuerdo con lo que he dicho antes?..es realmente fácil de construir, ¿no?


    El software

    Ahora que el hardware está hecho vamos a pasar a la programación, para lo cual es necesario descargar el boceto de la comunidad de element 14. Puede descargar todos los archivos en la Comunidad element14! https://bit.ly/3fv0oqy

    Antes de que pueda usar un esp32 con el entorno Arduino, necesita instalar las bibliotecas adecuadas
    y para ello vamos al archivo hacemos clic en preferencias y luego buscamos la línea que dice
    administradores adicionales de la placa . Haga clic en el icono y asegúrese de añadir esta línea . Pulse OK y de nuevo pulse OK (esto significa que la librería el enlace a la librería está instalada)

    Ahora vamos a instalar la biblioteca, para ello vamos a herramientas, y hacemos clic en el gestor de placas y el gestor de placas manager. Primero tenemos que esperar hasta que se cargue y una vez cargado, (esto puede tomar algún tiempo dependiendo de la cantidad de biblioteca que tenga instalada), en la barra de búsqueda hacemos clic en esp32 y esp32 by expressive systems aparecerá). Asegúrese de instalarlo correctamente.

    Bien si ya lo he hecho, el botón se pondrá en gris. Una vez que se instala asegúrese de seleccionar la placa apropiada, (una conocida es la esp32 dev kit que se encuentra en esp32 Arduino boards, pero encontrará más abajo do it esp32 def kit version , que es una de las más usadas por su bajo precio,y es la que se usa en este analizador)

    El sketch se compone de dos archivos : uno de dos archivos es nuestro elemento de especificación web
    que es el archivo principal y nuestra configuración , y el otro es la gestión de la entrada de audio y su correspondiente gestión con la transformada rapida de Fourier

    Echemos un vistazo al elemento web primero básicamente porque no hay nada en este archivo que necesite ser cambiado a menos que quiera añadir funcionalidad o quiera hacer algunos cambios que tengan bastante impacto, pero básicamente no necesita cambiarlo. Por supuesto puede si quiere en la configuración, hay algunos parámetros que puede cambiar, puede cambiar el número de bandas, que ahora está fijado en 64 y básicamente este es el número de bandas en el arranque se puede cambiar a 8 16 24 32 o 64. Podemos definir el modo si tiene un hardware diferente o si usa un pin diferente puede cambiarlo. Asimismo hay amortiguación de ganancia y umbral de ruido, y esos dos parámetros que puede tener en cuenta, si usted ve una gran cantidad de estática, lo que significa que los gráficos de barras ya te están dando una lectura tremendamente cuando no hay señal que puede cambiar aquí, entonces tenemos la velocidad del filtro mientras que básicamente es un retraso tiempo para que las barras caigan y lo hace más suave si el número es demasiado alto entonces se convertirá en bastante
    nervioso, tenemos la frecuencia de muestreo y un bloque de muestreo que ( se recomienda que se deje igual, no los cambie). Asimismo tenemos por supuesto nuestras tablas de corte de banda para cada número de canales de modo que para cada grupo hay un parámetro diferente. Tomemos el de
    para ocho canales, primero se ve el en el color de la tabla y ahora es 100 Hertz, 250, 500, Etc .Usted
    puede cambiarlo, pero asegúrese de que el secuencial debe ser siempre más alto que el anterior y
    esta regal se mantiene sucesivamente. Asimismo tenemos las etiquetas, que por supuesto básicamente eso es lo que se mostrará en la pantalla, y lo mismo ocurre con la banda de 16, la de 24, la de 32 y 64.

    Básicamente eso es todo lo que hay, si quiere profundizar en el código, Mark ha puesto
    comentarios allí que nos pueden ayudar a entender un poco más los entresijos y puede leerlo.



    Bueno, puede ser un poco de molestia compilar : tenemos que instalar el Arduino IIDE, las librerías, tenemos que instalar el gestor de placas adecuado, abrir el boceto compilarlo y subirlo, así que muchas cosas pueden salir mal, ¿y si hubiese otra manera más fácil? Pues la hay, con una versión de Mark que ya lo he compilado para nosotros de modo que podemos usar nuestro navegador de internet para simplemente subirlo directamente a la esp32 ( sin embargo esto solo funciona si va usando el sketch sin modificar de modo que si piensa hacer modificaciones esto no funcionara) .

    En efecto para hacer modificaciones en el sketch tal vez quiera añadir una funcionalidad extra o
    cambiar el ruido o los parámetros de retardo… entonces, por supuesto, usted tendra que
    recompilarlo y subirlo usando el Arduino IDE pero para todos los demás, veamos la programación en el navegador web

    La forma más manera más fácil de programar esp32 que jamás hayas visto, es sencilla : sólo tiene que ir a la siguiente sitio web , pulse instalar, seleccione el puerto com apropiado y asegúrese de que su
    esp32 está conectado con el conector USB y presiona connect para que comience a programar.
    Programar es tan fácil como eso.. !sólo esperar hasta que llegue a 100% y ya está!, eso es todo lo que hay que hacer si utilizas el navegador web para programar su esp32 es seguro decir que la
    la programación fue incluso más fácil que el hardware y el hardware en sí no era difícil fue así es el momento para una demostración


    ¿No crees que vamos a ver lo que hemos construido ? tomemos nuestro esp32 que hemos programado y pongámoslo en la placa que acabamos de crear. Ahora todo lo que necesita hacer es encenderlo de modo que cuando lo arranque por primera vez el dispositivo, como no tiene memoria de sus redes, lo que se iniciará como un punto de acceso y tiene que conectarse al punto de acceso utilizando su teléfono móvil o cualquier otro dispositivo.En el momento en que se conecte se iniciará el gestor de Wi-Fi. Es justo ahi donde puede introducir sus credenciales como su red o contraseña y pulsar guardar. Después de un reinicio, ahora será parte de su red y podrá acceder a ella yendo a la dirección IP correspondiente

    Para terminar veamos el video que ha hecho Mark donde explica en ingles todo lo que hemos visto anteriormente:

    Sin duda es un proyecto muy interesante que además nos puede ayudar a comprender mucho mejor la programación con el ESP32 y por supuesto entender un poco mejor la ciencia que hay detrás del mundo del sonido.

    Fuente aqui

    Medidas eléctricas de +6canales ( software)


    Ya se trató en este blog el hardware de EmonESP/EmonCMS ,una placa medidora de energía que usa tambien un ESP32 proporcionado 6 canales expandibles pudiendo leer 6 canales de corriente y 2 canales de voltaje a la vez. Para ello utiliza transformadores de corriente y un transformador de CA para medir el voltaje y alimentar la(s) placa(s)/ESP32. 

    Estas son algunas de sus carastericticas

    • Muestras de 6 canales de corriente y 1 canal de voltaje (ampliable a 2 voltajes)
    • Las placas complementarias (hasta 6) pueden expandir el medidor hasta 42 canales de corriente y 8 canales de voltaje
    • Utiliza 2  Microchip ATM90E32AS – 3 canales de corriente y 1 voltaje por IC
    • Para cada canal, el medidor también puede calcular lo siguiente:
      • Poder activo
      • Poder reactivo
      • Poder aparente
      • Factor de potencia
      • Frecuencia
      • La temperatura
    • Utiliza abrazaderas de transformador de corriente estándar para probar la corriente
    • Resistencias de carga de 22 ohmios por canal de corriente
    • Incluye convertidor reductor incorporado para alimentar ESP32 y electrónica
    • 2 interrupciones IRQ y 1 salida de advertencia conectada a ESP32
    • Salidas de cruce por cero
    • Salidas de pulso de energía por IC (4 por IC x2)
    • Interfaz SPI
    • Error de medición IC: 0,1%
    • Rango dinámico IC: 6000:1
    • Selección de ganancia actual: hasta 4x
    • Deriva de referencia de voltaje típica (ppm/°C): 6
    • Resolución ADC (bits): 16

    La placa principal cuyas medidas pueden ser bien MonofásicaTrifásicas incluye un convertidor reductor para alimentar la electrónica y la placa de desarrollo ESP32, que se conecta directamente a la placa. Se pueden apilar hasta 6 placas adicionales encima de la placa principal para permitirle monitorear hasta 42 canales actuales en resolución de 16 bits, en tiempo real, ¡todo a la vez!

    La potencia se puede calcular en el software, pero el factor de potencia deberá estimarse ((voltaje*corriente)*power_factor)).

    A continuación destacamos los elementos hardware necesarios para completar la instalación:

    • Transformadores de corriente (cualquier combinación de los siguientes, o cualquier transformador de corriente que no supere los 720 mV RMS o la salida de 33 mA)
      • SCT-006 20A/25mA Micro (apertura de 6 mm – conectores de 3,5 mm)
      • SCT-010 80A/26.6mA Mini (apertura 10mm – conectores 3.5mm)
      • SCT-013-000 100A/50mA (apertura 13mm – conectores 3.5mm)
      • SCT-016 120A/40mA (apertura 16mm – conectores 3.5mm)
      • Magnelab SCT-0750-100 (conectores de tornillo: debe cortar la conexión de la resistencia de carga en la parte posterior de la placa, ya que tienen una resistencia de carga incorporada).
      • SCT-024 200A/100mA (apertura 24mm – salida terminal)
      • También se pueden usar otros, siempre que estén clasificados para la cantidad de energía que desea medir y tengan una salida de corriente de no más de 720 mV RMS, o 33 mA en la salida máxima.
    • Transformador de CA (NO CC):
      • América del Norte: Jameco Reliapro 120V a 9V AC-AC o 12v. El pin positivo debe ser de 2,5 mm (algunos son de 2,1)
      • Europa: 240 V a 9 V o 12 V CA-CA al menos 500 mA
    • ESP32 (elija uno):
      • NodoMCU 32s
      • Espressif DevKitC
      • DevKitC-32U si necesita una mejor recepción wifi (no olvide la antena )
      • Cualquier otra cosa con los mismos pines que el anterior, que generalmente son 19 pines por lado con 3v3 en la parte superior izquierda y CLK en la parte inferior derecha
    • Software (elija uno):
    Diagrama posterior del medidor de energía ESP32 de 6 canales expandible

    Conectando el ESP32

    El medidor de energía ESP32 de 6 canales expandible está hecho para que una placa de desarrollo ESP32 se pueda conectar directamente al medidor. Consulte la lista anterior para conocer las placas de desarrollo ESP32 compatibles. Siempre inserte el ESP32 con el pin 3V3 en la parte superior izquierda del medidor . Los pines inferiores se utilizan para conectar la señal de voltaje (del enchufe de alimentación) a las placas adicionales. Si el ESP32 se inserta en los pines inferiores, lo más probable es que haga un cortocircuito en el ESP32.

    El medidor de energía ESP32 de 6 canales expandible utiliza SPI para comunicarse con el ESP32. Cada placa utiliza 2 pines CS.

    La placa principal utiliza los siguientes pines SPI:

    • CLK – 18
    • miso – 19
    • MOSI – 23
    • CS1 – 5 (CT1-CT3 y voltaje 1)
    • CS2 – 4 (CT4-CT6 y voltaje 2)

    El software EmonESP/EmonCMS

    EmonESP se usa para enviar datos de medidores de energía a una instalación local de EmonCMS o emoncms.org . Los datos también se pueden enviar a un corredor MQTT a través de esto. EmonCMS tiene aplicaciones para Android e IOS. El software ESP32 para EmonESP se encuentra aquí , y se puede flashear a un ESP32 usando Arduino IDE o PlatformIO 

    ESPHome/Asistente de hogar

    ESPHome se puede cargar en un ESP32 para integrar sin problemas los datos de energía en Home Assistant . Los datos de energía se pueden guardar en InfluxDB y mostrar con Grafana. Al mismo tiempo, los datos de energía también se pueden usar para automatizaciones en Home Assistant.

    Una nueva característica en Home Assistant le permite monitorear el uso de electricidad directamente en Home Assistant . ¡También puede rastrear el uso de dispositivos individuales y/o energía solar usando el medidor de 6 canales!

    Intermitente ESPHome
    • Si tiene Home Assistant instalado, vaya a Supervisor en el menú de la izquierda, haga clic en Tienda de complementos en la parte superior, busque ESPHome – Haga clic en Instalar
    • Haga clic en Abrir interfaz de usuario web
    Complemento ESPHome
    • Haga clic en el círculo verde + en la parte inferior derecha para agregar un nuevo nodo
    • Complete el nombre (por ejemplo, ‘energy_meter’ y el tipo de dispositivo como NodeMCU-32S o Generic ESP32
    • Agregue los detalles de su wifi y haga clic en Enviar para crear el nodo
    • ESPHome se compilará; cuando esté completo, haga clic en Descargar binario
    ESPHome Descargar Binario
    • Descargue la herramienta intermitente ESPHome para su sistema operativo aquí
    • Conecte el ESP32 que pretende usar con su medidor a su computadora a través de USB (no es necesario que esté conectado al medidor en este punto, pero si lo está, no conecte el transformador de CA todavía para el medidor al mismo tiempo). vez que el ESP32 está conectado al USB)
    • En la luz intermitente de ESPHome, seleccione el puerto COM al que está conectado el ESP32
    • Seleccione el archivo .bin que acaba de descargar y haga clic en Flash ESP (si no se conecta, haga clic en ver registros para ver qué está pasando; probablemente tendrá que mantener presionado el botón de arranque derecho en el ESP32 después de hacer clic en Flash ESP)
    • ESPHome se cargará en el ESP32 con una configuración básica
    ESPInicio Flasher
    • Suponiendo que el ESP32 esté lo suficientemente cerca del AP al que desea conectarse para WiFi, ahora debería estar disponible en ESPHome dentro de Home Assistant
    • En Home Assistant, vaya a Configuración > Integraciones y Configure para ESPHome. Debe estar resaltado como Descubierto
    Cargando la configuración del medidor de energía
    • Elija una configuración de ejemplo que mejor se adapte a la configuración de su medidor de energía aquí en el sitio de ESPHome , y aquí para algunas configuraciones más avanzadas
    • En la interfaz de usuario web de Home Assistant/ESPHome, haga clic en Editar para el nodo Medidor de energía
    • Copie/pegue la configuración de ejemplo, cambie cualquier configuración aplicable, como las calibraciones actuales a los transformadores de corriente que utiliza, y haga clic en Guardar
    edición de configuración de yaml
    • En este punto, es una buena idea cerrar el cuadro de diálogo de edición y hacer clic en Validar en la pantalla principal para asegurarse de que su archivo .yaml sea válido. Corrige los errores que puedan surgir.
    • Haga clic en Cargar para guardar su configuración en el ESP32. Tenga en cuenta que si tiene 4 o más placas adicionales, puede recibir un error y quedarse sin memoria en su ESP32 si tiene muchos sensores. 
    nodo ESPHome
    • Para una mayor precisión, puede calibrar los sensores de corriente. 
    • Al actualizar los valores de los transformadores de corriente en la configuración de ESPHome, haga clic en Editar y luego en Cargar

    Obtener datos en InfluxDB

    • Si aún no lo ha hecho, instale el complemento InfluxDB en Home Assistant a través de Supervisor > Tienda de complementos
    • Abra la interfaz de usuario web y haga clic en la pestaña Administrador de InfluxDB , agregue un asistente de base de datos
    • Haga clic en la pestaña Usuarios (en Bases de datos en la misma pantalla) y cree un nuevo usuario homeassistant con Todos los permisos
    • Edite su configuración .yaml y agregue los parámetros de InfluxDB enumerados en Supervisor > InfluxDB > Documentación (menú superior) > Integración en Home Assistant
    • Reiniciar Asistente de inicio
    • Los datos ahora deberían estar disponibles en Home Assistant y disponibles en http://homeassistant.local:8086 o la IP de Home Assistant

    Obtener datos en el panel de energía de Home Assistant

    Configuración de energía de Home Assistant

    Para mostrar datos en el panel de energía de Home Assistant, debe usar ESPHome v1.20.4 o superior, y tener al menos una total_daily_energyplataforma configurada en su configuración de ESPHome. timetambién se necesita.

    Para consumo total de energía
    #Total kWh
      - platform: total_daily_energy
        name: ${disp_name} Total kWh
        power_id: totalWatts
        filters:
          - multiply: 0.001
        unit_of_measurement: kWh
    time:
      - platform: sntp
        id: sntp_time 

    ¿Dónde totalWattsestá la suma de todos los cálculos de vatios en el medidor? Vea un ejemplo de esto aquí. En el ejemplo, esto se hizo con una plantilla lambda .

    para paneles solares

    Se puede hacer lo mismo que arriba para rastrear el uso y la exportación de paneles solares. Los canales actuales en el medidor que rastrean el uso solar deben tener su propio cálculo de plantilla lambda.

    Vea este ejemplo para saber cómo puede configurar esto con el medidor de 6 canales.

    Para dispositivo individual/seguimiento de circuito

    Para hacer esto, debe tener la potencia calculada por el medidor, o una plantilla lambda que calcula los vatios por circuito. Luego puede usar una plataforma de kWh para cada uno de los canales actuales en el medidor de energía de 6 canales. Por ejemplo:

    #CT1 kWh
      - platform: total_daily_energy
        name: ${disp_name} CT1 Watts Daily
        power_id: ct1Watts
        filters:
          - multiply: 0.001
        unit_of_measurement: kWh

    ct1Wattshace referencia a la identificación del cálculo de vatios. En la configuración de ejemplo , esto es:

          power:
            name: ${disp_name} CT1 Watts
            id: ct1Watts
    Configuración en Home Assistant
    • Vaya a Configuración > Energía
    • Para la energía total, haga clic en Agregar consumo en Red eléctrica
    • El nombre de la plataforma total_daily_energy, como 6C Total kWh, debería estar disponible para elegir
    • También puede establecer un costo estático por kWh o elegir una entidad que rastree el costo de su electricidad
    • Para Dispositivos individuales, elija el nombre de los circuitos individuales, como 6C CT1 Watts Daily
    • Si monitorea sus paneles solares con un medidor de 6 canales, también puede configurar esto aquí, pero no se registrará a menos que su casa consuma energía o fluya hacia la red.

    Preguntas más frecuentes

     Obtengo una lectura baja o nada en absoluto para un CT. ¿Qué sucede? : A veces, el conector para el CT es un poco rígido y es posible que deba empujar el conector del CT en el conector de la placa hasta que haga clic. Si definitivamente está completamente adentro, es posible que el conector o algún otro lugar tenga una conexión suelta, y reemplazaremos el medidor de forma gratuita.

    ¿Funciona el medidor de energía de 6 canales en mi país?: ¡Sí! Hay una configuración para configurar el medidor a 50 Hz o 60 Hz de potencia. Deberá comprar un transformador de CA que reduzca el voltaje a entre 9 y 12 V CA. Los transformadores para EE. UU. están a la venta en la tienda circuitsetup.us.

     Obtengo un valor negativo en un canal actual. ¿Qué está pasando? Esto generalmente significa que el CT está en la parte posterior del cable, ¡simplemente gírelo!

     Obtengo un pequeño valor negativo cuando no hay ninguna carga, pero de lo contrario obtengo un valor positivo. ¿Qué está pasando?: Esto se debe a variaciones en las resistencias y los transformadores de corriente. Puede calibrar los transformadores de corriente al medidor o agregar esta sección lambda para permitir solo valores positivos para un canal de corriente:

      - platform: template
        name: ${disp_name} CT1 Watts Positive
        id: ct1WattsPositive
        lambda: |-
          if (id(ct1Watts).state < 0) {
            return 0;
          } else {
            return id(ct1Watts).state ;
          }
        accuracy_decimals: 2
        unit_of_measurement: W
        icon: "mdi:flash-circle"
        update_interval: ${update_time}

    Luego, para su cálculo de vatios totales, use ct1WattsPositive

     Los cables del CT no son lo suficientemente largos. ¿Puedo extenderlos? ¡Sí, absolutamente puedes! Se puede usar algo como una extensión de auriculares o incluso un cable de ethernet (si no le importa hacer algo de cableado). Se recomienda calibrar los TC después de añadir cualquier extensión particularmente larga.

     ¿Puedo usar este CT con el medidor de 6 canales?: ¡Lo más probable es que sí! Siempre que la salida tenga una potencia nominal inferior a 720 mV RMS o 33 mA.

     ¿Puedo usar CT SCT-024 200A con el medidor de 6 canales?: Si necesita medir hasta 200 A, no se recomienda. A 200A, el SCT-024 emitirá 100mA. Eso significa que el máximo que debe medir con el SCT-024 conectado al medidor de 6 canales es 66A . En un entorno residencial con un servicio de 200 A, es muy poco probable que utilice más de 66 A por fase sostenida. De hecho, a menos que tenga su propio transformador dedicado y una casa muy grande, es imposible.

     ¿Cómo sé si mi CT tiene una resistencia de carga?: Hay una resistencia de carga incorporada si la salida está clasificada en voltios. En este caso, se debe cortar el puente correspondiente en la parte posterior del medidor.

    Cuando se usan más de 3 tableros complementarios, ESPHome no funciona. ESPHome se quedará sin memoria de pila después de usar más de 15 sensores, más o menos. Deberá aumentar el tamaño de la memoria de pila antes de compilar. Ver detalles aquí.

    ACTUALIZACIÓN: Puede reemplazar la definición esphome: en su configuración de ESPHome para resolver este problema con lo siguiente:

    esphome:
      name: 6chan_energy_meter
      platformio_options:
        build_flags: 
          - -DCONFIG_ARDUINO_LOOP_STACK_SIZE=32768
    
    esp32:
      board: nodemcu-32s
      variant: esp32
      framework:
        type: arduino
        version: 2.0.2
        source: https://github.com/espressif/arduino-esp32.git#2.0.2
        platform_version: https://github.com/platformio/platform-espressif32.git#feature/arduino-upstream

    Fuente: https://github.com/CircuitSetup/Expandable-6-Channel-ESP32-Energy-Meter

    Conexión de un ESP32 a un PZEM004


    El Pzem004 es un módulo de prueba de monitorización eléctrica que incluye un transformador de corriente que viene además ya calibrado. El módulo puede usarse para medir la energía, el voltaje y la corriente, y luego mostrarlo en un PC u otros terminales ofreciendo una precisión del 1%.

    En la versión con display incluye un botón de restablecimiento que puede restablecer los datos de energía simplemente pulsándolo. Además, puede almacenar datos cuando se apaga, y almacenar los datos de energía acumulados antes de apagarse, por lo que es muy conveniente usarlo.

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

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

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

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

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

    Especificaciones del fabricante

    FunciónRango de mediciónResoluciónPrecisión
    Voltaje80~260V0.1V0,5%
    Actual0~10A o 0~100A*0.01A o 0.02A*0,5%
    Poder activo0~2,3kW o 0~23kW*0.1W0,5%
    energía activa0~9999.99kWh1Wh0,5%
    Frecuencia45~65Hz0,1 Hz0,5%
    Factor de potencia0,00~1,000.011%

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

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

    Compatibilidad con Arduino

    A continuación mostramos la compatibilidad con diferentes microcontroladores:

    UCMSerie de hardwareSerie de softwareNo probadoEjemplosnotas
    ATmega168XHardware Serie Software Serie
    ATmega328 ( Arduino Uno)( ✅)✔️Hardware Serie Software SerieHW Serial entra en conflicto con la salida de depuración. Sin embargo, se puede usar sin tener ninguna salida de consola serie
    ATmega2560 ( Arduino Mega​​)✔️✔️Hardware Serie Software Serie
    ESP8266( ✅)✔️SoftwareSerialHW Serial entra en conflicto con la salida de depuración Serial
    ESP32✔️HardwareSerieSW Serial no es realmente necesario ya que ESP32 tiene 3 seriales HW con pines configurables
    STM32X

    Comunicación en serie


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

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

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

    Veamos ahora un ejemplo de protocolo de comunicación:

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

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

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

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

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

    4-Leer el comando de envío actual actual

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

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

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

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

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

    Circuito Básico con ejemplo de código

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

    Compatibilidad

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

    Código arduino:

    A continuación vemos un ejemplo básico de código Arduino para probar nuestro montaje mostrando a traves del puerto serie a 115200 las medidas de potencia, tensión , corriente, frecuencia y factor de potencia a intervalos de unos 20ms.

    #include <PZEM004Tv30.h>
    
    /* Hardware Serial2 is only available on certain boards.
     * For example the Arduino MEGA 2560
    */
    #if defined(ESP32)
    PZEM004Tv30 pzem(Serial2, 16, 17);
    #else
    PZEM004Tv30 pzem(Serial2);
    #endif
    
    void setup() {
        Serial.begin(115200);
    
        // Uncomment in order to reset the internal energy counter
        // pzem.resetEnergy()
    }
    
    void loop() {
            
        Serial.print("Custom Address:");
        Serial.println(pzem.readAddress(), HEX);
    
        // Read the data from the sensor
        float voltage = pzem.voltage();
        float current = pzem.current();
        float power = pzem.power();
        float energy = pzem.energy();
        float frequency = pzem.frequency();
        float pf = pzem.pf();
    
        // Check if the data is valid
        if(isnan(voltage)){
            Serial.println("Error reading voltage");
        } else if (isnan(current)) {
            Serial.println("Error reading current");
        } else if (isnan(power)) {
            Serial.println("Error reading power");
        } else if (isnan(energy)) {
            Serial.println("Error reading energy");
        } else if (isnan(frequency)) {
            Serial.println("Error reading frequency");
        } else if (isnan(pf)) {
            Serial.println("Error reading power factor");
        } else {
    
            // Print the values to the Serial console
            Serial.print("Voltage: ");      Serial.print(voltage);      Serial.println("V");
            Serial.print("Current: ");      Serial.print(current);      Serial.println("A");
            Serial.print("Power: ");        Serial.print(power);        Serial.println("W");
            Serial.print("Energy: ");       Serial.print(energy,3);     Serial.println("kWh");
            Serial.print("Frequency: ");    Serial.print(frequency, 1); Serial.println("Hz");
            Serial.print("PF: ");           Serial.println(pf);
    
        }
    
        Serial.println();
        delay(2000);
    }

    Por supuesto este código lo podemos mejorar salvando por ejemplo los datos en una SD, enviando los datos a un proveedor de IoT y un largo etc

    Mas información en https://github.com/mandulaj/PZEM-004T-v30

    Obtener la fecha y hora del servidor NTP con ESP32


    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.

    Arquitectura jerárquica NTP con estratos

    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:

    1. El dispositivo cliente, como ESP32, se conecta al servidor mediante el Protocolo de datagramas de usuario (UDP) en el puerto 123.
    2. Luego, un cliente transmite un paquete de solicitud a un servidor NTP.
    3. En respuesta a esta solicitud, el servidor NTP envía un paquete de marca de tiempo.
    4. 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.
    5. Luego, un cliente puede analizar los valores de fecha y hora actuales.
    Funcionamiento del servidor NTP: transferencia de paquetes de solicitud y marca de tiempo

    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.

    ESP32 lee la fecha y la hora de la salida del servidor NTP en el monitor serie

    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.

    ÁreaNombre de host
    En todo el mundopiscina.ntp.org
    Asiaasia.pool.ntp.org
    Europaeuropa.pool.ntp.org
    América del nortenorteamerica.pool.ntp.org
    Oceaníaoceania.pool.ntp.org
    Sudamericasudamerica.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.

    %Adevuelve el día de la semana
    %Bdevuelve el mes del año
    %ddevuelve el día del mes
    % Yaño de retorno
    %Hhora de regreso
    %Mdevuelve minutos
    %Sdevuelve segundos
    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");
    }

    ¿Meadow es el sucesor de Netduino?


    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 .

    Meadow IoT Kickstarter

     

    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 .

    Primeros pasos con NodeMCU y Firebase


    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. 

     

    Picture of Bill of Materials

     NodeMCU ESP-12E  es 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  :

    Archivo  > Preferencias >Gestor de URL’s Adicionales de Tarjetas : http://arduino.esp8266.com/stable/package_esp8266com_index.json

    4. Seleccione la placa  pulsando en 

    Herramientas > Placa >NodeMCU 1.0

    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.
    • Aceptar las condiciones entre responsables del tratamiento de datos. Es obligatorio marcar esta casilla si vas a compartir tus datos de Analytics para mejorar los productos y servicios de Google. Más información


    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.

     

    El código empleado es el siguiente:

     

             // By CRN   mayo-2019

    #include <ArduinoJson.h>

    #include <ESP8266WiFi.h>  

    #include <FirebaseArduino.h>

    // Firebase

    #define FIREBASE_HOST «xxxxxxxxxxxxxxx.firebaseio.com»

    #define FIREBASE_AUTH «xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx»

    // Wifi

    #define WIFI_SSID «wwwwwwwwwwwww»

    #define WIFI_PASSWORD «pppppppppppppppppppp»


    void setup()

    {

    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 …

     

     

    Enchufe inteligente basado en Cayenne


    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:

    1.  Módulo de ESP8266-12E
    2.  Adaptador  DC5V 
    3.  Regulador de 3.3V 
    4. Modulo sharp S108T02 
    5. .  Sensor de temperatura  (DS18B20)
    6.   Sensor Consumo  (ACS712)
    7.  Sensor de  presencia PIR HC-SR501 
    8.  Cables y placa de prototipos.

     

    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.

     

    DS18B20

     

    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

    Rrefiriéndonos al sensor PIR  podemos conectar un sensor PIR HC-SR501   que alimentaremos a 5v DC

     

    hcsr501.PNG

     

    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.

    sensor

     

    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 yours
    char 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"

    WemoManager wemoManager;
    WemoSwitch *light = NULL;

    // configurar la depuración de cayenne
    define CAYENNE_PRINT Serial

    // 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";

    void setup() {
    Serial.begin(9600);
    pinMode(PLUG, OUTPUT);
    pinMode(pirPin, INPUT);

    //configurar cayenne
    Cayenne.begin(username, password, clientID, ssid, wifiPassword);

    // 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);
    }

    void check_time()
    {
    if(((millis()-timer_millis)/60000) > timer_time)
    {
    digitalWrite(PLUG, !digitalRead(PLUG));
    Cayenne.virtualWrite(7, !digitalRead(PLUG), TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
    timer_flag = 0;
    }
    }


    void PIRSensor()
    {
    if(digitalRead(pirPin) == HIGH)
    {
    if(lockLow)
    {
    PIRValue = 1;
    lockLow = false;
    Serial.println("Movimiento detectado.");
    digitalWrite(PLUG, HIGH);
    Cayenne.virtualWrite(7, 1, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
    delay(50);
    }
    takeLowTime = true;
    }
    if(digitalRead(pirPin) == LOW) {
    if(takeLowTime){
    lowIn = millis();takeLowTime = false;
    }
    if(!lockLow && millis() - lowIn > pause) {
    PIRValue = 0;
    lockLow = true;
    Serial.println("Movimiento terminado.");
    digitalWrite(PLUG, LOW);
    Cayenne.virtualWrite(7, 0, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
    delay(50);
    }
    }
    }

    void plugOn()
    {
    Serial.print("Conmutar 1 a encendido …");
    digitalWrite(PLUG, HIGH);
    Cayenne.virtualWrite(7, 1, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
    }

    void plugOff()
    {
    Serial.print("Conmutar 1 a apagado …");
    digitalWrite(PLUG, LOW);
    Cayenne.virtualWrite(7, 0, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
    }

    En el siguiente vídeo podemos ver el resultado de este interesante proyecto

     

     

     

     

     

    Fuente https://www.instructables.com/id/Smart-Plug/