/*
 * Tabla de verdad para números pares de 4 entradas
 * Genera todas las combinaciones posibles de 4 bits y determina si el número es par
 * 
 * Conexiones:
 * - LED en pin 13 para indicar números pares
 * - Pulsadores en pins 22, 24, 26, 28 para entradas A, B, C, D
 * - Display 7 segmentos opcional en pins 6-12
 */

// Definición de pines
const int PIN_ENTRADA_A = 22;
const int PIN_ENTRADA_B = 24;
const int PIN_ENTRADA_C = 26;
const int PIN_ENTRADA_D = 28;
const int PIN_LED_PAR = 13;

// Variables para almacenar el estado de las entradas
int entrada_A, entrada_B, entrada_C, entrada_D;
int numero_decimal;
int es_par;

void setup() {
  // Configurar pines de entrada (con resistencias externas)
  pinMode(PIN_ENTRADA_A, INPUT);
  pinMode(PIN_ENTRADA_B, INPUT);
  pinMode(PIN_ENTRADA_C, INPUT);
  pinMode(PIN_ENTRADA_D, INPUT);
  
  // Configurar pin de salida para LED
  pinMode(PIN_LED_PAR, OUTPUT);
  
  // Inicializar comunicación serial
  Serial.begin(9600);
  
  // Mostrar encabezado de la tabla
  mostrar_encabezado();
  
  // Generar tabla de verdad completa
  generar_tabla_verdad_completa();
}

void loop() {
  // Leer estado actual de las entradas
  leer_entradas();
  
  // Calcular número decimal
  numero_decimal = calcular_decimal();
  
  // Determinar si es par
  es_par = determinar_si_es_par();
  
  // Controlar LED
  digitalWrite(PIN_LED_PAR, es_par ? HIGH : LOW);
  
  // Mostrar estado actual en serial
  mostrar_estado_actual();
  
  delay(500); // Pequeña pausa para estabilidad
}

void mostrar_encabezado() {
  Serial.println("============================================================");
  Serial.println("TABLA DE VERDAD PARA NUMEROS PARES DE 4 ENTRADAS");
  Serial.println("============================================================");
  Serial.println("A  B  C  D  |  Decimal  |  Binario  |  Es Par");
  Serial.println("------------------------------------------------------------");
}

void generar_tabla_verdad_completa() {
  int contador_pares = 0;
  
  Serial.println("TABLA COMPLETA:");
  Serial.println("------------------------------------------------------------");
  
  // Generar todas las combinaciones de 4 bits (0 a 15)
  for (int i = 0; i < 16; i++) {
    // Convertir a binario de 4 bits
    int A = (i >> 3) & 1;  // Bit más significativo
    int B = (i >> 2) & 1;
    int C = (i >> 1) & 1;
    int D = i & 1;         // Bit menos significativo
    
    // Un número es par si el bit menos significativo (D) es 0
    int es_par_num = (D == 0);
    
    // Mostrar la fila
    Serial.print(A);
    Serial.print("  ");
    Serial.print(B);
    Serial.print("  ");
    Serial.print(C);
    Serial.print("  ");
    Serial.print(D);
    Serial.print("  |    ");
    Serial.print(i);
    Serial.print("     |   ");
    Serial.print(A);
    Serial.print(B);
    Serial.print(C);
    Serial.print(D);
    Serial.print("   |    ");
    Serial.println(es_par_num ? "1" : "0");
    
    if (es_par_num) {
      contador_pares++;
    }
  }
  
  Serial.println("------------------------------------------------------------");
  Serial.print("Total de numeros pares: ");
  Serial.print(contador_pares);
  Serial.println(" de 16");
  Serial.print("Total de numeros impares: ");
  Serial.print(16 - contador_pares);
  Serial.println(" de 16");
  Serial.println("============================================================");
  Serial.println();
  Serial.println("ESTADO ACTUAL DE LAS ENTRADAS:");
  Serial.println("------------------------------------------------------------");
}

void leer_entradas() {
  // Leer estado de las entradas (con resistencias externas)
  entrada_A = digitalRead(PIN_ENTRADA_A);
  entrada_B = digitalRead(PIN_ENTRADA_B);
  entrada_C = digitalRead(PIN_ENTRADA_C);
  entrada_D = digitalRead(PIN_ENTRADA_D);
}

int calcular_decimal() {
  // Calcular valor decimal a partir de los bits
  return (entrada_A << 3) | (entrada_B << 2) | (entrada_C << 1) | entrada_D;
}

int determinar_si_es_par() {
  // Un número es par si el bit menos significativo (D) es 0
  return (entrada_D == 0);
}

void mostrar_estado_actual() {
  // Mostrar estado actual de las entradas
  Serial.print("A=");
  Serial.print(entrada_A);
  Serial.print(" B=");
  Serial.print(entrada_B);
  Serial.print(" C=");
  Serial.print(entrada_C);
  Serial.print(" D=");
  Serial.print(entrada_D);
  Serial.print(" | Decimal=");
  Serial.print(numero_decimal);
  Serial.print(" | Binario=");
  Serial.print(entrada_A);
  Serial.print(entrada_B);
  Serial.print(entrada_C);
  Serial.print(entrada_D);
  Serial.print(" | Es Par=");
  Serial.println(es_par ? "SI" : "NO");
}

/*
 * FUNCIONES ADICIONALES PARA DISPLAY 7 SEGMENTOS
 * (Opcional - descomenta si tienes un display 7 segmentos)
 */

/*
// Pines para display 7 segmentos (ánodo común)
const int PIN_SEG_A = 6;
const int PIN_SEG_B = 7;
const int PIN_SEG_C = 8;
const int PIN_SEG_D = 9;
const int PIN_SEG_E = 10;
const int PIN_SEG_F = 11;
const int PIN_SEG_G = 12;

// Patrones para dígitos 0-9 en display 7 segmentos
const byte patrones_digitos[10] = {
  B11111100, // 0
  B01100000, // 1
  B11011010, // 2
  B11110010, // 3
  B01100110, // 4
  B10110110, // 5
  B10111110, // 6
  B11100000, // 7
  B11111110, // 8
  B11110110  // 9
};

void configurar_display_7_segmentos() {
  pinMode(PIN_SEG_A, OUTPUT);
  pinMode(PIN_SEG_B, OUTPUT);
  pinMode(PIN_SEG_C, OUTPUT);
  pinMode(PIN_SEG_D, OUTPUT);
  pinMode(PIN_SEG_E, OUTPUT);
  pinMode(PIN_SEG_F, OUTPUT);
  pinMode(PIN_SEG_G, OUTPUT);
}

void mostrar_digito_en_display(int digito) {
  if (digito >= 0 && digito <= 9) {
    byte patron = patrones_digitos[digito];
    digitalWrite(PIN_SEG_A, patron & B10000000);
    digitalWrite(PIN_SEG_B, patron & B01000000);
    digitalWrite(PIN_SEG_C, patron & B00100000);
    digitalWrite(PIN_SEG_D, patron & B00010000);
    digitalWrite(PIN_SEG_E, patron & B00001000);
    digitalWrite(PIN_SEG_F, patron & B00000100);
    digitalWrite(PIN_SEG_G, patron & B00000010);
  }
}
*/