FreeMODBUS库的扩展与增强（2）- 四种寄存器的数据读写操作

最新推荐文章于 2024-05-23 10:00:23 发布
最新推荐文章于 2024-05-23 10:00:23 发布
阅读量2k 收藏 22
点赞数 4
分类专栏： STM32-MCU 文章标签： STM32 MODBUS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013441358/article/details/109470925
版权
日期作者版本说明
2020.11.03TaoV0.0完成主体内容的撰写

目录

介绍

modbus通讯的核心功能就是四种寄存器的数据读写操作。FreeModbus库提供了四种modbus寄存器的读写接口，但是具体的功能需要根据项目的不同自己实现。本文介绍了一套实现四种modbus寄存器读写操作的函数与方法，在笔者的项目中有着大量的应用和验证。

需要说明的是，本套库函数是需要配合移植的FreeModbus库一起使用的。对于保持寄存器，由于需要实现掉电保存数据与上电加载数据，需要与其他的库函数配合使用（例如EEPROM数据读写函数等），在移植到其他平台时应该特别加以注意。

类型简称起始地址结束地址功能码
线圈寄存器0x00000099990x01 读一组逻辑线圈；
0x05 写单个线圈；
0x0f 写多个线圈
离散寄存器1x10000199990x02 读一组开关输入
输入寄存器3x30000399990x04 读一个或多个输入寄存器
保持寄存器4x40000499990x03 读一个或多个保持寄存器的值；
0x06 写单个保持寄存器；
0x10 写多个保持寄存器

输入寄存器

头文件

/*
 * mb_inputreg.h
 *
 *  Created on: Oct 22, 2019
 *      Author: tao
 */

#ifndef REGISTERS_MB_INPUTREG_H_
#define REGISTERS_MB_INPUTREG_H_

#include "mb.h"

//设置起始地址（PLC地址，base 1）
#define REG_INPUT_START 1000
//设置寄存器数量
#define REG_INPUT_NREGS 50

typedef union
{
	float toFloat;
	uint16_t toUint16Array[2];
}MB_InputRegUnion;

extern USHORT usRegInputBuf[REG_INPUT_NREGS];

void RegInputBuf_Init();
eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs );
float InputReg_GetData(uint16_t index);
void InputRegReg_SetData(uint16_t index, float value);

#endif /* REGISTERS_MB_INPUTREG_H_ */

源文件

/*
 * mb_inputreg.c
 *
 *  Created on: Oct 22, 2019
 *      Author: tao
 */

#include "mb_inputreg.h"

//static USHORT usRegInputStart = REG_INPUT_START;
USHORT usRegInputBuf[REG_INPUT_NREGS];
MB_InputRegUnion *mb_InputRegUnion = (MB_InputRegUnion *) usRegInputBuf;


/**
 * @brief 完成输入寄存器的初始化
 */
void RegInputBuf_Init()
{
	
}


/**
 * @brief 读输入寄存器的服务函数
 * 		在mbfuncinput.c的eMBFuncReadInputRegister函数中被调用。
 * 		其功能可以简单理解为将业务程序中的usRegInputBuf数组的值copy到pucRegBuffer数组中。
 * @param pucRegBuffer: 保存输入寄存器值的缓存
 * @param usAddress: 输入寄存器的起始地址
 * @param usNRegs: 输入寄存器的数量
 * @return modbus执行的错误状态码
 */
eMBErrorCode eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;

    if( ( usAddress >= REG_INPUT_START )
        && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    {
        iRegIndex = ( int )( usAddress - REG_INPUT_START );
        while( usNRegs > 0 )
        {
            *pucRegBuffer++ =
                ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
            *pucRegBuffer++ =
                ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
            iRegIndex++;
            usNRegs--;
        }
    }
    else
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}


/**
 * @brief 获取指定输入寄存器的值（读）
 * @param index: 输入寄存器的索引号
 * @return 指定输入寄存器的值数据（float类型）
 */
float InputReg_GetData(uint16_t index)
{
	return mb_InputRegUnion[index].toFloat;
}


/**
 * @brief  设置指定输入寄存器的值（写）
 * @param index: 输入寄存器的索引号
 * @param value: 需要设置的值（float类型）
 */
void InputRegReg_SetData(uint16_t index, float value)
{
	mb_InputRegUnion[index].toFloat = value;
}

保持寄存器

头文件

/*
 * mb_holdingreg.h
 *
 *  Created on: Oct 25, 2019
 *      Author: tao
 */

#ifndef REGISTERS_MB_HOLDINGREG_H_
#define REGISTERS_MB_HOLDINGREG_H_

#include "mb.h"

//设置起始地址（PLC地址，base 1）
#define REG_HOLDING_START 1000
//设置寄存器数量
#define REG_HOLDING_NREGS 200

typedef union
{
	float toFloat;
	uint16_t toUint16Array[2];
}MB_HoldingRegUnion;

extern USHORT usRegHoldingBuf[REG_HOLDING_NREGS];
extern MB_HoldingRegUnion *mb_HoldingRegUnion;

void RegHoldingBuf_Init();
eMBErrorCode eMBRegHoldingCB(UCHAR * pucRegBuffer, uint16_t usAddress, uint16_t usNRegs, eMBRegisterMode eMode);
float HoldingReg_GetData(uint16_t index);
void HoldingReg_SetData(uint16_t index, float value);

#endif /* REGISTERS_MB_HOLDINGREG_H_ */

源文件

/*
 * mb_holdingreg.c
 *
 *  Created on: Oct 25, 2019
 *      Author: tao
 */

#include "mb_holdingreg.h"
#include "globalVariate.h"

//static USHORT usRegHoldingStart = REG_HOLDING_START;
USHORT usRegHoldingBuf[REG_HOLDING_NREGS];
MB_HoldingRegUnion *mb_HoldingRegUnion = (MB_HoldingRegUnion *) usRegHoldingBuf;


/**
 * @brief 完成保持寄存器的初始化
 * 		保持寄存器需要掉电保存，因此在初始化的时候需要读取EEPROM数据完成初始化
 */
void RegHoldingBuf_Init()
{
	for (uint8_t i = 0; i < STORABLE_DATA_COUNT; i++)
	{
		usRegHoldingBuf[2 * i] = StorableData[i + 1].value.toUint16Array[0];
		usRegHoldingBuf[2 * i + 1] = StorableData[i + 1].value.toUint16Array[1];
	}
}


/**
 * @brief 读保持寄存器的服务函数
 * 		在mbfuncholding.c的eMBFuncReadHoldingRegister, eMBFuncReadWriteMultipleHoldingRegister,
 * 		eMBFuncWriteHoldingRegister, eMBFuncWriteMultipleHoldingRegister四个函数中被调用。
 * 		其功能可以简单理解为将业务程序中的usRegInputBuf数组的值copy到pucRegBuffer数组中。
 * @param pucRegBuffer: 保存保持寄存器值的缓存
 * @param usAddress: 保存寄存器的起始地址
 * @param usNRegs: 保持寄存器的数量
 * @param eMode: 操作保持寄存器的模式（读 or 写）
 * @return modbus执行的错误状态码
 */
eMBErrorCode eMBRegHoldingCB(UCHAR * pucRegBuffer, uint16_t usAddress, uint16_t usNRegs, eMBRegisterMode eMode)
{
	//错误状态
	eMBErrorCode eStatus = MB_ENOERR;
	//偏移量
	int16_t iRegIndex;

	//判断寄存器是不是在范围内
	if (((int16_t) usAddress >= REG_HOLDING_START) && (usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS))
	{
		//计算偏移量
		iRegIndex = (int16_t) (usAddress - REG_HOLDING_START);

		switch (eMode)
		{
		//读处理函数
		case MB_REG_READ:
			while (usNRegs > 0)
			{
				*pucRegBuffer++ = (uint8_t) (usRegHoldingBuf[iRegIndex] >> 8);
				*pucRegBuffer++ = (uint8_t) (usRegHoldingBuf[iRegIndex] & 0xFF);
				iRegIndex++;
				usNRegs--;
			}
			break;

			//写处理函数
		case MB_REG_WRITE:
			while (usNRegs > 0)
			{
				usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
				usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
				/**
				 * Sync holding register data to storable data.
				 * Save holding register data to eeprom.
				 */
				/*************************************/
				if (iRegIndex % 2 == 1)
				{
//					StorableData[iRegIndex / 2 + 1].value.toUint16Array[0] = usRegHoldingBuf[iRegIndex - 1];
//					StorableData[iRegIndex / 2 + 1].value.toUint16Array[1] = usRegHoldingBuf[iRegIndex];

					StorableData_SetValue_16BitArray(iRegIndex / 2 + 1,&usRegHoldingBuf[iRegIndex - 1]);
					StorableData_SaveValue((const EepromData_typedef *)&StorableData[iRegIndex / 2 + 1]);
				}
				/*************************************/

				iRegIndex++;
				usNRegs--;
			}
			break;
		default:
			eStatus = MB_EINVAL;
			break;
		}
	}
	else
	{
		//返回错误状态
		eStatus = MB_ENOREG;
	}

	return eStatus;
}


/**
 * @brief 获取指定保持寄存器的值（读）
 * @param index: 输入寄存器的索引号
 * @return 指定保持寄存器的值（float类型）
 */
float HoldingReg_GetData(uint16_t index)
{
	return mb_HoldingRegUnion[index].toFloat;
}


/**
 * @brief 设置指定保持寄存器的值（写）
 * @param index: 保持寄存器的索引号
 * @param value: 需要设置的值（float类型）
 */
void HoldingReg_SetData(uint16_t index, float value)
{
	mb_HoldingRegUnion[index].toFloat = value;
}

离散寄存器

头文件

/*
 * mb_discretereg.h
 *
 *  Created on: Oct 25, 2019
 *      Author: tao
 */

#ifndef REGISTERS_MB_DISCRETEREG_H_
#define REGISTERS_MB_DISCRETEREG_H_

#include "mb.h"

//设置起始地址（PLC地址，base 1）
#define REG_DISCRETE_START		1000
//设置寄存器数量
#define REG_DISCRETE_NREGS		20
//由于线圈/离散寄存器表示的是开关量，因此1个字节可以保存8个开关量
#define REG_DISCRETE_SIZE		REG_DISCRETE_NREGS * 8

UCHAR ucRegDiscteteBuf[REG_DISCRETE_NREGS];
void RegDiscreteBuf_Init();
eMBErrorCode eMBRegDiscreteCB( UCHAR * pucRegBuffer, uint16_t usAddress, uint16_t usNDiscrete );
uint8_t DiscreteReg_GetBit(uint16_t index);
void DiscreteReg_SetBit(uint16_t index, uint8_t status);

#endif /* REGISTERS_MB_DISCRETEREG_H_ */

源文件

/*
 * mb_discretereg.c
 *
 *  Created on: Oct 25, 2019
 *      Author: tao
 */

#include "mb_discretereg.h"
#include "mbutils.h"

//static USHORT usRegDiscreteStart = REG_DISCRETE_START;
UCHAR ucRegDiscreteBuf[REG_DISCRETE_NREGS];


/**
 * @brief 完成离散寄存器的初始化
 */
void RegDiscreteBuf_Init()
{
//	for(uint8_t i =0; i<REG_DISCRETE_SIZE; i++)
//	{
//		DiscreteReg_SetBit(i,0);
//	}
}


/**
 * @brief 读离散寄存器的服务函数
 * @param pucRegBuffer: 操作离散寄存器值的缓存
 * @param usAddress: 离散寄存器的首地址
 * @param usNDiscrete: 离散寄存器的数量（字节数组数量 x 8）
 * @return modbus执行的错误状态码
 */
eMBErrorCode eMBRegDiscreteCB(UCHAR * pucRegBuffer, uint16_t usAddress, uint16_t usNDiscrete)
{
	//错误状态
	eMBErrorCode eStatus = MB_ENOERR;
	//寄存器个数
	int16_t iNDiscrete = (int16_t) usNDiscrete;
	//偏移量
	uint16_t usBitOffset;

	//判断寄存器时候再制定范围内
	if (((int16_t) usAddress >= REG_DISCRETE_START)
			&& (usAddress + usNDiscrete <= REG_DISCRETE_START + REG_DISCRETE_SIZE))
	{
		//获得偏移量
		usBitOffset = (uint16_t) (usAddress - REG_DISCRETE_START);

		while (iNDiscrete > 0)
		{
			*pucRegBuffer++ = xMBUtilGetBits(ucRegDiscreteBuf, usBitOffset, (uint8_t) (iNDiscrete > 8 ? 8 : iNDiscrete));
			iNDiscrete -= 8;
			usBitOffset += 8;
		}
	}
	else
	{
		eStatus = MB_ENOREG;
	}
	return eStatus;
}


/**
 * @brief 获取指定离散寄存器的值（读）
 * @param index: 离散寄存器的索引号
 * @return 指定离散寄存器的值（uint8_t类型）
 */
uint8_t DiscreteReg_GetBit(uint16_t index)
{
	return ((0x01 << index%8) & ucRegDiscreteBuf[index/8]) >> (index%8);
}


/**
 * @brief 设置指定离散寄存器的值（写）
 * @param index: 离散寄存器的索引号
 * @param value: 需要设置的值（uint8_t类型）
 */
void DiscreteReg_SetBit(uint16_t index, uint8_t status)
{
	if(status != 0)
	{
		ucRegDiscreteBuf[index/8] |= (0x01 << (index%8));
	}
	else
	{
		ucRegDiscreteBuf[index/8] &= (~(0x01 << (index%8)));
	}
}

线圈寄存器

头文件

/*
 * mb_coilsreg.h
 *
 *  Created on: Oct 25, 2019
 *      Author: tao
 */

#ifndef REGISTERS_MB_COILSREG_H_
#define REGISTERS_MB_COILSREG_H_

#include "mb.h"

//设置起始地址（PLC地址，base 1）
#define REG_COILS_START 1000
//设置寄存器数量
#define REG_COILS_NREGS 20
//由于线圈/离散寄存器表示的是开关量，因此1个字节可以保存8个开关量
#define REG_COILS_SIZE REG_COILS_NREGS * 8

UCHAR ucRegCoilsBuf[REG_COILS_NREGS];
void RegCoilsBuf_Init();
eMBErrorCode eMBRegCoilsCB( UCHAR * pucRegBuffer, uint16_t usAddress, uint16_t usNCoils, eMBRegisterMode eMode );
uint8_t CoilsReg_GetBit(uint16_t index);
void CoilsReg_SetBit(uint16_t index, uint8_t status);

#endif /* REGISTERS_MB_COILSREG_H_ */

源文件

/*
 * mb_coilsreg.c
 *
 *  Created on: Oct 25, 2019
 *      Author: tao
 */

#include "mb_coilsreg.h"
#include "mbutils.h"

UCHAR ucRegCoilsBuf[REG_COILS_NREGS];


/**
 * @brief 完成线圈寄存器的初始化
 */
void RegCoilsBuf_Init()
{
//	for(uint8_t i =0; i<REG_COILS_SIZE; i++)
//	{
//		CoilsReg_SetBit(i,0);
//	}
}


/**
 * @brief 读写线圈寄存器的服务函数
 * @param pucRegBuffer: 操作线圈寄存器值的缓存
 * @param usAddress: 线圈寄存器的首地址
 * @param usNCoils: 线圈寄存器的数量（字节数组数量 x 8）
 * @param eMode: 操作线圈寄存器的模式（读 or 写）
 * @return modbus执行的错误状态码
 */
eMBErrorCode eMBRegCoilsCB(UCHAR * pucRegBuffer, uint16_t usAddress, uint16_t usNCoils, eMBRegisterMode eMode)
{
	//错误状态
	eMBErrorCode eStatus = MB_ENOERR;
	//寄存器个数
	int16_t iNCoils = (int16_t) usNCoils;
	//寄存器偏移量
	int16_t usBitOffset;

	//检查寄存器是否在指定范围内
	if (((int16_t) usAddress >= REG_COILS_START) && (usAddress + usNCoils <= REG_COILS_START + REG_COILS_SIZE))
	{
		//计算寄存器偏移量
		usBitOffset = (int16_t) (usAddress - REG_COILS_START);
		switch (eMode)
		{
		//读操作
		case MB_REG_READ:
			while (iNCoils > 0)
			{
				*pucRegBuffer++ = xMBUtilGetBits(ucRegCoilsBuf, usBitOffset, (uint8_t) (iNCoils > 8 ? 8 : iNCoils));
				iNCoils -= 8;
				usBitOffset += 8;
			}


			break;

			//写操作
		case MB_REG_WRITE:
			while (iNCoils > 0)
			{
				xMBUtilSetBits(ucRegCoilsBuf, usBitOffset, (uint8_t) (iNCoils > 8 ? 8 : iNCoils), *pucRegBuffer++);
				iNCoils -= 8;
			}
			break;
		default:
			eStatus = MB_EINVAL;
			break;
		}
	}
	else
	{
		eStatus = MB_ENOREG;
	}
	return eStatus;
}


/**
 * @brief 获取指定线圈寄存器的值（读）
 * @param index: 线圈寄存器的索引号
 * @return 指定线圈寄存器的值（uint8_t类型）
 */
uint8_t CoilsReg_GetBit(uint16_t index)
{
	return ((0x01 << index%8) & ucRegCoilsBuf[index/8]) >> (index%8);
}


/**
 * @brief 设置指定线圈寄存器的值（写）
 * @param index: 线圈寄存器的索引号
 * @param value: 需要设置的值（uint8_t类型）
 */
void CoilsReg_SetBit(uint16_t index, uint8_t status)
{
	if(status != 0)
	{
		ucRegCoilsBuf[index/8] |= (0x01 << (index%8));
	}
	else
	{
		ucRegCoilsBuf[index/8] &= (~(0x01 << (index%8)));
	}
}
全能骑士涛锅锅
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
计组 | 各程序员、用户 可见 / 不可见 寄存器总结
"You are worthy! You can do it!"
11-15 1万+
对所有用户（所有程序员）透明：MAR，MDR，IR，Cache, 微程序结构和功能，控制存储器，锁存器/暂存器。汇编语言（系统）程序员能够看到汇编语言中出现的寄存器、以及寻址方式。对所有用户（所有程序员）可见：PSW、PC、通用寄存器。汇编程序员可见：通过汇编程序可以对某个寄存器进行访问。判断技巧：该寄存器是否能在汇编语言中出现。
[STM32]超详细STM32移植freemodbus实现modbusRTU协议
ic2121的博客
02-20 3965
就可以实现之前定义的寄存器变量中的数据读写功能。最近在STM32平台上开发DTU网关设备，需要用到RS485接口实现ModBus-RTU协议来进行一些线圈寄存器的控制（继电器开关）和一些保持寄存器的读写（模拟量的读写和一些设备参数配置等），其实通过自己编写函数进行命令解析也可以实现，但是对于多个MODBUS命令及多个不定数寄存器的读写操作略显麻烦，就一次性移植了一下FreeModbus协议栈进行开发。四、在.c中定义自己的寄存器变量和自己的寄存器其实地址，如线圈和输入寄存器的定义。//输入寄存器起始地址。
网络协议——Modbus-RTU
最新发布
计算机硕士的博客
05-23 1025
网络协议——Modbus-RTU，简介、消息格式、Modbus寄存器种类说明、功能码01H、功能码02H、功能码03H、功能码04H、功能码05H、功能码06H、功能码0FH、功能码10H。
程序员可见的寄存器有哪些_程序员应如何理解CPU：上篇
weixin_28764585的博客
01-27 9355
本节属于操作系统第一章即基础篇，在真正开始操作系统相关章节前回顾一些重要的主题，以下是目录，由于本文篇幅较多因此按上篇、下篇两次发布，目录中黑体为本篇内容。什么是机器指令程序语言的演变CPU是如何工作的寄存器程序计数器栈指针CPU的工作模式总结你可能会想，作为程序员，我们需要理解CPU吗？是的，如果你想彻底理解操作系统的话。在后面的课程中你会发现，仅仅依赖软件是无法完成某些特定的功能的，...
【组原】寄存器【之】程序员透明与可见
热门推荐
zcw1234515的博客
05-09 2万+
文章目录涉及对用户透明的知识点运算知识点 涉及对用户透明的知识点 第一章： 对所有用户可见： PSW， PC， 通用寄存器 对用户透明： MAR，MDR，IR，Cache, 微程序结构和功能； 对应用程序员透明： 暂存寄存器， 虚拟寄存器 汇编程序员可见： PC 系统程序员可见： 虚拟存储器 第二章 主存和缓存之间的数据调动是由硬件自动完成的，对所有程序员都是透明的； 主存和辅存之间的数据调用是由硬件和操作系统共同完成的，对应用程序员是透明的； 运算知识点
程序员可见的寄存器有哪些_线程间到底共享了哪些进程资源？看完这篇你就懂了~...
weixin_39630048的博客
01-27 1713
前言进程和线程这两个话题是程序员绕不开的，操作系统提供的这两个抽象概念实在是太重要了。关于进程和线程有一个极其经典的问题，那就是进程和线程的区别是什么？相信很多同学对答案似懂非懂。记住了不一定真懂关于这个问题有的同学可能已经“背得”滚瓜烂熟了：“进程是操作系统分配资源的单位，线程是调度的基本单位，线程之间共享进程资源”。可是你真的理解了上面最后一句话吗？到底线程之间共享了哪些进程资源，共享资源意味...
FreeModbus_Master 读取从机数据
aLife2P6的博客
11-25 3864
一、请求读取的函数和存储返回值的变量 1. 读取输入寄存器（功能04） 1.1 请求读取输入寄存器的函数 eMBMasterReqReadInputRegister() 1.2. 存储返回值的变量 usMRegInBuf[ ][ ] 1.3. 举例 eMBMasterReqReadInputRegister(从机地址, ...
GD32_FreeModbus_GD32_gd32modbus移植_FreeModBus
09-11
2. **FreeModBus库**：FreeModBus是一个完全符合ModBus RTU和ASCII协议的C语言实现，提供主站和从站模式，支持浮点数、整数、字符串等多种数据类型。它的开源性质使得开发者可以根据需求进行定制和扩展。 ### 二、...
FreeModbus--RTU--Master+Slave--uCOSIII--STM32F407
05-18
2. **FreeModbus库**：这个库实现了Modbus协议，提供了主站和从站功能，允许设备之间进行读写操作，如读取输入寄存器、读取线圈状态、写入单个寄存器等。它是免费且开源的，允许开发者根据自己的需求进行定制和扩展...
FreeModbus的从站模式+RT thread操作系统+STM32芯片
07-13
在本文中，我们将深入探讨如何在基于STM32微控制器的系统中，结合FreeModbus库的从站...通过FreeModbus和RT-Thread的结合，STM32设备可以无缝接入Modbus网络，与其他系统进行数据交换，提升系统的互操作性和可扩展性。
基于FreeRTOS的FreeModbus移植
01-01
在本文中，我们将深入探讨如何将FreeModbus库移植到基于FreeRTOS的操作系统上，以实现与西门子组态屏的有效通信。FreeModbus是一个开源的、跨平台的Modbus协议实现，它允许设备之间进行数据交换。FreeRTOS则是一个轻...
freemodbus-v1_FreeModBus.zip
10-11
2. **功能码支持**：FreeModBus实现了MODBUS协议的多种功能码，包括读输入寄存器（0x04）、读保持寄存器（0x03）、写单个线圈（0x05）、写多个线圈（0x0F）、写单个寄存器（0x06）和写多个寄存器（0x10）等，这些...
FreeModbus读/写寄存器小Bug
积跬步以至千里
11-10 3853
在STM32F401中移植了FreeModBus，移植教程参考了这里：http://www.openedv.com/thread-64794-1-1.html。采用03、04和06号功能码进行数据读写，发现数据能读出，但数值不对。单独调试串口证明串口正常。断点调试发现，每次读/写都是操作的本来想操作寄存器的下一个。于是，一步步查看协议栈各函数调用关系。终于发现，协议栈的小bug。 以03号功能码调
寄存器
血色残阳的专栏
04-03 770
处理器包括两类寄存器：        用户可见寄存器，高级语言编译器通过算法分配并使用之，以减少程序访问主存次数        控制和状态寄存器，用于控制处理器的操作,由OS的特权代码使用, 以控制其它程序的执行用户可见寄存器        机器语言直接引用        包括数据寄存器、地址寄存器以及条件码寄存器               数据寄存器（data register）又称通用寄存器
FreeModbus输入寄存器
lushoumin的博客
04-08 1739
输入寄存器的访问属性为只读 对输入寄存器的操作包括：读输入寄存器（0x04） 在一个远程设备中，使用该功能码读取1 至大约125 的连续输入寄存器。请求PDU 说明了起始地址和寄存器数量。从零开始寻址寄存器。因此，寻址输入寄存器1-16 为0-15。 将响应报文中的寄存器数据分成每个寄存器为两字节，在每个字节中直接地调整二进制内容。对于每个寄存器，第一个字节包括高位比特，并且第二个字...
唐朔飞计算机组成原理常见的寄存器(时不时就更新)
qq_62260432的博客
05-12 797
计组寄存器器杂记
FreeModbus开源协议栈-mbfuncholding.c（保持寄存器操作）
weixin_47077788的博客
12-09 804
mbfuncholding.c主要是对保持寄存器的一些描述。当主机接收到03、06、10等功能码时，会进入对应功能码处理函数。
FreeModbus开源协议栈-mbfuncinput.c（输入寄存器操作）
weixin_47077788的博客
12-22 283
mbfuncinput.c主要是对输入寄存器的一些描述。当主机接收到04等功能码时，会进入对应功能码处理函数。
freeMODBUS
03-15
freeMODBUS是一个开源的Modbus通信协议栈，用于实现Modbus通信协议的主站和从站设备之间的数据交换。Modbus是一种常用的工业通信协议，用于在自动化系统中传输数据。freeMODBUS提供了一套完整的Modbus协议栈，包括主站和从站的实现，支持串口和以太网通信方式。 freeMODBUS的特点包括： 1. 开源免费：freeMODBUS是开源项目，可以免费使用和修改。 2. 跨平台支持：freeMODBUS可以在多种操作系统上运行，如Windows、Linux、嵌入式系统等。 3. 灵活可扩展：freeMODBUS提供了丰富的API和配置选项，可以根据需求进行定制和扩展。 4. 支持多种通信方式：freeMODBUS支持串口通信（如RS-232、RS-485）和以太网通信（如TCP/IP）。 5. 完整的功能支持：freeMODBUS支持Modbus协议的常用功能，如读写寄存器、读写线圈等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

全能骑士涛锅锅

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

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

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

打赏作者

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

抵扣说明：

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

余额充值