设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机8个IO口扫描检测64个按键+仿真程序+算法实现和 ...
返回列表 发新帖
查看: 6367|回复: 6
打印 上一主题 下一主题
收起左侧

51单片机8个IO口扫描检测64个按键+仿真程序+算法实现和心法要点讲解

  [复制链接]
跳转到指定楼层
楼主
ID:795427 发表于 2021-9-11 23:23 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
51单片机8个IO口扫描检测64个按键+数码管显示+程序+Proteus仿真+算法实现和心法要点讲解
  • 扫描原理想通了很简单，就是通过一个IO拉低，其检测这一组其他7个IO口状态，如果检测到有被拉低了，说明就有按键按下了，因为检测到拉低的IO口，是被被用来检测的IO口拉低的。相当于我用一个接GND的探针去碰一个高电平的IO口，肯定是会拉低的。电路原理的话，利用二极管单向导通特性，在检查过程中，如果IO口被拉低，只能构成一个回路，依次不断轮询进行。
  • 知道了按键扫描原理然后去实现的过程并不是很艰难，我觉得最困难的是调试过程遇到的各种问题。掌握其原理并不那么复杂，在写完之后，代码并不是很顺利按照自己的思路去运行的，也许就是一个项目的学习过程。一个DIY创意可能很简单，真正让其按照自己的想法运行还是有很多细节点要打通的。
  • 小bug折腾的时间比整个写代码花费的精力和时间多得多，想想一个稳定好用的产品都需要几个版本的迭代。

总结要领     最难的地方是，控制56-64最后一排的数码管显示，因为，这个你是对P0总线端口自身的扫描，最容易出问题的地方，也是卡在这个地方最长时间。一定要了解其单片机运行和按键扫描原理。在没有延时或打断的情况下，按键动作的时间一定是快不过单片机运行的速度。所以在处理最后一排按键时，需要特别注意，显示时要比其他行扫描处理的时间留长一点，不然就很容易跳数，按下的按键，和显示的数值不是你想要的结果，下面我会将经验一一写下来。
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

  • 在处理最后一排按键，我有想过两个办法来处理逻辑判断问题：
  • 利用复合逻辑来写，很直观，但是代码阅读和可执行性看起来相对很臃肿一样，写的时候很爽，单片机处理逻辑，运行的时间会多一些。是我最先想到的第一种办法，写法如下：
    1. if(P0==0x7f||P0==0xbf||P0==0xdf||P0==0xef||P0==0xf7||P0==0xfb||P0==0xfd||P0==0xfe)
    复制代码

  • 第二种办法，通过二分查找的方式：（为什么可以采用二分查找算法来快速筛查对象，是有讲究的）：二分查找的条件就是注意事项，定义的数组必须是有序序列才行。最优方法看不懂不要紧，直接搜算法拿来用就行！写法如下：
    1. int Search(uchar arr[], int len, int flag)
    2. {
    3. int right = len - 1;
    4. int left = 0;
    5. while (left <= right)
    6. {
    7. int mid = (right + left) / 2;
    8. if (arr[mid] > flag)
    9. {
    10. right = mid - 1;
    11. }
    12. else if (arr[mid] < flag)
    13. {
    14. left = mid + 1;
    15. }
    16. else
    17. {
    18. return arr[mid];
    19. }
    20. }
    21. return 0;
    22. }
    复制代码

  • 第三种遍历方法，就不需要参照二分查找算法那样考虑什么注意事项了，随便写一个简单的遍历程序即可，执行效率虽然慢一点，起码实现起来简单，代码可敲性强，比起二分查找算法写起来。
    1. uchar libian(uchar a[], int value, int n)
    2. {
    3.         int i;
    4.   for (i = 0; i < n; i++)
    5.   {
    6.     if (value == a[i])
    7.     {
    8.       return a[i];
    9.     }
    10.   }
    11.   return 0;
    12. }
    复制代码

0-64个按键，需要考虑消抖的只有最后一排56-64的8个按键的响应。为什么这么说呢?这是因为按键从设计原理和实现来看的。0-56的按键不管你怎么长按还是短按，单片机给你的响应数值都是一样的不会变，但是在处理56-64这8个按键时，是做了特殊处理，连接的是GND，如果敲代码没注意的话，就很容易造成跳数字，单片机扫描是通过按照规定先给指定的IO口拉点，再去检测其他7个IO的电平状态，所以在处理第56-64按键时，如果你操作的按键按下时，单片机扫描按键的速度已经从你按下那一到弹起前已经超过了你的速度，那么会造成，单片机读取到错误的响应数据，处理方式如下：
  1. /****************自身端口读取*********************/
  2.                 P0=0xff;//扫描第8行
  3. //    delay(5);
  4.                 tmp=P0;
  5.     if (Search(arr, 8, tmp))
  6.     {
  7.         //将检测到的P0状态值赋值给临时变量
  8.         switch(Search(arr, 8, tmp))
  9.         {   //临时变量对逐个IO口进行查询
  10.         case 0xfe:
  11.             keynum=57;
  12.             break;//第1行第1个按键按下
  13.         case 0xfd:
  14.             keynum=58;
  15.             break;//第1行第2个按键按下
  16.         case 0xfb:
  17.             keynum=59;
  18.             break;//第1行第3个按键按下
  19.         case 0xf7:
  20.             keynum=60;
  21.             break;//第1行第4个按键按下
  22.         case 0xef:
  23.             keynum=61;
  24.             break;//第1行第5个按键按下
  25.         case 0xdf:
  26.             keynum=62;
  27.             break;//第1行第6个按键按下
  28.         case 0xbf:
  29.             keynum=63;
  30.             break;//第1行第7个按键按下
  31.         case 0x7f:
  32.             keynum=64;
  33.             break;//第1行第8个按键按下
  34.         }        
  35.                         display();//这里必须单独处理P0的IO检测和显示，否则容易跳数
  36.                         delay(80);//阻塞按键扫描，防止数码管跳变，其他行扫描不需要此处的延时。
  37.     }
复制代码
完整实现代码：
  1. #include <reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int
  5. //共阴极数码管0~9
  6. uchar code table[]= {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//0-9共阴数码管
  7. uchar code arr[] = {0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe};

  9. uchar duanZhi[]= {0,0};//保存每段数码管显示位数的数值
  10. sbit P36=P3^6;//数码管时能端
  11. sbit P37=P3^7;
  12. sbit ST=P3^0;//定义74HC595移位寄存器
  13. sbit SH=P3^2;
  14. sbit DS=P3^1;
  15. sbit P33=P3^3;
  16. sbit P34=P3^4;
  17. sbit P35=P3^5;

  19. uchar shi,ge;//数码管个位和十位显示
  20. uchar tmp;//暂存P0的值
  21. static uchar keynum=0;//按键值
  22. unsigned char Trg;
  23. unsigned char Cont;
  24. static char count=1;
  25. //毫秒级延时
  26. void delay(uint z)
  27. {
  28.     uint x,y;
  29.     for(x=z; x>>0; x--)
  30.         for(y=110; y>>0; y--);
  31. }
  32. void SendTo595(uchar byteData);
  33. int Search(uchar arr[], int len, int flag)
  34. {
  35.     int right = len - 1;
  36.     int left = 0;
  37.     while (left <= right)
  38.     {
  39.         int mid = (right + left) / 2;
  40.         if (arr[mid] > flag)
  41.         {
  42.             right = mid - 1;
  43.         }
  44.         else if (arr[mid] < flag)
  45.         {
  46.             left = mid + 1;
  47.         }
  48.         else
  49.         {
  50.             return arr[mid];
  51.         }
  52.     }
  53.     return 0;
  54. }
  55. /*----------------------------------------------------------------------------------
  56.                                 显示

  58. void display2()
  59. {
  60.     ge = keynum%10;
  61.     shi = keynum/10;
  62.     duanZhi[0]=table[ge];
  63.     duanZhi[1]=table[shi];
  64.     P34=0x00;
  65.     SendTo595(duanZhi[0]);                 //
  66.     delay(5);
  67.     P34=0x01;//消隐

  69.     P33=0x00;
  70.     SendTo595(duanZhi[1]);//
  71.     delay(5);
  72.     P33=0x01;//消隐

  74. }
  75. ----------------------------------------------------------------------------------*/
  76. void display()
  77. {
  78.     ge = keynum%10;
  79.     shi = keynum/10;
  80.     duanZhi[0]=table[ge];
  81.     duanZhi[1]=table[shi];
  82.     //显示个位
  83.     P37=0;
  84.     SendTo595(duanZhi[0]);                 //
  85.     delay(2);
  86.     P37=1;//消隐
  87.     //显示十位
  88.     P36=0;
  89.     SendTo595(duanZhi[1]);//
  90.     delay(2);
  91.     P36=1;//消隐

  93. }
  94. /***********************************************************
  95. *函数名                ：SendTo595
  96. *功能                :串行发送8个比特（一个字节）的数据给595，再并行输出
  97. *参数                ：byteData
  98. ************************************************************/
  99. void SendTo595(uchar byteData)
  100. {
  101.     uchar i=0;
  102.     ST = 0;   //ST //先拉低，为后面的上升沿做准备
  103.     for(i; i<8; i++)
  104.     {
  105.         SH = 0;//先拉低，
  106.         if(byteData&0x80)DS=1;
  107.         else DS=0;
  108. //        DS = (byteData&0x80)?1:0;
  109.         byteData = byteData <<1;                //该字节右移一位

  111.         SH = 1;//上升沿，让串行输入时钟变为高电平，并延时2个时钟周期
  112.         _nop_();
  113.         _nop_();
  114.         SH = 0;        //上升沿，让串行输入时钟变为高电平，并延时2个时钟周期
  115.     }
  116.     /*位移寄存器数据准备完毕,转移到存储寄存器*/
  117.     ST =1;
  118.     _nop_();
  119.     _nop_();
  120.     ST = 0;
  121. }

  123. void key_scan()
  124. {
  125. //    P0=0xff;
  126. //    delay(6);

  128.     /********************第1行扫描**************************/

  130.     P0=0x7F;//扫描第1行0111 1111
  131.     delay(5);
  132.     if (!Search(arr, 8, tmp))//有按键按下
  133.     {
  134.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  135.         switch(tmp)
  136.         {   //临时变量对逐个IO口进行查询
  137.         case 0x7e:
  138.             keynum=50;
  139.             break;//第1行第1个按键按下
  140.         case 0x7d:
  141.             keynum=51;
  142.             break;//第1行第2个按键按下
  143.         case 0x7b:
  144.             keynum=52;
  145.             break;//第1行第3个按键按下
  146.         case 0x77:
  147.             keynum=53;
  148.             break;//第1行第4个按键按下
  149.         case 0x6f:
  150.             keynum=54;
  151.             break;//第1行第5个按键按下
  152.         case 0x5f:
  153.             keynum=55;
  154.             break;//第1行第6个按键按下
  155.         case 0x3f:
  156.             keynum=56;
  157.             break;//第1行第7个按键按下
  158.         }
  159.     }
  160.     /********************第2行扫描**************************/
  161.     P0=0xbf;//扫描第2行
  162.     delay(5);
  163.     if(P0!=0xbf)//有按键按下
  164.     {
  165.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  166.         switch(tmp)
  167.         {   //临时变量对逐个IO口进行查询
  168.         case 0xbe:
  169.             keynum=43;
  170.             break;//第2行第1个按键按下
  171.         case 0xbd:
  172.             keynum=44;
  173.             break;//第2行第2个按键按下
  174.         case 0xbb:
  175.             keynum=45;
  176.             break;//第2行第3个按键按下
  177.         case 0xb7:
  178.             keynum=46;
  179.             break;//第2行第4个按键按下
  180.         case 0xaf:
  181.             keynum=47;
  182.             break;//第2行第5个按键按下
  183.         case 0x9f:
  184.             keynum=48;
  185.             break;//第2行第6个按键按下
  186.         case 0x3f:
  187.             keynum=49;
  188.             break;//第2行第7个按键按下
  189.         }        
  190.     }
  191.     /********************第3行扫描**************************/

  193.     P0=0xdf;//扫描第3行
  194.     delay(5);
  195.      if(P0!=0xdf)//有按键按下
  196.     {
  197.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  198.         switch(tmp)
  199.         {   //临时变量对逐个IO口进行查询
  200.         case 0xde:
  201.             keynum=36;
  202.             break;//第3行第1个按键按下
  203.         case 0xdd:
  204.             keynum=37;
  205.             break;//第3行第2个按键按下
  206.         case 0xdb:
  207.             keynum=38;
  208.             break;//第3行第3个按键按下
  209.         case 0xd7:
  210.             keynum=39;
  211.             break;//第3行第4个按键按下
  212.         case 0xcf:
  213.             keynum=40;
  214.             break;//第3行第5个按键按下
  215.         case 0x9f:
  216.             keynum=41;
  217.             break;//第3行第6个按键按下
  218.         case 0x5f:
  219.             keynum=42;
  220.             break;//第3行第7个按键按下
  221.         }

  223.     }
  224.     /********************第4行扫描**************************/

  226.     P0=0xef;//扫描第4行
  227.     delay(5);
  228.     if(P0!=0xef)//有按键按下
  229.     {
  230.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  231.         switch(tmp)
  232.         {   //临时变量对逐个IO口进行查询
  233.         case 0xee:
  234.             keynum=29;
  235.             break;//第4行第1个按键按下
  236.         case 0xed:
  237.             keynum=30;
  238.             break;//第4行第2个按键按下
  239.         case 0xeb:
  240.             keynum=31;
  241.             break;//第4行第3个按键按下
  242.         case 0xe7:
  243.             keynum=32;
  244.             break;//第3行第4个按键按下
  245.         case 0xcf:
  246.             keynum=33;
  247.             break;//第4行第5个按键按下
  248.         case 0xaf:
  249.             keynum=34;
  250.             break;//第4行第6个按键按下
  251.         case 0x6f:
  252.             keynum=35;
  253.             break;//第4行第7个按键按下
  254.         }               
  255.     }
  256.     /********************第5行扫描**************************/

  258.     P0=0xf7;//扫描第5行
  259.     delay(5);
  260.     if(P0!=0xf7)//有按键按下
  261.     {
  262.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  263.         switch(tmp)
  264.         {   //临时变量对逐个IO口进行查询
  265.         case 0xf6:
  266.             keynum=22;
  267.             break;//第5行第1个按键按下
  268.         case 0xf5:
  269.             keynum=23;
  270.             break;//第5行第2个按键按下
  271.         case 0xf3:
  272.             keynum=24;
  273.             break;//第5行第3个按键按下
  274.         case 0xe7:
  275.             keynum=25;
  276.             break;//第5行第4个按键按下
  277.         case 0xd7:
  278.             keynum=26;
  279.             break;//第5行第5个按键按下
  280.         case 0xb7:
  281.             keynum=27;
  282.             break;//第5行第6个按键按下
  283.         case 0x77:
  284.             keynum=28;
  285.             break;//第5行第7个按键按下
  286.         }               
  287.     }
  288.     /********************第6行扫描**************************/

  290.     P0=0xfb;//扫描第6行
  291.     delay(5);
  292.     if(P0!=0xfb)//有按键按下
  293.     {
  294.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  295.         switch(tmp)
  296.         {   //临时变量对逐个IO口进行查询
  297.         case 0xfa:
  298.             keynum=15;
  299.             break;//第6行第1个按键按下
  300.         case 0xf9:
  301.             keynum=16;
  302.             break;//第6行第2个按键按下
  303.         case 0xf3:
  304.             keynum=17;
  305.             break;//第6行第3个按键按下
  306.         case 0xeb:
  307.             keynum=18;
  308.             break;//第6行第4个按键按下
  309.         case 0xdb:
  310.             keynum=19;
  311.             break;//第6行第5个按键按下
  312.         case 0xbb:
  313.             keynum=20;
  314.             break;//第6行第6个按键按下
  315.         case 0x7b:
  316.             keynum=21;
  317.             break;//第6行第7个按键按下
  318.         }
  319.     }
  320.     /********************第7行扫描**************************/
  321.     P0=0xfd;//扫描第7行
  322.     delay(5);
  323.     if(P0!=0xfd)//有按键按下
  324.     {
  325.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  326.         switch(tmp)
  327.         {   //临时变量对逐个IO口进行查询
  328.         case 0xfc:
  329.             keynum=8;
  330.             break;//第7行第1个按键按下
  331.         case 0xf9:
  332.             keynum=9;
  333.             break;//第7行第2个按键按下
  334.         case 0xf5:
  335.             keynum=10;
  336.             break;//第7行第3个按键按下
  337.         case 0xed:
  338.             keynum=11;
  339.             break;//第7行第4个按键按下
  340.         case 0xdd:
  341.             keynum=12;
  342.             break;//第7行第5个按键按下
  343.         case 0xbd:
  344.             keynum=13;
  345.             break;//第7行第6个按键按下
  346.         case 0x7d:
  347.             keynum=14;
  348.             break;//第7行第7个按键按下
  349.         }
  350.     }
  351.     /********************第8行扫描**************************/

  353.     P0=0xfe;//扫描第8行
  354.     delay(5);
  355.     if(P0!=0xfe)//有按键按下
  356.     {
  357.         tmp=P0;//将检测到的P0状态值赋值给临时变量
  358.         switch(tmp)
  359.         {   //临时变量对逐个IO口进行查询
  360.         case 0xfc:
  361.             keynum=1;
  362.             break;//第8行第1个按键按下
  363.         case 0xfa:
  364.             keynum=2;
  365.             break;//第8行第2个按键按下
  366.         case 0xf6:
  367.             keynum=3;
  368.             break;//第8行第3个按键按下
  369.         case 0xee:
  370.             keynum=4;
  371.             break;//第8行第4个按键按下
  372.         case 0xde:
  373.             keynum=5;
  374.             break;//第8行第5个按键按下
  375.         case 0xbe:
  376.             keynum=6;
  377.             break;//第8行第6个按键按下
  378.         case 0x7e:
  379.             keynum=7;
  380.             break;//第8行第7个按键按下
  381.         }
  382.     }
  383. /****************自身端口读取*********************/
  384.                 P0=0xff;//扫描第8行
  385. //    delay(5);
  386.                 tmp=P0;
  387.     if (Search(arr, 8, tmp))
  388.     {
  389.         //将检测到的P0状态值赋值给临时变量
  390.         switch(Search(arr, 8, tmp))
  391.         {   //临时变量对逐个IO口进行查询
  392.         case 0xfe:
  393.             keynum=57;
  394.             break;//第1行第1个按键按下
  395.         case 0xfd:
  396.             keynum=58;
  397.             break;//第1行第2个按键按下
  398.         case 0xfb:
  399.             keynum=59;
  400.             break;//第1行第3个按键按下
  401.         case 0xf7:
  402.             keynum=60;
  403.             break;//第1行第4个按键按下
  404.         case 0xef:
  405.             keynum=61;
  406.             break;//第1行第5个按键按下
  407.         case 0xdf:
  408.             keynum=62;
  409.             break;//第1行第6个按键按下
  410.         case 0xbf:
  411.             keynum=63;
  412.             break;//第1行第7个按键按下
  413.         case 0x7f:
  414.             keynum=64;
  415.             break;//第1行第8个按键按下
  416.         }        
  417.                         display();//这里必须单独处理P0的IO检测和显示，否则容易跳数
  418.                         delay(80);//阻塞按键扫描，防止数码管跳变，其他行扫描不需要此处的延时。
  419.     }
  420.    display();//这里的显示是保存上一次的显示值

  422. }
  423. void main()
  424. {
  425.     keynum=0;
  426.     P0=0xff;
  427.     while(1)
  428.     {               
  429.         key_scan();
  430.     }
  431. }
复制代码
仿真器件选选择也是很有讲究的。附上截图


  • 注意：二极管选型，不能选择发光二极管，有些其他的二极管也不好使，我使用的是10A01
  • 注意走线，线路连接中最好不要出现重复线或者点，有多余的线或者连接点最好删除，不然出问题了排查问题带来难度，有可能也会影响仿真效果，电阻选择不能过大。仿真时，会比较占电脑内存。按键操作和响应速度可能会存在卡顿。





我会附上源码，提供两套不同实现方案的代码。
8个IO口检测64个按键.zip (118.94 KB, 下载次数: 42)

  • 创作不易，写出来调试代码，折腾了我好几天，对于有帮助的朋友，希望能用上，避免重复的道路上采坑。

评分

参与人数 3黑币 +119 收起 理由
waerdeng + 5 很给力！
wps10025 + 24 很给力！
admin + 90 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏7 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:333678 发表于 2021-9-12 07:51 | 只看该作者
感谢楼主的无私奉献，下载学习了。
回复

使用道具 举报

板凳
ID:284488 发表于 2021-9-12 09:14 | 只看该作者
感谢楼主的分享，学习了。
回复

使用道具 举报

地板
ID:164385 发表于 2021-9-12 10:14 | 只看该作者
楼主很厉害，辛苦了
回复

使用道具 举报

5#
ID:57657 发表于 2021-9-12 16:58 | 只看该作者
这个程序还可以优化很多，仿真测试OK。
  1. #include "reg51.h"
  2. #include "intrins.h"
  3. #define u8 unsigned char
  4. sbit P36 = P3 ^ 6;
  5. sbit P37 = P3 ^ 7;
  6. sbit STCP = P3 ^ 0;//定义74HC595移位寄存器
  7. sbit SHCP = P3 ^ 2;
  8. sbit DS = P3 ^ 1;

  10. u8 code table[16] = {                //共阴数码管段码16进制
  11.         0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71
  12. };

  14. void delay(){
  15.     u8 a,b;
  16.     for(b=19;b>0;b--)
  17.         for(a=130;a>0;a--);
  18. }

  20. void txd595(u8 d) {
  21.         u8 i;
  22.         for (i = 0; i < 8; i++) {
  23.                 DS = d & 0x80;
  24.                 SHCP = 0;
  25.                 d <<= 1;
  26.                 SHCP = 1;
  27.         }
  28.         STCP=0;_nop_();STCP=1;
  29. }

  31. void display(u8 d) {
  32.         P37 = 0;
  33.         txd595(table[d%10]);
  34.         delay();
  35.         P37 = 1;
  36.         _nop_();
  37.         P36 = 0;
  38.         txd595(table[d/10]);
  39.         delay();
  40.         P36 = 1;
  41. }

  43. u8 b0(u8 dat) {                //取一个字节中有多少个二进制0 返回0~8
  44.         u8 i, j = 0;
  45.         for (i = 0; i < 8; i++) {
  46.                 if (!(dat & (1 << i))) {
  47.                         j++;
  48.                 }
  49.         }
  50.         return j;
  51. }

  53. u8 key_scan() {                //无按键返回0 有按键返回1~64 (禁止多个按键同时按下,出错返回99)
  54.         u8 i, j, k, l, m;
  55.         P0 = 0xFF;
  56.         _nop_();
  57.         k = P0;
  58.         if (k != 0xFF) {
  59.                 if (b0(k) != 1) return 99;
  60.                 for (i = 0; i < 8; i++) {
  61.                         if (!(k & (1 << i))) {
  62.                                 return 57 + i;
  63.                         }
  64.                 }
  65.         }

  67.         for (i = 0; i < 8; i++) {
  68.                 j = ~(1 << i);
  69.                 P0 = j;
  70.                 _nop_();
  71.                 k= P0;
  72.                 if (k != j) {
  73.                         if (k & ~j || b0(k) != 2) return 99;
  74.                         m = 0;
  75.                         for (l = 0; l < 8; l++) {
  76.                                 if (i == l) continue;
  77.                                 m++;
  78.                                 if (!(k & (1 << l))) {
  79.                                         return i * 7 + m;
  80.                                 }
  81.                         }
  82.                 }

  84.         }
  85.         return 0;
  86. }

  88. void main() {
  89.         while (1) {
  90.                 display(key_scan());
  91.         }
  92. }
复制代码
回复

使用道具 举报

6#
ID:954686 发表于 2021-9-12 17:03 | 只看该作者
不错，这个例程好。IO不够的时候，之前用过4个IO口实现16个按键的方法，和楼主的电路差不多。
回复

使用道具 举报

7#
ID:795427 发表于 2021-9-16 10:33 | 只看该作者
npn 发表于 2021-9-12 16:58
这个程序还可以优化很多，仿真测试OK。

感谢坛友的集思广益，群策群力，在源代码基础上做的优化和改进。
回复

使用道具 举报

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

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表