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° 37 - Beacon Fonia/CW per Trasmettitore LPD

Arduino n° 36

Achille De Santis

> Arduino n° 38

I piccoli moduli per applicazioni IoT a corto raggio funzionano con una particolare tecnica di trasmissione in cui la portante viene attivata dalla stessa modulante.

Un problema è rappresentato dal valore a riposo della modulante: diretto o invertito.
In considerazione delle caratteristiche circuitali, molto spesso si trovano in commercio moduli trasmittenti con modulante inversa, cioè con tensione alta a riposo, un po' come avviene per la codifica di canale per quanto riguarda i segnali di Mark e Space.

Un altro problema è rappresentato dal "ritmo" dei bit di dati che si susseguono nella modulante. Infatti, mancando il comando di PTT, la portante deve essere abilitata dal ritmo di modulazione, che deve avere un determinato duty-cycle, compatibile con il mantenimento in trasmissione. Lunghe sequenze di "zero" tenderebbero a far disabilitare la portante.

Il programma qui proposto lavora a modulante inversa ed è adatto a molti moduli in commercio che usano questa tecnica.


/* --------------------------- Inizio programma -------------------------------------------------
  Achille De Santis V2.0 del 12-12-2014 V3.0 del 13-12-2015
  V4.0 del 13-12-2016. V5 del 28-10-2019
  Beacon RDF CW Multiplo, con 5 messaggi pre-selezionabili.
  1 linea di uscita per la spia di TX;
  1 linea di uscita per il testo CW_BF, invertita.
  5 testi beacon, in uscita, selezionabili alternativamente;
  pin 13: uscita del testo beacon;
  pin 12: spia di portante;
  senza comando di PTT.
*/

// ------------------- I/O -----------------------------------------------
#define U     13        // Uscita testo beacon sul piedino 13.
#define ptt   12        // comando PTT sul piedino 12.
// -----------------------------------------------------------------------
// ------------------ Selezione del beacon --------------------------
#define beaconset1    11
#define beaconset2    10
#define beaconset3    9
#define beaconset4    8
#define beaconset5    7
// ----------------------------------------------------------------------

const int freq = 800;
const int T = 100;            // base tempi.
const int T2=2*T;
const int T3=3*T;
const int T4=4*T;
const int T5=5*T;
const int T6=6*T;
const int T7=7*T;

void intestazione()
  { // Serial.begin(9600);        // velocità seriale
    Serial.println(" ________ Tecnatron Creation ___________");
    Serial.println(" Beacon Fonia/CW per Trasmettitore LPD  --");
    Serial.println(" prof. Achille De Santis - 27-10-2019 ----------");
  }
 
void genera(int T1)   { tone(U, freq); delay(T1);   noTone(U); delay(T);  }
void punto()          { genera(T); }
void linea()          { genera(T3); }

void AR() { punto();linea();punto();linea();punto();delay(T6); }  // AR - messaggio iniziale di accensione Beacon

void MO()
{
  linea(); linea();                 delay (T2);            // M
  linea(); linea(); linea();    delay (T2);            // O
}

void beacon1()  { punto(); linea(); linea(); linea(); linea(); delay (T4); }   // 1
void beacon2()  { punto(); punto(); linea(); linea(); linea(); delay (T4); }   // 2
void beacon3()  { punto(); punto(); punto(); linea(); linea(); delay (T4); }   // 3
void beacon4()  { punto(); punto(); punto(); punto(); linea(); delay (T4); }   // 4
void beacon5()  { punto(); punto(); punto(); punto(); punto(); delay (T4); }   // 5

void setup()
{
 Serial.begin(9600);            // serial monitor output
 intestazione();

 pinMode (U, OUTPUT),   // uscita tono
         (ptt, OUTPUT);         // uscita PTT

 pinMode (beaconset1, INPUT_PULLUP),  // set di messaggi
         (beaconset2, INPUT_PULLUP),
         (beaconset3, INPUT_PULLUP),
         (beaconset4, INPUT_PULLUP),
         (beaconset5, INPUT_PULLUP);

 digitalWrite(U, HIGH);     delay (T7);
 AR();                           // - messaggio iniziale di accensione Beacon
 digitalWrite(U, HIGH);     delay (T3);
}

void loop()
{
  digitalWrite(ptt, HIGH);      // indicatore di trasmissione, opzionale
                                // digitalWrite(U, HIGH);     delay (T5);
  MO();
  if (digitalRead(beaconset1)==LOW)   {beacon1();  }
    else if (digitalRead(beaconset2)==LOW)   {beacon2();  }
           else if (digitalRead(beaconset3)==LOW)   {beacon3();  }
                 else if (digitalRead(beaconset4)==LOW)   {beacon4();  }
                     else if (digitalRead(beaconset5)==LOW)   {beacon5();   } 
  delay (T4);
  digitalWrite(ptt, LOW);
  digitalWrite(U, HIGH); 
  delay (50*T);
 }
// ----------------------------- Fine programma --------------------------------------------------

Simulazione: 

Beacon per ARDF - selezionabile - modulante inversa

Argomenti correlati:

Arduino N° 3 - Beacon CW OOK Arduino N° 1 - Semplice beacon per caccia alla volpe Beacon ARDF – UHF - conversione di RS41-SG

> Arduino n° 38

Arduino N° 36 - Sirena Italiana

                           

< Arduino N° 35

Achille De Santis

> Arduino n° 37

Sirena tipo "Italiana", modulata in modo continuo utilizzando la funzione predefinita "tone" di Arduino.  Un interruttore di ingresso abilita/disabilita il funzionamento.
Sull'uscita è disponibile un segnale pseudo-sinusoidale che, con un condensatore di accoppiamento, si potrebbe iniettare su un amplificatore di BF con uscita su altoparlante a tromba.


/* --------------- Inizio Programma ------------------
  Achille De Santis  17-10-2019 "Sirena Italiana"
  V1.0 in data 17-10-2019.
  ---------------------------------------------------------
*/

// -------------- I/O ---------------------------------------------------------------------------------
#define Led_Red     11    // uscita ausiliaria per LED
#define out              13    // uscita BF
#define SW              8     // interruttore di ingresso (abilitazione sirena verso massa)
// -----------------------------------------------------------------------------------------------------
const int f1 = 392;
const int f2 = 660;
// --------------------------
const int T1=1;
const int T2=100;
int f;
bool S=true;

  // non è richiesta la dichiarazione di variabili int o long per la funzione "tone"

void setup()
{
  intestazione();
  pinMode(SW, INPUT_PULLUP);
  pinMode(Led_Red, OUTPUT);
  // non richiede setup la funzione "tone"
}

void intestazione()
  { Serial.begin(9600);        // velocità seriale di comunicazione
    Serial.println(" _________ Tecnatron Creation ___________");
    Serial.println(" Sirena tipo Italiana                   ___________");
    Serial.println(" prof. Achille De Santis - 17-10-2019  V1.0 .--");
  }

void tono(int F)  // generazione tono
{  tone(out, F);  delay(T1); }

void loop()
{
  S=digitalRead(SW);
  switch(S)
  {
    case 0:
     {digitalWrite(Led_Red, HIGH);
      for (f=f1; f<=f2; f++)      {  tono(f);  delay(T2);  }           // Primo tono ascendente  da 392 Hz
      for (f=f2; f>=f1; f--)        {  tono(f);  delay(T2);  }           // Secondo tono discendente da 660 Hz
      break;
     }
    default:  { noTone(out); digitalWrite(Led_Red, LOW); }   // spegne la sirena
  }
}
// ------------------------------- Fine programma --------------------------------------------------



Simulazione: Sirena Italiana

Argomenti correlati: Sirena "Bitonale"


> Arduino n° 37

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° 33 - Pilotaggio di un relay con driver a BJT

> Arduino N° 36