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

已于 2022-03-17 14:55:09 修改
阅读量4.9k 收藏 78
点赞数 8
分类专栏： STM32F407 MODBUS 文章标签： 单片机 stm32 嵌入式硬件
于 2021-01-08 17:07:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ba_wang_mao/article/details/112344582
版权

       

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

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

 

        因为工程需要经常要在STM32F407上编写MODBUS RTU 多主站程序。何谓多主站程序呢？即：1个单片机系统需要编写多个MODBUS RTU主程序，例如：USART1需要编写1个MODBUS RTU 主站程序， 读取相关的数据；USART2也需要编写1个MODBUS RTU 主站程序，读取相关的数据。

        按照一般的方式，USART1串口编写一个主站程序，USART2也串口编写一个主站程序，就样就显然太不专业了，显然我们可以实现USART1串口和USART2串口共用一个主站程序，我使用了队列+指针的方式实现MODBUS RTU 多主站程序。

1、宏定义

#define BOOL                    		uint8_t


#ifndef	TRUE
#define TRUE                    		(1)
#endif

#ifndef	FALSE
#define FALSE                   		(!(TRUE))
#endif

2、CRC16.H


#ifndef __CRC16_H__
#define __CRC16_H__


#include "stm32f4xx.h"


uint16_t CRC16(uint8_t *puchMsg, uint16_t usDataLen);


#endif

 3、CRC16.c

#include "stm32f4xx.h"
#include "CRC16.h"



const uint8_t auchCRCHi[] = {
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
};



const uint8_t auchCRCLo[] = {
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
};



uint16_t CRC16(uint8_t *puchMsg, uint16_t usDataLen)
{
	uint8_t uchCRCHi = 0xFF;
	uint8_t uchCRCLo = 0xFF;
	uint32_t uIndex;

	while (usDataLen--)
	{
		uIndex = uchCRCHi ^ *puchMsg++;
		uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
		uchCRCLo = auchCRCLo[uIndex];
	}
	return (uchCRCHi << 8 | uchCRCLo);
}

4、modbus_queue.h

#ifndef __MODBUS_QUEUE_H__
#define __MODBUS_QUEUE_H__



#include <stm32f4xx.h>
#define MODBUS_ELEMENT_DATA_LENGTH  	(255)



typedef struct TagMODBUS_ELEMENT
{
	uint8_t Reserved;
    uint8_t DeviceAddr;
    uint8_t Func;
    uint8_t StartAddr;
    uint8_t RegisterAmount;		
    uint8_t ByteCount;			
    uint8_t SendBytes;	
    int8_t  SendCount;	
    uint8_t Data[MODBUS_ELEMENT_DATA_LENGTH];	
} MODBUS_ELEMENT;



typedef struct tagMODBUS_QUEUE_STRUCT
{
	MODBUS_ELEMENT *MODBUS_Element;
	uint8_t volatile size;	
	uint8_t volatile front;
	uint8_t volatile rear;
}MODBUS_QUEUE_STRUCT , *MODBUS_QUEUE_STRUCT_PTR;



BOOL MODBUS_QUEUE_Empty(MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MODBUS_QUEUE_Full(MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL  MODBUS_QUEUE_In(MODBUS_QUEUE_STRUCT *MODBUS_queue , MODBUS_ELEMENT MODBUS_element);
BOOL MODBUS_QUEUE_Out(MODBUS_QUEUE_STRUCT *MODBUS_queue , MODBUS_ELEMENT *MODBUS_element);


#endif //__MODBUS_QUEUE_H__

5、modbus_queue.c

#include "platform.h"
#include "modbus_queue.h"



BOOL MODBUS_QUEUE_Empty(MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	return (MODBUS_queue->rear == MODBUS_queue->front);
}



BOOL MODBUS_QUEUE_Full(MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	return ((MODBUS_queue->rear + 1) % MODBUS_queue->size == MODBUS_queue->front);
}



BOOL  MODBUS_QUEUE_In(MODBUS_QUEUE_STRUCT *MODBUS_queue , MODBUS_ELEMENT MODBUS_element)
{	
	if (!MODBUS_QUEUE_Full(MODBUS_queue))
	{
		MODBUS_queue->rear = (MODBUS_queue->rear + 1) % MODBUS_queue->size;
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].Reserved       = MODBUS_element.Reserved;//MODBUS主站增加识别码，识别MODBUS主站使用16号功能码给HMI液晶下发的报文到底是何报文
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].DeviceAddr     = MODBUS_element.DeviceAddr;
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].Func           = MODBUS_element.Func;
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].StartAddr      = MODBUS_element.StartAddr;
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].RegisterAmount = MODBUS_element.RegisterAmount;
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].ByteCount      = MODBUS_element.ByteCount;
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].SendBytes      = MODBUS_element.SendBytes;		
		MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].SendCount      = MODBUS_element.SendCount;
		memcpy(MODBUS_queue->MODBUS_Element[MODBUS_queue->rear].Data , MODBUS_element.Data , MODBUS_ELEMENT_DATA_LENGTH);
		return (TRUE);
	}
	return (FALSE);
}



BOOL MODBUS_QUEUE_Out(MODBUS_QUEUE_STRUCT *MODBUS_queue , MODBUS_ELEMENT *MODBUS_element)
{	
	if (!MODBUS_QUEUE_Empty(MODBUS_queue))
	{
		MODBUS_queue->front = (MODBUS_queue->front + 1) % MODBUS_queue->size;
		MODBUS_element->Reserved       = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].Reserved;//MODBUS主站增加识别码，识别MODBUS主站使用16号功能码给HMI液晶下发的报文到底是何报文
		MODBUS_element->DeviceAddr     = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].DeviceAddr;
		MODBUS_element->Func           = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].Func;
		MODBUS_element->StartAddr      = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].StartAddr;
		MODBUS_element->RegisterAmount = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].RegisterAmount;
		MODBUS_element->ByteCount      = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].ByteCount;
		MODBUS_element->SendBytes      = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].SendBytes;		
		MODBUS_element->SendCount      = MODBUS_queue->MODBUS_Element[MODBUS_queue->front].SendCount;
		memcpy(MODBUS_element->Data , MODBUS_queue->MODBUS_Element[MODBUS_queue->front].Data , MODBUS_ELEMENT_DATA_LENGTH);
		return (TRUE);
	}
	return (FALSE);
}

6、modbus_hosts.h

#ifndef __MODBUS_HOSTS_H__
#define __MODBUS_HOSTS_H__


#include <stm32f4xx.h>
#include "modbus_queue.h"



#define MODBUS_HOSTS_FUNC_ReadCoil							(0x01)
#define MODBUS_HOSTS_FUNC_ReadDiscrete						(0x02)
#define	MODBUS_HOSTS_FUNC_ReadHoldingRegisters				(0x03)
#define	MODBUS_HOSTS_FUNC_ReadInputRegisters				(0x04)
#define MODBUS_HOSTS_FUNC_ForceSingleCoil					(0x05)
#define	MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister		(0x06)
#define MODBUS_HOSTS_FUNC_ForceMultipleCoil					(0x0F)
#define MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters	(0x10)



//MODBUS主站最大传输254字节，当波特率=115200时，1秒钟最大能够传输11520字节，则50毫秒能传输576字节
//30毫秒能传输345字节，25毫秒能传输288字节，20毫秒能传输234字节
//MODBUS主站最大传输254字节，当波特率=9600时，1秒钟最大能够传输960字节，则100毫秒能传输96字节,
//50毫秒能传输48字节
#define MODBUS_HOSTS_POLL_TIME								(10)
#define MBHOSTS_MIN_REPEAT_SEND_COUNT						(1)
#define MBHOSTS_MAX_REPEAT_SEND_COUNT						(5)



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,
};



uint16_t CRC16(uint8_t *puchMsg, uint16_t usDataLen);
void MBHOSTS_Init(void);
BOOL MBHOSTS_ReadCoilRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_ReadDiscreteRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_ReadInputRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_ReadHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_ForceSingleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t On_Off , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_PresetSingleHoldingRegister(uint8_t DeviceAddr , uint16_t startAddr , int16_t Value , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_ForceMultipleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t Data_Buffer[] , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue);
BOOL MBHOSTS_PresetMultipleHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , int16_t Data_Buffer[] , uint8_t SendCount , uint8_t Reserved_Func , MODBUS_QUEUE_STRUCT *MODBUS_queue);



#endif //__MODBUS_HOSTS_H__

7、modbus_hosts.c

#include "modbus_hosts.h"



BOOL MBHOSTS_ReadCoilRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{	
	uint8_t ByteCount;
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;

	
	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_ReadCoil;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = registerAmount >> 0x08;
	MODBUS_element.Data[5] = registerAmount & 0xFF;
	crcData = CRC16(MODBUS_element.Data , 6);
	MODBUS_element.Data[6] = crcData >> 0x08;
	MODBUS_element.Data[7] = crcData & 0xFF;	
	
	ByteCount = registerAmount >> 0x03;
	if (registerAmount & 0x07)
		ByteCount++;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_ReadCoil;
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = registerAmount;
	MODBUS_element.ByteCount = ByteCount;
	MODBUS_element.SendBytes = 0x08;
	MODBUS_element.SendCount = SendCount;
	
	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);
}



BOOL MBHOSTS_ReadDiscreteRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{	
	uint8_t ByteCount;
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;


	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_ReadDiscrete;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = registerAmount >> 0x08;
	MODBUS_element.Data[5] = registerAmount & 0xFF;
	crcData = CRC16(MODBUS_element.Data , 6);
	MODBUS_element.Data[6] = crcData >> 0x08;
	MODBUS_element.Data[7] = crcData & 0xFF;
	
	ByteCount = registerAmount >> 0x03;
	if (registerAmount & 0x07)
		ByteCount++;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_ReadDiscrete;	
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = registerAmount;
	MODBUS_element.ByteCount = ByteCount;
	MODBUS_element.SendBytes = 0x08;
	MODBUS_element.SendCount = SendCount;
	
	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);
}



BOOL MBHOSTS_ReadInputRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;


	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_ReadInputRegisters;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = registerAmount >> 0x08;
	MODBUS_element.Data[5] = registerAmount & 0xFF;
	crcData = CRC16(MODBUS_element.Data , 6);
	MODBUS_element.Data[6] = crcData >> 0x08;
	MODBUS_element.Data[7] = crcData & 0xFF;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_ReadInputRegisters;
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = registerAmount;
	MODBUS_element.ByteCount = registerAmount << 0x01;
	MODBUS_element.SendBytes = 0x08;
	MODBUS_element.SendCount = SendCount;

	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);	
	return (FALSE);	
}



BOOL MBHOSTS_ReadHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;

	
	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_ReadHoldingRegisters;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = registerAmount >> 0x08;
	MODBUS_element.Data[5] = registerAmount & 0xFF;
	crcData = CRC16(MODBUS_element.Data , 6);
	MODBUS_element.Data[6] = crcData >> 0x08;
	MODBUS_element.Data[7] = crcData & 0xFF;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_ReadHoldingRegisters;
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = registerAmount;
	MODBUS_element.ByteCount = registerAmount << 0x01;
	MODBUS_element.SendBytes = 0x08;
	MODBUS_element.SendCount = SendCount;

	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);	
}



BOOL MBHOSTS_ForceSingleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t On_Off , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;

	
	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_ForceSingleCoil;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;

	switch (On_Off)
	{
		case 1:
			MODBUS_element.Data[4] = 0xFF;	// (4,5) = 0x0000/0xFF00
			MODBUS_element.Data[5] = 0x00;
			break;
		default:
			MODBUS_element.Data[4] = 0x00;	// (4,5) = 0x0000/0xFF00
			MODBUS_element.Data[5] = 0x00;
			break;
	}
	
	crcData = CRC16(MODBUS_element.Data , 6);
	MODBUS_element.Data[6] = crcData >> 0x08;
	MODBUS_element.Data[7] = crcData & 0xFF;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_ForceSingleCoil;
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = 0x01;								//	无意义
	MODBUS_element.ByteCount = MODBUS_element.RegisterAmount << 0x01;	//	无意义
	MODBUS_element.SendBytes = 0x08;
	MODBUS_element.SendCount = SendCount;

	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);
}



BOOL MBHOSTS_PresetSingleHoldingRegister(uint8_t DeviceAddr , uint16_t startAddr , int16_t Value , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;
	

	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = Value >> 0x08;
	MODBUS_element.Data[5] = Value & 0xFF;
	crcData = CRC16(MODBUS_element.Data , 6);
	MODBUS_element.Data[6] = crcData >> 0x08;
	MODBUS_element.Data[7] = crcData & 0xFF;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_PresetSingleHoldingRegister;
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = 0x01;
	MODBUS_element.ByteCount = MODBUS_element.RegisterAmount << 0x01;	//无意义
	MODBUS_element.SendBytes = 0x08;
	MODBUS_element.SendCount = SendCount;

	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);
}



BOOL MBHOSTS_ForceMultipleCoil(uint8_t DeviceAddr , uint16_t startAddr , uint16_t registerAmount , uint8_t Data_Buffer[] , uint8_t SendCount , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	uint8_t i;	
	uint8_t j;
	uint16_t k;
	uint8_t ByteCount;
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;

	
	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_ForceMultipleCoil;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = registerAmount >> 0x08;
	MODBUS_element.Data[5] = registerAmount & 0xFF;
	
	ByteCount = registerAmount >> 3;
	if (registerAmount & 0x07)
		ByteCount++;
	MODBUS_element.Data[6] = ByteCount;	
	
	k = 0x00;
	for (i = 0 ; i < ByteCount ; i++)
	{
		MODBUS_element.Data[i + 7] = 0x00;
		for (j = 0 ; j < 8 ; j++ )
		{
			MODBUS_element.Data[i + 7] |=  (Data_Buffer[k] << j);
			k++;
			if (k >= registerAmount)
				break;
		}
	}					
	crcData = CRC16(MODBUS_element.Data , (ByteCount + 9) - 2);
	MODBUS_element.Data[(ByteCount + 9) - 2] = crcData >> 0x08;
	MODBUS_element.Data[(ByteCount + 9) - 1] = crcData & 0xFF;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_ForceMultipleCoil;
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = registerAmount;
	MODBUS_element.ByteCount = ByteCount;
	MODBUS_element.SendBytes = ByteCount + 9;
	MODBUS_element.SendCount = SendCount;

	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);	
}



BOOL MBHOSTS_PresetMultipleHoldingRegisters(uint8_t DeviceAddr , uint16_t startAddr , uint8_t registerAmount , int16_t Data_Buffer[] , uint8_t SendCount , uint8_t Reserved_Func , MODBUS_QUEUE_STRUCT *MODBUS_queue)
{
	uint8_t k;
	uint8_t ByteCount;
	uint16_t crcData;
	MODBUS_ELEMENT MODBUS_element;

	
	memset(&MODBUS_element , 0x00 , sizeof(MODBUS_ELEMENT));
	MODBUS_element.Data[0] = DeviceAddr;
	MODBUS_element.Data[1] = MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters;
	MODBUS_element.Data[2] = startAddr >> 0x08;
	MODBUS_element.Data[3] = startAddr & 0xFF;
	MODBUS_element.Data[4] = registerAmount >> 0x08;
	MODBUS_element.Data[5] = registerAmount & 0xFF;
	ByteCount = registerAmount << 0x01;
	MODBUS_element.Data[6] = ByteCount;
	
	for (k = 0 ; k < ByteCount ; k++)
	{
		MODBUS_element.Data[7+2*k]   = Data_Buffer[k] >> 0x08;
		MODBUS_element.Data[7+2*k+1] = Data_Buffer[k] & 0xFF;
	}
	crcData = CRC16(MODBUS_element.Data , (ByteCount + 9) - 2);
	MODBUS_element.Data[(ByteCount + 9) - 2] = crcData >> 0x08;
	MODBUS_element.Data[(ByteCount + 9) - 1] = crcData & 0xFF;
	
	MODBUS_element.DeviceAddr = DeviceAddr;
	MODBUS_element.Func = MODBUS_HOSTS_FUNC_PresetMultipleHoldingRegisters;
	MODBUS_element.Reserved = Reserved_Func; 
	MODBUS_element.StartAddr = startAddr;
	MODBUS_element.RegisterAmount = registerAmount;
	MODBUS_element.ByteCount = ByteCount;
	MODBUS_element.SendBytes = ByteCount + 9;
	MODBUS_element.SendCount = SendCount;

	if (MODBUS_QUEUE_In(MODBUS_queue , MODBUS_element))
		return (TRUE);
	return (FALSE);	
}

8、main.c

#define MBCOM1_MODBUS_QUEUE_LENGTH   20
#define MBCOM2_MODBUS_QUEUE_LENGTH   20


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



MODBUS_ELEMENT MBCOM2_MODBUS_ELEMENT[MBCOM2_MODBUS_QUEUE_LENGTH];
MODBUS_QUEUE_STRUCT MBCOM2_MODBUS_QUEUE_STRUCT;
MODBUS_QUEUE_STRUCT *MBCOM2_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 MBCOM2_MODBUS_QUEUE_Init(void)
{	
	uint16_t i;

	
	MBCOM2_MODBUS_QUEUE = &MBCOM2_MODBUS_QUEUE_STRUCT;
	MBCOM2_MODBUS_QUEUE->size = MBCOM2_MODBUS_QUEUE_LENGTH;
	MBCOM2_MODBUS_QUEUE->MODBUS_Element = MBCOM2_MODBUS_ELEMENT;
	
	for (i = 0; i < MBCOM2_MODBUS_QUEUE->size ; i++)
	{
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].Reserved = 0x00;
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].DeviceAddr = 0x00;		
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].Func = 0x00;
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].StartAddr = 0x00;		
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].RegisterAmount = 0x00;
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].ByteCount = 0x00;
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].SendBytes = 0x00;
		MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].SendCount = 0x00;
		memset(MBCOM2_MODBUS_QUEUE->MODBUS_Element[i].Data , 0x00 , MODBUS_ELEMENT_DATA_LENGTH);
	}
	MBCOM2_MODBUS_QUEUE->front = 0x00;
	MBCOM2_MODBUS_QUEUE->rear = 0x00;
}


int main(void)
{
     MBCOM1_MODBUS_QUEUE_Init();
     MBCOM2_MODBUS_QUEUE_Init();

     while (1)
     {
         MBHOSTS_ReadInputRegisters(1 , 0 , 10 , MBHOSTS_MAX_REPEAT_SEND_COUNT , MBCOM1_MODBUS_QUEUE);
         MBHOSTS_ReadHoldingRegisters(2 , 0 , 10 , MBHOSTS_MAX_REPEAT_SEND_COUNT , MBCOM1_MODBUS_QUEUE);

         MBHOSTS_ReadInputRegisters(1 , 0 , 10 , MBHOSTS_MAX_REPEAT_SEND_COUNT , MBCOM2_MODBUS_QUEUE);
         MBHOSTS_ReadHoldingRegisters(2 , 0 , 10 , MBHOSTS_MAX_REPEAT_SEND_COUNT , MBCOM2_MODBUS_QUEUE);

     }
  
}

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

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

ba_wang_mao
关注
  • 8
    点赞
  • 踩
  • 78
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
MODBUS_RTU_Master.zip（STM32F407单片机上开发的MODBUS RTU 多主站源程序）
03-29
在这个名为"MODBUS_RTU_Master.zip"的压缩包中，包含了一个针对STM32F407微控制器实现的MODBUS RTU多主站源代码。STM32F407是一款高性能、低功耗的ARM Cortex-M4内核微控制器，适用于各种嵌入式应用，尤其是工业控制...
STM32F407单片机用Modbus RTU协议通信的实例
01-29
在STM32F407上实现Modbus RTU通信，你需要以下步骤： 1. **配置串口**：STM32F407的UART或USART接口可以用于Modbus RTU通信。你需要配置波特率、奇偶校验、数据位数和停止位，以符合Modbus RTU的标准（通常是9600...
单片机移植freemodbus主机(STM32、GD32、瑞萨、国民技术等)
qq_22560021的博客
05-08 2998
STM32单片机移植freemodbus主机。 生成的项目文件将任务初始化都生成再freertos.c文件中，配置时STM32Cube工程时，配置了一个MasterTask的任务，一个StartReadTask、一个StartWriteTask。否则返回的是MB_MRE_EXE_FUN。**注意：**实际使用中可以将任务代码放在单独的文件中。解决办法：在eMBMasterPoll() 的EV_MASTER_READY状态下先释放信号量。FreeModbus的移植主要包含：物理层接口的修改、应用层回调的修改。
移植FreeModbus+ModbusMaster（主机）+STM32至RT-Thread（3、4阶段）
热门推荐
Armink Studio
09-16 4万+
1、移植了FreeModbus1.5及RT-Thread1.1.1至STM32 2、开发平台支持Eclipse、Keil、IAR 3、可在Eclipse采用EGIT插件进行版本管理 4、支持Modbus RTU（ASCII未测试） 5、目前主机方面只移植了寄存器相关功能，其余功能后期加入 详细说明可参见：http://blog.csdn.net/arminkztl/article/details/11738395 欢迎讨论 (备注：如果您需要把这个项目商用，请及时联系RT-Thread给您授权)
STM32下实现基于MODBUS-RTU协议的主机和从机代码，包含温度传感器DS18B20的从机示例
gptLHcESGKRg的博客
05-01 598
MODBUS-RTU协议主机和从机代码分为两部分，主机部分负责发送指令，从机部分负责接收指令并返回相应数据。在本实例中，主机发送的是指令"01 03 20 00 00 01 8F CA"，从机收到指令后返回温度数据。主机代码还实现了主动发出"03"指令读取其他设备的数据，并将返回数据通过数码管进行显示。总的来说，MODBUS-RTU协议的主机和从机代码实现了主机与从机之间的通信和数据交换。针对功能号的实现原理，主机代码通过if语句判断数据帧的功能号，从而实现不同功能的处理。好运佳星(=^_^=)
STM32 RS485 modbus通讯
m0_59388312的博客
11-30 464
其中MODBUS-RTU最常用，比较简单，在单片机上很容易实现。从机地址 功能号 数据地址 数据 CRC校验。从机地址 功能号 数据地址 读取数据个数 CRC校验。从机地址 功能号 数据字节个数 两个字节数据 CRC校验。MODBUS主机就完成了一次对从机数据的写操作，实现了通讯。MODBUS主机就完成了一次对从机数据的读操作，实现了通讯。
手机端ModbusTcp主站工具及程序
cetclyb的博客
12-02 3491
Modbus协议在工业现场使用比较频繁，为方便手机调试，在android上做了个ModbusTcp主站功能。
最新版Modbus RTU 51单片机从机（源码）
J_Giser的博客
12-14 2637
最新版Modbus RTU 51单片机从机源码,在原源码基础上添加了芯片型号选择,适应的芯片型号多了STC12系列，STC15系列，STC8系列。包括以前的版本加更新版本，赠送4个组态触摸屏测试工程文件，具体看图片。支持01,02,03,04,05,06,15,16等常用功能码。
MODBUS MASTER RTU在STM32上的实现
weixin_33874713的博客
10-26 1471
MODBUS MASTER RTU在STM32上的实现 1.概述 最近需要将几个信号采集模块通过总线串联起来，这样便于系统模块化。故将目光关注到了工业上经常使用的modbus协议。 modbus协议是一种一主多从的拓扑结构，主要是应用层软件协议，有关modbus的相关信息，可以自行google、百度。 STM32实现的Master工程代码在github上，点击获取。 2.开发环境 STM32...
基于STM32F407单片机的modbusRTU协议主机代码
最新发布
05-29
在STM32F407单片机上实现Modbus RTU协议的主机程序，你需要遵循Modbus RTU的通信规范，并使用STM32的硬件资源来编写代码。以下是一个基本的步骤和代码示例，用于在STM32F407上实现Modbus RTU主机功能。 1. 硬件准备...
FreeModbus--RTU--Master+Slave--uCOSIII--STM32F407.rar
07-22
此软件包包括FreeModbus从栈协议和补充的主栈协议，采用的是RTU模式，主从协议栈与uC/OSIII进行的整合，并在STM32F407硬件平台上进行了移植，经过调试和测试，运行正常。
STM32_modbus_master_成功.rar_Modbus 主机 stm32_modbus STM32F103_stm3
07-15
自己做的STM32F103单片机的MODBUSRTU主机程序,架构清晰，测试通过
STM32F4 485 modbus
07-11
编写了stm32f4的主从机的485通信，编写的modbus协议，能够实现主机向从机发送命令，和从机向主机发送数据，通过设定不同从机地址，读取不同从机的数据，两个stm32f4可以直连，可以直接使用，欢迎大家一起交流讨论
51单片机实现Modbus从机程序
04-24
51单片机实现Modbus从机程序 好用 可修改用于工业实际
STM32F407 MODBUS主从站工程.rar
05-01
实验目的：Modbus从站，使用RTU通过USB与PC机通信。 实验器材：MDK5，STM32CUBEMX，Modsbu_Tool(这个是PC端的modbus的主站) 实验软件平台：Keil5 实验硬件平台：ARM STM32F407
STM32F407 Mobbus RTU从站程序
10-20
基于正点原子STM32F407探索者开发板 Mobbus RTU从站程序，支持01 02 03 05 05 15命令, 使用的是串口2
基于stm32单片机实现modbus-rtu 通讯规约源码-有注释.zip
06-06
基于stm32单片机实现modbus-rtu 通讯规约源码-有注释 通讯数据的类型及格式： 信息传输为异步方式，并以字节为单位。每个字节由8位二进制数组成。主机和从机之间传递的通讯信息是10位的字格式： 字格式（串行数据） ...
STM32开发之Modbus协议之示例
scl8295的博客
02-26 2625
在这里使用控制台打印进行验证* @brief 发送驱动回调函数* @note 此函数可替换成STM32中的串口或网口进行发送i < len;++ i) {} /*** @brief 接收驱动回调函数* @note 此函数可替换成STM32中的串口或网口进行接收* @returnreturn 0;// 注册发送回调函数 Modbus_RegistrySendCallBack(send_driver);
高效实用的STM32 Modbus RTU主从机源码，支持单/多寄存器读写和配套上位机软件，代码注释详尽易理解
ASFHevkpn的博客
04-21 444
通过对主从机源码的详细解读，读者可以了解Modbus RTU通信协议的具体实现细节，包括寄存器的读写等操作。首先介绍Modbus RTU通信协议的基本原理和特点，然后详细解读STM32 Modbus RTU包主从机源码，包括单个和多个寄存器的写入和读取。stm32modbus RTU包主从机源码，支持单个多个寄存器的写入和读取，有相应的上位机软件，代码注释详细可读性强。关键词：STM32，Modbus RTU，通信协议，主从机，寄存器，上位机软件，源码注释。第二章：Modbus RTU通信协议概述。
stm32 modbus主机程序
04-30
STM32 Modbus主机程序是一个运行在STM32单片机上的Modbus通讯协议程序，该协议支持串口通信和TCP/IP网络通信。通过Modbus主机程序，STM32单片机可以作为Modbus主机与其他Modbus从机设备进行通讯，实现设备之间的数据交互。 在STM32 Modbus主机程序的实现过程中，需要对Modbus通讯协议进行解析和封装。具体实现包括在STM32单片机上实现Modbus协议的串口通信或TCP/IP网络通信，并对Modbus通讯协议进行解析和封装，实现数据的读或写操作。 在使用STM32 Modbus主机程序时，需要注意一些问题。首先，需要根据具体的Modbus从机设备进行配置，并确保通讯参数的正确性，包括从机地址、数据类型、寄存器地址等参数。其次，通讯过程中需要保证数据的正确性和完整性，并通过校验码等方式进行校验。 总的来说，STM32 Modbus主机程序可以为工业设备之间的通讯提供高效、可靠的解决方案，实现数据的实时传输和共享，有力地提升了工业生产过程的智能化和自动化水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值