UN CONTRIBUTO PER LA CENTRALINA DI ALESSANDRO FEDI
https://www.chiusiblog.it/?p=31430
Proviamo a complicare un po’ il quadro utilizzando alcune funzionalità di Arduino di cui abbiamo parlato poco (o niente) durante i nostri incontri del gruppo di “Scienza di cittadinanza”. Prima prospettiva: interrogare Arduino in un contesto web. Una scheda Arduino presenta un’interfaccia Ethernet che possiamo utilizzare per le nostre finalità di pigroni. Per esigenze di brevità, darò per conosciuta tutta la (complessa) architettura Ethernet e il sistema di networking che vi si appoggia sopra. Per Ethernet, Arduino presenta una libreria già integrata nell’IDE di sviluppo e che consente di comunicare con il mondo circostante. Con questa libreria si possono configurare fino a un totale di 4 server e clients concorrenti. Si può impostare il server in modo che consenta ai clients di contattarlo e stabilire quindi il traffico di richieste e risposte. Si può anche fare in modo che i clients facciano connessioni esterne al server e quindi generino il traffico dei dati necessari. La libreria presenta tre classi principali e sono Ethernet, Server e Client. Ciascuna classe ha i suoi metodi che possiamo utilizzare per i nostri scopi. Oltre a queste, la libreria presenta anche una classe EthernetUDP, che consente di inviare broadcast su una rete le informazioni. Questo è un punto importante. Quando un server o un client non sono richiesti, la classe UDP è quel che ci consente di inviare o ricevere dati da un Arduino. L’interfaccia Ethernet, alimentata da un chip WIZnet W5100, fornisce uno stack IP con entrambi i protocolli TCP e UDP su una connessione 10/100 Mb Ethernet. Lo shield presenta il classico standard RJ45 per l’attacco plug and play dei vari devices (router, modem o altro). Attualmente, sullo shield viene consentito l’alloggiamento di un microSD. Lo dico per mettere in guardia: si possono memorizzare (leggere e scrivere) dati sull’SD ma il bus che viene utilizzato da SD e chip W5100 è sempre lo stesso SPI, quindi possono essere attivi solo uno per volta. Vedremo in un’altra occasione quali pin sono utilizzati dai due devices. Per il momento vorrei presentare uno scheletro di codice per il web-server minimale che avevo in mente, un sistema call-and-response che possa accettare richieste da un client e restituisca dati in ritorno alla chiamata. Dobbiamo disporre del MAC address del nostro Ethernet Shield (stampigliato in un’etichetta sulla nostra scheda): nel codice, imposteremo il MAC address come un array di bytes, qualcosa come
byte indir[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
Se si è perso il MAC Address, si può utilizzare quello proposto: l’importante è che sia un indirizzo UNICO sulla nostra rete. Inoltre, se non abbiamo un DHCP attivo, possiamo impostare manualmente l’IP address della nostra scheda (lo vedremo nel codice) così come imposteremo manualmente anche l’IP address del gateway.
Ok, partiamo.
#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; # istruzione già vista
IPAddress manualIP(192,168,1,120); # assegna l’indirizzo ip manualmente
EthernetServer server(80); # inizializza il server
boolean dhcpConnected = false;
void setup()
{
if (!Ethernet.begin(mac)){ # tenta di connettersi al DHCP
Ethernet.begin(mac, manualIP); # imposta l’indirizzo manuale
}
server.begin(); # parte il server
}
void loop()
{
EthernetClient client = server.available(); # ascolta per connessioni client
if (client) {
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
if (c == ‘\n’ && currentLineIsBlank) {
client.println(“HTTP/1.1 200 OK”);
client.println(“Content-Type: text/html”);
client.println();
client.println(“Eccomi! Il server web Arduino sono io!”);
# per ricevere i dati occorre sostituire
# questa linea di codice con la seguente
# client.println(analogRead(0));
break;
}
if (c == ‘\n’) {
currentLineIsBlank = true;
}
else if (c != ‘\r’) {
currentLineIsBlank = false;
}
}
}
delay(1); # da’ tempo al client per ricevere I dati
client.stop(); # chiude la connessione
}
}
L’alternativa è che Arduino ci avverta su qualcosa che non va. Bene, utilizzeremo Twitter.
Una volta che si disponga dell’account Twitter (non cercatemi, non ci sono), si può inviare un tweet (140 caratteri) all’intera rete Twitter.Le persone possono sottoscrivere il vostro feed e quindi ricevere i vostri “cinguettii”. Disporre dell’account su Twitter è solo il primo passo. Occorre avere anche uno speciale “token” che autorizzerà Arduino a inviare tweets al vostro account. Saltiamo a pie’ pari i dettagli e otteniamo il token dal sito http://arduino-tweet.appspot.com/ e clicchiamo sul link “Step 1: Get a token to post a message using OAuth”.
A questo punto ci procuriamo il necessario su www.arduino.cc/playground/Code/TwitterLibrary e , una volta scaricata, mettiamo la nostra libreria nella cartella delle librerie ovvero nello sketchbook.
Il codice proposto è impostato sulla pressione di un pulsante, mentre invece va testato e impostato con l’evento che si verifica al momento della variazione attesa e che accende il LED del dispositivo di Alessandro. Utilizziamo parti del codice proposto in precedenza.
#include <SPI.h>
#include <Ethernet.h>
#include <Twitter.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress manualIP(192,168,1,120);
int b1Pin = 2; # specifica il pin del pulsante
int pressCount = 0;
Twitter twitter(“YOUR-TOKEN-HERE”);
void setup()
{
delay(1000);
if(!Ethernet.begin(mac)){
Ethernet.begin(mac, manualIP);
}
Serial.begin(9600);
}
void sendTweet(const char msgToSend[]) # funzione che formatta il tweet
{
Serial.println(“prova di connessione …”);
if (twitter.post(msgToSend)) {
int status = twitter.wait(&Serial);
if (status == 200) {
Serial.println(“OK.”);
}
else {
Serial.print(“errato : code “);
Serial.println(status);
}
}
else {
Serial.println(“connessione fallita.”);
}
}
void loop()
{
if(digitalRead(b1Pin) == HIGH)
{
pressCount++;
sendTweet(“Il pulsante è stato premuto: ” + pressCount + “ volte”);
delay(2000);
}
}
Ovviamente, quello proposto è solo un contributo minimo. Può essere migliorato contestualizzandolo nel sistema e facendolo diventare effettivamente produttivo.