Prezzemolo!

era da un po' di tempo che avevo in mente di creare una piattaforma "tiny" multiuso che impiegasse un attiny...ed è nato "prezzemolo". condivido il mio lavoro beneficio di quanti ne possano essere interessati.

beh non ho di certo inventato niente di nuovo, si tratta di una piccola piattaforma basata sul microcontrollore attiny85 che consente, opportunamente programmata, di svolgere operazioni di controllo che prevedano l'accensione di un utilizzatore. 
il punto essenziale di prezzemolo è che esso, grazie alle sue ridotte dimensioni (solo 50x37mm), può trovare agevolmente collocazione praticamente dappertutto, ad esempio all'interno di una cassetta di derivazione presente nell'impianto elettrico e di conseguenza può essere la giusta soluzione in tutte quelle occasioni nelle quali si prevede l'azionamento di un dispositivo funzionante rete 230v (max 1000w) secondo una logica controllata.
ecco una foto del prototipo.
dopo un accurato collaudo ho fatto qualche piccola modifica allo schema per cui la versione attuale è "leggermente" differente da quella nella foto.

esempi di applicazione possono essere:
-   interruttore crepuscolare (fotoresistenza): può essere collegato all'impianto luci esterne di un edificio per regolare la loro accensione/spegnimento secondo soglie programmate.
-   rilevazione movimento crepuscolare (pir + fotoresitenza): può accendere le luci di un ambiente solo in presenza di qualcuno e solo se l'illuminazione ambientale scende sotto una certa soglia.
-   lampeggiatore frequenza regolabile
-   temporizzatore luce scale
-   attivazione di un carico con ritardo: tipica applicazione di questo genere è il motore dell'autoclave che in caso di blackout della rete elettrica, durante il successivo ripristino potrebbe subire danneggiamenti causa delle brusche variazioni della tensione di rete durante la fase di "assestamento".
queste sono solo le prime applicazioni che ho già scritto per "prezzemolo", ma praticamente potrebbe trovare impiego (e posto) dappertutto…proprio come il suo nome suggerisce :-)

per ottenere una dimensione cosi contenuta (50x37mm) è stato necessario rinunciare al classica alimentazione con trasformatore e relativo stabilizzatore di tensione; il dispositivo, infatti, in questo caso viene alimentato  direttamente dalla tensione di rete 230v ac sfruttando la reattanza capacitiva di un condensatore (quello blu nella foto), la tensione è poi stabilizzata tramite uno zener da 5,1v 1w. la corrente erogata è di circa 30ma, sufficiente per alimentare attiny85, un led di segnalazione e l'optoisolatore che comanda il triac (bta06 400v).
l'optoisolatore è un comune fototriac moc3063 che ha al suo interno un circuito di rilevamento dello "zero crossing" garantendo la commutazione del triac solo durante il passaggio dello "zero" di rete e limitando così disturbi introdotti dalla commutazione. e' presente, comunque, anche una piccola rete snubber.

prezzemolo ha tre ingressi disponibili, essi possono essere impiegati come ingressi o uscite, una delle quali è anche utilizzabile come ingresso analogico. questo permette di collegare al dispositivo componenti quali pulsanti, fotoresistenze, pir e sensori di temperatura. inoltre è possibile usare tre ingressi come dip switch per settare impostazioni.
ecco una foto con un sensore mini pir e la fotoresistenza durante la prova dello sketch "rilevazione di movimento crepuscolare"


nonostante la semplicità dello schema elettrico, la sua realizzazione non è assolutamente consigliabile coloro che sono ancora alle prime armi con l'elettronica. si ha che fare, infatti, direttamente con la tensione di rete 230v ed è quindi un circuito potenzialmente pericoloso, ragione per la quale non pubblicherò lo schema elettrico e il relativo assemblaggio.
dato, comunque, che non ho problemi rendere pubblico il mio lavoro, se qualcuno fosse interessato alla realizzazione pubblicherò lo schema ma solo dopo l'autorizzazione del moderatore del forum e/o il benestare degli "anziani" :-)

il codice delle applicazioni, invece, posso pubblicarlo da subito...ma nel post seguente, perchè qui ho già esaurito il limite di lunghezza disponibile :-)

*** interruttore crepuscolare ***

code: [select]


/*
* ** prezzemolo ** applicazione #1: interruttore crepuscolare + luce temporizzata
* ==================================================================================
* hardware: - fotoresistenza collegata su analog1 con resistenza da 10k verso gnd (r4 nello schema)
*           - pulsante collegato su sens1 (switch) lato gnd.
*
* interruttore crepuscolare. due funzionalità:
* 1) accende il carico quando la luce ambientale diminuisce sotto la soglia minima e
*    lo spegne quando la luce aumenta oltre la sogla massima.
* 2) premendo il pulsante si ottiene l'accensione temporizzata del carico (1 min)
*
* funzionamento esclusivo come luce temporizzata
* se si vuol far funzionare il dispositivo solo come "luce temporizzata" (ad esempio per
* utilizzarlo come temporizzatore per luce scala) inserire un jumper in analog1 verso vcc.
*/ 
#define led           3    // fpin 2
#define triac         4    // fpin 3
#define switch        0    // fpin 5 (ingresso sens1)
#define analog1       1    // fpin 7
#define load_on       portb &= ~(1 << ddb4)            // attuatore acceso (uscita stato logico low)
#define load_off      portb |= (1 << ddb4)             // attuatore spento (uscita stato logico high)
#define led_on        portb |= (1 << ddb3)             // led acceso
#define led_off       portb &= ~(1 << ddb3)            // led spento
#define led_toggle    portb ^= (1 << ddb3)             // led toggle

#define photor_port              1
#define photor_time            100                     // tempo di refresh per la lettura della fotoresistenza (ogni 100 ms)
#define photor_num_read          4                     // numero di letture prima di fare la media (ogni 4 letture calcola la media)
#define photor_treshold_light   50                     // soglia per alta luminosità: valori da 1 99
#define photor_treshold_dark    20                     // soglia per bassa luminosità: valori da 1 99
#define switch_time          60000                     // durata del pulsante temporizzato (2 min)

unsigned long current_photor;                          // contatore riservato alla temporizzazione della fotoresistenza
byte photor_value;                                     // valore corrente medio della fotoresistenza
int photor_read;                                       // valore letto dalla porta e totalizzato x la media
byte photor_counter_media;                             // contatore per numero di letture prima della media
boolean photor_flag;                                   // indica se si sono superati valori di soglia (true=buio, false=luce)

boolean switch_flag;                                   // on/off pulsante accensione temporizzata
unsigned long current_switch;                          // contatore riservato alla temporizzazione del pulsante
unsigned long current_led;                             // contatore riservato alla temporizzazione del led (lampeggio durante temporizzazione)


void setup() {   
  pinmode(led, output);                                // definisce uscite:
  pinmode(triac, output);
  pinmode(switch, input);                              // ingresso pulsante per luce temporizzata
  pinmode(analog1, input);                             // ingresso fotoresistenza
  digitalwrite(switch, high);                          // pull per interruttore. e' attivo quando low
  digitalwrite(analog1, low);                          // nessun pull per fotoresistenza
  load_off;                                            // attuatore spento
  lamp(10);                                            // esegue 5 lampeggi del led per segnalare inizializzazione effettuata.
  delay(1000);                                         // attende un secondo...
} 
 
void loop() { 

  /* gestione della fotoresistenza */
   if ( (millis() - current_photor) > photor_time ) {
      current_photor = millis();
      photor_read += analogread( photor_port );
      if (++photor_counter_media == photor_num_read) {
         photor_counter_media = 0;
         // converte valori della fotoresistenza tra 1=buio e 99=max luce
         photor_value = map(photor_read / photor_num_read, 5, 1023, 1, 99);
         photor_read = 0;
         
        // controllo soglia di bassa luminosità: accende e stacca lampeggio
        if ( !switch_flag && !photor_flag && (photor_value <= photor_treshold_dark) ) {
            photor_flag = true;
            load_on;
            digitalwrite(led, high);
        }
        // controllo soglia: spegne; solo se la linea non è occupata
        if ( !switch_flag && photor_flag && (photor_value >= photor_treshold_light) ) {
            photor_flag = false;
            load_off;
            digitalwrite(led, low);
        }       
      }
   }
   
   /* attivazione pulsante luce temporizzata.
      dispositivo di debounce per disturbi nella linea elettrica:
      il pulsante deve essere premuto per almeno 30ms, altrimenti
      viene scambiato per un disturbo della linea e non viene considerato.
      la pressione del pulsante causa un'accensione forzata temporizzata del carico(vedi switch_time)
      un pulsante dev'essere collegato su ingresso sens1 */
   if (!switch_flag && (digitalread(switch) == low)) {     // la pressione del pulsante deve durare almeno 20ms
     delay(30);                                            // aspetta 30 ms
     if ((digitalread(switch) == low)) {                   // se il pulsante è ancora premuto allora...
       switch_flag = true;                                 // abilita temporizzatore e disattiva gestione fotoresistenza
       photor_flag = false;                                // disattiva eventuale attivazione precedente della fotoresitenza
       load_on;                                            // accende attuatore
       current_switch = millis();                          // prepara per la temporizzazione
       current_led = millis();                             // prepara per il lampeggio
     }
   }
   
   // controllo tempo di switch raggiunto
   if (switch_flag) {
     if (millis() - current_switch > switch_time) {         // tempo raggiunto.
       switch_flag = false;                                 // disabilita temporizzatore e riabilita gestione fotoresistenza
       load_off;                                            // spegne attuatore
       led_off;                                             // spegne led
       delay(1000);                                         // aspetta un secondo prima di passare nuovamente alla gestione della fotoresistenza
     }
     else {                                                 // temporizzazione in corso...
        if (millis() - current_led > 200) {                 // lampeggio del led
          current_led = millis();
          led_toggle;
        }
     }
   } 
} 

// esegue n/2 lampeggi del led
void lamp(byte n) {
  (byte i=0; i<n; i++) { 
    led_toggle;
    delay(70);
  }
  led_off;
} 


per chi fosse interessato posso pubblicare anche gli altri sketch...

Arduino Forum > International > Italiano > Generale (Moderator: leo72) > Prezzemolo!

arduino