OLED 显示屏

原理简介

OLED（有机发光二极管）显示屏是一种自发光的显示技术。

工作原理：通过有机材料在电流作用下发光
类型：单色 OLED、彩色 OLED
接口：I2C 或 SPI

典型应用

信息显示
菜单界面
传感器数据显示
小型设备界面
物联网设备

接线图

[接线图占位，后续添加]

文字说明（具体接法见下方代码注释）：

OLED VCC → Pico 3V3
OLED GND → Pico GND
OLED SCL → Pico GP9（I2C0 SCL）
OLED SDA → Pico GP8（I2C0 SDA）

示例代码

基础示例：OLED 显示

# ============ 接线 ============
# OLED VCC → Pico 3V3
# OLED GND → Pico GND
# OLED SCL → Pico GP9（I2C0 SCL）
# OLED SDA → Pico GP8（I2C0 SDA）
# I2C 引脚可换其他空闲 GPIO，同时修改下面 I2C() 里的脚号即可
# =============================
from machine import I2C, Pin
import ssd1306
import time

# 初始化 I2C
i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=400000)
# 初始化 OLED（128x64）
lcd = ssd1306.SSD1306_I2C(128, 64, i2c)

print('OLED 显示测试')

# 清屏
lcd.fill(0)

# 显示文本
lcd.text('Hello, World!', 0, 0)
lcd.text('MicroPython', 0, 16)
lcd.text('OLED Test', 0, 32)

# 显示
lcd.show()

# 停留 3 秒
time.sleep(3)

# 滚动显示
for i in range(0, 128, 4):
    lcd.fill(0)
    lcd.text('Scrolling Text', -i, 24)
    lcd.show()
    time.sleep(0.1)

进阶示例：显示传感器数据

# ============ 接线 ============
# 接线同基础示例：VCC→3V3，GND→GND，SCL→GP9，SDA→GP8
# 电位器：两端脚 → 3V3 和 GND，中间抽头 → GP26（ADC0）
# =============================
from machine import I2C, Pin, ADC
import ssd1306
import time

# 初始化 I2C 和 OLED
i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=400000)
lcd = ssd1306.SSD1306_I2C(128, 64, i2c)

# 初始化 ADC（电位器）
adc = ADC(Pin(26))

print('OLED 显示传感器数据')

while True:
    # 读取电位器值
    value = adc.read_u16()
    voltage = value * 3.3 / 65535

    # 清屏
    lcd.fill(0)

    # 显示数据
    lcd.text('ADC Value:', 0, 0)
    lcd.text(str(value), 0, 16)
    lcd.text('Voltage:', 0, 32)
    lcd.text(f'{voltage:.2f}V', 0, 48)

    # 显示
    lcd.show()

    time.sleep(0.5)

应用示例：简单菜单

# ============ 接线 ============
# 接线同基础示例：VCC→3V3，GND→GND，SCL→GP9，SDA→GP8
# 按键1：一脚 → GP15，另一脚 → GND（用内部上拉）
# 按键2：一脚 → GP14，另一脚 → GND（用内部上拉）
# =============================
from machine import I2C, Pin
import ssd1306
import time

# 初始化 I2C 和 OLED
i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=400000)
lcd = ssd1306.SSD1306_I2C(128, 64, i2c)

# 按键
up_key = Pin(15, Pin.IN, Pin.PULL_UP)
down_key = Pin(14, Pin.IN, Pin.PULL_UP)

# 菜单选项
menu_items = ['Option 1', 'Option 2', 'Option 3', 'Option 4']
selected = 0

print('OLED 菜单示例')

while True:
    # 检查按键
    if up_key.value() == 0:
        selected = (selected - 1) % len(menu_items)
        time.sleep(0.2)  # 防抖
    if down_key.value() == 0:
        selected = (selected + 1) % len(menu_items)
        time.sleep(0.2)  # 防抖

    # 清屏
    lcd.fill(0)

    # 显示菜单
    lcd.text('Menu:', 0, 0)
    for i, item in enumerate(menu_items):
        if i == selected:
            # 选中项
            lcd.text('> ' + item, 0, 16 + i*10)
        else:
            lcd.text('  ' + item, 0, 16 + i*10)

    # 显示
    lcd.show()

    time.sleep(0.1)

注意事项

电源：确保 OLED 工作在规定的电压范围内
初始化：需要正确初始化 I2C 或 SPI 接口
库：需要安装 ssd1306 库
亮度：有些 OLED 支持亮度调节
寿命：OLED 有使用寿命，长时间显示同一内容可能导致烧屏
温度：温度变化可能影响 OLED 性能

常见问题

Q: OLED 不显示怎么办？ A: 检查接线是否正确，确保 I2C 地址正确，检查电源是否正常。

Q: 显示内容乱码怎么办？ A: 检查字符编码，确保使用正确的字体。

Q: 如何提高显示速度？ A: 减少刷新频率，只更新变化的部分。

库文件

本页示例用到 ssd1306 库，MicroPython 固件不自带，必须先把这个库文件保存到 Pico 上，否则 import 时会直接报错。

操作步骤（Thonny）

用 Thonny 连上 Pico
点菜单「文件 → 新建」，把下面的代码整段粘贴进去
点「文件 → 另存为」，在弹出的窗口里选 Raspberry Pi Pico
文件名填 ssd1306.py，保存
存好后，本页示例就能正常运行了

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const
import framebuf

# 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_IREF_SELECT = const(0xAD)
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,  # display off
            # address setting
            SET_MEM_ADDR,
            0x00,  # horizontal
            # resolution and layout
            SET_DISP_START_LINE,  # start at line 0
            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
            SET_IREF_SELECT,
            0x30,  # enable internal IREF during display on
            # charge pump
            SET_CHARGE_PUMP,
            0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01,  # display on
        ):  # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP)

    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 rotate(self, rotate):
        self.write_cmd(SET_COM_OUT_DIR | ((rotate & 1) << 3))
        self.write_cmd(SET_SEG_REMAP | (rotate & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width != 128:
            # narrow displays use centred columns
            col_offset = (128 - self.width) // 2
            x0 += col_offset
            x1 += col_offset
        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)

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
        import time

        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)