Arduino in the cloud!

La mania del cloud pervade anche gli ambienti più diversi!
Anche Arduino ha il suo IDE in cloud (anche se in versione beta).
Codebander, questo il nome del progetto, è una webapp scritta in HTML 5 + javascript.

Maggiori informazioni qui: http://arduino.cc/blog/2012/07/04/programming-arduino-on-the-cloud-codebender/

Come usare un sensore di prossimità con Arduino

Collegare un sensore di prossimità ad Arduino per calcolare la distanza da un oggetto.
Esistono diversi circuiti integrati che assolvono questo compito.
Le tecnologie utilizzate sono sostanzialmente due: infrarossi ed ultrasuoni. La mia scelta è caduta sul Sonic SRF05 che impiega la seconda tecnologia: dal datasheet e dai vari post che ho visto in giro, sembrava quello più affidabile, più economico e più semplice da impiegare.
Ho acquistato l’integrato in Italia su Robot-Italy
Il circuito si presenta così:



Il funzionamento è semplice, avviene inviando un impulso ad ultrasuoni (frequenza attorno ai 40Khz), attendendo che l’impulso ritorni dopo aver colpito un oggetto. Misurando il tempo impiegato fra il momento in cui l’impulso è stato emesso e quello in cui questo ritorna, viene calcolata la distanza fra il sensore e l’oggetto. Le distanze misurabili vanno dai 3 cm ai 4 metri.

Interfacciare il sensore ad Arduino è veramente molto semplice, ci sono solo 4 connettori di cui preoccuparsi: alimentazione, massa, trigger ed echo. L’alimentazione richiesta è pari a 5V, esattamente la tensione emessa da Arduino, per cui per alimentarlo è sufficiente collegarlo al controllore senza l’ausilio di alimentazioni esterne.

Schema di collegamento

Colleghiamo il connettore ‘echo’ al Pin 2 del controllore, quello trigger al Pin 3 e, in fine, i due Pin di alimentazione (+5V e GND).
Fatti i dovuti collegamenti hardware passiamo alla parte software, useremo questo algoritmo per la lettura della misura: dopo aver inizializzato le variabili e i PIN del controllore, eseguiamo 10 letture consecutive, ne calcoliamo le media e prendiamo quella come valore della distanza in cm.

Di seguito il codice sorgente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/*
 * Autore: Corrado Ignoti
 *
 * Descrizione: Interfaccia un SFR05 con Arduino
 *
 * Maggiori informazioni su: http://www.corradoignoti.it
 */


const int numOfReadings = 10;                   // numero di letture
int readings[numOfReadings];                    
int arrayIndex = 0;                             // contatore per ciclare nell'array
int total = 0;                                  
int averageDistance = 0;                        // distanza media

// inizializzo i PIN per collegare la scheda SFR05
int echoPin = 2;                                // echo (digital 2)

int initPin = 3;                                // trigger  (digital 3)
unsigned long pulseTime = 0;                    
unsigned long distance = 0;                     // distanza in cm

//setup
void setup() {
  pinMode(initPin, OUTPUT);                    
  pinMode(echoPin, INPUT);    
 
  // inizializza un array delle letture
  for (int thisReading = 0; thisReading < numOfReadings; thisReading++) {
    readings[thisReading] = 0;
  }
     Serial.begin(9600);  //inizializza la seriale
}

// loop principale
void loop() {
  //manda un impulso di ampiezza 10 us
  digitalWrite(initPin, HIGH);                    
  delayMicroseconds(10);                          
  digitalWrite(initPin, LOW);                    
  pulseTime = pulseIn(echoPin, HIGH);             // Aspetta l'eco di risposta
  distance = pulseTime/58;                        // Distance = tempo impulso / 58 per calcolare i [cm] di distanza.
 
 //Per diminuire l'errore crea un array con le letture e calcola la media
  total= total - readings[arrayIndex];            
  readings[arrayIndex] = distance;              
  total= total + readings[arrayIndex];            
  arrayIndex = arrayIndex + 1;                    
 
  if (arrayIndex >= numOfReadings)  {
      arrayIndex = 0;
  }
  averageDistance = total / numOfReadings;      //Media dei valori delle distanze acquisite
 
  //Scrive il valore della distanza media sulla seriale
  Serial.print ("Distanza (media): ");
  Serial.println(averageDistance, DEC);        
  delay(100);                                  
}

All’inizio del ciclo loop() questa porzione di codice:

1
2
3
4
5
  digitalWrite(initPin, HIGH);                    
  delayMicroseconds(10);                          
  digitalWrite(initPin, LOW);                    
  pulseTime = pulseIn(echoPin, HIGH);            
  distance = pulseTime/58;

manda un impulso per 10us aspetta e si mette in ascolto aspettando l’eco di risposta. Attraverso la primitiva pulseIn(), calcola il tempo fra l’emissione del segnale e la ricezione dell’impulso di risposta. La distanza in cm si ottiene dividendo per 58 questo valore.
La seconda parte del codice, esegue 10 letture consecutive, le mette in un array. Calcola la media delle letture e stampa questo valore sulla seriale.

Iniziare con Arduino

Ed eccomi con la mia nuova tencomalattia: arduino.
Ho provato in tutti i modi a limitarmi e non comprare l’ennesimo giocattolo tecnologico, ma non ci sono riuscito: alla fine ho ceduto e ho fatto l’acquisto.
Seguendo un po’ di documentazione qui e la, ho preso il set minimo di componenti per iniziare ad usare il processore.
L’ultima versione di Arduino è denominata “uno”: leggendo in giro ho visto che è la versione consigliata. Il mio ordine d’acquisto era quindi composto da:

  • 1 Arduino Uno
  • 1 starter kit

Lo starter kit contiene: una basetta millefori per testare i circuiti, alcuni LED, alcuni resistori, un paio di micropulsanti, un cavo USB ed altri componenti minimi utili per iniziare a fare i primi circuiti. Chi ha già dimestichezza con l’elettronica, sicuramente avrà già una buona parte dei componenti necessari ad iniziare.

Per iniziare a giocare è necessario installare il software di sviluppo di Android, io ho deciso di fare il setup sul Mac. L’ambiente è disponibile per Windows, Mac e Linux.

La documentazione messa a disposizione sul sito ufficiale del progetto arduino è esaustiva, qui si trova il tutorial per fare il setup del software per Mac

Il .dmg è scaricabile direttamente dalla pagina dei download del sito ufficiale di Arduino.

Nel DMG ci sono due oggetti: un file che contiene l’applicazione per lo sviluppo e un .pkg che contiene i driver per far riconoscere al Mac la scheda Arduino collegata via USB.

L’installazione avviene facendo doppio click sul file .pkg e trascinando l’applicazione nella cartella di sistema “Applicazioni”.

Bene adesso siamo pronti a collegare il controllore al Mac attraverso il cavo USB.
Le procedure descritte nel “Getting Started” dicono di iniziare sul inviando al processore Blink che, come si intuisce dal nome, fa lampeggiare il LED “L13” presente sulla scheda. Nel mio caso, una volta collegato, il controller ha iniziato a far lampeggiare L13 senza che io facessi nessuna operazione particolare. A questo punto, per capire se avevo fatto tutto bene, ho provato a cambiare il codice dell’esempio in questo modo:

1
2
3
4
5
6
7
...
void loop() {
digitalWrite(13, HIGH);   // set the LED on
delay(100);              // wait
digitalWrite(13, LOW);    // set the LED off
delay(100);              // wait
...

Nulla di particolare rispetto all’esempio originale: semplicemente ho cambiato la frequenza con la quale il LED lampeggia. Nell’esempio originale il LED la frequenza è pari a 1 secondo, dopo la modifica sarà pari a 1/10 di secondo.