21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 关于单片机项目中，键盘何时扫描，哪种方式扫描，希望大 ...
返回列表 发新帖我要提问

关于单片机项目中，键盘何时扫描，哪种方式扫描，希望大虾们指点下

[复制链接]
3586|12
 楼主| qqcaiyin 发表于 2013-6-15 15:50 | 显示全部楼层 |阅读模式
单片机, 键盘, 定时, 定时器, 扫描键盘
主要为通过按键控制测试任务的一系列操作（比如，开始，结束，切换等），
现在是越想感觉与复杂，关键是如何才能及时的响应键盘的操作，但又不影响任务的测试。
开始想到的是 外部中断，但感觉会受很大干扰，然后想用定时器，但不知道改怎么实施。
假如用定时器，定时多久扫一次呢？
              状态机键扫能嵌入到项目中吗？
              一直扫描键盘会不会影响到任务的测试呢？
              如果这个定时器还用来触发别的任务会不会和键扫有矛盾？

新人太多的不懂，大侠们有什么好的思路指点下小弟。
回复

收藏1 举报

相关帖子
zd420325 发表于 2013-6-17 14:42 | 显示全部楼层
按键的动作相对于单片机来说是超慢动作，每10ms扫描一次都是可以正常识别的，放到主循环内就行了。
回复

收藏1 举报

zhao305149619 发表于 2013-6-17 14:55 | 显示全部楼层
可以把按键扫描放在定时器里面，其他程序放在主函数，按键可以设置相应的标志位，来调用主函数
回复

收藏1 举报

NE5532 发表于 2013-6-17 15:12 | 显示全部楼层
楼主程序模块化没有想明白，你试着认为键盘就是扫描用户按键动作，输出用户按键信息，主程序根据按键信息控制操作流程，再看看。
回复

收藏1 举报

 楼主| qqcaiyin 发表于 2013-6-18 22:11 | 显示全部楼层
本帖最后由 qqcaiyin 于 2013-6-18 22:15 编辑
NE5532 发表于 2013-6-17 15:12
楼主程序模块化没有想明白，你试着认为键盘就是扫描用户按键动作，输出用户按键信息，主程序根据按键信息控 ...

谢谢指点，
另问，

void Timer0(void) interrupt 1
{
....
KeyRead();//只获取按键值
}

void main（void）
{
   ....
   while(1)
  {
       switch（KeyValue）
       {
            case task1_start:   task1();  //假设此任务须执行2S ，但是我在1s的时候按下
                                          // 了task1_end（停止键，为了使任务task1停止），
                                          //这样要么丢按键 要么有延迟。

                                          //如果task1end();在中断中运行，也许没有延迟，但感觉
                                          //又乱了。
            case task1_end  :   task1end();
            ......
       }
  }
}

请教前辈，应该怎么处理呢？
回复

收藏1 举报

Regsen 发表于 2013-6-19 08:15 | 显示全部楼层
放到主函数里面执行按键的内容，又想要收到结束按钮命令及时的退出开始命令的按键操作，你只能将开始按钮所要执行的内容分步骤的来做，每个步骤去检测一下有无结束命令按键。不过这样就要有结束命令标志位这个全局变量，可读性，错误率就会高了
回复

收藏1 举报

 楼主| qqcaiyin 发表于 2013-6-19 08:24 | 显示全部楼层
Regsen 发表于 2013-6-19 08:15
放到主函数里面执行按键的内容，又想要收到结束按钮命令及时的退出开始命令的按键操作，你只能将开始按钮所 ...

有什么比较好的解决办法吗，指点下思路
回复

收藏1 举报

NE5532 发表于 2013-6-19 08:40 | 显示全部楼层
qqcaiyin 发表于 2013-6-18 22:11
谢谢指点，
另问，

一个任务已经开始，相悖的按键按下，要么马上中断操作，要么延迟，这个有什么好乱的？你自己需要做成什么样子就做成什么样子啊，跟程序都无关，跟需求有关。

比如一个大型机器的紧急停车键，你认为是应该立即响应还是延迟响应呢？
回复

收藏1 举报

 楼主| qqcaiyin 发表于 2013-6-19 08:40 | 显示全部楼层
zd420325 发表于 2013-6-17 14:42
按键的动作相对于单片机来说是超慢动作，每10ms扫描一次都是可以正常识别的，放到主循环内就行了。 ...

放在主循环 10MS扫一次  ，但是单单执行的任务就不止100ms不合理啊
回复

收藏1 举报

 楼主| qqcaiyin 发表于 2013-6-19 08:43 | 显示全部楼层
NE5532 发表于 2013-6-19 08:40
一个任务已经开始，相悖的按键按下，要么马上中断操作，要么延迟，这个有什么好乱的？你自己需要做成什么 ...

嗯 ，看来钻牛角尖了
回复

收藏1 举报

NE5532 发表于 2013-6-19 10:37 | 显示全部楼层
qqcaiyin 发表于 2013-6-19 08:43
嗯 ，看来钻牛角尖了

呵呵，所以说这个问题，是用自然语言描述的，而不是程序会不会写的问题。
回复

收藏1 举报

lacfg 发表于 2013-6-19 11:13 | 显示全部楼层
void KeyScan()
{
        Key_State[0]=RC0;
        Key_State[1]=RC1;
        Key_State[2]=RC2;
        if(Key_State[Pin_Scan]==0)
        {
                if(Key_Pushed[Pin_Scan]<200)
                        Key_Pushed[Pin_Scan]++;
                if((Key_Pushed[Pin_Scan]>10)&&(Wait_Release[Pin_Scan]==0))
                {
                        Key_UnPushed[Pin_Scan]=0;
                        Wait_Release[Pin_Scan]=1;
                }
                else
                {
                        if(Wait_Release[Pin_Scan]==1)
                        {
                                Key_UnPushed[Pin_Scan]=0;
                                Key_Ing=Pin_Scan+1;
                        }
                               
                }
        }
        else
        {
                if(Key_UnPushed[Pin_Scan]<200)
                        Key_UnPushed[Pin_Scan]++;
                if((Key_UnPushed[Pin_Scan]>20)&&(Wait_Release[Pin_Scan]==1))
                {
                        Key_Pushed[Pin_Scan]=0;
                        Wait_Release[Pin_Scan]=0;
                        Key_Over=Pin_Scan+1;
                }
        }
        Pin_Scan++;
        if(Pin_Scan==3)
                Pin_Scan=0;
}

void KeyServ()
{
        switch(Key_Over)
        {
                case 1:
                        if(Num_Pointer==&Num_Ray_A)
                        {
                                if(Key_Speed_Add[0]==0)
                                {
                                        if((*Num_Pointer)<32)
                                        {
                                                (*Num_Pointer)++;
                                                Page_Changed=1;
                                        }                                               
                                }
                        }
                        else
                        {
                                if(Num_Pointer==&Num_Ray_B)
                                {
                                        if(Key_Speed_Add[0]==0)
                                        {
                                                if((*Num_Pointer)<255)
                                                {
                                                        (*Num_Pointer)++;
                                                        Page_Changed=1;
                                                }
                                        }
                                }
                        }
                        Key_Over=0;
                        Key_Speed_Add[0]=0;
                        break;
                case 2:
                        if(Num_Pointer==&Num_Ray_A)
                        {
                                if(Key_Speed_Add[1]==0)
                                {
                                        if((*Num_Pointer)>1)
                                        {
                                                (*Num_Pointer)--;
                                                Page_Changed=1;
                                        }
                                }
                        }
                        else
                        {
                                if(Num_Pointer==&Num_Ray_B)
                                {
                                        if(Key_Speed_Add[1]==0)
                                        {
                                                if((*Num_Pointer)>1)
                                                {
                                                        (*Num_Pointer)--;
                                                        Page_Changed=1;
                                                }
                                        }
                                }
                        }
                        Key_Over=0;
                        Key_Speed_Add[1]=0;
                        break;
                case 3:
                        if(Num_Pointer==&Num_Ray_A)
                        {
                                Num_Pointer=&Num_Ray_B;
                        }
                        else
                        {
                                if(Num_Pointer==&Num_Ray_B)
                                {
                                        Num_Pointer=&Num_Ray_A;
                                }
                        }
                        Key_Over=0;
                        Page_Changed=1;
                        break;
                default:
                        break;
        }
       
       
       
        switch(Key_Ing)
        {
                case 1:
                        Key_Ing=0;
                        if(Num_Pointer==&Num_Ray_A)
                        {
                                if(Key_Pushed[0]>150)
                                {
                                        Key_Pushed[0]=20+Key_Speed_Add[0];                                       
                                        if((*Num_Pointer)<32)
                                        {
                                                (*Num_Pointer)++;
                                                Page_Changed=1;
                                        }
                                        if(Key_Speed_Add[0]<120)
                                                Key_Speed_Add[0]+=10;
                                }
                        }
                        else
                        {
                                if(Num_Pointer==&Num_Ray_B)
                                {
                                        if(Key_Pushed[0]>150)
                                        {
                                                Key_Pushed[0]=20+Key_Speed_Add[0];                                       
                                                if((*Num_Pointer)<255)
                                                {
                                                        (*Num_Pointer)++;
                                                        Page_Changed=1;
                                                }
                                                if(Key_Speed_Add[0]<120)
                                                        Key_Speed_Add[0]+=10;
                                        }
                                }
                        }
                        break;
                case 2:
                        Key_Ing=0;
                        if(Num_Pointer==&Num_Ray_A)
                        {
                                if(Key_Pushed[1]>150)
                                {
                                        Key_Pushed[1]=20+Key_Speed_Add[1];                                       
                                        if((*Num_Pointer)>1)
                                        {
                                                (*Num_Pointer)--;
                                                Page_Changed=1;
                                        }
                                        if(Key_Speed_Add[1]<120)
                                                Key_Speed_Add[1]+=10;
                                }
                        }
                        else
                        {
                                if(Num_Pointer==&Num_Ray_B)
                                {
                                        if(Key_Pushed[1]>150)
                                        {
                                                Key_Pushed[1]=20+Key_Speed_Add[1];                                       
                                                if((*Num_Pointer)>1)
                                                {
                                                        (*Num_Pointer)--;
                                                        Page_Changed=1;
                                                }
                                                if(Key_Speed_Add[1]<120)
                                                        Key_Speed_Add[1]+=10;
                                        }
                                }
                        }
                        break;
                default:
                        break;
        }
}

KeyScan()放定时中断  ，KeyServ()放主程序  




回复

收藏1 举报

 楼主| qqcaiyin 发表于 2013-6-19 15:48 | 显示全部楼层
lacfg 发表于 2013-6-19 11:13
void KeyScan()
{
        Key_State[0]=RC0;

可以说下思路吗
回复

收藏1 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

qqcaiyin

15

主题

148

帖子

1

粉丝
快速回复 在线客服 返回列表 返回顶部