Statistics
| Branch: | Revision:

root / freemodbus / modbus / include / mb.h @ 20e5429c

History | View | Annotate | Download (19.3 KB)

1
/* 
2
 * FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
3
 * Copyright (c) 2006 Christian Walter <wolti@sil.at>
4
 * All rights reserved.
5
 *
6
 * Redistribution and use in source and binary forms, with or without
7
 * modification, are permitted provided that the following conditions
8
 * are met:
9
 * 1. Redistributions of source code must retain the above copyright
10
 *    notice, this list of conditions and the following disclaimer.
11
 * 2. Redistributions in binary form must reproduce the above copyright
12
 *    notice, this list of conditions and the following disclaimer in the
13
 *    documentation and/or other materials provided with the distribution.
14
 * 3. The name of the author may not be used to endorse or promote products
15
 *    derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 *
28
 * File: $Id: mb.h,v 1.17 2006/12/07 22:10:34 wolti Exp $
29
 */
30

    
31
#ifndef _MB_H
32
#define _MB_H
33

    
34
#include "port.h"
35

    
36
#ifdef __cplusplus
37
PR_BEGIN_EXTERN_C
38
#endif
39

    
40
#include "mbport.h"
41
#include "mbproto.h"
42

    
43
/*! \defgroup modbus Modbus
44
 * \code #include "mb.h" \endcode
45
 *
46
 * This module defines the interface for the application. It contains
47
 * the basic functions and types required to use the Modbus protocol stack.
48
 * A typical application will want to call eMBInit() first. If the device
49
 * is ready to answer network requests it must then call eMBEnable() to activate
50
 * the protocol stack. In the main loop the function eMBPoll() must be called
51
 * periodically. The time interval between pooling depends on the configured
52
 * Modbus timeout. If an RTOS is available a separate task should be created
53
 * and the task should always call the function eMBPoll().
54
 *
55
 * \code
56
 * // Initialize protocol stack in RTU mode for a slave with address 10 = 0x0A
57
 * eMBInit( MB_RTU, 0x0A, 38400, MB_PAR_EVEN );
58
 * // Enable the Modbus Protocol Stack.
59
 * eMBEnable(  );
60
 * for( ;; )
61
 * {
62
 *     // Call the main polling loop of the Modbus protocol stack.
63
 *     eMBPoll(  );
64
 *     ...
65
 * }
66
 * \endcode
67
 */
68

    
69
/* ----------------------- Defines ------------------------------------------*/
70

    
71
/*! \ingroup modbus
72
 * \brief Use the default Modbus TCP port (502)
73
 */
74
#define MB_TCP_PORT_USE_DEFAULT 0   
75

    
76
/* ----------------------- Type definitions ---------------------------------*/
77

    
78
/*! \ingroup modbus
79
 * \brief Modbus serial transmission modes (RTU/ASCII).
80
 *
81
 * Modbus serial supports two transmission modes. Either ASCII or RTU. RTU
82
 * is faster but has more hardware requirements and requires a network with
83
 * a low jitter. ASCII is slower and more reliable on slower links (E.g. modems)
84
 */
85
    typedef enum
86
{
87
    MB_RTU,                     /*!< RTU transmission mode. */
88
    MB_ASCII,                   /*!< ASCII transmission mode. */
89
    MB_TCP                      /*!< TCP mode. */
90
} eMBMode;
91

    
92
/*! \ingroup modbus
93
 * \brief If register should be written or read.
94
 *
95
 * This value is passed to the callback functions which support either
96
 * reading or writing register values. Writing means that the application
97
 * registers should be updated and reading means that the modbus protocol
98
 * stack needs to know the current register values.
99
 *
100
 * \see eMBRegHoldingCB( ), eMBRegCoilsCB( ), eMBRegDiscreteCB( ) and 
101
 *   eMBRegInputCB( ).
102
 */
103
typedef enum
104
{
105
    MB_REG_READ,                /*!< Read register values and pass to protocol stack. */
106
    MB_REG_WRITE                /*!< Update register values. */
107
} eMBRegisterMode;
108

    
109
/*! \ingroup modbus
110
 * \brief Errorcodes used by all function in the protocol stack.
111
 */
112
typedef enum
113
{
114
    MB_ENOERR,                  /*!< no error. */
115
    MB_ENOREG,                  /*!< illegal register address. */
116
    MB_EINVAL,                  /*!< illegal argument. */
117
    MB_EPORTERR,                /*!< porting layer error. */
118
    MB_ENORES,                  /*!< insufficient resources. */
119
    MB_EIO,                     /*!< I/O error. */
120
    MB_EILLSTATE,               /*!< protocol stack in illegal state. */
121
    MB_ETIMEDOUT                /*!< timeout error occurred. */
122
} eMBErrorCode;
123

    
124

    
125
/* ----------------------- Function prototypes ------------------------------*/
126
/*! \ingroup modbus
127
 * \brief Initialize the Modbus protocol stack.
128
 *
129
 * This functions initializes the ASCII or RTU module and calls the
130
 * init functions of the porting layer to prepare the hardware. Please
131
 * note that the receiver is still disabled and no Modbus frames are
132
 * processed until eMBEnable( ) has been called.
133
 *
134
 * \param eMode If ASCII or RTU mode should be used.
135
 * \param ucSlaveAddress The slave address. Only frames sent to this
136
 *   address or to the broadcast address are processed.
137
 * \param ucPort The port to use. E.g. 1 for COM1 on windows. This value
138
 *   is platform dependent and some ports simply choose to ignore it.
139
 * \param ulBaudRate The baudrate. E.g. 19200. Supported baudrates depend
140
 *   on the porting layer.
141
 * \param eParity Parity used for serial transmission.
142
 *
143
 * \return If no error occurs the function returns eMBErrorCode::MB_ENOERR.
144
 *   The protocol is then in the disabled state and ready for activation
145
 *   by calling eMBEnable( ). Otherwise one of the following error codes 
146
 *   is returned:
147
 *    - eMBErrorCode::MB_EINVAL If the slave address was not valid. Valid
148
 *        slave addresses are in the range 1 - 247.
149
 *    - eMBErrorCode::MB_EPORTERR IF the porting layer returned an error.
150
 */
151
eMBErrorCode    eMBInit( eMBMode eMode, UCHAR ucSlaveAddress,
152
                         UCHAR ucPort, ULONG ulBaudRate, eMBParity eParity );
153

    
154
/*! \ingroup modbus
155
 * \brief Initialize the Modbus protocol stack for Modbus TCP.
156
 *
157
 * This function initializes the Modbus TCP Module. Please note that
158
 * frame processing is still disabled until eMBEnable( ) is called.
159
 *
160
 * \param usTCPPort The TCP port to listen on.
161
 * \return If the protocol stack has been initialized correctly the function
162
 *   returns eMBErrorCode::MB_ENOERR. Otherwise one of the following error
163
 *   codes is returned:
164
 *    - eMBErrorCode::MB_EINVAL If the slave address was not valid. Valid
165
 *        slave addresses are in the range 1 - 247.
166
 *    - eMBErrorCode::MB_EPORTERR IF the porting layer returned an error.
167
 */
168
eMBErrorCode    eMBTCPInit( USHORT usTCPPort );
169

    
170
/*! \ingroup modbus
171
 * \brief Release resources used by the protocol stack.
172
 *
173
 * This function disables the Modbus protocol stack and release all
174
 * hardware resources. It must only be called when the protocol stack 
175
 * is disabled. 
176
 *
177
 * \note Note all ports implement this function. A port which wants to 
178
 *   get an callback must define the macro MB_PORT_HAS_CLOSE to 1.
179
 *
180
 * \return If the resources where released it return eMBErrorCode::MB_ENOERR.
181
 *   If the protocol stack is not in the disabled state it returns
182
 *   eMBErrorCode::MB_EILLSTATE.
183
 */
184
eMBErrorCode    eMBClose( void );
185

    
186
/*! \ingroup modbus
187
 * \brief Enable the Modbus protocol stack.
188
 *
189
 * This function enables processing of Modbus frames. Enabling the protocol
190
 * stack is only possible if it is in the disabled state.
191
 *
192
 * \return If the protocol stack is now in the state enabled it returns 
193
 *   eMBErrorCode::MB_ENOERR. If it was not in the disabled state it 
194
 *   return eMBErrorCode::MB_EILLSTATE.
195
 */
196
eMBErrorCode    eMBEnable( void );
197

    
198
/*! \ingroup modbus
199
 * \brief Disable the Modbus protocol stack.
200
 *
201
 * This function disables processing of Modbus frames.
202
 *
203
 * \return If the protocol stack has been disabled it returns 
204
 *  eMBErrorCode::MB_ENOERR. If it was not in the enabled state it returns
205
 *  eMBErrorCode::MB_EILLSTATE.
206
 */
207
eMBErrorCode    eMBDisable( void );
208

    
209
/*! \ingroup modbus
210
 * \brief The main pooling loop of the Modbus protocol stack.
211
 *
212
 * This function must be called periodically. The timer interval required
213
 * is given by the application dependent Modbus slave timeout. Internally the
214
 * function calls xMBPortEventGet() and waits for an event from the receiver or
215
 * transmitter state machines. 
216
 *
217
 * \return If the protocol stack is not in the enabled state the function
218
 *   returns eMBErrorCode::MB_EILLSTATE. Otherwise it returns 
219
 *   eMBErrorCode::MB_ENOERR.
220
 */
221
eMBErrorCode    eMBPoll( void );
222

    
223
/*! \ingroup modbus
224
 * \brief Configure the slave id of the device.
225
 *
226
 * This function should be called when the Modbus function <em>Report Slave ID</em>
227
 * is enabled ( By defining MB_FUNC_OTHER_REP_SLAVEID_ENABLED in mbconfig.h ).
228
 *
229
 * \param ucSlaveID Values is returned in the <em>Slave ID</em> byte of the
230
 *   <em>Report Slave ID</em> response.
231
 * \param xIsRunning If TRUE the <em>Run Indicator Status</em> byte is set to 0xFF.
232
 *   otherwise the <em>Run Indicator Status</em> is 0x00.
233
 * \param pucAdditional Values which should be returned in the <em>Additional</em>
234
 *   bytes of the <em> Report Slave ID</em> response.
235
 * \param usAdditionalLen Length of the buffer <code>pucAdditonal</code>.
236
 *
237
 * \return If the static buffer defined by MB_FUNC_OTHER_REP_SLAVEID_BUF in
238
 *   mbconfig.h is to small it returns eMBErrorCode::MB_ENORES. Otherwise
239
 *   it returns eMBErrorCode::MB_ENOERR.
240
 */
241
eMBErrorCode    eMBSetSlaveID( UCHAR ucSlaveID, BOOL xIsRunning,
242
                               UCHAR const *pucAdditional,
243
                               USHORT usAdditionalLen );
244

    
245
/*! \ingroup modbus
246
 * \brief Registers a callback handler for a given function code.
247
 *
248
 * This function registers a new callback handler for a given function code.
249
 * The callback handler supplied is responsible for interpreting the Modbus PDU and
250
 * the creation of an appropriate response. In case of an error it should return
251
 * one of the possible Modbus exceptions which results in a Modbus exception frame
252
 * sent by the protocol stack. 
253
 *
254
 * \param ucFunctionCode The Modbus function code for which this handler should
255
 *   be registers. Valid function codes are in the range 1 to 127.
256
 * \param pxHandler The function handler which should be called in case
257
 *   such a frame is received. If \c NULL a previously registered function handler
258
 *   for this function code is removed.
259
 *
260
 * \return eMBErrorCode::MB_ENOERR if the handler has been installed. If no
261
 *   more resources are available it returns eMBErrorCode::MB_ENORES. In this
262
 *   case the values in mbconfig.h should be adjusted. If the argument was not
263
 *   valid it returns eMBErrorCode::MB_EINVAL.
264
 */
265
eMBErrorCode    eMBRegisterCB( UCHAR ucFunctionCode, 
266
                               pxMBFunctionHandler pxHandler );
267

    
268
/* ----------------------- Callback -----------------------------------------*/
269

    
270
/*! \defgroup modbus_registers Modbus Registers
271
 * \code #include "mb.h" \endcode
272
 * The protocol stack does not internally allocate any memory for the
273
 * registers. This makes the protocol stack very small and also usable on
274
 * low end targets. In addition the values don't have to be in the memory
275
 * and could for example be stored in a flash.<br>
276
 * Whenever the protocol stack requires a value it calls one of the callback
277
 * function with the register address and the number of registers to read
278
 * as an argument. The application should then read the actual register values
279
 * (for example the ADC voltage) and should store the result in the supplied
280
 * buffer.<br>
281
 * If the protocol stack wants to update a register value because a write
282
 * register function was received a buffer with the new register values is
283
 * passed to the callback function. The function should then use these values
284
 * to update the application register values.
285
 */
286

    
287
/*! \ingroup modbus_registers
288
 * \brief Callback function used if the value of a <em>Input Register</em>
289
 *   is required by the protocol stack. The starting register address is given
290
 *   by \c usAddress and the last register is given by <tt>usAddress +
291
 *   usNRegs - 1</tt>.
292
 *
293
 * \param pucRegBuffer A buffer where the callback function should write
294
 *   the current value of the modbus registers to.
295
 * \param usAddress The starting address of the register. Input registers
296
 *   are in the range 1 - 65535.
297
 * \param usNRegs Number of registers the callback function must supply.
298
 *
299
 * \return The function must return one of the following error codes:
300
 *   - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
301
 *       Modbus response is sent.
302
 *   - eMBErrorCode::MB_ENOREG If the application can not supply values
303
 *       for registers within this range. In this case a 
304
 *       <b>ILLEGAL DATA ADDRESS</b> exception frame is sent as a response.
305
 *   - eMBErrorCode::MB_ETIMEDOUT If the requested register block is
306
 *       currently not available and the application dependent response
307
 *       timeout would be violated. In this case a <b>SLAVE DEVICE BUSY</b>
308
 *       exception is sent as a response.
309
 *   - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case
310
 *       a <b>SLAVE DEVICE FAILURE</b> exception is sent as a response.
311
 */
312
eMBErrorCode    eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress,
313
                               USHORT usNRegs );
314

    
315
/*! \ingroup modbus_registers
316
 * \brief Callback function used if a <em>Holding Register</em> value is
317
 *   read or written by the protocol stack. The starting register address
318
 *   is given by \c usAddress and the last register is given by
319
 *   <tt>usAddress + usNRegs - 1</tt>.
320
 *
321
 * \param pucRegBuffer If the application registers values should be updated the
322
 *   buffer points to the new registers values. If the protocol stack needs
323
 *   to now the current values the callback function should write them into
324
 *   this buffer.
325
 * \param usAddress The starting address of the register.
326
 * \param usNRegs Number of registers to read or write.
327
 * \param eMode If eMBRegisterMode::MB_REG_WRITE the application register 
328
 *   values should be updated from the values in the buffer. For example
329
 *   this would be the case when the Modbus master has issued an 
330
 *   <b>WRITE SINGLE REGISTER</b> command.
331
 *   If the value eMBRegisterMode::MB_REG_READ the application should copy 
332
 *   the current values into the buffer \c pucRegBuffer.
333
 *
334
 * \return The function must return one of the following error codes:
335
 *   - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
336
 *       Modbus response is sent.
337
 *   - eMBErrorCode::MB_ENOREG If the application can not supply values
338
 *       for registers within this range. In this case a 
339
 *       <b>ILLEGAL DATA ADDRESS</b> exception frame is sent as a response.
340
 *   - eMBErrorCode::MB_ETIMEDOUT If the requested register block is
341
 *       currently not available and the application dependent response
342
 *       timeout would be violated. In this case a <b>SLAVE DEVICE BUSY</b>
343
 *       exception is sent as a response.
344
 *   - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case
345
 *       a <b>SLAVE DEVICE FAILURE</b> exception is sent as a response.
346
 */
347
eMBErrorCode    eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress,
348
                                 USHORT usNRegs, eMBRegisterMode eMode );
349

    
350
/*! \ingroup modbus_registers
351
 * \brief Callback function used if a <em>Coil Register</em> value is
352
 *   read or written by the protocol stack. If you are going to use
353
 *   this function you might use the functions xMBUtilSetBits(  ) and
354
 *   xMBUtilGetBits(  ) for working with bitfields.
355
 *
356
 * \param pucRegBuffer The bits are packed in bytes where the first coil
357
 *   starting at address \c usAddress is stored in the LSB of the
358
 *   first byte in the buffer <code>pucRegBuffer</code>.
359
 *   If the buffer should be written by the callback function unused
360
 *   coil values (I.e. if not a multiple of eight coils is used) should be set
361
 *   to zero.
362
 * \param usAddress The first coil number.
363
 * \param usNCoils Number of coil values requested.
364
 * \param eMode If eMBRegisterMode::MB_REG_WRITE the application values should
365
 *   be updated from the values supplied in the buffer \c pucRegBuffer.
366
 *   If eMBRegisterMode::MB_REG_READ the application should store the current
367
 *   values in the buffer \c pucRegBuffer.
368
 *
369
 * \return The function must return one of the following error codes:
370
 *   - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
371
 *       Modbus response is sent.
372
 *   - eMBErrorCode::MB_ENOREG If the application does not map an coils
373
 *       within the requested address range. In this case a 
374
 *       <b>ILLEGAL DATA ADDRESS</b> is sent as a response.
375
 *   - eMBErrorCode::MB_ETIMEDOUT If the requested register block is
376
 *       currently not available and the application dependent response
377
 *       timeout would be violated. In this case a <b>SLAVE DEVICE BUSY</b>
378
 *       exception is sent as a response.
379
 *   - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case
380
 *       a <b>SLAVE DEVICE FAILURE</b> exception is sent as a response.
381
 */
382
eMBErrorCode    eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress,
383
                               USHORT usNCoils, eMBRegisterMode eMode );
384

    
385
/*! \ingroup modbus_registers
386
 * \brief Callback function used if a <em>Input Discrete Register</em> value is
387
 *   read by the protocol stack.
388
 *
389
 * If you are going to use his function you might use the functions
390
 * xMBUtilSetBits(  ) and xMBUtilGetBits(  ) for working with bitfields.
391
 *
392
 * \param pucRegBuffer The buffer should be updated with the current
393
 *   coil values. The first discrete input starting at \c usAddress must be
394
 *   stored at the LSB of the first byte in the buffer. If the requested number
395
 *   is not a multiple of eight the remaining bits should be set to zero.
396
 * \param usAddress The starting address of the first discrete input.
397
 * \param usNDiscrete Number of discrete input values.
398
 * \return The function must return one of the following error codes:
399
 *   - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
400
 *       Modbus response is sent.
401
 *   - eMBErrorCode::MB_ENOREG If no such discrete inputs exists.
402
 *       In this case a <b>ILLEGAL DATA ADDRESS</b> exception frame is sent 
403
 *       as a response.
404
 *   - eMBErrorCode::MB_ETIMEDOUT If the requested register block is
405
 *       currently not available and the application dependent response
406
 *       timeout would be violated. In this case a <b>SLAVE DEVICE BUSY</b>
407
 *       exception is sent as a response.
408
 *   - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case
409
 *       a <b>SLAVE DEVICE FAILURE</b> exception is sent as a response.
410
 */
411
eMBErrorCode    eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress,
412
                                  USHORT usNDiscrete );
413

    
414
#ifdef __cplusplus
415
PR_END_EXTERN_C
416
#endif
417
#endif