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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机数码管矩阵按键控制
返回列表 发新帖
查看: 3423|回复: 1
收起左侧

单片机数码管矩阵按键控制

[复制链接]
ID:234344 发表于 2017-11-18 22:18 | 显示全部楼层 |阅读模式
QQ图片20171118221748.jpg QQ图片20171118221732.jpg
效果：：每次按下的键对应的编码显示在数码管最后一位，之前的数码管显示的向左移动一位

单片机：：stc89c52


代码：
  1. #include <REG52.h>
  2. typedef unsigned int uint;
  3. typedef unsigned char uchar;

  5. #define GPIO_DIG P0
  6. #define GPIO_KEY P1
  7. uint j=0,ii=1000,kk=0,pp;
  8. sbit LSA=P2^2;
  9. sbit LSB=P2^3;
  10. sbit LSC=P2^4;
  11. uchar  Key;
  12.    uint amd=0;
  13. uchar code  KKK[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71} ;
  14. uchar code app[]={0x00,0x04,0x08,0x0c,0x10,0x14,0x18,0x1c};        
  15. uchar amm[100];
  16. void delay(uint j)
  17. {
  18.   while(j--);
  19. }

  21. void KeyDown(void)
  22. {
  23.         char a=0;
  24.         GPIO_KEY=0x0f;
  25.         if(GPIO_KEY!=0x0f)
  26.         {
  27.                 delay(1000);
  28.                 if(GPIO_KEY!=0x0f)
  29.                 {
  30.                         GPIO_KEY=0x0f;        
  31.                 //行
  32.                 kk++;
  33.                         switch(GPIO_KEY)
  34.                         {
  35.                                  case(0x07):Key=0;break;
  36.                                   case(0x0b):Key=1;break;
  37.                                   case(0x0d):Key=2;break;
  38.                                  case(0x0e):Key=3;break;
  39.                         }  
  40.                 GPIO_KEY=0xf0;
  41.                
  42.                 //列
  43.                 switch (GPIO_KEY)
  44.                 {
  45.                          case(0x70):Key=Key+0;break;
  46.                          case(0xb0):Key=Key+4;break;
  47.                          case(0xd0):Key=Key+8;break;
  48.                          case(0xe0):Key=Key+12;break;
  49.                 }
  50.                 while((a<50)&&(GPIO_KEY= 0xf0))
  51.                 {
  52.                         delay(1000);
  53.                         a++;
  54.                 }
  55.         }
  56. }
  57. }

  59. void main()
  60. {
  61.         LSA=0;
  62.         LSB=0;
  63.         LSC=0;
  64.         while(1)
  65.         {
  66.                 KeyDown();
  67.                 if(kk==1)
  68.                 {
  69.                         P2=~app[0];
  70.                         GPIO_DIG= KKK[Key];
  71.                         amm[0]=KKK[Key];
  72.                 }
  73.                
  74.                 if(kk==2)
  75.                 {
  76.                          P2=~app[1];
  77.                          GPIO_DIG= amm[0];
  78.                          delay(100);
  79.                          P2=~app[0];
  80.                          GPIO_DIG= KKK[Key];
  81.                          amm[1]=KKK[Key];
  82.                          delay(100);
  83.                 }
  84.                 if(kk==3)
  85.                 {
  86.                         P2=~app[2];
  87.                         GPIO_DIG= amm[0];
  88.                         delay(100);
  89.                          P2=~app[1];
  90.                          GPIO_DIG= amm[1];
  91.                          delay(100);
  92.                          P2=~app[0];
  93.                           GPIO_DIG= KKK[Key];
  94.                           amm[2]=KKK[Key];
  95.                           delay(100);
  96.                 }        
  97.                 if(kk==4)
  98.                 {
  99.                         P2=~app[3];         
  100.                         GPIO_DIG= amm[0];
  101.                          delay(100);
  102.                          P2=~app[2];
  103.                         GPIO_DIG= amm[1];
  104.                          delay(100);
  105.                          P2=~app[1];
  106.                          GPIO_DIG=amm[2];
  107.                          delay(100);
  108.                          P2=~app[0];
  109.                           GPIO_DIG= KKK[Key];
  110.                           amm[3]=KKK[Key];
  111.                           delay(100);
  112.                 }
  113.                 if(kk==5)
  114.                 {
  115.                         P2=~app[4];
  116.                         GPIO_DIG= amm[0];
  117.                          delay(100);
  118.                           P2=~app[3];
  119.                          GPIO_DIG= amm[1];
  120.                          delay(100);
  121.                         P2=~app[2];
  122.                         GPIO_DIG= amm[2];
  123.                          delay(100);
  124.                          P2=~app[1];
  125.                          GPIO_DIG= amm[3];
  126.                          delay(100);
  127.                          P2=~app[0];
  128.                           GPIO_DIG= KKK[Key];
  129.                           amm[4]=KKK[Key];
  130.                           delay(100);
  131.                 }
  132.                 if(kk==6)
  133.                 {
  134.                         P2=~app[5];
  135.                         GPIO_DIG= amm[0];
  136.                          delay(100);
  137.                          P2=~app[4];
  138.                         GPIO_DIG= amm[1];
  139.                          delay(100);
  140.                           P2=~app[3];
  141.                          GPIO_DIG= amm[2];
  142.                          delay(100);
  143.                           P2=~app[2];
  144.                         GPIO_DIG= amm[3];
  145.                          delay(100);
  146.                          P2=~app[1];
  147.                          GPIO_DIG= amm[4];
  148.                          delay(100);
  149.                          P2=~app[0];
  150.                           GPIO_DIG= KKK[Key];
  151.                           amm[5]=KKK[Key];
  152.                           delay(100);}
  153.                 if(kk==7)
  154.                 {
  155.                         P2=~app[6];
  156.                         GPIO_DIG=amm[0];
  157.                          delay(100);
  158.                          P2=~app[5];
  159.                         GPIO_DIG= amm[1];
  160.                          delay(100);
  161.                          P2=~app[4];
  162.                         GPIO_DIG= amm[2];
  163.                          delay(100);
  164.                           P2=~app[3];
  165.                          GPIO_DIG= amm[3];
  166.                          delay(100);
  167.                            P2=~app[2];
  168.                         GPIO_DIG= amm[4];
  169.                          delay(100);
  170.                          P2=~app[1];
  171.                          GPIO_DIG= amm[5];
  172.                          delay(100);
  173.                          P2=~app[0];
  174.                           GPIO_DIG= KKK[Key];
  175.                           amm[6]=KKK[Key];
  176.                           delay(100);
  177.                         }
  178.                 if(kk==8)
  179.                 {  
  180.                         P2=~app[7];
  181.                         GPIO_DIG= amm[0];
  182.                          delay(100);
  183.                          P2=~app[6];
  184.                         GPIO_DIG=amm[1];
  185.                          delay(100);
  186.                          P2=~app[5];
  187.                         GPIO_DIG= amm[2];
  188.                          delay(100);
  189.                          P2=~app[4];
  190.                         GPIO_DIG= amm[3];
  191.                          delay(100);
  192.                         P2=~app[3];
  193.                          GPIO_DIG= amm[4];
  194.                          delay(100);
  195.                         P2=~app[2];
  196.                         GPIO_DIG= amm[5];
  197.                          delay(100);
  198.                          P2=~app[1];
  199.                          GPIO_DIG= amm[6];
  200.                          delay(100);
  201.                          P2=~app[0];
  202.                           GPIO_DIG= KKK[Key];
  203.                           amm[7]=KKK[Key];
  204.                           delay(100);
  205.                 }
  206.                  if(kk==9)
  207.                 {  

  209.                         P2=~app[7];
  210.                         GPIO_DIG= amm[1];
  211.                         delay(100);
  212.                          P2=~app[6];
  213.                         GPIO_DIG=amm[2];
  214.                          delay(100);
  215.                          P2=~app[5];
  216.                         GPIO_DIG= amm[3];
  217.                          delay(100);
  218.                          P2=~app[4];
  219.                         GPIO_DIG= amm[4];
  220.                          delay(100);
  221.                         P2=~app[3];
  222.                          GPIO_DIG= amm[5];
  223.                          delay(100);
  224.                         P2=~app[2];
  225.                         GPIO_DIG= amm[6];
  226.                          delay(100);
  227.                          P2=~app[1];
  228.                          GPIO_DIG= amm[7];
  229.                          delay(100);
  230.                          P2=~app[0];
  231.                           GPIO_DIG= KKK[Key];
  232.                            amm[8]=KKK[Key];
  233.                           delay(100);
  234.                  }
  235.                   if(kk>9)
  236.                   {
  237.                            amd++;
  238.                           P2=~app[7];
  239.                         GPIO_DIG= amm[kk-8];
  240.                          delay(100);
  241.                          P2=~app[6];
  242.                         GPIO_DIG=amm[kk-7];
  243.                          delay(100);
  244.                          P2=~app[5];
  245.                         GPIO_DIG= amm[kk-6];
  246.                          delay(100);
  247.                          P2=~app[4];
  248.                         GPIO_DIG= amm[kk-5];
  249.                          delay(100);
  250.                         P2=~app[3];
  251.                          GPIO_DIG= amm[kk-4];
  252.                          delay(100);
  253.                         P2=~app[2];
  254.                         GPIO_DIG= amm[kk-3];
  255.                          delay(100);
  256.                          P2=~app[1];
  257.                          GPIO_DIG= amm[kk-2];
  258.                          delay(100);
  259.                          P2=~app[0];
  260.                           GPIO_DIG= KKK[Key];
  261.                    amm[kk-1]=KKK[Key];
  262.                           delay(100);
  263.                   }
  264.           }
  265. }
复制代码






回复

使用道具 举报

ID:252128 发表于 2017-11-21 23:38 来自手机 | 显示全部楼层
楼主，你好，我有问题想问你，我今天刚好做这个实验，我可以加你吗？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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