# #############################################################################
# **    Proyecto       : 204-Torre Leds utilizando Herencia, tuplas, 
# **                         listas y diccionarios (Contenedores)
# **    Plataforma     : ESP32 / WROOM
# **    Herramienta    : https://www.wokwi.com        
# **                   : Thonny aplicacion de escritorio descargar en www.thonny.org
# **    Compilador     : wokwi Simulador online
# **    Version        : 1.0
# **    Fecha/Hora     : 17-02-2026, 2:00 am, 
# **    
# **           Torre de Leds utilizando tuplas, listas, Diccionarios y Clases/Herencia
# ** 
# **   Versión        : 1
# **   Revisión       : A
# **   Release        : 0
# **   Bugs & Fixes   :
# **   Date           : 17-02-2026
# **   
# **   By             : Jorge Anzaldo    
# **   contact        : [email protected]
# **   twitter x      : @janzaldob
#  #############################################################################

# ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
# :                       Librerias / Bibliotecas / Modulos                      :
# ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

from machine import Pin     #https://docs.micropython.org/en/latest/library/machine.Pin.html
import time                 #https://docs.micropython.org/en/latest/library/time.html

# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# |                    Definición y Desarrollo de Clases                         |
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Led:
    def __init__(self, *pines, dispositivo="led", color="rojo", estado="apagado"):
        '''
        Constructor de la clase Led con atributos de dispositivo
        
        Args:
            *pines: Uno o más números de pin para los LEDs
            dispositivo: Tipo de dispositivo (ej: "led", "torreta", "rgb")
            color: Color del dispositivo
            estado: Estado inicial ("encendido" o "apagado")
        '''
        self._leds = []  # Lista para guardar los pines
        # Uso de diccionarios
        self._atributos = {
            'dispositivo': dispositivo,
            'pines': pines,
            'color': color,
            'estado': estado
        }
        
        for pin in pines:  # Recorre cada pin recibido
            led = Pin(pin, Pin.OUT)  # Configura pin como salida
            self._leds.append(led)  # Agrega a la lista de LEDs
        
        print(f'{self.__class__.__name__} construido con atributos: {self._atributos}')

    def leer(self):
        print("\n.      INGRESO DE DATOS DEL DISPOSITIVO ")
        self._atributos['dispositivo'] = input("Tipo de dispositivo (ej: led, torreta, rgb): ") or self._atributos['dispositivo']
        
        # Para pines, pedimos como cadena separada por comas
        pines_input = input("Pines (separados por comas, ej: 2,3,4): ")
        if pines_input:
            pines_list = [int(p.strip()) for p in pines_input.split(',')]
            self._atributos['pines'] = tuple(pines_list)
            # Reconstruir LEDs con nuevos pines
            self._leds = []
            for pin in self._atributos['pines']:
                led = Pin(pin, Pin.OUT)
                self._leds.append(led)
        
        self._atributos['color'] = input("Color del dispositivo: ") or self._atributos['color']
        self._atributos['estado'] = input("Estado inicial (encendido/apagado): ") or self._atributos['estado']
        
        print("Datos actualizados correctamente!")
        self.mostrar_estado()

    def mostrar_estado(self):
        print("\n=== ESTADO DEL DISPOSITIVO ===")
        print(f"Dispositivo: {self._atributos['dispositivo']}")
        print(f"Pines: {self._atributos['pines']}")
        print(f"Color: {self._atributos['color']}")
        print(f"Estado: {self._atributos['estado']}")
        print("=" * 30)

    def prender(self, tiempo=0.2):
        for led in self._leds:
            led.on()
            time.sleep(tiempo)
        self._atributos['estado'] = "encendido"
        self.mostrar_estado()

    def apagar(self, tiempo=0.2):
        for led in self._leds:
            led.off()
            time.sleep(tiempo)
        self._atributos['estado'] = "apagado"
        self.mostrar_estado()
        
    def parpadear(self):
        self.prender()
        self.apagar()


class Torreta(Led):
    def __init__(self, *pines, dispositivo="torreta", color="multicolor", estado="apagado"):
        #Constructor de la clase Torreta
        super().__init__(*pines, dispositivo=dispositivo, color=color, estado=estado)

    def prender_izquierda_derecha(self, tiempo=0.1):
        # Enciende los LEDs de izquierda a derecha
    
        print(f"\nActivando secuencia izquierda-derecha en {self._atributos['dispositivo']}")
        # Prende de izquierda a derecha
        for led in self._leds:
            led.on()       
            time.sleep(tiempo)
        self._atributos['estado'] = "encendido"
        self.mostrar_estado()
        self.apagar()
    def prender_derecha_izquierda(self):
        pass
    
    def prender_centro_afuero(self):
        pass


class RGB(Led):
    colores_disponibles = {
        'ROJO': (1, 0, 0),
        'VERDE': (0, 1, 0),
        'AZUL': (0, 0, 1),
        'AMARILLO': (1, 1, 0),
        'CIAN': (0, 1, 1),
        'MAGENTA': (1, 0, 1),
        'BLANCO': (1, 1, 1),
        'APAGADO': (0, 0, 0)
    }
    
    def __init__(self, pin_rojo, pin_verde, pin_azul, dispositivo="rgb", color="blanco", estado="apagado"):
        """
        Constructor de la clase RGB
        """
        super().__init__(pin_rojo, pin_verde, pin_azul, dispositivo=dispositivo, color=color, estado=estado)
        self._pin_rojo, self._pin_verde, self._pin_azul = self._leds
        
    def color(self, color, tiempo=1):
        """
        Establece un color específico
        """
        color = color.upper()
        if color not in self.colores_disponibles:
            raise ValueError(f"Color no válido. Opciones: {list(self.colores_disponibles.keys())}")
        
        r, g, b = self.colores_disponibles[color]
        self._pin_rojo.value(r)
        self._pin_verde.value(g)
        self._pin_azul.value(b)
        
        # Actualizar atributos
        self._atributos['color'] = color.lower()
        self._atributos['estado'] = "encendido" if color != "APAGADO" else "apagado"
        self.mostrar_estado()
        
        time.sleep(tiempo)
    
    def prender(self, color='blanco'):
        """
        Enciende el RGB con un color específico
        """
        self.color(color)
    
    def apagar(self):
        """
        Apaga el RGB
        """
        self.color('APAGADO')
    
    def ciclo_colores(self, retardo=0.5):
        """
        Ciclo por todos los colores disponibles
        """
        print(f"\nIniciando ciclo de colores en {self._atributos['dispositivo']}")
        for nombre_color, valores in self.colores_disponibles.items():
            if nombre_color != 'APAGADO':
                print(f"Mostrando color: {nombre_color}")
                self.color(nombre_color)
                time.sleep(retardo)
        self.apagar()
    
    def agregar_color_personalizado(self, nombre, valor_rojo, valor_verde, valor_azul):
        """
        Agrega un color personalizado al diccionario
        """
        if not all(0 <= v <= 1 for v in [valor_rojo, valor_verde, valor_azul]):
            raise ValueError("Los valores de color deben estar entre 0 y 1")
        self.colores_disponibles[nombre.upper()] = (valor_rojo, valor_verde, valor_azul)
        print(f"Color '{nombre}' añadido correctamente")
# +-------------------------------------------------------------------------------
# |            V A R I A B L E S / O B J E T O S - G L O B A L E S               |
# +-------------------------------------------------------------------------------

# Creación de instancias con parámetros específicos
ledi = Led(2, dispositivo="led_indicador", color="rojo", estado="apagado")
torre = Torreta(13, 12, 14, 27, dispositivo="torreta_alarma", color="multicolor", estado="apagado")
rgb = RGB(18, 17, 16, dispositivo="rgb_principal", color="blanco", estado="apagado")

# ===============================================================================
# ||                                                                            ||
# ||        P R O G R A M A / F U N C I O N    P R I N C I P A L                ||
# ||                                                                            ||
# =============================================================================== 

if __name__ == "__main__":
    # Demostración del uso
    print("\n=== DEMOSTRACIÓN DEL SISTEMA LED ===")
    
    # Mostrar estado inicial
    ledi.mostrar_estado()
    torre.mostrar_estado()
    rgb.mostrar_estado()
    
    # Usar método leer() para modificar atributos
    print("\n¿Desea modificar los atributos del LED? (s/n)")
    respuesta = input()
    if respuesta.lower() == 's':
        ledi.leer()
    
    # Ejecutar secuencia principal
    while True:
        print("\n=== EJECUTANDO SECUENCIA PRINCIPAL ===")
        ledi.parpadear()
        torre.prender_izquierda_derecha()
        rgb.color("ROJO")
        rgb.apagar()
        rgb.color("VERDE")
        rgb.apagar()
        rgb.color("AZUL")
        rgb.apagar()
        
        # Preguntar si continuar
        print("\n¿Desea continuar la secuencia? (s/n)")
        respuesta = input()
        if respuesta.lower() != 's':
            break
    
# ********************************************************************************
#                                                                            
#                                                                            
#                                                                            
#                R E F E R E N C I A S  / C O M E N T A R I O S  
#                                                                        
# *********************************************************************************
'''
machine.Pin: Clase que permite manipular los pines físicos del microcontrolador (entradas/salidas).

time.sleep(x): Pausa el programa por x segundos (aquí usado para animaciones con LEDs).

*pines: Permite recibir varios pines como argumentos.

self._leds: Lista que guarda los objetos Pin ya configurados como salida.

Pin(pin, Pin.OUT): Configura el pin como salida digital (para encender/apagar LEDs).

La línea comentada self._leds = [Pin(pin, Pin.OUT) for pin in pines] es una versión más compacta usando 
list comprehension.

Hereda de la clase Led → reutiliza su funcionalidad.

super().__init__() llama al constructor de la clase padre para inicializar los pines.

Crea un objeto torre de la clase Torreta, con los pines GPIO 13, 12, 14 y 27.

En un ciclo infinito, ejecuta prenderID(), que:

Enciende LEDs uno a uno.

Los apaga todos.

---------------------------------------------
Crea un objeto torre de la clase Torreta, con los pines GPIO 13, 12, 14 y 27.

En un ciclo infinito, ejecuta prenderID(), que:

Enciende LEDs uno a uno.

Los apaga todos.

----------------------------------------------
Resumen 

Torreta
   ↳ Hereda de Led
       ↳ Gestiona lista de pines como salidas
           ↳ .prender() → todos encendidos
           ↳ .apagar() → todos apagados
   ↳ .prenderID() → encender uno a uno + apagar


----------------------------------------------
Diagra 

Inicio
  ↓
Crear instancia de Torreta con pines (13, 12, 14, 27)
  ↓
[Inicio del bucle infinito]
  ↓
Llamar a torre.prenderID()
  ↓
  ┌─────────────────────────────────────────────┐
  │ Método prenderID():                         │
  │   Para cada LED en la lista _leds:          │
  │     - Encender el LED                       │
  │     - Esperar 0.1 segundos                  │
  │   Llamar a self.apagar()                    │
  │     - Para cada LED en _leds:               │
  │         - Apagar el LED                     │
  │         - Esperar 0.1 segundos              │
  └─────────────────────────────────────────────┘
  ↓
[Fin del bucle infinito]

-------------------------------------------------
Descripción del flujo:

Inicio: El programa comienza creando una instancia de la clase Torreta, pasando los pines GPIO 13, 12, 14 y 27 como argumentos. Estos pines están conectados a los LEDs.

Bucle Infinito: El programa entra en un bucle infinito (while True:) donde repetidamente llama al método prenderID() de la instancia torre.

Método prenderID(): Este método enciende cada LED en la lista _leds uno por uno, esperando 0.1 segundos entre cada encendido. Después de encender todos los LEDs, llama al método apagar().

Método apagar(): Este método apaga cada LED en la lista _leds uno por uno, esperando 0.1 segundos entre cada apagado.

-------------------------------------------------
Esquema de Conexión de Hardware para el ESP32
Para conectar los LEDs al ESP32, sigue este esquema:

Componentes necesarios:

4 LEDs
4 resistencias de 220 Ω
Cables de conexión
Protoboard (opcional)

Conexiones:

LED	Anodo (+) conectado a GPIO	Cátodo (−) conectado a
1	GPIO 13	GND a través de resistencia de 220 Ω
2	GPIO 12	GND a través de resistencia de 220 Ω
3	GPIO 14	GND a través de resistencia de 220 Ω
4	GPIO 27	GND a través de resistencia de 220 Ω

Notas:

Resistencias: Es importante colocar una resistencia de 220 Ω en serie con cada LED para limitar la corriente y evitar dañar tanto el LED como el pin del ESP32.
Conexión a GND: El cátodo de cada LED debe conectarse al pin GND del ESP32 a través de su respectiva resistencia.
GPIOs utilizados: Asegúrate de que los pines GPIO 13, 12, 14 y 27 estén configurados como salidas en tu código, como se muestra en la clase Led.
Precaución: Algunos pines del ESP32 tienen funciones especiales o restricciones. Por ejemplo, los GPIOs 34 a 39 son de solo entrada y no deben usarse para controlar LEDs. Para más detalles sobre los pines del ESP32, puedes consultar la referencia de pines del ESP32 .

---- 
'''