Archivi categoria: arduino

Appunti di programmazione su Arduino: ingressi e uscite analogiche


analogRead(pin)
Legge un valore di tensione applicato al piedino analogico ‘pin’ con una risoluzione di 10 bit. La funzione restituisce un valore compreso tra 0 e 1023.

value = analogRead(pin);   // imposta 'value' uguale al
                           // valore letto su 'pin'
                           // dalla funzione analogRead

Nota: i pin analogici a differenza di quelli digitali non hanno bisogno di essere dichiarati come pin di INPUT o OUTPUT.

analogWrite(pin, value)

Cambia il duty cycle (nella funizione: ‘value’) della modulazione di ampiezza di impulso (PWM: Pulse Width Modulation) su uno dei ‘pin’ contrassegnati dall’etichetta PWM.
Sull’attuale Arduino UNO su cui è montato un ATmega 328, il PWM è abilitato sui piedini 3,5,6,9,10 e 11.
Il valore del duty cycle può essere specificato da una variabile o una costante con un valore compreso tra 0 e 255.

analogWrite(pin, value);   // scrive il valore 'value'
                           // sul 'pin' analogico

Un valore di 0 genera in uscita una tensione continua di 0 volt sul pin specificato nella funzione; un valore di 255 genera una tensione continua 5 volt sul pin specificato nella funzione. Per valori compresi tra 0 e 255, il valore in uscita varierà rapidamente tra 0 e 5 volt. Più alto sarà il valore di ‘value’ più spesso su ‘pin’ si avrà una tensione di 5 volt. Ad esempio un valore di ‘value’ pari a 64 genera un segnale in cui per tre quarti del periodo dell’onda il segnale sarà a 0 volt e per un quarto del periodo dell’onda sarà a 5 volt. Se ‘value’ è posto a 128 avremo un segnale che per metà del periodo sarà a 0 volte e per la restante metà del periodo sarà a 5 volt. Se ‘value’ è posto a 192 avremo 0 volt per un quarto del periodo e 5 volt per i restanti tre quarti del periodo.

Per approfondire l’argomento sul PWM leggete la lezione su questo sito: Arduino – lezione 06: modulazione di larghezza di impulso (PWM) corredata da esempi pratici e filmati.

Poiché analogWrite è una funzione hardware, sul pin avremo un onda quadra dopo una chiamata della funzione analogWrite e questa verrà continuativamente emessa in background fino alla successiva chiamata della analogWrite (o chiamata della digitalRead o digitalWrite sullo stesso pin).

L’esempio che segue legge un valore analogico da un pin di ingresso analogico, converte il valore dividendolo per 4, e fornisce un segnale PWM sul pin PWM specificato:

int led = 10;   // al pin 10 è collegato un LED
                // in cui in serie è posta un
                // resistore da 220 Ohm
int pin = 0;    // inseriamo un potenziometro sul pin 0
int value;      // valore che sarà letto

void setup(){} // non è necessaria nessuna configurazione
void loop()
{
   value = analogRead(pin); // imposta 'value' al
                            // valore letto su 'pin'
   value /= 4; // dividendo per 4 si converte
               // il valore letto compreso tra
               // 0 e 1023 in un valore
               // compreso tra 0 e 255
   analogWrite(led, value); // il valore del PWM
                            // viene assegnato al led
}

Per le lezioni precedenti consultare la sezione Appunti di programmazione che trovate nella pagina Arduino di questo sito.

Appunti di programmazione su Arduino: ingressi e uscite digitali

Continuano le lezioni sulla programmazione su Arduino, se avete necessità di consultare le lezioni precedenti guardate la sezione Appunti di programmazione che trovate nella sezione Arduino di questo sito.

pinMode(pin, mode)

Utilizzato all’interno del void setup(), consente di configurare un determinato pin e stabilisce se deve essere un pin di INPUT o di OUTPUT.

pinMode(pin, OUTPUT);        // imposta 'pin' come output

I pin digitali di Arduino sono per default impostati come pin di INGRESSO, perciò non è necessario dichiararli esplicitamente come input con la pinMode(). Nel caso si debba utilizzarli come pin di uscite è indispensabile impostare il pin come OUTPUT con il comando pinMode(pin, OUTPUT). I pin configurati come input si dice che sono in uno stato di alta impedenza.

Il processore Atmega presente sulla scheda Arduino è dotata, sui ogni piedino di ingresso digitale, di una resistenza di pull-up da 20KOhm che abilitata via software consente di impostare il pin come input. Le istruzioni sono le seguenti:

pinMode(pin, INPUT);       // imposta 'pin' come input
digitalWrite(pin, HIGH);   // attiva la resistenza di pull-up,
                           //'pin' viene impostato HIGH

Le resistenze di pull-up vengono normalmente utilizzate per connettere gli input come interruttori.

Si noti che nell’esempio sopra non viene configurato un pin come output, è un modo per attivare il pull-up interno.

I pin configurati come OUTPUT sono detti a bassa impedenza e sono in grado di fornire 40 mA (milliampere) ad altri dospositivi o circuiti. Questa è una corrente sufficiente per accendere un LED (non dimenticate di inserire in serie una resistenza), ma non è una corrente sufficiente per pilotare la maggior parte dei relè, bobine o motori.

I cortocircuiti sui piedini di Arduino possono danneggiare o distruggere i pin di output o danneggiare l’intero chip Atmega. Quando si ha la necessità di utilizzare i pin come output per collegare dispositivi esterni è buona prassi inserire in serie al pin un resistore da 470 Ohm o 1 KOhm.

digitalRead(pin)

Legge lo stato di uno specifico pin digitale ed il valore restituito può essere HIGH o LOW. Il ‘pin’ può essere specificato come una variabile o una costante (0-13).

value = digitalRead(Pin);   // imposta 'value' al valore
                            // letto sul pin

digitalWrite(pin, value)

Pone a livello HIGH o LOW l’uscita digitale ‘pin’. Il ‘pin’ può essere specificato come una variabile o una costante (0-13).

L’esempio che segue legge un pulsante collegato ad un ingresso digitale e visualizza su un LED, connesso ad una uscita digitale, quando il pulsante viene premuto:

int led = 13;  // il LED è connesso all'uscita digitale 13
int pin = 7;   // il pulsante è collegato al pin digitale 7
int value = 0; // variabile per memorizzare il valore letto

void setup()
{
  pinMode(led, OUTPUT); // imposta il pin 13 come OUTPUT
  pinMode(pin, INPUT);  // imposta il pin 7 come INPUT
}

void loop()
{
  value = digitaRead(pin);   // imposta 'value' uguale
                             // al valore letto su 'pin'
  digitalWrite(led, value);  // imposta 'led' al valore
                             // della variabile 'value'
}

Per le lezioni precedenti consultare la sezione Appunti di programmazione che trovate nella pagina Arduino di questo sito.

Massimo Banzi: How Arduino is open-sourcing imagination

Massimo Banzi helped invent the Arduino, a tiny, easy-to-use open-source microcontroller that’s inspired thousands of people around the world to make the coolest things they can imagine — from toys to satellite gear. Because, as he says, “You don’t need anyone’s permission to make something great.”

Grazie a Niccolò Bertoldi per la segnalazione.

Codebender: un IDE Arduino online

Siete un programmatore professionista, un hacker hardware o un artista? Con Codebender potrete realizzare i vostri sketch in modo semplice e veloce utilizzando un editor di testo ricco di funzionalità, tantissime librerie incluse e vasta documentazione. Potrete memorizzare gli sketch sul cloud ed usare il compilatore di Codebender per creare eseguire ed effettuare il debug, tutto attraverso il browser e quando avete concluso di scrivere potrete caricare direttamente il vostro programma su Arduino direttamente attraverso il vostro browser, non è richiesta nessuna installazione!

Una delle innovazioni più interessanti portate da Codebender sarà quello di usare un bootloader TFTP, in questo modo utilizzando una shield Ethernet, sarà facile caricare codice su qualsiasi Arduino connesso ad Internet in qualsiasi parte del mondo. Immaginate le innumerevoli applicazioni possibili, non vedo l’ora di vederlo in azione.

Quando tutto ciò sarà possibile? Al più preso, Stay tuned!

Per maggiori informazioni seguite il link.



Appunti su Arduino: interrupts


Dopo l’estenuante periodo di fine anno scolastico passato tra interrogazioni, recuperi, esami di qualifica, esami di alternanza scuola lavoro, preparazioni tesine e svariate riunioni/scrutini… riesco a rimettere mani sui miei appunti realizzati durante l’anno scolastico e questa volta colgo l’occasione di rispondere al commento di Raffaele che vuole avere ulteriori informazioni sull’uso degli interrupt in Arduino:

salve sono un vecchio appassionato di elettronica (analogica )- Essendo che ci siamo dovuti convertire sui microcontrollori solo 5 mesi fà sono riuscito finalmente dopo aver tentato con i PIC ,sono passato ad Arduino
duemilaenove e finalmente ho incominciato a capirlo e sviluppare tutti i tipi di esempi che dava nel softwere, dal led ai motori passo passo
e i servo perchè il tipo di programmazzione e soprattutto molti esempi erano spiegati
pure in video e come dicevo sono riuscito a capirci qualcosa.Ovviamente nel mio caso
riuscivo a modificare quelli già presenti ma in sostanza ero abbastanza sodisfatto perchè su di uno sviluppavo le modifiche creandone dei nuovi. Adesso però mi sono fermato un pò perchè ho una richiesta da farle.Pur avendo letto e capito l’istruzione
interrupt cosa significa avendola vista in altri programmi qualè il suo scopo non riesco a capire come inserirla avrei bisogno quindi se possibile di qualche esempio o modo di capire. Ci conto molto

A risentirci e Grazie

Di seguito vi riporto la parte (provvisoria) del manuale che ho realizzato per i miei studenti che si riferisce agli interrupt (sto realizzando alcuni esempi pratici che chiarificano questa funzionalità), sono tratte dal reference on-line di Arduino.cc con alcune mie rielaborazioni.

Con il termine interrupt (interruzione) intendiamo un segnale asincrono che indica la necessità di “attenzione” da parte di una periferica collegata ad Arduino.
L’interrupt viene generato quando si verifica una variazione di stato su uno dei piedini di Arduino. Normalmente il microcontrollore esegue all’interno del loop() in modo sequenziale e ripetitivo le istruzioni in esso inserite, ma quando si verifica un interrupt viene interrotto il flusso delle istruzioni all’interno del loop() ed invocate altre routine (create dall’utente). Quando le routine terminano il flusso del programma prosegue normalmente.
L’utilizzo dell’interrupt è particolarmente utile quando abbiamo la necessità di gestitire in background alcune routine ovvero eseguire istantaneamente un’operazione nel caso si manifesti un evento asincrono esterno.

Capita spesso di avere la necessità di controllare lo stato di diversi pin di input, in questa situazione potrebbe capitare che il programma non si accorga del cambiamento di stato su uno dei pin, utilizzando gli interrupt evitiamo questo tipo di errore.

Continua a leggere