Luci scale in sequenza con Arduino: accensione automatica bidirezionale

const bool INPUT_ACTIVE_LOW = true;

const bool INPUT_ACTIVE_LOW = false;

/*
  LUCI SCALE IN SEQUENZA CON ARDUINO UNO
  Versione completa bidirezionale e non bloccante

  FUNZIONAMENTO
  - Sensore/pulsante BASSO: accensione dal gradino 1 al gradino 10.
  - Sensore/pulsante ALTO: accensione dal gradino 10 al gradino 1.
  - Dopo un tempo di permanenza, le luci si spengono nella stessa direzione.
  - La sequenza usa millis(): Arduino continua a leggere gli ingressi.

  USCITE GRADINI:
  D2  -> gradino 1
  D3  -> gradino 2
  D4  -> gradino 3
  D5  -> gradino 4
  D6  -> gradino 5
  D7  -> gradino 6
  D8  -> gradino 7
  D9  -> gradino 8
  D10 -> gradino 9
  D11 -> gradino 10

  INGRESSI:
  A0 -> comando/sensore lato BASSO
  A1 -> comando/sensore lato ALTO

  Per pulsanti:
  - collega il pulsante tra A0/A1 e GND
  - lascia INPUT_ACTIVE_LOW = true

  Per sensori PIR con uscita HIGH:
  - collega OUT a A0/A1
  - imposta INPUT_ACTIVE_LOW = false

  IMPORTANTE:
  Le uscite Arduino NON devono alimentare direttamente lampade,
  strisce LED potenti o carichi a 230 V.
  Usa MOSFET, driver o relè adeguati.
*/

const byte NUM_GRADINI = 10;

// Pin delle 10 uscite
const byte luci[NUM_GRADINI] = {
  2, 3, 4, 5, 6,
  7, 8, 9, 10, 11
};

// Ingressi di comando
const byte INGRESSO_BASSO = A0;
const byte INGRESSO_ALTO  = A1;

// true  = pulsanti verso GND con INPUT_PULLUP
// false = sensori che portano HIGH quando rilevano presenza
const bool INPUT_ACTIVE_LOW = true;

// Se i tuoi moduli di uscita sono active LOW,
// inverti questi due valori.
const byte LUCE_ON  = HIGH;
const byte LUCE_OFF = LOW;

// Tempo tra un gradino e il successivo
const unsigned long TEMPO_PASSO = 180;

// Quanto restano accese tutte le luci
const unsigned long TEMPO_ACCESE = 10000;

// Antirimbalzo / filtro ingresso
const unsigned long DEBOUNCE_MS = 60;

enum Stato {
  ATTESA,
  ACCENSIONE,
  PERMANENZA,
  SPEGNIMENTO
};

Stato stato = ATTESA;

// +1 = dal basso verso l'alto
// -1 = dall'alto verso il basso
int direzione = +1;

// Indice usato durante le sequenze
int indice = 0;

unsigned long ultimoPasso = 0;
unsigned long inizioPermanenza = 0;

// Variabili per evitare retrigger continui
bool ultimoBasso = false;
bool ultimoAlto  = false;
unsigned long ultimoCambioBasso = 0;
unsigned long ultimoCambioAlto  = 0;

void setup() {

  // Configura tutte le uscite
  for (byte i = 0; i < NUM_GRADINI; i++) {
    pinMode(luci[i], OUTPUT);
    digitalWrite(luci[i], LUCE_OFF);
  }

  // Configurazione ingressi
  if (INPUT_ACTIVE_LOW) {
    pinMode(INGRESSO_BASSO, INPUT_PULLUP);
    pinMode(INGRESSO_ALTO, INPUT_PULLUP);
  } else {
    pinMode(INGRESSO_BASSO, INPUT);
    pinMode(INGRESSO_ALTO, INPUT);
  }
}

void loop() {

  // Legge continuamente i due ingressi
  bool triggerBasso = ingressoAttivo(
    INGRESSO_BASSO,
    ultimoBasso,
    ultimoCambioBasso
  );

  bool triggerAlto = ingressoAttivo(
    INGRESSO_ALTO,
    ultimoAlto,
    ultimoCambioAlto
  );

  switch (stato) {

    // ------------------------------------------------
    // ATTESA
    // ------------------------------------------------
    case ATTESA:

      if (triggerBasso) {
        avviaSequenza(+1);
      }
      else if (triggerAlto) {
        avviaSequenza(-1);
      }

      break;

    // ------------------------------------------------
    // ACCENSIONE PROGRESSIVA
    // ------------------------------------------------
    case ACCENSIONE:

      if (millis() - ultimoPasso >= TEMPO_PASSO) {

        ultimoPasso = millis();

        digitalWrite(luci[indice], LUCE_ON);

        indice += direzione;

        // Fine della sequenza di accensione
        if (
          indice >= NUM_GRADINI ||
          indice < 0
        ) {
          stato = PERMANENZA;
          inizioPermanenza = millis();
        }
      }

      break;

    // ------------------------------------------------
    // TUTTE LE LUCI RESTANO ACCESE
    // ------------------------------------------------
    case PERMANENZA:

      // Se passa qualcuno dall'altro lato mentre
      // le luci sono accese, prolunga il tempo.
      if (triggerBasso || triggerAlto) {
        inizioPermanenza = millis();
      }

      if (
        millis() - inizioPermanenza >= TEMPO_ACCESE
      ) {

        // Per uno spegnimento visivamente naturale
        // partiamo dallo stesso lato da cui
        // era iniziata l'accensione.
        indice = (direzione == +1)
               ? 0
               : NUM_GRADINI - 1;

        ultimoPasso = millis();

        stato = SPEGNIMENTO;
      }

      break;

    // ------------------------------------------------
    // SPEGNIMENTO PROGRESSIVO
    // ------------------------------------------------
    case SPEGNIMENTO:

      // Se qualcuno arriva mentre stiamo spegnendo,
      // riaccendiamo la scala nella sua direzione.
      if (triggerBasso) {
        avviaSequenza(+1);
        break;
      }

      if (triggerAlto) {
        avviaSequenza(-1);
        break;
      }

      if (millis() - ultimoPasso >= TEMPO_PASSO) {

        ultimoPasso = millis();

        digitalWrite(luci[indice], LUCE_OFF);

        indice += direzione;

        if (
          indice >= NUM_GRADINI ||
          indice < 0
        ) {
          stato = ATTESA;
        }
      }

      break;
  }
}

// ----------------------------------------------------
// Avvia la sequenza nella direzione richiesta
// ----------------------------------------------------
void avviaSequenza(int nuovaDirezione) {

  direzione = nuovaDirezione;

  indice = (direzione == +1)
         ? 0
         : NUM_GRADINI - 1;

  ultimoPasso = millis();

  stato = ACCENSIONE;
}

// ----------------------------------------------------
// Restituisce true SOLO sul fronte di attivazione
// dell'ingresso, con un piccolo filtro antirimbalzo.
// ----------------------------------------------------
bool ingressoAttivo(
  byte pin,
  bool &ultimoStato,
  unsigned long &ultimoCambio
) {

  bool lettura;

  if (INPUT_ACTIVE_LOW) {
    lettura = (digitalRead(pin) == LOW);
  } else {
    lettura = (digitalRead(pin) == HIGH);
  }

  // Se lo stato cambia, memorizziamo il momento
  if (lettura != ultimoStato) {

    if (millis() - ultimoCambio >= DEBOUNCE_MS) {

      ultimoCambio = millis();
      ultimoStato = lettura;

      // Genera trigger solo quando passa a "attivo"
      if (lettura) {
        return true;
      }
    }
  }

  return false;
}

const unsigned long TEMPO_ACCESE = 10000;

const unsigned long TEMPO_PASSO = 180;