Archivi tag: led

Evitare il loop di messaggi inviati sulla Serial Monitor

Con questo post rispondo ad alcuni miei studenti su quesiti posti sull’uso di Arduino durante il ripasso condotto in questi giorni sulla modalità di stampa di messaggi sulla Serial Monitor.

L’esercizio assegnato consisteva nella tipica accensione e spegnimento di un LED mediante un pulsante con antirimbalzo software, nella seconda parte bisognava aggiungere un secondo pulsante che permetteva di accendere e spegnere un secondo LED e nella terza fase segnalare l’accensione e lo spegnimento sulla Serial Monitor mediante i messaggi:

“LED Rosso ON”
“LED Rosso OFF”
“LED Verde ON”
“LED Verde OFF”

Qundi per ciascun LED, alla prima pressione del pulsante accensione del LED e segnalazione ON sulla Serial, alla seconda pressione del pulsante segnalazione OFF sulla Serial e spegnimento del LED, ovviamente senza alcun limite sul numero di pressioni sui pulsanti.

Gli studenti sono riusciti a realizzare lo sketch ma con il solito problema di ripetizione in loop del testo di segnalazione sulla Serial.

Il problema può essere superato utilizzando un codice simile al seguente:

int stampaMessaggio = 0;

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

void loop() {
  if(!stampaMessaggio)
  {
     Serial.println(“Qualsiasi testo da stampare una sola volta…“);
     stampaMessaggio = 1;
  }
}

Nel primo ciclo di loop la condizione dell’if risulterà vera e ciò permetterà l’esecuzione della stampa del testo, successivamente impostata la variabile “stampaMessaggio” ad 1 non sarà più possibile stampare il testo al ciclo di loop successivo in quanto “!stampaMessaggio” risulterà uguale a 0.

Di seguito le due soluzioni, la prima con testo in loop sulla Serial, mentre la seconda con testo NON in loop.

Al fondo del post un esercizio aggiuntivo per i miei studenti.

All’interno del codice la spiegazione del funzionamento.

Soluzione con testo di output in loop

/*
   Prof. Michele Maffucci
   Accensione e spegnimento
   23.09.19

   Accensione e spegnimento di LED mediante pulsanti
   con antirimbalzo e messaggio ripetuto dello stato del LED
   sulla Serial Monitor

   Pulsante Rosso: accensione e spegnimento LED Rosso
   (prima pressione accende, seconda pressione spegne)

   Pulsante Verde: accensione e spegnimento LED Verde
   (prima pressione accende, seconda pressione spegne)

*/

// ledRosso variabile di tipo intero a cui viene assegnato
// il valore intero 5 che sarà associato al pin digitale 5

int ledRosso = 5;

// ledVerde variabile di tipo intero a cui viene assegnato
// il valore intero 4 che sarà associato al pin digitale 4

int ledVerde = 4;


// pulsanteRosso variabile di tipo intero a cui viene assegnato
// il valore intero 7 che sarà associato al pin digitale 7
// a cui sarà collegato il pulsante che comanda il LED Rosso

int pulsanteRosso = 7;

// pulsanteVerde variabile di tipo intero a cui viene assegnato
// il valore intero 6 che sarà associato al pin digitale 6
// a cui sarà collegato il pulsante che comanda il LED Verde

int pulsanteVerde = 6;

// inizializzazione della variabili in cui verrà memorizzato il valore della
// digitalRead: 0 non premuto, 1 premuto

int valRosso = 0;
int valVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int statoRosso = 0;
int statoVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato precedente del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int valRossoOld = 0;
int valVerdeOld = 0;

void setup() {
  pinMode(ledRosso, OUTPUT);           // imposta il pin digitale come output
  pinMode(ledVerde, OUTPUT);           // imposta il pin digitale come output
  pinMode(pulsanteRosso, INPUT);       // imposta il pin digitale come input
  pinMode(pulsanteVerde, INPUT);       // imposta il pin digitale come input

  Serial.begin(9600);                 // imposta la velocità di scrittura della serial monitor
}

void loop() {

  valRosso = digitalRead(pulsanteRosso);  // lettura dell'input (pulsante) e memorizzazione in valRosso
  valVerde = digitalRead(pulsanteVerde);  // lettura dell'input (pulsante) e memorizzazione in valVerde

  // ---------- Controllo pulsante LED Rosso ----------

  if ((valRosso == HIGH) && (valRossoOld == LOW)) {
    statoRosso = 1 - statoRosso;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi
    delay(15);
  }


  // memorizzazione del valore precedente restituito dalla digitalRead

  valRossoOld = valRosso;

  // ---------- Controllo pulsante LED Verde ----------

  // viene controllato che l'input sia HIGH (pulsante premuto) e cambia lo stato del LED

  if ((valVerde == HIGH) && (valVerdeOld == LOW)) {
    statoVerde = 1 - statoVerde;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi

    delay(15);

    // memorizzazione del valore precedente restituito dalla digitalRead
  }

  valVerdeOld = valVerde;

  // ---------- Stampa sulla Serial Monitor dello stato del LED Rosso ----------

  // Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Rosso si accende

  if (statoRosso == 1) {
    digitalWrite(ledRosso, HIGH);
    Serial.println("LED Rosso ON");
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Rosso OFF"

  else {
    digitalWrite(ledRosso, LOW);
    Serial.println("LED Rosso OFF");
  }

  // ---------- Stampa sulla Serial Monitor dello stato del LED Verde ----------

  // Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Verde si accende

  if (statoVerde == 1) {
    digitalWrite(ledVerde, HIGH);
    Serial.println("LED Verde ON");
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Verde OFF"

  else {
    digitalWrite(ledVerde, LOW);
    Serial.println("LED Verde OFF");
  }
}

Soluzione con testo di output NON in loop

/*
   Prof. Michele Maffucci
   Data: 23.09.19

   Accensione e spegnimento di LED mediante pulsanti
   con antirimbalzo e messaggio NON ripetuto dello stato del LED
   sulla Serial Monitor

   Stampa 1 sola volta il messaggio dello stato del LED sulla Serial Monitor
   (non va in loop la stampa dello stato del LED)

   Pulsante Rosso: accensione e spegnimento LED Rosso
   (prima pressione accende, seconda pressione spegne)

   Pulsante Verde: accensione e spegnimento LED Verde
   (prima pressione accende, seconda pressione spegne)

*/

// ledRosso variabile di tipo intero a cui viene assegnato
// il valore intero 5 che sarà associato al pin digitale 5

int ledRosso = 5;

// ledVerde variabile di tipo intero a cui viene assegnato
// il valore intero 4 che sarà associato al pin digitale 4

int ledVerde = 4;


// pulsanteRosso variabile di tipo intero a cui viene assegnato
// il valore intero 7 che sarà associato al pin digitale 7
// a cui sarà collegato il pulsante che comanda il LED Rosso

int pulsanteRosso = 7;

// pulsanteVerde variabile di tipo intero a cui viene assegnato
// il valore intero 6 che sarà associato al pin digitale 6
// a cui sarà collegato il pulsante che comanda il LED Verde

int pulsanteVerde = 6;

// inizializzazione della variabili in cui verrà memorizzato il valore della
// digitalRead: 0 non premuto, 1 premuto

int valRosso = 0;
int valVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int statoRosso = 0;
int statoVerde = 0;

// inizializzazione della variabili in cui verrà memorizzato lo stato precedente del pulsante
// All'avvio dello sketch i pulsanti non sono premuti

int valRossoOld = 0;
int valVerdeOld = 0;

// inizializzazione delle variabili che consentono la stampa dello stato del LED

int stampoRossoON = 0;
int stampoRossoOFF = 0;

int stampoVerdeON = 0;
int stampoVerdeOFF = 0;

void setup() {
  pinMode(ledRosso, OUTPUT);           // imposta il pin digitale come output
  pinMode(ledVerde, OUTPUT);           // imposta il pin digitale come output
  pinMode(pulsanteRosso, INPUT);       // imposta il pin digitale come input
  pinMode(pulsanteVerde, INPUT);       // imposta il pin digitale come input

  Serial.begin(9600);                 // imposta la velocità di scrittura della serial monitor
  Serial.println("Avvio programma");  // stampa la stringa tra le " e va a campo
  Serial.println("---------------");  // stampa la stringa tra le " e va a campo
}

void loop() {

  valRosso = digitalRead(pulsanteRosso);  // lettura dell'input (pulsante) e memorizzazione in valRosso
  valVerde = digitalRead(pulsanteVerde);  // lettura dell'input (pulsante) e memorizzazione in valVerde

// ---------- Controllo pulsante LED Rosso ----------

  // viene controllato che l'input sia HIGH (pulsante premuto) e cambia lo stato del LED

  if ((valRosso == HIGH) && (valRossoOld == LOW)) {
    statoRosso = 1 - statoRosso;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi
    delay(15);

    // poichè il pulsante è stato premuto la variabile stampoRossoON viene posta a 0
    // per consentire la stampa del messaggio "LED Rosso ON"

    stampoRossoON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valRossoOld = valRosso;

// ---------- Controllo pulsante LED Verde ----------

  // viene controllato che l'input sia HIGH (pulsante premuto) e cambia lo stato del LED

  if ((valVerde == HIGH) && (valVerdeOld == LOW)) {
    statoVerde = 1 - statoVerde;

    // antirimbalzo software - attesa di 15 ms per attendere che l'input si stabilizzi

    delay(15);

    // poichè il pulsante è stato premuto la variabile stampoVerdeON viene posta a 0
    // per consentire la stampa del messaggio "LED Verde ON"

    stampoVerdeON = 0;
  }

  // memorizzazione del valore precedente restituito dalla digitalRead

  valVerdeOld = valVerde;

// ---------- Stampa sulla Serial Monitor dello stato del LED Rosso ----------

// Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Rosso si accende

  if (statoRosso == 1) {
    digitalWrite(ledRosso, HIGH);

    // Se la variabile stampoRossoON è 0 allora !stampoRossoON vale 1
    // ciò consente la stampa del messaggio "LED Rosso ON"

    if (!stampoRossoON) {
      Serial.println("LED Rosso ON");

      // Per evitare una stampa continua del messaggio viene posto ad 1 stampoRossoON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Rosso ON". Viene posto a 0 stampoRossoOFF per consentire la stampa "LED Rosso OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.

      stampoRossoON = 1;
      stampoRossoOFF = 0;
    }
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Rosso OFF"

  else {
    digitalWrite(ledRosso, LOW);

    if (!stampoRossoOFF) {
      Serial.println("LED Rosso OFF");

      // Per evitare una stampa continua del messaggio viene posto ad 0 stampoRossoON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Rosso OFF". Viene posto a 1 stampoRossoOFF per consentire la stampa "LED Rosso OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.

      stampoRossoON = 0;
      stampoRossoOFF = 1;
    }
  }

// ---------- Stampa sulla Serial Monitor dello stato del LED Verde ----------

// Se il pulsante è stato premuto la condizione dell'if risulta vera ed il LED Verde si accende

  if (statoVerde == 1) {
    digitalWrite(ledVerde, HIGH);

    // Se la variabile stampoVerdeON è 0 allora !stampoVerdeoON vale 1
    // ciò consente la stampa del messaggio "LED verde ON"

    if (!stampoVerdeON) {
      Serial.println("LED Verde ON");

      // Per evitare una stampa continua del messaggio viene posto ad 1 stampoVerdeON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Verde ON". Viene posto a 0 stampoVerdeOFF per consentire la stampa "LED Verde OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Rosso.

      stampoVerdeON = 1;
      stampoVerdeOFF = 0;
    }
  }

  // nel caso in cui il pulsante non sia premuto o nello stato precedente era stato premuto
  // allora il LED dovrà essere spento ed il messaggio sulla seriale dovrà essere "LED Verde OFF"

  else {
    digitalWrite(ledVerde, LOW);

    if (!stampoVerdeOFF) {
      Serial.println("LED Verde OFF");

      // Per evitare una stampa continua del messaggio viene posto ad 0 stampoVerdeON
      // in modo che nel ciclo di loop successivo non venga più stampato il messaggio
      // "LED Verde OFF". Viene posto a 1 stampoVerdeOFF per consentire la stampa "LED Verde OFF"
      // nel caso si prema nuovamente il pulsante che controlla il LED Verde.

      stampoVerdeON = 0;
      stampoVerdeOFF = 1;
    }
  }
}

Esercizio: implementare il controllo della marci e dell’arresto di un motore

Realizzare un circuito in cui con tre pulsanti vengono identificate le tre situazioni:

Marcia
Arresto
Anomalia

Associare ad ogni situazione il colore del LED:

Rosso: marcia
Verde: arresto
Giallo: anomalia

Alla pressione del corrispondente pulsante mostrare sulla Serial Monitor :

Motore in marcia
Motore fermo
Anomalia motore

Buon lavoro 🙂

Due papà ansiosi dal barbiere ed una striscia led per la mente

5 Repliche

Questo è il post delle piccole ansie di un papà 🙂

striscia-led01

Il consueto appuntamento mensile dal barbiere Luigi per il taglio di capelli. Incontro Albino, entrambi abbiamo i figli della stessa età che frequentano il medesimo Liceo. Inevitabile i discorsi di scuola e problemi adolescenziali, primo tra tutti la difficoltà nel trovare una passione o ampliare le proprie relazioni al di fuori della scuola.
Un’adolescente in casa insegna molte cose. Osservavo in queste serate, guardando mio figlio che studia, la modalità con cui al liceo vengono propinate le materie scientifiche: fisica, chimica, biologia… tutte categoricamente su carta, esercizi sui moti uniformemente accelerati, studio di molecole e composti organici solo su carta mannaggia… il laboratorio e luogo sconosciuto, per non parlare dellinformatica lasciamo perdere.
Non voglio incominciare il solito discorso disfattista e lamentoso su taglio delle ore dei laboratori e mancanza di denaro e se pur impegnato a scuola nel trovare soluzioni, incominciano a stancarmi i ragionamenti sui massimi sistemi e sulla funzione docente, sono più concentrato sulle soluzioni e dare possibilità, nel limite delle mie forze, ai ragazzi che mostrano interesse.
Il carico di studio elevatissimo (che noto al liceo) e la quasi assenza di materie svolte in laboratorio fanno perdere nei ragazzi la percezione del senso degli argomenti che stanno studiando provocando disagio, a ciò si aggiunge il periodo di scombussolamento ormonale che provoca stati danimo estremamente controversi sicuro che mi procurerò lira dei colleghi del liceo ma poco importa.
Come genitore ci si interroga continuamente e si cercano strategie che possano favorire laccensione di quella fiammella di passione nei propri figli, attivando, si spera, il volano che porta al desiderio di scoperta insomma ansie da genitori.
Tutto ciò per dire, che siano esperimenti di elettronica, osservazioni astronomiche con un telescopio, luso di un microscopio, è importante insegnare a dare forma fisica ai propri progetti, potranno nascere da un copia ed incolla visto su internet, ma è così che si impara , se non ci si ferma al copia ed incolla ovviamente, comprendere, rielaborare.
Nella mente di mio figlio, ora piena di poemi Omerici, Epica Latina e tra poco anche dei Promessi Sposi, sto cercando di inserire anche la materia progetta e costruisci.
Con stampante 3D e tanta elettronica che gira per casa da qualche tempo abbiamo incominciato con Arduino, robotica ed automazione in genere e come per i miei studenti anche per questo, particolare studente 🙂 Arduino svolge egregiamente la funzione di facilitatore e mi sta rendendo la vita da padre un po più serena.

Corsi su Arduino ovunque online a scuola e nei FabLab ora è giunta lora di farli anche alla famiglia 🙂 la figlia più piccola costruisce piccolo alberi di Natale con LED, il grande programmazione ed elettronica.

Con il liceale siamo giunti in queste serate alla realizzazione di un semplice controllo di una striscia RGB che abbiamo utilizzato per adornare la zona in cui è collocato lalbero di Natale, poiché lo sketch è di interesse per alcuni miei allievi di 5, pubblico e lascio a chi vorrà la possibilità di migliorarlo.

La spiegazione nei commenti dello sketch.

Nello sketch che è lultima versione sviluppata dal giovane studente, trovate commentate alcune parti di codice che potrete attivare e che svolgono funzioni diverse.

1. Cambio colore graduale (in accensione ed in spegnimento) casuale nella scelta del colore:

solo bianco
solo rosso
solo verde
solo blu
variazione continua di tutti i colori

2. Variazione di una sola delle modalità del punto 1

Compiti per Natale:

3. inserimento di un sensore ad ultrasuoni che percepisce il passaggio di persone davanti allAlbero di Natale emettendo una luce intensa bianca
4. Controllo remoto con telecomando
5. Controllo remoto con cellulare (per questo però credo che ci penserà il papà)

materiale sufficiente per fare qualcosa di creativo durante le prossime vacanze di Natale 🙂

Lista componenti:

Arduino UNO R3
N. 3 transistor BD 709 (quelli che avevo a disposizione)
N.3 resistori da 220 Ohm

Striscia LED alimentata a 12V.
Si è utilizzato un alimentatore esterno a 12V per l’alimentazione della scheda e della striscia LED.
L’alimentazione a 12V della striscia LED è presa direttamente dalla Vin della scheda.

strip-led-rgb

/* Pilotaggio striscia LED
 Mattia Maffucci
 ...con lo zampino di suo papà Michele
 20.12.14
 */

// pin a cui è collegata la striscia LED
#define pinRosso 5
#define pinVerde 6
#define pinBlu 3

// velocità tra un'intensità luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeBianco = 60;

// velocità tra un'intensità luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeRosso = 60;

// velocità tra un'intensità luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeVerde = 60;

// velocità tra un'intensità luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeBlu = 60;

// velocità tra un'intensità luminosa e la successiva.
// Per rallentare il fade aumentare il valore
int velocitaFadeContinuo = 60;

// attesa prima della partenza della successiva accensione
int attesaFinaleBianco = 2000;
int attesaFinaleRosso = 2000;
int attesaFinaleVerde = 2000;
int attesaFinaleBlu = 2000;
int attesaFinaleContinuo = 2000;

// intensità massima di bianco. Per
// rallentare il fade aumentare il valore
int limiteBianco = 30;

// intensità massima di rosso. Per
// rallentare il fade aumentare il valore
int limiteRosso = 30;

// intensità massima di verde. Per
// rallentare il fade aumentare il valore
int limiteVerde = 30;

// intensità massima di blu. Per
// rallentare il fade aumentare il valore
int limiteBlu = 30;

// intensità massima dei colori. Per
// rallentare il fade aumentare il valore
// massimo 255
int limiteContinuo = 100;

// per rallentare il fade aumentare il valore
int limiteFadeRandom = 120;

// numero massimo di colori scelto in
// maniera casuale
int randomColor = 5;

void setup() {
  pinMode(pinRosso, OUTPUT);
  pinMode(pinVerde, OUTPUT);
  pinMode(pinBlu, OUTPUT);
}

void loop() {

  // --- accensione solo bianco alla massima luminosità ---

  /*
  analogWrite(pinRosso, 255);
   analogWrite(pinRossoDue, 255);
   analogWrite(pinVerde, 255);
   analogWrite(pinVerdeDue, 255);
   analogWrite(pinBlu, 255);
   analogWrite(pinBluDue, 255);
   */

  // ------------------------------------------------------

  /*
// --- variazione luminosità bianco ---

   variazioneBianco();

   // ------------------------------------------------------
   */

  // --- casuale nella scelta del colore ---

  casuale();

  // ------------------------------------------------------

  /*
// --- variazione continua colori incluso il bianco ---

   variazioneContinua();

   // ------------------------------------------------------
   */

}

// funzioni esterne per la variazione continua del colore

// -- casuale

void casuale() {
  int sceltaSequenza=random(randomColor);
  switch (sceltaSequenza) {
  case 0:
    variazioneBianco(limiteBianco, velocitaFadeBianco, attesaFinaleBianco);
    break;
  case 1:
    variazioneRosso(limiteRosso, velocitaFadeRosso, attesaFinaleRosso);
    break;
  case 2:
    variazioneVerde(limiteVerde, velocitaFadeVerde, attesaFinaleVerde);
    break;
  case 3:
    variazioneBlu(limiteBlu, velocitaFadeBlu, attesaFinaleBlu);
    break;
  case 4:
    variazioneContinua(limiteContinuo, velocitaFadeContinuo, attesaFinaleContinuo);
    break;
  default:
    {
      // nulla
    }
  }
}

// --- variazione contina del colore

void variazioneContinua(int limiteContinuo, int velocitaFadeContinuo, int attesaFinaleContinuo) {
  int rosso, verde, blu;
  // fade da blu a viola
  for (rosso = 0; rosso < limiteContinuo; rosso++) {      analogWrite(pinRosso, rosso);     delay(velocitaFadeContinuo);   }    // fade da viola a rosso   for (blu = limiteContinuo; blu > 0; blu--) {
    analogWrite(pinBlu, blu);
    delay(velocitaFadeContinuo);
  }
  // fade da rosso a giallo
  for (verde = 0; verde < limiteContinuo; verde++) {      analogWrite(pinVerde, verde);     delay(velocitaFadeContinuo);   }    // fade da giallo a verde   for (rosso = limiteContinuo; rosso > 0; rosso--) {
    analogWrite(pinRosso, rosso);
    delay(velocitaFadeContinuo);
  }
  // fade da verde a bianco
  for (blu = 0; blu < limiteContinuo; blu++) {      analogWrite(pinBlu, blu);     delay(velocitaFadeContinuo);   }    // fade da bianco a blu   for (verde = limiteContinuo; verde > 0; verde--) {
    analogWrite(pinVerde, verde);
    delay(velocitaFadeContinuo);
  }
}

// --- variazione intensità luminosa del bianco ---

void variazioneBianco(int limiteBianco, int velocitaFadeBianco, int attesaFinaleBianco) {

  for (int fade = 0; fade < limiteBianco; fade++) {     analogWrite(pinRosso, fade);     analogWrite(pinVerde, fade);     analogWrite(pinBlu, fade);     delay(velocitaFadeBianco);   }   for (int fade = limiteRosso; fade >= 0; fade--) {
    analogWrite(pinRosso, fade);
    analogWrite(pinVerde, fade);
    analogWrite(pinBlu, fade);
    delay(velocitaFadeBianco);
    delay(attesaFinaleBianco);
  }
}

// --- variazione luminosità del rosso

void variazioneRosso(int limiteRosso, int velocitaFadeRosso, int attesaFinaleRosso) {

  analogWrite(pinVerde, 0);
  analogWrite(pinBlu, 0);

  for (int fade = 0; fade < limiteRosso; fade++) {     analogWrite(pinRosso, fade);     delay(velocitaFadeRosso);   }   for (int fade = limiteRosso; fade >= 0; fade--) {
    analogWrite(pinRosso, fade);
    delay(velocitaFadeRosso);
    delay(attesaFinaleRosso);
  }
}

// --- variazione luminosità del verde

void variazioneVerde(int limiteVerde, int velocitaFadeVerde, int attesaFinaleVerde) {

  analogWrite(pinRosso, 0);
  analogWrite(pinBlu, 0);

  for (int fade = 0; fade < limiteVerde; fade++) {     analogWrite(pinVerde, fade);     delay(velocitaFadeVerde);   }   for (int fade = limiteVerde; fade >= 0; fade--) {
    analogWrite(pinVerde, fade);
    delay(velocitaFadeVerde);
    delay(attesaFinaleVerde);
  }
}

// --- variazione luminosità del blu

void variazioneBlu(int limiteBlu, int velocitaBlu, int attesaFinaleBlu) {

  analogWrite(pinRosso, 0);
  analogWrite(pinVerde, 0);

  for (int fade = 0; fade < limiteBlu; fade++) {     analogWrite(pinBlu, fade);     delay(velocitaFadeBlu);   }   for (int fade = limiteBlu; fade >= 0; fade--) {
    analogWrite(pinBlu, fade);
    delay(velocitaFadeBlu);
    delay(attesaFinaleBlu);
  }
}

Arduino – lezione 09: uso di LED RGB

4 Repliche

Mi viene continuamente richiesto da molti lettori di questo blog di inserire le lezioni che svolgo a scuola con i miei studenti quindi dopo questa tirata d’orecchie che mi viene fatta 🙂 spessissimo riprendo questa attività.

Per dare ordine al percorso di apprendimento, riprendo i contenuti sviluppati nelle mie slide di dominio pubblico e quanto già scritto in una mia precedente attività pratica svolta con gli studenti: Arduino: effetti luminosi per rendere attraente la lezione

Agendo in questo modo i miei colleghi, che desiderano implementare una didattica in cui viene utilizzo Arduino, si troveranno una sequenza ordinata di lezioni dove gli argomenti e gli esercizi sono scelti per sviluppare ed approfondire aspetti particolari della programmazione, quindi perdonate le ripetizioni (fisime da Prof. bacchettone), ma l’ordine è fondamentale se si desidera spiegare e quindi faccio ordine 🙂

Parliamo dei LED RGB, uno dei componenti che suscita negli studenti sempre molto interesse, soprattutto perché si presta a molteplici attività creative i LED RGB.

Quanto scritto è ripreso dalle mie slide che sono di dominio pubblico a queste aggiungerò ulteriori esercizi.

I led RGB sono led capaci di produrre 3 differenti lunghezze d’onda:

Rosso (R, red)
Verde (G, green)
Blu (B, blue)

arduino-led-rgb-01

Posseggono 4 terminali e si possono presentare in due tipi di configurazione:

1 anodo e 3 catodi (RGB ad anodo comune)
3 anodi e 1 catodo (RGB a catodo comune)

La mescolanza dei tre colori dà luogo ad una luce di un determinato colore che dipende dall’intensità di ciascuno dei tre colori originari (si veda la composizione RGB) Continua a leggere→

Arduino: effetti luminosi per rendere attraente la lezione

12 Repliche

Ormai è da tempo che svolgo i mie corsi su Arduino e gli allievi stanno diventando sempre più esigenti. Mi accorgo che andando avanti con le lezioni, gli allievi hanno l’esigenza, legittime, di realizzare esperienze di laboratorio sempre più attinenti al mondo reale che loro conoscono. Qualche anno fa era sufficiente mostrare come era semplice variare il colore di un diodo led RGB per avere interesse ed attenzione duratura, ciò mi permetteva di conseguenza di dettagliare alcuni aspetti di programmazione che se non spiegati con Arduino sarebbero risultati più difficili da comprendere, ma ora per mantenere lo stesso livello di attenzione è necessario aggiungere altri elementi di sensibilizzazione.

Maggiori pretese e quindi fin dalle prime lezioni si vuole “la sorpresa tecnologica”…

mamma mia quanto è faticoso fare l’insegnante!

Sono in quel periodo del corso in cui si accendono il led con Arduino in tutte le maniere possibili, dal blink al fade, in sequenza e in molti altri modi, ma alla lunga, mi rendo conto, la cosa può diventare un po’ “noiosetta”, vorrei evitare il più possibile l’effetto “sbadiglio” 🙂 e quindi ho pensato di modificare le prime esperienze con qualcosa di più coreografico.

Tutto nasce da alcune idee che ho sulla realizzazione di una struttura semplificata (ad incastro) per la realizzazione di un kit robotico basato su Arduino da usare a scuola e da realizzare con materiali di basso costo di facile reperibilità, sto costruendo alcuni prototipi usando il plexiglass.

E proprio mentre manipolavo il plexiglass ho avuto l’idea di utilizzare questo materiale per nuove esperienze che fanno uso di led.

Ho voluto condividere questa bozza di lezione con voi in modo che se vorrete potrete darmi suggerimenti o alternative che potranno essere in futuro sfruttate a scuola.

Tutti sapete che quando la luce passa attraverso due materiali diversi, come tra l’aria e l’acqua oppure tra l’aria e la plastica, subisce rifrazione, effetto tipico che potete notare quando ad esempio mettete una cannuccia in un bicchiere d’acqua, si nota che la cannuccia nell’acqua sembra piegata.
Sfruttiamo questo fenomeno per far cambiare direzione alla luce che attraversa uno strato di plexiglass e la variazione di percorso della luce viene realizzata incidendo (graffiando) la superficie di plastica, così facendo i raggi luminosi prodotti da diodi led che colpiscono la zona incisa si rifletteranno (cambiano direzione) provocando un effetto visivo molto bello.

Poiché siamo in periodo natalizio l’idea potrebbe essere quella di realizzare una piccola insegna su cui scrivere “Buone Feste” facendo variare il suo colore in maniera ciclica.

Scopo dell’esperienza:

reciclando materiali di uso comune reperibili a scuola, realizzare un’insegna luminosa che auguri “Buone Feste” ai visitatori della scuola.
Tempo di realizzazione 3 ore (max).

Materiali:

plexiglass (misure a piacere nel mio caso inferiori alla lunghezza massima di una breadboard)
piccolo trapano con punta per incisione
breadboard
Arduino UNO
2 diodi RGB (nel mio caso ad anodo comune)
4 resistenze da 82 ohm
2 resistenze da 150 ohm
porta diodi (per evitare la saldatura diretta su millefori dei LED)
millefori
mammut (usati come supporto a scorrimento – vedi foto)
pezzi metallici per blocco insegna (ho usato delle punte da saldatore)

Vi state chiedendo perché ho usato i mammut e le punte da saldatore?
Perché nel magazzino della scuola ho trovato una scorta infinita e quindi mi sembrava uno spreco non usarli 🙂

Continua a leggere→

Pilotare una matrice di led con una tastiera PS2

Lascia una risposta

Poiché in ambito didattico mi occupo anche di probematiche legate alla formazione di allievi diversamente abili ho la necessità di realizzare nelle prossime settimane per un allievo un dispositivo che mi permetta di scrivere del testo su un display molto grande, il testo deve poter essere scritto mediante una normalissima tastiera PS2, stavo incominciando a progettare il dispositivo, quando una ricerca su web mi ha regalato la soluzione e guarda caso proprio su uno dei miei siti preferiti instructables, fonte di ispirazione per moltissimi miei esperimenti. Il progetto che mi risolverà il problema è: PS/2/You: Go-anywhere, LED digital message board
Nel progetto sono stati uniti insieme tre matrici di led per un totale di 768 led, una tastiera PS2, un microcontrollore Ardweeny (è dotato di un ATmega328 e lo si programma come Arduino, per il montaggio del kit seguite il link).
Probabilmente io sostituirò Ardweeny con un Arduino nano perché è già in mio possesso. Vi allego il video che mostra il funzionamento del dispositivo.

Related posts:

Related posts:

Related posts:

Related posts:

Related posts: