单片机学习笔记————51单片机实现常用的自定义串口通讯协议

proteus虚拟串口的实现：https://mp.csdn.net/console/editor/html/107251649

一、使用proteus绘制简单的电路图，用于后续仿真

二、编写程序

/********************************************************************************************************************
----	@Project:	USART
----	@File:	main.c
----	@Edit:	ZHQ
----	@Version:	V1.0
----	@CreationTime:	20200711
----	@ModifiedTime:	20200711
----	@Description:	
----	波特率是：9600 。
----	通讯协议：EB 00 55  GG HH HH XX XX …YY YY CY
----	其中第1,2,3位EB 00 55就是数据头
----	其中第4位GG就是数据类型。01代表驱动奉命，02代表驱动Led灯。
----	其中第5,6位HH就是有效数据长度。高位在左，低位在右。
----	其中第5,6位HH就是有效数据长度。高位在左，低位在右。
----	其中从第7位开始，到最后一个字节Cy之前，XX..YY都是具体的有效数据。
----	在本程序中，当数据类型是01时，有效数据代表蜂鸣器鸣叫的时间长度。当数据类型是02时，有效数据代表Led灯点亮的时间长度。
----	最后一个字节CY是累加和，前面所有字节的累加。
----	发送以下测试数据，将会分别控制蜂鸣器和Led灯的驱动时间长度。
----	蜂鸣器短叫发送：eb 00 55 01 00 02 00 28 6b  
----	蜂鸣器长叫发送：eb 00 55 01 00 02 00 fa 3d  
----	Led灯短亮发送：eb 00 55 02 00 02 00 28 6c
----	Led灯长亮发送：eb 00 55 02 00 02 00 fa 3e 
----	单片机：AT89C52
********************************************************************************************************************/
#include "reg52.h"
/*——————宏定义——————*/
#define FOSC 11059200L
#define BAUD 9600
#define T1MS (65536-FOSC/12/500)   /*0.5ms timer calculation method in 12Tmode*/

#define const_rc_size 20	/*接收串口中断数据的缓冲区数组大小*/

#define const_receive_time 5	/*如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小*/

/*——————变量函数定义及声明——————*/
/*蜂鸣器的驱动IO口*/
sbit BEEP = P2^7;
/*LED*/
sbit LED = P3^5;

unsigned int uiSendCnt = 0;	/*用来识别串口是否接收完一串数据的计时器*/
unsigned char ucSendLock = 1;	/*串口服务程序的自锁变量，每次接收完一串数据只处理一次*/
unsigned int uiRcregTotal = 0;	/*代表当前缓冲区已经接收了多少个数据*/
unsigned char ucRcregBuf[const_rc_size];	/*接收串口中断数据的缓冲区数组*/
unsigned int uiRcMoveIndex = 0;	/*用来解析数据协议的中间变量*/

/*为串口计时器多增加一个原子锁，作为中断与主函数共享数据的保护*/
unsigned char ucSendCntLock = 0;	/*串口计时器的原子锁*/
unsigned char ucVoiceLock = 0;	/*蜂鸣器鸣叫的原子锁*/
unsigned char ucLedLock = 0;	/*Led灯点亮时间的原子锁*/

unsigned char ucRcType = 0;	/*数据类型*/
unsigned int uiRcSize = 0;	/*数据长度*/
unsigned char ucRcCy = 0;	/*校验累加和*/

unsigned int uiVoiceCnt = 0;	/*蜂鸣器鸣叫的持续时间计数器*/
unsigned int uiRcVoiceTime = 0;	/*蜂鸣器发出声音的持续时间*/

unsigned int uiRcLedTime = 0;	/*在串口服务程序中，Led灯点亮时间长度的中间变量*/
unsigned int uiLedTime = 0;	/*Led灯点亮时间的长度*/
unsigned int uiLedCnt = 0;	/*Led灯点亮的计时器*/

/**
* @brief  定时器0初始化函数
* @param  无
* @retval 初始化T0
**/
void Init_T0(void)
{
	TMOD = 0x01;                    /*set timer0 as mode1 (16-bit)*/
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
}

/**
* @brief  串口初始化函数
* @param  无
* @retval 初始化T0
**/
void Init_USART(void)
{
	SCON = 0x50;
	TMOD = 0x21;                    
	TH1=TL1=-(FOSC/12/32/BAUD);
}

/**
* @brief  外围初始化函数
* @param  无
* @retval 初始化外围
* 让数码管显示的内容转移到以下几个变量接口上，方便以后编写更上一层的窗口程序。
* 只要更改以下对应变量的内容，就可以显示你想显示的数字。
**/
void Init_Peripheral(void)
{
	ET0 = 1;/*允许定时中断*/
	TR0 = 1;/*启动定时中断*/
	TR1 = 1;
	ES = 1;	/*允许串口中断*/
	EA = 1;/*开总中断*/  
}

/**
* @brief  初始化函数
* @param  无
* @retval 初始化单片机
**/
void Init(void)
{
	LED  = 0;
	BEEP = 1;
	Init_T0();
	Init_USART();
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  /*内嵌循环的空指令数量*/
          {
             ; /*一个分号相当于执行一条空语句*/
          }
   }
}
///**
//* @brief  延时函数
//* @param  无
//* @retval 无
//**/
//void Delay_Short(unsigned int uiDelayShort)
//{
//   unsigned int i;
//   for(i=0;i<uiDelayShort;i++)
//   {
//		 ; /*一个分号相当于执行一条空语句*/
//   }
//}
/**

* @brief  Led灯的服务程序
* @param  无
* @retval 无
**/
void led_service(void)
{
	if(uiLedCnt < uiLedTime)
	{
		LED = 1;	/*LED亮*/
	}
	else
	{
		LED = 0;
	}
	
}

/**
* @brief  串口服务程序
* @param  无
* @retval 在main函数里
* 识别一串数据是否已经全部接收完了的原理:
* 在规定的时间里，如果没有接收到任何一个字节数据，那么就认为一串数据被接收完了，然后就进入数据协议
* 解析和处理的阶段。这个功能的实现要配合定时中断，串口中断的程序一起阅读，要理解他们之间的关系。
**/
void usart_service(void)
{
	/*局部变量定义*/
	unsigned int i;	
	/*如果超过了一定的时间内，再也没有新数据从串口来*/
	if(uiSendCnt >= const_receive_time && ucSendLock == 1)
	{
		ucSendLock = 0;	/*处理一次就锁起来，不用每次都进来,除非有新接收的数据*/
		/*下面的代码进入数据协议解析和数据处理的阶段*/
		uiRcMoveIndex = 0;	/*由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动*/
		/*
		* 判断数据头，进入循环解析数据协议必须满足两个条件:
		* 第一：最大接收缓冲数据必须大于一串数据的长度（这里是5。包括2个有效数据，3个数据头）
		* 第二：游标uiRcMoveIndex必须小于等于最大接收缓冲数据减去一串数据的长度（这里是5。包括2个有效数据，3个数据头）
		*/
		while(uiRcregTotal >= 5 && uiRcMoveIndex <= (uiRcregTotal - 5))	
		{
			/*数据头的判断*/
			if(ucRcregBuf[uiRcMoveIndex + 0] == 0xeb && ucRcregBuf[uiRcMoveIndex + 1] == 0x00 && ucRcregBuf[uiRcMoveIndex + 2] == 0x55)
			{
				ucRcType = ucRcregBuf[uiRcMoveIndex + 3];	/*数据类型  一个字节*/
				uiRcSize = ucRcregBuf[uiRcMoveIndex + 4];	/*数据长度  两个字节*/
				uiRcSize = uiRcSize << 8;
				uiRcSize = ucRcregBuf[uiRcMoveIndex + 5];
				ucRcCy = ucRcregBuf[uiRcMoveIndex + 6 + uiRcSize];	/*记录最后一个字节的校验*/
				ucRcregBuf[uiRcMoveIndex + 6 + uiRcSize] = 0;	/*清零最后一个字节的累加和变量*/
				/* 
				* 计算校验累加和的方法:除了最后一个字节，其它前面所有的字节累加起来，
				* 溢出的不用我们管,C语言编译器会按照固定的规则自动处理。
				* 以下for循环里的(3+1+2+uiRcSize)，其中3代表3个字节数据头，1代表1个字节数据类型，
				* 2代表2个字节的数据长度变量，uiRcSize代表实际上一串数据中的有效数据个数。
				*/
				for(i = 0; i < (3+1+2+uiRcSize); i ++)	/*计算校验累加和*/
				{
					ucRcregBuf[uiRcMoveIndex + 6 + uiRcSize] += ucRcregBuf[uiRcMoveIndex + i];
				}
				if(ucRcCy == ucRcregBuf[uiRcMoveIndex + 6 + uiRcSize])	/*如果校验正确，则进入以下数据处理*/
				{
					switch(ucRcType)	/*根据不同的数据类型来做不同的数据处理*/
					{
						case 0x01:	/*驱动蜂鸣器发出声音，并且可以控制蜂鸣器持续发出声音的时间长度*/
							uiRcVoiceTime = ucRcregBuf[uiRcMoveIndex + 6];	/*把两个字节合并成一个int类型的数据*/
							uiRcVoiceTime = uiRcVoiceTime << 8;
							uiRcVoiceTime += ucRcregBuf[uiRcMoveIndex + 7];

							ucVoiceLock = 1;	/*共享数据的原子锁加锁*/
							uiVoiceCnt = uiRcVoiceTime;	/*蜂鸣器发出声音*/
							ucVoiceLock = 0;	/*共享数据的原子锁解锁*/
							break;
						case 0x02:	/*点亮一个LED灯，并且可以控制LED灯持续亮的时间长度*/
							uiRcLedTime = ucRcregBuf[uiRcMoveIndex + 6];	/*把两个字节合并成一个int类型的数据*/
							uiRcLedTime = uiRcLedTime << 8;
							uiRcLedTime += ucRcregBuf[uiRcMoveIndex + 7];

							ucLedLock = 1;	/*共享数据的原子锁加锁*/
							uiLedTime = uiRcLedTime;	/*更改点亮Led灯的时间长度*/
							uiLedCnt = 0;	/*在本程序中，清零计数器就等于自动点亮Led灯*/
							ucLedLock = 0;	/*共享数据的原子锁解锁*/						
							break;
					}
				}
				break;	/*退出循环*/
			}
			uiRcMoveIndex ++;	/*因为是判断数据头，游标向着数组最尾端的方向移动*/
		}
		uiRcregTotal = 0;	/*清空缓冲的下标，方便下次重新从0下标开始接受新数据*/
	}
}
/**
* @brief  定时器0中断函数
* @param  无
* @retval 无
**/
void ISR_T0(void)	interrupt 1
{
	TF0 = 0;  /*清除中断标志*/
	TR0 = 0; /*关中断*/
	/* 
	* 此处多增加一个原子锁，作为中断与主函数共享数据的保护
	*/
	if(ucSendCntLock == 0)	/*原子锁判断*/
	{
		ucSendCntLock = 1;	/*加锁*/
		if(uiSendCnt < const_receive_time)	/*如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完*/
		{
			uiSendCnt ++;	/*表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来*/
			ucSendLock = 1;	/*开自锁标志*/
		}	
		ucSendCntLock = 0;	/*解锁*/	
	}

	if(ucVoiceLock == 0)	/*原子锁判断*/
	{
		if(uiVoiceCnt != 0)
		{
			uiVoiceCnt --;
			BEEP = 0;
		}
		else
		{
			;
			BEEP = 1;
		}		
	}

	if(ucLedLock == 0)	/*原子锁判断*/
	{
		if(uiLedCnt < uiLedTime)
		{
			uiLedCnt ++;	/*Led灯点亮的时间计时器*/
		}
	}
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
  	TR0 = 1; /*开中断*/	
}

/**
* @brief  串口接收数据中断
* @param  无
* @retval 无
**/
void usart_receive(void)	interrupt 4
{
	if(RI == 1)
	{
		RI = 0;
		++ uiRcregTotal;
		if(uiRcregTotal > const_rc_size)
		{
			uiRcregTotal = const_rc_size;
		}
		ucRcregBuf[uiRcregTotal - 1] = SBUF;	/*将串口接收到的数据缓存到接收缓冲区里*/
		if(ucSendCntLock == 0)	/*原子锁判断*/
		{
			ucSendCntLock = 1;	/*加锁*/
			uiSendCnt = 0;	/*及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。*/
			ucSendCntLock = 0;	/*解锁*/
		}
	}
	else
	{
		TI = 0;
	}
}

/*————————————主函数————————————*/
/**
* @brief  主函数
* @param  无
* @retval 实现LED灯闪烁
**/
void main()
{
	/*单片机初始化*/
	Init();
	/*延时，延时时间一般是0.3秒到2秒之间，等待外围芯片和模块上电稳定*/
	Delay_Long(100);
	/*单片机外围初始化*/	
	Init_Peripheral();
	while(1)
	{
		usart_service();	/*串口服务程序*/
		led_service();	/*Led灯的服务程序*/
	}
}

三、仿真实现