# #############################################################################
# **    Proyecto       : pilas (stack) con estructuras dinamicas 
# **    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     : 26/02/2026, 1:35 am, 
# **    
# **           Simulación de una pila (estructura dinamica) 
# **           utlizadno Leds y botones para 
# **           insertar y extraer objetos (leds) de la pila 
# **   Versión        : 1
# **   Revisión       : A
# **   Release        : 0
# **   Bugs & Fixes   :
# **   Date           : 26/02/2026,
# **   
# **   By             : Jorge Anzaldo    
# **   contact        : [email protected]
# **   twitter x      : @janzaldob
#  #############################################################################

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

from machine import Pin
import time

# ------------------------------------------------------------
# Clase Nodo
# Representa un nodo de la pila (estructura dinámica)
# ------------------------------------------------------------
class Nodo:
    def __init__(self, dato):
        self.dato = dato              # LED (Pin)
        self.siguiente = None         # Referencia al siguiente nodo

# ------------------------------------------------------------
# Clase Pila (Stack con nodos enlazados)
# ------------------------------------------------------------
class Pila:
    def __init__(self):
        self.cima = None

    def apilar(self, dato):
        nuevo_nodo = Nodo(dato)
        nuevo_nodo.siguiente = self.cima
        self.cima = nuevo_nodo

    def desapilar(self):
        if self.cima is None:
            return None
        dato = self.cima.dato
        self.cima = self.cima.siguiente
        return dato

    def esta_vacia(self):
        return self.cima is None

# ------------------------------------------------------------
# Clase ControladorLED
# Maneja LEDs, botones y la pila
# ------------------------------------------------------------
class ControladorLED:
    def __init__(self,*pines):
        # Pines de LEDs
        self.leds = [Pin(pin, Pin.OUT) for pin in pines]

        # Botones
        self.botonInsertar = Pin(16, Pin.IN, Pin.PULL_UP)
        self.botonExtraer = Pin(17, Pin.IN, Pin.PULL_UP)

        # Pila dinámica
        self.pila = Pila()
        self.indice_led = 0

    def insertar_led(self):
        if self.indice_led < len(self.leds):
            led = self.leds[self.indice_led]
            led.value(1)                  # Encender LED
            self.pila.apilar(led)         # Push en la pila
            self.indice_led += 1

    def extraer_led(self):
        if not self.pila.esta_vacia():
            led = self.pila.desapilar()   # Pop de la pila
            led.value(0)                  # Apagar LED
            self.indice_led -= 1

    def ejecutar(self):
        while True:
            if not self.botonInsertar.value():
                self.insertar_led()
                time.sleep(0.3)

            if not self.botonExtraer.value():
                self.extraer_led()
                time.sleep(0.3)

# ------------------------------------------------------------
# Programa principal
# ------------------------------------------------------------
if __name__ == "__main__":
    sistema = ControladorLED(32, 33, 25, 26, 27, 14, 12, 13)
    sistema.ejecutar()

# ==============================================================================
# R E F E R E N C I A S  /  C O M E N T A R I O S
# ==============================================================================
# 1. Programación Orientada a Objetos (POO)
#    - El programa está estructurado en clases: Nodo, Pila y ControladorLED.
#    - Cada clase tiene una responsabilidad clara (principio de responsabilidad única).
#    - Se utilizan métodos para encapsular el comportamiento del sistema.
#
# 2. Estructuras de Datos Dinámicas
#    - La pila se implementa mediante nodos enlazados dinámicamente.
#    - No se utiliza un arreglo fijo para la pila, sino referencias entre nodos.
#    - Cada nodo contiene un dato (LED) y una referencia al siguiente nodo.
#
# 3. Estructura Pila (Stack) – LIFO
#    - Se aplica el principio LIFO (Last In, First Out).
#    - El último LED encendido es el primero en apagarse.
#    - Los métodos apilar() y desapilar() representan push y pop respectivamente.
#
# 4. Abstracción de Hardware
#    - Los LEDs se manejan como objetos Pin de MicroPython.
#    - El hardware se controla desde una clase, evitando código desordenado.
#    - Los botones actúan como eventos de entrada para modificar la pila.
#
# 5. Integración Software – Hardware
#    - El programa enlaza conceptos abstractos (pila, nodos) con elementos físicos (LEDs).
#    - Cada LED representa visualmente el estado interno de la pila.
#
# 6. Buenas Prácticas de Programación
#    - Uso de nombres descriptivos en clases, métodos y variables.
#    - Separación clara entre definición de clases y programa principal.
#    - Uso del bloque if __name__ == "__main__" como punto de entrada.
#
# 7. Aplicación Educativa
#    - Este ejemplo refuerza estructuras de datos, POO y electrónica básica.
#    - Permite al alumno observar el comportamiento de la pila en tiempo real.
#    - Facilita la comprensión de conceptos abstractos mediante visualización.
#
# 8. Plataforma de Simulación
#    - El programa puede ejecutarse en el simulador Wokwi con ESP32.
#    - No requiere hardware físico para su validación.
#
# ==============================================================================
# Fin del programa
# ==============================================================================