• 51单片机—智能垃圾桶（定时器）

    一. 定时器

    1. 简介

    C51中的定时器和计数器是同一个硬件电路支持的，通过寄存器配置不同，就可以将他当做定时器或者计数器使用。

    确切的说，定时器和计数器区别是致使他们背后的计数存储器加1的信号不同。当配置为定时器使用时，每经过1个机器周期，计数存储器的值就加1。而当配置为计数器时，每来一个负跳变信号(信号从P3.4 或者P3.5引脚输入)，就加1，以此达到计数的目的。

    标准C51有2个定时器/计数器：T0和T1。他们的使用方法一致。C52相比C51多了一个T2

    1.1 概念解读
    • 定时器和计数器，电路一样
    • 定时或者计数的本质就是让单片机某个部件数数
    • 当定时器用的时候，靠内部震荡电路数数
    • 当计数器用的时候，数外面的信号，读取针脚的数据

    在51单片机中，定时器和计数器的主要区别在于它们的工作方式和用途：

    • 定时器（Timer）：
      • 工作方式：定时器使用内部时钟源（例如晶振）进行计数。
      • 用途：用于计时，例如生成精确的时间延迟、实现周期性中断等。
      • 例子：设定一个定时器来每隔一秒触发一次中断，用于更新系统时钟。
    • 计数器（Counter）：
      • 工作方式：计数器通过外部信号（例如外部引脚上的脉冲信号）进行计数。
      • 用途：用于计数外部事件或脉冲，例如计数输入脉冲的次数。
      • 例子：连接一个传感器到单片机的计数器引脚，计数传感器发出的脉冲信号。
    1.2 定时器怎么定时

    定时器的本质原理： 每经过一个机器周期，就加1 :寄存器

    思考：

    • 什么是晶振

    晶振(晶体震荡器)，又称数字电路的“心脏”，是各种电子产品里面必不可少的频率元器件。数字电

    路的所有工作都离不开时钟，晶振的好坏、晶振电路设计的好坏，会影响到整个系统的稳

    • 什么是时钟周期

    时钟周期也称为振荡周期，定义为时钟频率的倒数。时钟周期是计算机中最基本的、最小的时间单

    位。在一个时钟周期内，CPU仅完成一个最基本的动作。时钟周期是一个时间的量。更小的时钟周

    期就意味着更高的工作频率

    • 什么是机器周期

    机器周期也称为CPU周期。在计算机中，为了便于管理，常把一条指令的执行过程划分为若干个阶

    段（如取指、译码、执行等），每一阶段完成一个基本操作。完成一个基本操作所需要的时间称为

    机器周期。一般情况下，一个机器周期由若干个时钟周期组成

    • 加1经过了多少时间

    当晶振频率是11.0592MHz的时候，等于11059.2KHz = 11059200Hz

    跳一次等于一个机器周期

    一个机器周期等于12个时钟周期

    一个时钟周期等于晶振的倒数：1/11059200秒

    那么跳一次就是：12/11059200秒 = 12000000/11059200 微秒= 1.085微妙

    机器周期 = 12 x 时钟周期

    = 12 x (1/时钟频率) 秒 = 12 / 时钟频率 秒 = 12 / 11059200 秒 = 12 000 000 / 11059200 微秒 = 1.085 微秒

    1.3 定时器编程

    相关寄存器：

    • 在哪里加1，最大计数时间，也就是爆表了能计算多长

    在T8H0/1和TL0/1寄存器中加1，默认是从0开始数数，最多能数65536下，累计计时71ms ，71毫秒

    • 如何算出10ms定时器的初值

    就不让他从0开始数数，10ms需要数9216下，你让他从65536-9126=56320（16进制表示为

    0xDC00）开始数数

    这样TL0=0x00；TH0=0xDC

    • 关于TCON

    • 怎么知道爆表

    TCON寄存器的bit5（TF0）能表示爆表：当爆表的时候，硬件会修改bit5(TF0)位上面的数据，改成 1（置1），如果不用中断，我们代码清零。

    • 怎么开始计时

    TCON寄存器的bit4，TRO通过编程让这个位为1的时候，开始计时，相当于按下了闹钟

    • 定时器使用是有很多种模式的

    定时器模式寄存器：TMOD来选择定时器模式，选择工作方式1，TMOD的bit0 bit1配置成0 1 ：16 位的定时器功能

    • 四个二进制数表示一位的16进制数

    8421法进制的转换，二进制转16进制（方便人类来看，对计算机底层来说，不关心二进制010101010）。

    配寄存器推荐用按位操作，清零的时候，对应的需要清零的位与上0，不需要清零的位与上1

    置1的时候，需要置1的位置或1，不需要置一的位置或0

    AUXR，降低单片机时钟对外界的辐射。

    • 定时器控制led灯每隔一秒灭一次
    1. #include "reg52.h"
    2.  
    3. sbit led1 = P3^6;   // 定义 led1 变量，指向 P3.6 引脚
    4. sbit led2 = P3^7;   // 定义 led2 变量，指向 P3.7 引脚
    5.  
    6. void main()
    7. {
    8.     // 1.配置定时器0工作模式为16位计数器模式
    9.  
    10.     int cnt = 0;  // 定义一个整数变量 'cnt' 用于计数
    11.  
    12.     led1 = 1; // 初始化 led1 为高电平（假设高电平点亮）
    13.     led2 = 0; // 初始化 led2 为低电平（假设低电平熄灭）
    14.     TMOD = 0x01; // 配置定时器0为模式1（16位定时器模式）
    15.  
    16.     // 2.设置定时器初值，使其每10ms产生一次溢出
    17.  
    18.     TL0 = 0x00; // 设置定时器0低8位初值为 0x00
    19.     TH0 = 0xDC; // 设置定时器0高8位初值为 0xDC
    20.  
    21.     // 3.启动计时
    22.  
    23.     TR0 = 1;  // 启动定时器0
    24.     TF0 = 0;  // 清除定时器0溢出标志位
    25.  
    26.     while(1) {   // 无限循环
    27.         if(TF0 == 1) { // 如果定时器0溢出  爆表
    28.             TF0 = 0; // 清除定时器0溢出标志位
    29.  
    30.             cnt++; // 增加计数器 'cnt' 的值
    31.  
    32.             // 重新设置定时器初值
    33.             TL0 = 0x00;   
    34.             TH0 = 0xDC;
    35.             if(cnt == 100) { // 如果计数器 'cnt' 达到 100（即经过1秒）
    36.                 cnt = 0; // 重置计数器 'cnt'
    37.                 led1 = !led1; // 翻转 led1 的状态
    38.                 led2 = !led2; // 翻转 led2 的状态
    39.             }
    40.         }
    41.     }
    42. }

    1.4 定时器中断方式控制 （相当于多线程）

    中断寄存器

    • 定时器中断方式控制led
    1. #include "reg52.h"  // 包含51系列单片机寄存器定义文件
    2.  
    3. sbit led = P3^6;   // 定义一个位变量led，连接到P3端口的第6位（LED1）
    4. sbit led1 = P3^7;  // 定义一个位变量led1，连接到P3端口的第7位（LED2）
    5. int cnt = 0;       // 定义一个整数变量cnt，用来统计定时器溢出的次数
    6.  
    7. // 定义定时器0初始化函数
    8. void Time0Init()
    9. {
    10. 	// 1. 配置定时器0工作模式为16位计时模式
    11. 	TMOD = 0x01;    // 设置TMOD寄存器为0x01，定时器0为16位定时器模式
    12.  
    13. 	// 2. 设置定时器初值，以生成大约10ms的定时
    14. 	TL0 = 0x00;    // 设置定时器0低8位初值为0x00
    15. 	TH0 = 0xDC;    // 设置定时器0高8位初值为0xDC（即0xDC00）
    16.  
    17. 	// 3. 启动定时器0
    18. 	TR0 = 1;       // 启动定时器0，使其开始计时
    19. 	TF0 = 0;       // 清除定时器0的溢出标志位（初始为0）
    20.  
    21. 	// 4. 启用定时器0中断
    22. 	ET0 = 1;       // 使能定时器0中断，使单片机能够响应定时器0的中断请求
    23.  
    24. 	// 5. 启用总中断
    25. 	EA = 1;        // 启用全局中断，使单片机能够响应所有中断请求
    26. }
    27.  
    28. void main()
    29. {
    30. 	led = 1;       // 将LED1点亮（即将P3^6置为高电平）
    31. 	led1 = 0;      // 将LED2熄灭（即将P3^7置为低电平）
    32. 	Time0Init();   // 调用定时器初始化函数，设置定时器0并启动定时器
    33. 	while(1) {
    34. 		// 无限循环，程序在这里等待中断事件发生
    35. 		// 这部分代码可以执行其他任务，但本例中为空
    36. 	}
    37. }
    38.  
    39. // 定时器0中断处理函数  interrupt 1 定时器0的优先级
    40. void Time0Handler() interrupt 1
    41. {
    42. 	cnt++;        // 每次定时器0溢出时，计数器cnt增加1
    43.  
    44. 	// 重新设置定时器0的初值，保持定时周期不变
    45. 	TL0 = 0x00;  // 重新加载定时器0低8位初值为0x00
    46. 	TH0 = 0xDC;  // 重新加载定时器0高8位初值为0xDC（即0xDC00）
    47.  
    48. 	if (cnt == 30) { // 如果定时器0溢出30次（约300ms）
    49. 		cnt = 0;     // 重置计数器cnt为0
    50.  
    51. 		// 翻转LED的状态
    52. 		led = !led;   // 每300ms翻转LED1的状态
    53. 		led1 = !led1; // 每300ms翻转LED2的状态
    54. 	}
    55. }

    这段代码是用来在51系列单片机中配置定时器0，使其每隔1秒钟翻转一个LED的状态。下面是对每一部分的详细解释：

    1. 头文件和变量定义
    1. #include "reg52.h"
    2.  
    3. sbit led = P3^6;  // 定义一个位变量led，连接到P3端口的第6位（LED1）
    4. sbit led1 = P3^7; // 定义一个位变量led1，连接到P3端口的第7位（LED2）
    5. int cnt = 0;      // 定义一个整数变量cnt，用来统计定时器溢出次数
    • #include "reg52.h"：包含51系列单片机的寄存器定义文件。
    • sbit led = P3^6;：将单片机的P3端口的第6位定义为 led，用于控制LED的开关。
    • sbit led1 = P3^7;：将P3端口的第7位定义为 led1，虽然在代码中没有使用。
    • int cnt = 0;：定义一个计数器 cnt，用于跟踪定时器0的溢出次数。
    2. Time0Init 函数
    1. void Time0Init()
    2. {
    3.     //1. 配置定时器0工作模式位16位计时
    4.     TMOD = 0x01;
    5.     //2. 给初值，定一个10ms出来
    6.     TL0=0x00;
    7.     TH0=0xDC;
    8.     //3. 开始计时
    9.     TR0 = 1;
    10.     TF0 = 0;
    11.     //4. 打开定时器0中断
    12.     ET0 = 1;
    13.     //5. 打开总中断EA
    14.     EA = 1;
    15. }
    • TMOD = 0x01;：将 TMOD 寄存器的值设置为 0x01，将定时器0配置为模式1（16位定时器模式）。低4位 0001 表示定时器0的工作模式。
    • TL0 = 0x00; 和 TH0 = 0xDC;：设置定时器0的初始值。TH0 和 TL0 设置为 0xDC00，这样定时器从 0xDC00 开始计数。
    • TR0 = 1;：启动定时器0。
    • TF0 = 0;：清除定时器0的溢出标志位。
    • ET0 = 1;：允许定时器0的中断。
    • EA = 1;：允许总中断，使单片机能够响应所有中断请求。
    3. main 函数
    1. void main()
    2. {
    3.     led = 1;     // 初始时点亮LED
    4.     Time0Init(); // 初始化定时器0
    5.     while(1){
    6.         // 无限循环，等待中断发生
    7.     }
    8. }
    • led = 1;：在程序开始时，将 led 设为1，点亮LED。
    • Time0Init();：调用初始化定时器0的函数。
    • while(1){}：无限循环，程序在这里等待中断事件发生。实际的操作由中断处理函数完成。
    4. 定时器0中断处理函数
    1. void Time0Handler() interrupt 1
    2. {
    3.     cnt++;  // 统计溢出次数
    4.     // 重新设置定时器初值
    5.     TL0=0x00;
    6.     TH0=0xDC;
    7.     if(cnt == 100) {  // 每100次溢出表示1秒
    8.         cnt = 0;     // 重置计数器
    9.         led = !led;  // 翻转LED状态
    10.     }
    11. }
    • void Time0Handler() interrupt 1：定义了一个中断服务函数，用于处理定时器0的中断。interrupt 1 表示这是定时器0的中断处理函数。
    • cnt++;：每次定时器0溢出时，计数器 cnt 增加1。
    • TL0 = 0x00; 和 TH0 = 0xDC;：重新加载定时器初值，保持定时器周期不变。
    • if(cnt == 100)：检查 cnt 是否达到100。每100次溢出表示1秒（因为10毫秒 × 100 = 1000毫秒，即1秒）。
      • cnt = 0;：重置 cnt 以开始新的计时周期。
      • led = !led;：每秒钟翻转LED的状态。
    总结
    • 初始化：Time0Init 函数设置定时器0的工作模式和初值，并开启定时器中断。
    • 主程序：main 函数设置LED初始状态，并无限循环等待中断。
    • 中断处理：Time0Handler 函数在每次定时器0溢出时执行，统计溢出次数，并每1秒翻转一次LED的状态。

    • 定时器中断方式控制led，led灯多线程 控制
    1. #include "reg52.h"
    2.  
    3. // 定义LED控制的位变量
    4. sbit led = P3^6;   // LED1 连接到P3端口的第6位
    5. sbit led1 = P3^7;  // LED2 连接到P3端口的第7位
    6.  
    7. int cnt = 0;       // 用于计数定时器溢出次数的变量
    8.  
    9. // 定时器0初始化函数
    10. void Time0Init()
    11. {
    12. 	// 1. 配置定时器0工作模式为16位计时模式
    13. 	TMOD = 0x01;   // 设置定时器0为16位计时器模式（模式1）
    14. 	
    15. 	// 2. 给定初值，设置一个10ms的定时周期
    16. 	TL0 = 0x00;    // 设置定时器0的低8位初值
    17. 	TH0 = 0xDC;    // 设置定时器0的高8位初值
    18. 	// (0xDC00 是 16位定时器初值，用来生成10ms的定时周期)
    19. 	
    20. 	// 3. 开始计时
    21. 	TR0 = 1;       // 启动定时器0
    22. 	TF0 = 1;       // 设置定时器0的溢出标志位（启动时应清零，但此处设为1可能是为确保中断服务函数能被触发）
    23. 	
    24. 	// 4. 打开定时器0中断
    25. 	ET0 = 1;       // 使能定时器0中断
    26. 	
    27. 	// 5. 打开总中断EA
    28. 	EA = 1;        // 使能总中断，允许所有中断请求
    29. }
    30.  
    31. // 延时函数
    32. void Delay300ms()		//@11.0592MHz
    33. {
    34. 	unsigned char i, j, k;
    35.  
    36. 	i = 3;  // 外循环计数
    37. 	j = 26; // 中循环计数
    38. 	k = 223; // 内循环计数
    39. 	do
    40. 	{
    41. 		do
    42. 		{
    43. 			while (--k);  // 内循环延时
    44. 		} while (--j);  // 中循环延时
    45. 	} while (--i);  // 外循环延时
    46. }
    47.  
    48. // 主函数
    49. void main()
    50. {
    51. 	led = 1;    // 初始化时将LED1点亮
    52. 	led1 = 0;   // 初始化时将LED2熄灭
    53. 	Time0Init(); // 调用定时器0初始化函数
    54. 	while(1) {
    55. 		// 无限循环
    56. 		led1 = 0;       // LED2熄灭
    57. 		Delay300ms();   // 延时300ms
    58. 		led1 = 1;       // LED2点亮
    59. 		Delay300ms();   // 延时300ms
    60. 	}
    61. }
    62.  
    63. // 定时器0中断服务函数
    64. void Time0Handler() interrupt 1
    65. {
    66. 	cnt++;      // 每次定时器0溢出时，计数器cnt增加1
    67. 	
    68. 	// 重新给定时器0初值，以保持定时周期
    69. 	TL0 = 0x00; // 重新加载定时器0的低8位初值
    70. 	TH0 = 0xDC; // 重新加载定时器0的高8位初值
    71. 	
    72. 	if(cnt == 30) { // 每30次溢出表示约1秒（10ms * 30 = 300ms）
    73. 		cnt = 0;     // 重置计数器cnt，以开始新的计时周期
    74. 		led = !led;  // 翻转LED1的状态
    75. 	}
    76. }

    当然，下面是对你提供的代码的详细解释，逐步解释每一部分的功能和目的：

    1. 头文件和变量定义
    1. #include "reg52.h"
    2.  
    3. // 定义LED控制的位变量
    4. sbit led = P3^6;   // LED1 连接到P3端口的第6位
    5. sbit led1 = P3^7;  // LED2 连接到P3端口的第7位
    6.  
    7. int cnt = 0;       // 用于计数定时器溢出次数的变量
    • #include "reg52.h"：包括一个头文件，这个文件通常包含对51系列单片机寄存器的定义。
    • sbit led = P3^6; 和 sbit led1 = P3^7;：将 led 和 led1 分别定义为 P3 端口的第6位和第7位，控制对应的LED灯。sbit 是位变量的定义方式，用于操作单片机的特定位。
    • int cnt = 0;：定义一个全局变量 cnt，用来计数定时器溢出次数。
    2. 定时器0初始化函数
    1. void Time0Init()
    2. {
    3.     // 1. 配置定时器0工作模式为16位计时模式
    4.     TMOD = 0x01;   // 设置定时器0为16位定时器模式（模式1）
    5.     
    6.     // 2. 给定初值，设置一个10ms的定时周期
    7.     TL0 = 0x00;    // 设置定时器0的低8位初值
    8.     TH0 = 0xDC;    // 设置定时器0的高8位初值
    9.     // (0xDC00 是 16位定时器初值，用来生成10ms的定时周期)
    10.     
    11.     // 3. 开始计时
    12.     TR0 = 1;       // 启动定时器0
    13.     TF0 = 1;       // 设置定时器0的溢出标志位（启动时应清零，但此处设为1可能是为确保中断服务函数能被触发）
    14.     
    15.     // 4. 打开定时器0中断
    16.     ET0 = 1;       // 使能定时器0中断
    17.     
    18.     // 5. 打开总中断EA
    19.     EA = 1;        // 使能总中断，允许所有中断请求
    20. }
    • 配置定时器模式：
      • TMOD = 0x01;：设置定时器0为模式1（16位定时器模式）。TMOD 寄存器的低4位设置定时器0的模式，0x01 表示模式1，即16位计时器。
    • 设置定时初值：
      • TL0 = 0x00; 和 TH0 = 0xDC;：设置定时器0的低8位（TL0）和高8位（TH0）的初值。这里的初值 0xDC00（16位）用来生成一个10ms的定时周期。具体的10ms周期计算基于单片机的时钟频率（11.0592 MHz）。
    • 启动定时器和中断：
      • TR0 = 1;：启动定时器0，开始计时。
      • TF0 = 1;：设置溢出标志位。这通常在定时器启动时应清除，但此处设为1可能是为了确保中断服务函数能被触发。
      • ET0 = 1;：使能定时器0的中断，允许定时器溢出时触发中断。
      • EA = 1;：使能所有中断，允许中断请求的处理。
    3. 延时函数
    1. void Delay300ms()		//@11.0592MHz
    2. {
    3.     unsigned char i, j, k;
    4.  
    5.     i = 3;  // 外循环计数
    6.     j = 26; // 中循环计数
    7.     k = 223; // 内循环计数
    8.     do
    9.     {
    10.         do
    11.         {
    12.             while (--k);  // 内循环延时
    13.         } while (--j);  // 中循环延时
    14.     } while (--i);  // 外循环延时
    15. }
    • 延时函数：
      • Delay300ms() 用来实现一个大约300ms的延时。
      • 使用嵌套的 do-while 循环来耗费时间。外层循环 i 控制循环次数，中层循环 j 和内层循环 k 控制每次循环的延时。具体的延时时间取决于单片机的时钟频率（11.0592 MHz）。
    4. 主函数
    1. void main()
    2. {
    3.     led = 1;    // 初始化时将LED1点亮
    4.     led1 = 0;   // 初始化时将LED2熄灭
    5.     Time0Init(); // 调用定时器0初始化函数
    6.     while(1) {
    7.         // 无限循环
    8.         led1 = 0;       // LED2熄灭
    9.         Delay300ms();   // 延时300ms
    10.         led1 = 1;       // LED2点亮
    11.         Delay300ms();   // 延时300ms
    12.     }
    13. }
    • 主函数：
      • 初始化时将LED1点亮 (led = 1;)，LED2熄灭 (led1 = 0;)。
      • 调用 Time0Init() 初始化定时器0。
      • 进入无限循环，在其中交替点亮和熄灭LED2，每次切换后调用 Delay300ms() 实现300ms的延时。
    5. 定时器0中断服务函数
    1. void Time0Handler() interrupt 1
    2. {
    3.     cnt++;      // 每次定时器0溢出时，计数器cnt增加1
    4.     
    5.     // 重新给定时器0初值，以保持定时周期
    6.     TL0 = 0x00; // 重新加载定时器0的低8位初值
    7.     TH0 = 0xDC; // 重新加载定时器0的高8位初值
    8.     
    9.     if(cnt == 30) { // 每30次溢出表示约1秒（10ms * 30 = 300ms）
    10.         cnt = 0;     // 重置计数器cnt，以开始新的计时周期
    11.         led = !led;  // 翻转LED1的状态
    12.     }
    13. }
    • 定时器0中断服务函数：
      • void Time0Handler() interrupt 1：这是定时器0的中断服务函数。interrupt 1 表示它处理定时器0的中断请求。
      • cnt++：每次定时器0溢出时，计数器 cnt 增加1。
      • 重新设置定时器0的初值 (TL0 和 TH0)，以保持定时器的计时周期。
      • 当 cnt 达到30时（每30次10ms溢出约300ms），重置 cnt 并翻转LED1的状态。

    二、PWM开发SG90

    2.1 简介

    PWM，英文名Pulse Width Modulation，是脉冲宽度调制缩写，它是通过对一系列脉冲的宽度进 行调制，等效出所需要的波形（包含形状以及幅值），对模拟信号电平进行数字编码，也就是说通过调节占空比的变化来调节信号、能量等的变化，占空比就是指在一个周期内，信号处于高电平的 时间占据整个信号周期的百分比，例如方波的占空比就是50%.

    • 脉冲宽度调制
    • 通过占空比编码模拟信号
    • 占空比 一个周期内，高电平占据时长的百分比

    4毫秒为一个（波形）周期，其中3ms为低电平，1ms为高电平

    什么是占空比 ：一个周期内，高电平占据时长的百分比，为25%。

    2.2 如何实现PWM信号输出

    1. 通过芯片内部模块输出，一般观察手册或者芯片IO口都会标明这个是否是PWM口

    如下图增强51，STC15w的

    2. 如果没有集成PWM功能，可以通过IO口软件模拟，相对硬件PWM来说精准度略差 ，怎么模拟；

    搞个50HZ频率的pwm；

    2.3 控制舵机
    1. 什么是舵机

    如下图所示，最便宜的舵机sg90，常用三根或者四根接线，黄色为PWM信号控制

    用处：垃圾桶项目开盖用、智能小车的全比例转向、摄像头云台、机械臂等

    常见的有0-90°、0-180°、0-360°

    2. 怎么控制舵机

    向黄色信号线“灌入”PWM信号。

    PWM波的频率不能太高，大约50HZ，即周期=1/频率=1/50=0.02s，20ms左右

    数据：

    0.5ms-------------0度； 2.5% 对应函数中占空比为250

    1.0ms------------45度； 5.0% 对应函数中占空比为500

    1.5ms------------90度； 7.5% 对应函数中占空比为750

    2.0ms-----------135度； 10.0% 对应函数中占空比为1000

    2.5ms-----------180度； 12.5% 对应函数中占空比为1250

    定时器需要定时20ms, 关心的单位0.5ms, 40个的0.5ms,初值0.5m cnt++

    1s = 10ms * 100

    20ms = 0.5ms * 40 \

    • 编程实现

    1. #include "reg52.h"
    2.  
    3. sbit sg90_con = P1^1;  // 定义一个名为 sg90_con 的引脚，与 P1 端口的第 1 位连接
    4.  
    5. int jiaodu ;  // 定义一个整数变量 jiaodu，用于表示角度
    6. int cnt = 0;  // 定义一个计数器变量 cnt，用于统计定时器溢出次数
    7.  
    8. // 延时 2000 毫秒函数
    9. void Delay2000ms()		//@11.0592MHz
    10. {
    11. 	unsigned char i, j, k;
    12. 	i = 15;
    13. 	j = 2;
    14. 	k = 235;
    15. 	do
    16. 	{
    17. 		do
    18. 		{
    19. 			while (--k);  // 内层循环，k 减到 0
    20. 		} while (--j);  // 中层循环，j 减到 0
    21. 	} while (--i);  // 外层循环，i 减到 0
    22. }
    23.  
    24. // 定时器0初始化函数
    25. void Time0Init()
    26. {
    27. 	//1. 配置定时器0工作模式为16位计时
    28. 	TMOD = 0x01;
    29. 	//2. 设置初值，定时10ms
    30. 	TL0=0x33;
    31. 	TH0=0xFE;
    32. 	//3. 开始计时
    33. 	TR0 = 1;
    34. 	TF0 = 0;
    35. 	//4. 打开定时器0中断
    36. 	ET0 = 1;
    37. 	//5. 打开总中断EA
    38. 	EA = 1;
    39. }
    40.  
    41. // 延时 300 毫秒函数
    42. void Delay300ms()		//@11.0592MHz
    43. {
    44. 	unsigned char i, j, k;
    45. 	i = 3;
    46. 	j = 26;
    47. 	k = 223;
    48. 	do
    49. 	{
    50. 		do
    51. 		{
    52. 			while (--k);  // 内层循环，k 减到 0
    53. 		} while (--j);  // 中层循环，j 减到 0
    54. 	} while (--i);  // 外层循环，i 减到 0
    55. }
    56.  
    57. void main()
    58. {
    59. 	Delay300ms();  // 让硬件稳定一下
    60. 	Time0Init();  // 初始化定时器
    61. 	jiaodu = 1;   // 初始角度是 0 度，高电平时间为 0.5ms
    62. 	cnt = 0;
    63. 	sg90_con = 1;  // 一开始从高电平开始
    64. 	
    65. 	// 每隔两秒切换一次角度
    66. 	while(1){
    67. 	
    68. 		jiaodu = 3;  // 90度，高电平时间为 1.5ms
    69. 		cnt = 0;
    70. 		Delay2000ms();
    71. 		jiaodu = 1;  // 0度，高电平时间为 0.5ms
    72. 		cnt = 0;
    73. 		Delay2000ms();
    74. 	}
    75. }
    76.  
    77. // 定时器0中断处理函数
    78. void Time0Handler() interrupt 1
    79. {
    80. 	cnt++;  // 统计溢出次数
    81. 	// 重新设置定时器初值
    82. 	TL0=0x33;
    83. 	TH0=0xFE;
    84. 	
    85. 	// 控制PWM波
    86. 	if(cnt < jiaodu){	
    87. 		sg90_con = 1;  // 设置高电平
    88. 	}else{
    89. 		sg90_con = 0;  // 设置低电平
    90. 	} 
    91. 	if(cnt == 40){  // 溢出40次，经过20ms
    92. 		cnt = 0;  // 重新开始计数
    93. 		sg90_con = 1;  // 开始新的PWM周期，从高电平开始
    94. 	}
    95. }
    详细解释
    1. 头文件和变量定义：
      • #include "reg52.h"：包含51单片机的头文件。
      • sbit sg90_con = P1^1;：定义舵机控制引脚，连接到P1.1。
      • int jiaodu; 和 int cnt = 0;：用于控制舵机角度和计数器的变量。
    1. 延时函数：
      • Delay2000ms() 和 Delay300ms()：这两个函数通过嵌套的空循环实现延时，用于产生约2000毫秒和300毫秒的延时。
    1. 定时器初始化函数：
      • Time0Init()：配置定时器0为16位计时模式，设置初始值，启动定时器，并开启定时器中断和全局中断。
    1. 主函数：
      • main()：主函数初始化定时器，并在一个无限循环中每隔2秒切换舵机的角度。jiaodu 设置为1表示0度，设置为3表示90度。
    1. 定时器中断处理函数：
      • Time0Handler()：定时器0溢出时调用此函数。每次溢出时计数器 cnt 增加，设置新的初始值，并根据 cnt 和 jiaodu 控制舵机信号引脚 sg90_con 的高低电平，从而产生PWM波。
    工作原理
    • PWM信号生成：
      • 中断处理函数通过计数器 cnt 控制 sg90_con 的高低电平时间，从而生成PWM信号。每个PWM周期为20ms，其中高电平时间由 jiaodu 控制。
    • 舵机控制：
      • 主函数通过设置 jiaodu 控制舵机角度，每隔2秒改变一次角度。通过 Delay2000ms() 函数实现延时。
    • 中断处理：
      • 每次定时器0溢出时，进入中断处理函数。计数器 cnt 增加，并根据 cnt 的值控制PWM波的高低电平。当 cnt 达到40次溢出时（相当于20ms），重置 cnt 并开始新的PWM周期。

    主函数和中断一起执行 ，如果cnt 大于角度的时候，是低电压，中断函数cnt继续加加，直到加到等于40的时候，这个周期结束，进入下一个周期，

    三、 超声波测距

    3.1 简介

    型号：HC-SR04

    接线参考：模块除了两个电源引脚外，还有TRIG，ECHO引脚，这两个引脚分别接我们开发板的P1.5和

    P1.6端口

    超声波测距模块是用来测量距离的一种产品，通过发送和收超声波，利用时间差和声音传播速度， 计算出模块到前方障碍物的距离。

    • 怎么让它发送波

    Trig ，给Trig端口至少10us的高电平

    • 怎么知道它开始发了

    Echo信号，由低电平跳转到高电平，表示开始发送波

    • 怎么知道接收了返回波

    Echo，由高电平跳转回低电平，表示波回来了

    • 怎么算时间

    Echo引脚维持高电平的时间！

    波发出去的那一下，开始启动定时器

    波回来的拿一下，我们开始停止定时器，计算出中间经过多少时间

    • 怎么算距离

    距离 = 速度 （340m/s）* 时间/2

    3.2 超声波的时序图

    3.3 超声波测距代码实现
    1. #include "reg52.h"
    2.  
    3. //距离小于10cm ，D5 亮，6灭，反之想反
    4.  
    5. sbit D5 = P3^7;//根据原理图（电路图），设备变量led1指向P3组IO口的第7口
    6. sbit D6 = P3^6;//根据原理图（电路图），设备变量led2指向P3组IO口的第6口
    7.  
    8. sbit Trig = P1^5;   // 发送声波
    9. sbit Echo = P1^6;   // 接收声波
    10.  
    11. void Delay10us()		//@11.0592MHz  //声波的持续时间   10微妙  
    12. {
    13. 	unsigned char i;
    14.  
    15. 	i = 2;
    16. 	while (--i);
    17. }
    18. /*
    19. 十进制2左移1位，变成20。相当于乘以10
    20. 二禁止1左移1位，变成10（2）。相当于乘以2，左移8位，乘以2的8次方=256；*/
    21. void startHC()   //Trig  输出10ms的高电平 启动发波
    22. {
    23. 	Trig = 0;    //发声波 低电压 
    24. 	Trig = 1;    //发声波 高电压 维持10秒
    25. 	Delay10us();
    26. 	
    27. 	Trig = 0;  //发声波 低电压 
    28. 	
    29. 	}//设置定时器0工作模式1，初始值设定0开始数数，不着急启动定时器
    30.  
    31. void Time0Init()   //不用关心初值  定时器
    32. {
    33. 	TMOD &= 0xF0;		//设置定时器模式
    34. 	TMOD |= 0x01;		//设置定时器模式
    35. 	
    36. 	 TH0 = 0;    //16进制计时
    37. 	 TL0 = 0;
    38. 	
    39. 	// 设置定时器-0工作模块1.初值为0，不着急启动定时器、
    40. 	
    41. }
    42. double get_distance()
    43. {
    44.     double time;
    45. 		//定时器数据清零，以便下一次测距
    46. 		TH1 = 0;
    47. 		TL1 = 0;
    48.      startHC(); //调用超声波函数，启动发波；
    49.     
    50.     while(Echo == 0);   // 当接收端由低电压转换至高电压时，循环结束 表示声波发出
    51. 			//	启动定时器
    52. 			TR0 = 1;   // 开始计时
    53. 		//		3、Echo，由高电平跳转回低电平，表示波回来了 
    54. 		//	 停止计时
    55. 			while(Echo == 1);  // 当接收端由高电压转换至低电压时，循环结束，表示声波返回
    56. 				TR0 = 0;  // 停止计时
    57. 	
    58. 		//4. 计算出中间经过多少时间 （公式）
    59. 		time = (TH0 * 256 + TL0)*1.085;//us为单位
    60. 		//5. 距离 = 速度 （340m/s）* 时间/2
    61. 		dis = time * 0.017;
    62.     double dis;  //返回一个数值
    63. }
    64. void openStatusLight()   // 开启状态灯
    65. {
    66. 	D5 = 0;
    67. 	D6 = 1;
    68. }
    69. void closeStatusLight()  // 关闭状态灯
    70. {
    71. 	D5 = 1;
    72. 	D6 = 0;
    73. }
    74. void main()
    75. {
    76.  
    77. 		double dis;   // 距离
    78.  
    79.     	Time0Init();   //初始化定时器
    80. 	
    81.     	while(1){
    82.     		
    83.     		dis = get_distance();  // 计算距离
    84.  
    85.              // 判断距离是否小于10cm
    86.     		if(dis < 10){   // 如果小于10cm  
    87.     				openStatusLight();  // 调用开启函数
    88.     		}else{     // 否则。其他情况
    89.     				closeStatusLight();     // 调用关闭函数
    90.     		}
    91. 		
    92. 	}
    93. }

    四、本节项目感应开关盖垃圾桶

    4.1 项目概述
    • 功能描述
        • 检测靠近时，垃圾桶自动开盖并伴随滴一声，2秒后关盖
        • 发生震动时，垃圾桶自动开盖并伴随滴一声，2秒后关盖
        • 按下按键时，垃圾桶自动开盖并伴随滴一声，2秒后关盖
    • 硬件说明
        • SG90舵机，超声波模块，震动传感器，蜂鸣器
    • 接线说明

    舵机控制口 P1.1；超声波Trig接 P1.5 ,Echo接 P1.6 ；蜂鸣器接 P2.0 口; 震动传感器接 P3.2`口(外部 中断0)

    4.2 编程实现
    • 开发步骤：

    1. 舵机和超声波代码整合

      • 舵机用定时器0
      • 超声波用定时器1
      • 实现物体靠近后，自动开盖，2秒后关盖

    2. 查询的方式添加按键控制

    3. 查询的方式添加震动控制

    4. 使用外部中断0配合震动控制

    代码：

    1. #include "reg52.h"
    2.  
    3. sbit sg90_con = P1^1;
    4. sbit D5 = P3^7;//根据原理图（电路图），设备变量led1指向P3组IO口的第7口
    5. sbit D6 = P3^6;//根据原理图（电路图），设备变量led2指向P3组IO口的第6口
    6.  
    7.  
    8. sbit Trig = P1^5;
    9. sbit Echo = P1^6;
    10.  
    11. int jiaodu ;  // 舵机的角度
    12. int cnt = 0;  //爆表的累计次数
    13.  
    14. void Delay2000ms()		//@11.0592MHz  // 延迟2秒
    15. {
    16. 	unsigned char i, j, k;
    17.  
    18. 	i = 15;
    19. 	j = 2;
    20. 	k = 235;
    21. 	do
    22. 	{
    23. 		do
    24. 		{
    25. 			while (--k);
    26. 		} while (--j);
    27. 	} while (--i);
    28. }
    29.  
    30. void Delay10us()		//@11.0592MHz 
    31. {
    32. 	unsigned char i;
    33.  
    34. 	i = 2;
    35. 	while (--i);
    36. }
    37.  
    38. void startHC()   //Trig  输出10ms的高电平 启动发波
    39. {
    40. 	Trig = 0;
    41. 	Trig = 1;
    42. 	Delay10us();
    43. 	
    44. 	Trig = 0;
    45. 	
    46. 	}
    47. void Time0Init1()  // 初始化定时器0，用于舵机控制
    48. {
    49. 	//1. 配置定时器0工作模式位16位计时
    50. 	TMOD &= 0xF0;		//设置定时器模式
    51. 	TMOD |= 0x01;
    52. 	//2. 给初值，定一个10ms出来
    53. 	TL0=0x33;
    54. 	TH0=0xFE;
    55. 	//3. 开始计时
    56. 	TR0 = 1;
    57. 	TF0 = 0;
    58. 	//4. 打开定时器0中断
    59. 	ET0 = 1;
    60. 	//5. 打开总中断EA
    61. 	EA = 1;
    62. }
    63.  
    64. void Time0Init2()   // 初始化定时器1，用于超声波控制
    65. {
    66. 	TMOD &= 0x0F;		//设置定时器模式
    67. 	TMOD |= 0x10;		//设置定时器模式
    68. 	
    69. 	 TH1 = 0;
    70. 	 TL1 = 0;
    71. 	
    72. 	// 设置定时器-0工作模块1.初值为0，不着急启动定时器、
    73. 	
    74. }
    75. void Delay300ms()		//@11.0592MHz
    76. {
    77. 	unsigned char i, j, k;
    78. 	i = 3;
    79. 	j = 26;
    80. 	k = 223;
    81. 	do
    82. 	{
    83. 		do
    84. 		{
    85. 			while (--k);
    86. 		} while (--j);
    87. 	} while (--i);
    88. }
    89.  
    90. void initSG90_0()
    91. {
    92. 	jiaodu = 1;      //初始角度是0度，0.5ms,溢出1就是0.5，高电平
    93. 	cnt = 0;
    94. 	sg90_con = 1;		//一开始从高电平开始
    95. }
    96. double  get_distance()
    97. {
    98. 		double time;
    99. 		double dis;
    100. 		//定时器数据清零，以便下一次测距
    101. 		TH1 = 0;
    102. 		TL1 = 0;
    103. 	//1. Trig ，给Trig端口至少10us的高电平
    104. 			startHC();
    105. 	
    106. 	// 2、Echo信号，由低电平跳转到高电平，表示开始发送波
    107. 			//		波发出去的那一下，开始启动定时器
    108. 			while(Echo == 0);
    109. 			
    110. 			//	启动定时器
    111. 			TR1 = 1;
    112. 		
    113. 		//		3、Echo，由高电平跳转回低电平，表示波回来了 
    114. 		//	 停止计时
    115. 			while(Echo == 1);
    116. 			
    117. 				TR1 = 0;
    118. 	
    119. 		//4. 计算出中间经过多少时间
    120. 		time = (TH1 * 256 + TL1)*1.085;//us为单位
    121. 		//5. 距离 = 速度 （340m/s）* 时间/2
    122. 		dis = time * 0.017;
    123. 		return dis;
    124. }
    125. void openStatusLight() {
    126.     D5 = 0;  // 点亮D5
    127.     D6 = 1;  // 熄灭D6
    128. }
    129.  
    130. void closeStatusLight() {
    131.     D5 = 1;  // 熄灭D5
    132.     D6 = 0;  // 点亮D6
    133. }
    134.  
    135. void openlajitong() {
    136.     jiaodu = 3;  // 90度，1.5ms高电平
    137.     cnt = 0;
    138.     Delay2000ms();
    139. }
    140.  
    141. void closelajitong() {
    142.     jiaodu = 1;  // 0度，0.5ms高电平
    143.     cnt = 0;
    144.     Delay2000ms();
    145. }
    146. void main()
    147. {
    148. 	double dis;
    149. 	Delay300ms(); 	//  让硬件稳定一下
    150. 	Time0Init1();  	//  初始化定时器1
    151. 	Time0Init2();	//  初始化定时器2
    152.     initSG90_0();   //  初始化舵机的角度
    153. 	
    154. 	
    155. 	// 每隔两秒切换一次角度
    156. 	while(1){
    157. 		dis = get_distance();   // 计算距离
    158. 			
    159. 			if(dis < 10){        // 判断距离  
    160.                                         //  如果距离小于10 调用开启函数
    161. 				openStatusLight();    //
    162. 				openlajitong();
    163. 			}else{                 //  如果距离大于10 调用关闭函数
    164. 				closeStatusLight();
    165. 				closelajitong();
    166. 			}
    167. 	}
    168. }
    169. void Time0Handler() interrupt 1  // 定时器中断
    170. {
    171. 	cnt++;  //统计爆表的次数，cnt = 1的时候，报表了1
    172. 	//重新给初值
    173. 	TL0=0x33;
    174. 	TH0=0xFE;
    175. 	
    176. 	// 控制PWM波
    177. 	if(cnt < jiaodu){	
    178. 			sg90_con = 1 ;
    179. 		}else{
    180. 			sg90_con = 0 ;
    181. 		} 
    182. 	if(cnt == 40){//爆表40次，经过了20ms
    183. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    184. 		sg90_con = 1 ;
    185. 		
    186. 	}
    187. 		
    188. }
    • 测距开关盖添加按键开盖功能
      • 51单片机KY1 按键
      • 遥控发送接收433M
        • https://wenku.baidu.com/view/8fe8f444bed5b9f3f80f1c33.html
        • 默认低电平，按键之后是高电平。
        • 遥控控制开关
    1. #include "reg52.h"
    2.  
    3. // 定义各个IO口
    4. sbit D5       = P3^7;      // LED D5连接到P3.7口
    5. sbit D6       = P3^6;      // LED D6连接到P3.6口
    6. sbit SW1      = P2^1;      // 开关 SW1连接到P2.1口
    7. sbit Trig     = P1^5;      // 超声波传感器Trig引脚连接到P1.5口
    8. sbit Echo     = P1^6;      // 超声波传感器Echo引脚连接到P1.6口
    9. sbit sg90_con = P1^1;      // SG90舵机控制引脚连接到P1.1口
    10. sbit D0_ON    = P1^2;      // LED D0_ON连接到P1.2口
    11. sbit D1_OFF   = P1^3;      // LED D1_OFF连接到P1.3口
    12.  
    13. int jiaodu ;  // 舵机的角度
    14. int cnt = 0;  //爆表的累计次数
    15.  
    16. void Delay2000ms()		//@11.0592MHz  // 延迟2秒
    17. {
    18. 	unsigned char i, j, k;
    19.  
    20. 	i = 15;
    21. 	j = 2;
    22. 	k = 235;
    23. 	do
    24. 	{
    25. 		do
    26. 		{
    27. 			while (--k);
    28. 		} while (--j);
    29. 	} while (--i);
    30. }
    31. void Delay10us()		//@11.0592MHz 
    32. {
    33. 	unsigned char i;
    34.  
    35. 	i = 2;
    36. 	while (--i);
    37. }
    38. void startHC()   //Trig  输出10ms的高电平 启动发波
    39. {
    40. 	Trig = 0;
    41. 	Trig = 1;
    42. 	Delay10us();
    43. 	
    44. 	Trig = 0;
    45. 	
    46. 	}
    47. void Time0Init1()  // 初始化定时器0，用于舵机控制
    48. {
    49. 	//1. 配置定时器0工作模式位16位计时
    50. 	TMOD &= 0xF0;		//设置定时器模式
    51. 	TMOD |= 0x01;
    52. 	//2. 给初值，定一个10ms出来
    53. 	TL0=0x33;
    54. 	TH0=0xFE;
    55. 	//3. 开始计时
    56. 	TR0 = 1;
    57. 	TF0 = 0;
    58. 	//4. 打开定时器0中断
    59. 	ET0 = 1;
    60. 	//5. 打开总中断EA
    61. 	EA = 1;
    62. }
    63. void Time0Init2()   // 初始化定时器1，用于超声波控制
    64. {
    65. 	TMOD &= 0x0F;		//设置定时器模式
    66. 	TMOD |= 0x10;		//设置定时器模式
    67. 	
    68. 	 TH1 = 0;
    69. 	 TL1 = 0;
    70. 	
    71. 	// 设置定时器-0工作模块1.初值为0，不着急启动定时器、
    72. 	
    73. }
    74. void Delay300ms()		//@11.0592MHz
    75. {
    76. 	unsigned char i, j, k;
    77. 	i = 3;
    78. 	j = 26;
    79. 	k = 223;
    80. 	do
    81. 	{
    82. 		do
    83. 		{
    84. 			while (--k);
    85. 		} while (--j);
    86. 	} while (--i);
    87. }
    88. void initSG90_0()
    89. {
    90. 	jiaodu = 1;      //初始角度是0度，0.5ms,溢出1就是0.5，高电平
    91. 	cnt = 0;
    92. 	sg90_con = 1;		//一开始从高电平开始
    93. }
    94. double  get_distance()
    95. {
    96. 		double time;
    97. 		double dis;
    98. 		//定时器数据清零，以便下一次测距
    99. 		TH1 = 0;
    100. 		TL1 = 0;
    101. 	//1. Trig ，给Trig端口至少10us的高电平
    102. 			startHC();
    103. 	
    104. 	// 2、Echo信号，由低电平跳转到高电平，表示开始发送波
    105. 			//		波发出去的那一下，开始启动定时器
    106. 			while(Echo == 0);
    107. 			
    108. 			//	启动定时器
    109. 			TR1 = 1;
    110. 		
    111. 		//		3、Echo，由高电平跳转回低电平，表示波回来了 
    112. 		//	 停止计时
    113. 			while(Echo == 1);
    114. 			
    115. 				TR1 = 0;
    116. 	
    117. 		//4. 计算出中间经过多少时间
    118. 		time = (TH1 * 256 + TL1)*1.085;//us为单位
    119. 		//5. 距离 = 速度 （340m/s）* 时间/2
    120. 		dis = time * 0.017;
    121. 		return dis;
    122. }
    123. void openStatusLight() {
    124.     D5 = 0;  // 点亮D5
    125.     D6 = 1;  // 熄灭D6
    126. }
    127. void closeStatusLight() {
    128.     D5 = 1;  // 熄灭D5
    129.     D6 = 0;  // 点亮D6
    130. }
    131. void openlajitong() {
    132.     jiaodu = 3;  // 90度，1.5ms高电平
    133.     cnt = 0;
    134.     Delay2000ms();
    135. }
    136. void closelajitong() {
    137.     jiaodu = 1;  // 0度，0.5ms高电平
    138.     cnt = 0;
    139.     Delay2000ms();
    140. }
    141. void main()
    142. {
    143. 	double dis;
    144. 	Delay300ms(); 	//  让硬件稳定一下
    145. 	Time0Init1();  	//  初始化定时器1
    146. 	Time0Init2();	//  初始化定时器2
    147.     initSG90_0();   //  初始化舵机的角度
    148. 	
    149. 		// 每隔两秒切换一次角度
    150. 	while(1){
    151. 		dis = get_distance();   // 计算距离
    152. 			if(dis < 10 || SW1 == 0 || D0_ON == 1){
    153. 				openStatusLight();
    154. 				openDusbin();
    155.     		}else if (D1_OFF == 1){
    156. 				//关盖，灯状态，D5灭
    157. 				closeStatusLight();
    158. 				closeDusbin();
    159.     		}else{
    160. 				closeStatusLight();
    161. 				closeDusbin();
    162. 		}
    163. 	}
    164. }
    165. void Time0Handler() interrupt 1  // 定时器中断
    166. {
    167. 	cnt++;  //统计爆表的次数，cnt = 1的时候，报表了1
    168. 	//重新给初值
    169. 	TL0=0x33;
    170. 	TH0=0xFE;
    171. 	
    172. 	// 控制PWM波
    173. 	if(cnt < jiaodu){	
    174. 			sg90_con = 1 ;
    175. 		}else{
    176. 			sg90_con = 0 ;
    177. 		} 
    178. 	if(cnt == 40){//爆表40次，经过了20ms
    179. 		cnt = 0;  //当100次表示1s，重新让cnt从0开始，计算下一次的1s
    180. 		sg90_con = 1 ;
    181. 	}	
    182. }
    • 测距开关盖添加振动传感器开盖功能
    1. #include "reg52.h"
    2.  
    3. // 定义各个IO口
    4. sbit D5       = P3^7;      // LED D5连接到P3.7口
    5. sbit D6       = P3^6;      // LED D6连接到P3.6口
    6. sbit SW1      = P2^1;      // 开关 SW1连接到P2.1口
    7. sbit Trig     = P1^5;      // 超声波传感器Trig引脚连接到P1.5口
    8. sbit Echo     = P1^6;      // 超声波传感器Echo引脚连接到P1.6口
    9. sbit sg90_con = P1^1;      // SG90舵机控制引脚连接到P1.1口
    10. sbit D0_ON    = P1^2;      // LED D0_ON连接到P1.2口
    11. sbit D1_OFF   = P1^3;      // LED D1_OFF连接到P1.3口
    12. sbit vibrate  = P3^2;      // 振动传感器连接到P3.2口
    13. sbit beep     = P2^0;
    14.  
    15.  
    16.  
    17. char jiaodu;  // 舵机的角度变量
    18. char jd_bak;
    19. char cnt = 0;// 定时器溢出次数累计变量
    20. char mark_vibrate = 0;
    21.  
    22. // 延迟2秒
    23. void Delay2000ms()		//@11.0592MHz
    24. {
    25. 	unsigned char i, j, k;
    26. 	i = 15;
    27. 	j = 2;
    28. 	k = 235;
    29. 	do {
    30. 		do {
    31. 			while (--k);
    32. 		} while (--j);
    33. 	} while (--i);
    34. }
    35.  
    36. // 延迟10微秒
    37. void Delay10us()		//@11.0592MHz 
    38. {
    39. 	unsigned char i;
    40. 	i = 2;
    41. 	while (--i);
    42. }
    43.  
    44. // Trig输出10微秒的高电平以启动超声波传感器
    45. void startHC()
    46. {
    47. 	Trig = 0;
    48. 	Trig = 1;
    49. 	Delay10us();
    50. 	Trig = 0;
    51. }
    52.  
    53. // 初始化定时器0，用于舵机控制
    54. void Time0Init1()
    55. {
    56. 	TMOD &= 0xF0;		// 设置定时器模式
    57. 	TMOD |= 0x01;		// 配置定时器0工作模式为16位计数
    58. 	TL0 = 0x33;			// 定时器初值
    59. 	TH0 = 0xFE;			// 定时器初值
    60. 	TR0 = 1;			// 开始计时
    61. 	TF0 = 0;			// 清除定时器溢出标志
    62. 	ET0 = 1;			// 打开定时器0中断
    63. 	EA = 1;				// 打开总中断
    64. }
    65.  
    66. // 初始化定时器1，用于超声波控制
    67. void Time0Init2()
    68. {
    69. 	TMOD &= 0x0F;		// 设置定时器模式
    70. 	TMOD |= 0x10;		// 配置定时器1工作模式为16位计数
    71. 	TH1 = 0;			// 定时器1初值
    72. 	TL1 = 0;			// 定时器1初值
    73. }
    74.  
    75. // 延迟300毫秒
    76. void Delay300ms()		//@11.0592MHz
    77. {
    78. 	unsigned char i, j, k;
    79. 	i = 3;
    80. 	j = 26;
    81. 	k = 223;
    82. 	do {
    83. 		do {
    84. 			while (--k);
    85. 		} while (--j);
    86. 	} while (--i);
    87. }
    88.  
    89. // 初始化舵机角度为0度（0.5ms高电平）
    90. void initSG90_0()
    91. {
    92. 	jiaodu = 1;      // 初始角度是0度
    93. 	cnt = 0;
    94. 	sg90_con = 1;	 // 一开始从高电平开始
    95. }
    96.  
    97. // 获取距离
    98. double get_distance()
    99. {
    100. 	double time;
    101. 	double dis;
    102. 	TH1 = 0;  // 定时器1数据清零
    103. 	TL1 = 0;
    104. 	startHC();  // 启动超声波传感器
    105. 	while(Echo == 0);  // 等待Echo信号变高
    106. 	TR1 = 1;  // 启动定时器1
    107. 	while(Echo == 1);  // 等待Echo信号变低
    108. 	TR1 = 0;  // 停止定时器1
    109. 	time = (TH1 * 256 + TL1) * 1.085;  // 计算时间，单位为微秒
    110. 	dis = time * 0.017;  // 计算距离，单位为厘米
    111. 	return dis;
    112. }
    113.  
    114. // 打开状态灯
    115. void openStatusLight() {
    116.     D5 = 0;  // 点亮D5
    117.     D6 = 1;  // 熄灭D6
    118. }
    119.  
    120. // 关闭状态灯
    121. void closeStatusLight() {
    122.     D5 = 1;  // 熄灭D5
    123.     D6 = 0;  // 点亮D6
    124. }
    125.  
    126. // 打开垃圾桶
    127. void openlajitong() {
    128.     char n;
    129. 	jiaodu = 3; //90度 1.5ms高电平
    130. 	//舵机开盖
    131. 	if(jd_bak != jiaodu){
    132. 		cnt = 0;
    133. 		beep = 0;
    134. 		for(n=0;n<2;n++)
    135. 			Delay150ms();
    136. 		beep = 1;
    137. 		Delay2000ms();
    138. 	}
    139. 	
    140. 	jd_bak = jiaodu;
    141. 	
    142. }
    143.  
    144. // 关闭垃圾桶
    145. void closelajitong() {
    146.    char n;
    147. 	//关盖
    148. 	for(n=0;n<2;n++)
    149. 			Delay150ms();
    150. 	jd = 1; //0度
    151. 	jd_bak = jd;
    152. 	cnt = 0;
    153. 	Delay150ms();
    154. }
    155. void EX0_Init()
    156. {
    157. 	//打开外部中断
    158. 	EX0 = 1;
    159. 	//低电平触发
    160. 	IT0 = 0;
    161. }
    162. // 主函数
    163. void main()
    164. {
    165. 	double dis;
    166. 	Delay300ms(); 	// 让硬件稳定一下
    167. 	Time0Init1();  	// 初始化定时器0
    168. 	Time0Init2();	// 初始化定时器1
    169.     EX0_Init();
    170.     initSG90_0();   // 初始化舵机角度
    171. 	
    172. 	while(1) {
    173. 		dis = get_distance();  // 获取距离
    174. 		if(dis < 10 || SW1 == 0 || D0_ON == 1 ||  mark_vibrate == 1 ) {  // 距离小于10cm或SW1按下或D0_ON为高电平
    175. 			openStatusLight();
    176. 			openlajitong();
    177.     	} else if (D1_OFF == 1) {  // D1_OFF为高电平
    178. 			closeStatusLight();
    179. 			closelajitong();
    180.     	} else {  // 其他情况
    181. 			closeStatusLight();
    182. 			closelajitong();
    183. 		}
    184. 	}
    185. }
    186.  
    187. // 定时器中断处理函数
    188. void Time0Handler() interrupt 1
    189. {
    190. 	cnt++;  // 累计定时器溢出次数
    191. 	TL0 = 0x33;  // 重新设置定时器初值
    192. 	TH0 = 0xFE;
    193. 	if(cnt < jiaodu) {
    194. 		sg90_con = 1;  // 输出高电平
    195. 	} else {
    196. 		sg90_con = 0;  // 输出低电平
    197. 	}
    198. 	if(cnt == 40) {  // 溢出40次，经过20ms
    199. 		cnt = 0;  // 重置计数
    200. 		sg90_con = 1;
    201. 	}
    202.     
    203. }
    204.  
    205. void Ex0_Handler() interrupt 0   //			振动传感器输出低电平 中断
    206. {
    207. 	mark_vibrate = 1;          
    208. }
  • 相关阅读:
    路由之间的转跳及传参
    ThreeJs学习
    测试开发技能实践-搭建ELK日志管理系统
    肝不完这份HTTP八股文的你，再强大也是假的
    SpringMVC 04 RestFul风格
    纽约时报个人叙事赛及纽约时报学生评论赛选哪个？
    java计算机毕业设计家庭财务管理系统设计与实现MyBatis+系统+LW文档+源码+调试部署
    接口的用法、常量接口、微观接口和宏观接口（JAVA基础六）
    【知识】从音频CS4334 DAC转换的电路引发的一些知识
    掌握4C原则，设计高效的系统架构
  • 原文地址：https://blog.csdn.net/2301_79405674/article/details/140912103