DP51 按键问题，当1个键按下时是什么判断的？部分程序有点看不懂，请教一下

thanks1

DP51 按键问题，当1个键按下时是什么判断的？部分程序有点看不懂，请教一下 [复制链接]

#define RCtrl                0x10       
void send_shift(uchar d)
{
        uchar i;
        for(i = 0x80; i >= 0x01; i=i>>1)
        {
                if((d&i) == 0)
                        sda = 0;
                else
                        sda = 1;
                clk = 0;
                clk = 1;
        }
}

void scankey(keyret *kpd)
{
        uchar i,scan = 0xfe;
        shut_dis();                                                        //关显示
        for(i = 1; i <= 8; i++)
        {
                send_shift(scan);
                if( !key_sl )
                {
                        if(~scan&RCtrl)
                        {
                                kpd->shiftcnt++;
                                kpd->shiftval = i;                               
                        }
                        else
                        {
                                kpd->funcnt++;
                                kpd->funval = i;
                        }
                }
                scan = _crol_(scan, 1);
        }
}

请问当一个键按下的时候是怎么判断这个键了
比如当3键按下        kpd->funcnt++;
              kpd->funval = 3;才对，但是此时怎么退出循环了？

zt13

scankey ()是在定时器0中断服务程序里跑的

linguoxian

但是此时怎么退出循环了？

扫八次,才退的!!

LZ应该再描述一下按键的结构,不然,咱去猜电路结构很吐血的!!

baoaboo

/*定义键盘扫描程序返回数据类型*/
typedef struct{
        uchar         shiftcnt;                                        //上档键的个数
        uchar        funcnt;                                                //功能键的个数
        uchar        shiftval;                                        //最后扫描到的上档键的值
        uchar        funval;                                                //最后扫描到的功能键的值
}keyret;

P1。0（SDA）上的串行数据转换成8位并行数据作为键盘扫描线， key_sl作为键盘数据回送线

大小姐

按下3键 还是扫8次，这样最后的结果有点让人不懂了。 程序运行是没有问题的

FU33

这么一说就清楚了!!

不过我还是得猜
应该有八个键,分为:四个分一组.一共两组!!

这个程序,是定时扫描一次,不管你按没有按键,或一次按多个键,它都扫全了!!

但是:它的结果只记录一个组合键区(我自己假设的)最后边(相对的,这个要看电路怎么走了,我说后边是对于它的扫描码来讲的)的按键的键值,和该组合区的键被按下的个数,一个功能键区相应的按键个数和最后的键值.

例子:
*o*o o***
*表示按下,o反之

这样的话得到的结果就是:
keyret->shiftcnt == 2;
keyret->shiftval == 3;
keyret->funcnt == 3;
keyret->funval == 8;

要不楼主你试试?然后咱们再继续吹吹

dfx168

大虾我大概明白了因为第二次扫的时候就可以确定是那个键了。。我CODE没贴完。不好意思

158675811

void key()
{
        uchar krpt = RConti;
        static uchar        keycnt;
        static bit                keysec;
        keyret keytemp = {0x00, 0x00, 0x00, 0x00};

        if(keydone)                                                                // 上次按键任务已完成
        {       
                scankey(&keytemp);                                        // 扫描键盘
                if(!keytemp.funcnt || keytemp.shiftcnt > 1)                        //无功能键按下或者上档键个数多于1个
                {
                        enflash = 1;                                        // 允许闪烁
                       
                        keypre[1] = 0x00;                                //上次功能键和上档键缓冲清零
                        keypre[0] = 0x00;
                        keysec = 0x00; task = 0x00; keycnt = 0x00;                //年龄计数器, 键释放标志, 按键状态清零
                }
                else if(!keysec)                                        //键已释放
                {
                        if(keytemp.funcnt > 1)                        //有多于一个功能键按下，置位按键释放标志
                                keysec = 1;
                        else if(keytemp.funval != keypre[0] || keytemp.shiftval != keypre[1] && keypre[1])
                        //本次功能键键值和上次不同或者本次上档键键值和上次不同且上次有上档键       
                        {
                                keypre[0] = keytemp.funval;                        //用本次键值更新上次键值
                                keypre[1] = keytemp.shiftval;
                                keycnt = 0x00;                                                //年龄计数器复位
                        }
                        else if( !keypre[1] && keytemp.shiftval)                        // 2次功能键相同,上次无上档键本次有
                                keysec = 1;
                                                //置位keysec, 屏蔽先按下功能键, 再按上档键这种按键组合
                        else
                        {
                                keycnt ++;                                                        // 2次功能键和上档键都相同
                                switch(task)
                                {
                                        case 0:                                                        //去抖阶段
                                                if(keycnt == N)                                //年龄等于下限N
                                                {
                                                        enflash = 1;
                                                        keyprocess = 1;                        //进行键值处理
                                                        if((keytemp.shiftcnt == 1) || !(krpt >> (keytemp.funval - 1) & 0x01))
                                                                                                        //是一对复合键或者该键不允许连击
                                                                keysec = 1;
                                                        else
                                                        {
                                                                task++;                                //按键状态转入重复的延缓阶段
                                                                keycnt = 0;                        //按键年龄清零
                                                        }
                                                               
                                                }
                                        break;

                                        case 1:                                                        //重复的延缓阶段
                                                if(keycnt == MaxRate)                //按键年龄等于重复的延缓时间
                                                {
                                                        enflash = 0;                        //不允许闪烁

                                                        keyprocess = 1;                        //进行键值处理
                                                        keycnt = 0;                                //按键年龄清零
                                                        task ++;                                //按键状态转入重复阶段       
                                                }
                                        break;

                                        case 2:                                                        //重复阶段
                                                if(keycnt == MinRate)                //重复时间到
                                                {
                                                        enflash = 0;                        //不允许闪烁

                                                        keyprocess = 1;                        //进行键值处理
                                                        keycnt = 0;                                //按键年龄清零
                                                }
                                        break;
                                }
                        }
                }
        }
}

jumpingpig

SCANKEY（）出来                        
keytemp.funcnt 应该是大于1的哦 这个又有点迷糊了。。

cancan_919

keyret keytemp = {0x00, 0x00, 0x00, 0x00};

由于这个是临时变量,每次在你的定时器中断里,进入KEY()后都是keytemp.funcnt 都为0

所以不迷糊了吧???