ARDUINO - [PROGETTO] Semaforo (v. 1.1)

Bentornati al progetto del semaforo con Arduino. Con questo post continueremo lo sviluppo del programma del semaforo, introducendo alcune semplificazioni. Questa è la versione 1.1 del programma.

Materiale occorrente

• Arduino;
• 2x LED Rossi;
• 2x LED Gialli;
• 2x LED Verdi;
• 1x resistori da 220 Ohm;
• Breadboard e cavi di collegamento.

Funzionamento del circuito 

Incrocio di riferimento

Il funzionamento del circuito è uguale a quello della versione 1.0 del programma.

Lo sketch

A livello di sketch introduciamo una semplificazione eliminando tutte le istruzioni inutili tra una passaggio e l'altro.
Se, per esempio, abbiamo pin 13 acceso e pin 12 spento nel passaggio uno e, nel passaggio 2, pin 13 spento e pin 12 spento, allora nel passaggio due potremmo evitare di scrivere che il pin 12 è spento. Questo perché Arduino ha memorizzato lo stato del pin e non lo cambia se non gli viene detto di farlo.
Utilizzando questa semplificazione abbiamo risparmiato ben 12 istruzioni nel void loop. Questo si traduce in un risparmio nella memoria di Arduino e in meno tempo per eseguire i vari passaggi. Il minor tempo impegato per eseguire i vari passaggi in alcuni casi potrebbe dare fastidio, nel nostro caso però possiamo applicare questa semplificazione e ottenere lo sketch che segue.

//Semaforo v. 1.1
void setup() {  //Dichiarazione pin
  //Semaforo 1
  pinMode (13, OUTPUT);  //LED Rosso
  pinMode (12, OUTPUT);  //LED Giallo
  pinMode (11, OUTPUT);  //LED Verde
  //Semaforo 2
  pinMode (10, OUTPUT);  //LED Rosso
  pinMode (9,  OUTPUT);  //LED Giallo
  pinMode (8,  OUTPUT);  //LED Verde
  
  //Dichiarazione stato iniziale pin
  //Tutti i led all'inizio sono spenti
  digitalWrite (13, LOW);
  digitalWrite (12, LOW);
  digitalWrite (11, LOW); 
  digitalWrite (10, LOW);
  digitalWrite (9,  LOW);
  digitalWrite (8,  LOW);
}
void loop() {
  // Semaforo 1: Rosso - Semaforo 2: Verde
  digitalWrite (13, HIGH);  //Rosso  1
  digitalWrite (12, LOW);   //Giallo 1
  digitalWrite (10, LOW);   //Rosso  2
  digitalWrite (8,  HIGH);  //Verde  2
  delay (4500);
  // Semaforo 1: Rosso - Semaforo 2: Giallo
  digitalWrite (9,  HIGH);  //Giallo 2
  digitalWrite (8,  LOW);   //Verde  2
  delay (1500);
  // Semaforo 1: Verde - Semaforo 2: Rosso
  digitalWrite (13, LOW);   //Rosso  1
  digitalWrite (11, HIGH);  //Verde  1
  digitalWrite (10, HIGH);  //Rosso  2
  digitalWrite (9,  LOW);   //Giallo 2
  delay (4500);
  // Semaforo 1: Giallo - Semaforo 2: Rosso
  digitalWrite (12, HIGH);  //Giallo 1
  digitalWrite (11, LOW);   //Verde  1
  delay (1500);
}

 

Il circuito 

Il circuito è anch'esso molto semplice. Si tratta di sei led collegati alle sei uscite che abbiamo utilizzato. Sapendo che i led sono collegati tutti a massa e che non è importante che la resistenza sia posta sul catodo o sull'anodo del led, colleghiamo tutti i catodi insieme e li mandiamo ad un'unica resistenza da 220 Ohm. Con questa piccola semplificazione abbiamo risparmiato ben 5 resistenze rispetto alla precedente versione del programma.

Se il mio lavoro vi è piaciuto commentate e ci diamo appuntamento al prossimo sketch!

Lo staff di elettromatica.blogspot.com 

ARDUINO - [PROGETTO] Semaforo (v. 1.0)

Benvenuti in questo nuovo post. Con questo post cominceremo un progetto: comandare un semaforo con Arduino. Successivamente andremo a raffinare sempre più il programma.

In questo post cercheremo di capire come funziona un semaforo e di  come comandarne uno da Arduino.
Questo sketch è la versione 1.0 del programma.

Materiale occorrente

• Arduino;
• 2x LED Rossi;
• 2x LED Gialli;
• 2x LED Verdi;
• 6x resistori da 220 Ohm;
• Breadboard e cavi di collegamento.

Funzionamento del circuito

Consideriamo un incrocio tra due strade come nella figura che segue. (L'incrocio in questione è quello che considereremo durante tutto il progetto).

Notiamo che i due semafori della strada 1 (1a e 1b) avranno la stessa luce accesa nello stesso istante di tempo. Lo stesso discorso vale per la strada 2. Di conseguenza, anziché realizzare sul circuito i quattro semafori (1a, 1b, 2a, 2b) ne realizzeremo solo due (Semaforo1 e Semaforo2). Tale semplificazione è utile sopratutto in circuiti più complessi, dove conviene usare meno uscite possibili. Per realizzare i quattro semafori basta collegare ad in parallelo ad ogni LED un altro dello stesso colore.



Dopo aver caricato lo sketch in Arduino questi farà accendere e spegnere in sequenza i led che rappresentano la luce rossa del semaforo. Notiamo inoltre che il tempo di accensione della luce rossa (6 sec) sarà dato dalla somma del tempo di accensione della luce verde e della luce gialla (4.5 sec + 1.5 sec).

Lo sketch

Anche qui non credo ci sia niente da spiegare, dato che i commenti all'interno dello sketch stesso spiegano tutto.

//Semaforo v. 1.0
void setup() {  //Dichiarazione pin
  //Semaforo 1
  pinMode (13, OUTPUT);  //LED Rosso
  pinMode (12, OUTPUT);  //LED Giallo
  pinMode (11, OUTPUT);  //LED Verde
  //Semaforo 2
  pinMode (10, OUTPUT);  //LED Rosso
  pinMode (9,  OUTPUT);  //LED Giallo
  pinMode (8,  OUTPUT);  //LED Verde
}
void loop() {
  // Semaforo 1: Rosso - Semaforo 2: Verde
  digitalWrite (13, HIGH);  //Rosso  1
  digitalWrite (12, LOW);   //Giallo 1
  digitalWrite (11, LOW);   //Verde  1
  digitalWrite (10, LOW);   //Rosso  2
  digitalWrite (9,  LOW);   //Giallo 2
  digitalWrite (8,  HIGH);  //Verde  2
  delay (4500);
  // Semaforo 1: Rosso - Semaforo 2: Giallo
  digitalWrite (13, HIGH);  //Rosso  1
  digitalWrite (12, LOW);   //Giallo 1
  digitalWrite (11, LOW);   //Verde  1
  digitalWrite (10, LOW);   //Rosso  2
  digitalWrite (9,  HIGH);  //Giallo 2
  digitalWrite (8,  LOW);   //Verde  2
  delay (1500);
  // Semaforo 1: Verde - Semaforo 2: Rosso
  digitalWrite (13, LOW);   //Rosso  1
  digitalWrite (12, LOW);   //Giallo 1
  digitalWrite (11, HIGH);  //Verde  1
  digitalWrite (10, HIGH);  //Rosso  2
  digitalWrite (9,  LOW);   //Giallo 2
  digitalWrite (8,  LOW);   //Verde  2
  delay (4500);
  // Semaforo 1: Giallo - Semaforo 2: Rosso
  digitalWrite (13, LOW);   //Rosso  1
  digitalWrite (12, HIGH);  //Giallo 1
  digitalWrite (11, LOW);   //Verde  1
  digitalWrite (10, HIGH);  //Rosso  2
  digitalWrite (9,  LOW);   //Giallo 2
  digitalWrite (8,  LOW);   //Verde  2
  delay (1500);
}

 

Il circuito 

Il circuito è anch'esso molto semplice. Si tratta di sei led collegati alle sei uscite che abbiamo utilizzato. Ogni LED ha in serie una resistenza da 220 Ohm per evitare che si bruci.

Se il mio lavoro vi è piaciuto commentate e ci diamo appuntamento al prossimo sketch!

Lo staff di elettromatica.blogspot.com 

PS: merito un commento e una condivisione per lo schema fatto a mano! ;)

ARDUINO - Bluetooth - I 5 LED

Benvenuti in questo nuovo post.

Dopo aver precedentemente trattato come usare un modulo bluetooth (HC-06) per accendere un solo LED, ora vedremo come estendere il programma a 5 LED, aggiungendo la possibilità di accenderli tutti o di spegnerli tutti.

Materiale occorrente

• Arduino;
• Modulo Bluetooth HC-06;
• 1x LED;
• Breadboard e cavi di collegamento.

Funzionamento del circuito

Con un app Android come Blue Serial si comandano i LED. 

Avviando il terminale di Blue Serial andramo a scrivere un singolo carattere che verrà inviato al modulo B/T. Questo modulo poi, tramite i pin RX e TX comunicherà ad Arduino l'azione da eseguire.
Per come è scritto il programma, quando verrranno inviate lettere maiuscole si accenedranno le uscite, al contrario, quando si invieranno lettere minuscole, le uscite si spegneranno.

Lo sketch

Non credo ci sia nulla da spiegare, dato che lo sketch si commenta da sé.

 

void setup() {
  //Definisce i pin a cui sono collegati i LED
  pinMode(13, OUTPUT);  //Rosso
  pinMode(12, OUTPUT);  //Giallo
  pinMode(11, OUTPUT);  //Bianco
  pinMode(10, OUTPUT);  //Verde
  pinMode(9, OUTPUT);   //Blu
  //Inizializza la comunicazione seriale
  Serial.begin(9600);
}
void loop() {
  //Legge un carattere dal seriale e lo pone in c
  char c = Serial.read();
  //Se il carattere letto è 'R' accende il LED rosso
  if (c == 'R') {
    digitalWrite (13, HIGH);
  }
  //Se il carattere letto è 'r' spegne il LED rosso
  if (c == 'r') {
    digitalWrite (13, LOW);
  }
  //Se il carattere letto è 'G' accende il LED giallo
  if (c == 'G') {
    digitalWrite (12, HIGH);
  }
  //Se il carattere letto è 'g' spegne il LED giallo
  if (c == 'g') {
    digitalWrite (12, LOW);
  }
  //Se il carattere letto è 'W' accende il LED bianco
  if (c == 'W') {
    digitalWrite (11, HIGH);
  }
  //Se il carattere letto è 'w' spegne il LED bianco
  if (c == 'w') {
    digitalWrite (11, LOW);
  }
  //Se il carattere letto è 'V' accende il LED verde
  if (c == 'V') {
    digitalWrite (10, HIGH);
  }
  //Se il carattere letto è 'v' spegne il LED verde
  if (c == 'v') {
    digitalWrite (10, LOW);
  }
  //Se il carattere letto è 'B' accende il LED blu
  if (c == 'B') {
    digitalWrite (9, HIGH);
  }
  //Se il carattere letto è 'b' spegne il LED blu
  if (c == 'b') {
    digitalWrite (9, LOW);
  }
  //Se il carattere letto è '0' spegne tutti i LED
  if (c == '0') {
    digitalWrite (13, LOW);
    digitalWrite (12, LOW);
    digitalWrite (11, LOW);
    digitalWrite (10, LOW);
    digitalWrite (9, LOW);
  }
  //Se il carattere letto è '1' accende tutti i LED
  if (c == '1') {
    digitalWrite (13, HIGH);
    digitalWrite (12, HIGH);
    digitalWrite (11, HIGH);
    digitalWrite (10, HIGH);
    digitalWrite (9, HIGH);
  }
} 

Il circuito 

Di seguito ecco il circuito, anch'esso molto semplice.

In questo caso però vogliamo ricordare che il modulo bluetooth deve essere scollegato quando si invia il programma ad Arduino, poiché in caso contrario occuperebbe la porta seriale impedendo al computer di comunicare con la scheda.

Dopo aver inviato il programma ad Arduino occorre scollegarlo dall'alimentazione, collegare il modulo B/T e ricollegare la scheda ad Arduino.

Ricordiamo anche i pin RX (ricevente) e TX (trasmittente) vanno collegati "ad incrociare", vale a dire RX di Arduino su TX del modulo e TX di Arduino su RX del modulo.

 

Se il mio lavoro vi è piaciuto commentate e ci diamo appuntamento al prossimo sketch!

Lo staff di elettromatica.blogspot.com

ARDUINO - Programma 01 - Blink

Eccoci infine al primo programma che andremo a relizzare usando Arduino.
La cosa più semplice che si può fare con Arduino è quella di accendere e spegnere un'uscita. In seguito potremo collegare questa uscita a qualcosa, come un led, per vederne il funzionamento reale.

Funzionamento del programma:
Faremo accendere e lasceremo acceso per un secondo il pin 13.
Dopo di che andremo a spegnere e lasciar spento per un altro secondo il pin 13.
Infine faremo riciclare tutto.

Passiamo ora al programma:

void setup(){
//istruzioni da eseguire una sola volta
pinMode (13, OUTPUT); //diciamo che il pin 13 è un pin di output
}
void loop(){
//istruzioni da eseguire continuamente
digitalWrite (13, HIGH); //accende il pin 13
delay(1000); //aspetta un secondo (mille millisecondi)
digitalWrite (13, LOW); //spegne il pin 13
delay(1000); //aspetta un secondo
//ricicla dall'inizio
}

Andiamo ora a vedere il circuito da realizzare.
Si collega il pin 13 ad una resistenza (un 220 ohm è sufficiente), dalla resistenza si va all'anodo (positivo) del LED. Si collega in GND al catodo (negativo) del LED. (Vedi i collegamenti in figura sotto).

A questo punto, dopo aver scaricato il programma sulla scheda, come andremo ad alimentarla potremo vedere lampeggiare il LED che abbiamo collegato. Inoltre, dato che abbiamo usato il pin 13, vedremo lampeggiare anche il LED on-board di Arduino.

Questo programma lo si può già trovare tra gli esempi di Arduino andando in File → Esempi → 01.Basics → Blink.
Malgrado la semplicità di questo sketch, non va sottovalutata la sua importanza. Usandolo come base si possono costruire programma più complessi e già con pochissime modifiche lo si può usare per pilotare un braccio meccanico.


Nuove istruzioni imparate e loro sintassi:
 pinMode (n,type); → definisce il pin n come pin di input (se al posto di type mettiamo input) o come pin di output (se al post di type mettiamo output)

 digitalWrite (n,logic_level); → pone il pin n al livello logico indicato (alto (o acceso) se logic_level = HIGH e basso (o spento) se logic_level = LOW)
 delay (millisec); → aspetta tanti millisecondi quanti sono indicati fra parentesi prima di passare all'istruzione successiva

Tutte le istruzioni le saranno successivamente raccolte e spiegate in una pagina apposita.

Al prossimo programma con Arduino!

ARDUINO - Pre 02 - Com'è fatto Arduino?

Hai conosciuto cos'è Arduino e sei curioso di sapere di pù su com'è fatto? 

Non ti ricordi la piedinatura della scheda? 

Allora sei nel posto giusto, andiamo a vedere cos'è Arduino.

La scheda ARDUINO UNO Rev. 3

Guardando l'immagine qui a fianco notiamo subito la presenza di vari componenti montati sulla scheda, tra cui il più importante è il circuito integrato.

Questo cirtcuito integrato è un microcontrollore (ATMEL ATMEGA 328-P), che gestisce tutte le operazione che fa Arduino.

Nella scheda originale questo microcontrollore è di tipo a foro passante, vale a dire che si può estrarre dalla scheda e montare altrove. In alcune schede compatibili, come quella in mio possesso, lo si può trovare di tipo SMD (o a montaggio superficiale), cioè saldato sulla scheda.

Oltre a questo circuito integrato la scheda include molti altri componenti, che vedremo in seguito.

ATMEGA 328 SMD

Indipendentemente da quale di questi due microcontrollori monti la nostra scheda, il suo funzionamento non cambia.

Andiamo ora a vedere più nel dettaglio cosa troviamo sul nostro Arduino.

La nostra scheda comprende molti pin che suddivideremo in risorse di alimentazione, risorse di comunicazione e risorse di I/O (input/output). Nella foto che segue troverete indicati in blu le risorse di alimentazione, in verde le risorse di comunicazione, in rosso le risorse di I/O e in giallo i pin non collegati.

Nelle RISORSE DI ALIMENTAZIONE troviamo:

• la porta USB, che, se collegata ad un computer fornisce ad Arduino 5 V di alimentazione;
• il jack da 2,1 mm di alimentazione esterna (7 - 12 V consigliati, tollerati fino a 20 V);
• una serie di pin (denominate in figura "Risorse di alimentazione") che comprendo due gruppi di pin: l'alimentazione in entrata e l'alimentazione in uscita.

L'alimentazione in entrata è costituita dai due pin di destra (Vin e GND (massa analogica)). A questi piedini può essere connessa una batteria esterna con lo stesso range di tensioni del jack di alimentazione.

L'alimentazione in uscita, che funziona quando l'Arduino è alimentato, è costituita dagli altri tre pin (5V, 3V3 e GND), che ci permettono di prelevare le tensioni di 5 V e 3.3 V tra il rispettivo pin e la massa (analogica).

• un pin GND, posto vicino agli I/O digitali, che rappresenta la massa (digitale);
• il pulsante RESET che, se premuto, riavvia la scheda;
• il pin RESET che funziona come il pulsante di RESET ma deve essere collegato esternamente.

Nelle RISORSE DI COMUNICAZIONE troviamo:

• una porta ICSP (In Circuit Serial Program) collegata alla porta USB;
• un'altra porta ICSP collegata al microcontrollore;
• la stessa porta USB, che permette di interfacciare Arduino ad un PC;
• due pin per la comunicazione seriale con il potocollo I2C (o IIC), che sono il pin SDA (Serial Data) ed il pin SCL (Serial Clock);
• altri due pin non indicati in foto (il pin 0 e il pin 1) destinati alla comunicazione seriale.

In seguito vedremo meglio il funzionamento di queste porte.

Nelle RISORSE DI INPUT/OUTPUT troviamo:

• 14 pin di I/O digitale (dal pin 0 al pin 13), di cui 5 di tipo PWM (Pulse-Width Modulation), che permettono di regolare la larghezza dell'impulso (capiremo meglio come funziona il PWM in seguito);
• 6 pin di I/O analogico (dal pin A0 ad A5);
• un pin di Analog Reference, che permette di impostare la tensione degli input analogici;
• un pin di I/O Refernce;
• il microcontrollore ATMEGA 328, anche se non è propriamente una risorsa di I/O.

In ultimo troviamo un pin non collegato (segnato in giallo nella foto sopra).

Ora che conosci meglio la scheda non vedi l'ora di provarla? Continua a seguirmi e inizieremo a programmarla insieme.
Per programmare la scheda è necessario proseguire installando i relativi driver.
Se invece hai tutto pronto e vuoi iniziare a programmare clicca qui.

ARDUINO - Pre 01 - Che cos'è Arduino?

Hai sentito parlare di Arduino e vorresti saperne di più? Ne hai uno e vorresti capire cosa ci puoi fare? Bene, sei nel posto giusto! Vediamo insieme cos'è Arduino e cosa possiamo farci.

Se vogliamo dare una definizione semplice possiamo dire che Arduino è una "scatola" con entrate (sia fisiche che programma) e uscite. Le uscite ci sono date in funzione delle entrate e del programma. Se, invece, vogliamo dare una definizione più "tecnica" possiamo dire che Arduino è una scheda elettronica, di tipo programmabile, che viene spesso utilizzata come piattaforma di prototipazione.

In realtà, Arduino non è una sola scheda, ma, se così vogliamo dire, la "marca" di molte schede. Esistono infatti vari "modelli" di Arduino destinati ad altrettanto vari usi.

Arduino LilyPad

Per esempio esiste Arduino Micro destinata a progetti più semplici, Arduino Mega per progetti più complessi ed esiste anche un versione "indossabile" che è Arduino LilyPad.
Durante questa serie di articoli, quando parleremo di Arduino, ci riferiremo alla scheda Arduino UNO Revisione 3.

Arduino MEGA 2560

A questo punto viene da chiedersi "perché proprio Arduino? Cosa ha questa scehda che le altre non hanno?".
Beh, secondo me, i suoi punti di forza sono tanti tra cui la semplicità di programmazione, la sua vasta diffusione, il supporto della community, il costo contenuto...

Inoltre Arduino merita una mezione speciale perché si tratta di un progetto open suorce e made in Italy.

Ora che hai capito cos'è Arduino sei curioso di sapere cosa può farci? Sono qua per rispondere anche a questa tua domanda.

Le potenzialità di questa scheda elettronica sono davvero tante: come abbiamo visto è una piattaforma di prototipazione, quindi possiamo usarla per realizzare prototipi.

Possiamo realizzare un drone radiocomandato, simulare una casa domotica, pilotare bracci robotici e molto altro, tutto ciò grazie alla capacità di Arduino di comunicare con una vastissima gamma di sensori e componenti vari.

Adesso che ti sei fatto un'idea su cosa sia Arduino e hai capito cosa si può fare usando questa scheda sei ansioso di metterla in fuzione? Allora ho buone notizie per te: chiunque può programmare Arduino!
Continua a seguirmi e ti spiegherò le basi di Arduino e, andando avanti, realizzeremo anche alcuni progetti interessanti.

Vuoi saperne di più su Arduino e vedere com'è strutturata la scheda? Allora clicca qui.
Conosci già Arduino e sei ansioso di programmare? In questo caso clicca qui.