449d2a6367
Contains two different component folders per each implementation (serial_master and serial_slave) with concrete ports. Added common public api for master and slave and common interface for master and slave implementation. Add support of cmake system (added cmake files). Added sdkconfig.defaults files for slave and master modbus examples. Updated make file and KConfig for freemodbus component Update according to review and fix doxygen warnings Fix Doxyfile to pass documentation build Update headers and change interface file names as per review comments Merge branch feature/freemodbus_move_rs485_mode_control Update after review: The stack modbus folder updated to support master and slave ports together and moved into freemodbus/modbus Stack and port files updated to remove duplicated simbols Make file, KConfig and CMakeLists.txt updated to compile master and slave stacks, common interface and concrete implementations of ports Stack callback functions execute callbacks using interface pointer from concrete port implementation User can instantiate any of concrete port using common API (only one concrete port at a time) and it does not require to select port by KConfig Port pins and mode configuration moved into example files from port files to allow user select pins and port mode (customer request) Changes tested using pymodbus, ModbusPoll and communication between two boards Updated DoxyFile according to public include path Fix maximum instance size for slave (merge from master of customer issue) Fix critical section issue TW#28622 (change spin lock based critical section to semaphore) Move serial port files into component port folder for master and slave accordingly Fix example issue showed in the log when IO slave is not configured correctly Fix conflicts while merging from origin/master Fix errors handling in modbus controller interface + some final corrections according to review Update maximum allowed number of slaves in the network segment Fix bug with incorrect coils read mask Closes https://github.com/espressif/esp-idf/issues/858
456 lines
20 KiB
C
456 lines
20 KiB
C
/*
|
|
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
|
|
* Copyright (C) 2013 Armink <armink.ztl@gmail.com>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* File: $Id: mb_m.h,v 1.60 2013/09/03 10:20:05 Armink Add Master Functions $
|
|
*/
|
|
|
|
#ifndef _MB_M_H
|
|
#define _MB_M_H
|
|
|
|
#include "mbconfig.h"
|
|
#include "port.h"
|
|
|
|
#ifdef __cplusplus
|
|
PR_BEGIN_EXTERN_C
|
|
#endif
|
|
|
|
#include "mbport.h"
|
|
#include "mbproto.h"
|
|
/*! \defgroup modbus Modbus
|
|
* \code #include "mb.h" \endcode
|
|
*
|
|
* This module defines the interface for the application. It contains
|
|
* the basic functions and types required to use the Modbus Master protocol stack.
|
|
* A typical application will want to call eMBMasterInit() first. If the device
|
|
* is ready to answer network requests it must then call eMBEnable() to activate
|
|
* the protocol stack. In the main loop the function eMBMasterPoll() must be called
|
|
* periodically. The time interval between pooling depends on the configured
|
|
* Modbus timeout. If an RTOS is available a separate task should be created
|
|
* and the task should always call the function eMBMasterPoll().
|
|
*
|
|
* \code
|
|
* // Initialize protocol stack in RTU mode for a Master
|
|
* eMBMasterInit( MB_RTU, 38400, MB_PAR_EVEN );
|
|
* // Enable the Modbus Protocol Stack.
|
|
* eMBMasterEnable( );
|
|
* for( ;; )
|
|
* {
|
|
* // Call the main polling loop of the Modbus Master protocol stack.
|
|
* eMBMasterPoll( );
|
|
* ...
|
|
* }
|
|
* \endcode
|
|
*/
|
|
|
|
/* ----------------------- Defines ------------------------------------------*/
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Use the default Modbus Master TCP port (502)
|
|
*/
|
|
#define MB_MASTER_TCP_PORT_USE_DEFAULT 0
|
|
|
|
#ifndef _MB_H
|
|
|
|
/* ----------------------- Type definitions ---------------------------------*/
|
|
/*! \ingroup modbus
|
|
* \brief Modbus serial transmission modes (RTU/ASCII).
|
|
*
|
|
* Modbus serial supports two transmission modes. Either ASCII or RTU. RTU
|
|
* is faster but has more hardware requirements and requires a network with
|
|
* a low jitter. ASCII is slower and more reliable on slower links (E.g. modems)
|
|
*/
|
|
typedef enum {
|
|
MB_RTU, /*!< RTU transmission mode. */
|
|
MB_ASCII, /*!< ASCII transmission mode. */
|
|
MB_TCP /*!< TCP mode. */
|
|
} eMBMode;
|
|
|
|
/*! \ingroup modbus
|
|
* \brief If register should be written or read.
|
|
*
|
|
* This value is passed to the callback functions which support either
|
|
* reading or writing register values. Writing means that the application
|
|
* registers should be updated and reading means that the modbus protocol
|
|
* stack needs to know the current register values.
|
|
*
|
|
* \see eMBRegHoldingCB( ), eMBRegCoilsCB( ), eMBRegDiscreteCB( ) and
|
|
* eMBRegInputCB( ).
|
|
*/
|
|
typedef enum {
|
|
MB_REG_READ, /*!< Read register values and pass to protocol stack. */
|
|
MB_REG_WRITE /*!< Update register values. */
|
|
} eMBRegisterMode;
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Errorcodes used by all function in the protocol stack.
|
|
*/
|
|
typedef enum {
|
|
MB_ENOERR, /*!< no error. */
|
|
MB_ENOREG, /*!< illegal register address. */
|
|
MB_EINVAL, /*!< illegal argument. */
|
|
MB_EPORTERR, /*!< porting layer error. */
|
|
MB_ENORES, /*!< insufficient resources. */
|
|
MB_EIO, /*!< I/O error. */
|
|
MB_EILLSTATE, /*!< protocol stack in illegal state. */
|
|
MB_ETIMEDOUT /*!< timeout error occurred. */
|
|
} eMBErrorCode;
|
|
|
|
#endif
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Errorcodes used by all function in the Master request.
|
|
*/
|
|
typedef enum
|
|
{
|
|
MB_MRE_NO_ERR, /*!< no error. */
|
|
MB_MRE_NO_REG, /*!< illegal register address. */
|
|
MB_MRE_ILL_ARG, /*!< illegal argument. */
|
|
MB_MRE_REV_DATA, /*!< receive data error. */
|
|
MB_MRE_TIMEDOUT, /*!< timeout error occurred. */
|
|
MB_MRE_MASTER_BUSY, /*!< master is busy now. */
|
|
MB_MRE_EXE_FUN /*!< execute function error. */
|
|
} eMBMasterReqErrCode;
|
|
|
|
/*! \ingroup modbus
|
|
* \brief TimerMode is Master 3 kind of Timer modes.
|
|
*/
|
|
typedef enum
|
|
{
|
|
MB_TMODE_T35, /*!< Master receive frame T3.5 timeout. */
|
|
MB_TMODE_RESPOND_TIMEOUT, /*!< Master wait respond for slave. */
|
|
MB_TMODE_CONVERT_DELAY /*!< Master sent broadcast ,then delay sometime.*/
|
|
}eMBMasterTimerMode;
|
|
|
|
/* ----------------------- Function prototypes ------------------------------*/
|
|
/*! \ingroup modbus
|
|
* \brief Initialize the Modbus Master protocol stack.
|
|
*
|
|
* This functions initializes the ASCII or RTU module and calls the
|
|
* init functions of the porting layer to prepare the hardware. Please
|
|
* note that the receiver is still disabled and no Modbus frames are
|
|
* processed until eMBMasterEnable( ) has been called.
|
|
*
|
|
* \param eMode If ASCII or RTU mode should be used.
|
|
* \param ucPort The port to use. E.g. 1 for COM1 on windows. This value
|
|
* is platform dependent and some ports simply choose to ignore it.
|
|
* \param ulBaudRate The baudrate. E.g. 19200. Supported baudrates depend
|
|
* on the porting layer.
|
|
* \param eParity Parity used for serial transmission.
|
|
*
|
|
* \return If no error occurs the function returns eMBErrorCode::MB_ENOERR.
|
|
* The protocol is then in the disabled state and ready for activation
|
|
* by calling eMBMasterEnable( ). Otherwise one of the following error codes
|
|
* is returned:
|
|
* - eMBErrorCode::MB_EPORTERR IF the porting layer returned an error.
|
|
*/
|
|
eMBErrorCode eMBMasterInit( eMBMode eMode, UCHAR ucPort,
|
|
ULONG ulBaudRate, eMBParity eParity );
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Initialize the Modbus Master protocol stack for Modbus TCP.
|
|
*
|
|
* This function initializes the Modbus TCP Module. Please note that
|
|
* frame processing is still disabled until eMBEnable( ) is called.
|
|
*
|
|
* \param usTCPPort The TCP port to listen on.
|
|
* \return If the protocol stack has been initialized correctly the function
|
|
* returns eMBErrorCode::MB_ENOERR. Otherwise one of the following error
|
|
* codes is returned:
|
|
* - eMBErrorCode::MB_EINVAL If the slave address was not valid. Valid
|
|
* slave addresses are in the range 1 - 247.
|
|
* - eMBErrorCode::MB_EPORTERR IF the porting layer returned an error.
|
|
*/
|
|
eMBErrorCode eMBMasterTCPInit( USHORT usTCPPort );
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Release resources used by the protocol stack.
|
|
*
|
|
* This function disables the Modbus Master protocol stack and release all
|
|
* hardware resources. It must only be called when the protocol stack
|
|
* is disabled.
|
|
*
|
|
* \note Note all ports implement this function. A port which wants to
|
|
* get an callback must define the macro MB_PORT_HAS_CLOSE to 1.
|
|
*
|
|
* \return If the resources where released it return eMBErrorCode::MB_ENOERR.
|
|
* If the protocol stack is not in the disabled state it returns
|
|
* eMBErrorCode::MB_EILLSTATE.
|
|
*/
|
|
eMBErrorCode eMBMasterClose( void );
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Enable the Modbus Master protocol stack.
|
|
*
|
|
* This function enables processing of Modbus Master frames. Enabling the protocol
|
|
* stack is only possible if it is in the disabled state.
|
|
*
|
|
* \return If the protocol stack is now in the state enabled it returns
|
|
* eMBErrorCode::MB_ENOERR. If it was not in the disabled state it
|
|
* return eMBErrorCode::MB_EILLSTATE.
|
|
*/
|
|
eMBErrorCode eMBMasterEnable( void );
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Disable the Modbus Master protocol stack.
|
|
*
|
|
* This function disables processing of Modbus frames.
|
|
*
|
|
* \return If the protocol stack has been disabled it returns
|
|
* eMBErrorCode::MB_ENOERR. If it was not in the enabled state it returns
|
|
* eMBErrorCode::MB_EILLSTATE.
|
|
*/
|
|
eMBErrorCode eMBMasterDisable( void );
|
|
|
|
/*! \ingroup modbus
|
|
* \brief The main pooling loop of the Modbus Master protocol stack.
|
|
*
|
|
* This function must be called periodically. The timer interval required
|
|
* is given by the application dependent Modbus slave timeout. Internally the
|
|
* function calls xMBMasterPortEventGet() and waits for an event from the receiver or
|
|
* transmitter state machines.
|
|
*
|
|
* \return If the protocol stack is not in the enabled state the function
|
|
* returns eMBErrorCode::MB_EILLSTATE. Otherwise it returns
|
|
* eMBErrorCode::MB_ENOERR.
|
|
*/
|
|
eMBErrorCode eMBMasterPoll( void );
|
|
|
|
/*! \ingroup modbus
|
|
* \brief Registers a callback handler for a given function code.
|
|
*
|
|
* This function registers a new callback handler for a given function code.
|
|
* The callback handler supplied is responsible for interpreting the Modbus PDU and
|
|
* the creation of an appropriate response. In case of an error it should return
|
|
* one of the possible Modbus exceptions which results in a Modbus exception frame
|
|
* sent by the protocol stack.
|
|
*
|
|
* \param ucFunctionCode The Modbus function code for which this handler should
|
|
* be registers. Valid function codes are in the range 1 to 127.
|
|
* \param pxHandler The function handler which should be called in case
|
|
* such a frame is received. If \c NULL a previously registered function handler
|
|
* for this function code is removed.
|
|
*
|
|
* \return eMBErrorCode::MB_ENOERR if the handler has been installed. If no
|
|
* more resources are available it returns eMBErrorCode::MB_ENORES. In this
|
|
* case the values in mbconfig.h should be adjusted. If the argument was not
|
|
* valid it returns eMBErrorCode::MB_EINVAL.
|
|
*/
|
|
eMBErrorCode eMBMasterRegisterCB( UCHAR ucFunctionCode,
|
|
pxMBFunctionHandler pxHandler );
|
|
|
|
/* ----------------------- Callback -----------------------------------------*/
|
|
|
|
/*! \defgroup modbus_master registers Modbus Registers
|
|
* \code #include "mb_m.h" \endcode
|
|
* The protocol stack does not internally allocate any memory for the
|
|
* registers. This makes the protocol stack very small and also usable on
|
|
* low end targets. In addition the values don't have to be in the memory
|
|
* and could for example be stored in a flash.<br>
|
|
* Whenever the protocol stack requires a value it calls one of the callback
|
|
* function with the register address and the number of registers to read
|
|
* as an argument. The application should then read the actual register values
|
|
* (for example the ADC voltage) and should store the result in the supplied
|
|
* buffer.<br>
|
|
* If the protocol stack wants to update a register value because a write
|
|
* register function was received a buffer with the new register values is
|
|
* passed to the callback function. The function should then use these values
|
|
* to update the application register values.
|
|
*/
|
|
|
|
/*! \ingroup modbus_registers
|
|
* \brief Callback function used if the value of a <em>Input Register</em>
|
|
* is required by the protocol stack. The starting register address is given
|
|
* by \c usAddress and the last register is given by <tt>usAddress +
|
|
* usNRegs - 1</tt>.
|
|
*
|
|
* \param pucRegBuffer A buffer where the callback function should write
|
|
* the current value of the modbus registers to.
|
|
* \param usAddress The starting address of the register. Input registers
|
|
* are in the range 1 - 65535.
|
|
* \param usNRegs Number of registers the callback function must supply.
|
|
*
|
|
* \return The function must return one of the following error codes:
|
|
* - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
|
|
* Modbus response is sent.
|
|
* - eMBErrorCode::MB_ENOREG If the application does not map an coils
|
|
* within the requested address range. In this case a
|
|
* <b>ILLEGAL DATA ADDRESS</b> is sent as a response.
|
|
*/
|
|
eMBErrorCode eMBMasterRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress,
|
|
USHORT usNRegs );
|
|
|
|
/*! \ingroup modbus_registers
|
|
* \brief Callback function used if a <em>Holding Register</em> value is
|
|
* read or written by the protocol stack. The starting register address
|
|
* is given by \c usAddress and the last register is given by
|
|
* <tt>usAddress + usNRegs - 1</tt>.
|
|
*
|
|
* \param pucRegBuffer If the application registers values should be updated the
|
|
* buffer points to the new registers values. If the protocol stack needs
|
|
* to now the current values the callback function should write them into
|
|
* this buffer.
|
|
* \param usAddress The starting address of the register.
|
|
* \param usNRegs Number of registers to read or write.
|
|
* \param eMode If eMBRegisterMode::MB_REG_WRITE the application register
|
|
* values should be updated from the values in the buffer. For example
|
|
* this would be the case when the Modbus master has issued an
|
|
* <b>WRITE SINGLE REGISTER</b> command.
|
|
* If the value eMBRegisterMode::MB_REG_READ the application should copy
|
|
* the current values into the buffer \c pucRegBuffer.
|
|
*
|
|
* \return The function must return one of the following error codes:
|
|
* - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
|
|
* Modbus response is sent.
|
|
* - eMBErrorCode::MB_ENOREG If the application does not map an coils
|
|
* within the requested address range. In this case a
|
|
* <b>ILLEGAL DATA ADDRESS</b> is sent as a response.
|
|
*/
|
|
eMBErrorCode eMBMasterRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress,
|
|
USHORT usNRegs, eMBRegisterMode eMode );
|
|
|
|
/*! \ingroup modbus_registers
|
|
* \brief Callback function used if a <em>Coil Register</em> value is
|
|
* read or written by the protocol stack. If you are going to use
|
|
* this function you might use the functions xMBUtilSetBits( ) and
|
|
* xMBUtilGetBits( ) for working with bitfields.
|
|
*
|
|
* \param pucRegBuffer The bits are packed in bytes where the first coil
|
|
* starting at address \c usAddress is stored in the LSB of the
|
|
* first byte in the buffer <code>pucRegBuffer</code>.
|
|
* If the buffer should be written by the callback function unused
|
|
* coil values (I.e. if not a multiple of eight coils is used) should be set
|
|
* to zero.
|
|
* \param usAddress The first coil number.
|
|
* \param usNCoils Number of coil values requested.
|
|
* \param eMode If eMBRegisterMode::MB_REG_WRITE the application values should
|
|
* be updated from the values supplied in the buffer \c pucRegBuffer.
|
|
* If eMBRegisterMode::MB_REG_READ the application should store the current
|
|
* values in the buffer \c pucRegBuffer.
|
|
*
|
|
* \return The function must return one of the following error codes:
|
|
* - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
|
|
* Modbus response is sent.
|
|
* - eMBErrorCode::MB_ENOREG If the application does not map an coils
|
|
* within the requested address range. In this case a
|
|
* <b>ILLEGAL DATA ADDRESS</b> is sent as a response.
|
|
*/
|
|
eMBErrorCode eMBMasterRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress,
|
|
USHORT usNCoils, eMBRegisterMode eMode );
|
|
|
|
/*! \ingroup modbus_registers
|
|
* \brief Callback function used if a <em>Input Discrete Register</em> value is
|
|
* read by the protocol stack.
|
|
*
|
|
* If you are going to use his function you might use the functions
|
|
* xMBUtilSetBits( ) and xMBUtilGetBits( ) for working with bitfields.
|
|
*
|
|
* \param pucRegBuffer The buffer should be updated with the current
|
|
* coil values. The first discrete input starting at \c usAddress must be
|
|
* stored at the LSB of the first byte in the buffer. If the requested number
|
|
* is not a multiple of eight the remaining bits should be set to zero.
|
|
* \param usAddress The starting address of the first discrete input.
|
|
* \param usNDiscrete Number of discrete input values.
|
|
* \return The function must return one of the following error codes:
|
|
* - eMBErrorCode::MB_ENOERR If no error occurred. In this case a normal
|
|
* Modbus response is sent.
|
|
* - eMBErrorCode::MB_ENOREG If the application does not map an coils
|
|
* within the requested address range. In this case a
|
|
* <b>ILLEGAL DATA ADDRESS</b> is sent as a response.
|
|
*/
|
|
eMBErrorCode eMBMasterRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress,
|
|
USHORT usNDiscrete );
|
|
|
|
/*! \ingroup modbus
|
|
*\brief These Modbus functions are called for user when Modbus run in Master Mode.
|
|
*/
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqReadInputRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usNRegs, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqWriteHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usRegData, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqWriteMultipleHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr,
|
|
USHORT usNRegs, USHORT * pusDataBuffer, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqReadHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usNRegs, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqReadWriteMultipleHoldingRegister( UCHAR ucSndAddr,
|
|
USHORT usReadRegAddr, USHORT usNReadRegs, USHORT * pusDataBuffer,
|
|
USHORT usWriteRegAddr, USHORT usNWriteRegs, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqReadCoils( UCHAR ucSndAddr, USHORT usCoilAddr, USHORT usNCoils, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqWriteCoil( UCHAR ucSndAddr, USHORT usCoilAddr, USHORT usCoilData, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqWriteMultipleCoils( UCHAR ucSndAddr,
|
|
USHORT usCoilAddr, USHORT usNCoils, UCHAR * pucDataBuffer, LONG lTimeOut );
|
|
eMBMasterReqErrCode
|
|
eMBMasterReqReadDiscreteInputs( UCHAR ucSndAddr, USHORT usDiscreteAddr, USHORT usNDiscreteIn, LONG lTimeOut );
|
|
|
|
eMBException
|
|
eMBMasterFuncReportSlaveID( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncReadInputRegister( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncReadHoldingRegister( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncWriteHoldingRegister( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncReadCoils( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncWriteCoil( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncWriteMultipleCoils( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncReadDiscreteInputs( UCHAR * pucFrame, USHORT * usLen );
|
|
eMBException
|
|
eMBMasterFuncReadWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen );
|
|
|
|
/* \ingroup modbus
|
|
* \brief These functions are interface for Modbus Master
|
|
*/
|
|
void vMBMasterGetPDUSndBuf( UCHAR ** pucFrame );
|
|
UCHAR ucMBMasterGetDestAddress( void );
|
|
void vMBMasterSetDestAddress( UCHAR Address );
|
|
BOOL xMBMasterGetCBRunInMasterMode( void );
|
|
void vMBMasterSetCBRunInMasterMode( BOOL IsMasterMode );
|
|
USHORT usMBMasterGetPDUSndLength( void );
|
|
void vMBMasterSetPDUSndLength( USHORT SendPDULength );
|
|
void vMBMasterSetCurTimerMode( eMBMasterTimerMode eMBTimerMode );
|
|
BOOL xMBMasterRequestIsBroadcast( void );
|
|
eMBMasterErrorEventType eMBMasterGetErrorType( void );
|
|
void vMBMasterSetErrorType( eMBMasterErrorEventType errorType );
|
|
eMBMasterReqErrCode eMBMasterWaitRequestFinish( void );
|
|
|
|
/* ----------------------- Callback -----------------------------------------*/
|
|
|
|
#ifdef __cplusplus
|
|
PR_END_EXTERN_C
|
|
#endif
|
|
#endif
|