本教程重點介紹在樹莓派 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 位數碼管模塊將顯示所有不同的數字和文本。

審核編輯：劉清