En este post vamos a ver como haciendo uso de módulos nos permite hacer que nuestros programas sean más robustos y poderosos a medida que aprovechamos el código existente. También podemos crear nuestros propios módulos para nosotros y para que otros programadores los utilicen en programas futuros.
El lenguaje de programación Python viene con una variedad de funciones integradas . Entre estas se encuentran varias funciones comunes, que incluyen:
print() que imprime expresiones
abs() que devuelve el valor absoluto de un número
int() que convierte otro tipo de datos en un entero
len() que devuelve la longitud de una secuencia o colección
Sin embargo, estas funciones integradas son limitadas y podemos hacer uso de módulos para hacer programas más sofisticados.
Los módulos son archivos con extension .py de Python que constan lógicamente de código Python. Se puede hacer referencia a cualquier archivo de Python como módulo. Un archivo de Python llamado hello.py tiene el nombre de módulo hello que puede importarse a otros archivos de Python o usarse en el intérprete de línea de comandos de Python.
Los módulos pueden definir funciones , clases y variables a las que puede hacer referencia en otros archivos .py de Python o mediante el intérprete de línea de comandos de Python.
En Python, se accede a los módulos mediante la instrucción import . Cuando hacemos esto, ejecutamos el código del módulo, manteniendo los alcances de las definiciones para que tus archivos actuales puedan hacer uso de estos.
Cuando Python importa un módulo llamado, hello por ejemplo, el intérprete primero buscará un módulo incorporado llamado hello. Si no se encuentra un módulo integrado, el intérprete de Python buscará un archivo nombrado hello.py en una lista de directorios que recibe de la variable sys.path.
Vamos a ver la verificación e instalación de módulos, la importación de módulos y los módulos de alias.
Comprobación e instalación de módulos
Hay varios módulos que están integrados en la biblioteca estándar de Python , que contiene muchos módulos que brindan acceso a la funcionalidad del sistema o brindan soluciones estandarizadas. La biblioteca estándar de Python es parte de cada instalación de Python.
Para comprobar que estos módulos de Python están listos para funcionar, ingrese a su entorno de programación Python 3 local o al entorno de programación basado en servidor e inicie el intérprete de Python en su línea de comando así:
python
Desde dentro del intérprete, puede ejecutar la declaración import para asegurarse de que el módulo dado esté listo para ser llamado, como en:
import math
Dado que math es un módulo integrado, su intérprete debe completar la tarea sin comentarios, volviendo a la indicación. Esto significa que no necesita hacer nada para comenzar a usar el módulo math.
Ejecutemos la declaración import con un módulo que quizás no haya instalado, como la biblioteca de trazado 2D matplotlib:
import matplotlib
Si matplotlib no está instalado, recibirá un error como este:
Output
ImportError: No module named 'matplotlib'
Puede desactivar el intérprete de Python con CTRL + D y luego instalarlo matplotlibcon pip.
A continuación, podemos utilizar pip para instalar el módulo matplotlib:
pip install matplotlib
Una vez que esté instalado, puede importar matplotlib en el intérprete de Python usando import matplotlib, y se completará sin errores.
Importación de módulos
Para hacer uso de las funciones de un módulo, deberá importar el módulo con una declaración import
Una declaracion import se compone de la palabra clave import junto con el nombre del módulo.
En un archivo de Python, esto se declarará en la parte superior del código, debajo de las líneas shebang o comentarios generales.
Entonces, en el archivo de programa de Python my_rand_int.py importaríamos el modulo random para generar números aleatorios de esta manera: my_rand_int.py
import random
Cuando importamos un módulo, lo ponemos a nuestra disposición en nuestro programa actual como un espacio de nombres separado. Esto significa que tendremos que referirnos a la función en notación de puntos, como en [module].[function].
En la práctica, con el ejemplo del módulo random, esto puede parecer una función como:
random.randint() que llama a la función para devolver un entero aleatorio, o
random.randrange() que llama a la función para devolver un elemento aleatorio de un rango especificado.
Creemos un ciclo for para mostrar cómo llamaremos a una función del módulo random dentro de nuestro programa: my_rand_int.py
import random
for i in range(10):
print(random.randint(1, 25))
Este pequeño programa primero importa el módulo random en la primera línea, luego se mueve a un ciclo for que trabajará con 10 elementos. Dentro del ciclo, el programa imprimirá un número entero aleatorio dentro del rango de 1 a 25 (inclusive). Los enteros 1 y 25se pasan a random.randint()como sus parámetros.
Cuando ejecutamos el programa con python my_rand_int.py, recibiremos 10 enteros aleatorios como salida. Debido a que estos son aleatorios, es probable que obtenga diferentes enteros cada vez que ejecute el programa, pero se verán así:
Output
6
9
1
14
3
22
10
1
15
9
Los números enteros nunca deben estar por debajo de 1 o por encima de 25.
Si desea utilizar funciones de más de un módulo, puede hacerlo agregando varias declaraciones import a my_rand_int.py
import random
import math
Es posible que vea programas que importan varios módulos con comas que los separan, como en import random, math, pero esto no es coherente con la Guía de estilo de PEP 8 .
Para hacer uso de nuestro módulo adicional, podemos agregar la constante pi de math a nuestro programa y disminuir el número de enteros aleatorios impresos: my_rand_int.py
import random
import math
for i in range(5):
print(random.randint(1, 25))
print(math.pi)
Ahora, cuando ejecutamos nuestro programa, recibiremos una salida que se ve así, con una aproximación de pi como nuestra última línea de salida:
Output
18
10
7
13
10
3.141592653589793
La declaración import le permite importar uno o más módulos a su programa Python, permitiéndole hacer uso de las definiciones construidas en esos módulos.
Usando from…import
Para hacer referencia a elementos de un módulo dentro del espacio de nombres de su programa, puede usar la declaración from… import. Cuando importa módulos de esta manera, puede hacer referencia a las funciones por su nombre en lugar de mediante la notación de puntos
En esta construcción, puede especificar qué definiciones hacer referencia directamente.
En otros programas, puede ver que la declaración import toma referencias a todo lo definido dentro del módulo mediante el uso de un asterisco ( *) como comodín, pero PEP 8 lo desaconseja. .
Primero veamos la importación de una función específica, randint()desde el módulo random en my_rand_int.py
from random import randint
Aquí, primero llamamos a la palabra clave from, luego al módulo random. A continuación, usamos la palabra clave import y llamamos a la función específica que nos gustaría usar.
Ahora, cuando implementemos esta función dentro de nuestro programa, ya no escribiremos la función en notación de puntos como, random.randint()sino que simplemente escribiremos randint() en my_rand_int.py
from random import randint
for i in range(10):
print(randint(1, 25))
Cuando ejecute el programa, recibirá un resultado similar al que recibimos anteriormente.
Usando la construcción from…import nos permite hacer referencia a los elementos definidos de un módulo dentro del espacio de nombres de nuestro programa, lo que nos permite evitar la notación de puntos.
Módulos de aliasing
Es posible modificar los nombres de los módulos y sus funciones dentro de Python usando la palabra clave as.
Es posible que desee cambiar un nombre porque ya ha usado el mismo nombre para otra cosa en su programa, otro módulo que ha importado también usa ese nombre, o puede abreviar un nombre más largo que está usando mucho.
La construcción de esta declaración se ve así:
import [module] as [another_name]
Modificaremos el nombre del módulo math en nuestro archivo de programa my_math.py. Cambiaremos el nombre del módulo de matha m para abreviarlo. Nuestro programa modificado se verá así: my_math.py
import math as m
print(m.pi)
print(m.e)
Dentro del programa, ahora nos referimos a la constante pi como m.pi en lugar de math.pi .
Para algunos módulos, es habitual utilizar alias. La documentación oficial del módulomatplotlib.pyplotr equiere el uso de pltcomo alias:
import matplotlib.pyplot as plt
Esto permite a los programadores agregar la palabra más corta plt a cualquiera de las funciones disponibles dentro del módulo, como en plt.show().
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.
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
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:
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.
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:
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/
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
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:
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), sonsensores 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.
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
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:
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.
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:
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:
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.
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/ )
Soloelectronicos.com 
Debe estar conectado para enviar un comentario.