// ===== DECLARACIÓN DE PINES =====
// Pines del 74HC595
const int DS_PIN = 13;      // Datos seriales (pin 14 del 74HC595)
const int SHCP_PIN = 14;    // Reloj de desplazamiento (pin 11)
const int STCP_PIN = 12;    // Reloj de almacenamiento / Latch (pin 12)
// Pines de control de dígitos (ánodo común)
const int DIGIT_PINS[] = {27, 26, 25, 33};

// ===== CONSTANTES =====
const int NUM_DIGITS = 4;
const int NUM_SEGMENTS = 8;  // 7 segmentos + punto decimal

// ===== MAPEO DE SEGMENTOS PARA CADA DÍGITO =====
// Formato: [dp, g, f, e, d, c, b, a]
// Para ánodo común, se invierte la lógica

// Mapeo para display de CÁTODO COMÚN
const byte digitPatterns[] = {
  0b11000000,  // 0: a b c d e f
  0b11111001,  // 1: b c
  0b10100100,  // 2: a b d e g
  0b10110000,  // 3: a b c d g
  0b10011001,  // 4: b c f g
  0b10010010,  // 5: a c d f g
  0b10000010,  // 6: a c d e f g
  0b11111000,  // 7: a b c
  0b10000000,  // 8: a b c d e f g
  0b10010000,  // 9: a b c d f g
  0b11111111   // Apagado
};

// ===== FUNCIÓN PARA ENVIAR DATOS AL 74HC595 =====
void enviarDatos74HC595(byte data) {
  // Enviar los datos bit por bit (MSB primero)
  for (int i = 7; i >= 0; i--) {
    // Extraer el bit i
    int bit = (data >> i) & 0x01;
    
    // Escribir el bit en DS
    digitalWrite(DS_PIN, bit);
    
    // Generar pulso de reloj (SHCP)
    digitalWrite(SHCP_PIN, HIGH);
    delayMicroseconds(1);
    digitalWrite(SHCP_PIN, LOW);
  }
  
  // Generar pulso de latch (STCP) para actualizar las salidas
  digitalWrite(STCP_PIN, HIGH);
  delayMicroseconds(1);
  digitalWrite(STCP_PIN, LOW);
}

// ===== FUNCIÓN PARA MOSTRAR UN DÍGITO =====
void mostrarDigito(int digito, int valor) {
  // Apagar todos los dígitos primero (para evitar ghosting)
  for (int i = 0; i < NUM_DIGITS; i++) {
    digitalWrite(DIGIT_PINS[i], LOW);
  }
  
  // Enviar el patrón del dígito al 74HC595
  // Si el valor es 0-9, mostrar el dígito; si no, apagar
  if (valor >= 0 && valor <= 9) {
    enviarDatos74HC595(digitPatterns[valor]);
  } else {
    enviarDatos74HC595(0x00);  // Apagar
  }
  
  // Encender el dígito correspondiente
  digitalWrite(DIGIT_PINS[digito], HIGH);
}

// ===== FUNCIÓN PARA MOSTRAR UN NÚMERO DE 4 DÍGITOS =====
void mostrarNumero(int numero) {
  // Separar el número en dígitos individuales
  int digitos[4];
  
  // Si el número es 0, mostrar "0000"
  if (numero == 0) {
    digitos[0] = 0;
    digitos[1] = 0;
    digitos[2] = 0;
    digitos[3] = 0;
  } else {
    // Extraer los dígitos
    for (int i = 3; i >= 0; i--) {
      digitos[i] = numero % 10;
      numero /= 10;
    }
  }
  
  // Mostrar cada dígito con multiplexación
  for (int i = 0; i < NUM_DIGITS; i++) {
    mostrarDigito(i, digitos[i]);
    delay(5);  // Tiempo de persistencia para cada dígito
  }
}

// ===== SETUP =====
void setup() {
  Serial.begin(115200);
  
  // Configurar pines del 74HC595 como salidas
  pinMode(DS_PIN, OUTPUT);
  pinMode(SHCP_PIN, OUTPUT);
  pinMode(STCP_PIN, OUTPUT);
  
  // Configurar pines de dígitos como salidas
  for (int i = 0; i < NUM_DIGITS; i++) {
    pinMode(DIGIT_PINS[i], OUTPUT);
    digitalWrite(DIGIT_PINS[i], LOW);
  }
  
  // Inicializar el 74HC595 (limpiar salidas)
  enviarDatos74HC595(0x00);
  
  Serial.println("=== DISPLAY 7 SEGMENTOS CON 74HC595 ===");
  Serial.println("Iniciando contador de 0 a 9999...");
}

// ===== VARIABLES GLOBALES =====
int contador = 0;
unsigned long tiempoAnterior = 0;
const unsigned long INTERVALO = 1000;  // 1 segundo

// ===== LOOP PRINCIPAL =====
void loop() {
  unsigned long tiempoActual = millis();
  
  // Actualizar el contador cada segundo
  if (tiempoActual - tiempoAnterior >= INTERVALO) {
    tiempoAnterior = tiempoActual;
    contador++;
    if (contador > 9999) {
      contador = 0;
    }
    Serial.print("Contador: ");
    Serial.println(contador);
  }
  
  // Mostrar el número en el display (multiplexación)
  mostrarNumero(contador);
}