STM32F407单片机上开发MODBUS RTU 多主站程序（二）

2023-05-16

STM32F407单片机上开发MODBUS RTU 多主站程序（一）

STM32F407单片机上开发MODBUS RTU 多主站程序（二）

前面一篇文章 STM32F407单片机上开发MODBUS RTU 多主站程序（一），实现了MODBUS RTU 主站的底层代码，现在介绍如何编写MODBUS RTU 主站轮巡和解析MODBUS 从站程序。

由于STM32系列单片机可以用DMA方式接收串口通信，因此本文的串口通信用DMA实现。

一、主站轮巡超时定时器

由于主站发送完请求报文后，需要检测从站是否在规定的时间应答。

1、如果从站应答，就清除超时定时器的计时值同时让超时定时器停止，好主站下次开始发送请求报文时，重新开启超时定时器。

2、如果从站未应答，则一直等待，直到超时定时器溢出，当超时定时器溢出，就能证明这个从站不在线，返回超时标识。

TIM1定时器作为超时定时器，超时时间为100毫秒。


void TIM1_Start(void)
{
	TIM_Cmd(TIM1, DISABLE);	
	TIM_SetCounter(TIM1,0x0000);
	TIM_Cmd(TIM1, ENABLE);
}



void TIM1_Stop(void)
{
	TIM_Cmd(TIM1, DISABLE);
	TIM_SetCounter(TIM1,0x0000);
}



//超时定时器超时时间=100毫秒
void TIM1_Configuration(void)
{
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;


	RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1,ENABLE);
    TIM_DeInit(TIM1);
 	TIM_InternalClockConfig(TIM1);
    TIM_TimeBaseStructure.TIM_Period = 10000 - 1;

	TIM_TimeBaseStructure.TIM_Prescaler = (1679);  //100毫秒
    TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_CounterMode=TIM_CounterMode_Up; 
    TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
    TIM_ClearFlag(TIM1, TIM_FLAG_Update);
	TIM_ITConfig(TIM1,TIM_IT_Update,ENABLE);
	TIM_Cmd(TIM1, DISABLE);
}


void TIM1_UP_TIM10_IRQHandler(void)
{
		
	if (TIM_GetITStatus(TIM1,TIM_IT_Update) != RESET)
	{
		TIM_ClearITPendingBit(TIM1,TIM_IT_Update);		
		TIM_Cmd(TIM1, DISABLE);
		if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
			MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_TIME_OUT;
	}
}

二、DMA配置


#define USART1_DMA_RX_BUFFER_MAX_LENGTH  255
#define USART1_DMA_TX_BUFFER_MAX_LENGTH  255

uint8_t USART1_DMA_RX_Buffer[USART1_DMA_RX_BUFFER_MAX_LENGTH];
uint8_t USART1_DMA_TX_Buffer[USART1_DMA_TX_BUFFER_MAX_LENGTH];




void USART1_DMA_Tx_Configuration(void)
{
	DMA_InitTypeDef  DMA_InitStructure;
	
	
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 , ENABLE);					//DMA2时钟使能
	DMA_DeInit(DMA2_Stream7);
	while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE);						//等待DMA可配置
	DMA_InitStructure.DMA_Channel = DMA_Channel_4; 							//DMA通道配置
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;		//DMA外设地址
	DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART1_DMA_TX_Buffer;//发送缓存指针
	DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;					//DMA传输方向：内存--->外设
	DMA_InitStructure.DMA_BufferSize = USART1_DMA_TX_BUFFER_MAX_LENGTH;		//数据传输字节数量
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;		//外设非增量模式
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;					//存储器增量模式
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;	//外设数据长度:8位
	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;			//存储器数据长度:8位
	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;							//使用普通模式 
	DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;					//中等优先级 DMA_Priority_High
	DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;         
	DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
	DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;				//存储器突发单次传输
	DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;		//外设突发单次传输
	DMA_Init(DMA2_Stream7, &DMA_InitStructure);								//初始化DMA Stream
	DMA_Cmd(DMA2_Stream7, DISABLE); 										//开启DMA传输
}



void USART1_DMA_Rx_Configuration(void)
{
	DMA_InitTypeDef  DMA_InitStructure;

	
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA2 , ENABLE);					//DMA2时钟使能
	DMA_DeInit(DMA2_Stream5);
	while (DMA_GetCmdStatus(DMA2_Stream5) != DISABLE);						//等待DMA可配置  
	DMA_InitStructure.DMA_Channel = DMA_Channel_4;  						//通道选择
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;		//DMA外设地址
	DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)USART1_DMA_RX_Buffer;//接收缓存指针
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory ;				//DMA传输方向：外设到存储器模式：外设--->内存
	DMA_InitStructure.DMA_BufferSize = USART1_DMA_RX_BUFFER_MAX_LENGTH;		//缓冲大小 
	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;		//外设非增量模式
	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;					//存储器增量模式
	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;	//外设数据长度:8位
	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;			//存储器数据长度:8位
	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;							//使用普通模式 
	DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;					//中等优先级 DMA_Priority_VeryHigh
	DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;         
	DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
	DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;				//存储器突发单次传输
	DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;		//外设突发单次传输
	DMA_Init(DMA2_Stream5 , &DMA_InitStructure);							//初始化DMA_Stream5	
	DMA_Cmd(DMA2_Stream5, ENABLE);  										//开启DMA传输
}




void USART1_DMA_Begin_Send(uint8_t *send_buffer , uint16_t nSendCount)
{		
	if (nSendCount < USART1_DMA_TX_BUFFER_MAX_LENGTH)
	{
		memcpy(USART1_DMA_TX_Buffer , send_buffer , nSendCount);
		DMA_Cmd(DMA2_Stream7 , DISABLE);                    //关闭DMA传输
		while (DMA_GetCmdStatus(DMA2_Stream7) != DISABLE);	//确保DMA可以被设置
		DMA_SetCurrDataCounter(DMA2_Stream7 , nSendCount);  //数据传输量
		DMA_Cmd(DMA2_Stream7 , ENABLE);               		//开启DMA传输
	}
}

三、USART1串口配置

void USART1_Configuration(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	
	USART_DeInit(USART1);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);	
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);		
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
	GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_Init(GPIOA, &GPIO_InitStructure);	

	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No ;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART1, &USART_InitStructure);
	USART_Cmd(USART1, ENABLE);

	USART_ClearFlag(USART1, USART_FLAG_TC);
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
	USART_ClearFlag(USART1, USART_FLAG_TC);

    USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
	USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
	USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
	USART_ITConfig(USART1, USART_IT_TC, ENABLE);	
	USART_DMACmd(USART1 ,   USART_DMAReq_Tx,ENABLE);   //使能DMA发送
	USART_DMACmd(USART1 ,   USART_DMAReq_Rx,ENABLE);    //    使能DMA接收
}



void USART1_Begin_Send(void)
{
	USART1_DMA_Begin_Send(MBCOM1.send_buffer , MBCOM1.sendBytes);
	
}

四、DMA接收串口不定长报文以及DMA方式发送报文


void USART1_IRQHandler(void)
{
	uint16_t ch;

	
	if (USART_GetITStatus(USART1,USART_IT_IDLE) != RESET)
	{		
		USART_ClearITPendingBit(USART1 , USART_IT_IDLE);	//必须先清除总线空闲中断标识，然后读一下数据寄存器，DMA接收才会正确（先读SR，然后读DR才能清除空闲中断标识）注意：这句必须要，否则不能够清除中断标志位。
		ch =  USART_ReceiveData(USART1);					//必须先清除总线空闲中断标识，然后读一下数据寄存器，DMA接收才会正确（先读SR，然后读DR才能清除空闲中断标识）注意：这句必须要，否则不能够清除中断标志位。	
		
		DMA_Cmd(DMA2_Stream5 , DISABLE);
		DMA_ClearFlag(DMA2_Stream5 , DMA_FLAG_TCIF5 | DMA_FLAG_FEIF5 | DMA_FLAG_DMEIF5 | DMA_FLAG_TEIF5 | DMA_FLAG_HTIF5);
		ch = USART1_DMA_RX_BUFFER_MAX_LENGTH - DMA_GetCurrDataCounter(DMA2_Stream5);
		if (ch > 0)
		{
			if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
			{
				MBCOM1.Outtime_mark = TRUE;
				MBCOM1.receCount = ch;
				memcpy(MBCOM1.mscomm_buffer , USART1_DMA_RX_Buffer , MBCOM1.receCount);
			}
		}
		DMA_SetCurrDataCounter(DMA2_Stream5 , USART1_DMA_RX_BUFFER_MAX_LENGTH);
		DMA_Cmd(DMA2_Stream5, ENABLE);
	}
	
	else if (USART_GetITStatus(USART1,USART_IT_TC)!= RESET) 
	{
		USART_ClearITPendingBit(USART1, USART_IT_TC);
		
		DMA_ClearFlag(DMA2_Stream7 , DMA_FLAG_TCIF7 | DMA_FLAG_FEIF7 | DMA_FLAG_DMEIF7 | DMA_FLAG_TEIF7 | DMA_FLAG_HTIF7);
		DMA_SetCurrDataCounter(DMA2_Stream7 , 0);
		
		if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_BEGINING)
		{
			MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_SEND_OVER;
			TIM1_Start();  //请求报文发送完毕，开启超时定时器TIM1

		}	
	}	
}

四、主站轮巡发送请求报文

使用状态机进行发送。


enum MODBUS_HOSTS_STATUS 
{	
	enum_MODBUS_STATUS_READY = 0,	
	enum_MODBUS_STATUS_SEND_BEGIN =1,
	enum_MODBUS_STATUS_SEND_BEGINING =2,	
	enum_MODBUS_STATUS_SEND_OVER =3,
	enum_MODBUS_STATUS_RECV_OVER =4,
	enum_MODBUS_STATUS_RECV_ERROR =5,
	enum_MODBUS_STATUS_TIME_OUT =6,
};

typedef struct
{
    BOOL volatile Outtime_mark;	
	uint8_t volatile MBHosts_Query_isr;
	uint16_t volatile MBHosts_Poll_Time;
    uint16_t volatile sendBytes;
    uint16_t volatile sendPosi;
    uint16_t volatile receCount;
    uint8_t send_buffer[MSCOMM_BUFFER_LENGTH];
    uint8_t mscomm_buffer[MSCOMM_BUFFER_LENGTH];
} USART_DataType;



USART_DataType MBCOM1;

MODBUS_ELEMENT MBCOM1_MBHOSTS_Node;

MODBUS_ELEMENT MBCOM1_MODBUS_ELEMENT[MBCOM1_MODBUS_QUEUE_LENGTH];
MODBUS_QUEUE_STRUCT MBCOM1_MODBUS_QUEUE_STRUCT;
MODBUS_QUEUE_STRUCT *MBCOM1_MODBUS_QUEUE;



void MBCOM1_MODBUS_QUEUE_Init(void)
{	
	uint16_t i;
	
		
	MBCOM1_MODBUS_QUEUE = &MBCOM1_MODBUS_QUEUE_STRUCT;
	MBCOM1_MODBUS_QUEUE->size = MBCOM1_MODBUS_QUEUE_LENGTH;
	MBCOM1_MODBUS_QUEUE->MODBUS_Element = MBCOM1_MODBUS_ELEMENT;
	
	for (i = 0; i < MBCOM1_MODBUS_QUEUE->size ; i++)
	{
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].Reserved = 0x00;
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].DeviceAddr = 0x00;		
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].Func = 0x00;
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].StartAddr = 0x00;		
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].RegisterAmount = 0x00;
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].ByteCount = 0x00;
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].SendBytes = 0x00;
		MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].SendCount = 0x00;
		memset(MBCOM1_MODBUS_QUEUE->MODBUS_Element[i].Data , 0x00 , MODBUS_ELEMENT_DATA_LENGTH);
	}
	MBCOM1_MODBUS_QUEUE->front = 0x00;
	MBCOM1_MODBUS_QUEUE->rear = 0x00;
}


void MBCOM1_Init(void)
{
	uint8_t i;
	
	
	MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_READY; //初始状态机	
	memset(&MBCOM1 , 0x00 , sizeof(USART_DataType));	
	memset(&MBCOM1_MBHOSTS_Node  , 0x00 , sizeof(MODBUS_ELEMENT));
}


#define MBHOSTS_MAX_REPEAT_SEND_COUNT   5    //自动重发次数=5（超时或接收错误，自动重发次数）
BOOL MBCOM1_150ms_mark = FALSE;

void MBCOM1_MODBUS_Hosts_Poll(void)
{	

	MBCOM1_MODBUS_Hosts_Analysize();

    if (MBCOM1_150ms_mark)    //150毫秒轮巡1次
    {
        MBCOM1_150ms_mark = FALSE;
	switch (MBCOM1.MBHosts_Query_isr)
	{			
		case enum_MODBUS_STATUS_READY:
			if (!MODBUS_QUEUE_Empty(MBCOM1_MODBUS_QUEUE))
			{
				MODBUS_QUEUE_Out(MBCOM1_MODBUS_QUEUE , &MBCOM1_MBHOSTS_Node);
				MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_SEND_BEGIN;
				break;
			}
            else
            {
                MBHOSTS_ReadInputRegisters( 1 ,                                                  0 , 125  , MBHOSTS_MAX_REPEAT_SEND_COUNT , MBCOM1_MODBUS_QUEUE);
			MBHOSTS_ReadHoldingRegisters( 2,  0    , 125     , MBHOSTS_MAX_REPEAT_SEND_COUNT , MBCOM1_MODBUS_QUEUE);


            }
			break;
		
		case enum_MODBUS_STATUS_SEND_BEGIN:	    
			MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_SEND_BEGINING;
			memcpy(MBCOM1.send_buffer , MBCOM1_MBHOSTS_Node.Data , MBCOM1_MBHOSTS_Node.SendBytes);
			MBCOM1.sendBytes = MBCOM1_MBHOSTS_Node.SendBytes;
			USART1_Begin_Send();
			break;		
				
		case enum_MODBUS_STATUS_RECV_OVER:
			TIM1_Stop();
			MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_READY;
			break;		
		
		case enum_MODBUS_STATUS_RECV_ERROR:
		case enum_MODBUS_STATUS_TIME_OUT:
			TIM1_Stop();
		
            //超时或错误时，自动重发  
			if (--MBCOM1_MBHOSTS_Node.SendCount > 0)
				MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_SEND_BEGIN;					
			else
				MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_READY;						
			break;						
			}//switch (MBCOM1.MBHosts_Query_isr)
			break;
    }	
    }		
}

五、主站解析从站报文

使用状态机进行解析。


void MBCOM1_MODBUS_Hosts_Analysize(void)
{
	uint16_t i,j,k;
	uint16_t startAddr;
	uint16_t registerAmount;
	uint16_t tempData;
	uint16_t crcData;
	int16_t  bad;
	
		
	if (MBCOM1.Outtime_mark)
	{
		MBCOM1.Outtime_mark = FALSE;

		if (MBCOM1.receCount >= 5)
        {			
            switch (MBCOM1.mscomm_buffer[1])
            {
                case MODBUS_HOSTS_FUNC_ReadCoil:					
					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
					{
						tempData = MBCOM1.mscomm_buffer[2] + 5;
						if (MBCOM1.receCount == tempData)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , tempData - 2);
							if (crcData == (uint16_t)(MBCOM1.mscomm_buffer[tempData - 2] << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							{
								k = 0;
								for (i = 0 ; i < MBCOM1_MBHOSTS_Node.ByteCount ; i++)
								{
									for (j = 0 ; j < 8 ; j++)
									{
										if (MBCOM1.mscomm_buffer[3+i] & (0x01 << j))
											__NOP();//reg0x_buffer[k++] = 0x01;
										else
											__NOP();//reg0x_buffer[k++] = 0x00;
										
										if (k >= MBCOM1_MBHOSTS_Node.RegisterAmount)
											break;
									}
								}//for (i = 0 ; i < MBCOM1_MBHOSTS_Node.ByteCount ; i++)
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif	
							}//if (crcData == (uint16_t)(MBCOM1.mscomm_buffer[tempData - 2] << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
                        }//if (MBCOM1.receCount == tempData)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
                    break;
									
					
               case MODBUS_HOSTS_FUNC_ReadDiscrete:
				   	if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
					{
						tempData = MBCOM1.mscomm_buffer[2] + 5;
						if (MBCOM1.receCount == tempData)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , tempData - 2);
							if (crcData ==(((uint16_t)MBCOM1.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							{
								k = 0;
								for (i = 0 ; i < MBCOM1_MBHOSTS_Node.ByteCount ; i++)
								{
									for (j = 0 ; j < 8 ; j++)
									{
										if (MBCOM1.mscomm_buffer[3+i] & (0x01 << j))
											__NOP();//reg1x_buffer[k++] = 0x01;
										else
											__NOP();//reg1x_buffer[k++] = 0x00;

										if (k >= MBCOM1_MBHOSTS_Node.RegisterAmount)
											break;
									}
								}//for (i = 0 ; i < MBCOM1_MBHOSTS_Node.ByteCount ; i++)
								
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif									
                            }//if (crcData ==(((uint16_t)MBCOM1.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
                        }//if (MBCOM1.receCount == tempData)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
                    break;

					
                case MODBUS_HOSTS_FUNC_ReadHoldingRegisters:
					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
					{
						tempData = MBCOM1.mscomm_buffer[2] + 5;
						if (MBCOM1.receCount == tempData)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , tempData - 2);
							if (crcData ==(((uint16_t)MBCOM1.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							{
								
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif
								
									tempData = ((int16_t)MBCOM1.mscomm_buffer[3+2*4] << 0x08) + (int16_t)MBCOM1.mscomm_buffer[3+2*4+1];

								
							}//if (crcData ==(((uint16_t)MBCOM1.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == tempData)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
                    break;
					
				
                case MODBUS_HOSTS_FUNC_ReadInputRegisters:					
 					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
					{
						tempData = MBCOM1.mscomm_buffer[2] + 5;
						if (MBCOM1.receCount == tempData)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , tempData - 2);
							if (crcData ==(((uint16_t)MBCOM1.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
									tempData = ((int16_t)MBCOM1.mscomm_buffer[3+2*0] << 0x08) + (int16_t)MBCOM1.mscomm_buffer[3+2*0+1];
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif									
							}//if (crcData ==(((uint16_t)MBCOM1.mscomm_buffer[tempData - 2]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[tempData - 1])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == tempData)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func && MBCOM1.mscomm_buffer[2] == MBCOM1_MBHOSTS_Node.ByteCount)
                    break;


				case MODBUS_HOSTS_FUNC_ForceSingleCoil:					
 					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					{
						startAddr = (uint16_t)(MBCOM1.mscomm_buffer[2] << 8) + (uint16_t)MBCOM1.mscomm_buffer[3];
						if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , 6);
							if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							{								
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif									
							}//if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
                    break;
				
					
				case MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister:					
  					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					{
						startAddr = (uint16_t)(MBCOM1.mscomm_buffer[2] << 8) + (uint16_t)MBCOM1.mscomm_buffer[3];
						if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , 6);
							if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							{								
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif									
							}//if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
                    break;

				
				case MODBUS_HOSTS_FUNC_ForceMultipleCoil:
  					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					{
						startAddr = (uint16_t)(MBCOM1.mscomm_buffer[2] << 8) + (uint16_t)MBCOM1.mscomm_buffer[3];
						registerAmount = (uint16_t)(MBCOM1.mscomm_buffer[4] << 8) + (uint16_t)MBCOM1.mscomm_buffer[5];						
						if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr && registerAmount == MBCOM1_MBHOSTS_Node.RegisterAmount)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , 6);
							if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							{																	
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
								
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif									
							}//if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr && registerAmount == MBCOM1_MBHOSTS_Node.RegisterAmount)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					break;
				
					
				case MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters:
  					if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					{
						startAddr = (uint16_t)(MBCOM1.mscomm_buffer[2] << 8) + (uint16_t)MBCOM1.mscomm_buffer[3];
						registerAmount = (uint16_t)(MBCOM1.mscomm_buffer[4] << 8) + (uint16_t)MBCOM1.mscomm_buffer[5];						
						if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr && registerAmount == MBCOM1_MBHOSTS_Node.RegisterAmount)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , 6);
							if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							{								
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
																						
								#ifdef __DEBUG_stm32f407__
									__DEBUG_MBCOM1_MODBUS_Recv_Count++;
								#endif									
							}//if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[6]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[7])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == 8 && startAddr == MBCOM1_MBHOSTS_Node.StartAddr && registerAmount == MBCOM1_MBHOSTS_Node.RegisterAmount)
                    }//if (MBCOM1.mscomm_buffer[0] == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)					
					break;
				
				
				case 0x81:
				case 0x82:
				case 0x83:
				case 0x84:
				case 0x85:
				case 0x8F:
				case 0x90:					
 					if ((MBCOM1.mscomm_buffer[0] - 0x80) == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					{
						if (MBCOM1.receCount == 5)
						{
							crcData = CRC16(MBCOM1.mscomm_buffer , 3);
							if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[3]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[4])
							{								
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_OVER;
							}//if (crcData == (((uint16_t)MBCOM1.mscomm_buffer[3]) << 8) + (uint16_t)MBCOM1.mscomm_buffer[4])
							else
							{
								if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
									MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
							}
						}//if (MBCOM1.receCount == 5)
						else
						{
							if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
								MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;						
						}
					}//if ((MBCOM1.mscomm_buffer[0] - 0x80) == MBCOM1_MBHOSTS_Node.DeviceAddr && MBCOM1.mscomm_buffer[1] == MBCOM1_MBHOSTS_Node.Func)
					break;	

				default:
					if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
						MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;
					break;				
            }//switch (MBCOM1.mscomm_buffer[1])
			
			//USART_ITConfig(MBCOM1, USART_IT_RXNE, ENABLE);//DMA通信，则删除
			
        }//if (MBCOM1.receCount >= 5)
		else
		{
			if (MBCOM1.MBHosts_Query_isr == enum_MODBUS_STATUS_SEND_OVER)
				MBCOM1.MBHosts_Query_isr = enum_MODBUS_STATUS_RECV_ERROR;		
		}				
    }//if (MBCOM1.Outtime_mark)
}

本程序已经在很多工程项目上成功运用。

源程序参见：MODBUS_RTU_Master.zip（STM32F407单片机上开发的MODBUSRTU多主站源程序）_modbusRTU主站程序-C文档类资源-CSDN下载

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

STM32F407单片机上开发MODBUS RTU 多主站程序（二）的相关文章

ROS个别命令的使用 ros ros2

ros1 录包 rosbag record a O filename bag 解释 xff1a a是把所有的包都进行录制 xff0c O表示后面需要跟输出的文件名字 xff0c o的话系统会自己添加录制日期为文件名上 xff1b rosba
浅析自动驾驶、遥控驾驶、平行驾驶区别

以下内容仅为个人粗浅理解 xff0c 欢迎大家留言指正图片内容来源于互联网 xff0c 图片权利归图片作者所有 xff0c 本文仅引用自动驾驶 xff1a 重点在车端 xff0c 自动驾驶相关资源部署在车端 xff0c 或大部分算力等都
CNN图像分割简史：从R-CNN到Mask R-CNN（译）

一直想总结一下CNN在图像分割中的发展脉络 xff08 主要是R CNN及其改进方法 xff09 xff0c 看到一篇不错的英文博文 A Brief History of CNNs in Image Segmentation From R
c: __FILE__, __LINE__

这是编译器内置宏 xff0c 这些宏定义不仅可以帮助我们完成跨平台的源码编写 xff0c 灵活使用也可以巧妙地帮我们输出非常有用的调试信息注意 xff0c 是双下划线 xff0c 而不是单下划线 FILE 包含当前程序文件名的字符串 LI
当数组遇到mybatis in 的时候

我想实现多个id 传入sql 语句的操作 1 我试着将数组 stringUtils join 数组 34 34 数组转string 并以逗号分隔没成功因为传到sql 里是 123 234 435 xff0c 而我们需要的是 123
jeesite中的ztree应用

话不多说 xff0c 直接开始一二三 jeesite页面上通过以自定义jstl lt sys treeselect gt 方式引入树形选择 1 lt sys treeselect id 61 34 company 34 name 61 34
getByte()用法小结

在Java中 xff0c String的getBytes 方法是得到一个操作系统默认的编码格式的字节数组这个表示在不同情况下 xff0c 返回的东西不一样 xff01 String getBytes String decode 方法会根据
plsql 导出表和表数据

导出数据表结构打开pl sql客户端 Tools Export User Objects xff08 工具导出用户对象 xff09 按图选择自己需要导出的表 xff0c 在选择导出文件位置导出表数据 Tools Exports Tab
String的按值传递，java传参都是传值

看完绝对清晰 java中对象作为参数传递给一个方法 xff0c 到底是值传递 xff0c 还是引用传递 xff1f pdd xff1a 所谓java只有按值传递 xff1a 基本类型值传递 xff1b 引用类型 xff0c 地址值传递 x
Bili视频弹幕播放器后台源码

介绍此款播放器源码添加及修复了很多功能 xff0c 且所有源码均本地化 xff0c 不存在外链的情况 xff0c 测试环境 xff1a PHP7 0 43 MySQL5 6 播放器跨域远程下一集代码 xff1a 说明 xff1a 就是你的
小程序与java的session问题

一般web开发中 xff0c 我们需要通过session将数据用户重要数据存储到session中 xff0c 而由于html自带cookie xff0c 能够帮助我们存储从服务器端发送jsessionid到客户端浏览器 xff0c 客户端发
mac下java开发环境配置

1 下载并安装jdk xff0c 配置环境变量 jdk1 8下载地址 xff1a http www oracle com technetwork java javase downloads jdk8 downloads 2133151 ht
数组协变

在某些情况下 xff0c 即使某个对象不是数组的基类型 xff0c 我们也可以把它赋值给数组元素这种属性叫做协变 xff08 covariance xff09 在下面的情况下可以使用协变 xff1a 数组是引用类型数组在赋值的对象类型和
策略模式

策略模式由于最近在研究学习设计模式 xff0c 我会用自己的理解方式来表述对设计模式的学习和认识 xff0c 通过最常用好记的案例来记住和使用设计模式 xff0c 希望对设计代码方面有所提高和改进一应用背景在软件开发中常常遇到这种
Vs2010与VC的区别

VS2010与VC 43 43 编译器的区别 xff1a 1 VS2010并不是针对C 43 43 的 xff0c C 43 43 只是它的一小部分 xff0c 它更加关注 net平台程序开发 xff08 主要是C VB xff0c C 4
通过OAuth2.0方式弹出授权页面获得用户基本信息

获取微信用户的个人的信息的时候 xff0c 要特别注意的是有两个不同的Access Token xff0c 他们产生的方式不一样 xff0c 一种是使用AppID和AppSecret获取的access token xff0c 一种是OAut
SqlSugar入门级教程+实例（.net core下的）

官方参考 xff1a http www codeisbug com Doc 8 前言 xff1a 这应该是目前最好用的ORM框架之一了 xff0c 而且支持 net core xff0c 网上除了官方文档其他参考就少了点 xff0c 自己整
c#通过串口及CAN模块实现上位及下位机通讯

目录前言一串口 CAN总线二使用步骤 1 RS232串口通讯 xff08 指令下发与接收 xff09 2 CAN总线通讯总结前言学习及工作中我们经常会遇到上位机与下位机通讯等工作 xff0c 结合场景使用不同的通讯方式实时通
C# String转int主要有四种方法

String转int主要有四种方法 1 int Parse 是一种类容转换 xff1b 表示将数字内容的字符串转为int类型如果字符串为空 xff0c 则抛出ArgumentNullException异常 xff1b 如果字符串内容不是数
基于正点原子STM32F103精英板IIC实验的MS5611气压计的使用

MS5611是一款气压计 xff0c 能够提供高精度的气压值与温度值 xff0c 这次做项目正好需要用到这款传感器 xff0c 包括之前也没好好学习用过IIC xff0c 所以写下博客记录一下如果有需要使用的朋友可以去https down

随机推荐

关于C#使用XMLDocument生成XML文档时，UTF-8编码的BOM问题

XmlSerializer 的序列化默认指定编码 xmlWriterSettings Encoding 61 Encoding UTF8 这种编码是带bom标记位 BOM byte order mark 字节顺序标记的改为 xff1
Winform datagridview中显示下拉框示例

方式一 xff1a 如下图所示 xff0c 该方式也是较为简单的一种你只需要添加一列类型为DataGridViewComboBoxColumn的列 xff0c 然后添加数据源即可但是我们看到这种方式的下拉列表看起来并不是十分的美观 xf
subject may not be empty[Git]

PS D MySource sino manager gt git commit husky gt pre commit node v10 15 3 STARTED Preparing SUCCESS Preparing STARTED R
[转]C# HTTP 错误 403.14 - Forbidden Web

HTTP 错误 403 14 ForbiddenWeb 服务器被配置为不列出此目录的内容出现以上这个错误可能有如下解决方法 xff1a 1 将应用程序池设置成V4 0 2 在配置文件中加上以下几句代码 xff1a lt system we
c# 创建Web Api项目

创建WebApi项目 xff1a 在VS工具中创建一个ASP NET Web应用程序选择Webapi 一个webapi项目就创建好了这里简单的写一个post和get两种请求的方法 xff0c 由于post请求参数需要参数体的形式 xff
C# 反射获取类的成员变量名称及值

测试用的类 public class PersonData public string gender 61 string Empty public List lt int gt pifuRGB 61 new List lt int gt 0
cstring转换为char*

在Visual C 43 43 NET2005中 xff0c 默认的字符集形式是Unicode xff0c 但在VC6 0等工程中 xff0c 默认的字符集形式是多字节字符集 xff08 MBCS xff1a Multi Byte Char
Error creating bean with name 'userController'

Caused by org springframework beans factory UnsatisfiedDependencyException Error creating bean with name 39 userControll
IntelliJ IDEA Cannot find declaration to go to

最近在用IntelliJ IDEA开发一个微服务的项目的时候 xff0c 从git clone了代码 xff0c 再用IntelliJ IDEA导入项目以后项目里好多方法类和属性都无法转到定义或者声明处 xff0c 无论是Ctrl 43
CString转char * ,string

CString头文件 include lt afx h gt string头文件 include lt string h gt 1 CString转char CString cstr char p 61 LPSTR LPCTSTR cstr
GPS数据包格式+数据解析

GPS数据包格式 43 数据解析一全球时区的划分 xff1a 每个时区跨15 经度以0 经线为界向东向西各划出7 5 经度 xff0c 作为0时区即0时区的经度范围是7 5 W 7 5 E 从7 5 E与7 5 W分别向东向西每1
在C#中使用libcurl库

几乎在所有的linux发行版中 xff0c 默认都是包含有libcurl库的那么 xff0c libcurl是使用C开发的 xff0c 自然 xff0c 当你用C或C 43 43 使用libcurl库的时候很方便但是 xff0c 如果你
Linux下chrony授时监测脚本

1 背景概述 Linux下基于gpsd 43 chrony授时 xff0c 在有些情况下会存在收敛慢或者参考时间选择错误问题 xff0c 因此需要授时监测脚本进行监测 xff0c 便于在异常时候发现并处理 2 gpsd 43 chrony授
关于linux下shell输出^M特殊字符的处理

shell中echo输出时 M特殊字符的处理今天在csdn论坛看一网友发了一个帖子 xff1a https bbs csdn net topics 392668752 post 403986636 xff0c 我很好奇 xff0c 于是将
VS2010(VS2017)+Boost_1_68_0环境搭建

文 Seraph 一下载首先从Boost下载官网下载源码 xff0c 当然你也可以下载编译好的库文件直接用我下载的是boost 1 68 0 zip 解压到某个目录下 xff0c 我解压到了D盘根目录 xff1a E boost 1
2.gstreamer USB摄像头RTSP推流

目录 1 操作系统版本 2 使用gstreamer播放mp4文件 3 采集USB摄像头视频源 xff0c 并RTSP推流 4 使用RTSP播放器播放 5 注意事项 1 操作系统版本使用的虚拟机加ubuntu 20 04 2 使用gstre
3.gstreamer UDP推流RTP及拉流播放

目录 1 将H264数据流打包为RTP包 xff0c 然后UDP推流 2 UDP client拉流 xff0c 然后RTSP传输 3 easyplayer rtsp exe播放器播放RTSP数据流将H264打包为RTP包 xff0c 然后
靶机渗透练习80-Momentum：1

靶机描述靶机地址 xff1a https www vulnhub com entry momentum 1 685 Description Info easy medium 一搭建靶机环境攻击机Kali xff1a IP地址 xff1
靶机渗透练习81-Momentum：2

靶机描述靶机地址 xff1a https www vulnhub com entry momentum 2 702 Description Difficulty mediumKeywords curl bash code review T
STM32F407单片机上开发MODBUS RTU 多主站程序（二）

STM32F407单片机上开发MODBUS RTU 多主站程序 xff08 一 xff09 STM32F407单片机上开发MODBUS RTU 多主站程序 xff08 二 xff09 前面一篇文章 STM32F407单片机上开发MODBUS

STM32F407单片机上开发MODBUS RTU 多主站程序（二）

STM32F407单片机上开发MODBUS RTU 多主站程序（二） 的相关文章

随机推荐

热门标签

STM32F407单片机上开发MODBUS RTU 多主站程序（二）的相关文章