from machine import Pin, ADC, PWM   # <-- Agregamos PWM
import time
 
# === GPIO ===
BTN_PULLUP_GPIO   = 14      # Pull-up: suelto=1, presionado=0
BTN_PULLDOWN_GPIO = 13      # Pull-down: suelto=0, presionado=1
 
LED_ROJO_GPIO  = 23         # Usaremos PWM aquí
LED_VERDE_GPIO = 22
 
LDR_ADC_GPIO  = 34
POT_ADC_GPIO  = 35
 
# === ENTRADAS (BOTONES) ===
btn_pullup_pin = Pin(BTN_PULLUP_GPIO, Pin.IN)   # Detecta 0 al presionar
btn_pulldn_pin = Pin(BTN_PULLDOWN_GPIO, Pin.IN) # Detecta 1 al presionar
 
# === ENTRADAS ANALÓGICAS (LDR y POT) ===
ldr = ADC(Pin(LDR_ADC_GPIO))
pot = ADC(Pin(POT_ADC_GPIO))
 
# Rango típico 0..4095
for adc in (ldr, pot):
    adc.atten(ADC.ATTN_11DB)      # ~0..3.3V
    adc.width(ADC.WIDTH_12BIT)    # 12 bits
 
# === SALIDAS ===
# LED rojo con PWM para controlar brillo
pwm_led = PWM(Pin(LED_ROJO_GPIO), freq=1000)  # 1 kHz es buena frecuencia
# LED verde como on/off normal (opcional)
led_verde = Pin(LED_VERDE_GPIO, Pin.OUT)
 
print("Listo: botones + LDR + POT controlando brillo por PWM...")
 
t_print = time.ticks_ms()
 
# Detectar API PWM disponible (ESP32 MicroPython suele usar duty de 0..1023)
# Tendremos helpers que funcionan en ambos casos.
def set_pwm_from_pct(pct):
    """pct: 0..100"""
    pct = max(0, min(100, int(pct)))
    try:
        # Algunos firmwares tienen duty_u16 (0..65535)
        value = int(pct * 65535 / 100)
        pwm_led.duty_u16(value)
    except AttributeError:
        # ESP32 clásico: duty de 10 bits (0..1023)
        value = int(pct * 1023 / 100)
        pwm_led.duty(value)
 
while True:
    # --- LECTURAS DIGITALES (BOTONES) ---
    v_up = btn_pullup_pin.value()
    v_dn = btn_pulldn_pin.value()
 
    # LED verde on/off según botón pull-down (presionado=1)
    led_verde.value(1 if v_dn == 1 else 0)
 
    # --- LECTURAS ANALÓGICAS ---
    ldr_raw = ldr.read()          # 0..4095
    pot_raw = pot.read()          # 0..4095
 
    # Mapeo a porcentaje 0..100
    ldr_pct = int((ldr_raw * 100) / 4095)
    pot_pct = int((pot_raw * 100) / 4095)
 
    # --- CONTROL DE BRILLO POR POT ---
    # pot_pct controla el brillo del LED PWM
    set_pwm_from_pct(pot_pct)
 
    # --- DEBUG (cada 300 ms) ---
    if time.ticks_diff(time.ticks_ms(), t_print) >= 300:
        t_print = time.ticks_ms()
        print(
            "UP:", v_up,
            "DN:", v_dn,
            "| LDR:", ldr_raw, f"({ldr_pct}%)",
            "| POT:", pot_raw, f"({pot_pct}%)",
            "| PWM:", f"{pot_pct}%"
        )
 
    time.sleep_ms(10)
 
 
from machine import Pin, ADC, PWM
import time
import dht
# CONFIGURAR GPIO => General Purpose In/Out
BTN_PULLUP_GPIO = 14
BTN_PULLDOWN_GPIO = 13
LED_ROJO_GPIO = 23
LED_VERDE_GPIO = 22
LED_PWM_GPIO = 21   # Nuevo LED controlado por potenciómetro
# Pines ADC (Analog Digital Converter)
LDR_ADC_GPIO = 34   # Solo entrada
POT_ADC_GPIO = 35   # Solo entrada
 
# ============================================================
# NUEVO SENSOR AGREGADO: DHT11
# ============================================================
# Se usa un pin libre para no afectar la configuración existente
# Puedes cambiarlo si ya tienes otro cableado.
DHT11_GPIO = 15
# VARIABLES DE LAS ENTRADAS DIGITALES
btn_pullup_pin = Pin(BTN_PULLUP_GPIO, Pin.IN)
btn_pulldown_pin = Pin(BTN_PULLDOWN_GPIO, Pin.IN)
# VARIABLES DE LAS ENTRADAS ANALÓGICAS
ldr = ADC(Pin(LDR_ADC_GPIO))
pot = ADC(Pin(POT_ADC_GPIO))
# Rango típico de lectura en ESP32 con MicroPython: 0–4095
ldr.atten(ADC.ATTN_11DB)   # Permite leer hasta ~3.3V
pot.atten(ADC.ATTN_11DB)
ldr.width(ADC.WIDTH_12BIT)
pot.width(ADC.WIDTH_12BIT)
# VARIABLES DE LAS SALIDAS
led_rojo = Pin(LED_ROJO_GPIO, Pin.OUT)
led_verde = Pin(LED_VERDE_GPIO, Pin.OUT)
# LED PWM en pin 21
led_pwm = PWM(Pin(LED_PWM_GPIO), freq=1000)  # Frecuencia de 1 kHz
led_pwm.duty(0)  # Inicia apagado
# ============================================================
# CONFIGURACIÓN DEL DHT11
# ============================================================
# OJO: DHT11 (circuito real), DHT22 (simulación), descomenta según lo requieras
sensor_dht = dht.DHT11(Pin(DHT11_GPIO))
# sensor_dht = dht.DHT22(Pin(DHT11_GPIO))
# Variables para almacenar la última lectura válida
temperatura = None
humedad = None
# Intervalos de trabajo
PRINT_INTERVAL_MS = 3000
DHT_INTERVAL_MS = 2000  # DHT11 no debe leerse demasiado rápido
print("Iniciando lectura de botones, LDR, POT, PWM y DHT11...")
 
t_print = time.ticks_ms()
 
t_dht = time.ticks_ms()
 
while True:
 
    # Lecturas actuales digitales
 
    v_up = btn_pullup_pin.value()
 
    v_dn = btn_pulldown_pin.value()
 
    # Lecturas actuales analógicas
 
    ldr_raw = ldr.read()      # 0..4095
 
    pot_raw = pot.read()      # 0..4095
 
    # Opcional: normalizar a porcentaje (0..100)
 
    ldr_pct = int((ldr_raw * 100) / 4095)
 
    pot_pct = int((pot_raw * 100) / 4095)
 
    # Control directo de LEDs digitales
 
    if v_up == 0:              # Pull-up
 
        led_verde.value(1)
 
    else:
 
        led_verde.value(0)
 
    led_rojo.value(1 if v_dn == 1 else 0)   # Pull-down
 
    # Convertir potenciómetro (0..4095) a PWM duty (0..1023)
 
    duty_pwm = int((pot_raw * 1023) / 4095)
 
    led_pwm.duty(duty_pwm)
 
    # ============================================================
 
    # LECTURA DEL DHT11 CADA 2 SEGUNDOS
 
    # ============================================================
 
    if time.ticks_diff(time.ticks_ms(), t_dht) >= DHT_INTERVAL_MS:
 
        t_dht = time.ticks_ms()
 
        try:
 
            sensor_dht.measure()
 
            temperatura = sensor_dht.temperature()
 
            humedad = sensor_dht.humidity()
 
        except OSError as e:
 
            # Si falla la lectura, se conservan los últimos valores válidos
 
            print("Error leyendo DHT11:", e)
 
    # Debug (muestra valores cada 3000 ms)
 
    if time.ticks_diff(time.ticks_ms(), t_print) >= 3000:
 
        t_print = time.ticks_ms()
 
        temp_txt = str(temperatura) + " C" if temperatura is not None else "Sin dato"
 
        hum_txt = str(humedad) + " %" if humedad is not None else "Sin dato"
 
        print(
 
            'UP:', v_up,
 
            'DN:', v_dn,
 
            'LDR:', ldr_raw, f'({ldr_pct}%)',
 
            'POT:', pot_raw, f'({pot_pct}%)',
 
            'PWM:', duty_pwm,
 
            'TEMP:', temp_txt,
 
            'HUM:', hum_txt
 
        )
 
    time.sleep_ms(10)