Proyecto: Descargar datos en MatLAB

El siguiente paso en el proyecto, una vez subidos todos los datos a la red, es descargarlos en nuestro equipo.

Lo primero que se debe hacer es abrir MatLAB e introducir lo siguiente en el cuadro de comandos:

>> data = thingSpeakRead(XXXXXX)

En este caso he introducido la ID de mi canal. Esto sirve a modo de comprobación, si no tienes instalada la toolbox necesaria, ofrecerá el siguiente error:

Cannot detect thingSpeakRead function. Install the ThingSpeak Support Toolbox to use this function.

Ofrece un hipervínculo al que hay que ir para instalar la toolbox necesaria:

En esta sección hay un botón de descargar mediante el cual nos pedirá logearnos con la cuenta de MathWorks. Esta cuenta debe ser la misma que la que se usa para ThingSpeak. Una vez dentro, la herramienta necesaria se instala automáticamente, y el quipo ya esta listo para recoger los datos de la red.

Para recopilar los datos, se va a emplear una función mas completa a la mencionada previamente, que incluye varios campos de información:

[Canal1,timestampsC1] = thingSpeakRead(XXXXXX,'ReadKey','XXXXXXXXXXXXXXXX',
                                     'Fields',[1,2], 'NumPoints',8000)

 Los campos introducidos, por orden:

     - ID del canal

     - Clave de lectura

     - Numero de campos

     - Numero de puntos

Hay que especificar el numero de puntos para que adquiera los datos correctamente. En concreto solo permite coger 8000 en total.

Una vez ejecutado esto, se han creado dos arrays de dos columnas cada uno, ya que tal y como hemos realizado el proyecto, se han creado dos canales para el almacenamiento de los datos. A continuación, se van a juntar los canales. 

Para ello, se han creado dos bucles "for" con los que se pretenden crear un array de una dimensión de valor el doble que los individuales, e ir intercalando los datos de ambos arrays en uno único.

Es importante que el tamaño de ambos arrays sea igual para que el script se ejecute correctamente, por lo que se van a igualar los tamaños, ya que al ser dos canales independientes, es posible que el tamaño de datos difiera. El código empleado es el siguiente:

El resultado graficado es el siguiente:

Proyecto: Graficar datos

En esta entrada se está continuando el proyecto de la Raspberry. En esta ocasión se van a descargar los datos de ThingSpeak y se van a graficar usando Google Charts, html y JavaScript. Como en el caso del programa de Python, esta entrada está muy relacionada con la entrada de la sesión 05. Como el caso anterior, si no has leído la entrada podría ser conveniente echarla un ojo antes de comenzar con esta.

Como siempre, si quieres saltarte toda la explicación, al final de la entrada tienes el código para copiar. Y si no, siempre puedes acudir a GitHub.

Reconstrucción de los datos

Como se querían subir datos cada 10 segundos, se han creado dos canales y se han subido los datos de forma alterna. Por tanto, el primer paso tras descargarlos será reconstruir los datos. Para descárgalos, se hará de forma análoga a la entrada de la sesión 05, solo que esta vez se trabajará con 3 callback functions. Estas funciones se usarán para descargar los datos a graficar. Las funciones que se tendrán serán como la siguientes:

<script type="text/javascript">

  var jsonData01
  function myCallback01(dataWeGotViaJsonp) {
    jsonData01 = dataWeGotViaJsonp['feeds'];
  };
</script>

Esta se realizará tres veces, para los datos del canal 01, los del canal 02 y, finalmente, los datos juntos. El código de las descargas quedará:

<script src="https://api.thingspeak.com/channels/CHANNEL_ID/feeds.json?results=40&amp;callback=myCallback01" type="text/javascript"></script>

<script src="https://api.thingspeak.com/channels/CHANNEL_ID/feeds.json?results=40&amp;callback=myCallback02" type="text/javascript"></script>

<script src="https://api.thingspeak.com/channels/CHANNEL_ID/feeds.json?results=80&amp;callback=myCallback03" type="text/javascript"></script>

La cantidad de resultados pueden variar, pero es importante que los del canal 01 y 02 descarguen la misma cantidad y que la tercera función descargue el doble. Par esta última da igual el canal elegido, lo que se busca es crear la estructura, los datos ya se pisarán.

A la hora de reconstruir los datos es importante detectar cuál ha sido el último canal actualizado. Esto se puede realizar comparando los timestamp. Si el último canal actualizado es el 01, se comenzará la reconstrucción por el 02 y viceversa. 

<script type="text/javascript"> 

  var j =0;

  for(var i=0; i<jsonData.length-1; i++) {

    if(jsonData01[j]['created_at']>jsonData02[j]['created_at']){

      j = i/2;

      jsonData[i]['created_at'] = jsonData02[j]['created_at'];

      jsonData[i]['field1'] = jsonData02[j]['field1'];

      jsonData[i]['field2'] = jsonData02[j]['field2'];

      jsonData[i+1]['created_at'] = jsonData01[j]['created_at'];

      jsonData[i+1]['field1'] = jsonData01[j]['field1'];

      jsonData[i+1]['field2'] = jsonData01[j]['field2'];

      i = i+1; 

    } else {

      j = i/2;

      jsonData[i]['created_at'] = jsonData01[j]['created_at'];

      jsonData[i]['field1'] = jsonData01[j]['field1'];

      jsonData[i]['field2'] = jsonData01[j]['field2'];

      jsonData[i+1]['created_at'] = jsonData02[j]['created_at'];

      jsonData[i+1]['field1'] = jsonData02[j]['field1'];

      jsonData[i+1]['field2'] = jsonData02[j]['field2'];

      i = i+1; 

    };

  }; 

</script>

Y de esta manera se tiene todos los datos en jsonData, con los valores de humedad, temperatura y tiempo bien ordenados. Importante, si no reconstruyes teniendo en cuenta el momento de actualización, al graficar podrías acabar encontrándote con algo como esto:

Graficando

Una vez se tiene los datos bien reconstruidos, graficar es casi lo más fácil. Puedes usar las librerías que más te gusten. En este caso se ha decidido trabajar con Google charts debido a que es muy sencillo de utilizar y perfectamente funcional.

Se van a crear dos gráficas lineales, una para la humedad y otra para la temperatura, y una tabla con los datos que aparecen en las gráficas para que sea más fácil buscar algún en concreto.

El proceso de introducción de los datos es idéntico al de la sesión 05, con la diferencia que en esta ocasión se tendrán 3 ids en el body en vez de tan solo uno. Dos de ellos corresponderán a las gráficas y el tercero será de la tabla.

<body>
   <div id="hum_chart"></div>
  <div id="temp_chart"></div>
  <div id="table_div"></div>
</body>

La visualización sería la siguiente:

El código completo lo tienes a continuación. Y por otro lado, el paso final del proyecto es la descarga de los datos a MatLab para su posterior análisis.

Proyecto: Lectura de datos y subida a ThingSpeak

A estas alturas ya se debería tener la Raspberry completamente configurada, el circuito montado, las librerías necesarias descargadas y la conexión a Internet realizada. Si ves que te falta algún paso, puedes volver a visitar las respectivas entradas, aunque si lo que te falta es la librería se recuerda a continuación:

En este proyecto se va a trabajar con Python 2.7, por lo que habrá que descargar la librería correspondiente que permite trabajar con estos sensores. Se trata de Adafruit_Python_DHT. La forma más fácil de instalar esta librería es mediante el comando sudo pip install Adafruit_DHT. En caso de no reconocerse el comando pip, habrá que instalar pip mediante sudo apt-get install pip y volver a intentarlo.

Recordamos también cuáles eran los requerimientos que debía cumplir el proyecto:

• Creación automática del canal sin intervención del usuario.
• Muestreo cada 10 segundos.

Ya se vio en la entrada de la Sesión 03 y 04 cómo subir datos ThingSpeak mediante un programa escrito en Python. Puede ser conveniente repasar esa entrada, más simple, antes de meterse de lleno en esta.

A continuación, se va a ir explicando paso a paso cómo se ha montado el código. Si quieres saltarte toda la explicación y solo te interesa el código, puedes ir directamente al final de la entrada o incluso al repositorio de GitHub.

Lectura del sensor

Primero hay que preparar las variables y librerías necesarias para trabajar con el sensor.

import Adafruit_DHT
sensor = Adafruit_DHT.DHT11
pin= 23 #conectado al PIN GPIO23

Con esto se tiene importada la librería, definido el Pin por el cual va a entrar los datos y definido el tipo de sensor que se va a usar. El siguiente paso es la lectura del sensor. Para ello se cuenta con dos funciones: Adafruit_DHT.read_retry(sensor, pin) y Adafruit_DHT.read(sensor, pin). La diferencia entre ambas en que retry se ejecuta cada 2 segundos hasta que haya dato, o bien hasta que haya habido 15 intentos. Read lee el dato, pero no asegura que vaya a devolver algo porque no reintenta la lectura.

Como se quieren datos cada 10 segundos y retry no podría asegurarlo, solo se va a usar retry en la primera medida y a partir de ahí read. En caso de que read no encontrara dato, se copiaría el dato anterior.

Como la humedad y la temperatura de una estación meteorológica no son datos que vayan a sufrir variaciones muy rápidas, se considera que es una buena aproximación, aunque exista riesgo de que una variación se detecte diez segundos más tarde. Así, esa parte del código será algo parecido a lo siguiente (recuerda que al final de la entrada tendrás el código completo y preparado para copiar):

#LECTURA DEL SENSOR

if primerflag == 0:

  hum, temp = Adafruit_DHT.read_retry(sensor, pin

  if hum is not None and temp is not None:

    print('Temperatura={0:0.1f}*C Humedad={1:0.1f}%'.format(temp, hum))

    hum01 = hum

    temp01 = temp

    primerflag = 1 #ya se ha obtenido el primer dato

else:

  # No se quiere perder el tiempo con reintento

  # Temp y Hum varían lento, se acepta el margen de error

  # La máxima diferencia con una medida real y una repetida serían 10 segundos

  hum, temp = Adafruit_DHT.read(sensor, pin)

  if hum is not None and temp is not None:

    print('Temperatura={0:0.1f}*C Humedad={1:0.1f}%'.format(temp, hum))

    hum01 = hum

    temp01 = temp

  else:

    hum01 = hum02

    temp01 = temp02

# FIN LECTURA DEL SENSOR

Creación de los canales

La plataforma de ThingSpeak solo permite la subida de datos cada 15 segundos. Por tanto, para “saltar” esa barrera y tener datos cada 10 segundos, se va a trabajar con dos canales. Los datos recogidos del sensor se irán subiendo de forma alterna a un canal y a otro. Por ello, cuando se quieran usar, habrá que montar toda la ristra de datos alternando entre un canal y otro.

La creación de los canales se hace de forma análoga a la entrada de la sesión 03 y 04: primero se crea la conexión TCP. Una vez se confirma se pasa a la creación del canal. La forma de crear los canales es idéntica.

#CREACIÓN DE CANAL 01
#petición HTTP y obtención de respuesta
print("Creando canal 01..."),
method = "POST"
uri = "/channels.json"
headers_01= {'Host': server,
            'Content-Type': 'application/x-www-form-urlencoded'}
payload_01= {'api_key': USER_API_KEY,
            'public_flag':'true',
            'name' : 'Canal 01 automático.',
            'field1' : 'Humedad [%RH]',
            'field2' : 'Temperatura [ºC]'}
payload_01_encoded = urllib.urlencode(payload_01)
headers_01['Content-Length'] = len(payload_01_encoded)
print("\t Enviando petición para crear canal 01...")
connTCP.request(method, uri, body=payload_01_encoded, headers=headers_01)

respuesta_01= connTCP.getresponse()
status_01 = respuesta_01.status
print ("\t Petición de creación canal 01: " + str(status_01))

#Hay que coger los datos del canal para usar más adelante
contenido_01= respuesta_01.read()
# copiamos contenido en formato json a un dict
contenido_01_json = json.loads(contenido_01)
CHANNEL_ID_01 = contenido_01_json['id'
WRITE_API_KEY_01 = contenido_01_json['api_keys'][0]['api_key']

# FIN CREACIÓN DE CANAL 01

ACTUALIZACIÓN (14/02/19): ¡Muy importante! Desde esta misma semana ThingSpeak ha limitado el número de canales en las cuentas gratuitas a cuatro. Si intentas crear un canal teniendo ya los cuatro, recibirás un código 402. 

En teoría ThingSpeak ha avisado a todos los usuarios, pero es posible que el email haya acabado en la bandeja de Spam.

Subida a los canales

De nuevo, este proceso es idéntico al explicado en entradas anteriores. La única diferencia radicará en que ahora, tras recibir la respuesta HTTP se usará el comando Respuesta.read() para asegurarnos de leer correctamente el contenido de la misma. Esto significa que el código será algo parecido a lo siguiente:

# SUBIR DATO AL CANAL 01
# se crea una petición HTTP que sube datos
method = "POST"
relativ_uri = "/update.json"
headers = {'Host' : server,
          'Content-Type' : 'application/x-www-form-urlencoded'}
           payload = {'api_key' : WRITE_API_KEY_01,
          'field1' : hum01,
          'field2' : temp01}
payload_encoded = urllib.urlencode(payload)
headers['Content-Length'] = len(payload_encoded)

# se envía la petición
print("Enviando petición HTTP para subir al canal 01...")
connTCP.request(method, relativ_uri, body=payload_encoded, headers=headers)
#print("Petición enviada!")

# se recibe la respuesta
print("Esperando respuesta HTTP...")
respuesta = connTCP.getresponse()
respuesta.read()
status = respuesta.status
print (str(status))
SubidaCanal01=time.time() #cuando se recibe el 200 se acaba de subir el dato
# FIN SUBIR DATO CANAL 01

Subida cada 10 segundos

Para realizar correctamente dicha subida deberá ocurrir en canales alternativos, y habrá que realizar un control del tiempo. Para ello se importará la librería time mediante el comando import time. Y se establece un timeout = 9.

Lo ideal para conseguir subir cada 10 segundos sería trabajar o bien con MQTT (ya que no se requiere de respuesta al trabajar en modo publisher/subscriber) o bien con real time. Debido a las limitaciones propias de ser novatos en esto, se va a usar TCP y se un valor de timeout menor para compensar el tiempo de ejecución el código. Además de ello, en cuanto se reciba una respuesta 200 que indique que los datos se han subido correctamente, se usará el comando: SubidaCanal01=time.time(). De esta forma en la variable SubidaCanal01 se tendrá el momento en el que ha terminado la subida. A continuación, se iniciará un bucle que medirá el tiempo y permitirá avanzar al código cuando se lleguen a esos 10 segundos de espera. Se hará de forma análoga con el canal 02.

# ESPERAR PARA SUBIR
Medida01 = time.time()
DeltaTiempo2 = Medida01 - SubidaCanal02
while (DeltaTiempo2 Medida01 = time.time() #loop 10 segundos
  Medida01 = time.time()
  DeltaTiempo2 = Medida01 - SubidaCanal02
# FIN ESPERAR PARA SUBIR

El resultado de la subida se puede visualizar como gráfica en la página de ThingSpeak. A continuación se muestra el del canal 01, pero el del canal 02 es similar:

El código completo lo tenéis a continuación. En lo que respecta al proyecto en sí, el siguiente paso es descargar estos datos y graficarlos.

Proyecto: Conexión a Internet

Una vez preparada la Raspberry y conectado el circuito para la medida de temperatura, es necesario crear el código que realice las mediciones. El objetivo del código que se va a desarrollar va a ser leer datos del sensor y subirlos a una plataforma IoT. En este caso se ha decidido que sea ThingSpeak. Además de ello también se han de cumplir los siguientes requerimientos:

• Creación automática del canal sin intervención del usuario.
• Muestreo cada 10 segundos.
• Subir los datos desde la red eduroam de la facultad.

Se va a comenzar explicando como realizar la conexión a internet. Si esta parte no te interesa, puedes saltar directamente a la entrada del código de Python. O si solo te interesa el código de conexión al wifi, puedes ir al repositorio de GitHub.

Conexión a Internet

En caso de haber instalado Raspbian con interfaz gráfica, la conexión se realiza de forma similar a la de cualquier ordenador. Trabajando desde el propio Raspbian, basta con ir a la sección de redes e introducir las credenciales que se soliciten. La dificultad viene cuando se trabaja en línea de comandos. Se va a explicar cómo realizar la conexión usando como supuesto este último caso.

El primer paso va a ser editar el archivo interfaces. Para ello se ha de usar el comando sudo nano /etc/network/interfaces. Este archivo, dependiendo de la versión de Raspbian que se tenga instalado, puede tener dos aspectos.

En el caso de tener un aspecto parecido al que aparece a continuación, significa que se tiene una versión nueva de Raspbian, y no hace falta tocarlo. Hay que dejarlo tal cual viene.

#interfaces(5) file used by ifup(8) and ifdown(8)

#Please note that this file is written to be used with dhcpcd

#For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf'

#Include files from /etc/network/interfaces.d:

source-directory /etc/network/interfaces.d

Otra opción es que tenga un aspecto parecido a:

auto lo

iface lo inet loopback

iface eth0 inet manual

allow-hotplug wlan0

iface wlan0 inet manual

wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

allow-hotplug wlan1

iface wlan1 inet manual

wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

En caso de que el código tenga ese aspecto, va a ser necesario editar este archivo antes de pasar al siguiente paso. El archivo debe dejarse de la siguiente manera:

La línea iface id_str inet dhcp permite añadir más redes, con lo que basta con añadir tantas líneas al código como redes se tengan configuradas en el archivo .config. Por otro lado, id_str deberá sustituirse por el valor que se le haya dado al mismo en el archivo .config.

Si se ha abierto por la consola de comando haciendo uso de sudo, tal y como se indica arriba, para editarlo bastará con seguir las instrucciones que aparecen en la propia consola. Esto es muy importante ya que, si se abre desde el navegador como usuario pi, no se tienen permisos de edición y se denegará la acción.

Editado o no el archivo interfaces (en función de la necesidad), se puede pasar a la edición del archivo .config, necesario en todos los casos. Esto se realizará usando el comando sudo nano /etc/wpa_supplicant/wpa_supplicant.conf Versiones anteriores de Raspbian permiten un archivo .config más simple, pero aquí se va a indicar cómo debe ser el código completo, para que así función en todas las versiones.

Aquí se muestra la configuración más básica, para la red eduroam (requerimiento del proyecto) y un ejemplo de cómo conectarse a la red de casa. Los parámetros que hay que editar son:

• ssid: habrá que poner la de la red a la que se quiere conectar, debe ir entre comillas.
• identity: hay que indicar el usuario, entre comillas.
• password: es la contraseña, también entre comillas.
• id_str: el nombre que le vas a poner a la red para llamarla desde el archivo interfaces (esta línea se puede omitir si no has tenido que editar interfaces).
• psk: contraseña de la red doméstica. Entre comillas.
• Country: iniciales del país de la configuración de Raspbian.

Tras esto, la Raspberry debería ser capaz de conectarse ella sola a internet en cuanto detecte alguna red que coincida con las configuradas en .config. Finalmente, si la Raspberry de repente es incapaz de ver redes, es posible que sea porque:

• Has editado el archivo interfaces cuando no era necesario.
• Hayas incluido la línea id_str="nombre" en el archivo .config cuando no era necesario.

Con la conexión realizada, el siguiente paso será la programación.

Proyecto: Preparación de Raspberry Pi y montaje del circuito

En esta primera parte del proyecto se va a realizar el montaje de la Raspberry al sensor de temperatura y humedad. Las herramientas necesarias serán:

• Raspberry PI
• Tarjeta SD
• Sensor de temperatura y humedad DHT11/DHT22
• Cable HDMI (con adaptador VGA si fuera necesario)
• Pantalla
• Teclado con USB
• Ratón con USB

La Raspberry PI

El primer paso es entender que una Raspberry no es un Arduino: no basta con compilar un programa y cargarlo. Raspberry es un ordenador de placa reducida, y tiene un sistema operativo llamado Raspbian.

Por defecto Raspbian puede venir sin instalar, por lo que es tarea del usuario el instalarlo. La forma más fácil de hacerlo es mediante NOOBS. Para ello será necesario una tarjeta SD de al menos 8Gb (en caso de instalar el SO sin interfaz gráfica podría ser suficiente con 4Gb).

Raspbian se puede descargar desde la página oficial de Raspberry. Una vez realizado esto, habría que cargarlo en la SD. Para ello basta con copiar el contenido de la carpeta NOOBs al completo. Si la SD tenía información o un Raspbian anterior, convendrá formatearla. Recuerda realizar una copia de seguridad de cualquier archivo que desees conservar.

Una vez cargado, se introduce la SD en la ranura destinado a ello en la Raspberry. Para finalizar la instalación será necesario trabajar desde la propia Raspberry. Para ello, conecta el teclado, el ratón y la pantalla. Finalmente, conecta la alimentación.

Raspbian se iniciará y ofrecerá una lista de posibles programas a instalar. Basta con elegir Raspbian y darle aceptar en la advertencia que saldrá. La instalación llevará un tiempo en el que estará la Raspberry trabajando sola.

Con esto ya estaría configurada, pero si aún te queda alguna duda, siempre puedes consultar la página oficial.

Los sensores DHT11/DHT22

Se tratan de unos sensores que miden tanto humedad como temperatura. Ambos sensores vienen en los mismos formatos, funcionan igual y hacen uso de las mismas librerías. Sus diferencias radican en características como exactitud o rango de medida. En lo que respecta a este proyecto, se ha usado el DHT11, pero ambos son válidos.

Tabla extraída de aquí

En este proyecto se va a trabajar con Python 2.7, por lo que habrá que descargar la librería correspondiente que permite trabajar con estos sensores. Se trata de Adafruit_Python_DHT. La forma más fácil de instalar esta librería es mediante el comando sudo pip install Adafruit_DHT. En caso de no reconocerse el comando pip, habrá que instalar pip mediante sudo apt-get install pip y volver a intentarlo.

Una vez instalada la librería, hay que saber cómo conectar el sensor, para lo cual hay que distinguir qué tipo de montaje se tiene: 4 patas sin resistencia pull-up o 3 patas con resistencia pull-up. En caso de tener de 4 patas, será necesario poner la resistencia de pull up de 10k entre el pin de VCC y la salida. Para este proyecto se ha usado la opción de 3 patas con la resistencia pull-up incluída.

Imagen obtenida de aquí

Por supuesto, puede ser que en tu sensor las patas no vengan en este orden. Recuerda siempre revisarlo antes de conectar, y conectarlo siempre en frio, es decir, con la Raspberry sin alimentación.

Es importante saber a qué pata se ha conectado el Pin de Signal/Data, ya que será el que luego se lea desde el programa para obtener los datos. Para ello puede ser útil tener presente la numeración de los mismos.

Imagen obtenida de aquí

Finalmente solo quedaría la conexión del sensor a la Raspberry y ya estaría el circuito montado con las librarías descargadas. Ya se tiene todo listo para funcionar. A continuación, basta con hacer el código, explicado en la siguiente entrada. Por si aún te queda alguna duda, tienes una imagen de cómo seria el circuito a continuación. Además, si sigues teniendo dudas y problemas, puedes consultar el datahseet de estos sensores tanto online como descargándolos en pdf. Son muy buenos e incluyen ejemplos de código y montajes.

Imagen obtenida de aquí

Si quieres saber cómo configurar la conexión a Internet de Raspberry puedes ir aquí. Si en cambio prefieres pasar directamente a la programación, mejor ve aquí.

Proyecto: Introducción

A lo largo de la asignatura de aplicación de las TIC en la investigación, se ha aprendido a realizar ciertas operaciones con aplicaciones web.  Esto incluye a su vez, el conocimiento interno del modo de funcionamiento de dichas web, y el modo de navegar, hacer peticiones y obtener datos sin necesidad de una interfaz física. Este proyecto se basa en esto mismo, en potenciar dichos conocimientos mediante un sistema embebido con conexión a internet.

Para ello, se va a desarrollar una aplicación tipica de la industria 4.0: un sistema recoge datos de un proceso, estos datos se recogen en una plataforma que bien podría ser un servidor  interno o externo, para posteriormente descargar los datos y analizarlos.

Proyecto: recopilacion de datos con Raspberry

Como el título indica, se va a realizar una aplicación de industria 4.0 con una Raspberry Pi. Este sistema embebido junto con el sensor DHT11, que es un medidor de temperatura y humedad, son los que se encargan de recopilar los datos y subirlos a la red gracias a todas las posibilidades de conectividad que ofrece. La lectura de datos y subida se va a realizar cada 10 segundos.

Para el alojamiento de los datos, se va a emplear ThingSpeak, que es una aplicación diseñada exclusivamente para este tipo de tareas. A su vez, permite una alta conectividad con la plataforma MatLAB, que es la seleccionada para realizar los análisis a los datos.

Se va a realizar también una visualización web de los datos recopilados en Google Charts, la descarga de datos a MatLab y un pequeño análisis de los mismos.

En las siguientes entradas, se va a realizar una explicación detallada de cómo se ha llevado a cabo la ejecución de este proyecto. 

Tema 03 - Sesion 06 (31/01/19)

En esta practica se va a realizar una subida y lectura de datos mediante otro protocolo: MQTT

Este protocolo se basa en el modelo publicista-subscriptor, en el que el que produce los datos, los sube a la red, y el subscriptor dispone de ellos cuando quiera. Por lo tanto, no existe un dialogo constante entre ambos, en el que cada cierto tiempo definido se consultan dichos datos.

Para esta práctica se va a definir un broker, que es el que produce los datos. A su vez, se va a crear un tema. Como subscriptor, te puedes inscribir en distintos temas de tu interés. En este ejemplo, hemos creado a un canal en el que se va a subir la información del consumo de CPU y RAM, mediante el protocolo MQTT: