Proyecto: Análisis de los datos

Con los datos obtenidos, y a modo de conclusión, se puede realizar un análisis, que es el objetivo principal de una aplicación IoT como esta. Por lo tanto, se ha elegido la realización de un control difuso para determinar la sensación térmica empleando las dos variables de las que se dispone: humedad y temperatura.

Un controlador difuso de estas características dispone de una serie de reglas que se van a evaluar para cada punto. De cada uno de ellos, se pretende extraer un estado como el se la siguiente tabla:

Pero antes de seleccionar uno de los estados resultado de esta tabla, se debe conocer a qué clase pertenecen la temperatura y humedad, y para ello se va a realizar una evaluación con funciones trapezoidales de cada uno de los puntos.
Para ello, se va a dividir en dos puntos:

Temperatura

La temperatura puede variar desde valores negativos pequeños hasta valores no por encima de los 40, debido a que la zona en la que residimos no tiene picos extremos, los datos tenderán a estar muy agrupados. Esto va a dificultar la calidad de la medida, ya que va a ser mas complicado establecer la diferencia entre un grupo y otro. La distinción que se ha realizado es la siguiente:

Para valores muy bajos se considera frío, las temperaturas medias estarán entre fresco y templado y las extremas por encima se situaran en caluroso. La manera de evaluar donde se sitúa el punto es la siguiente:
Cuando se analiza una temperatura, por ejemplo 17 grados, esta cruza varias rectas, en concreto la de fresco y templado. La clase que se le va a aplicar a esta temperatura, sera el valor más alto obtenido al cruzar por ellas, es decir, unos 0,7 en templado y unos 0,3 en fresco. Por lo tanto, el valor más alto indica que 17 grados es una temperatura templada mayoritariamente. 
Para el análisis de los puntos, se ha creado una estructura condicional en MatLAB:


Esta estructura devuelve siempre 4 valores, que corresponden a las clases. El valor más alto define la clase de temperatura.

Humedad

Para la humedad se va a realizar un análisis idéntico. Sin embargo, en este caso, se ha decidido realizar una división en tres clases de la zona de la gráfica, que oscila entre el 0 y el 100%:

Esto deja tres rangos situados entre baja, suave y alta. La función de evaluación va a ser idéntica a la anterior, devolviendo tres funciones con valor entre cero y la unidad:

Evaluación

Entonces, una vez analizadas ambas variables, toca a continuación realizar una serie de condiciones que encajen con la primera tabla expuesta:

• Si la temperatura es fría y la humedad baja, entonces la sensación es soportable.
• Si la temperatura es fría y la humedad suave, entonces la sensación es mala.
• Si la temperatura es fría y la humedad alta, entonces la sensación es inclemente.
• Si la temperatura es fresca y la humedad baja, entonces la sensación es agradable.
• Si la temperatura es fresca y la humedad suave, entonces la sensación es soportable.
• Si la temperatura es fresca y la humedad alta, entonces la sensación es mala.

Y así con todas las condiciones que dan como resultado un único valor dentro de la tabla de resultados.

Sin embargo, la forma de programar estas funciones, difiere de las anteriores. Entre otros métodos, se ha elegido la funciona mínima como método de evaluación, que consiste en buscar el valor mínimo de las funciones cruzadas que se han visto previamente. Por ejemplo:

• Estado 1: La temperatura es fría y la humedad es baja. Las funciones previas darían como resultado 1 en temperatura y 1 en humedad, por lo que el valor mínimo de ambos es 1. Al ser el valor máximo, con toda probabilidad la sensación térmica es soportable.

Todas estas funciones se programan de esta manera:

Esta función entonces devuelve la probabilidad de que la temperatura pertenezca a uno de los estados de la tabla de sensaciones térmicas. Sin embargo, siguiendo con la programación, se puede depurar un programa que devuelva exactamente la sensación térmica:

La ejecución de esta función devuelve un caso como este:

Con esto se puede analizar del lote de datos, por ejemplo una muestra cada tiempo configurable:


Se ha realizado una división exacta cada 60 muestras, lo que equivale a 10 minutos. Esto devuelve la siguiente ejecución:

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.

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:

Tema 03 - Sesion 05 (29/01/19)

Esta sesión se trata de una continuación de la sesión anterior. Se va a tomar el canal de ThingSpeak creado en la sesión anterior y se van a graficar sus datos.

Dicha gráfica va a programarse mediante html usando para ello Notepad++ como editor y Google Charts como el servicio que creará la gráfica.

Notepad++ se trata de un editor de texto con  soporte para varios lenguajes de programación. En esta sesión se va a trabajar en html, combinándolo con JavaScript. Al trabajar con html hay que crear una suerte de "árbol" del que luego van "colgando" elementos. Así, dentro de <html>...</html> han de incluirse <head>...</head> y <body>...</body>.

Dentro de  <head>....</head> se van a incluir varios <script type="text/javascript">...</script> dentro de los cuáles irá el código en JavaScript. A su vez, dentro de <body>...</body> se va a incluir <div id="curve_chart"></div>.

El código: por partes

La primera línea de código relevante a analizar es la siguiente: <script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>

Con ella se le está indicando al html que tiene un script de tipo JavaScript, y que está en la URI https://www.gstatic.com/charts/loader.js Esto  significa que en cada ejecución se va a descargar el código JavaScript de esa URI, por lo que el código está lo más compactado posible. No tiene casi saltos de línea o espacios, y los nombres de las variables son lo más simples posibles: a, bc, e, etc.
 

El código que aparece en la página de Google Charts trabaja con datos estáticos. Sin embargo, en este caso se quiere trabajar con los datos provenientes de ThingSpeak. Para ello es necesario recuperar esos datos, por lo que se crea la función myCallback, y se utiliza para almacenar los datos.

<script type="text/javascript">

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

<script type="text/javascript" src="https://api.thingspeak.com/channels/[CHANNEL_ID]/feeds.json?api_key=[API_KEY]&results=10&callback=myCallback"></script>

Se observa que se añade &callback=myCallback a la URI. La URI está extraída del propio canal de ThingSpeak, y se trata del Get a Channel Feed que se tiene en la sección Data Import/Export de cada canal. 

El siguiente paso sería crear la gráfica, de nuevo usando JavaScript. Para ello se cargan las funciones tal como se indica en la guía de Google, pero se modifica la función de DrawChart de la siguiente manera:

function drawChart() {
  var data = new google.visualization.DataTable();
  data.addColumn('datetime','Time');
  data.addColumn('number','CPU');
  data.addColumn('number','RAM');
  for(var i=0; i<jsonData.length; i++) {
    var timestamp = jsonData[i]['created_at'];
    var cpu = jsonData[i]['field1'];
    var ram = jsonData[i]['field2'];
    data.addRow([new Date(timestamp), parseFloat(cpu), parseFloat(ram)]);
  };
  var options = {
    title: 'Computer performance', legend: {position: 'bottom'},
    curveType: 'function', colors: ['red','blue'],
    series: {0: {targetAxisIndex:0},1:{targetAxisIndex:1}},
    vAxes: {0: {title: '%CPU'},1:{title: '%RAM'}}
  };
  var chart = new google.visualization.LineChart(document.getElementById('curve_chart'));
  chart.draw(data,options);
}

Con data.addColumn se añaden los datos deseados, que en este caso son el tiempo, el %CPU y el %RAM. Mediante un for se cargan los datos de ThingSpeak a las variables timestamp, ram y cpu. A continuación se especifican las opciones, que serán las que darán el aspecto visual a la gráfica.

El código: resultados

Todo este código se encuentra dentro un archivo .html, con lo que para ver su resultado se puede abrir el fichero con el navegador.

Finalmente, el código completo está a continuación, donde solo habrá que editar los huecos indicados por [MAYÚSCULAS] según sea necesario.

Tema 03 - Sesion 03 y 04 (24/01/19)

En la clase de hoy se ha hecho uso de la herramienta de programación Python para la realización de peticiones HTTP en ThingSpeak similar a lo realizado previamente. La sesión de hoy se va a dividir en dos ejercicios.

EJERCICIO 1: Visualización del uso de RAM y CPU del pc y envío de datos a ThingSpeak  

En este ejercicio, se va a realizar un programa en la herramienta Python que lea el consumo de CPU y RAM del ordenador para después subirlo a la red mediante la API REST que hemos visto con anterioridad, con un previo borrado del canal.

Lo primero de todo va a ser abrir Python y descargar la librería Psutil, que se realiza escribiendo en el terminal de la aplicación: pip install psutil. Este comando ejecuta la instalación directamente, sin necesidad de pasos adicionales. Una vez que esté instalada, estamos listos para la realización del ejercicio.  

En cualquier programa de Python, el primer paso es añadir las librerías:

import psutil
import httplib
import urllib

Estas tres librerías son las que van a permitir realizar, tanto la lectura del consumo, como las peticiones HTTP necesarias para subir los datos a la red.

A continuación, se debe realizar una conexión TCP al servidor deseado, por lo que se añade tanto la dirección del servidor como la definición de la conexión:

server = 'api.thingspeak.com'
connTCP = httplib.HTTPSConnection(server)
Write_apkey = 'GTXNVDI95SFSUDRQ'
Delete_apkey = 'KEJU9WAA6A7VQS2C'

Se pueden poner visualizaciones con print a modo de depuración, es decir, a la hora de ejecutar el código, se se ejecuta la linea print, significa que el programa hasta esa linea es correcto. Se realiza la conexión:

print("Estableciendo conexion TCP..."),
connTCP.connect()
print("Conexion TCP establecida")

Una vez realizada la conexión, debemos establecer las reglas del diálogo con el servidor. Empleando la información obtenida del REST API, se incluyen aquellos campos necesarios, que son el formato y la llave de escritura de la que disponemos en nuestra pagina de ThingSpeak.

En este código se puede ver el recurso DELETE, la URI relativa a la que apunta el programa, las cabeceras y el contenido del mensaje. Debido a que el contenido del mensaje es una librería Python que el servidor web puede no reconocer, se decodifica a json para realizar una petición que sí entienda.

La última línea sirve para añadir la longitud del mensaje en la librería de la cabecera.

methodC1 = "DELETE"
relative_uriC1 = "/channels/680589/feeds.json"
headersC1 = {'Host': server,
           'Content-Type': 'application/x-www-form-urlencoded'}
payloadC1 = {'api_key': Delete_apkey}
payload_encodedC1 = urllib.urlencode(payloadC1)
headersC1['Content-Length'] = len(payload_encodedC1)

Para realizar la conexión y el envío de la petición, se emplea el código a continuación:

connTCP.request(methodC1, relative_uriC1, body=payload_encodedC1, 

headers=headersC1)
respuestaC1 = connTCP.getresponse()
statusC1 = respuestaC1.status
print(str(statusC1))

El comando STATUS nos va a devolver el resultado de la conexión, siendo 200 una petición correcta.

Con esta petición, se ha solicitado el borrado del canal previo a la subida de los datos.

Una vez estén los datos borrados, se va a realizar una subida de nuevos datos, para lo cual se va a realizar una estructura WHILE que va a ejecutar indefinidamente el segmento siguiente:

try:
    while(True):
        cpuPercent = psutil.cpu_percent(interval=15)
        ramPercent = psutil.virtual_memory().percent

        print("%CPU: " + str(cpuPercent)),
        print("\t%RAM: " + str(ramPercent))

        method = "POST"
        relative_uri = "/update.json"
        headers = {'Host' : server,
                   'Content-Type' : 

                      'application/x-www-form-urlencoded'}
        payload ={'api_key' : Write_apkey,
                  'field1': cpuPercent,
                  'field2': ramPercent}

        payload_encoded = urllib.urlencode(payload)
        headers['Content-Length'] = len(payload_encoded)

        print("Enviando peticion HTTP..."),
        connTCP.request(method, relative_uri, body=payload_encoded, 

                        headers=headers)
        print("Peticion enviada")
        print("Esperando respuesta HTTP...")

        respuesta = connTCP.getresponse()
        status = respuesta.status
        print(str(status))

Con una estructura similar al borrado pero empleando el recurso POST, se envian los datos al servidor realizando la peticion HTTP.

Para detener la ejecución del programa, se presiona CTRL+C, y se adjunta una linea de comandos para la realización de una secuencia de apropiada, junto con el cierre de la conexión:

except KeyboardInterrupt:
    connTCP.close()
    print("Se ha pulsado CTRL+C. Saliendo del programa")

EJERCICIO 2: Creación de un canal, subida de datos y borrado del canal al finalizar

En este ejercicio, como indica en el título, se va a crear un código que cree un canal, obtenga la información necesaria para subir datos a ese canal, y después borrarlo a la salida de la ejecución. El código es el siguiente:

Tema 03 - Sesión 03, Preparación (24/01/19)

La tercera sesión de esta asignatura será doble y en ella se trabajará con peticiones HTTP, Thingspeak y Python. Con el objetivo de preparar la sesión, se han mandado una serie de ejercicios para terminar de afianzar lo explicado en las sesiones 1 y 2

Ejercicio 01: Envío de datos con formulario

En la URI http://august-outlet-228919.appspot.com/ hay un formulario que permite obtener la letra de un DNI. Se pide: 

a ) Ver qué es lo que ocurre cuando se solicita la URI anteriormente indicada. 

Se obtiene un código 302: redirige a https://august-outlet-228919.appspot.com/html/form.html

 
b) Introducir un DNI válido y ver a qué URI se envía la petición.
La petición se envía a https://august-outlet-228919.appspot.com/obtener Letra. Como tiene espacio, en la petición este se convertirá en un %

c) Obtener los siguientes parámetros:

• Nombre del parámetro asociado al DNI: nan
• Nombre y el valor de los parámetros ocultos adicionales: ezkutua: kalkulatu

d) Editar manualmente en Burp la petición HTTP para obtener la letra y comprobar que la respuesta HTTP contiene la letra en el cuerpo del mensaje.
La petición a enviar será de la forma:

POST /obtener%20Letra HTTP/1.1
Host: august-outlet-228919.appspot.com
Content-Type: application/x-www-form-urlencoded
Content-Length: [largura_mensaje]

nan=22725983&ezkutua=kalkulatu

Donde [largura_mensaje] deberá sustituirse por el valor adecuado en cada caso. Burp lo rellena automáticamente. El valor de nan también deberá modificarse a conveniencia.

Petición de letra

Respuesta entregada por el servidor

Ejercicio 02: Enviar datos en formato formulario a ThingSpeak y recibir una respuesta vacía

Siguiendo la documentación de Matlab para trabajar con ThingSpeak se hace la petición desde Burp Suite. El canal a actualizar es el ya creado durante la sesión número 02. El formato de la petición será:  

POST /update HTTP/1.1

Host: api.thingspeak.com

Content-Type: application/x-www-form-urlencoded

Content-Length: [largura_mensaje]

api_key=[channel_api_key]&field1=[valor_campor_1]&field2=[valor_campo_2] 

• [channel api_key] habrá que sustituirlo entero por el api_key del canal.
• [valor_campor_1] y [valor_campor_2]: se deberán sustituir por lo valores que se quieren subir al canal.
• [largura_mensaje]: se deberá sustituir por la largura del mensaje (depende de cada caso y Burp lo rellena automáticamente)

La respuesta entregada por el servidor así como los datos actualizados en el canal pueden observarse a continuación:

Respuesta del servidor: está vacia

Ejercicio 03: Enviar los datos en formato formulario y recibir una respuesta en formato JSON

De nuevo, la petición será de la forma: 

POST /update.json HTTP/1.1

Host: api.thingspeak.com

Content-Type: application/x-www-formurlencoded

Content-Length: [largura_mensaje]

api_key=[channel_api_key]&field1=[valor_campor_1]&field2=[valor_campo_2]

La respuesta entregada por el servidor así como los datos actualizados en el canal pueden observarse a continuación:

Respuesta del servidor

Ejercicio 04: Enviar los datos en formato JSON y recibir una respuesta en formato XML

Esta vez la petición se hace en formato json, con lo cual cambia un poco su aspecto respecto a las veces anteriores 

POST /update.xml HTTP/1.1

Host: api.thingspeak.com
Content-Type: application/json
Content-Length: [largura_mensaje] 

{"api_key":"[channel_api_key]","field1":=[valor_campo_1],"field2":=[valor_campo_2]} 

La respuesta entregada por el servidor así como los datos actualizados en el canal pueden observarse a continuación:

Respuesta del servidor

Tema 03 - Sesión 02 (17/01/19)

En esta sesión, se ha introducido una nueva herramienta de análisis de datos:

Es una plataforma abierta basada en el principio IoT que hace uso de MatLAB para la recopilación y análisis de datos en la nube, teniendo una opción gratuita y otra de pago.

En nuestro caso se ha elegido la gratuita, que únicamente permite subir datos limitados en cantidad y tiempo, cada 15 segundos máximo. Sin embargo, para nuestro uso educacional es suficiente. El funcionamiento de este sistema es sencillo.

Los dispositivos proncipales son Smart Devices conectados a la red, los cuales recopilan datos de cualquier tipo. Estos datos, se suben directamente a este servidor en la nube, en el cual se pueden visualizar y analizar directamente desde el navegador web. Como añadido, estos datos se pueden descargar a MatLAB para realizar análisis mas detallados.

A continuación, veremos como se suben los datos a la plataforma web:

CHARTS 

Los datos almacenados se organizan de manera muy sencilla en las tablas de datos. Esto es una representación visual que es accesible desde cualquier plataforma, y tiene el siguiente aspecto:

Para introducir los datos aquí, debemos hacer uso de una API específica: 

REST API

Rest API es un entorno de programación de aplicaciones basado en MatLAB que permite realizar ciertas operaciones respecto a la base de datos ThingSpeak. Podemos encontrar diferentes apartados como los siguientes:

En este primer acercamiento, nos vamos a centrar en la subida de datos a la nube. Para ello, se han creado dos tablas vacías e idénticas a las del ejemplo previo.

Se puede realizar mediante dos funciones, GET o POST, pero nos vamos a centrar en POST en este ejemplo. La especificación API define como hay que realizar la petición de envió de datos, la cual se puede realizar de la siguiente manera, empleando el programa BurpSuite, mencionado en anteriores artículos.

Primero se va a apuntar a la dirección web apropiada:

La siguiente va a ser la realización del envío de información, para lo cual empleamos la REST API mencionada previamente. Dicho esto, la petición queda de la siguiente manera: 

Como es una petición de escritura, se adjunta en el cuerpo la clave privada de escritura. Una vez realizado todo esto, se observa el resultado:

Como el valor recibido de la petición es 200, todo esta correcto, y el dato se ha cargado completamente.