From e7c16f92d00150e61f2d3ae20b6007776ef80f0f Mon Sep 17 00:00:00 2001 From: aleks Date: Tue, 22 Sep 2020 14:21:25 +0200 Subject: [PATCH] freemodbuss: fix event processing after merge --- .../modbus/functions/mbfunccoils_m.c | 6 +- .../modbus/functions/mbfuncdisc_m.c | 44 ++-- .../modbus/functions/mbfuncholding_m.c | 136 +++++----- .../modbus/functions/mbfuncinput_m.c | 32 +-- components/freemodbus/modbus/include/mbport.h | 14 +- components/freemodbus/modbus/mb_m.c | 248 +++++++++--------- components/freemodbus/modbus/rtu/mbrtu.c | 3 +- components/freemodbus/modbus/rtu/mbrtu_m.c | 121 +++++---- components/freemodbus/port/port.h | 5 +- components/freemodbus/port/portevent_m.c | 63 ++--- .../modbus_controller/mbc_serial_master.c | 8 +- 11 files changed, 343 insertions(+), 337 deletions(-) diff --git a/components/freemodbus/modbus/functions/mbfunccoils_m.c b/components/freemodbus/modbus/functions/mbfunccoils_m.c index 744806a1e7..6749a6e67b 100644 --- a/components/freemodbus/modbus/functions/mbfunccoils_m.c +++ b/components/freemodbus/modbus/functions/mbfunccoils_m.c @@ -103,7 +103,7 @@ eMBMasterReqReadCoils( UCHAR ucSndAddr, USHORT usCoilAddr, USHORT usNCoils, LONG ucMBFrame[MB_PDU_REQ_READ_COILCNT_OFF ] = usNCoils >> 8; ucMBFrame[MB_PDU_REQ_READ_COILCNT_OFF + 1] = usNCoils; vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); eErrStatus = eMBMasterWaitRequestFinish( ); } @@ -210,7 +210,7 @@ eMBMasterReqWriteCoil( UCHAR ucSndAddr, USHORT usCoilAddr, USHORT usCoilData, LO ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF ] = usCoilData >> 8; ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF + 1] = usCoilData; vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_SIZE ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; @@ -320,7 +320,7 @@ eMBMasterReqWriteMultipleCoils( UCHAR ucSndAddr, *ucMBFrame++ = pucDataBuffer[usRegIndex++]; } vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_MUL_SIZE_MIN + ucByteCount ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; diff --git a/components/freemodbus/modbus/functions/mbfuncdisc_m.c b/components/freemodbus/modbus/functions/mbfuncdisc_m.c index 34e2d0c947..6e9a8666b0 100644 --- a/components/freemodbus/modbus/functions/mbfuncdisc_m.c +++ b/components/freemodbus/modbus/functions/mbfuncdisc_m.c @@ -78,16 +78,16 @@ eMBMasterReqReadDiscreteInputs( UCHAR ucSndAddr, USHORT usDiscreteAddr, USHORT u else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { - vMBMasterGetPDUSndBuf(&ucMBFrame); - vMBMasterSetDestAddress(ucSndAddr); - ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_DISCRETE_INPUTS; - ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usDiscreteAddr >> 8; - ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usDiscreteAddr; - ucMBFrame[MB_PDU_REQ_READ_DISCCNT_OFF ] = usNDiscreteIn >> 8; - ucMBFrame[MB_PDU_REQ_READ_DISCCNT_OFF + 1] = usNDiscreteIn; - vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); - eErrStatus = eMBMasterWaitRequestFinish( ); + vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterSetDestAddress(ucSndAddr); + ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_DISCRETE_INPUTS; + ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usDiscreteAddr >> 8; + ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usDiscreteAddr; + ucMBFrame[MB_PDU_REQ_READ_DISCCNT_OFF ] = usNDiscreteIn >> 8; + ucMBFrame[MB_PDU_REQ_READ_DISCCNT_OFF + 1] = usNDiscreteIn; + vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); + eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; } @@ -106,11 +106,11 @@ eMBMasterFuncReadDiscreteInputs( UCHAR * pucFrame, USHORT * usLen ) /* If this request is broadcast, and it's read mode. This request don't need execute. */ if ( xMBMasterRequestIsBroadcast() ) { - eStatus = MB_EX_NONE; + eStatus = MB_EX_NONE; } else if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READ_SIZE_MIN ) { - vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterGetPDUSndBuf(&ucMBFrame); usRegAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] << 8 ); usRegAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] ); usRegAddress++; @@ -122,26 +122,26 @@ eMBMasterFuncReadDiscreteInputs( UCHAR * pucFrame, USHORT * usLen ) * byte is only partially field with unused coils set to zero. */ if( ( usDiscreteCnt & 0x0007 ) != 0 ) { - ucNBytes = ( UCHAR )( usDiscreteCnt / 8 + 1 ); + ucNBytes = ( UCHAR )( usDiscreteCnt / 8 + 1 ); } else { - ucNBytes = ( UCHAR )( usDiscreteCnt / 8 ); + ucNBytes = ( UCHAR )( usDiscreteCnt / 8 ); } /* Check if the number of registers to read is valid. If not * return Modbus illegal data value exception. */ - if ((usDiscreteCnt >= 1) && ucNBytes == pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF]) + if ((usDiscreteCnt >= 1) && ucNBytes == pucFrame[MB_PDU_FUNC_READ_DISCCNT_OFF]) { - /* Make callback to fill the buffer. */ - eRegStatus = eMBMasterRegDiscreteCB( &pucFrame[MB_PDU_FUNC_READ_VALUES_OFF], usRegAddress, usDiscreteCnt ); + /* Make callback to fill the buffer. */ + eRegStatus = eMBMasterRegDiscreteCB( &pucFrame[MB_PDU_FUNC_READ_VALUES_OFF], usRegAddress, usDiscreteCnt ); - /* If an error occured convert it into a Modbus exception. */ - if( eRegStatus != MB_ENOERR ) - { - eStatus = prveMBError2Exception( eRegStatus ); - } + /* If an error occured convert it into a Modbus exception. */ + if( eRegStatus != MB_ENOERR ) + { + eStatus = prveMBError2Exception( eRegStatus ); + } } else { diff --git a/components/freemodbus/modbus/functions/mbfuncholding_m.c b/components/freemodbus/modbus/functions/mbfuncholding_m.c index a0c526d33a..c2d7b94e62 100644 --- a/components/freemodbus/modbus/functions/mbfuncholding_m.c +++ b/components/freemodbus/modbus/functions/mbfuncholding_m.c @@ -106,16 +106,16 @@ eMBMasterReqWriteHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usRe else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { - vMBMasterGetPDUSndBuf(&ucMBFrame); - vMBMasterSetDestAddress(ucSndAddr); - ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_REGISTER; - ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF] = usRegAddr >> 8; - ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF + 1] = usRegAddr; - ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF] = usRegData >> 8; - ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF + 1] = usRegData ; - vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_SIZE ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); - eErrStatus = eMBMasterWaitRequestFinish( ); + vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterSetDestAddress(ucSndAddr); + ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_REGISTER; + ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF] = usRegAddr >> 8; + ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF + 1] = usRegAddr; + ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF] = usRegData >> 8; + ucMBFrame[MB_PDU_REQ_WRITE_VALUE_OFF + 1] = usRegData ; + vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_SIZE ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); + eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; } @@ -167,7 +167,7 @@ eMBMasterFuncWriteHoldingRegister( UCHAR * pucFrame, USHORT * usLen ) */ eMBMasterReqErrCode eMBMasterReqWriteMultipleHoldingRegister( UCHAR ucSndAddr, - USHORT usRegAddr, USHORT usNRegs, USHORT * pusDataBuffer, LONG lTimeOut ) + USHORT usRegAddr, USHORT usNRegs, USHORT * pusDataBuffer, LONG lTimeOut ) { UCHAR *ucMBFrame; USHORT usRegIndex = 0; @@ -177,23 +177,23 @@ eMBMasterReqWriteMultipleHoldingRegister( UCHAR ucSndAddr, else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { - vMBMasterGetPDUSndBuf(&ucMBFrame); - vMBMasterSetDestAddress(ucSndAddr); - ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_MULTIPLE_REGISTERS; - ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF] = usRegAddr >> 8; - ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF + 1] = usRegAddr; - ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF] = usNRegs >> 8; - ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF + 1] = usNRegs ; - ucMBFrame[MB_PDU_REQ_WRITE_MUL_BYTECNT_OFF] = usNRegs * 2; - ucMBFrame += MB_PDU_REQ_WRITE_MUL_VALUES_OFF; - while( usNRegs > usRegIndex) - { - *ucMBFrame++ = pusDataBuffer[usRegIndex] >> 8; - *ucMBFrame++ = pusDataBuffer[usRegIndex++] ; - } - vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_MUL_SIZE_MIN + 2*usNRegs ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); - eErrStatus = eMBMasterWaitRequestFinish( ); + vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterSetDestAddress(ucSndAddr); + ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_MULTIPLE_REGISTERS; + ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF] = usRegAddr >> 8; + ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF + 1] = usRegAddr; + ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF] = usNRegs >> 8; + ucMBFrame[MB_PDU_REQ_WRITE_MUL_REGCNT_OFF + 1] = usNRegs ; + ucMBFrame[MB_PDU_REQ_WRITE_MUL_BYTECNT_OFF] = usNRegs * 2; + ucMBFrame += MB_PDU_REQ_WRITE_MUL_VALUES_OFF; + while( usNRegs > usRegIndex) + { + *ucMBFrame++ = pusDataBuffer[usRegIndex] >> 8; + *ucMBFrame++ = pusDataBuffer[usRegIndex++] ; + } + vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_MUL_SIZE_MIN + 2*usNRegs ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); + eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; } @@ -212,7 +212,7 @@ eMBMasterFuncWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen ) /* If this request is broadcast, the *usLen is not need check. */ if( ( *usLen == MB_PDU_SIZE_MIN + MB_PDU_FUNC_WRITE_MUL_SIZE ) || xMBMasterRequestIsBroadcast() ) { - vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterGetPDUSndBuf(&ucMBFrame); usRegAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF] << 8 ); usRegAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF + 1] ); usRegAddress++; @@ -270,16 +270,16 @@ eMBMasterReqReadHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usNRe else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { - vMBMasterGetPDUSndBuf(&ucMBFrame); - vMBMasterSetDestAddress(ucSndAddr); - ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_HOLDING_REGISTER; - ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usRegAddr >> 8; - ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usRegAddr; - ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF] = usNRegs >> 8; - ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF + 1] = usNRegs; - vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); - eErrStatus = eMBMasterWaitRequestFinish( ); + vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterSetDestAddress(ucSndAddr); + ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_HOLDING_REGISTER; + ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usRegAddr >> 8; + ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usRegAddr; + ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF] = usNRegs >> 8; + ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF + 1] = usNRegs; + vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); + eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; } @@ -297,11 +297,11 @@ eMBMasterFuncReadHoldingRegister( UCHAR * pucFrame, USHORT * usLen ) /* If this request is broadcast, and it's read mode. This request don't need execute. */ if ( xMBMasterRequestIsBroadcast() ) { - eStatus = MB_EX_NONE; + eStatus = MB_EX_NONE; } else if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READ_SIZE_MIN ) { - vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterGetPDUSndBuf(&ucMBFrame); usRegAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] << 8 ); usRegAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] ); usRegAddress++; @@ -354,8 +354,8 @@ eMBMasterFuncReadHoldingRegister( UCHAR * pucFrame, USHORT * usLen ) */ eMBMasterReqErrCode eMBMasterReqReadWriteMultipleHoldingRegister( UCHAR ucSndAddr, - USHORT usReadRegAddr, USHORT usNReadRegs, USHORT * pusDataBuffer, - USHORT usWriteRegAddr, USHORT usNWriteRegs, LONG lTimeOut ) + USHORT usReadRegAddr, USHORT usNReadRegs, USHORT * pusDataBuffer, + USHORT usWriteRegAddr, USHORT usNWriteRegs, LONG lTimeOut ) { UCHAR *ucMBFrame; USHORT usRegIndex = 0; @@ -365,27 +365,27 @@ eMBMasterReqReadWriteMultipleHoldingRegister( UCHAR ucSndAddr, else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { - vMBMasterGetPDUSndBuf(&ucMBFrame); - vMBMasterSetDestAddress(ucSndAddr); - ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READWRITE_MULTIPLE_REGISTERS; - ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF] = usReadRegAddr >> 8; - ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF + 1] = usReadRegAddr; - ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF] = usNReadRegs >> 8; - ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF + 1] = usNReadRegs ; - ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF] = usWriteRegAddr >> 8; - ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF + 1] = usWriteRegAddr; - ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF] = usNWriteRegs >> 8; - ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF + 1] = usNWriteRegs ; - ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_BYTECNT_OFF] = usNWriteRegs * 2; - ucMBFrame += MB_PDU_REQ_READWRITE_WRITE_VALUES_OFF; - while( usNWriteRegs > usRegIndex) - { - *ucMBFrame++ = pusDataBuffer[usRegIndex] >> 8; - *ucMBFrame++ = pusDataBuffer[usRegIndex++] ; - } - vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READWRITE_SIZE_MIN + 2*usNWriteRegs ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); - eErrStatus = eMBMasterWaitRequestFinish( ); + vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterSetDestAddress(ucSndAddr); + ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READWRITE_MULTIPLE_REGISTERS; + ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF] = usReadRegAddr >> 8; + ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF + 1] = usReadRegAddr; + ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF] = usNReadRegs >> 8; + ucMBFrame[MB_PDU_REQ_READWRITE_READ_REGCNT_OFF + 1] = usNReadRegs ; + ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF] = usWriteRegAddr >> 8; + ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_ADDR_OFF + 1] = usWriteRegAddr; + ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF] = usNWriteRegs >> 8; + ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_REGCNT_OFF + 1] = usNWriteRegs ; + ucMBFrame[MB_PDU_REQ_READWRITE_WRITE_BYTECNT_OFF] = usNWriteRegs * 2; + ucMBFrame += MB_PDU_REQ_READWRITE_WRITE_VALUES_OFF; + while( usNWriteRegs > usRegIndex) + { + *ucMBFrame++ = pusDataBuffer[usRegIndex] >> 8; + *ucMBFrame++ = pusDataBuffer[usRegIndex++] ; + } + vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READWRITE_SIZE_MIN + 2*usNWriteRegs ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); + eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; } @@ -405,11 +405,11 @@ eMBMasterFuncReadWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen /* If this request is broadcast, and it's read mode. This request don't need execute. */ if ( xMBMasterRequestIsBroadcast() ) { - eStatus = MB_EX_NONE; + eStatus = MB_EX_NONE; } else if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READWRITE_SIZE_MIN ) { - vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterGetPDUSndBuf(&ucMBFrame); usRegReadAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF] << 8U ); usRegReadAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READWRITE_READ_ADDR_OFF + 1] ); usRegReadAddress++; @@ -433,8 +433,8 @@ eMBMasterFuncReadWriteMultipleHoldingRegister( UCHAR * pucFrame, USHORT * usLen if( eRegStatus == MB_ENOERR ) { /* Make the read callback. */ - eRegStatus = eMBMasterRegHoldingCB(&pucFrame[MB_PDU_FUNC_READWRITE_READ_VALUES_OFF], - usRegReadAddress, usRegReadCount, MB_REG_READ); + eRegStatus = eMBMasterRegHoldingCB(&pucFrame[MB_PDU_FUNC_READWRITE_READ_VALUES_OFF], + usRegReadAddress, usRegReadCount, MB_REG_READ); } if( eRegStatus != MB_ENOERR ) { diff --git a/components/freemodbus/modbus/functions/mbfuncinput_m.c b/components/freemodbus/modbus/functions/mbfuncinput_m.c index 6ae3ab11ea..9a6b5677b6 100644 --- a/components/freemodbus/modbus/functions/mbfuncinput_m.c +++ b/components/freemodbus/modbus/functions/mbfuncinput_m.c @@ -78,16 +78,16 @@ eMBMasterReqReadInputRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usNRegs else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { - vMBMasterGetPDUSndBuf(&ucMBFrame); - vMBMasterSetDestAddress(ucSndAddr); - ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_INPUT_REGISTER; - ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usRegAddr >> 8; - ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usRegAddr; - ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF] = usNRegs >> 8; - ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF + 1] = usNRegs; - vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); - ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); - eErrStatus = eMBMasterWaitRequestFinish( ); + vMBMasterGetPDUSndBuf(&ucMBFrame); + vMBMasterSetDestAddress(ucSndAddr); + ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_INPUT_REGISTER; + ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usRegAddr >> 8; + ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usRegAddr; + ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF] = usNRegs >> 8; + ucMBFrame[MB_PDU_REQ_READ_REGCNT_OFF + 1] = usNRegs; + vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE ); + ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_TRANSMIT ); + eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; } @@ -103,13 +103,13 @@ eMBMasterFuncReadInputRegister( UCHAR * pucFrame, USHORT * usLen ) eMBErrorCode eRegStatus; /* If this request is broadcast, and it's read mode. This request don't need execute. */ - if ( xMBMasterRequestIsBroadcast() ) - { - eStatus = MB_EX_NONE; - } - else if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READ_SIZE_MIN ) + if ( xMBMasterRequestIsBroadcast() ) { - vMBMasterGetPDUSndBuf(&ucMBFrame); + eStatus = MB_EX_NONE; + } + else if( *usLen >= MB_PDU_SIZE_MIN + MB_PDU_FUNC_READ_SIZE_MIN ) + { + vMBMasterGetPDUSndBuf(&ucMBFrame); usRegAddress = ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] << 8 ); usRegAddress |= ( USHORT )( ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] ); usRegAddress++; diff --git a/components/freemodbus/modbus/include/mbport.h b/components/freemodbus/modbus/include/mbport.h index 6be73ad834..ad06449600 100644 --- a/components/freemodbus/modbus/include/mbport.h +++ b/components/freemodbus/modbus/include/mbport.h @@ -47,14 +47,14 @@ typedef enum EV_FRAME_SENT = 0x08 /*!< Frame sent. */ } eMBEventType; -#if MB_MASTER_RTU_ENABLED > 0 || MB_MASTER_ASCII_ENABLED > 0 +#if MB_MASTER_RTU_ENABLED || MB_MASTER_ASCII_ENABLED typedef enum { EV_MASTER_NO_EVENT = 0x0000, EV_MASTER_READY = 0x0001, /*!< Startup finished. */ EV_MASTER_FRAME_RECEIVED = 0x0002, /*!< Frame received. */ EV_MASTER_EXECUTE = 0x0004, /*!< Execute function. */ EV_MASTER_FRAME_SENT = 0x0008, /*!< Frame sent. */ - EV_MASTER_FRAME_TRANSMITTED = 0x0010, /*!< Request execute function error. */ + EV_MASTER_FRAME_TRANSMIT = 0x0010, /*!< Frame transmission. */ EV_MASTER_ERROR_PROCESS = 0x0020, /*!< Frame error process. */ EV_MASTER_PROCESS_SUCCESS = 0x0040, /*!< Request process success. */ EV_MASTER_ERROR_RESPOND_TIMEOUT = 0x0080, /*!< Request respond timeout. */ @@ -63,9 +63,11 @@ typedef enum { } eMBMasterEventType; typedef enum { + EV_ERROR_INIT, /*!< No error, initial state. */ EV_ERROR_RESPOND_TIMEOUT, /*!< Slave respond timeout. */ - EV_ERROR_RECEIVE_DATA, /*!< Receive frame data erroe. */ + EV_ERROR_RECEIVE_DATA, /*!< Receive frame data error. */ EV_ERROR_EXECUTE_FUNCTION, /*!< Execute function error. */ + EV_ERROR_OK /*!< No error, processing completed. */ } eMBMasterErrorEventType; #endif @@ -156,7 +158,7 @@ void vMBMasterPortTimersConvertDelayEnable( void ); void vMBMasterPortTimersRespondTimeoutEnable( void ); void vMBMasterPortTimersDisable( void ); -#endif + /* ----------------- Callback for the master error process ------------------*/ void vMBMasterErrorCBRespondTimeout( UCHAR ucDestAddress, const UCHAR* pucPDUData, @@ -169,7 +171,7 @@ void vMBMasterErrorCBExecuteFunction( UCHAR ucDestAddress, const UCHA USHORT ucPDULength ); void vMBMasterCBRequestSuccess( void ); - +#endif /* ----------------------- Callback for the protocol stack ------------------*/ /*! * \brief Callback function for the porting layer when a new byte is @@ -206,8 +208,8 @@ void vMBTCPPortDisable( void ); BOOL xMBTCPPortGetRequest( UCHAR **ppucMBTCPFrame, USHORT * usTCPLength ); BOOL xMBTCPPortSendResponse( const UCHAR *pucMBTCPFrame, USHORT usTCPLength ); -#endif +#endif #ifdef __cplusplus PR_END_EXTERN_C #endif diff --git a/components/freemodbus/modbus/mb_m.c b/components/freemodbus/modbus/mb_m.c index 3f2a97e4cc..a668243b2c 100644 --- a/components/freemodbus/modbus/mb_m.c +++ b/components/freemodbus/modbus/mb_m.c @@ -257,13 +257,13 @@ eMBMasterDisable( void ) eMBErrorCode eMBMasterPoll( void ) { - static UCHAR *ucMBFrame; + static UCHAR *ucMBFrame = NULL; static UCHAR ucRcvAddress; static UCHAR ucFunctionCode; static USHORT usLength; static eMBException eException; - - int i , j; + int i; + int j; eMBErrorCode eStatus = MB_ENOERR; eMBMasterEventType eEvent; eMBMasterErrorEventType errorType; @@ -278,133 +278,141 @@ eMBMasterPoll( void ) * Otherwise we will handle the event. */ if( xMBMasterPortEventGet( &eEvent ) == TRUE ) { - switch ( eEvent ) - { - case EV_MASTER_NO_EVENT: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_NO_EVENT", __func__); - // Something went wrong and task unblocked but there are no any events set - assert(0); - break; - case EV_MASTER_PROCESS_SUCCESS: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_PROCESS_SUCCESS", __func__); - break; - case EV_MASTER_ERROR_RESPOND_TIMEOUT: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_ERROR_RESPOND_TIMEOUT", __func__); - break; - case EV_MASTER_ERROR_RECEIVE_DATA: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_ERROR_RECEIVE_DATA", __func__); - break; - case EV_MASTER_ERROR_EXECUTE_FUNCTION: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_ERROR_EXECUTE_FUNCTION", __func__); - break; - case EV_MASTER_READY: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_READY", __func__); - break; - case EV_MASTER_FRAME_RECEIVED: - eStatus = peMBMasterFrameReceiveCur( &ucRcvAddress, &ucMBFrame, &usLength ); - // Check if the frame is for us. If not ,send an error process event. - if ( ( eStatus == MB_ENOERR ) && ( ucRcvAddress == ucMBMasterGetDestAddress() ) ) - { - ESP_LOGD(MB_PORT_TAG, "%s: Packet data received successfully (%u).", __func__, eStatus); - ( void ) xMBMasterPortEventPost( EV_MASTER_EXECUTE ); - } - else - { - vMBMasterSetErrorType(EV_ERROR_RECEIVE_DATA); - ESP_LOGD(MB_PORT_TAG, "%s: Packet data receive failed (addr=%u)(%u).", __func__, ucRcvAddress, eStatus); - ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); - } - break; - case EV_MASTER_EXECUTE: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_EXECUTE", __func__); - ucFunctionCode = ucMBFrame[MB_PDU_FUNC_OFF]; - eException = MB_EX_ILLEGAL_FUNCTION; - /* If receive frame has exception. The receive function code highest bit is 1.*/ - if(ucFunctionCode >> 7) { - eException = (eMBException)ucMBFrame[MB_PDU_DATA_OFF]; - } - else - { - for (i = 0; i < MB_FUNC_HANDLERS_MAX; i++) + while( eEvent ) { + // In some cases it is possible that more than one event set + // together (even from one subset mask) than process them consistently + if ( MB_PORT_CHECK_EVENT( eEvent, EV_MASTER_READY ) ) { + ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_READY", __func__); + MB_PORT_CLEAR_EVENT( eEvent, EV_MASTER_READY ); + } else if ( MB_PORT_CHECK_EVENT( eEvent, EV_MASTER_FRAME_TRANSMIT ) ) { + ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_FRAME_TRANSMIT", __func__); + /* Master is busy now. */ + vMBMasterGetPDUSndBuf( &ucMBFrame ); + ESP_LOG_BUFFER_HEX_LEVEL("POLL transmit buffer", (void*)ucMBFrame, usMBMasterGetPDUSndLength(), ESP_LOG_DEBUG); + eStatus = peMBMasterFrameSendCur( ucMBMasterGetDestAddress(), ucMBFrame, usMBMasterGetPDUSndLength() ); + if (eStatus != MB_ENOERR) { - /* No more function handlers registered. Abort. */ - if (xMasterFuncHandlers[i].ucFunctionCode == 0) { - break; - } - else if (xMasterFuncHandlers[i].ucFunctionCode == ucFunctionCode) { - vMBMasterSetCBRunInMasterMode(TRUE); - /* If master request is broadcast, - * the master need execute function for all slave. - */ - if ( xMBMasterRequestIsBroadcast() ) { - usLength = usMBMasterGetPDUSndLength(); - for(j = 1; j <= MB_MASTER_TOTAL_SLAVE_NUM; j++){ - vMBMasterSetDestAddress(j); - eException = xMasterFuncHandlers[i].pxHandler(ucMBFrame, &usLength); + ESP_LOGE( MB_PORT_TAG, "%s:Frame send error. %d", __func__, eStatus ); + } + MB_PORT_CLEAR_EVENT( eEvent, EV_MASTER_FRAME_TRANSMIT ); + } else if ( MB_PORT_CHECK_EVENT( eEvent, EV_MASTER_FRAME_SENT ) ) { + ESP_LOGD( MB_PORT_TAG, "%s:EV_MASTER_FRAME_SENT", __func__ ); + ESP_LOG_BUFFER_HEX_LEVEL("POLL sent buffer", (void*)ucMBFrame, usMBMasterGetPDUSndLength(), ESP_LOG_DEBUG); + MB_PORT_CLEAR_EVENT( eEvent, EV_MASTER_FRAME_SENT ); + } else if ( MB_PORT_CHECK_EVENT( eEvent, EV_MASTER_FRAME_RECEIVED ) ) { + eStatus = peMBMasterFrameReceiveCur( &ucRcvAddress, &ucMBFrame, &usLength); + + // Check if the frame is for us. If not ,send an error process event. + if ( ( eStatus == MB_ENOERR ) && ( ucRcvAddress == ucMBMasterGetDestAddress() ) ) + { + ( void ) xMBMasterPortEventPost( EV_MASTER_EXECUTE ); + ESP_LOGD(MB_PORT_TAG, "%s: Packet data received successfully (%u).", __func__, eStatus); + ESP_LOG_BUFFER_HEX_LEVEL("POLL receive buffer", (void*)ucMBFrame, (uint16_t)usLength, ESP_LOG_DEBUG); + } + else + { + vMBMasterSetErrorType(EV_ERROR_RECEIVE_DATA); + ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); + ESP_LOGD( MB_PORT_TAG, "%s: Packet data receive failed (addr=%u)(%u).", + __func__, ucRcvAddress, eStatus); + } + MB_PORT_CLEAR_EVENT( eEvent, EV_MASTER_FRAME_RECEIVED ); + } else if ( MB_PORT_CHECK_EVENT( eEvent, EV_MASTER_EXECUTE ) ) { + if ( !ucMBFrame ) + { + return MB_EILLSTATE; + } + ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_EXECUTE", __func__); + ucFunctionCode = ucMBFrame[MB_PDU_FUNC_OFF]; + eException = MB_EX_ILLEGAL_FUNCTION; + /* If receive frame has exception. The receive function code highest bit is 1.*/ + if (ucFunctionCode & MB_FUNC_ERROR) + { + eException = (eMBException)ucMBFrame[MB_PDU_DATA_OFF]; + } else { + for ( i = 0; i < MB_FUNC_HANDLERS_MAX; i++ ) + { + /* No more function handlers registered. Abort. */ + if (xMasterFuncHandlers[i].ucFunctionCode == 0) + { + break; + } + if (xMasterFuncHandlers[i].ucFunctionCode == ucFunctionCode) + { + vMBMasterSetCBRunInMasterMode(TRUE); + /* If master request is broadcast, + * the master need execute function for all slave. + */ + if ( xMBMasterRequestIsBroadcast() ) + { + usLength = usMBMasterGetPDUSndLength(); + for(j = 1; j <= MB_MASTER_TOTAL_SLAVE_NUM; j++) + { + vMBMasterSetDestAddress(j); + eException = xMasterFuncHandlers[i].pxHandler(ucMBFrame, &usLength); + } } + else + { + eException = xMasterFuncHandlers[i].pxHandler( ucMBFrame, &usLength ); + } + vMBMasterSetCBRunInMasterMode( FALSE ); + break; } - else { - eException = xMasterFuncHandlers[i].pxHandler(ucMBFrame, &usLength); - } - vMBMasterSetCBRunInMasterMode(FALSE); - break; } } - } - /* If master has exception ,Master will send error process.Otherwise the Master is idle.*/ - if (eException != MB_EX_NONE) { - vMBMasterSetErrorType(EV_ERROR_EXECUTE_FUNCTION); - ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); - } - else { - vMBMasterCBRequestSuccess( ); + /* If master has exception, will send error process event. Otherwise the master is idle.*/ + if ( eException != MB_EX_NONE ) + { + vMBMasterSetErrorType( EV_ERROR_EXECUTE_FUNCTION ); + ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); + } + else + { + if ( eMBMasterGetErrorType( ) == EV_ERROR_INIT ) { + vMBMasterSetErrorType(EV_ERROR_OK); + ESP_LOGD( MB_PORT_TAG, "%s: set event EV_ERROR_OK", __func__ ); + ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); + } + } + MB_PORT_CLEAR_EVENT( eEvent, EV_MASTER_EXECUTE ); + } else if ( MB_PORT_CHECK_EVENT( eEvent, EV_MASTER_ERROR_PROCESS ) ) { + ESP_LOGD( MB_PORT_TAG, "%s:EV_MASTER_ERROR_PROCESS", __func__ ); + /* Execute specified error process callback function. */ + errorType = eMBMasterGetErrorType( ); + vMBMasterGetPDUSndBuf( &ucMBFrame ); + switch ( errorType ) + { + case EV_ERROR_RESPOND_TIMEOUT: + vMBMasterErrorCBRespondTimeout( ucMBMasterGetDestAddress( ), + ucMBFrame, usMBMasterGetPDUSndLength( ) ); + break; + case EV_ERROR_RECEIVE_DATA: + vMBMasterErrorCBReceiveData( ucMBMasterGetDestAddress( ), + ucMBFrame, usMBMasterGetPDUSndLength( ) ); + break; + case EV_ERROR_EXECUTE_FUNCTION: + vMBMasterErrorCBExecuteFunction( ucMBMasterGetDestAddress( ), + ucMBFrame, usMBMasterGetPDUSndLength( ) ); + break; + case EV_ERROR_OK: + vMBMasterCBRequestSuccess( ); + break; + default: + ESP_LOGE( MB_PORT_TAG, "%s: incorrect error type = %d.", __func__, errorType); + break; + } + vMBMasterSetErrorType( EV_ERROR_INIT ); + MB_PORT_CLEAR_EVENT( eEvent, EV_MASTER_ERROR_PROCESS ); vMBMasterRunResRelease( ); } - break; - case EV_MASTER_FRAME_SENT: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_FRAME_SENT", __func__); - /* Master is busy now. */ - vMBMasterGetPDUSndBuf( &ucMBFrame ); - eStatus = peMBMasterFrameSendCur( ucMBMasterGetDestAddress(), ucMBFrame, usMBMasterGetPDUSndLength() ); - if (eStatus != MB_ENOERR) - { - ESP_LOGD(MB_PORT_TAG, "%s:Frame send error. %d", __func__, eStatus); - } - - break; - case EV_MASTER_FRAME_TRANSMITTED: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_FRAME_TRANSMITTED", __func__); - break; - case EV_MASTER_ERROR_PROCESS: - ESP_LOGD(MB_PORT_TAG, "%s:EV_MASTER_ERROR_PROCESS", __func__); - /* Execute specified error process callback function. */ - errorType = eMBMasterGetErrorType(); - vMBMasterGetPDUSndBuf( &ucMBFrame ); - switch (errorType) { - case EV_ERROR_RESPOND_TIMEOUT: - vMBMasterErrorCBRespondTimeout(ucMBMasterGetDestAddress(), - ucMBFrame, usMBMasterGetPDUSndLength()); - break; - case EV_ERROR_RECEIVE_DATA: - vMBMasterErrorCBReceiveData(ucMBMasterGetDestAddress(), - ucMBFrame, usMBMasterGetPDUSndLength()); - break; - case EV_ERROR_EXECUTE_FUNCTION: - vMBMasterErrorCBExecuteFunction(ucMBMasterGetDestAddress(), - ucMBFrame, usMBMasterGetPDUSndLength()); - break; - default: - ESP_LOGD(MB_PORT_TAG, "%s: incorrect error type.", __func__); - break; - } - vMBMasterRunResRelease(); - break; } } else { - // xMBMasterPortEventGet has unbloked the task but the event bits are not set - ESP_LOGD(MB_PORT_TAG, "%s: task event wait failure.", __func__); + // Something went wrong and task unblocked but there are no any correct events set + ESP_LOGE( MB_PORT_TAG, "%s: Unexpected event triggered 0x%02x.", __func__, eEvent ); + eStatus = MB_EILLSTATE; } - return MB_ENOERR; + return eStatus; } // Get whether the Modbus Master is run in master mode. diff --git a/components/freemodbus/modbus/rtu/mbrtu.c b/components/freemodbus/modbus/rtu/mbrtu.c index 0a3bb87ad4..6287ae9d9b 100644 --- a/components/freemodbus/modbus/rtu/mbrtu.c +++ b/components/freemodbus/modbus/rtu/mbrtu.c @@ -342,8 +342,7 @@ xMBRTUTimerT35Expired( void ) /* Function called in an illegal state. */ default: - assert( ( eRcvState == STATE_RX_INIT ) || - ( eRcvState == STATE_RX_RCV ) || ( eRcvState == STATE_RX_ERROR ) ); + assert( ( eRcvState == STATE_RX_IDLE ) || ( eRcvState == STATE_RX_ERROR ) ); } vMBPortTimersDisable( ); diff --git a/components/freemodbus/modbus/rtu/mbrtu_m.c b/components/freemodbus/modbus/rtu/mbrtu_m.c index 3d80e6e8f7..315e5c69fb 100644 --- a/components/freemodbus/modbus/rtu/mbrtu_m.c +++ b/components/freemodbus/modbus/rtu/mbrtu_m.c @@ -264,11 +264,11 @@ xMBMasterRTUReceiveFSM( void ) * the timer of respond timeout . */ case STATE_M_RX_IDLE: - /* In time of respond timeout,the receiver receive a frame. - * Disable timer of respond timeout and change the transmiter state to idle. - */ - vMBMasterPortTimersDisable( ); - eSndState = STATE_M_TX_IDLE; + /* In time of respond timeout,the receiver receive a frame. + * Disable timer of respond timeout and change the transmiter state to idle. + */ + vMBMasterPortTimersDisable( ); + eSndState = STATE_M_TX_IDLE; usMasterRcvBufferPos = 0; ucMasterRTURcvBuf[usMasterRcvBufferPos++] = ucByte; @@ -336,11 +336,11 @@ xMBMasterRTUTransmitFSM( void ) * else master will enable timer of respond timeout. */ if ( xFrameIsBroadcast == TRUE ) { - vMBMasterPortTimersConvertDelayEnable( ); + vMBMasterPortTimersConvertDelayEnable( ); } else { - vMBMasterPortTimersRespondTimeoutEnable( ); + vMBMasterPortTimersRespondTimeoutEnable( ); } xNeedPoll = TRUE; } @@ -353,96 +353,95 @@ xMBMasterRTUTransmitFSM( void ) BOOL xMBMasterRTUTimerExpired(void) { - BOOL xNeedPoll = FALSE; + BOOL xNeedPoll = FALSE; - switch (eRcvState) - { - /* Timer t35 expired. Startup phase is finished. */ - case STATE_M_RX_INIT: - xNeedPoll = xMBMasterPortEventPost(EV_MASTER_READY); - break; + switch (eRcvState) + { + /* Timer t35 expired. Startup phase is finished. */ + case STATE_M_RX_INIT: + xNeedPoll = xMBMasterPortEventPost(EV_MASTER_READY); + break; - /* A frame was received and t35 expired. Notify the listener that - * a new frame was received. */ - case STATE_M_RX_RCV: - xNeedPoll = xMBMasterPortEventPost(EV_MASTER_FRAME_RECEIVED); - break; + /* A frame was received and t35 expired. Notify the listener that + * a new frame was received. */ + case STATE_M_RX_RCV: + xNeedPoll = xMBMasterPortEventPost(EV_MASTER_FRAME_RECEIVED); + break; - /* An error occured while receiving the frame. */ - case STATE_M_RX_ERROR: - vMBMasterSetErrorType(EV_ERROR_RECEIVE_DATA); - xNeedPoll = xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); - break; + /* An error occured while receiving the frame. */ + case STATE_M_RX_ERROR: + vMBMasterSetErrorType(EV_ERROR_RECEIVE_DATA); + xNeedPoll = xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); + break; - /* Function called in an illegal state. */ - default: - assert((eRcvState == STATE_M_RX_INIT) || (eRcvState == STATE_M_RX_RCV) - || (eRcvState == STATE_M_RX_ERROR) || (eRcvState == STATE_M_RX_IDLE)); - break; - } - eRcvState = STATE_M_RX_IDLE; + /* Function called in an illegal state. */ + default: + assert((eRcvState == STATE_M_RX_INIT) || (eRcvState == STATE_M_RX_RCV) + || (eRcvState == STATE_M_RX_ERROR) || (eRcvState == STATE_M_RX_IDLE)); + break; + } + eRcvState = STATE_M_RX_IDLE; - switch (eSndState) - { - /* A frame was send finish and convert delay or respond timeout expired. - * If the frame is broadcast,The master will idle,and if the frame is not - * broadcast.Notify the listener process error.*/ - case STATE_M_TX_XFWR: - if ( xFrameIsBroadcast == FALSE ) { - vMBMasterSetErrorType(EV_ERROR_RESPOND_TIMEOUT); - xNeedPoll = xMBMasterPortEventPost(EV_MASTER_ERROR_PROCESS); - } - break; - /* Function called in an illegal state. */ - default: - assert( - ( eSndState == STATE_M_TX_XFWR ) || ( eSndState == STATE_M_TX_IDLE )); - break; - } - eSndState = STATE_M_TX_IDLE; + switch (eSndState) + { + /* A frame was send finish and convert delay or respond timeout expired. + * If the frame is broadcast,The master will idle,and if the frame is not + * broadcast.Notify the listener process error.*/ + case STATE_M_TX_XFWR: + if ( xFrameIsBroadcast == FALSE ) { + vMBMasterSetErrorType(EV_ERROR_RESPOND_TIMEOUT); + xNeedPoll = xMBMasterPortEventPost(EV_MASTER_ERROR_PROCESS); + } + break; + /* Function called in an illegal state. */ + default: + assert( ( eSndState == STATE_M_TX_XMIT ) || ( eSndState == STATE_M_TX_IDLE )); + break; + } + eSndState = STATE_M_TX_IDLE; - vMBMasterPortTimersDisable( ); - /* If timer mode is convert delay, the master event then turns EV_MASTER_EXECUTE status. */ - if (eMasterCurTimerMode == MB_TMODE_CONVERT_DELAY) { - xNeedPoll = xMBMasterPortEventPost( EV_MASTER_EXECUTE ); - } + vMBMasterPortTimersDisable( ); + /* If timer mode is convert delay, the master event then turns EV_MASTER_EXECUTE status. */ + if (eMasterCurTimerMode == MB_TMODE_CONVERT_DELAY) { + xNeedPoll = xMBMasterPortEventPost( EV_MASTER_EXECUTE ); + } - return xNeedPoll; + return xNeedPoll; } /* Get Modbus Master send RTU's buffer address pointer.*/ void vMBMasterGetRTUSndBuf( UCHAR ** pucFrame ) { - *pucFrame = ( UCHAR * ) ucMasterRTUSndBuf; + *pucFrame = ( UCHAR * ) ucMasterRTUSndBuf; } /* Get Modbus Master send PDU's buffer address pointer.*/ void vMBMasterGetPDUSndBuf( UCHAR ** pucFrame ) { - *pucFrame = ( UCHAR * ) &ucMasterRTUSndBuf[MB_SER_PDU_PDU_OFF]; + *pucFrame = ( UCHAR * ) &ucMasterRTUSndBuf[MB_SER_PDU_PDU_OFF]; } /* Set Modbus Master send PDU's buffer length.*/ void vMBMasterSetPDUSndLength( USHORT SendPDULength ) { - usMasterSendPDULength = SendPDULength; + usMasterSendPDULength = SendPDULength; } /* Get Modbus Master send PDU's buffer length.*/ USHORT usMBMasterGetPDUSndLength( void ) { - return usMasterSendPDULength; + return usMasterSendPDULength; } /* Set Modbus Master current timer mode.*/ void vMBMasterSetCurTimerMode( eMBMasterTimerMode eMBTimerMode ) { - eMasterCurTimerMode = eMBTimerMode; + eMasterCurTimerMode = eMBTimerMode; } /* The master request is broadcast? */ BOOL xMBMasterRequestIsBroadcast( void ){ - return xFrameIsBroadcast; + return xFrameIsBroadcast; } #endif diff --git a/components/freemodbus/port/port.h b/components/freemodbus/port/port.h index d90e29f6c9..f0070f1d2c 100644 --- a/components/freemodbus/port/port.h +++ b/components/freemodbus/port/port.h @@ -31,7 +31,7 @@ #define MB_PORT_CHECK(a, ret_val, str, ...) \ if (!(a)) { \ ESP_LOGE(MB_PORT_TAG, "%s(%u): " str, __FUNCTION__, __LINE__, ##__VA_ARGS__); \ - return (ret_val); \ + return ret_val; \ } #ifdef __cplusplus @@ -68,6 +68,9 @@ void vMBPortExitCritical( ); #define MB_PORT_PARITY_GET(parity) ((parity != UART_PARITY_DISABLE) ? \ ((parity == UART_PARITY_ODD) ? MB_PAR_ODD : MB_PAR_EVEN) : MB_PAR_NONE) +#define MB_PORT_CHECK_EVENT( event, mask ) ( event & mask ) +#define MB_PORT_CLEAR_EVENT( event, mask ) do { event &= ~mask; } while(0) + #ifdef __cplusplus PR_END_EXTERN_C #endif /* __cplusplus */ diff --git a/components/freemodbus/port/portevent_m.c b/components/freemodbus/port/portevent_m.c index 21fdf77bea..33814ebe72 100644 --- a/components/freemodbus/port/portevent_m.c +++ b/components/freemodbus/port/portevent_m.c @@ -53,7 +53,7 @@ EV_MASTER_FRAME_RECEIVED | \ EV_MASTER_EXECUTE | \ EV_MASTER_FRAME_SENT | \ - EV_MASTER_FRAME_TRANSMITTED | \ + EV_MASTER_FRAME_TRANSMIT | \ EV_MASTER_ERROR_PROCESS ) // Event bit mask for eMBMasterWaitRequestFinish() @@ -62,7 +62,6 @@ EV_MASTER_ERROR_RECEIVE_DATA | \ EV_MASTER_ERROR_EXECUTE_FUNCTION ) -#define MB_CHECK_EVENT(event, mask) (event & mask) /* ----------------------- Variables ----------------------------------------*/ static SemaphoreHandle_t xSemaphorMasterHdl; @@ -123,14 +122,15 @@ xMBMasterPortEventGet( eMBMasterEventType * eEvent) MB_EVENT_POLL_MASK, // The bits within the event group to wait for. pdTRUE, // Masked bits should be cleared before returning. pdFALSE, // Don't wait for both bits, either bit will do. - portMAX_DELAY); // Wait forever for either bit to be set. + portMAX_DELAY); // Wait forever for either bit to be set. // Check if poll event is correct - if (uxBits & MB_EVENT_POLL_MASK) { - *eEvent = (eMBMasterEventType)(uxBits); + if (MB_PORT_CHECK_EVENT(uxBits, MB_EVENT_POLL_MASK)) { + *eEvent = (eMBMasterEventType)(uxBits & MB_EVENT_POLL_MASK); xEventHappened = TRUE; } else { - ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event triggered.", __func__); + ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event triggered = %d.", __func__, uxBits); + *eEvent = (eMBMasterEventType)uxBits; xEventHappened = FALSE; } return xEventHappened; @@ -140,10 +140,7 @@ xMBMasterPortEventGet( eMBMasterEventType * eEvent) void vMBMasterOsResInit( void ) { xSemaphorMasterHdl = xSemaphoreCreateBinary(); - if (xSemaphorMasterHdl == NULL) - { - ESP_LOGE(MB_PORT_TAG,"%s: OS semaphore create error.", __func__); - } + MB_PORT_CHECK((xSemaphorMasterHdl != NULL), ; , "%s: OS semaphore create error.", __func__); } /** @@ -156,15 +153,13 @@ void vMBMasterOsResInit( void ) */ BOOL xMBMasterRunResTake( LONG lTimeOut ) { - BOOL xResult = FALSE; BaseType_t xStatus = pdTRUE; // If waiting time is -1. It will wait forever xStatus = xSemaphoreTake(xSemaphorMasterHdl, lTimeOut ); - if (xStatus == pdTRUE) { - xResult = TRUE; - } - return xResult; + MB_PORT_CHECK((xStatus == pdTRUE), FALSE , "%s:Take resource failure.", __func__); + ESP_LOGV(MB_PORT_TAG,"%s:Take resource (%lu ticks).", __func__, lTimeOut); + return TRUE; } /** @@ -173,11 +168,9 @@ BOOL xMBMasterRunResTake( LONG lTimeOut ) */ void vMBMasterRunResRelease( void ) { - BaseType_t xStatus = pdTRUE; + BaseType_t xStatus = pdFALSE; xStatus = xSemaphoreGive(xSemaphorMasterHdl); - if (xStatus != pdTRUE) { - ESP_LOGE(MB_PORT_TAG,"%s: resource release failure.", __func__); - } + MB_PORT_CHECK((xStatus == pdTRUE), ; , "%s: resource release failure.", __func__); } /** @@ -192,9 +185,7 @@ void vMBMasterRunResRelease( void ) void vMBMasterErrorCBRespondTimeout(UCHAR ucDestAddress, const UCHAR* pucPDUData, USHORT ucPDULength) { BOOL ret = xMBMasterPortEventPost(EV_MASTER_ERROR_RESPOND_TIMEOUT); - if(ret != TRUE) { - ESP_LOGE(MB_PORT_TAG, "Post event 'EV_MASTER_ERROR_RESPOND_TIMEOUT' failed!!!"); - } + MB_PORT_CHECK((ret == TRUE), ; , "%s: Post event 'EV_MASTER_ERROR_RESPOND_TIMEOUT' failed!", __func__); ESP_LOGD(MB_PORT_TAG,"%s:Callback respond timeout.", __func__); } @@ -209,10 +200,9 @@ void vMBMasterErrorCBRespondTimeout(UCHAR ucDestAddress, const UCHAR* pucPDUData void vMBMasterErrorCBReceiveData(UCHAR ucDestAddress, const UCHAR* pucPDUData, USHORT ucPDULength) { BOOL ret = xMBMasterPortEventPost(EV_MASTER_ERROR_RECEIVE_DATA); - if(ret != TRUE) { - ESP_LOGE(MB_PORT_TAG,"xMBMasterPortEventPost event 'EV_MASTER_ERROR_RECEIVE_DATA' failed!!!"); - } + MB_PORT_CHECK((ret == TRUE), ; , "%s: Post event 'EV_MASTER_ERROR_RECEIVE_DATA' failed!", __func__); ESP_LOGD(MB_PORT_TAG,"%s:Callback receive data timeout failure.", __func__); + ESP_LOG_BUFFER_HEX_LEVEL("Err rcv buf", (void*)pucPDUData, (uint16_t)ucPDULength, ESP_LOG_DEBUG); } /** @@ -228,9 +218,9 @@ void vMBMasterErrorCBReceiveData(UCHAR ucDestAddress, const UCHAR* pucPDUData, U void vMBMasterErrorCBExecuteFunction(UCHAR ucDestAddress, const UCHAR* pucPDUData, USHORT ucPDULength) { BOOL ret = xMBMasterPortEventPost(EV_MASTER_ERROR_EXECUTE_FUNCTION); - if(ret != TRUE) { - ESP_LOGE(MB_PORT_TAG,"xMBMasterPortEventPost event 'EV_MASTER_ERROR_EXECUTE_FUNCTION' failed!!!"); - } + MB_PORT_CHECK((ret == TRUE), ; , "%s: Post event 'EV_MASTER_ERROR_EXECUTE_FUNCTION' failed!", __func__); + ESP_LOGD(MB_PORT_TAG,"%s:Callback execute data handler failure.", __func__); + ESP_LOG_BUFFER_HEX_LEVEL("Exec func buf", (void*)pucPDUData, (uint16_t)ucPDULength, ESP_LOG_DEBUG); } /** @@ -244,9 +234,8 @@ void vMBMasterCBRequestSuccess( void ) { * If you don't use OS, you can change it. */ BOOL ret = xMBMasterPortEventPost(EV_MASTER_PROCESS_SUCCESS); - if (ret != TRUE) { - ESP_LOGE(MB_PORT_TAG,"xMBMasterPortEventPost event 'EV_MASTER_PROCESS_SUCCESS' failed!!!"); - } + MB_PORT_CHECK((ret == TRUE), ; , "%s: Post event 'EV_MASTER_PROCESS_SUCCESS' failed!", __func__); + ESP_LOGD(MB_PORT_TAG,"%s: Callback request success.", __func__); } /** @@ -271,20 +260,20 @@ eMBMasterReqErrCode eMBMasterWaitRequestFinish( void ) { if (xRecvedEvent) { ESP_LOGD(MB_PORT_TAG,"%s: returned event = 0x%x", __func__, xRecvedEvent); if (!(xRecvedEvent & MB_EVENT_REQ_MASK)) { - // if we wait for certain event bits but get other then set in mask + // if we wait for certain event bits but get from poll subset ESP_LOGE(MB_PORT_TAG,"%s: incorrect event set = 0x%x", __func__, xRecvedEvent); } - if MB_CHECK_EVENT(xRecvedEvent, EV_MASTER_PROCESS_SUCCESS) { + if (MB_PORT_CHECK_EVENT(xRecvedEvent, EV_MASTER_PROCESS_SUCCESS)) { eErrStatus = MB_MRE_NO_ERR; - } else if MB_CHECK_EVENT(xRecvedEvent, EV_MASTER_ERROR_RESPOND_TIMEOUT){ + } else if (MB_PORT_CHECK_EVENT(xRecvedEvent, EV_MASTER_ERROR_RESPOND_TIMEOUT)) { eErrStatus = MB_MRE_TIMEDOUT; - } else if MB_CHECK_EVENT(xRecvedEvent, EV_MASTER_ERROR_RECEIVE_DATA){ + } else if (MB_PORT_CHECK_EVENT(xRecvedEvent, EV_MASTER_ERROR_RECEIVE_DATA)) { eErrStatus = MB_MRE_REV_DATA; - } else if MB_CHECK_EVENT(xRecvedEvent, EV_MASTER_ERROR_EXECUTE_FUNCTION){ + } else if (MB_PORT_CHECK_EVENT(xRecvedEvent, EV_MASTER_ERROR_EXECUTE_FUNCTION)) { eErrStatus = MB_MRE_EXE_FUN; } } else { - ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event or timeout xRecvedEvent = 0x%x", __func__, xRecvedEvent); + ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event or timeout xRecvedEvent = 0x%x", __func__, uxBits); assert(0); } return eErrStatus; diff --git a/components/freemodbus/serial_master/modbus_controller/mbc_serial_master.c b/components/freemodbus/serial_master/modbus_controller/mbc_serial_master.c index c2fb9493be..1cd9bdcd20 100644 --- a/components/freemodbus/serial_master/modbus_controller/mbc_serial_master.c +++ b/components/freemodbus/serial_master/modbus_controller/mbc_serial_master.c @@ -64,7 +64,7 @@ static void modbus_master_task(void *pvParameters) BOOL xSentState = xMBMasterPortSerialTxPoll(); if (xSentState) { // Let state machine know that response was transmitted out - (void)xMBMasterPortEventPost(EV_MASTER_FRAME_TRANSMITTED); + (void)xMBMasterPortEventPost(EV_MASTER_FRAME_SENT); } } } @@ -279,7 +279,13 @@ static esp_err_t mbc_serial_master_send_request(mb_param_request_t* request, voi case MB_MRE_REV_DATA: error = ESP_ERR_INVALID_RESPONSE; break; + + case MB_MRE_MASTER_BUSY: + error = ESP_ERR_INVALID_STATE; // Master is busy (previous request is pending) + break; + default: + ESP_LOGE(MB_MASTER_TAG, "%s: Incorrect return code (%x) ", __FUNCTION__, mb_error); error = ESP_FAIL; break; }