ModbusSlave从机源码实现，支持多从机

最新推荐文章于 2025-03-12 09:01:59 发布

qq_40078712

最新推荐文章于 2025-03-12 09:01:59 发布

阅读量1.4k

点赞数 3

文章标签：单片机 c++ c语言

本文链接：https://blog.youkuaiyun.com/qq_40078712/article/details/129165743

版权

该代码实现了ModbusRTU协议的从机端，支持功能码01到0F，包括读线圈状态、读离散输入、读保持寄存器、读输入寄存器、写单个线圈、写单个保持寄存器等操作。代码中包含了CRC校验和STM32的串口接收示例，用于处理从机接收到的请求并生成响应。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

  支持多从机的modbus。网上看到很多modbusRTU从机代码不规范且缺少对应的功能码，所以自己写了*一个从机支持01 02 03 04 05 06 0F 10功能码。

```
 modbus.h文件代码如下：
```

*	#ifndef _MODBUSSLAVE_H
#define _MODBUSSLAVE_H
#define MODBUS_SLAVE_TX_RX_MAX_LEN  255
typedef struct
{
	unsigned char txBuff[MODBUS_SLAVE_TX_RX_MAX_LEN];
	unsigned char rxBuff[MODBUS_SLAVE_TX_RX_MAX_LEN];
	unsigned short rxTimerCnt;
	unsigned char sendCount;
	unsigned char rxTimerEnable;
	unsigned char rxRecvLen;
	unsigned char rxWriteIdx;
	unsigned char rxWriteLock;
	unsigned char slaveId;
	unsigned short timeout;
	unsigned char *reg01Ptr;
	unsigned char *reg02Ptr;
	short * reg03Ptr;
	short * reg04Ptr;
	short * reg05Ptr;
	short * reg06Ptr;
	short * reg10Ptr;
	unsigned char* reg0FPtr;
	unsigned char reg01Num;
	unsigned char reg02Num;
	unsigned char reg03Num;
	unsigned char reg04Num;
	unsigned char reg05Num;
	unsigned char reg06Num;
	unsigned char reg10Num;
	unsigned char reg0FNum;
	void (*SerialWrite)(unsigned char *buff,int length);
}ModbusSlaveObj_t;
//主循环运行
void MsProcess(ModbusSlaveObj_t * pObj);
//对象初始化
void MsInit(ModbusSlaveObj_t *pObj,unsigned char slaveId,unsigned short timeout,void (*SerialWrite)(unsigned char *buff,int length));
//串口读取
void MsSerialRead(ModbusSlaveObj_t * pObj,unsigned char *buff,int length);
//超时判断
void MsTimeout(ModbusSlaveObj_t * pObj);
//设置寄存器
void MsConfigureRegister(ModbusSlaveObj_t *pObj,unsigned char cmd,void *reg,unsigned char count);
//错误码定义
typedef enum
{
	MS_OK                          = 0x00,
	MS_Illegal_function 	    = 0x01,
	MS_Illegal_data_address = 0x02,
	MS_Illegal_data_value 	= 0x03,
	MS_Slave_device_failure = 0x04,
	MS_Slave_device_busy 	= 0x06,
	MS_CRC_check_failure 	= 0x0C,
}MsState;
#endif

modbus.c文件定义如下

	#include "modbus.h"
#include <string.h>
#define _MsGetUint16(A,B)  (unsigned short)((A[B] << 8) | A[B + 1])
#define _MsGetInt16(A,B)   (short)((A[B] << 8) | A[B + 1])
/*******************************************************************************
*功能：解锁接收队列
*******************************************************************************/
void _MsRxQueueUnLock(ModbusSlaveObj_t * pObj)
{
    pObj->rxWriteLock = 0;
    pObj->rxWriteIdx = 0;
    pObj->rxRecvLen = 0;
}
/*******************************************************************************
*功能：超时计数，放到定时器中运行，一般放到1ms中断足够满足要求
*******************************************************************************/
void MsTimeout(ModbusSlaveObj_t * pObj)
{
    if(pObj->rxTimerEnable)
    {
        if(pObj->rxTimerCnt < pObj->timeout)
        {
            pObj->rxTimerCnt++;
        }
        else
        {
            pObj->rxWriteLock = 1;
            pObj->rxTimerEnable = 0;
            pObj->rxTimerCnt = 0;
        }
    }
}
/*******************************************************************************
*功能：串口读取，放到中读取，一个字节读取也是可以的
*******************************************************************************/
void MsSerialRead(ModbusSlaveObj_t * pObj,unsigned char *buff,int length)
{
    int i = 0;
    if(pObj->rxWriteLock)
    {
        return;
    }
    length = length % MODBUS_SLAVE_TX_RX_MAX_LEN;
    pObj->rxTimerEnable = 1;
    pObj->rxTimerCnt = 0;
    for(i = 0; i < length; i++)
    {

        pObj->rxBuff[pObj->rxWriteIdx] = buff[i];
        if(pObj->rxWriteIdx < (MODBUS_SLAVE_TX_RX_MAX_LEN - 1))
        {
            pObj->rxWriteIdx++;
        }
    }
}
/* CRC余式表 */
const unsigned short crc_table[256] = {
    0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
    0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
    0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
    0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
    0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
    0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
    0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
    0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
    0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
    0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
    0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
    0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
    0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
    0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
    0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
    0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
    0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
    0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
    0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
    0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
    0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
    0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
    0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
    0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
    0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
    0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
    0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
    0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
    0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
    0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
    0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040,
};

/*******************************************************************************
*功能：CRC校验
*******************************************************************************/
unsigned short _MsCRC16(unsigned char *ptr, int len)
{
    unsigned short crc = 0xFFFF;

    while(len--)
    {
        crc = (crc >> 8) ^ crc_table[(crc ^ *ptr++) & 0xff];
    }

    return (crc);
}
/*******************************************************************************
*功能：对象初始化
*参数：pObj 对象 slaveId 从机号 timeout一帧超时时间 SerialWrite 写接口
*注意：timeout根据MsTimeout(ModbusSlaveObj_t * pObj)中断时间进行计算,如中断时间50us,要求一帧超时时间为3.7ms timeout = 3700 / 50
*******************************************************************************/
void MsInit(ModbusSlaveObj_t *pObj,unsigned char slaveId,unsigned short timeout,void (*SerialWrite)(unsigned char *buff,int length))
{
	int i = 0;
	char *p = (char *)(pObj);
	for(i = 0;i < sizeof(ModbusSlaveObj_t);i++)
	{
		p[i] = 0;
	}
	pObj->slaveId = slaveId;
	pObj->timeout = timeout;
	pObj->SerialWrite = SerialWrite;
}
/*******************************************************************************
*功能：设置寄存器
*参数：pObj 对象 cmd 命令 reg寄存器类型  count 寄存器个数
*注意：线圈类型均为unsigned char类型 一个字节代表一位 寄存器为16位有符号
*******************************************************************************/
void MsConfigureRegister(ModbusSlaveObj_t *pObj,unsigned char cmd,void *reg,unsigned char count)
{
    switch(cmd)
    {
    case 0x01:
        pObj->reg01Num = count;
        pObj->reg01Ptr = (unsigned char*)(reg);
        break;
    case 0x02:
        pObj->reg02Num = count;
        pObj->reg02Ptr = (unsigned char*)(reg);
        break;
    case 0x03:
        pObj->reg03Num = count;
        pObj->reg03Ptr = (short*)(reg);
        break;
    case 0x04:
        pObj->reg04Num = count;
        pObj->reg04Ptr = (short*)(reg);
        break;
    case 0x05:
        pObj->reg05Num = count;
        pObj->reg05Ptr = (short*)(reg);
        break;
    case 0x06:
        pObj->reg06Num = count;
        pObj->reg06Ptr = (short*)(reg);
        break;
    case 0x10:
        pObj->reg10Num = count;
        pObj->reg10Ptr = (short*)(reg);
        break;
    case 0x0F:
        pObj->reg0FNum = count;
        pObj->reg0FPtr = (unsigned char*)(reg);
        break;
    }
	
}
/*******************************************************************************
*功能：解析0x01命令
*******************************************************************************/
MsState _MsAnalyzeCmd01(ModbusSlaveObj_t *pObj)
{
	unsigned short count,addr;
	int i,j,idx = 0;
	addr = _MsGetUint16(pObj->rxBuff,2);
	count = _MsGetUint16(pObj->rxBuff,4);
	pObj->txBuff[0] = pObj->rxBuff[0];
	pObj->txBuff[1] = pObj->rxBuff[1];
	pObj->txBuff[2] = (count >> 3) + ((count % 8) > 0);
	if(addr + count > pObj->reg01Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg01Num == 0)
	{
		return MS_Illegal_function;
	}
	for(i = 0;i < pObj->txBuff[2];i++)
	{
		pObj->txBuff[i + 3] = 0;
		for(j = 0;j < 8;j++)
		{
			idx = (i << 3) + j;
			if(idx + addr > pObj->reg01Num)
			{
				break;
			}			
			if(pObj->reg01Ptr[addr + idx])
			{
				pObj->txBuff[i + 3] |= (0x01 << j);
			}
			else
			{
				pObj->txBuff[i + 3] &= ~(0x01 << j);
			}
		}
	}
	count = 3 + pObj->txBuff[2];
	addr =  _MsCRC16(pObj->txBuff,count);
	pObj->txBuff[count++] = (addr >> 0) & 0xFF;
	pObj->txBuff[count++] = (addr >> 8) & 0xFF;
	pObj->sendCount = count;
	return MS_OK;
}
/*******************************************************************************
*功能：解析0x02命令
*******************************************************************************/
MsState _MsAnalyzeCmd02(ModbusSlaveObj_t *pObj)
{
	unsigned short count,addr;
	int i,j,idx = 0;
	addr = _MsGetUint16(pObj->rxBuff,2);
	count = _MsGetUint16(pObj->rxBuff,4);
	pObj->txBuff[0] = pObj->rxBuff[0];
	pObj->txBuff[1] = pObj->rxBuff[1];
	pObj->txBuff[2] = (count >> 3) + ((count % 8) > 0);
	if(addr + count > pObj->reg02Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg02Num == 0)
	{
		return MS_Illegal_function;
	}
	for(i = 0;i < pObj->txBuff[2];i++)
	{
		pObj->txBuff[i + 3] = 0;
		for(j = 0;j < 8;j++)
		{
			idx = (i << 3) + j;
			if(idx + addr > pObj->reg02Num)
			{
				break;
			}
			if(pObj->reg02Ptr[addr + idx] )
			{
				pObj->txBuff[i + 3] |= (0x01 << j);
			}
			else
			{
				pObj->txBuff[i + 3] &= ~(0x01 << j);
			}
		}
	}
	count = 3 + pObj->txBuff[2];
	addr =  _MsCRC16(pObj->txBuff,count);
	pObj->txBuff[count++] = (addr >> 0) & 0xFF;
	pObj->txBuff[count++] = (addr >> 8) & 0xFF;
	pObj->sendCount = count;
	return MS_OK;
}
/*******************************************************************************
*功能：解析0x10命令
*******************************************************************************/
MsState _MsAnalyzeCmd10(ModbusSlaveObj_t *pObj)
{
	unsigned short count,addr;
	int i,j,idx = 0;
	addr = _MsGetUint16(pObj->rxBuff,2);
	count = _MsGetUint16(pObj->rxBuff,4);

	if(addr + count > pObj->reg10Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg10Num == 0)
	{
		return MS_Illegal_function;
	}
	j = 0;
	for(i = 0;i < count;i++)
	{
		pObj->reg10Ptr[addr + i] = _MsGetInt16(pObj->rxBuff,7 + j);
		j += 2;
	}
	pObj->txBuff[0] = pObj->rxBuff[0];
	pObj->txBuff[1] = pObj->rxBuff[1];
	pObj->txBuff[2] = pObj->rxBuff[2];
	pObj->txBuff[3] = pObj->rxBuff[3];
	pObj->txBuff[4] = pObj->rxBuff[4];
	pObj->txBuff[5] = pObj->rxBuff[5];
	addr =  _MsCRC16(pObj->txBuff,6);
	pObj->txBuff[6] = (addr >> 0) & 0xFF;
	pObj->txBuff[7] = (addr >> 8) & 0xFF;
	pObj->sendCount = 8;
	return MS_OK;
}
/*******************************************************************************
*功能：解析0x0F命令
*******************************************************************************/
MsState _MsAnalyzeCmd0F(ModbusSlaveObj_t *pObj)
{
	unsigned short count,addr,byteCount;
	int i,j,idx = 0;
	addr = _MsGetUint16(pObj->rxBuff,2);
	count = _MsGetUint16(pObj->rxBuff,4);
	byteCount = pObj->rxBuff[6];
	if(addr + count > pObj->reg0FNum)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg0FNum == 0)
	{
		return MS_Illegal_function;
	}
	for(i = 0;i < byteCount;i++)
	{
		
		for(j = 0;j < 8;j++)
		{
			idx = addr + (i << 3) + j;
			if(idx > (pObj->reg0FNum - 1))
			{
				break;
			}
			else
			{
				if((pObj->rxBuff[i + 7]) & (0x01 << j))
				{
					pObj->reg0FPtr[idx] = 1;
				}
				else
				{
					pObj->reg0FPtr[idx] = 0;
				}
			}
		}
	}
	pObj->txBuff[0] = pObj->rxBuff[0];
	pObj->txBuff[1] = pObj->rxBuff[1];
	pObj->txBuff[2] = pObj->rxBuff[2];
	pObj->txBuff[3] = pObj->rxBuff[3];
	pObj->txBuff[4] = pObj->rxBuff[4];
	pObj->txBuff[5] = pObj->rxBuff[5];
	pObj->txBuff[6] = pObj->rxBuff[6];
	addr =  _MsCRC16(pObj->txBuff,7);
	pObj->txBuff[7] = (addr >> 0) & 0xFF;
	pObj->txBuff[8] = (addr >> 8) & 0xFF;
	pObj->sendCount = 9;
	return MS_OK;
}
/*******************************************************************************
*功能：解析0x03命令
*******************************************************************************/
MsState _MsAnalyzeCmd03(ModbusSlaveObj_t *pObj)
{
	unsigned short count,addr;
	int i,idx = 0;
	addr = _MsGetUint16(pObj->rxBuff,2);
	count = _MsGetUint16(pObj->rxBuff,4);
	pObj->txBuff[idx++] = pObj->rxBuff[0];
	pObj->txBuff[idx++] = pObj->rxBuff[1];
	pObj->txBuff[idx++] = (count << 1) % 0xFF;
	if(addr + count > pObj->reg03Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg03Num == 0)
	{
		return MS_Illegal_function;
	}
	for(i = 0;i < count;i++)
	{
		 pObj->txBuff[idx++] = pObj->reg03Ptr[addr + i] >> 8;
		 pObj->txBuff[idx++] = pObj->reg03Ptr[addr + i] & 0xFF;
	}
	addr =  _MsCRC16(pObj->txBuff,idx);
	pObj->txBuff[idx++] = (addr >> 0) & 0xFF;
	pObj->txBuff[idx++] = (addr >> 8) & 0xFF;
	pObj->sendCount = idx;
	return MS_OK;
}
/*******************************************************************************
*功能：解析0x04命令
*******************************************************************************/
MsState _MsAnalyzeCmd04(ModbusSlaveObj_t *pObj)
{
	unsigned short count,addr;
	int i,idx = 0;
	addr = _MsGetUint16(pObj->rxBuff,2);
	count = _MsGetUint16(pObj->rxBuff,4);
	pObj->txBuff[idx++] = pObj->rxBuff[0];
	pObj->txBuff[idx++] = pObj->rxBuff[1];
	pObj->txBuff[idx++] = (count << 1) % 0xFF;
	if(addr + count > pObj->reg04Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg04Num == 0)
	{
		return MS_Illegal_function;
	}
	for(i = 0;i < count;i++)
	{
		 pObj->txBuff[idx++] = pObj->reg03Ptr[addr + i] >> 8;
		 pObj->txBuff[idx++] = pObj->reg03Ptr[addr + i] & 0xFF;
	}
	addr =  _MsCRC16(pObj->txBuff,idx);
	pObj->txBuff[idx++] = (addr >> 0) & 0xFF;
	pObj->txBuff[idx++] = (addr >> 8) & 0xFF;
	pObj->sendCount = idx;
	return MS_OK;
}

/*******************************************************************************
*功能：解析0x05命令
*******************************************************************************/
MsState _MsAnalyzeCmd05(ModbusSlaveObj_t *pObj)
{
unsigned short addr;
	int count = 1;
	addr = _MsGetUint16(pObj->rxBuff,2);
	if(addr + count > pObj->reg05Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg05Num == 0)
	{
		return MS_Illegal_function;
	}
	pObj->reg05Ptr[addr] = _MsGetInt16(pObj->rxBuff,4);
	pObj->txBuff[0] = pObj->rxBuff[0];
	pObj->txBuff[1] = pObj->rxBuff[1];
	pObj->txBuff[2] = pObj->rxBuff[2];
	pObj->txBuff[3] = pObj->rxBuff[3];
	pObj->txBuff[4] = pObj->rxBuff[4];
	pObj->txBuff[5] = pObj->rxBuff[5];
	pObj->txBuff[6] = pObj->rxBuff[6];
	pObj->txBuff[7] = pObj->rxBuff[7];
	pObj->sendCount = 8;
	return MS_OK;
}
/*******************************************************************************
*功能：解析0x06命令
*******************************************************************************/
MsState _MsAnalyzeCmd06(ModbusSlaveObj_t *pObj)
{
	unsigned short addr;
	int count = 1;
	addr = _MsGetUint16(pObj->rxBuff,2);
	if(addr + count > pObj->reg06Num)
	{
		return MS_Illegal_data_address;
	}
	if(pObj->reg06Num == 0)
	{
		return MS_Illegal_function;
	}
	pObj->reg06Ptr[addr] = _MsGetInt16(pObj->rxBuff,4);
	pObj->txBuff[0] = pObj->rxBuff[0];
	pObj->txBuff[1] = pObj->rxBuff[1];
	pObj->txBuff[2] = pObj->rxBuff[2];
	pObj->txBuff[3] = pObj->rxBuff[3];
	pObj->txBuff[4] = pObj->rxBuff[4];
	pObj->txBuff[5] = pObj->rxBuff[5];
	pObj->txBuff[6] = pObj->rxBuff[6];
	pObj->txBuff[7] = pObj->rxBuff[7];
	pObj->sendCount = 8;
	return MS_OK;
}
/*******************************************************************************
*功能：解析命令
*******************************************************************************/
void MsProcess(ModbusSlaveObj_t * pObj)
{
	MsState res;
	unsigned short crc,crc2;
    if(!pObj->rxWriteLock)
    {
        return;
    }
    if(pObj->rxWriteIdx < 4)
    {
        _MsRxQueueUnLock(pObj);
        return;
    }
    if(pObj->slaveId != pObj->rxBuff[0])
    {
        _MsRxQueueUnLock(pObj);
        return;
    }
    if(_MsCRC16(pObj->rxBuff,pObj->rxWriteIdx) != 0)
    {
		res = MS_CRC_check_failure;
		pObj->txBuff[1] += 128; 
		pObj->txBuff[2]  = res;
		crc = _MsCRC16(&pObj->txBuff[0],3);
		pObj->txBuff[3] = crc & 0xFF;
		pObj->txBuff[4] = (crc >> 8) & 0xFF;
		pObj->SerialWrite(pObj->txBuff,5);
        _MsRxQueueUnLock(pObj);
        return;
    }
    switch(pObj->rxBuff[1])
    {
		case 0x01:
			res = _MsAnalyzeCmd01(pObj);
			break;
		case 0x02:
			res = _MsAnalyzeCmd02(pObj);
			break;
		case 0x03:
			res = _MsAnalyzeCmd03(pObj);
			break;
		case 0x04:
			res = _MsAnalyzeCmd04(pObj);
			break;
		case 0x05:
			res = _MsAnalyzeCmd05(pObj);
			break;
		case 0x06:
			res = _MsAnalyzeCmd06(pObj);
			break;
		case 0x10:
			res = _MsAnalyzeCmd10(pObj);
			break;
		case 0x0F:
			res = _MsAnalyzeCmd0F(pObj);
			break;
		default :
			res = MS_Illegal_function;
			break;
    }
	if(res == MS_OK)
	{
		pObj->SerialWrite(pObj->txBuff,pObj->sendCount);
	}
	else
	{
		pObj->txBuff[1] += 128; 
		pObj->txBuff[2]  = res;
		crc = _MsCRC16(&pObj->txBuff[0],3);
		pObj->txBuff[3] = crc & 0xFF;
		pObj->txBuff[4] = (crc >> 8) & 0xFF;
		pObj->SerialWrite(pObj->txBuff,5);
	}
	 _MsRxQueueUnLock(pObj);
}

在stm32例程如下：

//线圈寄存器
unsigned char buff01[20];
//16位寄存器
short buff03[20];
//串口接收
unsigned char uart1Buff[200];
//声明一个对象
ModbusSlaveObj_t Ms1;
//串口发送接口
void SerialWrite(unsigned char *buff,int length)
{
	HAL_UART_Transmit(&huart1,buff,length,1000);
}
//DMA接收 ，改成中断接收也可以无非MsSerialRead接收长度为1
extern DMA_HandleTypeDef hdma_usart1_rx;
void USART1_IRQHandler(void)
{
	if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE))
	{
		__HAL_UART_CLEAR_IDLEFLAG(&huart1);
		int len = 200 - hdma_usart1_rx.Instance->CNDTR;
		HAL_UART_DMAStop(&huart1);
		MsSerialRead(&Ms1,uart1Buff,len);
		HAL_UART_Receive_DMA(&huart1,uart1Buff,200);
	}
}
//主循环
void ModbusTask(void* p)
{
	//ControlBeep(4);
	HAL_UART_Receive_DMA(&huart1,uart1Buff,200);
	//初始化对象
	MsInit(&Ms1,1,5,SerialWrite);
	//设置01寄存器的参数，不设置的话会返回无效的功能错误码
	MsConfigureRegister(&Ms1,0x01,buff01,sizeof(buff01));
	MsConfigureRegister(&Ms1,0x0F,buff01,sizeof(buff01));
	MsConfigureRegister(&Ms1,0x03,buff03,sizeof(buff03) / 2);
	MsConfigureRegister(&Ms1,0x06,buff03,sizeof(buff03) / 2);
	MsConfigureRegister(&Ms1,0x10,buff03,sizeof(buff03) / 2);
	MsConfigureRegister(&Ms1,0x05,buff03,sizeof(buff03) / 2);
	for(;;)
	{
		//解析循环
		MsProcess(&Ms1);
		vTaskDelay(5);
	}
}