Categoria: Giochi di luce con Arduino

 Un gioco simpatico con luci e suoni

 

 

 

 

Componenti:

 

• 7 Cavi di collegamento

• 1 Microfono

• 3 LED di diverso colore

• 3 Resistenze da 220Ω
  
  Si potrebbe usare un solo LED RGB.

 

 

 

 

 

 

 

 

 

 

 

Esempio n. 1

   All’emissione di un suono viene accesso casualmente un solo LED.

#define sensore_suono 8

void setup() {
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
pinMode(sensore_suono, INPUT);
}

void loop() {
  int colore;
  if (digitalRead(sensore_suono){
    colore = random(11, 14);
    delay(100);
    digitalWrite(colore, HIGH);
    delay(150);
    digitalWrite(colore, 0);
  }
}

 

Esempio n. 2

   All’emissione di un suono vengono accessi a caso i LED.

#define sensore_suono 8

void setup() {
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
  pinMode(sensore_suono, INPUT);
}

void loop() {
  if (digitalRead(sensore_suono)){
    digitalWrite(11, random(0,2));
    digitalWrite(12, random(0,2));
    digitalWrite(13, random(0,2));
    delay(100);
  }
}

 

Esempio n. 3

   All’emissione di un suono vengono accessi tutti e tre i LED; vengono impegnati 3 pin PWM.

#define sensore_suono 8

void setup() {
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(sensore_suono, INPUT);
}

void loop() {
  if (digitalRead(sensore_suono)){
    analogWrite(9, random(0, 256));
    analogWrite(10, random(0, 256));
    analogWrite(11, random(0, 256));
    delay(100);
  }
}

Un LED commuta il suo stato se si hanno due suoni ciascuno seguito da una pausa; trovare il battito ottimale per tentativi.

   Durante l’esecuzione dell’esercitazione precedente ti sarai reso conto che anche un rumore qualsiasi può creare una commutazione dello stato del LED non desiderata. Proviamo con un doppio battito di mani in un breve intervallo di tempo.

Nell’esempio che segue il LED commuta il suo stato se si hanno due suoni ciascuno seguito da una pausa; trovare il battito ottimale per tentativi.

#define tempo 100
#define attesa 100

int k;
long inizio;

void setup() {
  pinMode(8,INPUT);
  pinMode(13,OUTPUT);
  Serial.begin(9600);
}

void loop() {
  k=0;
  if(digitalRead(8)){
    Serial.println("PRIMO battito");
    delay(attesa);
    inizio=millis();
    k=1;
    while(millis()-inizio<200){ // se vi è un suono prima di 200 millisecondi azzera il contatore ed esci
      if(digitalRead(8)){
        Serial.println("Prima pausa non coerente");
        k=0;
        break;
      }
    }
    if(k==1){ // se vi è stato il primo battito seguito dalla pausa, attendi il secondo battito
      delay(attesa);
      inizio=millis();
      while(millis()-inizio<200){
        if(digitalRead(8)){
          Serial.println("SECONDO battito");
          k=2;
          break;
        }
      }
      if(k==2){ // controlla che ci sia anche la seconda pausa, altrimenti azzera il contatore
        delay(attesa);
        inizio=millis();
        while(millis()-inizio<200){
          if(digitalRead(8)){
            Serial.println("Manca SECONDA PAUSA");
            k=0;
            break;
          }
        }
        if(k==2){
          Serial.println();
          Serial.println();
          Serial.println();
          Serial.println("Commutazione effettuata

");
          commuta();
        }
      }
    }
  }
}

 

void commuta(){
  digitalWrite(13,!digitalRead(13));
  delay(200);
}

 

 Sitografia

https://www.youtube.com/watch?v=Uom–PyCVGw

Comandare un LED con battito di mani.

Il modulo

 

Nel modulo possiamo notare la presenza di

• un microfono CZN-15E,

  • una resistenza variabile,

  • un modulo LM393,

  • LED,

  • un’uscita digitale (OUT)

  • VCC e GND

   L’uscita digitale fornisce un segnale positivo (HIGH) quando l’intensità del suono supera un limite regolato dalla resistenza variabile. Nello specifico

1. Il microfono converte i segnali audio in segnali elettrici

2. Il modulo LM393 confronta il voltaggio del segnale proveniente dal microfono con quello regolato con il potenziometro e produce sul pin OUT in uscita un segnale:
   HIGH, se è maggiore,
   LOW, se è inferiore.

 

Dunque è preventivamente necessario regolare attraverso il potenziometro la sensibilità in modo da ottenere il segnale HIGH solo quando il rumore supera la soglia desiderata, in questo caso il battito delle mani.

 

Il codice

 

int stato_del_microfono;


 

void setup(){

  pinMode(8,INPUT);

  pinMode(12,OUTPUT);

  digitalWrite(12,0);

}

void loop(){

  stato_del_microfono = digitalRead(8);

  if(((stato_del_microfono)==(1))){

    digitalWrite(12,!(digitalRead(12)));

    delay(300);

  }

}

 

 

   Volendo simulare quelle lampade che si accendono e rimangono in tale stato per un tempo prestabilito:

int stato_del_microfono;


 

void setup(){

pinMode(8,INPUT);

pinMode(13,OUTPUT);

digitalWrite(13,0);

}

void loop(){

stato_del_microfono = digitalRead(8);

if(((stato_del_microfono)==(1))){

digitalWrite(13,1);

delay(10000);

digitalWrite(13,0);

}

}

 

 Decodificheremo i segnali provenienti da un telecomando qualsiasi che trasmetta con frequenza di 38 kHz e utilizzeremo gli stessi segnali per comandare Arduino a distanza per accendere e spegnere un LED.

Utilizzeremo la libreria IR.remote.h ed un TL1838, che è un componente elettronico economico che rileva segnali a raggi infrarossi (IR).

In figura, i 3 pin del ricevitore IR, sono collegati, nell’ordine da destra verso sinistra rispettivamente ai 5 V, al GND ed alla porta A0 di Arduino.

---

 

Decodifica dei segnali provenienti dal telecomando

   Utilizziamo questo sketch:

#include <IRremote.h> // carica la libreria per ricezione di dati IR
IRrecv ricevitore(A0); // Crea un oggetto ricevente da noi battezzato “ricevitore”: impostiamo il pin A0 per la ricezione dei dati
decode_results codice_tasto; // ed il segnale che decodificherà lo dovrà salvare nella variabile codice_tasto

void setup(){
Serial.begin(9600);
ricevitore.enableIRIn(); // Attiva la ricezione
}

void loop() {
if (ricevitore.decode(&codice_tasto)) {
/* Tenta di ricevere un segnale IR.Restituisce vero se un segnale è stato ricevuto, falso altrimenti. Quando un segnale è stato ricevuto, immagazzina l'informazioneall'interno della variabile "codice_tasto". */
Serial.println(codice_tasto.value, HEX);
ricevitore.resume(); /* Va eseguita dopo il comando di ricezione per resettare il ricevitore e prepararlo a ricevere il segnale successivo */
}
}

 

Primo passo

Carichiamo lo schizzo ed apriamo il monitor seriale;

 

Secondo passo

Premiamo un pulsante del telecomando e leggiamo il valore che appare sulla finestra del monitor seriale.
Per utilizzare i valori scritti nel serial monitor basta aggiungere 0x prima della sigla del valore nello sketch.

---

 

Accensione del LED 13

 

#include <IRremote.h>
IRrecv ricevitore(A0);
decode_results codice_tasto;

void setup()
{
  pinMode(13,OUTPUT);
  Serial.begin(9600);
  ricevitore.enableIRIn(); // attiva la ricezione
}

void loop() {
  if (ricevitore.decode(&codice_tasto)) {
    Serial.println(codice_tasto.value, HEX);
    ricevitore.resume();
    if ( codice_tasto.value == 0x804E58A7){  //tasto 1 sul telecomando   
      digitalWrite(13, HIGH); // accende il LED
    }
    if ( codice_tasto.value == 0x804EF807){ //tasto 2 sul telecomando
      digitalWrite(13, LOW); // spegne il LED
    }
  }
}

 

Analisi del codice

 

linea 1:

#include <IRremote.h>
includo la libreria IRemote nel mio sketch.

 

linea 2:

IRrecv ricevitore(A0);
inizializzo la libreria Iremote; dichiaro che il pin A0 è il “receiver” ovvero il pin da cui la libreria leggerà il segnale dal sensore,
il pin A0 viene collegato al piedino OUT del sensore:

 

linea 3:
decode_results codice_tasto;
decodifico il risultato che Arduino riceve dal sensore per ottenere un valore numerico utilizzabile nel confronto.

 

Costruisco la funzione setup()

• attivo la comunicazione seriale per vedere i valori letti dal sensore sulla Serial Monitor di Arduino quando premo un tasto sul telecomando
•  utilizzo il metodo ricevitore.enableIRIn(); della libreria IRemote perchè legga i valori provenienti dal sensore
• imposto, mediante il comando pinMode(13, OUTPUT); l’utilizzo del pin 13 di Arduino come output per pilotare il led

 

Costruisco la funzione loop()

• quando il sensore riceve un segnale proveniente dal mio telecomando scrive sul monitor seriale il valore rilevato
  Serial.println(results.value, HEX);
  e prosegue mettendo il sensore nuovamente in modalità di ascolto: ricevitore.resume();
• se viene premuto il tasto 1, per cui il valore letto dal sensore sarà uguale a 804E58A7 , porta l’uscita del pin 13 ad HIGH ( 1 ) ed il LED si accenderà
• se viene premuto il tasto 2 , per cui il valore letto dal sensore sarà uguale a 804EF807, porta l’uscita del pin 9 a LOW ( 0 ) ed il LED si spegnerà

I codici dei tasti vanno aggiornati con quelli ottenuti con il telecomando in nostro possesso.

   In questo esempio accenderemo e spegneremo un LED mediante un pulsante esterno al circuito del LED, che per questioni di praticità potrà essere inserito direttamente sulle porte GND e 13 di Arduino.

   Per prendere confidenza con diversi modi di risolvere lo stesso problema, vengono presentate più soluzioni leggermente diverse fra loro.

 

 

 

 

 

 

 

Componenti

•  1 LED
•  1 pulsante 1
•  3 cavetti MM
•  1 resistenza da 10 kΩ

 

 

 

 

 

 

 

 

 

 

---

 

Esempio presente nell’IDE in 02.Digital/Botton

 

 

 

const int buttonPin = 2;
const int ledPin = 13;
int buttonState = 0;

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

void loop() {
buttonState = digitalRead(buttonPin);

if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
}

else {
digitalWrite(ledPin, LOW);
}
}

   A riposo, i due lati dell’interruttore non sono collegati tra loro, e si dice che il pulsante è normalmente aperto. In tale esempio il LED rimane acceso finché è premuto il pulsante, poi si spegne; negli esempi che seguono il pulsante si comporta da commutatore.

---

Prima proposta (con due variabili char)

 

   Memorizzeremo lo stato del LED e del pulsante, rispettivamente nelle variabile statoLED e statoPulsante ambedue di tipo char inizializzate con il valore “false” ossia 0.

int led = 13;
int pulsante = 2;
char statoLED = 0;
char statoPulsante = 0;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(pulsante, INPUT);
}

void loop() {
  statoPulsante = digitalRead(pulsante);
  if (statoPulsante == HIGH) {
    if (statoLED == 0) {
      digitalWrite(led, 1);
      statoLED = 1;
    }
    else {
      digitalWrite(led, 0);
      statoLED = 0;
    }
  }
delay(250);
}

---

Seconda proposta (con una sola variabile char)

 

int led=13;
int pulsante=2;
char statoLED=false;

void setup() {
  pinMode(led,OUTPUT);
  pinMode(pulsante,INPUT);
}

void loop(){
  if(digitalRead(pulsante)==HIGH){
    statoLED=!statoLED;
    digitalWrite(led,statoLED);
  }
delay(250);
}

 

Terza proposta

 

int led = 13;
int pulsante = 2;

void setup() {
pinMode(led, OUTPUT);
pinMode(pulsante, INPUT);
}

void loop() {
if (digitalRead(pulsante)) {
digitalWrite(led, !digitalRead(pulsante));
}
delay(250);
}

---

 

Nota

   Per come sono costruiti i pulsanti presentano il cosiddetto effetto rimbalzo, ovvero non appena premuti, nei primi millisecondi, generano rumore che potrebbe dare false letture.

Per alcuni il modo per superare questo problema può essere quello di ripetere la lettura dell’input a distanza di qualche millisecondo e verificare se sono uguali

...

void loop(){
  val1 = digitalRead(pinPulsante); // legge il valore
  delay(10); // aspetta 10 millisecondi
  val2 = digitalRead(pinPulsante); // rilegge il valore
  if (val1 == val2) { // se i due valori sono uguali...
etc. etc.

  Per altri basterebbe introdurre una pausa opportuna, ad esempio 100-300 ms, fra una lettura dello stato dell’interruttore e la successiva.

 

---

 http://mbortolotti.blogspot.com/2012/01/led-e-pulsante-digital-inputcontinua.html?m=1

 https://www.arduino.cc/reference/en/language/functions/math/constrain/

   In questo progetto mediante il monitor seriale invieremo stringhe ad Arduino per cambiare il colore della luce emessa da un LED RGB.

Ci serviremo della funzione

  Serial.parseInt()

per rilevare da una stringa valori separati da un carattere non alfanumerico, che in genere è una punteggiatura come una virgola, un punto; va bene anche uno spazio.
Questa funzione restituisce il primo numero intero valido (di tipo long) letto dal buffer seriale; vengono saltati i caratteri che non siano un numero intero o il segno meno.

 

 

 

 

Componenti

• LED RGB
• 3 resistenze 220 Ω
• Fili di collegamento

 

 

 

 

 

 

 

 

 

Il codice

const int pinVerde = 9;
const int pinBlu = 10;
const int pinRosso = 11;

void setup() {
Serial.begin(9600);
pinMode(pinRosso, OUTPUT);
pinMode(pinVerde, OUTPUT);
pinMode(pinBlu, OUTPUT);
}

void loop() {
while (Serial.available() > 0) {
int rosso = Serial.parseInt(); // leggi il primo dato
int verde = Serial.parseInt(); // leggi il secondo dato
int blu = Serial.parseInt(); // leggi il terzo dato

if (Serial.read() == '
') { // se la stringa è esaurita

/* //RGB ad anodo comune
rosso = 255 - constrain(rosso, 0, 255);
verde = 255 - constrain(verde, 0, 255);
blu = 255 - constrain(blu, 0, 255);
*/
// RGB a catodo comune
rosso = constrain(rosso, 0, 255); // Nel caso si ecceda l’intervallo (0,255)
verde = constrain(verde, 0, 255);
blu = constrain(blu, 0, 255);

// configura il rosso, il verde, ed il blu sul LED RGB
analogWrite(pinRosso, rosso);
analogWrite(pinVerde, verde);
analogWrite(pinBlu, blu);
} // end if
} // end while
} // end loop

 

---

https://www.arduino.cc/en/Tutorial/ReadASCIIString

Il comando di accensione del LED non sarà dato da un pulsante, bensì dalla tastiera del computer.

Prendiamo un LED e colleghiamolo alle porte adiacenti 13 e GND di Arduino rispettando le polarità.

 

Algoritmo in linguaggio naturale

Configurazione

   Imposta la 13 come porta di uscita;

   Attiva la comunicazione seriale con il monitor ad una velocità di 9600 bit al secondo;

Ciclo

   Solo Se sono stati inviati dati dalla linea di input del monitor seriale allora

      memorizza il dato disponibile nella variabile intera comando;

      Se la variabile comando == ‘a’ allora

         eroga 5V dal pin 13;

         scrivi sul monitor “LED acceso”;

      Se comando == ‘s’ allora

         eroga 0V dal pin 13

         scrivi sul monitor “LED spento”

 

Codice

Configurazione Imposta la 13 come porta di uscita; Attiva la comunicazione seriale con il monitor ad una velocità di 9600 bit al secondo;	void setup() {    pinMode(13, OUTPUT);    Serial.begin(9600 ); }
Ciclo Solo Se sono stati inviati dati dalla linea di input del monitor seriale allora memorizza il dato disponibile nella variabile intera comando;       Se la variabile comando == ‘a’ allora          eroga 5V dal pin 13;          scrivi sul monitor “LED acceso”;       Se comando == ‘s’ allora          eroga 0V dal pin 13          scrivi sul monitor “LED spento”	void loop() {   if (Serial.available() > 0) { //oppure if (Serial.available()) int comando = Serial.read(); if (comando == 'a') { digitalWrite(13, HIGH); Serial.println("LED acceso"); } if (comando == 's') { digitalWrite(13, LOW); Serial.println("LED spento"); } } }

•  Compila e carica il programma su Arduino;
•  apri il monitor seriale;
•  accertati che la velocità di trasmissione sia quella indicata nel programma;
•  digita a ed invia: il led si accenderà e sul monitor comparirà la scritta ”Led acceso”;
•  digita s ed invia: il led si spegnerà e sul monitor comparirà la scritta ”Led spento”;
•  digita un carattere diverso da a ed s e non si avrà nessun effetto.

 

---

Mischiando, con diversa intensità, la luce di 3 LED di colore rosso, verde e blu è possibile creare tutti i colori.

   Un LED RedGgreeBlue raccoglie in un modo compatto 3 LED di colore rispettivamente rosso, verde e blu. Mischiando questi tre colori con diversa intensità (metodo additivo) è possibile creare tutti i colori della luce. I LED RGB hanno quattro pin, uno per ognuno dei tre colori ed uno per terra o potenza, a seconda della configurazione se a “catodo comune” o ad “anodo comune”; noi utilizzeremo il primo.

   Proprio perché, per creare i diversi colori dobbiamo usare il metodo additivo, per variare le intensità dei colori primari è necessario usare le uscite analogiche PWM di Arduino contrassegnate da una tilde.

Non è opportuno utilizzare una sola resistenza sul catodo comune in quanto ogni LED necessita di una propria resistenza poiché richiedono correnti di diversa intensità.

   A volte si intravedono separati i colori primari; prova a coprire il LED con materiali diffusori come ad esempio carta da forno o una pallina da ping pong. Comprenderai così come vengono creati i singoli pixel, anche se molto più piccoli, negli schermi della TV o del computer.

Componenti

• 1 LED RGB
• 3 resistenze di 220Ω

 

 

 

 

 

 

 

void setup()
{
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
}

void loop()
{
  analogWrite(11, 255), analogWrite(10, 0), analogWrite(9, 0);
  delay(1000);
  analogWrite(11, 255), analogWrite(10, 255), analogWrite(9, 102);
  delay(1000);
}

Effetto Fade

Componenti

• 1 LED rosso
• 1 resistenza di 220 Ω
• 2 cavetti

   La dissolvenza di un LED, conosciuta anche come effetto Fade, la si può ottenere gestendo la tecnica PWM (Pulse Width Modulation, pag. 5) su una delle sei porte digitali contrassegnate con una tilde; ovvero le 3, 5, 6, 9, 10 e 11 (Tali pin utilizzati in modo analogico non necessariamente vanno inizializzati come pin di output con pinMode). Tale tecnica permette ad Arduino di fornire, attraverso tali porte e tramite l’istruzione:

  analogWrite (pin, parametro);

tensioni variabili da 0 a 5 V e quindi gestire attuatori in modalità analogica.

In questa esercitazione con Arduino varieremo la luminosità di un led portandola progressivamente dal minimo al massimo e viceversa.

Si fa variare gradualmente la tensione in uscita dalla porta da 0 a 5 V agendo sul parametro dell’istruzione analogWrite con valori interi n che vanno da 0 a 255 (con una risoluzione di 19,6 mV); per cui con il valore 0 si ha in uscita un segnale di 0 V mentre con 255 un segnale con la tensione massima, cioè di 5 V. In generale

da cui

  Il circuito da realizzare è semplicissimo: il catodo e l’anodo del LED vanno collegati, rispettivamente, al GND e ad una resistenza da 220 Ω che a sua volta va collegata alla porta digitale 9.
Vengono proposte due metodologie: una con l’uso dell’if, l’altra con il for.

1. Nel primo caso il parametro del comando analogWrite viene prima sottoposto ad un incremento, per la positività della “variazione”, finché non raggiunge o supera il valore di 255, dopo di che la “variazione” viene cambiata di segno ed il parametro viene decrementato fino ad assumere il valore uguale o minore di zero: a questo punto la “variazione” viene nuovamente cambiata di segno e si passa nuovamente da un decremento ad un incremento del parametro e così via ciclicamente con una luminosità che prima cresce e poi decresce.
Nella programmazione a blocchi, per motivi di praticità, dal momento che la variazione è unitaria, il confronto si limiterà alla sola uguaglianza.

Con mBlock

 

int brillanza = 0;
int variazione = 1;
#define pinFade 9

void setup () {
pinMode(pinFade, OUTPUT);
}

void loop() {
analogWrite (pinFade, brillanza);
brillanza = brillanza + variazione;
if ( brillanza <= 0 || brillanza >= 255) {
variazione = variazione * (-1);
}
delay (50);
}

 

2. Nel secondo caso si ricorre a due cicli for che si alternano:

#define pinFade 9

void setup () {
  pinMode(pinFade, OUTPUT);

}

void loop() {
  for(int brillanza=0; brillanza<=255; brillanza=brillanza+5) {
    analogWrite (pinFade, brillanza);
    delay (20);
  }
  for(int brillanza=255; brillanza>=0; brillanza=brillanza-5) {
    analogWrite (pinFade, brillanza);
    delay (20);
  }
}

Con Tinkercad

 

 

 

 

 

   La simulazione dell’effetto FADE con Tinkercad, con l’inserimento di un oscilloscopio ai capi del LED, con tempo di divisione di 1 ms, ed un multimetro, può essere di aiuto per comprendere meglio, in modo qualitativo, il comportamento dei pin PWM.

Uno stimolo all’applicazione del ciclo for.

 

Componenti

• 2 LED di diverso colore,
• 3 cavetti,
• 2 ponticelli.

Cablaggio

 

 

Programmazione visuale

 

  mBlock 3

 

  Con Tinkercad

Dietro le quinte

void setup(){
  pinMode(12,OUTPUT);
  pinMode(13,OUTPUT);
}

void loop(){
  digitalWrite(12,1);
  delay(500);
  digitalWrite(12,0);
  digitalWrite(13,1);
  delay(500);
  digitalWrite(13,0);
  delay(500);
  digitalWrite(12,1);
  delay(500);
  digitalWrite(13,1);
  delay(500);
  for(int i=0;i<10;++i)
  {
    digitalWrite(12,0);
    digitalWrite(13,0);
    delay(200);
    digitalWrite(12,1);
    digitalWrite(13,1);
    delay(200);
  }
}