Se vi siete chiesti il perché di questi mesi di assenza, ecco la spiegazione: Apple ha appena approvato la mia prima applicazione per iPad, si chiama Chords Archiver, è gratis ed è un archiviatore di accordi e testi di canzoni, con alcune ottimizzazioni per l’utilizzo durante le performance live.

Ho approntato anche un pagina di supporto che ne spiega il funzionamento e le caratteristiche principali.

Ovviamente, trattandosi della mia prima applicazione per iPad (e più in generale per iOS), sono graditi, anzi incoraggiati, commenti, suggerimenti e critiche.

Condividi

Il pulsante (o pushbutton) è un componente che, quando premuto, connette due punti del circuito. Ci sono 5 pushbutton nel KIT Workshop che abbiamo acquistato all’inizio di questo viaggio alla scoperta di Arduino e ognuno di questi ha il seguente schema costruttivo:

In pratica i piedini A e C sono sempre connessi fra loro, così come i piedini B e D, mentre se il pulsante viene premuto, sono connessi tra loro tutti i piedini. Come possiamo utilizzare il pushbutton con Arduino? Basta seguire un tutorial, sul sito ufficiale, chiamato appunto Button e che permette di accendere un led quando viene premuto il pulsante. Ecco come si realizza.

Come si realizza questo circuito con pulsante? Colleghiamo il piedino A direttamente a terra (ad esempio uno dei pin etichettati con Gnd nella fila di pin chiamata POWER) e il piedino B prima ad una resistenza da 2.2 KOhm (ecco come è fatta) e poi all’alimentazione da 5 V. Come mostrato nello schema seguente, dobbiamo connettere il piedino B anche con il pin 2 che sarà quello che riceverà il messaggio “pulsante premuto”:

Il tutorial originale spiega che la resistenza da 2.2 KOhm ha una funzione cosiddetta di pull-up che serve ad evitare che il segnare sul pin 2 fluttui quando il pin viene disconnesso dal circuito. Durante le mie prove non ho però riscontrato fluttuazioni ma piuttosto, quando ho eliminato la resistenza sostituendola con un collegamento normale, un assorbimento eccessivo di energia che ha fatto decidere al Mac di disattivare momentaneamente la porta USB a cui Arduino era collegato (con conseguente riavvio del dispositivo). Osservando il funzionamento del circuito, che illustrerò qui di seguito, ho idea che la resistenza di pull-up serva sostanzialmente a forzare un livello logico (come il nostro HIGH) quando il circuito è aperto permettendo di andare su LOW non appena si chiude il circuito. Ma vediamo in dettaglio il circuito e di seguito ne illustrerò il funzionamento e il software da utilizzare:

Come funziona esattamente il circuito? Quando il pushbutton è aperto (ovvero, come abbiamo visto prima, non è premuto) non c’è nessuna connessione fra i due piedini che abbiamo usato, il piedino A e il B. In tale situazione (anche se attraverso la resistenza di pull-up) il pin 2 è connesso all’alimentazione da 5 V e quindi Arduino legge il pin ad un livello HIGH. Quando invece il pushbutton è premuto il circuito è chiuso e fra il piedino A e il B si crea una connessione, quindi il pin 2 si trova allo stesso potenziale della terra e Arduino leggerà quindi il valore LOW (ovviamente il pin 2 è ancora connesso con l’alimentazione a 5 V, ma la resistenza interposta fa sì che tale pin sia più vicino alla terra).

Viene a stabilirsi quindi la seguente corrispondenza:

• Pulsante non premuto -> pin 2 a livello HIGH
• Pulsante premuto -> pin 2 a livello LOW

A questo punto manca solo il codice da inviare ad Arduino, che non farà altro che ricevere il segnale dal pin 2 e reagire con una istruzione, nel nostro a caso al pin 13:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

int ledPin = 13;
int inPin = 2;
int val = 0;
 
void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(inPin, INPUT);
}
 
void loop(){
  val = digitalRead(inPin);
  if (val == HIGH) {
    digitalWrite(ledPin, LOW);
  } else {
    digitalWrite(ledPin, HIGH);
  }
}

Più in dettaglio, le prime tre righe di codice dichiarano le variabili che impostano il pin 13 come collegamento al led rosso, il pin 2 come pin di entrata del segnale del pulsante, e che infine (con val) impostano il valore iniziale dello status del pin 2 (ovvero del pushbutton).

All’interno del blocco setup() avviene qualcosa di importante, ovvero viene impostato il led 13 come OUTPUT e, per la prima volta, il pin 2 come INPUT.

A questo punto, nel blocco loop(), la prima istruzione, in riga 11, non fa altro che leggere il valore di input, ovvero lo status del pulsante, tramite la funzione digitalRead().

Successivamente il blocco if controlla se il valore di input val è stato letto come HIGH e quindi accende il led rosso (riga 13), altrimenti, lo spegne.

Se volessimo invertire il funzionamento del pushbutton basterebbe scambiare LOW e HIGH nelle righe 13 e 15 del software (senza dover toccare il circuito).

Ma la caratteristica più importante di questo circuito e del software annesso è che le istruzioni di accensione e spegnimento del led sono solamente un esempio e quindi, una volta ricevuto l’input dal dito della persona che ha premuto il pulsante, Arduino può reagire virtualmente in qualsiasi modo. Il limite è il nostro ingegno.

A presto per nuovi articoli su come imparare a usare Arduino!

Condividi

In che senso? Mentre infatti è in esecuzione la funzione delay() (ad esempio per 1000 millisecondi), non possono essere eseguite altre istruzioni e, se il nostro obiettivo è quello di far interagire Arduino col mondo esterno, non avrebbe molto senso un blocco del dispositivo dal momento che, probabilmente, il mondo esterno non aspetterà pazientemente la fine dell’esecuzione della funzione delay()…

La soluzione è allora tenere traccia dell’istante in cui si è fatto accendere o spegnere il nostro led rosso e, ogni volta che il loop() viene eseguito, è sufficiente controllare se un intervallo di tempo minimo è passato. Se sì, il led va spento, o riacceso.

Vediamo come. Innanzitutto bisogna introdurre una nuova funzione denominata millis() che restituisce il numero di millisecondi trascorsi dall’inizio dell’esecuzione del programma (e si riazzera una volta ogni 50 giorni circa… sempre che teniate Arduino acceso per così tanto tempo).

Ecco il listato che utilizzeremo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int ledPin = 13;
int value = LOW;
long previousMillis = 0;
long interval = 1000;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  if (millis() - previousMillis > interval) {
    previousMillis = millis();
 
    if (value == LOW)
      value = HIGH;
    else
      value = LOW;
 
    digitalWrite(ledPin, value);
  }
}

Le prime quattro righe dichiarano 4 variabili. Le prime due sono interi che stabiliscono il numero del pin a cui è connessa la zampa lunga del nostro led rosso (l’altra è sempre connessa al GND) e il valore iniziale di corrente al pin (LOW è come dire 0 Volt). Le seconde due variabili sono di tipo long (ovvero hanno la possibilità di immagazzinare valori numerici interi con molte più cifre del tipo int) e servono per memorizzare il valore in millisecondi restituito da millis() e l’attesa fra un’accensione e uno spegnimento del led rosso. Il fatto che anche interval sia una variabile long (pur avendo solo 4 cifre) è per permettere di eseguire correttamente la sottrazione in riga 13 fra tipi uguali di variabili.

In riga 8 settiamo il pin 13 come OUTPUT e poi entriamo nel blocco loop(). A questo punto, ad ogni esecuzione del ciclo, viene controllato se millis() - previousMillis è maggiore di interval, ovvero se è passato un tempo uguale o superiore a quello impostato come intervallo fra un’accensione e uno spegnimento. Se sì, in riga 14 viene subito impostato l’attuale valore di millis() come nuovo valore di previousMillis, pronto per la successiva esecuzione del loop().

Nelle righe dalla 16 alla 19 non viene fatto altro che controllare lo stato precedente del pin 13 e, in pratica, se il led è spento viene deciso di accenderlo, se è acceso viene deciso di spegnerlo. Nella riga 21 viene data esecuzione al comando digitalWrite() che, in base al valore della variabile value, agisce direttamente sui livelli del pin 13.

Fra la riga 22 e la 23 (quindi fuori dal primo costrutto if (iniziato in riga 13 e ancora dentro il loop()) possiamo inserire un numero qualsiasi di istruzioni che verranno eseguite immediatamente, senza attendere che siano passati i 1000 millisecondi impostati con interval.

Il prossimo tutorial introdurrà un primo esempio di interazione Arduino-essere umano. Come sempre se avete domande lasciate un messaggio, ehm, un commento.

Condividi

In poche parole, la breadboard (letteralmente tavola di pane) è una basetta provvista di numerosi fori connessi fra loro secondo uno schema a righe o colonne, ovvero:

In particolare la nostra breadboard è quella nella figura qui in basso e possiede una parte centrale (divisa in due) costituita da 63 righe con 10 fori per ogni riga (posizioni da A a E e, separate dalle prime, da F a J), più due fasce laterali con ognuna due colonne costituite da 50 fori e contrassegnate da i segni + e -, per un totale di 830 fori (anziché 840 come indicato nella confezione):

A questo punto possiamo utilizzare la breadboard per costruire un circuito elettrico da collegare al nostro Arduino.

Innanzitutto immaginiamo di voler far lampeggiare un led rosso che sia connesso ad un pin diverso dal numero 13. Potremmo piegare le zampette del led per adattarle alla distanza da coprire ma questo, oltre ad essere antiestico, è certamente una soluzione che rischia di rovinare le zampette stesse e limita fortemente l’espansione futura, non permettendo la possibilità di inserire ulteriori componenti. L’idea è quindi quella di utilizzare la breadboard per realizzare delle connessioni elettriche (con dei cavi o con i ponticelli in dotazione con il KIT Workshop) in modo da scegliere facilmente da quale pin far alimentare il nostro caro led rosso.

Ecco come realizzarlo:

In pratica si due collegamenti verdi sono connessi con le due zampette del led rosso e le connettono con le prime due colonne della breadboard, le quali, a loro volta, sono connesse tramite i ponticelli rossi ai pin GND e 10 di Arduino.

In questo modo il programma Hello, Blink! può essere scritto nella seguente maniera

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int ledPin = 10;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

ovvero modificando in riga 1 il numero corrispondente al pin da alimentare. Ovviamente, se non si usa il pin 13, il led L incorporato in Arduino non lampeggerà.

Tre led lampeggianti alternativamente. A questo punto è facilmente implementabile una fila di led (nell’esempio 3, ma al massimo 14) che accendono e si spengono in sequenza. Innanzitutto bisogna collegare tutte e tre le zampe corte al GND e ognuna delle tre zampe lunghe a un differente pin, ad esempio il 2, 3 e 4.

Il codice che ho utilizzato per far illuminare alternativamente i tre led è il seguente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

int ledPinStart = 2;
int numberOfPin = 3;
int interval = 500;
int i, j;
 
void setup() 
{
  for (j = 0; j < numberOfPin; j++) {
      pinMode(ledPinStart + j, OUTPUT);
  }
}
 
void loop()
{
  for (i = 0; i < numberOfPin; i++) {
    for (j = 0; j < numberOfPin; j++) {
      digitalWrite(ledPinStart + j, LOW); 
    }
    digitalWrite(ledPinStart + i, HIGH);    
      delay(interval);
  }
}

Come si interpreta il codice? Il primo il costrutto for dentro la funzione setup() serve per settare tutti i pin come OUTPUT. Nel blocco loop() il primo costrutto for ne include un secondo allo scopo di abbassare il livello di tutti i pin a LOW (zero Volt) per poi, fuori dal for nidificato, alzare a HIGH (5 Volt) il livello di un solo pin, sequenzialmente corrispondente ai tre led rossi. Le variabili ledPinStart e numberOfPin permettono di impostare rispettivamente il numero più basso della fila di pin e il numero di led usati.

Studiare le connessioni realizzabili con una breadboard è il primo importante passo per l’espansione di Arduino Duemilanove verso l’utilizzo di periferiche e sensori esterni, collegati ad esso in varia maniera. Nel prossimo articolo, però, affronteremo il secondo tutorial proposto dal sito ufficiale di Arduino, molti utile perché, pur ottenendo sempre il nostro lampeggìo, è basato su un software dalla concezione molto diversa. Stay tuned!

Condividi

Il codice di partenza è il seguente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int ledPin = 13;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Ricordando che al funzione delay() non è altro che una pausa, espressa in millisecondi imposta ad Arduino prima di eseguire l’istruzione successiva, possiamo ovviamente giocare a modificarne il valore tra parentesi (ovvero l’argomento della funzione), aumentandolo o diminuendolo a piacere.

Provate ad esempio a scrivere nelle corrispondenti righe:

11

  delay(2000);

e

13

  delay(500);

Effettuando queste modifiche e inviando il programma ad Arduino, tramite il comando Command+U, avremo, dopo il solito scintillio di led L, TX e RX, un lampeggiare del led L che rimarrà acceso per 2 secondi e resterà spento per mezzo secondo.

Ecco la prima piccola modifica hardware. Nel KIT WorkShop che abbiamo acquistato e di cui abbiamo parlato nel primo articolo introduttivo, sono presenti 5 led rossi, 1 verde e 1 giallo. Prendiamo, ad esempio il led rosso e proviamo a collegarlo ad Arduino. Prima di tutto però osserviamolo, perché noterete che possiede una zampa più lunga dell’altra.

Senza nemmeno dover piegare le zampe, inseriamo quella più corta nel pin contrassegnato con l’etichetta GND e quella più lunga nel famoso pin 13. Se non avete scollegato Arduino dall’alimentazione (o dalla porta USB), vedrete immediatamente il led illuminarsi secondo il ritmo stabilito dal programma.

Cosa abbiamo fatto? Semplicemente, siccome tutte le zampe corte dei led vanno messe a terra (da cui GND, ground in inglese vuol dire appunto terra) e siccome il pin 13 è, come abbiamo visto nel precedente tutorial, regolato sui 5 volt a intervalli regolari, il led rosso che abbiamo aggiunto viene alimentato esattamente come il piccolo e verde led L, e i due dovrebbero quindi lampeggiare all’unisono.

Ora qualcosa di divertente. Come prima cosa modifichiamo il programma in modo da creare una nuova variabile che chiameremo interval e assegniamole il valore di 1000. Dopo di che inseriamo tale variabile come argomento delle due funzioni delay(). Il nuovo listato del programma sarà quindi:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int ledPin = 13;
int interval = 1000;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(interval);
  digitalWrite(ledPin, LOW);
  delay(interval);
}

A questo punto possiamo modificare solo il valore assegnato alla variabile interval in riga 2 per modificare automaticamente gli argomenti delle due funzioni delay(). La cosa divertente accade quando proviamo ad assegnare ad interval valori sempre più piccoli. Proviamo ad esempio a scrivere interval = 100. Cosa accade? Ovviamente il nostro led rosso comincia a lampeggiare come una luce natalizia.

Ma se impostiamo interval = 10 cosa accade? Il led sembra aver messo di lampeggiare rimanendo sempre accesso. Perché?

Una breve digressione sul funzionamento del sistema visivo occhio-cervello ci fa capire la ragione di questo strano comportamento (non nascondo che appena provato ho istintivamente pensato ad un malfunzionamento o una limitazione di Arduino…). La persistenza della visione è un fenomeno che ci permette di credere che la sequenza di fotogrammi di un cartone animato sia una azione continua e non una serie di disegni statici (idem per i fotogrammi di un film). Alla stessa maniera anche la luce delle lampadine collegate ad una rete domestica a corrente alternata ci appare come stabile ma in realtà è un alternanza, appunto, di luce e buio, così rapida da non essere percettibile. Un tempo si pensava che questo fenomeno coinvolgesse la retina, ma ora è chiaro che è tutto un processo a livello della corteccia cerebrale, ovvero in poche parole, mentre la guardiamo, una immagine ci mette alcuni centesimi di secondi prima di perdere la sua luminosità originale e, se nel frattempo, è già pronta un’altra immagine, noi non siamo in grado di percepire il momento del cambiamento di immagine.

Nel caso del nostro led, se impostiamo un valore di interval di 20 ms vediamo chiaramente un lampeggiare (seppur frenetico) della luce, ma se interval è 18 ( o 16, 14, fino 11 ms) riusciamo a percepire solo un sempre più lieve tremolio. Quando interval = 10 il nostro cervello non ha fatto in tempo a cancellare, e neppure ad attenuare, l’immagine del led acceso che, dopo la pausa in cui il led rimane spento, è già ora di riaccenderlo.

In termini matematici, siccome la sequenza si compone di due delay() ognuno da 10 ms, questo significa che l’intera sequenza dura 20 ms, e quindi l’alternanza di accensioni e spegnimenti avviene 50 volte al secondo (50 x 20 ms = 1000 ms = 1 secondo), ovvero 50 Hz. Tenendo conto, però, che un lieve sfarfallio seppur invisibile può comunque essere fastidioso per l’occhio, la corrente alternata della rete domestica, cioè quella che fa funzionare le nostre lampadine, è sì fissata ad una frequenza di 50 Hz ma (dal momento che la corrente è alternata secondo un onda sinusoidale e rimane accesa sia a 220 V che a -220 V) la frequenza dell’intensità luminosa è doppia, ovvero di 100 Hz.

Ok, ma io non ci credo. Se siete arrivati a questo punto, con interval impostato a 10 ms, Arduino e il suo led apparentemente immobili, e la spiegazione che avete letto vi sembra plausibile ma non una dimostrazione che vi convinca in modo incontrovertibile… beh allora sappiate che avete una mentalità scientifica e tutta la mia stima.

Ad ogni modo, la dimostrazione la potete realizzare semplicemente agitando su e già il vostro Arduino con led rosso collegato. Ebbene sì, provateci. In questo modo, anziché una scia continua rossa, vedrete una scia interrotta da punti di buio, a riprova della rapida alternanza decisa nel programma che avete caricato sul dispositivo. In pratica, ciò che prima veniva percepito dal nostro cervello come immagine statica del led acceso, ora è un immagine spalmata su un certo spazio visivo dal vostro movimento e, in momenti diversi, il led si trova in punti diversi, permettendo al cervello di registrare le immagini della luce in punti diversi della cortecce cerebrale, con buona pace della persistenza della visione.

Ispirandomi ad un mio vecchio articolo, pomposamente intitolato Come trasformare la propria fotocamera digitale in un oscilloscopio, ho fotografato Arduino mentre girava il software Hello, Blink! con interval = 10 ms spostandomi velocemente con la fotocamera, durante lo scatto di un 1/10 di secondo. Nell’immagine in basso potete notare come il led rosso si spenga e si riaccenda varie volte (in sincrono col led verde L) mentre il led PWR mostra una scia continua proprio perché sempre acceso:

A conti fatti, ci sono 4 immagini di led interi più 2 mezzi led alle due estremità della scia intermittente. Infatti, con interval = 10, se in un secondo ci sono 50 lampeggiamenti, in un decimo di secondo (la durata dello scatto) ce ne saranno 5.

Nel prossimo articolo realizzeremo un’altra espansione hardware. Nel frattempo, se avete domande, critiche o richieste, scrivete pure nei commenti.

Condividi

Come abbiamo notato nel precedente articolo introduttivo, sono installati su Arduino almeno due led: il primo è arancione ed è contrassegnato dall’etichetta PWR (che sta per power) e segnala se c’è alimentazione, mentre il secondo è verde ed ha l’etichetta L e per quel che sappiamo, per ora, il suo unico scopo e quello di essere un led, appunto.

Questo secondo led chiamato L è connesso al pin 13, quindi: inviare corrente al pin 13 significa accendere il led L. Ricordiamocelo.

Apriamo il software Arduino e copiamo il seguente codice (in alternativa lo si può prelevare dal menu File>Sketchbook>Examples>Digital>Blink)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int ledPin = 13;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

prima di inviarlo ad Arduino, vediamo in dettaglio come si legge questo codice (che è scritto in linguaggio C) e cosa ordina di fare al dispositivo.

La riga 1 del codice recita int ledPin = 13; e non fa altro che impostare una variabile chiamata ledPin (ma la si può chiamare come si vuole) al valore 13. Ricordatevi sempre il punto e virgola alla fine di una istruzione, comprese quelle all’interno dei blocchi definiti dalle parentesi graffe.

La riga 3 apre, con il comando void setup(), una sezione entro la quale si possono settare alcuni parametri iniziali di Arduino. In questo caso, in riga 5, il comando pinMode(ledPin, OUTPUT); non fa l’altro che imporre ad Arduino uno specifico uso per il pin 13, cioè come output. In parole povere con questo comando stiamo dicendo che il pin 13 non dev’essere usato per raccogliere informazioni (input) ma per mostrare informazioni (output).

Il gruppo successivo di istruzioni, introdotto dal comando void loop(), descrive la sequenza di istruzioni che Arduino deve eseguire continuamente. Loop infatti sta per ciclo, e tutto ciò che si trova tra le rige 10 e 13 viene ripetuto all’infinito.

Ma cosa dicono le istruzioni tra le righe 10 e 13? Essendo il pin 13 uno della seriei dei pin DIGITAL, la riga 10 assegna a questo pin un valore HIGH (ovvero alto) tramite il comando digitalWrite(ledPin, HIGH);. Questo significa, nella fattispecie, che la riga 10 ordina ad Arduino di applicare una differenza di potenziale di 5 Volt al pin 13 (e corrisponde all’1 del sistema binario usato in elettronica). questo perché la variabile ledPin è stata impostata al valore 13, nella prima riga del codice.

La riga successiva, la 11, ordina ad Arduino di attendere per un secondo esatto e lo fa tramite il comando delay(1000); il cui valore tra parentesi è espresso in millisecondi.

La riga 12 imposta il valore del pin 13 su LOW, lo zero digitale, zero anche in Volt.

L’ultima riga del blocco è identica alla riga 11, e serve ad attendere un altro secondo prima di ripetere l’intero ciclo.

Ok, abbiamo parlato di pin, e il led che doveva lampeggiare? E’ sufficiente ricordarsi che il led L e il pin 13 sono connessi nella scheda Arduino modello Duemilanove. E quindi i valori di potenziale HIGH e LOW di cui abbiamo parlato vengono automaticamente visti dal led L che comincerà immediatamente a lampeggiare, con il ritmo di una accensione od uno spegnimento al secondo.

Ok, come si carica il programma su Arduino per farglielo eseguire? Prima di tutto è sempre buona norma controllare che il codice scritto sia conforme alle specifiche della scheda Arduino utilizzata. Per questo, premendo Command+R (su Mac) o andando sul menu Sketch>Verify/Compile, possiamo chiedere alla piattaforma di programmazione di controllare la correttezza del codice.

Se, dopo qualche secondo, appare in basso la scritta Done compiling. vuol dire che la verifica è andata a buon fine e non ci sono né errori di sintassi né incompatibilità con l’hardware (ah, Arduino si chiama così proprio per assonanza con hardware… l’avevate già capito? Bravi.).

Sotto a Done compiling appare anche una riga che ci dice quanta memoria occuperebbe questo programma una volta caricato su Arduino:

Binary sketch size: 1124 bytes (of a 14336 byte maximum)

Arduino è dotato di una memoria flash da 16 Kbyte, di cui circa 2 KB utilizzati dal bootloader (il sistema che consente ad Arduino di ricevere correttamente i programmi dal computer).

Ok, carichiamo il programma su Arduino? Sì, è sufficiente premere Command+U, oppure andare su File>Upload to I/O Board e il programma, in pochi secondi, viene caricato e mandato in esecuzione.

Durante la fase di caricamento vedrete alcuni led lampeggiare anche molto velocemente. Si tratta del già conosciuto led L ed anche dei due nuovi led RX e TX (si tratta di indicatori di lettura e scrittura sulla memoria di Arduino). Finito il vortice di lampeggii, il led L comincia a comportarsi esattamente come definito nel programma, alternando accensioni e spegnimenti al ritmo di una al secondo.

Complimenti, il vostro primo Blink funziona egregiamente!

Per interrompere il programma bisogna spegnere Arduino staccando il cavo USB, ma ricordate che il programma è memorizzato e, appena ricollegate Arduino (alla porta USB, ad un alimentatore per iPod, ad un trasformatore a corrente continua tra 7 e 12 Volt o ad una batteria) il programma ripartirà immediatamente.

Nel prossimo articolo vedremo come personalizzare questo primo programma per esplorare la logica con cui è scritto e nuovi modi per espandere Arduino.

Condividi

Arduino è una “piattaforma di prototipazione elettronica open-source” (ne accennai un anno fa).

E’ cioè? In poche parole è un fantastico aggeggio made in Italy che può caricare in memoria un software, registrare stimoli dall’esterno e inviare comandi a una serie infinita di motori, luci ed attuatori di ogni genere. Apparecchiatura dal grande successo internazionale, è stata progettata per artisti, designer, hobbisti e chiunque sia interessato a create oggetti o ambienti interattivi. Arduino, in sostanza, è uno strumento che permette di costruire computer in grado di interagire con l’ambiente in cui si trovano.

E quindi? Con questo primo articolo introduttivo iniziamo (io e Andrea Giansanti, la mente creativa del progetto) lo studio di questa piccola ma potente apparecchiatura elettronica allo scopo di esplorarne le potenzialità e di vedere… dove ci porta.

L’avventura è iniziata mercoledì mattina quando abbiamo fatto l’ordine per il KIT Workshop – Livello base (che comprende l’ultima versione di Arduino, chiamata Duemilanove) sullo shop online di Smart Projects (Arduino è reperibile anche singolarmente, ed anche su Robot Italy). Con una spesa di soli 50 euro ci siamo portati a casa la seguente attrezzatura:

1 Arduino Duemilnove Board + 1 USB cable, 1 Straight single line pinhead connectors 2,54 40×1, 1 Breadboard, 840 tie points, 1 Set of 70 breadboard jumper wires, 5 10K Ohm Resistors 1/4W, 5 2.2K Ohm Resistor 1/4 W, 10 220 Ohm Resistors 1/4W, 5 330K Ohm Resistors 1/4W, 5 100nF capacitor polyester, 5 10nF capacitor polyester, 3 100uF electrolytic capacitor 25Vdc, 1 4,7K Ohm Thermistor, 1 70..100K Ohm LDR VT90N2, 3 5mm RED LED, 1 5mm GREEN LED, 1 5mm YELLOW LED, 1 10Kohm linear potentiometer, pcb terminals, 2 BC547 Transistor in TO92 Package, 1 Piezo buzzer, 5 PCB Pushbutton, 12×12mm size, 2 4N35 Optocoupler DIL-6 package, 2 Tilt sensor, 1 Diode 1n4007, 1 MOS Irf540.

Nonostante lo shop on-line avesse specificato un tempo di consegna di 48-72 ore, Arduino e tutto il kit sono arrivati in sole 24 ore.

Ho deciso di pubblicare una serie di articoli per creare un resoconto dello studio di Arduino Duemilanove in italiano, sia come riferimento futuro per noi stessi, ma anche per rendere meno ampia la mancanza di materiale on-line su questo specifico modello di Arduino e in particolar modo in italiano. Essendo alle prime armi e non avendo una conoscenza dei precedenti modelli, ci concentreremo quindi solo su questo modello.

Ok, come si installa? Acquistato l’hardware, anche se è possibile autocostruirselo (qui lo schema costruttivo, ricordate che è open-source!), è stato necessario installare sia la piattaforma di programmazione, ovvero il software Arduino, disponibile per Mac OS X, Linux e Windows, sia il giusto driver USB (allegato al software, anche se la versione più aggiornata è scaricabile sul sito della FTDI).

Installato tutto? Bene, lanciate il software Arduino, collegate Arduino Duemilanove al computer tramite il cavo USB in dotazione, selezionate (se necessario) la corretta Serial Port (su Mac è quella che contiene la dicitura tty.usbserial) nel menu Tools e… se il led etichettato PWR è acceso e arancione (vedi figura in basso) allora il vostro Arduino è correttamente alimentato!

Il led etichettato L dovrebbe lampeggiare con una luce verde, in seguito vedremo come utilizzata tale led.

Nel prossimo articolo vedremo come caricare il primo programma d’esempio, per insegnare i primi passi al vostro Arduino. Per qualsiasi domanda, richiesta o segnalazione d’errore, lasciate un commento.

Condividi

Condividi

Tempo fa vi parlare delle voci su GoOSe, acronimo di “Google Operating System Environment”, il quale più che un sistema operativo vero e proprio doveva essere un “ambiente” Web capace di sfruttare tutte le varie applicazioni in Ajax sviluppate da Google. In realtà si è scoperto che questo Google OS, era semplicemente una distribuzione Linux usata dagli sviluppatori Google con tutti i propri strumenti ed applicazioni utili.

Come riferisce downloadblog, invece, pare che sia stato distribuito un gPC (la g sta per green, non Google) che monta una distribuzione verde di Ubuntu:

si tratta del primo sistema operativo che esce con le applicazioni di Google come scelta primaria (è presente anche una installazione di OpenOffice).
Nella barra delle applicazioni OSX-style troviamo infatti oltre alle applicazioni di Docs & Spreadsheets, link a YouTube, Blogger, Google Maps ma anche a Facebook e Wikipedia.

Si può scaricare l’immagine del Live CD per provarla senza installarla. Si tratta però di un immagine più grande di un CD e va quindi masterizzata su un DVD. Il file torrent si trova qui.

Condividi

Dimensioni ridottissime, carrozzeria giocattolosa ma robusta, ideale per i bambini, nessuno spigolo tagliente, una tastiera impermeabile con tasti piccoli per dita piccole, uno schermo che si vede benissimo in piena luce, Wifi integrato… questo è un laptop che farà gola anche a molti utenti del Primo Mondo. E’ quindi validissima la formula “con 399 dollari ne paghi due, ne prendi uno, e l’altro lo doni ai bambini” [...] ha una webcam incorporata. E lo schermo è girevole per trasformare l’OLPC in un libro elettronico. Niente HD; solo memoria Flash, più che sufficiente per foto e testi. E ci gira su Linux.

questa la descrizione dell’OLPC, presentato al Linuxday di Cinisello Balsamo di pochi giorni fa, scritta da Paolo Attivissimo in questo post. Decisamente interessante.

Condividi