10 Practicas con MycroPython con Display y sensores

gistfile1.txt

Alumno: Carretero Ocaña Kevin Isaac
Numero de control: 22211531

Practicas usando raspberry pi pico w

 Práctica 1: Mostrar mensaje en pantalla OLED
 
from machine import Pin, I2C
import ssd1306
import time

# Configurar I2C: GP0 = SDA, GP1 = SCL
i2c = I2C(0, scl=Pin(1), sda=Pin(0))

# Inicializar pantalla OLED (128x64)
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Limpiar pantalla
oled.fill(0)

# Mostrar texto en la pantalla
oled.text("Hola, Kevin!", 0, 0)
oled.text("Raspberry Pi Pico W", 0, 16)
oled.text("OLED funcionando :)", 0, 32)

# Actualizar la pantalla
oled.show()

# Mantener mensaje en pantalla
while True:
    time.sleep(1)
    
 
Práctica 2: Sensor DHT22 con pantalla OLED

from machine import Pin, I2C
import ssd1306
import dht
import time

# Configuración del sensor DHT22 en el pin GP15
sensor = dht.DHT22(Pin(15))

# Configuración de la pantalla OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

while True:
    try:
        sensor.measure()
        temp = sensor.temperature()
        hum = sensor.humidity()

        # Limpiar pantalla
        oled.fill(0)

        # Mostrar los datos en OLED
        oled.text("Temp: {:.1f} C".format(temp), 0, 0)
        oled.text("Hum: {:.1f} %".format(hum), 0, 16)
        oled.text("Lectura OK", 0, 40)

        oled.show()
    except OSError as e:
        oled.fill(0)
        oled.text("Error lectura DHT", 0, 0)
        oled.show()

    time.sleep(2)
    
 Práctica 3: Medir distancia con sensor ultrasónico HC-SR04 y mostrar en pantalla OLED

from machine import Pin, I2C, time_pulse_us
import ssd1306
import time

# Configuración de I2C y OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Pines para el HC-SR04
trig = Pin(14, Pin.OUT)
echo = Pin(13, Pin.IN)

def medir_distancia():
    # Enviar pulso de 10us al Trig
    trig.low()
    time.sleep_us(2)
    trig.high()
    time.sleep_us(10)
    trig.low()
    
    # Medir duración del pulso en el pin Echo
    duracion = time_pulse_us(echo, 1)
    
    # Calcular distancia (velocidad del sonido = 34300 cm/s)
    distancia_cm = (duracion * 0.0343) / 2
    return distancia_cm

# Bucle principal
while True:
    distancia = medir_distancia()
    
    # Mostrar en pantalla
    oled.fill(0)
    oled.text("Distancia:", 0, 0)
    oled.text("{:.2f} cm".format(distancia), 0, 16)

    if distancia < 10:
        oled.text("Muy cerca!", 0, 40)
    elif distancia < 50:
        oled.text("Dist. media", 0, 40)
    else:
        oled.text("Lejos", 0, 40)
        
    oled.show()
    time.sleep(1)
    
Práctica 4: Sensor de luz (LDR) con pantalla OLED

from machine import ADC, Pin, I2C
import ssd1306
import time

# Configurar OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Configurar entrada analógica en GP26
ldr = ADC(Pin(26))

while True:
    valor = ldr.read_u16()  # 0 a 65535

    # Convertir a porcentaje (aproximado)
    porcentaje = (valor / 65535) * 100

    # Mostrar en OLED
    oled.fill(0)
    oled.text("Sensor de Luz", 0, 0)
    oled.text("Brillo: {:.1f}%".format(porcentaje), 0, 20)

    # Mensaje según nivel de luz
    if porcentaje > 80:
        oled.text("Ambiente claro", 0, 40)
    elif porcentaje > 40:
        oled.text("Luz media", 0, 40)
    else:
        oled.text("Ambiente oscuro", 0, 40)

    oled.show()
    time.sleep(1)

Práctica 5: Contador con pulsador y pantalla OLED

from machine import Pin, I2C
import ssd1306
import time

# Configuración del I2C y pantalla OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Configuración del pulsador (usa pull-up interno)
boton = Pin(12, Pin.IN, Pin.PULL_UP)

# Contador de pulsaciones
contador = 0
estado_anterior = 1  # Estado inicial (no presionado)

while True:
    estado_actual = boton.value()

    # Detectar flanco de bajada (presión de botón)
    if estado_anterior == 1 and estado_actual == 0:
        contador += 1

        # Mostrar en OLED
        oled.fill(0)
        oled.text("Contador:", 0, 0)
        oled.text(str(contador), 0, 20)
        oled.show()

        time.sleep(0.2)  # Debounce

    estado_anterior = estado_actual
Práctica 6: Controlar un servo con potenciómetro y mostrar ángulo en OLED

from machine import ADC, Pin, PWM, I2C
import ssd1306
import time

# Configurar I2C para OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Configurar potenciómetro (ADC)
pot = ADC(Pin(26))

# Configurar servo motor
servo = PWM(Pin(15))
servo.freq(50)  # Frecuencia estándar de servo: 50Hz

def map_angle(value, in_min, in_max, out_min, out_max):
    """Mapea el valor del potenciómetro a ángulo de 0-180"""
    return int((value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min)

while True:
    valor_pot = pot.read_u16()  # 0 a 65535
    angulo = map_angle(valor_pot, 0, 65535, 0, 180)

    # Convertir ángulo a ciclo de trabajo para servo
    duty = int((angulo / 180) * 5000 + 1000)  # 1000-6000 = 0° a 180°
    servo.duty_u16(duty)

    # Mostrar en OLED
    oled.fill(0)
    oled.text("Control de Servo", 0, 0)
    oled.text("Angulo:", 0, 20)
    oled.text(str(angulo) + " grados", 0, 40)
    oled.show()

    time.sleep(0.1)
    
 7: Sensor de temperatura y humedad DHT22 con pantalla OLED
 
 from machine import Pin, I2C
import ssd1306
import dht
import time

# Inicializar I2C y OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Inicializar sensor DHT22 en pin GP14
sensor = dht.DHT22(Pin(14))

while True:
    try:
        sensor.measure()
        temp = sensor.temperature()
        hum = sensor.humidity()

        # Mostrar en OLED
        oled.fill(0)
        oled.text("DHT22 - Temp/Hum", 0, 0)
        oled.text("Temp: {:.1f} C".format(temp), 0, 20)
        oled.text("Hum:  {:.1f} %".format(hum), 0, 40)
        oled.show()

    except OSError as e:
        oled.fill(0)
        oled.text("Error al leer", 0, 0)
        oled.show()

    time.sleep(2)  # Medición cada 2 segundos


 Práctica 8: Medición de distancia con sensor ultrasónico HC-SR04 y OLED
 
from machine import Pin, I2C, time_pulse_us
import ssd1306
import time

# Inicializar pantalla OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Pines del sensor ultrasónico
trig = Pin(13, Pin.OUT)
echo = Pin(12, Pin.IN)

def medir_distancia():
    # Activar el trigger con un pulso de 10us
    trig.low()
    time.sleep_us(2)
    trig.high()
    time.sleep_us(10)
    trig.low()

    # Medir duración del pulso de retorno
    duracion = time_pulse_us(echo, 1, 30000)  # Timeout de 30 ms

    # Convertir tiempo a distancia en cm
    distancia_cm = (duracion / 2) / 29.1
    return distancia_cm

while True:
    try:
        distancia = medir_distancia()

        # Mostrar en OLED
        oled.fill(0)
        oled.text("Sensor Ultrasonico", 0, 0)
        oled.text("Distancia:", 0, 20)
        oled.text("{:.1f} cm".format(distancia), 0, 40)
        oled.show()

    except Exception as e:
        oled.fill(0)
        oled.text("Error:", 0, 0)
        oled.text(str(e), 0, 20)
        oled.show()

    time.sleep(1)
 
 Práctica 9: Acelerómetro MPU6050 con OLED – Mostrar inclinación
 from machine import Pin, I2C
import ssd1306
import mpu6050
import time

# Inicializar I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0))

# Inicializar OLED
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Inicializar MPU6050
sensor = mpu6050.accel(i2c)

while True:
    datos = sensor.get_values()
    ax = datos["AcX"] / 16384  # Normalizar (-2g a 2g)
    ay = datos["AcY"] / 16384

    # Calcular inclinación en grados (solo una estimación)
    inclinacion_x = ax * 90
    inclinacion_y = ay * 90

    # Mostrar en OLED
    oled.fill(0)
    oled.text("MPU6050 Inclinacion", 0, 0)
    oled.text("X: {:.1f}°".format(inclinacion_x), 0, 20)
    oled.text("Y: {:.1f}°".format(inclinacion_y), 0, 40)
    oled.show()

    time.sleep(0.2)

 
 Práctica 10: Control básico de un punto en OLED con 2 botones
 
 from machine import Pin, I2C
import ssd1306
import time

# Inicializar I2C y OLED
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

# Configurar botones con pull-down
btn_right = Pin(14, Pin.IN, Pin.PULL_DOWN)
btn_left = Pin(15, Pin.IN, Pin.PULL_DOWN)

# Posición inicial del punto en X
pos_x = 64
pos_y = 32  # Fijo verticalmente en la mitad de la pantalla

def dibujar_punto(x, y):
    oled.fill(0)
    oled.pixel(x, y, 1)
    oled.show()

while True:
    if btn_right.value() == 1:
        pos_x += 1
        if pos_x > 127:
            pos_x = 127

    if btn_left.value() == 1:
        pos_x -= 1
        if pos_x < 0:
            pos_x = 0

    dibujar_punto(pos_x, pos_y)
    time.sleep(0.05)

 

vacio y sin embargo se califico con 100 ?