# ############################################################################
# **    Proyecto       : 206 sobre carga de operadores
# **    Herramienta    : https://www.wokwi.com        
# **    Compilador     : wokwi Simulador online
# **    Version        : 1.0
# **    Fecha/Hora     : 16-05-2025, 1:15 am, 
# **    
# **   Descripción del programa :      
# **        Programa que utiliza la sobre carga de operadores para encender y apagar
# **        2 leds adicionales sin afectar la memoria
# **        led3 = led1 + led2      se enciede led3
# **        led4 = led1 - led2      se enciend led4 
# ** 
# **   Versión        : 1
# **   Revisión       : A
# **   Release        : 0
# **   Bugs & Fixes   :
# **   Date           : 16/15/2025
# **   
# **   By             : Jorge Anzaldo    
# **   contact        : [email protected]
# **   twitter x      : @janzaldob
#############################################################################

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

from machine import Pin
import time
import gc 
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# |                    Definición y Desarrollo de FUNCIONE / CLASES              |
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Led:
    def __init__(self, pin):
        self._led = Pin(pin, Pin.OUT)
        print(f'El objeto {self} fue construido ')
    
    def prender(self):
        self._led.on()      #_led.value(1)
    
    def apagar(self):
        self._led.off()     #_led.value(0)

    def pausar(self, tiempo=1):
        time.sleep(tiempo)

    def __add__(self, otro):
        return Led(2)

    def __sub__(self,otro):
        return Led(15)

    def __str__(self):
        return f'led conectado en {self._led}' 
        
    def __del__(self):
        print(f'El objeto {self._led} fue destruido ')


# +-------------------------------------------------------------------------------
# |              V A R I A B L E S  G L O B A L E S   U   O B J E T O S          |
# +-------------------------------------------------------------------------------

led1 = Led(17)
led2 = Led(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:

        led1.prender()
        led2.prender()
  
        led3 = led1 + led2
        led3.prender()
        time.sleep(2)
        led3.apagar()
        del led3

 
        led1.apagar()
        led2.apagar()

        led4 = led1 - led2
        led4.prender()
        time.sleep(2)
        led4.apagar()
        del led4

    




# ********************************************************************************
#                                                                           
#                   R E F E R E N C I A S  / C O M E N T A R I O S  
#
#
# -------------------------------------------------------------------------------------
# 1. Uso de gc (Recolección de Basura)
# MicroPython tiene un módulo llamado gc que te permite interactuar con la recolección de basura, 
# y a través de este, puedes obtener algunas métricas sobre el uso de memoria.
#
# Funciones de gc para obtener información de la memoria:
#
# gc.mem_free(): Devuelve la cantidad de memoria libre disponible en el dispositivo (en bytes).
# gc.mem_alloc(): Devuelve la cantidad de memoria que está siendo utilizada actualmente por los 
#                 objetos de Python (en bytes).
# gc.mem_limit() (en algunos casos): Te muestra el límite máximo de memoria que se puede usar 
#                (en dispositivos con soporte para esta función).
# gc.collect(): Fuerza la recolección de basura para liberar memoria no utilizada.
#
# En MicroPython para el ESP32, puedes medir el tiempo de ejecución de un evento 
# (o un fragmento de código) utilizando el módulo time que está disponible en MicroPython. 
# Una manera común de medir el tiempo de ejecución es utilizando la función time.ticks_ms() o 
# time.ticks_us(), que proporcionan la cantidad de milisegundos o microsegundos desde que el 
# dispositivo se encendió, respectivamente.
#
# time.ticks_ms() devuelve el número de milisegundos desde que el dispositivo fue encendido.
# time.ticks_us(), devuelve el número de microsegundos desde el inicio del dispositivo. 
#                  El procedimiento es el mismo que con ticks_ms(), pero con una mayor resolución.
# time.ticks_diff(end_time, start_time): Calcula la diferencia entre el tiempo de fin y el tiempo 
#                  de inicio en microsegundos, proporcionando el tiempo transcurrido.
# *********************************************************************************