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

mercoledì 11 novembre 2020

Arduino N° 68 - Sensore Luci temporizzate - retriggerabile

< Arduino N° 67 

 Achille De Santis

 > Arduino N°  69


Interruttore per luci temporizzate. Premendo l'interruttore, verso la fine del tempo di accensione, il dispositivo fa ripartire la temporizzazione senza spegnere le luci.


Fig, 1: la scheda di prova;
Fig. 2: collaudo dello sketch su modulo a led;


   






/*  ------
















----------- Inizio programma -----------------------------------------
 * Sensore Luci temporizzate - retriggerabile
 * Achille De Santis 03-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 - retriggerabile - "); 
  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("\nTemporizzatore ON\t"); 
      digitalWrite(U,HIGH);
      delay(T1); 
      S=digitalRead(sensore);
      if (S==true) 
        { digitalWrite(U,LOW);  Serial.print("OFF");  }
    }
}
// -------------------------- Fine programma --------------------------------------



Simulazione: Multivibratore Monostabile,


Argomenti correlati: 


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ì 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ì 15 aprile 2020

Arduino N° 45 - Luci psichedeliche a LED V2.0





< Segue da Arduino N°  44             

 Achille De Santis

> Arduino N° 46


            






Con questo sketch è possibile pilotare una striscia LED RGB alimentata a 12 volt.
Potete provare il funzionamento del programma predisponendo un solo LED RGB a catodo comune, opportunamente polarizzato, su una piccola breadboard. Un potenziometro in ingresso al segnale di bassa frequenza serve a regolare la sensibilità del dispositivo e ad adattarlo al livello audio.

Poiché molte strisce LED operano a logica negata, serve uno stadio separatore a transistori in configurazione invertente, a tre canali. Il positivo di alimentazione a 12 volt sarà collegato alla linea di ingresso, mentre le tre linee RGB andranno collegate alle uscite (open collector) del driver a BJT.




/* ----------------------------- Inizio Programma ---------------------------------------
 * prof. Achille De Santis  19-01-2020
 * Variazione continua del colore di un LED RGB a catodo comune
 * o di una striscia LED ad anodo comune con driver a BJT
 * Luci psichedeliche a LED V2.0
 * le uscite utilizzate DEVONO essere PWM.
 * -------------------------------------------------------------------------------------------
*/

// ------------ Ingresso analogico ---------------
#define BF   A2
// -----------------------------------------------
// -------- uscite PWM per il LED RGB -----------------
#define ROSSO   10
#define VERDE   11
#define BLU     9
// --------------------------------------------------------------

const int T1=200;                       // tempo di transizione colore
int segnale=0,     segnale2=0;          // inizializza le variabili
int soglia1=20,    soglia2=30;          // ------ valori di soglia per i colori ---------
// -------------------------------------------------------------------------------------------

void coefficienti(int a,int b,int c)  { analogWrite(ROSSO,a); analogWrite(VERDE,b); analogWrite(BLU,c); }

void test()             // routine di prova dei colori.
  {
    coefficienti(255,0,0); delay(500);   coefficienti(0,255,0); delay(500);
    coefficienti(0,0,255); delay(500);   coefficienti(0,0,0); delay(1000);
  }

void intestazione()
  { Serial.println(" ----------------------------------------------\n - Autore: Tecnatron - ing. Achille De Santis -");
    Serial.println(" - Variazione continua della luminosità       -\n - per LED RGB a catodo comune CK             -");
    Serial.println(" - ingresso analogico: A2                     -\n - uscite PWM usate:  D11, D10, D9   V2.0     -");
    Serial.println(" ----------------------------------------------");
  }

void setup()
  {
    Serial.begin(9600);                                         // velocità seriale di comunicazione
    pinMode(BF, INPUT),                                   // imposta il pin come input per il segnale audio
    pinMode(VERDE, OUTPUT), (BLU, OUTPUT), (ROSSO, OUTPUT);   // imposta i pin di uscita
    digitalWrite (VERDE, LOW), (BLU, LOW), (ROSSO, LOW);      // inizialmente, led RGB spento;
    intestazione();    test();
  }

void loop()
  {
    segnale=analogRead(A2);
    segnale2=map(segnale,0,1023,0,255); //
    if (segnale2<soglia1)                      { analogWrite(ROSSO, segnale2); }
    if (segnale2>=soglia1 & segnale2<soglia2)  { analogWrite(VERDE, segnale2); }
    if  (segnale2>=soglia2)                    { analogWrite(BLU, segnale2); }
    // delay(100);
    coefficienti(0,0,0);
 }
// ----------------------------- Fine Programma ---------------------------------------



Simulazione:


Argomenti correlati:


> Arduino N° 46

giovedì 19 marzo 2020

Bike Light Generator

Generatore elettrico per bicicletta.
Il generatore è integrato nel mozzo della ruota anteriore; non richiede molta potenza meccanica ed è completo di una piccola batteria di accumulo che può mantenere accese le luci anche quando si è fermi. Può anche ricaricare piccoli dispositivi USB.

mercoledì 13 novembre 2019

Arduino N° 23 - Fader per canali RGB

< Arduino N° 22

 Achille De Santis

> Arduino N° 24




Gestione proporzionale PWM dei colori per un LED RGB a "catodo comune".
Lo sketch produce lo spegnimento progressivo dei LED (affievolimento).

Con facili modifiche è possibile ottenere l'accensione progressiva di ogni colore, lo spegnimento progressivo, il lampeggio, la miscelazione dei colori primari ecc...
I colori "primari" Rosso, Verde, Blu permettono di generare tutti gli altri colori, compreso il bianco, con opportuni coefficienti.

/* ------------------- Inizio Programma ----------------------------------------------------------------
 * Achille De Santis
 * fader per canali RGB  - V2.0 del 02-07-2019
 * collegare i LED con una resistenza, in serie, da 470 Ohm.
*/

// ------------- I/O -----------
#define VERDE   9
#define BLU     10
#define ROSSO   11
// -----------------------------

int delayTime = 20;

void setup()
  {
    pinMode(VERDE, OUTPUT);
    pinMode(BLU, OUTPUT);
    pinMode(ROSSO, OUTPUT);
 
  }

void accenditutto()
  {
    analogWrite(VERDE, 255);
    analogWrite(BLU, 255);
    analogWrite(ROSSO, 255);
  }

void spegni(int colore)
  {
    for (int i=0; i<255; i++)
     {
      analogWrite(colore, 255-i);
      delay (delayTime);
     } 
  }
 
void loop()
   { 
      accenditutto();
      spegni(VERDE); 
      spegni(BLU);
      spegni(ROSSO);
   }
 // ---------------------- Fine Programma -------------------------------------------------------------


Simulazione:
Fader per RGB a catodo comune
Fader per RGB ad anodo comune
Controllo di accelerazione per motore in DC con PWM


Arduino N° 24

mercoledì 25 settembre 2019

Arduino N° 16 - Luci sequenziali 8 canali - avanti/indietro

< Arduino N° 15

 Achille De Santis

> Arduino N° 17




Questo sketch fa accendere in sequenza le uscite, una per volta, avanti e indietro.

Per commutazioni rapide, in continua, si consiglia l'uso di moduli MOSFET in uscita.

Per carichi maggiori, a corrente alternata, è possibile inserire in uscita un banco di 8 relé sulle cui uscite collegare i carichi di potenza.
Attenzione all'isolamento!


/* ---------------------Inizio Programma ----------------------------------------
  Comando luci sequenziali 8 canali, avanti/indietro
  30-12-2018 V.2.1
  Programma di Achille De Santis
*/

// uscite: da D2 a D9

const int T= 100;
int i;

void setup()
  {
    for(i=2; i<=9; i++)
    {pinMode(i, OUTPUT);}
  }

void accendi(int pin)  {digitalWrite(pin, HIGH);    }       // eccito il relè collegato al pin
void spegni(int pin)   {digitalWrite(pin, LOW);    }        // rilascio il relè collegato al pin
void commuta(int k)  { accendi(k); delay(T); spegni(k);  }

void sequenza_avanti()
  {  for (i=2; i<=9; i++)  {commuta(i);}    delay(T);  }
void sequenza_indietro()
  {  for (i=9; i>=2; i--)   {commuta(i);}    delay(T);  }

void loop()
  {
    sequenza_avanti();
    sequenza_indietro();
  }
// --------------------- Fine Programma -----------------------------------------------------------------



Simulazione: 

mercoledì 7 agosto 2019

Arduino N° 9 - Effetto Alba/Tramonto


< Arduino N° 8

 Achille De Santis

> Arduino N° 10


Effetto Alba/Tramonto, con l'uso di una uscita analogica ed una piccola routine che viene richiamata per effettuare le variazioni di luminosità
Collegare una resistenza da 470 Ohm in serie ad un LED sull'uscita, verso massa.


/* -----------------Inizio Programma ------------------------
 *  Varia la luminosità di un LED
 *  Uso dei valori analogici di uscita (da 0 a 255)
*/
// ------------------------- I/O ---------------------------------------
#define  LED    9        // definiamo il piedino per il LED
// ----------------------------------------------------------------
const int T1= 20;
const int T2= 1000;    // durata giorno e notte
// ----------------------------------------------------------------
int i=0;                  // definiamo ed inizializziamo il contatore

void varia() // routine che viene richiamata per variare la luminosità
  {
    analogWrite(LED, i);      // assegna il valore a LED
    delay(T1);                       // attesa T1 ms
  }

void setup()
{
  pinMode(LED, OUTPUT);     // LED come uscita
}

void loop()
{
  for (i=0; i<=255; i++)
  { // ciclo da 0 a 255 (affievolimento)
    varia();          // viene richiamata la routine "varia"
                         // contatore up - down
  }
   delay(T2);

  for (i=255; i>=0; i--)
    {    varia();    }
  delay(T2);
}

// ---------------- Fine Programma -------------------------

Simulazione: 

Effetto Alba/Tramonto


Argomenti correlati:

Fader per canali RGB

> Arduino N° 10

mercoledì 10 luglio 2019

Arduino - giochi di luce


prof. De Santis

/*
  Achille De Santis - tecnatron@gmail.com
 questa semplice funzione è comoda nei giochi di luce e nell'uso di led RGB per la transizione di  colore.
*/

// per accendere LED2: commuta(LED1,  LED2);
// per accendere LED1: commuta(LED2, LED1);

void commuta(int a, int b) //funzione per la transizione ON/OFF di colore
{
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH); 
}
// ------------------------------------------------------------------

Argomenti correlati:

LED Rotanti
Luci sequenziali 8 canali avanti/indietro

Arduino N° 5 - LED rotanti


 Achille De Santis








/* ------------- Inizio Programma -------------------------------

 - da un'idea del prof. A. De Santis
  ----------------------------------------------
  Collegare i 5 LED sui piedini 13, 12, 11, 10, 9 di Arduino, con catodo a massa tramite resistenza da    220 Ohm.
  Uso delle funzioni "annidate".
 */

// ------------------- piedini di I/O ---------------------
#define led1  13
#define led2  12
#define led3  11
#define led4  10
#define led5  9
// ---------------------------------------------------------

const int T1=500, T2=500;

void setup()
{             
  // inizializza i pin digitali
    pinMode (led1, OUTPUT);
    pinMode (led2, OUTPUT);
    pinMode (led3, OUTPUT);
    pinMode (led4, OUTPUT);
    pinMode (led5, OUTPUT); 
}

void accendi(int led)                            // accensione del led generico
          {  digitalWrite(led, HIGH); delay(T1); }

void spegni (int led)                            // spegnimento del led generico
         { digitalWrite(led, LOW); delay(T2);   }

void commuta (int A, int B)               //accensione di un LED e spegnimento di un altro
         {   spegni(A);  accendi(B);   }

void loop()
{
  commuta(led1, led2);
  commuta(led2, led3);
  commuta(led3, led4);
  commuta(led4, led5);
  commuta(led5, led1);
}

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

LED Rotanti

> Arduino N°6