Index: firmware/App/Services/SystemComm.c =================================================================== diff -u -r31c4bf94671f58375d2e1dbbbb37b37c6949e0c4 -rc0273c73da6b6dee4ad6f1d54cb6c6f27a262b5b --- firmware/App/Services/SystemComm.c (.../SystemComm.c) (revision 31c4bf94671f58375d2e1dbbbb37b37c6949e0c4) +++ firmware/App/Services/SystemComm.c (.../SystemComm.c) (revision c0273c73da6b6dee4ad6f1d54cb6c6f27a262b5b) @@ -1,4 +1,4 @@ -/************************************************************************** +/**********************************************************************//** * * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. * @@ -32,33 +32,40 @@ #include "CPLD.h" #endif +/** + * @addtogroup SystemComm + * @{ + */ + // ********** private definitions ********** -#define NUM_OF_CAN_OUT_BUFFERS 5 // # of CAN buffers for transmit -#define NUM_OF_CAN_IN_BUFFERS 7 // # of CAN buffers for receiving -#ifdef DEBUG_ENABLED - #define NUM_OF_MSG_IN_BUFFERS 8 // # of Msg buffers for receiving - 1 is UART +#define NUM_OF_CAN_OUT_BUFFERS 5 ///< # of CAN buffers for transmit +#define NUM_OF_CAN_IN_BUFFERS 7 ///< # of CAN buffers for receiving +#ifndef DEBUG_ENABLED + #define NUM_OF_MSG_IN_BUFFERS 7 ///< # of Msg buffers for receiving #else - #define NUM_OF_MSG_IN_BUFFERS 7 // # of Msg buffers for receiving + #define NUM_OF_MSG_IN_BUFFERS 8 + #define SCI1_RECEIVE_DMA_REQUEST 30 + #define SCI1_TRANSMIT_DMA_REQUEST 31 #endif -#define SCI1_RECEIVE_DMA_REQUEST 30 -#define SCI1_TRANSMIT_DMA_REQUEST 31 #define CAN_XMIT_PACKET_TIMEOUT_MS 200 ///< if transmitted CAN frame does not cause a transmit complete interrupt within this time, re-send or move on +#define MAX_XMIT_RETRIES 5 ///< maximum number of retries on no transmit complete interrupt timeout -#define UI_COMM_TIMEOUT_IN_MS 5000 -#define DG_COMM_TIMEOUT_IN_MS 2000 +#define UI_COMM_TIMEOUT_IN_MS 5000 ///< UI has not checked in for this much time +#define DG_COMM_TIMEOUT_IN_MS 2000 ///< DG has not checked in for this much time -#define MAX_COMM_CRC_FAILURES 5 -#define MAX_COMM_CRC_FAILURE_WINDOW_MS (10 * SEC_PER_MIN * MS_PER_SECOND) +#define MAX_COMM_CRC_FAILURES 5 ///< maximum number of CRC errors within window period before alarm +#define MAX_COMM_CRC_FAILURE_WINDOW_MS (10 * SEC_PER_MIN * MS_PER_SECOND) ///< CRC error window -#define MSG_NOT_ACKED_TIMEOUT_MS 150 -#define MSG_NOT_ACKED_MAX_RETRIES 3 -#define PENDING_ACK_LIST_SIZE 25 +#define MSG_NOT_ACKED_TIMEOUT_MS 150 ///< maximum time for a Denali message that requires ACK to be ACK'd +#define MSG_NOT_ACKED_MAX_RETRIES 3 ///< maximum number of times a message that requires ACK that was not ACK'd can be re-sent before alarm +#define PENDING_ACK_LIST_SIZE 25 ///< maximum number of Delanli messages that can be pending ACK at any given time #pragma pack(push, 1) +/// Record for transmitted message that is pending acknowledgement from receiver. typedef struct { BOOL used; @@ -74,6 +81,7 @@ // ********** private data ********** +/// Array of out-going CAN buffers. const COMM_BUFFER_T CAN_OUT_BUFFERS[ NUM_OF_CAN_OUT_BUFFERS ] = { COMM_BUFFER_OUT_CAN_HD_ALARM, @@ -83,6 +91,7 @@ COMM_BUFFER_OUT_CAN_PC }; +/// Array of in-coming CAN buffers. const COMM_BUFFER_T MSG_IN_BUFFERS[ NUM_OF_MSG_IN_BUFFERS ] = { COMM_BUFFER_IN_CAN_DG_ALARM, @@ -97,45 +106,38 @@ #endif }; -static U08 lastCANPacketSent[ CAN_MESSAGE_PAYLOAD_SIZE ]; -static CAN_MESSAGE_BOX_T lastCANPacketSentChannel = (CAN_MESSAGE_BOX_T)0; -static U32 lastCANPacketSentTimeStamp = 0; +static U08 lastCANPacketSent[ CAN_MESSAGE_PAYLOAD_SIZE ]; ///< Keep last packet sent on CAN bus in case we need to re-send. +static CAN_MESSAGE_BOX_T lastCANPacketSentChannel = (CAN_MESSAGE_BOX_T)0; ///< Keep channel last packet was sent on CAN bus in case we need to re-send. +static U32 lastCANPacketSentTimeStamp = 0; ///< Keep time last packet sent on CAN bus so we can timeout on transmission attempt. -#ifdef DEBUG_ENABLED - static U08 pcXmitPacket[ 1024 ]; - static U08 pcRecvPacket[ PC_MESSAGE_PACKET_SIZE ] = { 0, 0, 0, 0, 0, 0, 0, 0 }; +static PENDING_ACK_RECORD_T pendingAckList[ PENDING_ACK_LIST_SIZE ]; ///< list of outgoing messages that are awaiting an ACK - // DMA control records - static g_dmaCTRL pcDMAXmitControlRecord; // DMA transmit control record (UART-debug) - static g_dmaCTRL pcDMARecvControlRecord; // DMA receive control record (UART-debug) -#endif +static volatile BOOL hdIsOnlyCANNode = TRUE; ///< flag indicating whether HD is alone on CAN bus. +static U32 canXmitRetryCtr = 0; ///< counter for CAN transmit retries. +static volatile BOOL dgIsCommunicating = FALSE; ///< has DG sent a message since last check +static U32 timeOfLastDGCheckIn = 0; ///< last time DG checked in +static volatile BOOL uiIsCommunicating = FALSE; ///< has UI sent a message since last check +static U32 timeOfLastUICheckIn = 0; ///< last time UI checked in +static volatile BOOL uiDidCommunicate = FALSE; ///< has UI every sent a message -static PENDING_ACK_RECORD_T pendingAckList[ PENDING_ACK_LIST_SIZE ]; // list of outgoing messages that are awaiting an ACK - -static volatile BOOL dgIsCommunicating = FALSE; // has DG sent a message since last check -static U32 timeOfLastDGCheckIn = 0; // last time DG checked in -static volatile BOOL uiIsCommunicating = FALSE; // has UI sent a message since last check -static U32 timeOfLastUICheckIn = 0; // last time UI checked in -static volatile BOOL uiDidCommunicate = FALSE; // has UI every sent a message - -static U32 badCRCTimeStamps[ MAX_COMM_CRC_FAILURES ]; // time of last five bad message CRCs (wrapping list) -static U32 badCRCListIdx = 0; // where next bad message CRC time stamp will go in list -static U32 badCRCListCount = 0; // # of bad CRCs in the list - #ifdef EMC_TEST_BUILD -static U32 badCANCount; // test code in support of EMC testing + static U32 badCANCount; // test code in support of EMC testing #endif +#ifdef DEBUG_ENABLED + // debug buffers + static U08 pcXmitPacket[ 1024 ]; + static U08 pcRecvPacket[ PC_MESSAGE_PACKET_SIZE ] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + + // DMA control records + static g_dmaCTRL pcDMAXmitControlRecord; + static g_dmaCTRL pcDMARecvControlRecord; +#endif + // ********** private function prototypes ********** -#ifdef DEBUG_ENABLED - static void initUARTAndDMA( void ); - static U32 transmitNextUARTPacket( void ); -#endif +static void clearCANXmitBuffers( void ); -static BOOL isCANBoxForXmit( CAN_MESSAGE_BOX_T srcCANBox ); -static BOOL isCANBoxForRecv( CAN_MESSAGE_BOX_T srcCANBox ); - static COMM_BUFFER_T findNextHighestPriorityCANPacketToTransmit( void ); static U32 transmitNextCANPacket( void ); @@ -151,13 +153,17 @@ static BOOL matchACKtoPendingACKList( S16 seqNo ); static void checkPendingACKList( void ); -/************************************************************************* - * @brief initSystemComm +#ifdef DEBUG_ENABLED + static void initUARTAndDMA( void ); + static U32 transmitNextUARTPacket( void ); +#endif + +/*********************************************************************//** + * @brief * The initSystemComm function initializes the SystemComm module. * @details * Inputs : none * Outputs : SystemComm module initialized. - * @param none * @return none *************************************************************************/ void initSystemComm( void ) @@ -169,11 +175,8 @@ initUARTAndDMA(); #endif - // initialize bad message CRC list - for ( i = 0; i < MAX_COMM_CRC_FAILURES; i++ ) - { - badCRCTimeStamps[ i ] = 0; - } + // initialize bad message CRC time windowed count + initTimeWindowedCount( TIME_WINDOWED_COUNT_BAD_MSG_CRC, MAX_COMM_CRC_FAILURES, MAX_COMM_CRC_FAILURE_WINDOW_MS ); // initialize pending ACK list for ( i = 0; i < PENDING_ACK_LIST_SIZE; i++ ) @@ -182,14 +185,13 @@ } } -/************************************************************************* - * @brief checkInFromDG +/*********************************************************************//** + * @brief * The checkInFromDG function checks in the DG with the HD - indicating that \n * the DG is communicating. * @details * Inputs : none * Outputs : dgIsCommunicating - * @param none * @return none *************************************************************************/ void checkInFromDG( void ) @@ -198,14 +200,13 @@ timeOfLastDGCheckIn = getMSTimerCount(); } -/************************************************************************* - * @brief checkInFromUI +/*********************************************************************//** + * @brief * The checkInFromUI function checks in the UI with the HD - indicating that \n * the UI is communicating. * @details * Inputs : none * Outputs : uiIsCommunicating - * @param none * @return none *************************************************************************/ void checkInFromUI( void ) @@ -215,14 +216,13 @@ uiDidCommunicate = TRUE; } -/************************************************************************* - * @brief isDGCommunicating +/*********************************************************************//** + * @brief * The isDGCommunicating function determines whether the DG is communicating \n * with the HD. * @details * Inputs : dgIsCommunicating * Outputs : none - * @param none * @return TRUE if DG has checked in since last call, FALSE if not *************************************************************************/ BOOL isDGCommunicating( void ) @@ -234,14 +234,13 @@ return result; } -/************************************************************************* - * @brief isUICommunicating +/*********************************************************************//** + * @brief * The isUICommunicating function determines whether the UI is communicating \n * with the HD. * @details * Inputs : uiIsCommunicating * Outputs : none - * @param none * @return TRUE if UI has checked in since last call, FALSE if not *************************************************************************/ BOOL isUICommunicating( void ) @@ -253,27 +252,39 @@ return result; } -/************************************************************************* - * @brief uiCommunicated +/*********************************************************************//** + * @brief * The uiCommunicated function determines whether the UI has communicated. * @details * Inputs : uiDidCommunicate * Outputs : none - * @param none * @return TRUE if UI has communicated since power up, FALSE if not *************************************************************************/ BOOL uiCommunicated( void ) { return uiDidCommunicate; +} + +/*********************************************************************//** + * @brief + * The isHDOnlyCANNode function determines whether the HD is the only node \n + * currently on the CAN bus. + * @details + * Inputs : hdIsOnlyCANNode + * Outputs : none + * @return TRUE if HD is only node on CAN bus, FALSE if not + *************************************************************************/ +BOOL isHDOnlyCANNode( void ) +{ + return hdIsOnlyCANNode; } -/************************************************************************* - * @brief execSystemCommRx +/*********************************************************************//** + * @brief * The execSystemCommRx function manages received data from other sub-systems. * @details * Inputs : none - * Outputs : none - * @param none + * Outputs : Incoming messages parsed and processed. * @return none *************************************************************************/ void execSystemCommRx( void ) @@ -291,30 +302,53 @@ checkPendingACKList(); } -/************************************************************************* - * @brief execSystemCommTx +/*********************************************************************//** + * @brief * The execSystemCommTx function manages data to be transmitted to other \n * sub-systems. * @details * Inputs : none - * Outputs : none - * @param none + * Outputs : Outgoing messages transmitted. * @return none *************************************************************************/ void execSystemCommTx( void ) { // if CAN transmitter is idle, start transmitting any pending packets - if ( FALSE == isCAN1TransmitInProgress() ) + if ( ( FALSE == hdIsOnlyCANNode ) && ( FALSE == isCAN1TransmitInProgress() ) ) { transmitNextCANPacket(); } else { // generally, transmitter should not be busy at time of this function call - check timeout just in case so we don't get stuck waiting forever if ( TRUE == didTimeout( lastCANPacketSentTimeStamp, CAN_XMIT_PACKET_TIMEOUT_MS ) ) - { - // TODO - depending on why we timed out, we may need to reset CAN controller??? - // assume last packet was not successfully transmitted. TODO - Re-send last packet? Or should we move on? - canTransmit( canREG1, lastCANPacketSentChannel, lastCANPacketSent ); + { + // assume last packet was not successfully transmitted. Re-send last packet. + if ( ++canXmitRetryCtr <= MAX_XMIT_RETRIES ) + { + canTransmit( canREG1, lastCANPacketSentChannel, lastCANPacketSent ); +#ifdef DEBUG_ENABLED + { + char debugStr[100]; + sprintf( debugStr, "SystemComm-HD resend Last Frame. %2d\n", lastCANPacketSentChannel ); + sendDebugDataToUI( (U08*)debugStr ); + } +#endif + } + // we must be only node on CAN bus - nobody is ACKing our transmitted frames + else + { + hdIsOnlyCANNode = TRUE; // set only CAN node flag + canXmitRetryCtr = MAX_XMIT_RETRIES; + signalCANXmitsCompleted(); // clear pending xmit flag + clearCANXmitBuffers(); // clear xmit buffers - nothing is going out right now +#ifdef DEBUG_ENABLED + { + char debugStr[100]; + sprintf( debugStr, "SystemComm-HD is only node.\n" ); + sendDebugDataToUI( (U08*)debugStr ); + } +#endif + } } } @@ -327,8 +361,8 @@ #endif } -/************************************************************************* - * @brief handleCANMsgInterrupt +/*********************************************************************//** + * @brief * The handleCANMsgInterrupt function handles a CAN message interrupt. \n * This may have occurred because a CAN packet transmission has completed \n * or because a CAN packet has been received. The appropriate handler is \n @@ -378,14 +412,13 @@ } } -/************************************************************************* - * @brief handleUARTMsgRecvPacketInterrupt +/*********************************************************************//*** + * @brief * The handleUARTMsgRecvPacketInterrupt function handles a DMA UART receive \n * packet completed interrupt. * @details * Inputs : none - * Outputs : none - * @param none + * Outputs : UART received packet interrupt handled. * @return none *************************************************************************/ #ifdef DEBUG_ENABLED @@ -400,14 +433,13 @@ } #endif -/************************************************************************* - * @brief handleUARTMsgXmitPacketInterrupt +/*********************************************************************//** + * @brief * The handleUARTMsgXmitPacketInterrupt function handles a DMA UART transmit \n * packet completed interrupt. * @details * Inputs : none - * Outputs : none - * @param none + * Outputs : UART transmit packet interrupt handled. * @return none *************************************************************************/ #ifdef DEBUG_ENABLED @@ -422,14 +454,13 @@ } #endif -/************************************************************************* - * @brief initUARTAndDMA +/*********************************************************************//** + * @brief * The initUARTAndDMA function initializes the SCI1 peripheral and the DMA \n * to go with it for PC communication. * @details * Inputs : none * Outputs : SCI1 and DMA initialized - * @param none * @return none *************************************************************************/ #ifdef DEBUG_ENABLED @@ -489,8 +520,8 @@ } #endif -/************************************************************************* - * @brief isCANBoxForXmit +/*********************************************************************//** + * @brief * The isCANBoxForXmit function determines whether a given CAN message box \n * is configured for transmit. * @details @@ -499,7 +530,7 @@ * @param srcCANBox : which CAN message box to check * @return TRUE if the given CAN message box is configured for transmit, FALSE if not. *************************************************************************/ -static BOOL isCANBoxForXmit( CAN_MESSAGE_BOX_T srcCANBox ) +BOOL isCANBoxForXmit( CAN_MESSAGE_BOX_T srcCANBox ) { BOOL result = FALSE; U32 i; @@ -516,8 +547,8 @@ return result; } -/************************************************************************* - * @brief isCANBoxForRecv +/*********************************************************************//** + * @brief * The isCANBoxForRecv function determines whether a given CAN message box \n * is configured for receiving. * @details @@ -526,7 +557,7 @@ * @param srcCANBox : which CAN message box to check * @return TRUE if the given CAN message box is configured for receiving, FALSE if not. *************************************************************************/ -static BOOL isCANBoxForRecv( CAN_MESSAGE_BOX_T srcCANBox ) +BOOL isCANBoxForRecv( CAN_MESSAGE_BOX_T srcCANBox ) { BOOL result = FALSE; U32 i; @@ -541,6 +572,24 @@ } return result; +} + +/*********************************************************************//** + * @brief + * The clearCANXmitBuffers function clears all CAN transmit buffers. + * @details + * Inputs : CAN_OUT_BUFFERS[] + * Outputs : CAN transmit buffers cleared. + * @return none + *************************************************************************/ +static void clearCANXmitBuffers( void ) +{ + U32 i; + + for ( i = 0; i < NUM_OF_CAN_OUT_BUFFERS; i++ ) + { + clearBuffer( CAN_OUT_BUFFERS[ i ] ); + } } @@ -549,14 +598,13 @@ *************************************************************************/ -/************************************************************************* - * @brief findNextHighestPriorityCANPacketToTransmit +/*********************************************************************//** + * @brief * The findNextHighestPriorityCANPacketToTransmit function gets the next \n * 8 byte packet and initiates a CAN transmit on the appropriate CAN channel. \n * @details * Inputs : Output CAN Comm Buffer(s) * Outputs : none - * @param msg : none * @return buffer with highest priority CAN packet to transmit, \n * COMM_BUFFER_NOT_USED if not CAN packets pending transmit found *************************************************************************/ @@ -578,14 +626,13 @@ return result; } -/************************************************************************* - * @brief transmitNextCANPacket +/*********************************************************************//** + * @brief * The transmitNextCANPacket function gets the next 8 byte packet and initiates \n * a CAN transmit on the appropriate CAN channel. * @details * Inputs : Output CAN Comm Buffers * Outputs : CAN packet transmit initiated. - * @param msg : none * @return # of bytes transmitted *************************************************************************/ static U32 transmitNextCANPacket( void ) @@ -617,26 +664,25 @@ { signalCANXmitsCompleted(); // TODO - shouldn't get here, but let's see if we do - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_SOFTWARE_FAULT, (U32)mBox ) + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, (U32)mBox ) } } else { // TODO - shouldn't get here - just testing - set first data to new s/w fault enum later - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_SOFTWARE_FAULT, (U32)buffer, (U32)dataSize ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, (U32)buffer, (U32)dataSize ) } } return result; } -/************************************************************************* - * @brief transmitNextUARTPacket +/*********************************************************************//** + * @brief * The transmitNextUARTPacket function sets up and initiates a DMA transmit \n * of the next packet pending transmit (if any) via UART. * @details * Inputs : Output UART Comm Buffer(s) * Outputs : UART DMA transmit initiated. - * @param msg : none * @return # of bytes transmitted *************************************************************************/ #ifdef DEBUG_ENABLED @@ -669,14 +715,13 @@ *************************************************************************/ -/************************************************************************* - * @brief processIncomingData +/*********************************************************************//** + * @brief * The processIncomingData function parses out messages from the Input \n * Comm Buffers and adds them to the Received Message Queue. * @details * Inputs : Input Comm Buffers * Outputs : Parsed message(s) added to Received Message Queue - * @param msg : none * @return none *************************************************************************/ static void processIncomingData( void ) @@ -704,7 +749,10 @@ if ( numOfBytesInBuffer >= MESSAGE_OVERHEAD_SIZE ) { // peek at minimum of all bytes available or max message size (+1 for sync byte) U32 bytesPeeked = peekFromCommBuffer( MSG_IN_BUFFERS[ i ], data, MIN( numOfBytesInBuffer, sizeof( MESSAGE_WRAPPER_T ) + 1 ) ); - S32 msgSize = parseMessageFromBuffer( data, bytesPeeked ); + S32 msgSize = parseMessageFromBuffer( data, bytesPeeked ); + + hdIsOnlyCANNode = FALSE; // if we're getting a message, we can't be alone + canXmitRetryCtr = 0; if ( msgSize > 0 ) // valid, complete message found? { @@ -749,13 +797,13 @@ } } -/************************************************************************* - * @brief consumeBufferPaddingBeforeSync +/*********************************************************************//** + * @brief * The consumeBufferPaddingBeforeSync function removes any bytes in a given \n * buffer that lie before a sync byte. * @details * Inputs : none - * Outputs : none + * Outputs : Any padding at front of buffer is consumed. * @param msg : buffer : the comm buffer to process * @return none *************************************************************************/ @@ -780,8 +828,8 @@ } } -/************************************************************************* - * @brief parseMessageFromBuffer +/*********************************************************************//** + * @brief * The parseMessageFromBuffer function looks for a complete message in a \n * given buffer. If a message is found, its size is returned. * @details @@ -832,14 +880,13 @@ return result; } -/************************************************************************* - * @brief processReceivedMessages +/*********************************************************************//** + * @brief * The processReceivedMessages function processes any messages in the \n * received message queues. * @details * Inputs : Received Message Queues * Outputs : Message(s) processed. - * @param msg : none * @return none *************************************************************************/ static void processReceivedMessages( void ) @@ -883,14 +930,13 @@ } } -/************************************************************************* - * @brief checkForCommTimeouts +/*********************************************************************//** + * @brief * The checkForCommTimeouts function checks for sub-system communication \n * timeout errors. * @details * Inputs : timeOfLastDGCheckIn, timeOfLastUICheckIn * Outputs : possibly a comm t/o alarm - * @param none * @return none *************************************************************************/ static void checkForCommTimeouts( void ) @@ -905,8 +951,8 @@ // TODO - check DG comm timeout } -/************************************************************************* - * @brief checkTooManyBadMsgCRCs +/*********************************************************************//** + * @brief * The checkTooManyBadMsgCRCs function checks for too many bad message CRCs \n * within a set period of time. Assumed function is being called when a new \n * bad CRC is detected so a new bad CRC will be added to the list. @@ -917,26 +963,23 @@ *************************************************************************/ static void checkTooManyBadMsgCRCs( void ) { - U32 listTimeInMS; - - // replace oldest bad CRC in list with this new one - badCRCTimeStamps[ badCRCListIdx ] = getMSTimerCount(); - // move list index to next position (may wrap) - badCRCListIdx = INC_WRAP( badCRCListIdx, 0, MAX_COMM_CRC_FAILURES - 1 ); - // update list count - badCRCListCount = INC_CAP( badCRCListCount, MAX_COMM_CRC_FAILURES ); - // check if too many bad CRCs in window of time - listTimeInMS = calcTimeSince( badCRCTimeStamps[ badCRCListIdx ] ); - if ( ( badCRCListCount >= MAX_COMM_CRC_FAILURES ) && ( listTimeInMS <= MAX_COMM_CRC_FAILURE_WINDOW_MS ) ) - { -#ifndef DISABLE_CRC_ERROR - activateAlarmNoData( ALARM_ID_COMM_TOO_MANY_BAD_CRCS ); -#endif - } + if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_BAD_MSG_CRC ) ) + { +#ifndef DISABLE_CRC_ERROR + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_COMM_TOO_MANY_BAD_CRCS, 1 ); // 1 for HD +#endif + } +#ifdef DEBUG_ENABLED + { + char debugStr[100]; + sprintf( debugStr, "SystemComm-HD-Bad Msg CRC.\n" ); + sendDebugDataToUI( (U08*)debugStr ); + } +#endif } -/************************************************************************* - * @brief addMsgToPendingACKList +/*********************************************************************//** + * @brief * The addMsgToPendingACKList function adds a given message to the pending \n * ACK list. Messages in this list will require receipt of an ACK message \n * for this particular message within a limited time. @@ -981,8 +1024,8 @@ return result; } -/************************************************************************* - * @brief matchACKtoPendingACKList +/*********************************************************************//** + * @brief * The matchACKtoPendingACKList function searches the pending ACK list to \n * see if the sequence # from a received ACK msg matches any. If found, \n * the list entry is removed. @@ -1011,15 +1054,14 @@ return result; } -/************************************************************************* - * @brief checkPendingACKList +/*********************************************************************//** + * @brief * The checkPendingACKList function searches the pending ACK list to \n * see if any have expired. Any such messages will be queued for retransmission \n * and if max retries reached a fault is triggered. * @details * Inputs : pendingAckList[] * Outputs : pendingAckList[] - * @param none * @return none *************************************************************************/ static void checkPendingACKList( void ) @@ -1048,8 +1090,8 @@ } } -/************************************************************************* - * @brief processReceivedMessage +/*********************************************************************//** + * @brief * The processReceivedMessage function processes a given message. * @details * Inputs : none @@ -1311,3 +1353,5 @@ } } } + +/**@}*/