STM32开发之Modbus协议(主站RTU)

最新推荐文章于 2024-07-24 22:27:20 发布
最新推荐文章于 2024-07-24 22:27:20 发布
阅读量8.1k 收藏 145
点赞数 14
分类专栏： Modbus协议 嵌入式学习 文章标签： stm32 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742767/article/details/129095054
版权

前言

在单片机方面，针对于通讯常用的协议之一modbus,这里将modbus协议和硬件之间的关系完全独立出来，硬件和协议之间的联系采用的是回调的方式进行一个关联。

说明

1、此协议可直接移植，并不需要关心硬件相关的。
2、modbus相关协议概念自行查找，本文只做代码的实现。

代码

宏定义（modbus_core_define）

modbus_core_define.h此头文件定义枚举和回调以及相关的功具类

#ifndef PROCOTOCOLBUILDPROJ_MODBUS_CORE_DEFINE_H
#define PROCOTOCOLBUILDPROJ_MODBUS_CORE_DEFINE_H

#include <stdint.h>
#include "stdio.h"

typedef enum {
	/**
	 * @brief 读线圈状态
	 */
	ReadCoilState = 0x1,
	/**
	 * @brief 读输入状态
	 */
	ReadInputState = 0x2,
	/**
	 * @brief 读保持寄存器
	 */
	ReadHoldReg = 0x3,
	/**
	 * @brief 读输入寄存器
	 */
	ReadInputReg = 0x4,
	/**
	 * @brief 写一个线圈
	 */
	WriteOneCoil = 0x05,
	/**
	 * @brief 写一个寄存器
	 */
	WriteOneReg = 0x06,
	/**
	 * @brief 写多个寄存器
	 */
	WriteMulReg = 0x10,
	/**
	 * @brief 写多个线圈
	 */
	WriteMulCoilsReg = 0x0F,
} Modbus_FuncCode_TypeDef;

typedef enum {
	// 非法数据
	InvalidDataErrorCode = 0x2,
	// 接收数据长度不正确
	RecDataLenErrorCode = 0xFF,

} Modbus_RecCode_TypeDef;
#define modbus_u8_to_u16(a, b) (uint16_t)((uint16_t)((a)<<8)+(b))
// 发送数据回调函数指针
typedef void (*SwSendDataCallBack)(void *data, uint16_t len);
// 接收数据回调函数指针
typedef uint16_t (*SwRecDataCallBack)(void *recDataBuf);

#endif //PROCOTOCOLBUILDPROJ_MODBUS_CORE_DEFINE_H

crc校验(modbus_core_crc)

头文件

#ifndef PROCOTOCOLBUILDPROJ_MODBUS_CORE_CRC_H
#define PROCOTOCOLBUILDPROJ_MODBUS_CORE_CRC_H

#include "modbus_core_define.h"

uint16_t Modbus_Crc_Compute(const uint8_t *buf, uint16_t bufLen);

#endif //PROCOTOCOLBUILDPROJ_MODBUS_CORE_CRC_H

源文件

#include "modbus_core_crc.h"

static uint16_t crcTb[];

/**
 * @brief Modbus crc计算
 * @param buf
 * @param bufLen
 * @return
 */
uint16_t Modbus_Crc_Compute(const uint8_t *buf, uint16_t bufLen) {
	uint8_t num;
	uint16_t modbus16 = UINT16_MAX;
	for (uint16_t index = 0; index < bufLen; ++index) {
		num = (uint8_t) (modbus16 & UINT32_MAX);
		modbus16 = (uint16_t) (((uint32_t) modbus16 >> 8) ^ crcTb[(num ^ buf[index]) & UINT8_MAX]);
	}
	return modbus16;
}


static uint16_t crcTb[] = {
		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
};

核心文件(modbus_core)

头文件

#ifndef PROCOTOCOLBUILDPROJ_MODBUS_CORE_H
#define PROCOTOCOLBUILDPROJ_MODBUS_CORE_H

#include "string.h"
#include "stdbool.h"
#include "modbus_core_define.h"
#include "modbus_core_crc.h"
#include "modbus_core_master.h"
#include "modbus_core_slave.h"

extern SwSendDataCallBack modbusSendCallBack;
extern SwRecDataCallBack modbusRecCallBack;

// 注册发送数据回调
__attribute__((unused)) void Modbus_RegistrySendCallBack(SwSendDataCallBack sendDataCallBack);
// 注册结束数据回调
__attribute__((unused)) void Modbus_RegistryRecCallBack(SwRecDataCallBack recDataCallBack);

/**
 * @brief 将bool型指针转字节数组
 * @param dst 存储转换的字节数据
 * @param data bool数据
 * @param dataLen 数据长度
 * @return
 */
uint16_t PackBoolArray(uint8_t *dst, const bool *data, uint16_t dataLen);

/**
 * @brief bool类型数组转字节数组
 * @param dst 存储
 * @param cnt 转换的个数
 * @param data 字节数据
 * @param dataLen 数据长度
 */
void UnPackBool(bool *dst, uint16_t cnt, const uint8_t *data, uint16_t dataLen);


#endif //PROCOTOCOLBUILDPROJ_MODBUS_CORE_H

源文件

#include "modbus_core.h"

// 发送数据回调指针
SwSendDataCallBack modbusSendCallBack = NULL;
// 接收数据回调指针
SwRecDataCallBack modbusRecCallBack = NULL;

/**
 * @brief 注册发送数据回调
 * @param sendDataCallBack
 */
__attribute__((unused)) void Modbus_RegistrySendCallBack(SwSendDataCallBack sendDataCallBack) {
	modbusSendCallBack = sendDataCallBack;
}

/**
 * @brief 注册接收数据回调
 * @param recDataCallBack
 */
__attribute__((unused)) void Modbus_RegistryRecCallBack(SwRecDataCallBack recDataCallBack) {
	modbusRecCallBack = recDataCallBack;
}

uint16_t PackBoolArray(uint8_t *dst, const bool *data, uint16_t dataLen) {
	uint8_t retLen = 0;
	uint8_t curDat = 0;
	uint8_t bitIdx = 0;
	for (int i = 0; i < dataLen; ++i) {
		if (data[i]) {
			curDat |= (uint8_t) (1 << bitIdx);
		}
		if (++bitIdx == 8) {
			dst[retLen++] = curDat;
			curDat = 0;
			bitIdx = 0;
		}
	}
	if (bitIdx != 8) {
		dst[retLen++] = curDat;
	}
	return retLen;
}

/**
 * @brief bool类型数组转字节数组
 * @param dst 存储
 * @param cnt 转换的个数
 * @param data 字节数据
 * @param dataLen 数据长度
 */
void UnPackBool(bool *dst, uint16_t cnt, const uint8_t *data, uint16_t dataLen) {
	uint16_t retLen = 0;
	uint8_t curDat = 0;
	uint8_t bitIdx = 0;
	for (int i = 0; i < dataLen; ++i) {
		curDat = data[i];

		for (int j = 0; j < 8; ++j) {
			if (cnt == 0) { return; };
			*dst++ = (curDat & (1 << j)) != 0;
			cnt--;
		}
	}
}

主站统一API接口(modbus_core_master)

头文件

#ifndef PROCOTOCOLBUILDPROJ_MODBUS_CORE_MASTER_H
#define PROCOTOCOLBUILDPROJ_MODBUS_CORE_MASTER_H

#include "stdio.h"
#include "stdint.h"

/**
 * @brief 06
 * @param slaveAddr
 * @param regAddr
 * @param val
 * @param errorCode 错误码，根据返回状态，如果正确,错误码不生效
 * @return
 */
bool Master_WriteOneRegister(uint8_t slaveAddr, uint16_t regAddr, uint16_t val, uint8_t *errorCode);

/**
 * @brief 10
 * @param slaveAddr
 * @param regAddr
 * @param data
 * @param dataLen
 * @param errorCode
 * @return
 */
bool Master_WriteMulRegister(uint8_t slaveAddr, uint16_t regAddr, uint8_t *data, uint16_t dataLen, uint8_t *errorCode);

/**
 * @brief 05
 * @param slaveAddr
 * @param regAddr
 * @param val
 * @param errorCode
 * @return
 */
bool Master_WriteOneCoil(uint8_t slaveAddr, uint16_t regAddr, bool val, uint8_t *errorCode);

/**
 * @brief 0F
 * @param slaveAddr
 * @param regAddr
 * @param val
 * @param dataLen
 * @param errorCode
 * @return
 */
bool Master_WriteMulCoil(uint8_t slaveAddr, uint16_t regAddr, bool *val, uint16_t dataLen, uint8_t *errorCode);

/**
 * @brief 读保持寄存器
 * @param slaveAddr
 * @param regAddr
 * @param regNum
 * @param retData 返回的数据（数据长度为寄存器个数*2）
 * @param errorCode
 * @return
 */
bool Master_ReadHoldRegisters(uint8_t slaveAddr, uint16_t regAddr, uint16_t regNum, uint8_t *retData, uint8_t *errorCode);

/**
 * @brief 读输入寄存器
 * @param slaveAddr
 * @param regAddr
 * @param regNum
 * @param retData 返回的数据（数据长度为寄存器个数*2）
 * @param errorCode
 * @return
 */
bool Master_ReadInputRegisters(uint8_t slaveAddr, uint16_t regAddr, uint16_t regNum, uint8_t *retData, uint8_t *errorCode);

/**
 * @brief 读线圈状态
 * @param slaveAddr
 * @param regAddr
 * @param regNum 寄存器个数
 * @param retData 返回的数据（数据长度为寄存器个数）
 * @param errorCode
 * @return
 */
bool Master_ReadCoilStatus(uint8_t slaveAddr, uint16_t regAddr, uint16_t regNum, uint8_t *retData, uint8_t *errorCode);

#endif //PROCOTOCOLBUILDPROJ_MODBUS_CORE_MASTER_H

源文件(RTU实现)

#include "modbus_core.h"
// 错误指令响应长度
#define ERROR_RESP_DATA_LEN (5)
// 错误响应码下标位置
#define ERROR_RESP_CODE_IDX (2)
#define MODBUS_PACKET_BUF_LEN (100)

// modbus 包缓存数组
static uint8_t modbus_packet_buf[MODBUS_PACKET_BUF_LEN] = {0};

static uint8_t core_build_packet(uint8_t slaveAddr, uint16_t regAddr, uint16_t val, uint8_t funcCode, uint8_t *retBuf);
/**
 * 从机地址(1)-功能码(1)-寄存器地址(2)--数据(2)-CRC(2)
 * @brief 写一个寄存器
 * @param slaveAddr 从机地址
 * @param regAddr 寄存器地址
 * @param val 值
 * @param errorCode 错误码
 * @return
 */
bool Master_WriteOneRegister(uint8_t slaveAddr, uint16_t regAddr, uint16_t val, uint8_t *errorCode) {
	bool retFlag = true;
	uint8_t idx = core_build_packet(slaveAddr, regAddr, val, WriteOneReg, modbus_packet_buf);
	modbusSendCallBack(modbus_packet_buf, idx);
	if (modbusRecCallBack != NULL) {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		if (recLen == idx && Modbus_Crc_Compute(modbus_packet_buf, recLen) == 0) {
		} else {
			retFlag = false;
			if (errorCode != NULL) {
				if (recLen == ERROR_RESP_DATA_LEN) {
					*errorCode = modbus_packet_buf[ERROR_RESP_CODE_IDX];
				} else {
					*errorCode = RecDataLenErrorCode; // 接收数据格式不争取
				}
			}
		}
	}

	return retFlag;
}
/**
 * 从机地址(1)-功能码(1)-寄存器地址(2)-寄存器个数(2)-字节数(1)-数据(n)-CRC(2)
 * @brief  串口协议包(0x10) 写多个寄存器
 * @param slaveAddr 从机地址
 * @param regAddr 寄存器地址
 * @param data 数据（长度为2的倍数）
 * @param dataLen 数据长度()
 * @param errorCode 错误码
 * @return
 */
bool Master_WriteMulRegister(uint8_t slaveAddr, uint16_t regAddr, uint8_t *data, uint16_t dataLen, uint8_t *errorCode) {
	uint8_t idx = 0;
	bool retFlag = true;
	modbus_packet_buf[idx++] = slaveAddr;
	modbus_packet_buf[idx++] = WriteMulReg;
	modbus_packet_buf[idx++] = (uint8_t) (regAddr >> 8);
	modbus_packet_buf[idx++] = (uint8_t) (regAddr);
	uint16_t regNum = (uint16_t) (dataLen / 2);
	modbus_packet_buf[idx++] = (uint8_t) (regNum >> 8);
	modbus_packet_buf[idx++] = (uint8_t) (regNum);
	modbus_packet_buf[idx++] = (uint8_t) (dataLen);
	for (int i = 0; i < dataLen; ++i) {
		modbus_packet_buf[idx++] = data[i];
	}
	uint16_t crc = Modbus_Crc_Compute(modbus_packet_buf, idx);
	modbus_packet_buf[idx++] = (uint8_t) (crc);
	modbus_packet_buf[idx++] = (uint8_t) (crc >> 8);
	modbusSendCallBack(modbus_packet_buf, idx);
	if (modbusRecCallBack != NULL) {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		if (recLen != 8 || Modbus_Crc_Compute(modbus_packet_buf, recLen) != 0) {
			retFlag = false;
			if (errorCode != NULL) {
				if (recLen == ERROR_RESP_DATA_LEN) {
					*errorCode = modbus_packet_buf[ERROR_RESP_CODE_IDX];
				} else {
					*errorCode = RecDataLenErrorCode; // 接收数据格式不争取
				}
			}
		}
	}
	return retFlag;
}

/**
 * 从机地址(1)-功能码(1)-寄存器地址(2)--数据(2)-CRC(2)
 * @brief 写一个线圈
 * @param slaveAddr 从机地址
 * @param regAddr 寄存器地址
 * @param val 值
 * @param errorCode 错误码
 * @return
 */
bool Master_WriteOneCoil(uint8_t slaveAddr, uint16_t regAddr, bool val, uint8_t *errorCode) {
	uint16_t data = val ? 0xFF00 : 0x0000;
	bool retFlag = true;
	uint8_t idx = core_build_packet(slaveAddr, regAddr, data, WriteOneCoil, modbus_packet_buf);
	modbusSendCallBack(modbus_packet_buf, idx);
	if (modbusRecCallBack != NULL) {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		if (recLen == idx && Modbus_Crc_Compute(modbus_packet_buf, recLen) == 0) {
		} else {
			retFlag = false;
			if (errorCode != NULL) {
				if (recLen == ERROR_RESP_DATA_LEN) {
					*errorCode = modbus_packet_buf[ERROR_RESP_CODE_IDX];
				} else {
					*errorCode = RecDataLenErrorCode; // 接收数据格式不争取
				}
			}
		}
	}
	return retFlag;
}
/**
 * @brief 写多个线圈
 * @param slaveAddr
 * @param regAddr
 * @param val
 * @param dataLen
 * @param errorCode
 * @return
 */
bool Master_WriteMulCoil(uint8_t slaveAddr, uint16_t regAddr, bool *val, uint16_t dataLen, uint8_t *errorCode) {
	uint8_t idx = 0;
	bool retFlag = true;
	// 计算数据占几个字节
	uint16_t realDataLen = PackBoolArray(modbus_packet_buf + 7, val, dataLen);
	modbus_packet_buf[idx++] = slaveAddr;
	modbus_packet_buf[idx++] = WriteMulCoilsReg;
	modbus_packet_buf[idx++] = (uint8_t) (regAddr >> 8);
	modbus_packet_buf[idx++] = (uint8_t) (regAddr);
	modbus_packet_buf[idx++] = (uint8_t) (dataLen >> 8);
	modbus_packet_buf[idx++] = (uint8_t) (dataLen);
	modbus_packet_buf[idx++] = (uint8_t) (realDataLen);
	idx += realDataLen;
	uint16_t crc = Modbus_Crc_Compute(modbus_packet_buf, idx);
	modbus_packet_buf[idx++] = (uint8_t) (crc);
	modbus_packet_buf[idx++] = (uint8_t) (crc >> 8);
	modbusSendCallBack(modbus_packet_buf, idx);
	if (modbusRecCallBack != NULL) {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		if (recLen == idx && Modbus_Crc_Compute(modbus_packet_buf, recLen) == 0) {
		} else {
			retFlag = false;
			if (errorCode != NULL) {
				if (recLen == ERROR_RESP_DATA_LEN) {
					*errorCode = modbus_packet_buf[ERROR_RESP_CODE_IDX];
				} else {
					*errorCode = RecDataLenErrorCode; // 接收数据格式不争取
				}
			}
		}
	}
	return retFlag;
}
/**
 * @brief 读保持寄存器
 * @param slaveAddr
 * @param regAddr
 * @param regNum
 * @param retData
 * @param errorCode
 * @return
 */
bool Master_ReadHoldRegisters(uint8_t slaveAddr, uint16_t regAddr, uint16_t regNum, uint8_t *retData, uint8_t *errorCode) {
	bool retFlag = true;
	uint8_t packetLen = core_build_packet(slaveAddr, regAddr, regNum, ReadHoldReg, modbus_packet_buf);
	modbusSendCallBack(modbus_packet_buf, packetLen);
	if (modbusRecCallBack == NULL) {
		// todo 回调未注册
		return false;
	} else {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		// 验证CRC
		if (Modbus_Crc_Compute(modbus_packet_buf, recLen) == 0) {
			if (recLen == ERROR_RESP_DATA_LEN) {
				retFlag = false;
				if (errorCode != NULL) *errorCode = modbus_packet_buf[2];
			} else {
				// todo 拷贝数据
				uint8_t cpyDataLen = modbus_packet_buf[2];
				memcpy(retData, modbus_packet_buf + 3, cpyDataLen);
			}
		} else {
			// CRC 不正确
			return false;
		}
	}
	return retFlag;
}
/**
 * @brief
 * @param slaveAddr
 * @param regAddr
 * @param regNum
 * @param retData
 * @param errorCode
 * @return
 */
bool Master_ReadInputRegisters(uint8_t slaveAddr, uint16_t regAddr, uint16_t regNum, uint8_t *retData, uint8_t *errorCode) {
	bool retFlag = true;
	uint8_t packetLen = core_build_packet(slaveAddr, regAddr, regNum, ReadInputReg, modbus_packet_buf);
	modbusSendCallBack(modbus_packet_buf, packetLen);
	if (modbusRecCallBack == NULL) {
		// todo 回调未注册
		return false;
	} else {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		// 验证CRC
		if (Modbus_Crc_Compute(modbus_packet_buf, recLen) == 0) {
			if (recLen == ERROR_RESP_DATA_LEN) {
				retFlag = false;
				if (errorCode != NULL) *errorCode = modbus_packet_buf[2];
			} else {
				// todo 拷贝数据
				uint8_t cpyDataLen = modbus_packet_buf[2];
				memcpy(retData, modbus_packet_buf + 3, cpyDataLen);
			}
		} else {
			// CRC 不正确
			return false;
		}
	}
	return retFlag;
}

bool Master_ReadCoilStatus(uint8_t slaveAddr, uint16_t regAddr, uint16_t regNum, uint8_t *retData, uint8_t *errorCode) {
	bool retFlag = true;
	uint8_t packetLen = core_build_packet(slaveAddr, regAddr, regNum, ReadHoldReg, modbus_packet_buf);
	modbusSendCallBack(modbus_packet_buf, packetLen);
	if (modbusRecCallBack == NULL) {//  回调未注册

		return false;
	} else {
		uint16_t recLen = modbusRecCallBack(modbus_packet_buf);
		// 验证CRC
		if (Modbus_Crc_Compute(modbus_packet_buf, recLen) == 0) {
			if (recLen == ERROR_RESP_DATA_LEN) {
				retFlag = false;
				if (errorCode != NULL) *errorCode = modbus_packet_buf[2];
			} else {
				// todo 拷贝数据
				uint8_t cpyDataLen = modbus_packet_buf[2];
				memcpy(retData, modbus_packet_buf + 3, cpyDataLen);
			}
		} else {
			// CRC 不正确
			return false;
		}
	}
	return retFlag;
}


static uint8_t core_build_packet(uint8_t slaveAddr, uint16_t regAddr, uint16_t val, uint8_t funcCode, uint8_t *retBuf) {
	uint8_t idx = 0;
	retBuf[idx++] = slaveAddr;
	retBuf[idx++] = funcCode;
	retBuf[idx++] = (uint8_t) (regAddr >> 8);
	retBuf[idx++] = (uint8_t) (regAddr);
	retBuf[idx++] = (uint8_t) (val >> 8);
	retBuf[idx++] = (uint8_t) (val);
	uint16_t crc = Modbus_Crc_Compute(retBuf, idx);
	retBuf[idx++] = (uint8_t) (crc);
	retBuf[idx++] = (uint8_t) (crc >> 8);
	return idx;
}

结尾

1、此代码可直接移植到单片机工程，不受硬件相关的配置

詩不诉卿
关注
  • 14
    点赞
  • 踩
  • 145
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
MODBUS-RTU协议主机和从机代码STM32
m0_64634370的博客
11-29 2495
MODBUS-RTU协议主机和从机代码STM32 包含2个程序代码，主机和从机（我代码最容易看懂） 基于温度传感器DS18B20的MODBUS-RTU从机 主机发送指令：01 03 20 00 00 01 8F CA 从机收到指令返回温度数据 06指令修改Add通信地址/站号和波特率 主机代码，主动发03指令读其它设备数据并把返回用数码管显示 程序代码包含：stm32单片机（stm32f103vet6） 我的代码是最容易看懂的 很多人想要很多功能号 实现原理就是用if判断数据帧有点区别，所以学会一条功能
STM32开发之Modbus协议(主站和从站)
08-09
在STM32中实现Modbus主站，你需要编写代码来构建和解析Modbus请求和响应报文。主站负责发起通信，向从站发送读/写请求，并接收从站的回应。这涉及到对CRC校验码的计算和帧同步的处理。例如，你可以使用STM32的串口...
通过stm32来实现modbus协议，作为主站实现的，实现对寄存器的单读单写多读多写
01-31
通过stm32来实现modbus协议，作为主站实现的，实现对寄存器的单读单写多读多写，想通过stm32来实现modbus协议的同学可以下载了，相互学习一下.zip
stm32f103re modbus主站和从站例程
01-06
stm32f103re modbus rtu主站和从站例程，采用RS485通信，串口接收采用队列方式实现，modbus指令很完整，包括常用的读写指令01H,02H,03H,04H,06H,10H 【EWARMv6】 IAR公司EWARM工程文件夹 【MDK-ARM(uV4)】KEIL的MDK工程文件，uVision4版本。 output(mdk).hex - 采用KEIL MDK编译好的可执行文件(定位在CPU内部Flash执行)，可以直接下载到CPU内部Flash执行。 output(iar).hex - 采用IAR EWARM编译好的可执行文件(定位在CPU内部Flash执行)，，可以直接下载到CPU内部Flash执行。
stm32编写Modbus步骤
robin__su的博客
06-09 548
（1）分析板子的具体信息，编写不同的设备结构体，比如只读的结构体，可读写的结构体，保存配置信息的结构体（当主机发送改变配置信息的消息帧时，会改变相应的变量，并写入flash）（3）根据上一步获取的从机寄存器地址，对保持寄存器的指针进行偏移指向，即指向不同信息结构体的首地址，此过程判断寄存器地址是否溢出。会首先进行处理在串口数据中找出符合要求，接收正确的数据帧，并记录其功能码，输出帧的真实地址，就可以得到主机想要操作的从机的寄存器地址。（2） modbus寄存器映射，定义保持寄存器的指针；
STM32 MODBUS主机程序
05-07
最近在学习使用MODBUS协议，这里有一份STM32_MODBUS_Master完整程序想跟大家分享下，一起学习，一起进步。
STM32 Modbus通信学习笔记—— 代码及示例
热门推荐
qq_41954556的博客
03-06 1万+
STM32 通过modbus与维控屏通信
STM32开发之Modbus协议(RTU从站)
scl8295的博客
02-27 2367
*** @brief 读线圈状态* @brief 读输入状态* @brief 读保持寄存器* @brief 读输入寄存器* @brief 写一个线圈* @brief 写一个寄存器* @brief 写多个寄存器* @brief 写多个线圈// 非法数据 InvalidDataErrorCode = 0x2 , // 接收数据长度不正确 RecDataLenErrorCode = 0xFF , } Modbus_RecCode_TypeDef;/*** @brief 读线圈状态。
STM32开发之Modbus协议之示例
scl8295的博客
02-26 2657
在这里使用控制台打印进行验证* @brief 发送驱动回调函数* @note 此函数可替换成STM32中的串口或网口进行发送i < len;++ i) {} /*** @brief 接收驱动回调函数* @note 此函数可替换成STM32中的串口或网口进行接收* @returnreturn 0;// 注册发送回调函数 Modbus_RegistrySendCallBack(send_driver);
2021-06-11 STM32的MODBUS RTU 主站通讯
jacklood的博客
06-11 1692
一、STM32的TFTLCD实验、
基于STM32F407单片机的modbusRTU协议主机代码
05-29
在STM32F407单片机上实现Modbus RTU协议的主机程序，你需要遵循Modbus RTU的通信规范，并使用STM32的硬件资源来编写代码。以下是一个基本的步骤和代码示例，用于在STM32F407上实现Modbus RTU主机功能。 1. 硬件准备...
MODBUS- 485SLAVER.rar_STM32F103_modbus 485_modbus主站_rtu_串口 超时
07-15
本例程为 RS485 MODBUS 主站例程。可以通过按键发送相应的 MODBUS 命令，然后等待从站应答 （或超时）退出等待。 程序使用串口 3（ USART1）与从机通讯，执行结果通过串口 1（ USART1）送到计算机的串口。可以 通过 ...
STM32 modbus协议实现例程
05-06
STM32 Modbus协议实现例程是一套专为STM32微控制器设计的代码库，旨在帮助开发者在项目中快速集成Modbus通信功能。Modbus是一种广泛应用的工业通信协议，尤其在PLC（可编程逻辑控制器）和嵌入式系统之间进行数据交换...
STM32实现基于RS485的简单的Modbus协议
大牛攻城狮的专栏
05-21 8303
这里用STM32实现，其实可以搬移到其他MCU，之前有项目使用STM32实现Modbus协议这个场景比较正常，很多时候都能碰到这里主要是Modbus和变频器通信最常见的是使用Modbus实现传感器数据的采集，我记得之前用过一些传感器都是Modbus协议这就需要MCU实现Modbus协议，不过实际使用的Modbus协议往往都是简化版本的可能只是几条Modbus协议格式的指令而已初学者，网上一搜Modubus协议，往往越看越糊涂。
STM32F103C8T6的MODBUS-RTU通讯（485通讯）
wshl_2018的博客
11-23 4837
STM32F103C8T6的MODBUS-RTU通讯（485通讯） 附上源码与所有资料！！！！！
STM32智能医疗监控系统教程
stm32d1219的博客
07-21 1229
本教程详细介绍了如何在STM32嵌入式系统中实现智能医疗监控系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能医疗监控系统。
韦东山嵌入式linux系列-具体单板的按键驱动程序(查询方式)
最新发布
StudyWinter的博客
07-24 948
button_operations 结 构 体 中 有 init 函 数 指 针 ， 它 指 向board_stm32mp157_button_init 函数，在里面将会初始化 LED 引脚：使能、设置为 GPIO 模式、设置为输出引脚。该寄存器共32位，涉及16个GPIO，每个GPIO对应 2 位。button_operations 结 构 体 中 还 有 有 read 函 数 指 针 ， 它 指 向board_stm32mp157_button_read 函数，在里面将会读取并返回按键引脚的电平。
STM32嵌入式人工智能边缘计算应用教程
2401_84204806的博客
07-23 819
本教程详细介绍了如何在STM32嵌入式系统中实现嵌入式人工智能边缘计算系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的嵌入式人工智能边缘计算系统。
stm32 modbus rtu主站
08-10
STM32是一款常用的微控制器，具有强大的处理能力和丰富的外设，适用于各种应用场景。Modbus RTU是一种常见的串行通信协议，常用于工业自动化领域中设备之间的通信。 STM32可以作为Modbus RTU主站，与其他Modbus RTU从站设备进行通信。作为主站，STM32负责发送命令、接收从站设备的响应，并处理数据。 要实现STM32作为Modbus RTU主站，需要进行以下几个步骤： 1. 硬件连接：将STM32的串口引脚与Modbus RTU从站设备的串口通信引脚连接，确保物理连接正确。 2. 配置串口：在STM32的软件开发环境中，配置串口的参数，包括波特率、数据位、停止位等，以保证与从站设备的通信参数一致。 3. 编写主站程序：在STM32的主控程序中，使用相应的Modbus RTU协议库，通过串口发送命令给从站设备，并接收响应。根据需求，可以编写不同的功能模块，例如读取寄存器、写入寄存器等。 4. 解析响应数据：主站程序接收到从站设备的响应后，需要解析数据，并进行相应的处理。可以根据具体的应用需求，将数据存储到内存中、显示在LCD屏幕上或者通过其他方式进行处理。 使用STM32作为Modbus RTU主站可以实现与各种从站设备的通信，例如传感器、执行器等。它可以实现数据的采集、控制和监测，广泛应用于自动化控制系统、智能家居系统等领域。利用STM32的强大功能和Modbus RTU协议的灵活性，可以实现更多的高级功能和自定义需求。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

詩不诉卿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值