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

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;
const int SOLENOIDE = 12;  // Pin rele (de solenoide)

const int CLK = 11;    // Pin para CLK de Display
const int DIO = 10;   // Pin para sg. de Display

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

// Segundo ANTI-REBOTE para sg. encerado conteo
int estadoPulsador2;           // lee el estado actual del pin de entrada
int ultimoEstadoPuls2 = LOW;  // 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
long retardoRebote2 = 20;       // El tiempo de rebote; aumentar si los parpadeos de salida son superiores

// 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

// Variables para retardo de act. solenoide
unsigned long timing1 = 0;              // Primer temporizador
unsigned long timing2 = 0;             // Segundo temporizador
unsigned long intervalo = 10000;      // Tiempo de retardo de habilitado 
bool aux = false;                       // Para validar cuando fue activado Solenoide

TM1637 tm(CLK, DIO);    // Se crea objeto tm de Display, estableciendo los pines de conexión

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);

  // Ininicialización de display
  tm.init();
  tm.set(BRIGHT_TYPICAL);

  // 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);
  if (count==-1) {      // Se valida si es el primer conteo
  // En su primera ejecución, en la celda del EEPROM no tiene guardado ningún valor admintido
  // El valor que tiene guarado por default es un (-1)
  // Si es su primera ejecución, el conteo inicia desde 0
    count = 0;
  }
}

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 = count + 1;    // Incrementa conteo
        EEPROM.put(0, count);  // Guarda el valor de conteo en EEPROM
        Serial.println(count);
        display();            // Muestra el conteo en el display
        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);

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

  if ((millis() - ultimoTiempoRebote) > retardoRebote2) {
    // 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 (sensorVal2 != estadoPulsador2) {
      estadoPulsador2 = sensorVal2;

      // solo conmuta el LED si el nuevo estado del pulsador es LOW
      if (estadoPulsador2 == HIGH) {
        count = 0;
        EEPROM.put(0, count);
        display();
        Serial.println(count);
      }
    }
  }
  /*
    if (sensorVal2 == HIGH) {
      count = 0;
      EEPROM.put(0, count);
      display();
      Serial.println(count);
    }
  */
  ultimoEstadoPuls2 = sensorVal2;
}

void display() {
  // Impresión de conteo en Display, distribuido por segmentos
  tm.display(0, (count / 1000) % 10);
  tm.display(1, (count / 100) % 10);
  tm.display(2, (count / 10) % 10);
  tm.display(3, count % 10);
}