from machine import Pin
import time

# ==========================================
# 1. CONFIGURACIÓN Y MAPEO DE 7 SEGMENTOS
# ==========================================
# Representación binaria para Cátodo Común: [g, f, e, d, c, b, a]
# 1 = Encendido, 0 = Apagado
HEX_7SEG = {
    0: 0x3F, 1: 0x06, 2: 0x5B, 3: 0x4F, 4: 0x66,
    5: 0x6D, 6: 0x7D, 7: 0x07, 8: 0x7F, 9: 0x6F,
    '-': 0x40, ' ': 0x00
}

# Configuración de los pines para los segmentos (A-G)
# Conectar en orden a los pines correspondientes del display
pines_segmentos = [Pin(p, Pin.OUT) for p in [12, 13, 14, 27, 26, 25, 32]] 

# Configuración de los pines de activación de cada Display (Habilitadores)
# Disp1 (Izquierda), Disp2 (Centro), Disp3 (Derecha)
pines_displays = [Pin(p, Pin.OUT) for p in [19, 18, 5]]

# Configuración de las entradas del DIP Switch (4 bits)
# Se usa PULL_DOWN interno para evitar ruidos lógicos sin usar resistencias externas
pines_dip = [Pin(p, Pin.IN, Pin.PULL_DOWN) for p in [15, 2, 4, 16]]

# ==========================================
# 2. ARREGLO BASE PARAMETRIZADO (CÉDULA)
# ==========================================
# Cédula de 10 dígitos (>= 8): Secuencia continua + guion + reinicio cíclico
# Total de 16 estados exactos (del 0 al 15)
secuencia = [1, 0, 0, 5, 1, 9, 0, 8, 0, 5, '-', 1, 0, 0, 5, 1]

# ==========================================
# 3. FUNCIONES DE CONTROL
# ==========================================
def leer_estado_dip():
    """
    Lee los 4 interruptores binarios y calcula el estado decimal (0 a 15).
    Evita estructuras redundantes usando desplazamiento de bits.
    """
    estado_decimal = 0
    for i, pin in enumerate(pines_dip):
        estado_decimal |= (pin.value() << i)
    return estado_decimal

def mapear_segmentos(caracter):
    """ Enciende físicamente los pines del bus de segmentos (A-G) """
    bits_segmento = HEX_7SEG.get(caracter, 0x00)
    for i in range(7):
        pines_segmentos[i].value((bits_segmento >> i) & 1)

def mostrar_en_pantalla(estado):
    """
    Implementa la ventana deslizante sobre el arreglo circular
    y realiza la multiplexación por división de tiempo en los displays.
    """
    # Ventana de visualización dinámica de 3 elementos basada en el estado
    valores_pantalla = [
        secuencia[estado % 16],          # Elemento para Display 1
        secuencia[(estado + 1) % 16],    # Elemento para Display 2
        secuencia[(estado + 2) % 16]     # Elemento para Display 3
    ]
    
    # Ciclo rápido de multiplexación para engañar la persistencia de la visión humana
    for i in range(3):
        # 1. Limpieza (Apagar todos los habilitadores para evitar el efecto "fantasma")
        for habilitador in pines_displays:
            habilitador.value(1) # 1 apaga el display en configuración cátodo común (transistor PNP/corte)
            
        # 2. Cargar los segmentos del carácter actual en el bus común
        mapear_segmentos(valores_pantalla[i])
        
        # 3. Encender únicamente el display en foco
        pines_displays[i].value(0) # 0 activa el display correspondiente
        
        # 4. Pequeña retención de tiempo para el brillo del display antes del cambio
        time.sleep_ms(4)

# ==========================================
# 4. BUCLE PRINCIPAL (MAIN LOOP)
# ==========================================
print("Sistema Inicializado de Desplazamiento Circular.")
while True:
    # 1. Monitorear constantemente el valor del DIP Switch
    estado_actual = leer_estado_dip()
    
    # 2. Refrescar dinámicamente la visualización multiplexada
    mostrar_en_pantalla(estado_actual)