使用Micropython控制灯板

内容介绍

1、开发环境的搭建

微雪课堂相关教程
硬禾学堂相关教程
具体开发环境的搭建文字版可以参考以下链接:

Pico Pi MicroPytho开发集成环境搭建 - 电子森林 (eetree.cn)

熟悉的同学可以直接跳过。

2、硬件介绍：

其原理图如下图所示：

FrEtqxIPfaB6r8uQO5tukmNeGVAF

该板子的具体详情可以参考该链接：硬禾实战营焊接训练用LED点阵灯板 - 电子森林 (eetree.cn)

该灯板的LED阵列是由发光二极管与限流电阻有规律地排布而成。发光二极管的亮灭通过ROW与COL的电平关系决定，仅当ROW为HIGH且COL为HIGH时，发光二极管导通。

3、程序控制

因为灯板的每行每列都被芯片74HC595所控制，所以我们要点亮灯板只需要控制芯片74HC595输出的数据。这里驱动74HC595采用的是SPI总线的方式。这种方式可以精确的控制每一个LED点阵中的“像素”

下面是用于74HC595 8位寄存器的Micropython SPI库。

class SR:
    def __init__(self, spi, rclk, len=1, srclr=None, oe=None):
        self.spi = spi
        self.rclk = rclk
        self.srclr = srclr  # tie high if functionality not needed
        self.oe = oe        # tie low if functionality not needed

        self.buf = bytearray(len)
        self.rclk.init(rclk.OUT, value=0)

        if self.srclr is not None:
            self.srclr.init(srclr.OUT, value=1)
        if self.oe is not None:
            self.oe.init(oe.OUT, value=0)

    def _write(self, latch=False):
        self.spi.write(self.buf)
        if latch:
            self.latch()

    def latch(self):
        self.rclk(1)
        self.rclk(0)

    def pin(self, pin, value=None, latch=True):
        if value is None:
            return (self.buf[pin // 8] >> (pin % 8)) & 1
        elif value:
            self.buf[pin // 8] |= (1 << (pin % 8))
            #print(self.buf[pin // 8])
        else:
            self.buf[pin // 8] &= ~(1 << (pin % 8))
            #print(self.buf[pin // 8])
        self._write(latch)

    def toggle(self, pin, latch=True):
        self.buf[pin // 8] ^= (1 << (pin % 8))
        self._write(latch)

    def clear(self, latch=True):
        if self.srclr is None:
            raise RuntimeError('srclr pin is required')
        self.srclr(0)
        self.srclr(1)
        if latch:
            self.latch()

    def enable(self, enabled=True):
        if self.oe is None:
            raise RuntimeError('oe pin is required')
        self.oe(not enabled)

    def __getitem__(self, index):   #类的方法
        return self.buf[index]

    def __setitem__(self, index, value):
        self.buf[index] = value
        self._write(True)

使用对 spi 和用于锁存的 rclk 引脚以及可选数量的级联移位寄存器的引用进行构造。
引脚 srclr 和 oe 是可选的。如果您不需要清除输出，请将 srclr 连接到 vcc。如果您不需要禁用输出，请将 oe 连接到 gnd。

__init__(spi, rclk, len=1, srclr=None, oe=None)

读取引脚的布尔值。第一个引脚是索引 0。如果您是级联移位寄存器，则第二个移位寄存器的第一个引脚是索引 8，依此类推。索引 0-7 是距离串行数据最远的移位寄存器

pin(index)

将布尔值写入引脚。这会更新引脚值的内部缓冲区，然后将所有值写入链中的每个移位寄存器。

pin(index, value, latch=True)

这将按索引切换单个引脚。读取引脚然后写入相反值

toggle(index, latch=True)

你可以将类视为一个列表，其中每个索引代表一个完整的移位寄存器。按索引返回移位寄存器的 8 位值，其中最低索引最远。

__getitem__(index)

将 8 位值写入给定索引的移位寄存器

__setitem__(index, value)

通过 SPI 发送整个内部缓冲区的私有方法

_write(latch=False)

用于脉冲 rclk 引脚的私有方法，它将移位寄存器的输出锁存到存储寄存器并显示输出

_latch()

应用程序

from machine import Pin, SPI,RTC
from sr_74hc595_spi import SR
from time import*
import framebuf,array
spi = SPI(1, 5000_000, sck=Pin(26), mosi=Pin(27))
rclk = Pin(22, Pin.OUT)
sr = SR(spi, rclk, 2) # chain of 2 shift registers
buffer1=bytearray(1)  #
buffer0=bytearray(1)  #
buffer=bytearray(8*5) #
buffer_clear=bytearray(1)
fbuf = framebuf.FrameBuffer(buffer,8*5,8,framebuf.MONO_VLSB)
def show(buf):  
    for y in range(8):                 #每循环控制所有灯板同一列
        buffer1[0]=0x80                 #选中行
        buffer1[0] = buffer1[0]>> y
        
        for i in range (5):             #每循环控制一个灯板
            buffer0[0] = buf[(5-i)*8-1-y] #选中列                       
            spi.write(buffer0)
            spi.write(buffer1) 
                      
        sr.latch()
a = 0
m = 0
buffer_clear[0]=0X00
while True:
    rtc = RTC()
    time =bytearray(8)
    time=rtc.datetime()
    if time[5] < 10:
        fbuf.text(str(time[4])+":"+"0"+str(time[5]),0,0,1)
    else:
        fbuf.text(str(time[4])+":"+str(time[5]),0,0,1)
    for i in range(250):
        show(buffer)
    for i in range (5*8):
        buffer[i]=0x00

注：以上代码是参考Github中大佬的代码修改而来，