您可以捐助，支持我们的公益事业。

1元 10元 50元





认证码：  验证码,看不清楚?请点击刷新验证码 必填



  求知 文章 文库 Lib 视频 iPerson 课程 认证 咨询 工具 讲座 Model Center   Code  
会员   
   
 
     
   
 
 订阅
51单片机入门基础知识
 
作者： 王家寧
   次浏览      次
 2023-12-22
 
编辑推荐:
本文讲解了51单片机入门基础知识相关内容。希望对您的学习有所帮助。
本文来自于CSDN，由火龙果软件Linda编辑、推荐。

一、单片机介绍

单片机，英文Micro Controller Unit，简称MCU

内部集成了CPU、RAM、ROM、定时器、中断系统、通讯接口等一系列电脑的常用硬件功能

单片机的任务是信息采集（依靠传感器）、处理（依靠CPU）和硬件设备（例如电机，LED等）的控制

单片机跟计算机相比，单片机算是一个袖珍版计算机，一个芯片就能构成完整的计算机系统。但在性能上，与计算机相差甚远，但单片机成本低、体积小、结构简单，在生活和工业控制领域大有所用

同时，学习使用单片机是了解计算机原理与结构的最佳选择

51单片机是指80年代Intel开发的8051单片机内核的统称，就是因为这个“8051”有个51，所以凡是与“8051”内核一样的单片机都统称为51系列单片机

二、LED代码

2-1点亮一个LED

这里使用的普中单片机的LED是共阳极，所以将P2寄存器设置值为如下0xFE //1111 1110

  1.  #include <REGX52.H>
  2.  ​
  3.  voidmain()
  4.  {
  5.      P2=0xFE;  //1111 1110
  6.  }

2-2LED循环闪烁

通过调用延时函数实现闪烁

  1.  #include <REGX52.H>
  2.  #include <INTRINS.H>  //_nop_()函数所在库
  3.  ​
  4.  voidDelay500ms()       //@11.0592MHz
  5.  {
  6.      unsignedchari, j, k;
  7.  ​
  8.      _nop_();  //空操作，延时一个指令的时间
  9.      i=4;
  10.      j=129;
  11.      k=119;
  12.      do
  13.      {
  14.          do
  15.          {
  16.              while (--k);
  17.          } while (--j);
  18.      } while (--i);
  19.  }
  20.  ​
  21.  voidmain()
  22.  {
  23.      
  24.      while(1)
  25.      {
  26.          P2=0x00;
  27.          Delay500ms();  //这里是通过STC-ISP软件生成的延时函数调用
  28.          P2=0xFF;
  29.          Delay500ms();
  30.      }
  31.  }

 

2-3LED流水灯

通过进行P2寄存器的不断延时赋值实现流水灯-基础版

  1.  #include <REGX52.H>
  2.  #include <INTRINS.H>  //_nop_()函数所在库
  3.  ​
  4.  voidDelay500ms()       //@11.0592MHz
  5.  {
  6.      unsignedchari, j, k;
  7.  ​
  8.      _nop_();  //空操作，延时一个指令的时间
  9.      i=4;
  10.      j=129;
  11.      k=119;
  12.      do
  13.      {
  14.          do
  15.          {
  16.              while (--k);
  17.          } while (--j);
  18.      } while (--i);
  19.  }
  20.  ​
  21.  voidmain()
  22.  {
  23.      
  24.      while(1)
  25.      {
  26.          P2=0xFE;      //1111 1110
  27.          Delay500ms();  //这里是通过STC-ISP软件生成的延时函数调用
  28.          P2=0xFD;      //1111 1101
  29.          Delay500ms();
  30.          P2=0xFB;      //1111 1011
  31.          Delay500ms();  
  32.          P2=0xF7;      //1111 0111
  33.          Delay500ms();
  34.          P2=0xEF;      //1110 1111
  35.          Delay500ms();  
  36.          P2=0xDF;      //1101 1111
  37.          Delay500ms();
  38.          P2=0xBF;      //1011 1111
  39.          Delay500ms();  
  40.          P2=0x7F;      //0111 1111
  41.          Delay500ms();
  42.      }
  43.  }

2-4LED流水灯Plus

优化含参延时函数,但是会有一定的误差

  1.  #include <REGX52.H>
  2.  #include <INTRINS.H>  //_nop_()函数所在库
  3.  ​
  4.  voidDelay1ms(xms)      //@11.0592MHz
  5.  {
  6.      unsignedchari, j;
  7.      while(xms)
  8.      {
  9.          _nop_();
  10.          i=2;
  11.          j=199;
  12.          do
  13.          {
  14.              while (--j);
  15.          } while (--i);
  16.          xms--;
  17.      }
  18.  }
  19.  ​
  20.  ​
  21.  voidmain()
  22.  {
  23.      
  24.      while(1)
  25.      {
  26.          P2=0xFE;      //1111 1110
  27.          Delay1ms(500);  //优化含参延时函数
  28.          P2=0xFD;      //1111 1101
  29.          Delay1ms(500);
  30.          P2=0xFB;      //1111 1011
  31.          Delay1ms(500);
  32.          P2=0xF7;      //1111 0111
  33.          Delay1ms(500);
  34.          P2=0xEF;      //1110 1111
  35.          Delay1ms(500); 
  36.          P2=0xDF;      //1101 1111
  37.          Delay1ms(500);
  38.          P2=0xBF;      //1011 1111
  39.          Delay1ms(500);
  40.          P2=0x7F;      //0111 1111
  41.          Delay1ms(500);
  42.      }
  43.  }

 

三、独立按键与LED

轻触按键：相当于是一种电子开关，按下时开关接通，松开时开关断开，实现原理是通过轻触按键内部的金属弹片受力弹动来实现接通和断开

LED发光二极管：Light Emitting Diode

LED正极引脚较长，负极引脚较短

LED正极闪电极较小，负极闪电极较小（在玻璃灯罩里面的）

3-1独立按键控制LED亮灭

通过循环和判断实现按键控制LED亮灭功能

  1.  #include <REGX52.H>
  2.  voidmain()
  3.  ​
  4.  {
  5.      while(1)
  6.      {
  7.          if(P3_1==0)
  8.              P2_0=0;
  9.          else
  10.              P2_0=1;
  11.      }
  12.  }

 

3-2独立按键控制LED状态

按键的抖动

对于机械开关，当机械触点断开、闭合时，由于机械触点的弹性作用，一个开关在闭合时不会马上稳定地接通，在断开时也不会一下子断开，所以在开关闭合及断开的瞬间会伴随一连串的抖动

为了避免误操作，需要进行消抖处理：硬件消抖、软件消抖

硬件消抖： RS触发器、电容充放电滤波等方式

软件消抖：Delay函数延时消抖，定时消抖以及外部中断消抖

  1. #include <REGX52.H>
  2. #include <intrins.h>
  3.  
  4. void Delay(unsigned int xms)        //@11.0592MHz
  5. {
  6.     unsigned char i, j;
  7.  
  8.     while(xms)
  9.     {    
  10.         _nop_();
  11.         i = 2;
  12.         j = 199;
  13.         do
  14.         {
  15.             while (--j);
  16.         } while (--i);
  17.     xms--;
  18.     }
  19. }
  20.  
  21.  
  22. void main()
  23. {
  24.     while(1)
  25.     {
  26.             if(P3_1==0)
  27.             {
  28.                 Delay(20);
  29.                 while(P3_1==0);  //判断是否还在按下按键，等松开时跳出循环，并延时消抖，执行相关操作
  30.                 Delay(20);
  31.                 P2_0=~P2_0;
  32.             }
  33.     }    
  34. }

3-3独立按键控制LED显示二进制

通过二进制值的输出来让LED显示

  1. #include <REGX52.H>
  2. #include <intrins.h>
  3.  
  4. void Delay(unsigned int xms)        //@11.0592MHz
  5. {
  6.     unsigned char i, j;
  7.  
  8.     while(xms--)
  9.     {    
  10.         _nop_();
  11.         i = 2;
  12.         j = 199;
  13.         do
  14.         {
  15.             while (--j);
  16.         } while (--i);
  17.     }
  18. }
  19. void main()
  20. {
  21.     unsigned char LEDnum;        //定义无符号字符变量用来存储二进制
  22.     while(1)
  23.     {    
  24.             if(P3_1==0)
  25.             {
  26.                 Delay(20);
  27.                 while(P3_1==0);
  28.                 Delay(20);
  29.                 LEDnum++;     //逐渐递增
  30.                 P2=~LEDnum;  //并将二进制结果传给P2寄存器，因为LED共阳极，低电平亮，所以取反
  31.                 // P2_0=~P2_0;   //这样不行是因为会导致P2_0值改变
  32.             }
  33.     }
  34. }

 

3-4独立按键控制LED移位

通过C语言移位指令以及对LEDNum变量值的控制来完成LED移位显示操作

  1. #include <REGX52.H>
  2. #include <intrins.h>
  3.  
  4. void Delay(unsigned int xms)        //@11.0592MHz
  5. {
  6.     unsigned char i, j;
  7.  
  8.     while(xms--)
  9.     {    
  10.         _nop_();
  11.         i = 2;
  12.         j = 199;
  13.         do
  14.         {
  15.             while (--j);
  16.         } while (--i);
  17.     }
  18. }
  19.  
  20. unsigned char LEDnum;
  21.  
  22. void main()
  23. {
  24.     while(1)
  25.     {
  26.         if(P3_1==0)
  27.         {
  28.             Delay(20);
  29.             while(P3_1==0);
  30.             Delay(20);
  31.             
  32.             LEDnum++;
  33.             if(LEDnum>=8)   //当到8的时候应该先清零再进行取反，不然灯会不亮
  34.                 LEDnum=0;
  35.             P2=~(0x01<<LEDnum);
  36.         }
  37.         if(P3_0==0)
  38.         {
  39.             Delay(20);
  40.             while(P3_0==0);
  41.             Delay(20);
  42.             
  43.             if(LEDnum==0)  //因为定义的是无符号字符变量，所以为了避免向下溢出，进行0值判断置7操作
  44.                 LEDnum=7;
  45.             else
  46.                 LEDnum--;
  47.             P2=~(0x01<<LEDnum);
  48.         }
  49.         
  50.     }
  51.  
  52. }

 

四、数码管

4-1静态数码管显示

注意若用开发板的时候不要接LCD1602显示屏，因为引脚共用原因会导致数字显示异常

  1.  #include <REGX52.H>
  2.  #include <intrins.h>
  3.  ​
  4.  voidDelay(unsignedintxms)        //@11.0592MHz
  5.  {
  6.      unsignedchari, j;
  7.  ​
  8.      while(xms)
  9.      {   
  10.          _nop_();
  11.          i=2;
  12.          j=199;
  13.          do
  14.          {
  15.              while (--j);
  16.          } while (--i);
  17.      xms--;
  18.      }
  19.  }
  20.  ​
  21.  unsignedcharNixieTable[]=
  22.  {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
  23.  0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};   //定义数码管数组，用来存储显示对应数字时应该给寄存器赋的值
  24.  voidNixie(unsignedcharLocation,Number)
  25.  {
  26.      switch(Location)        //Location用来接收数字在哪一个数码管显示，通过三八译码器来实现数码管的选择
  27.      {
  28.          case1:P2_4=1;P2_3=1;P2_2=1;break;      
  29.          case2:P2_4=1;P2_3=1;P2_2=0;break;
  30.          case3:P2_4=1;P2_3=0;P2_2=1;break;
  31.          case4:P2_4=1;P2_3=0;P2_2=0;break;
  32.          case5:P2_4=0;P2_3=1;P2_2=1;break;
  33.          case6:P2_4=0;P2_3=1;P2_2=0;break;
  34.          case7:P2_4=0;P2_3=0;P2_2=1;break;
  35.          case8:P2_4=0;P2_3=0;P2_2=0;break;
  36.      }
  37.      P0=NixieTable[Number];
  38.  }
  39.  ​
  40.  voidmain() 
  41.  {
  42.      while(1)
  43.      {
  44.      Nixie(1,1);     //测试数字循环显示
  45.      Delay(500);
  46.      Nixie(2,2);
  47.      Delay(500);
  48.      Nixie(3,3);
  49.      Delay(500);
  50.      Nixie(4,4);
  51.      Delay(500);
  52.      Nixie(5,5);
  53.      Delay(500);
  54.      Nixie(6,6);
  55.      Delay(500);
  56.      Nixie(7,7);
  57.      Delay(500);
  58.      Nixie(8,8);
  59.      Delay(500);
  60.                          
  61.      Nixie(1,9);
  62.      Delay(500); 
  63.      Nixie(2,0);
  64.      Delay(500);
  65.      
  66.      Nixie(3,10);        //以下为ABCDEF
  67.      Delay(500);
  68.      Nixie(4,11);
  69.      Delay(500);
  70.      Nixie(5,12);
  71.      Delay(500);
  72.      Nixie(6,13);
  73.      Delay(500);
  74.      Nixie(7,14);
  75.      Delay(500);
  76.      Nixie(8,15);
  77.      Delay(500);
  78.      }
  79.  }

 

4-2动态数码管显示

想要进行多个数码管同时显示，需要进行消影操作

出现串位显示的原因是因为数码管的位选和段选出现了交叉，导致串位：位选-段选-位选-段选-位选-段选

消影：位选-段选-清零-位选-段选-清零

  1.  #include <REGX52.H>
  2.  #include <intrins.h>
  3.  ​
  4.  voidDelay(unsignedintxms)        //@11.0592MHz
  5.  {
  6.      unsignedchari, j;
  7.  ​
  8.      while(xms)
  9.      {   
  10.          _nop_();
  11.          i=2;
  12.          j=199;
  13.          do
  14.          {
  15.              while (--j);
  16.          } while (--i);
  17.      xms--;
  18.      }
  19.  }
  20.  ​
  21.  ​
  22.  ​
  23.  unsignedcharNixieTable[]=
  24.  {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
  25.  0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};
  26.  voidNixie(unsignedcharLocation,Number)
  27.  {
  28.      switch(Location)
  29.      {
  30.          case1:P2_4=1;P2_3=1;P2_2=1;break;
  31.          case2:P2_4=1;P2_3=1;P2_2=0;break;
  32.          case3:P2_4=1;P2_3=0;P2_2=1;break;
  33.          case4:P2_4=1;P2_3=0;P2_2=0;break;
  34.          case5:P2_4=0;P2_3=1;P2_2=1;break;
  35.          case6:P2_4=0;P2_3=1;P2_2=0;break;
  36.          case7:P2_4=0;P2_3=0;P2_2=1;break;
  37.          case8:P2_4=0;P2_3=0;P2_2=0;break;
  38.      }
  39.      P0=NixieTable[Number];
  40.      Delay(1);  //保持显示，避免变暗
  41.  ​
  42.      P0=0X00;  //清零进行消影
  43.  }
  44.  ​
  45.  voidmain() 
  46.  {
  47.      while(1)
  48.      {
  49.      Nixie(1,1);
  50.      // Delay(500);    //消除延时之后，再加上消影功能就可以实现同时显示
  51.      Nixie(2,2);
  52.      // Delay(500);
  53.      Nixie(3,3);
  54.      
  55.      }
  56.  }

 

数码管驱动方式：

1.单片机直接扫描：硬件设备简单，但会耗费大量的单片机CPU时间

2.专用驱动芯片：内部自带显存、扫描电路，单片机只需告诉它显示什么即可

以上代码均为针对单片机直接扫描实现的，while(1)不断循环实现

五、LCD1602（模块化编程开始）

5-1模块化编程

模块化编程：

•传统方式编程：所有的函数均放在main.c里，若使用的模块比较多，则一个文件内会有很多的代码，不利于代码的组织和管理，而且很影响编程者的思路

•模块化编程：把各个模块的代码放在不同的.c文件里，在.h文件里提供外部可调用函数的声明，其它.c文件想使用其中的代码时，只需要#include "XXX.h"文件即可。使用模块化编程可极大的提高代码的可阅读性、可维护性、可移植性等

以Delay函数为例

  1.  #include "Delay.h"
  2.  voidmain()
  3.  {
  4.      Delay(10);
  5.  }

Delay.h

  1.  #ifndef __DELAY_H__
  2.  #define __DELAY_H__
  3.  ​
  4.  voidDelay(unsignedintxms);
  5.  ​
  6.  #endif

Delay.c

  1.  voidDelay(unsignedintxms)
  2.  {
  3.      unsignedchari, j;
  4.      while(xms--)
  5.      {
  6.          i=2;
  7.          j=239;
  8.          do
  9.          {
  10.              while (--j);
  11.          } while (--i);
  12.      }
  13.  }

图示

模块化实现数码管显示

  1.  #include <REGX52.H>
  2.  #include "Delay.h"
  3.  #include "Nixie.h"
  4.  ​
  5.  voidmain() 
  6.  {
  7.      while(1)
  8.      {
  9.      Nixie(1,1);
  10.      // Delay(500);
  11.      Nixie(2,2);
  12.      // Delay(500);
  13.      Nixie(3,3);
  14.      Nixie(4,4);
  15.      Nixie(5,5);
  16.      }
  17.  }

Delay.h

  1. #ifndef __DELAY_H__
  2. #define __DELAY_H__
  3.     void Delay(unsigned int xms);
  4. #endif

 

Nixie.h

  1. #ifndef __NIXIE_H__
  2. #define __NIXIE_H__
  3.     void Nixie(unsigned char Location,Number);
  4. #endif

Delay.c

  1. #include <intrins.h>
  2.  
  3. void Delay(unsigned int xms)        //@11.0592MHz
  4. {
  5.     unsigned char i, j;
  6.  
  7.     while(xms)
  8.     {    
  9.         _nop_();
  10.         i = 2;
  11.         j = 199;
  12.         do
  13.         {
  14.             while (--j);
  15.         } while (--i);
  16.     xms--;
  17.     }
  18. }

Nixie.c

  1. #include "Delay.h"
  2. #include <REGX52.H>
  3.  
  4. unsigned char NixieTable[]=
  5. {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,
  6.  0x77,0x7c,0x39,0x5e,0x79,0x71,0x00};
  7.  
  8. void Nixie(unsigned char Location,Number)
  9. {
  10.     switch(Location)
  11.     {
  12.         case 1:P2_4=1;P2_3=1;P2_2=1;break;
  13.         case 2:P2_4=1;P2_3=1;P2_2=0;break;
  14.         case 3:P2_4=1;P2_3=0;P2_2=1;break;
  15.         case 4:P2_4=1;P2_3=0;P2_2=0;break;
  16.         case 5:P2_4=0;P2_3=1;P2_2=1;break;
  17.         case 6:P2_4=0;P2_3=1;P2_2=0;break;
  18.         case 7:P2_4=0;P2_3=0;P2_2=1;break;
  19.         case 8:P2_4=0;P2_3=0;P2_2=0;break;
  20.     }
  21.     P0=NixieTable[Number];
  22.     Delay(1);
  23.     P0=0X00;
  24. }

 

5-2LCD1602调试工具*

LCD1602调试函数模块

不同的LCD1602调试函数代码决定了不同的调试函数以及使用方法

使用时应注意对应的文件函数的异同

函数

作用

LCD_Init();

初始化

LCD_ShowChar(1,1,'A');

显示一个字符

LCD_ShowString(1,3,"Hello");

显示字符串

LCD_ShowNum(1,9,123,3);

显示十进制数字

LCD_ShowSignedNum(1,13,-66,2);

显示有符号十进制数字

LCD_ShowHexNum(2,1,0xA8,2);

显示十六进制数字

LCD_ShowBinNum(2,4,0xAA,8);

显示二进制数字

代码暂略，等后续对头文件以及源代码进行全方面分析之后再复盘补充

六、矩阵键盘

6-1矩阵键盘*

涉及到了施密特触发电路和上拉电阻和下拉电阻，等模电再学一学复盘一下

这里同样使用了前面的LCD1602的调试文件：LCD1602.H、LCD1602.C

编译时会出现WARNING L16: UNCALLED SEGMENT, IGNORED FOR OVERLAY PROCESS的报错，是因为引用的LCD1602的文件中的函数虽然定义了，但是并没有在程序中显式调用到定义过的函数，可以无视，但是会浪费RAM

main.c

  1.  #include "DELAY.H"
  2.  #include "lcd1602.h"
  3.  #include "Delay.h"
  4.  #include "MatrixKey.h"
  5.  ​
  6.  unsignedcharKeyNum;       //定义无符号整型用来接收键码
  7.  ​
  8.  voidmain()
  9.  {
  10.      lcd1602_init();     //初始化LCD1602
  11.      lcd1602_show_string(0,0,"MatrixKey:");//在第一列第一行显示MatrixKey:
  12.      while(1)
  13.      {
  14.          KeyNum=MatrixKey();   //调用函数接收键码
  15.          if(KeyNum)              //接受到键码则判断键码值并显示
  16.          {
  17.              switch(KeyNum)
  18.              {
  19.                case1: lcd1602_show_string(0,1,"1");break;
  20.                  case2: lcd1602_show_string(0,1,"2");break;
  21.                  case3: lcd1602_show_string(0,1,"3");break;
  22.                  case4: lcd1602_show_string(0,1,"4");break;
  23.                  
  24.                  case5: lcd1602_show_string(0,1,"5");break;
  25.                  case6: lcd1602_show_string(0,1,"6");break;
  26.                  case7: lcd1602_show_string(0,1,"7");break;
  27.                  case8: lcd1602_show_string(0,1,"8");break;
  28.                  
  29.                  case9: lcd1602_show_string(0,1,"9");break;
  30.                  case10: lcd1602_show_string(0,1,"10");break;
  31.                  case11: lcd1602_show_string(0,1,"11");break;
  32.                  case12: lcd1602_show_string(0,1,"12");break;
  33.                  
  34.                  case13: lcd1602_show_string(0,1,"13");break;
  35.                  case14: lcd1602_show_string(0,1,"14");break;
  36.                  case15: lcd1602_show_string(0,1,"15");break;
  37.                  case16: lcd1602_show_string(0,1,"16");break;
  38.              }
  39.          }
  40.      }
  41.  }

 

MatrixKey.h

  1. #ifndef __MATRIXKEY_H__
  2. #define __MATRIXKEY_H__
  3.  
  4.     unsigned char MatrixKey();
  5.  
  6. #endif

 

MatrixKey.c

  1.  #include <REGX52.H>
  2.  #include "Delay.h"
  3.  ​
  4.  unsignedcharMatrixKey()
  5.  {
  6.          unsignedcharKeyNumber=0;
  7.          P1=0xff; // 全部拉高
  8.          P1_3=0;  //单独留一个低电位进行扫描按键
  9.          if(P1_7==0){Delay(20);while(P1_7==0);Delay(20);KeyNumber=1;}
  10.          if(P1_6==0){Delay(20);while(P1_6==0);Delay(20);KeyNumber=5;}
  11.          if(P1_5==0){Delay(20);while(P1_5==0);Delay(20);KeyNumber=9;}
  12.          if(P1_4==0){Delay(20);while(P1_4==0);Delay(20);KeyNumber=13;}
  13.          
  14.          P1=0xff; // 全部拉高
  15.          P1_2=0;  //单独留一个低电位进行扫描按键
  16.          if(P1_7==0){Delay(20);while(P1_7==0);Delay(20);KeyNumber=2;}
  17.          if(P1_6==0){Delay(20);while(P1_6==0);Delay(20);KeyNumber=6;}
  18.          if(P1_5==0){Delay(20);while(P1_5==0);Delay(20);KeyNumber=10;}
  19.          if(P1_4==0){Delay(20);while(P1_4==0);Delay(20);KeyNumber=14;}
  20.          
  21.          P1=0xff; // 全部拉高
  22.          P1_1=0;  //单独留一个低电位进行扫描按键
  23.          if(P1_7==0){Delay(20);while(P1_7==0);Delay(20);KeyNumber=3;}
  24.          if(P1_6==0){Delay(20);while(P1_6==0);Delay(20);KeyNumber=7;}
  25.          if(P1_5==0){Delay(20);while(P1_5==0);Delay(20);KeyNumber=11;}
  26.          if(P1_4==0){Delay(20);while(P1_4==0);Delay(20);KeyNumber=15;}
  27.          
  28.          P1=0xff; // 全部拉高
  29.          P1_0=0;  //单独留一个低电位进行扫描按键
  30.          if(P1_7==0){Delay(20);while(P1_7==0);Delay(20);KeyNumber=4;}
  31.          if(P1_6==0){Delay(20);while(P1_6==0);Delay(20);KeyNumber=8;}
  32.          if(P1_5==0){Delay(20);while(P1_5==0);Delay(20);KeyNumber=12;}
  33.          if(P1_4==0){Delay(20);while(P1_4==0);Delay(20);KeyNumber=16;}
  34.      
  35.          returnKeyNumber;
  36.  }

 

6-2矩阵键盘密码锁

所使用的前述模块化列表

LCD1602

Delay

MatrixKey

  1.  #include "lcd1602.h"
  2.  #include "Delay.h"
  3.  #include "MatrixKey.h"
  4.  ​
  5.  unsignedcharKeyNum;   //定义KeyNum用于接收键码值
  6.  unsignedintPassword,Count;  //定义无符号整型用于存储 密码值 和 密码位数
  7.  ​
  8.  voidmain()
  9.  {
  10.      LCD_Init();
  11.      LCD_ShowString(0,1,"Password:");
  12.      while(1)
  13.      {
  14.          KeyNum=MatrixKey();
  15.          if(KeyNum)
  16.          {
  17.              if(KeyNum<=10) //如果S1~S10按键按下，输入密码
  18.              {
  19.                  if(Count<4) //如果位数不超过设定范围
  20.                  {
  21.                      Password*=10; //向左移动一位
  22.                      Password+=KeyNum%10; //累加密码
  23.                      Count++; //计次加一，确保四位
  24.                  }   
  25.                  LCD_ShowNum(1,1,Password,4); //更新显示
  26.              }
  27.              if(KeyNum==11) //确认键
  28.              {
  29.                  if(Password==2345)  //设定密码为2345
  30.                  {
  31.                      LCD_ShowString(1,14,"OK!");
  32.                      Password=0; //密码清零
  33.                      Count=0;  //计次清零
  34.                      LCD_ShowNum(1,1,Password,4); //更新显示
  35.                  }
  36.                  else
  37.                  {
  38.                      LCD_ShowString(1,14,"ERR");
  39.                      Password=0; //密码清零
  40.                      Count=0;  //计次清零
  41.                      LCD_ShowNum(1,1,Password,4); //更新显示
  42.                  }
  43.              }
  44.              if(KeyNum==12) //删除键
  45.              {
  46.                  Password=Password/10; //删除数字
  47.                  LCD_ShowNum(1,1,Password,4); //更新显示
  48.                  Count--; //计次减少
  49.              }
  50.          }
  51.      }
  52.  }

七、定时器

7-1定时器

定时器介绍:

51单片机的定时器属于单片机的内部资源，其电路的连接和运转均在单片机内部完成

定时器作用：

（1）用于计时系统，可实现软件计时，或者使程序每隔一固定时间完成一项操作

（2）替代长时间的Delay，提高CPU的运行效率和处理速度

（3）多任务处理

（…）

STC89C52定时器资源

•定时器个数：3个（T0、T1、T2），T0和T1与传统的51单片机兼容，T2是此型号单片机增加的资源

•注意：定时器的资源和单片机的型号是关联在一起的，不同的型号可能会有不同的定时器个数和操作方式，但一般来说，T0和T1的操作方式是所有51单片机所共有的

定时器框图

定时器在单片机内部就像一个小闹钟一样，根据时钟的输出信号，每隔“一秒”，计数单元的数值就增加一，当计数单元数值增加到“设定的闹钟提醒时间”时，计数单元就会向中断系统发出中断申请，产生“响铃提醒”，使程序跳转到中断服务函数中执行

定时器工作模式

STC89C52的T0和T1均有四种工作模式：

工作模式1（16位定时器/计数器）框图：

SYSclk：系统时钟，用来产生固定频率的脉冲（晶振电路）来使后面的计数器的技术值累加，此时作定时器使用，

MCU in 12T/6T mode：分频模式，例如当晶振频率为12MHz，采用MCU in 12T mode时，产生的脉冲频率就是1MHz

T0 Pin：外部接口，当由外部接口来提供脉冲时，作计数器使用

C/T非：配置寄存器时若其对应的控制字为1，则为Count计数器模式，为0，则为Time定时器模式

TH0和TL0：Time High 0和Time Low 0，代表了定时器的高位和低位，后面的0表示计时器0，计数器共十六位，最大计数值为65535

TF0：Time Flag 0，表示计时器0的标志位，当达到最大技术值后，下一次计数就会溢出，产生脉冲传送到标志位从而影响后面的Interrupt，从而申请中断。

 
   
次浏览       
相关文章
一文了解汽车嵌入式AUTOSAR架构
嵌入式Linux系统移植的四大步骤
嵌入式中设计模式的艺术
嵌入式软件架构设计 模块化 & 分层设计
相关文档
企点嵌入式PHP的探索实践
ARM与STM简介
ARM架构详解
华为鸿蒙深度研究
相关课程
嵌入式C高质量编程
嵌入式操作系统组件及BSP裁剪与测试
基于VxWorks的嵌入式开发、调试与测试
嵌入式单元测试最佳实践

最新活动计划
QT应用开发 11-21[线上]
C++高级编程 11-27[北京]
LLM大模型应用与项目构建 12-26[特惠]
UML和EA进行系统分析设计 12-20[线上]
数据建模方法与工具 12-3[北京]
SysML建模专家 1-16[北京]
 
 
最新文章
基于FPGA的异构计算在多媒体中的应用
深入Linux内核架构——简介与概述
Linux内核系统架构介绍
浅析嵌入式C优化技巧
进程间通信（IPC）介绍
最新课程
嵌入式Linux驱动开发
代码整洁之道-态度、技艺与习惯
嵌入式软件测试
嵌入式C高质量编程
嵌入式软件可靠性设计
成功案例
某军工所 嵌入式软件架构
中航工业某研究所 嵌入式软件开发指南
某轨道交通 嵌入式软件高级设计实践
深圳 嵌入式软件架构设计—高级实践
某企业 基于IPD的嵌入式软件开发
更多...