# ==========================================================
# UTILIDADES PARA RASPBERRY PI PICO (MicroPython / Wokwi)
# OLED SSD1306 | Servo | LED RGB | Ultrasonico HC-SR04 | Potenciometro
#
# Como usarlo: copia todo esto en main.py y usa solo lo que necesites.
# Para el OLED, el proyecto debe tener el archivo ssd1306.py
# (en Wokwi: boton "+" > Add new file > ssd1306.py, o copialo de tu otro proyecto).
# ==========================================================
from machine import Pin, I2C, PWM, ADC, time_pulse_us
import utime
# ----------------------------------------------------------
# GENERALES
# ----------------------------------------------------------
def mapear(x, in_min, in_max, out_min, out_max):
"""Convierte x de un rango a otro (como map() de Arduino)."""
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
def limitar(x, minimo, maximo):
"""Evita que x se salga del rango [minimo, maximo]."""
return max(minimo, min(maximo, x))
def iniciar_pot(pin=28):
"""Potenciometro en ADC. Pines validos: 26, 27, 28."""
return ADC(pin)
def leer_pot(pot, minimo=0, maximo=100):
"""Lee el potenciometro y lo devuelve en el rango que pidas."""
return mapear(pot.read_u16(), 0, 65535, minimo, maximo)
# ----------------------------------------------------------
# OLED SSD1306 (I2C)
# Pantalla de 128x64: cada letra mide 8x8 px -> 16 letras por linea.
# Pines I2C0 validos: SDA = 0, 4, 8, 12... SCL = 1, 5, 9, 13...
# ----------------------------------------------------------
def iniciar_oled(sda=0, scl=1, ancho=128, alto=64, bus=0):
from ssd1306 import SSD1306_I2C # se importa aqui para no fallar si no hay OLED
i2c = I2C(bus, sda=Pin(sda), scl=Pin(scl), freq=400000)
return SSD1306_I2C(ancho, alto, i2c)
def oled_mostrar(oled, lineas, limpiar=True):
"""Muestra una lista de textos, uno por linea (hasta 6 lineas)."""
if limpiar:
oled.fill(0)
for i, texto in enumerate(lineas):
oled.text(str(texto), 0, i * 10)
oled.show()
def oled_texto(oled, texto, x, y, limpiar=False):
"""Escribe un texto en una posicion exacta (x, y)."""
if limpiar:
oled.fill(0)
oled.text(str(texto), x, y)
oled.show()
def oled_centrado(oled, texto, y, limpiar=False):
"""Escribe un texto centrado horizontalmente."""
if limpiar:
oled.fill(0)
texto = str(texto)
x = (oled.width - len(texto) * 8) // 2
oled.text(texto, max(0, x), y)
oled.show()
def oled_limpiar(oled):
oled.fill(0)
oled.show()
def oled_barra(oled, valor, maximo, y=50, alto=10):
"""Dibuja una barra de progreso (por ejemplo para distancia o angulo)."""
ancho = int(limitar(valor / maximo, 0, 1) * (oled.width - 2))
oled.rect(0, y, oled.width, alto, 1) # marco
oled.fill_rect(1, y + 1, ancho, alto - 2, 1) # relleno
oled.show()
# ----------------------------------------------------------
# SERVO (PWM a 50 Hz)
# Valores de duty (de tu ejercicio): 2000 = 0 grados, 9000 = 180 grados.
# Si el servo no llega a los extremos, ajusta SERVO_MIN / SERVO_MAX.
# ----------------------------------------------------------
SERVO_MIN = 2000
SERVO_MAX = 9000
def iniciar_servo(pin):
servo = PWM(Pin(pin))
servo.freq(50)
return servo
def servo_angulo(servo, angulo):
"""Mueve el servo a un angulo de 0 a 180."""
angulo = limitar(angulo, 0, 180)
servo.duty_u16(int(mapear(angulo, 0, 180, SERVO_MIN, SERVO_MAX)))
def servo_barrido(servo, desde=0, hasta=180, paso=5, pausa_ms=20):
"""Va de 'desde' a 'hasta' y regresa."""
for a in range(desde, hasta + 1, paso):
servo_angulo(servo, a)
utime.sleep_ms(pausa_ms)
for a in range(hasta, desde - 1, -paso):
servo_angulo(servo, a)
utime.sleep_ms(pausa_ms)
# ----------------------------------------------------------
# LED RGB (3 pines PWM)
# anodo_comun=False -> catodo comun (el pin comun va a GND) [lo normal en Wokwi]
# anodo_comun=True -> anodo comun (el pin comun va a 3V3), la logica se invierte
# Cada color va de 0 a 255.
# ----------------------------------------------------------
COLORES = {
"rojo": (255, 0, 0),
"verde": (0, 255, 0),
"azul": (0, 0, 255),
"amarillo": (255, 255, 0),
"cian": (0, 255, 255),
"magenta": (255, 0, 255),
"blanco": (255, 255, 255),
"naranja": (255, 80, 0),
"apagado": (0, 0, 0),
}
def iniciar_rgb(pin_r, pin_g, pin_b, anodo_comun=False):
pines = []
for p in (pin_r, pin_g, pin_b):
pwm = PWM(Pin(p))
pwm.freq(1000)
pines.append(pwm)
return {"pwm": pines, "anodo": anodo_comun}
def rgb_color(rgb, r, g, b):
"""Pone un color con valores de 0 a 255."""
for pwm, valor in zip(rgb["pwm"], (r, g, b)):
duty = int(limitar(valor, 0, 255) / 255 * 65535)
pwm.duty_u16(65535 - duty if rgb["anodo"] else duty)
def rgb_nombre(rgb, nombre):
"""Pone un color por nombre: rgb_nombre(led, "rojo")."""
r, g, b = COLORES[nombre]
rgb_color(rgb, r, g, b)
def rgb_apagar(rgb):
rgb_color(rgb, 0, 0, 0)
def semaforo_rgb(rgb, distancia, cerca=20, medio=50):
"""Rojo si esta cerca, amarillo a distancia media, verde si esta lejos.
Si distancia es None (no detecto nada), apaga el LED."""
if distancia is None:
rgb_apagar(rgb)
elif distancia <= cerca:
rgb_nombre(rgb, "rojo")
elif distancia <= medio:
rgb_nombre(rgb, "amarillo")
else:
rgb_nombre(rgb, "verde")
# ----------------------------------------------------------
# ULTRASONICO HC-SR04
# Devuelve la distancia en cm, o None si no detecto nada.
# ----------------------------------------------------------
def iniciar_ultrasonico(pin_trig, pin_echo):
return (Pin(pin_trig, Pin.OUT), Pin(pin_echo, Pin.IN))
def medir_distancia(sensor, timeout_us=30000):
trig, echo = sensor
trig.low()
utime.sleep_us(2)
trig.high()
utime.sleep_us(10)
trig.low()
duracion = time_pulse_us(echo, 1, timeout_us)
if duracion < 0:
return None
return duracion * 0.0343 / 2 # velocidad del sonido: 0.0343 cm/us, ida y vuelta
def distancia_promedio(sensor, muestras=5):
"""Promedia varias lecturas para que el numero no salte tanto."""
total, validas = 0, 0
for _ in range(muestras):
d = medir_distancia(sensor)
if d is not None:
total += d
validas += 1
utime.sleep_ms(10)
return total / validas if validas else None
# ==========================================================
# EJEMPLOS COMBINADOS
# Quita el # de UN bloque a la vez (selecciona y Cmd + /) y ajusta los pines
# a como armaste el circuito.
# ==========================================================
# ---- 1) Ultrasonico + OLED: mostrar la distancia ----------
# oled = iniciar_oled(sda=0, scl=1)
# sensor = iniciar_ultrasonico(pin_trig=3, pin_echo=2)
# while True:
# d = distancia_promedio(sensor)
# if d is None:
# oled_mostrar(oled, ["Sin objeto"])
# else:
# oled_mostrar(oled, ["Distancia:", "%.1f cm" % d])
# oled_barra(oled, d, 200)
# utime.sleep_ms(200)
# ---- 2) Potenciometro + Servo + OLED: mostrar el angulo ---
# oled = iniciar_oled(sda=0, scl=1)
# servo = iniciar_servo(15)
# pot = iniciar_pot(28)
# while True:
# angulo = leer_pot(pot, 0, 180)
# servo_angulo(servo, angulo)
# oled_mostrar(oled, ["Angulo:", "%d grados" % angulo])
# utime.sleep_ms(50)
# ---- 3) Ultrasonico + RGB: semaforo de distancia ----------
# sensor = iniciar_ultrasonico(pin_trig=3, pin_echo=2)
# led = iniciar_rgb(pin_r=10, pin_g=11, pin_b=12)
# while True:
# d = distancia_promedio(sensor)
# semaforo_rgb(led, d, cerca=20, medio=50)
# print("Distancia:", d)
# utime.sleep_ms(200)
# ---- 4) Ultrasonico + Servo: puerta automatica ------------
# sensor = iniciar_ultrasonico(pin_trig=3, pin_echo=2)
# servo = iniciar_servo(15)
# while True:
# d = distancia_promedio(sensor)
# if d is not None and d < 20:
# servo_angulo(servo, 90) # abre
# else:
# servo_angulo(servo, 0) # cierra
# utime.sleep_ms(100)
# ---- 5) Todo junto: sensor -> OLED + RGB + Servo ----------
# oled = iniciar_oled(sda=0, scl=1)
# sensor = iniciar_ultrasonico(pin_trig=3, pin_echo=2)
# led = iniciar_rgb(10, 11, 12)
# servo = iniciar_servo(15)
# while True:
# d = distancia_promedio(sensor)
# semaforo_rgb(led, d)
# if d is None:
# oled_mostrar(oled, ["Sin objeto"])
# servo_angulo(servo, 0)
# else:
# oled_mostrar(oled, ["Distancia:", "%.1f cm" % d])
# servo_angulo(servo, mapear(limitar(d, 0, 100), 0, 100, 0, 180))
# utime.sleep_ms(200)Loading
ssd1306
ssd1306