/** * This is modbus master execute function error process callback function. * @note There functions will block modbus master poll while execute OS waiting. * So,for real-time of system.Do not execute too much waiting process. * * @param ucDestAddress destination salve address * @param pucPDUData PDU buffer data * @param ucPDULength PDU buffer length * */ void vMBMasterErrorCBExecuteFunction(UCHAR ucDestAddress, const UCHAR* pucPDUData, USHORT ucPDULength) { /** * @note This code is use OS's event mechanism for modbus master protocol stack. * If you don't use OS, you can change it. */ //rt_event_send(&xMasterOsEvent, EV_MASTER_ERROR_EXECUTE_FUNCTION); /* You can add your code under here. */ xMBMasterPortEventPost(EV_MASTER_ERROR_EXECUTE_FUNCTION); }
/** * This is modbus master respond timeout error process callback function. * @note There functions will block modbus master poll while execute OS waiting. * So,for real-time of system.Do not execute too much waiting process. * * @param ucDestAddress destination slave address * @param pucPDUData PDU buffer data * @param ucPDULength PDU buffer length * */ void vMBMasterErrorCBRespondTimeout(UCHAR ucDestAddress, const UCHAR* pucPDUData, USHORT ucPDULength) { /** * @note This code is use OS's event mechanism for modbus master protocol stack. * If you don't use OS, you can change it. */ //rt_event_send(&xMasterOsEvent, EV_MASTER_ERROR_RESPOND_TIMEOUT); /* You can add your code under here. */ xMBMasterPortEventPost(EV_MASTER_ERROR_RESPOND_TIMEOUT); }
eMBMasterReqErrCode eMBMasterReqReadWriteMultipleHoldingRegister(uint8_t ucSndAddr, uint16_t usReadRegAddr, uint16_t usNReadRegs, uint16_t *pusDataBuffer, uint16_t usWriteRegAddr, uint16_t usNWriteRegs, uint32_t lTimeOut) { uint8_t *ucMBFrame; uint16_t usRegIndex = 0; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if (ucSndAddr > CONFIG_MB_MASTER_TOTAL_SLAVE_NUM) { eErrStatus = MB_MRE_ILL_ARG; } 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(); } return eErrStatus; }
/** * This function will request write multiple coils. * * @param ucSndAddr salve address * @param usCoilAddr coil start address * @param usNCoils coil total number * @param usCoilData data to be written * @param lTimeOut timeout (-1 will waiting forever) * * @return error code * * @see eMBMasterReqWriteCoil */ eMBMasterReqErrCode eMBMasterReqWriteMultipleCoils( UCHAR ucSndAddr, USHORT usCoilAddr, USHORT usNCoils, UCHAR * pucDataBuffer, LONG lTimeOut) { UCHAR *ucMBFrame; USHORT usRegIndex = 0; UCHAR ucByteCount; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if ( ucSndAddr > MB_MASTER_TOTAL_SLAVE_NUM ) eErrStatus = MB_MRE_ILL_ARG; else if ( usNCoils > MB_PDU_REQ_WRITE_MUL_COILCNT_MAX ) eErrStatus = MB_MRE_ILL_ARG; // else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { vMBMasterGetPDUSndBuf(&ucMBFrame); vMBMasterSetDestAddress(ucSndAddr); ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_MULTIPLE_COILS; ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF] = usCoilAddr >> 8; ucMBFrame[MB_PDU_REQ_WRITE_MUL_ADDR_OFF + 1] = usCoilAddr; ucMBFrame[MB_PDU_REQ_WRITE_MUL_COILCNT_OFF] = usNCoils >> 8; ucMBFrame[MB_PDU_REQ_WRITE_MUL_COILCNT_OFF + 1] = usNCoils ; if( ( usNCoils & 0x0007 ) != 0 ) { ucByteCount = ( UCHAR )( usNCoils / 8 + 1 ); } else { ucByteCount = ( UCHAR )( usNCoils / 8 ); } ucMBFrame[MB_PDU_REQ_WRITE_MUL_BYTECNT_OFF] = ucByteCount; ucMBFrame += MB_PDU_REQ_WRITE_MUL_VALUES_OFF; while( ucByteCount > usRegIndex) { *ucMBFrame++ = pucDataBuffer[usRegIndex++]; } vMBMasterSetPDUSndLength( MB_PDU_SIZE_MIN + MB_PDU_REQ_WRITE_MUL_SIZE_MIN + ucByteCount ); ( void ) xMBMasterPortEventPost( EV_MASTER_FRAME_SENT ); eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; }
/** * This function will request write holding register. * * @param ucSndAddr salve address * @param usRegAddr register start address * @param usRegData register data to be written * @param lTimeOut timeout (-1 will waiting forever) * * @return error code */ eMBMasterReqErrCode eMBMasterReqWriteHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usRegData, LONG lTimeOut ) { UCHAR *ucMBFrame; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else if ( ucSndAddr > MB_MASTER_TOTAL_SLAVE_NUM ) eErrStatus = MB_MRE_ILL_ARG; 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 ); } return eErrStatus; }
eMBMasterReqErrCode eMBMasterReqReadHoldingRegister( UCHAR ucSndAddr, USHORT usRegAddr, USHORT usNRegs ) { UCHAR *ucMBFrame; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if ( xMBMasterGetIsBusy() ) eErrStatus = MB_MRE_MASTER_BUSY; else if ( ucSndAddr > MB_MASTER_TOTAL_SLAVE_NUM ) eErrStatus = MB_MRE_ILL_ARG; 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 ); } return eErrStatus; }
/** * This function will request read and write holding register. * * @param ucSndAddr salve address * @param usReadRegAddr read register start address * @param usNReadRegs read register total number * @param pusDataBuffer data to be written * @param usWriteRegAddr write register start address * @param usNWriteRegs write register total number * @param lTimeOut timeout (-1 will waiting forever) * * @return error code */ eMBMasterReqErrCode eMBMasterReqReadWriteMultipleHoldingRegister( UCHAR ucSndAddr, USHORT usReadRegAddr, USHORT usNReadRegs, USHORT * pusDataBuffer, USHORT usWriteRegAddr, USHORT usNWriteRegs, LONG lTimeOut ) { UCHAR *ucMBFrame; USHORT usRegIndex = 0; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else if ( ucSndAddr > MB_MASTER_TOTAL_SLAVE_NUM ) eErrStatus = MB_MRE_ILL_ARG; 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 ); } return eErrStatus; }
eMBMasterReqErrCode eMBMasterReqWriteCoil(uint8_t ucSndAddr, uint16_t usCoilAddr, uint16_t usCoilData, uint32_t lTimeOut) { uint8_t *ucMBFrame; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if (ucSndAddr > CONFIG_MB_MASTER_TOTAL_SLAVE_NUM) { eErrStatus = MB_MRE_ILL_ARG; } else if ((usCoilData != 0xFF00) && (usCoilData != 0x0000)) { eErrStatus = MB_MRE_ILL_ARG; } else if (xMBMasterRunResTake(lTimeOut) == false) { eErrStatus = MB_MRE_MASTER_BUSY; } else { vMBMasterGetPDUSndBuf(&ucMBFrame); vMBMasterSetDestAddress(ucSndAddr); ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_WRITE_SINGLE_COIL; ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF] = usCoilAddr >> 8; ucMBFrame[MB_PDU_REQ_WRITE_ADDR_OFF + 1] = usCoilAddr; 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); eErrStatus = eMBMasterWaitRequestFinish(); } return eErrStatus; }
/** * This function will request read coil. * * @param ucSndAddr salve address * @param usCoilAddr coil start address * @param usNCoils coil total number * @param lTimeOut timeout (-1 will waiting forever) * * @return error code */ eMBMasterReqErrCode eMBMasterReqReadCoils( UCHAR ucSndAddr, USHORT usCoilAddr, USHORT usNCoils ,LONG lTimeOut ) { UCHAR *ucMBFrame; eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR; if ( ucSndAddr > MB_MASTER_TOTAL_SLAVE_NUM ) eErrStatus = MB_MRE_ILL_ARG; //else if ( xMBMasterRunResTake( lTimeOut ) == FALSE ) eErrStatus = MB_MRE_MASTER_BUSY; else { vMBMasterGetPDUSndBuf(&ucMBFrame); vMBMasterSetDestAddress(ucSndAddr); ucMBFrame[MB_PDU_FUNC_OFF] = MB_FUNC_READ_COILS; ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF] = usCoilAddr >> 8; ucMBFrame[MB_PDU_REQ_READ_ADDR_OFF + 1] = usCoilAddr; 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 ); eErrStatus = eMBMasterWaitRequestFinish( ); } return eErrStatus; }
eMBErrorCode eMBMasterPoll( void ) { static UCHAR *ucMBFrame; static UCHAR ucRcvAddress; static UCHAR ucFunctionCode; static USHORT usLength; static eMBException eException; // int i; eMBErrorCode eStatus = MB_ENOERR; eMBMasterEventType eEvent; /* Check if the protocol stack is ready. */ if( eMBState != STATE_ENABLED ) { return MB_EILLSTATE; } /* Check if there is a event available. If not return control to caller. * Otherwise we will handle the event. */ if( xMBMasterPortEventGet( &eEvent ) == TRUE ) { switch ( eEvent ) { case EV_MASTER_READY: break; case EV_MASTER_FRAME_RECEIVED: eStatus = peMBMasterFrameReceiveCur( &ucRcvAddress, &ucMBFrame, &usLength ); if ( eStatus == MB_ENOERR ) { ( void ) xMBMasterPortEventPost( EV_MASTER_EXECUTE ); } else { ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); } #if 0 /* 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 ); } else { ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); } #endif break; case EV_MASTER_EXECUTE: //接受到了一帧RTU 数据 //Mb2TcpBuff[256]; if(usLength<256) { Mb2TcpLenth=usLength;//更新接受到的数据长度,准备启动TCP发送 Mb2TcpBuff[0]=0xFF; Mb2TcpBuff[1]=0x55; Mb2TcpBuff[2]=Statues_MB; Mb2TcpBuff[3]=UID_STM32[0]; Mb2TcpBuff[4]=UID_STM32[1]; Mb2TcpBuff[5]=UID_STM32[2]; memcpy(&Mb2TcpBuff[6],ucMBFrame,Mb2TcpLenth);//数据复制进TCP发送buf中 Mb2TcpBuff[Mb2TcpLenth+6]=0x24; Mb2TcpBuff[Mb2TcpLenth+6+1]=0x0d; Mb2TcpBuff[Mb2TcpLenth+6+2]=0x0a; Mb2TcpLenth+=9; } eException = MB_EX_ILLEGAL_FUNCTION; #if 0 ucFunctionCode = ucMBFrame[MB_PDU_FUNC_OFF]; eException = MB_EX_ILLEGAL_FUNCTION; for( i = 0; i < MB_FUNC_HANDLERS_MAX; i++ ) { // No more function handlers registered. Abort. if( xMasterFuncHandlers[i].ucFunctionCode == 0 ) { break; } else if( xMasterFuncHandlers[i].ucFunctionCode == ucFunctionCode ) { vMBMasterSetCBRunInMasterMode(TRUE); eException = xMasterFuncHandlers[i].pxHandler( ucMBFrame, &usLength ); vMBMasterSetCBRunInMasterMode(FALSE); break; } } /* If receive frame has exception .The receive function code highest bit is 1.*/ if(ucFunctionCode >> 7) eException = (eMBException)ucMBFrame[MB_PDU_DATA_OFF]; /* If master has exception ,Master will send error process.Otherwise the Master is idle.*/ if (eException != MB_EX_NONE) ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); else vMBMasterSetIsBusy( FALSE ); #endif break; case EV_MASTER_FRAME_SENT: /* Master is busy now. */ vMBMasterSetIsBusy( TRUE ); vMBMasterGetPDUSndBuf( &ucMBFrame ); eStatus = peMBMasterFrameSendCur( ucMBMasterGetDestAddress(), ucMBFrame, ucMBMasterGetPDUSndLength() ); break; case EV_MASTER_ERROR_PROCESS: vMBMasterSetIsBusy( FALSE ); break; } } return MB_ENOERR; }
eMBErrorCode eMBMasterPoll( void ) { static UCHAR *ucMBFrame; static UCHAR ucRcvAddress; static UCHAR ucFunctionCode; static USHORT usLength; static eMBException eException; int i , j; eMBErrorCode eStatus = MB_ENOERR; eMBMasterEventType eEvent; eMBMasterErrorEventType errorType; /* Check if the protocol stack is ready. */ if( eMBState != STATE_ENABLED ) { return MB_EILLSTATE; } /* Check if there is a event available. If not return control to caller. * Otherwise we will handle the event. */ if( xMBMasterPortEventGet( &eEvent ) == TRUE ) { switch ( eEvent ) { case EV_MASTER_READY: 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() ) ) { ( void ) xMBMasterPortEventPost( EV_MASTER_EXECUTE ); } else { vMBMasterSetErrorType(EV_ERROR_RECEIVE_DATA); ( void ) xMBMasterPortEventPost( EV_MASTER_ERROR_PROCESS ); } break; case EV_MASTER_EXECUTE: 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++) { /* 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); } } 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 { vMBMasterCBRequestScuuess( ucMBMasterGetDestAddress()); vMBMasterRunResRelease( ); } break; case EV_MASTER_FRAME_SENT: /* Master is busy now. */ vMBMasterGetPDUSndBuf( &ucMBFrame ); eStatus = peMBMasterFrameSendCur( ucMBMasterGetDestAddress(), ucMBFrame, usMBMasterGetPDUSndLength() ); break; case EV_MASTER_ERROR_PROCESS: /* 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; } vMBMasterRunResRelease(); break; } }