From 526c058b7e6c78cdd20da80c99bcaa73862c3701 Mon Sep 17 00:00:00 2001 From: Gregory Nutt Date: Sat, 11 Apr 2015 09:37:31 -0600 Subject: Add master support to modbus. From Darcy Gong --- apps/include/modbus/mb.h | 47 ++--- apps/include/modbus/mb_m.h | 465 +++++++++++++++++++++++++++++++++++++++++++ apps/include/modbus/mbport.h | 64 +++++- 3 files changed, 549 insertions(+), 27 deletions(-) create mode 100644 apps/include/modbus/mb_m.h (limited to 'apps/include/modbus') diff --git a/apps/include/modbus/mb.h b/apps/include/modbus/mb.h index b8defac8d..cf1e867bb 100644 --- a/apps/include/modbus/mb.h +++ b/apps/include/modbus/mb.h @@ -32,25 +32,6 @@ #ifndef __APPS_INCLUDE_MODBUS_MB_H #define __APPS_INCLUDE_MODBUS_MB_H -/**************************************************************************** - * Included Files - ****************************************************************************/ - -#include -#include -#include - -#ifdef __cplusplus -PR_BEGIN_EXTERN_C -#endif - -#include "mbport.h" -#include "mbproto.h" - -/**************************************************************************** - * Pre-processor Definitions - ****************************************************************************/ - /* 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 @@ -75,6 +56,26 @@ PR_BEGIN_EXTERN_C * } */ +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#include +#include + +#ifdef __cplusplus +PR_BEGIN_EXTERN_C +#endif + +#include "mbport.h" +#include "mbproto.h" + +/**************************************************************************** + * Pre-processor Definitions + ****************************************************************************/ + + /* Use the default Modbus TCP port (502) */ #define MB_TCP_PORT_USE_DEFAULT 0 @@ -319,7 +320,7 @@ eMBErrorCode eMBRegisterCB(uint8_t ucFunctionCode, * ILLEGAL DATA ADDRESS exception frame is sent as a response. * - eMBErrorCode::MB_ETIMEDOUT If the requested register block is * currently not available and the application dependent response - * timeout would be violated. In this case a SLAVE DEVICE BUSY + * timeout would be violated. In this case a SLAVE DEVICE BUSY * exception is sent as a response. * - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case * a SLAVE DEVICE FAILURE exception is sent as a response. @@ -354,7 +355,7 @@ eMBErrorCode eMBRegInputCB(uint8_t * pucRegBuffer, uint16_t usAddress, * ILLEGAL DATA ADDRESS exception frame is sent as a response. * - eMBErrorCode::MB_ETIMEDOUT If the requested register block is * currently not available and the application dependent response - * timeout would be violated. In this case a SLAVE DEVICE BUSY + * timeout would be violated. In this case a SLAVE DEVICE BUSY * exception is sent as a response. * - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case * a SLAVE DEVICE FAILURE exception is sent as a response. @@ -390,7 +391,7 @@ eMBErrorCode eMBRegHoldingCB(uint8_t * pucRegBuffer, uint16_t usAddress, * ILLEGAL DATA ADDRESS is sent as a response. * - eMBErrorCode::MB_ETIMEDOUT If the requested register block is * currently not available and the application dependent response - * timeout would be violated. In this case a SLAVE DEVICE BUSY + * timeout would be violated. In this case a SLAVE DEVICE BUSY * exception is sent as a response. * - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case * a SLAVE DEVICE FAILURE exception is sent as a response. @@ -421,7 +422,7 @@ eMBErrorCode eMBRegCoilsCB(uint8_t *pucRegBuffer, uint16_t usAddress, * as a response. * - eMBErrorCode::MB_ETIMEDOUT If the requested register block is * currently not available and the application dependent response - * timeout would be violated. In this case a SLAVE DEVICE BUSY + * timeout would be violated. In this case a SLAVE DEVICE BUSY * exception is sent as a response. * - eMBErrorCode::MB_EIO If an unrecoverable error occurred. In this case * a SLAVE DEVICE FAILURE exception is sent as a response. diff --git a/apps/include/modbus/mb_m.h b/apps/include/modbus/mb_m.h new file mode 100644 index 000000000..3723b0edd --- /dev/null +++ b/apps/include/modbus/mb_m.h @@ -0,0 +1,465 @@ +/**************************************************************************** + * apps/include/modbus/mb_m.h + * + * FreeModbus Library: A portable Modbus implementation for Modbus ASCII/RTU. + * Copyright (C) 2013 Armink + * 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. + * + ****************************************************************************/ + +#ifndef __APPS_INCLUDE_MODBUS_MB_M_H +#define __APPS_INCLUDE_MODBUS_MB_M_H + +/* 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(). + * + * // 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(); + * ... + * } + */ + + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include +#include +#include + +#ifdef __cplusplus +PR_BEGIN_EXTERN_C +#endif + +#include "mbport.h" + +/**************************************************************************** + * Pre-processor Definitions + ****************************************************************************/ + +/* Use the default Modbus Master TCP port (502) */ + +#define MB_MASTER_TCP_PORT_USE_DEFAULT 0 + +/**************************************************************************** + * Public Type Definitions + ****************************************************************************/ + +/* Error codes 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; + +/* 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; + +/**************************************************************************** + * Public Function Prototypes + ****************************************************************************/ + +/**************************************************************************** + * Description: + * 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. + * + * Input Parameters: + * eMode If ASCII or RTU mode should be used. + * 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. + * ulBaudRate The baudrate. E.g. 19200. Supported baudrates depend + * on the porting layer. + * eParity Parity used for serial transmission. + * + * Returned Value: + * 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, uint8_t ucPort, speed_t ulBaudRate, + eMBParity eParity); + +/**************************************************************************** + * Description: + * 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. + * + * Input Parameters: + * usTCPPort The TCP port to listen on. + * + * Returned Value: + * 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(uint16_t usTCPPort); + +/**************************************************************************** + * Description: + * 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. + * + * Returned Value: + * 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); + +/**************************************************************************** + * Description: + * 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. + * + * Returned Value: + * 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); + +/**************************************************************************** + * Description: + * Disable the Modbus Master protocol stack. + * + * This function disables processing of Modbus frames. + * + * Returned Value: + * 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); + +/**************************************************************************** + * Description: + * 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. + * + * Returned Value: + * 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); + +/**************************************************************************** + * Description: + * 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. + * + * Input Parameters: + * ucFunctionCode The Modbus function code for which this handler should + * be registers. Valid function codes are in the range 1 to 127. + * pxHandler The function handler which should be called in case + * such a frame is received. If NULL a previously registered function + * handler for this function code is removed. + * + * Returned Value: + * 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(uint8_t ucFunctionCode, + pxMBFunctionHandler pxHandler); + +/**************************************************************************** + * Description: + * Callback function used if the value of a Input Register is required by + * the protocol stack. The starting register address is given by usAddress + * and the last register is given by usAddress + usNRegs - 1. + * + * 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. + * + * 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. + * + * 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. + * + * Input Parameters: + * pucRegBuffer A buffer where the callback function should write + * the current value of the modbus registers to. + * usAddress The starting address of the register. Input registers + * are in the range 1 - 65535. + * usNRegs Number of registers the callback function must supply. + * + * Returned Value: + * 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 + * ILLEGAL DATA ADDRESS is sent as a response. + * + ****************************************************************************/ + +eMBErrorCode eMBMasterRegInputCB(uint8_t *pucRegBuffer, uint16_t usAddress, + uint16_t usNRegs); + +/**************************************************************************** + * Description: + * Callback function used if a Holding Register value is + * read or written by the protocol stack. The starting register address + * is given by usAddress and the last register is given by + * usAddress + usNRegs - 1. + * + * Input Parameters: + * 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. + * usAddress The starting address of the register. + * usNRegs Number of registers to read or write. + * 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 + * WRITE SINGLE REGISTER command. + * If the value eMBRegisterMode::MB_REG_READ the application should copy + * the current values into the buffer pucRegBuffer. + * + * Returned Value: + * 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 + * ILLEGAL DATA ADDRESS is sent as a response. + * + ****************************************************************************/ + +eMBErrorCode eMBMasterRegHoldingCB(uint8_t *pucRegBuffer, uint16_t usAddress, + uint16_t usNRegs, eMBRegisterMode eMode); + +/**************************************************************************** + * Description: + * Callback function used if a Coil Register 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. + * + * Input Parameters: + * pucRegBuffer The bits are packed in bytes where the first coil + * starting at address usAddress is stored in the LSB of the + * first byte in the buffer pucRegBuffer. + * 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. + * usAddress The first coil number. + * usNCoils Number of coil values requested. + * eMode If eMBRegisterMode::MB_REG_WRITE the application values should + * be updated from the values supplied in the buffer pucRegBuffer. + * If eMBRegisterMode::MB_REG_READ the application should store the + * current values in the buffer pucRegBuffer. + * + * Returned Value: + * 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 + * ILLEGAL DATA ADDRESS is sent as a response. + * + ****************************************************************************/ + +eMBErrorCode eMBMasterRegCoilsCB(uint8_t *pucRegBuffer, uint16_t usAddress, + uint16_t usNCoils, eMBRegisterMode eMode); + +/**************************************************************************** + * Description: + * Callback function used if a Input Discrete Register 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. + * + * Input Parameters: + * pucRegBuffer The buffer should be updated with the current + * coil values. The first discrete input starting at 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. + * usAddress The starting address of the first discrete input. + * usNDiscrete Number of discrete input values. + * + * Returned Value: + * 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 + * ILLEGAL DATA ADDRESS is sent as a response. + * + ****************************************************************************/ + +eMBErrorCode eMBMasterRegDiscreteCB(uint8_t *pucRegBuffer, uint16_t usAddress, + uint16_t usNDiscrete); + +/**************************************************************************** + * Description: + * These Modbus functions are called for user when Modbus run in Master Mode. + * + ****************************************************************************/ + +eMBMasterReqErrCode eMBMasterReqReadInputRegister(uint8_t ucSndAddr, + uint16_t usRegAddr, uint16_t usNRegs, uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqWriteHoldingRegister(uint8_t ucSndAddr, + uint16_t usRegAddr, uint16_t usRegData, uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqWriteMultipleHoldingRegister(uint8_t ucSndAddr, + uint16_t usRegAddr, uint16_t usNRegs, uint16_t *pusDataBuffer, + uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqReadHoldingRegister(uint8_t ucSndAddr, + uint16_t usRegAddr, uint16_t usNRegs, uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqReadWriteMultipleHoldingRegister(uint8_t ucSndAddr, + uint16_t usReadRegAddr, uint16_t usNReadRegs, uint16_t *pusDataBuffer, + uint16_t usWriteRegAddr, uint16_t usNWriteRegs, uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqReadCoils(uint8_t ucSndAddr, + uint16_t usCoilAddr, uint16_t usNCoils, uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqWriteCoil(uint8_t ucSndAddr, + uint16_t usCoilAddr, uint16_t usCoilData, uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqWriteMultipleCoils(uint8_t ucSndAddr, + uint16_t usCoilAddr, uint16_t usNCoils, uint8_t *pucDataBuffer, + uint32_t lTimeOut); +eMBMasterReqErrCode eMBMasterReqReadDiscreteInputs(uint8_t ucSndAddr, + uint16_t usDiscreteAddr, uint16_t usNDiscreteIn, uint32_t lTimeOut); + +eMBException eMBMasterFuncReportSlaveID(uint8_t *pucFrame, uint16_t *usLen); +eMBException eMBMasterFuncReadInputRegister(uint8_t *pucFrame, + uint16_t *usLen); +eMBException eMBMasterFuncReadHoldingRegister(uint8_t *pucFrame, + uint16_t *usLen); +eMBException eMBMasterFuncWriteHoldingRegister(uint8_t *pucFrame, + uint16_t *usLen); +eMBException eMBMasterFuncWriteMultipleHoldingRegister(uint8_t *pucFrame, + uint16_t *usLen); +eMBException eMBMasterFuncReadCoils(uint8_t *pucFrame, uint16_t *usLen); +eMBException eMBMasterFuncWriteCoil(uint8_t *pucFrame, uint16_t *usLen); +eMBException eMBMasterFuncWriteMultipleCoils(uint8_t *pucFrame, + uint16_t *usLen); +eMBException eMBMasterFuncReadDiscreteInputs(uint8_t *pucFrame, + uint16_t *usLen); +eMBException eMBMasterFuncReadWriteMultipleHoldingRegister(uint8_t *pucFrame, + uint16_t *usLen); + +/* These functions are interface for Modbus Master */ + +void vMBMasterGetPDUSndBuf(uint8_t **pucFrame); +uint8_t ucMBMasterGetDestAddress(void); +void vMBMasterSetDestAddress(uint8_t Address); +bool xMBMasterGetCBRunInMasterMode(void); +void vMBMasterSetCBRunInMasterMode(bool IsMasterMode); +uint16_t usMBMasterGetPDUSndLength(void); +void vMBMasterSetPDUSndLength(uint16_t SendPDULength); +void vMBMasterSetCurTimerMode(eMBMasterTimerMode eMBTimerMode); +bool xMBMasterRequestIsBroadcast(void); +eMBMasterErrorEventType eMBMasterGetErrorType(void); +void vMBMasterSetErrorType(eMBMasterErrorEventType errorType); +eMBMasterReqErrCode eMBMasterWaitRequestFinish(void); + +#ifdef __cplusplus +PR_END_EXTERN_C +#endif + +#endif /* __APPS_INCLUDE_MODBUS_MB_M_H */ diff --git a/apps/include/modbus/mbport.h b/apps/include/modbus/mbport.h index cfb1838ba..626469981 100644 --- a/apps/include/modbus/mbport.h +++ b/apps/include/modbus/mbport.h @@ -55,6 +55,26 @@ typedef enum EV_FRAME_SENT /* Frame sent. */ } eMBEventType; +typedef enum +{ + EV_MASTER_READY = 1<<0, /* Startup finished. */ + EV_MASTER_FRAME_RECEIVED = 1<<1, /* Frame received. */ + EV_MASTER_EXECUTE = 1<<2, /* Execute function. */ + EV_MASTER_FRAME_SENT = 1<<3, /* Frame sent. */ + EV_MASTER_ERROR_PROCESS = 1<<4, /* Frame error process. */ + EV_MASTER_PROCESS_SUCESS = 1<<5, /* Request process success. */ + EV_MASTER_ERROR_RESPOND_TIMEOUT = 1<<6, /* Request respond timeout. */ + EV_MASTER_ERROR_RECEIVE_DATA = 1<<7, /* Request receive data error. */ + EV_MASTER_ERROR_EXECUTE_FUNCTION = 1<<8 /* Request execute function error. */ +} eMBMasterEventType; + +typedef enum +{ + EV_ERROR_RESPOND_TIMEOUT, /* Slave respond timeout. */ + EV_ERROR_RECEIVE_DATA, /* Receive frame data erroe. */ + EV_ERROR_EXECUTE_FUNCTION /* Execute function error. */ +} eMBMasterErrorEventType; + /* Parity used for characters in serial mode. * * The parity which should be applied to the characters sent over the serial @@ -84,9 +104,13 @@ typedef enum * currently blocked on the eventqueue. */ -extern bool(*pxMBFrameCBByteReceived)(void); -extern bool(*pxMBFrameCBTransmitterEmpty)(void); -extern bool(*pxMBPortCBTimerExpired)(void); +extern bool(*pxMBFrameCBByteReceived)(void); +extern bool(*pxMBFrameCBTransmitterEmpty)(void); +extern bool(*pxMBPortCBTimerExpired)(void); + +extern bool(*pxMBMasterFrameCBByteReceived)(void); +extern bool(*pxMBMasterFrameCBTransmitterEmpty)(void); +extern bool(*pxMBMasterPortCBTimerExpired)(void); /**************************************************************************** * Public Function Prototypes @@ -96,7 +120,14 @@ extern bool(*pxMBPortCBTimerExpired)(void); bool xMBPortEventInit(void); bool xMBPortEventPost(eMBEventType eEvent); -bool xMBPortEventGet(/*@out@ */ eMBEventType * eEvent); +bool xMBPortEventGet(eMBEventType *eEvent); + +bool xMBMasterPortEventInit(void); +bool xMBMasterPortEventPost(eMBMasterEventType eEvent); +bool xMBMasterPortEventGet(eMBMasterEventType * eEvent); +void vMBMasterOsResInit(void); +bool xMBMasterRunResTake(int32_t time); +void vMBMasterRunResRelease(void); /* Serial port functions */ @@ -108,6 +139,14 @@ void vMBPortSerialEnable(bool xRxEnable, bool xTxEnable); bool xMBPortSerialGetByte(int8_t * pucByte); bool xMBPortSerialPutByte(int8_t ucByte); +bool xMBMasterPortSerialInit(uint8_t ucPort, speed_t ulBaudRate, + uint8_t ucDataBits, eMBParity eParity); +void vMBMasterPortClose(void); +void xMBMasterPortSerialClose(void); +void vMBMasterPortSerialEnable(bool xRxEnable, bool xTxEnable); +bool xMBMasterPortSerialGetByte(int8_t * pucByte); +bool xMBMasterPortSerialPutByte(int8_t ucByte); + /* Timers functions */ bool xMBPortTimersInit(uint16_t usTimeOut50us); @@ -116,6 +155,23 @@ void vMBPortTimersEnable(void); void vMBPortTimersDisable(void); void vMBPortTimersDelay(uint16_t usTimeOutMS); +bool xMBMasterPortTimersInit(uint16_t usTimeOut50us); +void xMBMasterPortTimersClose(void); +void vMBMasterPortTimersT35Enable(void); +void vMBMasterPortTimersConvertDelayEnable(void); +void vMBMasterPortTimersRespondTimeoutEnable(void); +void vMBMasterPortTimersDisable(void); + +/* Callback for the master error process */ + +void vMBMasterErrorCBRespondTimeout(uint8_t ucDestAddress, const uint8_t *pucPDUData, + uint16_t ucPDULength); +void vMBMasterErrorCBReceiveData(uint8_t ucDestAddress, const uint8_t *pucPDUData, + uint16_t ucPDULength); +void vMBMasterErrorCBExecuteFunction(uint8_t ucDestAddress, const uint8_t *pucPDUData, + uint16_t ucPDULength); +void vMBMasterCBRequestScuuess(void); + #ifdef CONFIG_MB_TCP_ENABLED /* TCP port function */ -- cgit v1.2.3