Thingspeak: fondamenti

Thingspeak: una piattaforma per IoT
Mobile And Cyber-physical Systems
Augusto Ciuffoletti
5 marzo 2018

Le piattaforme per IoT
• E’ opinione diffusa che l’Internet of Things dominerà il
mercato ICT nel prossimo futuro
• Quindi stanno proliferando piattaforme per applicazioni IoT
• ...strumenti in rapida evoluzione, con forti investimenti
• Una caratterizzazione di una piattaforma per IoT
• raccoglie dati da dispositivi IoT
• fornisce un supporto di sicurezza per lo scambio dei dati
• presenta ed aggrega i dati raccolti
• li usa per innescare azioni
• Queste funzionalità sono generalmente supportate da
risorse di cloud
• ...questo genere di applicazioni si può conﬁgurare come
SaaS (Software as a Service)
• ...ma anche come PaaS (Platform as a Service)
• Ma le cose sono destinate a cambiare nel prossimo futuro

L’offerta di piattaforme IoT
• I protagonisti dell’ICT hanno la loro offerta di servizi IoT
• Amazon sta preparando un AWS IoT
• Microsoft ha un progetto Azure IoT
• IBM offre Watson
• CISCO ha un progetto IoT (con attenzione a Edge
Computing)
• Oracle offre un IoT Cloud Service
• General Electric ha un componente IoT chiamato Predix
Service
• Poi esistono servizi commerciali indipendenti
• Thing Workx
• Salesforce IoT specializzato sulla manutenzione
• Carriots
• Inﬁne il middleware per realizzare piattaforme IoT
• Kaa, Opens Source middleware
• ThingSpeak, che offre sia il middleware che un servizio
• ...con un Free Plan interessante

ThingSpeak: servizio e middleware
• ThingSpeak ha due distinte offerte:
• un servizio web su https://thingspeak.com
• il codice Open Source del middleware per la realizzazione
del servizio su risorse proprie
• Il free plan del Web Service consente di
• caricare sulla piattaforma 8200 messaggi al giorno
• con la frequenza massima di uno ogni 15 secondi
• Il server ThingSpeak offre:
• una interfaccia REST/HTTP per l’invio dei dati
• la possibilità di trattare e visualizzare i dati con MATLAB
• rielaborazione dei dati per creare nuovi documenti
• integrazione con twitter per inviare e ricevere comandi
• produzione di REQUEST HTTP di tipo GET e POST
• innesco delle operazioni sulla base dei dati
• feedback verso il dispositivo

L’interfaccia REST di ThingSpeak
• L’interfaccia REST consente di utilizzare il protocollo HTTP
per operare su una risorsa remota
• per se REST non implica HTTP
• Il funzionamento stateless di REST si adatta bene alla
inaffidabilità dei dispositivi
• Librerie HTTP sono presenti per molti dispositivi IoT
• Per il trasferimento si usa una comune connessione ad
Internet
• L’uso di standard diffusi (HTTP, JSON ecc.) semplifica
l’interoperabilità dei dispositivi
• Semplicità di progetto di nuovi dispositivi
• Ma REST non è la fine della storia: sono in arrivo i
protocolli publish/subscribe come MQTT

Il channel di ThingSpeak
• L’entità base di ThingSpeak è il channel
• Rappresenta il valore di una o più variabili in tempi
successivi
• Ad un certo channel è associata un identiﬁcatore
• Più dispositivi possono riversare dati sullo stesso channel
• Per accedere al channel è necessaria una password
• Write API key per scrivere
• Read API key per leggere (il channel può essere privato)
• Ad esempio, i diversi dispositivi di una centralina
metereologica possono separatamente riversare i propri
dati in un channel

Il field di ThingSpeak
• Ciascuna delle variabili che compongono un channel si
chiama field
• Ad esempio, nella centralina ci può essere un field per la
temperatura
• I field hanno idenficatori fissi: field1, field2 ecc.
• L’operazione di inserimento di uno o più valori in un certo
channel si chiama feed
• un singolo feed può interessare diversi field
• Un feed può essere realizzato in due modi:
• con un POST che contenga nel body della REQUEST le
coppie (field, valore)
• con un GET che contenga nella URI le coppie (field,valore)

Il field di ThingSpeak
• Ciascuna delle variabili che compongono un channel si
chiama field
• Ad esempio, nella centralina ci può essere un field per la
temperatura
• I field hanno idenficatori fissi: field1, field2 ecc.
• L’inserimento di uno o più valori in un certo channel si dice
feed
• un singolo feed può interessare diversi field
• Un feed può essere realizzato in due modi:
• con un GET che contenga nella URL della REQUEST le
coppie field=valore
• con un POST che contenga nel body della REQUEST le
coppie field=valore

Prepariamo il laboratorio: account ThingSpeak
• Accedete a http://thingspeak.com e click su Get started for
free
• Compilate il form:
• indirizzo di email valido
• un nome utente compatto
• una password da annotare
• nome e cognome
• poi premere Continue
• attendere l’arrivo dell’email di conferma (circa 30 secondi)
• Cliccate il link nella mail
• conferma la creazione dell’account MathWorks
• Tornate alla pagina http://thingspeak.com
• Utilizzate le nuove credenziali per il Sign In

Iniziamo a usare ThingSpeak
• Creare un nuovo canale (channel)
• Configuratelo pubblico (tutti possono leggere)
• Annotate l’id del canale (in alto a sinistra), (NNNNNN)
• Annotate la chiave di scrittura (nella linguetta "Chiavi API")
(XXXXXXXXXXXXXXXX)
• Un field è di default, potete definirne altri mettendo le
crocette
• Nella schermata del canale ciascun campo è
rappresentato con un grafico
• controllate l’effetto della matita in alto a destra

Laboratorio
• Per provare la Web API di thingspeak possiamo utilizzare il
nostro browser
• quando accediamo ad una URL facciamo una GET
• Per inserire un nuovo feed, impostiamo nel campo della
URL
https://api.thingspeak.com/update?api_key=XXXX&field1=18
• sostituendo alle X la vostra chiave di scrittura
• Osserviamo che riceviamo come risposta un singolo
numero
• è il numero d’ordine del dato inserito
• ricordate che non potete inserire un nuovo dato prima di 15
secondi
• Ora spostiamoci sulla visualizzazione graﬁca del channel
• entro brevissimo tempo dovrebbe apparire un punto con
ordinata 18, e ascissa l’ora del giorno
• Ripetete aggiungendo altri punti
• ricordate la regola dei 15 secondi

Proviamo con Python
• Tuttavia noi vogliamo che sia un programma ad inserire i
dati
• Il programma che segue accede al server thingspeak e
alimenta il canale con un nuovo dato
• Svolge la stessa funzione dell’esercizio precedente:
• una GET con il dato nella URL

Proviamo con Python (feed_get)
import httplib, json
api_key="XXXX"
conn = httplib.HTTPSConnection("api.thingspeak.com") # Apro la connessione
# Invio la request
conn.request(
"GET", # metodo HTTP
"/update?field1=25&api_key="+api_key # HTTP header
)
response = conn.getresponse()
print response.status, response.reason
print response.read()
conn.close()

Proviamo con Python (POST)
• La stessa funzione può essere ottenuta anche con un
POST
• Per questo i dati devono essere inseriti nel body con un
formato appropriato
• sono codiﬁcati in JSON: breve excursus per capire cosa è

JSON: un semplice linguaggio per descrivere dati
• Un dato JSON viene chiamato oggetto (object), e
corrisponde ad una mappa che associa chiavi con valori;
• L’oggetto è esso stesso un valore, quindi un oggetto può
contenere altri oggetti;
• Anche una sequenza (array) di valori è considerata un
valore
• In JSON esistono solo due valori elementari: stringa e
numero
• Poi esistono tre costanti: true, false e null
• Come elementi separatori sintattici si usano le parentesi, la
virgola e i due punti

Un esempio
• Ad esempio, consideriamo un oggetto complesso che
rappresenta una scatola nello scaffale di una ferramenta,
con il suo contenuto, il fornitore, gli ordini passati, la scorta;
• Immaginiamo una scatola che contiene 100 viti, forniti da
Giuseppe in Via dei Tigli, con uno storico di tre ordini e la
scorta presente
• Viene rappresentata in JSON con la seguente stringa di
caratteri:
{ "contenuto":"viti",
"scorta":"true",
"fornitore": {"nome":"Giuseppe",
"indirizzo":"Via dei Tigli"
}
"ordini":[201,221,341]
}

POST in Python (feed_post)
import httplib, json
api_key="XXXX"
# Il documento da inserire come oggetto Python (insieme di coppie chiave−valore)
feed = {
"api_key":api_key,
"field1":"30"
}
feed_json=json.JSONEncoder().encode(feed) # Lo codiﬁco in JSON
conn = httplib.HTTPSConnection("api.thingspeak.com") # Apro la connessione
conn.request(
"POST", # metodo HTTP
"/update", # URL
feed_json, # HTTP body
{"Content-type": "application/json"} # HTTP header
)
response = conn.getresponse()
conn.close()

Alimentazione automatica di un canale (ts_test)
• Il programma che segue alimenta un canale con un intero
progressivo
• Il periodo di generazione dei dati è di 20 secondi
#!/usr/bin/python
import time, sys, httplib
if len(sys.argv) != 2: # Controllo parametri
print("nUsage: ts_test.py <writekey>n")
exit(1)
writekey=sys.argv[1]
n=0
while True:
conn = httplib.HTTPSConnection("api.thingspeak.com") # Apertura connession
conn.request("GET","/update?field1="+str(n)+"&api_key="+writekey) # Invio request
response = conn.getresponse() # Attendo la response
print response.status, response.reason # Stampo l’esito
time.sleep(20) # 20 secondi...
n=n+1

Prelevare i dati registrati in un channel
• E’ possibile utilizzare l’interfaccia REST per prelevare i dati
di un channel
• Utilizzando il browser, impostare la URL seguente
https://api.thingspeak.com/channels/NNN/feeds.json
• Il valore NNN nel path è l’identiﬁcatore del channel
(pubblico)
• I dati vengono restituiti in JSON: facili da elaborare
• Attenzione: se il canale non è pubblico, dovrete
aggiungere anche la chiave di lettura
• come elemento della richiesta
https://api.thingspeak.com/channels/NNN/feeds.json?api_key=XXXX

Un programma per il download dei dati (ts_download)
#!/usr/bin/python
import sys, httplib, json
print("nUsage: ts_sensor.py <channel id>n")
exit(1)
channel_id=sys.argv[1] # acquisizione parametri
connection = httplib.HTTPSConnection("api.thingspeak.com") # apertura connessione
connection.request("GET", "/channels/"+channel_id+"/feeds.json") # invio request
response = connection.getresponse() # ricezione response
print response.status, response.reason # startline response
#print response.read()
my_hash=json.loads(response.read())
print json.dumps(my_hash,indent=2)
• NOTA: per avere una risposta più leggibile togliete i
commenti in fondo e commentate la riga precedente

Ancora per selezionare ed elaborare dati
• Posso scaricare solo gli ultimi cinque dati. Esempio:
https://api.thingspeak.com/channels/NNN/feeds.json?results=5
• Nell’esempio scarico cinque valori di tutti i campi del
canale
• Posso scaricare gli ultimi valori di un campo (ﬁeld)
https://api.thingspeak.com/channels/NNN/fields/1.json?results=2
• Oppure mediarli su intervalli temporali. Esempio:
https://api.thingspeak.com/channels/NNN/feeds.json?result=40&average=10
• Nell’esempio scarico quaranta dati, e li medio su intervalli
di dieci minuti
• l’intervallo è deﬁnito in minuti: valori ammessi 10,15,20,30...
• https:
//it.mathworks.com/help/thingspeak/get-a-channel-feed.html
• Provate le stesse funzionalità con Python

Realizzare nuovi graﬁci (chart.html)
• Con il feed può essere creato un graﬁco sul browser
https://api.thingspeak.com/channels/NNN/charts/1?results=20&average=10
• Può essere facilmente incorporato in una pagina web:
<html>
<body>

<iframe
width="450"
height="250"
src="http://thingspeak.com/channels/NNNNNN/charts/1?average=10"
>
</iframe>
</body>
</html>

Laboratorio
• Provate gli esempi sul vostro channel
• Create un nuovo field ed eseguite esercizi simili su
ambedue i campi
• Modificate i programmi per alimentare o scaricare
ambedue i campi
• Modificate i programmi per scaricare gli ultimi dati
• Modificate i programmi per ottenere i dati mediati
• Realizzate una pagina che mostri diversi grafici, incluso il
nuovo field

Esempio: monitorare un server (ServerMonitor)
import time, sys, httplib, json, psutil
print("nUsage: ServerMonitor.py <writekey>n")
exit(1)
while True:
body = json.JSONEncoder().encode(
{ "field1": psutil.cpu_percent(), # percentuale cpu occupata
"field2": psutil.virtual_memory().percent, # memoria usata
"field3": psutil.net_io_counters().packets_sent, # pacchetti inviati
"field4": psutil.net_io_counters().packets_recv, # pacchetti ricevuti
"key":writekey}
)
print body
headers = {"Content-type": "application/json"}
conn = httplib.HTTPConnection("api.thingspeak.com")
try: # Gestione delle eccezioni (errori)
conn.request("POST", "/update", body, headers)
conn.close()
except: # In caso di errore...
print "Connessione fallita: dato non registrato."
time.sleep(60)

Avvertenze
• Per far funzionare il programma precedente è necessario:
• creare i ﬁeld necessari, ed etichettare in modo opportuno i
graﬁci
• installare la libreria psutils sulla vostra macchina
$ pip install psutil

Funzione di relay di comandi: TalkBack
• Un dispositivo può inserire in una coda un comando che
altri dispositivi possono leggere
• ...si chiama TalkBack
• Per inserire un nuovo comando il dispositivo invia una
richiesta POST
• Il path è talkbacks/NNN/commands.json
• dove NNN è l’identiﬁcatore della coda
• Il body del POST contiene la chiave del canale TalkBack, e
un messaggio
• Sono codiﬁcati in JSON, come coppie (chiave,valore):
• le chiavi (o key) sono api_key e command_string
• Ad esempio:
{"api_key"="XXXX","command_string"="Do it"}

Proviamoci
• E’ necessario costruire una nuova coda di TalkBack
• Createla con Applicazioni -> TalkBack -> New TalkBack
• Annotate la key e il suo id
• Il programma Python che segue inserisce un comando
nella coda
• potete veriﬁcare nella pagina dove avetre creato la coda
TalkBack

Inserimento di un comando TalkBack
(ts_talkback_send)
import time, sys, httplib, json
if len(sys.argv) != 4: # Controllo parametr
print("nUsage: ts_sensor.py <channel id> <api_key> <command>n")
exit(1)
channel_id=sys.argv[1] # Acquisizione param
api_key=sys.argv[2]
command=sys.argv[3]
connection = httplib.HTTPSConnection("api.thingspeak.com") # Connessione
connection.request( # Request
"POST", # − metodo
"/talkbacks/"+channel_id+"/commands.json", # − URL
json.JSONEncoder().encode({ "command_string": command,"api_key": api_key }), # − body
{"Content-type": "application/json"} # − headers
)
response = connection.getresponse() # response
connection.close()

Funzione di relay di comandi: estrazione di un
comando
• Per leggere l’ultimo comando ed estrarlo dalla coda
• utilizzare il path talkbacks/10449/commands/execute.json
• nella richiesta inserire la api_key del canale.
• Ad esempio, questa URL
http://api.thingspeak.com/talkbacks/NNN/commands/execute.json?api_key=XXX
• E’ anche possibile
• leggere un comando senza estrarlo
• accedere ad un comando per identiﬁcatore
• accedere alla lista di tutti i comandi

Estrazione di un comando TalkBack
import time, sys, httplib, json
if len(sys.argv) != 3:
print("nUsage: ts_talkback.rcv.py <channel id> <api_key>n")
exit(1)
channel_id=sys.argv[1]
api_key=sys.argv[2]
connection = httplib.HTTPSConnection("api.thingspeak.com") # Connessione
connection.request( # Request
"GET", # − method
"/talkbacks/"+channel_id+"/commands/execute.json?api_key="+ api_key # − URL
)
response = connection.getresponse() # Response
print response.read() # Il comando estratto

Appendice: un sensore fasullo
• Utilizzando le librerie http di Python è possibile costruire un
sensore fasullo
• genera dati casuali
• senza uscire da un range preﬁssato
• potete installarlo sul vostro PC o (meglio) sul Raspberry
• Prende come parametri
• il numero del ﬁeld da alimentare
• l’intervallo entro cui generare il valore
• la massima differenze tra due valori successivi
• la chiave (se necessaria)
• Poi
• genera un nuovo dato (ogni 20 secondi)
• costruisce la parte di URL che contiene path e richiesta
• apre la connessione TCP con il server (usando TSL)
• invia la request che alimenta il campo
• stampa la startline della response

Il sensore fasullo
#!/usr/bin/python
import time, random, sys, httplib
print("nUsage: ts_sensor.py <field#> <min> <max> <deltamax> <apikey>n")
exit(1)
fieldname=sys.argv[1] # acquisizione parametri
minimum=int(sys.argv[2])
maximum=int(sys.argv[3])
deltamax=int(sys.argv[4])
value=(minimum+maximum)/2 # inizializzazione
while True: # loop
value+=random.randint(-deltamax*10,+deltamax*10)/10.0 # calcolo valore
if value<minimum: value=minimum
if value>maximum: value=maximum
URL="/update?api_key=%s&field%s=%.1f" % (writekey,fieldname,value) # costruzione URL
print URL
connection = httplib.HTTPSConnection("api.thingspeak.com") # apertura connessione
connection.request("GET", URL) # invio request
response = connection.getresponse() # ricezione response
print response.status, response.reason # startline response
time.sleep(20)

Monitorare la temperatura con psutil
#!/usr/bin/env python
# −∗− coding: utf−8 −∗−
# Copyright (c) 2009, Giampaolo Rodola’. All rights reserved.
from __future__ import print_function
import sys
import psutil
def main():
if not hasattr(psutil, "sensors_temperatures"): sys.exit("platform not supported")
temps = psutil.sensors_temperatures()
if not temps: sys.exit("can’t read any temperature")
for name, entries in temps.items():
print(name)
for entry in entries:
print(" %-20s %s C (high = %s C, critical = %s C)" % (
entry.label or name, entry.current, entry.high,
entry.critical))
print()
if __name__ == ’__main__’:
main()

Thingspeak: fondamenti

Recommended

Recommended

More Related Content

Similar to Thingspeak: fondamenti

Similar to Thingspeak: fondamenti (20)

More from Augusto Ciuffoletti

More from Augusto Ciuffoletti (20)

Thingspeak: fondamenti