Costruire centralina luci/tapparelle

[Gabrydark]

Salve a tutti,

la maggior parte di utenti del forum sa che mi piace cimentarmi in imprese di vario tipo, questo piccolo oggettino a BASSO costo è capace di comandare carichi che siano al max 250vac 10A, nel mio caso comanderà faretti 220v a led e un motore tapparella, il tutto con un qualsiasi telecomando IR e noi del forum telecomandi ne abbiamo una quantità indicibile

materiale utilizzato:

- basetta mille fori
- arduino nano (per contenere le dimensioni del progetto)
- scheda relè 5vdc (numero relè variabile)
- fili vari
- morsetti a vite da pcb
- qualche bulloncino + dadino
- una resistenza da 10kohm (se dovete aggiungere un pulsante come nel mio caso)
- strip maschio, strip femmina
- saldatore a penna
- stagno

ovviamente bisogna avere una certa manualità e dimestichezza con le piccole saldature!



per chi non lo sapesse arduino è un progetto italiano OpenSource, che facilita l'approccio all'aspetto elettronico/informatico atto alla realizzazione di progetti interattivi.
Una board che comprende fondamentalmente un certo numero di ingressi/uscite digitali e/o analogiche che possono acquisire valori analogici da sensori (per esempio) o per esempio fornire degli impulsi elettrici per determinare una data azione (azionare un relè per esempio).



effettuare le connessioni:

- la scheda relè viene alimentata a 5vdc, quindi ha 2 contatti per l'alimentazione, vin e gnd che vanno collegati rispettivamente al pin +5v di arduino e al pin gnd di arduino.

- sempre sulla scheda relè avremo un numero di ingressi pari al numero di relè presenti, quindi colleghiamo ogni pin di ingresso relè ai pin di arduino che preferiamo, nel mio caso ho utilizzato i pin 11,10,9,8,7,6,5,4.

- adesso dobbiamo alimentare arduino, andiamo a collegare un morsetto a 2 vie con viti rispettivamente a VIN e GND su arduino, a cui dopo collegheremo un alimentatore VCC 5v-12v da almeno 500mAh.

- colleghiamo adesso il nostro sensore IR, ce ne sono di mille tipi/sigle, il mio l'ho recuperato da un vecchio lettore dvd, sopra il componente a caratteri microscopici (serve una lente di ingrandimento) vi è inciso il modello da cui potrete recuperare il datasheet, ne ho controllati diversi e normalmente la piedinatura è questa: guardiamolo frontalmente, col pallino rivolto verso di noi, 3 piedini, destro alimentazione (molto probabilmente anche qui andranno i 5v), centro GND, sinistra DATI.. quindi colleghiamo il piedino dx ai 5v dell'arduino, il piedino centrale al GND di arduino e il piedino sx lo andiamo a collegare ad un ingresso di arduino (nel mio caso il 2 dei pin digitali). Visto che il sensore andrà molto lontano da arduino, anche qui, ho saldato dei morsetti a cui collegare i cavi che porteranno il segnale del sensore ir..

- se vogliamo aggiungere un pulsante, bisogna collegarlo da un lato sui 5v e da un lato su un pin di arduino, interponendo poi, una resistenza di pulldown da 10kohm tra il pin di arduino e gnd.

adesso viene la parte bella, lo sketch, che in questo caso sono 2:

- il primo sketch serve a catturare i codici che vengono generati dalla pressione dei pulsanti sul nostro telecomando

#include <IRremote.h>

int RECV_PIN = 2; //pin a cui è collegato il sensore IR

IRrecv irrecv(RECV_PIN); // assegniamo la facoltà di ricevere via IR al pin 2 

decode_results results; //variabile risultato

void setup()
{
  Serial.begin(9600);  //avviamo la comunicazione con monitor seriale
  irrecv.enableIRIn(); // inizializziamo il ricevitore IR
}

void loop() {
  if (irrecv.decode(&results)) { // se riceviamo un codice dal telecomando
    Serial.println(results.value, DEC); //scriviamo sul monitor seriale il risultato in formato decimale
    irrecv.resume(); // pronti per ricevere un nuovo valore
  }
  delay(100); // aspetta 100ms e ricomincia il loop
}

una volta catturati tutti i pulsanti del telecomando che vogliamo utilizzare ed averli segnati da qualche parte per non dimenticarli, andiamo a scrivere il programma che ci permetterà di utilizzarli.

[Gabrydark]

non sono un informatico e non sono nemmeno un programmatore esperto ma lo sketch funziona alla perfezione e quindi lo pubblico qui, chiunque abbia domande riguardo qualsiasi aspetto di questo progetto, le scriva qui e cercherò di essere esaustivo per quanto le mie conoscenze permettano

#include <IRremote.h>

#define ACCESO 0
#define SPENTO 1

byte stato_rele_alzatapp = 0; // conserva lo stato rele alza tapparella
byte stato_rele_abbassatapp = 0; // conserva lo stato rele abbassa tapparella
int on1 = 0; 
int on2 = 0;
int on3 = 0;
int on4 = 0;
int on5 = 0;
int on6 = 0;
int buttonstate = 0;
int lastbuttonstate = 0;

const byte RECV_PIN = 2; //pin ricevitore IR
const byte RELE1 = 11; //rele' luce 1
const byte RELE2 = 10; //rele' luce 2
const byte RELE3 = 9; //rele' luce 3
const byte RELE4 = 8; //rele' luce 4 
const byte RELE5 = 7; //rele' luce 5 
const byte RELE6 = 6; //rele' luce 6
const byte RELE7 = 5; //rele' alza tapparella
const byte RELE8 = 4; //rele' abbassa tapparella
const byte BUTTON = 3; //pusalnte all'ingresso

unsigned long lastmillis = millis();
unsigned long lastmillis1 = millis();
unsigned long last = millis();
unsigned long attesa = 10000;
unsigned long attesa1 = 10000;

IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
  delay(1000);
  pinMode(RELE1, OUTPUT);
  pinMode(RELE2, OUTPUT);
  pinMode(RELE3, OUTPUT);
  pinMode(RELE4, OUTPUT);
  pinMode(RELE5, OUTPUT);
  pinMode(RELE6, OUTPUT);
  pinMode(RELE7, OUTPUT);
  pinMode(RELE8, OUTPUT);
  pinMode(BUTTON, INPUT);
  digitalWrite(RELE1, SPENTO);
  digitalWrite(RELE2, SPENTO);
  digitalWrite(RELE3, SPENTO);
  digitalWrite(RELE4, SPENTO);
  digitalWrite(RELE5, SPENTO);
  digitalWrite(RELE6, SPENTO);
  digitalWrite(RELE7, SPENTO);
  digitalWrite(RELE8, SPENTO);
  on1 = SPENTO;
  on2 = SPENTO;
  on3 = SPENTO;
  on4 = SPENTO;
  on5 = SPENTO;
  on6 = SPENTO;
  Serial.begin(9600);
  irrecv.enableIRIn(); // avvio la ricezione IR
}

void loop() {
  
  if(irrecv.decode(&results)) {
    switch(results.value) {
      case 50167935: // tasto 1 (luci)
        if (millis() - last > 250) {
          on1 = !on1;
          digitalWrite(RELE1, on1 ? HIGH : LOW); //accende o spegne
          Serial.println("stato luce 1:  ");
          Serial.println(on1);
        } 
        last = millis();
      break; 
  
    case 50151615: // tasto 2 (luci)
        if (millis() - last > 250) {
          on2 = !on2;
          digitalWrite(RELE2, on2 ? HIGH : LOW); //accende o spegne
        Serial.println("stato luce 2:    ");
        Serial.println(on2);
        } 
        last = millis();
    break;
    
    case 50184255: // tasto 3 (luci)
        if (millis() - last > 250) {
          on3 = !on3;
          digitalWrite(RELE3, on3 ? HIGH : LOW); //accende o spegne
        Serial.println("stato luce 3:    ");
        Serial.println(on3);
        } 
        last = millis();
    break;
    
    case 50143455: // tasto 4 (luci)
        if (millis() - last > 250) {
          on4 = !on4;
          digitalWrite(RELE4, on4 ? HIGH : LOW); //accende o spegne
        Serial.println("stato luce 4:    ");
        Serial.println(on4);
        } 
        last = millis();
    break; 
    
    case 50176095: // tasto 5 (luci)
        if (millis() - last > 250) {
          on5 = !on5;
          digitalWrite(RELE5, on5 ? HIGH : LOW); //accende o spegne
        Serial.println("stato luce 5:    ");
        Serial.println(on5);
        } 
        last = millis();
    break; 
    
    case 50159775: // tasto 6 (luci)
        if (millis() - last > 250) {
          on6 = !on6;
          digitalWrite(RELE6, on6 ? HIGH : LOW); //accende o spegne
        Serial.println("stato luce 6:    ");
        Serial.println(on6);
        } 
        last = millis();
    break; 
    
    case 50157735: // tasto alza tapparella
      stato_rele_alzatapp = LOW;
      stato_rele_abbassatapp = HIGH;
      digitalWrite(RELE7, stato_rele_alzatapp); // accende il rele' di salita
      digitalWrite(RELE8, stato_rele_abbassatapp); //mi assicuro che sia spento il rele' di abbassamento
      lastmillis = millis();
      Serial.print("la tapp si alza:   ");
      Serial.println(millis());
    break;
    
    case 50165895: // tasto abbassa tapparella
      stato_rele_abbassatapp = LOW;
      stato_rele_alzatapp = HIGH;
      digitalWrite(RELE8, stato_rele_abbassatapp); 
      digitalWrite(RELE7, stato_rele_alzatapp);
      lastmillis1 = millis();
      Serial.print("la tapp si abbassa:    ");
      Serial.println(millis());
    break;
 
    case 50153655: // tasto rosso spegne tutte le luci
        if (millis() - last > 250) {
          on1 = SPENTO;
          on2 = SPENTO;
          on3 = SPENTO;
          on4 = SPENTO;
          on5 = SPENTO;
          on6 = SPENTO;
          digitalWrite(RELE1, SPENTO); //spegne 
          digitalWrite(RELE2, SPENTO); //spegne
          digitalWrite(RELE3, SPENTO); //spegne 
          digitalWrite(RELE4, SPENTO); //spegne
          digitalWrite(RELE5, SPENTO); //spegne 
          digitalWrite(RELE6, SPENTO); //spegne
          Serial.println("spengo tutto");
        } 
        last = millis();
    break;
    
    } // end switch
    
  irrecv.resume(); // Receive the next value
  }  // end if 
  
  buttonstate = digitalRead(BUTTON); // immagazzino il valore di button
  if (buttonstate != lastbuttonstate) { //se lo stato button è diverso dal precedente
    buttonstate = lastbuttonstate;
    delay(250);
    if (on1 == 0 || on2 == 0 || on3 == 0 || on4 == 0 || on5 == 0 || on6 == 0) { //se una delle due variabili ha valore 0
      digitalWrite (RELE1, SPENTO); // spegni rele1
      digitalWrite (RELE2, SPENTO); // spegni rele2
      digitalWrite (RELE3, SPENTO); // spegni rele3
      digitalWrite (RELE4, SPENTO); // spegni rele4
      digitalWrite (RELE5, SPENTO); // spegni rele5
      digitalWrite (RELE6, SPENTO); // spegni rele6
      Serial.print ("on1:   ");
      Serial.println (on1);
      Serial.print ("on2:  ");
      Serial.println (on2);
      Serial.print ("on3:   ");
      Serial.println (on3);
      Serial.print ("on4:  ");
      Serial.println (on4);
      Serial.print ("on5:   ");
      Serial.println (on5);
      Serial.print ("on6:  ");
      Serial.println (on6);
      on1 = SPENTO;
      on2 = SPENTO;
      on3 = SPENTO;
      on4 = SPENTO;
      on5 = SPENTO;
      on6 = SPENTO;
      
    }
    
  else {
      digitalWrite (RELE1, ACCESO); // accendi rele1
      digitalWrite (RELE2, ACCESO); // accendi rele2
      digitalWrite (RELE3, ACCESO); // accendi rele3
      digitalWrite (RELE4, ACCESO); // accendi rele4
      digitalWrite (RELE5, ACCESO); // accendi rele5
      digitalWrite (RELE6, ACCESO); // accendi rele6
      Serial.print ("on1:   ");
      Serial.println (on1);
      Serial.print ("on2:  ");
      Serial.println (on2);
      Serial.print ("on3:   ");
      Serial.println (on3);
      Serial.print ("on4:  ");
      Serial.println (on4);
      Serial.print ("on5:   ");
      Serial.println (on5);
      Serial.print ("on6:  ");
      Serial.println (on6);
      on1 = ACCESO;
      on2 = ACCESO;
      on3 = ACCESO;
      on4 = ACCESO;
      on5 = ACCESO;
      on6 = ACCESO;
    }
     
  } //end if di controllo buttonstate
  
  
  if ((millis() - lastmillis) >= attesa) {
    lastmillis = millis();
    if (stato_rele_alzatapp == LOW) {
      stato_rele_alzatapp = HIGH;
      digitalWrite(RELE7, stato_rele_alzatapp);
      Serial.print("la tapparella ha smesso di alzarsi   ");
      Serial.println(millis());
    }
  }
  
  if ((millis() - lastmillis1) >= attesa1) {
    lastmillis1 = millis();
    if (stato_rele_abbassatapp == LOW) {
      stato_rele_abbassatapp = HIGH;
      digitalWrite(RELE8, stato_rele_abbassatapp);
      Serial.print("la tapparella ha smesso di abbassarsi    ");
      Serial.println(millis());
    }
  }
 
} //end loop

il programma, col telecomando della mia tv (che ho usato sperimentalmente), mi permette di accendere 6 luci diverse (o gruppi di luci), cliccando sui tasti 1,2,3,4,5,6, primo click accendo, secondo click spengo. Tasto rosso spegne tutte le luci accese a prescindere dal numero di esse. I tasti Vol+ e Vol- portano su o giù la tapparella, il relè viene automaticamente diseccitato dopo 10secondi (la tapparella avrà già raggiunto i fine corsa).
Infine il pulsante che utilizzerò a parete, accende tutto o spegne tutto.
Spero di aver fatto cosa utile.
Saluti!

[jossi11poesie]

Ottimo ed interessante.
ma poi questa scheda dove va posizionata?

[Gabrydark]

io la inserisco nella scatola di derivazione ove si raccolgono tutti i cavi dei faretti e l'alimentazione della tapparella.. chiaramente il sensore IR va portato li dove vuoi puntare il telecomando

[Gabrydark]

aggiungo la versione definitiva del codice, più elegante e completa

#include <IRremote.h>

#define ACCESO 0
#define SPENTO 1

byte stato_rele_alzatapp = 0; // conserva lo stato rele alza tapparella
byte stato_rele_abbassatapp = 0; // conserva lo stato rele abbassa tapparella
byte on[]={0,0,0,0,0,0,0}; // 
byte buttonstate = 0;
byte lastbuttonstate = 0; 

const byte RECV_PIN = 2; //pin ricevitore IR
const byte pinReleLuci[]={0,11,10,9,8,7,6}; // pin rele' luci
const byte pinReleTapp[]={0,5,4}; //pin rele' tapparella
const byte BUTTON = 3; //pulsante all'ingresso

unsigned long lastmillis = millis();
unsigned long lastmillis1 = millis();
unsigned long last = millis();
unsigned long attesa = 10000;
unsigned long attesa1 = 10000;

IRrecv irrecv(RECV_PIN);
decode_results results;

void stampaON() {
  Serial.print ("on1:   ");
    Serial.println (on[1]);
    Serial.print ("on2:  ");
    Serial.println (on[2]);
    Serial.print ("on3:   ");
    Serial.println (on[3]);
    Serial.print ("on4:  ");
    Serial.println (on[4]);
    Serial.print ("on5:   ");
    Serial.println (on[5]);
    Serial.print ("on6:  ");
    Serial.println (on[6]);
}

void GestioneLuce(int nluce) { 
  on[nluce] = !on[nluce];
  digitalWrite(pinReleLuci[nluce], on[nluce] ? HIGH : LOW); //accende o spegne
  Serial.print("stato luce "); Serial.print(nluce); Serial.println(":    ");
  Serial.println(on[nluce]);
} 

void setup() {
  delay(1000);
  for(int i=0; i<=6; i++) 
  { pinMode(pinReleLuci[i], OUTPUT);
    digitalWrite(pinReleLuci[i], SPENTO);
    on[i]=SPENTO;
  }
  for(int x=0; x<=2; x++)
  { pinMode(pinReleTapp[x], OUTPUT);
    digitalWrite(pinReleTapp[x], SPENTO);
  }    
  
  pinMode(BUTTON, INPUT);
  Serial.begin(9600);
  irrecv.enableIRIn(); // avvio la ricezione IR
}

void loop() {
  if(irrecv.decode(&results)) {
    switch(results.value) {
      case 50167935: // tasto 1 (luci)
        if (millis() - last > 250) {
          GestioneLuce(1);
        } 
        last = millis();
      break; 
  
    case 50151615: // tasto 2 (luci)
        if (millis() - last > 250) {
          GestioneLuce(2);
        } 
        last = millis();
    break;
    
    case 50184255: // tasto 3 (luci)
        if (millis() - last > 250) {
          GestioneLuce(3);
        } 
        last = millis();
    break;
    
    case 50143455: // tasto 4 (luci)
        if (millis() - last > 250) {
          GestioneLuce(4);
        } 
        last = millis();
    break; 
    
    case 50176095: // tasto 5 (luci)
        if (millis() - last > 250) {
          GestioneLuce(5);
        } 
        last = millis();
    break; 
    
    case 50159775: // tasto 6 (luci)
        if (millis() - last > 250) {
          GestioneLuce(6);
        } 
        last = millis();
    break; 
    
    case 50157735: // tasto alza tapparella
      stato_rele_alzatapp = LOW;
      stato_rele_abbassatapp = HIGH;
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp); // accende il rele' di salita
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp); //mi assicuro che sia spento il rele' di abbassamento
      lastmillis = millis();
      Serial.print("la tapp si alza:   ");
      Serial.println(millis());
    break;
    
    case 50165895: // tasto abbassa tapparella
      stato_rele_abbassatapp = LOW;
      stato_rele_alzatapp = HIGH;
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp); 
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp);
      lastmillis1 = millis();
      Serial.print("la tapp si abbassa:    ");
      Serial.println(millis());
    break;

    case 50137335: // tasto blocca tapparella
      digitalWrite (pinReleTapp[1], SPENTO);
      digitalWrite (pinReleTapp[2], SPENTO);
      Serial.println("la tapparella si blocca");
    break;
  
    case 50153655: // tasto rosso spegne tutte le luci
        if (millis() - last > 250) {
        for(int i=0; i<=6; i++) {  
        on[i] = SPENTO;
        digitalWrite (pinReleLuci[i], SPENTO); } 
        Serial.println("spengo tutto");
        } 
        last = millis();
    break;
    
    } // end switch
    
  irrecv.resume(); // Receive the next value
  }  // end if 
  
  buttonstate = digitalRead(BUTTON); // immagazzino il valore di button
  if (buttonstate != lastbuttonstate) { //se lo stato button è diverso dal precedente
    buttonstate = lastbuttonstate;
    delay(250);
    if (on[1] == 0 || on[2] == 0 || on[3] == 0 || on[4] == 0 || on[5] == 0 || on[6] == 0) { //se una delle due variabili ha valore 0
    for (int i=0; i<=6; i++) {
    digitalWrite (pinReleLuci[i], SPENTO);  // spegne tutti i rele luci
    on[i] = SPENTO; }
    stampaON();

  }
  
  else {
    for (int i=0; i<=6; i++) {
    digitalWrite (pinReleLuci[i], ACCESO); // accendo tutti i rele'   
    on[i] = ACCESO; }
    stampaON();
  }
  
 } //end if di controllo buttonstate
  
  if ((millis() - lastmillis) >= attesa) {
    lastmillis = millis();
    if (stato_rele_alzatapp == LOW) {
      stato_rele_alzatapp = HIGH;
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp);
      Serial.print("la tapparella ha smesso di alzarsi   ");
      Serial.println(millis());
    }
  }
  
  if ((millis() - lastmillis1) >= attesa1) {
    lastmillis1 = millis();
    if (stato_rele_abbassatapp == LOW) {
      stato_rele_abbassatapp = HIGH;
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp);
      Serial.print("la tapparella ha smesso di abbassarsi    ");
      Serial.println(millis());
    }
  }
} //end loop

[Brescio]

Ma che fig.ata!!! Grazie x il supporto!

[giansa]

te lo rubo, posso? complimenti

[Gabrydark]

ma certo figurati! se fossi contrario non avrei pubblicato

se hai cavi molto lunghi che vanno ad eventuali pulsanti, potrebbero fungere da "antenne" capta disturbi, in quel caso bisognerà aggiungere un controllo sulla durata del comando impartito (pressione del pulsante) di modo che il pogramma possa scartare impulsi inferiori ad un certo Tot..

buon divertimento!

[giansa]

grazie!!! magari per i disturbi si può provvedere nel codice aggiungendo un delay sulla pressione del tasto, una sorta di antirimbalzo

[Gabrydark]

la versione con antirimbalzo (togliamo il delay che mette in pausa lo sketch e inserisco millis() )

#include <IRremote.h>

#define ACCESO 0
#define SPENTO 1

byte stato_rele_alzatapp = 0; // conserva lo stato rele alza tapparella
byte stato_rele_abbassatapp = 0; // conserva lo stato rele abbassa tapparella
byte on[]={0,0,0,0,0,0,0}; // 
byte buttonstate = 0;
byte lastbuttonstate = 0; 

const byte RECV_PIN = 2; //pin ricevitore IR
const byte pinReleLuci[]={0,11,10,9,8,7,6}; // pin rele' luci
const byte pinReleTapp[]={0,5,4}; //pin rele' tapparella
const byte BUTTON = 3; //pulsante all'ingresso
const byte pinAnalog[]={0,A0,A1,A2,A3,A4,A5,A6,A7}; //pin inutili

unsigned long lastmillis = millis();
unsigned long lastmillis1 = millis();
unsigned long last = millis();
unsigned long attesa = 40000;
unsigned long attesa1 = 40000;

IRrecv irrecv(RECV_PIN);
decode_results results;

void stampaON() {
  Serial.print ("on1:   ");
    Serial.println (on[1]);
    Serial.print ("on2:  ");
    Serial.println (on[2]);
    Serial.print ("on3:   ");
    Serial.println (on[3]);
    Serial.print ("on4:  ");
    Serial.println (on[4]);
    Serial.print ("on5:   ");
    Serial.println (on[5]);
    Serial.print ("on6:  ");
    Serial.println (on[6]);
}

void GestioneLuce(int nluce) { 
  on[nluce] = !on[nluce];
  digitalWrite(pinReleLuci[nluce], on[nluce] ? HIGH : LOW); //accende o spegne
  Serial.print("stato luce "); Serial.print(nluce); Serial.println(":    ");
  Serial.println(on[nluce]);
} 

void setup() {
  delay(1000);
  for(int i=0; i<=6; i++) 
  { pinMode(pinReleLuci[i], OUTPUT);
    digitalWrite(pinReleLuci[i], SPENTO);
    on[i]=SPENTO;
  }
  for(int x=0; x<=2; x++)
  { pinMode(pinReleTapp[x], OUTPUT);
    digitalWrite(pinReleTapp[x], SPENTO);
  }    
  
  pinMode(12, OUTPUT); //non utilizzato, impostato in OUTPUT per evitare disturbi
  
  
  for(int a=0; a<=8; a++)
  { pinMode(pinAnalog[a], INPUT); //antidisturbo
  }
  
  pinMode(BUTTON, INPUT_PULLUP);
  Serial.begin(9600);
  irrecv.enableIRIn(); // avvio la ricezione IR
  
  pinMode(RECV_PIN, INPUT_PULLUP);
}

void loop() {
  if(irrecv.decode(&results)) {
    switch(results.value) {
      case 16724175: // tasto 1 (luci)
        if (millis() - last > 250) {
          GestioneLuce(1);
        } 
        last = millis();
      break; 
  
    case 16718055: // tasto 2 (luci)
        if (millis() - last > 250) {
          GestioneLuce(2);
        } 
        last = millis();
    break;
    
    case 16743045: // tasto 3 (luci)
        if (millis() - last > 250) {
          GestioneLuce(3);
        } 
        last = millis();
    break;
    
    case 16716015: // tasto 4 (luci)
        if (millis() - last > 250) {
          GestioneLuce(4);
        } 
        last = millis();
    break; 
    
    case 16726215: // tasto 5 (luci)
        if (millis() - last > 250) {
          GestioneLuce(5);
        } 
        last = millis();
    break; 
    
    case 16734885: // tasto 6 (luci)
        if (millis() - last > 250) {
          GestioneLuce(6);
        } 
        last = millis();
    break; 
    
    case 16754775: // tasto alza tapparella
      stato_rele_alzatapp = LOW;
      stato_rele_abbassatapp = HIGH;
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp); // accende il rele' di salita
      if (millis() - last > 500) { //pausa di 1/2 sec prima di far partire nel senso contrario
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp);} //mi assicuro che sia spento il rele' di abbassamento
      last = millis();
      Serial.print("la tapp si alza:   ");
      Serial.println(millis());
    break;
    
    case 16769055: // tasto abbassa tapparella
      stato_rele_abbassatapp = LOW;
      stato_rele_alzatapp = HIGH;
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp); 
      if (millis() - last > 500) { //pausa di 1/2 sec prima di far partire nel senso contrario
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp);}
      last = millis();
      Serial.print("la tapp si abbassa:    ");
      Serial.println(millis());
    break;

    case 16748655: // tasto blocca tapparella
      digitalWrite (pinReleTapp[1], SPENTO);
      digitalWrite (pinReleTapp[2], SPENTO);
      Serial.println("la tapparella si blocca");
    break;
  
    case 16753245: // tasto rosso spegne tutte le luci
        if (millis() - last > 250) {
        for(int i=0; i<=6; i++) {  
        on[i] = SPENTO;
        digitalWrite (pinReleLuci[i], SPENTO); } 
        Serial.println("spengo tutto");
        } 
        last = millis();
    break;
    
    } // end switch
    
  irrecv.resume(); // Receive the next value
  }  // end if 
  
  buttonstate = digitalRead(BUTTON); // immagazzino il valore di button
  if (buttonstate != lastbuttonstate) { //se lo stato button è diverso dal precedente
    lastbuttonstate = buttonstate;
//    delay(250);
    if (millis() - last > 250) {
      if (on[1] == 0 || on[2] == 0 || on[3] == 0 || on[4] == 0 || on[5] == 0 || on[6] == 0) { //se una delle due variabili ha valore 0
      for (int i=0; i<=6; i++) {
      digitalWrite (pinReleLuci[i], SPENTO);  // spegne tutti i rele luci
      on[i] = SPENTO; }
      stampaON();
      }
     
    else {
      for (int d=0; d<=6; d++) {
      digitalWrite (pinReleLuci[d], ACCESO); // accendo tutti i rele'   
      on[d] = ACCESO; }
      stampaON();
    }
  }
  last = millis(); //aggiorno valore di last al millis attuale
  
 } //end if di controllo buttonstate
  
  if ((millis() - lastmillis) >= attesa) {
    lastmillis = millis();
    if (stato_rele_alzatapp == LOW) {
      stato_rele_alzatapp = HIGH;
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp);
      Serial.print("la tapparella ha smesso di alzarsi   ");
      Serial.println(millis());
    }
  }
  
  if ((millis() - lastmillis1) >= attesa1) {
    lastmillis1 = millis();
    if (stato_rele_abbassatapp == LOW) {
      stato_rele_abbassatapp = HIGH;
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp);
      Serial.print("la tapparella ha smesso di abbassarsi    ");
      Serial.println(millis());
    }
  }
} //end loop

questo codice evita semplicemente i rimbalzi di corrente durante la pressione del tasto.. quello che segue invece non fa solo da antirimbalzo ma accetta impulsi (pressione del pulsante) con un tempo NON inferiore ai 50ms (1/20 di secondo) questo fa si che se venga captato un disturbo elettrico inferiore ai 50ms verrà automaticamente ignorato, la stessa identica costa se premi il pulsante per meno di 50ms non si accenderà alcuna luce

segue nel prossimo post..

[Gabrydark]

eccolo!

#include <IRremote.h>

#define ACCESO 0
#define SPENTO 1

byte stato_rele_alzatapp = 0; // conserva lo stato rele alza tapparella
byte stato_rele_abbassatapp = 0; // conserva lo stato rele abbassa tapparella
byte on[]={0,0,0,0,0,0,0}; // 
byte buttonstate = 0;
byte lastbuttonstate = 0; 

const byte RECV_PIN = 2; //pin ricevitore IR
const byte pinReleLuci[]={0,11,10,9,8,7,6}; // pin rele' luci
const byte pinReleTapp[]={0,5,4}; //pin rele' tapparella
const byte BUTTON = 3; //pulsante all'ingresso
const byte pinAnalog[]={0,A0,A1,A2,A3,A4,A5,A6,A7}; //pin inutili
//****
byte reading ;
boolean Puls_prem = false;

unsigned long lastmillis = millis();
unsigned long lastmillis1 = millis();
unsigned long last = millis();
unsigned long last1 = millis();
unsigned long attesa = 40000;
unsigned long attesa1 = 40000;
unsigned long pausa_tapp = 500;
//****
unsigned long tempo_pulsante = millis();
unsigned long Ritardo_pulsante = 50;

IRrecv irrecv(RECV_PIN);
decode_results results;

void stampaON() {
  Serial.print ("on1:   ");
    Serial.println (on[1]);
    Serial.print ("on2:  ");
    Serial.println (on[2]);
    Serial.print ("on3:   ");
    Serial.println (on[3]);
    Serial.print ("on4:  ");
    Serial.println (on[4]);
    Serial.print ("on5:   ");
    Serial.println (on[5]);
    Serial.print ("on6:  ");
    Serial.println (on[6]);
}

void GestioneLuce(int nluce) { 
  on[nluce] = !on[nluce];
  digitalWrite(pinReleLuci[nluce], on[nluce] ? HIGH : LOW); //accende o spegne
  Serial.print("stato luce "); Serial.print(nluce); Serial.println(":    ");
  Serial.println(on[nluce]);
} 

void setup() {
  delay(1000);
  for(int i=0; i<=6; i++) 
  { pinMode(pinReleLuci[i], OUTPUT);
    digitalWrite(pinReleLuci[i], SPENTO);
    on[i]=SPENTO;
  }
  for(int x=0; x<=2; x++)
  { pinMode(pinReleTapp[x], OUTPUT);
    digitalWrite(pinReleTapp[x], SPENTO);
  }    
  
  pinMode(12, OUTPUT); //non utilizzato, impostato in OUTPUT per evitare disturbi
  
  
  for(int a=0; a<=8; a++)
  { pinMode(pinAnalog[a], INPUT); //antidisturbo
  }
  
  pinMode(BUTTON, INPUT_PULLUP);
  Serial.begin(9600);
  irrecv.enableIRIn(); // avvio la ricezione IR
  
  pinMode(RECV_PIN, INPUT_PULLUP);
}

void loop() {
  if(irrecv.decode(&results)) {
    switch(results.value) {
      case 16724175: // tasto 1 (luci)
        if (millis() - last > 250) {
          GestioneLuce(1);
        } 
        last = millis();
      break; 
  
    case 16718055: // tasto 2 (luci)
        if (millis() - last > 250) {
          GestioneLuce(2);
        } 
        last = millis();
    break;
    
    case 16743045: // tasto 3 (luci)
        if (millis() - last > 250) {
          GestioneLuce(3);
        } 
        last = millis();
    break;
    
    case 16716015: // tasto 4 (luci)
        if (millis() - last > 250) {
          GestioneLuce(4);
        } 
        last = millis();
    break; 
    
    case 16726215: // tasto 5 (luci)
        if (millis() - last > 250) {
          GestioneLuce(5);
        } 
        last = millis();
    break; 
    
    case 16734885: // tasto 6 (luci)
        if (millis() - last > 250) {
          GestioneLuce(6);
        } 
        last = millis();
    break; 
    
    case 16754775: // tasto alza tapparella
      if (millis() - last > 250) { //pausa di 1/4 sec prima di far partire la tapp
      stato_rele_alzatapp = LOW;
      stato_rele_abbassatapp = HIGH;
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp); //mi assicuro che sia spento il rele' di abbassamento
        if (millis() - last1 > 500) {
        digitalWrite(pinReleTapp[1], stato_rele_alzatapp); // accende il rele' di salita
        Serial.print("la tapp si alza:   ");
        Serial.println(millis());
        }
      }
      last = millis();
      last1 = millis();
    break;
    
    case 16769055: // tasto abbassa tapparella
      if (millis() - last > 250) { //pausa di 1/4 sec prima di far partire la tapp
      stato_rele_abbassatapp = LOW;
      stato_rele_alzatapp = HIGH;
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp);
        if (millis() - last > 500) {
        digitalWrite(pinReleTapp[2], stato_rele_abbassatapp); // accende il rele' di discesa
        Serial.print("la tapp si abbassa:    ");
        Serial.println(millis());
        }
      }
      last = millis();
      last1 = millis();
    break;

    case 16748655: // tasto blocca tapparella
      digitalWrite (pinReleTapp[1], SPENTO);
      digitalWrite (pinReleTapp[2], SPENTO);
      Serial.println("la tapparella si blocca");
    break;
  
    case 16753245: // tasto rosso spegne tutte le luci
        if (millis() - last > 250) {
        for(int i=0; i<=6; i++) {  
        on[i] = SPENTO;
        digitalWrite (pinReleLuci[i], SPENTO); } 
        Serial.println("spengo tutto");
        } 
        last = millis();
    break;
    
    } // end switch
    
  irrecv.resume(); // Receive the next value
  }  // end if 
  
reading = digitalRead(BUTTON);
  if (reading  && !Puls_prem) {
    tempo_pulsante = millis();								// Record time
    Puls_prem = true;
    buttonstate = 1 ;
   }
  
  else if(reading && (millis() - tempo_pulsante) > Ritardo_pulsante) {
    tempo_pulsante = millis();
    if (buttonstate != lastbuttonstate) { 
      lastbuttonstate = buttonstate;
      if (on[1] == 0 || on[2] == 0 || on[3] == 0 || on[4] == 0 || on[5] == 0 || on[6] == 0) { //se una delle due variabili ha valore 0
      for (int i=0; i<=6; i++) {
      digitalWrite (pinReleLuci[i], SPENTO);  // spegne tutti i rele luci
      on[i] = SPENTO; }
      stampaON();
      }
     
    else {
      for (int d=0; d<=6; d++) {
      digitalWrite (pinReleLuci[d], ACCESO); // accendo tutti i rele'   
      on[d] = ACCESO; 
      }
      stampaON();
    }
//  }

//  last = millis(); //aggiorno valore di last al millis attuale
    }
 }
   else if(!reading)  {
    Puls_prem = false;
    lastbuttonstate = 0;
    buttonstate = 0 ;
  }
 
    
  if ((millis() - lastmillis) >= attesa) {
    lastmillis = millis();
    if (stato_rele_alzatapp == LOW) {
      stato_rele_alzatapp = HIGH;
      digitalWrite(pinReleTapp[1], stato_rele_alzatapp);
      Serial.print("la tapparella ha smesso di alzarsi   ");
      Serial.println(millis());
    }
  }
  
  if ((millis() - lastmillis1) >= attesa1) {
    lastmillis1 = millis();
    if (stato_rele_abbassatapp == LOW) {
      stato_rele_abbassatapp = HIGH;
      digitalWrite(pinReleTapp[2], stato_rele_abbassatapp);
      Serial.print("la tapparella ha smesso di abbassarsi    ");
      Serial.println(millis());
    }
  }
} //end loop