IoT e Javascript: come creare una piattaforma di “Javascript of Anything”

In questi ultimi tempi non si fa altro che parlare di IoT (Internet of Things o Internet delle cose) e della rivoluzione che l’IoT sta determinando su ognuno di noi; alcuni hanno addirittura paragonato l’avvento dell’IoT alla prima rivoluzione industriale in termini di impatti e sconvoglimenti sul nostro modo di vivere.

Non so dire se questo cambiamento sia paragonabile alla rivoluzione industriale, fatto sta che è in atto e ne siamo attori protagonisti ogni giorno, spesso magari senza rendercene conto.

Ogni qualvolta usiamo uno smartphone, un orologio digitale di nuova generazione, un qualsiasi wearable device (oggetto digitale indossabile), azioniamo oggetti digitali in casa o in macchina (Es. allarmi, sensori, spie, navigatori, … ), insomma ogni qualvolta ci interfacciamo con uno o più di questi oggetti stiamo di fatto entrando nel mondo dell'IoT.

Un generico sistema di IoT

Per descriverlo in breve, un sistema di IoT altro non è che una applicazione in grado di archiviare dati provenienti dal “mondo reale”, su questi dati effettuare delle analisi ed in funzione dei risultati rispondere proattivamente sempre sul “mondo reale”.

Il tutto deve essere fatto in real-time, senza che sia necessariamente richiesto l’intervento umano.

Per realizzare un generico sistema di IoT è quindi necessario che ci siano:

• dei sensori in grado di rilevare determinate grandezze fisiche o chimiche del “mondo reale”
• degli attuatori in grado di agire fisicamente sul “mondo reale”
• dei device in grado di pilotare sensori ed attuatori
• un protocollo di comunicazione tra gli oggetti fisici e la nostra applicazione
• una componente applicativa (message broker) dedicata allo smistamento delle informazioni
• uno o più storage in grado di archiviare una grandissima mole di dati
• una piattaforma di reportistica, controllo ed analisi statistica in grado di generare “desideri” ed “informazione” per gli esseri umani
• gli esseri umani in grado di interagire attivamente con la piattaforma

Si faccia riferimento a questa semplice ma esplicativa immagine:

I Device

Nella breve descrizione di un sistema di IoT ho parlato di sensori ed attuatori, utili per interagire fisicamente con il mondo reale. Quando parliamo di tali oggetti non possiamo non riallacciarci ai concetti di device e maker già trattati in passato in questo articolo:

Riporto dal manifesto del Maker Faire di Roma la definizione “ufficiale”:

Potrebbero essere definiti gli hobbisti tecnologici del 21esimo secolo. Si interessano di tecnologia, design, arte, sostenibilità, modelli di business alternativi.

Vivono di comunità online, software e hardware open source, ma anche del sogno di inventare qualcosa da produrre autonomamente, per vivere delle proprie invenzioni.

In una fase di crisi si affidano alla creatività facendo della propria passione un lavoro.

Il movimento dei Maker si basa sulla riutilizzazione e condivisione dei risultati, sulla creatività e sull’innovazione. Sul medio e lungo periodo potrebbe permettere di innescare importanti effetti virtuosi sull’economia, in cui comunità crescenti di makers sperimentano nuovi approcci alla produzione basati su tecnologie a basso costo.

Per maggiori info sul movimento dei makers : http://www.makerfairerome.eu/it/

Per cui l’ultima catena di un sistema di IoT è composta proprio dai device e dalle intuizioni dei maker, la cosa importante è che il nostro sistema di IoT sia in grado di parlare con il maggior numero di device possibile e soprattutto utilizzando dei protocolli standard riconosciuti dalla comunità dei maker e dai produttori di device.

IoT e Javascript: nasce il “Javascript of Anyting”

Esistono in commercio moltissime piattaforme di IoT, già pronte e collaudate per interagire con moltissimi device in commercio, noi però vogliamo realizzare un nostro sistema di IoT e per far questo vogliamo utilizzare il javascript.

Perché proprio il javascript?

Perché il javascript è l’unico linguaggio al mondo in grado “coprire” tutte le componenti già descritte per un generico sistema di IoT, a partire dal device, passando per la componente client, il protocollo di comunicazione, la componente server fino a terminare con il database.

In tal caso possiamo quindi parlare di “Javascript of Anyting System” o “full stack IoT system”

Questa una brevissima rappresentazione grafica

Ho colorato in celeste tutte le componenti che possiamo programmare in javascript.

Vediamo nel dettaglio ogni singola componente.

Tessel.io

Tessel è un device interamente programmabile in node.js quindi in javascript, ne ho parlato più volte sul blog mettendolo a confronto anche con altri device in questi articoli:

Come detto Tessel supporta nativamente node.js, in realtà anche altri device (Es. Raspberry Pi) possono essere programmati in node.js, trattandosi di device che nativamente incorporano Linux. In rete si trovano centinaia di tutorial su come installare node su device non tessel, questo un esempio:

>>> http://weworkweplay.com/play/raspberry-pi-nodejs/

Cylon.js

Nel caso in cui i nostri device non supportino javascript o siano stati utilizzati con linguaggio “nativo”, il javascript ci viene comunque in contro fornendoci una serie di librerie e script in grado di interfacciarsi con la quasi totalità di device ad oggi in commercio.

La migliore tra le librerie di colloquio con i device è senza ombra di dubbio Cylon.js, una libreria in grado di interfacciare 36 differenti device, tra i quali Arduino, ArduinoYun, Raspberry Pi, Tessel, Intel Galileo, Intel Edison, Ardrone, Pinoccio, MiP e moltissimi altri.

Oltre a fornire un framework di colloquio con i device fornisce anche degli standard di colloquio M2M tra il device e la piattaforma di IoT, tra i quali i protocolli http (REST), MQTT e socket.io.

Questo un semplicissimo esempio di colloquio con Arduino:

var Cylon = require('cylon');

Cylon.robot({

  connections: {
    arduino: { adaptor: 'firmata', port: '/dev/ttyACM0' }
  },

  devices: {
    led: { driver: 'led', pin: 13 }
  },

  work: function(my) {
    every((1).second(), my.led.toggle);
  }

 }).start();

MQTT.JS

In relazione ai protocolli M2M ovvero “Machine to Machine” specifici per le piattaforme di IoT vorrei menzionare il protocollo MQTT, diventato di fatto lo standard per questo tipo di colloquio (mqtt.org)

Questo protocollo ha la caratteristica di essere molto “leggero” ovvero consente un trasferimento di byte molto basso e basato sul concetto di publish/subscribe ottimo proprio per questi tipi di architetture.

fonte: http://www.nearform.com/nodecrunch/internet-of-things-how-to-build-it-faster/

Matteo Collina (https://it.linkedin.com/in/matteocollina) uno dei massimi esperti italiani di IoT e javascript ha contribuito alla scrittura di mqtt.js, la versione node.js del protocollo MQTT, utilizzabile nel caso in cui si voglia dialogare direttamente in mqtt con la nostra piattaforma di IoT senza passare per il framewok Cylon.js (che comunque lo supporta).

https://www.npmjs.com/package/mqtt

L’utilizzo di mqtt.js è molto semplice, prima di tutto installiamo il node package manager con il comando:

npm install mqtt --save

Poi nel nostro progetto node utilizziamo il seguente codice:

var mqtt = require('mqtt');

var client = mqtt.connect('mqtt://test.mosquitto.org');

client.on('connect', function () {
  client.subscribe('presence');
  client.publish('presence', 'Hello mqtt');
});

client.on('message', function (topic, message) {
  console.log(message.toString());
});

In questo caso stiamo parlando con il cloud server MQTT ‘mqtt://test.mosquitto.org', dobbiamo ovviamente sostituire questo server con il nostro Server di IoT.

Possiamo facilmente usare mqtt.js anche via websocket per l'implementazione del colloquio M2M via browser (javascript/HTML5).

Ma come facciamo a creare il server? Ci viene in aiuto sempre Matteo con Mosca.js

Mosca.js

Mosca.js è un node.js MQTT broker che può essere usato sia standalone che inserito in un progetto esistente.

https://github.com/mcollina/mosca

Se ci rifacciamo all’immagine in cui veniva evidenziato il colloquio pub/sub tramite broker, capiamo subito come Mosca rappresenti la riga centrale verde che funge da “message broker” in grado di smistare i messaggi pubblicati da un client a tutti i client che hanno sottoscritto un determinato “topic” (argomento).

Uno dei punti di forza di Mosca è la capacità di rendere persistente tutte le operazioni di scambio dati tra client su diverse piattaforme di archiviazione, tra le quali MongoDB piattaforma noSql realizzata in javascript, ma anche Redis e molte altre.

Questo il codice per realizzare un semplice MQTT broker in javascript conneso con MongoDB.

Prima di tutto installiamo mosca con il comando:

npm install mosca --save

Poi utilizziamo Mosca con il codice seguente:

var mosca = require('mosca');

var ascoltatore = {
  type: 'mongo',
  url: 'mongodb://localhost:27017/mqtt',
  pubsubCollection: 'ascoltatori',
  mongo: {}
};

var settings = {
  port: 1883,
  backend: ascoltatore
};

var server = new mosca.Server(settings);

server.on('clientConnected', function(client) {
  console.log('client connected', client.id);
});

// fired when a message is received
server.on('published', function(packet, client) {
  console.log('Published', packet.payload);
});

server.on('ready', setup);

// fired when the mqtt server is ready
function setup() {
  console.log('Mosca server is up and running');
}

In questo modo siamo riuciti a connettere dinamicamente e senza sforzo alcuno mongoDb alla nostra piattaforma di IoT.

Vuoi vedere un esempio completo?

Se vuoi vedere un esempio completo, ho creato sul mio account gitHub una semplice applicazione composta da:

• Server (Mosca Server MQTT Broker)
• Client 1
• Client 2
• Client Web

https://github.com/etrusco74/iot

I client sono semplici MQTT client che ad intervalli regolari pubblicano un messaggio randomico sulla topic “/iot/api/” ed allo stesso tempo, avendo tutti sottoscritto il topic “/iot/api/“, ricevono i messaggi pubblicati dagli altri client e da loro stessi.

Il Server Mosca è realizzato in node.js e richiede solo il npm mosca.js; i Client 1 e Client 2 sono realizzati anche loro in node.js e richiedono solo il npm mqtt.js mentre il Client Web è realizzato in semplice HTML5/javascript e richiede la libreria “lib/mqtt.js” pubblicata dal Server Mosca al quale ho dovuto “agganciare” un semplice webserver.

Conclusioni e Riferimenti

Abbiamo in questo articolo analizzato e descritto tutte le componenti che potrebbero comporre la nostra primissima versione di “Javascript of Anyting System” o “full stack IoT system”, partendo dai device fino a terminare con il dbms.

Di seguito i riferimenti ai quali mi sono ispirato:

• http://www.nearform.com/nodecrunch/internet-of-things-how-to-build-it-faster/
• Matteo Collina: https://github.com/mcollina
• mqtt: http://mqtt.org/
• mqtt.js: https://www.npmjs.com/package/mqtt
• mosca: https://github.com/mcollina/mosca
• cylon.js: http://cylonjs.com/

 

Che te ne pare dell’articolo? Sei interessato al full stack development in javascript? Hai esperienza di IoT system?