# ===============================================================================
# # 1.- ---------------- Encabezado ----------------------------------------------
# ===============================================================================
# INSTITUTO POLITÉCNICO NACIONAL
# ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA (ESIME ZACATENCO)
# Ingenieria en Comunicaciones y Electrónica
#
# ASIGNATURA: Programación Avanzada
# PRÁCTICA: Implementación de Concurrencia en Sistemas Embebidos con MicroPython
# AUTOR: Jorge Anzaldo 
# FECHA: 21 de Mayo 2026
# MODIFICADO POR : [Nombre del Alumno]
# FECHA: [Fecha]
# DESCRIPCIÓN DEL PROGRAMA:
# Este programa base demuestra el concepto de "Concurrencia" mediante el uso de 
# hilos (threads). Permite ejecutar múltiples tareas de forma simultánea en hardware. 
# Actualmente, el sistema ejecuta de manera concurrente un LED testigo y un Semáforo.
# El alumno deberá extender el código para integrar una Torreta y un LED RGB.
# ===============================================================================

# ===============================================================================
# # 2.- ---------------- Importación de Módulos y Bibliotecas --------------------
# ===============================================================================
from machine import Pin     
import time   
import _thread  # Biblioteca vital para habilitar el uso de hilos (multihilo)

# ===============================================================================
# # 3.- ---------------- Definición de Funciones o clases ------------------------
# ===============================================================================

# Clases Base y Heredadas (Arquitectura Orientada a Objetos)

# importar las clases desde el archivo classLed.py
from classLed import Led 
from classLed import Semaforo

# revisar el programa / modulo classLed.py se requiere
# modificar lineas que tiene ???___???


# -------------------------------------------------------------------------------
# Definición y Desarrollo de Hilos (Funciones Concurrentes)
# -------------------------------------------------------------------------------

# HILO 1: Ejecución del Semáforo (YA FUNCIONANDO)
def hilo1():
    while True:
        semaforo.prender()
        semaforo.apagar()

# HILO 2: [ACTIVIDAD ALUMNO] Control de la Torreta
def hilo2():
    # TODO: Desarrollar el ciclo infinito para que la torreta prenda y apague
    pass

# HILO 3: [ACTIVIDAD ALUMNO] Control del LED RGB
def hilo3():
    # TODO: Desarrollar el ciclo infinito para que el RGB cicle sus colores
    pass

# ===============================================================================
# # 4.- ---------------- Variables u Objetos Globales ----------------------------
# ===============================================================================

# Instanciación de objetos ya funcionales
led = Led(22)
semaforo = Semaforo(21, 19, 18)

# [ACTIVIDAD ALUMNO]: Verificar los pines asignados en 
# simulador (Wokwi) para la Torreta y el RGB antes de probar.
#torreta = Torreta(2, 15, 13, 12, 16, 27, 26, 25)
#rgb = RGB(15, 17, 16)

# ===============================================================================
# # 5.- ---------------- Bloque Principal ----------------------------------------
# ===============================================================================
if __name__ == '__main__': 
    
    # Iniciación del Hilo 1 (Semáforo)
    _thread.start_new_thread(hilo1, ())
    
    # ---------------------------------------------------------------------------
    # [ACTIVIDAD ALUMNO]: Lanzamiento de Hilos Concurrentes
    # Instrucciones: Descomenta las siguientes dos líneas y coloca la sintaxis
    # correcta para iniciar hilo2 e hilo3 utilizando el módulo _thread.
    # ---------------------------------------------------------------------------
    # _thread.start_new_thread( ... )   
    # _thread.start_new_thread( ... )   
    
    # Hilo Principal (Main Thread): Controla el LED Testigo de manera independiente
    while True:
        led.prender()
        led.apagar()

# ===============================================================================
# # 6.- ---------------- Documentación y Comentarios ----------------------------
# ===============================================================================
#
# PRÁCTICA A: "CONCURRENCIA EN SISTEMAS EMBEBIDOS"
#
# 1. INTRODUCCIÓN TEÓRICA:
# En la programación secuencial tradicional, el procesador ejecuta una línea de
# código después de otra. Si una instrucción contiene una pausa (como time.sleep),
# todo el programa se "congela" (bloqueo por Entrada/Salida). Esto es un problema
# grave en ingeniería: no podemos permitir que un semáforo detenga las alertas
# de una torreta de emergencia.
#
# La CONCURRENCIA es la capacidad de organizar y ejecutar varias tareas de forma
# "simultánea" o aparentemente simultánea. En MicroPython, logramos esto creando
# "Hilos" (Threads) mediante el módulo `_thread`. Cada hilo actúa como un pequeño 
# programa independiente que comparte la memoria principal, permitiendo que el 
# hardware responda a diferentes ritmos de tiempo de manera asíncrona.
#
# 2. COMPETENCIA A DESARROLLAR:
# El alumno implementará y comprobará el funcionamiento de sistemas multihilo en 
# un microcontrolador, coordinando periféricos con diferentes frecuencias de tiempo 
# (retardos de 0.5s, 1.0s y 0.1s) sin que interfieran entre sí.
#
# 3. ACTIVIDADES A REALIZAR POR EL ALUMNO:
#    A) Análisis Inicial: Ejecuta el código tal como está provisto. Observa cómo el 
#       'led' y el 'semaforo' funcionan al mismo tiempo a pesar de que ambos usan 
#       pausas directas (`time.sleep`).
#    B) Desarrollo de Hilos complementarios: Completa el cuerpo de las funciones 
#       `hilo2()` e `hilo3()`. Utiliza los métodos `.prender()` y `.apagar()` de los 
#       objetos globales correspondientes.
#    C) Activación de Concurrencia: Dirígete al Bloque Principal (`__main__`) y utilza 
#       la función `_thread.start_new_thread` para dar de alta en el sistema los 
#       nuevos flujos de ejecución.
#    D) Pruebas Físicas/Simulación: Demuestra que la Torreta destella velozmente (0.1s),
#       el RGB cambia de color (1.0s), el semáforo cicla (3.0s totales) y el LED 
#       testigo parpadea (0.5s), todo de manera simultánea.
#
# 4. CUESTIONARIO DE EVALUACIÓN Y SIGNIFICADO:
#    Contesta en tu reporte de práctica las siguientes preguntas:
#    1. ¿Qué ocurriría con el LED testigo si quitaras el hilo del semáforo y pusieras 
#       su código directamente dentro del ciclo `while True` principal?
#    2. Observa el orden de inicialización en la consola. ¿Qué objeto se construye 
#       primero y por qué? Explica basándote en la sección 4 de este código.
#    3. ¿Para qué sirve el segundo parámetro de `_thread.start_new_thread(funcion, ())`?
#       (Pista: Piensa en los parámetros que reciben las funciones).
#
# *******************************************************************************