from machine import Pin, I2C
import time
# Configurar bus I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
# Escanear dispositivos conectados
devices = i2c.scan()
print("Dispositivos I2C detectados:", devices)
# Debe mostrar [60] si lo detecta.
#Conexión de Pantalla en Raspberry
<img width="1384" height="545" alt="image" src="https://gist.github.com/user-attachments/assets/a371afeb-1ef5-4ad6-88e5-7a14365d507f" />
## 2. Mostrar Información en Pantalla OLD de 7 Lineas
```python
"""
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Raspberry Pi Pico SSD1306 OLED Display (MicroPython) ┃
┃ ┃
┃ A program to display Hola Pico! SSD1306, text, and a ┃
┃ Texto Linea 0-7 al Final Muesta Finalizado :) ┃
┃ connected to a Raspberry Pi Pico. ┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
"""
from machine import Pin, I2C
import ssd1306
import time
# Inicializa I2C (ajusta si tus pines son distintos)
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
print("Direcciones I2C detectadas:", i2c.scan())
# Inicializa pantalla OLED
oled = ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C)
# Pantalla de inicio
oled.fill(0)
oled.text("Hola Pico!", 0, 0)
oled.text("SSD1306 OK", 0, 10)
oled.show()
time.sleep(2) # ← espera 2 segundos
# Animación lenta
for i in range(0, 64, 8):
oled.fill(0)
oled.text(f"Linea {i//8}", 0, i)
oled.show()
time.sleep(1) # ← espera 1 segundo entre líneas
# Mensaje final
oled.fill(0)
oled.text("Finalizado", 0, 0)
oled.text(":)", 100, 0)
oled.show()
# Código para pantallas OLED pequeñas (0.91", 128x32)
## Inicialización de pantalla OLED SSD1306 (128x32)
from machine import Pin, I2C
import ssd1306
import time
# Configurar I2C
i2c = I2C(0, scl=Pin(1), sda=Pin(0))
# Crear objeto OLED: resolución 128x32 para pantallas 0.91"
oled = ssd1306.SSD1306_I2C(128, 32, i2c)
# Limpiar pantalla
oled.fill(0)
# Mostrar texto
oled.text("OLED 0.91", 0, 0)
oled.text("SSD1306 OK", 0, 10)
oled.text(":)", 0, 20)
# Actualizar pantalla
oled.show()
> **Nota:** Antes de usar la pantalla OLED con MicroPython, es necesario guardar el archivo `ssd1306.py` en la Raspberry Pi Pico.
> Esto permite importar el módulo con `import ssd1306` sin errores.
> Puedes hacerlo usando Thonny:
> 1. Abrir `ssd1306.py` en Thonny.
> 2. Seleccionar **Archivo > Guardar como** y elegir **Raspberry Pi Pico** como destino.-
-
Save cavj83/fb536a3105e49cfae6186aa1da2e6748 to your computer and use it in GitHub Desktop.
Test Pantalla LCD ssd1306
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # MicroPython SSD1306 OLED driver, I2C and SPI interfaces | |
| # | |
| # library taken from repository at: | |
| # https://github.com/micropython/micropython/blob/master/drivers/display/ssd1306.py | |
| # | |
| from micropython import const | |
| import framebuf | |
| import time | |
| # Register definitions | |
| SET_CONTRAST = const(0x81) | |
| SET_ENTIRE_ON = const(0xA4) | |
| SET_NORM_INV = const(0xA6) | |
| SET_DISP = const(0xAE) | |
| SET_MEM_ADDR = const(0x20) | |
| SET_COL_ADDR = const(0x21) | |
| SET_PAGE_ADDR = const(0x22) | |
| SET_DISP_START_LINE = const(0x40) | |
| SET_SEG_REMAP = const(0xA0) | |
| SET_MUX_RATIO = const(0xA8) | |
| SET_COM_OUT_DIR = const(0xC0) | |
| SET_DISP_OFFSET = const(0xD3) | |
| SET_COM_PIN_CFG = const(0xDA) | |
| SET_DISP_CLK_DIV = const(0xD5) | |
| SET_PRECHARGE = const(0xD9) | |
| SET_VCOM_DESEL = const(0xDB) | |
| SET_CHARGE_PUMP = const(0x8D) | |
| # Subclassing FrameBuffer provides support for graphics primitives | |
| # http://docs.micropython.org/en/latest/pyboard/library/framebuf.html | |
| class SSD1306(framebuf.FrameBuffer): | |
| def __init__(self, width, height, external_vcc): | |
| self.width = width | |
| self.height = height | |
| self.external_vcc = external_vcc | |
| self.pages = self.height // 8 | |
| self.buffer = bytearray(self.pages * self.width) | |
| super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB) | |
| self.init_display() | |
| def init_display(self): | |
| for cmd in ( | |
| SET_DISP | 0x00, # off | |
| # Address setting | |
| SET_MEM_ADDR, | |
| 0x00, # horizontal | |
| # Resolution and layout | |
| SET_DISP_START_LINE | 0x00, | |
| SET_SEG_REMAP | 0x01, # Column addr 127 mapped to SEG0 | |
| SET_MUX_RATIO, | |
| self.height - 1, | |
| SET_COM_OUT_DIR | 0x08, # Scan from COM[N] to COM0 | |
| SET_DISP_OFFSET, | |
| 0x00, | |
| SET_COM_PIN_CFG, | |
| 0x02 if self.width > 2 * self.height else 0x12, | |
| # Timing and driving scheme | |
| SET_DISP_CLK_DIV, | |
| 0x80, | |
| SET_PRECHARGE, | |
| 0x22 if self.external_vcc else 0xF1, | |
| SET_VCOM_DESEL, | |
| 0x30, # 0.83*Vcc | |
| # Display | |
| SET_CONTRAST, | |
| 0xFF, # maximum | |
| SET_ENTIRE_ON, # Output follows RAM contents | |
| SET_NORM_INV, # Not inverted | |
| # Charge pump | |
| SET_CHARGE_PUMP, | |
| 0x10 if self.external_vcc else 0x14, | |
| SET_DISP | 0x01, | |
| ): # On | |
| self.write_cmd(cmd) | |
| self.fill(0) | |
| self.show() | |
| def poweroff(self): | |
| self.write_cmd(SET_DISP | 0x00) | |
| def poweron(self): | |
| self.write_cmd(SET_DISP | 0x01) | |
| def contrast(self, contrast): | |
| self.write_cmd(SET_CONTRAST) | |
| self.write_cmd(contrast) | |
| def invert(self, invert): | |
| self.write_cmd(SET_NORM_INV | (invert & 1)) | |
| def show(self): | |
| x0 = 0 | |
| x1 = self.width - 1 | |
| if self.width == 64: | |
| # Displays with width of 64 pixels are shifted by 32 | |
| x0 += 32 | |
| x1 += 32 | |
| self.write_cmd(SET_COL_ADDR) | |
| self.write_cmd(x0) | |
| self.write_cmd(x1) | |
| self.write_cmd(SET_PAGE_ADDR) | |
| self.write_cmd(0) | |
| self.write_cmd(self.pages - 1) | |
| self.write_data(self.buffer) | |
| class SSD1306_I2C(SSD1306): | |
| def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False): | |
| self.i2c = i2c | |
| self.addr = addr | |
| self.temp = bytearray(2) | |
| self.write_list = [b"\x40", None] # Co=0, D/C#=1 | |
| super().__init__(width, height, external_vcc) | |
| def write_cmd(self, cmd): | |
| self.temp[0] = 0x80 # Co=1, D/C#=0 | |
| self.temp[1] = cmd | |
| self.i2c.writeto(self.addr, self.temp) | |
| def write_data(self, buf): | |
| self.write_list[1] = buf | |
| self.i2c.writevto(self.addr, self.write_list) | |
| # Only required for SPI version (not covered in this project) | |
| class SSD1306_SPI(SSD1306): | |
| def __init__(self, width, height, spi, dc, res, cs, external_vcc=False): | |
| self.rate = 10 * 1024 * 1024 | |
| dc.init(dc.OUT, value=0) | |
| res.init(res.OUT, value=0) | |
| cs.init(cs.OUT, value=1) | |
| self.spi = spi | |
| self.dc = dc | |
| self.res = res | |
| self.cs = cs | |
| self.res(1) | |
| time.sleep_ms(1) | |
| self.res(0) | |
| time.sleep_ms(10) | |
| self.res(1) | |
| super().__init__(width, height, external_vcc) | |
| def write_cmd(self, cmd): | |
| self.spi.init(baudrate=self.rate, polarity=0, phase=0) | |
| self.cs(1) | |
| self.dc(0) | |
| self.cs(0) | |
| self.spi.write(bytearray([cmd])) | |
| self.cs(1) | |
| def write_data(self, buf): | |
| self.spi.init(baudrate=self.rate, polarity=0, phase=0) | |
| self.cs(1) | |
| self.dc(1) | |
| self.cs(0) | |
| self.spi.write(buf) | |
| self.cs(1) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment