Detener Python remoto y ver la OLED en el mismo instante

Siguiente nivel

Hablar con otros chips

El ESP32 puede conversar con sensores, pantallas y otras placas. Cada uno habla un «idioma» (protocolo). Aquí verás cuatro, cada uno con su circuito en Wokwi, su código completo y una práctica. Todo está en la carpeta chips/ del repositorio (haz git pull si no la tienes).

1. Teoría

   Los cuatro idiomas de los chips

   Protocolo	Cables de datos	¿Cómo sabe a quién le habla?	Chip de ejemplo
   Un cable	1: datos	Solo hay un chip en ese cable	DHT22 (temperatura)
   I2C	2: SDA (datos) y SCL (reloj)	Cada chip tiene una dirección, como un número de casa	MPU6050 (movimiento) y la OLED
   SPI	3: MOSI (datos), SCK (reloj) y CS	Un cable CS por chip: «te hablo a ti»	MAX7219 (matriz de LEDs)
   UART	2: TX (envía) y RX (recibe), cruzados	Solo hay dos: uno en cada punta	Otra placa, un GPS, el PC

   Para cualquier chip, la receta siempre es la misma:

   1. Energía: VCC a 3V3 (o 5V si el chip lo pide) y GND a GND.
   2. Cables de datos: a los pines que elijas, según el protocolo.
   3. Crear el bus en el código diciendo qué pines usaste.
   4. Comprobar que el chip responde antes de pedirle nada.
   5. Leer o escribir datos y mostrarlos.
2. Concepto nuevo · Un cable

   Chip 1 · DHT22, el termómetro embrujado

   El DHT22 mide temperatura y humedad. Usa un solo cable de datos: el ESP32 le pide una medida y el sensor responde por el mismo cable, por turnos.

   • VCC → 3V3
   • GND → GND
   • SDA (datos) → 4

   También lleva la OLED conectada como siempre (21, 22, 3V3 y GND) para mostrar los valores.

   Configurar la comunicación, paso a paso

   1. 1

      Importar el módulo

      MicroPython ya trae el idioma del DHT22: se llama dht.

      python

      import dht
      from machine import Pin

   2. 2

      Crear el sensor con su pin

      Solo hay que decirle en qué pin está el cable de datos. Si el cable va al 4, el código dice 4.

      python

      sensor = dht.DHT22(Pin(4))

   3. 3

      Pedir una medida

      measure() hace la conversación por el cable: el ESP32 pregunta y el sensor contesta.

      python

      sensor.measure()

   4. 4

      Leer los valores

      Después de medir, se leen los dos números. Entre medidas hay que esperar al menos 2 segundos.

      python

      temperatura = sensor.temperature()   # grados Celsius
      humedad = sensor.humidity()         # porcentaje

   5. 5

      Comprobar

      Pon un breakpoint en mostrar(...) y mira temperatura y humedad en Variables. Mientras corre la simulación, haz clic en el DHT22 de Wokwi: aparecen controles para cambiar la temperatura.

   Ver el archivo completo: chips/1-dht22/termometro.py

   python · termometro.pyCopiar

   # Chip 1 · DHT22: el termómetro embrujado.
   # Protocolo de UN cable: el sensor y el ESP32 se turnan para hablar por el pin 4.
   import time
   import dht
   from machine import Pin, I2C
   import ssd1306
   
   
   def preparar_pantalla():
       i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
       return ssd1306.SSD1306_I2C(128, 64, i2c)
   
   
   def preparar_sensor():
       # El DHT22 solo necesita saber en qué pin está su cable de datos.
       return dht.DHT22(Pin(4))
   
   
   def leer(sensor):
       sensor.measure()  # pide una medida nueva al sensor
       return sensor.temperature(), sensor.humidity()
   
   
   def mostrar(display, temperatura, humedad):
       display.fill(0)
       display.text("Termometro", 24, 0, 1)
       display.text("Temp: %.1f C" % temperatura, 0, 20, 1)
       display.text("Humedad: %d %%" % humedad, 0, 32, 1)
       if temperatura > 30:
           display.text("Calor de caldero", 0, 52, 1)
       display.show()
   
   
   def main():
       display = preparar_pantalla()
       sensor = preparar_sensor()
       for vuelta in range(30):
           temperatura, humedad = leer(sensor)
           mostrar(display, temperatura, humedad)  # breakpoint aquí para ver los valores
           time.sleep(2)  # el DHT22 necesita 2 segundos entre medidas
   
   
   if __name__ == "__main__":
       main()

   Para probarlo: en Wokwi, Select Config File → chips/1-dht22/wokwi.toml y Start Simulation. Luego, en Ejecutar y depurar, elige Chip 1 · DHT22 termómetro — REMOTA GHI.
3. Práctica · Chip 1

   Alarma de frío de tumba

   Usa: if · elif · el DHT22

   En termometro.py, dentro de mostrar, añade un aviso cuando haga frío:

   python · termometro.pyCopiar

       if temperatura > 30:
           display.text("Calor de caldero", 0, 52, 1)
       elif temperatura < ___:
           display.text(___, 0, 52, 1)

   Pista 1

   elif significa «si no pasó lo de arriba, pero pasa esto otro».

   Pista 2

   Elige un número de grados que te parezca frío, por ejemplo menos de 5.

   Pista 3

   El texto va entre comillas y no puede pasar de 16 letras. Sin tildes: la OLED no las tiene.

   Comprueba: haz clic en el DHT22 en Wokwi y baja la temperatura. ¿En qué valor exacto cambia el mensaje? ¿Qué pasa justo en ese número?

   ¡Lo logré!
4. Profundización · I2C

   Chip 2 · MPU6050, la varita mágica

   El MPU6050 mide inclinación y movimiento. Habla I2C, el mismo idioma que la OLED, así que comparte los mismos dos cables: SDA en el 21 y SCL en el 22. ¿Cómo sabe cada chip que le hablan a él? Por su dirección: la OLED es la 0x3C y el MPU6050 la 0x68.

   Configurar la comunicación, paso a paso

   1. 1

      Crear el bus I2C una sola vez

      Un bus para los dos chips, con los pines del reloj y los datos.

      python

      i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)

   2. 2

      Buscar quién está conectado

      scan() pregunta en todas las direcciones y devuelve las que contestan. Las da en decimal: 60 es 0x3C y 104 es 0x68.

      python

      print(i2c.scan())   # [60, 104]

   3. 3

      Despertar el MPU6050

      Los chips I2C guardan su configuración en registros, cajitas numeradas. El MPU6050 arranca dormido: se despierta escribiendo 0 en su registro 0x6B.

      python

      i2c.writeto_mem(0x68, 0x6B, b"\x00")   # (dirección, registro, dato)

   4. 4

      Leer los datos

      La aceleración está en 6 bytes a partir del registro 0x3B: dos por cada eje X, Y, Z.

      python

      datos = i2c.readfrom_mem(0x68, 0x3B, 6)

   5. 5

      Convertir los bytes en números

      Cada eje viene en dos bytes que se juntan en un número con signo. Dividido entre 16384 da la aceleración en «g» (1 g es la gravedad).

      python

      ax = con_signo(datos[0], datos[1]) / 16384

   6. 6

      Comprobar

      Mira la consola: debe imprimir [60, 104]. Pon un breakpoint en mostrar(...) y mira ax y ay. Para «inclinar» la varita, cambia accelX y accelY en chips/2-mpu6050/diagram.json y vuelve a iniciar la simulación.

   Ver el archivo completo: chips/2-mpu6050/varita.py

   python · varita.pyCopiar

   # Chip 2 · MPU6050: la varita mágica.
   # Protocolo I2C: comparte los cables SDA (21) y SCL (22) con la OLED.
   # Cada chip tiene su dirección: OLED = 0x3C (60), MPU6050 = 0x68 (104).
   import time
   from machine import Pin, I2C
   import ssd1306
   
   MPU = 0x68          # dirección del MPU6050 en el bus I2C
   REG_ENCENDIDO = 0x6B  # registro PWR_MGMT_1: 0 = despierto
   REG_ACELERACION = 0x3B  # aquí empiezan los 6 bytes de aceleración X, Y, Z
   
   
   def preparar_bus():
       return I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
   
   
   def despertar_mpu(i2c):
       # Al encender, el MPU6050 está dormido: se despierta escribiendo 0 en su registro.
       i2c.writeto_mem(MPU, REG_ENCENDIDO, b"\x00")
   
   
   def con_signo(alto, bajo):
       # Junta dos bytes en un número que puede ser negativo (−32768 a 32767).
       valor = (alto << 8) | bajo
       if valor > 32767:
           valor -= 65536
       return valor
   
   
   def leer_aceleracion(i2c):
       datos = i2c.readfrom_mem(MPU, REG_ACELERACION, 6)
       ax = con_signo(datos[0], datos[1]) / 16384  # 16384 = 1 g en el rango de ±2 g
       ay = con_signo(datos[2], datos[3]) / 16384
       az = con_signo(datos[4], datos[5]) / 16384
       return ax, ay, az
   
   
   def mostrar(display, ax, ay):
       display.fill(0)
       display.text("Varita magica", 12, 0, 1)
       x = 60 + int(ax * 50)
       y = 34 + int(ay * 20)
       x = max(0, min(120, x))
       y = max(12, min(56, y))
       display.fill_rect(x, y, 8, 8, 1)  # el fantasma se mueve al inclinar
       display.show()
   
   
   def main():
       i2c = preparar_bus()
       print("Chips encontrados:", i2c.scan())  # debería mostrar [60, 104]
       display = ssd1306.SSD1306_I2C(128, 64, i2c)
       despertar_mpu(i2c)
       for vuelta in range(100):
           ax, ay, az = leer_aceleracion(i2c)
           mostrar(display, ax, ay)  # breakpoint aquí para ver ax, ay
           time.sleep(0.2)
   
   
   if __name__ == "__main__":
       main()

   Para probarlo: en Wokwi, Select Config File → chips/2-mpu6050/wokwi.toml y Start Simulation. Luego, en Ejecutar y depurar, elige Chip 2 · MPU6050 varita — REMOTA GHI.
5. Práctica · Chip 2

   ¿Dónde está la varita?

   Usa: i2c.scan() · direcciones · in

   En varita.py, dentro de main, cambia la línea del print por esta comprobación:

   python · varita.pyCopiar

       chips = i2c.scan()
       print("Chips encontrados:", chips)
       if ___ not in chips:
           print("No encuentro la varita: revisa SDA y SCL")

   Pista 1

   Busca la dirección del MPU6050: está guardada en una variable al principio del archivo.

   Pista 2

   x in lista pregunta si x está en la lista; not in, si NO está.

   Pista 3

   Para probar que funciona, en diagram.json borra la conexión de imu1:SDA y vuelve a iniciar.

   Comprueba: con todo conectado no aparece el aviso; sin el cable SDA del MPU6050, sí. Reto: haz que el fantasma se mueva al revés cuando inclinas.

   ¡Lo logré!
6. Concepto nuevo · SPI

   Chip 3 · MAX7219, la calabaza de LEDs

   El MAX7219 controla una matriz de 8 × 8 LEDs. Habla SPI: un cable de reloj, uno de datos y uno llamado CS que funciona como levantar la mano: mientras está en 0, el chip escucha.

   • VCC → 5V
   • GND → GND
   • DIN → 23
   • CLK → 18
   • CS → 5

   Configurar la comunicación, paso a paso

   1. 1

      Crear el bus SPI

      Se indica el reloj (sck) y los datos de salida (mosi). La velocidad es cuántos bits por segundo se envían.

      python

      spi = SPI(2, baudrate=1000000, sck=Pin(18), mosi=Pin(23))

   2. 2

      Preparar el pin CS

      CS empieza en 1: «no te estoy hablando».

      python

      cs = Pin(5, Pin.OUT, value=1)

   3. 3

      Hablar con el chip

      Cada orden son dos bytes: el número del registro y su valor, siempre entre bajar y subir CS.

      python

      cs.value(0)                          # levantar la mano
      spi.write(bytes([registro, valor]))  # enviar la orden
      cs.value(1)                          # el chip la guarda

   4. 4

      Encender y configurar

      Al arrancar se le dice cómo trabajar: usar las 8 filas, dibujar punto por punto, el brillo, y encender.

      python

      escribir(spi, cs, 0x0B, 7)   # usar las 8 filas
      escribir(spi, cs, 0x09, 0)   # punto por punto
      escribir(spi, cs, 0x0A, 3)   # brillo (0 a 15)
      escribir(spi, cs, 0x0C, 1)   # encender

   5. 5

      Dibujar

      Las filas son los registros 1 a 8. Cada fila es un número binario: cada 1 es un LED encendido.

      python

      escribir(spi, cs, 1, 0b00011000)   # fila 1: dos LEDs en el centro

   6. 6

      Comprobar

      Pon un breakpoint en dibujar(...) y avanza con F5: la matriz cambia entre calabaza y fantasma. Si el dibujo sale girado o como en un espejo, es por cómo está montada la matriz: prueba "layout": "fc16" en los attrs de la matriz en diagram.json.

   Ver el archivo completo: chips/3-max7219/calabaza_leds.py

   python · calabaza_leds.pyCopiar

   # Chip 3 · MAX7219: la calabaza de LEDs (matriz de 8 × 8).
   # Protocolo SPI: reloj (18), datos (23) y un pin de "te hablo a ti" llamado CS (5).
   import time
   from machine import Pin, SPI
   
   REG_DECODIFICAR = 0x09  # 0 = dibujamos punto por punto, sin números automáticos
   REG_BRILLO = 0x0A       # de 0 (tenue) a 15 (máximo)
   REG_FILAS = 0x0B        # cuántas filas usar: 7 = las 8 (de 0 a 7)
   REG_ENCENDIDO = 0x0C    # 1 = encendido
   REG_PRUEBA = 0x0F       # 1 = enciende todo para probar
   
   CALABAZA = [
       0b00011000,
       0b01111110,
       0b11111111,
       0b10111101,
       0b11111111,
       0b10100101,
       0b11011011,
       0b01111110,
   ]
   
   FANTASMA = [
       0b00111100,
       0b01111110,
       0b11011011,
       0b11111111,
       0b11111111,
       0b11111111,
       0b11111111,
       0b10101010,
   ]
   
   
   def preparar_spi():
       spi = SPI(2, baudrate=1000000, sck=Pin(18), mosi=Pin(23))
       cs = Pin(5, Pin.OUT, value=1)  # CS en 1 = "no te estoy hablando"
       return spi, cs
   
   
   def escribir(spi, cs, registro, valor):
       cs.value(0)                       # 1. levantar la mano: "te hablo a ti"
       spi.write(bytes([registro, valor]))  # 2. enviar dirección del registro y valor
       cs.value(1)                       # 3. bajar la mano: el chip guarda el dato
   
   
   def iniciar(spi, cs):
       escribir(spi, cs, REG_PRUEBA, 0)
       escribir(spi, cs, REG_FILAS, 7)
       escribir(spi, cs, REG_DECODIFICAR, 0)
       escribir(spi, cs, REG_BRILLO, 3)
       escribir(spi, cs, REG_ENCENDIDO, 1)
   
   
   def dibujar(spi, cs, filas):
       for numero in range(8):
           escribir(spi, cs, numero + 1, filas[numero])  # las filas son los registros 1 a 8
   
   
   def main():
       spi, cs = preparar_spi()
       iniciar(spi, cs)
       for vez in range(6):
           dibujar(spi, cs, CALABAZA)  # breakpoint aquí
           time.sleep(1)
           dibujar(spi, cs, FANTASMA)
           time.sleep(1)
       print("Fin del espectáculo")
   
   
   if __name__ == "__main__":
       main()

   Para probarlo: en Wokwi, Select Config File → chips/3-max7219/wokwi.toml y Start Simulation. Luego, en Ejecutar y depurar, elige Chip 3 · MAX7219 calabaza — REMOTA GHI.
7. Práctica · Chip 3

   Dibuja un murciélago

   Usa: números binarios · dibujar · brillo

   Añade esta figura debajo de FANTASMA y complétala. Dibújala antes en papel en una cuadrícula de 8 × 8.

   python · calabaza_leds.pyCopiar

   MURCIELAGO = [
       0b00000000,
       0b10000001,
       0b11000011,
       0b11111111,
       0b___,      # cuerpo: 8 cifras, 1 = encendido
       0b00100100,
       0b00000000,
       0b00000000,
   ]

   Luego, en main, añade dibujar(spi, cs, MURCIELAGO) y un time.sleep(1) dentro del for, y cambia el brillo:

   python · calabaza_leds.pyCopiar

       escribir(spi, cs, REG_BRILLO, ___)   # de 0 a 15

   Pista 1

   Cada fila tiene exactamente 8 cifras, solo ceros y unos.

   Pista 2

   El cuerpo del murciélago va en el centro: los LEDs de los extremos de esa fila, apagados.

   Pista 3

   Para el brillo, cualquier número de 0 a 15. ¿Se nota la diferencia entre 1 y 15?

   Comprueba: aparecen calabaza, fantasma y murciélago. ¿Qué pasa si una fila tiene 9 cifras?

   ¡Lo logré!
8. Concepto nuevo · UART

   Chip 4 · UART, el mensaje secreto

   UART (puerto serie) es como un teléfono: TX habla y RX escucha. Entre dos placas se cruzan: el TX de una va al RX de la otra, y comparten GND. Es el mismo idioma con el que el ESP32 te manda los print(). En este circuito hay un solo ESP32, así que el cable sale por el 17 y vuelve a entrar por el 16: el ESP32 se habla a sí mismo.

   • 16 RX → 17 TX

   Configurar la comunicación, paso a paso

   1. 1

      Crear el puerto serie

      Se elige el UART 2 (el 0 lo usa el PC), la velocidad y los pines. Los dos lados tienen que usar la misma velocidad; si no, llegan letras sin sentido.

      python

      uart = UART(2, baudrate=9600, tx=17, rx=16)

   2. 2

      Enviar

      write manda el texto letra por letra por el cable TX.

      python

      uart.write("BOO")

   3. 3

      Esperar y comprobar si llegó algo

      any() dice cuántos bytes están esperando en RX.

      python

      time.sleep(0.1)
      if uart.any():
          mensaje = uart.read().decode()   # bytes → texto

   4. 4

      Comprobar

      Pon un breakpoint en mostrar(...) y compara palabra con llegada en Variables. La OLED muestra lo enviado y lo recibido.

   Ver el archivo completo: chips/4-uart/mensaje_secreto.py

   python · mensaje_secreto.pyCopiar

   # Chip 4 · UART: el mensaje secreto.
   # Protocolo UART (puerto serie): un cable para enviar (TX, 17) y otro para recibir (RX, 16).
   # En este circuito el cable sale del 17 y vuelve a entrar por el 16: el ESP32 se habla a sí mismo.
   # Con dos placas reales, el TX de una va al RX de la otra (y comparten GND).
   import time
   from machine import Pin, I2C, UART
   import ssd1306
   
   
   def preparar_pantalla():
       i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
       return ssd1306.SSD1306_I2C(128, 64, i2c)
   
   
   def preparar_uart():
       # UART 2, velocidad 9600 bits por segundo. Los dos lados deben usar la MISMA velocidad.
       return UART(2, baudrate=9600, tx=17, rx=16)
   
   
   def enviar(uart, texto):
       uart.write(texto)
   
   
   def recibir(uart):
       time.sleep(0.1)  # dar tiempo a que lleguen las letras
       if uart.any():
           return uart.read().decode()
       return ""
   
   
   def mostrar(display, enviado, recibido):
       display.fill(0)
       display.text("Mensaje secreto", 4, 0, 1)
       display.text("Envie: " + enviado, 0, 24, 1)
       display.text("Llego: " + recibido, 0, 40, 1)
       display.show()
   
   
   def main():
       display = preparar_pantalla()
       uart = preparar_uart()
       for palabra in ["BOO", "Dulce", "Truco"]:
           enviar(uart, palabra)
           llegada = recibir(uart)
           mostrar(display, palabra, llegada)  # breakpoint aquí
           time.sleep(1)
   
   
   if __name__ == "__main__":
       main()

   Para probarlo: en Wokwi, Select Config File → chips/4-uart/wokwi.toml y Start Simulation. Luego, en Ejecutar y depurar, elige Chip 4 · UART mensaje secreto — REMOTA GHI.
9. Práctica · Chip 4

   Corta la línea

   Usa: uart.write · listas · el cable TX → RX

   En mensaje_secreto.py, añade tu propia palabra a la lista:

   python · mensaje_secreto.pyCopiar

       for palabra in ["BOO", "Dulce", "Truco", ___]:

   Pista 1

   La palabra va entre comillas. Recuerda el límite: «Envie: » ya ocupa 7 letras de las 16.

   Pista 2

   Después, abre chips/4-uart/diagram.json, borra la conexión esp:17 → esp:16 y vuelve a iniciar. Predice antes qué mostrará «Llego:».

   Comprueba: tu palabra aparece en «Envie» y en «Llego». Sin el cable, ¿qué llega? ¿Por qué el programa no se queda esperando para siempre?

   ¡Lo logré!
10. Reto final de chips

    La casa embrujada

    Con tu tutor, diseña un circuito con DHT22 y MAX7219 a la vez: si hace calor, la matriz muestra la calabaza; si hace frío, el fantasma. Antes de programar, haz la tabla de pines: ¿alguno se repite? Revisa el mapa de pines para elegir.

    ¡Lo logré!

Estos circuitos y programas se prepararon con la misma configuración de la demo, pero aún no se han probado en tu Wokwi. Si algo no responde, revisa primero los cables con la receta de 5 pasos y avisa a tu tutor con el mensaje completo.