¿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/