Archivi tag: Arduino

Lux: Arduino incontra la fotografia

11218312213_628ca5bb89_hAbbiamo già visto quanto sia versatile l’Arduino, mettetelo in mano ad un appassionato di fotografia e il risultato è incredibile.

Kevin Kadooka, un fotografo delle Hawaii nonché studente di Ingegneria Meccanica presso l’Università di Portland ha sviluppato Lux, una macchina fotografica open-source.

Le caratteristiche di questo progetto sono veramente interessanti ed ancora più interessante è l’avere a disposizione i codici sorgenti col quale programmare l’Arduino, l’elenco completo di tutti i componenti (incluse le indicazioni su dove acquistarli) e i disegni per costruirsi (o stamparsi con una stampante 3D) le varie parti della macchina fotografica.


Il progetto è veramente ben fatto e le indicazioni sono molto complete. Vengono elencate nel dettaglio persino tutte le viti necessarie e dove reperirle.

Oltre a un paio do problemi tecnici inerenti la fotografia (il tempo massimo di scatto è 1/125 e il mirino ha qualche problemino) vi è un problema di design che rendere un po’ noiosa la ricarica delle batterie. Bisogna infatti smontare la parte posteriore della macchina fotografica per accedere al vano contenente le batterie.

shutter-circuit

luxexplode2

via (MakingPhoto)

Come trovare la giusta resistenza da mettere in serie ai LED

In quasi tutte le applicazioni di elettronica ciò che non manca mai sono i diodi LED (per approfondimenti riguardo i LED leggi il seguente articolo: Introduzione ai diodi). Specialmente quando si inizia con i primi progetti i LED la fanno da padrone stante la semplicità che richiede il loro utilizzo.

Precedentemente avevamo fatto un paio di applicazioni con i led usando l’Arduino per pilotarli. In particolare avevamo visto come Accendere un led mediante un pulsante, come effettuare il Blink (lampeggiamento), come  fare il Fade di un LED con un potenziometro e come regolare il Blink con l’ausilio di un potenziometro.

In particolare nelle prime due applicazioni non è stato necessario inserire alcuna resistenza in serie al LED poichè questo era collegato al pin 13 dell’Arduino. Infatti tale pin presenta già integrata una resistenza da 1 kΩ che protegge il LED da eccessive correnti.

Per calcolare la resistenza da mettere in serie ad un LED un primo dato che dobbiamo conoscere è il loro assorbimento di corrente (I):

  • LED a basso consumo: 3 ÷ 10 mA
  • LED normali: 10 ÷ 15 mA
  • LED Flash: 20 ÷ 40 mA
  • LED di potenza: 100 ÷ 20000 mA

Di seguito useremo, nei calcoli di esempio, i LED normali, ma il tutto avrà una validità trasversale a tutti i LED.

Fondamentale è anche la conoscenza della caduta di tensione ai capi del LED (Vled):

  • colore rosso: 1,8 V
  • colore giallo: 1,9 V
  • colore verde: 2,0 V
  • colore arancio: 2,0 V
  • colore blu: 3,0 V
  • colore bianco: 3,0 V

Nota la caduta di tensione ai capi del LED ed il suo assorbimento, l’ultimo dato mancante è la tensione di alimentazione (Val). Ipotizzando che la nostra applicazione preveda l’alimentazione del LED tramite l’Arduino questa risulta essere pari a 5V.

Lo schema dei collegamenti è veramente semplice implicando solo l’inserimento di una resistenza in serie:

blink_schem
Schema circuito resistenza in serie al LED
blink_bb
Schema circuito con Arduino e breadboard

Riepilogando stiamo ipotizzando di usare un led normale di colore rosso collegato all’Arduino.

Per il calcolo della resistenza basta applicare la seguente formula:

[latex]R=(Val-Vled)/I=(5-1,8)/0,015=213,333[/latex]

Con questa formuletta sarete in grado di calcolare il valore della resistenza da mettere in serie al led. Ovviamente non sempre vi verrà fuori un valore intero o di una resistenza esistente in commercio. Dovrete scegliere il valore della resistenza commerciale immediatamente superiore a quello risultante dai calcoli (nel nostro caso 213,333≈220).

Arduino e nunchuk – risparmiamo sui sensori

Chiunque conosca Arduino prima o poi si sarà trovato di fronte a quest’accoppiata. Usare il nunchuck della console Wii oltre ad essere una cosa molto divertente ci permette anche di risparmiare qualche soldo: al suo interno troviamo un accelerometro a tre assi, due pulsanti e un joystick, già saldati contenuti in un box ergonomico e facilmente accessibili tramite protocollo seriale (I2C).

Cerchiamo di capire come funziona e come possiamo fruttarlo per un nostro progetto.

Il protocollo.

Il nunchuck utilizza una versione leggermente “personalizzata” del protocollo I2C.

Senza addentrarci troppo nei meandri dell’I2C il nunchuck per funzionare ha bisogno di una prima fase di inizializzazione in cui vengono inviati 3 byte:

0x52: indirizzo del nunchuck;
0x40:indirizzo di memoria;
0x00: inviamo uno zero, che rappresenta la richiesta di dati.

Successivamente alla richiesta di informazioni il nunchuck risponde con 6 byte il cui significato è riportato nella seguente tabella:

Byte Descrizione
1 Asse X del joystick analogico
2 Asse Y del joystick analogico
3 8 bit MSB del valore dell’accelerazione sull’asse X
4 8 bit MSB del valore dell’accelerazione sull’asse Y
5 8 bit MSB del valore dell’accelerazione sull’asse Z
6 0 Pulsante Z vale 0 quando pressato
1 Pulsante C vale 0 quando pressato
3:2 2 bit LSB accelerazione X
5:4 2 bit LSB accelerazione Y
7:6 2 bit LSB accelerazione Z

L’accelerometro ha un’uscita a 10 bit, ma il protocollo I2C permette l’invio di soli 8 bit per volta: per questo motivo il valore degli assi dell’accelerometro è diviso in questo modo (8 bit a se stanti e gli ultimi due nel 6° byte).

Nota: In base al nunchuk utilizzato può essere necessario una decodifica del valore: in pratica dobbiamo fare un’operazione di XOR tra il byte ricevuto e il valore 0x17 e successivamente sommarlo con lo stesso valore (0x17). Nella libreria wiichuck (che andremo ad utilizzare) per ovviare a questo problema viene utilizzata un’inizializzazione più complessa che vedremo quando analizzeremo il codice e non sarà necessaria alcuna decodifica.

La Connessione.

I colori dei fili posso cambiare  in base alla casa che ha prodotto il nunchuck (non credo che stiamo smontando un nunchuck originale) però basta guardare il connettore:

nunchuck_plug__10b2oq__

una volta individuati i segnali di SDA (data) e SCL (clock) basta collegarli rispettivamente a ai pin analogici 4 e 5 dell’arduino. Per l’alimentazione il nunchuck funziona a 3.3V (anche se molti lo alimentano a 5V senza riscontrare problemi) quindi basterà collegarlo ai 3.3V dell’arduino e la massa al GND.

Il codice.

All’inizio pensavamo di dover scrivere il codice per gestire il nunchuk, operazione che non risulta troppo complicata una volta conosciuto il protocollo. Ma poi abbiamo pensato che reinventare la ruota non aveva senso, che sarebbe stato più utile prendere la libreria già presente nei reference di Arduino e commentarla insieme.
Inoltre la libreria Wiichuck.h ci fornisce anche un output con il calcolo del rollio e del beccheggio del controller a partire dai valori dell’accelerazione sui 3 assi.

Potete scaricare da qui un file .zip contenente la libreria e il file di esempio presenti nel playground di Arduino. Analizziamo insieme la libreria.

Funzione Tab

Tutti noi sappiamo come sia facile mettersi a scrivere un pò di codice nella “foga dell’ispirazione” e dopo non riuscire a capirci niente.

Finchè stiamo elaborando brevi sketch la cosa non sembra molto grave, ma non appena arriviamo ad avere un listato con più di 500 righe di codice e almeno una ventina di funzioni vi assicuro che andare a capirci qualcosa l’indomani è quasi impossibile.

Oltre all’uso dei commenti (caldamente consigliati da qualsiasi guida di programmazione) l’Ide di Arduino ci viene incontro fornendoci la funzione tab.

Cliccando sul triangolino cerchiato nella figura sottostante si apre il menù di gestione dei tab. Facciamo New Tab

1

Ci verrà chiesto di inserire un nome per il nuovo tab. Questo serve perchè tutto il codice che andremo a scrivere in questo nuovo tab verrà salvato in un file diverso nominato proprio con lo stesso nome del tab.

2

All’interno del tab possiamo scrivere qualsiasi codice vogliamo (ovviamente funzioni a se stanti, non possiamo cioè continuare il void loop in un secondo file) con il vantaggio di poter dividere le diverse funzioni in file appositi senza bisogno di particolari direttive #include.

3

Nelle immagini proposte potete vedere come il progetto di un multimetro venga agevolmente suddiviso nelle sue varie sezioni (voltmetro, capacimetro, ecc…) senza che il codice diventi troppo ingarbugliato.

Viaggio nei cloni di Arduino – chipKIT Uno e Maxi

Nel panorama delle piattaforme cloni del famoso Arduino risulta degna chipKIT, prodotta dalla Digilent.

Questo microcontrollore è presente in due versioni la Uno32™ (con 42 I/O) e la Max32™ (con 83 I/O) entrabe perfettamente compatibili con tutti i codici sviluppati per l’Arduino nonchè per i vari shield sviluppati per la piattaforma Italiana.

La versione Uno32™ presenta:

tile_chipkit-uno32_150

  • Microchip® PIC32MX320F128 processor
    • 80 Mhz 32-bit MIPS
    • 128K Flash, 16K SRAM
  • Compatible with many existing Arduino™ code examples, reference materials and other resources
  • Can also be programmed using Microchip’s MPLAB® IDE (along with a PICkit 3 and our PICkit3 Programming Cable Kit, seen below)
  • Arduino™ “Uno” form factor
  • Compatible with many Arduino™ shields
  • 42 available I/O
  • User LED
  • Connects to a PC using a USB A -> mini B cable
Le caratteristiche della versione Max32™ sono:
tile_chipkit-max32_150
  • Microchip® PIC32MX795F512 processor
    • 80 Mhz 32-bit MIPS
    • 512K Flash, 128K RAM
    • USB 2.0 OTG controller
    • 10/100 Ethernet MAC
    • Dual CAN controllers
  • Provides additional memory and advanced communications peripherals
  • Compatible with many existing Arduino code examples, reference materials and other resources
  • Can also be programmed using Microchip’s MPLAB® IDE (along with a PICkit 3 and our PICkit3 Programming Cable Kit, seen below)
  • Arduino™ “Mega” form factor
  • Compatible with many Arduino™ shields
  • 83 available I/O
  • User LED
  • Connects to a PC using a USB A -> mini B cable
I costi sono inferiori rispetto ad Arduino, essendo di $26.95 per la Uno e di $49.50.
Lo sviluppo delle applicazioni per queste piattaforme avviene utilizzando un ambiente basato sull’originale Arduino ™ IDE opportunamente modificato per supportare PIC32. Tale ambiente di sviluppo modificato mantiene, comunque, anche il supporto per l’originale Arduino.
Link per l’acquisto:
Per il modello Uno32™
Per il modello Max32™

Liquid Crystal – Ultime funzioni

Continuiamo lo studio della libreria LiquidCrystal.
Vediamo subito le due funzioni display() e noDisplay(). Queste semplicemente spengono e riaccendono lo schermo conservando quello che era visualizzato prima di spegnerlo.  La sintassi è molto semplice, la vediamo in quest’esempio

[arduino]
#include LiquidCrystal.h;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
lcd.begin(16, 2);
lcd.print("hello world!");
}
void loop() {
delay(2000);
lcd.noDisplay();
delay(2000);
lcd.display();
}
[/arduino]

Scroll del testo

Affrontiamo adesso lo scroll del testo.  Abbiamo a disposizione due tipi diversi di scroll.

Il primo si riferisce allo scroll di un testo già visualizzato, ci riferiamo alle funzioni scrollDisplayLeft() e scrollDisplayRight(). Esempio:

[arduino]

//Sketch preso dagli esempi dell’IDE di Aurduino

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
lcd.begin(16, 2);
lcd.print("hello, world!");
delay(1000);
}

void loop() {
for (int positionCounter = 0; positionCounter < 13; positionCounter++) {
lcd.scrollDisplayLeft();
delay(150);
}
for (int positionCounter = 0; positionCounter < 29; positionCounter++) {
lcd.scrollDisplayRight();
delay(150);
}
for (int positionCounter = 0; positionCounter < 16; positionCounter++) {
lcd.scrollDisplayLeft();
delay(150);
}
delay(1000);
}

[/arduino]

La sintassi è abbastanza semplice ed intuitiva.

Il secondo tipo di scrol che abbiamo a disposizione fa riferimento al modo in cui i caratteri “entrano” nello schermo.

[arduino]

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
lcd.begin(16,2);
}

void loop() {
lcd.setCursor(0, 0);
for (int thisChar = 0; thisChar < 10; thisChar++) {
lcd.print(thisChar);
delay(500);
}
lcd.setCursor(16,0);
lcd.autoscroll();
for (int thisChar = 0; thisChar < 10; thisChar++) {
lcd.print(thisChar);
delay(500);
}
lcd.noAutoscroll();
lcd.clear();
}

[/arduino]

Come vedete nei due for il codice è uguale, nel secondo for è stato attivati l’auto scrol con il comando lcd.autoscroll();.

Di default la direzione di scorrimento è da destra a sinistra, ma la possiamo impostare noi con i due comandi lcd.leftToRight() e lcd.rightToLeft().

Creazione di un simbolo

Se guardiamo con attenzione il nostro schermo ci rendiamo conto che ogni carattere è visualizzato da una matrice di quadratini scuri 5×8. La libreria Liquid Crystal ci mette a disposizione una funzione per pilotare direttamente questa matrice. Commentiamo in seguente esempio:

[arduino]
#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte smiley[8] = {
B00000,
B10001,
B00000,
B00000,
B10001,
B01110,
B00000,
};

void setup() {
lcd.createChar(0, smiley);
lcd.begin(16, 2);
lcd.write(0);
}
void loop() {}
[/arduino]

Come potete vedere il simbolo che vogliamo visualizzare lo “disegnamo” con un vettore (qui chiamato smiley[]). Mantenendo la sintassi di quest’esempio vediamo come si disegna la faccina sorridente:la prima riga di pixel è lasciata bianca, nella seconda ne accendiamo solo due per gli occhi, terza e quarta bianche e così via.

Una volta disegnato il vettore, creiamo il carattere con la funzione lcd.createChar() dove i parametri rappresentano rispettivamente il numero del carattere appena creato (possiamo crearne e gestirne fino a 8 nello stesso sketch) ed il vettore del simbolo.

Per poi visualizzarlo a schermo usiamo un lcd.write() indicando il numero del carattere che vogliamo disegnare.

Il LED diventa sensore di luce

Abbiamo già visto in precedenza cosa sono i LED, ovvero dei perticolari diodi in grado di emettere luce (la sigla sta appunto per Light Emission Diode). In una serie di articoli vi avviamo mostrato come usarli per sviluppare dei progetti con l’Arduino.

Abbiamo anche parlato delle fotoresistenze dedicandogli un articolo apposito.

Fin quì nulla di nuovo, ma se volessimo usare un LED come se fosse una fotoresistenza? L’utilizzo di un LED è bidirezionale: se sottoposto ad una tensione opportuna emette luce (che può ricadere nel visibile, nell’UV o nell’infrarosso a seconda del led), ma se sottoposto ad una sorgente luminosa genera una tensione ai suoi capi.

Seppur tale tensione è dell’ordine di poco più di un Volt è sufficiente per una applicazione di misurazione dell’intensità luminosa di una sorgente. A dirla tutta esistono delle applicazioni sperimentali per l’uso dei LED come celle fotovoltaiche, ma i risultati non sono ancora molto soddisfacenti.

Quello che faremo sarà collegare il LED ad un ingresso analogico dell’arduino e visualizzare le letture di luminosità in seriale. In particolare collegheremo il polo positivo alla porta 3V3 dell’arduino ed il negativo alla porta analogica 3.

Per il montaggio del circuito seguite il seguente schema:

led_come_sensore

Il codice da usare per leggere sul monitor seriale i valori è:

[arduino]

void setup() {
Serial.begin(9600);
}

void loop() {
int LEDsensorValue = analogRead(3);
Serial.println(LEDsensorValue);
}
[/arduino]

Mi raccomando, nel codice usate il comando println così da avere un valore per ogni rigo, altrimenti la lettura risulta troppo confuzionaria.

LiquidCrystal – LCD con l’Arduino

Nella prossima serie di articoli vedremo come usare la libreria LiquidCrystal.

Indice degli argomenti

Setup dell’LCD;
print();
Gestione del cursore;
setCursor();
home() e clear();
Scroll del testo;
creare un simbolo;

Essa ci permette di pilotare con facilità gli schermi lcd alfanumerici (che si basano sul chipset HD44780) mettendoci a disposizione molte funzioni per la gestione dei caratteri visualizzati.

Per questi articoli abbiamo usato lo schermo CM162-4 con 2 righe e 16 caratteri, ma va bene qualsiasi schermo compatibile con lo standard HD44780

schermo

Setup dello schermo
Prima di vedere il codice vediamo come collegare lo schermo all’arduino.
Il cablaggio non è molto agevole, basti guardare lo schema in Fritzing

lcd_bb

Su breadBoard possiamo realizzarlo così:

xxx cablaggio1 xxx cablaggio2
cablaggio3

Da notare che abbiamo saldato una striscia di pin sullo schermo, questo ci facilita il lavoro sia su breadboard che sui nostri circuiti (dove basterà usare una striscia di pin femmina);

Regoliamo il blinking con un potenziometro

Precedentemente abbiamo imparato a far lampeggiare (Blink) un LED mediante l’Arduino. In quel semplice esempio la velocità di lampeggiamento veniva impostata nel codice e, quindi, non era possibile farla variare (a meno di andare a cambiare il valore impostato nel codice).

Adesso vedremo come modificare il codice ed il circuito per permetterci di regolare il Blinking con un potenziometro.

Fare ciò vuol dire aggiungere un potenziometro al nostro sistema, collegarlo ad un ingresso analogico ed usare il valore letto da tale ingresso per stabilire la velocità del lampeggiamento.

Vediamo subito come fare il circuito:

analoginputoutput_bb

Nell’immagine ho usato il pin 3 (che supporta il PWM) solo perchè l’avevo già fatta per un altro esempio. Ovviamente potete usare anche una porta digitale senza PWM in quanto non è necessario per il blinking.

Adesso passiamo al codice:

[arduino]
int ledPin = 3;
int potPin= 0;
int pausa = 0;

void setup()
{
pinMode(ledPin, OUTPUT);
pinMode(potPin, INPUT);
}

void loop()
{
pausa = analogRead(potPin);
 digitalWrite(ledPin, HIGH);
delay(pausa);
digitalWrite(ledPin, LOW);
delay(pausa);
}
[/arduino]

Come al solito nella prima parte del codice dichiariamo le variabili che ci serviranno nella seconda parte del codice.
Nel void loop abbiamo salvato il valore della lettura analogica del potenziometro all’interno della variabile pausa. Tale variabile è stata usata per impostare il tempo di lampeggiamento di un led.

Gestiamo i servomotori con Arduino

In quest’articolo parleremo un pò dei servomotori (o più comunemente servi). Si tratta di dispositivi meccanici di precisione che servono (passatemi il termine) per gestire la posizione angolare di un disco rotante o di un braccio meccanico. Sostanzialmente un servo è composto da un motore elettrico, un motoriduttore ed un circuito di feedback per la gestione della posizione. In commercio, esiste una vasta scelta di servi, ciascuno caratterizzabile per valore di coppia e precisione.

Il servo trattato in questo articolo è il B2232, un piccolo servo economico, ideale per i primi esperimenti didattici.

Questo tipo di servo ha un angolo di rotazione di circa 180° (la rotazione effettiva è un pò inferiore), inoltre esistono altri tipi di servi che hanno una rotazione continua e, anzichè pilotarne la posizione, ne possiamo gestire la velocità.

dynam-b2232

Qualunque sia il servo scelto, ci troveremo davanti sempre 3 contatti di cui due sono di alimentazione (V+ e GND) mentre il terzo è il pin di controllo. Per il servo in questione (i colori sono differenti dalla foto) il filo rosso corrisponde a V+, il filo viola è il GND mentre il filo giallo è quello del segnale.

Per gestire i servi con l’Arduino abbiamo a disposizione la libreria Servo. L’uso di questa libreria è molto semplice, vediamo quest’esempio preso direttamente dal sito ufficiale dell’Arduino.

xxxxxx [arduino]
#include <Servo.h>

Servo myservo;

int pos = 0;

void setup()
{
  myservo.attach(9); //pin a cui è collegato il controllo del servo
}

void loop()
{
  for(pos = 0; pos < 180; pos += 1)
{
myservo.write(pos);
 delay(15);
 }
for(pos = 180; pos>=1; pos-=1)
  {
    myservo.write(pos);
    delay(15);
  }
}
[/arduino]

Con l’istruzione

Servo myservo;

dichiariamo un oggetto di tipo Servo, e lo chiamiamo myservo. Invece per indicare a quale pin è collegato l’oggetto myservo usiamo la funzione attach(), di cui possiamo vedere la sintassi all’interno del void setup(). Per pilotare il servo usiamo la funzione myservo.write(pos) dove con pos si indica la posizione in gradi.

Dopo aver visto la sintassi vediamo un esempio pratico.