# #############################################################################
# ** Proyecto : 303- Torre Leds utilizando Herencia, tuplas y listas
# ** 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 : 08-05-2025, 2:00 am,
# **
# ** Torre de Leds utilizando tuplas, listas y ciclo for
# **
# ** Versión : 1
# ** Revisión : A
# ** Release : 0
# ** Bugs & Fixes :
# ** Date : 08-11-2025
# **
# ** 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
# +-------------------------------------------------------------------------------
# | V A R I A B L E S / O B J E T O S - G L O B A L E S |
# +-------------------------------------------------------------------------------
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# | Definición y Desarrollo de Clases |
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class Led:
def __init__(self, *pines):
self._leds = [] # Lista para guardar los pines
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 pines: {pines}')
def prender(self,tiempo=0.2):
for led in self._leds:
led.on()
time.sleep(tiempo)
def apagar(self,tiempo=0.2):
for led in self._leds:
led.off()
time.sleep(tiempo)
def parpadear(self):
self.prender()
self.apagar()
class Torreta(Led):
def __init__(self, *pines):
super().__init__(*pines)
def prender_izquierda_derecha(self):
# Prende de izquierda a derecha
for led in self._leds:
led.on()
time.sleep(0.1)
self.apagar()
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):
super().__init__(pin_rojo, pin_verde, pin_azul)
self._pin_rojo, self._pin_verde, self._pin_azul = self._leds
def color(self, color, tiempo=1):
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)
time.sleep(tiempo)
def prender(self, color='blanco'):
self.color(color)
def apagar(self):
self.color('APAGADO')
def ciclo_colores(self, retardo=0.5):
for nombre_color, valores in self.colores_disponibles.items():
if nombre_color != 'apagado':
print(f"Mostrando color: {nombre_color}")
self.establecer_color(nombre_color)
time.sleep(retardo)
self.apagar()
def agregar_color_personalizado(self, nombre, valor_rojo, valor_verde, valor_azul):
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] = (valor_rojo, valor_verde, valor_azul)
print(f"Color '{nombre}' añadido correctamente")
ledi = Led(2)
torre = Torreta(13,12,14,27)
rgb = RGB(18,17,16)
# ===============================================================================
# || ||
# || 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__":
while True:
ledi.parpadear()
torre.prender_izquierda_derecha()
rgb.color("ROJO")
rgb.apagar()
rgb.color("VERDE")
rgb.apagar()
rgb.color("AZUL")
rgb.apagar()
# ********************************************************************************
#
#
#
# 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 .
----
'''