Autore: PugliaSOS

Mediante un pulsante si vuol passare da un funzionamento che coinvolga tre LED (rosso, giallo e verde) ad uno lampeggiante del LED giallo.  Ci serviremo di una variabile in cui salvare lo stato del pulsante con cui determinare la commutazione.

 

Il codice:

 

#define red1 9

#define yel1 10

#define gre1 11

#define puls 2

boolean statoP = 0;

 

void setup() {

pinMode(red1, OUTPUT);

pinMode(yel1, OUTPUT);

pinMode(gre1, OUTPUT);

pinMode(puls, INPUT);

}

 

void loop() {

if (digitalRead(puls) == HIGH) statoP = !statoP ;

delay(250);

if (statoP == 1) {

digitalWrite(yel1, LOW);

digitalWrite(red1, LOW);

digitalWrite(gre1, HIGH);

delay(6000);

digitalWrite(gre1, LOW);

digitalWrite(yel1, HIGH);

delay(1500);

digitalWrite(yel1, LOW);

digitalWrite(gre1, LOW);

digitalWrite(red1, HIGH);

delay(6000);

}

if (statoP == 0) {

digitalWrite(red1, LOW);

digitalWrite(gre1, LOW);

digitalWrite(yel1, HIGH);

delay(1000);

digitalWrite(yel1, LOW);

delay(1000);

}

}

 

---

 http://sistemisds.altervista.org/

   Si può rendere più frendly il codice con l’introduzione di due funzioni: una per il funzionamento normale, l’altro per quello lampeggiante.

   Per la presenza della funzione delay() la commutazione avviene se il pulsante viene tenuto premuto alla fine della fase normale o lampeggiante, cioè durante l’accensione del rosso nel primo caso e del giallo nel secondo. In definitiva, conviene tenere premuto il pulsante finché non avviene la commutazione.

Questo progetto simula il funzionamento di un semaforo con chiamata da parte di un pedone; nell’approssimarsi del divieto di attraversamento, il pedone riceve una segnalazione acustica.

 

 

 

 

Componenti:

• 8 cavetti MM
• 2 LED verde
• 2 LED giallo
• 2 LED rosso
• 1 cicalino
• 1 pulsante
• 1 resistenza di 100 Ω
• 6 resistenze di 220 Ω
• 1 resistenza di 10 kΩ
• 12 cavetti MM

 

 

 

 

   Le fasi:

 

AUTO	LED verde	+	–
	LED giallo		+	–
	LED rosso			+		–
PEDONE	LED verde			+	–
	LED giallo				+	–
	LED rosso	+		–

 

   Il codice

 

int pulsante;

int verde_auto = 8;

int giallo_auto = 9;

int rosso_auto = 10;

int verde_pedone = 11;

int giallo_pedone = 12;

int rosso_pedone = 13;

int cicalino = 7;

 

void setup() {

for (int i = 7; i < 14; i++) {

pinMode(i, OUTPUT);

digitalWrite(i, LOW);

}

pinMode(2, INPUT); //pulsante

}

 

void loop() {

noTone(cicalino);

digitalWrite(verde_auto, HIGH); // ON

digitalWrite(rosso_pedone, HIGH); // ON

 

pulsante = digitalRead(2);

 

if (pulsante == HIGH) {

delay[2000];

 

digitalWrite(verde_auto, LOW); //OFF

digitalWrite(giallo_auto, HIGH); // ON

 

delay (4000);

 

digitalWrite(giallo_auto, LOW ); // OFF

digitalWrite(rosso_auto, HIGH); // ON

digitalWrite(verde_pedone, HIGH ); // ON

digitalWrite(rosso_pedone, LOW); // OFF

tone(7, 100);

 

delay(4000);

 

digitalWrite(verde_pedone, LOW); // OFF

digitalWrite(giallo_pedone, HIGH); // ON

tone(cicalino, 200);

 

delay(2000);

 

digitalWrite(giallo_pedone, LOW); // OFF

digitalWrite(rosso_auto, LOW); // OFF

}

}

 

 

 

 

 Componenti:

• 5 cavetti MM
• 3 LED: verde, giallo e rosso
• 1 cicalino
• 3 resistenze di 220 Ω

 

 

 

 

 

 Il codice:

 

void setup()
{
  pinMode(3, OUTPUT); // cicalino
  pinMode(11, OUTPUT); // verde
  pinMode(10, OUTPUT); // giallo
  pinMode(9, OUTPUT); // rosso
}

void loop()
{
  digitalWrite(11, HIGH);
  delay(2500);

  for (int i = 0; i < 5; i++) {
    digitalWrite(3, HIGH);
    digitalWrite(10, HIGH);
    delay(500);
    digitalWrite(10, LOW);
    digitalWrite(3, LOW);
    delay(500);
  }

  digitalWrite(11, LOW);
  digitalWrite(10, HIGH);
  delay(1000);

  digitalWrite(10, LOW);
  digitalWrite(9, HIGH);
  delay(4000);

  digitalWrite(9, LOW);
}

L’obiettivo è quello di realizzare un semaforo con il solo LED RedGgreeBlue; poiché non è presente un LED per il giallo, tale colore sarà generato dalla mescolanza delle luci di tonalità rossa e verde.

 

 

 

 

 

 

 

Componenti:

•  1 LED RGB,
•  3 Resistenza da 220 Ω,
•  4 cavetti MM.

Gli anodi del rosso e verde vanno collegati a pin PWM; nel nostro caso

Pin 5 [PWM] = anodo del verde

Pin 6 [PWM] = anodo del rosso

 

 

 

 

 

 

 

 

 

Il codice:

 

#define rosso 6
#define verde 5

 

void setup() {
  pinMode(rosso, OUTPUT);
  pinMode(verde, OUTPUT);
}

 

void loop() {

  analogWrite(rosso, 255);
  delay(8000);

  analogWrite(rosso, 0);
  analogWrite(verde, 255);
  delay(8000);

  analogWrite(verde, 0);
  analogWrite(rosso, 255);
  analogWrite(verde, 255);
  delay(3000);

  analogWrite(rosso, 0);
  analogWrite(verde, 0);

}

 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