STM32 4x4矩阵键盘

可同时识别两个键值，并分别显示，用了自己的12864显示，有些注释的地方有乱码请忽略。基于STM32f103vct6.

主函数：

#include "Rect_key.h"
#include "12864.h"
int main()
{
    u16 keynum=0;
    delay_init();
    lcd_gpio_init();
    lcd_init();
    Rect_key_Init();
    lcd_6x8(0,0,"STM32 4x4 KEY Test :");
    while(1)
    {
        keynum=Read_one_key_value();
        lcd_6x8_num(50,2,keynum);
        Read_more_key_value();
    }
}

12864显示函数：

#ifndef _12864_H
#define _12864_H
#include "sys.h"
#include "delay.h"
#define rs PBout(0)
#define reset PBout(1)
#define cs PBout(2)
#define d6 PBout(6)
#define d7 PBout(7)
extern void lcd_gpio_init(void);
extern void lcd_init(void);
extern void lcd_clear(void);
extern void lcd_clear_y(u8 y);
extern void wr_cmd(u8 data1);
extern void wr_data(u8 data1);
extern void lcd_pos(u8 x,u8 y);
extern void lcd_6x8(u8 x, u8 y,u8 ch[]);
extern void lcd_6x8_num(u8 x,u8 y,u16 num);

#endif
#include "12864.h"
const u8 F6X8[][6]=
{    

    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // sp
    { 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 },   // !
    { 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
    { 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
    { 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
    { 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 },   // %
    { 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 },   // &
    { 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 },   // ‘
    { 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
    { 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
    { 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
    { 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
    { 0x00, 0x00, 0x00, 0xA0, 0x60, 0x00 },   // ,
    { 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 },   // -
    { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
    { 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
    { 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
    { 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
    { 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
    { 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
    { 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
    { 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
    { 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
    { 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
    { 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
    { 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
    { 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
    { 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
    { 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
    { 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
    { 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
    { 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
    { 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
    { 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C },   // A
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
    { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
    { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
    { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
    { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
    { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
    { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
    { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
    { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
    { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
    { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
    { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
    { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
    { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
    { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
    { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
    { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
    { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
    { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
    { 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
    { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
    { 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // 55
    { 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
    { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
    { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
    { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 },   // ‘
    { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
    { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
    { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
    { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
    { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
    { 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C },   // g
    { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
    { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
    { 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 },   // j
    { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
    { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
    { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
    { 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 },   // p
    { 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC },   // q
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
    { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
    { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
    { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
    { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
    { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
    { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
    { 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C },   // y
    { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 },   // z
    { 0x14, 0x14, 0x14, 0x14, 0x14, 0x14 }    // horiz lines
};

void lcd_gpio_init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);     

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_6|GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;          //ÍÆÍìÊä³ö
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    //GPIO_ResetBits(GPIOB,GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);
}
void wr_cmd(u8 data1)
{
    u8 i;
    cs=0;
    rs=0;                   //Ö¸ÁîÐźÅ
    for(i=0;i<8;i++)
    {
        if((data1<<i)&0x80)
            d7=1;
        else
            d7=0;
        d6=0;
        d6=1;
    }
}

void wr_data(u8 data1)
{
    u8 i;
    //cs=0;
    rs=1;              //Êý¾Ý
    for(i=0;i<8;i++)
    {
        if((data1<<i)&0x80)
            d7=1;
        else
            d7=0;
        d6=0;
        d6=1;
    }
}
void lcd_pos(u8 x,u8 y)
{
    wr_cmd(0xb0+y);   //ÉèÖÃÒ³µØÖ·
    wr_cmd(((x&0xf0)>>4)|0x10);  //ÁеØÖ·¸ßËÄλÉèÖÃ
    wr_cmd((x&0x0f)|0x01);       //ÁеØÖ·µÍËÄλÉèÖÃ
    wr_cmd(0xa0);                //ÁеØÖ·ÔöÁ¿´Ó×óµ½ÓÒ
    //wr_cmd(0xe0);
}

void lcd_init(void)
{
    u8 x,y;
    d6=1;
    reset=0;
    delay_ms(10);
    reset=1;      //¸´Î»Íê±Ï
    delay_ms(10);
    wr_cmd(0xe2); //Èí¸´Î»
    delay_ms(5);
    wr_cmd(0x2c); //Éýѹ²½¾Û
    delay_ms(5);
    wr_cmd(0x2e); //Éýѹ²½¾Û
    delay_ms(5);
    wr_cmd(0x2f); //Éýѹ²½¾Û
    delay_ms(5);
    wr_cmd(0xc8); //ÐÐɨÃè˳Ðò£º´ÓÉϵ½ÏÂ
    wr_cmd(0xa0); //ÁÐɨÃè˳Ðò£º´Ó×óµ½ÓÒ
    wr_cmd(0x40); //ÆðʼÐУºµÚÒ»ÐпªÊ¼
    wr_cmd(0xaf); //¿ªÏÔʾ
    for(y=0;y<8;y++)
    {
        wr_cmd(0xb0+y);
        wr_cmd(0x01);
        wr_cmd(0x10);
        for(x=0;x<128;x++)
            wr_data(0x00);
    }
}
void lcd_clear(void)
{
    u8 x,y;
    for(y=0;y<8;y++)
    {
        wr_cmd(0xb0+y);
        wr_cmd(0x01);
        wr_cmd(0x10);
        for(x=0;x<128;x++)
            wr_data(0x00);
    }          

}
void lcd_clear_y(u8 y)
{
    u8 x;
    wr_cmd(0xb0+y);
    wr_cmd(0x01);
    wr_cmd(0x10);
    for(x=0;x<128;x++)
        wr_data(0x00);
}
void lcd_6x8(u8 x, u8 y,u8 ch[])   //ÏÔʾ×Ö·û´®
{
    u8 c=0,i=0,j=0;
    while (ch[j]!=‘\0‘)
    {
        c =ch[j]-32;
        if(x>126){x=0;y++;}
        lcd_pos(x,y);
        for(i=0;i<6;i++)
        wr_data(F6X8[c][i]);
        x+=6;
        j++;
    }
}

void lcd_6x8_num(u8 x,u8 y,u16 num)   //ÏÔʾÊý×Ö±äÁ¿

{
    u8 ok=0,c=0,i=0,j=6;
    int n[7]={0};
    if(num==0)
    {
        lcd_6x8(x,y,"0  ");
//        lcd_pos(x,y);
//        for(j=0;j<7;j++)
//            wr_data(F6X8[16][j]);
    }
    while(num!=0)
    {
        n[j]=num%10;   //n[6]¸öλ
        num=num/10;
        j--;
    }
    for (j=0;j<7;j++)
    {
        if(n[j]==0&&ok==0);  //num=0
        else
        {
            ok=1;
            c =n[j]+16;
            if(x>126)
            {
                x=0;
                y++;
            }
            lcd_pos(x,y);
            for(i=0;i<6;i++)
            {
                 wr_data(F6X8[c][i]);
            }
            x+=6;
        }
    }
}

接下来是4x4矩阵键盘函数：

#include "12864.h"
#define row0 PDout(0)
#define row1 PDout(1)
#define row2 PDout(2)
#define row3 PDout(3)
#define col0 PDout(4)
#define col1 PDout(5)
#define col2 PDout(6)
#define col3 PDout(7)

/*
¿ª·¢°å 4x4¾ØÕó¼üÅÌ
     PD4 PD5 PD6 PD7
PD0   1   2   3   4
PD1   5   6   7   8
PD2   9   10   11  12
PD3   13  14   15  16
*/

extern void Rect_key_Init(void);
extern u16 Read_one_key_value(void);
extern void Read_more_key_value(void);
#endif
#include "Rect_key.h"
static u8 key_output[4]={GPIO_Pin_0,GPIO_Pin_1,GPIO_Pin_2,GPIO_Pin_3};
static u8 key_input[4]={GPIO_Pin_4,GPIO_Pin_5,GPIO_Pin_6,GPIO_Pin_7};
u16 keyvalue[4][4];

void Rect_key_Init()
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD,ENABLE);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
    GPIO_SetBits(GPIOD,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);    

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;  //
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
}
u16 Read_one_key_value(void)
{
    u16 row,col,temp;
    u16 KeyValue = 0;
    if((GPIO_ReadInputData(GPIOD) | 0x000f) != 0x000f)
    {
        delay_ms(10);
        if((GPIO_ReadInputData(GPIOD) | 0x000f) != 0x000f)
        {
            GPIO_SetBits(GPIOD,GPIO_Pin_0);
            GPIO_ResetBits(GPIOD,GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 );
            row = GPIOD->IDR & 0x000f;
            col = GPIOD->IDR & 0x00f0;
            switch(row | col)
            {
                case 0x0011:KeyValue = 1; break;
                case 0x0021:KeyValue = 2; break;
                case 0x0041:KeyValue = 3; break;
                case 0x0081:KeyValue = 4; break;
                default: break;
            }
            GPIO_SetBits(GPIOD,GPIO_Pin_1);
            GPIO_ResetBits(GPIOD,GPIO_Pin_0 | GPIO_Pin_2 | GPIO_Pin_3 );
            row = GPIOD->IDR & 0x000f;
            col = GPIOD->IDR & 0x00f0;
            switch(row | col)
            {
                case 0x0012:KeyValue = 5; break;
                case 0x0022:KeyValue = 6; break;
                case 0x0042:KeyValue = 7; break;
                case 0x0082:KeyValue = 8; break;
                default: break;
            }
            GPIO_SetBits(GPIOD,GPIO_Pin_2);
            GPIO_ResetBits(GPIOD,GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_3 );
            row = GPIOD->IDR & 0x000f;
            col = GPIOD->IDR & 0x00f0;
            switch(row | col)
            {
                case 0x0014:KeyValue = 9; break;
                case 0x0024:KeyValue = 10; break;
                case 0x0044:KeyValue = 11; break;
                case 0x0084:KeyValue = 12; break;
                default: break;
            }
            GPIO_SetBits(GPIOD,GPIO_Pin_3);
            GPIO_ResetBits(GPIOD,GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 );
            row = GPIOD->IDR & 0x000f;
            col = GPIOD->IDR & 0x00f0;
            switch(row | col)
            {
                case 0x0018:KeyValue = 13; break;
                case 0x0028:KeyValue = 14; break;
                case 0x0048:KeyValue = 15; break;
                case 0x0088:KeyValue = 16; break;
                default: break;
            }
            return KeyValue;
        }
    }
    else return KeyValue;
}

void Read_more_key_value(void)
{
    u8 i,j;
    for(i = 0; i < 4; i++)
    {
        GPIO_ResetBits(GPIOD,GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
        GPIO_SetBits(GPIOD, key_output[i]);
        for(j = 0; j < 4; j++)
        {
            if(GPIO_ReadInputDataBit(GPIOD, key_input[j]) == 1)
                keyvalue[i][j] = i*4+(j+1);
            else
                keyvalue[i][j] = 0;
    }
    lcd_6x8_num(10,4,keyvalue[0][0]);
    lcd_6x8_num(30,4,keyvalue[0][1]);
    lcd_6x8_num(50,4,keyvalue[0][2]);
    lcd_6x8_num(70,4,keyvalue[0][3]);
    lcd_6x8_num(10,5,keyvalue[1][0]);
    lcd_6x8_num(30,5,keyvalue[1][1]);
    lcd_6x8_num(50,5,keyvalue[1][2]);
    lcd_6x8_num(70,5,keyvalue[1][3]);
    lcd_6x8_num(10,6,keyvalue[2][0]);
    lcd_6x8_num(30,6,keyvalue[2][1]);
    lcd_6x8_num(50,6,keyvalue[2][2]);
    lcd_6x8_num(70,6,keyvalue[2][3]);
    lcd_6x8_num(10,7,keyvalue[3][0]);
    lcd_6x8_num(30,7,keyvalue[3][1]);
    lcd_6x8_num(50,7,keyvalue[3][2]);
    lcd_6x8_num(70,7,keyvalue[3][3]);

    GPIO_SetBits(GPIOD, key_output[i]);
    }
}

其他函数可在STM32库中找。

显示效果图：

时间： 2024-10-05 23:27:05

STM32 4x4矩阵键盘的相关文章

4x4矩阵键盘扫描

4x4矩阵键盘扫描 Windows 10 IoT Core 是微软针对物联网市场的一个重要产品,与以往的Windows版本不同,是为物联网设备专门设计的,硬件也不仅仅限于x86架构,同时可以在ARM架构上运行. 上一章我们讲了 Win10 IoT 如何对本地 IoT 设备内嵌 SQLite 数据库进行 CURD 操作 ,这章我们来学习如何使用 GPIO Pin 扫描4x4矩阵键盘按键状态.如果对安装部署过程还不熟悉可以参考前几篇文章,Raspberry安装 IoT系统及搭建开发环境(http:/

Win10 IoT C#开发 6 - 4x4矩阵键盘扫描

Windows 10 IoT Core 是微软针对物联网市场的一个重要产品,与以往的Windows版本不同,是为物联网设备专门设计的,硬件也不仅仅限于x86架构,同时可以在ARM架构上运行. 上一章我们讲了 Win10 IoT 如何对本地 IoT 设备内嵌 SQLite 数据库进行 CURD 操作 ,这章我们来学习如何使用 GPIO Pin 扫描4x4矩阵键盘按键状态.如果对安装部署过程还不熟悉可以参考前几篇文章,Raspberry安装 IoT系统及搭建开发环境(http://www.cnblo

4X4矩阵键盘扫描程序

4X4矩阵键盘扫描: 1. 4根行线的GIO均设为Output,根列线的GIO均设为Input: 2. 4根行线的GIO分别置为0111.1011.1101.1110,读逐一读取列线GIO的值,可确定是哪一个按键: 电路图如下: 注意: 1. 图中用作输入的GIO,一定要有一个上拉电阻. 2. 芯片中的每一个引脚是否用作了GPIO口来用,需配置芯片的寄存器,使引脚当作GPIO口来使用,才会有效. 测试代码如下: #define KEY_GIO_ROW_1 37 #define KEY_GIO_R

「雕爷学编程」Arduino动手做（26）——4X4矩阵键盘模块

37款传感器与模块的提法,在网络上广泛流传,其实Arduino能够兼容的传感器模块肯定是不止37种的.鉴于本人手头积累了一些传感器和模块,依照实践出真知(一定要动手做)的理念,以学习和交流为目的,这里准备逐一动手试试做实验,不管成功与否,都会记录下来---小小的进步或是搞不定的问题,希望能够抛砖引玉. [Arduino]108种传感器模块系列实验(资料+代码+图形+仿真) 实验二十六:4X4矩阵键盘模块(轻触式按键) 矩阵键盘 是单片机外部设备中所使用的排布类似于矩阵的键盘组.矩阵式结构的键盘显

4x4矩阵键盘 扫描程序

一:不排除第四位异常处理 uchar JuzhenkeyScan() { // P3=0xfe; // temp=P3; // while(temp!=0xfe) // { // temp=P3; // switch(temp) // { // case 0xee:num=10; // break; // case 0xde:num=3; // break; // case 0xbe:num=2; // break; // case 0x7e:num=1; // break; // } // d

单片机入门-矩阵键盘控制数码管显示

任务简述:通过按下4X4矩阵键盘实现数码管对应显示数字 实现方式:通过行列分接法,可以节省使用单片机的I/O口,扫描矩阵键盘是否有按下,判断P2端口得到的值. protues 硬件系统 单片机晶振复位电路: 锁存器.上拉电阻: 4x4矩阵键盘: 代码实现: void key44scan(void)//键盘扫描函数 { uint t; P2=0xfe; t=P2; t=t&0xf0; if(t!=0xf0) { delay(); t=P2; switch(t) { case 0xee:keynum

矩阵键盘的试验---verilog

矩阵键盘的试验,采用三段式状态机处理方法. 难点在于检测状态机中:按键消抖以后逐列检测. 电路图: 代码: /********************************Copyright************************************** **----------------------------File information-------------------------- ** File name :keyboard.v ** CreateDate :20

STM32 实现 4*4 矩阵键盘扫描（HAL库、标准库 都适用）

本文实现的代码是基于STM32HAL库的基础上的,不过标准库也可以用,只是调用的库函数不同,逻辑跟配置是一样的,按我这里的逻辑来配置即可. 1.键盘原理图: 2.STM32 cubemx 引脚配置图: 这里用外部晶振内部晶振都可以,时钟对这个没什么影响,不用开中断,所以其他的配置就不细说了,下面再说一下这8个GPIO的配置. 4个引脚配推挽输出,这4个配输出的引脚内部上下拉不用配置:另外4个配成输入,内部上拉. 3.生成代码后,开始编写逻辑: 编写之前我们先做一下头文件的定义,把一些要用到的宏定

51、52单片机使用矩阵键盘

为了学习矩阵键盘,先做个小小的实验目标 : 按下矩阵键盘后 ,数码管显示按下的是第几键. 我的矩阵键盘是4X4的,操作原理是先检测按下的键是哪行.再确定是哪列.这样就能识别是按的哪个键了. 首先看电路图,确定键盘是连CPU的哪个针.我的开发板上是连接的P1,具体是P10~P17,八个针对应逻辑的8位. (此处省略,直接贴代码) #include<reg52.h>void delay(int n);void juzhen(void); char duanxuan[16]={0x3f,0x06,0