/* * FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU. * Copyright (c) 2006-2018 Christian Walter * 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.h,v 1.17 2006/12/07 22:10:34 wolti Exp $ */ #ifndef _MB_H #define _MB_H #include "port.h" #ifdef __cplusplus PR_BEGIN_EXTERN_C #endif #include "mbport.h" #include "mbproto.h" #include "cmsis_os2.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 protocol stack. * A typical application will want to call eMBInit() 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 eMBPoll() 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 eMBPoll(). * * \code * // Initialize protocol stack in RTU mode for a slave with address 10 = 0x0A * eMBInit( MB_RTU, 0x0A, 38400, MB_PAR_EVEN ); * // Enable the Modbus Protocol Stack. * eMBEnable( ); * for( ;; ) * { * // Call the main polling loop of the Modbus protocol stack. * eMBPoll( ); * ... * } * \endcode */ /* ----------------------- Defines ------------------------------------------*/ /*! \ingroup modbus * \brief Use the default Modbus TCP port (502) */ #define MB_TCP_PORT_USE_DEFAULT 0 /* ----------------------- 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; /* ----------------------- Function prototypes ------------------------------*/ /*! \ingroup modbus * \brief Initialize the Modbus 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 eMBEnable( ) has been called. * * \param eMode If ASCII or RTU mode should be used. * \param ucSlaveAddress The slave address. Only frames sent to this * address or to the broadcast address are processed. * \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 eMBEnable( ). 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 eMBInit(eMBRTUSlaveObj *obj); /*! \ingroup modbus * \brief Initialize the Modbus 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 eMBTCPInit(USHORT usTCPPort); /*! \ingroup modbus * \brief Release resources used by the protocol stack. * * This function disables the Modbus 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 eMBClose(eMBRTUSlaveObj *obj); /*! \ingroup modbus * \brief Enable the Modbus protocol stack. * * This function enables processing of Modbus 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 eMBEnable(eMBRTUSlaveObj *obj); /*! \ingroup modbus * \brief Disable the Modbus 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 eMBDisable(eMBRTUSlaveObj *obj); /*! \ingroup modbus * \brief The main pooling loop of the Modbus 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 xMBPortEventGet() 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 eMBPoll(eMBRTUSlaveObj *obj); /*! \ingroup modbus * \brief Configure the slave id of the device. * * This function should be called when the Modbus function Report Slave ID * is enabled ( By defining MB_FUNC_OTHER_REP_SLAVEID_ENABLED in mbconfig.h ). * * \param ucSlaveID Values is returned in the Slave ID byte of the * Report Slave ID response. * \param xIsRunning If TRUE the Run Indicator Status byte is set to 0xFF. * otherwise the Run Indicator Status is 0x00. * \param pucAdditional Values which should be returned in the Additional * bytes of the Report Slave ID response. * \param usAdditionalLen Length of the buffer pucAdditonal. * * \return If the static buffer defined by MB_FUNC_OTHER_REP_SLAVEID_BUF in * mbconfig.h is to small it returns eMBErrorCode::MB_ENORES. Otherwise * it returns eMBErrorCode::MB_ENOERR. */ eMBErrorCode eMBSetSlaveID(UCHAR ucSlaveID, BOOL xIsRunning, UCHAR const *pucAdditional, USHORT usAdditionalLen); /*! \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 eMBRegisterCB(UCHAR ucFunctionCode, pxMBFunctionHandler pxHandler); /* ----------------------- Callback -----------------------------------------*/ #ifdef __cplusplus PR_END_EXTERN_C #endif #endif