物联网开发111 - Micropython ESP32 C3连接4x4矩阵按键模块操作

最新推荐文章于 2024-05-05 17:14:08 发布
最新推荐文章于 2024-05-05 17:14:08 发布
阅读量954 收藏 7
点赞数
分类专栏： 物联网开发 MicroPython 文章标签： Micropython 物联网开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhusongziye/article/details/130753898
版权

一、目的

        这一节我们来学习如何使用合宙ESP32 C3，连接0.96寸ssd1306屏幕、4x4 矩阵按键模块，进行两个小实验的演示。

二、环境

        ESP32 C3开发板（MicroPython v1.19.1 on 2022-06-18）+ I2C 0.96寸ssd1306屏幕模块+ 4x4 矩阵按键模块  + 几根杜邦线 + Win10商业版

        ESP32 C3和各个模块接线方法：

 三、示例代码1

演示将按下的按键名字显示在屏幕上

from machine import Pin,I2C
from ssd1306 import SSD1306_I2C
from ufont import BMFont
import time

# 创建I2C对象
i2c  = I2C(0,scl = Pin(5),sda = Pin(4),freq = 400_000)
# 创建oled屏幕对象
oled = SSD1306_I2C(128,64,i2c,0x3c)
# 定义字库文件
font = BMFont("fonts/unifont-14-12888-16.v3.bmf")
# 创建led对象
led = Pin(12,Pin.OUT)  # 板载led D4

# 行定义
R1 = Pin( 2,Pin.OUT)
R2 = Pin( 3,Pin.OUT)
R3 = Pin(10,Pin.OUT)
R4 = Pin( 6,Pin.OUT)

# 列第一
C1 = Pin( 7,Pin.IN,Pin.PULL_UP)
C2 = Pin( 8,Pin.IN,Pin.PULL_UP)
C3 = Pin(18,Pin.IN,Pin.PULL_UP)
C4 = Pin(19,Pin.IN,Pin.PULL_UP)

# 创建按键函数
def Key():
    
#     R1.value(0)
#     R2.value(1)
#     R3.value(1)
#     R4.value(1)
    
    key = 0
    bzw = 0
    
    # 第一行
    [R1.value(0),R2.value(1),R3.value(1),R4.value(1)]
    if(C1.value() == 0 or C2.value() == 0 or C3.value() == 0 or C4.value() == 0):
        
        time.sleep(0.020)
        
        if C1.value() == 0:
            bzw = 1
            key = 0
            while not C1.value():
                None
        elif C2.value() == 0:
            bzw = 1
            key = 1
            while not C2.value():
                None               
        elif C3.value() == 0:
            bzw = 1
            key = 2
            while not C3.value():
                None
        elif C4.value() == 0:
            bzw = 1
            key = 3
            while not C4.value():
                None
        else:
            
            key = 0
            bzw = 0
            R1.value(1)
            
    # 第二行
    [R1.value(1),R2.value(0),R3.value(1),R4.value(1)]
    if(C1.value() == 0 or C2.value() == 0 or C3.value() == 0 or C4.value() == 0):
        
        time.sleep(0.020)
        
        if C1.value() == 0:
            bzw = 1
            key = 4
            while not C1.value():
                None
        elif C2.value() == 0:
            bzw = 1
            key = 5
            while not C2.value():
                None               
        elif C3.value() == 0:
            bzw = 1
            key = 6
            while not C3.value():
                None
        elif C4.value() == 0:
            bzw = 1
            key = 7
            while not C4.value():
                None
        else:
            
            key = 0
            bzw = 0
            R1.value(1)
            
    # 第三行
    [R1.value(1),R2.value(1),R3.value(0),R4.value(1)]
    if(C1.value() == 0 or C2.value() == 0 or C3.value() == 0 or C4.value() == 0):
        
        time.sleep(0.020)
        
        if C1.value() == 0:
            bzw = 1
            key = 8
            while not C1.value():
                None
        elif C2.value() == 0:
            bzw = 1
            key = 9
            while not C2.value():
                None               
        elif C3.value() == 0:
            bzw = 1
            key = 10
            while not C3.value():
                None
        elif C4.value() == 0:
            bzw = 1
            key = 11
            while not C4.value():
                None
        else:
            
            key = 0
            bzw = 0
            R1.value(1)

    # 第四行
    [R1.value(1),R2.value(1),R3.value(1),R4.value(0)]
    if(C1.value() == 0 or C2.value() == 0 or C3.value() == 0 or C4.value() == 0):
        
        time.sleep(0.020)
        
        if C1.value() == 0:
            bzw = 1
            key = 12
            while not C1.value():
                None
        elif C2.value() == 0:
            bzw = 1
            key = 13
            while not C2.value():
                None               
        elif C3.value() == 0:
            bzw = 1
            key = 14
            while not C3.value():
                None
        elif C4.value() == 0:
            bzw = 1
            key = 15
            while not C4.value():
                None
        else:
            
            key = 0
            bzw = 0
            R1.value(1)


    if bzw == 1:
        bzw = 0
        
        if key == 3:
            led.value(not led.value())
            
        print("%d"%key)
        font.text(oled,"%.2d"%(key),48,16,color=1,font_size=24,reverse=False,clear=True,show=True,half_char=True, auto_wrap=True)
        time.sleep(0.1)
        
def main():
    font.text(oled,str("矩阵按值"),32,24,color=1,font_size=16,reverse=False,clear=False,show=True,half_char=True, auto_wrap=True)
   
    while True:
        Key()
    
    
if __name__ == "__main__":
    main()

演示效果

 四、示例代码2

演示使用按键控制开关灯（板载led灯）

from machine import Pin,I2C
from key_matrix import KEY
from ssd1306 import SSD1306_I2C

from ufont import BMFont
import time

i2c  = I2C(0,scl = Pin(5),sda = Pin(4),freq = 400_000)
oled = SSD1306_I2C(128,64,i2c,0x3c)

font = BMFont("fonts/unifont-14-12888-16.v3.bmf")

#行
R1 = Pin(2,Pin.OUT)
R2 = Pin(3,Pin.OUT)
R3 = Pin(10,Pin.OUT)
R4 = Pin(6,Pin.OUT)

#列
C1 = Pin(7 ,Pin.IN,Pin.PULL_UP)
C2 = Pin(8 ,Pin.IN,Pin.PULL_UP)
C3 = Pin(18,Pin.IN,Pin.PULL_UP)
C4 = Pin(19,Pin.IN,Pin.PULL_UP)

#创建按键对象
Key = KEY(C1,C2,C3,C4,R1,R2,R3,R4)

led = Pin(12,Pin.OUT)

def Matrix():
    code = [
            ['0','1','2','3'],
            ['4','5','6','7'],
            ['8','9','a','b'],
            ['c','d','e','f'],
           ]
    
    #接收按键值
    value = Key.matrix()

    if value == code[3][3]:
        led.value(not led.value())
        if led.value():
            font.text(oled,"开灯",40,24,color=1,font_size=16,reverse=False,clear=True,show=True,half_char=True, auto_wrap=True)
        else :
            font.text(oled,"关灯",40,24,color=1,font_size=16,reverse=False,clear=True,show=True,half_char=True, auto_wrap=True)
        
        print("%s"%value)

def main():
    font.text(oled,str("矩阵按值"),32,24,color=1,font_size=16,reverse=False,clear=False,show=True,half_char=True, auto_wrap=True)
   
    while True:
        Matrix()
            
            
if __name__ == "__main__":
    main()

演示效果

五、key_matrix库

key_matrix.py

'''
#行只负责拉高和拉低电瓶，让交叉的列进行扫描 R简称行

R1 = Pin(2,Pin.OUT)
R2 = Pin(3,Pin.OUT)
R3 = Pin(10,Pin.OUT)
R4 = Pin(6,Pin.OUT)

#列负责进行交叉的键值检测，当按键被按下时读取对应值 C简称列

C1 = Pin(7 ,Pin.IN,Pin.PULL_UP)
C2 = Pin(8 ,Pin.IN,Pin.PULL_UP)
C3 = Pin(18,Pin.IN,Pin.PULL_UP)
C4 = Pin(19,Pin.IN,Pin.PULL_UP)

#创建按键对象
Key = KEY(C1,C2,C3,C4,R1,R2,R3,R4)

#接收按键值
temp = Key.matrix()

'''
from machine import Pin
import time

class KEY(object):
    
    def __init__(self,C1,C2,C3,C4,R1,R2,R3,R4):
        
        self.C1 = C1 
        self.C2 = C2
        self.C3 = C3
        self.C4 = C4
        
        self.R1 = R1 
        self.R2 = R2 
        self.R3 = R3 
        self.R4 = R4 
    
    #按键扫描函数
    def matrix(self):
        
        key = 0
        bzw = 0
        
        #设置第一行拉低
        [self.R1.value(0),self.R2.value(1),self.R3.value(1),self.R4.value(1)]
        #扫描每一列键值
        if(self.C1.value() == 0 or self.C2.value() == 0 or self.C3.value() == 0 or self.C4.value() == 0):
            
            time.sleep(0.020)
            
            if self.C1.value() == 0:                
                bzw = 1
                key = '0'
                while not self.C1.value():
                    pass
                    
            elif self.C2.value() == 0:
                bzw = 1
                key = '1'
                while not self.C2.value():
                    pass
                
            elif self.C3.value() == 0:
                bzw = 1
                key = '2'
                while not self.C3.value():
                    pass
                
            elif self.C4.value() == 0:
                bzw = 1
                key = '3'
                while not self.C4.value():
                    pass
            else:
                
                self.R1.value(1)
        
        #设置第二行拉低
        [self.R1.value(1),self.R2.value(0),self.R3.value(1),self.R4.value(1)]
        #扫描每一列键值
        if(self.C1.value() == 0 or self.C2.value() == 0 or self.C3.value() == 0 or self.C4.value() == 0):
            
            time.sleep(0.020)
            
            if self.C1.value() == 0:                
                bzw = 1
                key = '4'
                while not self.C1.value():
                    pass
                    
            elif self.C2.value() == 0:
                bzw = 1
                key = '5'
                while not self.C2.value():
                    pass
                
            elif self.C3.value() == 0:
                bzw = 1
                key = '6'
                while not self.C3.value():
                    pass
                
            elif self.C4.value() == 0:
                bzw = 1
                key = '7'
                while not self.C4.value():
                    pass
            else:
                
                key = 0
                bzw = 0
                self.R2.value(1)
                 
        #设置第三行拉低
        [self.R1.value(1),self.R2.value(1),self.R3.value(0),self.R4.value(1)]
        #扫描每一列键值
        if(self.C1.value() == 0 or self.C2.value() == 0 or self.C3.value() == 0 or self.C4.value() == 0):
            
            time.sleep(0.020)
            
            if self.C1.value() == 0:                
                bzw = 1
                key = '8'
                while not self.C1.value():
                    pass
                    
            elif self.C2.value() == 0:
                bzw = 1
                key = '9'
                while not self.C2.value():
                    pass
                
            elif self.C3.value() == 0:
                bzw = 1
                key = 'a'
                while not self.C3.value():
                    pass
                
            elif self.C4.value() == 0:
                bzw = 1
                key = 'b'
                while not self.C4.value():
                    pass
            else:
                
                key = 0
                bzw = 0
                self.R3.value(1)
                 
        #设置第四行拉低
        [self.R1.value(1),self.R2.value(1),self.R3.value(1),self.R4.value(0)]
        #扫描每一列键值
        if(self.C1.value() == 0 or self.C2.value() == 0 or self.C3.value() == 0 or self.C4.value() == 0):
            
            time.sleep(0.020)
            
            if self.C1.value() == 0:                
                bzw = 1
                key = 'c'
                while not self.C1.value():
                    pass
                    
            elif self.C2.value() == 0:
                bzw = 1
                key = 'd'
                while not self.C2.value():
                    pass
                
            elif self.C3.value() == 0:
                bzw = 1
                key = 'e'
                while not self.C3.value():
                    pass
                
            elif self.C4.value() == 0:
                bzw = 1
                key = 'f'
                while not self.C4.value():
                    pass
            else:
                
                key = 0
                bzw = 0
                self.R4.value(1)
                 
        if bzw == 1:
            bzw = 0
            
            return key
            #返回的的是字符串类型

六、字库和ssd1306驱动

        字库fonts/unifont-14-12888-16.v3.bmf和ssd1306驱动见这个文章

物联网开发107 - Micropython ESP32 C3接DS1307时钟模块在SSD1306屏幕上显示时间_魔都飘雪的博客-CSDN博客Micropython ESP32 C3连接DS1307时钟模块在SSD1306屏幕上显示时间https://blog.csdn.net/zhusongziye/article/details/130535482?spm=1001.2014.3001.5501ufont.py

__version__ = 3

import time
import struct

import framebuf

DEBUG = False


def timeit(f, *args, **kwargs):
    try:
        myname = str(f).split(' ')[1]
    except:
        myname = "UNKONW"

    def new_func(*args, **kwargs):
        if DEBUG:
            try:
                t = time.ticks_us()
                result = f(*args, **kwargs)
                delta = time.ticks_diff(time.ticks_us(), t)
                print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000))
            except AttributeError:
                t = time.perf_counter_ns()
                result = f(*args, **kwargs)
                delta = time.perf_counter_ns() - t
                print('Function {} Time = {:6.3f}ms'.format(myname, delta / 1000000))
            return result
        else:
            return f(*args, **kwargs)

    return new_func


class BMFont:
    @staticmethod
    def _list_to_byte(arr):
        b = 0
        for a in arr:
            b = (b << 1) + a
        return bytes([b])

    @timeit
    def _bit_list_to_byte_data(self, bit_list):
        """将点阵转换为字节数据

        Args:
            bit_list:

        Returns:

        """
        byte_data = b''
        for _col in bit_list:
            for i in range(0, len(_col), 8):
                byte_data += self._list_to_byte(_col[i:i + 8])
        return byte_data

    @timeit
    def __init__(self, font_file):
        self.font_file = font_file

        self.font = open(font_file, "rb", buffering=0xff)

        self.bmf_info = self.font.read(16)

        if self.bmf_info[0:2] != b"BM":
            raise TypeError("字体文件格式不正确: " + font_file)

        self.version = self.bmf_info[2]
        if self.version != 3:
            raise TypeError("字体文件版本不正确: " + str(self.version))

        self.map_mode = self.bmf_info[3]  # 映射方式
        self.start_bitmap = struct.unpack(">I", b'\x00' + self.bmf_info[4:7])[0]  # 位图开始字节
        self.font_size = self.bmf_info[7]  # 字体大小
        self.bitmap_size = self.bmf_info[8]  # 点阵所占字节

    @timeit
    def _to_bit_list(self, byte_data, font_size, *, _height=None, _width=None):
        """将字节数据转换为点阵数据

        Args:
            byte_data: 字节数据
            font_size: 字号大小
            _height: 字体原高度
            _width: 字体原宽度

        Returns:

        """
        _height = _height or self.font_size
        _width = _width or self.bitmap_size // self.font_size * 8
        new_bitarray = [[0 for j in range(font_size)] for i in range(font_size)]
        for _col in range(len(new_bitarray)):
            for _row in range(len(new_bitarray[_col])):
                _index = int(_col / (font_size / _height)) * _width + int(_row / (font_size / _width))
                new_bitarray[_col][_row] = byte_data[_index // 8] >> (7 - _index % 8) & 1
        return new_bitarray

    @timeit
    def _color_render(self, bit_list, color):
        """将二值点阵图像转换为 RGB565 彩色字节图像

        Args:
            bit_list:
            color:

        Returns:

        """
        color_array = b""
        for _col in range(len(bit_list)):
            for _row in range(len(bit_list)):
                color_array += struct.pack("<H", color) if bit_list[_col][_row] else b'\x00\x00'
        return color_array

    @timeit
    def _get_index(self, word):
        """获取索引

        Args:
            word: 字符

        Returns:

        """
        word_code = ord(word)
        start = 0x10
        end = self.start_bitmap

        while start <= end:
            mid = ((start + end) // 4) * 2
            self.font.seek(mid, 0)
            target_code = struct.unpack(">H", self.font.read(2))[0]
            if word_code == target_code:
                return (mid - 16) >> 1
            elif word_code < target_code:
                end = mid - 2
            else:
                start = mid + 2
        return -1

    @timeit
    def get_bitmap(self, word):
        """获取点阵图

        Args:
            word: 字符

        Returns:
            bytes 字符点阵
        """
        index = self._get_index(word)
        if index == -1:
            return b'\xff\xff\xff\xff\xff\xff\xff\xff\xf0\x0f\xcf\xf3\xcf\xf3\xff\xf3\xff\xcf\xff?\xff?\xff\xff\xff' \
                   b'?\xff?\xff\xff\xff\xff'

        self.font.seek(self.start_bitmap + index * self.bitmap_size, 0)
        return self.font.read(self.bitmap_size)

    @timeit
    def text(self, display, string, x, y, color=1, *, font_size=None, reverse=False, clear=False, show=False,
             half_char=True, auto_wrap=False, **kwargs):
        """通过显示屏显示文字

        使用此函数显示文字，必须先确认显示对象是否继承与 framebuf.FrameBuffer。
        如果显示对象没有 clear 方法，需要自行调用 fill 清屏

        Args:
            display: 显示实例
            string: 字符串
            x: 字体左上角 x 轴
            y: 字体左上角 y 轴
            color: 颜色
            font_size: 字号
            reverse: 是否反转背景
            clear: 是否清除之前显示的内容
            show: 是否立刻显示
            half_char: 是否半字节显示 ASCII 字符
            auto_wrap: 自动换行
            **kwargs:

        Returns:
            None
        """
        font_size = font_size or self.font_size
        initial_x = x

        # 清屏
        try:
            display.clear() if clear else 0
        except AttributeError:
            print("请自行调用 display.fill(*) 清屏")

        for char in range(len(string)):
            # 是否自动换行
            if auto_wrap:
                if auto_wrap and ((x + font_size // 2 >= display.width and ord(string[char]) < 128 and half_char) or
                                  (x + font_size >= display.width and (not half_char or ord(string[char]) > 128))):
                    y += font_size
                    x = initial_x

            # 回车
            if string[char] == '\n':
                y += font_size
                x = initial_x
                continue
            # Tab
            elif string[char] == '\t':
                x = ((x // font_size) + 1) * font_size + initial_x % font_size
                continue
            # 其它的控制字符不显示
            elif ord(string[char]) < 16:
                continue

            # 超过范围的字符不会显示*
            if x > display.width or y > display.height:
                continue

            byte_data = list(self.get_bitmap(string[char]))

            # 反转
            if reverse:
                for _pixel in range(len(byte_data)):
                    byte_data[_pixel] = ~byte_data[_pixel] & 0xff

            # 缩放和色彩*
            if color > 1 or font_size != self.font_size:
                bit_data = self._to_bit_list(byte_data, font_size)
                if color > 1:
                    display.blit(
                        framebuf.FrameBuffer(bytearray(self._color_render(bit_data, color)), font_size, font_size,
                                             framebuf.RGB565), x, y)
                else:
                    display.blit(
                        framebuf.FrameBuffer(bytearray(self._bit_list_to_byte_data(bit_data)), font_size, font_size,
                                             framebuf.MONO_HLSB), x, y)
            else:
                display.blit(framebuf.FrameBuffer(bytearray(byte_data), font_size, font_size, framebuf.MONO_HLSB), x, y)

            # 英文字符半格显示
            if ord(string[char]) < 128 and half_char:
                x += font_size // 2
            else:
                x += font_size

        display.show() if show else 0

    def char(self, char, color=1, font_size=None, reverse=False):
        """ 获取字体字节数据

        在没有继承 framebuf.FrameBuffer 的显示驱动,或者内存不足以将一整个屏幕载入缓存帧时
        可以直接获取单字的字节数据,局部更新
        Args:
            char: 单个字符
            color: 颜色
            font_size: 字体大小
            reverse: 反转

        Returns:
            bytearray
        """
        font_size = font_size or self.font_size
        byte_data = list(self.get_bitmap(char))

        # 反转
        if reverse:
            for _pixel in range(len(byte_data)):
                byte_data[_pixel] = ~byte_data[_pixel] & 0xff
        if color > 1 or font_size != self.font_size:
            bit_data = self._to_bit_list(byte_data, font_size)
            if color > 1:
                return self._color_render(bit_data, color)
            else:
                return self._bit_list_to_byte_data(bit_data)
        else:
            return bytearray(byte_data)


if __name__ == '__main__':
    def show_bitmap(arr):
        """
        显示点阵字 MONO_HLSB
        :return:
        """
        for row in arr:
            for i in row:
                if i:
                    print('* ', end=' ')
                else:
                    print('. ', end=' ')
            print()


    font = BMFont("unifont-14-12888-16.v3.bmf")
    print("16 ----")
    bd = font.char("我", reverse=True, color=0xffff, font_size=16)
    print("24 ----")
    bd = font.char("我", reverse=True, color=0xffff, font_size=24)
    print("16 ----")
    # font._with_color(zoom(byte_to_bit(font.get_bitmap("我"), 16), 24), 0xff00)
    font._color_render(font._to_bit_list(font.get_bitmap("我"), 24), 0xff00)

七、4x4矩阵按键购买

        4x4 按键模块 矩阵模块 键盘模块 单片机 外围模块

https://detail.tmall.com/item.htm?_u=ip01rchfc25&id=538152113118&spm=a1z09.2.0.0.7f5e2e8dCdkoWOicon-default.png?t=N4HBhttps://detail.tmall.com/item.htm?_u=ip01rchfc25&id=538152113118&spm=a1z09.2.0.0.7f5e2e8dCdkoWO我收到的实物图和卖家详情页的不一样，但是可以使用。

 

 

魔都飘雪
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Arduino+ESP32专题】案例：按键控制LED灯
一点硬件
07-07 2593
在星球文章【Arduino+ESP32专题】数字I/O的使用 中我们讲到Arduino可以很方便的将管脚设置成各种状态。那么如果外面接的是输出（如LED、控制脚等）我们就能设置成输出模式，外面如果是输入，我也也能设置为浮空、输入上拉、输入下拉等管脚模式。现在要来设计一个按键控制LED灯的程序，此程序包含了输入输出，比较简单但是作用也很广泛。正常情况下单片机的IO口控制入门都会使用此案例。而且这种控制方式在实际的工作中很常用，比如可以将按键更换成传感器，传感器输入高电平，那么相应的LED或外设动作。按键的种类
物联网开发笔记（41）- 使用Micropython开发ESP32开发板之控制4*4矩阵键盘
zhusongziye的博客
11-13 1867
使用Micropython开发ESP32开发板之控制4*4矩阵键盘
【MicroPython】基于microbit的MicroPython编程--HELLO WORLD
Not Found 404
12-31 2247
基于microbit的MicroPython编程--HELLO WORLDhello worldpython知识显示图像程序一：显示内置图形程序二：显示自定义图形==python知识==引脚输出接线程序运行引脚说明错误信息 hello world 在microbit上，有5*5的LED矩阵，可以用来显示数字、字母和图形 我们可以通过以下程序来滚动显示“Hello World！” LC1-1 from microbit import * while True: display.scroll("Hel
【Micropython Pitaya Lite教程】key按键与EXTI中断
最新发布
m0_62599305的博客
05-05 989
Micropython Pitaya Lite开发板提供了丰富的功能和灵活的扩展性，其中包括了按键（key）输入和外部中断（EXTI）功能。通过这些功能，您可以轻松地与外部设备进行交互，并实现更加复杂的应用。本教程将重点介绍如何在Micropython Pitaya Lite上使用按键和外部中断，以便您更好地利用这些功能进行项目开发。几乎每个开发板都会板载有独立按键，因为按键用处很多。常态下，独立按键是断开的，按下的时候才闭合。每个独立按键会单独占用一个 IO 口，通过 IO 口的高低电平判断按键的状态。
ESP32（MicroPython）矩阵键盘控制RGB灯+按键震动
weixin_74155302的博客
06-24 636
本程序通过矩阵键盘控制RGB灯，三个矩阵键盘分别控制RGB三色，各15级亮度。面包板底部装有高电平触发的振动马达，按键时引脚输出高电平实现按键震动。ESP32（MicroPython） 矩阵键盘控制RGB灯。
Micropython按键检测模块，支持防抖、持续触发
applebomb的专栏
06-24 818
Micropython按键检测模块，支持防抖、持续触发。
【Java程序员学ESP32】06 ESP-IDF代码学习 - matrix-key 矩阵键盘
记录和分享也是一种学习
04-06 738
dedicated gpio在矩阵键盘上的应用
ESP32-C3把4*4矩阵键盘数据传输到OLED显示屏上
帕法西尔的博客
03-07 4941
利用ESP32-C3把4*4薄膜按键数据显示到0.96的Oled显示屏上
物联网项目实战开发之基于STM32F103的4x4矩阵扫描按键测试程序代码
05-06
1、按照4X4矩阵按键连接图把矩阵按键连接板子上，矩阵板卡端子K1~K8连接开发板J5上的PA0~PA7; 2、给开发板下载程序； 3、下载程序后,按下按键1，开发板蓝色指示灯(PB9)闪烁一次，按下按键2，开发板蓝色指示灯闪烁两...
4X4矩阵键盘16个按键模块电路PCB文件
05-02
在本案例中，"4X4矩阵键盘16个按键模块电路PCB文件.DDB" 是一个设计数据库文件，可能使用了特定的PCB设计软件如Altium Designer、EAGLE或KiCad等创建。这个文件包含了完整的电路图、元器件库、层设置以及制造所需的...
4X4矩阵按键的使用方法
08-04
在实际操作中，4X4矩阵键盘的连接方式是将按键排成4行4列，每行和每列分别连接到单片机的8个I/O口中的4个。例如，行线可以连接到P1口的低四位，列线连接到P1口的高四位。这样，通过控制行线的电平状态，可以逐行扫描...
4x4矩阵按键扫描实验 - 串口调试助手_STC15W4K58S4单片机_矩阵按键_源码
10-04
在电子工程领域，4x4矩阵按键扫描实验是学习单片机编程时常见的一个实践项目。这个实验主要涉及两个核心技术：STC15W4K58S4单片机和矩阵按键。下面将详细解释这两个核心概念以及如何实现它们之间的交互。 **STC15W4...
基于STM32F103单片机GPIO检测4x4矩阵按键信号的程序代码 0034
12-26
1、STM32F103通过设置GPIO口与4x4矩阵按键模块相连，通过代码读取哪些按键被按下。 2、代码使用KEIL开发，当前在STM32F103C8T6运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量...
09-MicroPython+ESP32实现中断方式扫描按键控制
weixin_42255154的博客
09-08 966
通过本实验，学会了使用MicroPython编程语言使用外部中断方式控制按键。
【Micropython教程】key按键与EXTI中断
m0_62599305的博客
02-29 1330
MicroPython为嵌入式系统提供了一种轻量级的Python解释器，使得开发者能够在资源受限的环境中使用Python语言。在嵌入式系统中，处理按键和中断是常见的任务，而MicroPython为这些任务提供了简单而强大的解决方案。本教程将重点介绍MicroPython中如何处理按键与外部中断（EXTI）的相关内容，以帮助开发者更好地理解和应用这些功能。几乎每个开发板都会板载有独立按键，因为按键用处很多。常态下，独立按键是断开的，按下的时候才闭合。
4x4矩阵按键应用详解
热门推荐
会飞的鱼的博客
11-18 1万+
一.简介 4x4矩阵按键是单片机外部设备中所使用的排布类似于矩阵的按键组。显然矩阵按键的使用要比独立按键要复杂一些，编程也要复杂一些，但可以单片机IO资源。4x4矩阵按键即分为4组列线，4组行线，并将行线所接的单片机的I/O口作为输出端，而列线所接的I/O口则作为输入。 二．硬件连接图 51单片机的P1口用作按键I/O口，键盘的列线接到P1口的低4位，键盘的行线接到P1口的高4位；把列线P1.0-...
物联网开发100 - Micropython ESP32 S3非取字模和刷写中文固件方式显示中文
zhusongziye的博客
03-26 2369
Micropython ESP32 S3非取字模和刷写中文固件方式显示中文，以及制作中文字体
esp32c3驱动iic1306oled屏
m0_52539320的博客
11-13 843
esp32c3驱动iic1306oled屏,显示温湿度
micropython按键,MicroPython动手做（24）——掌控板之拓展掌控宝
weixin_28694169的博客
03-16 401
5、按键控制小车前进、后退与旋转#MicroPython动手做(24)——掌控板之拓展掌控宝#按键控制小车前进、后退与旋转[mw_shl_code=python,true]#MicroPython动手做(24)——掌控板之拓展掌控宝#按键控制小车前进、后退与旋转import parrotfrom mpython import *def forward():parrot.set_speed(parr...
基于stm32的4x4矩阵按键
03-30
STM32是一种微控制器，可以用来实现4x4矩阵按键的功能。以下是实现方法的步骤： 1. 确定按键矩阵的引脚连接方式，一般使用行列扫描法。将按键连接在引脚上，行和列分别接入STM32的GPIO引脚。 2. 配置STM32的GPIO模式和中断。使用HAL库提供的GPIO_Init和HAL_NVIC_EnableIRQ函数，将引脚配置为输入模式和中断触发模式。 3. 在中断处理函数中检测按键状态。中断触发时，检测引脚的电平状态，根据行列扫描法判断按下的按键是哪一个，并执行相应的操作。 4. 可以使用定时器来控制按键的重复触发。如果按键一直按下，可以使用定时器来定时发送按键事件，实现长按功能。 5. 可以将按键事件通过串口或其他方式输出，方便调试和使用。 以上是基于STM32的4x4矩阵按键的实现方法，具体实现时需要根据不同的STM32型号和开发环境进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

魔都飘雪

您的1毛奖励是我创作的源源动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值