不含stm32 底层的代码
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
MyStm32Code/port/FreeModbus/modbus_app.c

866 lines
27 KiB

2 years ago
#include "mb.h"
#include "mbport.h"
#include "port.h"
#include "elog.h"
extern void Modbus_Port( );
extern void Modbus_Task(void * argument);
osThreadId_t modbus_taskHandle;
const osThreadAttr_t modbus_task_attributes = {
.name = "modbus_task",
.stack_size = 512,
.priority = (osPriority_t) osPriorityLow,
};
void Modbus_Port( )
{
modbus_taskHandle = osThreadNew( Modbus_Task, NULL, &modbus_task_attributes );
}
/* ----------------------- Defines ------------------------------------------*/
// 输入寄存器
#define REG_INPUT_START 0
#define REG_INPUT_NREGS 6
// 保持寄存器
#define REG_HOLD_START 0
#define REG_HOLD_NREGS 10
// 线圈
#define REG_COILS_START 0
#define REG_COILS_NREGS 4
// 开关寄存器
#define REG_DISCRETE_START 0
#define REG_DISCRETE_NREGS 4
/* ----------------------- Static variables ---------------------------------*/
static USHORT usRegInputStart = REG_INPUT_START;
static USHORT usRegHoldStart = REG_HOLD_START;
static USHORT usRegCoilsStart = REG_COILS_START;
static USHORT usRegDiscreteStart = REG_DISCRETE_START;
//static
uint16_t usRegInputBuf[REG_INPUT_NREGS];
uint16_t InputBuff[5]; // 这个buf 传递给usRegInputBuf
uint16_t usRegHoldBuf[REG_HOLD_NREGS];
uint16_t HoldBuff[10];
static uint8_t usRegCoilsBuf[REG_COILS_NREGS];
static uint8_t usRegDiscreteBuf[REG_DISCRETE_NREGS];
void Modbus_Set_HoldingBuff(uint8_t* buf, uint16_t size, uint16_t begin)
{
/* 设置 Holding 寄存器, usRegHoldBuf , 16 位寄存器 */
/* 判断是否超长 */
if (size > 2*(REG_HOLD_NREGS - begin))
{
return;
}
ENTER_CRITICAL_SECTION();
memcpy( (uint8_t*) (usRegHoldBuf+begin) , buf, size);
EXIT_CRITICAL_SECTION();
}
void Modbus_Task(void * argument)
{
/* ABCDEF */
InputBuff[0] = 0x11;
InputBuff[1] = 0x22;
InputBuff[2] = 0x33;
InputBuff[3] = 0x44;
InputBuff[4] = 0x55;
InputBuff[5] = 0x66;
usRegHoldBuf[0] = 0x99;
usRegHoldBuf[1] = 0x22;
usRegHoldBuf[2] = 0x33;
usRegHoldBuf[3] = 0x44;
usRegHoldBuf[4] = 0x55;
usRegHoldBuf[5] = 0x66;
usRegHoldBuf[6] = 0x77;
usRegHoldBuf[7] = 0x88;
usRegHoldBuf[8] = 0x99;
usRegHoldBuf[9] = 0xBB;
usRegCoilsBuf[0] = 0;
usRegCoilsBuf[1] = 1;
usRegCoilsBuf[2] = 1;
usRegCoilsBuf[3] =1;
usRegDiscreteBuf[0] = 1;
usRegDiscreteBuf[1] = 0;
usRegDiscreteBuf[2] = 0;
usRegDiscreteBuf[3] =1;
eMBInit(MB_RTU, 0x01, 0x00, 9600, MB_PAR_NONE);
eMBEnable();
for(;;)
{
eMBPoll();
osDelay(2);
}
}
// /****************************************************************************
// * 名 称:eMBRegInputCB 输入寄存器,如模拟量输入
// * 功 能:读取输入寄存器,对应功能码是 04 eMBFuncReadInputRegister
// * 入口参数:pucRegBuffer: 数据缓存区,用于响应主机
// * usAddress: 寄存器地址
// * usNRegs: 要读取的寄存器个数
// * 出口参数:
// * 注 意:上位机发来的 帧格式是: SlaveAddr(1 Byte)+FuncCode(1 Byte)
// * +StartAddrHiByte(1 Byte)+StartAddrLoByte(1 Byte)
// * +LenAddrHiByte(1 Byte)+LenAddrLoByte(1 Byte)+
// * +CRCAddrHiByte(1 Byte)+CRCAddrLoByte(1 Byte)
// 功 能 码:04
// ****************************************************************************/
eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
eMBErrorCode eStatus = MB_ENOERR;
int iRegIndex;
int i;
// 动态改变 Input
// InputBuff[0] = 0x11;
// InputBuff[1] = 0x22;
// InputBuff[2] = 0x33;
// InputBuff[3] = 0x44;
// InputBuff[4] = 0x55;
// InputBuff[5] = 0x66;
if( ( usAddress >= REG_INPUT_START )
&& ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
{
iRegIndex = ( int )( usAddress - usRegInputStart );
for(i=0;i<usNRegs;i++)
{
*pucRegBuffer=InputBuff[i+usAddress-1]>>8;
pucRegBuffer++;
*pucRegBuffer=InputBuff[i+usAddress-1]&0xff;
pucRegBuffer++;
}
}
else
{
eStatus = MB_ENOREG;
}
return eStatus;
}
/****************************************************************************
* eMBRegHoldingCB
* 06 eMBFuncWriteHoldingRegister
* 16 eMBFuncWriteMultipleHoldingRegister
* 03 eMBFuncReadHoldingRegister
* 23 eMBFuncReadWriteMultipleHoldingRegister
* pucRegBuffer:
* usAddress:
* usNRegs:
* eMode:
*
* 03 06 16
****************************************************************************/
eMBErrorCode
eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
{
eMBErrorCode eStatus = MB_ENOERR;
int iRegIndex;
usAddress = usAddress - 1;
// log_i("eMBRegHoldingCB eMode %d usNRegs %d usAddress :%d",eMode, usNRegs,usAddress);
// usRegHoldBuf[0] = 0x99;
// usRegHoldBuf[1] = 0x22;
// usRegHoldBuf[2] = 0x33;
// usRegHoldBuf[3] = 0x44;
// usRegHoldBuf[4] = 0x55;
// usRegHoldBuf[5] = 0x66;
// usRegHoldBuf[6] = 0x77;
// usRegHoldBuf[7] = 0x88;
// usRegHoldBuf[8] = 0x99;
// usRegHoldBuf[9] = 0xBB;
if((usAddress >= REG_HOLD_START) && ((usAddress+usNRegs) <= (REG_HOLD_START + REG_HOLD_NREGS)))
{
iRegIndex = (int)(usAddress - usRegHoldStart);
switch(eMode)
{
case MB_REG_READ://读寄存器
while(usNRegs > 0)
{
*pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] >> 8);
*pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF);
iRegIndex++;
usNRegs--;
}
break;
case MB_REG_WRITE://写寄存器
ENTER_CRITICAL_SECTION();
while(usNRegs > 0)
{
// log_i("eMBRegHoldingCB iRegIndex %d %02X %02X ",iRegIndex,(uint8_t)(*pucRegBuffer),(uint8_t)(*(pucRegBuffer+1)));
// log_i("eMBRegHoldingCB iRegIndex %d %02X %02X ",iRegIndex,(uint8_t)(*pucRegBuffer++ << 8),(uint8_t)(*pucRegBuffer++));
usRegHoldBuf[iRegIndex] = *pucRegBuffer++ << 8;
usRegHoldBuf[iRegIndex] |= *pucRegBuffer++;
// log_i("eMBRegHoldingCB %02X %02X",(uint8_t)(usRegHoldBuf[iRegIndex] >> 8), (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF ));
iRegIndex++;
usNRegs--;
}
EXIT_CRITICAL_SECTION();
}
}
else//错误
{
eStatus = MB_ENOREG;
}
// for (size_t i = 0; i < 10; i++)
// {
// log_i(" i : %d val : %04X", i, usRegHoldBuf[i]);
// }
return eStatus;
}
/****************************************************************************
* eMBRegCoilsCB
* 01 线 eMBFuncReadCoils
* 05 线 eMBFuncWriteCoil
* 15 线 eMBFuncWriteMultipleCoils
* pucRegBuffer:
* usAddress: 线
* usNCoils: 线
* eMode:
*
* 01
*
****************************************************************************/
eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
{
eMBErrorCode eStatus = MB_ENOERR;
USHORT iRegIndex;
USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
UCHAR ucStatus = 0;
UCHAR ucBits = 0;
UCHAR ucDisp = 0;
usAddress = usAddress - 1;
log_i("eMBRegCoilsCB eMode %d usNCoils %d usAddress :%d",eMode, usNCoils,usAddress);
if((usAddress >= REG_COILS_START) && ((usAddress + usNCoils) <= (REG_COILS_START + REG_COILS_NREGS)))
{
iRegIndex = (int)(usAddress - usRegCoilsStart);
switch(eMode)
{
case MB_REG_READ://读线圈
while(usCoilGroups--)
{
ucDisp = 0;
ucBits = 8;
while((usNCoils--) != 0 && (ucBits--) != 0)
{
ucStatus |= (usRegCoilsBuf[iRegIndex++] << (ucDisp++));
}
*pucRegBuffer++ = ucStatus;
}
break;
case MB_REG_WRITE://写线圈
// ENTER_CRITICAL_SECTION();
while(usCoilGroups--)
{
ucStatus = *pucRegBuffer++;
ucBits = 8;
while((usNCoils--) != 0 && (ucBits--) != 0)
{
usRegCoilsBuf[iRegIndex++] = ucStatus & 0X01;
ucStatus >>= 1;
}
}
// EXIT_CRITICAL_SECTION();
}
}
else//错误
{
eStatus = MB_ENOREG;
}
return eStatus;
}
/****************************************************************************
* eMBRegDiscreteCB
* 02 eMBFuncReadDiscreteInputs
* pucRegBuffer:
* usAddress:
* usNDiscrete:
*
* 02
****************************************************************************/
eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
eMBErrorCode eStatus = MB_ENOERR;
USHORT iRegIndex;
USHORT usDiscreteGroups = ((usNDiscrete - 1) / 8 + 1);
UCHAR ucStatus = 0;
UCHAR ucBits = 0;
UCHAR ucDisp = 0;
usAddress = usAddress - 1;
log_i("eMBRegDiscreteCB usAddress :%d usNDiscrete : %d", usAddress, usNDiscrete);
if((usAddress >= REG_DISCRETE_START) && ((usAddress + usNDiscrete) <= (REG_DISCRETE_START + REG_DISCRETE_NREGS)))
{
iRegIndex = (int)(usAddress - usRegDiscreteStart);
log_i("eMBRegDiscreteCB iRegIndex :%d usNDiscrete : %d", iRegIndex, usNDiscrete);
while(usDiscreteGroups--)
{
ucDisp = 0;
ucBits = 8;
while((usNDiscrete--) != 0 && (ucBits--) != 0)
{
log_i("val :%d %d ", iRegIndex, usRegDiscreteBuf[iRegIndex]);
if(usRegDiscreteBuf[iRegIndex])
{
ucStatus |= (1 << ucDisp);
}
iRegIndex++;
ucDisp++;
}
*pucRegBuffer++ = ucStatus;
}
}
else//错误
{
eStatus = MB_ENOREG;
}
return eStatus;
}
// ----------------------------------------------------
// #include "mb.h"
// #include "mbport.h"
// #include "main.h"
// #if !defined(LOG_TAG)
// #define LOG_TAG "Modbus"
// #endif
// #undef LOG_LVL
// #if defined(XX_LOG_LVL)
// #define LOG_LVL XX_LOG_LVL
// #endif
// #include "elog.h"
// //输入寄存器
// #define REG_INPUT_START 3000
// #define REG_INPUT_NREGS 4
// //保持寄存器
// #define REG_HOLD_START 4000
// #define REG_HOLD_NREGS 10
// //线圈
// #define REG_COILS_START 0
// #define REG_COILS_NREGS 4
// //开关寄存器
// #define REG_DISCRETE_START 1000
// #define REG_DISCRETE_NREGS 4
// /* ----------------------- Static variables ---------------------------------*/
// static USHORT usRegInputStart = REG_INPUT_START;
// static USHORT usRegInputBuf[REG_INPUT_NREGS];
// static USHORT usRegHoldStart = REG_HOLD_START;
// static USHORT usRegHoldBuf[REG_HOLD_NREGS];
// static USHORT usRegCoilsStart = REG_COILS_START;
// static uint8_t usRegCoilsBuf[REG_COILS_NREGS];
// static USHORT usRegDiscreteStart = REG_DISCRETE_START;
// static uint8_t usRegDiscreteBuf[REG_DISCRETE_NREGS];
// /** 初始化供调用*/
// void ModbusRTUTask(void const * argument)
// {
// eMBPoll();
// }
// void ModbusRTUInit(void const * argument)
// {
// /* ABCDEF */
// usRegInputBuf[0] = 11;
// usRegInputBuf[1] = 22;
// usRegInputBuf[2] = 33;
// usRegInputBuf[3] = 44;
// usRegInputBuf[4] = 55;
// usRegInputBuf[5] = 66;
// usRegInputBuf[6] = 77;
// usRegInputBuf[7] = 88;
// // 初始化modbus为RTU方式,地址0x01, 波特率9600,无校验
// eMBErrorCode eStatus = eMBInit( MB_RTU, 1, 3, 19200, MB_PAR_NONE );
// // 使能modbus协议栈
// eStatus = eMBEnable();
// // log_i("usRegInputBuf 0 8: %d %d ", usRegInputBuf[0], usRegInputBuf[7] );
// }
// /****************************************************************************
// * 名 称:eMBRegInputCB
// * 功 能:读取输入寄存器,对应功能码是 04 eMBFuncReadInputRegister
// * 入口参数:pucRegBuffer: 数据缓存区,用于响应主机
// * usAddress: 寄存器地址
// * usNRegs: 要读取的寄存器个数
// * 出口参数:
// * 注 意:上位机发来的 帧格式是: SlaveAddr(1 Byte)+FuncCode(1 Byte)
// * +StartAddrHiByte(1 Byte)+StartAddrLoByte(1 Byte)
// * +LenAddrHiByte(1 Byte)+LenAddrLoByte(1 Byte)+
// * +CRCAddrHiByte(1 Byte)+CRCAddrLoByte(1 Byte)
// * 3 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
// {
// eMBErrorCode eStatus = MB_ENOERR;
// int iRegIndex;
// usAddress = usAddress - 1;
// if( ( usAddress >= REG_INPUT_START ) && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
// {
// iRegIndex = ( int )( usAddress - usRegInputStart );
// while( usNRegs > 0 )
// {
// *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
// *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
// iRegIndex++;
// usNRegs--;
// }
// }
// else
// {
// eStatus = MB_ENOREG;
// }
// return eStatus;
// }
// /****************************************************************************
// * 名 称:eMBRegHoldingCB
// * 功 能:对应功能码有:06 写保持寄存器 eMBFuncWriteHoldingRegister
// * 16 写多个保持寄存器 eMBFuncWriteMultipleHoldingRegister
// * 03 读保持寄存器 eMBFuncReadHoldingRegister
// * 23 读写多个保持寄存器 eMBFuncReadWriteMultipleHoldingRegister
// * 入口参数:pucRegBuffer: 数据缓存区,用于响应主机
// * usAddress: 寄存器地址
// * usNRegs: 要读写的寄存器个数
// * eMode: 功能码
// * 出口参数:
// * 注 意:4 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
// {
// eMBErrorCode eStatus = MB_ENOERR;
// int iRegIndex;
// usAddress = usAddress - 1;
// if((usAddress >= REG_HOLD_START) && ((usAddress+usNRegs) <= (REG_HOLD_START + REG_HOLD_NREGS)))
// {
// iRegIndex = (int)(usAddress - usRegHoldStart);
// switch(eMode)
// {
// case MB_REG_READ://读寄存器
// while(usNRegs > 0)
// {
// *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] >> 8);
// *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[iRegIndex] & 0xFF);
// iRegIndex++;
// usNRegs--;
// }
// break;
// case MB_REG_WRITE://写寄存器
// while(usNRegs > 0)
// {
// usRegHoldBuf[iRegIndex] = *pucRegBuffer++ << 8;
// usRegHoldBuf[iRegIndex] |= *pucRegBuffer++;
// iRegIndex++;
// usNRegs--;
// }
// }
// }
// else//错误
// {
// eStatus = MB_ENOREG;
// }
// return eStatus;
// }
// /****************************************************************************
// * 名 称:eMBRegCoilsCB
// * 功 能:对应功能码有:01 读线圈 eMBFuncReadCoils
// * 05 写线圈 eMBFuncWriteCoil
// * 15 写多个线圈 eMBFuncWriteMultipleCoils
// * 入口参数:pucRegBuffer: 数据缓存区,用于响应主机
// * usAddress: 线圈地址
// * usNCoils: 要读写的线圈个数
// * eMode: 功能码
// * 出口参数:
// * 注 意:如继电器
// * 0 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
// {
// eMBErrorCode eStatus = MB_ENOERR;
// USHORT iRegIndex;
// USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
// UCHAR ucStatus = 0;
// UCHAR ucBits = 0;
// UCHAR ucDisp = 0;
// usAddress = usAddress - 1;
// if((usAddress >= REG_COILS_START) && ((usAddress + usNCoils) <= (REG_COILS_START + REG_COILS_NREGS)))
// {
// iRegIndex = (int)(usAddress - usRegCoilsStart);
// switch(eMode)
// {
// case MB_REG_READ://读线圈
// while(usCoilGroups--)
// {
// ucDisp = 0;
// ucBits = 8;
// while((usNCoils--) != 0 && (ucBits--) != 0)
// {
// ucStatus |= (usRegCoilsBuf[iRegIndex++] << (ucDisp++));
// }
// *pucRegBuffer++ = ucStatus;
// }
// break;
// case MB_REG_WRITE://写线圈
// while(usCoilGroups--)
// {
// ucStatus = *pucRegBuffer++;
// ucBits = 8;
// while((usNCoils--) != 0 && (ucBits--) != 0)
// {
// usRegCoilsBuf[iRegIndex++] = ucStatus & 0X01;
// ucStatus >>= 1;
// }
// }
// }
// }
// else//错误
// {
// eStatus = MB_ENOREG;
// }
// return eStatus;
// }
// /****************************************************************************
// * 名 称:eMBRegDiscreteCB
// * 功 能:读取离散寄存器,对应功能码有:02 读离散寄存器 eMBFuncReadDiscreteInputs
// * 入口参数:pucRegBuffer: 数据缓存区,用于响应主机
// * usAddress: 寄存器地址
// * usNDiscrete: 要读取的寄存器个数
// * 出口参数:
// * 注 意:1 区
// ****************************************************************************/
// eMBErrorCode
// eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
// {
// eMBErrorCode eStatus = MB_ENOERR;
// USHORT iRegIndex;
// USHORT usDiscreteGroups = ((usNDiscrete - 1) / 8 + 1);
// UCHAR ucStatus = 0;
// UCHAR ucBits = 0;
// UCHAR ucDisp = 0;
// usAddress = usAddress - 1;
// if((usAddress >= REG_DISCRETE_START) && ((usAddress + usNDiscrete) <= (REG_DISCRETE_START + REG_DISCRETE_NREGS)))
// {
// iRegIndex = (int)(usAddress - usRegDiscreteStart);
// while(usDiscreteGroups--)
// {
// ucDisp = 0;
// ucBits = 8;
// while((usNDiscrete--) != 0 && (ucBits--) != 0)
// {
// if(usRegDiscreteBuf[iRegIndex])
// {
// ucStatus |= (1 << ucDisp);
// }
// ucDisp++;
// }
// *pucRegBuffer++ = ucStatus;
// }
// }
// else//错误
// {
// eStatus = MB_ENOREG;
// }
// return eStatus;
// }
// // extern UART_HandleTypeDef huart2; // 引入串口
// // // 十路输入寄存器
// // #define REG_INPUT_SIZE 10
// // uint16_t REG_INPUT_BUF[REG_INPUT_SIZE];
// // // 十路保持寄存器
// // #define REG_HOLDING_START 0x0000
// // #define REG_HOLD_SIZE 8
// // // uint16_t REG_HOLD_BUF[REG_HOLD_SIZE];
// // uint16_t usRegHoldingBuf[REG_HOLD_SIZE] = {0x147b, 0x3f8e, 0x147b, 0x400e, 0x1eb8, 0x4055, 0x147b, 0x408e};
// // // 十路线圈
// // #define REG_COILS_SIZE 10
// // uint8_t REG_COILS_BUF[REG_COILS_SIZE] = {1, 1, 1, 1, 0, 0, 0, 0, 1, 1};
// // // 十路离散量
// // #define REG_DISC_SIZE 10
// // uint8_t REG_DISC_BUF[REG_DISC_SIZE] = {1, 1, 1, 1, 0, 0, 0, 0, 1, 1};
// // /// CMD4命令处理回调函数
// // eMBErrorCode eMBRegInputCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs)
// // {
// // USHORT usRegIndex = usAddress - 1;
// // // 非法检测
// // if ((usRegIndex + usNRegs) > REG_INPUT_SIZE)
// // {
// // return MB_ENOREG;
// // }
// // // 循环读取
// // while (usNRegs > 0)
// // {
// // *pucRegBuffer++ = (unsigned char)(REG_INPUT_BUF[usRegIndex] >> 8);
// // *pucRegBuffer++ = (unsigned char)(REG_INPUT_BUF[usRegIndex] & 0xFF);
// // usRegIndex++;
// // usNRegs--;
// // }
// // // 模拟输入寄存器被改变
// // for (usRegIndex = 0; usRegIndex < REG_INPUT_SIZE; usRegIndex++)
// // {
// // REG_INPUT_BUF[usRegIndex]++;
// // }
// // return MB_ENOERR;
// // }
// // /// CMD6、3、16命令处理回调函数
// // eMBErrorCode eMBRegHoldingCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode)
// // {
// // // 错误状态
// // eMBErrorCode eStatus = MB_ENOERR;
// // // 偏移量
// // int16_t iRegIndex;
// // // 判断寄存器是不是在范围内
// // if (((int16_t)usAddress >= REG_HOLDING_START) && (usAddress + usNRegs <= REG_HOLDING_START + REG_HOLD_SIZE))
// // {
// // // 计算偏移量
// // 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++;
// // iRegIndex++;
// // usNRegs--;
// // }
// // break;
// // }
// // }
// // else
// // {
// // // 返回错误状态
// // eStatus = MB_ENOREG;
// // }
// // return eStatus;
// // // USHORT usRegIndex = usAddress - 1;
// // // // 非法检测
// // // if((usRegIndex + usNRegs) > REG_HOLD_SIZE)
// // // {
// // // return MB_ENOREG;
// // // }
// // // // 写寄存器
// // // if(eMode == MB_REG_WRITE)
// // // {
// // // while( usNRegs > 0 )
// // // {
// // // usRegHoldingBuf[usRegIndex] = (pucRegBuffer[0] << 8) | pucRegBuffer[1];
// // // pucRegBuffer += 2;
// // // usRegIndex++;
// // // usNRegs--;
// // // }
// // // }
// // // // 读寄存器
// // // else
// // // {
// // // while( usNRegs > 0 )
// // // {
// // // *pucRegBuffer++ = ( unsigned char )( usRegHoldingBuf[usRegIndex] >> 8 );
// // // *pucRegBuffer++ = ( unsigned char )( usRegHoldingBuf[usRegIndex] & 0xFF );
// // // usRegIndex++;
// // // usNRegs--;
// // // }
// // // }
// // // return MB_ENOERR;
// // }
// // /// CMD1、5、15命令处理回调函数
// // eMBErrorCode eMBRegCoilsCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode)
// // {
// // USHORT usRegIndex = usAddress - 1;
// // UCHAR ucBits = 0;
// // UCHAR ucState = 0;
// // UCHAR ucLoops = 0;
// // // 非法检测
// // if ((usRegIndex + usNCoils) > REG_COILS_SIZE)
// // {
// // return MB_ENOREG;
// // }
// // if (eMode == MB_REG_WRITE)
// // {
// // ucLoops = (usNCoils - 1) / 8 + 1;
// // while (ucLoops != 0)
// // {
// // ucState = *pucRegBuffer++;
// // ucBits = 0;
// // while (usNCoils != 0 && ucBits < 8)
// // {
// // REG_COILS_BUF[usRegIndex++] = (ucState >> ucBits) & 0X01;
// // usNCoils--;
// // ucBits++;
// // }
// // ucLoops--;
// // }
// // }
// // else
// // {
// // ucLoops = (usNCoils - 1) / 8 + 1;
// // while (ucLoops != 0)
// // {
// // ucState = 0;
// // ucBits = 0;
// // while (usNCoils != 0 && ucBits < 8)
// // {
// // if (REG_COILS_BUF[usRegIndex])
// // {
// // ucState |= (1 << ucBits);
// // }
// // usNCoils--;
// // usRegIndex++;
// // ucBits++;
// // }
// // *pucRegBuffer++ = ucState;
// // ucLoops--;
// // }
// // }
// // return MB_ENOERR;
// // }
// // /// CMD2命令处理回调函数
// // eMBErrorCode eMBRegDiscreteCB(UCHAR *pucRegBuffer, USHORT usAddress, USHORT usNDiscrete)
// // {
// // USHORT usRegIndex = usAddress - 1;
// // UCHAR ucBits = 0;
// // UCHAR ucState = 0;
// // UCHAR ucLoops = 0;
// // // 非法检测
// // if ((usRegIndex + usNDiscrete) > REG_DISC_SIZE)
// // {
// // return MB_ENOREG;
// // }
// // ucLoops = (usNDiscrete - 1) / 8 + 1;
// // while (ucLoops != 0)
// // {
// // ucState = 0;
// // ucBits = 0;
// // while (usNDiscrete != 0 && ucBits < 8)
// // {
// // if (REG_DISC_BUF[usRegIndex])
// // {
// // ucState |= (1 << ucBits);
// // }
// // usNDiscrete--;
// // usRegIndex++;
// // ucBits++;
// // }
// // *pucRegBuffer++ = ucState;
// // ucLoops--;
// // }
// // // 模拟离散量输入被改变
// // for (usRegIndex = 0; usRegIndex < REG_DISC_SIZE; usRegIndex++)
// // {
// // REG_DISC_BUF[usRegIndex] = !REG_DISC_BUF[usRegIndex];
// // }
// // return MB_ENOERR;
// // }