飞利浦双串口51单片机485网关

已于 2023-10-30 09:42:25 修改
阅读量919 收藏 1
点赞数 10
分类专栏： 单片机外围电路 8051 文章标签： 51单片机 c# 嵌入式硬件
于 2023-10-29 12:04:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dmjkun/article/details/134101421
版权

主要功能将PC端的数据接收下来，分发到不同的设备，也是轮询设备数据读取回来，打包回传到PC端，数据包包头包尾识别，数据校验，接收超时处理，将协议结构化处理，协议的改动不需要改动程序，中断接收一帧完成置标志位交由上层协议程序校验并处理转发

协议格式定义，每一个位都进行了定仪

#ifndef PROTOCOL_H
#define PROTOCOL_H
#include "define.h"
//IO_EMM_31
typedef struct 
{
	uchar Stx;
	uchar Length;
	uchar ID;
	uchar TollCollectorID[3];
	uchar LoginDuration[2];
	uchar VehicleClass;
	union
	{
	 	uchar byte;
		struct
		{
			uchar Payment:4;
			uchar Axle:4;
		}BIT;
	}AxlePaymentDisplay;
	union
	{
		uint word;
		uchar byte[2];
	}TollFare;
	union
	{
		uchar byte;
		struct
		{			
			uchar reserved:1;
			uchar Exit_LSS_Rlight:1;
			uchar BarrierClose:1;
			uchar BarrierOpen:1;
			uchar Entry_LSS_Rlight:1;
			uchar Entry_LSS_Glight:1;
			uchar LaneLog:1;
			uchar zero:1;
		}BIT;
	}TMU_Control1;
	union
	{
		uchar byte;
		struct
		{
			uchar EmergencyAlarm:1;
			uchar EvasionAlarm:1;
			uchar DiscrepancyAlarm:1;
			uchar MisregistrationAlarm:1;
			uchar reserved:1;
			uchar AxleDectorFault:1;
			uchar BoothEquipmentFault:1;
			uchar zero:1;
		}BIT;
	}TMU_Control2;
	union
	{
		uchar byte;
		struct
		{
			uchar EmergencyAlarmRstBut:1;
			uchar EvalsionAlarmRstBut:1;
			uchar DiscrepancyAlarmRstBut:1;
			uchar MisregistrationAlarmRstBut:1;
			uchar AxleDetectorOVerride:1;
			uchar KeyInOverrideSelect:1;
			uchar reserved:1;
			uchar zero:1;
		}BIT;
	}ConStatus1;
	union
	{
		uchar byte;
		struct
		{
			uchar resetved:4;
			uchar TMUCommFail:1;
			uchar TMUDimmerOverAct:1;
			uchar AllSignageDimmming:1;
			uchar zero:1;
		}BIT;
	}ConStatus2;
	union
	{
		uchar byte;
		struct
		{
			uchar reserved:1;
			uchar CanopyBeacon:1;
			uchar Entry_LSS_Rlight:1;
			uchar Entry_LSS_Glight:1;
			uchar TPS_Glight:1;
			uchar TPS_Rlight:1;
			uchar DimmingNormal:1;
			uchar zero:1;
		}BIT;
	}SignageControl;
	union
	{
		uchar byte;
		struct
		{
			uchar TPSCommFail:1;
			uchar reserve2:1;
			uchar reserve1:1;
			uchar TPSTempHigher70:1;
			uchar CLSCommFail:1;
			uchar CLSPixelFaultDetect:1;
			uchar CLSTempHigher70:1;
			uchar zero:1;
		}BIT;
	}TPS_CLSFaultStatus;
	union
	{
		uchar byte;
		struct
		{
			uchar EntryCommFail:1;
			uchar ExitCommFail:1;
			uchar RlightAspectHigher50:1;
			uchar RlightAspectHigher25:1;
			uchar TempHigher70:1;
			uchar reseved:1;
			uchar Rlight:1;
			uchar zero:1;
		}BIT;
	}ExitLSSStatus;
	union
	{
		uchar byte;
		struct
		{
			uchar GlightAspectHigher50:1;
			uchar GlightAspectHigher25:1;
			uchar RlightAspectHigher50:1;
			uchar RlightAspectHigher25:1;
			uchar TempHigher70:1;
			uchar Glight:1;
			uchar Rlight:1;
			uchar zero:1;
		}BIT;
	}EntryLSSStatus;
	union
	{
		uchar byte;
		struct
		{
			uchar ShortDetect:1;
			uchar reserved:2;
			uchar KickBarAlarm:1;
			uchar CabinetOpen:1;
			uchar BarrierColse:1;
			uchar BarrierOpen:1;
			uchar zero:1;
		}BIT;
	}LocalIOInputStatus;
	union
	{
		uchar byte;
		struct
		{
			uchar Class0:1;
			uchar Class1:1;
			uchar Class2:1;
			uchar Class3:1;
			uchar Class4:1;
			uchar Class5:1;
			uchar Class6:1;
			uchar zero:1;
		}BIT;
	}AutoTollInputStatus1;
	union
	{
		uchar byte;
		struct
		{
			uchar Class7:1;
			uchar Class8:1;
			uchar Class9:1;
			uchar ClassAdd1:1;
			uchar LaneOpen:1;
			uchar LaneClose:1;
			uchar reserved:1;
			uchar zero:1;
		}BIT;
	}AutoTollInputStatus2;
	union
	{
		uchar byte;
		struct
		{
			uchar Axle1:1;
			uchar Axle2:1;
			uchar Axle3:1;
			uchar Axle4:1;
			uchar Axle5:1;
			uchar Axle6:1;
			uchar reserved:1;
			uchar zero:1;
		}BIT;
	}AutoTollInputStatus3;
	uchar Checksum;
	uchar Etx;
}IO_EMM_31;

//IO_EMM_32
typedef struct
{
	uchar Stx;
	uchar Length;
	uchar ID;
	union
	{
		uchar byte;
		struct
		{
			uchar reserved:1;
			uchar Dimmer:3;
			uchar Normal:3;
			uchar zero:1;
		}BIT;
	}TPSSetting;
	union
	{
		uchar byte;
		struct
		{
			uchar reserved:1;
			uchar Dimmer:3;
			uchar Normal:3;
			uchar zero:1;
		}BIT;
	}CLSSetting;
	union
	{
		uchar byte;
		struct
		{
			uchar reserved:1;
			uchar Dimmer:3;
			uchar Normal:3;
			uchar zero:1;
		}BIT;
	}EntryLSSSetting;
	union
	{
		uchar byte;
		struct
		{
			uchar reserved:1;
			uchar Dimmer:3;
			uchar Normal:3;
			uchar Zero:1;
		}BIT;
	}ExitLSSSetting;
	uchar Checksum;
	uchar Etx;
}IO_EMM_32;

//IO_TMU
typedef struct
{
	uchar Stx;
	uchar Length;
	uchar ID;
	uchar TollCollectorID[3];
	uchar LoginDuration[2];
	uchar VehicleClass;
	union
	{
	 	uchar byte;
		struct
		{
			uchar Payment:4;
			uchar Axle:4;
		}BIT;
	}AxlePaymentDisplay;
	union
	{
		uchar byte;
		struct
		{			
			uchar reserved:1;
			uchar Exit_LSS_Rlight:1;
			uchar BarrierClose:1;
			uchar BarrierOpen:1;
			uchar Entry_LSS_Rlight:1;
			uchar Entry_LSS_Glight:1;
			uchar LaneLog:1;
			uchar zero:1;
		}BIT;
	}TMU_Control1;
	union
	{
		uchar byte;
		struct
		{
			uchar EmergencyAlarm:1;
			uchar EvasionAlarm:1;
			uchar DiscrepancyAlarm:1;
			uchar MisregistrationAlarm:1;
			uchar reserved:1;
			uchar AxleDectorFault:1;
			uchar BoothEquipmentFault:1;
			uchar zero:1;
		}BIT;
	}TMU_Control2;
	union
	{
		uchar byte;
		struct
		{
			uchar EmergencyAlarmRstBut:1;
			uchar EvalsionAlarmRstBut:1;
			uchar DiscrepancyAlarmRstBut:1;
			uchar MisregistrationAlarmRstBut:1;
			uchar AxleDetectorOVerride:1;
			uchar KeyInOverrideSelect:1;
			uchar reserved:1;
			uchar zero:1;
		}BIT;
	}ConStatus1;
	union
	{
		uchar byte;
		struct
		{
			uchar resetved:5;
			uchar TMUDimmerOverAct:1;
			uchar AllSignageDimming:1;
			uchar zero:1;
		}BIT;
	}ConStatus2;
	uchar Checksum;
	uchar Etx;
}IO_TMU;

//IO_TPS
typedef struct
{
	uchar Stx;
	uchar Length;
	uchar ID;
	union
	{
		uint word;
		uchar byte[2];
	}TollFare;
	union
	{
		uchar byte;
		struct
		{
			uchar DispPleasePaid:1;
			uchar DispThankyou:1;
			uchar Rlight:1;
			uchar Glight:1;
			uchar BrightnessControl:3;
			uchar reserved:1;
		}BIT;
	}LedDisplay;
	union
	{
		uchar byte;
		struct
		{
			uchar TempHigher70:1;
			uchar reserved:7;
		}BIT;
	}Status;
	uchar Checksum;
	uchar Etx;
}IO_TPS;

//IO_CLS
typedef struct
{
	uchar Stx;
	uchar Length;
	uchar ID;
	uchar VehicleClass;
	union
	{
		uchar byte;
		struct
		{
			uchar Axle:3;
			uchar reserved1:1;
			uchar RelayContactClose:1;
			uchar reserved2:3;
		}BIT;
	}AxleCounterDisplay;
	union
	{
		uchar byte;
		struct
		{
			uchar reserved:4;
			uchar Brightness:3;
			uchar zero:1;
		}BIT;
	}BrightnessControl;
	union
	{
		uchar byte;
		struct
		{
			uchar TempHigher70:1;
			uchar PixelFaultDetected:1;
			uchar reserved:6;
		}BIT;
	}Status;
	uchar Checksum;
	uchar Etx;
}IO_CLS;

//IO_LSS
typedef struct
{
	uchar Stx;
	uchar Length;
	uchar ID;
	union
	{
		uchar byte;
		struct
		{
			uchar Rlight:1;
			uchar Glight:1;
			uchar reserved:6;			
		}BIT;
	}SignalDisp;
	union
	{
		uchar byte;
		struct
		{
			uchar RlightAspectHigher25:1;
			uchar RlightAspectHigher50:1;
			uchar GlightAspectHigher25:1;
			uchar GlightAspectHigher50:1;
			uchar BrightnessControl:3;
			uchar reserved:1;			
		}BIT;
	}Status1;
	union
	{
		uchar byte;
		struct
		{
			uchar TempHigher70:1;
			uchar reserved:7;
		}BIT;
	}Status2;
	uchar Checksum;
	uchar Etx;
}IO_LSS;

typedef struct
{
	uchar Dimmer;
	uchar Normal;
}BRIGHTNESS;
#endif

中断接收与发送

void IntUart0Rx( void ) interrupt 4
{
	uchar temp;
	static uchar MsgLen;
	if( RI_0 )
	{
		RI_0 = 0;
		temp = S0BUF;
		Timer1ms[TIMER_COM_DEV].Tick = 10;
		Timer1ms[TIMER_COM_DEV].Flg.BIT.Enable = 1;

		Timer[TIMER_RESPONSE].Tick = 5;

		ACC = temp;
		if( P==RB8_0 )
		{
			if( !DevStrEndFlg )
			{
				if( temp==0xaa )
				{									  
					DevStrEndFlg = 1;
					IO2Dev.RecvPtr = 0;
					IO2Dev.RecvBuf[IO2Dev.RecvPtr++] = temp;
					IO2Dev.Error.byte = 0;
				}
			}
			else
			{
				if( temp==0xab && IO2Dev.RecvPtr==MsgLen )
				{
					DevStrEndFlg = 0;
					IO2Dev.RecvBuf[IO2Dev.RecvPtr++] = temp;
					IO2Dev.Flg.BIT.Recv = 1;
					IO2Dev.RecvLen = IO2Dev.RecvPtr;
				}/*
				else if( temp==0xaa  && IO2Dev.RecvPtr!=MsgLen-1 )
				{
					IO2Dev.RecvPtr = 0;
					IO2Dev.RecvBuf[IO2Dev.RecvPtr++] = temp;
				}*/
				else if( IO2Dev.RecvPtr==2 )
				{
					IO2Dev.ID = temp;
					IO2Dev.RecvBuf[IO2Dev.RecvPtr++] = temp;
					switch( IO2Dev.ID )
					{
						case IO_TMU_ID:
							MsgLen = sizeof( IO_TMU )-1;
							break;
						case IO_TPS_ID:
							MsgLen = sizeof( IO_TPS )-1;
							break;
						case IO_CLS_ID:
							MsgLen = sizeof( IO_CLS )-1;
							break;
						case IO_ELSS_ID:
							MsgLen = sizeof( IO_LSS )-1;
							break;
						case IO_XLSS_ID:
							MsgLen = sizeof( IO_LSS )-1;
							break;
						default:
							DevStrEndFlg = 0;
					}
				}
				else if( IO2Dev.RecvPtr<RECVBUF_LEN )
				{
					IO2Dev.RecvBuf[IO2Dev.RecvPtr++] = temp;
				}
				else  //接收数据溢出
				{
					DevStrEndFlg = 0;
					IO2Dev.RecvPtr = 0;
				}
//				flg = IO2Dev.RecvPtr;
			}
		}
		else
		{
			IO2Dev.Error.BIT.Even = 1;
		}
	}
	else if( S0STAT&0x08 )//Framing Error
	{
		S0STAT &= ~0x08;
		IO2Dev.Error.BIT.Framing = 1;
	}
	else if( S0STAT&0x04 )//Break Detect
	{
		S0STAT &= ~0x04;
		IO2Dev.Error.BIT.BreakDetect = 1;
	}
	else if( S0STAT&0x02 )//Overrun Error
	{
		S0STAT &= ~0x02;
		IO2Dev.Error.BIT.Overrun = 1;
	}
}

//串行口0的发送中断程序
void IntUart0Tx( void ) interrupt 7
{
	Uart0SendData();
}

以指针提取数据
在这里插入图片描述

#include "Emm2IO.h"
#include "com.h"
#include "protocol.h"
#include "systemtask.h"
#include "IOCheck.h"

IO_EMM_31 IOEmm31;
extern BUF_DEF Emm2IO;
extern IO_TMU IOTmu;
extern IO_TPS IOTps;
extern IO_CLS IOCls;
extern IO_LSS IOEntryLss;
extern IO_LSS IOExitLss;
extern BRIGHTNESS TpsBrightness,ClsBrightness,EntryLssBrightness,ExitLssBrightness;

extern IO_CHECK_DEF IoCheck;
extern TIMER_DEF Timer[TIMER_NUM];
extern uchar flg;
void Emm2IOInit( void )
{
	//31
	IOEmm31.Stx = 0xaa;
	IOEmm31.Length = 0x18;
	IOEmm31.ID = 0x20;
	IOEmm31.ConStatus1.byte = 0;
	IOEmm31.ConStatus2.byte = 0x10;
	IOEmm31.TPS_CLSFaultStatus.byte = 0x11;
	IOEmm31.ExitLSSStatus.byte = 0x03;
	IOEmm31.EntryLSSStatus.byte = 0x00;
	IOEmm31.LocalIOInputStatus.byte = 0x00;
	IOEmm31.AutoTollInputStatus1.byte = 0x00;
	IOEmm31.AutoTollInputStatus2.byte = 0x00;
	IOEmm31.AutoTollInputStatus3.byte = 0x00;
	IOEmm31.Etx = 0xab;

	Emm2IO.Flg.byte = 0;
	Emm2IO.SendLen = 0;
	Emm2IO.RecvLen = 0;
	Emm2IO.SendPtr = 0;
	Emm2IO.RecvPtr = 0;

	Timer[TIMER_STOP].Flg.BIT.TimeOut = 0;
	Timer[TIMER_STOP].Tick = 500;
	Timer[TIMER_STOP].Flg.BIT.Enable = 1;
}
//从Emm2IOController31的接收数据中取出需要的内容放到设备缓冲区中
void CopyEmm31ToDev( IO_EMM_31 *IoEmm31Ptr )
{
	//TMU
	IOTmu.TollCollectorID[0] = IoEmm31Ptr->TollCollectorID[0];
	IOTmu.TollCollectorID[1] = IoEmm31Ptr->TollCollectorID[1];
	IOTmu.TollCollectorID[2] = IoEmm31Ptr->TollCollectorID[2];
	IOTmu.LoginDuration[0] = IoEmm31Ptr->LoginDuration[0];
	IOTmu.LoginDuration[1] = IoEmm31Ptr->LoginDuration[1];
	IOTmu.VehicleClass = IoEmm31Ptr->VehicleClass;
	IOTmu.AxlePaymentDisplay.byte = IoEmm31Ptr->AxlePaymentDisplay.byte;
	IOTmu.TMU_Control1.byte = IoEmm31Ptr->TMU_Control1.byte;
	IOTmu.TMU_Control2.byte = IoEmm31Ptr->TMU_Control2.byte;
	//TPS
	IOTps.TollFare.byte[0] = IoEmm31Ptr->TollFare.byte[0];
	IOTps.TollFare.byte[1] = IoEmm31Ptr->TollFare.byte[1];
	IOTps.LedDisplay.BIT.Glight = IoEmm31Ptr->SignageControl.BIT.TPS_Glight;
	IOTps.LedDisplay.BIT.Rlight = IoEmm31Ptr->SignageControl.BIT.TPS_Rlight;
	if( (((IoEmm31Ptr->TollFare.byte[0]&0xf0)>>4) == 0x000c) && (IoEmm31Ptr->AxlePaymentDisplay.BIT.Payment == 0x0b) )
	{
		IOTps.LedDisplay.BIT.DispPleasePaid = 1;
		IOTps.LedDisplay.BIT.DispThankyou = 0;
	}
	else if( (((IoEmm31Ptr->TollFare.byte[0]&0xf0)>>4) == 0x0000c) && (IoEmm31Ptr->AxlePaymentDisplay.BIT.Payment != 0x0b) )
	{
		IOTps.LedDisplay.BIT.DispPleasePaid = 0;
		IOTps.LedDisplay.BIT.DispThankyou = 1;
	}
	else if( ((IoEmm31Ptr->TollFare.byte[0]&0xf0)>>4) == 0x0000b )
	{
		IOTps.LedDisplay.BIT.DispPleasePaid = 0;
		IOTps.LedDisplay.BIT.DispThankyou = 0;
	}
	else
	{
		IOTps.LedDisplay.BIT.DispPleasePaid = 0;
		IOTps.LedDisplay.BIT.DispThankyou = 0;
	}
	//CLS
	IOCls.VehicleClass = IoEmm31Ptr->VehicleClass;
	if( IoEmm31Ptr->AxlePaymentDisplay.BIT.Axle>0 && IoEmm31Ptr->AxlePaymentDisplay.BIT.Axle<7 )
	{
		IOCls.AxleCounterDisplay.BIT.Axle = IoEmm31Ptr->AxlePaymentDisplay.BIT.Axle;
	}
	else
	{
		IOCls.AxleCounterDisplay.BIT.Axle = 0;
	}
	IOCls.AxleCounterDisplay.BIT.RelayContactClose = IoEmm31Ptr->SignageControl.BIT.CanopyBeacon;
	//EntryLSS
	IOEntryLss.SignalDisp.BIT.Rlight = IoEmm31Ptr->SignageControl.BIT.Entry_LSS_Rlight;
	if( IoEmm31Ptr->SignageControl.BIT.Entry_LSS_Glight && IOEmm31.LocalIOInputStatus.BIT.BarrierOpen &&
		!IOEmm31.LocalIOInputStatus.BIT.BarrierColse )
	{
		IOEntryLss.SignalDisp.BIT.Glight = 1;
		IOEntryLss.SignalDisp.BIT.Rlight = 0;
	}
	else
	{
		IOEntryLss.SignalDisp.BIT.Glight = 0;
		IOEntryLss.SignalDisp.BIT.Rlight = 1;
	}
	//ExitLSS
	if( IoEmm31Ptr->SignageControl.BIT.DimmingNormal )
	{
		IOTps.LedDisplay.BIT.BrightnessControl = TpsBrightness.Dimmer;
		IOCls.BrightnessControl.BIT.Brightness = ClsBrightness.Dimmer;
		IOEntryLss.Status1.BIT.BrightnessControl = EntryLssBrightness.Dimmer;
		IOExitLss.Status1.BIT.BrightnessControl = ExitLssBrightness.Dimmer;
	}
	else
	{
		IOTps.LedDisplay.BIT.BrightnessControl = TpsBrightness.Normal;
		IOCls.BrightnessControl.BIT.Brightness = ClsBrightness.Normal;
		IOEntryLss.Status1.BIT.BrightnessControl = EntryLssBrightness.Normal;
		IOExitLss.Status1.BIT.BrightnessControl = ExitLssBrightness.Normal;
	}
}
//从接收的Emm2IOController31的数据更新Emm31缓冲区
void CopyEmm31ToEmm31Buf( IO_EMM_31 *IoEmm31Ptr )
{
	uchar *Sptr,*Dptr,i;
	Sptr = (uchar*)IoEmm31Ptr;
	Dptr = (uchar*)&IOEmm31;
	for( i=0; i<11; i++ )
	{
		*(Dptr+i+3) = *(Sptr+i+3);
	}
	*(Dptr+16) = *(Sptr+16);
}
//更新各设备的亮度值
void CopyEmm32ToDev( IO_EMM_32 *IoEmm32Ptr )
{
	//TPS
	TpsBrightness.Dimmer = IoEmm32Ptr->TPSSetting.BIT.Dimmer;
	TpsBrightness.Normal = IoEmm32Ptr->TPSSetting.BIT.Normal;
	//CLS
	ClsBrightness.Dimmer = IoEmm32Ptr->CLSSetting.BIT.Dimmer;
	ClsBrightness.Normal = IoEmm32Ptr->CLSSetting.BIT.Normal;
	//EntryLSS
	EntryLssBrightness.Dimmer = IoEmm32Ptr->EntryLSSSetting.BIT.Dimmer;
	EntryLssBrightness.Normal = IoEmm32Ptr->EntryLSSSetting.BIT.Normal;
	//ExitLSS
	ExitLssBrightness.Dimmer = IoEmm32Ptr->ExitLSSSetting.BIT.Dimmer;
	ExitLssBrightness.Normal = IoEmm32Ptr->ExitLSSSetting.BIT.Normal;
}
//判断是否已从EMM接收完整的数据包，并进行处理
void Emm2IOMain( void )
{
	uchar ver,*ptr;
	IO_EMM_31 *IoEmm31Ptr;
	IO_EMM_32 *IoEmm32Ptr;
	if( Emm2IO.Flg.BIT.Recv )
	{
		Emm2IO.Flg.BIT.Recv = 0;

		Timer[TIMER_STOP].Tick = 500;
		Timer[TIMER_STOP].Flg.BIT.Enable = 1;

		if( Emm2IO.Error.byte == 0 )
		{
			ver = Checksum( &Emm2IO.RecvBuf[1],Emm2IO.RecvLen-3 );
			if( Emm2IO.ID==EMM_IO31_ID )
			{
				IoEmm31Ptr = (IO_EMM_31 *)Emm2IO.RecvBuf;
				if( ver==IoEmm31Ptr->Checksum )
				{
					CopyEmm31ToDev( IoEmm31Ptr );
					CopyEmm31ToEmm31Buf( IoEmm31Ptr );
					ptr = (uchar*)&IOEmm31;
					ptr++;
//					IOEmm31.AutoTollInputStatus3.byte = IoCheck.SaveState.byte[3];
//					IOEmm31.LocalIOInputStatus.byte = IoCheck.SaveState.byte[0];
//					IOEmm31.AutoTollInputStatus1.byte = IoCheck.SaveState.byte[1];
//					IOEmm31.AutoTollInputStatus2.byte = IoCheck.SaveState.byte[2];
//					IOEmm31.AutoTollInputStatus3.byte = IoCheck.SaveState.byte[3];
					ver = Checksum( ptr,sizeof(IO_EMM_31)-3 );
					IOEmm31.Checksum = ver;
					CopyToUart1SendBuf( (uchar*)&IOEmm31, sizeof(IO_EMM_31) );
				}
			}
			else if( Emm2IO.ID==EMM_IO32_ID )
			{
				IoEmm32Ptr = (IO_EMM_32 *)Emm2IO.RecvBuf;
				if( ver==IoEmm32Ptr->Checksum )
				{
					CopyEmm32ToDev( IoEmm32Ptr );
					CopyToUart1SendBuf( (uchar*)IoEmm32Ptr, sizeof(IO_EMM_32) );
				}
			}
		}
		else
		{
			Emm2IO.Error.byte = 0;
		}
		Emm2IO.RecvPtr = 0;
		Emm2IO.ID = 0;
	}
	//When no polling with EMM > 5 seconds.
	if( Timer[TIMER_STOP].Flg.BIT.TimeOut )
	{
		Timer[TIMER_STOP].Flg.BIT.TimeOut = 0;
		//TMU
		IOTmu.TollCollectorID[0] = 0x0b;
		IOTmu.TollCollectorID[1] = 0xbb;
		IOTmu.TollCollectorID[2] = 0xbb;
		IOTmu.LoginDuration[0] = 0xbb;
		IOTmu.LoginDuration[1] = 0xbb;
		IOTmu.VehicleClass = 0xbb;
		IOTmu.AxlePaymentDisplay.byte = 0xbb;
		IOTmu.TMU_Control1.byte = 0x00;
		IOTmu.TMU_Control2.byte = 0x40;
		//TPS
		IOTps.TollFare.word = 0xbbbb;
		IOTps.LedDisplay.BIT.Rlight = 1;
		IOTps.LedDisplay.BIT.Glight = 0;
		IOTps.LedDisplay.BIT.DispPleasePaid = 0;
		IOTps.LedDisplay.BIT.DispThankyou = 0;
		//CLS
		IOCls.VehicleClass = 0xbb;
		IOCls.AxleCounterDisplay.byte = 0x00;
		//Entry Lss
		IOEntryLss.SignalDisp.byte = 0x01;
		//Exit Lss
		IOExitLss.SignalDisp.byte = 0x01;
	}
}

主程序循环，
在这里插入图片描述
代码多年前写，基于飞利浦双串口51单片机，程序结构是大循环前后台标志，就算现在用上了linux、rtos等的方式，程序接收处理方式差别不大，只是实现起来更简单

下面是完整工程连接
链接：https://pan.baidu.com/s/1bXOrMRH6Gf7kcjra4uANtA?pwd=1234
提取码：1234

纵向深耕
关注
  • 10
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
UART.rar_51 串口_51单片机串口_virtual Port_虚拟串口
09-24
在本教程中，我们将深入探讨如何在51单片机上实现虚拟串口，以及虚拟串口的概念。 首先，了解51单片机。51系列是飞利浦（现恩智浦半导体）推出的8位微处理器，因其强大的性能和广泛的兼容性，被广泛用于嵌入式系统...
基于单片机的操作平台数据采集网关设计与实现
weixin_45905610的博客
05-29 1753
由于传统网关无法实现数据实时交换，数据传输速率较低，为此提出基于单片机的操作平台数据采集网关设计与实现研究。首先，结合单片机具有的显著优势对网关结构选型设计；其次，参照一体化设计理念，对数据采集网关的内部运行机制进行规划；最后，选择适用于操作平台数据采集网关的通信协议，实现操作平台数据采集设备之间的数据交换，以此完成网关设计。经实验证明，应用本文设计的网关操作平台数据采集设备的数据传输效率高于传统网关。
嵌入式单片机产品开发设计框架
无际单片机编程
08-11 3665
老板突然要给你一个新的需求，要你做一款自己不熟悉的产品，第一感觉都是懵的，不知道这个产品的工作原理是什么？用的是什么方案，什么芯片？ 我们首先是买个样品回来研究一下，看别人是怎么做的，然后在别人样品的基础上优化升级，做出自己的产品。 比较郁闷的事情就是买回来的样品，芯片的丝印被打磨了，或者找不到芯片相关的资料。 对于电子工程而言，个人从事的行业不一样，个人的经历和经验也局限于自己做过的产品，随意再有经验的工程师，碰到自己没有做过的产品都是一样。 设计一款，首先是要确定产品的设计方案。产品的设计方案决定
基于51单片机和物联网的智能家居系统（ESP8266物联网模块）
qq_45416203的博客
08-23 2万+
前言 该智能家居系统以 STC89C52单片机为控制核心，结合 LCD1602 液晶显示屏、L298N电机驱动模块、光敏电阻，ESP8266WiFi模块，DS18B20温度计设计并实现了自动感光窗帘与居室内外温度检测器。经过最终的调试，实现了基本部分和发挥部分的所有功能。温度检测系统在环境温度改变的情况下可以实现误差为 0.5℃的基本温度测量。而智能窗帘系统在光照强度不同的情况下电机表现了不同的转...
STM32F103 扩展以太网口
01-06 2万+
最新项目添加以太网功能进展： 一直使用的STM32F103系列的芯片，没有以太网接口，现在许多客户需要加入以太网连接，用了多年的STM32F103很稳定不想换，打算直接外加一颗网络芯片来实现。起初打算用DM9000，无奈何并口操作I/O不够用了，后来又在davicom官网搜了一下，发现还有一款SPI接口的网络芯片DM9051。 先介绍下硬件情况：最常见的STM32F103C8T6（价格...
基于51单片机电子抽奖系统仿真设计
12-22
首先，51单片机是飞利浦（现恩智浦半导体）推出的8位微处理器，具有丰富的I/O端口和强大的处理能力，非常适合进行简单的控制系统设计。在电子抽奖系统中，51单片机会负责数据处理、随机数生成以及与显示设备的通信，...
基于51单片机的无线数据采集设计
04-26
51单片机是飞利浦（现恩智浦半导体）推出的8位微控制器，具有丰富的外设接口和低功耗特性，适合实现简单的控制任务。在本设计中，51单片机作为核心处理器，负责管理数据采集、处理和无线传输等功能。它通过连接各种...
51单片机双机通信.zip
07-11
在电子工程领域，51单片机是一种广泛应用的微控制器，尤其在教学和小型嵌入式系统中。这个名为"51单片机双机通信.zip"的压缩包可能包含了关于如何实现两个51单片机之间通信的教程或代码示例。"Communication_C51-...
基于51单片机的温度报警器
01-26
1. **51单片机**：51系列单片机是飞利浦（现NXP）公司推出的C51架构，具有8位CPU、128字节RAM、4KB ROM等基本硬件资源。其指令集简洁，易于学习，且有丰富的扩展芯片支持，广泛应用于各类嵌入式系统。 2. **18B20...
STM32以太网通讯设计方案
热门推荐
个人工作学习笔记
10-25 3万+
STM32+网口设计方案(有效信息整理)： 网口芯片选型：W5100 w5500 CH9121 DM9000 DM9000A、ENC28J60、LAN91C111、RTL8019，LAN7820 韩国WIZnet公司生产的W5300芯片 很多stm32内部不带以太网，带以太网功能的内部只有以太网mac，没有phy。因此需要外扩以太网芯片。对于不带以太网的stm32，外扩常用的芯片有spi接......
浅谈单片机以太网接入方案
WIZnet2012专栏
04-14 1万+
单片机的种类繁多，从低端到高端，有以51单片机为代表的8位单片机和以ARM为代表的32位单片机，不同档次的单片机实现网络接口的方法不同。对于像ARM等高端处理器一般都可以运行嵌入式操作系统，例如嵌入式Linux。对于无操作系统要求的单片机如何实现网络接入，我下面将这些方案按TCP/IP协议栈的不同归结为两大类：第一类是传统的软件TCP/IP协议栈方案；第二类是最新的硬件TCP/IP协议栈方案。下面我就这两类方案的实现方式进行分析。
linux主机路由和网络路由,浅谈Linux的路由与网关
weixin_35934012的博客
05-04 1381
Linux的路由与网关：路由(Routing)：路由是指从一个设备(一般指路由器)的接口上接收到数据包，依据设备所既定的某些规则，将数据包转发到其它接口的 “过程”。路由工作在OSI参考模型第三层——网络层的数据包转发设备。路由器通过转发数据包来实现网络互连路由器(Router)：路由器是用于连接多个逻辑上分开的网络，所谓逻辑网络是代表一个单独的网络或者一个子网。当数据从一个子网传输到另一个子网时...
51单片机16（步进电机实验）
Yz202267的博客
07-25 979
一、步进电机简介： 1、步进电机是将电脉冲信号转变为角位移或线位移的开环控制元件。 2、 3、 4、我们这个电机的旋转停止的位置只取决于脉冲信号的频率和脉冲数，而不受负载的变化的影响，也就是说给我们的这个步进电机一个脉冲信号，那么电机就会旋转一个角度，那么这个角度我们通常称为步进电机的步距角。那么一个脉冲，一个步距角，我们就可以很精确的控制这个电机的一个位置以及速度。这个是直流电机所不能完成的一个功能。那么我们步进电机就弥补这一块。 5、那么要实现步进电机的控制，它不像这个普通电机那种直流电机
51单片机嵌入式开发：19、STC89C52R控制LCD1602码表+数码管+后台数显（串口）
sinat_30943509的博客
07-26 1303
本项目旨在利用STC89C52R单片机实现一个多功能的显示系统，包括LCD1602码表、数码管和后台数码显示器。通过串口通信，单片机可以与后台数码显示器进行数据交换和控制，实现更加灵活和多样化的显示功能。多功能显示系统：通过整合LCD1602码表和数码管，您可以实现多种信息的显示，如时间、日期、计数器数值等。后台数码显示器通过串口通信扩展了显示功能，使系统更加灵活和多样化。实时数据显示：LCD1602码表和数码管可以显示实时数据，如温度、湿度、计时等信息，帮助用户实时监测系统状态。
51单片机和STM32区别
一些个人笔记，写的不好之处，还请海涵
07-22 1010
51单片机由于其较老的架构，其内置的通信接口可能不如 STM32 丰富，因此在需要使用 I2C 等协议时，通常需要额外的硬件支持。
记录｜使用ＨslCommunication库进行写入Real数据的坑
技术小白=-=的博客
07-24 515
现在已经通过HslCommunication连接上了PLC，需要对DB1.DBD10的位置处进行数据写入。
C#实现数据采集系统-Mqtt实现采集数据转发
最新发布
海盗Sharp的博客
07-28 36
在数据采集系统中，通过ModbusTcp采集到数据之后，再通过MQTT转发到其他应用。
C# —— 析构函数
一个新人博客，愿多多支持。
07-25 323
构造函数创建对象 对属性进行初始化的作用析构函数: 当一个对象被释放的时候执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

纵向深耕

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

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

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

打赏作者

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

抵扣说明：

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

余额充值