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 ----------------------------------------

Simulazione: 

Comando relay con buzzer

Argomenti correlati:

Lampeggiatore, 
Intermittente, 
Lampeggiatore modulato

Arduino N° 30 - Lampeggiatore per indicatori di direzione
Arduino N° 50 - Modulo di prova per 6 uscite digitali



> Arduino N° 59

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° 30 - Lampeggiatore per indicatori di direzione

> Arduino N° 39

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° 50 - Modulo di prova per 6 uscite digitali

> Arduino N° 31

Nome	Quantità	Componente
Indicatore di direzione	1	Arduino Uno R3
R2 R4	2	470 Ω Resistenza
D1 D2	2	Arancione/giallo  LED
S1 S2 S3	1	deviatore a zero centrale + 1 switch N.O.