基于STEP Pico实现电压表

内容介绍

项目介绍：

本项目是基于硬禾版本树莓派Pico核心模块STEP Pico以及树莓派Pico的扩展板，按照官方要求实现的0-3.3V电压检测的电压表。

本项目所使用的硬件主要是STEP Pico模块和树莓派Pico扩展板上的电位器。使用128*64 OLED显示屏显示测得的电压值。

设计思路：

本项目要求使用Pico板载ADC，板载ADC将3.3V电压转化为12bit即4096个等级，读取到该数值后将其转化为电压即可实现电压检测。通过连接扩展板上的电位计调节电压从0-3.3V之间变化来检验电压表效果，并通过Pico控制OLED显示屏显示电压。

下面是该项目的流程图： QAAAAASUVORK5CYII=

实现功能：

通过旋转电位器改变接口电压，并将测得的电压显示在OLED屏幕上。

转动电位器后：

9k=

主要代码片段：

读取、处理和显示代码：

from machine import ADC

import time

from machine import Pin, SPI

from ssd1306 import SSD1306_SPI

import framebuf

from time import sleep

from utime import sleep_ms

from board import pin_cfg

sensor_temp = ADC(2)

conversion_factor = 3.3 / 65535  #定义转化ADC读值需要的常数

spi = SPI(1, 100000, mosi=Pin(pin_cfg.spi1_mosi), sck=Pin(pin_cfg.spi1_sck))

oled = SSD1306_SPI(128, 64, spi, Pin(pin_cfg.spi1_dc),Pin(pin_cfg.spi1_rstn), Pin(pin_cfg.spi1_cs))  #配置OLED屏幕的spi传输

oled.rotate(1)

#oled = SSD1306_SPI(WIDTH, HEIGHT, spi, dc,rst, cs) use GPIO PIN NUMBERS

v_text = ""  #定义需要显示的字符串

   

while True:

    reading = sensor_temp.read_u16() * conversion_f actor #将读取到的ADC值转化为电压值

    v_text = "V=" + str(reading) + "v"

    oled.fill(0)

    oled.show()

    #sleep(1)

    oled.text(v_text,5,10)

    oled.show()  #OLED显示

    sleep_ms(50)

    print(reading)  #pc端同步显示输出

   

    time.sleep(1)  #延时

本段代码为本次项目的核心代码，包含了配置OLED屏幕spi通信，电压转换的系数定义，以及电压表的执行代码。在死循环中，首先读取了片载ADC上面的16位数据并将其转化为电压值，经过字符串的拼接以后将其显示在屏幕上。同时也将读取到的数值发送给电脑作为校验。经过延时后再次运行采样过程。

SSD1306 OLED屏幕显示代码：

# 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):  #i2c通信
    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):  #spi通信
    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)

上述代码实现了oled的spi控制和i2c控制，截取自硬禾项目例程。该模块中定义了使用屏幕的一系列函数。本项目中使用其中的spi控制函数，将数据通过三线spi发送给ssd1306，并可以控制屏幕的刷新，开启和关闭。

遇到的难题和解决方法：

在本项目中主要遇到的难题是ADC数据的处理和OLED屏幕的显示。

由于ADC的返回的值并不是实际的电压值，因此，如何将ADC返回的数据处理为电压值就是本项目的核心。通过对芯片手册的阅读，我们可以明白返回值是0-4096中的一个数，也就是ADC将3.3V电压平均分为4096份，那么我们只需要将返回值除以4096再乘上3.3V即可得到稳定的电压。

OLED屏幕控制芯片ssd1306通过三线spi和pico引脚连接，因此我们将通过配置pico的软件spi实现与ssd1306的通信。而ssd1306的驱动库例程已经给出，只需要正确引用例程中的spi驱动函数即可控制屏幕的显示。

未来的计划和建议：

本项目仅仅实现了简单粗略的电压测量，oled的屏幕有些太小了，可以通过拓展板上的led灯珠实现电压的大概提示。
本项目仅仅使用了板载adc和电位器，这对于这个模块来说有些大材小用了。未来希望结合板子上面更多的外设实现更加复杂的功能。
该板卡还可以作为IOT设备的核心控制模块，连接蓝牙或者wifi模块实现远程控制，同时pico核心可以通过micropython编程实现简单的算法控制。
可以为OLED屏幕添加中文字库支持。