root / toolbox / freemodbus / modbus / include / mb.h @ ae250f1a
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
|