21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 有关51单片机程序函数使用的疑问
返回列表 发新帖我要提问

[51单片机] 有关51单片机程序函数使用的疑问

[复制链接]
1060|3
 楼主| 快鲨1 发表于 2019-5-14 23:52 | 显示全部楼层 |阅读模式
51单片机, 单片机程序, 函数, code, ST
复制
  1. #include<reg52.h>
    


  2. 

  3. sbit KEY_IN_1 = P2^4;
    

  4. sbit KEY_IN_2 = P2^5;
    

  5. sbit KEY_IN_3 = P2^6;
    

  6. sbit KEY_IN_4 = P2^7;
    

  7. sbit KEY_OUT_1 = P2^3;
    

  8. sbit KEY_OUT_2 = P2^2;
    

  9. sbit KEY_OUT_3 = P2^1;
    

  10. sbit KEY_OUT_4 = P2^0;
    

  11. signed long beats = 0;
    

  12. unsigned char KeySta[4][4] = { 
    

  13.         {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
    

  14.         };
    


  15. 

  16. unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
    

  17.     { 0x31, 0x32, 0x33, 0x26 }, //数字键1、数字键2、数字键3、向上键
    

  18.     { 0x34, 0x35, 0x36, 0x25 }, //数字键4、数字键5、数字键6、向左键
    

  19.     { 0x37, 0x38, 0x39, 0x28 }, //数字键7、数字键8、数字键9、向下键
    

  20.     { 0x30, 0x1B, 0x0D, 0x27 }  //数字键0、ESC键、  回车键、 向右键
    

  21.         };
    

  22. void  KeyDriver();
    

  23. void main()
    

  24. {
    

  25.     EA = 1;       //使能总中断
    

  26.     TMOD = 0x01;  //设置T0为模式1
    

  27.     TH0  = 0xFC;  //为T0赋初值0xFC67，定时1ms
    

  28.     TL0  = 0x67;
    

  29.     ET0  = 1;     //使能T0中断
    

  30.     TR0  = 1;     //启动T0
    

  31.         
    

  32.     while (1)
    

  33.     {
    

  34.         KeyDriver();   //调用按键驱动函数
    

  35.     }
    

  36. }
    


  37. 

  38. void StartMotor(signed long angle)
    

  39. {
    

  40.         EA = 0;
    

  41.         beats = (angle*4076)/360;
    

  42.         EA = 1;
    

  43. }
    

  44. void StopMotor()
    

  45. {
    

  46.         EA = 0;
    

  47.         beats = 0;
    

  48.         EA = 1;
    

  49. }
    

  50. void KeyAction(unsigned char keycode)
    

  51. {
    

  52.         static bit dirMotor = 0;
    

  53.         
    

  54.         if((keycode >= 0x30) &&(keycode <= 0x39))
    

  55.         {
    

  56.                 if(dirMotor == 0)
    

  57.                 {
    

  58.                         StartMotor(360 * (keycode - 0x30));
    

  59.                 }
    

  60.                 else
    

  61.                 {
    

  62.                         StartMotor(-360 * (keycode - 0x30));        
    

  63.                 }
    

  64.         }
    

  65.         
    

  66.         else if(keycode == 0x26)
    

  67.         {
    

  68.                 dirMotor = 0;
    

  69.         }
    

  70.         else if(keycode == 0x28)
    

  71.         {
    

  72.                 dirMotor = 1;
    

  73.         }
    

  74.         else if(keycode == 0x25)
    

  75.         {
    

  76.                 StartMotor(90);
    

  77.         }
    

  78.         else if(keycode == 0x27)
    

  79.         {
    

  80.                 StartMotor(-90);
    

  81.         }
    


  82. 


  83. 

  84.         else if(keycode == 0x1B)
    

  85.         {
    

  86.                 StopMotor();         
    

  87.         }        
    

  88.          
    

  89. }
    

  90. void  KeyDriver()
    

  91. {
    

  92.         unsigned char i, j;
    

  93.         static        unsigned char backup [4][4] = {
    

  94.         {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
    

  95.         };
    


  96. 

  97.         for(i=0; i<4; i++)
    

  98.                 {
    

  99.                         for(j=0; j<4; j++)
    

  100.                         {
    

  101.                                 if(backup[i][j] != KeySta[i][j])
    

  102.                                 {
    

  103.                                         if(backup[i][j] == 0)
    

  104.                                         {
    

  105.                                                 KeyAction(KeyCodeMap[i][j]);
    

  106.                                         }
    

  107.                                         backup[i][j] = KeySta[i][j];
    

  108.                                 }
    

  109.                         }        
    

  110.                 }
    


  111. 

  112.         
    

  113. }
    


  114. 

  115. /* 按键扫描函数，需在定时中断中调用，推荐调用间隔1ms */
    

  116. void KeyScan()
    

  117. {
    

  118.     unsigned char i;
    

  119.     static unsigned char keyout = 0;   //矩阵按键扫描输出索引
    

  120.     static unsigned char keybuf[4][4] = {  //矩阵按键扫描缓冲区
    

  121.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF},
    

  122.         {0xFF, 0xFF, 0xFF, 0xFF},  {0xFF, 0xFF, 0xFF, 0xFF}
    

  123.     };
    


  124. 

  125.     //将一行的4个按键值移入缓冲区
    

  126.     keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
    

  127.     keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
    

  128.     keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
    

  129.     keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
    

  130.     //消抖后更新按键状态
    

  131.     for (i=0; i<4; i++)  //每行4个按键，所以循环4次
    

  132.     {
    

  133.         if ((keybuf[keyout][i] & 0x0F) == 0x00)
    

  134.         {   //连续4次扫描值为0，即4*4ms内都是按下状态时，可认为按键已稳定的按下
    

  135.             KeySta[keyout][i] = 0;
    

  136.         }
    

  137.         else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
    

  138.         {   //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
    

  139.             KeySta[keyout][i] = 1;
    

  140.         }
    

  141.     }
    

  142.     //执行下一次的扫描输出
    

  143.     keyout++;                //输出索引递增
    

  144.     keyout = keyout & 0x03;  //索引值加到4即归零
    

  145.     switch (keyout)          //根据索引，释放当前输出引脚，拉低下次的输出引脚
    

  146.     {
    

  147.         case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
    

  148.         case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
    

  149.         case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
    

  150.         case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
    

  151.         default: break;
    

  152.     }
    

  153. }
    


  154. 

  155. void TurnMotor()
    

  156. {
    

  157.         unsigned char tmp;
    

  158.         static unsigned char index = 0;
    

  159.         unsigned char code BeatCode[8] = {
    

  160.         0x0E, 0x0C, 0x0D, 0x09, 0x0B, 0x03, 0x07, 0x06};
    


  161. 

  162.         if(beats != 0)
    

  163.         {
    

  164.                 if(beats > 0)
    

  165.                 {
    

  166.                         index++;
    

  167.                         index = index & 0x07;
    

  168.                         beats--;
    

  169.                 }
    

  170.                 else
    

  171.                 {
    

  172.                         index--;
    

  173.                         index = index & 0x07;
    

  174.                         beats++;
    

  175.                 }
    

  176.                 tmp = P1;
    

  177.                 tmp = tmp & 0xF0;
    

  178.                 tmp = tmp | BeatCode[index];                         
    

  179.                 P1 = tmp;
    

  180.         }
    

  181.         else
    

  182.         {
    

  183.                 P1 = P1 | 0x0F;
    

  184.         }
    

  185. }
    

  186. /* T0中断服务函数，用于数码管显示扫描与按键扫描 */
    

  187. void InterruptTimer0() interrupt 1
    

  188. {
    

  189.         static bit div = 0;
    


  190. 

  191.         TH0 = 0xFC;
    

  192.         TL0 = 0x67;
    


  193. 

  194.         KeyScan();
    


  195. 

  196.         div = ~ div;
    

  197.         if(div == 1)
    

  198.         {
    

  199.                 TurnMotor();
    

  200.         }
    


  201. 


  202. 

  203. }
复制
  1. #include
    


  2. 

  3. sbit ADDR0 = P1^0;
    


  4. 

  5. sbit ADDR1 = P1^1;
    


  6. 

  7. sbit ADDR2 = P1^2;
    


  8. 

  9. sbit ADDR3 = P1^3;
    


  10. 

  11. sbit ENLED = P1^4;
    


  12. 

  13. unsigned char code LedChar[] = {  //数码管显示字符转换表
    


  14. 

  15.     0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    


  16. 

  17.     0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
    


  18. 

  19. };
    


  20. 

  21. unsigned char LedBuff[6] = {  //数码管显示缓冲区，初值 0xFF 确保启动时都不亮
    


  22. 

  23.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
    


  24. 

  25. };
    


  26. 

  27. void SecondCount();
    


  28. 

  29. void LedRefresh();
    


  30. 

  31. void main(){
    


  32. 

  33.     ENLED = 0;  //使能 U3，选择控制数码管
    


  34. 

  35.     ADDR3 = 1;  //因为需要动态改变 ADDR0-2 的值，所以不需要再初始化了
    


  36. 

  37.     TMOD = 0x01;  //设置 T0 为模式 1
    


  38. 

  39.     TH0 = 0xFC;  //为 T0 赋初值 0xFC67，定时 1ms
    


  40. 

  41.     TL0 = 0x67;
    


  42. 

  43.     TR0 = 1;  //启动 T0
    


  44. 

  45.     while (1){
    


  46. 

  47.         if (TF0 == 1){  //判断 T0 是否溢出
    


  48. 

  49.             TF0 = 0;  //T0 溢出后，清零中断标志
    


  50. 

  51.             TH0 = 0xFC;  //并重新赋初值
    


  52. 

  53.             TL0 = 0x67;
    


  54. 

  55.             SecondCount();  //调用秒计数函数
    


  56. 

  57.             LedRefresh();  //调用显示刷新函数
    


  58. 

  59.         }
    


  60. 

  61.     }
    


  62. 

  63. }
    


  64. 

  65. /* 秒计数函数，每秒进行一次秒数+1，并转换为数码管显示字符 */
    


  66. 

  67. void SecondCount(){
    


  68. 

  69.     static unsigned int cnt = 0;  //记录 T0 中断次数
    


  70. 

  71.     static unsigned long sec = 0;  //记录经过的秒数
    


  72. 

  73.     cnt++;  //计数值自加 1
    


  74. 

  75.     if (cnt >= 1000){  //判断 T0 溢出是否达到 1000 次
    


  76. 

  77.         cnt = 0;  //达到 1000 次后计数值清零
    


  78. 

  79.         sec++;  //秒计数自加 1
    


  80. 

  81.        
    


  82. 

  83.         LedBuff[0] = LedChar[sec%10];
    


  84. 

  85.         LedBuff[1] = LedChar[sec/10%10];
    


  86. 

  87.         LedBuff[2] = LedChar[sec/100%10];
    


  88. 

  89.         LedBuff[3] = LedChar[sec/1000%10];
    


  90. 

  91.         LedBuff[4] = LedChar[sec/10000%10];
    


  92. 

  93.         LedBuff[5] = LedChar[sec/100000%10];
    


  94. 

  95.     }
    


  96. 

  97. }
    


  98. 

  99. /* 数码管动态扫描刷新函数 */
    


  100. 

  101. void LedRefresh(){
    


  102. 

  103.     static unsigned char i = 0; //动态扫描的索引
    


  104. 

  105.     switch (i){
    


  106. 

  107.         case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
    


  108. 

  109.         case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
    


  110. 

  111.         case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
    


  112. 

  113.         case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
    


  114. 

  115.         case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
    


  116. 

  117.         case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5]; break;
    


  118. 

  119.         default: break;
    


  120. 

  121.     }
    


  122. 

  123. }
这里有两个程序，一个是在main()里只调用了一个KeyDriver()函数，另一个是在main()调用SecondCount()和LedRefresh()函数，我想问一下为什么第一个程序没有像第二个程序那样子写直接在main里面调用函数，而是在函数里面调用函数。我应该怎么去理解第一个程序，难道要跟着他的函数思路跳来跳去？例如第一个是KeyDriver函数,然后到backup--->Keysta--->KeyCodeMap---->然后呢？我没找到去哪个函数了。这样子怎么办，各位是如何处理这样子的问题的？我应该怎么理解这样子的程序？如果跟着函数跳来跳去的话，代码量一多起来的话脑袋都绕晕了还怎么理解程序？
回复

收藏 举报

相关帖子
叶春勇 发表于 2019-5-15 21:43 | 显示全部楼层
要理解这种程序，你应该要建立一种模块化思想。
例如程序一的按键处理。
1、硬件扫描，就是读取io状态。这个跟单片机有关，不可移植。
第一个程序，把它弄到定时器中断里，每1ms扫描一次。就是这个keyscan
2、在硬件扫描的基础上建立，软按键，例如处理“按下”，“释放“，”长按“，”短按“，”双击“.这部分代码属于中间层。是可以用在别的单片机上的。
第一个程序，把这些也跟定时器中断搞在一起了，但是软件分层思想他有了。以我的软件水平，可以剥离硬件。
3、在软按键的基础上，是不是还有个按键处理。就是要执行命令。
就是这个keyaction
当然你也可以写道一起，但是在下个项目中，你可能还得写一遍。作为程序员，应该程序越写越少。每个项目都有一定的积累。
基于这个思想
按键处理分为：
1、硬件驱动。平台有关。
2、中间耦合层，强化处理。平台无关，项目无关。
3、事务处理。项目有关。
那么通过这个项目，你得到了一个中间耦合层，下次你还用到键盘处理的时候，你就有积累了。
另外，你这个程序1代码，水平还很低。相信你能超越他的。
回复

收藏 举报

datouyuan 发表于 2019-5-17 14:38 | 显示全部楼层
Keysta//由中断调用KeyScan()产生
backup//Keysta的备份。假如Keysta发生变化，0->1不处理只备份。1->0先处理，再备份。
KeyCodeMap//如何处理
回复

收藏 举报

datouyuan 发表于 2019-5-17 14:42 | 显示全部楼层
0->1不处理只备份。可以理解为按键抬起。
1->0先处理，再备份。可以理解为按键按下。

在51下，用一个字节表示一个位，太浪费了。
回复

收藏 举报

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

本版积分规则

快鲨1

13

主题

45

帖子

0

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