Primeros pasos con Fiware


FIWARE es una iniciativa de código abierto que define un conjunto universal de estándares para la gestión de datos de contexto que facilitan el desarrollo de soluciones inteligentes para diferentes dominios como Smart Cities, Smart Industry, Smart Agrifood y Smart Energy.

En cualquier solución inteligente existe la necesidad de recopilar y gestionar la información del contexto , procesando esa información e informando a los actores externos, permitiéndoles actuar y, por tanto, alterar o enriquecer el contexto actual. El componente FIWARE Context Broker es el componente central de cualquier plataforma “impulsada por FIWARE”. Permite al sistema realizar actualizaciones y acceder al estado actual del contexto.

El Broker de contexto, a su vez, está rodeado por un conjunto de componentes de plataforma adicionales , que pueden proporcionar datos de contexto (de diversas fuentes, como un sistema CRM, redes sociales, aplicaciones móviles o sensores de IoT, por ejemplo), lo que respalda el procesamiento, análisis y visualización de datos o brindar apoyo al control de acceso a los datos, la publicación o la monetización.

¿POR QUÉ UTILIZAR FIWARE?

Todas las interacciones entre las aplicaciones o los componentes de la plataforma y Context Broker se llevan a cabo utilizando la API RESTful de FIWARE NGSI , un estándar abierto simple pero poderoso.

  • SENCILLO:Proporciona una interfaz intuitiva fácilmente accesible para cualquier desarrollador web.
  • PODEROSO:Admite suscripción / notificación, consultas geográficas, federación, paginación y datos vinculadosnorte
  • ESTÁNDAR ABIERTO:Las especificaciones actuales de FIWARE NGSI son públicas y libres de regalías y se alinean con las  especificaciones NGSI-LD publicadas por ETSI.

La naturaleza de estándar abierto de FIWARE NGSI ofrece a los programadores la capacidad de trasladar sus aplicaciones a diferentes plataformas “Powered by FIWARE” y un marco estable para el desarrollo futuro . Se puede agregar fácilmente funcionalidad adicional a una solución inteligente simplemente usando componentes adicionales de FIWARE o de terceros para los cuales se resuelve la integración con el componente FIWARE Context Broker. Esta integración se simplifica ya que todos los componentes cumplen con la interfaz estándar FIWARE NGSI, lo que elimina el bloqueo del proveedor . La naturaleza basada en componentes de una solución basada en FIWARE permite rediseñar la arquitectura a medida que la solución evoluciona de acuerdo con las necesidades comerciales.

El ecosistema de FIWARE Lab es rico en información de contexto de dispositivos ubicados en Smartcities conectadas para que nuestros desarrolladores puedan integrarlos en sus aplicaciones o productos. La siguiente imagen muestra las principales ciudades con dispositivos públicos disponibles en la actualidad. Y estos son solo los primeros, ¡muchos llegarán pronto!

Internet de las cosas FI-WARE

Los desarrolladores pueden consumir fácilmente esta información a través de la instancia global segura de Orion Context Broker. Descubra cómo hacerlo en el anexo de este tutorial.

Sin embargo, creemos que podemos impulsar nuestro ecosistema si contribuyes conectando tus propios dispositivos , sean caseros, comerciales o lo que sea.¿Qué obtendrá a su vez? Podrá crear fácilmente aplicaciones, servicios o simplemente paneles de control útiles gracias al extenso catálogo de FIWARE GEs. Además, puede compartirlo con otros desarrolladores, que pueden hacer que funcione para usted.

1: Comprender las opciones para conectar dispositivos al laboratorio FIWARE

Básicamente, existen 3 formas o escenarios para conectar dispositivos a FIWARE Lab:

A) ContextConsumer : si está conectando un dispositivo que solo consume información de FIWARE Lab, como un reloj inteligente, lentes inteligentes, un dron que toma decisiones sobre las condiciones de los recursos de FIWARE Lab, etc., solo necesita conectarse a la instancia global de Orion ContextBroker como descrito en este manual . Además, hay un ejemplo práctico en el anexo de este artículo al final.

Por el contrario, si está conectando dispositivos que brindan información a FIWARE Lab y posiblemente reciben comandos, entonces tiene dos opciones según la escala y el alcance de su solución:

B) Grandes despliegues de IoT , especialmente si los dispositivos son sensores o puertas de enlace 2G / 3G autónomos. En este caso, recomendamos utilizar nuestra solución de nivel de operador “DCA-IDAS Backend Device Management GE”. Recomendamos este enfoque incluso cuando comienza con un número limitado de dispositivos

C) Implementaciones limitadas de IoT : en este caso, puede omitir el componente DCA y alimentar un ContextBroker directamente como lo haría cualquier otro ContextProvider, siempre que pueda desarrollar las operaciones NGSI REST en su dispositivo o en una puerta de enlace IoT cercana.

El escenario (A) no es realmente específico de IoT, ya que sus dispositivos consumirán información de contexto, como lo haría cualquier otra aplicación.

Para las opciones (B) y (C), la mejor manera de comenzar es usar una Raspberry PI como IoT Gateway y nuestra herramienta Figway de código abierto para RaspberryPI . Puede conectar dispositivos comerciales a Raspberry PI (Z-wave se explica en este artículo) o incluso dispositivos basados ​​en Arduino conectados al PI GPIO. Hay un buen tutorial para eso aquí.

Si no está utilizando una Raspberry Pi en absoluto, aún puede usar esta publicación para comprender los conceptos básicos, analizar el código fuente de los comandos (C / C ++) y otros archivos para que pueda adaptar fácilmente el código y la filosofía a su propia plataforma .

2: Instalar y configurar el software Figway en una Raspberry PI

Acceda al repositorio GIT en: https://github.com/telefonicaid/fiware-figway/ 

Obtenga una Raspberry PI con el último sistema operativo Raspbian instalado y clone nuestro software ejecutando:

> git clon git: //github.com/telefonicaid/fiware-figway/

Cambie a la carpeta “figway / sources” y compile con el siguiente comando:

> cd figway / fuentes

> g ++ -o registerDevice registerDevice.cpp clientSocketHttp6-test.cpp clientSocketHttp6-test.h g ++ -o sendObservations sendObservations.cpp clientSocketHttp6-test.cpp clientSocketHttp6-test.h g ++ -o addObservation addObservation.cpp

> g ++ -o fizway_switchd fizway_switchd.cpp

> cd ..

Si está conectando una red de dispositivos Z-wave, continúe ahora con el “PASO 6: Usar las herramientas de Fizway para conectar una red Z-wave completa”; de lo contrario, siga leyendo. 

Los archivos relevantes para usted en este momento son:

  • registerDevice : permite registrar un dispositivo en una plataforma M2M (a través de SensorML o NGSI9 / 10). Se espera que proporciones un DEVICE_ID y un DEVICE_TYPE. Los dispositivos deben registrarse en la plataforma M2M antes de enviar / recibir datos.
  • addObservation : una vez que recopila una observación de un sensor, puede almacenarla en el RPI con este comando.
  • sendObservations : una vez que haya recopilado todas las observaciones de un dispositivo, puede enviarlas todas en un solo paquete con este comando. Generará un error si no se agregan observaciones o no se han actualizado todos los tipos de observación.

Puede ignorar con seguridad los archivos fizway * ya que estos están relacionados principalmente con las redes Z-wave discutidas en el PASO 6, aunque también necesitará algunos de ellos para recibir comandos en el PASO 5.

Antes de ejecutar estos comandos, es posible que deba verificar y editar el archivo “Config” de figway. Se proporciona un archivo de ejemplo “Config.example”.

Todos los comandos anteriores proporcionan ayuda sobre el uso si se ejecutan sin argumentos.

Echemos un vistazo al archivo de configuración:

iot1

De hecho, se explica por sí mismo. Esta es la forma en que tienes que actualizarlo:

3: Uso de los comandos de Figway para registrar sus dispositivos

  • DEPURACIÓN = 1. Déjelo en 1 a menos que esté depurando.
  • PLATFORM_IP = 130.206.80.44 para el escenario B o C.
  • PLATFORM_PORT = 8002 para el escenario B o
  • PLATFORM_PORT = para el escenario C.
  • PLATFORM_PROTO = SML para conectarse a DCA (escenario B) o
  • PLATFORM_PROTO = NGSI para conectarse a ContextBroker
  • APIKEY = 6rs973ggt1q04gp7d9p0nho1bl. Solo es necesario para el Escenario B, ya que se ignora si se selecciona el Escenario C arriba.

Antes de enviar observaciones o recibir comandos de FIWARE Lab, todos sus dispositivos deben estar registrados. El registro es una operación idempotente, puede repetir este proceso para actualizar la información almacenada o si no está seguro de haberlo hecho antes.

El comando utilizado para el registro tiene la siguiente sintaxis:
> ./ registerDevice [DEVICE_ID] [DEVICE_TYPE]

  • [DEVICE_ID] es un identificador de 4 dígitos de su dispositivo. Este número debe ser único para cada dominio Raspberry PI conectado. Lo más fácil es hacer un plan de numeración para sus dispositivos como este: “0001”, “0002”, “0003”, etc.
  • [DEVICE_TYPE] es el tipo de dispositivo que está utilizando y debe coincidir con uno de los disponibles en la carpeta SensorML (Escenario B) o la carpeta NGSI (Escenario C). La razón de esto es que en el proceso de registro esa plantilla será modificada y enviada a nuestro backend de IoT.

Como ejercicio práctico asumiremos el siguiente escenario:

Internet de las cosas FI-WARE

Nuestro ejercicio de ejemplo tiene tres dispositivos:

  • un “sensor 4IN1”: medición de presencia, iluminancia, temperatura y humedad.
  • un “Sensor de puerta”: envío de actualizaciones de estado de apertura / cierre.
  • Un “Interruptor controlado”, que envía el consumo de energía, su estado actual (ENCENDIDO / APAGADO) y puede recibir comandos ENCENDIDO / APAGADO.

Tenga en cuenta que si comprende este escenario propuesto, podrá conectar cualquier otro tipo de dispositivos comerciales o caseros.

Tenga en cuenta también que ahora no nos importa cómo se conectan realmente los dispositivos a la Raspberry PI, porque puede utilizar cualquier tipo de solución: desde el cableado directo a la RaspberryPI GPIO o cualquier tecnología de radio / cable con los correspondientes dongle y controladores en la Raspberry. PI, como: X-10, X-10 RF, Zigbee, Z-wave (este en particular se explica más adelante en esta publicación).

3.1: Edite los archivos de plantilla para el registro de dispositivos

  1. Para el Escenario B, verá todas las plantillas de dispositivo que necesitamos en la carpeta SensorML / y las modificará de esta manera:
  • Register_4IN1. Edite este archivo y:
      – Reemplace todas las cadenas de “HACKSANTANDER” con el nombre real del servicio que estamos usando “OpenIoT” (nota importante: distingue entre mayúsculas y minúsculas).
  •     Register_DOOR. Del mismo modo, edite este archivo y:
    – Reemplace las cadenas de “HACKSANTANDER” por “OpenIoT”.
  •     Register_SWITCH. Como se trata de un actuador, necesitamos configurar no solo el servicio que estamos utilizando, sino también la dirección IP y el puerto para recibir comandos. Por lo tanto, edite este archivo y:
    – Reemplace las cadenas “HACKSANTANDER” por “OpenIoT”.
    – Reemplace “http://194.73.233.51:7777” por “http: // [IP]: 10000” donde IP es la dirección IP pública de su Raspberry PI.

Para el Escenario C, proceda exactamente igual que para el Escenario B pero:

  • trabajando en la carpeta NGSI /.
  • reemplazando las cadenas “UKCAMPUSPARTY” por “OpenIoT”.
  • y, para el SWITCH, reemplazando “http://1.0.0.1:8888” por “http: // [IP]: 10000” donde IP es la dirección IP pública de su Raspberry PI.

Nota importante: si se encuentra en un entorno NAT-ed (el PI tiene una IPv4 privada):

  • Para el campo [IP] en ​​los archivos anteriores, use la dirección IPv4 pública de su enrutador-NAT. No olvide configurar ese enrutador-NAT para reenviar el puerto TCP 10000 a la dirección IPv4 privada de su PI y Puerto 10000.
  • Tenga en cuenta que Figway está preparado para IPv6, por lo que si su ISP se lo proporciona, puede usar las direcciones PI IPv6 para recibir comandos. De esta forma evitará configurar un enrutador-NAT. Solo asegúrese de que su firewall v6 esté aceptando conexiones TCP entrantes al puerto 10000 para la dirección PI v6.

3.2: Registro de sus dispositivos en FIWARE Lab IoT Backend

Ahora que ha identificado y editado las plantillas de registro para su [DEVICE_TYPE] específico, solo necesita registrar dispositivos ejecutando:

> ./ registerDevice 0001 4IN1
> ./ registerDevice 0002 DOOR
> ./ registerDevice 0001 INTERRUPTOR

Para cada comando anterior, verá algo similar a esto en caso de éxito: (Esta es una instantánea del Escenario B, el Escenario C es una respuesta 200 OK diferente)

Internet de las cosas FI-WARE

3.3: ¿Y si quiero registrar diferentes tipos de dispositivos?

Lo único que necesita es definir un nuevo tipo de plantilla de sensor, decir “MYSENSOR” y crear el archivo de plantilla de registro correspondiente:

  • Si es, por ejemplo, simplemente enviando Temperature, simplemente copie el archivo “Register_4IN1” a “Register_MYSENSOR” y edite este archivo eliminando las secciones XML para otras observaciones (Move, Illuminance y Humidity).
  • Si su dispositivo solo está enviando cualquier otra observación numérica o de cadena, mejor copie “Register_DOOR” a “Register_MYSENSOR” y modifíquelo en consecuencia.
  • Si su dispositivo también está recibiendo comandos, simplemente agregue la sección XML que describe la URL para los comandos http: [IP]: [PORT] tomando “REGISTER_SWITCH” como ejemplo de trabajo.

Para todas estas modificaciones anteriores, recuerde crear los archivos en la carpeta SensorML / para el Escenario B o en NGSI / uno para el Escenario C.

4: Usar comandos de Figway para enviar las observaciones de sus dispositivos

Siempre que desee enviar una observación de un dispositivo al backend de FIWARE Lab IoT, debe hacerlo en dos pasos:

  • Agregar observaciones a un archivo temporal (comando addObservation)
  • Envíe todas las observaciones en el archivo temporal (comando sendObservation)

La razón de este enfoque es permitir que los dispositivos de detección múltiple (como el 4IN1) almacenen y / o envíen diferentes mediciones en diferentes momentos o desde diferentes componentes o funciones de software.

4.1: Edite los archivos de plantilla para observaciones de dispositivos

De manera similar al proceso de registro, debe identificar cada plantilla y modificarla adecuadamente. La diferencia aquí es que tendrá tantos archivos como tipos de observaciones por cada [DEVICE_TYPE]. En nuestro escenario de ejemplo:

Para el Escenario B, verá todas las plantillas de observación de dispositivos que necesitamos en la carpeta SensorML / y las modificará de esta manera:

  • Archivos relacionados con 4IN1: Observation_4IN1_MOV, Observation_4IN1_TEM, Observation_4IN1_LUM, Observation_4IN1_HUM

    – Reemplace las cadenas “HACKSANTANDER” por “OpenIoT”.

  • Archivos relacionados con DOOR: Observation_Door_STAT.

    – Reemplace las cadenas “HACKSANTANDER” por “OpenIoT”.

  • SWITCH archivos relacionados: Observation_Switch_POW, Observation_SWITCH_STAT.

    – Reemplace las cadenas “HACKSANTANDER” por “OpenIoT”.

Para el Escenario C, proceda exactamente igual que para el Escenario B pero:

  • trabajando en la carpeta NGSI /.
  • reemplazando las cadenas “UKCAMPUSPARTY” por “OpenIoT”.

4.2: Envío de las observaciones de sus dispositivos a FIWARE Lab IoT Backend

La sintaxis correcta de los dos comandos necesarios es la siguiente:

> ./ addObservation [DEVICE_ID] [DEVICE_TYPE] [OBS_TYPE] [OBS_VALUE]
> ./ sendObservation [DEVICE_ID] [DEVICE_TYPE] [OBS_TYPE]

Hagamos el ejercicio para el 4IN1 de dos formas diferentes:

  • Su código recopila todas las medidas de los entornos cada 10 minutos y desea enviarlas al backend:

> ./ addObservation 0001 4IN1 TEM [Temperatura]
> ./ addObservation 0001 4IN1 HUM [Humedad]
> ./ addObservation 0001 4IN1 LUM [Illuminance]
> ./ sendObservations 0001 4IN1 TEM
> ./ sendObservations 0001 4IN1 HUM
> ./ sendIN1 LUM LUM

  • Su código desea informar el estado de MOVE cada vez que el 4IN1 activa ese evento al detectar una persona en la habitación:

> ./ addObservation 0001 4IN1 MOV MOVIMIENTO
> ./ sendObservations 0001 4IN1 MOV

  • Su código quiere informar el estado QUIET siempre que el 4IN1 active ese estado (normalmente un tiempo de espera después de que se detectó MOVE).

> ./ addObservation 0001 4IN1 MOV QUIET
> ./ sendObservations 0001 4IN1 MOV

4.3: ¿Y si quiero usar diferentes tipos de dispositivos?

Supongamos que tiene un sensor tipo “MY_SENSOR” que ya ha registrado con su archivo de plantilla “Registration_MYSENSOR” como se indica en los párrafos anteriores.

Ahora necesita identificar cuántos tipos de observación están administrando sus dispositivos.

Supongamos que gestiona la temperatura y la humedad. Luego, necesitaría crear los archivos de plantilla “Observation_MYSENSOR_TEM” y “Observation_MYSENSOR_HUM” que puede tomar de “Observation_4IN1_TEM” y “Observation_4IN1_HUM” respectivamente.

Si su sensor estaría proporcionando un estado numérico o de cadena diferente, puede crear el archivo “Observation_MYSENSOR_STAT” tomando “Observation_DOOR_STAT” como referencia.

Si su dispositivo está recibiendo comandos, no necesita modificar ningún campo específico para eso en ningún archivo de plantilla de observación.

Recuerde crear plantillas de observación en la carpeta SensorML / si está trabajando con el Escenario B o en la carpeta NGSI / si está en el Escenario C,

PASO 5: habilitar dispositivos para recibir comandos

En nuestro escenario, existe un dispositivo SWITCH que es adecuado para recibir comandos de ENCENDIDO / APAGADO. Continúe leyendo esta sección solo si tiene dispositivos que recibirán comandos del backend o de cualquier otro lugar en Internet.

5.1: Configurar la herramienta fizway_switchd para recibir comandos.

Hay un comando que lanzará un servidor TCP por usted, analizará los comandos si los hay y entregará el resultado a otro programa llamado “fizway

Su sintaxis correcta es:
> ./ fizway_switchd [Device_ID] [DEVICE_TYPE] [Server_Port]

Donde [Device_ID] y [DEVICE_TYPE] son ​​los que usó para el registro de ese dispositivo y [Server_Port] es el puerto TCP para escuchar los comandos en Raspberry PI. Este puerto debe coincidir con el proporcionado en la cadena de URL de la plantilla de registro http: // [IP]: [PORT].

En nuestro ejemplo específico, solo necesitamos lanzarlo de esta manera:
> ./ fizway_switchd 0003 SWITCH 10000

Tenga en cuenta que puede iniciar tantos servidores (en diferentes puertos) como dispositivos con capacidad de comando tenga.

5.2: pruebe que sus dispositivos reciban comandos correctamente

Podemos probar para encender nuestro interruptor conectándonos a nuestro servidor de comando en Raspberry PI con un cliente telnet regular (desde el PI o cualquier otra máquina, asumimos que la dirección PI es 192.168.1.50) y tecleamos:

> telnet 192.168.1.50 10000
<FIZCOMMAND 255>

O, para apagar el interruptor con:
> telnet 192.168.1.50 10000
<FIZCOMMAND 0>

La siguiente sección explica cómo hacer que las herramientas efervescentes y su código cooperen para afectar eficazmente su dispositivo.

Paso 5.3: ¿Y si quiero usar diferentes tipos de dispositivos actuadores?

Los comandos enviados a los dispositivos tienen la forma “FIZCOMMAND [COMMAND]”, donde [COMMAND] puede ser cualquier cadena sin espacios ni símbolo “>” en el medio siempre que esos caracteres se utilicen para determinar su final.

Los comandos de ejemplo y su resultado son:

  • “FIZCOMMAND ON”: válido. El argumento del comando será “ON”
  • “FIZCOMMAND OFF”: No válido ya que no hay espacio al final.
  • “<FIZCOMMAND ON>” Válido porque hay un símbolo “>” al final.
  • “FIZCOMMAND THIS_IS_A_TEST_OF_STRING”: válido.
  • “<FIZCOMMAND THIS_IS_A_TEST_OF_STRING>“: válido.
  • “FIZCOMMAND ESTO ES UNA PRUEBA DE CADENA”: Válido, pero solo “ESTO” se enviará como argumento del comando.

Una vez que envíe un comando a este servidor y el análisis sea válido, automáticamente invocará el script bash “fizway_command” de esta manera:
> ./ fizway_command [DEVICE_NUMBER] [DEVICE_TYPE] [COMMAND_VALUE]

Donde [COMMAND_VALUE] es el comando que envió al servidor.

De esta manera, solo necesita incorporar en el script “fizway_command” las acciones que desea realizar para su dispositivo específico al recibir ciertos comandos. También puede reemplazar todo el script por cualquier otro componente siempre que mantenga su nombre y sintaxis de invocación para que el servidor “fizway_switchd” lo llame correctamente.

Más adelante en esta publicación se muestra un ejemplo de trabajo para el escenario Z-WAVE.

5.4: envíe comandos a sus dispositivos desde nuestro backend de IoT

En este momento, esta posibilidad solo funciona para el escenario B (DCA). Si se trata del escenario C, deberá enviar los comandos usted mismo al servidor de comandos en Raspberry PI como se explicó anteriormente en la sección 5.2.

Para el escenario B, solo necesitas usar la API de administración de DCA-IDAS que mostramos en la siguiente captura:

Internet de las cosas FI-WARE

Nota: a diferencia de esta captura de pantalla, la API ADMIN se ofrece públicamente en el puerto 80 y está protegida con un keyrock PEP-Proxy como todos los demás GEs públicos en FIWARE Lab. Consulte el anexo de este artículo para saber cómo obtener y utilizar un token de acceso antes de probar el ejemplo anterior.

6: Uso de las herramientas de Fizway para conectar una red Z-wave completa

Todos los pasos anteriores asumen que está conectando cualquier tipo de dispositivo. Sin embargo, hemos facilitado la vida en el caso de que esté conectando una red de dispositivos Z-wave proporcionando también el código para administrarlos como se muestra en la siguiente imagen:

Internet de las cosas FI-WARE

La imagen dibuja el caso del escenario B, pero en realidad el escenario C sería similar pero enviando información directamente al ContextBroker (sin pasar por DCA-IDAS). En el escenario C, los comandos solo se enviarían directamente a RaspberryPI (línea azul punteada).

La buena noticia para los dispositivos Z-WAVE es que solo necesita seguir los siguientes pasos:
1. Construya su red Z-WAVE como lo hace habitualmente. Para las pruebas usamos un RaspberryPI y un dongle GPIO Razberry Z-wave con su software incluido.

2.  Instale y configure la herramienta Figway como se describe en el “PASO 2: Instalar y configurar el software Figway en una Raspberry PI”.

3.  Edite el archivo “fizway_register” y los archivos “fizway”
   a. Actualice las ID correctas de su red z-wave (solo sus dispositivos)
b.  Para los actuadores asignamos un puerto de escucha por cada uno (10000…)

4. Configure los actuadores (plantillas de registro de dispositivos SWITCH y RGBS) para recibir comandos.
     una. Actualice la plantilla de dispositivo con la dirección IP de este RaspberryPI
     b.  El puerto es el puerto asignado al actuador en el paso anterior.

5.    Registre todos sus dispositivos ejecutando “fizway_register”

6.   Ejecute el script “fizway &” para que las observaciones se envíen automáticamente y también se reciban los comandos.
¡Y eso es todo, tendrás todos los dispositivos funcionando con los sencillos 6 pasos anteriores!

Bonus: obtener información de IoT de un Orion ContextBroker seguro

Esta sección muestra un ejemplo sobre la recopilación de información de IoT del agente de contexto de Orion. La documentación completa para esto está disponible aquí.

Hay una instancia global de Orion ContextBroker (CB) que está recibiendo toda la información de los otros Contextbrokers, por lo que no es necesario que te preocupes por eso.

Los pasos necesarios para poder acceder al CB global seguro de FIWARE Lab son:
1.     Regístrese en FIWARE Lab y obtenga una cuenta. http://account.lab.fi-ware.org
2.    Genere un token de acceso Oauth2 usando sus credenciales en (1).
Lo más fácil de probar es utilizar el script proporcionado en:
https://github.com/fgalan/oauth2-example-orion-client/blob/master/token_script.sh

Tenga en cuenta que el Token que se utilizará es el primero: “Token de acceso” (el más largo).

3.    Acceda a la API REST de ContextBroker con un encabezado de autorización configurado para el token de acceso recibido en (2) y luego realice una consulta específica (obteniendo su versión en esta captura de pantalla a continuación).

Mas informacion en https://www.fiware.org/2014/06/18/connect-your-own-internet-of-things-to-fi-lab/

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

Instalacion de Grafana en Windows


Grafana es un software libre basado en licencia de Apache 2.0,​ que permite la visualización y el formato de datos métricos. Permite crear cuadros de mando y gráficos a partir de múltiples fuentes, incluidas bases de datos de series de tiempo como Graphite, InfluxDB y OpenTSDB​ Originalmente comenzó como un componente de Kibana y que luego le fue realizado una bifurcación.​

Lanzado en 2013 por Grafana Labs,Grafana es una de las soluciones de monitoreo de más rápido crecimiento en uso en 2019. Es multiplataforma sin ninguna dependencia y también se puede implementar con Docker. Está escrito en lenguaje Go y tiene un HTTP API completo. Además de administrar cuadros de mando clásicos (adiciones, eliminaciones, favoritos), Grafana ofrece compartir un cuadro de mando actual mediante la creación de un enlace o una instantánea estática del mismo.

Todos los paneles de control y las fuentes de datos están vinculados a una organización, y los usuarios de la aplicación están vinculados a organizaciones a través de roles.Evita que los usuarios sobrescriban accidentalmente un panel de control. Existe una protección similar cuando se crea un nuevo panel de control cuyo nombre ya existe. La herramienta tambien ofrece la posibilidad de configurar alertas.

Es una solución de dashboarding que conecta a una amplia variedad de orígenes de datos (la mayoría de las bases de datos de series temporales) con el fin de visualizar datos casi en tiempo real siendo uilizada por muchas grandes empresas como el CERN, Digital Ocean o PayPal,Grafana también se utiliza en pequeñas y medianas corporaciones dispuestas a tener retroalimentación sobre la salud de su infraestructura.

Descarga del archivo Grafana desde el sitio web oficial

Para Windows, abra su navegador web y vaya a la página de descargas de Grafana.

Seleccione “Windows” en la lista de sistemas operativos disponibles y haga clic en “Descargar el instalador“.

Grafana for Windows download option

La descarga de MSI debe comenzar.

Cuando haya terminado, simplemente ejecute el instalador msi.

Grafana MSI on Windows

Instalar Grafana en Windows

Al ejecutar el MSI, esto es lo que debería ver.

Grafana installation first step

Haga clic en “Siguiente“.

Grafana installation second step

Acepte los términos del contrato de licencia y haga clic en“Siguiente”.

Grafana installation third  step

Asegúrese de que el sistema operativo Grafana (el servidor Grafana) y la opción Grafana como servicio estén correctamente seleccionados.

Si este es el caso, haga clic en “Siguiente” y en “Instalar

Grafana installation fourth step

En este punto, la instalación de Grafana debe comenzar.

Si en algún momento se le solicita una excepción de firewall, asegúrese de autorizar a Grafana a realizar cambios en el sistema.

Cuando se realiza la instalación, esta es la pantalla que debería ver.

Grafana installation last step

¡Impresionante! Acaba de instalar Grafana en Windows.

Compruebe que su servicio Grafana se está ejecutando

Antes de ir más lejos, debe comprobar que el servidor Grafana se está ejecutando correctamente como un servicio de Windows.

En muchos casos, es posible que el puerto predeterminado de Grafana (3000) ya esté tomado, lo que impide que Grafana se inicie correctamente.

Como consecuencia, así es como puede comprobar que se está ejecutando.

En el menú de búsqueda de Windows, escriba “Servicios” y abra la ventana Servicios.

Windows services panel

En la ventana Servicios, desplácese hasta llegar al servicio Grafana.

Grafana service on Windows

 El servicio Grafana puede comprobar que ya está en funcionamiento.

Iniciar Grafana v6 Web UI

Si el servicio se está ejecutando correctamente, debería poder acceder a la interfaz de usuario de Grafana v6.

Como recordatorio, Grafana se ejecuta de forma predeterminada en el puerto 3000.

Como consecuencia, abra un navegador web y vaya a http://localhost:3000.

Esta es la pantalla que debería ver.

Grafana v6.3 default web UI on Windows

En Grafana, las credenciales predeterminadas son admin (como nombre de usuario) y admin (como contraseña) de forma predeterminada.

En la siguiente ventana, se le pedirá que cambie su contraseña. Elija una contraseña segura para evitar brechas de seguridad.

Grafana change password window

Cuando lo haya hecho pulsar en “Save“.

Ahora debería ver la pantalla predeterminada para Grafana v6.3 en Windows.

Grafana welcome default screen

Antes de crear sus propios paneles, hay algunos pasos de configuración que debe realizar para una nueva instancia.

Definición de su propio archivo de configuración

En las últimas distribuciones grafana para Windows, el servicio es lanzado por NSSM (que es un administrador de servicios para Windows).

De forma predeterminada, Grafana se basa en los archivos de configuración ubicados en la carpeta conf del directorio de instalación.

Mine se encuentra en C:\Program Files\GrafanaLabs\grafana como ejemplo.

Este es el contenido de la carpeta conf.

Grafana configuration folder on Windows

De forma predeterminada, Grafana va a usar el contenido del archivo .ini predeterminado, pero vamos a sobrescribir eso para tener nuestro propio archivo de configuración personalizado.

En caso de que estemos teniendo algunos problemas con nuestro propio archivo de configuración, podemos volver al archivo predeterminado fácilmente.

Haga una copia del archivo predeterminado y asígnele el nombre “custom.ini”

Adding a custom configuration file

Al ejecutar la instalación MSI, Grafana va a almacenar un ejecutable de NSSM en la carpeta GrafanaLabs de la carpeta de instalación.

NSSM executable on Windows

Abra una instancia de Powershell en el equipo como administradory vaya a esta carpeta.

No olvide las comillas alrededor de la ruta de acceso, de lo contrario obtendrá una excepción de Powershell.

$ cd "C:\Program Files\GrafanaLabs"
$ .\nssm.exe edit grafana

Se debe abrir una ventana similar a esta.

NSSM window edit service

Al final de la variable path, agregue una marca –config con el nombre del archivo de configuración que acabamos de crear.

Adding a custom argument on NSSM
Argumentos: --config conf\custom.ini

pulsar en “Edit Service” y debderia ver el siguinte mensajesuccess message.

Service Grafana edit successfully

Reinicie el servicio y asegúrese de que Grafana sigue ejecutándose correctamente (http://localhost:3000)

Avtivar sign-up en Grafana

De forma predeterminada, la creación de la cuenta se encuentra en http://localhost:3000/signup en la instancia de Grafana.

En Grafana v6.3, el registro de la cuenta está deshabilitado de forma predeterminada.

Sign up option on Grafana

Sin embargo, es posible que desee habilitar esta opción en su servidor Grafana, si autoriza a los invitados a tener una cuenta para mostrar algunos paneles especiales.

Para habilitar el registro, diríjase al archivo de configuración personalizado.ini (ubicado en la carpeta conf) y vaya a la sección [usuarios] del archivo.

Modifique la entrada allow_sign_up a true..

Allowing user sign up on Grafana

Para comprobar que todo funciona correctamente, vaya a http://localhost:3000/signup e intente crear una cuenta.

Grafana sign up page

Haga clic en “Registrarse” y debe ser redirigido a la página principal.

Grafana user panel

Activar acceso anonimo

De forma predeterminada, el acceso anónimo está deshabilitado en Grafana.

El acceso anónimo significa que cualquier usuario no autenticado puede examinar la instancia de Grafana, al menos para la organización predeterminada que se les ha asignado.

Grafana anonymous access option

Si va http://localhost:3000, se le redirigirá a la pantalla de inicio de sesión si es un usuario anónimo.

Para cambiar eso, edite el archivo de configuración personalizado.ini y edite la sección [auth.anonymous].

Grafana anonymous access configuration file

Reinicie el servicio Grafana y busque http://localhost:3000 como usuario anónimo (en modo privado, por ejemplo).

Ahora debe tener un permiso viewer para los paneles permitidos.

Access allowed for anonymous users on Grafana on Windows

Aquí hay una selección de artículos que debe leer para mejorar con Grafana :