#define ledPin1 21
#define ledPin2 19
#define ledPin3 2

#define button1 33
#define button2 25
#define button3 26
#define buttonrst 14

#define ESTADO_0 0
#define ESTADO_1 1
#define ESTADO_2 2
#define ESTADO_3 3

volatile int state = ESTADO_0;
volatile int counter = 0;
volatile int counter1 = 0;


volatile bool b1_interrupted = false;
volatile bool b1_pressed = false;

volatile bool b2_interrupted = false;
volatile bool b2_pressed = false;

volatile bool b3_interrupted = false;
volatile bool b3_pressed = false;

volatile bool rst_pressed = false;

volatile bool timer0_interrupted = false;
volatile bool timer1_interrupted = false;

volatile bool long_pressed = false;
volatile bool ok = false;  //Variable de fin de cuenta del parpadeo

hw_timer_t *timer0 = NULL;
hw_timer_t *timer1 = NULL;

void IRAM_ATTR button_1_ISR() {
  b1_interrupted = true;
  b1_pressed = !b1_pressed; // Cambiar estado al detectar cambio
}

void IRAM_ATTR button_2_ISR() {
  b2_interrupted = true;
  b2_pressed = !b2_pressed;
}

void IRAM_ATTR button_3_ISR() {
  b3_interrupted = true;
  b3_pressed = !b3_pressed;
}

void IRAM_ATTR button_rst_ISR() {
  rst_pressed = true;
  // if(state != 0) state = ESTADO_0;
  resetVariables();
}

void IRAM_ATTR timer_count() {
  timer0_interrupted = true;
  //Serial.println(counter);
}

void IRAM_ATTR timer_blink() {
  timer1_interrupted = true;
}

void resetVariables() {
  counter = 0;
  long_pressed = false;
  ok = false;
  timer0_interrupted = false;
  timer1_interrupted = false;
  b1_interrupted = false;
  b2_interrupted = false;
  timerAlarmDisable(timer1);
  timerAlarmDisable(timer0);

}


void FineStateMachine() {
  switch (state) {
    case ESTADO_0:

      if (b1_interrupted) {
        counter = 0;
        b1_interrupted = false;
        if (b1_pressed) {
          Serial.println("Boton 1, presionado. Timer 0 arrancado");
          timerRestart(timer0);
          timerAlarmEnable(timer0);
        } else {
          Serial.println("Boton 1, soltado. Timer 0 parado");
          timerAlarmDisable(timer0);
          if (!long_pressed) {
            Serial.println("Pulsacion corta, parpadea 3 veces y estado 1");
            timerRestart(timer1);
            timerAlarmEnable(timer1);
          } else {
            Serial.println("Pulsacion larga parpadea 3 veces y , reset a estado 0");
            timerRestart(timer1);
            timerAlarmEnable(timer1);
          }
        }
      }

      if (timer0_interrupted) {
        Serial.println("Es larga");
        long_pressed = true;
        timer0_interrupted = false;
      }

      if (timer1_interrupted) {
        counter++;
        if (counter < 6) {
          digitalWrite(ledPin1, !digitalRead(ledPin1));
        } else {
          counter = 0;
          ok = true;
          timerAlarmDisable(timer1);
        }
        timer1_interrupted = false;
      }

      //Si ha cumplido los parpadeos, y fue corta. Estado 1

      if (ok && !long_pressed) {
        state = ESTADO_1;
        digitalWrite(ledPin1, HIGH);
        Serial.println("Siguiente estado -> 1");
        resetVariables();
      }
      //Si ha cumplido los parpadeos, y fue larga. Estado 0

      if (ok && long_pressed) {
        state = ESTADO_0;
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, LOW);
        digitalWrite(ledPin3, LOW);
        Serial.println("Siguiente estado -> 0");
        resetVariables();
      }
      break;

    case ESTADO_1:

      if (b2_interrupted) {
        counter = 0;
        b2_interrupted = false;
        if (b2_pressed) {
          Serial.println("Boton 2, presionado. Timer 0 arrancado");
          timerRestart(timer0);
          timerAlarmEnable(timer0);
        } else {
          Serial.println("Boton 2, soltado. Timer 0 parado");
          timerAlarmDisable(timer0);
          if (long_pressed) {
            Serial.println("Pulsacion larga, parpadea 3 veces y estado 2");
            timerRestart(timer1);
            timerAlarmEnable(timer1);
          } else {
            Serial.println("Pulsacion corta parpadea 3 veces y , reset a estado 0");
            timerRestart(timer1);
            timerAlarmEnable(timer1);
          }
        }
      }

      if (timer0_interrupted) {
        Serial.println("Es larga");
        long_pressed = true;
        timer0_interrupted = false;
      }

      if (timer1_interrupted) {
        Serial.println("Estado 1, se mete en contador");
        counter++;
        if (counter < 6) {
          digitalWrite(ledPin2, !digitalRead(ledPin2));
        } else {
          counter = 0;
          ok = true;
          timerAlarmDisable(timer1);
        }
        timer1_interrupted = false;
      }

      //Si ha cumplido los parpadeos, y fue larga. Estado 2

      if (ok && long_pressed) {
        state = ESTADO_2;
        digitalWrite(ledPin2, HIGH);
        Serial.println("Siguiente estado -> 2");
        ok = false;
        resetVariables();
      }
      //Si ha cumplido los parpadeos, y fue corta. Estado 0
      if (ok && !long_pressed) {
        state = ESTADO_0;
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, LOW);
        digitalWrite(ledPin3, LOW);
        Serial.println("Siguiente estado -> 0");
        ok = false;
        resetVariables();
      }
      break;

    case ESTADO_2:

      if (b3_interrupted) {
        counter = 0;
        b3_interrupted = false;
        if (b3_pressed) {
          Serial.println("Boton 3, presionado. Timer 0 arrancado");
          timerRestart(timer0);
          timerAlarmEnable(timer0);
        } else {
          Serial.println("Boton 3, soltado. Timer 0 parado");
          timerAlarmDisable(timer0);
          if (!long_pressed) {
            Serial.println("Pulsacion corta, parpadea 3 veces y estado 3");
            timerRestart(timer1);
            timerAlarmEnable(timer1);
          } else {
            Serial.println("Pulsacion larga parpadea 3 veces y , reset a estado 0");
            timerRestart(timer1);
            timerAlarmEnable(timer1);
          }
        }
      }

      if (timer0_interrupted) {
        Serial.println("Es larga");
        long_pressed = true;
        timer0_interrupted = false;
      }

      if (timer1_interrupted) {
        counter++;
        if (counter < 6) {
          digitalWrite(ledPin3, !digitalRead(ledPin3));
        } else {
          counter = 0;
          ok = true;
          timerAlarmDisable(timer1);
        }
        timer1_interrupted = false;
      }

      //Si ha cumplido los parpadeos, y fue larga. Estado 0

      if (ok && long_pressed) {
        state = ESTADO_0;
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, LOW);
        digitalWrite(ledPin3, LOW);
        Serial.println("Siguiente estado -> 0");
        resetVariables();
      }

      //Si ha cumplido los parpadeos, y fue corta. Estado 3

      if (ok && !long_pressed) {
        digitalWrite(ledPin1, HIGH);
        digitalWrite(ledPin2, HIGH);
        digitalWrite(ledPin3, HIGH);
        state = ESTADO_3;
        Serial.println("Siguiente estado -> 3");
        resetVariables();
        timerRestart(timer1);
        timerAlarmEnable(timer1);
      }

      break;

    case ESTADO_3:

      if (timer1_interrupted) {
        digitalWrite(ledPin1, !digitalRead(ledPin1));
        digitalWrite(ledPin2, !digitalRead(ledPin2));
        digitalWrite(ledPin3, !digitalRead(ledPin3));
        timer1_interrupted = false;
      }

      if (rst_pressed) {
        rst_pressed = false;
        state = ESTADO_0;
        Serial.println("FINAL, CODIGO CORRECTO. ESTADO 0");
        digitalWrite(ledPin1, LOW);
        digitalWrite(ledPin2, LOW);
        digitalWrite(ledPin3, LOW);
        resetVariables();
      }
      break;
  }
}
void setup() {
  Serial.begin(9600);

  // Configurar pines de botones y LEDs
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  pinMode(button3, INPUT_PULLUP);
  pinMode(buttonrst, INPUT_PULLUP);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);

  // Configurar interrupciones
  attachInterrupt(digitalPinToInterrupt(button1), button_1_ISR, CHANGE);
  attachInterrupt(digitalPinToInterrupt(button2), button_2_ISR, CHANGE);
  attachInterrupt(digitalPinToInterrupt(button3), button_3_ISR, CHANGE);
  attachInterrupt(digitalPinToInterrupt(buttonrst), button_rst_ISR, FALLING);

  // Configurar temporizador
  timer0 = timerBegin(0, 80, true);
  timerAttachInterrupt(timer0, &timer_count, true);
  timerAlarmWrite(timer0, 1000000, true); // Aviso cada 1s

  timer1 = timerBegin(1, 80, true);
  timerAttachInterrupt(timer1, &timer_blink, true);
  timerAlarmWrite(timer1, 500000, true); // Aviso cada 0.5s
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, LOW);
  digitalWrite(ledPin3, LOW);

}
void loop() {
  FineStateMachine();
  delay(10); // Pequeña espera para evitar rebotes
  //Serial.println(state);
}





//SIRVE:
/*
  #define ledPin1 21
  #define ledPin2 19

  #define button1 33
  #define buttonrst 14

  #define ESTADO_0 0
  #define ESTADO_1 1

  volatile int state = ESTADO_0;
  volatile int counter = 0;

  volatile bool b1_interrupted = false;
  volatile bool b1_pressed = false;

  volatile bool timer0_interrupted = false;
  volatile bool timer1_interrupted = false;

  volatile bool long_pressed = false;
  volatile bool parpadeando = false;
  volatile bool ok = false;

  hw_timer_t *timer0 = NULL;
  hw_timer_t *timer1 = NULL;




  void IRAM_ATTR button_1_ISR() {
  b1_interrupted = true;
  b1_pressed = !b1_pressed; // Cambiar estado al detectar cambio
  }

  void IRAM_ATTR button_rst_ISR() {
  state = ESTADO_0;
  timerAlarmDisable(timer0);
  timerAlarmDisable(timer1);
  timerRestart(timer0);  // Asegura reinicio
  timerRestart(timer1);  // Asegura reinicio
  counter = 0;
  long_pressed = false;
  ok = false;
  Serial.print("Tras reset, estado -->");
  Serial.println(state);
  }


  void IRAM_ATTR timer_count() {
  timer0_interrupted = true;
  }

  void IRAM_ATTR timer_blink() {
  timer1_interrupted = true;
  }

  void FineStateMachine() {
  switch (state) {
    case ESTADO_0:
      digitalWrite(ledPin1, LOW);
      digitalWrite(ledPin2, LOW);

      if (b1_interrupted) {
        counter = 0;
        b1_interrupted = false; // Reset de interrupción
        if (b1_pressed) {
          Serial.println("Boton 1, presionado. Timer 0 arrancado");
          timerRestart(timer0);
          timerAlarmEnable(timer0);
        } else {
          Serial.println("Boton 1, soltado. Timer 0 parado");
          timerAlarmDisable(timer0);
          if (!long_pressed) {
            Serial.println("Pulsacion corta, parpadea 3 veces y estado 1");
            timerAlarmEnable(timer1);
          } else {
            Serial.println("Pulsacion larga parpadea 3 veces y , reset a estado 0");
            timerAlarmEnable(timer1);
          }
        }
      }

      if (timer0_interrupted) {
        Serial.println("Es larga");
        long_pressed = true;
        timer0_interrupted = false;
      }

      if (timer1_interrupted) {
        counter++;
        if (counter < 4) {
          digitalWrite(ledPin1, !digitalRead(ledPin1));
        } else {
          counter = 0;
          ok = true;
          timerAlarmDisable(timer1);
        }
        timer1_interrupted = false;
      }

      //Si ha cumplido los parpadeos, y fue corta. Estado 1
      if (ok && !long_pressed) {
        state = ESTADO_1;
        digitalWrite(ledPin1, HIGH);
        Serial.println("Siguiente estado -> 1");
        ok = false;
      }
      //Si ha cumplido los parpadeos, y fue larga. Estado 0
      if (ok && long_pressed) {
        state = ESTADO_0;
        Serial.println("Siguiente estado -> 0");
        ok = false;
      }
      break;

    case ESTADO_1:
      Serial.println("Estado 1");
      digitalWrite(ledPin2, HIGH);
      break;
  }
  }

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

  // Configurar pines de botones y LEDs
  pinMode(button1, INPUT_PULLUP);
  pinMode(buttonrst, INPUT_PULLUP);
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);


  // Configurar interrupciones
  attachInterrupt(digitalPinToInterrupt(button1), button_1_ISR, CHANGE);
  attachInterrupt(digitalPinToInterrupt(buttonrst), button_rst_ISR, FALLING);

  // Configurar temporizador
  timer0 = timerBegin(0, 80, true);
  timerAttachInterrupt(timer0, &timer_count, true);
  timerAlarmWrite(timer0, 2000000, true); // Aviso cada 1s
  //timerAlarmEnable(timer0);

  timer1 = timerBegin(1, 80, true);
  timerAttachInterrupt(timer1, &timer_blink, true);
  timerAlarmWrite(timer1, 500000, true); // Aviso cada 0.5s
  //timerAlarmEnable(timer1);
  }
  void loop() {
  FineStateMachine();
  delay(10); // Pequeña espera para evitar rebotes
  //Serial.println(state);
  }

*/





/*

  #define LED_PIN 26        // LED conectado a GPIO26
  #define BUTTON_PIN 14     // BUTTON conectado a GPIO14

  hw_timer_t *timer0 = NULL; // Puntero al timer0 del hardware
  hw_timer_t *timer1 = NULL; // Puntero al timer1 del hardware

  volatile uint8_t interrupt_counter = 0;        // Variable volátil para contar cuántas veces se produce la interrupción
  volatile uint8_t fsm_state = 0;                // Variable volátil para almacenar el estado de la FSM
  volatile bool long_pressed = false;            // Variable volátil para detectar cuándo se ha presionado
  volatile uint8_t timer1_interrupt_counter = 0; // Variable volátil para contar los segundos que está pulsado el botón
  volatile bool button_pressed = false;          // Variable volátil que almacena el estado del botón (true = pulsado)
  volatile bool button_interrupted = false;      // Variable volátil que indica si el botón se ha interrumpido o no
  volatile bool timer0_interrupted = false;      // Variable volátil que indica si ha habido una interrupción del timer0
  volatile bool timer1_interrupted = false;      // Variable volátil que indica si ha habido una interrupción del timer1


  // Callback ISR botón cambia de estado (se pulsa o se suelta)
  void IRAM_ATTR buttonStateChange()
  {
  button_interrupted = true;        // Se ha interrumpido el botón
  button_pressed = !button_pressed; // Almaceno el cambio el estado del botón
  }

  // Callback ISR interrupción del timer 0
  void IRAM_ATTR timer0Interrupt()
  {
  timer0_interrupted = true;
  }

  // Callback ISR interrupción del timer 1
  void IRAM_ATTR timer1Interrupt()
  {
  timer1_interrupted = true;
  }

  // Función setup
  void setup()
  {
  Serial.begin(115200);

  // Establecer modos de los GPIO digitales del LED y BUTTON
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  // Inicializar interrupción por pulsación del botón
  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), buttonStateChange, CHANGE); // Flanco de bajada = botón se presiona

  // Inicializar el timer0
  // Parámetro 1: Timer que queremos usar. El ESP32 tiene 4 timers => valores válidos 0,1,2,3
  // Parámetro 2: Prescaler. El reloj por defecto del ESP32 va a 80MHz. Si ponemos 80, dividimos el reloj por 80, dándonos 1 000 000 ticks/s
  // Parámetro 3: true indica que el timer empieza en ON, false sería OFF
  timer0 = timerBegin(0, 80, true);                     // Timer 0, divisor de reloj 80
  timerAttachInterrupt(timer0, &timer0Interrupt, true); // Adjuntar la función de manejo de interrupción
  timerAlarmWrite(timer0, 5e5, true);                   // Interrupción cada medio segundo (500ms ON, 500ms OFF)

  // Inicializar el timer1
  timer1 = timerBegin(1, 80, true);                     // Timer 1, divisor de reloj 80
  timerAttachInterrupt(timer1, &timer1Interrupt, true); // Adjuntar la función de manejo de interrupción
  timerAlarmWrite(timer1, 1e6, true);                   // Interrupción cada segundo

  // Empezamos con el LED apagado
  digitalWrite(LED_PIN, LOW);
  }

  // Función loop
  void loop()
  {
  switch (fsm_state) {
    case 0: // Estoy en el estado 0 - LED apagado
      if (button_interrupted) { // Si ha habido una interrupción del botón
        if (button_pressed) { // Si está pulsado
          Serial.println("Button pressed");
          Serial.println("Counting time ON");
          timerAlarmEnable(timer1); // Activo el timer1 para que empiece a contar el tiempo
        } else {
          Serial.println("Button released");
        }
        else
        {
          if (!long_pressed) // Presionado menos de 1s
          {
            digitalWrite(LED_PIN, !digitalRead(LED_PIN)); // Se cambia el estado del LED
            fsm_state = int(digitalRead(LED_PIN));        // FSM en estado 0 si el LED está apagado, 1 si está encendido
            Serial.println(fsm_state);                    // Deubg
            timerAlarmDisable(timer0); // Desactivo el timer0 para dejar a parpadear
          }
          else // Presionado más de 1s
          {
            timerAlarmEnable(timer0); // Activo el timer0 para empezar a parpadear
            Serial.println("Counting time OFF");
          }
          // Desactivo el timer1 para que dejar de contar el tiempo
          timerAlarmDisable(timer1); // Deshabilitar timer 1
          Serial.println("Counting time OFF");
          long_pressed = false; // Se pone a FALSE la variable booleana que indica que la pulsación ha sido larga
          timer1_interrupt_counter = 0;
        }
        button_interrupted = false;
      }

      if (timer1_interrupted) { // Si se ha interrumpido el timer1
        long_pressed = true; // Se pone a TRUE la variable booleana que indica que la pulsación ha sido larga
        timer1_interrupted = false;  // Desactivo la variable de control de interrupción del timer1
      }


      break;
    case 1: // Estoy en el estado 1 - LED encendido
      if (button_interrupted && !button_pressed) { // Si se ha habido una interrupción del botón y se ha soltado el botón - Ir a estado 0
        Serial.println("Button released");
        digitalWrite(LED_PIN, LOW);   // Apagar el LED
        fsm_state = 0;                // FSM va al estado 0
        Serial.println(fsm_state);    // Debug
        button_interrupted = false;   // Desactivo la variable de control de interrupción del botón
      }
      break;
    case 2: // Estoy en el estado 2 - LED parpadeando
      if (timer0_interrupted) { // Si hay una interrupción del timer0 - parpadear
        digitalWrite(LED_PIN, !digitalRead(LED_PIN)); // Alternar el estado del LED
        timer0_interrupted = false;                   // Desactivo la variable de control de interrupción del timer0
      }
      if (button_interrupted && !button_pressed) { // Si se ha habido una interrupción del botón y se ha soltado el botón - Ir a estado 0
        Serial.println("Button released");
        digitalWrite(LED_PIN, LOW);
        fsm_state = 0;
        Serial.println(fsm_state);
        timerAlarmDisable(timer0); // Deshbilitar timer 0
        timerAlarmDisable(timer1); // Deshbilitar timer 1
        Serial.println("Counting time OFF");
        timer1_interrupt_counter = 0;
        long_pressed = false; // Poner a FALSE la variable long_pressed
        button_interrupted = false;   // Desactivo la variable de control de interrupción del botón
      }

      break;

  }
  delay(10); // Necesario para el rendimiento en Wokwi
  }

*/

/*
  #define ledPin1 21
  #define ledPin2 19
  #define ledPin3 2

  #define button1 33
  #define button2 25
  #define button3 26

  #define buttonrst 14 // Botón para resetear al estado 0

  #define ESTADO_0 0 // LED apagado
  #define ESTADO_1 1 //Pulsacion corta de button1
  #define ESTADO_2 2 //Pulsacion larga de button2
  #define ESTADO_3 3

  int conmuta = 0;

  volatile bool pulsarButton1 = false;
  volatile bool soltarButton1 = false;

  volatile bool pulsarButton2 = false;
  volatile bool soltarButton2 = false;

  volatile bool pulsarButton3 = false;
  volatile bool soltarButton3 = false;

  volatile bool pulsarButtonrst = false;
  volatile bool soltarButtonrst = false;

  volatile int state = ESTADO_0;
  volatile // Contador para el tiempo de pulsación del botón
  volatile int blinkCount = 0; // Contador para el parpadeo de 3 veces

  unsigned long previousMillis = 0;  // Variable para el temporizador
  unsigned long interval = 500;  // Intervalo de parpadeo (500 ms)

  hw_timer_t *timer0 = NULL;
  hw_timer_t *timer1 = NULL;

  void IRAM_ATTR button_1_ISR() {
  if (!digitalRead(button1)) { // Flanco de bajada (botón presionado)
    pulsarButton1 = tru // Iniciar contador al presionar el botón
    timerStart(timer0);
  } else { // Flanco de subida (botón soltado)
    soltarButton1 = true;
    timerStop(timer0);
  }
  }

  void IRAM_ATTR button_2_ISR() {
  if (!digitalRead(button2)) { // Flanco de bajada (botón presionado)
    pulsarButton2 = tru // Iniciar contador al presionar el botón
    timerStart(timer0);
  } else { // Flanco de subida (botón soltado)
    soltarButton2 = true;
    timerStop(timer0);
  }
  }

  void IRAM_ATTR button_3_ISR() {
  if (!digitalRead(button3)) { // Flanco de bajada (botón presionado)
    pulsarButton3 = tru // Iniciar contador al presionar el botón
    timerStart(timer0);
  } else { // Flanco de subida (botón soltado)
    soltarButton3 = true;
    timerStop(timer0);
  }
  }

  void IRAM_ATTR button_rst_ISR() {
  if (!digitalRead(buttonrst)) { // Flanco de bajada (botón de reset presionado)
    pulsarButtonrst = tru // Reiniciar el contador al presionar el botón de reset
    timerStop(timer0);
    timerStop(timer1); // Detener el temporizador de parpadeo
  } else { // Flanco de subida (botón de reset soltado)
    soltarButtonrst = true;
  }
  }

  void IRAM_ATTR cambiarEstadoLED() {

  if (conmuta == 1) {
    if (blinkCount < 3) {
      digitalWrite(ledPin1, !digitalRead(ledPin1)); // Cambiar el estado del LED (parpadeo)
      if (digitalRead(ledPin1) == HIGH) {
        blinkCount++; // Incrementar el contador de parpadeo
      }
    } else {
      //digitalWrite(ledPin1, HIGH); // Después de 3 parpadeos, el LED se queda fijo
      timerStop(timer1); // Detener el parpadeo
    }
  }

  if (conmuta == 2) {
    if (blinkCount < 3) {
      digitalWrite(ledPin2, !digitalRead(ledPin2)); // Cambiar el estado del LED (parpadeo)
      if (digitalRead(ledPin2) == HIGH) {
        blinkCount++; // Incrementar el contador de parpadeo
      }
    } else {
      digitalWrite(ledPin2, HIGH); // Después de 3 parpadeos, el LED se queda fijo
      timerStop(timer1); // Detener el parpadeo
    }
  }

  if (conmuta == 3) {
    if (blinkCount < 3) {
      digitalWrite(ledPin3, !digitalRead(ledPin3)); // Cambiar el estado del LED (parpadeo)
      if (digitalRead(ledPin3) == HIGH) {
        blinkCount++; // Incrementar el contador de parpadeo
      }
    } else {
      digitalWrite(ledPin3, HIGH); // Después de 3 parpadeos, el LED se queda fijo
      timerStop(timer1); // Detener el parpadeo
    }
  }

    if (conmuta == 4) {
    digitalWrite(ledPin1, !digitalRead(ledPin1));
    digitalWrite(ledPin2, !digitalRead(ledPin2));
    digitalWrite(ledPin3, !digitalRead(ledPin3)); // Cambiar el estado del LED (parpadeo)
    }

  }

  void timerON() {
  counter++; // Incrementar el contador de tiempo
  }
  String est = "inicializado";  // Valor inicial

  void FineStateMachine() {
  switch (state) {
    case ESTADO_0: // Estado 0: TODO APAGADO
      digitalWrite(ledPin1, LOW); // Cambié ledPin por ledPin1
      digitalWrite(ledPin2, LOW); // Añadí ledPin2 también apagado
      digitalWrite(ledPin3, LOW); // Añadí ledPin2 también apagado

      if (pulsarButton1 && soltarButton1) {
        // Si el botón se presionó menos de 1 segundo
        if (counter < 2) {
          state = ESTADO_1;
          conmuta = 1;
          blinkCount = 0; // Reiniciar el contador de parpadeo
          timerStart(timer1); // Comenzar el parpadeo
          est = "corta"; // Actualizar el estado
        }
        // Si el botón se presionó más de 1 segundo
        else {
          state = ESTADO_0; // LED apagado, permanece en estado 0
          conmuta = 1;
          blinkCount = 0; // Reiniciar el contador de parpadeo
          timerStart(timer1); // Comenzar el parpadeo
          est = "larga"; // Actualizar el estado
        }
        pulsarButton1 = false;
        soltarButton1 = false;
      }

      if (pulsarButton2 && soltarButton2) {
        state = ESTADO_0;
        pulsarButton2 = false;
        soltarButton2 = false;
      }
      if (pulsarButton3 && soltarButton3) {
        state = ESTADO_0;
        pulsarButton3 = false;
        soltarButton3 = false;
      }
      if (pulsarButtonrst && soltarButtonrst) {
        est = "inicializado";
        state = ESTADO_0;
        pulsarButtonrst = false;
        soltarButtonrst = false;
      }
      break;


    case ESTADO_1:
      //digitalWrite(ledPin1, HIGH); // Mantener el LED 1 encendido
      if (pulsarButton1 && soltarButton1) {
        state = ESTADO_0;
        pulsarButton1 = false;
        soltarButton1 = false;
      }
      if (pulsarButton2 && soltarButton2) {
        // Si el botón se presionó mas de 1 segundo
        if (counter > 2) {
          state = ESTADO_2;
          conmuta = 2;
          blinkCount = 0; // Reiniciar el contador de parpadeo
          timerStart(timer1); // Comenzar el parpadeo
          est = "larga"; // Actualizar el estado
        }
        // Si el botón se presionó más de 1 segundo
        else {
          state = ESTADO_0; // LED apagado, permanece en estado 0
          conmuta = 2;
          blinkCount = 0; // Reiniciar el contador de parpadeo
          timerStart(timer1); // Comenzar el parpadeo
          est = "corta"; // Actualizar el estado

        }
        pulsarButton2 = false;
        soltarButton2 = false;
      }
      if (pulsarButton3 && soltarButton3) {
        state = ESTADO_0;
        pulsarButton3 = false;
        soltarButton3 = false;
      }
      if (pulsarButtonrst && soltarButtonrst) {
        est = "inicializado";
        state = ESTADO_0;
        pulsarButtonrst = false;
        soltarButtonrst = false;
      }
      break;

    case ESTADO_2:
      if (pulsarButton1 && soltarButton1) {
        state = ESTADO_0;
        pulsarButton1 = false;
        soltarButton1 = false;
      }
      if (pulsarButton2 && soltarButton2) {
        state = ESTADO_0;
        pulsarButton2 = false;
        soltarButton2 = false;
      }
      if (pulsarButton3 && soltarButton3) {
        // Si el botón se presionó menos de 1 segundo
        if (counter < 2) {
          conmuta = 3;
          state = ESTADO_3;
          blinkCount = 0; // Reiniciar el contador de parpadeo
          timerStart(timer1); // Comenzar el parpadeo
          est = "corta"; // Actualizar el estado
          //conmuta = 4;
        }
        // Si el botón se presionó más de 1 segundo
        else {
          conmuta = 3;
          blinkCount = 0; // Reiniciar el contador de parpadeo
          timerStart(timer1); // Comenzar el parpadeo
          est = "larga"; // Actualizar el estado
          state = ESTADO_0; // LED apagado, permanece en estado 0

        }
        pulsarButton3 = false;
        soltarButton3 = false;
      }
      if (pulsarButtonrst && soltarButtonrst) {
        est = "inicializado";
        state = ESTADO_0;
        pulsarButtonrst = false;
        soltarButtonrst = false;
      }
      break;

    case ESTADO_3:
      //hacer que parpadee indefinidamente
      //conmuta = 4;
      if (pulsarButtonrst && soltarButtonrst) {
        state = ESTADO_0; // Vuelve al estado 0
        pulsarButtonrst = false;
        soltarButtonrst = false;
      }
      break;
  }

  }



  void setup() {
  Serial.begin(9600);
  pinMode(button1, INPUT_PULLUP);   // Configura el botón1 con pullup
  pinMode(button2, INPUT_PULLUP);   // Configura el botón2 con pullup
  pinMode(button3, INPUT_PULLUP);   // Configura el botón3 con pullup

  pinMode(buttonrst, INPUT_PULLUP); // Configura el botón de reset con pullup
  pinMode(ledPin1, OUTPUT);          // Configura el LED 1 como salida
  pinMode(ledPin2, OUTPUT);          // Configura el LED 2 como salida
  pinMode(ledPin3, OUTPUT);          // Configura el LED 3 como salida

  // Configuración de interrupciones
  attachInterrupt(digitalPinToInterrupt(button1), button_1_ISR, CHANGE); // Interrupción en ambos flancos para el botón1
  attachInterrupt(digitalPinToInterrupt(button2), button_2_ISR, CHANGE); // Interrupción en ambos flancos para el botón2
  attachInterrupt(digitalPinToInterrupt(button3), button_3_ISR, CHANGE); // Interrupción en ambos flancos para el botón3
  attachInterrupt(digitalPinToInterrupt(buttonrst), button_rst_ISR, CHANGE);  // Interrupción en ambos flancos para el botón de reset

  // Configuración de temporizadores
  timer0 = timerBegin(0, 80, true); // Timer 0, divisor de reloj 80
  timerAttachInterrupt(timer0, &timerON, true);
  timerAlarmWrite(timer0, 500000, true); // Aviso cada 500,000 ms
  timerAlarmEnable(timer0); // Habilitar la alarma

  timer1 = timerBegin(1, 80, true); // Timer 1, divisor de reloj 80
  timerAttachInterrupt(timer1, &cambiarEstadoLED, true);
  timerAlarmWrite(timer1, 500000, true); // Aviso cada 500,000 ms
  timerAlarmEnable(timer1); // Habilitar la alarma
  timerStop(timer0);
  timerStop(timer1);
  }

  void loop() {
  FineStateMachine();
  //Serial.println(state);
  //Serial.println(est);

  delay(10);
  }


*/