[STM32] 再问矩阵键盘的问题

[复制链接]
1000|7
 楼主| 比神乐 发表于 2020-7-11 15:52 | 显示全部楼层 |阅读模式
我用STM32写了个矩阵键盘的程序,原来是查询方式,现在改成定时器方式。
原理图:

程序:
  1. void KEY_Init(void)
  2. {

  3. GPIO_InitTypeDef  GPIO_InitStructure;
  4.        
  5. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOE, ENABLE);         //使能PB,PE端口时钟
  6.        
  7. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;                                 
  8. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;                  //开漏输出

  9. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
  10. GPIO_Init(GPIOE, &GPIO_InitStructure);                                         

  11. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 ;                                 
  12. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //浮空输入
  13. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
  14. GPIO_Init(GPIOE, &GPIO_InitStructure);                                         
  15.        
  16. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;                             
  17. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //浮空输入
  18. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
  19. GPIO_Init(GPIOB, &GPIO_InitStructure);                                            
  20.        

  21. }
  1. /*******************************************************************************
  2. * 函数名  : Timer4_Init_Config
  3. * 描述    : Timer4初始化配置
  4. * 输入    : 无
  5. * 输出    : 无
  6. * 返回    : 无
  7. * 说明    : 无
  8. *******************************************************************************/
  9. void Timer4_Init_Config(void)
  10. {
  11.         TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
  12.        
  13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);                //使能Timer1时钟
  14.         //设置在下一个更新事件装入活动的自动重装载寄存器周期的值(计数到200为20ms)
  15.         TIM_TimeBaseStructure.TIM_Period = 199;                                               
  16.         TIM_TimeBaseStructure.TIM_Prescaler = 7199;                                        //设置用来作为TIMx时钟频率除数的预分频值(10KHz的计数频率)
  17.         TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;                //设置时钟分割:TDTS = TIM_CKD_DIV1
  18.         TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;        //TIM向上计数模式
  19.         TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);                                //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
  20.          
  21.         TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE );                                 //使能TIM2指定的中断
  22.        
  23.         TIM_Cmd(TIM4, ENABLE);                                                                          //使能TIMx外设
  24. }


  25. /*******************************************************************************
  26. * 函数名  : TIM4_IRQHandler
  27. * 描述    : 定时器2中断断服务函数
  28. * 输入    : 无
  29. * 输出    : 无
  30. * 返回    : 无
  31. * 说明    : 无
  32. *******************************************************************************/
  33. void TIM4_IRQHandler(void)
  34. {
  35.        
  36.         if(TIM_GetITStatus(TIM4, TIM_IT_Update) == SET)
  37.         {
  38.                 TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
  39.                 if(KeyFlag == 1)
  40.                 {
  41.                        
  42.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  43.                         if (hangvalue != 0x3f)        // 读出的不是0x3f说明有按键被按下
  44.                         {
  45.                                 keynum = 0;
  46.                                 keyvalue = 0;
  47.                                 KeyFlag = 2;
  48.                                
  49.                                 GPIO_ResetBits(GPIOE,GPIO_Pin_6);                                                  //PE.6输出低
  50.                                 GPIO_SetBits(GPIOE,GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);                                         
  51.                                
  52.                                 delay_us(XD);                               
  53.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
  54.                                
  55.                                 switch (hangvalue)
  56.                                 {
  57.                                         case 0x0F:

  58.                                                                         keyvalue=4;

  59.                                                 break;
  60.                                         case 0x17:
  61.                                                        
  62.                                                                         keyvalue=5;
  63.                        
  64.                                                 break;
  65.                                         case 0x1b:
  66.                                                                         keyvalue=1;
  67.                                                 break;
  68.                                         case 0x1d:
  69.                                                        
  70.                                                        
  71.                                                                         keyvalue=2;
  72.                                                                        
  73.                                                 break;
  74.                                         case 0x1e:
  75.                                                        
  76.                                                        
  77.                                                                         keyvalue=3;
  78.                                                                        
  79.                                                 break;
  80.                                        
  81.                                         default: break;
  82.                                        
  83.                                 }
  84.                                
  85.                         if(keyvalue==0)
  86.                         {
  87.                                 GPIO_ResetBits(GPIOE, GPIO_Pin_5 );
  88.                                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_3);
  89.                                
  90.                                 delay_us(XD);       
  91.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
  92.                                
  93.                                
  94.                                 switch (hangvalue)
  95.                                 {
  96.                                         case 0x0F:
  97.                                                        
  98.                                                        
  99.                                                        
  100.                                                                         keyvalue=9;
  101.                                                                
  102.                                                 break;
  103.                                         case 0x17:
  104.                                                        
  105.                                                        
  106.                                                                         keyvalue=10;
  107.                                                
  108.                                                 break;
  109.                                         case 0x1b:
  110.                                                        
  111.                                                        
  112.                                                                         keyvalue=6;
  113.                                                        
  114.                                                 break;
  115.                                         case 0x1d:
  116.                                                        
  117.                                                        
  118.                                                                         keyvalue=7;
  119.                                                
  120.                                                 break;
  121.                                         case 0x1e:
  122.                                                        
  123.                                                        
  124.                                                                         keyvalue=8;
  125.                                                        
  126.                                                 break;
  127.                                        
  128.                                                
  129.                                         default: break;
  130.                                        
  131.                                 }
  132.                         }
  133.                
  134.                 if(keyvalue==0)
  135.                 {
  136.                         GPIO_ResetBits(GPIOE, GPIO_Pin_4 );
  137.                         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_3 | GPIO_Pin_5);
  138.                        
  139.                         delay_us(XD);       
  140.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  141.                
  142.                        
  143.                        
  144.                         // 第一回合中算出行号
  145.                                 switch (hangvalue)
  146.                                 {
  147.                                         case 0x1F:
  148.                                                        
  149.                                                        
  150.                                                
  151.                                                                         keyvalue=14;
  152.                                                
  153.                                                 break;
  154.                                         case 0x2F:
  155.                                                        
  156.                                                        
  157.                                                                         keyvalue=15;
  158.                                        
  159.                                                 break;
  160.                                         case 0x37:
  161.                                                        
  162.                                                        
  163.                                                                         keyvalue=16;
  164.                                                
  165.                                                 break;
  166.                                         case 0x3B:
  167.                                                        
  168.                                                        
  169.                                                                         keyvalue=11;
  170.                                                
  171.                                                 break;
  172.                                         case 0x3D:
  173.                                                        
  174.                                                        
  175.                                                                         keyvalue=12;
  176.                                                        
  177.                                                 break;
  178.                                         case 0x3E:
  179.                                                        
  180.                                                        
  181.                                                                         keyvalue=13;
  182.                                        
  183.                                                 break;
  184.                                         default: break;
  185.                                        
  186.                                 }
  187.                         }       
  188.                         if(keyvalue==0)
  189.                         {
  190.                                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_5);
  191.                                 GPIO_ResetBits(GPIOE, GPIO_Pin_3 );
  192.                                 delay_us(XD);       
  193.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  194.                        
  195.                                 switch (hangvalue)
  196.                                 {
  197.                                         case 0x1F:
  198.                                                        
  199.                                                        
  200.                                                        
  201.                                                                         keyvalue=20;
  202.                                                
  203.                                                 break;
  204.                                         case 0x2F:
  205.                                                        
  206.                                                        
  207.                                                                         keyvalue=21;
  208.                                                
  209.                                                 break;
  210.                                         case 0x37:
  211.                                                        
  212.                                                        
  213.                                                                         keyvalue=22;
  214.                                                        
  215.                                                 break;
  216.                                         case 0x3B:
  217.                                                        
  218.                                                        
  219.                                                                         keyvalue=17;
  220.                                                
  221.                                                 break;
  222.                                         case 0x3D:
  223.                                                        
  224.                                                                         keyvalue=18;
  225.                                                
  226.                                                 break;
  227.                                         case 0x3E:
  228.                                                        
  229.                                                        
  230.                                                                         keyvalue=19;
  231.                                                        
  232.                                                 break;
  233.                                         default: break;
  234.                                        
  235.                                 }
  236.                         }
  237.                                 GPIO_ResetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);          //PE.6,5,4,3 输出低
  238.                                 delay_us(XD);
  239.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  240.                                 while (hangvalue != 0x3f)
  241.                                 {
  242.                                         delay_us(20);
  243.                                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  244.                                 }
  245.                                 KeyFlag=0;
  246.                                 keynum = keyvalue;
  247.                                 if(S0_State == (S_INIT|S_CONN))
  248.                                 {
  249.                                         S0_Data&=~S_TRANSMITOK;
  250.                                        
  251.                                         Write_SOCK_Data_Buffer(0, &keynum, 1);//指定Socket(0~7)发送数据处理,端口0发送23字节数据
  252.                                 }
  253.                         }
  254.                         else
  255.                                 KeyFlag = 0;
  256.                 }
  257.                 GPIO_ResetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);          //PE.6,5,4,3 输出低
  258.                 delay_us(XD);
  259.                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  260.                 if (hangvalue != 0x3f)        // 读出的不是0x3f说明有按键被按下
  261.                 {
  262.                         KeyFlag = 1;
  263.                 }
  264.                 else
  265.                         KeyFlag = 0;
  266. //                led^=0x01;
  267. //                GPIO_WriteBit(GPIOE,GPIO_Pin_7,led);
  268.         }
  269. }
按下按键测试,通过网口打印出来:

可以看到,有的按键打印两次,实际按下一次。
还有的正确键值后面跟着一个0.
请高手指教,如何解决?谢谢!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?注册

×
elife 发表于 2020-7-11 23:36 | 显示全部楼层
中断中等待按键释放,按键时间在几百ms,这样很耗时间,会引起定时中断丢失。如果STM32的中断能够记住多个丢失的中断,会导致快速多次进入中断,在按键释放的抖动阶段,会出现多次按键或奇怪按键。可以在中断中设置标志,表示按键按下,在下次中断中判断按键释放,20mS的中断间隔,可以避开按键抖动阶段。
 楼主| 比神乐 发表于 2020-7-12 10:14 | 显示全部楼层
elife 发表于 2020-7-11 23:36
中断中等待按键释放,按键时间在几百ms,这样很耗时间,会引起定时中断丢失。如果STM32的中断能够记住多个丢 ...

谢谢!我试试
 楼主| 比神乐 发表于 2020-7-13 08:36 | 显示全部楼层
elife 发表于 2020-7-11 23:36
中断中等待按键释放,按键时间在几百ms,这样很耗时间,会引起定时中断丢失。如果STM32的中断能够记住多个丢 ...

我改了一下,没有那种多一个0的情况了,不过还有打印两次相同键值的情况。
程序如下:
  1. /*******************************************************************************
  2. * 函数名  : TIM4_IRQHandler
  3. * 描述    : 定时器4中断断服务函数
  4. * 输入    : 无
  5. * 输出    : 无
  6. * 返回    : 无
  7. * 说明    : 无
  8. *******************************************************************************/
  9. void TIM4_IRQHandler(void)
  10. {
  11.        
  12.         if(TIM_GetITStatus(TIM4, TIM_IT_Update) == SET)
  13.         {
  14.                 TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
  15.                 if(KeyFlag == 2)
  16.                 {
  17.                                 GPIO_ResetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);          //PE.6,5,4,3 输出低
  18.                                 delay_us(XD);
  19.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);

  20.                                 if(hangvalue == 0x3f)
  21.                                 {
  22.                                         KeyFlag=0;
  23.                                         keynum = keyvalue;
  24.                                         if(S0_State == (S_INIT|S_CONN))
  25.                                         {
  26.                                                 S0_Data&=~S_TRANSMITOK;
  27.                                                
  28.                                                 Write_SOCK_Data_Buffer(0, &keynum, 1);//指定Socket(0~7)发送数据处理,端口0发送23字节数据
  29.                                         }
  30.                                 }
  31.                 }
  32.                 if(KeyFlag == 1)
  33.                 {
  34.                         GPIO_ResetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);          //PE.6,5,4,3 输出低
  35.                         delay_us(XD);
  36.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  37.                         if (hangvalue != 0x3f)        // 读出的不是0x3f说明有按键被按下
  38.                         {
  39.                                 keynum = 0;
  40.                                 keyvalue = 0;
  41.                                 KeyFlag = 2;
  42.                                
  43.                                 GPIO_ResetBits(GPIOE,GPIO_Pin_6);                                                  //PE.6输出低
  44.                                 GPIO_SetBits(GPIOE,GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);                                         
  45.                                
  46.                                 delay_us(XD);                               
  47.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
  48.                                
  49.                                 switch (hangvalue)
  50.                                 {
  51.                                         case 0x0F:

  52.                                                                         keyvalue=4;

  53.                                                 break;
  54.                                         case 0x17:
  55.                                                        
  56.                                                                         keyvalue=5;
  57.                        
  58.                                                 break;
  59.                                         case 0x1b:
  60.                                                                         keyvalue=1;
  61.                                                 break;
  62.                                         case 0x1d:
  63.                                                        
  64.                                                        
  65.                                                                         keyvalue=2;
  66.                                                                        
  67.                                                 break;
  68.                                         case 0x1e:
  69.                                                        
  70.                                                        
  71.                                                                         keyvalue=3;
  72.                                                                        
  73.                                                 break;
  74.                                        
  75.                                         default: break;
  76.                                        
  77.                                 }
  78.                                
  79.                         if(keyvalue==0)
  80.                         {
  81.                                 GPIO_ResetBits(GPIOE, GPIO_Pin_5 );
  82.                                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_3);
  83.                                
  84.                                 delay_us(XD);       
  85.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
  86.                                
  87.                                
  88.                                 switch (hangvalue)
  89.                                 {
  90.                                         case 0x0F:
  91.                                                        
  92.                                                        
  93.                                                        
  94.                                                                         keyvalue=9;
  95.                                                                
  96.                                                 break;
  97.                                         case 0x17:
  98.                                                        
  99.                                                        
  100.                                                                         keyvalue=10;
  101.                                                
  102.                                                 break;
  103.                                         case 0x1b:
  104.                                                        
  105.                                                        
  106.                                                                         keyvalue=6;
  107.                                                        
  108.                                                 break;
  109.                                         case 0x1d:
  110.                                                        
  111.                                                        
  112.                                                                         keyvalue=7;
  113.                                                
  114.                                                 break;
  115.                                         case 0x1e:
  116.                                                        
  117.                                                        
  118.                                                                         keyvalue=8;
  119.                                                        
  120.                                                 break;
  121.                                        
  122.                                                
  123.                                         default: break;
  124.                                        
  125.                                 }
  126.                         }
  127.                
  128.                 if(keyvalue==0)
  129.                 {
  130.                         GPIO_ResetBits(GPIOE, GPIO_Pin_4 );
  131.                         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_3 | GPIO_Pin_5);
  132.                        
  133.                         delay_us(XD);       
  134.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  135.                
  136.                        
  137.                        
  138.                         // 第一回合中算出行号
  139.                                 switch (hangvalue)
  140.                                 {
  141.                                         case 0x1F:
  142.                                                        
  143.                                                        
  144.                                                
  145.                                                                         keyvalue=14;
  146.                                                
  147.                                                 break;
  148.                                         case 0x2F:
  149.                                                        
  150.                                                        
  151.                                                                         keyvalue=15;
  152.                                        
  153.                                                 break;
  154.                                         case 0x37:
  155.                                                        
  156.                                                        
  157.                                                                         keyvalue=16;
  158.                                                
  159.                                                 break;
  160.                                         case 0x3B:
  161.                                                        
  162.                                                        
  163.                                                                         keyvalue=11;
  164.                                                
  165.                                                 break;
  166.                                         case 0x3D:
  167.                                                        
  168.                                                        
  169.                                                                         keyvalue=12;
  170.                                                        
  171.                                                 break;
  172.                                         case 0x3E:
  173.                                                        
  174.                                                        
  175.                                                                         keyvalue=13;
  176.                                        
  177.                                                 break;
  178.                                         default: break;
  179.                                        
  180.                                 }
  181.                         }       
  182.                         if(keyvalue==0)
  183.                         {
  184.                                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_5);
  185.                                 GPIO_ResetBits(GPIOE, GPIO_Pin_3 );
  186.                                 delay_us(XD);       
  187.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  188.                        
  189.                                 switch (hangvalue)
  190.                                 {
  191.                                         case 0x1F:
  192.                                                        
  193.                                                        
  194.                                                        
  195.                                                                         keyvalue=20;
  196.                                                
  197.                                                 break;
  198.                                         case 0x2F:
  199.                                                        
  200.                                                        
  201.                                                                         keyvalue=21;
  202.                                                
  203.                                                 break;
  204.                                         case 0x37:
  205.                                                        
  206.                                                        
  207.                                                                         keyvalue=22;
  208.                                                        
  209.                                                 break;
  210.                                         case 0x3B:
  211.                                                        
  212.                                                        
  213.                                                                         keyvalue=17;
  214.                                                
  215.                                                 break;
  216.                                         case 0x3D:
  217.                                                        
  218.                                                                         keyvalue=18;
  219.                                                
  220.                                                 break;
  221.                                         case 0x3E:
  222.                                                        
  223.                                                        
  224.                                                                         keyvalue=19;
  225.                                                        
  226.                                                 break;
  227.                                         default: break;
  228.                                        
  229.                                 }
  230.                         }
  231.                                
  232.                         }
  233.                         else
  234.                                 KeyFlag = 0;
  235.                 }
  236.                 if(KeyFlag == 0)
  237.                 {
  238.                         GPIO_ResetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);          //PE.6,5,4,3 输出低
  239.                         delay_us(XD);
  240.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
  241.                         if (hangvalue != 0x3f)        // 读出的不是0x3f说明有按键被按下
  242.                         {
  243.                                 KeyFlag = 1;
  244.                         }
  245.                         else
  246.                                 KeyFlag = 0;
  247.                 }
  248. //                led^=0x01;
  249. //                GPIO_WriteBit(GPIOE,GPIO_Pin_7,led);
  250.         }
  251. }












一事无成就是我 发表于 2020-7-14 16:47 | 显示全部楼层
/*******************************************************************************
* 函数名  : TIM4_IRQHandler
* 描述    : 定时器4中断断服务函数
* 输入    : 无
* 输出    : 无
* 返回    : 无
* 说明    : 无
*******************************************************************************/
void TIM4_IRQHandler(void)
{
       static uint8_t    key_Pace = 0;
       static uint32_t  old_KeyVal;
       uint32_t           new_KeyVal;

        if(TIM_GetITStatus(TIM4, TIM_IT_Update) == SET)
        {   //设定4ms中断一次
                TIM_ClearITPendingBit(TIM4, TIM_IT_Update);

               //键盘检测可以做成for循环4次
               // PE.6,5,4设施成输入 ,PE3输出L
               new_KeyVal = (~(GPIO_ReadInputData(GPIOE) & 7) + (GPIO_ReadInputData(GPIOB) >>4))) & 0x3f ;
               //PE.3输入,PE4输出L
               new_KeyVal |= ((~(GPIO_ReadInputData(GPIOE) & 7) + (GPIO_ReadInputData(GPIOB) >>4))) & 0x3f) << 6;
               //PE.4输入,PE5输出L
               new_KeyVal |= ((~(GPIO_ReadInputData(GPIOE) & 7) + (GPIO_ReadInputData(GPIOB) >>4))) & 0x3f) << 12;
               //PE.5输入,PE6输出L
               new_KeyVal |= ((~(GPIO_ReadInputData(GPIOE) & 7) + (GPIO_ReadInputData(GPIOB) >>4))) & 0x3f ) << 18;
               //恢复键盘待机,PE.6,5,4,  3全部输出L

                key_Pace ++;
                if(key_Pace < 6)
                {  //键盘按下去抖, 时间4ms×6 = 24ms ,也可以设置6~8ms中断一次,响应该值调整
                    if((new_KeyVal == 0) || new_KeyVal != old_KeyVal)  //无键操作或者键值不对应
                       {old_KeyVal = new_KeyVal;  key_Pace = 0;}                      //返回等待键盘状态
                }
                else if(key_Pace == 6)
                {  //键值处理,或启动发送
                     switch(old_KeyVal)
                    {  //键盘比较离散或允许组合键采用这个方法
                    case   0x000001:        //键盘1
                              break;
                    case   0x000002:        //键盘2
                              break;
                    case   0x000004:        //键盘3
                              break;
                    case   0x000008:        //键盘4
                              break;
                    case   0x000010:        //键盘5
                              break;
                    case   0x000020:        //键盘6
                              break;
                    case   0x000040:        //键盘7
                              break;
                    case   0x000080:        //键盘8
                              break;
                    case   0x000100:        //键盘9
                              break;
                    case   0x000200:        //键盘10
                              break;
                    case   0x000400:        //键盘11
                              break;
                    case   0x000800:        //键盘12
                              break;
                    case   0x001000:        //键盘13
                              break;
                    case   0x002000:        //键盘14
                              break;
                    case   0x004000:        //键盘15
                              break;
                    case   0x008000:        //键盘16
                              break;
                    case   0x010000:        //键盘17
                              break;
                    case   0x020000:        //键盘18
                              break;
                    case   0x040000:        //键盘19
                              break;
                    case   0x080000:        //键盘20
                              break;
                    case   0x100000:        //键盘21
                              break;
                    case   0x200000:        //键盘22
                              break;
                    case   0x400000:        //键盘23
                              break;
                    case   0x800000:        //键盘24
                              break;
                    case   0xXXXXXX:        //其它组合键盘
                              break;
                    }
// 可以用统筹方法组合好后统一发送数据到通讯口
                    old_KeyVal = 0;
                }
                else if(key_Pace < 20)
                {   //键盘释放去抖
                    if(new_KeyVal != 0)  key_Pace = 6;    //等待键盘释放
                }
                else    key_Pace = 0;                               //键盘释放
        }
}

参考一下
 楼主| 比神乐 发表于 2020-7-14 17:05 | 显示全部楼层
一事无成就是我 发表于 2020-7-14 16:47
/*******************************************************************************
* 函数名  : TIM4_IR ...

谢谢!我试一下。
一事无成就是我 发表于 2020-7-14 17:13 | 显示全部楼层
一般我们不在定时器里做这些事情,只是在中断里设置状态位,而是在主程序里不断扫描状态位,有效则执行,执行后清除,那样不影响多任务实时性
 楼主| 比神乐 发表于 2020-7-15 09:20 | 显示全部楼层
一事无成就是我 发表于 2020-7-14 17:13
一般我们不在定时器里做这些事情,只是在中断里设置状态位,而是在主程序里不断扫描状态位,有效则执行,执 ...

搞好了,谢谢
您需要登录后才可以回帖 登录 | 注册

本版积分规则

470

主题

3537

帖子

7

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