STM32-矩阵键盘（中断）

最新推荐文章于 2024-07-14 22:02:12 发布
最新推荐文章于 2024-07-14 22:02:12 发布
阅读量5.3k 收藏 63
点赞数 9
分类专栏： STM32F4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu58430/article/details/116712974
版权

原理

矩阵键盘

在其中3列加上低电平，第x列加上高电平，当检测到第y行出现低电平，说明x行y列有按键按下

执行上述步骤四次，就可以准确知道那个键位按下

中断原理

行的GPIO设置输入，上拉（不输入时默认高电平）

列的GPIO设置推挽输出，初始化低电平

行GPIO对应LINE5~8,使用中断服务函数 EXTI9_5_IRQHandler

当中断产生，先进入中断服务函数，再去判断是哪一根中断线，再开始逐列扫描

注意：不要把多个GPIO映射到同一个中断线上，但多条中断线可以对应一个中断服务函数

实现

GPIO管脚定义

行:F5~F8

列:F1~F4

// Row:F5~F8
#define R1_PIN             GPIO_Pin_5
#define R1_GPIO_PORT       GPIOF
#define R1_GPIO_CLK        RCC_AHB1Periph_GPIOF

#define R2_PIN             GPIO_Pin_6
#define R2_GPIO_PORT       GPIOF
#define R2_GPIO_CLK        RCC_AHB1Periph_GPIOF

#define R3_PIN             GPIO_Pin_7
#define R3_GPIO_PORT       GPIOF
#define R3_GPIO_CLK        RCC_AHB1Periph_GPIOF

#define R4_PIN             GPIO_Pin_8
#define R4_GPIO_PORT       GPIOF
#define R4_GPIO_CLK        RCC_AHB1Periph_GPIOF

// Column:F1~F4
#define C1_PIN             GPIO_Pin_1    
#define C1_GPIO_PORT       GPIOF
#define C1_GPIO_CLK        RCC_AHB1Periph_GPIOF

#define C2_PIN             GPIO_Pin_2
#define C2_GPIO_PORT       GPIOF
#define C2_GPIO_CLK        RCC_AHB1Periph_GPIOF

#define C3_PIN             GPIO_Pin_3
#define C3_GPIO_PORT       GPIOF
#define C3_GPIO_CLK        RCC_AHB1Periph_GPIOF

#define C4_PIN             GPIO_Pin_4
#define C4_GPIO_PORT       GPIOF
#define C4_GPIO_CLK        RCC_AHB1Periph_GPIOF

代码实现

#include "delay.h"
#include "led.h"
#include "key.h"
#include "beep.h"

u8 flag_key = 0;
int key_code = 0;

void GPIO_GIVE() {  //全部置为低电平，中断检测
    GPIO_ResetBits(C1_GPIO_PORT, C1_PIN);
    GPIO_ResetBits(C2_GPIO_PORT, C2_PIN);
    GPIO_ResetBits(C3_GPIO_PORT, C3_PIN);
    GPIO_ResetBits(C4_GPIO_PORT, C4_PIN);
}

void EXTI9_5_IRQHandler(void) {  //中断服务函数
    delay_ms(10);
    if (EXTI_GetFlagStatus(EXTI_Line5) != RESET) {
        delay_ms(10);
        GPIO_ResetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0));
            flag_key = 1;
            key_code = 1;
            EXTI_ClearITPendingBit(EXTI_Line5); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_ResetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0));
            flag_key = 1;
            key_code = 2;
            EXTI_ClearITPendingBit(EXTI_Line5); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_ResetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0));
            flag_key = 1;
            key_code = 3;
            EXTI_ClearITPendingBit(EXTI_Line5); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_ResetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R1_GPIO_PORT, R1_PIN) == 0));
            flag_key = 1;
            key_code = 4;
            EXTI_ClearITPendingBit(EXTI_Line5); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
    }
    else if (EXTI_GetFlagStatus(EXTI_Line6) != RESET) {
        delay_ms(10);
        GPIO_ResetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0) {
            delay_ms(10);
            while (GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0);
            flag_key = 1;
            key_code = 5;
            EXTI_ClearITPendingBit(EXTI_Line6); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_ResetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0) {
            delay_ms(10);
            while (GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0);
            flag_key = 1;
            key_code = 6;
            EXTI_ClearITPendingBit(EXTI_Line6); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_ResetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0));
            flag_key = 1;
            key_code = 7;
            EXTI_ClearITPendingBit(EXTI_Line6); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_ResetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R2_GPIO_PORT, R2_PIN) == 0));
            flag_key = 1;
            key_code = 8;
            EXTI_ClearITPendingBit(EXTI_Line6); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
    }
    else if (EXTI_GetFlagStatus(EXTI_Line7) != RESET) {
        delay_ms(10);
        GPIO_ResetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0) {
            delay_ms(10);
            while (GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0);
            flag_key = 1;
            key_code = 9;
            EXTI_ClearITPendingBit(EXTI_Line7); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_ResetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0) {
            delay_ms(10);
            while (GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0);
            flag_key = 1;
            key_code = 10;
            EXTI_ClearITPendingBit(EXTI_Line7); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_ResetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0));
            flag_key = 1;
            key_code = 11;
            EXTI_ClearITPendingBit(EXTI_Line7); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_ResetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R3_GPIO_PORT, R3_PIN) == 0));
            flag_key = 1;
            key_code = 12;
            EXTI_ClearITPendingBit(EXTI_Line7); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
    }
    else if (EXTI_GetFlagStatus(EXTI_Line8) != RESET) {
        delay_ms(10);

        GPIO_ResetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0));
            flag_key = 1;
            key_code = 13;
            EXTI_ClearITPendingBit(EXTI_Line8); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_ResetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0) {

            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0));
            flag_key = 1;
            key_code = 14;
            EXTI_ClearITPendingBit(EXTI_Line8); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }

        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_ResetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_SetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0));
            flag_key = 1;
            key_code = 15;
            EXTI_ClearITPendingBit(EXTI_Line8); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }

        GPIO_SetBits(C1_GPIO_PORT, C1_PIN);
        GPIO_SetBits(C2_GPIO_PORT, C2_PIN);
        GPIO_SetBits(C3_GPIO_PORT, C3_PIN);
        GPIO_ResetBits(C4_GPIO_PORT, C4_PIN);
        if (GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0) {
            delay_ms(10);
            while ((GPIO_ReadInputDataBit(R4_GPIO_PORT, R4_PIN) == 0));
            flag_key = 1;
            key_code = 16;
            EXTI_ClearITPendingBit(EXTI_Line8); //清除LINE0上的中断标志位
            GPIO_GIVE();
            return;
        }
    }
    EXTI_ClearITPendingBit(EXTI_Line5); //清除LINE5上的中断标志位
    EXTI_ClearITPendingBit(EXTI_Line6); //清除LINE6上的中断标志位
    EXTI_ClearITPendingBit(EXTI_Line7); //清除LINE7上的中断标志位
    EXTI_ClearITPendingBit(EXTI_Line8); //清除LINE8上的中断标志位
    GPIO_GIVE();
}



//GPIO初始化程序
void GPIO_SET(void) {             
    RCC_AHB1PeriphClockCmd(C1_GPIO_CLK | C2_GPIO_CLK | C3_GPIO_CLK | C4_GPIO_CLK, ENABLE);
    RCC_AHB1PeriphClockCmd(R1_GPIO_CLK | R2_GPIO_CLK | R3_GPIO_CLK | R4_GPIO_CLK, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure;

    GPIO_InitStructure.GPIO_Pin = C1_PIN;//列输出
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;//普通输出模式
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出模式
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100M
    GPIO_Init(C1_GPIO_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = C2_PIN;//C2列输出
    GPIO_Init(C2_GPIO_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = C3_PIN;//C3列输出
    GPIO_Init(C3_GPIO_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = C4_PIN;//C4列输出
    GPIO_Init(C4_GPIO_PORT, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = R1_PIN;//R1_PIN 行输入
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;//普通输入模式
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
    GPIO_Init(R1_GPIO_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = R2_PIN;//R2_PIN 行输入
    GPIO_Init(R2_GPIO_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = R3_PIN;//R3_PIN 行输入
    GPIO_Init(R3_GPIO_PORT, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = R4_PIN;//R4_PIN 行输入
    GPIO_Init(R4_GPIO_PORT, &GPIO_InitStructure);

    GPIO_GIVE();
}

void EXTIX_Init(void) {          
    NVIC_InitTypeDef NVIC_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);//使能SYSCFG时钟
    GPIO_SET(); //按键对应的IO口初始化

    /* 配置EXTI_Line5~8 */
    EXTI_InitTypeDef EXTI_InitStructure;
    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOF, EXTI_PinSource5);//PF5 连接到中断线5
    EXTI_InitStructure.EXTI_Line = EXTI_Line5;//LINE5
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//中断事件
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;//使能
    EXTI_Init(&EXTI_InitStructure);//配置

    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOF, EXTI_PinSource6);//PF6 连接到中断线6
    EXTI_InitStructure.EXTI_Line = EXTI_Line6;//LINE6
    EXTI_Init(&EXTI_InitStructure);//配置
    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOF, EXTI_PinSource7);//PF7 连接到中断线7
    EXTI_InitStructure.EXTI_Line = EXTI_Line7;//LINE7
    EXTI_Init(&EXTI_InitStructure);//配置
    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOF, EXTI_PinSource8);//PF8 连接到中断线8
    EXTI_InitStructure.EXTI_Line = EXTI_Line8;//LINE8
    EXTI_Init(&EXTI_InitStructure);//配置

    NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;//外部中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02;//抢占优先级3
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x03;//子优先级2
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;//使能外部中断通道
    NVIC_Init(&NVIC_InitStructure);//配置

}

 

 

 

 

LoseHu
关注
专栏目录
STM32使用中断驱动矩阵键盘
weixin_44288508的博客
09-23 2723
STM32使用中断驱动矩阵键盘 代码 宏定义 //b6,b7,c8,c9做行扫描，c10~c12做列扫描 #define ROW1_GPIO_PORT GPIOB //行1 #define GPIO_CLK RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOC /* GPIO端口时钟 ...
【STM32】4*4矩阵键盘扫描程序（中断方式）
电子通信仔的学习杂记
08-12 6292
上一篇杂记写了个扫描方式的键盘程序，但是最近在做一个小游戏对CPU响应速度有要求，于是再弄个简单的键盘中断检测程序吧。 总体思路：中断线为4行连接的GPIO口，先初始化矩阵的4行输出低电平4列输出高电平，当有按键按下时的上升沿触发中断；然后在相应的中断处理函数里面采取查询的方式（参考上篇）获得键值。 部分程序 void EXTI9_5_IRQHandler(void) //外部中断中断函数 { if(EXTI_GetITStatus(EXTI
stm32中断详解
最新发布
weixin_73497355的博客
07-14 1127
本文对stm32的中断进行了详细的讲解，并通过一个例子演示了中断的配置流程。
基于STM32的矩阵键盘驱动（中断方式）
04-07
自己写的STM32的矩阵键盘驱动，用的中断方式 包含.c和.h文件的全部内容
stm32矩阵键盘（中断模式）
nbbskk的博客
05-15 3170
在搞定矩阵键盘的扫描模式以后，我就开始想用中断的方式来搞定矩阵键盘，通过中断的方式来搞定矩阵键盘非常方便，也不会占用太多的机时，扫描模式的文章在我另一个博客中，可以根据个人情况来选择合适的方式。 我选择的是3*4的矩阵键盘，具体的实物图如下所示 矩阵键盘是4行3列示意图如图所示 采用中断方式来进行检测按键具体的思想就是通过按键先来触发中断，如果中断被触发再来进行行或者列的扫描来确定是哪个具体的按键被按下，这样可以节省CPU的机时，也可以更有效率。 我的代码就是采用这种方法。首先是将行的引脚都
基于Stm32的矩阵键盘驱动（中断方式）
07-27
本程序实现4*5键盘的扫描 从左到右，从上到下，键值 依次为1-20 中断扫描模式 ,要在NVIC在中打开对应中断 /*可以自己定义其它扫描方式
stm32以中断方式扫描矩阵键盘
深圳五月花--老李的森林
08-09 4219
普通的按键，都是一个IO口控制一个按键，但是当按键数量变多时，单片机可能没有那么多的IO口来供给按键使用，这时候就需要用到矩阵键盘，比如4。定义一个结构体，有按键触发时，active置1，x，y分别记录行列值，num是最后的键值。4 在Y4中断内，将Y4配置为低电平输出，而X0~3配置为上拉输入，记录下Y值为4。X0到X3这4个IO口配置为低电平输出，无上拉，无下拉，即推挽方式，速度为中。5 逐一检测X0~3的电平，哪一路为低，即对应的为X键值，本例X值为2。最后调用键盘扫描函数，来确认X的键值。.....
stm32 4*4矩阵键盘 中断扫描
zyc18700766982的博客
08-01 4315
stm32f103c8t6 4*4矩阵键盘 中断扫描实现
132.STM32-矩阵键盘显示键值.zip
05-15
在本项目"132.STM32-矩阵键盘显示键值"中，我们将探讨如何利用STM32处理矩阵键盘并实时显示所按按键的值。矩阵键盘是一种常见的输入设备，通常用于小型电子设备中，如计算器、工控设备等，它通过排列按键在行和列上...
133.STM32-矩阵键盘动态显示键值.zip
05-15
总结来说，"133.STM32-矩阵键盘动态显示键值"项目涵盖了STM32的GPIO配置、中断处理、矩阵键盘扫描、按键识别、串行通信以及多任务处理等多个知识点。通过该项目，开发者能够学习到如何在实际应用中有效地控制和交互...
stm32矩阵键盘（中断）
05-15
STM32矩阵键盘中断实现是嵌入式系统中常见的用户输入处理方法，它涉及到了STM32微控制器、中断机制、矩阵键盘结构以及OLED显示技术。以下将详细阐述这些知识点。 1. STM32微控制器：STM32是意法半导体...
stm32矩阵按键程序(中断方式).rar
08-12
矩形键盘程序（中断方式）
stm32中断触发矩阵键盘
12-04
利用stm32中触发键盘，能够准确获得键位数值，提高了cpu性能，减少了占用。sdsasffsgfsaf
stm32f103vet6外部中断来获取矩阵键盘键值外加可精确到小数点后6位计算器源程序.zip
07-30
stm32f103vet6外部中断来获取矩阵键盘键值外加可精确到小数点后6位计算器源程序
矩阵键盘的中断实现的演示
03-08
基于proteus仿真的矩阵键盘实现，附有单片机C语言原程序
矩阵键盘中断方式电路图
07-15
本文主要讲了矩阵键盘中断方式电路图，希望对你的学习有所帮助。
STM32-矩阵键盘程序4×4.doc
10-07
STM32 矩阵键盘程序4×4的实现主要涉及单片机编程，特别是针对STM32F10x系列的微控制器。这个程序的主要目的是驱动4行4列的矩阵键盘，通过扫描键盘的输入状态来识别并返回被按下的键值。以下是程序的关键知识点： 1...
8.1STM32F103矩阵键盘
07-05
【标题】"8.1 STM32F103矩阵键盘" 在嵌入式系统设计中，矩阵键盘是一种常见的输入设备，它通过排列按键形成一个二维矩阵，有效地减少了微控制器如STM32F103所需的I/O引脚数量。STM32F103系列是意法半导体...
STM32操作矩阵键盘的两种方法——扫描和中断
热门推荐
qq_42031914的博客
08-22 2万+
目录STM32操作矩阵键盘的两种方法——扫描和中断一、矩阵键盘的结构和原理二、扫描式矩阵键盘的原理和实现三、中断式矩阵键盘的原理和实现四、两种方案优劣 STM32操作矩阵键盘的两种方法——扫描和中断 最近在准备电赛，有一道题要求设计一个简易的信号发生器，需要用到矩阵键盘来输入待生成信号的类型、频率和幅值等参数，因此写下本文来总结我试验过的单片机操作矩阵键盘的两种方法。 一、矩阵键盘的结构和原理 矩阵键盘的实物可能长这样： 也可能长这样： 不管它们外表什么样，它们的内部结构都大同小异： 每一个矩阵键盘有8
stm32中断矩阵键盘
07-20
### 回答1： STM32中断矩阵键盘是一种常见的输入设备，它可以通过矩阵排列的按键来检测用户的输入。在STM32微控制器上使用中断的方式处理矩阵键盘可以提供更高效和快速的输入响应。 首先，要使用STM32中断矩阵键盘，首先需要配置GPIO引脚作为输入模式，并将其连接到键盘矩阵的行和列。然后，我们需要设置外部中断，让微控制器能够捕获键盘按下和释放的事件。 中断矩阵键盘的原理是通过轮询的方式检测按键是否被按下，以及确定哪个按键被按下。当按键被按下时，引发中断，微控制器跳转到中断服务程序。 中断服务程序通常包括以下几个步骤：首先，检测中断是由键盘按下还是释放引起的。然后，确定是哪个按键被按下，通过行和列的组合确定按键的唯一标识。接下来，可以执行相应的操作，例如发送按键编码到串口或控制其他设备的功能。 使用中断的好处是能够实时捕获按键事件，响应速度更快。相对于轮询方式，减少了对系统资源的消耗。 总之，STM32中断矩阵键盘是一种常见的输入设备，它能够通过中断的方式实时捕获用户按键事件。通过合理配置和编程，可以提高系统的输入响应速度和效率。 ### 回答2： 在STM32微控制器中，矩阵键盘的使用可以通过中断来实现。矩阵键盘是一种常用的输入设备，由多个行和列的按键组成，通过行列的交叉点进行按键扫描。 首先，需要配置GPIO引脚作为键盘的行和列，并将其设置为输入模式。然后，需要使用外部中断对行引脚进行触发，并定义中断处理函数。 中断矩阵键盘的基本原理是，当某一行的按键被按下时，相应的中断触发，并进入中断处理函数。在处理函数中，需要判断是哪一列的按键被按下，并根据行列的对应关系来确定具体按键的值。 为了实现中断矩阵键盘的操作，可以通过以下步骤进行: 1. 配置行和列的GPIO引脚，并设置为输入模式。 2. 配置行的中断触发方式，可以选择上升沿触发、下降沿触发或双边沿触发等，具体根据实际情况而定。 3. 定义中断处理函数，在此函数中进行按键的判断和对应操作。可以使用读取列的GPIO状态来确定具体按键的值。 4. 开启中断，并将中断优先级设定为适当的值。可以使用NVIC_SetPriority()函数设置中断优先级。 5. 在主循环中保持运行，等待中断触发。 需要注意的是，中断矩阵键盘的使用需要详细了解键盘的连接配置和按键扫描原理。另外，中断的优先级设置也是需要考虑的重要因素，根据实际需求进行调整。 通过以上步骤的配置和实现，便可在STM32微控制器中使用中断矩阵键盘，并根据按键的情况做出相应的响应或控制操作。 ### 回答3： 在STM32微控制器中，可以使用中断来处理矩阵键盘输入。矩阵键盘是一种常用的输入设备，可以通过将键盘上的按键连接成矩阵的方式，减少使用的IO口。通过使用中断，可以及时地捕获按键的状态改变，并做出相应的处理。 首先，需要配置GPIO口的输入和输出模式，以及使用中断的触发条件。对于矩阵键盘，一般使用GPIO口的输入模式，因为需要检测按键的状态。 然后，编写中断服务函数，用于处理按键状态的改变。在中断服务函数中，可以使用GPIO口的中断标志位来判断触发中断的原因，即是否是按键状态的改变。当检测到按键状态的改变后，可以根据按键的位置信息，执行相应的操作，例如发送数据到其他设备或者控制某些功能的开关。 另外，还需要配置NVIC（Nested Vectored Interrupt Controller）控制器，以使其能够对外部中断进行优先级管理。这样可以确保矩阵键盘的中断能够被及时处理，并且可以设置不同的中断优先级来满足系统需求。 最后，在主函数中进行初始化和启用中断，以及其他需要的操作。通过配置GPIO口和中断服务函数，可以实现对矩阵键盘输入的监听和响应。 总之，利用STM32微控制器的中断功能，可以实现对矩阵键盘输入的处理。通过配置GPIO口的输入模式和中断触发条件，编写中断服务函数，配置NVIC控制器，以及初始化和启用中断，在主函数中完成对矩阵键盘输入的监听和响应。这样可以实现对矩阵键盘输入的及时处理，从而提高系统的交互性和响应速度。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LoseHu

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值