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

最新推荐文章于 2024-07-01 16:29:33 发布
最新推荐文章于 2024-07-01 16:29:33 发布
阅读量2.4k 收藏 41
点赞数 4
分类专栏： 嵌入式学习 Modbus协议 文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742767/article/details/129250458
版权
本文档提供了一个RTU从站协议的实现，包括读取线圈状态、寄存器等操作，并使用CRC校验确保数据完整性。代码中定义了功能码枚举、错误码、数据处理函数以及从站接口函数，实现了从站的基本功能并提供了错误处理机制。
摘要由CSDN通过智能技术生成

RTU从站协议

说明

1、本文不做协议格式的讲解，只做实现，如需了解协议格式，自行搜索
2、本文不依赖于硬件相关的资源，建立在硬件通讯之上，通过回调的形式和对应的硬件进行关联
3、相关协议内容参照，上一篇RTU主站

代码

宏定义（modbus_core_define）

#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 "slave_rtu.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接口(slave_rtu)

头文件

#ifndef PROCOTOCOLBUILDPROJ_SLAVE_RTU_H
#define PROCOTOCOLBUILDPROJ_SLAVE_RTU_H

#include "modbus_core_define.h"


typedef enum {
	RSP_OK = 0x0,
	// 不支持的功能码
	RSP_ERR_CMD = 0x1,
	// 寄存器地址错误
	RSP_ERR_REG_ADDR = 0x2,
	// 数据值域错误
	RSP_ERR_VALUE = 0x3,
	// 写入失败
	RSP_ERR_WRITE = 0x4,
} Slave_Rsp_Code;

/**
 * @brief 从机地址
 * @param addr
 */
void Modbus_Poll_Init(uint8_t addr);

/**
 * @brief 主调用函数
 * @param data
 * @param len
 */
void Modbus_Poll(uint8_t *data, uint16_t len);

/**
 * @brief
 * @param regAddr
 * @param regNum
 * @param retData
 */
Slave_Rsp_Code Slave_ReadHoldReg(uint16_t regAddr, uint16_t regNum, uint8_t *retData);

/**
 * @brief 0x4
 * @param regAddr
 * @param regNum
 * @param retData
 * @return
 */
Slave_Rsp_Code Slave_ReadInputReg(uint16_t regAddr, uint16_t regNum, uint8_t *retData);

/**
 * @brief 读取线圈状态
 * @param regAddr
 * @param regNum 单字节个数
 * @param retData
 * @return
 */
Slave_Rsp_Code Slave_ReadCoilState(uint16_t regAddr, uint16_t regNum, bool *retData);

/**
 * @brief 读取输入状态
 * @param regAddr
 * @param regNum 单字节个数
 * @param retData
 * @return
 */
Slave_Rsp_Code Slave_ReadInputState(uint16_t regAddr, uint16_t regNum, bool *retData);

/**
 * @brief 写一个寄存器
 * @param regAddr
 * @param data
 * @return
 */
Slave_Rsp_Code Slave_WriteOneReg(uint16_t regAddr, uint16_t data);

/**
 * @brief 连续写多个寄存器
 * @param regAddr
 * @param regNum
 * @param data
 * @return
 */
Slave_Rsp_Code Slave_WriteMulReg(uint16_t regAddr, uint16_t regNum, uint8_t *data);

/**
 * @brief 写多个寄存器
 * @param regAddr
 * @param regNum 单字节个数
 * @param data
 * @return
 */
Slave_Rsp_Code Slave_WriteMulCoilsReg(uint16_t regAddr, uint16_t regNum, bool *data);

/**
 * @brief 写一个线圈寄存器
 * @param regAddr
 * @param val
 * @return
 */
Slave_Rsp_Code Slave_WriteOneCoil(uint16_t regAddr, bool val);

#endif //PROCOTOCOLBUILDPROJ_SLAVE_RTU_H

源文件

#include "modbus_core.h"
#include "slave_rtu.h"


#define FIX_MIN_DATA_LEN 8
typedef struct {
	uint8_t slaveAddr;
	uint8_t funcCode;
	uint8_t regAddr;
	uint8_t regNum;
	uint8_t *data;
	uint16_t dataLen;
} slave_packet_t;
static uint8_t slaveAddr = 1;
static uint8_t modbus_slave_buf[256] = {0};
static bool status_buf[256] = {0};
static slave_packet_t packet;

static void core_slave_data_parse(uint8_t *data, uint16_t len, slave_packet_t *ptr);

static uint16_t core_build_err_resp(uint8_t code, slave_packet_t *pkt, uint8_t *retData);

static uint8_t core_slave_read(uint8_t funcCode, uint16_t regAddr, uint16_t regNum, uint8_t *retData);

void Modbus_Poll_Init(uint8_t addr) {
	slaveAddr = addr;
}

/**
 * @brief 添加crc
 * @param retData
 * @param len
 * @return
 */
uint16_t add_crc(uint8_t *retData, uint16_t len) {
	uint16_t crc = Modbus_Crc_Compute(modbus_slave_buf, len);
	modbus_slave_buf[len++] = crc;
	modbus_slave_buf[len++] = crc >> 8;
	return len;
}

void Modbus_Poll(uint8_t *data, uint16_t len) {
	if (len < FIX_MIN_DATA_LEN) return;
	if (slaveAddr != data[0] || Modbus_Crc_Compute(data, len) != 0) return;
	core_slave_data_parse(data, len, &packet);
	uint16_t rspLen = 0;
	uint8_t respCode = RSP_OK;
	// 获取功能码
	switch (packet.funcCode) {

		case ReadHoldReg: // 0x3
		case ReadInputReg: // 0x4
			modbus_slave_buf[rspLen++] = packet.slaveAddr;
			modbus_slave_buf[rspLen++] = packet.funcCode;
			modbus_slave_buf[rspLen++] = packet.regNum * 2;
			respCode = core_slave_read(packet.funcCode, packet.regAddr, packet.regNum, modbus_slave_buf + rspLen);
			if (respCode == RSP_OK) {
				rspLen += (packet.regNum * 2);
				rspLen = add_crc(modbus_slave_buf, rspLen);
			}
			break;
		case ReadCoilState:
		case ReadInputState:
			// 01 01 00 01 00 01 AC 0A
			// 01 01 00 01 00 0A ED CD
			modbus_slave_buf[rspLen++] = packet.slaveAddr;
			modbus_slave_buf[rspLen++] = packet.funcCode;
			// 返回的字节数
			if (packet.regNum % 8 == 0) {
				modbus_slave_buf[rspLen++] = packet.regNum / 8;
			} else {
				modbus_slave_buf[rspLen++] = packet.regNum / 8 + 1;
			}
			if (packet.funcCode == ReadCoilState) {
				respCode = Slave_ReadCoilState(packet.regAddr, packet.regNum, status_buf);
			} else {
				respCode = Slave_ReadInputState(packet.regAddr, packet.regNum, status_buf);
			}
			if (respCode == RSP_OK) {
				uint16_t cnt = PackBoolArray(modbus_slave_buf + rspLen, status_buf, packet.regNum);;
				rspLen += cnt;
				rspLen = add_crc(modbus_slave_buf, rspLen);
			}
			break;

		case WriteOneReg: // 0x06
			respCode = Slave_WriteOneReg(packet.regAddr, modbus_u8_to_u16(packet.data[0], packet.data[1]));
			if (respCode == RSP_OK) {
				modbusSendCallBack(data, len);
				return;
			}
			break;
		case WriteMulReg: // 0x10
		case WriteMulCoilsReg:
			if (packet.funcCode == WriteMulCoilsReg) {
				UnPackBool(status_buf, packet.regNum, packet.data, packet.dataLen);
				respCode = Slave_WriteMulCoilsReg(packet.regAddr, packet.regNum, status_buf);
			} else {
				respCode = Slave_WriteMulReg(packet.regAddr, packet.regNum, packet.data);

			}

			if (respCode == RSP_OK) {
				modbus_slave_buf[rspLen++] = packet.slaveAddr;
				modbus_slave_buf[rspLen++] = packet.funcCode;
				modbus_slave_buf[rspLen++] = packet.regAddr >> 8;
				modbus_slave_buf[rspLen++] = packet.regAddr;
				modbus_slave_buf[rspLen++] = packet.regNum >> 8;
				modbus_slave_buf[rspLen++] = packet.regNum;
				rspLen = add_crc(modbus_slave_buf, rspLen);
				modbusSendCallBack(modbus_slave_buf, rspLen);
				return;
			}
			break;
			bool stat;
		case WriteOneCoil:
			stat = modbus_u8_to_u16(*packet.data, *(packet.data + 1)) == 0xFF;
			respCode = Slave_WriteOneCoil(packet.regAddr, stat);
			if (respCode == RSP_OK) {
				modbusSendCallBack(modbus_slave_buf, rspLen);
				return;
			}
			break;
	}
	// 错误响应
	if (respCode != RSP_OK) {
		rspLen = core_build_err_resp(respCode, &packet, modbus_slave_buf);
	}
	modbusSendCallBack(modbus_slave_buf, rspLen);
}

/**
 * @brief 核心数据封装
 * @param funcCode
 * @param regAddr
 * @param regNum
 * @param retData
 * @return
 */
uint8_t core_slave_read(uint8_t funcCode, uint16_t regAddr, uint16_t regNum, uint8_t *retData) {
	switch (funcCode) {
		case ReadHoldReg:
			return Slave_ReadHoldReg(packet.regAddr, packet.regNum, retData);
		case ReadInputReg:
			return Slave_ReadInputReg(packet.regAddr, packet.regNum, retData);
	}
	return 0;
}

/**
 * @brief 数据长度
 * @param data
 * @param len
 * @param ptr
 */
static void core_slave_data_parse(uint8_t *data, uint16_t len, slave_packet_t *ptr) {
	uint8_t idx = 0;
	ptr->slaveAddr = data[idx++];
	ptr->funcCode = data[idx++];
	ptr->regAddr = modbus_u8_to_u16(data[idx++], data[idx++]);
	switch (ptr->funcCode) {
		case ReadHoldReg:
		case ReadInputReg:
		case ReadCoilState:
		case ReadInputState:
			ptr->regNum = modbus_u8_to_u16(data[idx++], data[idx++]);
			break;
		case WriteOneReg:
		case WriteOneCoil:
			ptr->data = data + idx;
			ptr->dataLen = 2;
			break;
		case WriteMulReg:
		case WriteMulCoilsReg:
			ptr->regNum = modbus_u8_to_u16(data[idx++], data[idx++]);
			ptr->dataLen = data[idx++];
			ptr->data = data + idx;
			break;
	}
}

/**
 * @brief 
 * @param code 
 * @param pkt 
 * @param retData 
 * @return 
 */
static uint16_t core_build_err_resp(uint8_t code, slave_packet_t *pkt, uint8_t *retData) {
	uint8_t idx = 0;
	retData[idx++] = pkt->slaveAddr;
	retData[idx++] = pkt->funcCode | 0x80;
	retData[idx++] = 2;
	uint16_t crc = Modbus_Crc_Compute(retData, idx);
	retData[idx++] = crc;
	retData[idx++] = crc >> 8;
	return idx;
}

uint16_t reg_start_addr = 0x000;
uint8_t reg_buf[200] = {0, 1};

/**
 * @brief 读寄存器
 * @param regAddr
 * @param regNum
 * @param retData
 * @return
 */
Slave_Rsp_Code Slave_ReadHoldReg(uint16_t regAddr, uint16_t regNum, uint8_t *retData) {
	if (regAddr < reg_start_addr) {
		return RSP_ERR_REG_ADDR;
	} else {
		memcpy(retData, reg_buf, regNum * 2);
		return RSP_OK;
	}

}/***************************************************************具体实现********************************************************/
/**
 * @brief 读取输入寄存器
 * @param regAddr
 * @param regNum
 * @param retData
 * @return
 */
Slave_Rsp_Code Slave_ReadInputReg(uint16_t regAddr, uint16_t regNum, uint8_t *retData) {
	return 0;
}

Slave_Rsp_Code Slave_ReadCoilState(uint16_t regAddr, uint16_t num, bool *retData) {
	printf_s("Slave_ReadCoilState reg: %X; num:%d\n", regAddr, num);
	for (int i = 0; i < num; ++i) {
		retData[i] = true;
	}
	return RSP_OK;
}

Slave_Rsp_Code Slave_ReadInputState(uint16_t regAddr, uint16_t regNum, bool *retData) {
	printf_s("Slave_ReadInputState reg: %X; num:%d\n", regAddr, regNum);
	return RSP_OK;
}

Slave_Rsp_Code Slave_WriteOneReg(uint16_t regAddr, uint16_t data) {
	printf_s("reg: %X; val:%d\n", regAddr, data);
	return RSP_ERR_REG_ADDR;
}

Slave_Rsp_Code Slave_WriteMulReg(uint16_t regAddr, uint16_t regNum, uint8_t *data) {
	uint8_t idx = 0;
	for (int i = 0; i < regNum; ++i) {
		printf("val:%d\n", modbus_u8_to_u16(data[idx++], data[idx++]));
	}
	return RSP_OK;
}

Slave_Rsp_Code Slave_WriteMulCoilsReg(uint16_t regAddr, uint16_t regNum, bool *data) {
	printf_s("Slave_WriteMulCoilsReg reg: %X; num:%d\n", regAddr, regNum);
	return RSP_OK;
}

Slave_Rsp_Code Slave_WriteOneCoil(uint16_t regAddr, bool val) {
	return RSP_ERR_REG_ADDR;
}

结尾

1、此代码已测试，无问题。后续更新测试用例

詩不诉卿
关注
专栏目录
STM32 MODBUS_RTU从站程序，KEIL编写
08-09
STM32 做的modbus_rtu程序，使用KEIL编写，没有移植FREEMODBUS,适合搞MODBUS协议开发的朋友
STM32作从机实现简单的Modbus RTU协议
04-04
STM32作从机实现简单的Modbus RTU协议，完整的代码，请下载附件,注意选择上位机调试助手最好用modscan32，我的代码也是在这个软件做主设备，调试通过的。
STM32F103-Modbus_RTU-slave-RS485
07-04
STM32F103-Modbus_RTU-slave-RS485，移植FreeModbus工作于STM32F103RTC6中
STM32——Modbus协议
最新发布
qq_23339307的博客
07-01 1656
CRC即循环冗余校验码，是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（CRC）是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。
基于STM32以及modbus——RTU的从机程序（STM32作为从机）
weixin_45739317的博客
04-24 6202
Modbus协议是一种应用层报文传输协议，协议本身并没有定义物理层，所以支持多种电气接口，直接可以理解成他是软件层面的，各种的电气接口比如RS232、RS485、TCP/IP等，他们是硬件层面。他们之间互不影响。3.2 Modbus通讯过程Modbus是一主多从的通信协议Modbus通信中只有一个设备可以发送请求。其他从设备接收主机发送的数据来进行响应，从机是任何外围设备，如I/O传感器，阀门，网络驱动器，或其他测量类型的设备。从站处理信息和使用Modbus将其数据发送给主站。
STM32：Modbus-RTU通讯协议
MQ0522的博客
06-24 8972
Modbus是一种串行通信协议，是Modicon公司（现在的施耐德电气 Schneider Electric）于1979年为使用可编程逻辑控制器（PLC）通信而发表。Modbus已经成为工业领域通信协议的业界标准（De facto），并且现在是工业电子设备之间常用的连接方式。 一、Modbus-RTU报文格式 设备地址 功能码 数据区 CRC校验 1个字节 1个字节 N个字节 2 个字节(16 位循环冗余校验码) 注：1 个字节由 8 位二进制组成，即 8 bits。 1. 设备地址
用KEIL编写的MODBUS_RTU从站程序（STM32）
07-16
自己编写的MODBUS_RTU从站程序（STM32），目前测试还行，共享了吧，有学哟啊的朋友，请下载！
用c语言写一个modbus RTU 从站的程序
SYUSYORIN的博客
03-15 1083
/ 简单的模拟数据。// 定义Modbus RTU响应结构。// 定义Modbus RTU帧结构。// 处理Modbus RTU请求。// 添加其他功能码的处理...
STM32开发之Modbus协议(主站和从站)
08-09
本文将深入探讨STM32如何实现Modbus协议的主站和从站功能。 首先，我们需要理解Modbus协议的基本概念。Modbus是串行通信协议，分为ASCII、RTU（远程终端单元）和TCP/IP三种模式。在STM32开发中，通常采用RTU模式，...
STM32F407 Modbus RTU从站实例4
01-29
MODBUS RTU，是现在工控行业非常重要的一个现场应用协议。相信做工控现场的师兄都知道。我也因需要，做了个从站，...经自己3个星期的努力，终于把MODBUS RTU在STM32F407控制器上成功实现了，每句话都加注了详细的说明。
基于stm32单片机实现modbus-rtu 通讯规约源码-有注释.zip
06-06
基于stm32单片机实现modbus-rtu 通讯规约源码-有注释 通讯数据的类型及格式： 信息传输为异步方式，并以字节为单位。每个字节由8位二进制数组成。主机和从机之间传递的通讯信息是10位的字格式： 字格式（串行数据） ...
基于STM32的modbus RTU源码以及工具包.rar
05-11
基于STM32的modbus RTU源码，内容包含了CRC校验码源码、modbusRTU源码---其中实现了功能码03和功能码06，以及一个基于stm32f103的工程。下载下来可以根据自己的硬件环境修改定时器和串口函数构建好物理传输通路即可，剩下的RTU部分为通信传输的软件部分没啥改动，可以按照自己的需求增加功能码。
Modbus_rtu(STM32ZET6从机).zip
05-14
Modbus_rtu 基于stm32平台 测试通过 可以通过modbus精灵 正常收发数据。在STM32霸道上测试通过！
STM32移植FreeModbus实现ModbusRTU.zip
04-10
STM32移植FreeModbus实现ModBusRTU和PLC通信。代码中实现了读线圈、写线圈、读离散输入、读输入寄存器、读保持寄存器、写保持寄存器等功能。
ModbusRTU从站C++源程序
12-05
ModbusRTU从站C++源程序，可以移植到C语言环境，对于开发单片机从站有一定的借鉴
stm32单片机程序Modbus.zip_STM32 MODBUS从站_modbus从站_stm32 modbus从机_stm
07-15
标准Modbus从站，stm32f103系列
stm32f103re modbus主站和从站例程
01-06
stm32f103re modbus rtu主站和从站例程，采用RS485通信，串口接收采用队列方式实现，modbus指令很完整，包括常用的读写指令01H,02H,03H,04H,06H,10H 【EWARMv6】 IAR公司EWARM工程文件夹 【MDK-ARM(uV4)】KEIL的MDK...
STM32F1之RS485通讯协议·MODBUS-RTU超详细解析
时光の尘的博客
05-21 3231
Modbus 是一种串 行通信协议，是Modicon 于 1979年，为使用可编程逻辑控制器（PLC)而发表的。Modbus是工业领域通信协议的业界标准,并且现在是工业电子设备之间相当常用的连接方式。Modbus 比其他通信协议使用的更广泛的主要原因有：（1）公开发表并且无版税要求；（2）相对容易的工业网络部署；（3）对供应商来说，修改移动原生的位元或字节限制较少。
基于STM32的MODBUS-RTU框架的实现
热门推荐
zhuzhu的博客
04-15 1万+
基于STM32的MODBUS-RTU框架的实现
modbus从站协议代码
07-08
### 回答1： Modbus从站协议代码是指在Modbus通讯协议中，从站设备执行的代码。Modbus是一种通信协议，用于将主站设备与从站设备进行通信。从站设备一般是指传感器、执行器或其他外部设备，而主站设备则是负责控制和监控从站设备的中央控制器或计算机。 Modbus从站协议代码通常由从站设备的厂商或开发人员编写。这些代码定义了从站设备与主站设备之间的通信规则和数据交换方式。 Modbus从站协议代码的编写需要遵循Modbus通信协议的规范，并根据从站设备的功能需求进行编写。代码的目的是实现从站设备与主站设备之间的数据交换和通信。 通常，Modbus从站协议代码包括以下几个方面的功能： 1. 与主站设备进行通信：代码需要实现与主站设备之间的通信连接，包括建立连接、数据传输和断开连接。 2. 处理主站设备发送的请求：代码需要解析主站设备发送的请求，根据请求类型执行相应的操作，例如读取传感器数据、执行控制指令等。 3. 组织和管理数据：代码需要处理从站设备的数据，包括存储和管理传感器数据、状态信息等。 4. 响应主站设备的请求：代码需要根据主站设备的请求，生成相应的响应数据，以便主站设备能够获取所需的数据或确认操作的执行情况。 5. 错误处理和异常情况处理：代码需要考虑各种错误和异常情况，例如通信超时、无效的请求等，并进行相应的处理和反馈。 编写Modbus从站协议代码需要对Modbus通讯协议有一定的了解，并具备相关编程技术。同时还需要根据具体的从站设备要求，进行功能设计和代码实现。 ### 回答2： Modbus从站协议代码是一种用于工业自动化领域的通信协议，主要用于数据传输和设备通信。Modbus从站协议代码可以通过编程方式实现在从站设备上。 Modbus从站协议代码通常由以下几部分组成：通信设置、数据处理、功能码处理和响应处理。 首先是通信设置，包括从站的通信参数设置，如串口波特率、数据位、停止位、奇偶校验等。这些设置用于确保从站设备与主站设备之间的通信能够正常进行。 然后是数据处理，包括数据的读取和写入。Modbus从站协议代码需要定义数据区域，以存储从主站发送过来的数据或将要发送给主站的数据。通过读取和写入这些数据区域，实现数据的传输和共享。 接下来是功能码处理，功能码是用于定义要执行的操作的代码。Modbus从站协议代码根据接收到的功能码来执行不同的操作，如读取寄存器、写入寄存器、读取线圈状态等。通过编写对应的功能码处理程序，使得从站设备能够根据主站设备的指令进行相应的操作。 最后是响应处理，即从站设备接收到主站设备的指令后，需要返回响应给主站设备。在Modbus从站协议代码中，需要编写针对不同操作的响应处理程序，确保返回正确的响应给主站设备。 总的来说，Modbus从站协议代码是通过编程实现在从站设备上的一种通信协议代码，用于处理与主站设备的通信、数据处理、功能码处理和响应处理。这些代码的编写需要根据具体的应用需求和设备特点来设计和实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

詩不诉卿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值