Guia paso a paso de despliegue con Fiware


FIWARE

 La plataforma FIWARE surgió en el año 2014 aproximadamente a partir de las propuestas del Horizonte 2020 de la Unión Europea. Se trata de un intento de estandarizar una nube que permita conectar el IoT estando ya finalizado, aunque su desarrollo continúa siendo dirigido por la propia comunidad de FIWARE. Si estudiamos el interés en esta plataforma, encontramos que su inicio fue explosivo, debido a la gran aglomeración de empresas y noticias que generaron contenido y búsquedas en su planteamiento, desarrollo y lanzamiento, que después se vio reducido. Sin embargo, podemos empezar a observar un leve repunte en el interés por esta plataforma, ya que algunas empresas como Telefónica buscan convertirlo en el estándar de facto mediante su uso, que comenzó a impulsarse en 2015

Para lograr esta conectividad de elementos y a su vez permitir la adición de otras funcionalidades, el elemento principal de la nube de FIWARE es el llamado ORION Context Broker, un intermediario que permite la conectividad a todo tipo de elementos, bien mediante su API NGSI que emplea REST, o bien mediante agentes. Estos agentes no son más que módulos intermediarios que pueden traducir otros formatos o protocolos de comunicación a NGSI, de manera que se posibilita de esta forma la conectividad con otros dispositivos que no puedan establecer comunicaciones mediante REST.

Por otro lado, aplicaciones externas de desarrolladores pueden comunicarse con Orion a través de la API REST mencionada.

Todos los componentes de FIWARE son, según su propia nomenclatura, denominados Generic Enablers (GEs), dado que proveen nuevas características al sistema que otros componentes no pueden ofrecer: persistencia de los datos, comunicación, autenticación segura, etc. 2.2.1 Cosmos Uno de los GE disponibles en FIWARE es Cosmos destinado a permitir el análisis Big Data una vez que los datos han sido almacenados de manera persistente.

Cosmos permite el análisis de los datos mediante aplicaciones del tipo map&reduce, o mediante Apache Hive. 2.3 Docker Docker es un sistema de contenedores de software, que empaqueta el software en estos contenedores, de manera que contienen todo lo necesario para funcionar. Esto facilita el despliegue y mantenimiento de las aplicaciones, ya que para que la propia aplicación funcione evitamos requerir unas dependencias previas a la máquina host, provee de una capa a la vez de seguridad y de abstracción al aislar los contenedores del resto de dicha máquina, y evita la sobrecarga de necesitar ejecutar un sistema operativo completo sobre el host.

 FIWARE sobre Docker

 De los múltiples componentes que existen en la arquitectura de FIWARE, la siguiente imagen refleja cuales son aquellos que existen como contenedores en Docker, con un color oscuro los propios de FIWARE, y en un color más claro aquellos relacionados y que también existen y por tanto es viable emplearlos en un despliegue.

Como podemos comprobar, Orion está disponible, y a su vez sería necesario emplear un contenedor de MongoDB para poder desplegar Orion y tenerlo en funcionamiento.

En este proyecto emplearemos FIWARE como intermediario para conectar nuestro escenario IoT. La razón de uso de esta plataforma se encuentra en dos motivos principales:

  • Permitir conectar un escenario IoT completo, sean cuales sean los componentes que lo conforman. Si bien nuestro escenario puede ser suficientemente pequeño como para no requerir el uso de esta plataforma, es útil de cara a la conceptualización del trabajo, su uso en un escenario de mayor tamaño y para el propio aprendizaje.
  •  La no existencia de plataformas similares que no sean privadas, por tanto, la única alternativa abierta a su uso para todo el mundo.
  • En tercer lugar, emplearemos Docker como sistema de contenedores para desplegar los componentes de FIWARE que necesitemos emplear. De esta manera, conseguiremos:
    •  Ahorrar tiempo y dificultades en el despliegue y configuración de los GE de FIWARE.
    •  Facilitar la actualización o reemplazo de componentes desplegados en contenedores.

Finalmente, hemos podido observar como el análisis de datos está a la orden del día, aplicándose estas técnicas 12 Análisis de datos de un escenario FIWARE basado en Docker 12 a ámbitos cada vez más diversos

  Instalación

En primer lugar, instalaremos Docker

https://hub.docker.com/r/fiware/orion

Docker Compose le permite vincular un contenedor Orion Context Broker a un contenedor MongoDB en unos minutos. Este método requiere que instale Docker Compose.

Considere este método si desea probar Orion Context Broker y no quiere preocuparse por las bases de datos o no le importa perder datos.

Seguimos estos pasos:

  • Creamos un directorio en su sistema en el que trabajar (por ejemplo, c: / fiware).
  • Creamos un nuevo archivo llamado docker-compose.yml dentro del directorio con el siguiente contenido:
mongo:
   image: mongo:3.6
   command: --nojournal
 orion:
   image: fiware/orion
   links:
     - mongo
   ports:
     - "1026:1026"
   command: -dbhost mongo
  • Usando la línea de comandos y dentro del directorio que creamos, escribiremos:

C:\fiware>docker-compose up

NOTA IMPORTANTE: Dado que   puede dar problemas en la ejecución  de la imagen de docker especialmente al lanzar la imagen de fiware_orion_1 , es mejor desde el directorio de despliegue lanzar el siguiente comando:

$ docker-compose up –force-recreate orion

Con respecto a –nojournal, no se recomienda para producción, pero acelera el inicio del contenedor mongo y evita algunos problemas de condiciones de carrera si el contenedor Orion es más rápido y no encuentra la base de datos lista y lista.

Lo que he hecho con este método es descargar imágenes para Orion Context Broker y MongoDB desde el repositorio público de imágenes llamado Docker Hub: es entonces cuando ha creado dos contenedores basados en ambas imágenes.

  • Después de unos segundos, debería tener su Context Broker ejecutándose y escuchando en el puerto 1026 lo cual podemos comprobar si nos vamos a la url: http// localhost: 1026/version

También desde el interfaz gráfico de dockers debe aparecer corriendo el contenedor de fiware ejecutándose:

Si desea detener el escenario, debe presionar Control + C en el terminal donde se está ejecutando docker-compose, pero se perderían todos los datos que se estaban utilizando en Orion con este método.

Pruebas iniciales

Creemos ahora una entidad tipo práctica del tipo Medida al que el vamos asociar la temperatura y humedad de una habitación.

Debemos extremar las cabeceras (headers) cuando enviamos datos a Orión Content Bróker, pues el Key Host que viene por defecto en Postman no nos sirve, para lo cual deberemos crear otra key asociándola a “application/json”. Asimismo, de igual manera lo haremos con el atributo “Content-Type”.

Y este el código para crearlo en formato Json:

{

        “id”: “Practica”,

        “type”: “Medida”,

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 25,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 50,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

Si queremos cambiar un valor se hará a través de la url http:// localhost:1026/v2/entities/Practica/attrs/    y cambiaremos el cuerpo y la cabecera

Es decir, en el código Json simplemente hemos eliminado el id y el tipo de la entidad y mantenido el resto:

    {       

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 35,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 51,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

También podemos recuperar el valor directamente desde sin usr postman llamando directamente a http://localhost:1026/v2/entities/

Asimismo, podemos cambiar no solo el valor de un atributo, sino también el tipo de dato usando PUT:

Es precisamente este el formato que podríamos usar para enviar las muestras al Content-bróker de Fiware  desde el endpoint http://192.168.1.66:1026/v2/entities/

{       

        “Temperatura”: {

            “type”: “Float”,

            “value”: 26,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 54,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

RESUMEN DE PRUEBAS FINALES

Para probar el funcionamiento del sistema:

-Iniciamos Orion Content Broker

-Iniciamos el agente Postman

-Desde Postman  configuramos la url a http://192.168.1.66:1026/v2/entities/Practica/attrs/  , usaremos el método PUT y añadiremos  a headers las keys Accept y Content-type al valor application/json

Como posibles valores de prueba podemos usar los siguientes:

{       

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 35,

            “metadata”: {}

        },

        “Humedad”: {

            “type”: “Float”,

            “value”: 51,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

Podemos cambiar solo la temperatura:

{       

        “Temperatura”: {

            “type”: “Integer”,

            “value”: 99,

            “metadata”: {}

        }

    }

O también cambiar el valor de la humedad:

{   “Humedad”: {

            “type”: “Float”,

            “value”: 51,

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            }

        }

    }

-Desde un navegador Chrome con las extensiones json y refresh nos iremos a http://192.168.1.66:1026/v2/entities/   podemos comprobar que se ha actualizado

Solución final

Dado que   puede dar problemas en la ejecución de la imagen de docker especialmente al lanzar la imagen de fiware_orion_1 , es mejor desde el directorio de despliegue lanzar el siguiente comando:

$ docker-compose up –force-recreate orion

Una vez iniciados los dos servicios comprobaremos mediante el interfaz de docker que ya podemos empezar a trabajar

Lo siguiente es crear las entidades finales usando el siguiente código en Json:

{"id": "Practica",

        "type": "Medida",

        "Temperatura": {

            "type": "Float",

            "value": 25,

            "metadata": {}

        },

        "Wifi": {

            "type": "Float",

            "value": 50,

            "metadata": {}

        },

        "Temperaturaint": {

            "type": "Float",

            "value": 28,

            "metadata": {}

        },

        "Humedad": {

            "type": "Float",

            "value": 50,

            "metadata": {

                "accuracy": {

                    "type": "Float",

                    "value": 9

                }

            }

        }

    }

Como end-point desde  postman establecemos a http://localhost:1026/v2/entities/        

Para el body no debemos olvidar insertar el código RAW en formato JSON.

Es importante configurar el token Accept como aplication/json:

Una vez creado podemos comprobar el resultado si nos vamos a http://localhost:1026/v2/entities/

En caso de problemas de conectividad deberemos cerrar el cortafuegos o configurarlo para que acepte tráfico desde fuera de la red externa.

También desde Postman podemos recuperar las últimas medidas enviadas a Orion Content Bróker.

Y una vez definidas la entidades con el método PUT vamos a ir actualizando los datos  usando la url http://192.168.1.66:1026/v2/entities/Practica/attrs/

¡No debemos olvidarnos de los headers!!

Como hemos comentado, una vez tengamos el contenido del body actualizado le daremos al botón “Put”;

Podemos comprobar mediante la consola de Orión Content Bróker las entidades, así como diferentes datos almacenados en la BBD:

sh-4.2$ ls

anaconda-post.log  bin  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

sh-4.2$ curl localhost:1026/v2/entities -s -S -H ‘Accept: application/json’ | python -mjson.tool

[

    {

        “Humedad”: {

            “metadata”: {

                “accuracy”: {

                    “type”: “Float”,

                    “value”: 9

                }

            },

            “type”: “Float”,

            “value”: 46

        },

        “Temperatura”: {

            “metadata”: {},

            “type”: “Float”,

            “value”: 26

        },

        “Temperaturaint”: {

            “metadata”: {},

            “type”: “Float”,

            “value”: 53.33

        },

        “Wifi”: {

            “metadata”: {},

            “type”: “Float”,

            “value”: -67

        },

        “id”: “Practica”,

        “type”: “Medida”

    }

]

sh-4.2$ curl localhost:1026/v2/types -s -S -H ‘Accept: application/json’ | python -mjson.tool

[

    {

        “attrs”: {

            “Humedad”: {

                “types”: [

                    “Float”

                ]

            },

            “Temperatura”: {

                “types”: [

                    “Float”

                ]

            },

            “Temperaturaint”: {

                “types”: [

                    “Float”

                ]

            },

            “Wifi”: {

                “types”: [

                    “Float”

                ]

            }

        },

        “count”: 1,

        “type”: “Medida”

    }

]

sh-4.2$ curl localhost:1026/v2/types?options=values -s -S -H ‘Accept: application/json’ | python -mjson.tool

[

    “Medida”

]

sh-4.2$ curl localhost:1026/v2/types/Room -s -S -H ‘Accept: application/json’ | python -mjson.tool

{

    “description”: “Entity type not found”,

    “error”: “NotFound”

}

sh-4.2$

   Sensor DHTXX

Para que esta práctica tenga sentido vamos a implementar un caso práctico de un sensor real basado en DHTX conectado a un ESP32 que será el que envié las medidas a ORION Content Broker que consistirán en las siguientes:

  • Temperatura exterior
  • Humedad exterior
  • Temperatura interior
  • Nivel señal wifi
  • Sensor Hall(opcional)

DHT11 y DHT22 son dos modelos de una misma familia de sensores, que permiten realizar la medición simultánea de temperatura y humedad usando además un único hilo para comunicar los datos vía serie, para lo cual ambos disponen de un procesador interno que realiza el proceso de medición, proporcionando la medición mediante una señal digital, por lo que resulta muy sencillo obtener la medición desde un microprocesador como Arduino, ESP8266 o el node MCU que usaremos.

Ambos son similares pero el DHT11 presenta una carcasa azul (es el que usaremos en la práctica), mientras que el sensor DHT22 es blanco, compartiendo además los mismos pines disponiendo de 4 patillas, de las cuales usaremos sólo 3: Vcc, Output y GND.  Como peculiaridad, la salida la conectaremos a una entrada digital, pero necesitaremos poner una resistencia de 10K entre Vic y el Pin Output, pero existen unos módulos que integran esta junto con los pines VCC, OUT y GND.

El DHT11 puede medir temperaturas entre 0 a 50, con una precisión de 2ºC, humedad entre 20 a 80%, con precisión del 5% y con una a frecuencia de muestreo de 1 muestras por segundo (1 Hz)

En clara superioridad con el dHT11, el modelo DHT22 tiene unas características mucho más profesionales.

  • Medición de temperatura entre -40 a 125, con una precisión de 0.5ºC
  • Medición de humedad entre 0 a 100%, con precisión del 2-5%.
  • Frecuencia de muestreo de 2 muestras por segundo (2 Hz)

Destacar que este tipo de sensores de temperatura (y, aún más, los sensores de humedad), son sensores con elevada inercia y tiempos de respuesta elevados. Es decir, al “lentos” para reflejar los cambios en la medición.

Conectar el DHT11   o el DHT22 a un Arduino o al Node MCU es sencillo, simplemente alimentamos desde Arduino al sensor a través de los pines GND y Vcc del mismo. Por otro lado, conectamos la salida Output a una entrada digital de Arduino. Necesitaremos poner una resistencia de 10K entre Vcc y el Pin Output.

El esquema eléctrico queda como la siguiente imagen:

Los sensores DHT11 y DHT22 usan su propio sistema de comunicación bidireccional mediante un único hilo, empleando señales temporizadas por lo que en general, lo normal es que empleemos una librería existente para simplificar el proceso.

Conexión de DHT22 a Node MCU-32S

 Como vemos el circuito para conectar al Node MCU   el sensor de temperatura y humedad DHT11 no puede ser más sencillo, pues simplemente alimentaremos con 3.3v DC tanto el DHT11 como el Node MCU   en sus pines correspondiente     sin olvidar que la salida de datos del DH11pin datos) tenemos que conectarla al pin 5 del GPIO.

Respecto a la placa de desarrollo usada es la NodeMCU-32S basada en ESP32, placa que cuenta con conectividad WiFi + Bluetooth, CP2102 a bordo y llaves. Además, todos los pines de E / S del módulo ESP-WROOM-32 son accesibles a través de los encabezados de extensión. Gracias a los ricos recursos de código abierto, admite el desarrollo de varias formas, como los comandos Lua / AT / MicroPython / Arduino / IOT, etc., lo que le ayuda a crear prototipos rápidos de aplicaciones de IoT.

Algunas características de esta placa:

  • Módulo ESP-WROOM-32 integrado
  • CP2102 integrado, convertidor de USB a UART
  • Puerto USB para entrada de energía, programación de firmware o depuración UART
  • Cabezales de extensión de 2×19 pines, rompen todos los pines de E / S del módulo
  • 2x teclas, utilizadas como reinicio o definidas por el usuario
  • Especificaciones
  • Módulo WIFI: ESP-WROOM-32
  • Procesador: ESP32-D0WDQ6
  • Flash incorporado: 32 Mbit
  • Antena: antena PCB integrada
  • Interfaz periférica: UART / GPIO / ADC / DAC / SDIO / PWM / I2C / I2S
  • Protocolo WiFi: IEEE 802.11 b / g / n
  • Bluetooth: Bluetooth 4.2
  • Rango de frecuencia: 2.4G ~ 2.5G (2400M ~ 2483.5M)
  • Modo WIFI: Estación / SoftAP / SoftAP + Station
  • Fuente de alimentación: 5 V
  • Nivel lógico: 3,3 V
  • Dimensiones: 48,26 mm x 25,4 mm

En la siguiente imagen podemos ver el montaje realizado:

 Programar el  Node MCU-32S

Para instalar el firmware en el node MCU32S   lo primero es descargar e instalar el IDE de Arduino (Arduino IDE.).

Para instalar el paquete de la placa en Archivo -> Preferencias, agregue http://arduino.esp8266.com/stable/package_esp8266com_index.json al campo URL del Administrador de tableros adicionales.

Después instalaremos la plataforma esp8266 desde Tools -> Board -> Boards Manager.

(En caso de que la placa fuese un ESP32, habría que instalar manualmente el paquete de la placa siguiendo las instrucciones aquí: https://github.com/espressif/arduino-esp32/blob/master/README.md#installation-instructions).

Lo siguiente es descargue esta biblioteca como un archivo zip  aquí.

Instalamos la biblioteca zip descargada desde Sketch -> Incluir biblioteca -> Agregar biblioteca .ZIP.

Ahora ya podemos conectar el módulo ESP a su pc a usando un USB y seleccionado su puerto (y el un módulo ESP) en el menú Herramientas.

Es interesante destaca de que puede según los casos, tengamos que añadir una regla al Cortafuegos de Windows 10 para permitir el acceso desde el ESP32 al Content Server Bróker.

Por ultimo cargaremos el siguiente código en nuestro ESP32 personalizándolo con las características de nuestra red wifi y los datos que vayamos a enviar al Content Bróker:

IMPLEMENTACION EN ESP32

#include <ArduinoJson.h>

#include <WiFi.h>

#include <HTTPClient.h>

#include <SimpleTimer.h>

#include “DHT.h”

#define DHTTYPE DHT11   // DHT 11

const int DHTPin = 5;     // what digital pin we’re connected to

DHT dht(DHTPin, DHTTYPE);

const char* ssid = “MI_RED_WIFI”;

const char* password =”CLAVE_WIFI”;

const char* servidor2=”http://192.168.1.66:1026/v2/entities/Practica2/attrs/&#8221;;

const char* servidor=”http://192.168.1.66:1026/v2/entities/&#8221;;

float dato_temp = 0.0;

float dato_rssi = 0.0;

int dato_conor = 0;

float dato_hall = 0.0;

// the following variables are unsigned longs because the time, measured in

// milliseconds, will quickly become a bigger number than can be stored in an int.

unsigned long lastTime = 0;

// Timer set to 10 minutes (600000)

//unsigned long timerDelay = 600000;

// Set timer to 5 seconds (5000)

unsigned long timerDelay = 5000;

// ledPin refers to ESP32 GPIO 23

const int ledPin = 2;

#define LED 2

#ifdef __cplusplus

extern “C” {

#endif

uint8_t temprature_sens_read();

#ifdef __cplusplus

}

#endif

uint8_t temprature_sens_read();

void setup() {

 Serial.begin(115200);

  delay(4000); // Esperar para que se configure la consola.

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) { // Comprobar la conexión.

    delay(1000);

    Serial.println(“Conectando a la red WiFi…”);

  }

  Serial.print(“Conectado a la red WiFi: “);

  Serial.println(ssid);

  Serial.println(“DHT11 test!”);

  dht.begin();

 Serial.println(“DHT11 test OK !”);

}

void loop() {

delay(2000);

 // Reading temperature or humidity takes about 250 milliseconds!

   float h = dht.readHumidity();

   float t = dht.readTemperature();

 if (isnan(h) || isnan(t)) {

     Serial.println(“!Fallo al leer sensor  DHT !”);

      //return;

    }

   else

   {

  Serial.print(“Temperatura exterior: “);

    Serial.println(t);

      Serial.print(“Humedad exterior:”);

        Serial.println(h);

   }

  //tomar valor de la temperatura interior

  // Convierte de F a ºC

  dato_temp=(temprature_sens_read()-32)/1.8;

   Serial.print(“Temperatura interior :”);

  Serial.println(dato_temp);

// medir nivel señal wifi

 dato_rssi = 0;

 for (int i=0;i < 10;i++){

 dato_rssi += WiFi.RSSI();

 delay(20);

 }

 dato_rssi = dato_rssi/10;

Serial.print(“Nivel WIFI :”);

Serial.println(dato_rssi);

 //sensor Hall

 dato_hall=hallRead();

String quote = “\””;

String mensaje=”{” +quote +”Humedad” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje +=h;

mensaje  +=”,” +quote +”metadata” +quote +”:{” +quote +”accuracy” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:9}}},” +quote +”Temperatura” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje +=  t;

mensaje += “,” +quote +”metadata” +quote +”:{}},” +quote +”Temperaturaint” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje += dato_temp;

mensaje +=”,” +quote +”metadata” +quote +”:{}},” +quote +”Wifi” +quote +”:{” +quote +”type” +quote +”:” +quote +”*” +quote +”,” +quote +”value” +quote +”:”;

mensaje += dato_rssi;

mensaje += “,” +quote +”metadata” +quote +”:{}}}”;

//calculo longitud del mensaje

int  mm= mensaje.length()+38;

String longitud= (String) mm;

 //Send an HTTP POST request every 10 minutes

if ((millis() – lastTime) > timerDelay) {

    //Check WiFi connection status

    if(WiFi.status()== WL_CONNECTED){

     // Mostrar mensaje de exito y dirección IP asignada

     Serial.println();

     Serial.print(“Conectado a:\t”);

     Serial.println(WiFi.SSID());

     Serial.print(“IP address:\t”);

     Serial.println(WiFi.localIP());

     Serial.println();

     Serial.print(“**PRUEBA DE ENVIO DE GET:\t”);

     Serial.println(“”);

    //prueba de GET

    HTTPClient http;

    // Your Domain name with URL path or IP address with path

    http.begin(servidor);

    int httpResponseCode = http.GET(); //POST(salidajson);

     String payload = http.getString();

    Serial.println(“respuesta devuelta al comando HTTP.getString( Payload): “);

    Serial.println(payload);

    Serial.print(“HTTP Response code: “);

    Serial.println(httpResponseCode);

    Serial.println();

     http.end();

    delay(10000);

 Serial.print(“**PRUEBA DE ENVIO DE POST:\t”);

 Serial.println(“”);

   digitalWrite(ledPin, HIGH);

   // you’re connected now, so print out the data

   Serial.println();

   Serial.println(“Starting connection to server…”);

   http.begin(servidor2);

  Serial.print(“Enviando mensaje JSON: “);

  // Specify content-type header

  http.addHeader(“Accept”, “application/json”);

  http.addHeader(“Content-Type”, “application/json”);

  http.addHeader(“Content-Length”,longitud);

 Serial.print(“Longitud del mensaje=”);

 Serial.println(longitud );

 Serial.println(“Contenido del mensaje=”);

 Serial.println(mensaje );

int  httpResponseCode2 = http.POST(mensaje);

  Serial.print(“HTTP Response code: “);

  Serial.println(httpResponseCode2);

  String payload2 = http.getString();

  Serial.println(payload2);

  Serial.println();

  http.end();

  salidajson=””;

 digitalWrite(ledPin, LOW);

 delay(10000);

    }

    else {

      Serial.println(“WiFi Disconnected”);

    }

    lastTime = millis();

  }

}

A continuación, mostramos un ejemplo de salida por consola del programa anterior funcionando:

Freeboard

Una vez que ya tenemos datos en la plataforma Fiware, necesitamos no solo que haga de conexión entre diferentes dispositivos, sino que buscamos ver y entender que nos están diciendo nuestros equipos. Hacer esto, hoy por hoy, requiere al menos un cierto manejo de lenguajes de programación como podría ser por ejemplo node-js. Sin embargo, hay quienes están trabajando porque esto no sea así como es el caso de Freeboard, un producto de Bug Labs, una Startup de Nueva York. “A damn-sexy, open source real-time dashboard builder/viewer for IOT and other web mashups”.

Freeboard seguramente no sea la plataforma de aplicaciones más sofisticada técnicamente que existe para el Internet de las Cosas pues estamos ante un panel web que podríamos decir “sencillo” y que muestra la información de los diferentes dispositivos que tengamos conectados en tiempo real.

Destacar también que es una plataforma Open Source, cuyo código fuente está disponible en GitHub donde allí tenemos el código fuente de la parte cliente.

Según sus fundadores, “Freeboard.io trata de convertir el Internet de las Cosas en un entorno mucho más sencillo, simple y accesible para todo el mundo”.

No necesitamos nada más para hacer funcionar tus dispositivos, aunque se podría potenciar mucho el sistema mediante la conexión por ejemplo con dweet.io o IFTTT.com, creando de una forma rápida y sencilla una robusta aplicación IoT. También podemos mezclar plataformas y dispositivos, levantando un excelente entorno desde donde controlar nuestros equipos.

Trabajar con ella es muy sencillo: Freeboard puede ejecutarse bien en un entorno cloud ( freeboard.io)   con  un plan gratuito con 30 días de duración. Una vez registrados podemos crear paneles indicadores configurados a nuestro gusto para visualizar la información, aunque primero habrá que añadir como fuente de datos(datasource) y sobre estos datos montar nuestro propio dashboard.

Otra forma de trabajar podría ser descargando o clonando el repositorio de Github, pero, aunque podría parecer trivial no se trata de abrir “index.html” simplemente en su navegador favorito pues tendremos que tener una servidor web (por ejemplo, Apache web server), tener node-js instalado y por supuesto tener Freeboard correctamente configurado especialmente todo lo relacionado con los CORS( Access-Control-Allow-Origin) donde por cierto la extensión de Chrome  “Allow Cors”  podría ser muy útil.

Como esta instalación podría ser problemática, lo más sencillo es cargar una imagen de docker con Freeboard pues así tendremos todo bien configurado y no tendremos ningún problema a la hora de ejecutar este entorno

No debemos por cierto antes de ejecutar dicha imagen de Freeboard de Docker instalar node-js, necesario para que todos los componentes funcionen correctamente.

Los pasos a seguir para hacer funcionar localmente Freeboad localmente:

  • Instalar node-js (si aún no lo tiene instalado)
  • Instalar Docker en la maquina
  • Crear  y ejecutar el contenedor de Freeboard(https://github.com/h6w/freeboard-docker  ) donde ejecutaremos el resto de contenedores Dockers, para lo cual simplemente desde el directorio desde line de comandos ejecutaremos:docker run --name myfreeboard -p 8080:80 -d tudorh/freeboard (este comando expondrá una instalación de Freeboard en  http://localhost:8080 )
  • Ahora nos iremos a Docker para comprobar que está corriendo en el puerto 8080 el servidor de Freeboard.
  • Ahora nos iremos a la dirección expuesta : http://localhost:8080/
  • Lo más importante es configurar antes de nada el Datasource que es de desde donde se obtendrá toda la información que se mostrará en el dashboard.
    • En Type seleccionaremos JSON
    • En Name elegiremos el nombre que deseemos
    • End headers añadiremos Accept: application/json
  • Una vez hecho esto pulsaremos en el símbolo de refresh en la parte superior y ya debería verse reflejado la hora de esa actualización.

Ahora pulsaremos en “ADD PANE” para crear el entorno donde mostraremos gráficamente las diferentes variables que queremos mostrar en nuestro panel:

  • Temperatura exterior
    • Humedad exterior
    • Temperatura interior
    • Nivel señal wifi
  • Temperatura exterior:

Lo ideal es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.

Asimismo, Freeboard permite añadir un histórico usando el tipo Sparkline.

Por ejemplo, así se mostraría en tiempo real como fluctúa la temperatura exterior:

  • Temperatura interior:Lo ideal, igual que con la temperatura exterior es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
  • Señal wifi:Lo ideal, es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.
  • Humedad:Lo ideal, es usar un controlador tipo gauge definiendo el origen de datos, los valores mínimos –máximo así la unidad y el descriptivo.

También podemos mostrar la misma información en modo texto:

Es interesante además de mostrar un histórico, de modo que al igual que se ha hecho con la temperatura exterior lo haremos con la humedad exterior usando el control Sparkline:

Para terminar, usaremos un Pointer para mostrar un valor de la humedad mas visible.

Con todos estos cambios pulsaremos en “SAVE FREEBORAD” para almacenar en un fichero Json en local todos los cambios realizados

El aspecto de como queda el panel es el siguiente:

Podemos comprobar que la información es actualizada con la fuente de datos, usando el monitor serie de Arduino:

Extensiones de Chrome

Sin tener instalado Freeboard, aparte de la herramienta Postman (fundamental para depurar los formatos de envió), hay dos herramientas muy interesantes para monitorizar las variables almacenadas en Fiware alimentado por los datos  que nos está enviando nuestra placa ESP32 y el sensor DHT11.

Las dos extensiones de Google Chrome que han resultado muy útiles son las siguientes:

Json Handle

Esta extensión es no solo un browser sino también un editor documentos JSON permitiendo ver de una sola vez de una manera muy visualmente atractiva los datos en nuestro caso de los diferentes sensores.

Easy Auto Refresh

Esta extensión permite recargar la página a intervalos definidos para refrescar los datos y poder mostrar los cambios, lo cual es muy útil para no tener que estar constantemente refrescando la  página desde obtenemos la información del Content bróker ( en nuestro caso http://192.168.1.66:1026/v2/entities/ )

  Información útil

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

IoT Cloud


En este post vamos a a ver conectar una placa MKR1000 (o MKR 1010) a la nube de Arduino IoT  de modo que podremos controlar y supervisar  las entradas  o salidas de estas places a través de Internet utilizando el sitio web de Arduino IoT Cloud.

Para ello simplemente seguiremos tres pasos,:

  • Agregaremos nuestra placa a Arduino IoT Cloud como una cosa( Thing) , es decir  una representación de nuestra placa en la nube.
  • A continuación, le daremos a nuestra cosa un conjunto de propiedades que representan sensores, LEDs, motores y muchos otros componentes en el proyecto al que queremos acceder desde la nube.
  • Subiremos a nuestra placa el código que nos propone Arduino IoT Cloud personalizado para nuestra red wifi

Si le  interesa  como hacerlo , vera que es muy sencillo,  pues como vamos a ver  casi todo esta hecho, pero antes, veremos las semejanzas   y diferencias de ambas placas  y después veremos paso a paso como lograrlo.

Arduino MKR1000

Arduino MKR1000 es una placa diseñada para ofrecer una solución práctica y rentable para cualquiera que busque agregar conectividad WiFi a sus proyectos con una experiencia mínima en redes.  Su precio no es excesivo  teniendo en cuenta que integra la conectividad  wifi (unos 38€ en Amazon)

El diseño incluye un circuito de carga Li-Po que permite que el Arduino MKR1000 funcione con una  batería o 5V externos, cargando la batería Li-Po mientras funciona con energía externa: el cambio de una fuente a otra se realizara automáticamente  y por tanto no tendremos que preocuparnos de nada más.

El MKR1000 tiene un procesador Arm Cortex-M0 + de 32 bits  corriendo a 2.4ghz ,  y cuenta con  el rico conjunto habitual de interfaces de E / S . Sin duda uno de su punto fuertes  es que integra  WiFi de baja potencia con un chip criptográfico para una comunicación segura.

Una de las grandes ventajas  es que puede programarlo utilizando el software Arduino (IDE) al que estamos  todos familiarizados  siendo muy  fácil de usar.

Todas estas características hacen de esta placa la opción preferida para los proyectos emergentes que funcionan con baterías de IoT en un factor de forma compacto.

 Desafortunadamente, Arduino aún no lo ha integrado en su IDE, por lo que la configuración no es tan fácil como lo es para la mayoría de sus otras placas ,sin embargo, siga algunos pasos para configurarlo y podrá ponerlo a prueba: –

  • Instale el último IDE de Arduino 
  •  Haga clic en Herramientas | Puerto – Seleccione el puerto COM (no se mostrará ninguna placa) 
  • Ahora haga clic en Herramientas | Junta | Obtener información del tablero. Verá información con “Tablero desconocido” como tipo
  •  A continuación, haga clic en Herramientas | Junta | Gerente de la Junta
  • Instale el paquete Arduino SAMD Boards (ARM Cortex-M0 + de 32 bits) que incluye MKR WiFi 1010, Genuino Zero, MKR1000, etc.
  • Reinicie el IDE para que surta efecto el nuevo paquete de placa
  • En este punto, puede desconectar y volver a conectar la placa para que el IDE lo vea
  • Haga clic en Herramientas | Información del tablero; esta vez verá “Arduino / Genuino MKR1000” !!! ¡No olvides este siguiente paso o no podrás subir tu boceto!
  • Haga clic en Herramientas | Tablero: 
  • Seleccione Arduino / Genuino MKR1000 . En este punto, yaa puede cargar un boceto en su tablero  como  por ejemplo el que vamos a ver en este post para controlar un led desde Internet

Como   se puede  ver en la imagen de  mas abajo , los pines disponibles son casi los mismos que los que solemos tener en un Arduino convencional  : los pines A0  a A6   para entradas  y salidas analógicas , los pines 0 al 14  para entradas salidas binarias y los típicos de alimentación externa(VIN,VCC 5v y GND)   , la referencia (AREF )  y  RESET.

Si le interesa esta placa la puede comprar en Amazon por unos 38€

Arduino MKR1010

Hablamos ahora de una placa muy similar a la anterior   algo mas barata que la la Mkr1000 ( unos  33€  en Amazon , es decir unos 5€ mas barato que la MKR1000)

Esta placa  está compuesta por tres bloques principales:

  • Microchip ATSAMD21 MCU basado en un procesador Arm Cortex-M0 
  • Serie u-blox NINA-W10 de baja potencia 2.4GHz IEEE 802.11 b / g / n Wi-Fi ECC508 CryptoAuthentication
  • El diseño incluye un Li-Po Circuito de carga que permite que Arduino MKR WiFi 1010 funcione con batería o 5V externos, cargando la batería Li-Po mientras funciona con energía externa. El cambio de una fuente a otra se realiza automáticamente.

Como  vemos , la gran diferencia  es  el Microcontrolador que es menos potente  pues  cuenta con el  Microchip ATSAMD21 (procesador Arm Cortex-M0 +)  en contraste  con el Arm Cortex-M0 + de 32 bits  corriendo a 2.4ghz del MKR100.

Respecto a la conectividad,  es similar al  MKR1000  contando con WiFi u-blox NINA-W102 (ESP32)

La alimentación se puede hacer con una fuente de alimentación externa de 5v DC  bien por  USB  o bien por el pin VIN , pero  cuenta   además  con conexión para Batería compatible (*) Li-Po de celda única, 3,7 V, 700 mAh  siendo el voltaje mínimo de funcionamiento del circuito 3,3 V .

 

Como   se puede  ver en la imagen de  mas abajo , los pines disponibles son casi los mismos que los que solemos tener en un Arduino convencional  ( y los mismo que el  MKR100)   : los pines A0  a A6   para entradas  y salidas analógicas , los pines 0 al 14  para entradas salidas binarias y los típicos de alimentación externa(VIN,VCC 5v y GND)   , la referencia (AREF )  y  RESET.

Si le interesa esta placa la puede comprar en Amazon por unos 33€

 

1. Crear una cosa y controlar un LED a través de la nube

Para empezar vamos a crear un circuito simple que consiste en un LED conectado a la placa Arduino MKR1000  (o MKR 1010).

Como se muestra en el esquema, simplemente conectaremos la pata positiva del LED al Pin digital 2 de la placa y la pata negativa a tierra a través de una resistencia de 150 ohmios.

Observe que la potencia de la placa de pan proviene del Vcc, no del pin de 5V de la placa MKR1000 pues  si lo conectamos al pin de 5V, podríamos dañar la placa  cuando por ejemplo  agreguemos  un botón.

An LED connected to Digital Pin 2 of an Arduino MKR1000

Ahora que hemos conectado nuestro LED, podremos  habilitado para IoT pero antes de eso, tendremos que configurar una placa Arduino para que pueda comunicarse con la nube.

Para este proyecto, podemos elegir un MKR1000 o un MKR  1010.  Una vez que nuestra placa está configurada, necesitaremos crear a una cuenta Arduino  ( ai aún no la tenemos creada, y hecho ya nos iremos a Arduino IoT Cloud y comenzaremos  con el  viaje a través de IoT 

Asi pues nos  iremos  Arduino IoT Cloud que comenzara con el proceso guiado de introducción  que nos ayudará a configurar nuestra placa, darle un nombre e instalar las claves que le permitirán conectarse de forma segura a nuestra nube mediante un canal cifrado.

Getting Started Wizard
Este es el asistente de introducción
Select a supported board
Seleccionaremos  una placa compatible
Let's make it connect securely to IoT Cloud
Haremos que se conecte de forma segura a IoT Cloud
Time to plug our board into our computer, it will be recognised automatically
Es hora de conectar nuestra placa a nuestro ordenador, se reconocerá automáticamente
Let's give it a name...
Vamos a darle un nombre…
and click on CONFIGURE
Ahora  haremos clic en CONFIGURAR
After a little time all is done, and we can get BACK TO CLOUD
Después de un poco de tiempo todo está hecho, y podemos llegar DE VUELTA A CLOUD

Al hacer clic en el botón “BACK TO CLOUD” podremos crear nuestra primera Cosa.

Nuestra placa MKR recién configurada se seleccionará automáticamente para ser asociada con nuestra Cosa, por lo que todo lo que queda es darle un nombre. Elegimos llamarlo IoTCloud_Tutorial_Thing pero puede nombrarlo como desee.

 

Our board is preselected ->
Nuestra placa está preseleccionada ->
Let's name it...
Vamos a nombrarlo…
and click the CREATE button
y haga clic en el botón CREAR

Ahora seremos redirigidos a nuestra vista de edición de Thing, donde podremos crear y modificar sus Propiedades – la representación de sensores y actuadores a los que queremos acceder a través de la nube.

Nuestro objetivo es encender y apagar el LED a través de Cloud cuando alternamos un interruptor gráfico en nuestro navegador. Para hacerlo, tenemos que crear una propiedad, así que haga clic en el botón + como se muestra en la imagen de abajo.

Time to create our first Property
Es hora de crear nuestra primera propiedad

Usaremos como nombre significativo que lo represente  (este nombre se reflejará en el nombre de la variable que usaremos en el boceto) como por ejemplo dado que va ser un led   de  “.light"

El Tipo de esta propiedad debe ser “ON/OFF (Boolean)”.

Our properties details are set, let's CREATE it
Nuestros detalles de propiedades están establecidos  así que vamos vamos a crearlo

Podemos dejar El permiso establecido en “Leer y escribir” – para que podamos encender y apagar el LED desde el navegador. 

También deje Actualizar en “Cuando cambie el valor”, lo cual  asegurará de que siempre que el valor de la propiedad/variable cambie dentro del boceto de la placa, dicho valor se enviará inmediatamente a la nube.

Finalmente haga clic en CREAR.

Property Edit view
Vista de edición de propiedades
Dashboard view
Vista del panel

 

Desde la vista Editar podemos hacer clic en “EDITAR CODE”. Esto nos redirigirá al Editor mostrando un boceto ya hecho que se ha generado para nuestra Cosa.

En este caso de ejemplo se generará el siguiente código que tendremos que cargar en nuestra placa:

 

*
Sketch generated by the Arduino IoT Cloud Thing "testThing"
https://create.arduino.cc/cloud/things/d276ab77-67cb-420b-9ea4-bd34cdf385d9



Arduino IoT Cloud Properties description



The following variables are automatically generated and updated when changes are made to the Thing properties



bool switchState;
int potentiometerValue;
bool ledState;



Properties which are marked as READ/WRITE in the Cloud Thing will also have functions
which are called when their values are changed from the Dashboard.
These functions are generated with the Thing and added at the end of this sketch.
*/



include "thingProperties.h"



include



define LED_PIN 2



define POT_PIN A1



define BUTTON_PIN 5



FTDebouncer buttons;



void setup() {
pinMode(LED_PIN, OUTPUT);
buttons.addPin(BUTTON_PIN, LOW);
buttons.init();



/*
The following function allows you to obtain more information
related to the state of network and IoT Cloud connection and errors
the higher number the more granular information you’ll get.
The default is 0 (only errors).
Maximum is 3
*/
setDebugMessageLevel(2);



// Initialize serial and wait for port to open:
Serial.begin(9600);
// This delay gives the chance to wait for a Serial Monitor without blocking if none is found
delay(1500);



// Defined in thingProperties.h
initProperties();



// Connect to Arduino IoT Cloud
ArduinoCloud.begin(ArduinoIoTPreferredConnection);
}



void loop() {
buttons.update();
ArduinoCloud.update();
// Your code here
int angleSensor = analogRead(A1);
angle = map(angleSensor, 0, 1023, 0, 270);
}



void onLightChange() {
digitalWrite(LED_PIN, light);
Serial.print("The light is ");
if (light) {
Serial.println("ON");
} else {
Serial.println("OFF");
}
}



void onPinActivated(uint8_t pinNr) {
// do something according to the _pinNR that is triggered. For instance:
Serial.println(pinNr);
toggle = !toggle;
}



void onPinDeactivated(uint8_t pinNr) {
// do something according to the _pinNR that is triggered. For instance:
Serial.println(pinNr);
}

 

El boceto se denominará exactamente igual que nuestra Cosa, más la fecha de creación y, finalmente, un número si ya existe un boceto con nombre .

Aparte del archivo .ino principal , verá tres archivos más:

  • ReadMe.adoc: se trata de un archivo de texto sin formato que contiene información sobre el boceto, el autor y el propio proyecto.
  • thingProperties.h: este es el código generado por Arduino IoT Cloud cuando agregamos nuestra propiedad. No necesitamos editar este código, pero es útil verlo ya que muestra qué variablesde nuestro archivo de boceto principal (.ino) se sincronizarán con la nube.light
  • En la Pestaña Secreto: Detalles de la conexión WiFi,  esta pestaña nos permite rellenar los valores  como  son el nombre y la contraseña de la red WiFi a la que se conectará nuestra placa.SECRET_SSIDSECRET_PASS

 

Vamos a profundizar en cada línea de este boceto para entender lo que hacen los difrentes ficheros qeu lo compone:

Fichero thingProperties.h

#include <ArduinoIoTCloud.h>

Importa la biblioteca ArduinoIoTCloud, que es necesaria para sincronizar nuestras variables de boceto locales con sus propiedadesde IoT Cloud.

#include <Arduino_ConnectionHandler.h>

El WiFiConnectionManager se utiliza para gestionar la conexión WiFi y la reconexión sin problemas.

char ssid[] = SECRET_SSID;
char pass[] = SECRET_PASS;

Estos valores se extraen de la pestaña Secreto.

#define THING_ID "d276ab77-67cb-420b-9ea4-bd34cdf385d9"

El código de identificación único de la cosa.

void onLightChange();

Esta línea declara una función que se llamará cada vez que se cambia el valor de nuestra propiedad en el panel. Este tipo de función se conoce como devolución de llamada.light

bool light;

Declaración de la variable.light

void initProperties()

Esta función se llamará dentro del bloque de nuestro archivo *.ino. setup()

ArduinoCloud.setThingId(THING_ID);

Le dice a nuestro boceto a qué cosa conectarse.

ArduinoCloud.addProperty(light, READWRITE, ON_CHANGE, onLightChange);

Este código pues le indica al sketch que trate la variable como una propiedad de nuestra cosa y que ejecute la función de devolución de llamada cada vez que se cambie el valor de propiedad de Arduino IoT Cloud.

Los permisos se establecen para esta propiedad porque esto es lo que seleccionamos al crear esta propiedad.lightonLightChangeREADWRITE

 

El resto de codigo es  el siguiente:

void onLightChange();

bool toggle;
int angle;
bool light;

void initProperties(){
ArduinoCloud.setThingId(THING_ID);
ArduinoCloud.addProperty(toggle, READ, ON_CHANGE, NULL);
ArduinoCloud.addProperty(angle, READ, ON_CHANGE, NULL, 3.000000);
ArduinoCloud.addProperty(light, READWRITE, ON_CHANGE, onLightChange);
}

WiFiConnectionHandler ArduinoIoTPreferredConnection(ssid, pass);

 

Este código Inicializa Connection Manager con el nombre de punto de acceso WiFi (SECRET_SSID) y la contraseña (SECRET_PASS)que establecemos en la pestaña Secreto

 

Fichero *.ino

Al igual que en cualquier Arduino Sketch, hay dos funciones principales, y . Se llama una sola vez; cuando el croquis se inicia o se restablece. El se ejecuta continuamente siempre y cuando la placa esté siendo alimentada.void setup(){...}void loop() {...}setup()loop()

#include "thingProperties.h"

Importa variables y funciones declaradas en thingProperties.h, así como en otras bibliotecas importadas.

setDebugMessageLevel(2);

Establece el nivel deseado de mensajes de registro que se imprimirán en el Monitor serie. En este momento el nivel se establece en 2, pero podemos cambiarlo de0 (que registra sólo errores) hasta 3 (que registra TODO!). Si algo no está funcionando con la conexión a WiFi o Cloud, será más fácil encontrar el problema si se establece en un nivel superior. Por ahora, podemos dejarlo como está.

Serial.begin(9600);

Inicializa el monitor seriepara imprimir lo y leer deél.

delay(1500);

Espera 1,5 segundos para dar al Monitor serie el tiempo necesario para inicializar.

initProperties();

Inicializa las propiedades tal como se definen en thingProperties.h.

ArduinoCloud.begin(ArduinoIoTPreferredConnection);

InicializatheArduinoCloudusingthe mencionado anteriormente ConnectionManager.

Dentro de lo que encontramosloop()

ArduinoCloud.update();

Maneja muchas cosas en segundo plano, incluyendo la sincronización de los valores de las propiedades entre la nube y la placa, checkingtheconnectiontonetworkyCloudy otra lógica. Si el valor de una propiedad cambia en el boceto, la biblioteca la detectará automáticamente y notificará a la nube, de modo que dicho valor se reflejará en nuestro Arduino IoT Cloud Dashboard. Del mismo modo, cuando se cambia el valor de una propiedad en el panel, la biblioteca actualizará el valor correspondiente en el dispositivo.

void onLightChange() {...}

La implementación de nuestra devolución de llamada que se llamará en cualquier momento que cambie el valor de la propiedad. Aquí agregaremos cualquier código que queramos que se ejecute cuando cambie la propiedad de nuestro panel.light

Y ahora, con el fin de encender y apagar el LED desde el Arduino IoT Cloud Dashboard, necesitamos escribir algunas líneas de código. Primero definimos el pin al que está conectado nuestro LED. Agregue este código justo encima de la funciónsetup()

#define LED_PIN 2

En la función, necesitamos inicializar este pin para que sea una SALIDA:setup()

pinMode(LED_PIN, OUTPUT);

Por último, en la función, agregamos un poco de lógica para rastrear el estado en el monitor serie y para encender y apagar el LED. Tenga en cuenta que esta función de devolución de llamada se genera automáticamente cada vez que se agrega una nueva propiedad con permisos de lectura y escritura.onLightChange()light

void onLightChange() {
    digitalWrite(LED_PIN, light);
    Serial.print("The light is ");
    if (light) {
        Serial.println("ON");
    } else {
        Serial.println("OFF");
    }
}

 

Pruebas

Una vez preparados los ficheros  anteriores  podemos cargar el boceto desde el IDE de Arduino haciendo clic en el botón Cargar y luego abra el Monitor Serie a la izquierda para ver si todo funciona.

Debido a que hemos establecido el nivel de registro en 2, el Monitor serie nos mostrará información sobre el progreso de nuestra placa que se conecta a IoT Cloud.

Una vez conectado con éxito a nuestro WiFi, logró obtener una dirección e inició un enlace seguro, la placa se conectará a IoT Cloud y comenzará a intercambiar datos con ella.

[ 144313 ] Connecting to "FT Mobile"
[ 148284 ] Connected to "FT Mobile"
[ 148284 ] Acquiring Time from Network
....
[ 148690 ] Network Time: 1550057496
[ 148910 ] Connecting to Arduino IoT Cloud...
[ 152212 ] Connected to Arduino IoT Cloud

Si alguno de los pasos anteriores falla, recibiremos un error. Si eso sucede, podemos restablecer el tablero e intentarlo de nuevo. Si los pasos anteriores se han seguido cuidadosamente, es un caso poco probable 🙂

Al hacer clic en el botón GO TO IOT CLOUD seremos redirigidos a la página de nuestra Cosa en Arduino IoT Cloud. Desde aquí haremos clic en el botón del panel.

Dasboard view
En la Vista de Dasboard ya deberíamos ver un widget que muestra el estado de la propiedad que creamos, y debe establecerse en OFF.light

Vamos a hacer clic en él un par de veces y vamos a ver el LED encender y apagar… y ON… y OFF de nuevo…

¡Misión cumplida!