精华内容
下载资源
问答
  • stm32矩阵键盘程序

    2016-07-25 13:43:46
    最简单的矩阵键盘程序代码,扫描只有九行代码,通俗易懂,方便移植,
  • STM32矩阵键盘程序

    2014-03-04 16:59:18
    键盘程序stm32
  • stm32矩阵键盘按键扫描程序亲测可用,PA0~PA7为矩阵键盘接口,PA9PA10为串口
  • STM32 矩阵键盘 程序 可以实现任意不连续引脚配置的完美设置 并且显示 显示采用JLX12864G-086-PC 引脚任意配置 完美显示
  • stm32矩阵键盘扫描

    2015-08-09 10:24:21
    stm32矩阵键盘扫描程序,亲测可用,GPIOA口,原理与51单片机类似
  • 一个基于stm32f103zet6的矩阵键盘程序stm32接上矩阵键盘即可使用。
  • stm32F1矩阵键盘程序

    2018-12-25 11:20:17
    这是一个基于STM32F1的矩阵键盘程序,使用的HAL库,已测试成功,移植方便
  • STM32矩阵键盘代码

    2016-12-16 08:43:17
    程序STM32F103系列的矩阵键盘代码,本人使用过
  • STM32F1的矩阵键盘程序

    2019-01-24 14:21:22
    STM32F1的矩阵键盘程序
  • STM32 矩阵键盘扫描实验

    热门讨论 2011-05-15 09:45:27
    STM32 矩阵键盘扫描实验,完整程序,高度的可移植性,可以接到任意IO口。 4*4 与4*3 扫描读按键程序
  • 矩阵键盘驱动 矩阵键盘驱动 /* *文件 *编写人LiuHui *描述扫描4x4矩阵键盘输入并返回键值 *适用范围驱动采用库编写适用于 STM32F10X系列单片机 *所用引脚PA0-PA7 *编写时间2014年5月20日 */ #i nclude" #i nclude" #...
  • STM32 矩阵键盘通过串口输出

    千次阅读 2018-05-21 21:18:08
    STM32F103C8T6 4*4矩阵键盘 通过串口输出,可以用来写密码锁程序的思路如下:1、首先需要配置的是矩阵键盘:配置两个函数: KEY44_Init(矩阵键盘初始化)和key44_Scan(扫描并获取值) 。2、其次,设置串口(本文设置...

     STM32F103C8T6 4*4矩阵键盘 通过串口输出,可以用来写密码锁

    程序的思路如下:

    1、首先需要配置的是矩阵键盘:配置两个函数:  KEY44_Init(矩阵键盘初始化)和key44_Scan(扫描并获取值)   。

    2、其次,设置串口(本文设置为STM32F103C8T6的串口三): 我们需要对USART进行初始化设置,详细请见下文。

    3、然后就开始写我们的主函数:主函数比较简单。因为程序已经分装了。

    4、最后我们要实现按下一个键,串口打出一个字符(按下1键,打出1)

    ——————————————————————————————————————————————————-

    下边为程序:所用芯片为STM32F103C8T6 

     串口3的管脚为PB10 -> TX 配置复用推挽式输出  PB11 ->RX配置浮空输入

    配置矩阵键盘为PA0~PA3 推挽式输出 PA4~PA7 上拉输入

    矩阵键盘的配置:

    声明:
    #define H_1 PAout(0)
    #define H_2 PAout(1)
    #define H_3 PAout(2)
    #define H_4 PAout(3)
    
    #define L_1 PAin(4)
    #define L_2 PAin(5)
    #define L_3 PAin(6)
    #define L_4 PAin(7)
    
    void  KEY44_Init(void);
    unsigned char key44_Scan(void);	

    KEY44_Init(矩阵键盘初始化):

    void  KEY44_Init(void)
    {
    			GPIO_InitTypeDef GPIO_InitStructure;//PA0~PA3 推挽式输出
    			RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//初始化GPIOA时钟
    			GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 |GPIO_Pin_1 |GPIO_Pin_2 |GPIO_Pin_3 ;
    			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    			GPIO_Init(GPIOA, &GPIO_InitStructure);
    	
    			
    			GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 |GPIO_Pin_5 |GPIO_Pin_6 |GPIO_Pin_7 ; //PA4~PA7 上拉输入
    			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    			GPIO_Init(GPIOA, &GPIO_InitStructure);
    }

    配置为串口三:

    void USART3_Init (u32 bound)
    {
    
    		GPIO_InitTypeDef GPIO_InitStructure;
    		USART_InitTypeDef USART_InitStructure;
    		//开启GPIOB和复用推挽式输出
    		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO,ENABLE);
    		//开启USART3初始化
    		RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
    		//PB10 -> TX 配置复用推挽式输出  
    		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10  ;
    		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    		GPIO_Init(GPIOB, &GPIO_InitStructure);
    
    		//PB11 ->RX配置浮空输入
    		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11  ;
    		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    		GPIO_Init(GPIOB, &GPIO_InitStructure);
    	
    		//串口初始化
    		USART_InitStructure.USART_BaudRate = bound;
    		USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    		USART_InitStructure.USART_StopBits = USART_StopBits_1;
    		USART_InitStructure.USART_Parity = USART_Parity_No;
    		USART_InitStructure.USART_HardwareFlowControl =USART_HardwareFlowControl_None;
    		USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;		
    		USART_Init(USART3, &USART_InitStructure);
    		//使能串口
    		USART_Cmd(USART3,ENABLE);
    		USART_ClearFlag(USART3,USART_FLAG_TC);//解决发送第一个字节丢失的问题
    }

    主函数:

    #include "sys.h"
    # include "KEY44.h"
    #include "usart3.h"
    #include "delay.h"
    u8 key_num = 0;//缓冲变量
    int main()
    {
    	uart3_init(115200);
    	delay_init();
    	KEY44_Init();
    
    	while(1)
    		{
    		key_num = key44_Scan();
    		if(key_num !=0)
    		{
    		printf("KEY Num is %d\r\n",key_num);
    
    		}
    		}
    }

    最后要注意的是,本文不是库编程打印,所以要在程序里加入以下程序,并加上头文件# include <stdio.h>

    int fputc(int ch, FILE *f)
    {      
    	while((USART3->SR&0X40)==0);//循环发送,直到发送完毕   
        USART3->DR = (u8) ch;      
    	return ch;

    可以加我交流哈,一起进步 q:896704973
    展开全文
  • stm32 4*4矩阵键盘程序

    2017-03-25 10:57:51
    stm32 4*4矩阵键盘程序
  • STM32矩阵键盘设值

    2015-08-08 17:05:35
    按键设值程序。按下15键进入设定,14键确定并退出。 10键为小数点。
  • STM32矩阵键盘 EEPROM OLED 综合代码源程序 亲写 亲测 可用....................................................................................................................................................
  • 完整版stm32f407键盘显示程序, 芯片使用的是stm32f407VET6,里面包含OLED显示,需要的自行下载
  • stm32矩阵按键程序.rar

    2020-06-16 13:19:05
    键盘扫描
  • 矩阵键盘STM32程序

    2018-07-06 15:54:39
    基于STM32F103单片机的矩阵键盘源代码 是电设竞赛的时候用到的
  • 亲测可用4X4矩阵键盘,简单好用,采用行列扫描方法,延时程序不占用MCU资源。 主控芯片为stm32f407VGT6
  • stm32 4*4矩阵键盘

    2012-10-09 19:49:14
    很好用的简单,stm32矩阵键盘程序,跟单片机C51类似
  • 基于stm32的8*8矩阵键盘程序,内含自写4*4矩阵键盘说明
  • 这是一个非阻塞式矩阵键盘驱动程序,支持单按、长按、组合键。稳定可靠用过就知道。 使用说明都在注释里。
  • 直接上源码 key.h文件 #ifndef __KEY_H #define __KEY_H #include "sys.h" ...#define Read_Lie1 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_0) #define Read_Lie2 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1) ...

    直接上源码

    key.h文件

    #ifndef __KEY_H
    #define __KEY_H	 
    #include "sys.h"
    
    
    
    #define Read_Lie1 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_0)
    #define Read_Lie2 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_1)
    #define Read_Lie3 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_2)
    #define Read_Lie4 GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_3)
    
    
    
    void KEY_Init(void);//IO初始化
    u8 KEY_Scan(void);  	//按键扫描函数	
    void Key_Text(void);
    #endif

    key.c文件

    #include "key.h"
    #include "sys.h" 
    #include "delay.h"
    #include "usart.h"
    #include "lcd.h"
    
    
    u8 tem;
    
    
    //按键初始化函数
    void KEY_Init(void) 
    { 
     	GPIO_InitTypeDef GPIO_InitStructure;
     
     	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOE,ENABLE);
    
    	GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; 
    	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
    	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
     	GPIO_Init(GPIOC, &GPIO_InitStructure);
    
    
    	GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;
    	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   
    	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    	GPIO_Init(GPIOE, &GPIO_InitStructure);
    
    }
    
    
    u8 KEY_Scan(void)//扫描函数
    {	
    	static u8 key_flag1=1,key_flag2=1,key_flag3=1,key_flag4=1;     //按键松开标志
    	u8 KeyVal;
    	
    	
      GPIO_Write(GPIOE,(( GPIOE->ODR & 0xFFC3 )|0x0004));	//0001
    	if(key_flag1&&(Read_Lie1==1||Read_Lie2==1||Read_Lie3==1||Read_Lie4==1))
    	{
    		 key_flag1=0;
    		     if (Read_Lie1==1){ KeyVal= 4; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie2==1) {KeyVal= 8; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie3==1) {KeyVal= 12; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie4==1) {KeyVal= 16; printf("key:%d\r\n",KeyVal);}
    	}
    	else if(Read_Lie1==0&&Read_Lie2==0&&Read_Lie3==0&&Read_Lie4==0)key_flag1=1;
    	else return 0;
    	
    
    		GPIO_Write(GPIOE,(( GPIOE->ODR & 0xFFC3 )|0x0008));//0010
    	if(key_flag2&&(Read_Lie1==1||Read_Lie2==1||Read_Lie3==1||Read_Lie4==1))
    	{
    		 key_flag2=0;
    		     if (Read_Lie1==1){ KeyVal= 3; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie2==1) {KeyVal= 7; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie3==1) {KeyVal= 11; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie4==1) {KeyVal= 15; printf("key:%d\r\n",KeyVal);}
    	}
    	else if(Read_Lie1==0&&Read_Lie2==0&&Read_Lie3==0&&Read_Lie4==0)key_flag2=1;
    	else return 0;
    	
    
    
    	GPIO_Write(GPIOE,(( GPIOE->ODR & 0xFFC3 )|0x0010));//0100
    	if(key_flag3&&(Read_Lie1==1||Read_Lie2==1||Read_Lie3==1||Read_Lie4==1))
    	{
    		key_flag3=0;
    		     if (Read_Lie1==1){ KeyVal= 2; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie2==1) {KeyVal= 6; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie3==1) {KeyVal= 10; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie4==1) {KeyVal= 14; printf("key:%d\r\n",KeyVal);}
    	}
    	else if(Read_Lie1==0&&Read_Lie2==0&&Read_Lie3==0&&Read_Lie4==0)key_flag3=1;
    	else return 0;
    	
    	
    	
    				
    	 GPIO_Write(GPIOE,(( GPIOE->ODR & 0xFFC3 )|0x0020));//1000
       if(key_flag4&&(Read_Lie1==1||Read_Lie2==1||Read_Lie3==1||Read_Lie4==1))
    	 {
    		 key_flag4=0;
    		     if (Read_Lie1==1){ KeyVal= 1; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie2==1) {KeyVal= 5; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie3==1) {KeyVal= 9; printf("key:%d\r\n",KeyVal);}
    		else if (Read_Lie4==1) {KeyVal= 13; printf("key:%d\r\n",KeyVal);}
    	 }
    	 else if(Read_Lie1==0 &&Read_Lie2==0 &&Read_Lie3==0 &&Read_Lie4==0 )key_flag4=1;
    	 else return 0;
    	 
    	 
    
    	
    	 return KeyVal;
    
    }
    
    
    void Key_Text(void)
    {
    		switch(tem)
    		{
    			case 1:LCD_Clear(WHITE);       break;
    			case 2:LCD_Clear(BLACK);       break;
    			case 3:LCD_Clear(BLUE);        break;
    			case 4:LCD_Clear(RED);         break;
    			case 5:LCD_Clear(MAGENTA);     break;
    			case 6:LCD_Clear(GREEN);       break;
    			case 7:LCD_Clear(CYAN);        break;
    			case 8:LCD_Clear(YELLOW);      break;
    			case 9:LCD_Clear(BRRED);       break;
    			case 10:LCD_Clear(GRAY);       break;
    			case 11:LCD_Clear(LGRAY);      break;
    			case 12:LCD_Clear(BROWN);      break;
    			case 13:LCD_Clear(DARKBLUE);   break;
    			case 14:LCD_Clear(LIGHTBLUE);  break;
    			case 15:LCD_Clear(LIGHTGREEN); break;
    			case 16:LCD_Clear(RED);        break;			
    		}	
    	
    }
    	
    

     

     

    展开全文
  • 矩形键盘程序(中断方式)
  • 8乘*8矩阵键盘STM32程序,无冲突矩阵键盘,有实物、原理图和PCB,有需要请私聊。
  • 【实例简介】使用STM32搭建的矩阵薄膜键盘,固件库版本,..C.H拉过去,就可以用了【实例截图】【核心代码】4x4矩阵薄膜键盘└── TopApex_4x4矩阵键盘├── ReadMe.txt├── keilkill.bat├── key.c├── key....

    【实例简介】

    使用STM32搭建的矩阵薄膜键盘,固件库版本,..C.H拉过去,就可以用了

    【实例截图】

    【核心代码】

    4x4矩阵薄膜键盘

    └── TopApex_4x4矩阵键盘

    ├── ReadMe.txt

    ├── keilkill.bat

    ├── key.c

    ├── key.h

    └── 控制类程序框架

    ├── Core

    │   ├── core_cm3.c

    │   ├── core_cm3.h

    │   └── startup_stm32f10x_hd.s

    ├── Driver

    │   ├── MPU9250.c

    │   ├── MPU9250.h

    │   ├── adc.c

    │   ├── adc.h

    │   ├── delay.c

    │   ├── delay.h

    │   ├── gpio.c

    │   ├── gpio.h

    │   ├── iic1.c

    │   ├── iic1.h

    │   ├── iicSoft.c

    │   ├── iicSoft.h

    │   ├── iwdg.c

    │   ├── iwdg.h

    │   ├── key.c

    │   ├── key.h

    │   ├── pid.c

    │   ├── pid.h

    │   ├── pwm.c

    │   ├── pwm.h

    │   ├── uart1.c

    │   └── uart1.h

    ├── Libraries

    │   ├── inc

    │   │   ├── misc.h

    │   │   ├── stm32f10x_adc.h

    │   │   ├── stm32f10x_bkp.h

    │   │   ├── stm32f10x_can.h

    │   │   ├── stm32f10x_cec.h

    │   │   ├── stm32f10x_crc.h

    │   │   ├── stm32f10x_dac.h

    │   │   ├── stm32f10x_dbgmcu.h

    │   │   ├── stm32f10x_dma.h

    │   │   ├── stm32f10x_exti.h

    │   │   ├── stm32f10x_flash.h

    │   │   ├── stm32f10x_fsmc.h

    │   │   ├── stm32f10x_gpio.h

    │   │   ├── stm32f10x_i2c.h

    │   │   ├── stm32f10x_iwdg.h

    │   │   ├── stm32f10x_pwr.h

    │   │   ├── stm32f10x_rcc.h

    │   │   ├── stm32f10x_rtc.h

    │   │   ├── stm32f10x_sdio.h

    │   │   ├── stm32f10x_spi.h

    │   │   ├── stm32f10x_tim.h

    │   │   ├── stm32f10x_usart.h

    │   │   └── stm32f10x_wwdg.h

    │   └── src

    │   ├── misc.c

    │   ├── stm32f10x_adc.c

    │   ├── stm32f10x_bkp.c

    │   ├── stm32f10x_can.c

    │   ├── stm32f10x_cec.c

    │   ├── stm32f10x_crc.c

    │   ├── stm32f10x_dac.c

    │   ├── stm32f10x_dbgmcu.c

    │   ├── stm32f10x_dma.c

    │   ├── stm32f10x_exti.c

    │   ├── stm32f10x_flash.c

    │   ├── stm32f10x_fsmc.c

    │   ├── stm32f10x_gpio.c

    │   ├── stm32f10x_i2c.c

    │   ├── stm32f10x_iwdg.c

    │   ├── stm32f10x_pwr.c

    │   ├── stm32f10x_rcc.c

    │   ├── stm32f10x_rtc.c

    │   ├── stm32f10x_sdio.c

    │   ├── stm32f10x_spi.c

    │   ├── stm32f10x_tim.c

    │   ├── stm32f10x_usart.c

    │   └── stm32f10x_wwdg.c

    ├── Output

    │   ├── adc.crf

    │   ├── adc.d

    │   ├── adc.o

    │   ├── core_cm3.crf

    │   ├── core_cm3.d

    │   ├── core_cm3.o

    │   ├── delay.crf

    │   ├── delay.d

    │   ├── delay.o

    │   ├── fourWheel.axf

    │   ├── fourWheel.build_log.htm

    │   ├── fourWheel.htm

    │   ├── fourWheel.lnp

    │   ├── fourWheel.sct

    │   ├── gpio.crf

    │   ├── gpio.d

    │   ├── gpio.o

    │   ├── inv_mpu.crf

    │   ├── inv_mpu.d

    │   ├── inv_mpu.o

    │   ├── inv_mpu_dmp_motion_driver.crf

    │   ├── inv_mpu_dmp_motion_driver.d

    │   ├── inv_mpu_dmp_motion_driver.o

    │   ├── iwdg.crf

    │   ├── iwdg.d

    │   ├── iwdg.o

    │   ├── key.crf

    │   ├── key.d

    │   ├── key.o

    │   ├── main.crf

    │   ├── main.d

    │   ├── main.o

    │   ├── misc.crf

    │   ├── misc.d

    │   ├── misc.o

    │   ├── mpu6050.crf

    │   ├── mpu6050.d

    │   ├── mpu6050.o

    │   ├── pid.crf

    │   ├── pid.d

    │   ├── pid.o

    │   ├── pwm.crf

    │   ├── pwm.d

    │   ├── pwm.o

    │   ├── sch.crf

    │   ├── sch.d

    │   ├── sch.o

    │   ├── startup_stm32f10x_hd.d

    │   ├── startup_stm32f10x_hd.o

    │   ├── stm32f10x_adc.crf

    │   ├── stm32f10x_adc.d

    │   ├── stm32f10x_adc.o

    │   ├── stm32f10x_dma.crf

    │   ├── stm32f10x_dma.d

    │   ├── stm32f10x_dma.o

    │   ├── stm32f10x_gpio.crf

    │   ├── stm32f10x_gpio.d

    │   ├── stm32f10x_gpio.o

    │   ├── stm32f10x_i2c.crf

    │   ├── stm32f10x_i2c.d

    │   ├── stm32f10x_i2c.o

    │   ├── stm32f10x_it.crf

    │   ├── stm32f10x_it.d

    │   ├── stm32f10x_it.o

    │   ├── stm32f10x_iwdg.crf

    │   ├── stm32f10x_iwdg.d

    │   ├── stm32f10x_iwdg.o

    │   ├── stm32f10x_rcc.crf

    │   ├── stm32f10x_rcc.d

    │   ├── stm32f10x_rcc.o

    │   ├── stm32f10x_tim.crf

    │   ├── stm32f10x_tim.d

    │   ├── stm32f10x_tim.o

    │   ├── stm32f10x_usart.crf

    │   ├── stm32f10x_usart.d

    │   ├── stm32f10x_usart.o

    │   ├── system_stm32f10x.crf

    │   ├── system_stm32f10x.d

    │   ├── system_stm32f10x.o

    │   ├── uart1.crf

    │   ├── uart1.d

    │   ├── uart1.o

    │   └── vrunst_Target 1.dep

    ├── Project

    │   ├── DebugConfig

    │   │   ├── Target_1_STM32F103RC.dbgconf

    │   │   ├── Target_1_STM32F103ZE.dbgconf

    │   │   └── Target_1_STM32F103ZE_1.0.0.dbgconf

    │   ├── JLinkSettings.ini

    │   ├── Listings

    │   │   ├── fourWheel.map

    │   │   └── startup_stm32f10x_hd.lst

    │   ├── readme.txt

    │   ├── vrunst.uvguix.Administrator

    │   ├── vrunst.uvguix.WXD

    │   ├── vrunst.uvguix.jian

    │   ├── vrunst.uvoptx

    │   └── vrunst.uvprojx

    └── User

    ├── eMPL

    │   ├── dmpKey.h

    │   ├── dmpmap.h

    │   ├── inv_mpu.c

    │   ├── inv_mpu.h

    │   ├── inv_mpu_dmp_motion_driver.c

    │   └── inv_mpu_dmp_motion_driver.h

    ├── iic_analog.c

    ├── iic_analog.h

    ├── main.c

    ├── mpu6050.c

    ├── mpu6050.h

    ├── sch.c

    ├── sch.h

    ├── stm32f10x.h

    ├── stm32f10x_conf.h

    ├── stm32f10x_it.c

    ├── stm32f10x_it.h

    ├── system.h

    ├── system_stm32f10x.c

    └── system_stm32f10x.h

    13 directories, 190 files

    展开全文
  • STM32矩阵键盘扫描及处理

    千次阅读 多人点赞 2020-10-04 11:04:48
    STM32矩阵键盘扫描及处理 前言 由于最近帮做一个毕业设计需要用到直接输入目标值去控制输出,所以才写这么一个按键处理的程序。对于一个才接触单片机没多久的大学生菜鸟来说,实现毕设里的每一项功能都有一定的...

    STM32的矩阵键盘扫描及处理

    前言

    由于最近帮做一个毕业设计需要用到直接输入目标值去控制输出,所以才写这么一个按键处理的程序。对于一个才接触单片机没多久的大学生菜鸟来说,实现毕设里的每一项功能都有一定的挑战。接下来就分享一下我在写这按键扫描及处理中的一些经验吧。
    整个工程所需要的输出值可通过键盘任意控制,有一位小数。

    一、按键扫描

    1.矩阵按键的原理图

    矩阵键盘原理图示意图,具体键值根据自己需求设置

    这里只是键盘示意图,具体键值需根据自己需求设置

    2、按键扫描代码

    总体思路:先设置两个初始化函数,KeyPad_Init1()是高四位初始化为下拉输入、低四位为上拉输入(相当于就是给高四位低电平,低四位为高电平);KeyPad_Init2()是高四位初始化为上拉输入、低四位为下拉输入(相当于就是给高四位高电平,低四位为高电平)。程序首先使用KeyPad_Init1(),如果读取低8位引脚不是0x0f,就说明有按键被按下,然后短暂延时消抖后再次检测到低8位引脚不是0x0f,就储存高四位的的值然后进行初始化KeyPad_Init2(),然后又读取低8位引脚不是0x0f,储存其中的低四位的值,然后将高低四位值加起来就对应了一个键值。
    在这段扫描程序里面,由于扫描出的键值后面还需要处理,所以只有当有键按下后才返回才是有效的键值,没有按键按下就返回的是个无效值-1,目的是为了对每一次按键按下值进行处理,没有按下就不去处理。

    //函数名:扫描函数
    //返回值:有效键值或-1
    //功能:矩阵按键扫描,返回一个值
    short KeyPad_Scan(void)
    {
    	short num = -1; //保持按键值返回
    	
    	u16 readvalue = 0;
    	u16 re=0;
    	u16 re1=0;
    	u16 re2=0;
    	KeyPad_Init1();					//低4位引脚上拉输入,高4位引脚下拉输入
    	readvalue = GPIO_ReadInputData(GPIOA);	//读GPIOA引脚电平
    	readvalue &= 0x00ff;				//保留低8位的值(PA7-PA0)
    	if(readvalue != 0x000f) 				//高4位引脚有一个被按下
    	{
    		delay_ms(10);//消抖10ms
    		readvalue = GPIO_ReadInputData(GPIOA);	//读GPIOA引脚电平
    		if(readvalue != 0x000f)
    		{
    			re1 = GPIO_ReadInputData(GPIOA);	//再次读取状态
    			re1 &= 0x00f0;  				//保留PA4-PA7的值
    
    			KeyPad_Init2();  				//低4位引脚下拉输入,高4位引脚上拉输入
    			delay_ms(50);//经我测试,这里延迟50ms反应最快而很少出现不反应的状况
    			re2 = GPIO_ReadInputData(GPIOA);	//再次读取状态
    			re2 &= 0x000f;				//保留PA0-PA3的值
    			
    			re=re1|re2;					//相与,就知道哪一行哪一列被按下啦
    			
    			switch(re)
    			{
    			case 0x0011: num = 12;break;  
    			case 0x0012: num = 8;break;  
    			case 0x0014: num = 4;break; 
    			case 0x0018: num = 0;break;  
    			case 0x0021: num = 13;break;  
    			case 0x0022: num = 9;break; 
    			case 0x0024: num = 5;break;  
    			case 0x0028: num = 1;break;  
    			case 0x0041: num = 14;break;  
    			case 0x0042: num = 10;break;  
    			case 0x0044: num = 6;break;  
    			case 0x0048: num = 2;break;  
    			case 0x0081: num = 15;break;  
    			case 0x0082: num = 11;break;  
    			case 0x0084: num = 7;break;  
    			case 0x0088: num = 3;break;  
    			}
    			return num;
    		}
    	}
    	return -1;
    }
    
    

    二、键值处理

    1、键值处理代码

    在这段程序中我要的是按下【确定】键按下后返回确定键按下前所输入的键值(0-99.9),返回更高的值也行,不过小数点后面只能有一位数。

    /****************
    //按键值处理函数,返回最后需要的目标值,
    返回-1,按键没有按下
    返回-2或0,有按键按下,无效可适当延时
    返回其他,键值处理后的值
    *******************/
    float Key_value_processing(void)		
    {
    	
    	float key=0.0;	
    	int key_flag = -1;
    	static int key2 = 0;		//按键扫描返回值暂存处		
    	static u8		key1 = 0;
    
    	static int		Point_flag=0;		//判断‘.’是否按下标志,(Point_flag=2表示按下,Point_flag=1表示按下后进行了一次小数后一位赋值)
    	static int		key1_temp = 0;				//缓存key1值
    	
    
    				key_flag=KEYPAD_Scan();		//
    		 
    		 if(-1 == key_flag)			//如果按键没有按下
    			{
    			 return -1;
    			}
    		 else if(0 <= key_flag && key_flag <= 9)		//返回数字键,根据小数点是否按下,对数字进行
    			{
    					key1 = key_flag+key1*10;	//如有多位值,进行累加
    					key1_temp = key1;		
    				if(2 == Point_flag)
    				{
    					printf("xiaoshudianhou:%d \r\n",key1);
    					OLED_ShowNum(103,16,key1,1,16);
    					OLED_Refresh();
    					Point_flag	=	1;
    				}
    				else if(1 == Point_flag)		//点按下
    				{
    					key1=key_flag;
    				}
    				else
    				{
    					printf("shuqian:%d \r\n",key1);
    					OLED_ShowNum(63,16,key1,2,16);
    					OLED_Refresh();
    				}
    				return -2;
    			}
    			/***无效按键**/	
    			else if(10 <= key_flag && key_flag <= 13)		//暂时没有用的值,不处理
    			{
    				printf("无效值::%d \r\n",key_flag);
    				return -2;
    			}
    		 else if(Point == key_flag)		//
    			{
    			 key2 = key1_temp;
    			 Point_flag=2;
    			 key1=0;
    			 printf("float-----\r\n");
    			 OLED_ShowString(83,16,":",16); 
    				OLED_Refresh();
    				return -2;
    			}
    		 else if(Sure == key_flag)		//确定键按下后,返回处理好的值
    			{
    				if(1==Point_flag)
    				{
    					key = key2 + (float)key1/10.0;
    					Point_flag=0;
    				}
    			 else 
    			 {
    				 key=key1;
    			 }
    			 printf(":%f \r\n",key);
    			 key_flag = -1,key1 = 0,key2 = 0;
    			 return key;
    			}	
    			return -1;
    }	
    
    

    三、总结

    学习这个专业来第一次对自己所学的知识进行总结,虽然是一个做完后看起来很简单的一个知识点,在键值处理的过程中还是遇到了很多的问题。多亏了学长的帮忙才算比较轻松的完成了。这其中发现了自己以前很多的盲点,比如对于数据类型把握得不是很清楚,还有就是if else语句与if if语句的使用,在这之前写有关单片机的代码都是只用if语句,没考虑到当有多个条件时可以用if else语句可以有更快地执行效率。

    展开全文
  • STM32程序4_4矩阵键盘哈哈哈.zip
  • 基于STM32的按键扫描测试程序(学习记录): 目录: 源码; 4x4按键原理; Tips: 粘贴代码时,粘贴在源文件存放的位置中(如:HARDWARE中的.c和.h文件),用C++编译器打开,而不是kei;最后keil会正常显示中文...
  • 将51单片机的矩阵键盘程序移植到stm32F4系列板子上,学习轮询并减少IO口的使用。在硬件上,通过4*4矩阵键盘控制1位数码管的显示。软件上,通过串口调试助手观察4*4键盘的输出

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

stm32矩阵键盘程序