精华内容
下载资源
问答
  • 基于STM32的按键扫描测试程序(学习记录): 目录: 源码; 4x4按键原理; Tips: 粘贴代码时,粘贴在源文件存放的位置中(如:HARDWARE中的.c和.h文件),用C++编译器打开,而不是kei;最后keil会正常显示中文...

    基于STM32的按键扫描测试程序(学习记录):

    目录:

    1. 源码;
    2. 4x4按键原理;
    3. 按键扫描逻辑;

    Tips:

    1. 粘贴代码时,粘贴在源文件存放的位置中(如:HARDWARE中的.c和.h文件),用C++编译器打开,而不是kei;最后keil会正常显示中文字符;
    2. 程序使用嵌套循环实现4x4按键扫描,如果IO口设置过乱时,将循环拆分即可;

    key4x4.h源文件

    #ifndef __KEY4x4_H
    #define __KEY4x4_H	 
    #include "sys.h"
     
    #define KEY_X(X)	PEin(X)				// 尽量避免使用PD以上GPIO,便于移植;
    #define KEY_Y(Y)	PEout(Y)
    
    #define ALL_DOWN_KEY_Y	{	KEY_Y(11) = 0; KEY_Y(12) = 0; KEY_Y(13) = 0; KEY_Y(14) = 0;}
     
    void KEY4x4_Init(void);		// IO口初始化
    u8 KEY4x4_Scan(void);  		// 矩阵按键反馈函数	// 可配置任意矩阵按键使用!!
    u8 KEY16_Scan(void);
    
    /**************
    按键扫描方案二:
    按键使用8个输入IO口, 且所有IO口一端接VCC/VSS;
    
    程序框架:	
    	扫描检测哪两个IO口输入高/低电平;VCC/VSS
    	根据对应坐标,return对应编号;
    **************/
    
    #endif
    

    key4x4.c源文件

    #include "stm32f10x.h"
    #include "key4x4.h"
    #include "sys.h" 
    #include "delay.h"
    #include "usart.h"
    
    
    /*************************
    X:
    	PEin	7-10
    Y:
    	PEout	11-14
    *************************/
    
    
    // 矩阵按键初始化函数
    void KEY4x4_Init(void)
    {
    		GPIO_InitTypeDef GPIO_InitStructure;
    
    		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE,ENABLE);
    
    		GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;//KEY0-KEY1
    		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //设置成下拉输入
    		GPIO_Init(GPIOE, &GPIO_InitStructure);//初始化GPIOE
    
    		GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14;				 //LED0-->PB.5 端口配置
    		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
    		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 //IO口速度为50MHz
    		GPIO_Init(GPIOE, &GPIO_InitStructure);					 		//根据设定参数初始化GPIOE
    }
    
    // 使所有输出拉低;初始化;		// 可以使用define宏定义,执行速度更快,不用跳转函数!!
    static void KEY_ALL_Pull_Down(void)
    {
    	KEY_Y(11) = 0;
    	KEY_Y(12) = 0;
    	KEY_Y(13) = 0;
    	KEY_Y(14) = 0;
    }
    
    // 4x4按键扫描函数
    // 使用一个嵌套循环,完成扫描X和Y;
    // 原理: 通过Y 依次输出高电平,
    //				扫描X 那个IO口输入高电平;
    // X轴:输入检查、扫描;
    // Y轴:设置输出状态;
    // 该函数适合任意排列矩阵按键,只需修改循环中对应编号!!
    // 注意: 1. 改变IO口时,该函数还需要改变循环中IO口编号;(可以定义好IO口编号,便于修改)
    //				2. 该函数同样有优先级问题! 即同时按下时,只反馈先被扫描到的(0-15标号最小的)
    //				3. 函数同一坐标轴的IO口编号必须相邻或能有 规律递增可寻;(否则无法用循环判断)
    //				4. 暂时未添加功能(模式):	按键复用 和 长按;
    // 2020-11-13		返回值调整为:1-16
    // 11/14 不支持连按;解决重复反馈的问题;
    u8 KEY4x4_Scan(void)
    {
    	int i,j;
    	u8 IO_Sign = 0;				// 很简便的一个IO反馈方式标签!!!  且嵌套循环特有!!  // 能返回0-15,适合任意排列矩阵按键
    	static key_up = 1;
    	
    	//KEY_ALL_Pull_Down();										// 初始化所有按键输出拉低;
    	
    	for (i = 11; i <= 14; i++)							// Y输出IO口编号;
    		for (j = 7; j <= 10; j++,IO_Sign++)		// X输出IO口编号;  // 递增IO_Sign,反馈对应值(0-15);
    		{
    			KEY_Y(i) = 1;			// 使PEout(i)输出高电平;
    			
    			if (KEY_Y(i))			// 扫描Y输出高电平, 可以取消此判断; 因为必须输出高电平时,才能正常判断!!
    			{
    				if (KEY_X(j) && key_up)		// 当输入检查到高电平时;
    				{
    					key_up = 0;
    					printf("按键扫描反馈: %d  \r\n",IO_Sign);
    					return IO_Sign;
    				}
    				else if (!KEY_X(7)&&!KEY_X(8)&&!KEY_X(9)&&!KEY_X(10))			// 当所有输入检测到低电平时,再次使能按键; 防止重复反馈
    				{
    					key_up = 1;
    					KEY_ALL_Pull_Down();										// 初始化所有按键输出拉低(低电平);必须在此位置;
    				}
    			}
    			else
    				printf("PEout:IO口%d输出异常!  \r\n ", i);
    		}
    		
    	delay_ms(10);					// 按键防抖;
    }
    
    
    /******************************************标准扫描函数*********************************************/
    // 支持连按
    u8 KEY16_Scan(void)
    {
    	int i,j;
    	u8 IO_Sign = 0;				// 很简便的一个IO反馈方式标签!!!  且嵌套循环特有!!  // 能返回0-15,适合任意排列矩阵按键
    	
    	ALL_DOWN_KEY_Y													// 初始化所有按键输出拉低;
    	
    	for (i = 11; i <= 14; i++)							// Y输出IO口编号;
    		for (j = 7; j <= 10; j++,IO_Sign++)		// X输出IO口编号;  // 递增IO_Sign,反馈对应值(0-15);
    		{
    			KEY_Y(i) = 1;			// 使PEout(i)输出高电平;
    
    			if (KEY_X(j))			// 当输入检查到高电平时;
    				return IO_Sign;
    		}
    		
    	delay_ms(20);					// 按键防抖;		// 连按延时;
    }
    
    

    *4x4按键原理图
    在这里插入图片描述

    1. 按键工作原理:
      当按键被按下时,相连的电路导通;即S1按下时,位于0行0列的线短路,使标号4和5对应的IO口相连(导通);
      最后通过扫描检测输入输出状态即可判断出对应按键被按下;

    2. 程序设计思路:
      程序通过依次使标号1、2、3、4(列0-3)输出高电平,判断5/6/7/8(行0-3)状态;完成按键扫描;

    展开全文
  • 一个基于stm32f103zet6的矩阵键盘程序,stm32接上矩阵键盘即可使用。
  • STM32F103C8T6配套程序源码-矩阵键盘
  • 基于STM32F103矩阵键盘代码,引脚可根据您的需求和爱好随意定义,无论连不连续都可以!引脚信息已经在key4_4.c中宏定义好了,只需要在宏定义中修改你定义的引脚时钟、引脚号和引脚对应的端口即可!非常方便。可...
  • stm32F103状态机矩阵键盘

    千次阅读 2015-12-08 08:06:48
    矩阵键盘程序,作为麦知club小车项目的一部分,从IAR状态机应用修改而来。 IAR7.4+STM32CUBEMX调试通过。 键盘行4,列3,每条线都有10K上拉电阻。改到4×4矩阵也很容易。 行线设置为 输入,针脚为浮空; 列线设置...

    矩阵键盘程序,作为麦知club小车项目的一部分,从IAR状态机应用修改而来。

    IAR7.4+STM32CUBEMX调试通过。

    键盘行4,列3,每条线都有10K上拉电阻。改到4×4矩阵也很容易。

    行线设置为 输入,针脚为浮空; 列线设置为开漏输出。


    不支持长按和组合键,主要是我不会改。

    在OS中使用20ms任务周期调用。


    以下贴出代码。

    keypad.h

    /*
    *
    * Name: keypad.h
    */
    #ifndef KEYPAD_H
    #define KEYPAD_H
    
    #include "stm32f1xx_hal.h"
    #include "pinname.h"
    
    #define PORT_KEY GPIOD
    #define COLS (GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6)
    
    // 读pin
    //#define In(GPIO_Pin) (PORT_KEY->IDR & GPIO_Pin)
    #define In(GPIO_Pin) HAL_GPIO_ReadPin(PORT_KEY, GPIO_Pin)
    // 写1到Pin
    //#define High(GPIO_Pin) PORT_KEY->BSRR = GPIO_Pin
    #define High(GPIO_Pin) HAL_GPIO_WritePin(PORT_KEY, GPIO_Pin, GPIO_PIN_SET)
    // 写0到Pin
    //#define Low(GPIO_Pin) PORT_KEY->BSRR = (uint32_t)GPIO_Pin << 16 
    #define Low(GPIO_Pin) HAL_GPIO_WritePin(PORT_KEY, GPIO_Pin, GPIO_PIN_RESET)
    
    /* 
    *  0  1  2   3
    *  4  5  6   7
    *  8  9  10  11
    *  12 13 14  15
    */
    
    typedef enum {
        Key_Up = 0x02,
        Key_Left = 0x03,
        Key_Right = 0x04,
        Key_Down = 0x08,
        Key_On =  0x09,
        Key_Mode = 0x0a,
        Key_None = 0xFF
    } KeyPressed;
    	
    static const int row_count = 4;
    static const int col_count = 3;
    
    uint16_t bus_out(void);
    
    void Keypad(void);
    char AnyKey(void);
    char SameKey(void);
    char ScanKey(void);
    void FindKey(void);
    void ClearKey(void);
    void Read(void);
    /** Start the keypad interrupt routines */
    void Start(void);
    /** Stop the keypad interrupt routines */
    void Stop(void);
    void Cols_out(uint16_t v);
    void Scan_Keyboard(void);
    KeyPressed getKey(void);
    #endif // KEYPAD_H
    

    keypad.c

    /*
    *
    * Name: keypad.cpp
    *
    */
    
    #include "keypad.h"
    
    // State:
    char KeyState;
    // Bit pattern after each scan:
    char KeyCode;
    // Output value from the virtual 74HC922:
    KeyPressed KeyValue;
    // KeyDown is set if key is down:
    char KeyDown;
    // KeyNew is set every time a new key is down:
    char KeyNew;
    // 映射表
    char KeyTable[12][2];  
    // Pin of Row
    uint16_t _rows[] = {KEYx0, KEYx1, KEYx2, KEYx3};
    uint16_t _cols[] = {KEYy0, KEYy1, KEYy2};
    
    //构造函数
    void Keypad(void)
    {
         
       Stop();   
       KeyState = 0; // 按键状态初始 0
    }
    
    
    //扫描键盘
    void Scan_Keyboard(void){
    switch (KeyState) {
      case 0: {
      if (AnyKey()) {    
        char scankey = ScanKey();
        if (scankey != 0xff)
            KeyCode = scankey;
        
        KeyState = 1;
      }
      
      break;
      }
      case 1: {
      if (SameKey()) {
        FindKey();
        KeyState = 2;  
      }
      else 
        KeyState = 0;
      
      break;
      }
      case 2: {
        if (SameKey()) {
        }
        else 
          KeyState = 3;
        
        break;
        }
      case 3: {
        if (SameKey()) {
          KeyState = 2;
        }
        else {
          ClearKey();
          KeyState = 0;
        }
        
        break;
       }
      }
    // func end
    }
    
    // 有键按下
    char AnyKey(void) {
     //Start();  //拉低
     
     int r = -1;
     for (r = 0; r < row_count; r++) {
         if (In(_rows[r]) == 0)  // In macro
             break;	 
     }
     
     //Stop();  //恢复
     
     if (!(0 <= r && r < row_count))
        return 0;
     else
        return 1;
    }
    
    // 键按下, 键值相同
    char SameKey(void) {
      
      // char KeyCode_new = KeyCode;
      char KeyCode_new = ScanKey();
      if (KeyCode == KeyCode_new)  
        return 1;
      else
        return 0;
    }
    
    // 扫描键
    char ScanKey(void) {
    
     /* 行扫描 */
        int r = -1;
        for (r = 0; r < row_count; r++) {
            if (In(_rows[r]) == 0)  // In macro
                break;
        }
    
        /* 若没有找到有效行,返回 */
        if (!(0 <= r && r < row_count)) {
          return 0xff;
            
        }
    
        /* 列扫描,找出行上哪个被拉低 */
        int c = -1;
        for (c = 0; c < col_count; c++) {
            // 轮流输出列线
            Cols_out(~(1 << c));
            
            if (In(_rows[r]) == 0)  // In macro
                break;
        }
    
        /* 给所有的列重新充电 */
        Start();
    
        /* 若没有找到有效列,返回 */
        if (!(0 <= c && c < col_count))
            return 0xff;
    
        return r * col_count + c;
     
    }
    
    // FindKey compares KeyCode to values in KeyTable.
    // If match, KeyValue, KeyDown and KeyNew are updated.
    void FindKey(void) {
     KeyValue = (KeyPressed)KeyCode;
     KeyDown = 1;
     KeyNew = 1;
    }
    
    
    void ClearKey(void) {
     KeyDown = 0;
    }
    
    KeyPressed getKey(void) {
      if(KeyNew)
      {
        KeyNew = 0;
        return KeyValue;
      }
      else
        return Key_None;
    }
    
    void Start(void)
    {
        /* 列输出0, 拉低行 */
        PORT_KEY->BRR = COLS;
    }
    
    void Stop(void)
    {
        /* 列输出1,使行不被拉低 */
        PORT_KEY->BSRR = COLS;
    }
    
    // cols bus output
    void Cols_out(uint16_t v)
    {
      if ((v & 0x01) > 0) //0b001
        High(_cols[0]);
      else
        Low(_cols[0]);
      
      if ((v & 0x02) > 0) //0b010
        High(_cols[1]);
      else
        Low(_cols[1]);
      
      if ((v & 0x04) > 0) //0b100
        High(_cols[2]);
      else
        Low(_cols[2]);
                                               
    }


    按键操作可以改到寄存器操作,提高速度。

    使用mbed写,会更省事,可惜VBT6的RAM太少。

    展开全文
  • 程序已经过测验通过,使用扫描法完成了矩阵键盘的设计,每一句基本都有注释,工程文件齐全,测试方便,使用的是神州I号 STM32F103RBT6
  • stm32f103vet6外部中断来获取矩阵键盘键值外加可精确到小数点后6位计算器源程序
  • 上一篇说完了STM32库开发的引脚输出控制,这一篇对其引脚输入控制方法进行说明,引脚设置为输入功能时能够感知引脚上的电平高低,具有模拟输入复用功能的引脚还可以结合芯片内部的A/D准确测量其电平值,后续在ADC...
  • 该文件为基于STM32F103C8T6的简易计算器设计,外接设备为行列式矩阵键盘与LCD12864,采用串行方式接口,能实现简单的加减乘除,LCD中英显示均无问题。程序里面的所用引脚有详细定义,可根据自己的实际情况适当修改。
  • 一 设计任务目标和要求 ...4、矩阵键盘 按下按键,显示对应的键值 二 设计方案的论证与选择 原理框图 三 系统硬件电路设计 四 系统软件设计 (说明:1.画出各模块程序设计流程图;2.画出主程序流程图;3.画出仿

    一 设计任务目标和要求

    任务名称 现象
    1、流水灯 依次点亮8个LED灯后,再逆向依次点亮,每次点亮间隔0.5s
    2、数码管静态显示 数码管静态显示,依次实现90计数、09计数、偶数计数,即 0->2->4…->8
    3、数码管动态显示 数码管动态显示数字:12
    4、矩阵键盘 按下按键,显示对应的键值

    二 设计方案的论证与选择

    原理框图
    在这里插入图片描述

    三 系统硬件电路设计
    在这里插入图片描述

    矩阵键盘

    四 系统软件设计
    (说明:1.画出各模块程序设计流程图;2.画出主程序流程图;3.画出仿真电路并仿真)

    无仿真
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    五 软硬件联调
    (说明:说说具体调试步骤、出现的问题及解决方法)
    调试步骤:

    问题 解决办法
    1、数码管动态显示不稳定 ①、检查硬件连接是否稳定 ②、若硬件连接没问题,就检查程序,可通过更改数码管或矩阵键盘函数中的延时函数参数调节动态显示的效果
    2、开发板上的排针虚焊、IO口被占用 ①、拿电烙铁再次焊接好;②、写程序时,避免使用该IO端口

    由于所使用的开发板部分IO口被占用,所以程序中使用的IO口参差不齐,使用者应注意

    代码

    最后:如有错误,请各位哥哥姐姐纠正,不胜感激!

    展开全文
  • 可直接用的4x4和4x3薄膜矩阵面板stm32f103控制实例,横列和竖列引脚请对照程序进行连接,也可自行更改引脚。
  • 矩阵键盘STM32程序

    2018-07-06 15:54:39
    基于STM32F103单片机的矩阵键盘源代码 是电设竞赛的时候用到的
  • STM32矩阵键盘代码

    2016-12-16 08:43:17
    程序STM32F103系列的矩阵键盘代码,本人使用过
  • 该文件为基于STM32F103C8T6的简易计算器设计,外接设备为行列式矩阵键盘与LCD12864,采用串行方式接口,能实现简单的加减乘除,LCD中英显示均无问题。程序里面的所用引脚有详细定义,可根据自己的实际情况适当修改。
  • 该文件为基于STM32F103C8T6的简易计算器设计,外接设备为行列式矩阵键盘与LCD12864,采用串行方式接口,能实现简单的加减乘除,LCD中英显示均无问题。程序里面的所用引脚有详细定义,可根据自己的实际情况适当修改。
  • 本设计选用属于STM32系列的STM32F103C8T6单片机作为控制电路的核心部件,矩阵键盘用于输入数字密码和进行各种功能的实现。由用户通过连接单片机的矩阵键盘输入密码,后经过单片机对用户输入的密码与自己保存的密码...

    硬件电路的设计

    (末尾附文件)

    方案框图
    在这里插入图片描述
    原理图:
    本设计选用属于STM32系列的STM32F103C8T6单片机作为控制电路的核心部件,矩阵键盘用于输入数字密码和进行各种功能的实现。由用户通过连接单片机的矩阵键盘输入密码,后经过单片机对用户输入的密码与自己保存的密码进行对比从而判断密码是否正确,然后控制引脚的高低电平传到开锁电路或者报警电路控制开锁还是报警,实际使用时只要将单片机的负载由继电器换成电子密码锁的电磁铁吸合线圈即可。

    各模块功能如下:
    1)键盘输入模块:分为密码输入按键与几个功能按键,用于完成密码锁输入功能。
    2)显示模块:用于完成对系统状态显示及操作提示功能。
    3)报警模块:用于完成输错密码多次时的警报功能。
    4)开锁模块:应用继电器及发光二极管模拟开锁,完成开锁及开锁提示。

    本系统外围电路包括矩阵键盘输入电路、复位电路、LCD显示电路、报警电路、开锁电路,根据实际情况键盘输入部分选择4×4矩阵键盘,显示部分选择字符型液晶显示LCD1602。

    按键输入模块
    由于本设计所用到的按键数量较多而不适合用独立按键式键盘。采用的是矩阵式按键键盘,它由行和列组成,也称行列式键盘,按键位于行列的交叉点上,密码锁的密码由键盘输入完成,与独立式按键键盘相比,要节省很多I/O口。本设计中使用的这个4×4键盘不但能完成密码的输入还能作特别功能键使用。键盘的每个按键功能在程序设计中设置

    在这里插入图片描述
    LCD 显示模块
    显示部分由液晶显示器LCD1602取代普通的数码管完成。开锁时,按下键盘上的开锁按键后,利用键盘上的数字键0-9输入密码,每按下一个数字键后在显示器上显示一个*,输入多少位就显示多少个*。当密码输入完成时,按下确认键,如果输入的密码正确的话, LCD显示“DOOR OPEN”,单片机其中P2.0引脚会输出低电平,使三极管T2导通,电磁铁吸合,继电器开关跳转,电子密码锁被打开,如果密码不正确,LCD显示屏会显示“CODE WRONG”,P2.0输出的是高电平,电子密码锁不能打开。通过LCD显示屏,可以清楚地判断出密码锁所处的状态。
    在这里插入图片描述
    报警模块
    报警部分由陶瓷压电发声装置及外围电路组成,加电后不发声,当有键按下时,“叮”声,每按一下,发声一次,密码正确时,响两声并开锁,当密码输入错误时,单片机的PC13引脚为高电平,三极管T3导通蜂鸣器发出噪声报警。如图2.4所示。

    在这里插入图片描述
    开锁模块
    开锁控制电路的功能是当输入正确的密码后将锁打开。系统使用单片机其中一引脚线发出信号,经三极管放大后,由继电器驱动电磁阀动作将锁打开。用户通过键盘任意设置密码,并储存在FLASH中作为锁码指令。开锁步骤如下:利用键盘上的数字键0-9输入密码,最后按下确认键。当用户输入密码后,单片机自动识别密码,如果密码不符,则报警。只有当密码正确,单片机才能使继电器处于开锁状态
    在这里插入图片描述

    软件设计

    在这里插入图片描述

    #include "stm32f10x.h"
    #include "stm32f10x_gpio.h"
    #include "sys.h"
    #include "delay.h"
    #include "lcd.h"
    #include "led.h"
    #include "usart.h"
    #include "dht11.h"
    #include "key.h"
    #include "beep.h"
    #include <stdio.h>
    #include "stmflash.h"
    #include "timer.h"
    #include "exit.h"
    #define ADDR_hum_up_1  0X0800b000
    #define ADDR_hum_up_2  0X0800c000
    int key=0;
    int j=0;
    u8 k1_flag=1;
    u8 k2_flag=1;
    u8 k3_flag=1;
    u8 k4_flag=1;
    int setpass_flag11=1;//标识正在设置密码,继电器不关闭
    int err3_flag=1;
    int i=0;
    int djtime_flag=360;
    int down_flag=0;
    static u8 key_up=1;//不支持连按
    u8 open_flag=1;//用于标识是否是系统的第一次打开
    
    u8 pass_shuru=0;
    
    u8 setpassword_flag=0;
    u8 setopen_flag=1;//用于标识开机之后是否打开过
    u8 setpass_flag=0;//当密码设置成功之后的标志位
    u8 err_flag=0;//输出错误次数记录标志位
    u8 errtime_flag=0;//用于错误之后延时并重置屏幕的标志位
    u8 beep_flag=1;//用于标识当按键按下,蜂鸣器滴一声的时间
    u8 password[]={9,9,9,9,9,9};;//记录输入的密码
    u8 setpassword1[6]={1,1,1,1,1,1};//设置密码的存放位置
    u8 setpassword2[6];//设置密码的存放位置
    
    static u8 ok_flag=0;//记录每次判断密码有几位正确
    u8 flag16=1;//标志按键16是第几次按下,做相应的动作
    
    u8 cspassword[]={0,0,0,0,0,0};
    u8 cjpassword[]={1,3,1,4,2,0};
    
    u8 table0[]="===Coded Lock===";
    u8 table1[]="password:       ";
    u8 table2[]="      open      ";
    u8 table3[]="      error     ";
    u8 table4[]="SetNewWordEnable";
    u8 table5[]="input again     ";
    u8 table6[]="ResetPassword OK";
    u8 flash1[]={0};
    u8 flash2[]={1,0,0,0,0,0};
    
    
    
    
    
    void show1(void)
     {
    	 	LCD1602_Show_dat(0,1,table1[0]);
    		LCD1602_Show_dat(1,1,table1[1]);
    		LCD1602_Show_dat(2,1,table1[2]);
    		LCD1602_Show_dat(3,1,table1[3]);
    		LCD1602_Show_dat(4,1,table1[4]);
    		LCD1602_Show_dat(5,1,table1[5]);
    		LCD1602_Show_dat(6,1,table1[6]);
    		LCD1602_Show_dat(7,1,table1[7]);
    		LCD1602_Show_dat(8,1,table1[8]);
    	 	LCD1602_Show_dat(9,1,table1[9]);
    	  for(j=0;j<i;j++)
    	 {
    		 LCD1602_Write_Dat('*');
    	 }
    	 for(j=0;j<6-i;j++)
    	 {
    		 LCD1602_Write_Dat(' ');
    	 }
    
    
     } 
     void show2(void)
     {
    	 	LCD1602_Show_dat(0,1,table2[0]);
    		LCD1602_Show_dat(1,1,table2[1]);
    		LCD1602_Show_dat(2,1,table2[2]);
    		LCD1602_Show_dat(3,1,table2[3]);
    		LCD1602_Show_dat(4,1,table2[4]);
    		LCD1602_Show_dat(5,1,table2[5]);
    		LCD1602_Show_dat(6,1,table2[6]);
    		LCD1602_Show_dat(7,1,table2[7]);
    		LCD1602_Show_dat(8,1,table2[8]);
    	 	LCD1602_Show_dat(9,1,table2[9]);
    		LCD1602_Show_dat(0xa,1,table2[10]);
    		LCD1602_Show_dat(0xb,1,table2[11]);
    		LCD1602_Show_dat(0xc,1,table2[12]);
    		LCD1602_Show_dat(0xd,1,table2[13]);
    		LCD1602_Show_dat(0xe,1,table2[14]);
    		LCD1602_Show_dat(0xf,1,table2[15]);
     }
      void show3(void)
     {
    	 	LCD1602_Show_dat(0,1,table3[0]);
    		LCD1602_Show_dat(1,1,table3[1]);
    		LCD1602_Show_dat(2,1,table3[2]);
    		LCD1602_Show_dat(3,1,table3[3]);
    		LCD1602_Show_dat(4,1,table3[4]);
    		LCD1602_Show_dat(5,1,table3[5]);
    		LCD1602_Show_dat(6,1,table3[6]);
    		LCD1602_Show_dat(7,1,table3[7]);
    		LCD1602_Show_dat(8,1,table3[8]);
    	 	LCD1602_Show_dat(9,1,table3[9]);
    		LCD1602_Show_dat(0xa,1,table3[10]);
    		LCD1602_Show_dat(0xb,1,table3[11]);
    
    	 	if(err3_flag==1)
    	  {
    			LCD1602_Show_dat(0xc,1,table3[12]);
    			LCD1602_Show_dat(0xd,1,table3[13]);
    		  LCD1602_Show_dat(0xe,1,table3[14]);
    		  LCD1602_Show_dat(0xf,1,table3[15]);
    	  }
    	  else if(err3_flag==2)
    	  {
    			LCD1602_Show_dat(0xc,1,0x30+djtime_flag/2/100);
    			LCD1602_Show_dat(0xd,1,0x30+djtime_flag/2/10%10);
    			LCD1602_Show_dat(0xe,1,0x30+djtime_flag/2%10);
    			LCD1602_Show_dat(0xf,1,'s');
    		}
    
     }
     void show4(void)
     {
    	 	LCD1602_Show_dat(0,1,table4[0]);
    		LCD1602_Show_dat(1,1,table4[1]);
    		LCD1602_Show_dat(2,1,table4[2]);
    		LCD1602_Show_dat(3,1,table4[3]);
    		LCD1602_Show_dat(4,1,table4[4]);
    		LCD1602_Show_dat(5,1,table4[5]);
    		LCD1602_Show_dat(6,1,table4[6]);
    		LCD1602_Show_dat(7,1,table4[7]);
    		LCD1602_Show_dat(8,1,table4[8]);
    	 	LCD1602_Show_dat(9,1,table4[9]);
    		LCD1602_Show_dat(0xa,1,table4[10]);
    		LCD1602_Show_dat(0xb,1,table4[11]);
    		LCD1602_Show_dat(0xc,1,table4[12]);
    		LCD1602_Show_dat(0xd,1,table4[13]);
    		LCD1602_Show_dat(0xe,1,table4[14]);
    		LCD1602_Show_dat(0xf,1,table4[15]);
     }
     void show5(void)
     {
    	 	LCD1602_Show_dat(0,1,table5[0]);
    		LCD1602_Show_dat(1,1,table5[1]);
    		LCD1602_Show_dat(2,1,table5[2]);
    		LCD1602_Show_dat(3,1,table5[3]);
    		LCD1602_Show_dat(4,1,table5[4]);
    		LCD1602_Show_dat(5,1,table5[5]);
    		LCD1602_Show_dat(6,1,table5[6]);
    		LCD1602_Show_dat(7,1,table5[7]);
    		LCD1602_Show_dat(8,1,table5[8]);
    	 	LCD1602_Show_dat(9,1,table5[9]);
    		LCD1602_Show_dat(0xa,1,table5[10]);
    		LCD1602_Show_dat(0xb,1,table5[11]);
    		LCD1602_Show_dat(0xc,1,table5[12]);
    		LCD1602_Show_dat(0xd,1,table5[13]);
    		LCD1602_Show_dat(0xe,1,table5[14]);
    		LCD1602_Show_dat(0xf,1,table5[15]);
     }
     void show6(void)
     {
    	 	LCD1602_Show_dat(0,1,table6[0]);
    		LCD1602_Show_dat(1,1,table6[1]);
    		LCD1602_Show_dat(2,1,table6[2]);
    		LCD1602_Show_dat(3,1,table6[3]);
    		LCD1602_Show_dat(4,1,table6[4]);
    		LCD1602_Show_dat(5,1,table6[5]);
    		LCD1602_Show_dat(6,1,table6[6]);
    		LCD1602_Show_dat(7,1,table6[7]);
    		LCD1602_Show_dat(8,1,table6[8]);
    	 	LCD1602_Show_dat(9,1,table6[9]);
    		LCD1602_Show_dat(0xa,1,table6[10]);
    		LCD1602_Show_dat(0xb,1,table6[11]);
    		LCD1602_Show_dat(0xc,1,table6[12]);
    		LCD1602_Show_dat(0xd,1,table6[13]);
    		LCD1602_Show_dat(0xe,1,table6[14]);
    		LCD1602_Show_dat(0xf,1,table6[15]);
     }
    void mound(void)
    {			
    
    	if(open_flag==1)
    	{
    		
    		show1();
    	}
    	else if(open_flag==2)
    	{
    		show2();
    	}
    	else if(open_flag==3)
    	{
    		show3();
    	}
    	else if(open_flag==4)
    	{
    		show4();
    	}
    	else if(open_flag==5)
    	{
    		show5();
    	}
    	else if(open_flag==6)
    	{
    		show6();
    	}
    
    

    .

    链接:https://pan.baidu.com/s/1G_gcOky-ssHRDY_aH9uRsQ
    提取码:1fnn

    .

    展开全文
  • STM32 矩阵键盘通过串口输出

    千次阅读 2018-05-21 21:18:08
    STM32F103C8T6 4*4矩阵键盘 通过串口输出,可以用来写密码锁程序的思路如下:1、首先需要配置的是矩阵键盘:配置两个函数: KEY44_Init(矩阵键盘初始化)和key44_Scan(扫描并获取值) 。2、其次,设置串口(本文设置...
  • 利用stm32f103vet6外部中断来获取矩阵键盘键值外加可精确到小数点后6位计算器源程序 利用外部中断来获取键值,避免了逐行扫描,减少了cpu的占用。准确的获取键值,运用二维数组来存放键值,让55的矩阵键盘输出键值,...
  • 基于正点原子开发板(芯片为stm32f103ZET6),编写了4*4的矩阵键盘程序,使用PC0--PC7gpio口,压缩包里有矩阵键盘程序,自己做的矩阵键盘(第一次做,不太好看),以及用串口打印的结果。可供学习和参考。若想用...
  • 双通道相位频率幅值可调波形发生器(STM32内置DAC实现)前言器件选型主控信号产生选型波形转换电路显示输入系统组成框图硬件部分电路单极性转双极性软件设计亲测可用,最终效果如下第一次...该项目采用STM32F103RCT6为
  • (寄存器版本)基于STM32F103寄存器版本的矩阵按键,可输入任意多位数(最高可达11位)。后期可自行增加其他功能,方便,程序易改。
  • adc键盘

    2020-04-04 01:08:40
    程序对应的开发板为蓝桥杯嵌入式开发板stm32f103rbt6,为中型mcu。开发板的矩阵键盘采用adc实现,电路图如下 通过测量adc测量电压从而得出按键位置。这里给出一个各按键对应的电压值和转换值的表[转换值=4095*...
  • H——STM32F103RB主芯片。 I——两位按键,触发低电平。 J——ISP下载电路,可以通过串口下载程序。 K——JTAG/SWD下载调试电路 L——上电电源指示灯。 M——miniUSB接口,同时可以为核心板供电。 N——5V-3.3V电路...
  • 门禁系统代码.zip

    2019-07-26 10:21:33
    工程中以STM32F103C8T6为核心主控,实现一个多方式解锁的门禁系统,以驱动舵机转动做为开锁标志,OLED显示指纹模块的相关操作选项(如增加,删除指纹等)。可移植性较好,注释多。包含一张程序流程图供参考使用。

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

stm32f103矩阵键盘程序