Sentire parlare di progetti IoT è quasi diventata una moda e nonostante la realizzazione di progetti più o meno interessanti, possiamo confermare che il mercato è in forte espansione e l’industria sta investendo ingenti capitali. Uno degli aspetti chiave dell’internet delle cose è sicuramente la remotizzazione dei dispositivi. Vengono perciò progettate reti dedicate, come la rete Sigfox oppure il sistema LoRa caratterizzate da lunghe distanze operative e bassi consumi.
Un altro canale di comunicazione che sta ritornando in uso è la rete gsm, forte della sua alta percentuale di copertura del territorio nazionale e un uso ormai semplificato grazie a libreria pronte all’uso.
Nonostante i moduli GSM abbiano un consumo energetico maggiore rispetto a quelli SigFox e LoRa, rimane comunque un sistema molto valido soprattutto in attesa che anche nel nostro paese vengano realizzate reti IoT dedicate.

Esistono diverse shield gsm o moduli stand alone che permettono di costruire circuiti capaci di dialogare tra loro a grandi distanze. La shield ufficiale Arduino è da tempo indisponibile, nonostante esiste una seconda versione, viste le diatribe tra le due società Arduino, ho preferito usare un altro prodotto ed in particolare quello sviluppato da Mikroelektronica che si basa sul modulo M95A perché  ha un costo contenuto ed è compatibile con la libreria ufficiale disponibile nell’ide sviluppato da Arduino.cc.

Di seguito potete vedere il modulo e la sua pin function

Mikroelektronica, oltre ha produrre diversi tipi di compilatori, ha un suo sistema di sviluppo hardware composto da delle schede chiamate Click Boards che si collegano tra loro utilizzando il Mikro Bus.

La comunicazione tra la GSM2click ed Arduino avviene tramite UART. Esiste anche la Arduino UNO click shield ma purtroppo non possiamo utilizzarla perché la libreria gsm utilizza la SoftwareSerial sui pin 2 e 3 mentre nella Arduino UNO click shield la seriale è collegata ai pin 0 e 1.
Quindi dovremmo adattare i collegamenti Arduino UNO e la GSM2click seguendo questo semplice schema:

Il modulo GSM2Click utilizza sia l’alimentazione a 3.3Vdc sia quella a 5Vdc. I pin TX e RX del modulo vanno rispettivamente collegati al pin 2 e pin 3 di Arduino (quelli utilizzati dalla SoftwareSerial della libraria GSM). Il pin7 di Arduino va collegato al pin RST che in pratica corrisponde al PowerKey del modulo M95.

Codice di esempio

Prima di caricare il codice dobbiamo inserire nel modulo GSM2Click una SIM attiva con relativo credito telefonico. Nonostante il modulo possa funzionare senza l’ausilio di un’antenna consiglio assolutamente il suo impiego per aumentare il segnale ricevuto e soprattutto evitare disadattamenti di impedenza del trasmettitore RF.

Il codice seguente inizializza il modem del modulo M95 e ne ricava il codice IMEI:

// libraria GSM
#include <GSM.h>

//creo un oggetto modem
GSMModem modem;

String IMEI = "";
float tempo_prec, tempo =0;

void setup()
{
//init seriale
Serial.begin(9600);
delay(100);

Serial.println("Avvio modem...");

//memorizzo il tempo corrente
tempo_prec = millis();

//inizializzo il modem e verifico il suo stato
if (modem.begin())
{
//memorizzo il tempo corrente
tempo= millis();

//calcolo il tempo di avvio del modem
Serial.print("Modem avviato in ");
Serial.print((tempo - tempo_prec)/1000);
Serial.println(" secondi.");

}
else
//avvisami in caso di errore
Serial.println("ERRORE, nussuna risposta dal modem.");

Serial.println("Leggo il codice IMEI");

//ottengo il codice imei
IMEI = modem.getIMEI();

//verifico il codice e lo visualizzo
if (IMEI != NULL)
{
Serial.print("Codice IMEI= " + IMEI);
}
else
{
Serial.println("ERRORE: lettura codice IMEI fallita!");
}
}

void loop()
{

}

La classe GSM permette di semplificare la comunicazione col modulo utilizzando una sintassi molto elementare. Abbiamo comunque la possibilità di scendere nel dettaglio utilizzando i comandi AT. La Quectel fornisce dettagliate documentazioni relative a tutti i sui moduli, in questo modo possiamo ottimizzare il nostro codice accedendo solo alle funzioni specifiche del modulo.

Per provare ad utilizzare i comandi AT, ho modificato il circuito elettrico prelevando il segnale sul pin STA del modulo GSM2Click, questo perchè prima di inviare un comando devo assicurarmi che il modulo sia attivo e funzionante.

Questo il codice che testa la comunicazione tramite comandi AT:

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

String risp_at = "";
char message[50];

void setup() {
// put your setup code here, to run once:
mySerial.begin(9600);
Serial.begin(9600);

pinMode(6, INPUT);
pinMode(7, OUTPUT);

//verifico se il modulo è attivo
if(digitalRead(6) == LOW)
{
//attivo il moduloinviando un livello
//logico alto al pin PWK (Power Key)
digitalWrite(7, HIGH);
delay(1000);
digitalWrite(7, LOW);
}

//attendi l'avvio del modulo
while(digitalRead(6) == LOW)
{
delay(100);
Serial.print(".");
}

//Invio il comando 'AT' per verificare la
//risposta del modulo
mySerial.write("AT");
mySerial.write(10);
mySerial.write(13);

delay(500);

//attendo finchè non ricevo dati dal modulo
while(mySerial.available())
{
risp_at += (char)mySerial.read();
}

if(risp_at.length() > 0)
{
risp_at.toCharArray(message, risp_at.length());
Serial.println(risp_at);
}
}

void loop()
{
delay(10);
}

Volendo possiamo utilizzare direttamente il Serial Monitor per inviare comandi AT al modulo. In pratica invio il comando ad Arduino UNO che lo rigira al modulo M95 e viceversa, i dati inviati dal modulo M95 vengono spediti al serial monitor tramite Arduino UNO. Questo è un ottimo metodo per testare comandi At e capirne il funzionamento.

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

SoftwareSerial mySerial(rxPin,txPin); // RX, TX

void setup(){

Serial.begin(9600);
Serial.println("Arduino serial initialized!");
delay(10);

mySerial.begin(9600);
Serial.println("Software serial initialized!");
delay(10);

pinMode(6, INPUT);
pinMode(7, OUTPUT);

//verifico se il modulo è attivo
if(digitalRead(6) == LOW)
{
//attivo il moduloinviando un livello
//logico alto al pin PWK (Power Key)
digitalWrite(7, HIGH);
delay(1000);
digitalWrite(7, LOW);
}

}

void loop()
{
if(Serial.available())
{
mySerial.write(Serial.read());
}

if(mySerial.available())
{
Serial.write(mySerial.read());
}
}

Ora possiamo usare il Serial Monitor come se fosse collegato direttamente al modulo M95.
Lanciamo il Serial Monitor ed assicuriamoci di avere impostata la velocità di comunicazione a 9600bps e di selezionare il ritorno carrello e la nuova linea (NL & CR).

Proviamo a scrivere sul serial monitor il comando AT e clicchiamo sul pulsante invia. Il modulo risponderà con questa stringa:

OK //comando eseguito correttamente

La risposta OK informa che il comando AT è stato eseguito correttamente.
Possiamo verificare ed esempio quale sia il livello del segnale della rete GSM inviando al modulo questi caratteri AT+CSQ
il risultato, nel mio caso è il seguente:

+CSQ: 26,0

OK

il comando CSQ è riconosciuto valido e il suo valore è 26,0. Questi dati possono essere interpretati utilizzando il manuale del modulo M95.

Le istruzioni AT sono molto semplici e permettono di eseguire sia comandi sia settaggi di impostazioni. Per ulteriori esempi non dovete fare altro che leggerli dal manuale!

The post Arduino. Utilizzare la rete GSM per progetti IoT appeared first on Esperimenti con logiche programmabili.

Il termine ‘internet delle cose‘ sta diventando sempre più popolare per due motivi fondamentali, il primo riguarda la grande diffusione dei dispositivi programmabili come Arduino e Netduino (senza tralasciare  il sistema OpenPicus e il RaspberryPI) con la loro relativa semplicità di utilizzo, mentre il secondo motivo è dovuto alla necessità di conoscere in tempo reale cosa questo dispositivo sta facendo e come sia possibile controllarne le funzionalità, anche a distanza.
Tutto questo è strettamente legato alla diffusione della rete 3G e degli smartphone che permettono di avere una connessione ad internet pressoché ovunque.

Questo scenario rende interessante lo sviluppo di nuove tipologie di applicazioni legate appunto al controllo e allo scambio dati tra dispositivi hardware collegati ad internet.

Esistono numerosi prototipi ma anche esempi reali che dimostrano come l’utilizzo di sistemi embedded+internet creino infrastrutture, anche complesse, controllabili. Il classico esempio riguarda la gestione del traffico che nelle nostre città viene gestito da semplici semafori che regolano il traffico in modo statico. Utilizzando dispositivi smart è possibile ottimizzare questo sistema migliorando la viabilità, evitando ingorghi e facendo risparmiare energia e carburante. Ma le applicazioni sono davvero notevoli e sono tutte orientate al risparmio energetico e al migliorare il nostro modo di vivere.

Di seguito sono elencate le categorie dove maggiormente verranno sviluppati dispositivi riconducibili all’internet delle cose

• Domotica
• Controllo inquinamento ambientale cittadino
• Monitoraggio Ambientale
• Energie rinnovabili, Smart Grid
• Illuminazione pubblica intelligente
• Sistemi per il rilevamento tempestivo degli incendi
• Controllo delle acque, tra cui livello degli argini.
• Controllo e gestione degli accessi con tecnologia RFID
• Agricoltura, irrigazione intelligente.
• Sorveglianza di pazienti e anziani in abitazioni isolate.
• Miglioramento processi industriali, gestione magazzino.

Gartner ha identificato l’IOT come una delle 10 tecnologiche trainanti per il 2013.

Per quello che ci riguarda dobbiamo dotarci di un dispositivo capace di connettersi ad internet, nel mio caso utilizzerò l’Arduino Ethernet, di una connessione internet e di un server web capace di elaborare le richieste inviate dall’Arduino.

Il progetto di questo tutorial permette di acquisire un segnale analogico, di inviarne il valore al server remoto che lo memorizzerà in una tabella del database MySql.
L’invio dei dati avviene tramite architettura REST. Praticamente i valori acquisiti da Arduino verranno inviati utilizzando l’URL.
Lato server, uno script PHP recupererà i valori dall’url e li memorizzerà sul database.

se non disponete di un server web remoto potete installarne uno nella vostra macchina locale utilizzando XAMPP. Il pacchetto installa automaticamente il server web Apache, l’interprete PHP ed il server MySql.

Iniziamo subito con il codice che ho caricato sull’Arduino:

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//indirizzo server web (locale)
IPAddress server(192, 168, 0, 140);

//indirizzo ip dell'Arduino
IPAddress ip(192, 168, 0, 200);

EthernetClient client;

String strURL = "";
float temp = 0;

void setup()
{
Serial.begin(9600);

if (Ethernet.begin(mac) == 0)
{
Serial.println("Configurazione DHCP fallita!");
Ethernet.begin(mac, ip);
}

delay(1000);

}

void loop()
{
UpdateTemp();

while(client.available())
{
char c = client.read();
Serial.print(c);
}

if (!client.connected())
{
Serial.println();
Serial.println("Disconnesso.");
client.stop();
}

//esegui la richiesta ogni 10 secondi
delay(10000);
}

void UpdateTemp()
{
Serial.println("Connessione...");

if (client.connect(server, 80))
{
Serial.println("Connesso");
//acquisisco il valore analogico dal sensore MCP9700
//vedi questo articolo
//logicaprogrammabile.it/mcp9700a-netduino-sensore-temperatura-analogico
temp = analogRead(0);

//creo l'url utilizzanso una stringa
strURL = "GET /arduino/index.php?valore=";
strURL += (int)temp;
strURL += "&localita=Sardegna HTTP/1.1";

//invio la richiesta al server
client.println(strURL);
client.println("Host: localhost");
client.println("Connection: close");
client.println();
//chiudo la connessione
client.stop();
}
else
{
Serial.println("Errore Connessione");
}
}

Il codice esegue una connessione al server locale e, dopo aver acquisito il segnale proveniente dal sensore analogico, costruisce l’indirizzo URL inserendo due parametri, il valore analogico acquisito e la località:

/arduino/index.php?valore=120&localita=Sardegna

La pagina index.php ha il compito di recuperare i parametri e di caricarli sul database. Questo è il codice PHP:

<?php
//controllo se sono presenti i parametri valore e localita
if(isset($_GET['valore']) && isset($_GET['localita']))
{
//Recupero il valore del parametro "valore"
$valore = $_GET['valore'];

//Recupero il valore del parametro "localita"
$localita = $_GET['localita'];

//eseguo la connessione al database sul server locale
//inserendo nome utente e password
$link = mysql_connect('localhost', 'root', 'root');

//gestione degli errori
if (!$link) {die('Impossibile connettersi: ' . mysql_error());}

//seleziono il databse di nome arduino
mysql_select_db("arduino") or die( "Impossibile selezionare il database.");

//creo una stringa sql di inserimento con i valori
//recuperati dall'url
$sql = "INSERT INTO `arduino`.`tbl_temperature`
(
`ID` ,
`Tempo_Server` ,
`Tempo_Locale` ,
`Valore` ,
`Localita`
)
VALUES
(
NULL , CURRENT_TIMESTAMP , NULL , '" . $valore . "', '" . $localita . "'
);";

//eseguo la query
$retval = mysql_query( $sql, $link );

//gestione degli errori
if(! $retval ){die('Impossibile eseguire la query: ' . mysql_error());}

//chiudo la connessione al db
mysql_close($link);
}
?>

Tramite phpMyAdmin ho creato un database di nome Arduino e una tabella di nome tbl_Temperature. Il codice sql per creare la tabella è il seguente:

CREATE TABLE `tbl_temperature` (
`ID` int(11) NOT NULL AUTO_INCREMENT,
`Tempo_Server` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`Tempo_Locale` datetime DEFAULT NULL,
`Valore` int(11) NOT NULL,
`Localita` varchar(50) NOT NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1;

Utilizzando Arduino, PHP e Mysql siamo riusciti a realizzare un piccolo sistema IOT. Certamente bisogna imparare ad utilizzare anche le tecnologie lato server per far interagire Arduino, ma con un po di impegno è possibile realizzare applicazione molto interessanti.

In questo tutorial non ho approfondito l’installazione e la configurazione di XAMPP, ne l’uso di PHP e MySql perché sarebbe stato necessario un tutorial dedicato, molto più lungo e forse dispersivo.

The post Memorizzare dati su un sito web con PHP e Mysql appeared first on Esperimenti con logiche programmabili.

Con i precedenti tutorial abbiamo visto tutti i passaggi per configurare l’ambiente di sviluppo e come caricare il nostro primo programma sul modulo Flyport ethernet senza però conoscere il modulo stesso. In questo articolo verrei analizzare le potenzialità di questo dispositivo, informazioni utili per poter sceglierlo nei nostri progetti.

Le sue dimensioni sono di 5 cm x 3.5 cm, caratteristica sempre apprezzata nelle installazioni dove le dimensioni contenute sono un fattore richiesto.

Il microprocessore che governa il modulo è il modello della serie PIC24F (PIC24FJ256) prodotto dalla Microchip, troviamo inoltre il controller ethernet ENC424j600, sempre prodotto da Microchip. Il processore opera a 16bit capace di eseguire, con i suoi 32MHz di clock, 16 milioni di istruzioni al secondo, possiede 256 KByte di Flash e 16KB di RAM. L’interfaccia di rete è una 10/100 Base-T.
Troviamo collegato sul pcb anche un quarzo da 32.768Mhz necessario al modulo RTCC (Real Time Clock and Calendar) implementato nel microprocessore PIC24F.

Le porte digitali sono 18, di cui 14 rimappabili (possibilità di configurarle come ingressi o come uscite), le porte analogiche sono 4 con una risoluzione di 10bit (valori da 0 a 1023). Inoltre possiamo configurare 4 porte UART, 9 canali PWM, una porta SPI e una porta I2C.

Il modulo ospita una memoria flash seriale da ben 16Mbit (SST25VF016Bb), utile per memorizzare le pagine html che poi verranno impiegate ad esempio dal webserver interno.

Il Flyport Ethernet può essere alimentato sia a 5Vdc sia a 3.3Vdc.

L’intervallo di temperature in cui il modulo può operare va da -20°C a +85°C. Questi valori sono veramente interessanti permettendo l’installazione in ambienti anche estremi.

Flyport framework

All’interno del microprocessore troviamo, il bootloader, un sistema operativo real-time (freeRTOS), lo stack TCP/IP e l’Openpicus Framework.
Il bootloader è un piccolo software che risiede nella flash del microcontrollore PIC24F. Questo software permette di caricare il programma scritto con l’Openpicus IDE dentro la flash del microcontrollore, tramite la porta seriale UART. Inoltre permette di avviare il programma o di resettarlo. Questa scelta permette di usare solamente il convertitore usb seriale piuttosto che impiegare un programmatore esterno più complesso per tutte le fasi di programmazione e di debug.
Il sistema operativo real time è basato su FreeRTOS, realizzato per girare su diversi dispositivi embedded. L’Openpicus framework integra lo stack TCP/IP tramite questo sistema operativo e permette così di facilitare la gestione di TCP/IP. Nonostante questa semplificazione è comunque richiesta una minima esperienza nell’uso delle reti e della loro configurazione.

Il modulo, o per meglio dire il sistema Openpicus, si dimostra utile in moltissime applicazioni, da quelle puramente hobbistiche a quelle industriali. Credo che conoscerne il funzionamento e la sua programmazione si davvero utile per arricchire le nostre competenze e per avere dalla nostra un utile strumento da utilizzare anche in campo lavorativo.

E poi è made in Italy!

The post Caratteristiche tecniche del Flyport Ethernet appeared first on Esperimenti con logiche programmabili.

Pachube è uno dei tanti servizi online che offrono un’applicazione web aggiornabile tramite dispositivi elettronici come Netduino, Arduino, smartphone, PC o altri sistemi capaci di interagire con Internet.
Banalmente possiamo definirlo un “datalogger on line” capace di registrare dati provenienti dai dispositivi e di creare grafici che ne mostrano l’andamento nel tempo.
Pachube certamente è un buon servizio che dimostra lo sviluppo di applicazioni dell’Internet delle cose.

Anche io ho voluto realizzare la mia applicazione per semplice curiosità e per condividere la mia esperienza.

Iniziamo registrandoci al servizio Pachube. Al momento in cui scrivo sono disponibili tre tipi di piani tariffari, tra cui uno gratuito. La differenza sostanziale tra essi, è il numero di dati che possiamo caricare sul sito e il tempo di memorizzazione degli stessi.
Per una piccola applicazione fortunatamente è sufficiente creare un account gratuito. La registrazione richiede solo pochi dati come il Nome Utente e una casella e-mail valida. Una volta compilati tutti i campi clicchiamo sul pulsante Sign Up, verrà spedita automaticamente una mail contenente il link di attivazione del vostro account. Successivamente l’attivazione Pachube fornisce una API Key che viene utilizzata per autorizzare le nostre applicazioni.

Il passo seguente è quello di creare un feed per memorizzare i dati inviati da un dispositivo remoto.
Clicchiamo sul link Create a Feed dal menu My Account. Le informazioni da inserire sono diverse, molto intuitive, che identificano una precisa locazione geografica e il tipo di dispositivo utilizzato.
Prima di salvare dobbiamo aggiungere almeno un datastream, fondamentale per memorizzare e rappresentare i dati provenienti dal nostro dispositivo.
Clicchiamo su Add a datastream per crearne uno. Il campo ID serve ad identificare il datastream all’interno del Feed, può essere un valore numerico o testuale, Tags specifica alcune parole chiave descrittive per il datastream, Units rappresenta l’unita di misura per i dati del datastream e Symbol rappresenta la dicitura dell’unità di misura.

I valori realmente necessari per la creazione di un feed sono il suo nome e l’ID del datastream, gli altri campi possono essere lasciati in bianco ma è comunque consigliabile compilarli per dare tutte le informazioni per interpretare i dati e capirne la provenienza.

Salviamo il Feed cliccando sul pulsante Save.

In questo esempio reale ho creato un Feed che monitorizza il carico della cpu del mio pc, potete osservare i dati recandovi a questo indirizzo http://pachube.com/feeds/28933

Pachube aggiorna la finestra mostrando le impostazioni del Feed appena creato. In questa finestra troviamo tre link, JSON, XML e CSV, sotto la voce Feed Format. Questi tre formati sono quelli accettati da Pachube per interagire da remoto con il Feed. Quello che preferisco è il formato XML, cliccando sul link viene caricata una nuova finestra che mostra la struttura del file XML. Nella barra degli indirizzi viene mostrato il percorso del file XML.

La documentazione presente sul sito è molto chiara. In questa sezione troviamo il codice XML necessario per aggiornare il Feed (possiamo anche apprendere come leggere, creare e cancellare i Feed da remoto).
Ho modificato il codice XML della guida in base alle impostazioni del Feed e del datastream che ho precedentemente creato:

<?xml version="1.0" encoding="UTF-8"?>
<eeml xmlns="http://www.eeml.org/xsd/0.5.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1
http://www.eeml.org/xsd/0.5.1/0.5.1.xsd">
<environment>

<title>Cpu_Usage</title>

<status>live</status>

<description>Monitoraggio Carico CPU</description>

<tag>Carico Cpu</tag>
<tag>Monitor</tag>

<data id="CpuLoad">
<current_value>10</current_value>
<max_value>100</max_value>
<min_value>0</min_value>
</data>

</environment>
</eeml>
<pre>

Prima di creare un applicazione basata su un dispositivo hardware ne ho sviluppato una in C# che permette di testare tutta la procedura per interagire con il Feed.

Il codice si basa sulla classe WebClient e permette con alcune righe di codice di eseguire l’aggiornamento

String UpdateData1 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<eeml xmlns=\"http://www.eeml.org/xsd/0.5.1\" " +
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
"version=\"0.5.1\" " +
"xsi:schemaLocation=\"http://www.eeml.org/xsd/0.5.1 " +
"http://www.eeml.org/xsd/0.5.1/0.5.1.xsd\"><environment>" +
"<status>live</status><data id=\"CpuLoad\"><current_value>";

String UpdateData2 = "</current_value></data></environment></eeml>";

try
{
String Value = "";
WebClient pachube = new WebClient();

//WebProxy mio_proxy = new WebProxy("Inserire nome proxy", 8080);
//pachube.Proxy = mio_proxy;

pachube.Headers.Add("X-PachubeApiKey", "Inserisci la tua API Key");

//questo codice recupera la percentuale di carico della CPU (testato su win XP)
ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\CIMV2",
 "SELECT * FROM Win32_Processor");

foreach (ManagementObject queryObj in searcher.Get())
{
Value = queryObj["LoadPercentage"].ToString();
}

Byte[] Data = Encoding.UTF8.GetBytes(UpdateData1 + Value + UpdateData2);

pachube.UploadData("Inserisci indirizzo file XML", "PUT", Data);

Console.WriteLine("Aggiornamento eseguito con successo");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}

Le prime variabili contengono il codice XML che permette di aggiornare il datastream. Ho diviso il listato XML in due parti in modo da inserire, via codice, il dato della variabile Value all’interno dei tag XML <current_value></current_value>.

Creiamo un’istanza di oggetto dalla classe WebClient, specifichiamo la nostra API key tramite il metodo Add della collection Headers.
Recuperiamo il valore della percentuale di carico della CPU ed assegnamolo alla variabile Value.
Creiamo la stringa XML completa e convertiamola in un array di Byte (necessario per l’invio tramite WebClient). In fine aggiorniamo il Feed tramite il metodo UploadData.
Nel metodo UploadData dobbiamo specificare, come primo parametro, il nome del file .xml relativo al Feed ( recuperabile dai link presenti sotto la voce Feed Formats).

Eseguendo questo codice in modo ciclico, ad esempio utilizzando un timer, Pachube realizzerà, con i dati inviati, un grafico sull’andamento del carico della CPU:

Questi dati vengono memorizzati, nel caso dell’account free per un mese.

I campi di applicazione di questo servizio sono numerosi, possiamo collegare al pc dei sensori ed inviare i dati ai Feed Pachube e condividerli con la comunità.
Il passo successivo che mi interessa realizzare è il porting di questa applicazione desktop su Netduino o Arduino.

The post Pachube, utilizzo con Netduino o Arduino (Introduzione) appeared first on Esperimenti con logiche programmabili.