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

已于 2023-10-30 09:42:25 修改
阅读量951 收藏 1
点赞数 11
分类专栏： 单片机外围电路 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

纵向深耕
关注
专栏目录
使用单片机实现网关功能
IELLQUI6的博客
09-12 264
在上述代码中，我们首先通过ReadTemperatureSensor函数读取温度传感器的模拟值，并将其转换为实际温度值。通过上述的代码示例，我们可以实现一个简单的网关功能，将传感器数据通过单片机的串口发送到云平台进行处理和分析。接下来，我们需要编写代码来处理来自传感器的数据，并将其发送到云平台。上述代码中，我们首先使能了USART2的时钟，并配置了USART2的引脚连接。为了实现网关功能，我们将选择一款常用的单片机，例如基于ARM架构的STM32系列。如有任何进一步的问题，请随时提问。
论嵌入式单片机软件架构
zhaoyun_zzz的专栏
01-23 9460
经过几天的回忆与思考，分析了我的成长路径，选择一些我自认为是成长关键点的位置，总结一个关键字，一步一步来讨论关于嵌入式单片机软件的架构。 我先把总结出的关键字写出来吧：**流水式、中断前后台、任务式、状态机、分层式，操作系统多任务**；这些就是我总结出的关键字，写这篇博客我决定不参照其他博客，只把我心中所想以及以前的代码示例或者记录翻出来，再加修改，然后呈现出来，供大家品鉴。
基于单片机的操作平台数据采集网关设计与实现
weixin_45905610的博客
05-29 1793
由于传统网关无法实现数据实时交换，数据传输速率较低，为此提出基于单片机的操作平台数据采集网关设计与实现研究。首先，结合单片机具有的显著优势对网关结构选型设计；其次，参照一体化设计理念，对数据采集网关的内部运行机制进行规划；最后，选择适用于操作平台数据采集网关的通信协议，实现操作平台数据采集设备之间的数据交换，以此完成网关设计。经实验证明，应用本文设计的网关操作平台数据采集设备的数据传输效率高于传统网关。
嵌入式单片机产品开发设计框架
无际单片机编程
08-11 3734
老板突然要给你一个新的需求，要你做一款自己不熟悉的产品，第一感觉都是懵的，不知道这个产品的工作原理是什么？用的是什么方案，什么芯片？ 我们首先是买个样品回来研究一下，看别人是怎么做的，然后在别人样品的基础上优化升级，做出自己的产品。 比较郁闷的事情就是买回来的样品，芯片的丝印被打磨了，或者找不到芯片相关的资料。 对于电子工程而言，个人从事的行业不一样，个人的经历和经验也局限于自己做过的产品，随意再有经验的工程师，碰到自己没有做过的产品都是一样。 设计一款，首先是要确定产品的设计方案。产品的设计方案决定
基于51单片机和物联网的智能家居系统（ESP8266物联网模块）
qq_45416203的博客
08-23 2万+
前言 该智能家居系统以 STC89C52单片机为控制核心，结合 LCD1602 液晶显示屏、L298N电机驱动模块、光敏电阻，ESP8266WiFi模块，DS18B20温度计设计并实现了自动感光窗帘与居室内外温度检测器。经过最终的调试，实现了基本部分和发挥部分的所有功能。温度检测系统在环境温度改变的情况下可以实现误差为 0.5℃的基本温度测量。而智能窗帘系统在光照强度不同的情况下电机表现了不同的转...
浅谈单片机以太网接入方案
WIZnet2012专栏
04-14 1万+
单片机的种类繁多，从低端到高端，有以51单片机为代表的8位单片机和以ARM为代表的32位单片机，不同档次的单片机实现网络接口的方法不同。对于像ARM等高端处理器一般都可以运行嵌入式操作系统，例如嵌入式Linux。对于无操作系统要求的单片机如何实现网络接入，我下面将这些方案按TCP/IP协议栈的不同归结为两大类：第一类是传统的软件TCP/IP协议栈方案；第二类是最新的硬件TCP/IP协议栈方案。下面我就这两类方案的实现方式进行分析。
UART.rar_51 串口_51单片机串口_virtual Port_虚拟串口
09-24
在本教程中，我们将深入探讨如何在51单片机上实现虚拟串口，以及虚拟串口的概念。 首先，了解51单片机。51系列是飞利浦（现恩智浦半导体）推出的8位微处理器，因其强大的性能和广泛的兼容性，被广泛用于嵌入式系统...
基于51单片机GUI设计TFTLCD触摸显示屏-串口通信应用显示实验例程源码.zip
05-22
1. **51单片机**：51系列单片机是飞利浦（现恩智浦半导体）推出的8位微处理器，具有丰富的指令集和简单的硬件结构。它广泛应用于各种嵌入式系统，如家用电器、工业控制、汽车电子等。这个项目中，51单片机作为核心...
参考资料-基于飞利浦51单片机的智能蓄电池巡检监控系统的设计.zip
01-22
《基于飞利浦51单片机的智能蓄电池巡检监控系统设计》 在现代电子技术领域，单片机在各种控制系统中扮演着至关重要的角色。飞利浦51系列单片机，以其高性价比、丰富的资源和易用性，被广泛应用于嵌入式硬件系统设计...
飞利浦51LPC系列单片机用于控制交流电机.doc
10-02
飞利浦51LPC系列单片机是基于80C51内核的高性能、低成本、低功耗的微控制器，特别适用于需要高抗干扰能力和低功耗的控制系统，如电子仪表、智能水表、电子秤等。该系列单片机提供了多种功能，如内置电源Brownout侦测...
51单片机串口通信控制蜂鸣器播放音乐.zip
07-31
51 单片机是对所有兼容 Intel 8031 指令系统的单片机的统称。该系列单片 机的始祖是 Intel 的 8004 单片机，后来随着 Flash rom 技术的发展，8004 单片 机取得了长足的进展，成为应用最广泛的 8 位单片机之一，其...
STM32F103 扩展以太网口
01-06 2万+
最新项目添加以太网功能进展： 一直使用的STM32F103系列的芯片，没有以太网接口，现在许多客户需要加入以太网连接，用了多年的STM32F103很稳定不想换，打算直接外加一颗网络芯片来实现。起初打算用DM9000，无奈何并口操作I/O不够用了，后来又在davicom官网搜了一下，发现还有一款SPI接口的网络芯片DM9051。 先介绍下硬件情况：最常见的STM32F103C8T6（价格...
STM32以太网通讯设计方案
热门推荐
个人工作学习笔记
10-25 3万+
STM32+网口设计方案(有效信息整理)： 网口芯片选型：W5100 w5500 CH9121 DM9000 DM9000A、ENC28J60、LAN91C111、RTL8019，LAN7820 韩国WIZnet公司生产的W5300芯片 很多stm32内部不带以太网，带以太网功能的内部只有以太网mac，没有phy。因此需要外扩以太网芯片。对于不带以太网的stm32，外扩常用的芯片有spi接......
【51单片机】蜂鸣器演奏音乐——小星星&天空之城
m0_72563041的博客
11-10 600
【51单片机】蜂鸣器演奏音乐 —— 小星星 & 天空之城
【51单片机4位数码管左右移位显示0-9不用数组】2022-4-19
浤济的专栏
11-10 306
缘由51单片机，89c52的-嵌入式-CSDN问答
【51单片机】I2C总线详解 + AT24C02
最新发布
m0_72563041的博客
11-10 674
【51单片机】I2C总线详解 & AT24C02存储器
51单片机教程（六）- LED流水灯
Oblning的博客
11-03 875
LED流水灯，LED花样流水灯
【51单片机】LED点阵屏 原理 + 使用
m0_72563041的博客
11-05 1297
【51单片机】LED点阵屏原理 + 使用
51单片机教程（五）- LED灯闪烁
Oblning的博客
11-02 982
LED灯闪烁，使用51单片机实现LED灯闪烁
飞利浦51单片机智能蓄电池监控系统设计
资源摘要信息:"参考资料-基于飞利浦51单片机的智能蓄电池巡检监控系统的设计" 知识点: 一、51单片机的基本概念及特性： 飞利浦51单片机，又称8051单片机，是由荷兰皇家飞利浦电子公司推出的一种经典的单片机芯片。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

纵向深耕

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

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

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

打赏作者

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

抵扣说明：

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

余额充值