sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modbus: changes to several C file to make them more compatible with NuttX coding style

Browse Source
This commit is contained in:
Gregory Nutt 2015-04-07 15:57:52 -06:00
parent b1151ef033
commit c36f2fd564
9 changed files with 792 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/modbus/mbport.h
View File

@ -102,9 +102,7 @@ bool xMBPortEventGet(/*@out@ */ eMBEventType * eEvent);
bool xMBPortSerialInit(uint8_t ucPort, speed_t ulBaudRate, bool xMBPortSerialInit(uint8_t ucPort, speed_t ulBaudRate,
uint8_t ucDataBits, eMBParity eParity); uint8_t ucDataBits, eMBParity eParity);
#ifdef CONFIG_MB_HAVE_CLOSE
void vMBPortClose(void); void vMBPortClose(void);
#endif
void xMBPortSerialClose(void); void xMBPortSerialClose(void);
void vMBPortSerialEnable(bool xRxEnable, bool xTxEnable); void vMBPortSerialEnable(bool xRxEnable, bool xTxEnable);
bool xMBPortSerialGetByte(int8_t * pucByte); bool xMBPortSerialGetByte(int8_t * pucByte);
@ -118,6 +116,7 @@ void vMBPortTimersEnable(void);
void vMBPortTimersDisable(void); void vMBPortTimersDisable(void);
void vMBPortTimersDelay(uint16_t usTimeOutMS); void vMBPortTimersDelay(uint16_t usTimeOutMS);
#ifdef CONFIG_MB_TCP_ENABLED
/* TCP port function */ /* TCP port function */
bool xMBTCPPortInit(uint16_t usTCPPort); bool xMBTCPPortInit(uint16_t usTCPPort);
@ -127,6 +126,7 @@ void vMBTCPPortClose(void);
void vMBTCPPortDisable(void); void vMBTCPPortDisable(void);
bool xMBTCPPortGetRequest(uint8_t **ppucMBTCPFrame, uint16_t * usTCPLength); bool xMBTCPPortGetRequest(uint8_t **ppucMBTCPFrame, uint16_t * usTCPLength);
bool xMBTCPPortSendResponse(const uint8_t *pucMBTCPFrame, uint16_t usTCPLength); bool xMBTCPPortSendResponse(const uint8_t *pucMBTCPFrame, uint16_t usTCPLength);
#endif
#ifdef __cplusplus #ifdef __cplusplus
PR_END_EXTERN_C PR_END_EXTERN_C

1
modbus/Kconfig
View File

@ -24,6 +24,7 @@ config MB_TCP_ENABLED
config MB_HAVE_CLOSE config MB_HAVE_CLOSE
bool "Platform close callbacks" bool "Platform close callbacks"
default n default n
depends on MB_TCP_ENABLED
---help--- ---help---
A port which wants to get an callback must select A port which wants to get an callback must select
CONFIG_MB_HAVE_CLOSE and provide vMBPortClose() as CONFIG_MB_HAVE_CLOSE and provide vMBPortClose() as

290
modbus/ascii/mbascii.c
View File

@ -1,4 +1,6 @@
/* /****************************************************************************
* apps/modbus/ascii/mbascii.c
*
* FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU. * FreeModbus Libary: A portable Modbus implementation for Modbus ASCII/RTU.
* Copyright (c) 2006 Christian Walter <wolti@sil.at> * Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved. * All rights reserved.
@ -25,19 +27,19 @@
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* File: $Id: mbascii.c,v 1.17 2010/06/06 13:47:07 wolti Exp $ ****************************************************************************/
*/
/****************************************************************************
* Included Files
****************************************************************************/
/* ----------------------- System includes ----------------------------------*/
#include <nuttx/config.h> #include <nuttx/config.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
/* ----------------------- Platform includes --------------------------------*/
#include "port.h" #include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h> #include <apps/modbus/mb.h>
#include <apps/modbus/mbframe.h> #include <apps/modbus/mbframe.h>
#include <apps/modbus/mbport.h> #include <apps/modbus/mbport.h>
@ -47,51 +49,63 @@
#ifdef CONFIG_MB_ASCII_ENABLED #ifdef CONFIG_MB_ASCII_ENABLED
/* ----------------------- Defines ------------------------------------------*/ /****************************************************************************
#define MB_ASCII_DEFAULT_CR '\r' /*!< Default CR character for Modbus ASCII. */ * Pre-processor Definitions
#define MB_ASCII_DEFAULT_LF '\n' /*!< Default LF character for Modbus ASCII. */ ****************************************************************************/
#define MB_SER_PDU_SIZE_MIN 3 /*!< Minimum size of a Modbus ASCII frame. */
#define MB_SER_PDU_SIZE_MAX 256 /*!< Maximum size of a Modbus ASCII frame. */ #define MB_ASCII_DEFAULT_CR '\r' /* Default CR character for Modbus ASCII. */
#define MB_SER_PDU_SIZE_LRC 1 /*!< Size of LRC field in PDU. */ #define MB_ASCII_DEFAULT_LF '\n' /* Default LF character for Modbus ASCII. */
#define MB_SER_PDU_ADDR_OFF 0 /*!< Offset of slave address in Ser-PDU. */ #define MB_SER_PDU_SIZE_MIN 3 /* Minimum size of a Modbus ASCII frame. */
#define MB_SER_PDU_PDU_OFF 1 /*!< Offset of Modbus-PDU in Ser-PDU. */ #define MB_SER_PDU_SIZE_MAX 256 /* Maximum size of a Modbus ASCII frame. */
#define MB_SER_PDU_SIZE_LRC 1 /* Size of LRC field in PDU. */
#define MB_SER_PDU_ADDR_OFF 0 /* Offset of slave address in Ser-PDU. */
#define MB_SER_PDU_PDU_OFF 1 /* Offset of Modbus-PDU in Ser-PDU. */
/****************************************************************************
* Private Type Definitions
****************************************************************************/
/* ----------------------- Type definitions ---------------------------------*/
typedef enum typedef enum
{ {
STATE_RX_IDLE, /*!< Receiver is in idle state. */ STATE_RX_IDLE, /* Receiver is in idle state. */
STATE_RX_RCV, /*!< Frame is beeing received. */ STATE_RX_RCV, /* Frame is beeing received. */
STATE_RX_WAIT_EOF /*!< Wait for End of Frame. */ STATE_RX_WAIT_EOF /* Wait for End of Frame. */
} eMBRcvState; } eMBRcvState;
typedef enum typedef enum
{ {
STATE_TX_IDLE, /*!< Transmitter is in idle state. */ STATE_TX_IDLE, /* Transmitter is in idle state. */
STATE_TX_START, /*!< Starting transmission (':' sent). */ STATE_TX_START, /* Starting transmission (':' sent). */
STATE_TX_DATA, /*!< Sending of data (Address, Data, LRC). */ STATE_TX_DATA, /* Sending of data (Address, Data, LRC). */
STATE_TX_END, /*!< End of transmission. */ STATE_TX_END, /* End of transmission. */
STATE_TX_NOTIFY /*!< Notify sender that the frame has been sent. */ STATE_TX_NOTIFY /* Notify sender that the frame has been sent. */
} eMBSndState; } eMBSndState;
typedef enum typedef enum
{ {
BYTE_HIGH_NIBBLE, /*!< Character for high nibble of byte. */ BYTE_HIGH_NIBBLE, /* Character for high nibble of byte. */
BYTE_LOW_NIBBLE /*!< Character for low nibble of byte. */ BYTE_LOW_NIBBLE /* Character for low nibble of byte. */
} eMBBytePos; } eMBBytePos;
/* ----------------------- Static functions ---------------------------------*/ /****************************************************************************
* Private Function Prototypes
****************************************************************************/
static uint8_t prvucMBint8_t2BIN(uint8_t ucCharacter); static uint8_t prvucMBint8_t2BIN(uint8_t ucCharacter);
static uint8_t prvucMBBIN2int8_t(uint8_t ucByte); static uint8_t prvucMBBIN2int8_t(uint8_t ucByte);
static uint8_t prvucMBLRC(uint8_t *pucFrame, uint16_t usLen); static uint8_t prvucMBLRC(uint8_t *pucFrame, uint16_t usLen);
/* ----------------------- Static variables ---------------------------------*/ /****************************************************************************
* Private Data
****************************************************************************/
static volatile eMBSndState eSndState; static volatile eMBSndState eSndState;
static volatile eMBRcvState eRcvState; static volatile eMBRcvState eRcvState;
/* We reuse the Modbus RTU buffer because only one buffer is needed and the /* We reuse the Modbus RTU buffer because only one buffer is needed and the
* RTU buffer is bigger. */ * RTU buffer is bigger.
*/
extern volatile uint8_t ucRTUBuf[]; extern volatile uint8_t ucRTUBuf[];
static volatile uint8_t *ucASCIIBuf = ucRTUBuf; static volatile uint8_t *ucASCIIBuf = ucRTUBuf;
@ -104,9 +118,67 @@ static volatile uint16_t usSndBufferCount;
static volatile uint8_t ucLRC; static volatile uint8_t ucLRC;
static volatile uint8_t ucMBLFCharacter; static volatile uint8_t ucMBLFCharacter;
/* ----------------------- Start implementation -----------------------------*/ /****************************************************************************
eMBErrorCode * Private Functions
eMBASCIIInit( uint8_t ucSlaveAddress, uint8_t ucPort, speed_t ulBaudRate, eMBParity eParity ) ****************************************************************************/
static uint8_t prvucMBint8_t2BIN(uint8_t ucCharacter)
{
if ((ucCharacter >= '0') && (ucCharacter <= '9'))
{
return (uint8_t)(ucCharacter - '0');
}
else if ((ucCharacter >= 'A') && (ucCharacter <= 'F'))
{
return (uint8_t)(ucCharacter - 'A' + 0x0A);
}
else
{
return 0xFF;
}
}
static uint8_t prvucMBBIN2int8_t(uint8_t ucByte)
{
if (ucByte <= 0x09)
{
return (uint8_t)('0' + ucByte);
}
else if ((ucByte >= 0x0A) && (ucByte <= 0x0F))
{
return (uint8_t)(ucByte - 0x0A + 'A');
}
else
{
/* Programming error. */
ASSERT(0);
}
return '0';
}
static uint8_t prvucMBLRC(uint8_t * pucFrame, uint16_t usLen)
{
uint8_t ucLocalLRC = 0; /* LRC char initialized */
while (usLen--)
{
ucLocalLRC += *pucFrame++; /* Add buffer byte without carry */
}
/* Return twos complement */
ucLocalLRC = (uint8_t) (-((int8_t) ucLocalLRC));
return ucLocalLRC;
}
/****************************************************************************
* Public Functions
****************************************************************************/
eMBErrorCode eMBASCIIInit(uint8_t ucSlaveAddress, uint8_t ucPort,
speed_t ulBaudRate, eMBParity eParity)
{ {
eMBErrorCode eStatus = MB_ENOERR; eMBErrorCode eStatus = MB_ENOERR;
(void)ucSlaveAddress; (void)ucSlaveAddress;
@ -124,12 +196,10 @@ eMBASCIIInit( uint8_t ucSlaveAddress, uint8_t ucPort, speed_t ulBaudRate, eMBPar
} }
EXIT_CRITICAL_SECTION(); EXIT_CRITICAL_SECTION();
return eStatus; return eStatus;
} }
void void eMBASCIIStart(void)
eMBASCIIStart( void )
{ {
ENTER_CRITICAL_SECTION(); ENTER_CRITICAL_SECTION();
vMBPortSerialEnable(true, false); vMBPortSerialEnable(true, false);
@ -137,11 +207,11 @@ eMBASCIIStart( void )
EXIT_CRITICAL_SECTION(); EXIT_CRITICAL_SECTION();
/* No special startup required for ASCII. */ /* No special startup required for ASCII. */
(void)xMBPortEventPost(EV_READY); (void)xMBPortEventPost(EV_READY);
} }
void void eMBASCIIStop(void)
eMBASCIIStop( void )
{ {
ENTER_CRITICAL_SECTION(); ENTER_CRITICAL_SECTION();
vMBPortSerialEnable(false, false); vMBPortSerialEnable(false, false);
@ -149,8 +219,8 @@ eMBASCIIStop( void )
EXIT_CRITICAL_SECTION(); EXIT_CRITICAL_SECTION();
} }
eMBErrorCode eMBErrorCode eMBASCIIReceive(uint8_t *pucRcvAddress, uint8_t **pucFrame,
eMBASCIIReceive( uint8_t * pucRcvAddress, uint8_t ** pucFrame, uint16_t * pusLength ) uint16_t *pusLength)
{ {
eMBErrorCode eStatus = MB_ENOERR; eMBErrorCode eStatus = MB_ENOERR;
@ -158,56 +228,67 @@ eMBASCIIReceive( uint8_t * pucRcvAddress, uint8_t ** pucFrame, uint16_t * pusLen
ASSERT(usRcvBufferPos < MB_SER_PDU_SIZE_MAX); ASSERT(usRcvBufferPos < MB_SER_PDU_SIZE_MAX);
/* Length and CRC check */ /* Length and CRC check */
if( ( usRcvBufferPos >= MB_SER_PDU_SIZE_MIN )
&& ( prvucMBLRC( ( uint8_t * ) ucASCIIBuf, usRcvBufferPos ) == 0 ) ) if ((usRcvBufferPos >= MB_SER_PDU_SIZE_MIN) &&
(prvucMBLRC((uint8_t *) ucASCIIBuf, usRcvBufferPos) == 0))
{ {
/* Save the address field. All frames are passed to the upper layed /* Save the address field. All frames are passed to the upper layed
* and the decision if a frame is used is done there. * and the decision if a frame is used is done there.
*/ */
*pucRcvAddress = ucASCIIBuf[MB_SER_PDU_ADDR_OFF]; *pucRcvAddress = ucASCIIBuf[MB_SER_PDU_ADDR_OFF];
/* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus
* size of address field and CRC checksum. * size of address field and CRC checksum.
*/ */
*pusLength = (uint16_t)(usRcvBufferPos - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_LRC); *pusLength = (uint16_t)(usRcvBufferPos - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_LRC);
/* Return the start of the Modbus PDU to the caller. */ /* Return the start of the Modbus PDU to the caller. */
*pucFrame = (uint8_t *) & ucASCIIBuf[MB_SER_PDU_PDU_OFF]; *pucFrame = (uint8_t *) & ucASCIIBuf[MB_SER_PDU_PDU_OFF];
} }
else else
{ {
eStatus = MB_EIO; eStatus = MB_EIO;
} }
EXIT_CRITICAL_SECTION(); EXIT_CRITICAL_SECTION();
return eStatus; return eStatus;
} }
eMBErrorCode eMBErrorCode eMBASCIISend(uint8_t ucSlaveAddress, const uint8_t *pucFrame,
eMBASCIISend( uint8_t ucSlaveAddress, const uint8_t * pucFrame, uint16_t usLength ) uint16_t usLength)
{ {
eMBErrorCode eStatus = MB_ENOERR; eMBErrorCode eStatus = MB_ENOERR;
uint8_t usLRC; uint8_t usLRC;
ENTER_CRITICAL_SECTION(); ENTER_CRITICAL_SECTION();
/* Check if the receiver is still in idle state. If not we where too /* Check if the receiver is still in idle state. If not we where too
* slow with processing the received frame and the master sent another * slow with processing the received frame and the master sent another
* frame on the network. We have to abort sending the frame. * frame on the network. We have to abort sending the frame.
*/ */
if (eRcvState == STATE_RX_IDLE) if (eRcvState == STATE_RX_IDLE)
{ {
/* First byte before the Modbus-PDU is the slave address. */ /* First byte before the Modbus-PDU is the slave address. */
pucSndBufferCur = (uint8_t *) pucFrame - 1; pucSndBufferCur = (uint8_t *) pucFrame - 1;
usSndBufferCount = 1; usSndBufferCount = 1;
/* Now copy the Modbus-PDU into the Modbus-Serial-Line-PDU. */ /* Now copy the Modbus-PDU into the Modbus-Serial-Line-PDU. */
pucSndBufferCur[MB_SER_PDU_ADDR_OFF] = ucSlaveAddress; pucSndBufferCur[MB_SER_PDU_ADDR_OFF] = ucSlaveAddress;
usSndBufferCount += usLength; usSndBufferCount += usLength;
/* Calculate LRC checksum for Modbus-Serial-Line-PDU. */ /* Calculate LRC checksum for Modbus-Serial-Line-PDU. */
usLRC = prvucMBLRC((uint8_t *) pucSndBufferCur, usSndBufferCount); usLRC = prvucMBLRC((uint8_t *) pucSndBufferCur, usSndBufferCount);
ucASCIIBuf[usSndBufferCount++] = usLRC; ucASCIIBuf[usSndBufferCount++] = usLRC;
/* Activate the transmitter. */ /* Activate the transmitter. */
eSndState = STATE_TX_START; eSndState = STATE_TX_START;
vMBPortSerialEnable(false, true); vMBPortSerialEnable(false, true);
} }
@ -215,12 +296,12 @@ eMBASCIISend( uint8_t ucSlaveAddress, const uint8_t * pucFrame, uint16_t usLengt
{ {
eStatus = MB_EIO; eStatus = MB_EIO;
} }
EXIT_CRITICAL_SECTION(); EXIT_CRITICAL_SECTION();
return eStatus; return eStatus;
} }
bool bool xMBASCIIReceiveFSM(void)
xMBASCIIReceiveFSM( void )
{ {
bool xNeedPoll = false; bool xNeedPoll = false;
uint8_t ucByte; uint8_t ucByte;
@ -236,12 +317,15 @@ xMBASCIIReceiveFSM( void )
* block. Other characters are part of the data block and their * block. Other characters are part of the data block and their
* ASCII value is converted back to a binary representation. * ASCII value is converted back to a binary representation.
*/ */
case STATE_RX_RCV: case STATE_RX_RCV:
/* Enable timer for character timeout. */ /* Enable timer for character timeout. */
vMBPortTimersEnable(); vMBPortTimersEnable();
if (ucByte == ':') if (ucByte == ':')
{ {
/* Empty receive buffer. */ /* Empty receive buffer. */
eBytePos = BYTE_HIGH_NIBBLE; eBytePos = BYTE_HIGH_NIBBLE;
usRcvBufferPos = 0; usRcvBufferPos = 0;
} }
@ -255,7 +339,9 @@ xMBASCIIReceiveFSM( void )
switch (eBytePos) switch (eBytePos)
{ {
/* High nibble of the byte comes first. We check for /* High nibble of the byte comes first. We check for
* a buffer overflow here. */ * a buffer overflow here.
*/
case BYTE_HIGH_NIBBLE: case BYTE_HIGH_NIBBLE:
if (usRcvBufferPos < MB_SER_PDU_SIZE_MAX) if (usRcvBufferPos < MB_SER_PDU_SIZE_MAX)
{ {
@ -266,9 +352,13 @@ xMBASCIIReceiveFSM( void )
else else
{ {
/* not handled in Modbus specification but seems /* not handled in Modbus specification but seems
* a resonable implementation. */ * a resonable implementation.
*/
eRcvState = STATE_RX_IDLE; eRcvState = STATE_RX_IDLE;
/* Disable previously activated timer because of error state. */ /* Disable previously activated timer because of error state. */
vMBPortTimersDisable(); vMBPortTimersDisable();
} }
break; break;
@ -286,28 +376,37 @@ xMBASCIIReceiveFSM( void )
if (ucByte == ucMBLFCharacter) if (ucByte == ucMBLFCharacter)
{ {
/* Disable character timeout timer because all characters are /* Disable character timeout timer because all characters are
* received. */ * received.
*/
vMBPortTimersDisable(); vMBPortTimersDisable();
/* Receiver is again in idle state. */ /* Receiver is again in idle state. */
eRcvState = STATE_RX_IDLE; eRcvState = STATE_RX_IDLE;
/* Notify the caller of eMBASCIIReceive that a new frame /* Notify the caller of eMBASCIIReceive that a new frame
* was received. */ * was received.
*/
xNeedPoll = xMBPortEventPost(EV_FRAME_RECEIVED); xNeedPoll = xMBPortEventPost(EV_FRAME_RECEIVED);
} }
else if (ucByte == ':') else if (ucByte == ':')
{ {
/* Empty receive buffer and back to receive state. */ /* Empty receive buffer and back to receive state. */
eBytePos = BYTE_HIGH_NIBBLE; eBytePos = BYTE_HIGH_NIBBLE;
usRcvBufferPos = 0; usRcvBufferPos = 0;
eRcvState = STATE_RX_RCV; eRcvState = STATE_RX_RCV;
/* Enable timer for character timeout. */ /* Enable timer for character timeout. */
vMBPortTimersEnable(); vMBPortTimersEnable();
} }
else else
{ {
/* Frame is not okay. Delete entire frame. */ /* Frame is not okay. Delete entire frame. */
eRcvState = STATE_RX_IDLE; eRcvState = STATE_RX_IDLE;
} }
break; break;
@ -316,8 +415,11 @@ xMBASCIIReceiveFSM( void )
if (ucByte == ':') if (ucByte == ':')
{ {
/* Enable timer for character timeout. */ /* Enable timer for character timeout. */
vMBPortTimersEnable(); vMBPortTimersEnable();
/* Reset the input buffers to store the frame. */ /* Reset the input buffers to store the frame. */
usRcvBufferPos = 0;; usRcvBufferPos = 0;;
eBytePos = BYTE_HIGH_NIBBLE; eBytePos = BYTE_HIGH_NIBBLE;
eRcvState = STATE_RX_RCV; eRcvState = STATE_RX_RCV;
@ -328,8 +430,7 @@ xMBASCIIReceiveFSM( void )
return xNeedPoll; return xNeedPoll;
} }
bool bool xMBASCIITransmitFSM(void)
xMBASCIITransmitFSM( void )
{ {
bool xNeedPoll = false; bool xNeedPoll = false;
uint8_t ucByte; uint8_t ucByte;
@ -338,7 +439,9 @@ xMBASCIITransmitFSM( void )
switch (eSndState) switch (eSndState)
{ {
/* Start of transmission. The start of a frame is defined by sending /* Start of transmission. The start of a frame is defined by sending
* the character ':'. */ * the character ':'.
*/
case STATE_TX_START: case STATE_TX_START:
ucByte = ':'; ucByte = ':';
xMBPortSerialPutByte((int8_t)ucByte); xMBPortSerialPutByte((int8_t)ucByte);
@ -349,7 +452,9 @@ xMBASCIITransmitFSM( void )
/* Send the data block. Each data byte is encoded as a character hex /* Send the data block. Each data byte is encoded as a character hex
* stream with the high nibble sent first and the low nibble sent * stream with the high nibble sent first and the low nibble sent
* last. If all data bytes are exhausted we send a '\r' character * last. If all data bytes are exhausted we send a '\r' character
* to end the transmission. */ * to end the transmission.
*/
case STATE_TX_DATA: case STATE_TX_DATA:
if (usSndBufferCount > 0) if (usSndBufferCount > 0)
{ {
@ -378,29 +483,40 @@ xMBASCIITransmitFSM( void )
break; break;
/* Finish the frame by sending a LF character. */ /* Finish the frame by sending a LF character. */
case STATE_TX_END: case STATE_TX_END:
xMBPortSerialPutByte((int8_t)ucMBLFCharacter); xMBPortSerialPutByte((int8_t)ucMBLFCharacter);
/* We need another state to make sure that the CR character has /* We need another state to make sure that the CR character has
* been sent. */ * been sent.
*/
eSndState = STATE_TX_NOTIFY; eSndState = STATE_TX_NOTIFY;
break; break;
/* Notify the task which called eMBASCIISend that the frame has /* Notify the task which called eMBASCIISend that the frame has
* been sent. */ * been sent.
*/
case STATE_TX_NOTIFY: case STATE_TX_NOTIFY:
eSndState = STATE_TX_IDLE; eSndState = STATE_TX_IDLE;
xNeedPoll = xMBPortEventPost(EV_FRAME_SENT); xNeedPoll = xMBPortEventPost(EV_FRAME_SENT);
/* Disable transmitter. This prevents another transmit buffer /* Disable transmitter. This prevents another transmit buffer
* empty interrupt. */ * empty interrupt.
*/
vMBPortSerialEnable(true, false); vMBPortSerialEnable(true, false);
eSndState = STATE_TX_IDLE; eSndState = STATE_TX_IDLE;
break; break;
/* We should not get a transmitter event if the transmitter is in /* We should not get a transmitter event if the transmitter is in
* idle state. */ * idle state.
*/
case STATE_TX_IDLE: case STATE_TX_IDLE:
/* enable receiver/disable transmitter. */ /* enable receiver/disable transmitter. */
vMBPortSerialEnable(true, false); vMBPortSerialEnable(true, false);
break; break;
} }
@ -408,8 +524,7 @@ xMBASCIITransmitFSM( void )
return xNeedPoll; return xNeedPoll;
} }
bool bool xMBASCIITimerT1SExpired(void)
xMBASCIITimerT1SExpired( void )
{ {
switch (eRcvState) switch (eRcvState)
{ {
@ -425,63 +540,12 @@ xMBASCIITimerT1SExpired( void )
ASSERT((eRcvState == STATE_RX_RCV) || (eRcvState == STATE_RX_WAIT_EOF)); ASSERT((eRcvState == STATE_RX_RCV) || (eRcvState == STATE_RX_WAIT_EOF));
break; break;
} }
vMBPortTimersDisable(); vMBPortTimersDisable();
/* no context switch required. */ /* no context switch required. */
return false; return false;
} }
static uint8_t
prvucMBint8_t2BIN( uint8_t ucCharacter )
{
if( ( ucCharacter >= '0' ) && ( ucCharacter <= '9' ) )
{
return ( uint8_t )( ucCharacter - '0' );
}
else if( ( ucCharacter >= 'A' ) && ( ucCharacter <= 'F' ) )
{
return ( uint8_t )( ucCharacter - 'A' + 0x0A );
}
else
{
return 0xFF;
}
}
static uint8_t
prvucMBBIN2int8_t( uint8_t ucByte )
{
if( ucByte <= 0x09 )
{
return ( uint8_t )( '0' + ucByte );
}
else if( ( ucByte >= 0x0A ) && ( ucByte <= 0x0F ) )
{
return ( uint8_t )( ucByte - 0x0A + 'A' );
}
else
{
/* Programming error. */
ASSERT( 0 );
}
return '0';
}
static uint8_t
prvucMBLRC( uint8_t * pucFrame, uint16_t usLen )
{
uint8_t ucLocalLRC = 0; /* LRC char initialized */
while( usLen-- )
{
ucLocalLRC += *pucFrame++; /* Add buffer byte without carry */
}
/* Return twos complement */
ucLocalLRC = ( uint8_t ) ( -( ( int8_t ) ucLocalLRC ) );
return ucLocalLRC;
}
#endif #endif

8
modbus/mb.c
View File

@ -160,11 +160,7 @@ eMBErrorCode eMBInit(eMBMode eMode, uint8_t ucSlaveAddress, uint8_t ucPort,
pvMBFrameStopCur = eMBRTUStop; pvMBFrameStopCur = eMBRTUStop;
peMBFrameSendCur = eMBRTUSend; peMBFrameSendCur = eMBRTUSend;
peMBFrameReceiveCur = eMBRTUReceive; peMBFrameReceiveCur = eMBRTUReceive;
#ifdef CONFIG_MB_HAVE_CLOSE
pvMBFrameCloseCur = vMBPortClose; pvMBFrameCloseCur = vMBPortClose;
#else
pvMBFrameCloseCur = NULL;
#endif
pxMBFrameCBByteReceived = xMBRTUReceiveFSM; pxMBFrameCBByteReceived = xMBRTUReceiveFSM;
pxMBFrameCBTransmitterEmpty = xMBRTUTransmitFSM; pxMBFrameCBTransmitterEmpty = xMBRTUTransmitFSM;
pxMBPortCBTimerExpired = xMBRTUTimerT35Expired; pxMBPortCBTimerExpired = xMBRTUTimerT35Expired;
@ -178,11 +174,7 @@ eMBErrorCode eMBInit(eMBMode eMode, uint8_t ucSlaveAddress, uint8_t ucPort,
pvMBFrameStopCur = eMBASCIIStop; pvMBFrameStopCur = eMBASCIIStop;
peMBFrameSendCur = eMBASCIISend; peMBFrameSendCur = eMBASCIISend;
peMBFrameReceiveCur = eMBASCIIReceive; peMBFrameReceiveCur = eMBASCIIReceive;
#ifdef CONFIG_MB_HAVE_CLOSE
pvMBFrameCloseCur = vMBPortClose; pvMBFrameCloseCur = vMBPortClose;
#else
pvMBFrameCloseCur = NULL;
#endif
pxMBFrameCBByteReceived = xMBASCIIReceiveFSM; pxMBFrameCBByteReceived = xMBASCIIReceiveFSM;
pxMBFrameCBTransmitterEmpty = xMBASCIITransmitFSM; pxMBFrameCBTransmitterEmpty = xMBASCIITransmitFSM;
pxMBPortCBTimerExpired = xMBASCIITimerT1SExpired; pxMBPortCBTimerExpired = xMBASCIITimerT1SExpired;

37
modbus/nuttx/port.h
View File

@ -2,23 +2,30 @@
* apps/modbus/nuttx/port.h * apps/modbus/nuttx/port.h
* *
* FreeModbus Library: NuttX Port * FreeModbus Library: NuttX Port
* Based on the FreeModbus Linux port by: * Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
* *
* Copyright (C) 2006 Christian Walter <wolti@sil.at> * 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 library is free software; you can redistribute it and/or * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* modify it under the terms of the GNU Lesser General Public * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* License as published by the Free Software Foundation; either * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* version 2.1 of the License, or (at your option) any later version. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* This library is distributed in the hope that it will be useful, * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* Lesser General Public License for more details. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
* *
****************************************************************************/ ****************************************************************************/

72
modbus/nuttx/portevent.c
View File

@ -1,54 +1,68 @@
/* /****************************************************************************
* apps/modbus/nuttx/portevent.c
*
* FreeModbus Libary: NuttX Port * FreeModbus Libary: NuttX Port
* Based on the FreeModbus Linux port by: * Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
* *
* Copyright (C) 2006 Christian Walter <wolti@sil.at> * 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 library is free software; you can redistribute it and/or * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* modify it under the terms of the GNU Lesser General Public * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* License as published by the Free Software Foundation; either * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* version 2.1 of the License, or (at your option) any later version. * 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.
* *
* This library is distributed in the hope that it will be useful, ****************************************************************************/
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU /****************************************************************************
* Lesser General Public License for more details. * Included Files
* ****************************************************************************/
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* File: $Id: portevent.c,v 1.1 2006/08/01 20:58:49 wolti Exp $
*/
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h> #include <apps/modbus/mb.h>
#include <apps/modbus/mbport.h> #include <apps/modbus/mbport.h>
#include "port.h" #include "port.h"
/* ----------------------- Variables ----------------------------------------*/ /****************************************************************************
* Private Data
****************************************************************************/
static eMBEventType eQueuedEvent; static eMBEventType eQueuedEvent;
static bool xEventInQueue; static bool xEventInQueue;
/* ----------------------- Start implementation -----------------------------*/ /****************************************************************************
bool * Public Functions
xMBPortEventInit( void ) ****************************************************************************/
bool xMBPortEventInit(void)
{ {
xEventInQueue = false; xEventInQueue = false;
return true; return true;
} }
bool bool xMBPortEventPost(eMBEventType eEvent)
xMBPortEventPost( eMBEventType eEvent )
{ {
xEventInQueue = true; xEventInQueue = true;
eQueuedEvent = eEvent; eQueuedEvent = eEvent;
return true; return true;
} }
bool bool xMBPortEventGet(eMBEventType * eEvent)
xMBPortEventGet( eMBEventType * eEvent )
{ {
bool xEventHappened = false; bool xEventHappened = false;
@ -66,11 +80,13 @@ xMBPortEventGet( eMBEventType * eEvent )
* amount of time. Both timeouts are configured from the timer * amount of time. Both timeouts are configured from the timer
* init functions. * init functions.
*/ */
(void)xMBPortSerialPoll(); (void)xMBPortSerialPoll();
/* Check if any of the timers have expired. */ /* Check if any of the timers have expired. */
vMBPortTimerPoll( );
vMBPortTimerPoll();
} }
return xEventHappened; return xEventHappened;
} }

62
modbus/nuttx/portother.c
View File

@ -1,27 +1,37 @@
/* /****************************************************************************
* apps/modbus/nuttx/portother.c
*
* FreeModbus Libary: NuttX Port * FreeModbus Libary: NuttX Port
* Based on the FreeModbus Linux port by: * Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
* *
* Copyright (C) 2006 Christian Walter <wolti@sil.at> * 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 library is free software; you can redistribute it and/or * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* modify it under the terms of the GNU Lesser General Public * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* License as published by the Free Software Foundation; either * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* version 2.1 of the License, or (at your option) any later version. * 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.
* *
* This library is distributed in the hope that it will be useful, ****************************************************************************/
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* File: $Id: portother.c,v 1.1 2006/08/01 20:58:49 wolti Exp $
*/
/* ----------------------- Standard includes --------------------------------*/ /****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h> #include <nuttx/config.h>
#include <stdio.h> #include <stdio.h>
@ -33,22 +43,26 @@
#include "port.h" #include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h> #include <apps/modbus/mb.h>
#include <apps/modbus/mbport.h> #include <apps/modbus/mbport.h>
/* ----------------------- Defines ------------------------------------------*/ /****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define NELEMS(x) (sizeof((x))/sizeof((x)[0])) #define NELEMS(x) (sizeof((x))/sizeof((x)[0]))
/* ----------------------- Static variables ---------------------------------*/ /****************************************************************************
* Private Data
****************************************************************************/
static FILE *fLogFile = NULL; static FILE *fLogFile = NULL;
static eMBPortLogLevel eLevelMax = MB_LOG_DEBUG; static eMBPortLogLevel eLevelMax = MB_LOG_DEBUG;
static pthread_mutex_t xLock = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t xLock = PTHREAD_MUTEX_INITIALIZER;
/* ----------------------- Start implementation -----------------------------*/ /****************************************************************************
* Public Functions
****************************************************************************/
void vMBPortLogLevel(eMBPortLogLevel eNewLevelMax) void vMBPortLogLevel(eMBPortLogLevel eNewLevelMax)
{ {

243
modbus/nuttx/portserial.c
View File

@ -1,27 +1,37 @@
/* /****************************************************************************
* apps/modbus/nuttx/portserial.c
*
* FreeModbus Libary: NuttX Port * FreeModbus Libary: NuttX Port
* Based on the FreeModbus Linux port by: * Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
* *
* Copyright (C) 2006 Christian Walter <wolti@sil.at> * 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 library is free software; you can redistribute it and/or * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* modify it under the terms of the GNU Lesser General Public * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* License as published by the Free Software Foundation; either * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* version 2.1 of the License, or (at your option) any later version. * 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.
* *
* This library is distributed in the hope that it will be useful, ****************************************************************************/
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* File: $Id: portserial.c,v 1.3 2006/10/12 08:35:34 wolti Exp $
*/
/* ----------------------- Standard includes --------------------------------*/ /****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h> #include <nuttx/config.h>
#include <stdio.h> #include <stdio.h>
@ -42,12 +52,12 @@
#include "port.h" #include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h> #include <apps/modbus/mb.h>
#include <apps/modbus/mbport.h> #include <apps/modbus/mbport.h>
/* ----------------------- Defines -----------------------------------------*/ /****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#ifdef CONFIG_MB_ASCII_ENABLED #ifdef CONFIG_MB_ASCII_ENABLED
#define BUF_SIZE 513 /* must hold a complete ASCII frame. */ #define BUF_SIZE 513 /* must hold a complete ASCII frame. */
@ -55,7 +65,9 @@
#define BUF_SIZE 256 /* must hold a complete RTU frame. */ #define BUF_SIZE 256 /* must hold a complete RTU frame. */
#endif #endif
/* ----------------------- Static variables ---------------------------------*/ /****************************************************************************
* Private Data
****************************************************************************/
static int iSerialFd = -1; static int iSerialFd = -1;
static bool bRxEnabled; static bool bRxEnabled;
@ -70,12 +82,97 @@ static int uiTxBufferPos;
static struct termios xOldTIO; static struct termios xOldTIO;
#endif #endif
/* ----------------------- Function prototypes ------------------------------*/ /****************************************************************************
* Private Function Prototypes
****************************************************************************/
static bool prvbMBPortSerialRead(uint8_t *pucBuffer, uint16_t usNBytes, uint16_t *usNBytesRead); static bool prvbMBPortSerialRead(uint8_t *pucBuffer, uint16_t usNBytes,
uint16_t *usNBytesRead);
static bool prvbMBPortSerialWrite(uint8_t *pucBuffer, uint16_t usNBytes); static bool prvbMBPortSerialWrite(uint8_t *pucBuffer, uint16_t usNBytes);
/* ----------------------- Begin implementation -----------------------------*/ /****************************************************************************
* Private Functions
****************************************************************************/
static bool prvbMBPortSerialRead(uint8_t *pucBuffer, uint16_t usNBytes,
uint16_t *usNBytesRead)
{
bool bResult = true;
ssize_t res;
fd_set rfds;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 50000;
FD_ZERO(&rfds);
FD_SET(iSerialFd, &rfds);
/* Wait until character received or timeout. Recover in case of an
* interrupted read system call.
*/
do
{
if (select(iSerialFd + 1, &rfds, NULL, NULL, &tv) == -1)
{
if (errno != EINTR)
{
bResult = false;
}
}
else if (FD_ISSET(iSerialFd, &rfds))
{
if ((res = read(iSerialFd, pucBuffer, usNBytes)) == -1)
{
bResult = false;
}
else
{
*usNBytesRead = (uint16_t)res;
break;
}
}
else
{
*usNBytesRead = 0;
break;
}
}
while (bResult == true);
return bResult;
}
static bool prvbMBPortSerialWrite(uint8_t *pucBuffer, uint16_t usNBytes)
{
ssize_t res;
size_t left = (size_t) usNBytes;
size_t done = 0;
while (left > 0)
{
if ((res = write(iSerialFd, pucBuffer + done, left)) == -1)
{
if (errno != EINTR)
{
break;
}
/* call write again because of interrupted system call. */
continue;
}
done += res;
left -= res;
}
return left == 0 ? true : false;
}
/****************************************************************************
* Public Functions
****************************************************************************/
void vMBPortSerialEnable(bool bEnableRx, bool bEnableTx) void vMBPortSerialEnable(bool bEnableRx, bool bEnableTx)
{ {
@ -141,12 +238,15 @@ bool xMBPortSerialInit(uint8_t ucPort, speed_t ulBaudRate,
{ {
case MB_PAR_NONE: case MB_PAR_NONE:
break; break;
case MB_PAR_EVEN: case MB_PAR_EVEN:
xNewTIO.c_cflag |= PARENB; xNewTIO.c_cflag |= PARENB;
break; break;
case MB_PAR_ODD: case MB_PAR_ODD:
xNewTIO.c_cflag |= PARENB | PARODD; xNewTIO.c_cflag |= PARENB | PARODD;
break; break;
default: default:
bStatus = false; bStatus = false;
} }
@ -156,9 +256,11 @@ bool xMBPortSerialInit(uint8_t ucPort, speed_t ulBaudRate,
case 8: case 8:
xNewTIO.c_cflag |= CS8; xNewTIO.c_cflag |= CS8;
break; break;
case 7: case 7:
xNewTIO.c_cflag |= CS7; xNewTIO.c_cflag |= CS7;
break; break;
default: default:
bStatus = false; bStatus = false;
} }
@ -226,82 +328,7 @@ void vMBPortClose(void)
} }
} }
bool prvbMBPortSerialRead(uint8_t *pucBuffer, uint16_t usNBytes, uint16_t *usNBytesRead) bool xMBPortSerialPoll(void)
{
bool bResult = true;
ssize_t res;
fd_set rfds;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 50000;
FD_ZERO(&rfds);
FD_SET(iSerialFd, &rfds);
/* Wait until character received or timeout. Recover in case of an
* interrupted read system call.
*/
do
{
if (select(iSerialFd + 1, &rfds, NULL, NULL, &tv) == -1)
{
if (errno != EINTR)
{
bResult = false;
}
}
else if (FD_ISSET(iSerialFd, &rfds))
{
if ((res = read(iSerialFd, pucBuffer, usNBytes)) == -1)
{
bResult = false;
}
else
{
*usNBytesRead = (uint16_t)res;
break;
}
}
else
{
*usNBytesRead = 0;
break;
}
}
while(bResult == true);
return bResult;
}
bool prvbMBPortSerialWrite(uint8_t *pucBuffer, uint16_t usNBytes)
{
ssize_t res;
size_t left = (size_t) usNBytes;
size_t done = 0;
while(left > 0)
{
if ((res = write(iSerialFd, pucBuffer + done, left)) == -1)
{
if (errno != EINTR)
{
break;
}
/* call write again because of interrupted system call. */
continue;
}
done += res;
left -= res;
}
return left == 0 ? true : false;
}
bool
xMBPortSerialPoll()
{ {
bool bStatus = true; bool bStatus = true;
uint16_t usBytesRead; uint16_t usBytesRead;
@ -314,6 +341,7 @@ xMBPortSerialPoll()
if (usBytesRead == 0) if (usBytesRead == 0)
{ {
/* timeout with no bytes. */ /* timeout with no bytes. */
break; break;
} }
else if (usBytesRead > 0) else if (usBytesRead > 0)
@ -321,8 +349,10 @@ xMBPortSerialPoll()
for (i = 0; i < usBytesRead; i++) for (i = 0; i < usBytesRead; i++)
{ {
/* Call the modbus stack and let him fill the buffers. */ /* Call the modbus stack and let him fill the buffers. */
(void)pxMBFrameCBByteReceived(); (void)pxMBFrameCBByteReceived();
} }
uiRxBufferPos = 0; uiRxBufferPos = 0;
} }
} }
@ -333,13 +363,16 @@ xMBPortSerialPoll()
bStatus = false; bStatus = false;
} }
} }
if (bTxEnabled) if (bTxEnabled)
{ {
while (bTxEnabled) while (bTxEnabled)
{ {
(void)pxMBFrameCBTransmitterEmpty(); (void)pxMBFrameCBTransmitterEmpty();
/* Call the modbus stack to let him fill the buffer. */ /* Call the modbus stack to let him fill the buffer. */
} }
if (!prvbMBPortSerialWrite(&ucBuffer[0], uiTxBufferPos)) if (!prvbMBPortSerialWrite(&ucBuffer[0], uiTxBufferPos))
{ {
vMBPortLog(MB_LOG_ERROR, "SER-POLL", "write failed on serial device: %d\n", vMBPortLog(MB_LOG_ERROR, "SER-POLL", "write failed on serial device: %d\n",
@ -351,8 +384,7 @@ xMBPortSerialPoll()
return bStatus; return bStatus;
} }
bool bool xMBPortSerialPutByte(int8_t ucByte)
xMBPortSerialPutByte(int8_t ucByte)
{ {
ASSERT(uiTxBufferPos < BUF_SIZE); ASSERT(uiTxBufferPos < BUF_SIZE);
ucBuffer[uiTxBufferPos] = ucByte; ucBuffer[uiTxBufferPos] = ucByte;
@ -360,8 +392,7 @@ xMBPortSerialPutByte(int8_t ucByte)
return true; return true;
} }
bool bool xMBPortSerialGetByte(int8_t *pucByte)
xMBPortSerialGetByte(int8_t *pucByte)
{ {
ASSERT(uiRxBufferPos < BUF_SIZE); ASSERT(uiRxBufferPos < BUF_SIZE);
*pucByte = ucBuffer[uiRxBufferPos]; *pucByte = ucBuffer[uiRxBufferPos];

81
modbus/nuttx/porttimer.c
View File

@ -1,27 +1,38 @@
/* /****************************************************************************
* apps/modbus/nuttx/porttimer.c
*
* FreeModbus Libary: NuttX Port * FreeModbus Libary: NuttX Port
* Based on the FreeModbus Linux port by: * Copyright (c) 2006 Christian Walter <wolti@sil.at>
* All rights reserved.
* *
* Copyright (C) 2006 Christian Walter <wolti@sil.at> * 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 library is free software; you can redistribute it and/or * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* modify it under the terms of the GNU Lesser General Public * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* License as published by the Free Software Foundation; either * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* version 2.1 of the License, or (at your option) any later version. * 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.
* *
* This library is distributed in the hope that it will be useful, ****************************************************************************/
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU /****************************************************************************
* Lesser General Public License for more details. * Included Files
* ****************************************************************************/
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* File: $Id: porttimer.c,v 1.1 2006/08/01 20:58:50 wolti Exp $
*/
/* ----------------------- Standard includes --------------------------------*/
#include <nuttx/config.h> #include <nuttx/config.h>
#include <sys/time.h> #include <sys/time.h>
@ -30,43 +41,47 @@
#include "port.h" #include "port.h"
/* ----------------------- Modbus includes ----------------------------------*/
#include <apps/modbus/mb.h> #include <apps/modbus/mb.h>
#include <apps/modbus/mbport.h> #include <apps/modbus/mbport.h>
/* ----------------------- Defines ------------------------------------------*/ /****************************************************************************
* Public Data
****************************************************************************/
/* ----------------------- Static variables ---------------------------------*/
uint32_t ulTimeOut; uint32_t ulTimeOut;
bool bTimeoutEnable; bool bTimeoutEnable;
static struct timeval xTimeLast; static struct timeval xTimeLast;
/* ----------------------- Start implementation -----------------------------*/ /****************************************************************************
bool * Public Functions
xMBPortTimersInit( uint16_t usTim1Timerout50us ) ****************************************************************************/
bool xMBPortTimersInit(uint16_t usTim1Timerout50us)
{ {
ulTimeOut = usTim1Timerout50us / 20U; ulTimeOut = usTim1Timerout50us / 20U;
if (ulTimeOut == 0) if (ulTimeOut == 0)
{
ulTimeOut = 1; ulTimeOut = 1;
}
return xMBPortSerialSetTimeout(ulTimeOut); return xMBPortSerialSetTimeout(ulTimeOut);
} }
void void xMBPortTimersClose()
xMBPortTimersClose( )
{ {
/* Does not use any hardware resources. */ /* Does not use any hardware resources. */
} }
void void vMBPortTimerPoll()
vMBPortTimerPoll( )
{ {
uint32_t ulDeltaMS; uint32_t ulDeltaMS;
struct timeval xTimeCur; struct timeval xTimeCur;
/* Timers are called from the serial layer because we have no high /* Timers are called from the serial layer because we have no high
* res timer in Win32. */ * res timer in Win32.
*/
if (bTimeoutEnable) if (bTimeoutEnable)
{ {
if (gettimeofday(&xTimeCur, NULL) != 0) if (gettimeofday(&xTimeCur, NULL) != 0)
@ -86,8 +101,7 @@ vMBPortTimerPoll( )
} }
} }
void void vMBPortTimersEnable()
vMBPortTimersEnable( )
{ {
int res = gettimeofday(&xTimeLast, NULL); int res = gettimeofday(&xTimeLast, NULL);
@ -95,8 +109,7 @@ vMBPortTimersEnable( )
bTimeoutEnable = true; bTimeoutEnable = true;
} }
void void vMBPortTimersDisable()
vMBPortTimersDisable( )
{ {
bTimeoutEnable = false; bTimeoutEnable = false;
} }