51单片机串口

已于 2023-07-24 19:27:31 修改
阅读量3.3k 收藏 54
点赞数 13
文章标签： 51单片机 嵌入式硬件 单片机
于 2023-07-24 19:21:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuechanba/article/details/131742094
版权

该部分的笔记来自视频教程链接https://www.bilibili.com/video/BV1bt4y197NR/?spm_id_from=333.788&vd_source=b91967c499b23106586d7aa35af46413

一、51单片机串口基础介绍

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
一般的应用层的协议中采用和校验或CRC校验，而奇偶校验还是解决基本通信中的帧格式中的校验。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

发送和接收缓冲寄存器都叫 SBUF 且共享逻辑地址 99H ，但在物理上是两个独立的寄存器。相当于是一个房间的前门和后门。

在这里插入图片描述

后面只介绍模式1。

与串口相关的功能寄存器：

在这里插入图片描述
对于 SCON ，主要用到的就是 SM0、SM1、REN、TI 和 RI ，其他几位用的不多。

对于 PCON，只用到了 SMOD 这一位，剩下的几位与串行口无关，与单片机的功耗（如进入掉电模式）有关。当 SMOD 为1时，设定的波特率会翻倍。

在这里插入图片描述

对于多机通信控制，实际上也多是在应用层的通信协议中自定义多机地址来解决，而很少使用 SM2 这种方式。

对于发送中断标志位 TI 和接收中断标志位 RI ，一定要用软件来清 0 。

对于波特率的计算，可以参考下面，

在这里插入图片描述

先确定波特率，再利用公式计算出 T1溢出率。再由 T1溢出率得到定时时间，再由定时时间得到配置定时器的初值。

如果想要做串行通信，一般推荐 11.0592 MHz 的晶振。因为使用 11.0592 MHz 的晶振，再计算定时器的初值时，计算的结果将会是一个整数。

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

二、安装虚拟串口

该软件已上传至 CSDN 资料库（内含安装视频）（资料和安装视频链接： https://www.bilibili.com/video/BV1u54y1s7B3/?spm_id_from=333.337.search-card.all.click&vd_source=b91967c499b23106586d7aa35af46413）。

安装好后，打开该软件，那如何使用这个软件呢？
在这里插入图片描述
点击添加端口，

在这里插入图片描述

在 Proteus 仿真中，搜索并添加器件 COMPIL，

在这里插入图片描述
与单片机相连接。
在这里插入图片描述
双击该元器件，将该器件的 COM 口设置为 COM2。

在这里插入图片描述
为什么要这样连接：
在这里插入图片描述

最后，设定的为COM2口、波特率为 4800，数据位为8位，无奇偶校验位，1位停止位。

在这里插入图片描述

而 COM3 则在电脑上的 STC-ISP 软件上进行选择。

在这里插入图片描述
上面工具准备好之后，就可以编程代码来进行实现了。

一、单片机串行口发送数据到上位机的编程实现之查询方式实现一帧数据的发送

首先，使用 STC-ISP 软件生成指定波特率的代码。

在这里插入图片描述

#include <reg52.h>
#include "delay.h"

void UartInit(void)		//4800bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI  RI  (REN是允许接收)
									//		0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFA;			//设置定时初始值
	TH1 = 0xFA;			//设置定时重载值
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
}

void main()
{
		UartInit();
		while(1)
		{
				// 将数据写到发送缓冲寄存器 SBUF 后，会自动发送出去。
				SBUF = 0x88; // 10位，异步串口通信     0      1000 1000      1 
			                //                    起始位     数据位     停止位
				// 当发送到停止位时，会将 TI 置 1
				while(!TI); // TI == 0 时，会一直等在这
				TI = 0;     // 手动清 0
				Delay_Xms(1000);
		}
}

将波特率修改为 11.0592 MHz，

在这里插入图片描述

后点击运行，在 STC-ISP 软件中的接收缓冲器中选择 HEX 模式。

在这里插入图片描述

在左侧栏的虚拟仪器中可以添加终端来进行查看。

在这里插入图片描述
这个可以代替 STC-ISP 这个软件的串口接收器，因此需要将其的 RXD 连接单片机的 TXD， TXD 连接单片机的 RXD。同时，也需要进行参数设置（ 双击 COMPIM ）。

在这里插入图片描述

之后，点击运行，将会弹出窗口

在这里插入图片描述

如果没有窗口弹出或者将窗口给 × （关闭）掉了，就采用下面的解决方法：

在这里插入图片描述

如果没有这个选项卡，则 先停止仿真，

在这里插入图片描述
之后，应该就可以了。

最后，如果接收到的是乱码，可能是因为显示设置的问题，双击或右键窗口

在这里插入图片描述

勾选 Hex 显示模式，否则，是以文本模式进行显示。

如果在程序中将 0x88 修改为 ‘a’ ，则可以尝试下，

在这里插入图片描述

以文本模式进行显示：

在这里插入图片描述
将其封装成函数，

发送一个字节：

在这里插入图片描述

发送一个字符串：

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}

二、单片机串口发送一串数据到上位机（使用中断的方式实现）及printf串口输出重定向的实现

这里将波特率改为 9600 ，
在这里插入图片描述

代码如下：

#include <reg52.h>
#include "delay.h"

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式
	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
	EA  = 1;        //打开串口中断
}

void main()
{
		UartInit();
		while(1)
		{
				// 将数据写到发送缓冲寄存器 SBUF 后，会自动发送出去。
				SBUF = 0x86; 
				Delay_Xms(1000);
		}
}

void usart_isr() interrupt 4
{
		if(TI)
		{	
				TI = 0;     // 手动清 0
		}
}

串口重定向：keil中的 printf 不能打印到串口，因此，需要做一个重定向，做法是重写 putchar 这个函数。标准C语言中，该函数是被输出到电脑屏幕的。

如何重写呢？

char putchar(char c)
{
	sendByte(c);
	return 0;
}

printf 通过调用该函数来实现向串口输出数据。

此外，使用 printf 函数时，还需要添加头文件 #include <stdio.h>

调用时，可如下所示。

在这里插入图片描述

更为方便的是可以使用格式化输出参数。

在这里插入图片描述
为了方便显示，可以加上回车换行符。

运行结果，如下：
在这里插入图片描述
在这里插入图片描述
有问题。这是格式化输出的问题。

参考手册

在这里插入图片描述

在这里插入图片描述

所以，修改代码，如下。

在这里插入图片描述

之后，输出正常。

总结下：基于 sendByte 函数实现的串口发送（sendString、putchar、printf）是利用的查询的方式实现的。

三、单片机串行口从上位机接收（中断的方式）一帧数据的编程并通过（上面讲解的中断和查询发送的方式）发送给电脑，然后通过串口助手显示的实现方法

12MHz，确实误差较大。

#include <reg52.h>

unsigned char recv_data;

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值

	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
	EA  = 1;        //打开总中断
}

void main()
{
		UartInit();
		while(1);
}

void usart_isr() interrupt 4
{
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
			  recv_data = SBUF; 
				recv_data = recv_data + 1;
				SBUF = recv_data;
		}	
		if(TI)  
		{
				TI = 0;
		}
}

这里，发现一个问题，就是在仿真中，

在这里插入图片描述

如果这根线是连着的话，是看不到实验效果的。

在这里插入图片描述

还有，就是在这个实验中，也要使用 HEX模式进行显示。

可以接着将上面的代码改为查询发送的方式，这样就需要多定义一个变量作为标志位。

完整代码如下：

#include <reg52.h>

unsigned char recv_flag = 0;
unsigned char recv_data;

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值

	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
	EA  = 1;        //打开总中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void main()
{
		UartInit();
		while(1)
		{
			if(recv_flag == 1)
			{
					recv_flag = 0;
					recv_data = recv_data + 1;
					sendByte(recv_data);
			}
		}
}

void usart_isr() interrupt 4
{
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
			  recv_data = SBUF; 
				recv_flag = 1 ;
		}	
}

运行效果与上图一样。

此外，还可以进行扩展，即根据接收的指令执行响应。

在这里插入图片描述

运行效果如下：

在这里插入图片描述

此外，也可以使用字母来作为 switch 的选择条件，

在这里插入图片描述
这时，就需要采用文本发送和接收的方式来进行。

在这里插入图片描述

但是，这种方式还是太过于简单，因为工程上会传很多数据。

四、单片机串行口从上位机接收（中断的方式）一串数据的编程

关键：以一个特定的字符作为结束符。

#include <reg52.h>


#define MAX_REV_NUM 10 

unsigned char recv_flag = 0;

unsigned char recv_length = 0;  // 接收字符数的实际长度

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
	EA  = 1;        //打开总中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}

void main()
{
		unsigned char i;
	
		UartInit();
		while(1)
		{
			if(recv_flag == 1)
			{
					recv_flag = 0;
					for(i = 0; i<recv_length; i++)
					{
						sendByte(recv_buf[i]);
					}
			}
		}
}

void usart_isr() interrupt 4
{
		static unsigned char recv_cnt = 0;
		unsigned char temp;
	
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
				temp = SBUF;
				if(temp != 0xFF)// 必须以0xFF作为此次发送的结束符
				{
					if(recv_cnt < MAX_REV_NUM)
					{
						recv_buf[recv_cnt++] = temp;
					}
				}
				else
				{
						recv_flag = 1 ;
						recv_length = recv_cnt ;
						recv_cnt = 0;
				}
		}	
}

这个程序是有瑕疵的，比如，在要发送的数据后面连续发送两个结束符，就会出现问题。

在这里插入图片描述
我分析，应该是串口中断抢占 while 循环，主循环只来的及发送一个 01，就被第二个 0D 给终止了，所以说该程序是有瑕疵的。

后面，将采用串行口定时中断实现超时接收一串数据的编程，将更加的实用。

五、串行口定时中断实现超时接收一串数据的编程

在这里插入图片描述

5.1 编程思路

假设有两个数据包，第一个数据包有四个数据帧，第二个数据包有五个数据帧。
在这里插入图片描述

那如何利用超时检测来判断第一个数据包是否已经被接收完毕呢？

首先是根据波特率来计算出接收一个字节（数据帧）所需要的时间。一个字节有 10 位，那在9600的波特率下接收完这一个字节的时间就是

在这里插入图片描述
从而在第二帧数据与第一帧数据相差的时间不会超过一个数据帧的时间长度，也就是 1.042 ms 。

当接收完第一个数据包的最后一个数据帧后，如果超过 1.042 ms， 没有数据帧发送来，就说明第一个数据包接受完毕，准备接收第二个数据包或结束接收。

在这里插入图片描述
在程序中实现时，可以在当接收到第一个数据帧后，开启定时器来进行计数，当接收到下一个数据后，就将计数器清零。（有点像喂狗的过程），这样当没有数据发送过来，计数器就不会被清零，从而超过设定的数值。（一般是3-5倍，计算的1.042ms，所以是3-5ms）

5.2 程序代码

main.c

#include <reg52.h>
#include "time.h"

#define MAX_REV_NUM  10  // 最大接收数据量为 10

unsigned char start_timer = 0;

unsigned char recv_flag = 0;

unsigned char recv_timer_cnt = 0; // 定时器启动时间计数

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

unsigned char recv_cnt = 0;

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
	EA  = 1;        //打开总中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}

void clear_recvBuffer(unsigned char *buf)
{
	unsigned char i;
	for(i = 0; i < MAX_REV_NUM; i++)
	{
		buf[i] = 0;
	}
}

void main()
{
		unsigned char i;
	
		Timer0_Init();
		UartInit();
		EA = 1;
		while(1)
		{
			if(recv_flag == 1)
			{
					recv_flag = 0;
				  start_timer = 0; // 关定时器
					sendString(recv_buf);
					clear_recvBuffer(recv_buf);
			}
		}
}

void usart_isr() interrupt 4
{
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
				start_timer = 1; // 1、接收第一帧数据的时候，打开软件定时器去计数

				if(recv_cnt < MAX_REV_NUM)
				{
						recv_buf[recv_cnt++] = SBUF; // 2、接收数据到数据缓冲区，注意缓冲区的大小和范围
				}		
				else
				{
						recv_cnt = MAX_REV_NUM;
				}
				recv_timer_cnt = 0;	// 3、当接收到下一个数据后，就将计数器清零，喂狗。
		}	
}

time.h

#ifndef _TIME_H_
#define _TIME_H_

#include <reg52.h>

#define MAX_REV_TIME 5 

// 函数的声明
void Timer0_Init(void);		//1毫秒@11.0592MHz

#endif

time.c

#include "time.h"

extern unsigned char recv_cnt;

extern unsigned char start_timer ;

extern unsigned char recv_flag;

extern unsigned char recv_timer_cnt ; // 定时器启动时间计数

void Timer0_Init(void)		//1毫秒@11.0592MHz
{

	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	
	TL0 = 0x66;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值

	TF0 = 0;					//清除TF0标志
	ET0 = 1;

	TR0 = 1;					//定时器0开始计时
}

void timer_isr() interrupt 1
{
		TR0 = 0;				//定时器0开始计时
		
		if(start_timer == 1)
		{
			  recv_timer_cnt++;  // 1、累加定时时间计数器
			  if(recv_timer_cnt > MAX_REV_TIME) // 2、判断定时时间是否超过了设定的最大的阈值，超过则说明等待一段时间后没有新的数据到，我们判定一个数据包接收完毕 
				{
					recv_timer_cnt = 0; // 3、清除定时计数器，处理数据(在主循环中)，清除buffer(放到数据处理之后)
					recv_cnt = 0;
					recv_flag = 1;
				}
		}
	
		TL0 = 0x66;				//设置定时初始值
		TH0 = 0xFC;				//设置定时初始值

		TR0 = 1;				//定时器0开始计时
}

六、判断数据帧头（非即时接收，匹配接收缓冲区的方式）来接收一串数据的串口通信程序编写

在上面程序的基础上进行完成。

如何选择数据的帧头呢？

一般有两种情况，一种是所要接收的数据是可预测的，此时可以人为的选择帧头，使得帧头和真正有价值的数据位完全不匹配。另外一种是所要接收的数据是不可预测的，具有随机性。此时，可以采用多个数据帧来构成帧头，即增加特征字节的长度来构成帧头。

本次实现的功能如下：

自定义一个数据帧头为 0x55 ，0xAA ，0x55，然后解析数据位，

在这里插入图片描述

其他数据为无效数据包，会被丢掉。

一般的用户自定义协议数据包会包含：

在这里插入图片描述
程序源码如下：

main.c

#include <reg52.h>
#include "time.h"
#include "led.h"

#define MAX_REV_NUM  10  // 最大接收数据量为 9 ,最后一位是 '\0'

unsigned char start_timer = 0;

unsigned char recv_flag = 0;

unsigned char recv_timer_cnt = 0; // 定时器启动时间计数

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

unsigned char recv_cnt = 0;

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
	EA  = 1;        //打开总中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}

/* 将接收数据缓冲区清零 */
void clear_recvBuffer(unsigned char *buf)
{
	unsigned char i;
	for(i = 0; i < MAX_REV_NUM; i++)
	{
		buf[i] = 0;
	}
}

void uart_service(unsigned char *buf)
{
		unsigned char recv_move_index = 0; // 查找的索引
	
		if(recv_flag)
		{
				recv_flag = 0;
				start_timer = 0; // 关定时器
			
				sendString(buf);
				
				/* 如果接收到的数据是 0x55 0xAA 0x55 0x01 0x02 0x55 0xAA 0x55 0x02 0x01 ，在第一个就响应退出了 */
				/* 接收到的一串数据中只要满足 0x55 0xAA 0x55 0x02 0x01 或 0x55 0xAA 0x55 0x01 0x02 就响应 */
				while((recv_cnt >= 5) && (recv_move_index <= 4)) // 5 + 4 = 9，保障数组不会溢出，而第9位一定是'\0'，所以从第四位就停止处理了
				// 原程序是 while((recv_cnt >= 5) && (recv_move_index <= recv_cnt)),因为当 recv_move_index > 5 时，buf会溢出，程序会无响应，特修改。
				{
						if((buf[recv_move_index + 0] == 0x55) && (buf[recv_move_index+1] == 0xAA) && (buf[recv_move_index+2] == 0x55 ))
						{
								if((buf[recv_move_index+3] == 0x01) && (buf[recv_move_index+4] == 0x02))
								{
										LED1 = 0;
										break;
								}
								if((buf[recv_move_index+3] == 0x02) && (buf[recv_move_index+4] == 0x01))
								{
										LED1 = 1;
										break;
								}
								/* 源程序是在这写了break; 但是存在假帧头的问题即：55 AA 55 AA 55 01 02 66 77 不满足就直接退出了,不会接着往下匹配了 */
						}
						recv_move_index++;
				}
			
				recv_cnt = 0;
				clear_recvBuffer(buf);
			}
}

void main()
{
		unsigned char i;
	
		led_init();
		Timer0_Init();
		UartInit();
		EA = 1;
		while(1)
		{
			uart_service(recv_buf);
		}
}

void usart_isr() interrupt 4
{
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
				start_timer = 1; // 1、接收第一帧数据的时候，打开软件定时器去计数

				if(recv_cnt < MAX_REV_NUM - 1)
				{
						recv_buf[recv_cnt++] = SBUF; // 2、接收数据到数据缓冲区，注意缓冲区的大小和范围
				}		
				else
				{
						recv_cnt = MAX_REV_NUM - 1;
				}
				recv_buf[recv_cnt] = '\0';
				recv_timer_cnt = 0;	// 3、当接收到下一个数据后，就将计数器清零，喂狗。
		}	
}

time.h

#ifndef _TIME_H_
#define _TIME_H_

#include <reg52.h>

#define MAX_REV_TIME 5 

// 函数的声明
void Timer0_Init(void);		//1毫秒@11.0592MHz

#endif

time.c

#include "time.h"

extern unsigned char recv_cnt;

extern unsigned char start_timer ;

extern unsigned char recv_flag;

extern unsigned char recv_timer_cnt ; // 定时器启动时间计数

void Timer0_Init(void)		//1毫秒@11.0592MHz
{

	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	
	TL0 = 0x66;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值

	TF0 = 0;					//清除TF0标志
	ET0 = 1;

	TR0 = 1;					//定时器0开始计时
}

void timer_isr() interrupt 1
{
		TR0 = 0;				//定时器0开始计时
		
		if(start_timer == 1)
		{
				recv_timer_cnt++;  // 1、累加定时时间计数器
			  if(recv_timer_cnt > MAX_REV_TIME) // 2、判断定时时间是否超过了设定的最大的阈值，超过则说明等待一段时间后没有新的数据到，我们判定一个数据包接收完毕 
				{
					recv_timer_cnt = 0; // 3、清除定时计数器，处理数据(在主循环中)，清除buffer(放到数据处理之后)
					
					recv_flag = 1;
				}
		}
	
		TL0 = 0x66;				//设置定时初始值
		TH0 = 0xFC;				//设置定时初始值

		TR0 = 1;				//定时器0开始计时
}

总结：这个程序是在上个程序的基础功能之上（定时中断实现超时接收一串数据）， 为了识别是否为有效数据，加了帧头，也就是多了几个个特定字符（为了增加随机性, 让数据中不出现冲突），然后在接收到数据后，通过逐个判断接收缓冲区中的内容，通过锁定帧头位置，从而获取我们所需要的数据，最后判断处理。此外，为了程序更加稳定，在视频程序的基础上做了两处修改，

一 是考虑数组结束标志：增加了 recv_buf[recv_cnt] = ‘\0’;

二 是考虑数组溢出问题：修改为 while((recv_cnt >= 5) && (recv_move_index <= 4))

三 是考假帧头的情况：在匹配帧头并执行条件时，再 break 退出。

程序上传至CSDN（判断数据帧头（非即时接收，匹配接收缓冲区的方式）来接收一串数据的串口通信程序编写.zip）。

七、串口中断中即时解析数据帧头的通信程序

上面是在接收完数据之后才开始解析数据（在 while 循环中），但是这种方式并不适合于实时性要求高的项目。可以使用在中断中边接收边解析的方式。

自定义一个数据协议如下，

在这里插入图片描述
状态机的编程思想（switch…case…语句）。

记录遇到的问题：是关于蜂鸣器的。因为将 led 的值赋值给了 beep ，导致蜂鸣器响的始终不对。。。从而让我怀疑了人生。折腾了一下午，服气了。。。

main.c

#include <reg52.h>
#include "time.h"
#include "led.h"
#include "beep.h"
#include "uart.h"

unsigned char recv_flag = 0;

extern unsigned char recv_buf[MAX_REV_NUM];

void main()
{
		led_init();
		beep_init();
		Timer0_Init();
		UartInit();
		EA = 1;
		while(1)
		{
				if(recv_flag)
				{
						recv_flag = 0;
						sendString(recv_buf);
						clear_recvBuffer(recv_buf, MAX_REV_NUM);
				}
		}
}

time.c

#include "time.h"

extern unsigned char recv_cnt;
extern unsigned char recv_flag;

extern unsigned int led_data;
extern unsigned int led_cnt;

extern unsigned int beep_data;
extern unsigned int beep_cnt;
extern unsigned char beep_flag;

void Timer0_Init(void)		//1毫秒@11.0592MHz
{

	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	
	TL0 = 0x66;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值

	TF0 = 0;					//清除TF0标志
	ET0 = 1;

	TR0 = 1;					//定时器0开始计时
}

void timer_isr() interrupt 1
{
		TR0 = 0;				//定时器0开始计时
		
		if(led_cnt < led_data)
		{
				led_cnt++;
				LED1 = 0;
		}
		else
		{
				LED1 = 1;
		}
		
//		if(beep_flag)
//		{
			if(beep_cnt > 0)
			{	
					beep_cnt--;
					BEEP = 0;
			}
			else
			{
//					beep_flag = 0;
					BEEP = 1;
			}
//		}
		
//		if(beep_cnt < beep_data)
//		{
//				beep_cnt++;
//				BEEP = 0;
//		}
//		else
//		{
//				BEEP = 1;
//		}
	
		TL0 = 0x66;				//设置定时初始值
		TH0 = 0xFC;				//设置定时初始值

		TR0 = 1;				//定时器0开始计时
}

time.h

#ifndef _TIME_H_
#define _TIME_H_

#include <reg52.h>
#include "led.h"
#include "beep.h"

// 函数的声明
void Timer0_Init(void);		//1毫秒@11.0592MHz

#endif

uart.c

#include "uart.h"

extern unsigned char recv_flag;

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

unsigned char recv_cnt = 0;

unsigned char machine_step = 0;

unsigned int led_data;
unsigned int led_cnt;

unsigned char beep_flag = 0;
unsigned int beep_data;
unsigned int beep_cnt;

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}

/* 将接收数据缓冲区清零 */
void clear_recvBuffer(unsigned char *buf, unsigned char len)
{
	unsigned char i;
	for(i = 0; i < len; i++)
	{
		buf[i] = 0;
	}
}

void usart_isr() interrupt 4
{
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
				switch(machine_step)			
				{
					case 0:									// 状态一
						recv_buf[0] = SBUF;
						if(recv_buf[0] == 0xAA)
						{
								machine_step = 1; // 在状态二接收下一帧的数据
						}
						else
						{
								machine_step = 0;
						}
						break;
						
					case 1:
						recv_buf[1] = SBUF;		// 状态二
						if(recv_buf[1] == 0x55)
						{
								machine_step = 2; 
								recv_cnt = 2;
						}
						else
						{
								machine_step = 0;
						}
						break;
						
					case 2:
						recv_buf[recv_cnt] = SBUF;
						recv_cnt++;
						if(recv_cnt > 4) // 三帧数据接收完毕
						{
								machine_step = 3;
						}
						else
						{
								machine_step = 2;
						}
						break;	
						
					case 3:	
						recv_buf[recv_cnt] = SBUF;
						if(recv_buf[recv_cnt] == 0x0D) // 将数据一次性接收过来
						{
								switch(recv_buf[2])
								{
										case 1:
											led_data = recv_buf[3];
											led_data = led_data << 8;
											led_data = led_data + recv_buf[4];
											led_cnt  = 0; // 目的是使 LED 点亮上述接收的数据时间
										break;
											
										case 2:
											beep_data = recv_buf[3];
											beep_data = beep_data << 8;
											beep_data = beep_data + recv_buf[4];
//											if(beep_flag == 0)
//											{
//												beep_flag = 1;
												beep_cnt  = beep_data;
//											}
//											beep_cnt  = 0;
										break;
										
										default:
											break;
								}
								machine_step = 0;
								recv_cnt = 0;
								recv_flag = 1; // 接收完一串数据，标志位置1
						}
						else // 重新接收
						{
								machine_step = 0;
								recv_cnt = 0;
						}
					break;	
					
					default:	
						break;	
				}
			
		}	
}

uart.h

#ifndef _UART_H_
#define _UART_H_

#include <reg52.h>

#define MAX_REV_NUM  10  // 最大接收数据量为 9 ,最后一位是 '\0'

// 函数声明
extern void UartInit(void);		//9600bps@11.0592MHz

extern void sendString(unsigned char *dat);

extern void clear_recvBuffer(unsigned char *buf, unsigned char len);

#endif

beep.c 和 led.c 省略。

总结：该代码上传至 CSDN 资料库，该部分代码并没有延续上一个程序的定时中断实现超时接收一串数据的编程方式，而是通过判断帧头和帧尾的方式。

程序还存在 Bug ，比如：sendString 函数的问题。比如

在这里插入图片描述

这是因为 sendString 函数判断到 ‘\0’ 就退出的原因，但是程序执行是没有问题的。

结论：该代码思路常规应用（知道对方大概会发过来约定好的协议数据）是没有问题的。

八、串口中断即时解析用户自定义通讯协议的编程实现——接收数据字节固定的情况

主要实现的功能是在前面的代码（中断即时解析用户自定义通讯协议的编程）之上，增加和校验或异或校验。

修改的地方有：把原先在中断中对 数据包中有效数值 的处理放到主程序的 while 循环中。

接收缓冲区是不需要保存帧头、帧尾以及校验等这些数据的。直接在中断中进行判断和解析即可。

在这里插入图片描述
main.c

#include <reg52.h>
#include "time.h"
#include "led.h"
#include "beep.h"
#include "uart.h"

unsigned char recv_flag = 0;

extern unsigned char recv_buf[MAX_REV_NUM];

unsigned int led_data;
unsigned int led_cnt;

unsigned int beep_data;
unsigned int beep_cnt;

void main()
{
		led_init();
		beep_init();
		Timer0_Init();
		UartInit();
		EA = 1;
		while(1)
		{
				if(recv_flag)
				{
						recv_flag = 0;
						sendString(recv_buf);
					
						switch(recv_buf[0])
						{
								case 1:
									led_data = recv_buf[1];
									led_data = led_data << 8;
									led_data = led_data + recv_buf[2];
									led_cnt  = 0; // 目的是使 LED 点亮上述接收的数据时间
								break;
									
								case 2:
									beep_data = recv_buf[1];
									beep_data = beep_data << 8;
									beep_data = beep_data + recv_buf[2];
									beep_cnt  = beep_data;
								break;
								
								default:
									clear_recvBuffer(recv_buf, MAX_REV_NUM);
									break;
						}	
				}
		}
}

uart.c

#include "uart.h"

extern unsigned char recv_flag;

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

unsigned char recv_cnt = 0;

unsigned char machine_step = 0;


void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}
	
/* 将接收数据缓冲区清零 */
void clear_recvBuffer(unsigned char *buf, unsigned char len)
{
	unsigned char i;
	for(i = 0; i < len; i++)
	{
		buf[i] = 0;
	}
}

void usart_isr() interrupt 4
{
		unsigned char recv_data;  // 接收到的数据不再放在接收缓冲区中，而是直接进行处理。
	
		static unsigned char sum_check; // 用于进行 和 校验
		static unsigned char xor_check; // 用于进行异或校验
	
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
			
				recv_data = SBUF;
			
				switch(machine_step)			
				{
					case 0:									// 状态一
						
						sum_check = 0;
						xor_check = 0;
					
						if(recv_data == 0x55)
						{
								machine_step = 1; // 在状态二接收下一帧的数据
						}
						else
						{
								machine_step = 0;
						}
						break;
						
					case 1:
						if(recv_data == 0xAA)// 状态二
						{
								machine_step = 2; 
								recv_cnt = 0; 
						}
						else
						{
								machine_step = 0;
						}
						break;
						
					case 2:// 开始和校验 异或校验
						sum_check += recv_data;
						xor_check ^= recv_data;
						recv_buf[recv_cnt] = recv_data;
						recv_cnt++;
						if(recv_cnt > 2) // 三帧数据接收完毕
						{
								machine_step = 3;
						}
						else
						{
								machine_step = 2;
						}
						break;	
						
					case 3:	
						if(sum_check == recv_data) // 将数据一次性接收过来
						{
								machine_step = 4;
						}
						else // 重新接收
						{
								machine_step = 0;
								sendByte('S');
						}
					break;

					case 4:	
						if(xor_check == recv_data) // 将数据一次性接收过来
						{
								recv_flag = 1; // 接收完一串数据，标志位置1
						}
						else
						{
								sendByte('X');
						}
						machine_step = 0;
						recv_cnt = 0; 
						
					break;					
					
					default:	
						break;	
				}
			
		}	
}

为了进一步保障代码的可行性以及增加错误提示功能，代码中还增加了特征码或提示信息的形式（直接使用 sendByte 函数发送即可）来提示用户因为什么原因造成通信出错。（比如：帧头、帧尾、校验等等）

这样，发现视频中的代码有一个问题，就是

校验字清零应该放到 step 0 处无条件执行，因为有可能 执行不到 step 4 .

其他的代码没变。

测试代码，为了方便校验位的计算，有网址链接: http://www.metools.info/code/c128.html。需要注意，这里使用的 hex 模式，如果是按照文本格式发的字符数据，就使用 ASCII 模式。

已验证，代码运行正常。
在这里插入图片描述

最终的代码已上传 CSDN 。

九、串口中断即时解析用户自定义通讯协议的编程实现——协议内带数据长度及接收应答处理

通信协议如下：
在这里插入图片描述
然后将接收到的有效数据用 OLED 显示出来。

main.c

//	 
//  功能描述   : OLED 4接口演示例程(51系列)
//              说明: 
//              ----------------------------------------------------------------
//              GND    电源地
//              VCC  接5V或3.3v电源
//              SCL  P17（SCL）
//              SDA  P16（SDA）
//              RES  P15 注：SPI接口显示屏改成IIC接口时需要接RES引脚
//                           IIC接口显示屏用户请忽略
//              ----------------------------------------------------------------
//******************************************************************************/

#include "stc12c5a60s2.h"		 
#include "oled.h"
#include "bmp.h"
#include "time.h"
#include "uart.h"
#include "led.h"
#include "beep.h"
#include "display.h"

extern unsigned char recv_flag;

void main(void)
{	
	led_init();
	beep_init();
	Timer0_Init();
	UartInit();
	OLED_Init();//初始化OLED
	
	EA = 1;
	WindowShow();	
	while(1) 
	{		
		if(recv_flag)
		{
			recv_flag = 0;
			Rec_ResolutionShow();
		}
	}	 
}

uart.c

#include "uart.h"

unsigned char code recv_correct[]    = {0x55, 0xAA, 0x80, 0x00, 0x80, 0x80};
unsigned char code sum_check_error[] = {0x55, 0xAA, 0x81, 0x00, 0x81, 0x81}; 
unsigned char code xor_check_error[] = {0x55, 0xAA, 0x82, 0x00, 0x82, 0x82}; 

unsigned char recv_flag;

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

unsigned char recv_cnt = 0;
unsigned char recv_length = 0; // 保存接收字节的长度

unsigned char machine_step = 0;


void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}
	
/* 将接收数据缓冲区清零 */
void clear_recvBuffer(unsigned char *buf, unsigned char len)
{
	unsigned char i;
	for(i = 0; i < len; i++)
	{
		buf[i] = 0;
	}
}

void usart_isr() interrupt 4
{
		unsigned char i;
		unsigned char recv_data;  // 接收到的数据不再放在接收缓冲区中，而是直接进行处理。
	
		static unsigned char sum_check; // 用于进行 和 校验
		static unsigned char xor_check; // 用于进行异或校验
	
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
			
				recv_data = SBUF;
			
				switch(machine_step)			
				{
					case 0:									// 状态一
						
						sum_check = 0;
						xor_check = 0;
					
						if(recv_data == 0x55)
						{
								machine_step = 1; // 在状态二接收下一帧的数据
						}
						else
						{
								machine_step = 0;
						}
						break;
						
					case 1:
						if(recv_data == 0xAA)// 状态二
						{
								machine_step = 2; 
								recv_cnt = 0; 
						}
						else
						{
								machine_step = 0;
						}
						break;
						
					case 2:// 开始和校验 异或校验
						sum_check = recv_data;
						xor_check = recv_data;
						recv_buf[recv_cnt] = recv_data; // 接收的是数据类型 — 放入接收缓冲区
						recv_cnt++;
						machine_step = 3;
						break;	
						
					case 3:	
						sum_check += recv_data;
						xor_check ^= recv_data;
						recv_length = recv_data;        // 接收的是数据长度 — 不放入接收缓冲区
						machine_step = 4;
					break;
					
					case 4:	
						sum_check += recv_data;
						xor_check ^= recv_data;
						recv_buf[recv_cnt] = recv_data;
						
						if(recv_cnt == recv_length)
						{
								machine_step = 5;
						}
						else
						{
								machine_step = 4;           // 继续接收
						}
						recv_cnt++;  // 如果放到 if 前面去，if条件判断中就需要使用 >
					break;
						
					case 5:	
						if(sum_check == recv_data) // 和校验正确
						{
								machine_step = 6;
						}
						else // 重新接收
						{
								machine_step = 0;
								for(i = 0; i<6; i++)
								{
										sendByte(sum_check_error[i]);
								}
						}
					break;

					case 6:	
						if(xor_check == recv_data) // 异或校验正确
						{
								recv_flag = 1; // 接收完一串数据，标志位置1
								for(i = 0; i<6; i++)
								{
										sendByte(recv_correct[i]);
								}
						}
						else
						{
								for(i = 0; i<6; i++)
								{
										sendByte(xor_check_error[i]);
								}
						}
						machine_step = 0;
						recv_cnt = 0; 
					break;					
					
					default:	
						machine_step = 0;
						recv_cnt = 0; 
						break;	
				}
		}	
}

uart.h

#ifndef _UART_H_
#define _UART_H_

#include "stc12c5a60s2.h"	

#define MAX_REV_NUM  10  // 最大接收数据量为 9 ,最后一位是 '\0'

// 函数声明
extern void UartInit(void);		//9600bps@11.0592MHz

extern void sendString(unsigned char *dat);

extern void clear_recvBuffer(unsigned char *buf, unsigned char len);

#endif

display.c (使用的是 IIC 接口的 OLED 显示屏)

#include "display.h"

extern unsigned char recv_buf[MAX_REV_NUM];

unsigned char display_buf[MAX_REV_NUM*2];

void WindowShow(void)
{
		INVERSE_OLED_ShowChinese(0,0,7,16);
		INVERSE_OLED_ShowChinese(16,0,1,16);//景
		INVERSE_OLED_ShowChinese(32,0,2,16);//园
		INVERSE_OLED_ShowChinese(48,0,3,16);//电
		INVERSE_OLED_ShowChinese(64,0,4,16);//子
		INVERSE_OLED_ShowChinese(80,0,5,16);//科
		INVERSE_OLED_ShowChinese(96,0,6,16);//技
		INVERSE_OLED_ShowChinese(112,0,7,16);
}

void Rec_ResolutionShow(void)
{
		OLED_ShowString(0,3,"      ",16);
		switch(recv_buf[0])
		{
				case 1:
						display_buf[0] = (recv_buf[1] >> 4) + '0';
						display_buf[1] = (recv_buf[1] & 0x0F) + '0';
						display_buf[2] ='\0';
						
				break;
					
				case 2:
						display_buf[0] = (recv_buf[1] >> 4) + '0';
						display_buf[1] = (recv_buf[1] & 0x0F)+ '0';
						display_buf[2] = (recv_buf[2] >> 4)+ '0';
						display_buf[3] = (recv_buf[2] & 0x0F)+ '0';
						display_buf[4] ='\0';
				break;
				
				case 3:
						display_buf[0] = (recv_buf[1] >> 4)+ '0';
						display_buf[1] = (recv_buf[1] & 0x0F)+ '0';
						display_buf[2] = (recv_buf[2] >> 4)+ '0';
						display_buf[3] = (recv_buf[2] & 0x0F)+ '0';
						display_buf[4] = (recv_buf[3] >> 4)+ '0';
						display_buf[5] = (recv_buf[3] & 0x0F)+ '0';
						display_buf[6] ='\0';
				break;
				
				default:
						clear_recvBuffer(recv_buf, MAX_REV_NUM);
						clear_recvBuffer(display_buf, MAX_REV_NUM*2);
				break;
		}	
		OLED_ShowString(0,3,display_buf,16);
}

用不到定时器，如果要用定时器的话，可以将显示部分放到定时器中，在实验时这样操作，遇到了一点问题。

上述函数 Rec_ResolutionShow(void) 是包含数据包解析和OLED显示两个部分，如果把 Rec_ResolutionShow 直接放到 while 循环中或者放到 定时中断 中时，实验效果都可以。但是，如果将解析部分放到 while 循环中，而将显示放到 定时器中断中（1ms 中断一次）时，就会出现只能接收一次的情况，后面再接收就不行了。我认为是定时器中断的优先级高于接收中断高于 while 循环，从而导致定时中断显示和接收打架。从而出现问题。

此外，这个程序还存在问题，就是如果再发送时不按照协议约定的发，比如将这种特征代码发送出来，

在这里插入图片描述
在本次范例中，82是类别，00是长度，而在程序中

case 3:	
	sum_check += recv_data;
	xor_check ^= recv_data;
	recv_length = recv_data;        // 接收的是数据长度 — 不放入接收缓冲区
	machine_step = 4;
break;

case 4:	
	sum_check += recv_data;
	xor_check ^= recv_data;
	recv_buf[recv_cnt] = recv_data;
	
	if(recv_cnt == recv_length)
	{
			machine_step = 5;
	}
	else
	{
			machine_step = 4;           // 继续接收
	}
	recv_cnt++;  // 如果放到 if 前面去，if条件判断中就需要使用 >
break;

由于 recv_length 是 0，而 recv_cnt 非 0，程序到后面会造成 recv_buf 溢出也不能往下执行，直到 recv_cnt 溢出变为 0 ，然后接着往下执行。所以就会造成问题，还有就是 recv_length 长度定义超过数据接收缓冲器的最大接收量，也会造成这样 recv_buf 溢出，造成问题。因此，结论就是，可以在上述发现问题的基础之上做一些修改进行约束（这里不再添加），该代码思路常规应用（知道对方大概会发过来约定好的协议数据）是没有问题的。

代码已上传至 CSDN 资料库。

十、串口超时接收用户自定义通讯协议的编程实现——协议内 CRC16 校验及接收应答处理

CRC校验一般指循环冗余校验码。 循环冗余校验码（CRC），简称循环码，是一种常用的、具有检错、纠错能力的校验码。在编程时，可以使用现有的CRC校验库或者算法实现来进行CRC校验。常见的编程语言和工具中都提供了CRC校验的函数库或者算法，可以方便地进行CRC校验的计算和验证

在单片机中，主要使用的是查表法（校验库）。因为查表法的算法比较简单，代码执行时间也较短。但有个缺点就是需要占用较大的 ROM，51 单片机有 4K 的 ROM，足够去使用。

算法链接: https://blog.csdn.net/weixin_41542513/article/details/94201518?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169018297716800197018920%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=169018297716800197018920&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allbaidu_landing_v2~default-4-94201518-null-null.142v90chatsearch,239v3insert_chatgpt&utm_term=modbus%20rtu%E9%80%9A%E8%AE%AF%E5%8D%8F%E8%AE%AE%20crc16&spm=1018.2226.3001.4187

CRC校验工具链接:http://www.ip33.com/crc.html

在这里插入图片描述
需要注意，这里的参数模型选择 CRC-16/MODBUS 。

校验计算的结果是高位在前，低位在后 （发送时要先发低位，再发高位）。所以要颠倒下。

这里将要实现的功能如下：

在这里插入图片描述

正常时，单片机执行相应的功能并将接收的数据发送回来，如果错误，将返回相应的一串代码 。

视频中的代码存在一定的问题，是在收到错误数据，回传后，要清除下 recv_buf 和 recv_cnt 数据（每次返回前需要清除）。不然发送两次错误后，就发送不了了。

代码如下，

main.c（应该分离出 uart.c 和 uart.h）

#include <reg52.h>
#include "crc16_modbus.h"
#include "time.h"
#include "led.h"
#include "beep.h"

#define MAX_REV_NUM   10  // 最大接收数据量为 9 ,最后一位是 '\0'

#define LOCAL_ADRESS  0x01

unsigned char start_timer = 0;

unsigned char recv_flag = 0;

unsigned char recv_timer_cnt = 0; // 定时器启动时间计数

unsigned char recv_buf[MAX_REV_NUM]; // 接收缓冲区, MAX_REV_NUM 要大于接收的字符数

unsigned char recv_cnt = 0;

unsigned int led_data;
unsigned int led_cnt;

unsigned int beep_data;
unsigned int beep_cnt;

void UartInit(void)		//9600bps@11.0592MHz
{
	SCON = 0x50;		//8位数据,可变波特率 SM0 SM1 SM2 REN TR8 RB8 TI RI  (REN是允许接收)
									//									 0   1   0   1   0   0   0  0
	TMOD &= 0x0F;		//设置定时器模式
	TMOD |= 0x20;		//设置定时器模式

	TL1 = 0xFD;			//设置定时初始值
	TH1 = 0xFD;			//设置定时重载值
  
	ET1 = 0;			  //禁止定时器中断(不用定时器1的中断)
	TR1 = 1;			  //定时器1开始计时
	ES  = 1;        //打开串口中断
}

void sendByte(unsigned char dat)
{
		SBUF = dat; // 10位，异步串口通信     0      1000 1000      1 
									//                    起始位     数据位     停止位
		// 当发送到停止位时，会将 TI 置 1
		while(!TI); // TI == 0 时，会一直等在这
		TI = 0;     // 手动清 0
}

void sendString(unsigned char *dat)
{
		while(*dat != '\0') 
		{
				sendByte(*dat++);
		}
}

/* 将接收数据缓冲区清零 */
void clear_recvBuffer(unsigned char *buf)
{
	unsigned char i;
	for(i = 0; i < MAX_REV_NUM; i++)
	{
		buf[i] = 0;
	}
}

void uart_service(unsigned char *buf)
{
		unsigned char i;
		unsigned int crc;
		unsigned char crch,crcl;
	
		if(recv_flag)
		{
				recv_flag = 0;
				start_timer = 0; // 关定时器
				
				// 校验本机地址 - 是本机 - 处理 - 否则直接返回
				if(recv_buf[0] != LOCAL_ADRESS)
				{
						clear_recvBuffer(buf);
						recv_cnt = 0;
						return ;
				}
				
				// CRC校验 - 校验正确才处理 - 否则直接返回 - 并给出错误码
				crc  = crc16(recv_buf, recv_cnt - 2);
				crch = crc >> 8;
				crcl = crc & 0xFF;
				if((crch != recv_buf[recv_cnt - 2]) || (crcl != recv_buf[recv_cnt - 1]))
				{
						recv_buf[1] = recv_buf[1] | 0x80;  // 到这说明校验错误
						crc = crc16(recv_buf, recv_cnt - 2);
						recv_buf[4] = crc & 0xFF; // 低位（先发）
						recv_buf[5] = crc >> 8;   // 高位（后发）
					
						for(i = 0; i<recv_cnt; i++)
						{
								sendByte(recv_buf[i]);
						}	
						
						clear_recvBuffer(buf);
						recv_cnt = 0;
						return ;
				}
				
				switch(recv_buf[1]) // 到这说明校验正确
				{
						case 1:
							led_data = recv_buf[2];
							led_data = led_data << 8;
							led_data = led_data + recv_buf[3];
							led_cnt  = 0; // 目的是使 LED 点亮上述接收的数据时间
						break;
							
						case 2:
							beep_data = recv_buf[2];
							beep_data = beep_data << 8;
							beep_data = beep_data + recv_buf[3];
							beep_cnt  = beep_data;
						break;
						
						default:
						break;
				}
				
				for(i = 0; i<recv_cnt; i++)
				{
						sendByte(recv_buf[i]);
				}	
			
				clear_recvBuffer(buf);
				recv_cnt = 0;
		}
}

void main()
{
	led_init();
	beep_init();
	Timer0_Init();
	UartInit();
	EA = 1;
	while(1)
	{
		 uart_service(recv_buf);
	}
}

void usart_isr() interrupt 4
{
		if(RI)          // 接收到1帧数据
		{	
				RI = 0;     // 手动清 0
				start_timer = 1; // 1、接收第一帧数据的时候，打开软件定时器去计数

				if(recv_cnt < MAX_REV_NUM - 1)
				{
						recv_buf[recv_cnt++] = SBUF; // 2、接收数据到数据缓冲区，注意缓冲区的大小和范围
				}		
				else
				{
						recv_cnt = MAX_REV_NUM - 1;
				}
				recv_buf[recv_cnt] = '\0';
				recv_timer_cnt = 0;	// 3、当接收到下一个数据后，就将计数器清零，喂狗。
		}	
}

time.c

#include "time.h"

extern unsigned char start_timer ;

extern unsigned char recv_flag;

extern unsigned char recv_timer_cnt ; // 定时器启动时间计数

extern unsigned int led_data;
extern unsigned int led_cnt;

extern unsigned int beep_data;
extern unsigned int beep_cnt;

void Timer0_Init(void)		//1毫秒@11.0592MHz
{

	TMOD &= 0xF0;			//设置定时器模式
	TMOD |= 0x01;			//设置定时器模式
	
	TL0 = 0x66;				//设置定时初始值
	TH0 = 0xFC;				//设置定时初始值

	TF0 = 0;					//清除TF0标志
	ET0 = 1;

	TR0 = 1;					//定时器0开始计时
}


void timer_isr() interrupt 1
{
		TR0 = 0;				//定时器0开始计时
	
		if(led_cnt < led_data)
		{
				led_cnt++;
				LED1 = 0;
		}
		else
		{
				LED1 = 1;
		}
		
		if(beep_cnt > 0)
		{
				beep_cnt--;
				BEEP = 0;
		}
		else
		{
				BEEP = 1;
		}
		
		if(start_timer == 1)
		{
			  recv_timer_cnt++;  // 1、累加定时时间计数器
			  if(recv_timer_cnt > MAX_REV_TIME) // 2、判断定时时间是否超过了设定的最大的阈值，超过则说明等待一段时间后没有新的数据到，我们判定一个数据包接收完毕 
				{
					recv_timer_cnt = 0; // 3、清除定时计数器，处理数据(在主循环中)，清除buffer(放到数据处理之后)
					recv_flag = 1;
				}
		}
	
		TL0 = 0x66;				//设置定时初始值
		TH0 = 0xFC;				//设置定时初始值

		TR0 = 1;				//定时器0开始计时
}

time.h

#ifndef _TIME_H_
#define _TIME_H_

#include <reg52.h>
#include "beep.h"
#include "led.h"

#define MAX_REV_TIME 5 

// 函数的声明
void Timer0_Init(void);		//1毫秒@11.0592MHz

#endif

crc16_modbus.c（代码来自 csdn ，豪哥追求卓越）

#include "crc16_modbus.h"

/***********************CRC校验*************************/

// CRC 高位字节值表
unsigned char code auchCRCHi[260] = { 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
	0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
	0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
	0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
	0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
	0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
	0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40 
} ; 

// CRC低位字节值表
unsigned char code  auchCRCLo[260] = { 
	0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 
	0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 
	0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 
	0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 
	0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 
	0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 
	0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 
	0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 
	0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 
	0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 
	0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 
	0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 
	0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 
	0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 
	0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 
	0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 
	0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 
	0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 
	0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 
	0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 
	0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 
	0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 
	0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 
	0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 
	0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 
	0x43, 0x83, 0x41, 0x81, 0x80, 0x40 
} ;

unsigned int crc16(unsigned char *puchMsg, unsigned int usDataLen) 
{ 
	 unsigned int  uIndex ;            // CRC循环中的索引 
	 unsigned char uchCRCHi = 0xFF ;   //*高CRC字节初始化 
	 unsigned char uchCRCLo = 0xFF ;   //*低CRC字节初始化  
	 
	 while (usDataLen--)               //传输消息缓冲区 
	 { 
		uIndex = uchCRCHi ^ *puchMsg++ ; // 计算CRC  
		uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ; 
		uchCRCLo = auchCRCLo[uIndex] ; 
	 } 
	 
	 return (uchCRCHi << 8 | uchCRCLo);
}

该代码可应用于实际项目，代码已上传 CSDN 。

测试指令(Hex模式发送)：
在这里插入图片描述
需要注意的是，代码中的 CRC 校验码的高低位的前后顺序。

xuechanba
关注
  • 13
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
51单片机串口数据发送，LCD显示
07-09
1. **51单片机串口通信**： - 串口通信是51单片机与其他设备间常见的一种通信方式，通常采用UART（通用异步收发传输器）协议。 - 串口通信的基本参数包括波特率、数据位、停止位和校验位，这些参数需在发送和接收...
51单片机串口发送16进制数并在数码管上显示
06-06
程序描述：以16进制发送一个0-65535之间的任一数，当单片机收到后再以16进制形式在数码管上动态显示出来，波特率自定。 使用开发板：清翔电子，普中的应该也适用。 注意事项：使用串口助手发送字符需要带上结束符...
C51单片机串口发送数据的使用
qq_27699199的博客
11-15 2875
c51单片机串口printf重定向
【单片机学习】51单片机【串口】，详细介绍
m0_55251293的博客
02-09 6179
文章目录一、先知先会1、计算串行通信基础2、串行通信的基本概念(1)、异步通信与同步通信a.异步通信b、同步通信(2)、串行通信的传输方向(3)、串行通信常见的错误校验(4)、传输速率(5)、传输距离与传输速率的关系(6)、串行通信接口标准a.RS-232C接口<1>、机械特性<2>、功能特性<3>、过程特性b.RS-232C电平与TTL电平转换驱动电路c.RS422A接口d.RS-485接口二、80C51的串行口1、80C51串行口的结构2、寄存器SCON3、寄存器PC
51单片机实现奇偶校验
最新发布
qq_45332251的博客
05-23 726
在STC15单片机中，不用自己写代码计算接收过来的数据有多少个1，可以使用ACC累加器，直接把一个字节数据丢进去，会把1是奇数个还是偶数个放在PSW寄存器中的P中。若数据位中的1为奇数个，P=1，若为偶数个，P=0，根据数据中的1的个数、奇校验还是偶校验，得到校验位应该是0还是1，再和RB8对比。如果是奇校验，第九位校验位等于程序状态字（PSW）中的奇偶标志位P取反；如果是偶校验，则第九位校验位等于P。奇校验：原数据+校验位 为奇数个1。偶校验：原数据+校验位 为偶数个1。
51单片机-串口通信(串口向电脑发送信息&电脑通过串口控制LED)
cyaya6的博客
10-23 3万+
51单片机-串口通信(串口向电脑发送信息&电脑通过串口控制LED)
51单片机之——串口通信（含实现部分）
欢迎一起交流问题！
09-25 2万+
本篇文章将实现两个部分，第一部分为实现单片机通过串口向电脑发送数据；第二部分为实现电脑通过串口控制单片机LED灯
51单片机单片机串口通信
weichen_78的博客
11-25 1333
讲述计算机串行通信基础知识和51单片机的串口编程。
51单片机——串行口通信
qq_65980796的博客
07-29 5200
①51单片机串行口通信理论、实操详解。 ②51单片机串行口通信的相关寄存器学习详解。 ③51单片机串行口通信实战篇——电脑通过串口控制LED。
51单片机串口接收使用队列C语言实现
02-24
通过以上方式，我们可以实现51单片机串口接收的高效管理，确保数据的稳定传输和正确处理。这个方法不仅适用于51单片机，也可以应用到其他支持串口通信的微控制器中。在实际项目中，可能还需要考虑错误检测、多线程...
51单片机串口通讯中断应用
01-16
3. **工作模式**：51单片机串口支持四种工作模式：方式0、1、2和3。其中，方式1是最常用的异步通信模式，方式2和3则用于实现多机通信或波特率可变的通信。 4. **中断机制**：中断是51单片机处理串口通讯的关键，当...
51单片机简单的中断法串口收发程序，51单片机串口数据收发
03-22
利用串口调试助手给单片机发数据，单片机会将改数据原样送回电脑
51单片机串口接收字符串比较
02-16
51单片机串口接收字符串的实践中，还会遇到一些常见问题，如数据丢失、串口波特率不匹配、中断处理不当等。这些问题需要通过调试和优化代码来解决。例如，确保中断服务程序的执行时间尽可能短，以避免错过其他中断...
关于单片机串口重定向示例展示
qq_44829055（金丝草）的博客
11-26 942
1、这个是我在STM32里的串口重定向函数。 2、目前在STM32里可以使用，不知道在51单片机里可不可以用。 3、展示给有需要的人。 ///重定向c库函数printf到串口，重定向后可使用printf函数 int fputc(int ch, FILE *f) { /* 发送一个字节数据到串口 */ USART_SendData(USARTx, (uint8_t) ch); /* 等待发送完毕 */ while (!USART_GetFlagStatus(USARTx, USART_
51单片机之串口通信详解及代码示例
热门推荐
Wendy的博客
04-20 7万+
目录一、串口介绍二、硬件电路三、51单片机的UART四、相关寄存器4.1 SCON：串口控制寄存器（可位寻址）4.2 PCON：电源控制寄存器（不可位寻址）4.3 TMOD五、串口通信操作流程5.1 发送数据流程5.2 接收数据流程六、波特率计算七、效果演示 一、串口介绍 串口是一种应用十分广泛的通讯接口，串口成本低、容易使用、通信线路简单，可实现两个设备的互相通信。 单片机的串口可以使单片机与单片机、单片机与电脑、单片机与各式各样的模块互相通信，极大的扩展了单片机的应用范围，增强了单片机系统的硬件实力。
实验（七）：串行口实验
心之所向
12-07 1万+
《单片机原理及应用》实验报告（七）【zzuli】
STC51单片机串口发送程序
sidely的专栏
10-10 1万+
#include    #define uchar unsigned char    unsigned char rtemp,sflag; unsigned char code Buffer[] = "Welcome To The MCU World."; //所要发送的数据 unsigned char *p;   unsigned char TestBuff[3];
单片机串口程序1
darren2015zdc的博客
06-27 975
//转的单片机串口程序 发一个用串口命令单片机控制开关输出的小程序，如串口发送led0_open回车后，单片机点亮led0 程序波特率设为2400bps(12Mhz晶振)，请根据需要自行修改 [attachment=2332028] #include #include "string.h" sbit led0=P0^0; //定义led接口 sbit led1=P0^1; //同上 sbit
51单片机实现串口偶校验
TrueLink的博客
01-14 1万+
1. STC单片机串口 2. PSW是一个8位寄存器。PSW的全称是Program Status Word，即程序状态字。 奇偶标志位P 每执行一条汇编指令，单片机都能根据A中1的个数的奇偶自动令P置位或清零，奇为1，偶为0。P可以填入TB8，作为偶校验。 此标志位对串行通信的数据传输非常有用，通过就校验可以检验传输的可靠性。 3. 奇偶校验 奇校验（odd parity）：让传输的数据（包含校验位）中1的个数为奇数。 偶校验（even parity）：让传输的数据（包含校验位）中1的个数为偶数。
proteus中的COMPIM元器件介绍
05-18
在Proteus中，COMPIM元器件是一个通用的模拟器件。它允许您以模拟数字或模拟信号源的形式向电路中注入信号。COMPIM元件可以模拟各种类型的信号源，例如方波、正弦波、三角波、锯齿波等等。 您可以通过在电路中添加COMPIM元件来模拟任何类型的数字或模拟信号源。您可以设置信号的幅度、频率、相位和其他参数。该元件还可以模拟输入信号的噪声和失真。 在Proteus中，使用COMPIM元器件的步骤如下： 1. 在库中选择COMPIM元件，并将其拖放到电路图中。 2. 双击COMPIM元件，打开其属性对话框。 3. 在属性对话框中，设置所需的信号参数，例如幅度、频率、相位等。 4. 将COMPIM元件的输出连接到电路中所需的位置。 希望我的回答能够帮助到您。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xuechanba

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值