21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 矩阵键盘程序问题
123下一页
返回列表 发新帖我要提问

[STM32F1] 矩阵键盘程序问题

[复制链接]
2844|43
kingkits 发表于 2020-6-19 13:19 | 显示全部楼层
你可以考虑这样，先一组线A全拉低（置0）读另一组线B，然后把另一组线B拉低，读先一组线A，两个数据就能解析到按键，为防止抖动，需要记录解析的按键，然后间隔4-10ms，再检测一次，两次的数据相同才能确认按键按下，按键按下后，如果需要检测释放，就需要连续检测，间隔相同。还可以增加一个变量记录按键按下的时间（检测的数据连续相同的次数）。就可以区分长按键了。
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-19 13:56 | 显示全部楼层
gx_huang 发表于 2020-6-19 08:18
扫描输出要线与的，那肯定是OD输出了。
无论什么样的按键程序，我全是自己编的，根据系统需要编程，从来 ...

开漏的话，列线接上拉电阻啦。行线没接上拉电阻，怎么办呀？谢谢
回复

收藏1 举报

gx_huang 发表于 2020-6-19 14:54 | 显示全部楼层
Cjy_JDxy 发表于 2020-6-19 13:56
开漏的话，列线接上拉电阻啦。行线没接上拉电阻，怎么办呀？谢谢

假设行是输出，列是输入，输出OD，输入上拉，这你好好理解。
按键按下，有输出0，相关的输入也是0，这难道还不理解？
回复

收藏1 举报

gx_huang 发表于 2020-6-19 14:56 | 显示全部楼层
Cjy_JDxy 发表于 2020-6-19 12:02
谢谢！我试试

凡事不能靠试呀，都可以预先想好的，不知道原理，不知道要试多少回
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-19 16:13 | 显示全部楼层
gx_huang 发表于 2020-6-19 14:54
假设行是输出，列是输入，输出OD，输入上拉，这你好好理解。
按键按下，有输出0，相关的输入也是0，这难 ...

第2句我理解。
第一句，行没接上拉，可以输出低，无法输出高。
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-19 16:14 | 显示全部楼层
gx_huang 发表于 2020-6-19 14:56
凡事不能靠试呀，都可以预先想好的，不知道原理，不知道要试多少回

我只写过51的矩阵键盘，STM32的没写过，不太一样。
回复

收藏1 举报

gx_huang 发表于 2020-6-19 16:45 | 显示全部楼层
Cjy_JDxy 发表于 2020-6-19 16:13
第2句我理解。
第一句，行没接上拉，可以输出低，无法输出高。

线与，当然不需要输出高，如何可以输出高，不就打架了，一个高一个低打架呀。
输出高就是高阻。
回复

收藏1 举报

gx_huang 发表于 2020-6-19 16:45 | 显示全部楼层
Cjy_JDxy 发表于 2020-6-19 16:14
我只写过51的矩阵键盘，STM32的没写过，不太一样。

有些51也有推挽输出，也会打架的，51和STM32没有本质区别
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-19 17:56 | 显示全部楼层
gx_huang 发表于 2020-6-19 16:45
线与，当然不需要输出高，如何可以输出高，不就打架了，一个高一个低打架呀。
输出高就是高阻。 ...

谢谢！我再想想
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-19 18:48 | 显示全部楼层
gx_huang 发表于 2020-6-19 16:45
有些51也有推挽输出，也会打架的，51和STM32没有本质区别
复制
  1. void KEY_Init(void)
    

  2. {
    

  3.  
    

  4.  GPIO_InitTypeDef  GPIO_InitStructure;
    

  5.          
    

  6.  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOE, ENABLE);         //使能PA,PD端口时钟
    

  7.         
    

  8.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;                                 //LED0-->PA.8 端口配置
    

  9.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;                  //推挽输出
    

  10.  
    

  11.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  12.  GPIO_Init(GPIOE, &GPIO_InitStructure);                                         //根据设定参数初始化GPIOA.8
    

  13.  
    

  14.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 ;                                 //LED0-->PA.8 端口配置
    

  15.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //推挽输出
    

  16.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  17.  GPIO_Init(GPIOE, &GPIO_InitStructure);                                         //根据设定参数初始化GPIOA.8
    

  18.         
    

  19.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;                             //LED1-->PD.2 端口配置, 推挽输出
    

  20.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //推挽输出
    

  21.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  22.  GPIO_Init(GPIOB, &GPIO_InitStructure);                                           //推挽输出 ，IO口速度为50MHz
    

  23.         
    

  24.  
    

  25. }
    

  26. void Hang_Output(void)
    

  27. {
    

  28.         GPIO_InitTypeDef  GPIO_InitStructure;
    

  29.          
    

  30.  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOE, ENABLE);         //使能PA,PD端口时钟
    

  31.         
    

  32.  
    

  33.  
    

  34.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 ;                                 //LED0-->PA.8 端口配置
    

  35.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;                  //推挽输出
    

  36.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  37.  GPIO_Init(GPIOE, &GPIO_InitStructure);                                         //根据设定参数初始化GPIOA.8
    

  38.         
    

  39.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;                             //LED1-->PD.2 端口配置, 推挽输出
    

  40.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;                  //推挽输出
    

  41.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  42.  GPIO_Init(GPIOB, &GPIO_InitStructure);                                           //推挽输出 ，IO口速度为50MHz
    

  43.         
    

  44. }
    

  45. void Hang_Input(void)
    

  46. {
    

  47.         GPIO_InitTypeDef  GPIO_InitStructure;
    

  48.          
    

  49.  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOE, ENABLE);         //使能PA,PD端口时钟
    

  50.         
    

  51.  
    

  52.  
    

  53.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 ;                                 //LED0-->PA.8 端口配置
    

  54.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //推挽输出
    

  55.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  56.  GPIO_Init(GPIOE, &GPIO_InitStructure);                                         //根据设定参数初始化GPIOA.8
    

  57.         
    

  58.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9;                             //LED1-->PD.2 端口配置, 推挽输出
    

  59.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                  //推挽输出
    

  60.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  61.  GPIO_Init(GPIOB, &GPIO_InitStructure);                                           //推挽输出 ，IO口速度为50MHz
    

  62.         
    

  63. }
    

  64. void Lie_Input(void)
    

  65. {
    

  66.         GPIO_InitTypeDef  GPIO_InitStructure;
    

  67.          
    

  68.  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);         //使能PA,PD端口时钟
    

  69.         
    

  70.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;                                 //LED0-->PA.8 端口配置
    

  71.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                  //上拉输入
    

  72.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  73.  GPIO_Init(GPIOE, &GPIO_InitStructure);                                         //根据设定参数初始化GPIOA.8
    

  74. }
    


  75. 

  76. void Lie_Output(void)
    

  77. {
    

  78.         GPIO_InitTypeDef  GPIO_InitStructure;
    

  79.          
    

  80.  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOE, ENABLE);         //使能PA,PD端口时钟
    

  81.         
    

  82.  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6;                                 //LED0-->PA.8 端口配置
    

  83.  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;                  //推挽输出
    

  84.  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    

  85.  GPIO_Init(GPIOE, &GPIO_InitStructure);                                         //根据设定参数初始化GPIOA.8
    

  86. }
    

  87. unsigned char GetKey(void)
    

  88. {
    

  89.         
    

  90.         unsigned char keyvalue = 0;
    

  91.         uint16_t hangvalue=0;
    

  92.         
    

  93. // 第1回合第1步
    

  94.         KEY_Init();
    

  95.         delay_us(20);
    

  96.         GPIO_ResetBits(GPIOE,GPIO_Pin_6);                                                  //PE.6，5，4，3 输出低 
    

  97.         GPIO_SetBits(GPIOE,GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);                 
    

  98.                 
    

  99.         
    

  100.         
    

  101.         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  102.         if (hangvalue != 0x1f)// 从IO口输入，读IO口
    

  103.         {
    

  104.         // 读出的不是0x0f说明有按键被按下
    

  105.         // 第1回合第2步：读出端口从读出值来判断是哪一行
    

  106.                 delay_ms(20);
    

  107.                 GPIO_ResetBits(GPIOE,GPIO_Pin_6);                                                  //PE.6，5，4，3 输出低 
    

  108.                 GPIO_SetBits(GPIOE,GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);                                         
    

  109.                 
    

  110.                 
    

  111.                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  112.                 if (hangvalue != 0x1f)// 从IO口输入，读IO口
    

  113.                 {
    

  114.                         Hang_Output();
    

  115.                         Lie_Input();
    

  116.                         delay_us(20);
    

  117.                 // 第一回合中算出行号
    

  118.                         switch (hangvalue)
    

  119.                         {
    

  120.                                 case 0x0F:
    


  121. 

  122.                                                                 keyvalue=4;
    


  123. 

  124.                                         break;
    

  125.                                 case 0x17:
    

  126.                                                 
    

  127.                                                                 keyvalue=5;
    

  128.                 
    

  129.                                         break;
    

  130.                                 case 0x1b: 
    

  131.                                                                 keyvalue=1;
    

  132.                                         break;
    

  133.                                 case 0x1d:
    

  134.                                                 
    

  135.                                                 
    

  136.                                                                 keyvalue=2;
    

  137.                                                                 
    

  138.                                         break;
    

  139.                                 case 0x1e: 
    

  140.                                                 
    

  141.                                                 
    

  142.                                                                 keyvalue=3;
    

  143.                                                                 
    

  144.                                         break;
    

  145.                                 
    

  146.                                 default: break;
    

  147.                                 
    

  148.                         }
    

  149.                         Hang_Input();
    

  150.                         Lie_Output();
    

  151.                         delay_us(20);
    

  152.                         GPIO_ResetBits(GPIOE,GPIO_Pin_6 );                                                  //PE.6，5，4，3 输出低 
    

  153.                         GPIO_SetBits(GPIOE,GPIO_Pin_5 | GPIO_Pin_4 | GPIO_Pin_3);
    

  154.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  155.                         while (hangvalue != 0x1f)
    

  156.                         {
    

  157.                                 
    

  158.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  159.                         }
    

  160.                         delay_ms(2);
    

  161.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  162.                         while (hangvalue != 0x1f)
    

  163.                         {
    

  164.                                 
    

  165.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  166.                         }
    

  167.                         return keyvalue;
    

  168.                 }
    

  169.                 
    

  170.         }
    

  171.         KEY_Init();
    

  172.         delay_us(20);
    

  173.         
    

  174.         GPIO_ResetBits(GPIOE, GPIO_Pin_5 ); 
    

  175.         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_3);
    

  176.         
    

  177.         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  178.         if (hangvalue != 0x1f)// 从IO口输入，读IO口
    

  179.         {
    

  180.         // 读出的不是0x0f说明有按键被按下
    

  181.         // 第1回合第2步：读出端口从读出值来判断是哪一行
    

  182.                 delay_ms(20);
    

  183.                 
    

  184.                 GPIO_ResetBits(GPIOE, GPIO_Pin_5 ); 
    

  185.                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_3);
    

  186.                 
    

  187.                 
    

  188.                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  189.                 if (hangvalue != 0x1f)// 从IO口输入，读IO口
    

  190.                 {
    

  191.                         Hang_Output();
    

  192.                         Lie_Input();
    

  193.                         delay_us(20);
    

  194.                 // 第一回合中算出行号
    

  195.                         switch (hangvalue)
    

  196.                         {
    

  197.                                 case 0x0F:
    

  198.                                                 
    

  199.                                                 
    

  200.                                                 
    

  201.                                                                 keyvalue=9;
    

  202.                                                         
    

  203.                                         break;
    

  204.                                 case 0x17:
    

  205.                                                 
    

  206.                                                 
    

  207.                                                                 keyvalue=10;
    

  208.                                         
    

  209.                                         break;
    

  210.                                 case 0x1b: 
    

  211.                                                 
    

  212.                                                 
    

  213.                                                                 keyvalue=6;
    

  214.                                                 
    

  215.                                         break;
    

  216.                                 case 0x1d:
    

  217.                                                 
    

  218.                                                 
    

  219.                                                                 keyvalue=7;
    

  220.                                         
    

  221.                                         break;
    

  222.                                 case 0x1e: 
    

  223.                                                 
    

  224.                                                 
    

  225.                                                                 keyvalue=8;
    

  226.                                                 
    

  227.                                         break;
    

  228.                                 
    

  229.                                         
    

  230.                                 default: break;
    

  231.                                 
    

  232.                         }
    

  233.                         Hang_Input();
    

  234.                         Lie_Output();
    

  235.                         delay_us(20);
    

  236.                         
    

  237.                         GPIO_ResetBits(GPIOE, GPIO_Pin_5 ); 
    

  238.                         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_3);
    

  239.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  240.                         while (hangvalue != 0x1f)
    

  241.                         {
    

  242.                                 
    

  243.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0300)>>5);
    

  244.                         }
    

  245.                         
    

  246.                         
    

  247.                         return keyvalue;
    

  248.                 }
    

  249.                 
    

  250.         }
    

  251.         KEY_Init();
    

  252.         delay_us(20);
    

  253.         
    

  254.         
    

  255.         GPIO_ResetBits(GPIOE, GPIO_Pin_4 ); 
    

  256.         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_3 | GPIO_Pin_5);
    

  257.         
    

  258.         
    

  259.         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  260.         if (hangvalue != 0x3f)// 从IO口输入，读IO口
    

  261.         {
    

  262.         // 读出的不是0x0f说明有按键被按下
    

  263.         // 第1回合第2步：读出端口从读出值来判断是哪一行
    

  264.                 delay_ms(20);
    

  265.                 
    

  266.                 GPIO_ResetBits(GPIOE, GPIO_Pin_4 ); 
    

  267.                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_3 | GPIO_Pin_5);
    

  268.                 
    

  269.                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  270.                 if (hangvalue != 0x3f)// 从IO口输入，读IO口
    

  271.                 {
    

  272.                         Hang_Output();
    

  273.                         Lie_Input();
    

  274.                         delay_us(20);
    

  275.                 // 第一回合中算出行号
    

  276.                         switch (hangvalue)
    

  277.                         {
    

  278.                                 case 0x1F:
    

  279.                                                 
    

  280.                                                 
    

  281.                                         
    

  282.                                                                 keyvalue=14;
    

  283.                                         
    

  284.                                         break;
    

  285.                                 case 0x2F:
    

  286.                                                 
    

  287.                                                 
    

  288.                                                                 keyvalue=15;
    

  289.                                 
    

  290.                                         break;
    

  291.                                 case 0x37: 
    

  292.                                                 
    

  293.                                                 
    

  294.                                                                 keyvalue=16;
    

  295.                                         
    

  296.                                         break;
    

  297.                                 case 0x3B:
    

  298.                                                 
    

  299.                                                 
    

  300.                                                                 keyvalue=11;
    

  301.                                         
    

  302.                                         break;
    

  303.                                 case 0x3D: 
    

  304.                                                 
    

  305.                                                 
    

  306.                                                                 keyvalue=12;
    

  307.                                                 
    

  308.                                         break;
    

  309.                                 case 0x3E: 
    

  310.                                                 
    

  311.                                                 
    

  312.                                                                 keyvalue=13;
    

  313.                                 
    

  314.                                         break;
    

  315.                                 default: break;
    

  316.                                 
    

  317.                         }
    

  318.                         Hang_Input();
    

  319.                         Lie_Output();
    

  320.                         delay_us(20);
    

  321.                         
    

  322.                         GPIO_ResetBits(GPIOE, GPIO_Pin_4 ); 
    

  323.                         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_3 | GPIO_Pin_5);
    

  324.                         
    

  325.                         
    

  326.                         
    

  327.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  328.                         while (hangvalue != 0x3f)
    

  329.                         {
    

  330.                                 
    

  331.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  332.                         }
    

  333.                         delay_ms(2);
    

  334.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  335.                         while (hangvalue != 0x3f)
    

  336.                         {
    

  337.                                 
    

  338.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  339.                         }
    

  340.                         return keyvalue;
    

  341.                 }
    

  342.                 
    

  343.         }
    

  344.         KEY_Init();
    

  345.         delay_us(20);
    

  346.         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_5);
    

  347.         GPIO_ResetBits(GPIOE, GPIO_Pin_3 ); 
    

  348.                         
    

  349.         
    

  350.         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  351.         if (hangvalue != 0x3f)// 从IO口输入，读IO口
    

  352.         {
    

  353.         // 读出的不是0x0f说明有按键被按下
    

  354.         // 第1回合第2步：读出端口从读出值来判断是哪一行
    

  355.                 delay_ms(20);
    

  356.                 GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_5);
    

  357.                 GPIO_ResetBits(GPIOE, GPIO_Pin_3 ); 
    

  358.                 
    

  359.                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  360.                 if (hangvalue != 0x3f)// 从IO口输入，读IO口
    

  361.                 {
    

  362.                         Hang_Output();
    

  363.                         Lie_Input();
    

  364.                         delay_us(20);
    

  365.                 // 第一回合中算出行号
    

  366.                         switch (hangvalue)
    

  367.                         {
    

  368.                                 case 0x1F:
    

  369.                                                 
    

  370.                                                 
    

  371.                                                 
    

  372.                                                                 keyvalue=20;
    

  373.                                         
    

  374.                                         break;
    

  375.                                 case 0x2F:
    

  376.                                                 
    

  377.                                                 
    

  378.                                                                 keyvalue=21;
    

  379.                                         
    

  380.                                         break;
    

  381.                                 case 0x37: 
    

  382.                                                 
    

  383.                                                 
    

  384.                                                                 keyvalue=22;
    

  385.                                                 
    

  386.                                         break;
    

  387.                                 case 0x3B:
    

  388.                                                 
    

  389.                                                 
    

  390.                                                                 keyvalue=17;
    

  391.                                         
    

  392.                                         break;
    

  393.                                 case 0x3D: 
    

  394.                                                 
    

  395.                                                                 keyvalue=18;
    

  396.                                         
    

  397.                                         break;
    

  398.                                 case 0x3E: 
    

  399.                                                 
    

  400.                                                 
    

  401.                                                                 keyvalue=19;
    

  402.                                                 
    

  403.                                         break;
    

  404.                                 default: break;
    

  405.                                 
    

  406.                         }
    

  407.                         Hang_Input();
    

  408.                         Lie_Output();
    

  409.                         delay_us(20);
    

  410.                         GPIO_SetBits(GPIOE,GPIO_Pin_6 | GPIO_Pin_4 | GPIO_Pin_5);
    

  411.                         GPIO_ResetBits(GPIOE, GPIO_Pin_3 ); 
    

  412.                         
    

  413.                         
    

  414.                         hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  415.                         while (hangvalue != 0x3f)
    

  416.                         {
    

  417.                                 
    

  418.                                 hangvalue=(GPIO_ReadInputData(GPIOE)&0x07)+((GPIO_ReadInputData(GPIOB)&0x0380)>>4);
    

  419.                         }
    

  420.                         
    

  421.                         return keyvalue;
    

  422.                 }
    

  423.                 
    

  424.         }
    

  425.         return 0;
    

  426. }
输出模式都改成开漏了。大神帮我看看，那儿还有问题？谢谢！
回复

收藏1 举报

gx_huang 发表于 2020-6-20 10:10 | 显示全部楼层
1、没看以前的代码，既然是OD输出，就不需要行列一会输出一会输入的，也不需要在按键判断过程中反复初始化。
   主要主程序中初始化了行是OD输出，列是输入即可，其它地方无需再次初始化。
  其它地方需要的操作就是行输出，读出列输入即可，不需要反复初始化。
2、代码和注释要一致，这是对自己的尊重，也是对别人的尊重。不要的代码删除掉，很多冗余代码。
   行已经输出0111了，延时后又输出0111，这是画蛇添足。
   已经得到了键值，又判断是否有按键，并延时，不知道啥目的。
回复

收藏1 举报

gx_huang 发表于 2020-6-20 10:16 | 显示全部楼层
从逻辑上考虑，你这个程序不适合实时多任务，延时20毫秒，影响多少其它任务呀。
要考虑程序效率，按键扫描程序，要去掉所有行列初始化的代码。
平时所有行输出为0，进入按键程序，判断是否有列输入被拉低，没有立即退出，这样效率最高。
有列输入别拉低，才0111、1011、1101、1110依次行输出，判断列输入。
退出行列扫描程序，行输出0000，方便下次按键判断，或者中断唤醒。
你的程序，像女人的裹脚布呀。
回复

收藏1 举报

gx_huang 发表于 2020-6-20 10:23 | 显示全部楼层
你本来行输出0111，中途又初始化了行列端口，还得分析行输出是否变化了，没有必要插入无关的、没有必要的代码。
难道你怕GPIO状态中途紊乱了，需要反复初始化？
回复

收藏1 举报

gx_huang 发表于 2020-6-20 10:24 | 显示全部楼层
不同初始化代码，列输入，一会高阻输入一会上拉输入。
混乱不堪！
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-20 11:04 | 显示全部楼层
gx_huang 发表于 2020-6-20 10:10
1、没看以前的代码，既然是OD输出，就不需要行列一会输出一会输入的，也不需要在按键判断过程中反复初始化 ...

谢谢！
2.
我是一行一行判断的。
回复

收藏1 举报

 楼主| Cjy_JDxy 发表于 2020-6-20 11:05 | 显示全部楼层
gx_huang 发表于 2020-6-20 10:16
从逻辑上考虑，你这个程序不适合实时多任务，延时20毫秒，影响多少其它任务呀。
要考虑程序效率，按键扫描 ...

我是菜鸟
回复

收藏1 举报

一叶倾城wwq 发表于 2020-6-20 14:00 | 显示全部楼层
本帖最后由 一叶倾城wwq 于 2020-6-20 14:10 编辑

直接讨论思路就好了，周末实在看不了代码楼主用的中断法吗？没怎么看代码，建议分时查询就好了，有确定的输出行，检测列上的电平来判断键值，很清晰明了的思路，IO口也不用反复在输出和输入之间切换，我看这个原理图，你可以一行一行的调试先，代码逻辑出问题的话把多余的屏蔽掉，先一点点调
回复

收藏1 举报

评论

一叶倾城wwq
惭愧，刚进论坛时也很受大家的帮助  发表于 2020-6-20 14:01
keaibukelian 发表于 2020-7-9 14:04 | 显示全部楼层
延时去抖是一个经验值？会不会不可靠
回复

收藏1 举报

labasi 发表于 2020-7-9 14:04 | 显示全部楼层
讨论的非常热烈
回复

收藏1 举报

paotangsan 发表于 2020-7-9 14:04 | 显示全部楼层
硬件去抖比较好
回复

收藏1 举报

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

本版积分规则

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