Ecco disegnato lo schema elettrico del circuito di Tweetino: si tratta di fatto dei collegamenti standard per l’LCD, cui si aggiunge l’uso di una uscita PWM per regolare il contrasto (con le variazioni rese più “smooth” da un condensatore) e di un LED che segnala quando il programma sta aggiornando il tweet corrente da internet. Da notare che la scarsità di uscite dovuta alla scheda ethernet sull’Arduino Uno obbliga ad usare anche i pin 0 e 1, e di conseguenza a non poter più usare la connessione seriale nella versione finale del programma.
Appena arriva l’LCD 16×2, metto tutto nella scatola adatta e pubblico le foto finali!
I’ve just released the first version of Tweetino, a little sketch for the Arduino which downloads the latest tweets and displays them on an LCD.
The idea is quite simple: the application periodically polls the Twitter servers for getting the latest tweet for the given user, and then the text is shown on a screen; there is already a similar sketch in the new Ethernet libraries for Arduino IDE 1.0, but the difference here is that the connection to the servers uses OAuth, so it is able to get tweets from private accounts (and not just the public ones, like the other implementation cited before).
The code is hosted on Github, as usual, and it has to be filled with several details before being used, in particular it needs the token and access keys that a user can obtain from dev.twitter.com by registering a new application; in particular, the secret keys are to be stored in the EEPROM memory before launching the Tweetino application. Please refer to the README file for more details.
Remarks
First and foremost: I know that a good OAuth implementation should be developed in a separated library, instead of being entangled with the whole program, but the problem is that I’m testing everything on an Arduino Uno, which has just 2 KB of SRAM and OAuth requires some string manipulation, and there is not much space for it; moving everything in an external library requires some work which I have not done (yet), so for now just play around with the current code. Probably an Arduino Mega would help the development (having 8 KB of SRAM), but I don’t have any. Besides, trying to stick everything in just 2 KB has been quite fun.
Second, there is a known bug (sorry!): the Base64 library that I’m using sometimes returns a wrong value (at least with respect to the Erlang code implementation to which I am doing comparisons), and the request is refused by Twitter; given this fact (and the fact that I have no idea, for now, on the cause of the error), I have just added some code to repeat the request a few times in each cycle, in the hope that at least one of the calls behaves correctly. So, don’t expect some real time behavior!
Non so perchè mi ero perso questa cosa, ma è disponibile da maggio ormai la versione beta della 1.0 di Arduino IDE; i tarball si possono trovare qui, mentre il branch Git è qui.
Sì, so che è software non ancora stabile, ma a parte il fatto che questo non mi ha mai fermato, la cosa importante (almeno per me, oggi) è che il client DHCP funziona. Fino alla versione 0.22, infatti, era necessario utilizzare una libreria esterna che a me personalmente ha sempre dato problemi; in particolare, con Arduino Uno e l’Ethernet Shield di Adafruit, le richieste inviate al server DHCP sono malformate la maggior parte delle volte e la scheda non riesce a rispondere al DHCPOFFER, di fatto impedendo l’acquisizione di un indirizzo IP corretto.
Con la nuova versione dell’IDE, le librerie ethernet hanno (finalmente) incluso tutte le funzionalità di indirizzamento dinamico, e lo sketch di esempio per DHCP ha funzionato al primo colpo; questo mi basta a decidere di passare a questa versione (direi definitivamente, ma questo lo stabilirò solo dopo ulteriori test). Presto vi farò sapere quali seghe mentali esperimenti ho in ballo…
Ecco la presentazione di oggi alla Conferenza sull’Embedded, organizzata dal POuL; è possibile trovare il codice utilizzato per il server Web mostrato oggi su Github.
Finalmente questa mattina ho avuto un po’ di tempo ed ho fatto il circuito che avevo in mente ormai da qualche giorno, e che potete vedere nel video qui sopra (e sentirne la descrizione live).
Il progettino è un semplice Web server, ed è servito a mettere assieme lo shield Ethernet con uno degli LCD che ho acquistato qualche settimana fa: nella MicroSD si trovano le pagine Web autogenerate dai tool integrati in Erlang, si tratta semplicemente dell’equivalente della Javadoc per quel linguaggio, è la documentazione di un progetto. Ho rinominato i file in modo tale che rispettassero il formato 8.3 richiesto dalla libreria SD, modificando quindi anche tutti i link interni alle pagine stesse, per il resto è un insieme di file html, fogli di stile ed immagini (più un paio di documenti testuali).
Lo sketch caricato sull’Arduino Uno è un remix di diversi esempi trovati in giro, e ciò che fa è avviare un server Web all’IP specificato (l’idea iniziale era di ricevere l’IP via DHCP, ma questo implicava agganciarsi al router via cavo ed era scomodo), attendere le singole connessioni e restituire i file richiesti, cercando di indovinare il mimetype corretto (a partire dall’estensione), così che i browser interpretino le pagine e le immagini correttamente. Nel contempo, sullo schermo LCD viene mostrata la richiesta HTTP, e due led indicano se gli hit sono positivi (200, led verde) o negativi (404, led rosso).
La vera sfida è stata trovare posto per tutte le connessioni, non solo perchè la mia breadboard è decisamente piccolina per farci stare tutto, ma soprattutto perchè lo shield richiede 5 pin (4, 10, 11, 12, 13) e l’LCD 6, e dei rimanenti tre, i primi due sono collegati anche alla seriale; alla fine ho risolto collegando uno dei due led nell’ultimo pin veramente libero, e l’altro nel pin RX: questo comporta il fatto che durante il caricamento dello sketch questo led si accende, ma durante il funzionamento dell’applicazione esso risponde correttamente ai digitalWrite (non faccio uso della seriale, eventuale debugging avviene sullo schermo LCD).
Ora ho in mente un altro progettino, che applicherò sul Duemilanove ma per il quale ho bisogno di un paio di componenti; vi dico solo che il tutto comporterà l’interfacciamento con Processing e CSound…
E’ arrivato l’LCD per l’Arduino, dal solito fornitore AdaFruit! Per essere precisi, ne sono arrivati due, entrambi da 20×4, testati con il buon vecchio “Hello world” presente tra gli esempi d’uso della libreria. Si prospetta un progettino carino con lo shield Ethernet, non appena mi procuro una MicroSD, probabilmente nel weekend scriverò qualche dettaglio aggiuntivo.
Non solo, questi schermi sono stati l’occasione per effettuare la mia prima saldatura…
Continuano gli esperimenti con l’Arduino: oggi ho fatto un leggero remix del circuito che misura la luminosità di una stanza tramite l’apposito sensore, ed anzichè utilizzarlo per fare fade in/out di un led, l’ho impiegato per misurare i livelli per una decina di ore di fila, e con quattro righe di Python tirarne fuori un pratico grafico.
Intanto, iniziamo dal circuito:
Il circuito
La figura è presa dal manuale allegato ai kit di Adafruit, dato che è sostanzialmente identica al mio circuito, fatto salvo per la resistenza da 560 ohm, che è stata sostituita da una da 1k; il led veniva utilizzato solamente per indicare quando veniva registrato un sample dal sensore, diciamo come feedback visivo.
Il plot finale è il seguente:
Luminosità della stanza
I valori sono quelli misurati direttamente dal sensore e sono stati tutti invertiti (prendendo il massimo e sottraendolo da tutti i valori registrati in origine), così che zero indica il buio. Si può notare il decadimento iniziale, dovuto al calo di luce del primo pomeriggio, la piccola “S” che corrisponde a quando è stata accesa la luce interna, quindi l’abbassamento ulteriore dovuto alla sera, che si stabilizza quando il contributo della luce esterna è diventato nullo, quindi il buio quando ho lasciato la stanza e spento il lampadario. I due picchi verso la fine corrispondono a due brevi momenti in cui sono entrato in stanza a prendere delle cose.
L’Arduino ha misurato il valore del sensore ogni 30 secondi, raccogliendo 10 samples e facendone la media prima di comunicarli al PC (quindi la raccolta dati è avvenuta, di fatto, ogni 5 minuti).
So che è un’applicazione piuttosto semplice, ma mi è finalmente arrivato il Budget Pack della AdaFruit, e di conseguenza la primissima cosa per verificare che funzionasse il tutto è stata costruire due righe di codice che mettessero in comunicazione entrambe le mie schede.
La prima sceglie quante volte far lampeggiare il led e la comunica al PC via seriale; uno script Python gira tale comunicazione alla seconda scheda, che replica quindi il comportamento della prima.
La qualità video è quella che è, ma si capisce cosa succede direi…
Brevissimo update del mio ultimo post su Arduino & Java: ho verificato un sospetto che avevo, ed in effetti il codice di test funziona, il problema era dovuto ad una differenza di baud rate: il default dello sketch è 57600, mentre quello della classe Java Arduino è 115200; sovrascritto quest’ultimo valore (usando un costruttore diverso), la demo funziona correttamente.
In allegato, il codice aggiornato (con tanto di script Ant, se non volete usare Eclipse; dovrete comunque passare il path della libreria nativa all’interprete, temo): Arduino – Eclipse.
Syvo3 