Galileo

Esplora l’immagine “Windows for IoT” della Intel Galileo (Gen2) comodamente sul tuo PC !

Vi siete iscritti al Windows Developer Program for IoT e siete in attesa della board oppure avete ordinato una Intel Galileo (Gen2) sulla quale caricherete l’immagine di Windows messa a disposizione sul sito ufficiale ? Siete in attesa delle board ma siete curiosi di sapere quali siano i componenti inclusi nell’immagine di Windows for IoT ?

Una soluzione c’è !

Una volta scaricato il file WIM del sito, è possibile eseguirne il mounting attraverso il comando DISM nel modo seguente :

dism /Mount-Wim /WimFile:<path_wim_file> /Index:1 /MountDir:<path_dir_mount>

Ad esempio :

dism /Mount-Wim /WimFile:C:\Users\ppatierno\Downloads\9600.16384.x86fre.winblue_rtm_iotbuild.140925-1000_galileo_v2.wim /Index:1 /MountDir:C:\Galileo

Attenzione !! La cartella in cui montare va creata prima.

01

Al termine di tale operazione, attraverso esplora risorse potrete vedere comodamente sul vostro PC il contenuto dell’immagine di Windows per la vostra Intel Galileo !

02

Infine, per poter cancellare la cartella creata, è necessario in primo luogo eseguire l’unmounting con il seguente comando :

dism /Unmount-Wim /MountDir:<path_dir_mount> /Discard

03

🙂

Windows for IoT : MQTT sulla board Intel Galileo

Una delle principali caratteristiche di un oggetto nell’ambito dell’Internet of Things è la sua capacità di scambiare messaggi, inviando dati o ricevendo comandi, nel modo più efficace ed efficiente possibile. Esistono numerosi protocolli standard per questo scopo ma uno dei miei preferiti è MQTT.

Nel corso di questo articolo, vedremo come sia possibile utilizzare un client MQTT sulla board Intel Galileo con “Windows for IoT”, in modo da aggiungere a quest’ultima la potenzialità necessaria per poter essere riconosciuta come parte del mondo dell’Internet of Things.

Paho project : il client MQTT

Paho è un progetto open source della Eclipse Foundation che mette a disposizione una serie di client, sviluppati con differenti linguaggi di programmazione, per i principali protocolli utilizzati nell’ambito della M2M (Machine To Machine) communication e dell’IoT (Internet of Things). In particolare, la nostra attenzione è focalizzata sul client MQTT in linguaggio ANSI C che fornisce il supporto Posix/Windows e che espone due tipologie di APIs :

  • Sincrone : ogni chiamata è bloccante e ritorna il controllo al chiamante solo al termine dell’operazione richiesta;
  • Asincrone : l’operazione richiesta viene avviata in maniera asincrona restituendo immediatamente il controllo al chiamante e tutte le notifiche sono eseguite attraverso delle callback (molto utile nell’ambito di software con una UI);

Per poter compilare tale progetto utilizzando Visual Studio 2013, è necessario utilizzare GIT per eseguire il clone del corrispondente repository il cui URL è disponibile nella pagina principale della libreria nella sezione Downloads –> MQTT –> C/C++ –> C (Posix/Windows).

00

Nella sottocartella “Windows Build”, possiamo trovare la solution “Paho C MQTT APIs” i cui progetti sono i seguenti :

  • MQTTVersion : applicazione console che visualizza la versione corrente di una specifica libreria;
  • paho-mqtt3c, paho-mqtt3a : sono rispettivamente le librerie MQTT sincrone ed asincrone senza il supporto SSL;
  • paho-mqtt3cs, paho-mqttas : sono rispettivamente le librerie MQTT sincrone ed asincrone con il supporto SSL;
  • stdoutsub, stdoutsuba : applicazioni console che forniscono un subscriber in modalità sincrona ed asincrona;
  • test1, test3 : applicazioni console di test per la libreria sincrona rispettivamente senza e con SSL;
  • test4, test5 : applicazioni console di test per la libreria asincrona rispettivamente senza e con SSL;

01

La solution è ben strutturata ma purtroppo è necessario effettuare una serie di modifiche alle impostazioni per poter compilare i progetti su Windows, per poi passare all’esecuzione sulla Intel Galileo con “Windows for IoT”.

Compiliamo la libreria sincrona

Focalizziamo la nostra attenzione sulla libreria che fornisce l’implementazione sincrona (paho-mqtt3c) senza il supporto SSL nella configurazione di Debug. Essa compila senza alcun problema ma per l’esecuzione sulla Intel Galileo è necessario disabilitare le “enhanced instructions” a causa di un errore a runtime di “illegal instruction” sulla funzione difftime. Ciò è possibile attraverso le proprietà del progetto ed impostando “No Enhanced Instructions (/arch:IA32)” in C/C++ –> Code Generation –> Enable Enhanced Instruction Set.

02

Le modifiche principali vanno effettuate sul progetto test1 per la libreria suddetta, in quanto esso non compila immediatamente a causa di una serie di impostazioni errate.

In primo luogo fallisce l’inclusione del file MQTTClient.h (Cannot open include file: ‘MQTTClient.h: No such file or directory) che possiamo risolvere aggiungendo la corrispondente directory nelle proprietà del progetto; in particolare va aggiunto il path $(SolutionDir)\..\src in C/C++ –> General –> AdditionalIncludeDirectoris.

03

Inoltre, è necessario aggiungere le seguenti define in C/C++ –> Preprocessor –> Preprocessor Definitions :

  • _WINDOWS : utilizzata per evitare l’inclusione di alcuni header files legati a Linux e garantire l’inclusione degli header files relativi alle WinSock;
  • _CRT_SECURE_NO_WARNINGS : purtroppo la libreria fa uso di molte funzioni nella versione “unsafe” (es. strtok al posto di strtok_s);

04

05

A questo punto, il compilatore riesce a fare il proprio lavoro ma il Linker segnala una serie di “unresolved externals”, in quanto non è in grado di trovare i simboli relativi alla libreria WinSock e la libreria MQTT. Nel caso della libreria WinSock, va aggiunto il riferimento per il Linker alla libreria ws2_32.lib in Linker –> Input –> Additional Dependencies.

06

Per quanto riguarda la libreria MQTT, possiamo referenziare direttamente il progetto (visto che è nella medesima solution) in Common Properties –> References –> Add New Reference.

07

Con queste ultime modifiche la compilazione viene eseguita correttamente ma purtroppo se proviamo ad eseguire l’applicazione di test sul nostro PC, ci ritroviamo di fronte ad un errore di “stack corruption”. Ho prontamente segnalato il bug (potete trovare i dettagli qui) che con la versione corrente non è stato ancora messo a posto. La soluzione consiste semplicemente in una modifica nel file MQTTClient.c (funzione MQTTClient_deliverMessage) e nello spostare la seguente riga di codice :

ListRemove(m->c->messageQueue, m->c->messageQueue->first->content);

subito dopo #endif e la chiamata della funzione MQTTPersistence_unpersistQueueEntry.

Il primo test su PC

Prima di lanciare l’esecuzione dell’applicazione di test sulla Intel Galileo, possiamo accertarci che tutto funzioni correttamente eseguendola sul proprio PC. In primo luogo, dobbiamo scegliere un broker MQTT per poter eseguire i test (oppure utilizzare quello online di default). Io ho preferito utilizzare un broker molto leggero come Mosquitto che è possibile scaricare qui. Lanciamo il broker con l’opzione “-v” ossia in modalità “verbose” in modo da poter vedere tutti i messaggi di debug durante il test.

Prima di ricompilare e lanciare l’applicazione test1, è necessario modificare la struttura options che contiene, tra l’altro, l’indirizzo del broker a cui collegarci (nel mio caso, l’indirizzo IP del mio PC).

struct Options
{
    char* connection;         /**< connection to system under test. */
    char** haconnections;
    int hacount;
    int verbose;
    int test_no;
    int MQTTVersion;
    int iterations;
} options =
{
    "tcp://192.168.10.188:1883",
    NULL,
    0,
    0,
    0,
    MQTTVERSION_DEFAULT,
    1,
};

Se tutto è impostato nel modo corretto, l’applicazione di test verrà eseguita senza alcun problema.

08

MQTT con “Windows for IoT”

Una volta accertato il funzionamento sul PC, possiamo passare alla configurazione del remote debugging per eseguire l’applicazione sulla board Intel Galileo direttamente da Visual Studio; le impostazioni necessarie sono disponibili sul sito ufficiale di Windows On Devices.

09

Anche in questo caso, lanciando l’applicazione in debug dovremmo vedere tutti i messaggi nella console di Mosquitto che vengono scambiati con la board.

Abbiamo un client MQTT in esecuzione su di essa !

10

Se siamo curiosi di vedere anche l’output dell’applicazione di test, possiamo lanciarla attraverso una sessione Telnet direttamente dalla board. Al termine dell’esecuzione, viene visualizzato il report con tutti i test superati.

11

Ovviamente, tutte le modifiche apportati ai progetti relativi alla libreria sincrona, possono essere applicate anche ai progetti relativi alla libreria asincrona senza alcuna differenza con la garanzie di avere il medesimo risultato.

Windows for IoT : “cannot open include file arduino.h” ? Verifica la connessione ad Internet, hai bisogno del package Galileo C++ SDK su Nuget !

Ieri ho ricevuto il mio kit con la board Intel Galileo con la versione di “Windows for IoT” ed ovviamente, come un bambino che ha tra le mani il suo nuovo giocattolo, ho iniziato a giocare !

La cosa più semplice è quella di seguire la documentazione online, raggiungibile dal sito ufficiale Windows On Devices, che descrive passo passo come essere “up and running” in pochi minuti. La mia voglia di fare mi ha portato a commettere un “errore” che non mi ha permesso di concludere la procedura nel modo corretto. Cosa è successo ?

Dopo aver acceso la Galileo, averla collegata al PC e navigato tra le cartelle (sia con una sessione telnet che come “network shared”), ho deciso di sviluppare il primo esempio relativo al blinking del led. Apro Visual Studio 2013 e seleziono il template di progetto C++ relativo a Windows for IoT, avvio la compilazione ed …. ecco l’errore !!

0654.arduino_header_error_6768BD29

Non trova il file arduino.h ? Come mai ? Non viene installato insieme all’SDK che dobbiamo scaricare dal sito Microsoft Connect ? La risposta è no !

Tutti gli headers file con relativa implementazione sono nel Galileo C++ SDK che trovate su Nuget. Per questo motivo, ho dovuto manualmente scaricare tale package e referenziarlo nel mio progetto. A quel punto, tutto ha funzionato correttamente !

A quanto pare, però, sono stato l’unico ad avere questo problema e mi sono chiesto come mai ! Tutte le altre persone che hanno il kit hanno compilato il progetto di esempio senza alcun problema ma soprattutto senza dover scaricare manualmente il package Galileo C++ SDK da Nuget.

Ebbene non è proprio così ! Quel package è necessario ma il wizard lo scarica automaticamente al momento della generazione del progetto ed a quanto pare, in quel momento, il mio PC non era connesso ad Internet !!!

Se il PC non è connesso ad Internet, il wizard crea il file package.config vuoto :

<?xml version=”1.0” encoding=”utf-8”?>
<packages>
</packages>

Viceversa, esso contiene un riferimento al Galileo C++ SDK (Microsoft.IoT.Galileo.Arduino 1.0.0.0) nel momento in cui c’è connessione.

<?xml version=”1.0” encoding=”utf-8”?>
<packages>
 <package id="Microsoft.IoT.Galileo.Arduino" version="1.0.0.0" targetFramework="Native" />
</packages>

E’ ovvio che tale package è necessario se avete intenzione di sviluppare applicazioni Arduino-like (infatti il wizard specifica “Galileo Wiring app”) ma non nel caso di applicazioni Win32 standard.

Insomma … prima di partire con il Windows Developer Program for IoT assicuratevi di avere il PC connesso alla grande rete !

IoT, Arduino, REST e Cloud … su HTML.it

0871.Cattura_6DB192D2

Giunti al nono capitolo della guida introduttiva su Arduino, possiamo finalmente toccare con mano la nuvola !

In particolare, si parte dalla realizzazione di un semplice client HTTP REST su Arduino attraverso il quale poter trasmettere nel Cloud i valori di temperatura rilevati dal relativo sensore e letti attraverso il driver sviluppato nei capitoli precedenti. La nuvola che ospita il servizio di acquisizione dati è ovviamente Azure attraverso una semplice applicazione ASP.NET MVC4 Web API.

Windows Developer Program for IoT ufficialmente partito !!

Capture

Seppure ne fosse stata annunciata l’esistenza dopo Build 2014 e subito dopo all’evento O’Reilly Solid, il programma “Windows Developer Program for IoT” è ufficialmente partito ieri !

L’annuncio è stato dato dal program manager, Steve Teixeira, sul blog di Windows sottolineando il lancio del nuovo portale Windows Developer for IoT e l’inizio della spedizione degli evaluation kit costituiti dalle board Intel Galileo con a bordo una versione specifica di Windows che supporta le API Arduino ed un sottoinsieme delle Win32.

Inoltre, sul sito della Microsoft Open Technologies è specificato che l’SDK sarà presto rilasciato in parte come open source.

Per chi si fosse già iscritto al programma, non gli resta che aspettare l’arrivo del kit direttamente a casa ma può iniziare a farsi un giro sul nuovo portale che già mette a disposizione tutte le informazioni sull’SDK con relativi esempi applicativi !

Arduino, sviluppiamo il nostro primo driver … su HTML.it

Capture

La guida introduttiva allo sviluppo su Arduino entra nel vivo con un capitolo dedicato alla realizzazione di un vero e proprio driver e nel caso specifico per un sensore di temperatura.

L’obiettivo è quello di ottenere un’interazione con il mondo che ci circonda e ricavare una grandezza fisica da trasformare in un dato da inviare al Cloud !

Arduino e l’accesso alla “grande rete” … su HTML.it

0675.Cattura_3A543116

Altro capitolo della mia guida introduttiva su Arduino e questa volta si inizia a parlare di connessione alla grande rete dalla Ethernet shield ad un semplicissimo client HTTP.

Ovviamente, questo non è nient’altro che la preparazione verso l’accesso al cloud !

Arduino, leggere i movimenti da un potenziometro…su HTML.it

0167.Cattura_64C45C4C

Dopo aver parlato di Physical Computing nel capitolo precedente, la mia guida introduttiva su Arduino è giunta al quinto appuntamento in cui si affronta il semplice utilizzo di un potenziometro mediante un esempio, per iniziare a capire come poter gestire i pin analogici.

Dal prossimo capitolo, senza svelarvi nulla e rovinarvi la sorpresa, inizia il nostro viaggio che porterà la nostra board sul Cloud !

IoT@Work : si è svolto a Roma l’evento sull’Internet of Things

Venerdì 6 Giugno si è tenuto l’evento IoT@Work a Roma presso la sede Microsoft, organizzato dalla community romana DomusDotNet e dalla community online TinyCLR.it (di cui faccio parte).

Grazie all’ospitalità di Massimo Bonanni e di tutti i ragazzi della community, abbiamo trascorso un’intera giornata all’insegna dell’Internet of Things.

6445.WP_20140606_10_45_59_Pro_7F6729C7 4382.WP_20140606_11_55_30_Pro_1F5286C5

La mattinata, molto teorica, è iniziata con Mirco Vanini che ci ha illustrato che cosa è e cosa non è l’Internet delle Cose, con una serie di casi d’uso reali e le proiezioni future di questo nuovo business. La sessione successiva ha visto me stesso come protagonista nell’affrontare da un punto di vista tecnico i principali protocolli che sono utilizzati maggiormente nell’IoT, ciascuno con i proprio vantaggi e svantaggi. Le sessioni mattutine sono state concluse da Lorenzo Maiorfi che ci ha parlato di “flow-programming”, del suo campo di applicazione nell’IoT e di due principali strumenti che possono essere utilizzati a questo scopo : NodeRed ed Orleans.

1261.WP_20140606_09_12_08_Pro_057E5096 4807.WP_20140606_09_07_48_Pro_19976D1F

Dopo la pausa pranzo, abbiamo ripreso con una parte assolutamente pratica ed una demo corale (io, Mirco e Lorenzo insieme) che ha visto protagonista ventole, luci, prese comandate, sensori ed attuatori pilotati e coordinati da un broker su base NodeRed …. insomma un intero sistema di domotica casalinga e/o industriale. Infine, Francesco Baldassarri ci ha illustrato quali sono gli strumenti che Intel mette a disposizione degli sviluppatori per l’IoT (vedi la board Galileo) e quali saranno le novità future !

Come sempre, in un evento del genere, fa sempre piacere avere il riscontro delle persone, soprattutto quando ti contattano il giorno dopo per farti le congratulazioni ed avere delucidazioni in merito !

Insomma…chi non è venuto…non potrà mai sapere cosa si è perso !

😉

Il Physical Computing con Arduino e Galileo … su HTML.it

Capture

La mia guida su Arduino è ormai giunta al quarto appuntamento in cui si parla (finalmente) di Physical Computing !

Nel corso di questo capitolo si parla del modo in cui il nostro sistema embedded può interfacciarsi con il mondo reale attraverso l’utilizzo dei sensori e pilotare la realtà che lo circonda attraverso gli attuatori.

Al suo termine sarete pronti per le puntate successive in cui inizieremo a toccare con mano questo fantastico mondo …. arrivando sino al Cloud !