Skip to content

Commit 5de9d82

Browse files
arminkarmink
committed
1、【增加】FreeModbus主机寄存器相关功能的实现，目前是异步模式，后期可以考虑支持同步模式；
2、【增加】FreeModbus主机寄存器相关测试用例，位于app_task.c； Signed-off-by: armink <[email protected]>
1 parent 3cf7da4 commit 5de9d82

File tree

4 files changed

+275
-54
lines changed

4 files changed

+275
-54
lines changed

‎APP/src/app_task.c

+4-3
Original file line numberDiff line numberDiff line change
@@ -48,9 +48,10 @@ void thread_entry_SysMonitor(void* parameter)
4848
//Test Modbus Master
4949
usModbusUserData[0] = (USHORT)(rt_tick_get()/10);
5050
usModbusUserData[1] = (USHORT)(rt_tick_get()%10);
51-
// eMBMasterFuncWriteHoldingRegister(1,usModbusUserData,3);
52-
// eMBMasterFuncWriteMultipleHoldingRegister(1,usModbusUserData,3,2);
53-
eMBMasterReqReadHoldingRegister(1,3,2);
51+
eMBMasterReqWriteHoldingRegister(1,usModbusUserData,3);
52+
// eMBMasterReqWriteMultipleHoldingRegister(1,usModbusUserData,3,2);
53+
// eMBMasterReqReadHoldingRegister(1,3,2);
54+
// eMBMasterReqReadWriteMultipleHoldingRegister(1,usModbusUserData,3,2,5,2);
5455
}
5556
}
5657

‎FreeModbus/modbus/functions/mbfuncholding_m.c

+240-47
Original file line numberDiff line numberDiff line change
@@ -43,31 +43,44 @@
4343
#include "mbconfig.h"
4444

4545
/* ----------------------- Defines ------------------------------------------*/
46-
#define MB_PDU_FUNC_READ_ADDR_OFF ( MB_PDU_DATA_OFF + 0)
47-
#define MB_PDU_FUNC_READ_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
48-
#define MB_PDU_FUNC_READ_SIZE ( 4 )
46+
#define MB_PDU_REQ_READ_ADDR_OFF ( MB_PDU_DATA_OFF + 0 )
47+
#define MB_PDU_REQ_READ_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
48+
#define MB_PDU_REQ_READ_SIZE ( 4 )
4949
#define MB_PDU_FUNC_READ_REGCNT_MAX ( 0x007D )
50+
#define MB_PDU_FUNC_READ_BYTECNT_OFF ( MB_PDU_DATA_OFF + 0 )
51+
#define MB_PDU_FUNC_READ_VALUES_OFF ( MB_PDU_DATA_OFF + 1 )
52+
#define MB_PDU_FUNC_READ_SIZE_MIN ( 1 )
5053

54+
#define MB_PDU_REQ_WRITE_ADDR_OFF ( MB_PDU_DATA_OFF + 0)
55+
#define MB_PDU_REQ_WRITE_VALUE_OFF ( MB_PDU_DATA_OFF + 2 )
56+
#define MB_PDU_REQ_WRITE_SIZE ( 4 )
5157
#define MB_PDU_FUNC_WRITE_ADDR_OFF ( MB_PDU_DATA_OFF + 0)
5258
#define MB_PDU_FUNC_WRITE_VALUE_OFF ( MB_PDU_DATA_OFF + 2 )
5359
#define MB_PDU_FUNC_WRITE_SIZE ( 4 )
5460

61+
#define MB_PDU_REQ_WRITE_MUL_ADDR_OFF ( MB_PDU_DATA_OFF + 0 )
62+
#define MB_PDU_REQ_WRITE_MUL_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
63+
#define MB_PDU_REQ_WRITE_MUL_BYTECNT_OFF ( MB_PDU_DATA_OFF + 4 )
64+
#define MB_PDU_REQ_WRITE_MUL_VALUES_OFF ( MB_PDU_DATA_OFF + 5 )
65+
#define MB_PDU_REQ_WRITE_MUL_SIZE_MIN ( 5 )
66+
#define MB_PDU_REQ_WRITE_MUL_REGCNT_MAX ( 0x0078 )
5567
#define MB_PDU_FUNC_WRITE_MUL_ADDR_OFF ( MB_PDU_DATA_OFF + 0 )
5668
#define MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
57-
#define MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF ( MB_PDU_DATA_OFF + 4 )
58-
#define MB_PDU_FUNC_WRITE_MUL_VALUES_OFF ( MB_PDU_DATA_OFF + 5 )
59-
#define MB_PDU_FUNC_WRITE_MUL_SIZE_MIN ( 5 )
60-
#define MB_PDU_FUNC_WRITE_MUL_REGCNT_MAX ( 0x0078 )
61-
62-
#define MB_PDU_FUNC_READWRITE_READ_ADDR_OFF ( MB_PDU_DATA_OFF + 0 )
63-
#define MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
64-
#define MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF ( MB_PDU_DATA_OFF + 4 )
65-
#define MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF ( MB_PDU_DATA_OFF + 6 )
66-
#define MB_PDU_FUNC_READWRITE_BYTECNT_OFF ( MB_PDU_DATA_OFF + 8 )
67-
#define MB_PDU_FUNC_READWRITE_WRITE_VALUES_OFF ( MB_PDU_DATA_OFF + 9 )
68-
#define MB_PDU_FUNC_READWRITE_SIZE_MIN ( 9 )
69+
#define MB_PDU_FUNC_WRITE_MUL_SIZE ( 4 )
70+
71+
#define MB_PDU_REQ_READWRITE_READ_ADDR_OFF ( MB_PDU_DATA_OFF + 0 )
72+
#define MB_PDU_REQ_READWRITE_READ_REGCNT_OFF ( MB_PDU_DATA_OFF + 2 )
73+
#define MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF ( MB_PDU_DATA_OFF + 4 )
74+
#define MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF ( MB_PDU_DATA_OFF + 6 )
75+
#define MB_PDU_REQ_READWRITE_WRITE_BYTECNT_OFF ( MB_PDU_DATA_OFF + 8 )
76+
#define MB_PDU_REQ_READWRITE_WRITE_VALUES_OFF ( MB_PDU_DATA_OFF + 9 )
77+
#define MB_PDU_REQ_READWRITE_SIZE_MIN ( 9 )
78+
#define MB_PDU_FUNC_READWRITE_READ_BYTECNT_OFF ( MB_PDU_DATA_OFF + 0 )
79+
#define MB_PDU_FUNC_READWRITE_READ_VALUES_OFF ( MB_PDU_DATA_OFF + 1 )
80+
#define MB_PDU_FUNC_READWRITE_SIZE_MIN ( 1 )
6981

7082
/* ----------------------- Static functions ---------------------------------*/
83+
eMBException prveMBError2Exception( eMBErrorCode eErrorCode );
7184

7285
/* ----------------------- Start implementation -----------------------------*/
7386
#if MB_MASTER_RTU_ENABLED > 0 || MB_MASTER_ASCII_ENABLED > 0
@@ -86,21 +99,53 @@ eMBMasterReqWriteHoldingRegister( UCHAR ucSndAddr, USHORT * pusDataBuffer, USHOR
8699
vMBMasterGetPDUSndBuf(&ucMBFrame);
87100
vMBMasterSetDestAddress(ucSndAddr);
88101
ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_REGISTER;
89-
ucMBFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] = usRegAddr >> 8;
90-
ucMBFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1] = usRegAddr;
91-
ucMBFrame[MB_PDU_FUNC_WRITE_VALUE_OFF] = pusDataBuffer[0] >> 8;
92-
ucMBFrame[MB_PDU_FUNC_WRITE_VALUE_OFF + 1] = pusDataBuffer[0] ;
93-
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_FUNC_WRITE_SIZE );
102+
ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF] = usRegAddr >> 8;
103+
ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF + 1] = usRegAddr;
104+
ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF] = pusDataBuffer[0] >> 8;
105+
ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF + 1] = pusDataBuffer[0] ;
106+
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_SIZE );
94107
( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT );
95108
}
96109
return eErrStatus;
97110
}
111+
112+
eMBException
113+
eMBMasterFuncWriteHoldingRegister( UCHAR * pucFrame, USHORT * usLen )
114+
{
115+
USHORT usRegAddress;
116+
eMBException eStatus = MB_EX_NONE;
117+
eMBErrorCode eRegStatus;
118+
119+
if( *usLen == ( MB_PDU_SIZE_MIN + MB_PDU_FUNC_WRITE_SIZE ) )
120+
{
121+
usRegAddress = ( USHORT )( pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF] << 8 );
122+
usRegAddress |= ( USHORT )( pucFrame[MB_PDU_FUNC_WRITE_ADDR_OFF + 1] );
123+
usRegAddress++;
124+
125+
/* Make callback to update the value. */
126+
eRegStatus = eMBRegHoldingCB( &pucFrame[MB_PDU_FUNC_WRITE_VALUE_OFF],
127+
usRegAddress, 1, MB_REG_WRITE );
128+
129+
/* If an error occured convert it into a Modbus exception. */
130+
if( eRegStatus != MB_ENOERR )
131+
{
132+
eStatus = prveMBError2Exception( eRegStatus );
133+
}
134+
}
135+
else
136+
{
137+
/* Can't be a valid request because the length is incorrect. */
138+
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
139+
}
140+
return eStatus;
141+
}
98142
#endif
99143

100144
#if MB_FUNC_WRITE_MULTIPLE_HOLDING_ENABLED > 0
101145

102146
eMBMasterReqErrCode
103-
eMBMasterReqWriteMultipleHoldingRegister( UCHAR ucSndAddr,USHORT * pusDataBuffer, USHORT usRegAddr, USHORT usNRegs )
147+
eMBMasterReqWriteMultipleHoldingRegister(UCHAR ucSndAddr,
148+
USHORT * pusDataBuffer, USHORT usRegAddr, USHORT usNRegs)
104149
{
105150
UCHAR *ucMBFrame;
106151
USHORT usRegIndex = 0;
@@ -112,23 +157,72 @@ eMBMasterReqWriteMultipleHoldingRegister( UCHAR ucSndAddr,USHORT * pusDataBuffer
112157
{
113158
vMBMasterGetPDUSndBuf(&ucMBFrame);
114159
vMBMasterSetDestAddress(ucSndAddr);
115-
ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_MULTIPLE_REGISTERS;
116-
ucMBFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF] = usRegAddr >> 8;
117-
ucMBFrame[MB_PDU_FUNC_WRITE_MUL_ADDR_OFF + 1] = usRegAddr;
118-
ucMBFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF] = usNRegs >> 8;
119-
ucMBFrame[MB_PDU_FUNC_WRITE_MUL_REGCNT_OFF + 1] = usNRegs ;
120-
ucMBFrame[MB_PDU_FUNC_WRITE_MUL_BYTECNT_OFF] = usNRegs * 2;
121-
ucMBFrame += MB_PDU_FUNC_WRITE_MUL_VALUES_OFF;
160+
ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_MULTIPLE_REGISTERS;
161+
ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF] = usRegAddr >> 8;
162+
ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF + 1] = usRegAddr;
163+
ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF] = usNRegs >> 8;
164+
ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF + 1] = usNRegs ;
165+
ucMBFrame[MB_PDU_REQ_WRITE_MUL_BYTECNT_OFF] = usNRegs * 2;
166+
ucMBFrame += MB_PDU_REQ_WRITE_MUL_VALUES_OFF;
122167
while( usNRegs > usRegIndex)
123168
{
124169
*ucMBFrame++ = pusDataBuffer[usRegIndex] >> 8;
125170
*ucMBFrame++ = pusDataBuffer[usRegIndex++] ;
126171
}
127-
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_FUNC_WRITE_MUL_SIZE_MIN + 2*usNRegs );
172+
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_MUL_SIZE_MIN + 2*usNRegs );
128173
( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT );
129174
}
130175
return eErrStatus;
131176
}
177+
178+
eMBException
179+
eMBMasterFuncWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen )
180+
{
181+
UCHAR *ucMBFrame;
182+
USHORT usRegAddress;
183+
USHORT usRegCount;
184+
UCHAR ucRegByteCount;
185+
186+
eMBException eStatus = MB_EX_NONE;
187+
eMBErrorCode eRegStatus;
188+
189+
if( *usLen == MB_PDU_SIZE_MIN + MB_PDU_FUNC_WRITE_MUL_SIZE )
190+
{
191+
vMBMasterGetPDUSndBuf(&ucMBFrame);
192+
usRegAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF] << 8 );
193+
usRegAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF + 1] );
194+
usRegAddress++;
195+
196+
usRegCount = ( USHORT )( ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF] << 8 );
197+
usRegCount |= ( USHORT )( ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF + 1] );
198+
199+
ucRegByteCount = ucMBFrame[MB_PDU_REQ_WRITE_MUL_BYTECNT_OFF];
200+
201+
if( ucRegByteCount == 2 * usRegCount )
202+
{
203+
/* Make callback to update the register values. */
204+
eRegStatus =
205+
eMBRegHoldingCB( &ucMBFrame[MB_PDU_REQ_WRITE_MUL_VALUES_OFF],
206+
usRegAddress, usRegCount, MB_REG_WRITE );
207+
208+
/* If an error occured convert it into a Modbus exception. */
209+
if( eRegStatus != MB_ENOERR )
210+
{
211+
eStatus = prveMBError2Exception( eRegStatus );
212+
}
213+
}
214+
else
215+
{
216+
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
217+
}
218+
}
219+
else
220+
{
221+
/* Can't be a valid request because the length is incorrect. */
222+
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
223+
}
224+
return eStatus;
225+
}
132226
#endif
133227

134228
#if MB_FUNC_READ_HOLDING_ENABLED > 0
@@ -146,23 +240,69 @@ eMBMasterReqReadHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usNRe
146240
vMBMasterGetPDUSndBuf(&ucMBFrame);
147241
vMBMasterSetDestAddress(ucSndAddr);
148242
ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_HOLDING_REGISTER;
149-
ucMBFrame[MB_PDU_FUNC_READ_ADDR_OFF] = usRegAddr >> 8;
150-
ucMBFrame[MB_PDU_FUNC_READ_ADDR_OFF + 1] = usRegAddr;
151-
ucMBFrame[MB_PDU_FUNC_READ_REGCNT_OFF] = usNRegs >> 8;
152-
ucMBFrame[MB_PDU_FUNC_READ_REGCNT_OFF + 1] = usNRegs;
153-
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_FUNC_READ_SIZE );
243+
ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usRegAddr >> 8;
244+
ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usRegAddr;
245+
ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF] = usNRegs >> 8;
246+
ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF + 1] = usNRegs;
247+
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE );
154248
( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT );
155249
}
156250
return eErrStatus;
157251
}
158252

253+
eMBException
254+
eMBMasterFuncReadHoldingRegister( UCHAR * pucFrame, USHORT * usLen )
255+
{
256+
UCHAR *ucMBFrame;
257+
USHORT usRegAddress;
258+
USHORT usRegCount;
259+
260+
eMBException eStatus = MB_EX_NONE;
261+
eMBErrorCode eRegStatus;
262+
263+
if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READ_SIZE_MIN)
264+
{
265+
vMBMasterGetPDUSndBuf(&ucMBFrame);
266+
usRegAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] << 8 );
267+
usRegAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] );
268+
usRegAddress++;
269+
270+
usRegCount = ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF] << 8 );
271+
usRegCount = ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF + 1] );
272+
273+
/* Check if the number of registers to read is valid. If not
274+
* return Modbus illegal data value exception.
275+
*/
276+
if( ( usRegCount >= 1 ) && ( 2 * usRegCount == pucFrame[MB_PDU_FUNC_READ_BYTECNT_OFF] ) )
277+
{
278+
/* Make callback to fill the buffer. */
279+
eRegStatus = eMBRegHoldingCB( &pucFrame[MB_PDU_FUNC_READ_VALUES_OFF], usRegAddress, usRegCount, MB_REG_READ );
280+
/* If an error occured convert it into a Modbus exception. */
281+
if( eRegStatus != MB_ENOERR )
282+
{
283+
eStatus = prveMBError2Exception( eRegStatus );
284+
}
285+
}
286+
else
287+
{
288+
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
289+
}
290+
}
291+
else
292+
{
293+
/* Can't be a valid request because the length is incorrect. */
294+
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
295+
}
296+
return eStatus;
297+
}
298+
159299
#endif
160300

161301
#if MB_FUNC_READWRITE_HOLDING_ENABLED > 0
162302

163303
eMBMasterReqErrCode
164-
eMBMasterReqReadWriteMultipleHoldingRegister( UCHAR ucSndAddr,USHORT * pusDataBuffer, USHORT usReadRegAddr, USHORT usNReadRegs ,
165-
USHORT usWriteRegAddr, USHORT usNWriteRegs)
304+
eMBMasterReqReadWriteMultipleHoldingRegister(UCHAR ucSndAddr, USHORT * pusDataBuffer, USHORT usWriteRegAddr,
305+
USHORT usNWriteRegs, USHORT usReadRegAddr, USHORT usNReadRegs)
166306
{
167307
UCHAR *ucMBFrame;
168308
USHORT usRegIndex = 0;
@@ -175,27 +315,80 @@ eMBMasterReqReadWriteMultipleHoldingRegister( UCHAR ucSndAddr,USHORT * pusDataBu
175315
vMBMasterGetPDUSndBuf(&ucMBFrame);
176316
vMBMasterSetDestAddress(ucSndAddr);
177317
ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READWRITE_MULTIPLE_REGISTERS;
178-
ucMBFrame[MB_PDU_FUNC_READWRITE_READ_ADDR_OFF] = usReadRegAddr >> 8;
179-
ucMBFrame[MB_PDU_FUNC_READWRITE_READ_ADDR_OFF + 1] = usReadRegAddr;
180-
ucMBFrame[MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF] = usNReadRegs >> 8;
181-
ucMBFrame[MB_PDU_FUNC_READWRITE_READ_REGCNT_OFF + 1] = usNReadRegs ;
182-
ucMBFrame[MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF] = usWriteRegAddr >> 8;
183-
ucMBFrame[MB_PDU_FUNC_READWRITE_WRITE_ADDR_OFF + 1] = usWriteRegAddr;
184-
ucMBFrame[MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF] = usNWriteRegs >> 8;
185-
ucMBFrame[MB_PDU_FUNC_READWRITE_WRITE_REGCNT_OFF + 1] = usNWriteRegs ;
186-
ucMBFrame[MB_PDU_FUNC_READWRITE_BYTECNT_OFF] = usNWriteRegs * 2;
187-
ucMBFrame += MB_PDU_FUNC_READWRITE_WRITE_VALUES_OFF;
318+
ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF] = usReadRegAddr >> 8;
319+
ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF + 1] = usReadRegAddr;
320+
ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF] = usNReadRegs >> 8;
321+
ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF + 1] = usNReadRegs ;
322+
ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF] = usWriteRegAddr >> 8;
323+
ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF + 1] = usWriteRegAddr;
324+
ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF] = usNWriteRegs >> 8;
325+
ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF + 1] = usNWriteRegs ;
326+
ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_BYTECNT_OFF] = usNWriteRegs * 2;
327+
ucMBFrame += MB_PDU_REQ_READWRITE_WRITE_VALUES_OFF;
188328
while( usNWriteRegs > usRegIndex)
189329
{
190330
*ucMBFrame++ = pusDataBuffer[usRegIndex] >> 8;
191331
*ucMBFrame++ = pusDataBuffer[usRegIndex++] ;
192332
}
193-
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_FUNC_READWRITE_SIZE_MIN + 2*usNWriteRegs );
333+
vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READWRITE_SIZE_MIN + 2*usNWriteRegs );
194334
( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT );
195335
}
196336
return eErrStatus;
197337
}
198338

339+
eMBException
340+
eMBMasterFuncReadWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen )
341+
{
342+
USHORT usRegReadAddress;
343+
USHORT usRegReadCount;
344+
USHORT usRegWriteAddress;
345+
USHORT usRegWriteCount;
346+
UCHAR *ucMBFrame;
347+
348+
eMBException eStatus = MB_EX_NONE;
349+
eMBErrorCode eRegStatus;
350+
351+
if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READWRITE_SIZE_MIN)
352+
{
353+
vMBMasterGetPDUSndBuf(&ucMBFrame);
354+
usRegReadAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF] << 8U );
355+
usRegReadAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF + 1] );
356+
usRegReadAddress++;
357+
358+
usRegReadCount = ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF] << 8U );
359+
usRegReadCount |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF + 1] );
360+
361+
usRegWriteAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF] << 8U );
362+
usRegWriteAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF + 1] );
363+
usRegWriteAddress++;
364+
365+
usRegWriteCount = ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF] << 8U );
366+
usRegWriteCount |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF + 1] );
367+
368+
if( ( 2 * usRegReadCount ) == pucFrame[MB_PDU_FUNC_READWRITE_READ_BYTECNT_OFF] )
369+
{
370+
/* Make callback to update the register values. */
371+
eRegStatus = eMBRegHoldingCB( &ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_VALUES_OFF],
372+
usRegWriteAddress, usRegWriteCount, MB_REG_WRITE );
373+
374+
if( eRegStatus == MB_ENOERR )
375+
{
376+
/* Make the read callback. */
377+
eRegStatus = eMBRegHoldingCB(&pucFrame[MB_PDU_FUNC_READWRITE_READ_VALUES_OFF],
378+
usRegReadAddress, usRegReadCount, MB_REG_READ);
379+
}
380+
if( eRegStatus != MB_ENOERR )
381+
{
382+
eStatus = prveMBError2Exception( eRegStatus );
383+
}
384+
}
385+
else
386+
{
387+
eStatus = MB_EX_ILLEGAL_DATA_VALUE;
388+
}
389+
}
390+
return eStatus;
391+
}
199392
#endif
200393
#endif
201394

0 commit comments

Comments
 (0)