在树莓派Pico上使用TM1637 4位数码管模块的方法

本教程重点介绍在树莓派 Pico 上使用 TM1637 4 位数码管模块的方法。

所需组件

– 树莓派 Pico 或 Pico W
– TM1637 4 位数码管模块
– 面包板和跳线
– microUSB 数据线

TM1637 是一种带键盘扫描接口的 LED（发光二极管显示器）驱动控制专用电路，内部集成有 MCU 数字接口、数据锁存器、LED 高压驱动、键盘扫描等电路。TM1637 驱动的数码管模块因其控制引脚数量少而广受欢迎。在这 4 个引脚中，其中两个是电源引脚，其余两个引脚控制模块上的显示值。

引脚名称功能

CLK 时钟引脚有助于保持时钟脉冲与模块和微控制器的同步。
DIO 数据引脚有助于从微控制器发送和接收数据。
GND 接地 （GND） 用于与外部设备建立公共接地。
VCC 电源 （VCC） 输入引脚，用于为模块供电。接受 3.3-5V VCC。

树莓派 Pico I2C 引脚

RP2040 芯片有两个 I2C 控制器。两个 I2C 控制器都可以通过树莓派 Pico 的 GPIO 引脚访问。下表显示了 GPIO 引脚与两个 I2C 控制器的连接。控制器的每个连接都可以通过多个GPIO引脚进行配置，如图所示。但在使用 I2C 控制器之前，你应该在软件中配置要与特定 I2C 控制器一起使用的 GPIO 引脚。

I2C 控制器 GPIO 引脚

I2C0 – SDA GP0/GP4/GP8/GP12/GP16/GP20
I2C0 – SCL GP1/GP5/GP9/GP13/GP17/GP21
I2C1 – SDA GP2/GP6/GP10/GP14/GP18/GP26
I2C1 – SCL GP3/GP7/GP11/GP15/GP19/GP27

两个设备之间的连接相当简单。我们用 GP26 连接 CLK，用 GP27 连接 DIO。你也可以使用其他 SDA/SCL 引脚组合，如上表所示。

请遵循下图：

安装 TMP1637 库

要使用 TM1637 数码管模块对树莓派 Pico 进行编程，我们需要来自 GitHub 的 TM1637 库。

复制此库并将其保存在名为 tm1637.py 的树莓派 Pico 中。在 Thonny 中打开一个新文件。复制下面给出的库或从此链接获取。将其保存到树莓派 Pico，名称 tm1637.py，放在根目录或 lib 文件夹下。

 

from micropython import const
from machine import Pin
from time import sleep_us, sleep_ms
 
TM1637_CMD1 = const(64)  # 0x40 data command
TM1637_CMD2 = const(192) # 0xC0 address command
TM1637_CMD3 = const(128) # 0x80 display control command
TM1637_DSP_ON = const(8) # 0x08 display on
TM1637_DELAY = const(10) # 10us delay between clk/dio pulses
TM1637_MSB = const(128)  # msb is the decimal point or the colon depending on your display
 
# 0-9, a-z, blank, dash, star
_SEGMENTS = bytearray(b'x3Fx06x5Bx4Fx66x6Dx7Dx07x7Fx6Fx77x7Cx39x5Ex79x71x3Dx76x06x1Ex76x38x55x54x3Fx73x67x50x6Dx78x3Ex1Cx2Ax76x6Ex5Bx00x40x63')
 
class TM1637(object):
    """Library for quad 7-segment LED modules based on the TM1637 LED driver."""
    def __init__(self, clk, dio, brightness=7):
        self.clk = clk
        self.dio = dio
 
        if not 0 <= brightness <= 7:
            raise ValueError("Brightness out of range")
        self._brightness = brightness
 
        self.clk.init(Pin.OUT, value=0)
        self.dio.init(Pin.OUT, value=0)
        sleep_us(TM1637_DELAY)
 
        self._write_data_cmd()
        self._write_dsp_ctrl()
 
    def _start(self):
        self.dio(0)
        sleep_us(TM1637_DELAY)
        self.clk(0)
        sleep_us(TM1637_DELAY)
 
    def _stop(self):
        self.dio(0)
        sleep_us(TM1637_DELAY)
        self.clk(1)
        sleep_us(TM1637_DELAY)
        self.dio(1)
 
    def _write_data_cmd(self):
        # automatic address increment, normal mode
        self._start()
        self._write_byte(TM1637_CMD1)
        self._stop()
 
    def _write_dsp_ctrl(self):
        # display on, set brightness
        self._start()
        self._write_byte(TM1637_CMD3 | TM1637_DSP_ON | self._brightness)
        self._stop()
 
    def _write_byte(self, b):
        for i in range(8):
            self.dio((b >> i) & 1)
            sleep_us(TM1637_DELAY)
            self.clk(1)
            sleep_us(TM1637_DELAY)
            self.clk(0)
            sleep_us(TM1637_DELAY)
        self.clk(0)
        sleep_us(TM1637_DELAY)
        self.clk(1)
        sleep_us(TM1637_DELAY)
        self.clk(0)
        sleep_us(TM1637_DELAY)
 
    def brightness(self, val=None):
        """Set the display brightness 0-7."""
        # brightness 0 = 1/16th pulse width
        # brightness 7 = 14/16th pulse width
        if val is None:
            return self._brightness
        if not 0 <= val <= 7:
            raise ValueError("Brightness out of range")
 
        self._brightness = val
        self._write_data_cmd()
        self._write_dsp_ctrl()
 
    def write(self, segments, pos=0):
        """Display up to 6 segments moving right from a given position.
        The MSB in the 2nd segment controls the colon between the 2nd
        and 3rd segments."""
        if not 0 <= pos <= 5:
            raise ValueError("Position out of range")
        self._write_data_cmd()
        self._start()
 
        self._write_byte(TM1637_CMD2 | pos)
        for seg in segments:
            self._write_byte(seg)
        self._stop()
        self._write_dsp_ctrl()
 
    def encode_digit(self, digit):
        """Convert a character 0-9, a-f to a segment."""
        return _SEGMENTS[digit & 0x0f]
 
    def encode_string(self, string):
        """Convert an up to 4 character length string containing 0-9, a-z,
        space, dash, star to an array of segments, matching the length of the
        source string."""
        segments = bytearray(len(string))
        for i in range(len(string)):
            segments[i] = self.encode_char(string[i])
        return segments
 
    def encode_char(self, char):
        """Convert a character 0-9, a-z, space, dash or star to a segment."""
        o = ord(char)
        if o == 32:
            return _SEGMENTS[36] # space
        if o == 42:
            return _SEGMENTS[38] # star/degrees
        if o == 45:
            return _SEGMENTS[37] # dash
        if o >= 65 and o <= 90:
            return _SEGMENTS[o-55] # uppercase A-Z
        if o >= 97 and o <= 122:
            return _SEGMENTS[o-87] # lowercase a-z
        if o >= 48 and o <= 57:
            return _SEGMENTS[o-48] # 0-9
        raise ValueError("Character out of range: {:d} '{:s}'".format(o, chr(o)))
 
    def hex(self, val):
        """Display a hex value 0x0000 through 0xffff, right aligned."""
        string = '{:04x}'.format(val & 0xffff)
        self.write(self.encode_string(string))
 
    def number(self, num):
        """Display a numeric value -999 through 9999, right aligned."""
        # limit to range -999 to 9999
        num = max(-999, min(num, 9999))
        string = '{0: >4d}'.format(num)
        self.write(self.encode_string(string))
 
    def numbers(self, num1, num2, colon=True):
        """Display two numeric values -9 through 99, with leading zeros
        and separated by a colon."""
        num1 = max(-9, min(num1, 99))
        num2 = max(-9, min(num2, 99))
        segments = self.encode_string('{0:0>2d}{1:0>2d}'.format(num1, num2))
        if colon:
            segments[1] |= 0x80 # colon on
        self.write(segments)
 
    def temperature(self, num):
        if num < -9:
            self.show('lo') # low
        elif num > 99:
            self.show('hi') # high
        else:
            string = '{0: >2d}'.format(num)
            self.write(self.encode_string(string))
        self.write([_SEGMENTS[38], _SEGMENTS[12]], 2) # degrees C
 
    def show(self, string, colon=False):
        segments = self.encode_string(string)
        if len(segments) > 1 and colon:
            segments[1] |= 128
        self.write(segments[:4])
 
    def scroll(self, string, delay=250):
        segments = string if isinstance(string, list) else self.encode_string(string)
        data = [0] * 8
        data[4:0] = list(segments)
        for i in range(len(segments) + 5):
            self.write(data[0+i:4+i])
            sleep_ms(delay)
 
 
class TM1637Decimal(TM1637):
    """Library for quad 7-segment LED modules based on the TM1637 LED driver.
    This class is meant to be used with decimal display modules (modules
    that have a decimal point after each 7-segment LED).
    """
 
    def encode_string(self, string):
        """Convert a string to LED segments.
        Convert an up to 4 character length string containing 0-9, a-z,
        space, dash, star and '.' to an array of segments, matching the length of
        the source string."""
        segments = bytearray(len(string.replace('.','')))
        j = 0
        for i in range(len(string)):
            if string[i] == '.' and j > 0:
                segments[j-1] |= TM1637_MSB
                continue
            segments[j] = self.encode_char(string[i])
            j += 1
        return segments

 

树莓派 Pico MicroPython：TM1637 代码

树莓派 Pico W 需要预加载 MicroPython UF2 文件才能在 MicroPython 中对其进行编程。你可以阅读我们的树莓派 Pico 入门指南，其中我们展示了在 MicroPython 中开始编程 RP2040 所需的所有步骤。


如上图所示完成所有连接后，使用 USB 数据线将 Pico 连接到你的计算机。打开 IDE，将以下代码粘贴到新项目中。

 

import tm1637
from machine import Pin
import time
tm = tm1637.TM1637(clk=Pin(0), dio=Pin(1))
 
#set brightness(0-7)
tm.brightness(5)
# display "10:24"
tm.numbers(10, 24, colon=True)
time.sleep(2)
# Word
tm.show("AbCd", colon=False)
time.sleep(2)
# display "COOL"
tm.write([0b00111001, 0b00111111, 0b00111111, 0b00111000])
time.sleep(2)
# Clear all
tm.show("    ")
time.sleep(2)
# display "bEEF"
tm.hex(0xbeef)
time.sleep(2)
# display "-123"
tm.number(-123)
time.sleep(2)
# show temperature '24*C'
tm.temperature(24)
time.sleep(2)
#scroll display contents
tm.scroll('RPI-ICU', delay=250)

 

通过单击“运行”图标或按 F5 键来运行代码。将脚本保存到你的树莓派 Pico中，作为 main.py 或任何其他文件扩展名为 “.py” 的名称。

成功上传代码后，你必须看到 TM1637 数码管模块显示更改的字符，每次更新之间有 2 秒的延迟。

TM1637 MicroPython 代码说明

首先，我们导入必要的模块。TM1637 模块用于与 7 段显示器通信，Pin 模块用于将 Pico W 引脚设置为输出引脚，Time 模块用于设置代码执行之间的延迟。

 

import tm1637
from machine import Pin
import time

 

然后，我们定义一个名为 tm 的实例，并启动 Raspberry Pi Pico 的引脚 0 和 1，分别与引脚 CLK 和 DIO 连接。

 

tm = tm1637.TM1637(clk=Pin(0), dio=Pin(1))

 

tm.brightness 可以设置为介于 1 到 7 之间的值。将其设置为“1”会将 TM1637 亮度设置为最低，“7”会亮起所有 LED。

 

tm.brightness(5)

 

接下来的行在冒号的两侧显示 2 个独立的数字，前导为零。如果不希望冒号显示在数字之间，则可以将参数冒号设置为 False。

 

tm.numbers(10, 24, colon=True)
time.sleep(2)

 

写入函数可用于点亮 LED 的每个部分。它的参数是 8 位二进制数，其中每个位对应于 7 段显示器的一个段。

 

tm.write([0b00111001, 0b00111111, 0b00111111, 0b00111000])

 

为了更好地理解上面的代码，让我们看到一个 7 段显示，其中标记了段。

 

   __2__
  |     |    |  0 ->  011 1111 -> 0x3f
1 |     | 3  |  1 ->  010 0001 -> 0x21
  |__7__|    |  2 ->  111 0110 -> 0x76
  |     |    |  4 ->  ...
6 |     | 4  |        ...
  |__5__|    |  9 ->  ...      -> 0x5f

 

在函数 tm.write 中，第一个参数是 0b00111001，它将在 TM1637 模块上显示单词“cool”的第一个字母（即字母 c）。参数中最低有效位表示段“a”，最高有效位表示段“DP”。因此，0b00111001 将点亮 7 段显示中的段 a、d、e 和 f。同样，参数 0b00111111、0b001111111 和 0b00111000 将分别显示字母“o”、“o”和“l”。

接下来，我们使用 tm.show 函数显示字符串 ‘heya’，使用 tm.hex 显示十六进制值，使用 tm.number 显示负数。函数 tm.number 可以显示数字 -999 到 9999，并且数字将右对齐。

 

tm.show('heya', colon=False)
tm.hex(0xbeef)
tm.number(-123)

 

如果要显示的内容不适合 TM1637 的 4 位段，则可以使用 scroll（） 函数滚动内容。delay 参数以毫秒为单位取值，它是字符在向左滚动之前在片段中停留的时间。

 

scroll('scrolling', delay=250)

 

最后

将代码上传到电路板后，TM1637 4 位数码管模块将显示所有不同的数字和文本。

审核编辑：刘清