Arduino Processing e iPhone

Processing è un linguaggio di programmazione basato su Java, che consente di sviluppare diverse applicazioni come giochi, animazioni e contenuti interattivi. Basandosi su Java, ne eredita completamente la sintassi, i comandi e il paradigma di programmazione orientata agli oggetti; in più, mette a disposizione numerose funzioni ad alto livello per gestire facilmente l’aspetto grafico e multimediale. E’ distribuito sotto licenza Open Source ed è supportato dai sistemi operativi GNU/Linux, Mac OS X e Windows. Il pacchetto, scaricabile gratuitamente dal sito ufficiale http://processing.org, mette a disposizione un ambiente di sviluppo integrato (IDE), e le varie creazioni (chiamate sketch) vengono organizzate in uno sketchbook. Ogni sketch contiene in genere, oltre alle classi che lo compongono, una cartella chiamata Data in cui viene inserito il materiale multimediale utile all’applicazione, quali, ad esempio, immagini, font e file audio. Ogni applicazione creata può inoltre essere esportata come Java applet. Le funzionalità di processing possono essere espanse tramite delle librerie aggiuntive, spesso CREATE da terze parti, ottenendo un ambiente di sviluppo molto poliedrico. Ad esempio, è possibile utilizzare in Processing protocolli di

comunicazione Seriale, TCP/IP, UDP, RDP, OSC, riuscendo in questo modo a gestire una moltitudine diapplicazione hardware esterne. Grazie alla libreria specifica Arduino, l’integrazione tra il

 

mondo software e quello hardware non è mai stata così facile: basti pensare che l’ambiente di sviluppo Software di Arduino è derivato proprio da Processing, con il quale condivide sia la

struttura che il linguaggio di programmazione. In questo articolo non ci addentreremo nella descrizione di Processing, peraltro ben documentato su diversi siti, ma piuttosto impariamo quei pochi ed essenziali passaggi che ci permettono di poterlo interfacciare con la scheda Arduino (la Duemilanove, in questo caso…) tramite alcuni semplici esempi. Lasciamo a voi il piacere di utilizzare questi strumenti come meglio vi conviene, realizzando degli applicativi più complessi e di maggiore utilità. Per prima cosa dobbiamo preparare la nostra scheda Arduino in modo che possa essere gestita in remoto dal software Processing; allo scopo, dobbiamo collegarla al PC e caricarvi l’apposito sketch denominato StandardFrimata.pde, situato nella cartella arduino-018\libraries\firmata\example\StandardFirmata.pde.
Con il termine Firmata si intende un generico protocollo di comunicazione per microcontrollori e computer, che essendo molto semplice, può essere facilmente implementato su qualsiasi piattaforma software. A chi volesse approfondire la conoscenza di questo protocollo, consigliamo il link: http://firmata.org/Wiki/Main_Page. Il riferimento ad Arduino, invece, lo si trova all’indirizzo web http://arduino.cc/en/Reference/Firmata, dal quale è possibile scaricare, oltre alla libreria, anche alcuni esempi.
Caricando questo firmware, si ha la possibilità di gestire in remoto la scheda Arduino proprio con questo protocollo; tra le altre cose, il firmware è facilmente adattabile alle più svariate applicazioni; infatti nella cartella esempi troverete altri sketch che permettono di gestire funzioni specifiche della scheda Arduino.
Prima di caricare lo sketch su Arduino assicuratevi che, nella riga Firmata.begin(57600);, sia impostata una velocità di comunicazione di 57.600 bps. Per collaudare i nostri esempi collegate al pin 9, tramite una resistenza da 200 ohm, un LED, mentre al pin 2 (che useremo come ingresso) connettete un pulsante con la relativa resistenza di pull-down. ( Fig. VEDI )

Codice ( Sketch ) Primo Listato

{codecitation class:”brush:cpp”}

/*
processing_02
Semplice esempio di utilizzo del software Processing per
dialogare con Arduino duemilanove. Su Arduino  caricato
StandardFirmata.pde, questo programma va utilizzato con Processing-I.2.1
Con il mouse sul shape-quadrato si attiva l’uscita 13
L’ingresso 2 viene usato per cambiare colore al shape-cerchio.
Con il mouse sullo shape rettangolo si regola la luminosità
del LED connesso all’uscita 9.
*/
import  processing.serial.*;
import  cc.arduino.*;
Arduino arduino;
color  off = color(4, 79, 111);
color  on  = color(84, 145, 158);
int[]  values =  {  Arduino.LOW  };
int  pin_out =  13;     //  Definisce pin di   uscita  13  (LED on  board)
int pin_in    = 2;       //  Definisce pin  di   ingresso  2
void setup()
{
size(200, 200);
println(Arduino.list());
arduino = new Arduino(this , Arduino.list()[2], 57600);
// Impostare l’indice array (2) a seconda della COM usata da Arduino
// Utilizzare le indicazioni riportate sulla taskbarr in basso all’avvio
// del programma
arduino.pinMode(pin_out, Arduino.OUTPUT);
arduino.pinMode(pin_in, Arduino.INPUT);
}
void draw()
{
background(off);
stroke(on);
// Modifica  colore  shape-qadrato  a  seconda  del   livello  logico dell’uscita
if   (values[0]  == Arduino.HIGH)
fill(on);
else
fill(off);
rect(40,   40,   40,   40);
// Modifica  colore  shape-cerchio  a  seconda  del   livello  logico dell’ingresso
if  (arduino.digitaiRead(pin_in) == Arduino.HIGH)
fill(on);
else
fill(off);
ellipse(150,   60,   40,   40);
//  Controllo  luminosita’   LED
fill(constrain(mouseX   /  2,   0,   255));
rect(40,   140,   140,   40);
arduino.analogWrite(9, constrain(mouseX / 2, 0, 255));
}
void   mousePressed()
{
//   Verifica sei premuto pulsante del mouse sopra la shape-quadrato
//   nel qual caso inverte stato pin di uscita
if (mouseX>40 & mouseX<80 & mouseY>40 & mouseY<80)
{
if (values[0] == Arduino.LOW)
{
arduino.digitalWrite(pin_out, Arduino.HIGH);
values[0] = Arduino.HIGH;
}
else
{
arduino.digitalWrite(pin_out, Arduino.LOW) ;
values[0] = Arduino.LOW;
}
}

 

{/codecitation}

A questo punto passiamo al lato PC; per prima cosa dobbiamo scaricare e scompattare Processing dal sito di riferimento: http:// processing.org/download/. Appena scompattato, il software è subito pronto e non necessita di installazione, proprio come l’IDE di Arduino. Affinché Processing possa dialogare con Arduino, è necessario installare l’apposita libreria che troverete qui: http://www.arduino.cc/playground/uploads/Interfacing/processing-arduino-0017.zip. Esiste anche una sezione del sito di Arduino dedicata a Processing, rintracciabile dalla pagina web http://www.arduino.cc/playground/Interfacing/Processing. Esistono diverse versioni di questa libreria; ad esempio, una meno recente si trova in un file chiamato processing-arduino2.zip, ma consigliamo di utilizzare sempre la libreria più recente. Scompattate i file scaricati e copiate la cartella Arduino all’interno della cartella libraries di Processing; l’aggancio alla libreria avviene al primo avvio del programma. All’interno dei file della libreria trovate anche alcuni esempi di sketch per Processing, con alcuni controlli per Arduino; ad esempio, arduino_output.pde (Fig. VEDI) disponibile in processing/libraries/arduino/example, che permette di comandare le uscite di Arduino. Con la scheda Arduino connessa alla USB, caricate questo sketch su Processing e verificate la riga arduino = new Arduino(this, Arduino.list()[0], 57600). Assicuratevi che la velocità di comunicazione sia impostata su 57600; ricordate che occorre impostare la porta di comunicazione settando l’indice del vettore Arduino.list, il quale contiene l’elenco delle porte COM installate nel PC. Andate su esplora risorse di Windows per conoscere su quale porta è presente Arduino, quindi avviate lo sketch; anche se ciò determinerà la segnalazione di errore in comunicazione, vi farà vedere nella taskbar in basso le porte COM installate ed il corrispondente indice del vettore. Avviate il programma, la prima casella a sinistra corrisponde all’uscita 13 di Arduino, alla quale è presente il LED interno. Potete accenderlo e spegnerlo a vostro piacimento. Per verificare le altre uscite è necessario connettere un LED su ogni uscita. Sono presenti altri due esempi utili per testare uno gli ingressi digitali e l’altro le uscite PWM.
Per provare appieno queste nuove funzioni, ci siamo cimentati nella stesura di uno sketch che permettesse di attivare un’uscita e visualizzare lo stato di un ingresso; lo abbiamo chiamato Processing_01.pde. Descriviamo, però, un secondo sketch denominato Processing_02, con il quale oltre
a gestire in ed out controlliamo la luminosità di un LED tramite l’uscita PWM. Le righe di codice corrispondenti sono riepilogate nel Primo Listato. La Fig. VEDI mostra la schermata di uno sketch che comanda i LED della scheda Arduino: facendo clic nella casella quadrata in alto a sinistra, attivate il LED interno ad Arduino, mentre sul cerchio in alto a destra potete vedere il livello logico del pin 2, usato come ingresso. Il rettangolo in basso, se puntato col mouse permette di regolare la luminosità del LED connesso all’uscita 9. Con un po’ di pratica, seguendo i numerosissimi tutoria! ed esempi disponibili in rete, potrete realizzare la vostra interfaccia; vi ricordiamo che il software è in grado di gestire anche grafica in 3D ed animazioni. L’applicativo può essere esportato in svariati formati, anche come applet java da inserire nel vostro sito personale. È anche possibile esportare l’applicazione in formato eseguibile (.exe) per i diversi sistemi operativi, in modo da distribuire molto facilmente il vostro lavoro.

OSC

 

Se già quanto esposto finora vi sembra abbastanza, adesso vi faremo vedere un’altra interessantissima applicazione realizzata con questo software. Si tratta di utilizzare il protocollo OSC per poter gestire la scheda Arduino tramite una periferica esterna con accesso alla rete in modalità Wi-Fi. Ma andiamo per gradi e spendiamo due parole per spiegare cos’è OSC. Open Sound Control (OSC) è un protocollo di comunicazione per messaggi tra computer, strumenti musicali elettronici e altri dispositivi multimediali, ottimizzato per funzionare nelle moderne reti informatiche. I benefici delle moderne tecnologie di reti nel mondo degli strumenti elettronici OSC permette di aggiungere molta flessibilità organizzativa oltre, ovviamente, a controlli centralizzati per grossi studi, teatri o concerti. Per chi volesse conoscere più approfonditamente questo standard di comunicazione consigliamo il sito: http://opensoundcontroi.org/.
Affinché Processing possa gestire una comunicazione con OSC è necessario installare l’apposita libreria, scaricabile all’indirizzo http://www.sojamo.de/libraries/oscP5/. Sempre a questo indirizzo, è disponibile tutta la documentazione per l’utilizzo di tale libreria. Il file oscP5.zip deve essere scompattato all’interno della cartella libraries di Processing (Fig.