44矩阵键盘程序

① 求msp430 4x4矩阵键盘显示键值的程序，

无
********************************************//
unsigned char keymap[] = {1;*********************************************************************
控制打开或者关闭键盘中断
SW= 0;关闭端口中断
else
KEY_IE =0xf0;/7 接上拉电阻
/控制键盘开关/消除抖动
Check_Key()：
[p13]→ 1 2 3 4
[p12]→ 5 6 7 8
[p11]→ 9 10 11 12
[p10]→ 13 14 15 16
***************************************/
void Key_Event(void)
{
unsigned char tmp;/
void delay(void)
{
unsigned int tmp;/如果有键按下
{
delay();/ //是否P1IN的P1;/ 列检测
{
if((KEY_IN tmp2) == 0x00) / 获取键值
return; 设置P1OUT全为0,P1.h>/ /p14\///

KEY_IES =0xf0; / /设置键盘逻辑键值

与程序计算键值的映射

tmp1 = 0x08/
void Check_Key(void)
{
unsigned char row ;P1;6\= 1;/*******************************************
函数名称; tmp2用于检测出哪一位为0
for(col = 0,15;/ 获取 p1IN
if((tmp 0xf0) < /gt.4~P1,7，完成消抖功能
参 数;
if(Key_Val; /
/msp430x14x;/ //*******************************************
函数名称!=0)
{
Key_Event();/

KEY_OUT =0，并获取键值
参 数;打开端口中断
}

//
void Init_Keypad(void)
{
KEY_DIR = 0x0f;P1.0~P1.4~p1;P1; 0;***************************************
key_Val 对应键值
列;row++) /5\ / /col lt； ELSE;

for(tmp = 12000;
for(row = 0,4：t= tmp*5*clk 根据使用时钟调整tmp值
********************************************/ tmp2右移1位
}
}
}
}

/键值,9：delay
功 能：扫描键盘的IO端口：无
返回值 ,12; /关键盘中断
}
}

KEY_IFG=0;KEY_OUT=0;col++) / 4;/ 0xf0) /row lt,14;=1;*端口1按键中断*/ / /行扫描
{
KEY_OUT = 0x0f; / 4;0xf0) / /////tmp >
#pragma vector=PORT1_VECTOR
__interrupt void Port(void)
{
if((KEY_IFG0xf0)：无
返回值 ;存放键值

void CtrlKey(unsigned char sw).4~P1;< // 调用check_Key()!=0) /P1.7输出四位中有一个为0
tmp1 gt！=0有键按下
{
CtrlKey(0)，等待按键输入
tmp = KEY_IN; /***************全局变量***************/sw=0关 sw=1开

/// //
if((KEY_IN 0xf0)< 退出循环
}
tmp2 < / / 是否是该列;

#define KEY_DIR P1DIR
#define KEY_OUT P1OUT
#define KEY_IN P1IN
#define KEY_IE P1IE
#define KEY_IES P1IES
#define KEY_IFG P1IFG

//
}

//
void CtrlKey(unsigned char sw)
{
if(sw==0)
KEY_IE =0;/中断标志清0

Key_Val = 0;*******************************************
函数名称;
}
// /P1;msp430F149 4*4矩阵键盘P1口中断扫描
#includelt,8;47

② 4X4矩阵键盘程序

4x4键盘的程序有扫描法与线反法，但我个人认为用线反法较好，用扫描法得依次扫描所有行或列，如果用线反法就简单多了。先使键盘的行置为低、列置为高（或列置为高、行置为低），接着读回端口的值。比如：如果使用P0为键盘接口就先使低四位为低、高四位为高即P0=0xf0然后就读回P0口的值赋给一个变量，a=P0;紧接就给行列赋相反的值行置为高、列置为低（或列置为低、行置为高）即P0=0x0f然后就读回再与a运算就能得到唯一的识别码下面的程序就是用线反写一个4x4键盘识别程序：#include<AT89X52.H>
#include<delay.h>#define KEY_SCAN P1
#define uchar unsigned char//char num;/********************************/
/*函数名称：KEY_DOWN() */
/*函数功能：延时子函数 */
/*参 数：无 */
/*返 回：返回1或0 */
/*备 注：1表示有键按下，0则无*/
/********************************/
bit KEY_DOWN()
{
KEY_SCAN=0x0f; //先给键盘口赋个初值
if(KEY_SCAN!=0x0f) //判断是有按键按下，即KEY_SCAN不等于初值时有键按下
{
delayms(10); //消抖
if(KEY_SCAN!=0x0f) //再次判断是否真有键按下
return 1; //真有就返回1没有返回零
else
return 0;
}
else
return 0;
}/********************************/
/*函数名称：SCAN_GET() */
/*函数功能：键盘值函数 */
/*参 数：无 */
/*返 回：返回1或0 */
/*备 注：无 */
/********************************/
uchar SCAN_GET()
{
char button;
uchar key_code;
button=KEY_SCAN;
KEY_SCAN=0xf0;
button=(button|KEY_SCAN);
while(KEY_SCAN!=0xf0);
delayms(10);
switch(button)
{
case 0xd7: key_code='1';break;
case 0xdb: key_code='2';break;
case 0xdd: key_code='3';break;
case 0xb7: key_code='4';break;
case 0xbb: key_code='5';break;
case 0xbd: key_code='6';break;
case 0x77: key_code='7';break;
case 0x7b: key_code='8';break;
case 0x7d: key_code='9';break;
case 0xeb: key_code='0';break;
case 0xee: key_code=0xee;break;
default : break;
}
return key_code;
}
//////////////////////////////////////////////////////////////
//此程序是上两个程序结合的
/********************************/
/*函数名称：Key_Get() */
/*函数功能：键盘扫描函数 */
/*参 数：无 */
/*返 回：无 */
/*备 注：无 */
/********************************/
void Key_Get()
{
char button;
KEY_SCAN=0x0f;
if(KEY_SCAN!=0x0f)
{
delayms(5);
if(KEY_SCAN!=0x0f)
{
button=KEY_SCAN;
KEY_SCAN=0xf0;
button=(button|KEY_SCAN);
while(KEY_SCAN!=0xf0);
switch(button)
{
case 0xd7: num='1';P0=0x00;break;
case 0xdb: num='2';P0=0x0f;break;
case 0xdd: num='3';break;
case 0xb7: num='4';break;
case 0xbb: num='5';break;
case 0xbd: num='6';break;
case 0x77: num='7';break;
case 0x7b: num='8';break;
case 0x7d: num='9';break;
case 0xeb: num='0';break;
case 0xe7: num='a';break;
case 0xed: num='b';break;
case 0xee: num='c';break;
case 0xde: num='d';break;
case 0xbe: num='e';break;
case 0x7e: num='f';break;
default : break;
}
}
}
}

③ 4*4矩阵键盘扫描汇编程序 怎么写，求大神!

因为不知道你的单片机板子的电路图，我用我自己的板子写的代码发给你，你可以参考我的矩阵键盘扫描的方法，仿照着写。（这个不难的，用心看看就能懂的）

/********************************************************************
* 文件名 ： 矩阵键盘.c
* 描述 : 该文件实现了 4 * 4 键盘的试验。通过数码管的最后一位来显示
当前的按键值。
* 创建人 ： 东流，2012年2月7日
*********************************************************************/
#include<reg51.h>
#include<intrins.h>

#define uint unsigned int
#define uchar unsigned char

uchar code table[16] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};

/********************************************************************
* 名称 : Delay_1ms()
* 功能 : 延时子程序，延时时间为 1ms * x
* 输入 : x (延时一毫秒的个数)
* 输出 : 无
***********************************************************************/
void Delay_1ms(uint i)//1ms延时
{
uchar x,j;
for(j=0;j<i;j++)
for(x=0;x<=148;x++);
}

/********************************************************************
* 名称 : Keyscan()
* 功能 : 实现按键的读取。下面这个子程序是按处理 矩阵键盘 的基本方法处理的。
* 输入 : 无
* 输出 : 按键值
***********************************************************************/
uchar Keyscan(void)
{
uchar i,j, temp, Buffer[4] = {0xfe, 0xfd, 0xfb, 0xf7}; //让矩阵键盘的每行分别为低电平
for(j=0; j<4; j++)
{
P1 = Buffer[j];
temp = 0x10;
for(i=0; i<4; i++)
{
if(!(P1 & temp)) //判断P1口高4位某一行为低电平
{
return (i+j*4); //返回键码
}
temp <<= 1;
}
}
}

/********************************************************************
* 名称 : Main()
* 功能 : 主函数
* 输入 : 无
* 输出 : 无
***********************************************************************/
void Main(void)
{
uchar Key_Value; //读出的键值
P2 = 7;
while(1)
{
P1 = 0xf0;
if(P1 != 0xf0) //判断有无按键按下
{
Delay_1ms(20); //按键消抖
if(P1 != 0xf0) //第二次判断有无按键按下
{
Delay_1ms(20); //按键消抖
if(P1 != 0xf0) //第三次判断有无按键按下
{
Key_Value = Keyscan();
}
}
}
P0 = table[Key_Value]; //数码管赋值
}
}

④ 帮我写一个4乘4矩阵键盘识别技术的程序

您好，把文本格式奉上 直接复制到你的程序里
volatile unsigned char CF[4]; //按键触发标志(表示4列，每一列同一行的
//值是一样的但列标不一样来区分不同列的键)
volatile unsigned char KeyVal;//键值
code unsigned char KeyOut[4] = {0xef,0xdf,0xbf,0x7f}; //4X4按输出端控制
#define KEY P2 //P2口作为4*4矩阵键盘输入
/*
**描述：新型4X4按键扫描程序 放在1ms-10ms中断内使用（十分稳定不需要再写消抖程序）
**备注：按键弹起时 keyVal = 0 单键按下 keyVal 有16个值，你自己程序可以针对不同值
**进行不同程序操作 keyVal单键值分别为
**0x11,0x12,0x14,0x18,
**0x21,0x22,0x24,0x28,
**0x31,0x32,0x34,0x38,
**0x41,0x42,0x44,0x48,
*/
void Key_Head()
{
unsigned char ReadData[4];
static unsigned char i;
if(++i>=4)i=0;

KEY = KeyOut[i]|0x0f; //忽略低4位
ReadData[i] = (KEY|0xf0)^0xff; //忽略高4位 取反
CF[i] = ReadData[i] & (ReadData[i] ^ Cont[i]);
Cont[i] = ReadData[i];
//输出键值
switch(CF[i])//第i列
{
case 0x08: KeyVal = (i<<4+8);break;
case 0x04: KeyVal = (i<<4+4);break;
case 0x02: KeyVal = (i<<4+2);break;
case 0x01: KeyVal = (i<<4+1);break;
default:KeyVal = 0;break;
}
}

⑤ 有关4X4矩阵键盘FPGA的程序的分析，有谁帮我分析一下这个状态机的程序啊

.always@后面内容是敏感变量，always@(*)里面的敏感变量为*，意思是说敏感变量由综合器根据always里面的输入变量自动添加，不用自己考虑。 2.如果没有@，那就是不会满足特定条件才执行，而是执行完一次后立马执行下一次，一直重复执行，比如testbench里面产生50Mhz的时钟就(假设时间尺度是1ns）可以写成 always #20 CLK_50Mhz = ～CLK_50Mhz;

⑥ 4*4矩阵键盘汇编语言程序，按键分别显示，1,2,3,4，5，6，7，8，9，A，b，c，d，E

ORG 00H
STRAT: MOV R4, #00H
L1: MOV R3, #0F7H
MOV R1, #00H
L2: MOV A, R3
MOV P3, A
MOV A, P3
MOV R4, A
SETB C
MOV R5, #04H
L3: RLC A
JNC KEY
INC R1
DJNZ R5, L3
MOV A, R3
SETB C
RRC A
MOV R3, A
JC L2
JMP L1
KEY: ACALL DELAY
D1: MOV A, P3
XRL A,R4
JZ D1
MOV A, R1
ACALL DISP
JMP L1
DISP: MOV DPTR, #TABLE
MOVC A, @A+ DPTR
MOV P0, A
RET
DELAY: MOV R7, #60
MOV R6, #248
DLY1: DJNZ R6, $
DJNZ R7, DLY1
RET
TABLE: DB 0C0H, 0F9H, 0A4H, 0B0H
DB 99H, 92H, 82H, 0F8H
DB 80H, 90H, 88H, 83H
DB 0C6H, 0A1H, 86H, 8EH
END89c51的，很经典，不懂的可以问我。

⑦ 4X4矩阵键盘程序

//4*4键盘检测程序,按下键后相应的代码显示在数码管上
#include<reg51.h>
sbit beep=P2^3;
sbit la=P2^6;
sbit wela=P2^7;
unsigned char i=100;
unsigned char j,k,temp,key;
void delay(unsigned char i)
{
for(j=i;j>0;j--)
for(k=125;k>0;k--);
}
unsigned char code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,
0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
display(unsigned char num)
{
P0=table[num];
// P0=0xff;
la=1;
la=0;
P0=0xc0;
wela=1;
wela=0;
}
void main()
{
la=0;
wela=0;
while(1)
{
P3=0xfe;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xee:
key=0;
break;
case 0xde:
key=1;
break;
case 0xbe:
key=2;
break;
case 0x7e:
key=3;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
// P0=table[key];
/* P0=0xff;
la=1;
while(i--);
la=0;
P0=0xc0;
wela=1;
wela=0;
la=0;
wela=0;
P0=0xff;
la=1;
la=0;
P0=0xc5;
wela=1;
wela=0; */
P1=0xfe;
}
}
P3=0xfd;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xed:
key=4;
break;
case 0xdd:
key=5;
break;
case 0xbd:
key=6;
break;
case 0x7d:
key=7;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
/* P0=table[key];
la=1;
// while(100--);
la=0;
P0=0xc0;
wela=1;
wela=0;
*/ P1=0xfc;
}
}
P3=0xfb;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xeb:
key=8;
break;
case 0xdb:
key=9;
break;
case 0xbb:
key=10;
break;
case 0x7b:
key=11;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
/* P0=table[key];
la=1;
// while(100--);
la=0;
P0=0xc0;
wela=1;
wela=0;
*/ P1=0xf8;
}
}
P3=0xf7;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xe7:
key=12;
break;
case 0xd7:
key=13;
break;
case 0xb7:
key=14;
break;
case 0x77:
key=15;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
/* P0=table[key];
la=1;
// while(100--);
la=0;
P0=0xc0;
wela=1;
wela=0;
*/ P1=0xf0;
}
}
}
}