用STEP Pico制作一个电压表

1 项目需求

制作一个电压表

具体要求：利用板上的电位计调节电压从0-3.3V之间变化，在OLED显示屏上显示电压值，可以以数字的方式，也可以以图形的方式来显示。

2 功能设计

2.1 电压测量功能

通过调节旋钮电位器（GPIO28）旋钮，模拟作为被测对象，产生0-3.3V之间变化的电压模拟量。

树莓派Pico内部ADC，模拟读取GPIO28数值，通过计算转换得到相应的电压值。

2.2 电压显示功能

将计算转换后的电压值，显示在OLED液晶屏上。

3 硬件介绍

3.1 STEP Pico

STEP Pico为兼容树莓派官方Pico的核心模块，在其基础上增加了4个WS2812彩色灯，以及一个复位按键，USB端口也改成了Type C。

采用了RaspberryPi官方自主研发的RP2040微处理器芯片，搭载了ARM Cortex M0+双核处理器，高达133MHz的运行频率，内置了264KB SRAM和2MB闪存，板载了26个多功能GPIO引脚，支持C/C++、Python编程。

3.2 树莓派Pico扩展板

• 2个按键输入
• 12个WS2812B RGB三色灯
• 1个姿态传感器
• 1个128*64 OLED显示屏
• 1个蜂鸣器
• 1个可调电位计
• 1路音频信号输入

4 功能实现

4.1流程图

（1）模拟读取树莓派Pico的GPIO28得到一个电压的数字量的值，并赋值给变量Value。

（2）通过计算，将电压数字量值Value转换成电压值，并赋值给VoltageValue。

4.2 Thonny的下载与安装

Thonny是一个面向初学者的 Python IDE。Thonny 由爱沙尼亚的 Tartu 大学开发，它采用了不同的方法，因为它的调试器是专为学习和教学编程而设计的。

Installer with 64-bit Python 3.10下载链接：https://github.com/thonny/thonny/releases/download/v4.0.2/thonny-4.0.2.exe

5 功能实现

5.1 旋转电位器读数范围测量

1、machine库

读取ADC值

adc_28 = ADC(28)#初始化ADC
Value = adc_28.read_u16()#读取ADC的值，返回16位数

2、读取并打印旋转电位器数值

from machine import Pin, ADC
import time
adc_28 = ADC(28)
while True:
    Value = adc_28.read_u16()
    print(Value)
    time.sleep(0.1)

执行上述代码，打开串口监视器，并将旋钮电位器分别顺时针、逆时针拧到头，查看打印的数值，查找最大值和最小值。

经过测试，旋转电位器最小值为256，旋转电位器最大值为65535。

5.2 将读取到Value的转化为电压

计算方法：（读取的旋转电位器值Value - 旋转电位器最小值）/(旋转电位器最大值 - 旋转电位器最小值)*3.3

这里乘以3.3的，是基于我们认定旋转电位器最小值对应于电压0V，旋转电位器最大值对应于3.3V。

因此，VoltageValue = (Value - 256)/(65535 - 256)*3.3

5.3 电压显示

树莓派Pico扩展板板载了一块0.96寸SSD1306驱动的SPI接口的OLED。

从Pico训练板的原理图可知，OLED各SPI引脚连接的GPIO。

1、SSD1306库

这里我们使用了一个OLED驱动库文件ssd1306.py，这个文件可以从github下载，也可以新建一个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)

将ssd1306.py驱动文件通过Thonny上传到Pico的根目录，如下图所示。

使用方法：

#导入Pin, SoftSPI, ssd1306

from machine import Pin, SoftSPI
import ssd1306

#实例化spi

spi = SoftSPI(baudrate=500000, polarity=1, phase=0, sck=Pin(10), mosi=Pin(11),

#定义引脚

miso = Pin(12))
dc = Pin(9)   
rst = Pin(8)  
cs = Pin(23)  

#实例化ssd1306

display = ssd1306.SSD1306_SPI(128, 64, spi, dc, rst, cs)

#清屏

display.fill(0)

#显示VoltageValue

display.text(str(VoltageValue), 50, 30, 1)
display.show()

6 完整代码

from machine import Pin, ADC, SoftSPI
import ssd1306
import time
adc_28 = ADC(28)
spi = SoftSPI(baudrate=500000, polarity=1, phase=0, sck=Pin(10), mosi=Pin(11), miso=Pin(12))
dc = Pin(9)   
rst = Pin(8)  
cs = Pin(23)  
display = ssd1306.SSD1306_SPI(128, 64, spi, dc, rst, cs)
while True:
    Value = adc_28.read_u16()
    VoltageValue = (Value - 256)/(65535 - 256)*3.3
    print(VoltageValue)
    display.fill(0)
    display.text(str(VoltageValue), 50, 30, 1)
    display.show()
    time.sleep(0.5)

 7 运行效果

程序运行效果如下图所示：

程序运行后，PC端显示如下图所示：

可以看出，电压随着旋转变阻器的转动而变化，电压在0V到3.3V之间连续变化。

8 遇到的主要难题及解决方法

本项目相对简单，未遇到什么难题。如果非要说什么难题，那就是ADC返回值与电压的转化。解决方法就是通过设计公式进行转换。

9 未来的计划或建议

在提交本项目总结报告前，笔者在一拿到板子后，就已经在第一时间完成了项目1-项目4的内容。未来计划继续完成其余的项目5-项目7的内容，进一步掌握姿态传感器的使用，滚动小球的绘制，通过定时器计数的方式来生成时、分、秒信号等。

也可以考虑结合旋钮、WS2812彩灯、mic、姿态传感器、OLED实现一个综合性项目。