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. VEDI). Al primo avvio di Processing la libreria verrà caricata e sarà subito utilizzabile. Quello che vogliamo fare è utilizzare questa libreria per dialogare con un iPhone connesso in Wi-Fi alla rete del PC e poter così gestire da remoto la scheda Arduino. Per arrivare a fare questo è necessario installare sull’iPhone un’applicazione in grado di utilizzare lo standard Open Sound Control che si chiama TouchOSC, il cui sito di riferimento è http://hexler.net/touchosc.
Dal sito è possibile scaricare il manuale utente touchosc-manual-v1-1.pdf ed alcuni esempi di utilizzo anche per Processing:

 

  • simple.pde; serve alla ricezione ed alla visualizzazione di messaggi dal “Simple” layout (solo pagina 1); richiede la libreria oscP5;
  • Example Code per la gestione dei dati dell’accelerometro;
  • Processing Apps – Processing examples + video by Mike Cook.

TouchOSC è scaricabile dall’AppStore della Apple, al costo di 3,99 euro, giustificato anche dal fatto che questa applicazione è completamente configurabile tramite un semplicissimo editor, che può essere scaricato dal sito di riferimento e che è:

  • touchosc-editor-1.4-osx.zip per Mac OS X;
  • touchosc-editor-1.4-win32.zip per Windows;
  • touchosc-editor-1.4-noarch.zip per Linux o altri sistemi operativi.

Per mettere in funzione il tutto è bene iniziare con l’esempio,denominato simple.pde, già disponibile sul sito. Per poterlo utilizzare dovete creare una cartella chiamata simple all’interno della libreria oscP5 e copiarci dentro il file simple.pde.

CREATE quindi una rete Wi-Fi tra il PC e l’iPhone (Fig. VEDI). Aprite processing ed avviate lo sketch simple.pde; dal lato iPhone avviate l’applicativo TouchOSC ed impostate i parametri per l’accesso alla rete mediante il protocollo UDP (figure VEDI e VEDI). Fatto ciò, alla voce HOST inserite l’indirizzo IP del Computer, quindi nella sezione PORT (outgoing) scrivete il numero 8000; alla voce PORT (incoming) immettete il numero 9000. Introdotti questi valori, alla voce LOCAL IP ADRESS comparirà in automatico l’indirizzo IP dell’iPhone.
Nella relativa schermata selezionate come Layout il modello Simple ed avviate l’applicativo (Fig. VEDI). Complimenti! Adesso il vostro iPhone potrà interagire con il software Processing. Adesso siamo pronti per creare il nostro applicativo per la gestione della scheda Arduino: vogliamo realizzare un controllo con un pulsante per accendere e spegnere un LED ed un fader per regolare la luminosità di quest’ultimo. Mentre su Arduino è sempre caricato firmataStandard.pde, noi dobbiamo occuparci di creare l’interfaccia per l’iPhone e lo sketch per Processing. Avviamo quindi TouchOSC editor e, sulla schermata dell’iPhone, cliccando con il pulsante destro inseriamo un toggle button ed un fader verticale (Fig. VEDI e VEDI). Cliccate su sync e seguite le istruzioni a video per caricare la nuova schermata sull’iPhone; l’operazione avviene tramite la rete Wi-Fi in modo molto semplice e funzionale. Selezionate questo nuovo layout ed avviatelo, aprite processing e caricate lo sketch processing_osc_01.pde che riportiamo nel Secondo Listato. Lo sketch in questione prevede la gestione dei messaggi in standard OSC provenienti dall’iPhone e intercettati grazie alla funzione oscEvent, dai quali viene estrapolato il valore del fader e del pulsante. Questi valori sono utilizzati per gestire la grafica a video (anche se non strettamente necessario) e i comandi per Arduino, già sperimentati nei precedenti esempi. Ricordatevi di attivare la casella stay connected per fare in modo che il canale di comunicazione rimanga aperto (Fig. VEDI).
Un ultimo esempio molto significativo (processing_osc_03.pde) prevede l’utilizzo dell’accelerometro interno all’iPhone i cui valori possono essere elaborati tramite Processing, in questo caso per comandare la luminosità del LED della scheda Arduino. Per questa applicazione è importante che attiviate la casella Accelerometer, questo permetterà all’applicazione TouchOSC di inviare in continuazione i valori dell’ accelerometro interno ad IPhone. Nella schermata dello sketch di processing sarà visualizzato un rettangolo in 3D che mostrerà l’orientamento dell’IPhone, mentre, a seconda della sua inclinazione, si potrà variate la luminosità del LED connesso al pin 9 della scheda Arduino. Il LED dell’uscita 13, invece, si accenderà e si spegnerà a seconda di quale faccia dell’iPhone è rivolta verso l’alto (Fig. VEDI). Completiamo l’articolo con un esempio conclusivo che prevede l’utilizzo di comandi OSC bidirezionali tra Processing (file processing_osc_04) e ToucOSC (file ein_testin.touchosc). Oltre ai comandi già descritti, che prevedono da IPhone la gestione di un pulsante e uno slider di Processing, adesso aggiungiamo un controllo LED su Touchosc la cui accensione è gestita da Processing. Non riportiamo l’intero codice, ma solo la nuova parte attinente l’invio di comandi. La prima riga dichiara una variabile IPhone-Location che contiene l’indirizzo IP del nostro IPhone e la porta di comunicazione adibita alla ricezione dei messaggi, già dichiarata su Touchosc:

 

{codecitation class=”brush:cpp”}

IPhoneLocation   =   new   NetAddress(“192.168.0.46”,9000);

{/codecitation}


Quando viene premuto il pulsante del mouse su un qualsiasi punto dello sketch di Processing avviene l’invio del comando per attivare il LED:

{codecitation class=”brush:cpp”}


void mousePressed()

{
OscMessage myMessage = new OscMessage(“/1/
led1”);
if (LEDStatus==1)

{

LEDStatus=0;
myMessage.add(LEDStatus) ; /* add comando per led1 */

}

else

{
LEDStatus=1;
myMessage.add(lEDStatus) ; /* add comando per led1 */

}
oscP5.send(myMessage, IPhoneLocation);

}

{/codecitation}

La prima riga provvede alla creazione del messaggio che deve riportare la posizione del LED (“/1/led1”); successivamente al messaggio, viene aggiunto (mymessage.add) il valore, in questo caso 1 o 0, a seconda se si vuole accendere o spegnere il LED. Dopodiché il messaggio viene spedito all’indirizzo specificato. L’istruzione IF viene semplicemente usata per la funzione toggle del LED ad ogni pressione del pulsante del mouse (Fig. VEDI – Fig. VEDI). L’aggiunta delle righe di codice per la gestione di Arduino risulta abbastanza semplice; prendete spunto dagli esempi precedenti.

Codice ( Sketch ) Secondo Listato

{codecitation class=”brush:cpp”}

/**

processing_osc

Test controllo Arduino con IPhone

su Arduino è installato firmatastandard

V1.0

*/

// Per OSC

import oscP5.*;

import netP5.*;

0scP5 oscP5;

// Per Arduino

import processing.serial.* ;

import ce.arduino.*;

Arduino arduino;

int[]  values = { Arduino.LOW };

int  pin_out =  13;     //  Definisce  pin di   uscita   13  (LED on  board)

float fader1 = O.Of;

float toggle1 = O.Of;

float led1 = O.Of;

void setupt()
{

size(320,440);

frameRate(25);

/* start oscP5, listening for incoming messages at port 8000 */

oscP5 = new OscP5(this,8000) ;

// Impostazioni per Arduino

println(Arduino.list());

arduino = new Arduino(this, Arduino.list()[3], 57600);

// Impostare l’indice array (2) a seconda della C0M usata da Arduino

// Utilizzare le indicazioni riportate sulla taskbarr in basso all’avvio

// del programma

arduino.pinMode(pin_out, Arduino.OUTPUT);

}

void oscEvent(OscMessage theOscMessage) {

String addr = theOscMessage.addrPattern);

float val = theOscMessage.get(0) .floatValue() ;

if(addr.equals(“/1/fader1”) )      { fader1 = val ; }

else if(addr.equals(“/1/toggle1”) ) { toggle1 = val ; )

}

void draw()
{

background(O);

// toggle 1 outlines

fill(O);

stroke(0,   196,   168);     //  Set  colore  bordo  pulsante

rect(80,95+100,60,60);     //Set  posizione bordo  pulsante

//  toggle  1  fills

fill(O,   196,   168);

if(toggle1 == 1.Of)   {

rect(80,95+100,60,60);

arduino.digitalWrite(pin_out, Arduino.HIGH);     //  LED 0N

}

else

arduino.digitalWrite(pin_out, Arduino.LOW) ; // LED OFF

// fader 1 outlines

fill(0);

stroke(255, 237, 0);   // Set colore bordo fader

rect(20+200,95,60,255); //Set posizione bordo fader

// fader 1 fills

fill(255, 237, 0);

rect(20+200,95+200+55,60,-fader1*255);  //Set posizione bordo fader

arduino.analogWrite(9, int(fader1*255) ) ;  //Set luminosità LED

}

{/codecitation}

 

Share This