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/

Node-red en Raspeberry Pi


Durante años hemos visto un goteo de proyectos de domótica realmente interesantes que utilizan el paquete Node-RED. Cada vez, los hackers detrás de estos proyectos han delirado sobre Node-RED y ahora me he unido a esas filas también.

Esta plataforma de codificación basada en gráficos le permite armar rápidamente operaciones útiles e interfaces gráficas de usuario (GUIs), ya sea que sea el greenhorn más fresco o un veterano experimentado. Puedes usarlo para cambiar tus luces conectadas a Internet según lo programado, o con solo tocar un botón a través de una aplicación web disponible para cualquier dispositivo de tu red doméstica. Puede usarlo como un panel de información para la previsión del tiempo, últimos artículos hackaday, horarios de autobús, o todos ellos a la vez. De un vistazo, abstrae la complejidad de escribir Javascript, a la vez que facilita la inmersión bajo el capó y utiliza sus habilidades de haxor 1337 para agregar su propio código.

Puede poner esto en marcha en menos de una hora y voy a abordar eso, así como ejemplos para jugar con MQTT, configurar una interfaz gráfica de usuario web y escribir en archivos de registro. Para que Node-RED sea persistente en la red, necesita un servidor, pero es lo suficientemente delgado como para ejecutarse desde una Raspberry Pi sin problemas, e incluso se instala de forma predeterminada en las distribuciones de BeagleBone. El código de todos los ejemplos de esta guía se puede encontrar en el repositorio del tutorial. ¡Vamos a sumergirnos!

LO QUE ES

Node-RED es un lenguaje de programación gráfico basado en Node.js. Implementa un servidor y ejecuta lo que se llama “Flujos”: programas basados en Javascript. ¿Por qué querría ejecutar un IDE del lado servidor para sus programas? Debido a que Node-RED también hace que sea muy fácil crear aplicaciones web y usarlas como su sistema de información y control en línea.

INSTALACIÓN

Para que sus programas Node-RED sean persistentes, necesita un servidor, sin embargo, si solo desea jugar por ahora puede ejecutarse localmente. Su servidor puede ser tan simple como instalar la plataforma en un Raspberry Pi o un ordenador siempre encendido en su LAN. Los requisitos previos incluyen Node.js y npm (node.js administrador de paquetes) que en un sistema Linux son una fácil instalación.

sudo apt install nodejs

Ahora podemos instalar Node-RED y, para seguir los ejemplos a continuación, también debe instalar el paquete del panel:

npm install node-red
npm install node-red-dashboard

Para ejecutar localmente sólo tiene que escribir en el terminal. Sin embargo, la forma más elocuente de ejecutar esto es como un servicio. Copie el contenido del archivo nodered.service y actualice el archivo , y variables de ese archivo para que coincidan con un usuario real del sistema. Con eso en su lugar, simplemente habilite e inicie el servicio. Ahora se reiniciará en un bloqueo o reinicio del sistema a partir de ahora.node-redsystemd/etc/systemd/system/nodered.serviceUserGroupWorkingDirectory

12systemctl enable nodered.servicesystemctl start nodered.service

You can now load up the Node-RED IDE simply by visiting in a web browser.localhost:1880

HELLO WORLD

Lo más sencillo de hacer como su primer “flujo” en Node-RED es: botón de clic, obtener marca de tiempo. Para hacer la imagen de arriba no hice nada más que arrastrar los nodos “Inyectar” y “Depurar” desde la columna izquierda al centro, luego arrastre la línea que conecta los dos nodos. Debe hacer clic en el botón “Implementar” en la parte superior derecha cada vez que realice cambios y, a continuación, haga clic en el botón que cuelga del lado izquierdo del nodo de inyección, que tiene la etiqueta “marca de tiempo” de forma predeterminada, para escupir el tiempo en la ventana de depuración. Haga clic en el icono de error situado encima de la ventana derecha si no ve la salida de depuración.

Este ejemplo no es muy útil, pero ese no es el punto del código Hello World. Esto lleva a casa la potencia del sistema de código gráfico. Lo que también es interesante es que los flujos se pueden exportar como archivos. Así es como se ve este Hello World y se puede importar a su propia instalación Node-RED.json+ ampliar la fuente

INICIO RÁPIDO DE MQTT

Node-RED parece que está hecho específicamente para ser utilizado con MQTT, el popular protocolo de Internet de las cosas para el que Elliot Williams ha escrito una guía fantástica. Se siente así porque un cliente MQTT está integrado y la mayoría de los nodos tienen “temas”, así como cargas útiles de mensajes que es todo lo que realmente necesita para comunicarse con un bróker MQTT.

Como se puede ver arriba, estoy haciendo exactamente el mismo truco de inyección / depuración, pero ahora he arrastrado un nodo “mqtt in” y “mqtt out” desde la columna “Red” de posibles nodos.

node-red-mqtt-server
node-red-mqtt-node

Hay un poco más de configuración aquí, ya que necesitamos elegir un servidor MQTT y seleccionar un tema para publicar y escuchar. Pero la interfaz hace que esto sea muy fácil, simplemente haga doble clic en uno de los nodos MQTT. Aquí estoy usando el servidor de pruebas mosquitto ()y el tema . Solo tienes que darte cuenta de que cualquiera que mire mensajes en ese servidor puede ver esto y si usas exactamente el mismo tema puedes ver a otros lectores enviando mensajes de prueba. Node-RED también se puede utilizar como bróker MQTT.test.mosquitto.orgHackaday/nodered/test

Intente hacer doble clic en el nodo de inyección y cambiar la carga útil de la marca de tiempo a una cadena y puede enviar sus propios mensajes personalizados. En su mayor parte me resulta fácil encontrar mi camino alrededor de Node-RED y jugar con la configuración es de bajo esfuerzo. Solo asegúrate de pulsar el botón implementar: tus cambios no estarán realmente en su lugar hasta que lo hagas.

WEB GUI HELLO WORLD

Vayamos a la parte realmente emocionante de Node-Red, la capacidad de crear una aplicación web con muy poco esfuerzo.

Aquí se puede ver un teléfono inteligente que muestra nuestra aplicación. La única parte realmente útil aquí es el botón. Haga clic en él y obtendrá “Hola Hackaday!” en la ventana de depuración de Node-RED como se ve arriba. Todo lo que se necesitó para crear esta página fue instalar el paquete de panel para Node-RED y, a continuación, arrastrar un botón al lienzo. Una vez implementada, la aplicación web se ubicará en localhost:1880/ui

La instalación del paquete es un simple revestimiento:

npm install node-red-dashboard

Arrastrar el botón al lienzo y enlazarlo a un nodo de depuración también es simple, pero necesita hacer sólo un poco de configuración. Al hacer doble clic en el nodo de botón, puede cambiar la carga para afectar a qué mensaje se envía a la ventana de depuración, pero también debe establecer un grupo y, dentro del cuadro de diálogo de edición de grupo, deberá establecer una pestaña. Esto afecta a la aplicación web, con grupos organizando bloques en cada página de la aplicación web, y pestañas seleccionando diferentes páginas del menú de hamburguesas en la parte superior izquierda. Puede nombrar grupos y pestañas como desee.

¡VAMOS A CREAR UNA APLICACIÓN WEB!

Suficiente con el código Hello World, vamos a construir algo útil. He estado usando Node-RED durante un mes más o menos y he construido un par de aplicaciones útiles, una interactúa con mi bróker MQTT para controlar y monitorear mi luz de pórtico frontal, la otra que uso como una simple pulsación de botón para realizar un seguimiento de los días que hago ejercicio. Vamos a construir la aplicación de ejercicios poco a poco porque hay más que simplemente enviar paquetes MQTT de un lado a otro.

Aquí está el estado actual de la aplicación de ejercicios, que incluye un botón que registra la fecha de hoy en un archivo de registro y un medidor que lee el archivo de registro para mostrar cuántos de los últimos siete días han incluido el ejercicio. Construyamos una cuadra a la vez.

Gui botón escritura a archivos

Aquí es donde comienza el flujo. Consta de un botón del paquete Dashboard que envía una marca de tiempo cuando se hace clic. Este mensaje se registrará en dos nodos “file”, el primero es el que simplemente registra una marca de tiempo UNIX para cada línea. Eso no es legible en humanos, por lo que el segundo nodo de archivo tiene un nodo de función que traduce la marca de tiempo mediante el siguiente fragmento de código JavaScript. Hay un poco de magia allí para asegurarse de que el mes y el día son siempre de dos dígitos.exerciselog-raw.txt

123456789var date;date = new Date();var year = date.getFullYear();var month = date.getMonth();month = (month < 9 ? '0' : '') + (month+1)var day = date.getDate();day = (day < 10 ? '0' : '') + daymsg.payload = year + '-' + month + '-' + day;return msg;

Adición de una notificación de usuario

node-red-notification-node
node-red-notification-dialog

El botón funciona según lo esperado, pero no da ninguna retroalimentación al usuario. Para mejorar esto, agregué un nodo de notificación del paquete de panel. Se conecta después del nodo de archivo para confirmar que la fecha se había escrito en el archivo de registro.

Lectura de un archivo, visualización de datos, actualización al inicio

Esta última parte del flujo utiliza el nodo “file in” bronceado para leer marcas de tiempo UNIX desde el archivo de registro sin procesar y lo muestra en el nodo “gauge” de color azul del paquete del panel. Se activa mediante dos desencadenadores diferentes, uno se actualiza después de que se escribe una nueva fecha en los archivos de registro. El otro es el nodo “inject” de lavanda que tiene una opción “index once after n seconds” para rellenar los datos iniciales cuando se inicia Node-RED.

El medidor sólo está buscando un número para rellenar y esto es alimentado por un nodo de función (lo llamé Magic). El código siguiente se lee en el archivo de registro como una matriz, calcula el código de fecha UNIX de hace siete días y, a continuación, recorre en iteraciones las últimas siete marcas de tiempo en el archivo de registro.

12345678910111213141516171819202122232425//Turn incoming timestamps log into an array:var exercisearray = msg.payload.split("\n");if (exercisearray.slice(-1)[0] === "") exercisearray.length = exercisearray.length-1 //Get timestamp for week ago to compare againstvar thismorning = new Date()thismorning.setHours(0)thismorning.setMinutes(0)thismorning.setSeconds(0)thismorning.setMilliseconds(0)var sixdays = 1000*60*60*24*6var oneweekago = thismorning.getTime()-sixdays //Iterate and count past week of exercisevar count = 0var secondsinday = 60*24*7for (var i=1; i<8; i++) {if (i>exercisearray.length) break;var testval = parseInt(exercisearray.slice(-i)[0]);if (testval >= oneweekago) ++count;} //Store our answer as the payload and pass alongmsg.payload = count;return msg;

¡PRUEBE NODE-RED!

Una de mis primeras preocupaciones con la plataforma fue el control de versiones, pero eso también está disponible. Hay integración git integrada denominada proyectos Node-RED, pero no está habilitada de forma predeterminada. No estoy acostumbrado a usar una GUI para git, pero de nuevo no estoy acostumbrado a las interfaces gráficas de programación por lo que no duele probar algo nuevo.

Los ejemplos que hemos visto son realmente la punta del iceberg. Mire a su alrededor y encontrará un montón de entusiasmo por Node-RED que se traduce en flujos increíbles y aplicaciones web impresionantes. Por ejemplo, he estado leyendo scargill’s Tech Blog durante años y allí encontrarás un montón de ejemplos de lo que se puede lograr. Aquí vemos el panel de control del termostato de Scargill que tiene todo tipo de personalización para darle un aspecto especial. Encontrar ejemplos que te gusten no es difícil, y copiar su código es aún más fácil.

Puede recoger fácilmente Node-RED en una tarde y terminar con algo útil. Para aquellos que quieren pasar más tiempo, el cielo es el límite. Si tienes algún tipo de domótica, es algo que debes probar, ya que desbloquea la capacidad de cualquier persona en tu LAN para acceder a la información y el control sin instalar una aplicación. Usted puede sacar fácilmente un teléfono inteligente en desuso del cajón y convertirlo en un panel de control dedicado, algo que hice para la imagen en la parte superior de este artículo con la ayuda de una aplicación de Android llamada Fully Kiosk Browser Lockdown para una verdadera experiencia de navegador a pantalla completa no proporcionada por Chrome o Firefox para Android. ¡Pruébalo con tu propio equipo sobrante!

Fuente https://hackaday.com/2020/01/15/automate-your-life-with-node-red-plus-a-dash-of-mqtt/

Instalación de Node-Red, InfuxDB y Grafana


La Raspberry Pi  es una placa ideal para monitorear todo tipo de cosas. Hoy usaremos Node-Red, InfluxDB y Grafana para monitorizar diferentes  entidades , así como habilitar  alarmas hacia nuestro  smartphone o  en el  correo.

Resumidamente estos son los tres componentes que usaremos

  • 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
  • InfluxDB es una base de datos de series de tiempo de código abierto (TSDB) desarrollada por InfluxData. Está escrito en Go y optimizado para el almacenamiento y la recuperación rápidos y de alta disponibilidad de datos de series de tiempo en campos como el monitoreo de operaciones, métricas de aplicaciones, datos de sensores de Internet de las cosas y análisis en tiempo real. También tiene soporte para procesar datos desde Graphite . 
  • Node-RED es una herramienta de desarrollo basada en flujo para programación visual desarrollada originalmente por IBM para conectar dispositivos de hardware, API y servicios en línea como parte del Internet de las cosas .Proporciona un editor de flujo basado en navegador web , que se puede utilizar para crear funciones de JavaScript . Los elementos de las aplicaciones se pueden guardar o compartir para su reutilización. El tiempo de ejecución se basa en Node.js . Los flujos creados en Node-RED se almacenan mediante JSON . Desde la versión 0.14, los nodos MQTT pueden realizar conexiones TLS configuradas correctamente . En 2016, IBM contribuyó con Node-RED como un proyecto de JS Foundation de código abierto .

Preparar imagen en tarjeta SD

Descargar imagen: http://bit.ly/2GdZbPe
Agregar archivo ssh vacío al directorio raíz de la tarjeta
Agregar wpa_supplicant.conf al directorio raíz

Contenido del archivo wpa_supplicant.conf:

country = CH
ctrl_interface = DIR = / var / run / wpa_supplicant GROUP = netdev
update_config = 1
network = {
  ssid = ”…”
  psk = ”…”
}

Inserte la tarjeta SD en su Raspberry, arranque y encuentre su dirección IP por ejemplo usando https://www.advanced-ip-scanner.com   o simplemente con el comando sudo ifconfig
Inicie sesión desde un terminal usando Putty https://www.putty.org/ usando  las credecniales por defcto: Pi/raspberry  

Ahora debe actualizar su Raspberry a la versión más reciente :

 sudo apt-get update && sudo apt-get upgrade 

Configuración en la  Raspbery

Configuración de Mosquitto

Tenemos que modificar el fichero mosquito,conf , para lo cual;

sudo nano /etc/mosquitto/mosquitto.conf 

Insertaremos el siguiente comando  al finala del fichero  y salivar  los cambios:
allow_anonymous true

Reiniciar Mosquitto

 sudo systemctl reiniciar mosquitto 

Configuración de influxDB

Crear usuario:

CREATE USER "pi" WITH PASSWORD 'raspberry' WITH ALL PRIVILEGES
exit

Cambiar archivo de configuración:

sudo nano /etc/influxdb/influxdb.conf

En [http] descomente:
enabled = true y bind-address =: 8086

en [monitor] descomente y cambie a:
store-enabled = false

sudo service influxdb restart

Configuración de Node-Red

Importar flujos desde: https://drive.google.com/open?id=1kECuykSaFO7Qb_67QqIHtlpvElpVWDMI

Instalar correo

sudo apt-get install ssmtp 
sudo apt-get install mailutils
sudo nano /etc/ssmtp/ssmtp.conf

Para Gmail, ingrese este texto:

mailhub = smtp.gmail.com: 587
AuthUser = [yourmailaddress] @ gmail.com
AuthPass = [emailPassword]
UseSTARTTLS = YES
UseTLS = YES

Pruebe su correo

echo "Hola mundo cuerpo del correo electrónico" | mail -s "Prueba asunto "   [email protected]

Agregue soporte para aplicaciones menos seguras en Gmail: https://myaccount.google.com/lesssecureapps

Crear una base de datos influxDB

influx

Create database [su nombre de la base de datos]
Show DATABASES
Use [ su nombre de la base de dato]
Show series

exit

Instalar y preparar Telegram

Instale Telegram en su PC https://desktop.telegram.org/

Inicie el telegrama y busque “botfather”

Ingrese el nombre de su bot deseado anotando la ficha.
Envíe un mensaje de texto al bot.

Vaya a: https://api.telegram.org/bot[Token]/getUpdates   y tome nota de la identificación (ID) pues lo usaremos más tarde:

Prepare Grafana

Agregue una fuente
Agregue el tablero importando un archivo JSON:

Ejemplos:
Presión de cerveza: https://drive.google.com/open?id=1beKyu4WuGErAHeYKyE3-8wtpyZJ8yHkZ
Clima: https://drive.google.com/open?id=18326_tjcVln0xBLRJINJn2ZwP0lNlyHX
YouTube: https://drive.google.com / open? id = 1TrZAGnxn4zRfyO_X8RXw4ZtQIvJi8JnQ

Agregar canal de notificación por correo

sudo nano /etc/grafana/grafana.ini

enabled=true
host = smtp.gmail.com:587
user =[receivingEmail]@gmail.com
password =”[emailPassword]”
skip_verify = true
from_address = [sendingEmail]@gmail.com
from_name = [whateverName]

Ir a los canales de notificación
Agregar nuevo canal
Editar canal de notificación  y presione Send Test (“Enviar texto”)

Agregar canal de notificación de Telegram

Agregar nuevo canal de notificación de Telegram

Añada ahora el nuevo canal de notificaciones de Telegram. Insertar chatID y token obtenidos anteriormente

Y presione “Enviar prueba”

 

Contraseñas por defecto usadas

Dónde Usuario Contraseña
Raspberry Pi raspberry
Flujos de node-red admin admin
IU Node-Red User user
Usuario de InfluxDB Pi raspberry
Grafana admin admin

 

 

 

Fuente: sensoriot.org