/******************************************
  74HC595 - Registro de desplazamiento
  Convierte una entrada Serie en una salida Paralelo

  La salida paralelo de 8 bits alimenta los 7 segmentos y el punto decimal DP del display
  En la entrada serie introducimos el valor binario del conjunto de segmentos y DP

  Necesitamos controlar 3 pines del chip 74HC595
    La patilla 14 SER del chip recibe los datos serie
    La patilla 11 SRCLK del chip es el reloj que guarda cada bit serie en el registro interno
    La patilla 12 RCLK del chip traslada el registro serie almacenado a las salidas paralelo Q0..Q7

    La patilla OE será 0 para habilitar el display y 1 para apagarlo
  ******************************************/

// Pines OUTPUT de Arduino
int dataPin = 5;           // Pin conectado a DS de 74HC595（Pin14 - SER）
int latchPin = 2;          // Pin conectado a ST_CP de 74HC595（Pin12 - RCLK）
int clockPin = 4;          // Pin conectado a SH_CP de 74HC595（Pin11 - SRCLK）
int outputEnablePin = 3;   // Pin PWM conectado a OE de 74HC595


// Pines OUTPUT de Arduino para controlar los 4 dígitos
// Usamos display de Cátodo Común, es decir, LOW es dígito encendido y HIGH es dígito apagado
int comPin[] = {11, 10, 9, 8};

// Display de Cátodo común
// Definimos una array con los bytes que representan los 7 segmentos del display GFEDCBA
//  bit0 = A, bit1 = B, .......bit6 = G
// El bit7 estará a cero/uno para apagar/encender el DP
int dp_off = 0x00;  // Apagar el punto en Cátodo Común
int dp_on  = 0x80;  // Encender el punto en Cátodo Común
byte num[16] = {
  0b0111111, // 0
  0b0000110, // 1
  0b1011011, // 2
  0b1001111, // 3
  0b1100110, // 4
  0b1101101, // 5
  0b1111101, // 6
  0b0000111, // 7
  0b1111111, // 8
  0b1101111, // 9
  0b1110111, // A
  0b1111100, // B
  0b0111001, // C
  0b1011110, // D
  0b1111001, // E
  0b1110001  // F
};

/*
  // Display de Ánodo común (0 enciende, 1 apaga)
  int dp_off = 0x80;  // Apagar el punto en Ánodo Común
  int dp_on  = 0x00;  // Encender el punto en Ánodo Común
  byte num[16] = {
  0b1000000, // 0
  0b1111001, // 1
  0b0100100, // 2
  0b0110000, // 3
  0b0011001, // 4
  0b0010010, // 5
  0b0000010, // 6
  0b1111000, // 7
  0b0000000, // 8
  0b0010000, // 9
  0b0001000, // A
  0b0000011, // B
  0b1000110, // C
  0b0100001, // D
  0b0000110, // E
  0b0001110  // F
  };
*/

// Contadores para hacer el Temporizador
long tempor = 0, contret = 0;

void setup() {
  // Establecemos todos los pines del Arduino
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(outputEnablePin, OUTPUT);
  for (int i = 0; i < 4; i++) {
    pinMode(comPin[i], OUTPUT);
  }
  // Establecemos el valor de OE a una señal PWM para regular el brillo
  digitalWrite(outputEnablePin, LOW);
  // setBrightness(1270);
}

void writeData(int value, int dp) {
  // Make latchPin output low level
  digitalWrite(latchPin, LOW);
  // Send serial data to 74HC595
  // El valor de dp enciende o apaga el Punto
  shiftOut(dataPin, clockPin, LSBFIRST, value | dp);
  // Make latchPin output high level, then 74HC595 will update the data to parallel output
  digitalWrite(latchPin, HIGH);
}


// setBrightness() - Genera una señal PWM para escruibir en el pin OE.
// Valores de 0 a 255
void setBrightness(byte brightness) {
  analogWrite(outputEnablePin, 255 - brightness);
}


// Función encargada de la multiplexación
void mostrar() // Rutina mostrar
{
  int dig[4]; // Declarar las variables
  // como un entero, es decir de 8bits
  // Dígito Millar
  dig[0] = tempor / 1000;
  // Dígito Centena
  dig[1] = (tempor - dig[0] * 1000) / 100;
  // Dígito Decena
  dig[2] = (tempor - dig[0] * 1000 - dig[1] * 100) / 10;
  // Dígito Unidad
  dig[3] = (tempor - dig[0] * 1000 - dig[1] * 100 - dig[2] * 10);
  
  // Rutina de Multiplexación
  for (int i = 0; i < 4; i++)
  {
    // Muestra el punto decimal en el 2º dígito
    if (i == 1) {
      writeData(num[dig[i]], dp_on);
    } else {
      writeData(num[dig[i]], dp_off);
    }
    digitalWrite(comPin[i], LOW);
    delay(1);              // Retardo de 1 milisegundos
    digitalWrite(comPin[i], HIGH);  // Apaga el display de unidades
  }
}

// Función que cuenta el tiempo que le toma al temporizador
// incrementar su cuenta
void temporizacion() {
  contret = 50;       // Cargue con 50 la variable CONTRET
  while (contret > 0) // Mientras que la variable CONTRET sea mayor que cero
  {
    mostrar(); // Llamar la rutina MOSTRAR
    contret--; // Decremente la variable CONTRET
  }
}

void loop() {
  tempor = 0;           // Inicializa el temporizador en Cero
  while (tempor < 9999) // mientras la variable TEMPOR es menor que 9999
  {
    temporizacion(); // Llama la Función Temporizaor
    tempor++;        // Incrementa el tempor
  }
}