Visualizzazione post con etichetta Lampeggiatore. Mostra tutti i post
Visualizzazione post con etichetta Lampeggiatore. Mostra tutti i post

mercoledì 20 gennaio 2021

Arduino N° 78 - Led ciclici temporizzati con potenziometro

< Arduino N°  77

 Achille De Santis

> Arduino N°  79


Foto 1: collaudo dello sketch;
Tre led vengono accesi ciclicamente con una durata di tempo impostabile dinamicamente attraverso una tensione rilevata su un potenziometro. 

Nello sketch, i led predisposti come esempio sono soltanto tre ma è possibile espandere opportunamente il listato e comandare tutti i led già inseriti sullo schema (v. foto 1). Questa operazione è resa semplice con l'uso della routine già impostata.

Utilizzando numerose uscite è possibile e più conveniente modificare l'impostazione dello sketch inserendo delle variabili indicizzate, richiamabili attraverso un vettore. 

Lascio al lettore l'onere e l'onore della modifica.


Lo sketch e la simulazione del circuito sono disponibili per l'analisi e il download.


Simulazione:   


LED Temporizzati con potenziometro

LED Temporizzati con potenziometro_V2




tecnatronATgmail.com


> Arduino N°  79


mercoledì 23 dicembre 2020

Arduino N° 74 - Albero di Natale


< Arduino N°  73

 Achille De Santis

> Arduino N°  75




Fig. 1: verifica su scheda di prova;

    

    Sotto Natale non poteva mancare un semplice programma per il comando delle luci del tradizionale albero natalizio o anche del più classico presepe.
     In questo caso, il dispositivo è sviluppato su tre sezioni di uscita per le luci, ognuna facente capo ad un transistore utilizzato come interfaccia pilota, per dispensare l'Arduino dalla erogazione di tutta la corrente assorbita dai led. 
    Cambiando il tipo di transistore ed aumentandone la portata in corrente sarà anche possibile espandere il numero di led di uscita da collegare, in questo caso, a gruppi di tre led con relativa resistenza di polarizzazione. Basta replicare un settore come quelli già inseriti, da disporre in parallelo su quelli esistenti.

Il primo circuito  viene mostrato nella simulazione Albero di Natale.

Un secondo dispositivo di viene mostrato nella simulazione Luci natalizie e prevede una serie di led ad accensione pseudo-casuale.

Quello che manca è un opportuno circuito di interfaccia atto ad aumentare la portata in corrente. Potete avere un'idea del circuito da realizzare visonando la pagina al link riportato nelle simulazioni.
  
Con questo vi saluto augurandovi buon lavoro e buon divertimento.


Argomenti correlati:
Arduino N° 50 - Modulo di prova per 6 uscite digitali

Simulazione:  
Albero di Natale
Albero di Natale con Arduino



> Arduino N°  75

mercoledì 9 dicembre 2020

Arduino N° 72 - Lampeggio LED N volte per T millisecondi

< Arduino N° 71 

 Achille De Santis

 > Arduino N°  73

Fig. 1: collaudo della routine;


Questa funzione permette di velocizzare la stesura di un programma nel caso si debbano gestire più led con una temporizzazione e una ripetizione multipla.

La routine non è nulla di eccezionale ma è direttamente fruibile su un programma molto più complesso e permette al programmatore di concentrarsi sulle parti essenziali del programma da sviluppare.

Inoltre, permette all'iniziando di comprendere l'uso delle "routines"

e l'organizzazione delle stesse.



Simulazione: 

Lampeggio LED N volte per T millisecondi.


tecnatronATgmail.com


> Arduino N°  73

mercoledì 2 dicembre 2020

Arduino N° 71 - Uso della definizione LED_BUILTIN

< Segue da Arduino N° 70  

 Achille De Santis

> Arduino N°  72


Fig. 1: valutazione della funzione su scheda di prova;
La funzione predefinita LED_BUILTIN permette di definire in modo implicito il piedino della scheda Arduino riferito al  led collegato a bordo scheda. Non tutti i tipi di schede hanno il led collegato allo stesso piedino; Arduino UNO usa il piedino D13 ma altre schede possono avere collegamenti diversi, che occorre conoscere. In alternativa, si può utilizzare questa "definizione" generica che assegna in modo automatico il piedino collegato al led a bordo scheda.

Questa funzione risulta molto comoda ed aumenta la "portabilità" dello sketch sulle varie schede Arduino.




/* ------------------- Inizio programma ---------------------------------------------------------------

  This program blinks pin D13 of the Arduino UNO (the built-in LED)

  Achille De Santis

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

*/


// ------ I/O -------------------------------------------------------------------------------------------------------

#define Led  LED_BUILTIN        // implicitamente è il piedino digitale collegato al led interno

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

void setup()

{  pinMode(Led, OUTPUT);

}

void loop()

{

  digitalWrite(Led, HIGH); // turn the LED on (HIGH is the voltage level)

  delay(2000);  // Wait for 2000 millisecond(s)

  digitalWrite(Led, LOW); // turn the LED off by making the voltage LOW

  delay(1000);  // Wait for 1000 millisecond(s)

} // ---------------------- Fine programma ---------------------------------------------


Nota: non tutte le schede supportano questa istruzione; verificate!


Simulazione: Uso della definizione LED_BUILTIN


Argomenti correlati: Arduino N° 50 - Modulo di prova per 6 uscite digitali


tecnatronATgmail.com


> Arduino N°  72

mercoledì 18 novembre 2020

Arduino N° 69 - Multivibratore astabile senza ritardo

< Segue da Arduino N° 68  

 Achille De Santis

> Arduino N°  70 


Fig. 1: Scheda di collaudo;

Questo sketch permette di utilizzare la temporizzazione con la funzione predefinita "millis()" senza usare la funzione "delay()" che inevitabilmente bloccherebbe l'esecuzione di altre istruzioni fino alla fine del "ritardo" impostato.

In questo modo si realizza un "Multivibratore astabile" senza ritardo nell'esecuzione del programma.

L'organizzazione come "procedura" permette il suo utilizzo in modo rapido e multiplo, semplicemente richiamando la funzione con la relativa variabile.

Facciamo l'esempio di un robot che debba essere comandato via infrarosso o bluetooth; il robot deve muoversi, rispondere ai comandi durante il movimento, accendere qualche luce per un determinato tempo e, contemporaneamente, rispondere ad ulteriori comandi impartiti. Un solo LED che si trovasse a lampeggiare con un tempo piuttosto lungo usando la funzione "delay()" bloccherebbe irrimediabilmente l'esecuzione di importanti comandi, come "svolta a destra", "svolta a sinistra", "stop", rendendo instabile governarne i movimenti.


Questa procedura risolve molto bene il problema menzionato. Basta familiarizzarsi con le poche istruzioni necessarie e assimilarne il principio informatore.

Buon lavoro!


Simulazione:  Multivibratore astabile senza ritardo



> Arduino N°  70 

mercoledì 4 novembre 2020

Arduino N° 67 - Sensore Luci temporizzate

< Arduino N°  66

 Achille De Santis

 > Arduino N°  68



Fig 1: Sensore di luci temporizzate; 
Fig 2: Sensore di luci temporizzate. collaudo; 























Questo firmware implementa un sensore di luci temporizzate, con un controllore ATmega168.
Il temporizzatore si potrebbe realizzare anche a "logica cablata": a transistori, a relay, a logica TTL, CMOS e quant'altro. Non me ne vogliano, quindi, i "puristi" o i nostalgici. Lo "sketch" viene qui presentato come parte ben funzionante da integrare in dispositivi molto più complessi, con un hardware ridotto veramente al minimo.
Buon lavoro! tecnatronATgmail.com



  
/* ------------------- Inizio programma -----------------------------
 * Sensore Luci temporizzate
 * Achille De Santis 02-11-2020
 * Versione 4.0
 * 
*/
// ---------- I/O ----------------------------------------
#define sensore   7        // sensore touch, interruttore 
// -------------------------------------------------------

const int  T0 = 1000;
const int  T1 = 5000;   // millisecondi

bool S; 
int U = 11;             // uscita digitale per comando luci 
int PreviousTime;

void intestazione()
{ Serial.println(" ---------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis         - ");
  Serial.println(" - Sensore Luci temporizzate                  - "); 
  Serial.println(" - Versione 4.0                               - "); 
  Serial.println(" - I/O                                        - ");
  Serial.println(" - D11: uscita                                - ");  
  Serial.println(" - D7: sensore/interruttore attivo basso      - "); 
  Serial.println(" ---------------------------------------------- ");
}

void ManovraLuci(int t)  
  { 
    digitalWrite(U,HIGH);
    delay(t); 
    digitalWrite(U,!digitalRead(U));
  }
  
void setup() 
{
  Serial.begin(9600);      // setto la velocità di comunicazione
  intestazione();          // intestazione, inviata alla seriale
  pinMode(sensore, INPUT_PULLUP); 
  pinMode(U, OUTPUT); 
  ManovraLuci(T0); // prova
}

void loop() 
{  
  S=digitalRead(sensore);               // lettura valore del sensore al tocco.
  while(S==false)  
    { 
      Serial.print("Temporizzatore ON\t"); 
      ManovraLuci(T1);
      Serial.print("OFF\n"); 
      S=digitalRead(sensore);
    }
}
// ----------------------- Fine programma -------------------------------
 


Simulazione: 


Argomenti correlati:

mercoledì 15 luglio 2020

Arduino N° 58 - Pilotaggio intermittente di una uscita digitale

      
< Arduino N°  57

 Achille De Santis

 > Arduino N°  59 




Fig. 1: Modulo di prova;


Pilotaggio intermittente di una uscita digitale, con segnalazione della commutazione attraverso un breve impulso che pilota un cicalino (buzzer).
Il ciclo di commutazione viene abilitato portando a massa il piedino S (switch).
Non occorre resistenza di pull-up, già prevista internamente. 

Il dispositivo non rappresenta nulla di nuovo ma è un esempio di come si possano elaborare nuove applicazioni da cose già note: l'intermittente (o lampeggiatore) , il "buzzer" attivo (o "cicalino"), il circuito universale di prova, il relay.






/* ----------------- Inizio Programma -------------------------------------------
 * Pilotaggio intermittente di un Relay con Arduino
 * Segnalazione tramite Buzzer
 * Uso delle routines per le operazioni elementari ripetitive.
 * Aggiungere il piedino di attivazione del comando!!!!!!!!
 * Se non è necessario il relay, come separatore galvanico, 
 * si può sostituire con un transistore di adeguata potenza.  
 * Achille De Santis - V5.0 del 09-06-2020
 * 
 */
// --------------- I/O -------------------------------
 #define S    6      // ingresso switch
 #define R    13     // Uscita comando relay
 #define B    12     // Uscita comando buzzer
// ---------------------------------------------------

 const int  T1=200, T2=1000;

void intestazione()
{ Serial.println("\n ------------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis        - ");
  Serial.println(" - Comando uscita intermittente     V. 1.0 - "); 
  Serial.println(" - Segnalazione con buzzer                       -"); 
  Serial.println(" --------------------------------------------------\n");
}

void buzz()
{
  digitalWrite(B,HIGH);     // comanda B alto 
  delay(T1);                // attende T1 millisecondi
  digitalWrite(B, LOW);     // comanda B basso 
}

void setup()
{
  pinMode (R,OUTPUT);          // Relay: viene settato il pin R come uscita
  pinMode (B,OUTPUT);          // Buzzer: viene settato il pin B come uscita
  pinMode (S,INPUT_PULLUP);    // Switch: ingresso
  Serial.begin(9600);         // predispongo la velocità di comunicazione
  intestazione();             // intestazione, inviata alla seriale
}

void loop()
{ 
  while (digitalRead(S)==0)
  { 
    digitalWrite(R,1);  buzz(); 
    delay(T2);
    digitalWrite(R,0);
    delay(T2);                  // ritardo, poi il ciclo si ripete
  }
}
// ---------------------- Fine Programma ----------------------------------------




mercoledì 20 maggio 2020

Arduino N° 50 - Modulo di prova per 6 uscite digitali

< Segue da Arduino N°  49 

prof. Achille De Santis

> Arduino N°  51




Fig. 1: il modulo, assemblato su  protoboard.












Questo modulo universale di prova vi permetterà di simulare e controllare rapidamente sei uscite digitali (da D8 a D13), senza dover ogni volta predisporvi dei LED.

L'assorbimento dei LED è di circa 7,4 mA l'uno, ampiamente al di sotto della corrente massima sia della singola uscita che della corrente totale.

Il collegamento a pettine consente una rapida inserzione sul connettore di Arduino relativo alle uscite D8-D13, massa compresa; sono previsti 8 contatti, per comodità di inserzione, ma ne vengono utilizzati soltanto sette; il primo contatto a destra (Vref) è, comunque, predisposto.

Come in figura 1, la piccola breadboard resta libera per gestire le altre parti circuitali.

L'assemblaggio dei componenti è stato eseguito sul lato rame, per un facile inserimento della striscia di contatti e una agevole visualizzazione dei LED.

Volendo, è anche possibile eseguire il lavoro per un montaggio in verticale, con un connettore a pettine, a 90°; in questo caso il montaggio dei componenti si eseguirà sulla faccia isolante.
 
Componenti:

6 x resistori 470 Ohm;
6 x diodi LED rosso, micro
basetta protoboard passo 2.54 mm
connettore a pettine, maschio, 8 contatti passo 2.54 mm.
Conservate i reofori: vi fanno comodo per creare le poche piste necessarie! 


Buon lavoro a tutti!


Argomenti correlati:



> Arduino N°  51

mercoledì 26 febbraio 2020

Arduino N° 38 - Lampeggiatore modulato

< Segue da Arduino N°  37

 Achille De Santis

> Arduino N° 39




Proviamo ad usare le uscite analogiche di Arduino.
In effetti la tensione di uscita non è proprio analogica ma a gradinata, sfruttando la tecnica PWM cioè modulando la larghezza degli impulsi. Si ottiene una tensione di uscita che può essere variata, in qualche modo, con il comando analogWrite().

Il programma qui presentato varia, a due livelli, la luminosità di un LED. I livelli di uscita possono essere 256 (da 0 a 255). In questo caso, sono stati usati i livelli 128 e 255, corrispondenti a circa 5 volt e 2,5 volt di tensione di uscita.
La resistenza in serie al LED può essere da 470 Ohm, il ché limita la corrente massima a circa 10mA.

Il programma può essere anche realizzato come "routine" da richiamare all'interno di un programma principale, ad esempio come spia lampeggiante a due livelli. In questo caso è opportuno modificare la routine facendo uso della funzione "millis", per evitare il blocco del programma principale.


/* ------------------ Inizio programma -----------------------------------------------------------
 * utilizzo della funzione analogWrite() per variare, a step, la luminosità di un LED.
 * Achille De Santis - V2 del 14-11-2019
*/

// ------------------ I/O --------------------------------------------------------
  #define LED 11 // LED collegato al pin digitale 11  (PWM)
// valori di uscita: 255/128
// -------------------------------------------------------------------------------

void intestazione()
{ Serial.println(" ------------------------------------------------------ ");
  Serial.println(" - Autore: Tecnatron - ing. Achille De Santis - ");
  Serial.println(" - Sketch: varia la luminosità di un LED - V.2- ");
  Serial.println(" - il piedino di uscita deve essere un PWM   - ");
  Serial.println(" ------------------------------------------------------- ");
}

void accendi(int L, int V)  {  analogWrite(L, V); delay(500);  }   // accende il LED a tensione variabile.

void setup() 
{
  pinMode(LED, OUTPUT);  // imposta il pin come output
  Serial.begin(9600);              // setto la velocità di comunicazione
  intestazione();                      // intestazione, inviata alla seriale
}       

void loop()
  {
    accendi(LED, 255);        // accende il LED a tensione massima.   
    accendi(LED, 128);        // accende il LED a tensione metà.
  }
// --------------- Fine programma ---------------------------------------------



Simulazione: Lampeggiatore modulato

Argomenti correlati:



> Arduino N° 39

mercoledì 5 febbraio 2020

Arduino N° 35 - Semaforo singolo a tre stati

< Arduino N° 34

 Achille De Santis

> Arduino N° 36




Questo sketch realizza un semaforo singolo a tre stati: Verde, Giallo/Verde, Rosso.
Può essere usato così com'è o rappresentare la base di partenza per lo sviluppo di un semaforo multiplo.

Innanzitutto si definiscono le uscite per il comando delle "lampade" rosso, giallo, verde; poi, le durate di accensione delle singole lampade.

Le routine servono ad organizzare meglio le varie operazioni e sono molto utili anche per espandere lo sketch ad altri gruppi di lampade e realizzare, così, un semaforo a più vie.

Per il pilotaggio delle lampade attuatrici si deve tenere conto della tensione di funzionamento.
La cosa più facile è utilizzare un modulo di interfaccia a tre relais. Si ottiene, così, una ottima separazione del circuito attuatore da quello della logica di comando. Basta utilizzare le uscite N.O. dei relais.

Nota importante! Alcuni moduli hanno il riferimento comune sul positivo di alimentazione; in questo caso è consigliabile utilizzare un transistore BJT come invertitore di fase per il pilotaggio dei relais (v. riferimenti).



/* Programma di simulazione di un semaforo singolo a tre stati
 *  Achille De Santis - V. 2.0 del 29-05-2019
 *
*/
// -------------------------------- I/O ---------------------------------------------------------
#define led_red       0    // red LED su Pin 0 di Arduino
#define led_yellow 1    // yellow LED su Pin 1 di Arduino
#define led_green   2   // green LED su Pin 2 di Arduino
// ----------------------------------------------------------------------------------------------
// ----------- Parametri da cambiare in base alle proprie esigenze ------------
const int TR=2000;  // durata ROSSO
const int TY=1000;  // durata GIALLO
const int TG=3000;  // durata VERDE
// ----------------------------------------------------------------------------------------------

void intestazione()
  { Serial.begin(9600);        // velocità seriale di comunicazione
    Serial.println(" _________ Tecnatron Creation ___________");
    Serial.println(" Semaforo singolo a tre stati       ___________");
    Serial.println(" prof. Achille De Santis - V. 2.0 29-05-2019.--");

  }
void attiva(bool R, bool Y, bool G)             // manovra
{
  digitalWrite(led_red, R);
  digitalWrite(led_yellow, Y);
  digitalWrite(led_green, G);
}

void rosso()   {  attiva(1,0,0);   delay(TR);  }     // durata TR secondi
void giallo()   {  attiva(0,1,1);   delay(TY);   }     //  durata TY secondi
void verde()  {  attiva(0,0,1);   delay(TG);   }     //  durata TG secondi

void setup()
{                              // predispone tutte le uscite
  pinMode(led_red,  OUTPUT);
  pinMode(led_yellow, OUTPUT);
  pinMode(led_green,  OUTPUT);
  intestazione();
}

void loop()
{
  verde();     // commuta GREEN LED
  giallo();     // accende GREEN & YELLOW LED  (giallo/verde)
  rosso();    // commuta RED LED
}
// ---------------------- Fine programma -----------------------------------------------------



Simulazione: Semaforo singolo a tre stati

Argomenti correlati:


> Arduino N° 36

mercoledì 22 gennaio 2020

Arduino N° 33 - Pilotaggio di un relay con driver a BJT

< Arduino N° 32

 Achille De Santis

> Arduino N° 34





Pilotaggio di un relay attraverso uno stadio driver a BJT, in configurazione ad "Emettitore Comune" opportunamente polarizzato.

Un cicalino, escludibile, segnala l'avvenuta attuazione.

Per il dimensionamento dello stadio a transistore BJT, del tipo NPN, vedere la pagina a questo link.

Immettendo i dati indicati in rosso si ottengono i valori dei componenti. Non modificate gli altri campi!

Il transistore NPN può essere un comune BJT per usi generali (BC108, BC109, 2n1711, 2N1613, 2N2222); consigliato il 2N2369 che è ottimo per l'uso in commutazione.

Per carichi notevoli serve un BJT di potenza da utilizzare come stadio finale.

Nota:
Il buzzer NON è un altoparlante ma un cicalino (ronzatore)! L'altoparlante manderebbe in corto-circuito l'alimentazione di Arduino!


/* ------------------------ Inizio Programma -----------------------
 * Pilotaggio intermittente di un Relay con Arduino
 * Segnalazione acustica tramite Buzzer
 * Uso delle routines per le operazioni elementari ripetitive.
 */ ---------------------------------------------------------------------

// --------------- I/O ------------------------------
 #define R 13     // Uscita comando relay
 #define B 12     // Uscita comando buzzer
// --------------------------------------------------

 const int  T1=100,   // ritardo
                 T2=1000,
                 T3=3000;     // ritardo

void setup()
{
  pinMode(R, OUTPUT); // viene settato il pin R come uscita
  pinMode(B, OUTPUT); // viene settato il pin B come uscita
}

void accendi(int r, int b)
{
  digitalWrite(r, HIGH);  // mette R a livello alto facendo andare il BJT in saturazione
  digitalWrite(b, HIGH); // mette B a livello alto facendo suonare il buzzer
  delay(T1);                    // attende T1 millisecondi
}
void spegni(int r, int b)
{
  digitalWrite(r, LOW);  // spegne il bjt, spegne il relè e il buzzer
  digitalWrite(b, LOW);
  delay(T1);                    // ritardo
}
void loop()
{
  accendi(R,B);   delay(100);
  // digitalWrite(B, LOW);    // per segnalazione impulsiva.
  delay(T2);   

  spegni(R,B);    delay(T3);    // ritardo, poi il ciclo si ripete
}

// --------------------- Fine programma -----------------------------



Simulazione: 

Pilotaggio relay con Arduino e driver a BJT;


Argomenti correlati: 

dimensionamento dello stadio a transistore;



> Arduino N° 34


mercoledì 1 gennaio 2020

Arduino N° 30 - Lampeggiatore per indicatori di direzione

< Arduino N° 29

 Achille De Santis

> Arduino N° 31




/* ----------------- Inizio Programma ------------------------------------------------------
  Lampeggiatore "destra e sinistra" per auto/moto/bici; più blinker 4 frecce di emergenza.
  Il programma fa uso di due routine di lampeggio/temporizzazione.
  Realizzato dal prof. Achille De Santis in data 18-07-2019 per i suoi studenti.
*/

// ----- Uscite ----------------------------
#define L1  9   // Linea L1 uscita SX
#define L2  8   // Linea L2 uscita DX
// ----- Ingressi --------------------------
#define S1  3   // linea S1 di ingresso (freccia a sinistra)
#define S2  2   // linea S2 di ingresso (freccia a destra)
#define SB  4  // Blinker 4 frecce
// ----------------------------------------------------------------

const int t1=500;  // durata

void titolo()
{
  Serial.println(" -          Tecnatron Creation                    - ");
  Serial.println(" -          tecnatron@gmail.com               - ");
  Serial.println(" - Lampeggiatore                                   -  ");
  Serial.println(" - per indicatori di direzione                  -  ");
  Serial.println(" ------------------------------------------------ ");
}

void lampeggia(int pin)
{
  digitalWrite(pin, HIGH); delay(t1);
  digitalWrite(pin, LOW); delay(t1);
}

void blinker()
{
  digitalWrite(L1, HIGH);
  digitalWrite(L2, HIGH);
  delay(t1);

  digitalWrite(L1, LOW);
  digitalWrite(L2, LOW);
  delay(t1);
}

 void setup()
 {
  Serial.begin(9600);             // velocità di comunicazione
  titolo();
  pinMode(L1, OUTPUT);
  pinMode(L2, OUTPUT);
 
  pinMode(S1, INPUT_PULLUP);
  pinMode(S2, INPUT_PULLUP);
  pinMode(SB, INPUT_PULLUP);
 }

void loop()
{
  while(digitalRead(S1)==LOW)    { lampeggia(L1); }
  while(digitalRead(S2)==LOW)    { lampeggia(L2); }
  while(digitalRead(SB)==LOW)    { blinker(); }
}
// --------- Fine programma --------------------------------------------------------------



Simulazione: 

Indicatori di direzione


Argomento correlati: 



> Arduino N° 31


NomeQuantitàComponente
Indicatore di direzione1Arduino Uno R3
R2
R4
2470 Ω Resistenza
D1
D2
2Arancione/giallo  LED
S1
S2
S3
1deviatore a zero centrale + 1 switch N.O.