// LIBRERIAS
#include "pt.h"      // Lib. para tareas paralelas*
#include <EEPROM.h>  // Se incluye lib. para uso de memoria EEPROM

//DEFINICION DE PINES
const int PULS_ACT_GIRO = 4;  // Pin sg. de activación solenoide
const int PULS_LIB_SOLE = 2;  // Pin sg. de liberación solenoide
const int PULS_DEL_COUTN = 7; // Pin sg. para borrar conteo
const int SOLENOIDE = 12;  // Pin rele (de solenoide)

//DEFINICION DE VARIABLES
// ** EJECUCION TORNO **
int count = 0;  // Var. para almac. registros de conteo
// Variables que cambian
// Primer ANTI-REBOTE para sg. act. Solenoide
int estadoLed = LOW;          // estado actual del pin de salida
int estadoPulsador;           // lee el estado actual del pin de entrada
int ultimoEstadoPuls = HIGH;  // lee el estado anterior del pulsador
// Las siguientes variables son de long porque el tiempo, medido en milisegundos,
// se convertirá rápidamente en un número más grande que puede ser almacenada en un int.
long ultimoTiempoRebote = 0;  // la última vez que el pin de salida se conmuta
long retardoRebote = 5;       // El tiempo de rebote; aumentar si los parpadeos de salida son superiores
// Variables para retardo de act. solenoide
unsigned long timing1 = 0;              // Primer temporizador
unsigned long timing2 = 0;             // Segundo temporizador

// Ejecuciones
struct pt hilo1;  // Para EjecParpadeo de ejecución
struct pt hilo2;  // Para ejecución actividad torno
struct pt hilo3;  // Para ejecución borrado conteo

unsigned long intervalo = 10000;      // Tiempo de retardo de habilitado
bool aux = false;                       // Para validar cuando fue activado Solenoide

void setup() {
  // Se inicia comuc. serial
  Serial.begin(9600);
  Serial.println("Inicio...");

  // Inic. de hilos de ejecución
  PT_INIT(&hilo1);  // Hilo para ejec. parpadeo
  PT_INIT(&hilo2);  // Hilo para ejec. torno
  PT_INIT(&hilo3);  // Hilo para ejec. encerado de conteo

  // Definición de modos de pines
  pinMode(PULS_ACT_GIRO, INPUT_PULLUP);
  pinMode(PULS_LIB_SOLE, INPUT_PULLUP);
  pinMode(PULS_DEL_COUTN, INPUT);
  pinMode(SOLENOIDE, OUTPUT);

  // Definición de interrupciones
  attachInterrupt(digitalPinToInterrupt(PULS_LIB_SOLE), liberarSolenoide, RISING);

  // Inicio de conteo con el ultimo registro guardado en EEPROM
  count = EEPROM.get(0, count);
}

void loop() {
  // Ejecuciones const.
  EjecParpadeo(&hilo1);
  EjecTorno(&hilo2);
  EjecborrarConteo(&hilo3);
}


void EjecParpadeo(struct pt *pt) {
  PT_BEGIN(pt);
  // void setup() {
  static long t = 0;
  pinMode(13, OUTPUT);
  // }

  do {
    // void loop() {
    // Enciende led cada 0.5 s
    digitalWrite(13, HIGH);
    t = millis();
    PT_WAIT_WHILE(pt, (millis() - t) < 500);

    digitalWrite(13, LOW);
    t = millis();
    PT_WAIT_UNTIL(pt, (millis() - t) >= 500);
    // }
  } while (true);
  PT_END(pt);
}

void EjecTorno(struct pt *pt) {
  // Lee sg cuando se activa solenoide
  int sensorVal = digitalRead(PULS_ACT_GIRO);

  // Si el interruptor cambió, debido al ruido, o pulsando:
  if (sensorVal != ultimoEstadoPuls) {
    // restablecer el temporizador de supresión de rebotes
    ultimoTiempoRebote = millis();
  }

  if ((millis() - ultimoTiempoRebote) > retardoRebote) {
    // cualquiera que sea la lectura que se mantiene más tiempo
    // que el retardo de entrada, así que se toma como el estado actual real:

    // Si el estado del botón ha cambiado:
    if (sensorVal != estadoPulsador) {
      estadoPulsador = sensorVal;

      // solo conmuta el LED si el nuevo estado del pulsador es LOW
      if (estadoPulsador == LOW && aux == false) {
        estadoLed = !estadoLed;
        count++;               // Incrementa conteo
        EEPROM.put(0, count);  // Guarda el valor de conteo en EEPROM
        Serial.println(count);
        digitalWrite(SOLENOIDE, HIGH);
        //delay(5000);
        aux = true;          // Auxiliar en true cuando se haya recibio sg. de act. solenoide
        timing1 = millis();  // Captura el tiempo en el que fue recibi la sg. de act. solenoide
      }
    }
  }

  // Retardo - tiempo que se mantiene solenoide act.
  timing2 = millis();  // Captura el tiempo de ejecución const.
  // La diferencia entre el tiempo timing2 y timing1 debe ser igual al intervalo de act. solenoide
  if ((timing2 - timing1) == intervalo && aux == true) {
    digitalWrite(SOLENOIDE, LOW);
    Serial.println("CERRADO");
    aux = false;  // Auxiliar en true cuando no se haya recibio sg. de act. solenoide
  }
  // Guardar la lectura. La próxima vez a través del bucle,
  // que va a ser el lastButtonState:
  ultimoEstadoPuls = sensorVal;
}

void liberarSolenoide() {
  digitalWrite(SOLENOIDE, LOW);
  aux = false;
}

void EjecborrarConteo(struct pt *pt) {
  // Si el pulsador de borrador fue pulsado se establece conteo en 0
  int sensorVal2 = digitalRead(PULS_DEL_COUTN);

  if (sensorVal2 == HIGH) {
    count = 0;
    EEPROM.put(0, count);
    Serial.println(count);
  }
}