Gracias a Telefónica R&D Chile( Telefónica I + D Chile) nos ofrecen un interesantisimo tutorial intruductorio sobre IOT concretamente usando la plataforma Orion Context Broker (FIWARE ) con Arduino aunque puede extrapolarse a otras placas de IoT ( por ejemplo Netduino ,Intel Edison o Raspberry Pi)
Un punto interesante para analizar el IoT (Internet of Things )es el uso de las normas. Para el caso concreto vamos a revisar más adelante en la sección Orion Context Broker, una adaptación basada en la especificación OMA (Open Mobile Alliance) NGSI (Next Generation Service Interface). En términos simples, esto significa que las peticiones HTTP o acciones que deben utilizarse son los que están actualmente empleados por los navegadores tales como GET, POST, DELETE y PUT para interactuar con el contexto Broker.
Configuración de hardware
Los componentes que vamos a utilizar son:
- Una placa Arduino (hay muchas alternativas, pero una versión con WiFi es esencial)
- Una placa protoboard
- LEDs
- Cables de conexión
- Un router o un dispositivo celular que pueden ofrecer Wi-Fi (tethering)
Como se ha comentado en este blog , Arduino tiene su propia interfaz de desarrollo utilizando el lenguaje C ++ y se integra una serie de librerías para facilitar la aplicación de prototipos. Esto no quiere decir que Arduino no se puede utilizar en entornos industriales o de alta demanda. Sin embargo, en estos escenarios cuestiones de costos por lo general conducen a la utilización de componentes ad-hoc.
Al observar la estructura, se puede reconocer algunos pines digitales en la parte superior y analógicas pines en la parte inferior (idéntico a muchas otras placas como Netduino). Además, en la parte inferior, también hay una fila de conectores para alimentar al propia placa u otras que se conecten. Por supuesto la placa también tiene un conector a una toma de corriente y un conector mini USB, entre otros componentes, dependiendo de la versión de la tarjeta y si se utiliza add-on «escudos» o no.
Si conectamos un LED a la placa podemos hacerlo directamente, conectando el ánodo LED de pin digital 13 y el cátodo del led al pin de GND como se ve aquí. Hay que señalar que es interesante conectar entre el pin digital 13 con una resistencia de 220 ohmios para proteger el diodo led , pero estrictamente podría omitirse dicha resistencia.
Por último, este mismo esquema se puede usar para agregar más LEDs o sensores de nuestra placa Arduino para que pueda añadir más funcionalidades. Para ello hay que recordar que en un tablero de alimentación corre horizontalmente en los puntos exteriores y vertical en los puntos interiores
Arduino, software and communications Arduino, software y comunicaciones
En este ejemplo vamos a aprender cómo programar la placa Arduino con el fin de activar el LED se instaló en la segunda parte y se apaga. A continuación, vamos a utilizar una conexión a Internet con WIFI en la placa.
Como requisito previo, hay que ya hemos configurado el software de Arduino según nuestro sistema operativo. Además, hay que tener USB de la placa conectada a nuestro ordenador para cargar el programa a nuestra placa ( consulte aquí para ver cómo instalar el software en una placa Intel Edison).
Debe onviamente seleccionar la versión del software que corresponde a su sistema operativo. Una vez que el software está configurado e instalado abrimos nuestra IDE hasta el comienzo de la codificación.
Vamos a ver un ejemplo de la IDE Arduino. Este ejemplo es específicamente para el IDE para los conjuntos de Intel, aunque los conceptos son los mismos. En la segunda fila de menú (donde el icono de comprobación es), encontrará los comandos para compilar y cargar nuestros desarrollos a la placa. Si examina el código, tenemos dos funciones. Uno es de configuración, donde las variables se inicializan y el bucle en el que se ejecutan las operaciones según se requiera. En el menú Archivo tenemos los ejemplos de opciones – 01 Básico – Blink. Esto mostrará una nueva ventana con el código necesario para poner a prueba nuestra LED:
/*
Blink Parpadeo
Se enciende un LED durante un segundo, luego se apaga durante un segundo, en repetidas ocasiones.
Este código de ejemplo está en el dominio público.
*/ Pin 13 tiene un LED conectado en la mayoría de las placas Arduino.
// Darle un nombre:
int led = 13;
// La instalación se ejecuta de rutina una vez cuando se presiona RESET:
void setup() {
// Inicializar el pin digital como salida.
pinMode (led, OUTPUT);
}
// La rutina de bucle se ejecuta una y otra vez para siempre:
void loop() {
digitalWrite(led, HIGH); // Enciende el LED (ALTA es el nivel de tensión)
delay(1000); // Espera un segundo
digitalWrite(led, LOW); // Apagar el LED haciendo que la tensión BAJA
delay(1000); // Espera un segundo
}
El ejemplo que genera Arduino es bastante simple. En la línea 10 se establece una variable con el número pin correspondiente en la placa . Posteriormente, el pasador la variable se configura como salida y se inicializa. Y, en el bucle, el LED se enciende y se apaga separado por un retraso de un segundo .
Antes de cargar el código anterior en la placa , el IDE se debe configurar para que sepa la placa y qué puerto se está utilizando:
Select Tools> Board> Intel Edison Seleccione Herramientas> Junta> Intel Edison ( para el caso de una placa Intel Edison)
Select Tools> Port> dev / ttyACM0 Seleccione Herramientas> Puerto> dev / ttyACM0
Ahora bien, si la tarjeta está correctamente conectada al puerto USB, podemos ‘Subir’ el código de la tarjeta (Ctrl + U) y deberíamos ver nuestra LED encendido y apagado de cada segundo.
Ahora para usar el wifi, tenemos que trabajar un poco más. Por suerte, en los ejemplos de Arduino, tenemos una sección de WIFI con diferentes alternativas utilizando las soluciones de redes. Entre ellos se encuentran los servidores Telnet y clientes, servidores Web y clientes, e incluso un cliente de Twitter.
CONSEJO: En nuestro caso, por motivos de simplicidad, podemos utilizar un cliente Web ya que vamos a enviar solicitudes posteriormente al corredor Orion Contexto utilizando el protocolo HTTP. Tenga en cuenta que hay mejores soluciones, pero para los propósitos educativos vamos a tratar de minimizar el código tanto como sea posible.
#include <SPI.h>
#include <WiFi.h> >
/ ************************** /
/ * * Configuración de la instalación /
/ ************************ /
char ssid[] = «YourWifiSSID»;//Nombre de la red
char pass[] = «WifiPassword»; //Contraseña de red
char server[] = «130.206.80.47»; // ORION IP address -> Create in /lab/ // Dirección IP ORION -> Crear en / lab /
int status = WL_IDLE_STATUS; int estado = WL_IDLE_STATUS; // we predefine the status as On but not connected // Nos predefinimos la condición pero no conectada
int led = 13; int LED = 13; // We initialize a variable to assign the pin number to which the led will be connected // Inicializamos una variable para asignar el número de identificación personal al cual se conectará el LED
/**
* Configuración Configuración Arduino
* (Ejecutar una sola vez)
**/
void setup() {
// Inititialization del puerto serie Arduino
Serial.begin(9600);
while (!Serial) {
// Esperar para el puerto serie para conectar. y Necesario para Leonardo solamente
}
// Comprobar que la placa tiene un escudo WiFi
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println(«Wifi shield is not available»);
// No continúe con la instalación, o en otras palabras, se quedan aquí para siempre
while(true);
}
El código completo está disponible en:
https://bitbucket.org/tidchile/ecosystem/src/ https://bitbucket.org/tidchile/ecosystem/src/
FIWARE y Orion Context Broker
Como se ha discutido anteriormente en este ejemplo, el Broker de Orión define un contexto como un servicio que en base al stándar OMA NGSI 9/10 puede manejar el envío y recepción de información contextual. ¿Qué significa esto? En primer lugar, para manejar un gran número de mensajes de entidades y administrar las actualizaciones, consultas, y también se encargan suscripciones de datos de las entidades. Recordemos que, según la NGSI 9 y 10 estándares, nos ocupamos de las entidades como una abstracción de los nodos físicos o dispositivos utilizados en las soluciones de la IO.
En el ejemplo anterior, hemos hecho una solicitud de actualización a una entidad ya creada. Pero primero vamos a revisar cómo trabajar con Orión. . Una manera simple de probar el servicio OCB es crear una cuenta en https://account.lab.fiware.org/ y crear una máquina virtual con Orion preconfigurada en la sección de la nube. Alternativamente, el sitio y el acceso GitHub de Orión descargar una máquina virtual para ejecutar en nuestro entorno local
Otra herramienta útil es un cliente REST, pero podemos usar cURL si parece más sencillo. RESTClient es un cliente para Firefox que es bastante fácil de usar.
Los aspectos de configuración de la OCB están fuera del alcance de este tutorial, ya que requeriría demasiados detalles. En cuanto al Laboratorio fiware, es importante tener en cuenta que fiware proporciona máquinas virtuales en la nube de forma gratuita para probar fiware compontents. Sólo tiene que crear una cuenta para acceder a los servicios. Sólo una advertencia rápida. . A partir de hoy (19-03-2015) y temporalmente, España no tiene recursos disponibles, pero hay otras regiones en las que las máquinas virtuales se pueden crear.
Cuando tengamos las herramientas necesarias, la forma más básica para interactuar con la OCB es:
1. Creando una entidad:Para ello hay que tener en cuenta varios factores. En primer lugar, la llamada se envía como una solicitud HTTP POST, por ejemplo, http://myhost.com:1026/v1/updateContext. Con esto queremos decir que estamos ocupando la versión 1 del API con la operación updateContext.
También tenemos que definir varias variables en la cabecera de la solicitud:
Accept: application/json
Content-Type: application/json
X-Auth-Token: [TOKEN AUTHENTICATION]
En cuanto a la generación de tokens, la forma más sencilla es utilizar un script en Python creado por Carlos Ralli en GitHub. Se necesita una cuenta FIWAREy ejecutar el ‘get_token.py se requiere la escritura’.
Después de configurar el encabezado de la solicitud, configurar el «cuerpo» de la solicitud mediante el siguiente código JSON:
{
«contextElements»:[
{
«type»:»LED»,
«isPattern»:»false»,
«id»:»LED001″, «
«attributes»:[
{
«name»:»switch»,
«type»:»bool»,
«value»:»false»
}
]
}
],
«updateAction»:»APPEND»
}
Esta es la estructura de un «contexto Elementos», que es un grupo de entidades con ciertos atributos, tales como, «isPattern» e «id», «tipo». » type » se refiere a un tipo definido y permite la búsqueda de entidades por un tipo particular. «Id» es un atributo que debe ser único para cada entidad para ejecutar búsquedas en base a este ID. «IsPattern» se explicará más adelante en el punto No. 2.
También puede agregar una serie de atributos de la entidad en la propiedad «atributos», donde cada atributo se define por el «nombre», «tipo» y «valor». Por último, «updateAction» define si vamos a realizar un «añadir» o y «UPDATE».
Si todo va bien, vamos a recibir una respuesta 200 OK desde el servidor y que nos dará los detalles de la entidad creada:
{
«contextResponses» :
{
«contextElement» : {
«type» : «LED»,
«isPattern» : «false»,
«id» : «LED001», «
«attributes» :
{
«name» : «switch»,
«type» : «bool»,
«value» : «»
}
]
},
«statusCode» : { «
«code» : «200»,
«reasonPhrase» : «OK»
}
}
]
}
2. Consultar la entidad: Para consultar una entidad, la operación estándar es ‘queryContext’ que sería http://myhost.com:1026/v1/queryContext.También aplicamos las cabeceras que se describen en el punto No. 1 y el uso post.
El JSON utilizado en el cuerpo de la petición sería la siguiente:
{
«entities»:[
{
«type»:»LED»,
«isPattern»:»false»,
«id»:»LED001″
}
]
}
Aquí es donde puede utilizar «isPattern» en «verdadero» y trabajar bien en el campo «tipo» o el campo «id» con expresiones regulares si queremos ejecutar una búsqueda un poco más compleja. En el ejemplo anterior sólo estamos buscando la misma entidad creada a través de la «id».
También hay una manera más sencilla de hacer la misma consulta utilizando la siguiente solicitud: GET http://myhost.com:1026/v1/contextEntities/LED001 donde LED001 es el «id» de la entidad a buscar.
3. Actualización de la entidad: Esto es idéntico al punto No. 1, pero cambiando el atributo «updateAction» de «añadir» a «UPDATE».
Por último, la integración de todo lo que hemos revisado, seremos capaces de generar una acción desde una página Web sencilla que se puede implementar en un servidor remoto y, de hecho demostrar que el LED de la aplicación se activa de forma remota utilizando la OCB.
Para ello vamos a utilizar el LED001 de reciente creación, estableciendo el atributo «interruptor» de verdadero a falso y viceversa para comprobar la acción.
Nuestra web se vería así:
Para ello, el código html, css y js se comparten en: https://bitbucket.org/tidchile/ecosystem/src/ https://bitbucket.org/tidchile/ecosystem/src/
Fuente aqui
Me gusta esto:
Me gusta Cargando...
${Nombre_proyecto}}« como un directorio de inclusión una vez para el «compilador AVR» y el «AVR C++ Compiler»
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.