aiuto con codice timer

Salve a tutti signori,
mi sto cimentando nel mio primo progettino arduino che consiste in un dispositivo countdown a led (ogni tot secondi si spegne un led) fino allo scadere del tempo che fa suonare un buzzer. per spegnerlo c'è un terminale che quando inserito nel connettore da la possibilità di disattivare il timer mediande combinazione e la pressione di un tasto.

Per ora sono riuscito a realizzare il countdown ed avvio con pressione del tasto ma ho difficoltà con il terminale. Ora.

  • il terminale da segnale al tester quindi i cablaggi sono corretti ma non riesco a farlo andare. potreste darmi una mano con il codice cosi da farmi imparare meglio?

vi incollo di seguito quando scritto finora.
-la combinazione sul terminale è data da dei commutatori rotativi in serie.

Quello che vorrei ottenere è:

armato il dispositivo ( che sarà una bomba sonora per softair) e premuto il pulsante sulla centralina parte il countdown.
quando i giocatori riusciranno a raggiungere il dispositivo con il terminale lo inseriscono nel connettore e dovranno inserire la combinazione (che non è altro che il passaggio in serie della corrente che alimenta arduino destinata ad un pin) e poi premere il pulsante.

Se tutto è corretto si deve spegnere tutto,mentre se è errato il countdown accelera per 2 volte al terzo tentativo di pressione errata del pulsante il buzzer suona.

La combinazione è sul pin 11
il pulsante del terminale è sul 12.

ecco il codice scritto finora:


const int PulsanteCentralina = 10;
const int led1rosso = 9;
const int led2rosso = 8;
const int led1giallo = 5;
const int led2giallo = 6;
const int led1verde = 3;
const int led2verde = 4;
const int ledARMED = 2;
const int ledDISARMED = 1;
const int Buzzer = 13;
const int Combinazione = 11;
const int PulsanteTerminale = 12;

//dichiarazione variabili. stato pulsante e buzzer.
int old_statopulsante = 0;
int old_statopulsanteterminale = 0;
int statopulsante = 0;
int statoled = 0;
int statobuzzer = 0;
int statocombinazione = 0;
int statopulsanteterminale = 0;
int CombinazioneIN = 0;

void setup () {
  //definisco i pin di output
  pinMode(led1verde, OUTPUT);
  pinMode(led2verde, OUTPUT);
  pinMode(led1giallo, OUTPUT);
  pinMode(led2giallo, OUTPUT);
  pinMode(led1rosso, OUTPUT);
  pinMode(led2rosso, OUTPUT);
  pinMode(ledARMED, OUTPUT);
  pinMode(ledDISARMED, OUTPUT);
  pinMode(Buzzer, OUTPUT);
  //definisco i pin di input
  pinMode(PulsanteCentralina, INPUT);
  pinMode(PulsanteTerminale, INPUT);
  pinMode(Combinazione, INPUT);
}

void loop(){
  digitalWrite(ledDISARMED, HIGH);
  statopulsante = digitalRead(PulsanteCentralina); //Lettura stato pulsante
  //se il pulsante è premuto lo stato è HIGH e avvia il ciclo
  if ((statopulsante == HIGH) && (old_statopulsante == LOW)){
   statopulsante = 1 ;
   delay(10);
  }
 
 //old_statopulsante = statopulsante - statopulsante;

if (statopulsante == 1) { //accendo tutti i led ed inizio il countdown
    delay(5000);
    digitalWrite(ledDISARMED, LOW);
    digitalWrite(led1rosso, HIGH);
    digitalWrite(led2rosso, HIGH);
    digitalWrite(led1giallo, HIGH);
    digitalWrite(led2giallo, HIGH);
    digitalWrite(led1verde, HIGH);
    digitalWrite(led2verde, HIGH);
    digitalWrite(ledARMED, HIGH);
    //countdown totale minuti 1
    delay(10000);
    digitalWrite(led1verde, LOW);
    delay(10000);
    digitalWrite(led2verde, LOW);
     delay(10000);
    digitalWrite(led1giallo, LOW);
    delay(10000);
    digitalWrite(led2giallo, LOW);
     delay(10000);
    digitalWrite(led1rosso, LOW);
    delay(10000);
    digitalWrite(led2rosso, LOW);
    delay(250);
    digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
     digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
     digitalWrite(Buzzer, HIGH);
    delay(3000);
    digitalWrite(Buzzer, LOW);
    delay(500);
   } else {
    digitalWrite(ledDISARMED, LOW);
    digitalWrite(ledARMED, LOW);
  } 
  //tentativo inserimento pulsante. eliminiare da qua sotto per ripristinare il codice.
   statopulsanteterminale = digitalRead(PulsanteTerminale); //Lettura stato pulsante terminale
  //se il pulsante è premuto blocca il countdown
    if ((statopulsanteterminale == LOW) && (old_statopulsanteterminale == LOW)){
    statopulsanteterminale = 0 ;
    delay(10);
    }
if (statopulsanteterminale, == 0) {
    } else {
    digitalWrite(ledDISARMED, HIGH);
    digitalWrite(led1rosso, LOW);
    digitalWrite(led2rosso, LOW);
    digitalWrite(led1giallo, LOW);
    digitalWrite(led2giallo, LOW);
    digitalWrite(led1verde, LOW);
    digitalWrite(led2verde, LOW);
    digitalWrite(ledARMED, LOW);
  } //eliminare questa graffa e lasciare quella sotto per ripristinare il codice.
}

edit by mod: per favore includi il codice usando gli appositi tag

potete darmi qualche dritta? non riesco a fargli sentire il terminale.

grazie in anticipo

nel momento in cui entri in "if (statopulsante == 1)" vai avanti a fare tutto attraverso i delay, senza controllare che qualcuno abbia inserito il terminale.

devi rivedere completamente il codice per funzionare "a stati" e usando la millis() senza delay: in pratica devi fare in modo che la loop venga eseguita velocissimamente senza mai fermarsi, e tu misurando il tempo trascorso dall'armamento vericfichi cosa devi fare o se ci sono dati sul terminale

Ricorda di includere il codice con gli appositi tag (vedi come fare al punto 7 --> [REGOLAMENTO] Come usare questa sezione del forum - Italiano - Arduino Forum).

Il codice così come non funzionerà: ci sono i delay che ti bloccano l'elaborazione, non è corretto come modo di ragionare per quello che vuoi fare.
Segui il consiglio di lesto.

Premendo il tasto modify sul topic precedente lo puoi modificare includendo il codice con i tag.
Inoltre col tasto replies, in altro a destra vicino al tuo nome utente, puoi controllare le nuove risposte alle tue discussioni o quelle a cui hai partecipato.

Ciao e benvenuto.

bhè intanto grazie davvero per i consigli.
siccome non ho mai programmato e sto imparando sulla pratica potete darmi qualche imboccata su come cominciare?

blinkWithoutDelay è un esempio da cui iniziare

non mi rimedio :~
non riesco a capire come sviluppare il programmino

Guarda qui --> Arduino timer sequenziale - #3 by PaoloP - Software - Arduino Forum

Non ho capito quale sia il problema: se fare il programma con millis oppure "fargli sentire il terminale". A proposito, com'è che dovrebbe "sentire" il terminale? Cos'è questo terminale?

PS:
per una mano su come fare per eseguire compiti diversi con millis puoi leggere questa mia guida.
http://www.leonardomiliani.com/2013/programmiamo-i-compiti-con-millis/

ottime le guide intanto ci studio un pò su.

il terminale non è altro che uno scatolotto esterno che viene alimentato in parallelo da Vin cioè da batteria non appena inserito.
questa tensione passa attraverso 4 commutatori rotativi a 12 pos in serie che sfociano su un altro piede del connettore che restituisce il segnale ad un pin digitale di arduino settato in imput.
Il pulsante è cablto uguale. riceve la tensione in ingresso e restituisce questa tensione su un altro piede del connettore che sfocia in un altro din in digital read.

quello che voglio ottenere è:

lo stesso codice iniziale che ho scritto va, però vorrei che quando inserisco il terminale nel connettore nel momento in cui premo il pulsante in esso arduino faccia un digitalRead della combinazione e se sente il segnale spenga tutto.
Se così non fosse che il delay del countdown diminuisca accelerando il conteggio.

sono inpantanato qua da giorni

Ah, ho capito. Tu agganci in pratica un "decoder" alla bomba e ci metti sopra la combinazione tramite encoder. Se la combinazione è giusta, passa corrente da un pin ad un altro.

Per fare quello che vuoi devi decrementare il tempo ogni x usando millis al posto del delay. Il decremento lo fai con un intervallo che poi modifichi, ossia poniamo che inizialmente x valga 1000, corrispondenti ad un decremento ogni 1000 ms. Se il codice è errato, poni x a 500, in questo modo dimezzi il tempo che intercorre fra un decremento ed il successivo. E così via.

Nel mio articolo trovi l'esempio di 2 compiti da eseguire con millis. E' il caso tuo: il primo compito controlla se ogni x deve decrementare il timer, il secondo compito legge il pin che controlla se il codice è esatto (entro un certo lasso di tempo).

provo a studiarci su. spero di riuscirci a capire qualcosa purtroppo non ho mai studiato programmazione,ne ho una vaga infarinatura e vorrei imparare ma farlo senza un obbiettivo da sviluppare mi risulta impossibile. provo a scrivere due righe vediamo cosa ne viene fuori.

domanda. posso far fare al buzzer dei suoni particolari tipo una sirena o altro o può solo suonare a cicalino?

Puoi riprodurre i suoni dell'Atari. :grin:
Leo ti può spiegare come. :wink:

Come ti ha detto Paolo, con un chip si possono fare tanti suoni XD
http://www.leonardomiliani.com/2013/una-atari-punk-console-con-un-attiny85/

Se vuoi però stare sulle cose semplici, c'è la funzione Tone

http://arduino.cc/en/Reference/Tone

Se ti serve una mano non hai che da chiedere

dunque spero di scrivere bene e non violare nessuna regola.

allora. non mi sono rimediato con la funzione millis per cui ho deciso di fare cosi; inserire 3 tentativi senza intaccare il countdown se al terzo tentativo con il pulsante il pin della combinazione non è HIGH il buzzer suona e resetta.
Ovviamente non va e non ci cavo i zampetti.
mi dareste una mano? dove sbaglio?

/*
Tentativo n.3 di codice per bomba softair.
Il programma prevede l'avvio tramite pulsante di un countdown
il cui tenpo è prograssivamente indicato dallo spegnersi dei led.
Al Disinnesco si spegneranno i led di countdown e armamento e accenderanno i disarm led.
L'errata combinazione aumenta la velocità di countdown e dopo 3 tentativi provoca la detonazione.

AL MOMENTO LA COMBINAZIONE NON FUNZIONA. POSSIBILITà DI DISINNESCO SOLO TRAMITE CHIAVE.
IL COUNTDOWN è TARATO PER MEZZ'ORA.
Realizzato da Omicini Alessandro.
*/

//dichiarazione costanti: sono tutti i pin assegnati
const int Pulsante = 8;
const int led1rosso = 7;
const int led2rosso = 6;
const int led1giallo = 4;
const int led2giallo = 5;
const int led1verde = 2;
const int led2verde = 3;
const int ledARMED = 9;
const int ledDISARMED = 1;
const int Buzzer = 12;
const int Combinazione = 11;
const int PulsanteTerminale = 10;

//dichiarazione variabili. stato pulsante e buzzer.
int old_statopulsante = 0;
int old_statopulsanteterminale = 0;
int old_statocombinazione = 0;
int statopulsante = 0;
int statoled = 0;
int statobuzzer = 0;
int statocombinazione = 0;
int statopulsanteterminale = 0;
int tentativi = 0;
void setup () {
  //definisco i pin di output
  pinMode(led1verde, OUTPUT);
  pinMode(led2verde, OUTPUT);
  pinMode(led1giallo, OUTPUT);
  pinMode(led2giallo, OUTPUT);
  pinMode(led1rosso, OUTPUT);
  pinMode(led2rosso, OUTPUT);
  pinMode(ledARMED, OUTPUT);
  pinMode(ledDISARMED, OUTPUT);
  pinMode(Buzzer, OUTPUT);
  //definisco i pin di input
  pinMode(Pulsante, INPUT);
  pinMode(PulsanteTerminale, INPUT);
  pinMode(Combinazione, INPUT);
}

void loop(){
  digitalWrite(ledDISARMED, HIGH);
  statopulsante = digitalRead(Pulsante); //Lettura stato pulsante
  //se il pulsante è premuto lo stato è HIGH e avvia il ciclo
  if ((statopulsante == HIGH) && (old_statopulsante == LOW)){
   statopulsante = 1 ;
   delay(10);
  }
 
 //old_statopulsante = statopulsante - statopulsante;

if (statopulsante == 1) { //accendo tutti i led ed inizio il countdown
    delay(5000);
    digitalWrite(ledDISARMED, LOW);
    digitalWrite(led1rosso, HIGH);
    digitalWrite(led2rosso, HIGH);
    digitalWrite(led1giallo, HIGH);
    digitalWrite(led2giallo, HIGH);
    digitalWrite(led1verde, HIGH);
    digitalWrite(led2verde, HIGH);
    digitalWrite(ledARMED, HIGH);
    //countdown totale minuti 30
    delay(300000);
    digitalWrite(led1verde, LOW);
    delay(300000);
    digitalWrite(led2verde, LOW);
     delay(300000);
    digitalWrite(led1giallo, LOW);
    delay(300000);
    digitalWrite(led2giallo, LOW);
     delay(300000);
    digitalWrite(led1rosso, LOW);
    delay(300000);
    digitalWrite(led2rosso, LOW);
    delay(250);
    digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
     digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
     digitalWrite(Buzzer, HIGH);
    delay(3000);
    digitalWrite(Buzzer, LOW);
    delay(500);
   } else {
    digitalWrite(ledDISARMED, LOW);
    digitalWrite(ledARMED, LOW);
  } 
 
 
  //codice che include il terminale nel processo
   statocombinazione = digitalRead(Combinazione); //Lettura stato pulsante terminale
  //se il pulsante è premuto lo stato è HIGH controlla la combinazione il ciclo
  if ((statocombinazione == HIGH) && (old_statocombinazione == LOW)){
   statocombinazione = 1 ;
   delay(10);
  }
    statopulsanteterminale = digitalRead(PulsanteTerminale); //Lettura stato pulsante terminale
  //se il pulsante è premuto lo stato è HIGH e avvia il ciclo
  if ((statopulsanteterminale == HIGH) && (old_statopulsanteterminale == LOW)){
   statopulsanteterminale = 1 ;
   delay(10);
  }
  if ((statocombinazione == HIGH) && (statopulsanteterminale == HIGH)){
    digitalWrite(ledDISARMED, HIGH);
    digitalWrite(led1rosso, LOW);
    digitalWrite(led2rosso, LOW);
    digitalWrite(led1giallo, LOW);
    digitalWrite(led2giallo, LOW);
    digitalWrite(led1verde, LOW);
    digitalWrite(led2verde, LOW);
    digitalWrite(ledARMED, LOW);
  }
   if ((statocombinazione == LOW) && (statopulsanteterminale == HIGH)){
     tentativi = 1 ;
     digitalWrite(Buzzer, HIGH);
     delay (100);
     digitalWrite(Buzzer, LOW);
   }
   if (tentativi = 3){
    digitalWrite(ledDISARMED, LOW);
    digitalWrite(led1rosso, LOW);
    digitalWrite(led2rosso, LOW);
    digitalWrite(led1giallo, LOW);
    digitalWrite(led2giallo, LOW);
    digitalWrite(led1verde, LOW);
    digitalWrite(led2verde, LOW);
    digitalWrite(ledARMED, HIGH);
     digitalWrite(Buzzer, HIGH);
    delay(1000);
     digitalWrite(Buzzer, LOW);
    delay(500);
     digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
     digitalWrite(Buzzer, HIGH);
    delay(3000);
    digitalWrite(Buzzer, LOW);
    delay(500);
   }
}

Bozza di quello che dovresti fare:

unsigned long newmilliseconds;

void setup()
{
    newmilliseconds=0;
}

void loop()
{
    newmilliseconds=millis();
    if(newmilliseconds>TuoIntervallo)
    {
          //fai quello che devi fare
          newmilliseconds=0; //nuovo conteggio dei millisecondi trascorsi
    }
    else if(newmilliseconds>ecc.)
    {
          //...
          newmilliseconds=0;
    }
}

Cerca di studiarti millis() e non usare i delay(). Il mio codice è per un sistema che si arma all'accensione, se vuoi fare qualcosa di diverso devi complicarlo un po'.

ok ci riprovo. ma usando quello che ho fatto fin'ora come faccio semplicemente a tenere in memoria tre pressioni del pulsante e alla terza far suonare il buzzer? almeno intanto fa grossomodo quello che deve poi continuo a perfezionarlo

Prova così, l'ho buttato di fretta

//dichiarazione costanti: sono tutti i pin assegnati
const int Pulsante = 8;
const int led1rosso = 7;
const int led2rosso = 6;
const int led1giallo = 4;
const int led2giallo = 5;
const int led1verde = 2;
const int led2verde = 3;
const int ledARMED = 9;
const int ledDISARMED = A0;
const int Buzzer = A1;
const int Combinazione = A2;
const int PulsanteTerminale = A3;

//dichiarazione variabili. stato pulsante e buzzer.
int old_statopulsante = LOW;
int old_statopulsanteterminale = LOW;
int old_statocombinazione = LOW;
int statopulsante = 0;
int statoled = 0;
int statobuzzer = 0;
int statocombinazione = 0;
int statopulsanteterminale = 0;
int tentativi = 0;

unsigned long T0 = 0;
unsigned long T1 = 0;
unsigned long Tint = 0;
unsigned int Tindex = 0;

void setup () {
  delay(1000);
  Serial.begin(9600);

  //definisco i pin di output
  pinMode(led1verde, OUTPUT);
  pinMode(led2verde, OUTPUT);
  pinMode(led1giallo, OUTPUT);
  pinMode(led2giallo, OUTPUT);
  pinMode(led1rosso, OUTPUT);
  pinMode(led2rosso, OUTPUT);
  pinMode(ledARMED, OUTPUT);
  pinMode(ledDISARMED, OUTPUT);
  pinMode(Buzzer, OUTPUT);

  //definisco i pin di input
  pinMode(Pulsante, INPUT);
  pinMode(PulsanteTerminale, INPUT);
  pinMode(Combinazione, INPUT);

  T0 = millis();
  Serial.print(F("Go at ")); 
  Serial.print(T0);
  Serial.println(F(" milliseconds."));   
}

void loop(){
  digitalWrite(ledDISARMED, HIGH);

  statopulsante = digitalRead(Pulsante); //Lettura stato pulsante
  statocombinazione = digitalRead(Combinazione); //Lettura stato pulsante terminale
  statopulsanteterminale = digitalRead(PulsanteTerminale); //Lettura stato pulsante terminale
  delay(20);

  //se il pulsante è premuto lo stato è HIGH e avvia il ciclo
  if ((statopulsante == HIGH) && (old_statopulsante == LOW)){
    statopulsante = 1 ;
    Serial.println(F("Armed - start countdown..."));
  }

  if (statopulsante == 1) { //accendo tutti i led ed inizio il countdown
    armed();
  } 
  else {
    disarmed();
    Serial.println(F("Disarmed."));
  } 

  //codice che include il terminale nel processo
  //se il pulsante è premuto lo stato è HIGH controlla la combinazione il ciclo
  if ((statocombinazione == HIGH) && (old_statocombinazione == LOW)){
    statocombinazione = 1 ;
    Serial.println(F("combinazione"));
  }

  //se il pulsante è premuto lo stato è HIGH e avvia il ciclo
  if ((statopulsanteterminale == HIGH) && (old_statopulsanteterminale == LOW)){
    statopulsanteterminale = 1 ;
    Serial.println(F("terminale"));
  }

  if ((statocombinazione == HIGH) && (statopulsanteterminale == HIGH)){
    Serial.println(F("All stop"));
    digitalWrite(ledDISARMED, HIGH);
    digitalWrite(led1rosso, LOW);
    digitalWrite(led2rosso, LOW);
    digitalWrite(led1giallo, LOW);
    digitalWrite(led2giallo, LOW);
    digitalWrite(led1verde, LOW);
    digitalWrite(led2verde, LOW);
    digitalWrite(ledARMED, LOW);
  }

  if ((statocombinazione == LOW) && (statopulsanteterminale == HIGH)){
    tentativi++;
    digitalWrite(Buzzer, HIGH);
    delay (100);
    digitalWrite(Buzzer, LOW);
    Serial.println(F("tentativi"));
    Serial.println(tentativi);
  }

  if (tentativi = 3){
    Serial.println(F("Hai raggiunto 3 tentativi"));
    digitalWrite(ledDISARMED, LOW);
    digitalWrite(led1rosso, LOW);
    digitalWrite(led2rosso, LOW);
    digitalWrite(led1giallo, LOW);
    digitalWrite(led2giallo, LOW);
    digitalWrite(led1verde, LOW);
    digitalWrite(led2verde, LOW);
    digitalWrite(ledARMED, HIGH);
    digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
    digitalWrite(Buzzer, HIGH);
    delay(1000);
    digitalWrite(Buzzer, LOW);
    delay(500);
    digitalWrite(Buzzer, HIGH);
    delay(3000);
    digitalWrite(Buzzer, LOW);
    delay(500);
  }
}

void armed(){
  T1 = millis();
  if ( (T1-T0)>Tint ) {
    Tindex++;
    Serial.print(F("Index: "));
    Serial.println(Tindex);

    switch(Tindex){
    case 1:
      Tint +=5000;
      break;

    case 2:
      digitalWrite(ledDISARMED, LOW);
      digitalWrite(led1rosso, HIGH);
      digitalWrite(led2rosso, HIGH);
      digitalWrite(led1giallo, HIGH);
      digitalWrite(led2giallo, HIGH);
      digitalWrite(led1verde, HIGH);
      digitalWrite(led2verde, HIGH);
      digitalWrite(ledARMED, HIGH);
      //countdown totale minuti 30
      Tint +=300000;
      break;

    case 3:
      digitalWrite(led1verde, LOW);
      Tint +=300000;
      break;

    case 4:
      digitalWrite(led2verde, LOW);
      Tint +=300000;
      break;

    case 5:
      digitalWrite(led1giallo, LOW);
      Tint +=300000;
      break;

    case 6:
      digitalWrite(led2giallo, LOW);
      Tint +=300000;
      break;

    case 7:
      digitalWrite(led1rosso, LOW);
      Tint +=300000;
      break;

    case 8:
      digitalWrite(led2rosso, LOW);
      Tint +=250;
      break;

    case 9:
      digitalWrite(Buzzer, HIGH);
      Tint +=1000;
      break;

    case 10:
      digitalWrite(Buzzer, LOW);
      Tint +=500;
      break;

    case 11:
      digitalWrite(Buzzer, HIGH);
      Tint +=1000;
      break;

    case 12:
      digitalWrite(Buzzer, LOW);
      Tint +=500;
      break;

    case 13:
      digitalWrite(Buzzer, HIGH);
      Tint +=3000;
      break;

    case 14:
      digitalWrite(Buzzer, LOW);
      Tint +=500;
      break;

    default:
      break;
    }
  }
}

void disarmed(){
  digitalWrite(ledDISARMED, LOW);
  digitalWrite(ledARMED, LOW);
}

Ho cambiato i pin perché mi serviva liberare la seriale.
Dopo caricato lo sketch apri il monitor seriale.

I pin analogici li puoi usare come digitali, funzionano! :grin:

non va :blush:

come si accende suona diretto. non fa fare nulla =(

Come hai collegato i pulsanti? Hai messo le pull-down?
Ho corretto il codice del countdown non la logica del programma.
Puoi spiegare qual'e la sequenza di azioni che vuoi che faccia il programma e quale deve essere la corretta sequenza dei pulsanti da premere?

dunque.

1: accensione e led DISARMED accesi. attesa input pulsante (non il terminale,quello centrale)

2: pressione pulsante centrale --> accensione 5 sec DISARMED poi si spengono, un BIP e si accende il countdown con i led ARMED.

3: durante il countdown il programma attende input che sono 2. combinazione e pulsante del terminale. se entrambe le condizioni sono HIGH si spegne tutto e si accende solo i led DISARMED. se si preme 3 volte il pulsante del terminale ma l'input della combinazione è LOW si blocca tutto e suona come se fosse finito il countdown.

4: alla fine di tutto,sia che sia stato premuto 3 volte il pulsante sia che sia terminato il tempo si deve resettare e ricominciare aspettando ancora il via con il pulsante centrale.