Index: firmware/App/Controllers/BloodLeak.c =================================================================== diff -u -r29b362c485f28f45ef367342ac895e1c1907ac45 -r8b73263b38f449dacc0795c67a7cf6240cb79026 --- firmware/App/Controllers/BloodLeak.c (.../BloodLeak.c) (revision 29b362c485f28f45ef367342ac895e1c1907ac45) +++ firmware/App/Controllers/BloodLeak.c (.../BloodLeak.c) (revision 8b73263b38f449dacc0795c67a7cf6240cb79026) @@ -7,8 +7,8 @@ * * @file BloodLeak.c * -* @author (last) Darren Cox -* @date (last) 10-Mar-2022 +* @author (last) Dara Navaei +* @date (last) 04-Aug-2022 * * @author (original) Peman Montazemi * @date (original) 18-Mar-2021 @@ -34,7 +34,6 @@ // ********** private definitions ********** #define BLOOD_LEAK_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the blood leak data is published on the CAN bus. -#define BLOOD_LEAK_TIMEOUT_MS 2000 ///< Blood leak detector timeout for zeroing and self-test (15 ms extended edge detection) #define BLOOD_LEAK_PERSISTENCE ( 10 * MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Persistence for blood leak detected alarm. #define BLOOD_LEAK_RESET_TX_FIFO 2 ///< Blood leak reset transmit FIFO command. #define BLOOD_LEAK_START_COMM_CTRL_U_ASCII 21 ///< Blood leak start communication command, ^U (Ctrl-U) in ascii. @@ -50,30 +49,47 @@ #define BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND 0 ///< Blood leak set point stop writing to FIFO command. #define BLOOD_LEAK_SET_POINT_START_CHAR_INDEX 0 ///< Blood leak set point sequence start character index number. #define BLOOD_LEAK_CARRIAGE_RETURN_ASCII 13 ///< Blood leak set point sequence carriage return character in ASCII. -#define BLOOD_LEAK_SET_POINT_SEQ_MAX_LENGTH 15 ///< Blood leak set point sequence maximum length. +#define BLOOD_LEAK_SET_POINT_SEQ_MAX_LENGTH 17 ///< Blood leak set point sequence maximum length. #define BLOOD_LEAK_WAIT_2_READ_SET_POINT ( 1 * MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Blood leak wait to read set point in counts. #define BLOOD_LEAK_WAIT_2_READ_CTRL_U ( 1 * MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Blood leak wait to read control U in counts. #define BLOOD_LEAK_MAX_SET_POINT_WRITE_TRIALS 3 ///< Blood leak maximum number of trials to write the set point. #define BLOOD_LEAK_MAX_CTRL_U_WRITE_TRIALS 3 ///< Blood leak maximum number of trials to write the control U command. - +#define BLOOD_LEAK_ZERO_CMD_STATUS_READY 0x80 ///< Blood leak zero command status ready value. +#define BLOOD_LEAK_SELF_TEST_CMD_STATUS_READY 0x80 ///< Blood leak self test command status ready value. +#define BLOOD_LEAK_STATUS_BIT_HIGH 1 ///< Blood leak status bit high. +#define BLOOD_LEAK_STATUS_BIT_LOW 0 ///< Blood leak status bit low. +#define BLOOD_LEAK_ZERO_CMD_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Blood leak zero command timeout in milliseconds. +#define BLOOD_LEAK_SELF_TEST_CMD_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Blood leak self test command timeout in milliseconds. +#define BLOOD_LEAK_BETWEEN_ZERO_ST_WAIT_MS 250 ///< Blood leak wait time in between zero and self test commands in milliseconds. #define BLOOD_LEAK_MIN_WAIT_TIME_2_GET_CAL_MS ( 2 * MS_PER_SECOND ) ///< Blood leak minimum wait time to get calibration in milliseconds. #define DATA_PUBLISH_COUNTER_START_COUNT 60 ///< Data publish counter start count. -// Calibration mode defines -#define BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH 4 ///< Blood leak embedded mode command sequence length. -#define BLOOD_LEAK_EMB_MODE_STOP_INDEX 1 ///< Blood leak embedded mode stop writing to FIFO index. +// Embedded mode defines +#define BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH 6 ///< Blood leak embedded mode command sequence length. +#define BLOOD_LEAK_EMB_MODE_RQST_RX_LENGTH 2 ///< Blood leak embedded mode request new Rx data length. #define BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_HIGH 5 ///< Blood leak embedded mode communication active high command. #define BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW 4 ///< Blood leak embedded mode communication active low command. -#define BLOOD_LEAK_EMB_MODE_RX_TIMEOUT_MS ( 5 * MS_PER_SECOND ) ///< Blood leak embedded mode calibration receive timeout in milliseconds. +#define BLOOD_LEAK_EMB_MODE_COMM_RESET 6 ///< Blood leak embedded mode communication reset. +#define BLOOD_LEAK_EMB_MODE_COMM_READ_REQST 12 ///< Blood leak embedded mode communication read Rx byte request. #define BLOOD_LEAK_EMB_MODE_RX_BUFFER_EMPTY 0x80 ///< Blood leak embedded mode buffer empty value. #define BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN 5 ///< Blood leak embedded mode number of commands. #define BLOOD_LEAK_EMB_MODE_MAX_NUM_CMD_TRIES 4 ///< Blood leak embedded mode max number of command tries. #define BLOOD_LEAK_EMB_MODE_0_NUM_ASCII 48 ///< Blood leak embedded mode character 0 in ASCII. #define BLOOD_LEAK_EMB_MODE_9_NUM_ASCII 57 ///< Blood leak embedded mode character 9 in ASCII. #define BLOOD_LEAK_EMB_MODE_SET_PNT_RESP_LEN 4 ///< Blood leak embedded mode set point response length. +#define BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX 0 ///< Blood leak embedded mode command (UART/Transmit) column index number. +#define BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX 1 ///< Blood leak embedded mode is command type UART or transmit flag. +#define BLOOD_LEAK_EMB_MODE_PASS_ASCII 80 ///< Blood leak embedded mode P (pass) in ASCII. +#define BLOOD_LEAK_EMB_MODE_FAIL_ASCII 70 ///< Blood leak embedded mode F (fail) in ASCII. +#define BLOOD_LEAK_EMB_MODE_RESET_INDEX 0 ///< Blood leak embedded mode reset FIFO command index. +#define BLOOD_LEAK_EMB_MODE_CMD_INDEX 2 ///< Blood leak embedded mode command index. +#define BLOOD_LEAK_EMB_MODE_STOP_WRITE_INDEX 3 ///< Blood leak embedded mode stop write to FIFO index. +#define BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX 4 ///< Blood leak embedded mode active high command index. +#define BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX 0 ///< Blood leak embedded mode request Rx to read index. + /// Defined states for the blood leak detector state machine. typedef enum BloodLeakStates { @@ -83,7 +99,9 @@ BLOOD_LEAK_CHECK_SET_POINT_STATE, ///< Check set point state. BLOOD_LEAK_SET_SET_POINT_STATE, ///< Set set point state. BLOOD_LEAK_INIT_STATE, ///< Init state. + BLOOD_LEAK_PREP_FOR_ZERO_CMD_STATE, ///< Prepare for zero command state. BLOOD_LEAK_ZERO_STATE, ///< Zero state. + BLOOD_LEAK_PREP_FOR_SELF_TEST_CMD_STATE, ///< Prepare for self test command state. BLOOD_LEAK_SELF_TEST_STATE, ///< Self-test state. BLOOD_LEAK_NORMAL_STATE, ///< Normal state. BLOOD_LEAK_CALIBRATION_STATE, ///< Calibration state. @@ -121,34 +139,41 @@ U08 commandASCII; ///< Blood leak sensor command ID number in ASCII. U08 expChar1; ///< Blood leak sensor expected response in character. U08 expChar2; ///< Blood leak sensor expected response in character. - U08 length; ///< Blood leak sensor expected response length in bytes. + U32 length; ///< Blood leak sensor expected response length in bytes. + U32 timeoutMS; ///< Blood leak sensor receive timeout in milliseconds. } EMB_MODE_CMD_T; +/// Zero command structure +typedef struct +{ + BOOL cmdZeroRequested; ///< Blood leak zero command requested. + U08 cmdPrevStatus; ///< Blood leak previous zero/self test status. + U32 cmdStartTimeMS; ///< Blood leak zero/self test command start time in milliseconds. + U32 cmdWaitBtwnZeroSTestMS; ///< Blood leak wait time in between zero and self test in milliseconds. +} BLOOD_LEAK_GPIO_CMD_T; + // ********** private data ********** static BLOOD_LEAK_STATE_T bloodLeakState; ///< Current state of blood leak state machine. +static BLOOD_LEAK_STATE_T bloodLeakPrevState; ///< Previous state of blood leak state machine. static OVERRIDE_U32_T bloodLeakStatus; ///< Detected blood leak status for blood leak detector. static SELF_TEST_STATUS_T bloodLeakSelfTestStatus; ///< Current status of blood leak self-test. - -static BOOL bloodLeakZeroRequested; ///< Blood leak zero requested flag -static U32 bloodLeakZeroStartTime; ///< Blood leak zeroing start time. -static U32 bloodLeakSelfTestStartTime; ///< Blood leak self-test start time. static BOOL bloodLeakIsPOSTComplete; ///< Blood leak is POST complete flag. - static U32 bloodLeakPersistenceCtr; ///< Blood leak alarm persistence timer counter. static OVERRIDE_U32_T bloodLeakDataPublishInterval = { BLOOD_LEAK_PUB_INTERVAL, BLOOD_LEAK_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms) at which to publish blood leak data to CAN bus. static U32 bloodLeakDataPublicationTimerCounter; ///< Timer counter used to schedule blood leak data publication to CAN bus. static U32 bloodLeakUARTCmdIndex; ///< Blood leak UART command index. static U32 bloodLeakSetPointSeqLength; ///< Blood leak set point sequence actual length. -static U08 bloodLeakSetPointSequence[ BLOOD_LEAK_SET_POINT_SEQ_MAX_LENGTH ]; ///< Blood leak set point sequence array. +static U08 bloodLeakSetPointSequence[ BLOOD_LEAK_SET_POINT_SEQ_MAX_LENGTH ][ 2 ]; ///< Blood leak set point sequence array. static U32 bloodLeakWait2ReadResponseCounter; ///< Blood leak wait to read response counter. static U32 bloodLeakCommandWriteTryCount; ///< Blood leak current set point write try number. static HD_BLOOD_LEAK_SENSOR_CAL_RECORD_T bloodLeakCalRecord; ///< Blood leak calibration record structure. static U32 bloodLeakGetCalStartTime; ///< Blood leak get calibration start time. static U32 bloodLeakPrevFPGARegisterCount; ///< Blood leak previous FPGA communications counter. static BOOL bloodLeakExitNormalRequested; ///< Blood leak exit normal state requested. +static BLOOD_LEAK_GPIO_CMD_T bloodLeakGPIOCmd; ///< Blood leak zero/self test GPIO command. /// Blood leak start up sequence array. static const U08 BLOOD_LEAK_START_UP_SEQUENCE[ BLOOD_LEAK_STARTUP_SEQ_LENGTH ] = { BLOOD_LEAK_RESET_TX_FIFO, @@ -160,14 +185,15 @@ // Embedded mode variables static BOOL bloodLeakSignalEmbModeReq; ///< Blood leak signal embedded mode has been requested. static U08 bloodLeakEmbModeRqstedCmd; ///< Blood leak signal embedded mode requested command. -static U08 bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ]; ///< Blood leak embedded mode command sequence. +static U08 bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ][ 2 ]; ///< Blood leak embedded mode command sequence. static BLOOD_LEAK_EMB_MODE_STATE_T bloodLeakEmbModeSubstate; ///< Blood leak embedded mode state. static U32 bloodLeakEmbModeOpsStartTime; ///< Blood leak embedded mode operations start time. static U16 bloodLeakEmbModeSetPoint; ///< Blood leak embedded mode set point command. static EMB_MODE_CMD_T bloodLeakEmbModeCmd [ NUM_OF_EMB_CMDS ]; ///< Blood leak embedded mode commands. static U08 bloodLeakEmbModeRespBuffer[ BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ]; ///< Blood leak embedded mode response buffer. static U32 bloodLeakEmbModeRespIndex; ///< Blood leak embedded mode response buffer index. -static U32 bloodLeakEmbModeNumOfCmdTries; ///< Blood leak embedded mode number of command trials. +static U32 bloodLeakEmbModeCmdSeqLength; ///< Blood leak embedded mode command sequence length. +static BOOL bloodLeakEmbModeHasRxRqstBeenSent; ///< Blood leak embedded mode Rx request has been sent signal. // ********** private function prototypes ********** @@ -177,7 +203,9 @@ static BLOOD_LEAK_STATE_T handleBloodLeakCheckSetPointState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakSetSetPointState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakInitState( void ); +static BLOOD_LEAK_STATE_T handleBloodLeakPrepForZeroCmdState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakZeroState( void ); +static BLOOD_LEAK_STATE_T handleBloodLeakPrepForSelfTestCmdState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakSelfTestState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakNormalState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakCalibrationState( void ); @@ -186,22 +214,24 @@ static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakSendCommandState( void ); static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandResponseState( void ); +static void processReceivedEmbModeChar( U08 data ); static void prepareSetPointSeq( U16 setPoint ); static void publishBloodLeakData( void ); static void initEmbModeSpecs( void ); +static BOOL hasZeroBloodLeakBeenRequested( void ); /*********************************************************************//** * @brief * The initBloodLeak function initializes the Blood Leak module. * @details Inputs: none * @details Outputs: bloodLeakState, bloodLeakStatus, bloodLeakSelfTestStatus, - * bloodLeakZeroRequested, bloodLeakZeroRequested, bloodLeakSelfTestStartTime, * bloodLeakUARTCmdIndex, bloodLeakSetPointSequence, bloodLeakPrevFPGARegisterCount * bloodLeakWait2ReadResponseCounter, bloodLeakDataPublicationTimerCounter, * bloodLeakCommandWriteTryCount, bloodLeakGetCalStartTime, bloodLeakEmbModeSubstate * bloodLeakIsPOSTComplete, bloodLeakPersistenceCtr, bloodLeakSignalEmbModeReq, * bloodLeakEmbModeRqstedCmd, bloodLeakEmbModeOpsStartTime, bloodLeakEmbModeRespBuffer, - * bloodLeakEmbModeRespIndex, bloodLeakEmbModeNumOfCmdTries, bloodLeakExitNormalRequested + * bloodLeakEmbModeRespIndex, bloodLeakExitNormalRequested, + * bloodLeakEmbModeCmdSeqLength, bloodLeakEmbModeHasRxRqstBeenSent * @return none *************************************************************************/ void initBloodLeak( void ) @@ -213,9 +243,6 @@ bloodLeakStatus.ovData = BLOOD_LEAK_NOT_DETECTED; bloodLeakStatus.override = OVERRIDE_RESET; bloodLeakSelfTestStatus = SELF_TEST_STATUS_IN_PROGRESS; - bloodLeakZeroRequested = FALSE; - bloodLeakZeroStartTime = 0; - bloodLeakSelfTestStartTime = 0; bloodLeakUARTCmdIndex = 0; bloodLeakSetPointSeqLength = 0; bloodLeakWait2ReadResponseCounter = 0; @@ -229,22 +256,18 @@ bloodLeakEmbModeSubstate = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; bloodLeakEmbModeOpsStartTime = 0; bloodLeakEmbModeRespIndex = 0; - bloodLeakEmbModeNumOfCmdTries = 0; bloodLeakExitNormalRequested = FALSE; + bloodLeakEmbModeCmdSeqLength = 0; + bloodLeakEmbModeHasRxRqstBeenSent = FALSE; // Set the blood leak set pint sequence to 0 to be initialized memset( bloodLeakSetPointSequence, 0x0, BLOOD_LEAK_SET_POINT_SEQ_MAX_LENGTH ); // Initialize the blood leak embedded mode response buffer memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); - // Initialize the blood leak calibration command sequence array. - // The first index is the command character so it can be changed upon request. - // The rest of the commands are never changing. - bloodLeakEmbModeCmdSquence[ 0 ] = 0; - bloodLeakEmbModeCmdSquence[ 1 ] = BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND; - bloodLeakEmbModeCmdSquence[ 2 ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_HIGH; - bloodLeakEmbModeCmdSquence[ 3 ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + // Initialize the blood leak embedded mode command sequence + memset( bloodLeakEmbModeCmdSquence, 0x0, BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); // Initialize the embedded mode specifications initEmbModeSpecs(); @@ -316,10 +339,18 @@ bloodLeakState = handleBloodLeakInitState(); break; + case BLOOD_LEAK_PREP_FOR_ZERO_CMD_STATE: + bloodLeakState = handleBloodLeakPrepForZeroCmdState(); + break; + case BLOOD_LEAK_ZERO_STATE: bloodLeakState = handleBloodLeakZeroState(); break; + case BLOOD_LEAK_PREP_FOR_SELF_TEST_CMD_STATE: + bloodLeakState = handleBloodLeakPrepForSelfTestCmdState(); + break; + case BLOOD_LEAK_SELF_TEST_STATE: bloodLeakState = handleBloodLeakSelfTestState(); break; @@ -348,13 +379,13 @@ * The zeroBloodLeak function requests that the Blood Leak Detector be * zeroed. * @details Inputs: none - * @details Outputs: Blood Leak module zeroing. + * @details Outputs: bloodLeakCmd.cmdZeroRequested, bloodLeakUARTCmdIndex * @return none *************************************************************************/ void zeroBloodLeak( void ) { - bloodLeakZeroRequested = TRUE; - bloodLeakUARTCmdIndex = 0; + bloodLeakGPIOCmd.cmdZeroRequested = TRUE; + bloodLeakUARTCmdIndex = 0; } /*********************************************************************//** @@ -418,7 +449,10 @@ // Read the value that is in the FPGA counter so it can be used to make sure the blood leak is communicating after // sending Ctrl U bloodLeakPrevFPGARegisterCount = getFPGABloodLeakRegisterCounter(); - state = BLOOD_LEAK_START_UP_STATE; + // TODO this has been disabled for the systems team testing. In their test, ^U is not sent + //state = BLOOD_LEAK_START_UP_STATE; + // TODO decide whether we need to go to ^U upon startup + state = BLOOD_LEAK_INIT_STATE; } return state; @@ -434,6 +468,7 @@ *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakStartupState( void ) { + // TODO NOTE: This function is bypassed until the use of ^U is finalized by the system's team BLOOD_LEAK_STATE_T state = BLOOD_LEAK_START_UP_STATE; U32 command = BLOOD_LEAK_START_UP_SEQUENCE[ bloodLeakUARTCmdIndex ]; @@ -477,6 +512,7 @@ *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakCheckCommState( void ) { + // TODO NOTE: This function is bypassed until the use of ^U is finalized by the system's team BLOOD_LEAK_STATE_T state = BLOOD_LEAK_CHECK_COMM_STATE; // Check if the blood leak sensor has started communicating @@ -519,7 +555,7 @@ { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_CHECK_SET_POINT_STATE; - U16 bloodLeakSetPoint = getFPGABloodLeakDetectSetPoint(); + U16 bloodLeakSetPoint = getFPGABloodLeakDetectSetPoint(); // TODO is this working in embedded mode? #ifdef BOARD_WITH_NO_HARDWARE // In case it is just a bare board, use this value @@ -546,7 +582,7 @@ } else { - state = BLOOD_LEAK_INIT_STATE; + state = BLOOD_LEAK_INIT_STATE; bloodLeakCommandWriteTryCount = 0; } @@ -562,12 +598,13 @@ *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakSetSetPointState( void ) { + // TODO remove this function BLOOD_LEAK_STATE_T state = BLOOD_LEAK_SET_SET_POINT_STATE; // Check if the current buffer index is less than the buffer length if( bloodLeakUARTCmdIndex < bloodLeakSetPointSeqLength ) { - U32 command = bloodLeakSetPointSequence[ bloodLeakUARTCmdIndex ]; + U32 command = bloodLeakSetPointSequence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; // The active high index is the length - 2 they are the last two elements U32 activeHighIndex = bloodLeakSetPointSeqLength - 2; @@ -610,15 +647,47 @@ { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_INIT_STATE; - if ( TRUE == bloodLeakZeroRequested ) - { - state = BLOOD_LEAK_ZERO_STATE; - bloodLeakZeroRequested = FALSE; - bloodLeakZeroStartTime = getMSTimerCount(); + // Check if the zero command has been requested + state = ( TRUE == hasZeroBloodLeakBeenRequested() ? BLOOD_LEAK_PREP_FOR_ZERO_CMD_STATE : state ); + return state; +} + +/*********************************************************************//** + * @brief + * The handleBloodLeakPrepForZeroCmdState function handles the blood leak + * prepare for zero command state. + * @details Inputs: bloodLeakCmd + * @details Outputs: bloodLeakCmd + * @return next state + *************************************************************************/ +static BLOOD_LEAK_STATE_T handleBloodLeakPrepForZeroCmdState( void ) +{ + BLOOD_LEAK_STATE_T state = BLOOD_LEAK_PREP_FOR_ZERO_CMD_STATE; + U08 zeroCmdStatus = getFPGABloodLeakZeroErrorCounter() & BLOOD_LEAK_ZERO_CMD_STATUS_READY; + + // Check if the zero command is ready to receive a command and the zero status is high + if ( ( BLOOD_LEAK_ZERO_CMD_STATUS_READY == zeroCmdStatus ) && ( BLOOD_LEAK_STATUS_BIT_HIGH == getFPGABloodLeakZeroStatus() ) ) + { + // The conditions are met start the command + // Start with the previous status bit is high + state = BLOOD_LEAK_ZERO_STATE; + bloodLeakGPIOCmd.cmdStartTimeMS = getMSTimerCount(); + bloodLeakGPIOCmd.cmdPrevStatus = BLOOD_LEAK_STATUS_BIT_HIGH; setFPGABloodLeakZero(); } + else if ( TRUE == didTimeout( bloodLeakGPIOCmd.cmdStartTimeMS, BLOOD_LEAK_ZERO_CMD_TIMEOUT_MS ) ) + { +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_ALARM ) != SW_CONFIG_ENABLE_VALUE ) +#endif + { + activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_ZERO_CMD_SEND_TIMEOUT ); + } + state = BLOOD_LEAK_INIT_STATE; + } + return state; } @@ -633,27 +702,77 @@ static BLOOD_LEAK_STATE_T handleBloodLeakZeroState( void ) { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_ZERO_STATE; + U08 bloodLeakZeroStatus = getFPGABloodLeakZeroStatus(); - if ( TRUE == FPGABloodLeakZeroDetected() ) + // Check if the previous zero status bit was a 0 (low) and the current zero status bit is a 1 (high) + // Clear the blood leak zero and self test commands and get ready to do the self test + if ( ( BLOOD_LEAK_STATUS_BIT_LOW == bloodLeakGPIOCmd.cmdPrevStatus ) && ( BLOOD_LEAK_STATUS_BIT_HIGH == bloodLeakZeroStatus ) ) { - state = BLOOD_LEAK_SELF_TEST_STATE; - bloodLeakSelfTestStatus = SELF_TEST_STATUS_IN_PROGRESS; - bloodLeakSelfTestStartTime = getMSTimerCount(); - + // Clear the zero command since it is done and clear the self test since we are getting ready to do a self test. clearFPGABloodLeakZero(); - setFPGABloodLeakSelfTest(); + clearFPGABloodLeakSelfTest(); + // Get ready for the next state. + state = BLOOD_LEAK_PREP_FOR_SELF_TEST_CMD_STATE; + bloodLeakGPIOCmd.cmdStartTimeMS = getMSTimerCount(); + bloodLeakGPIOCmd.cmdWaitBtwnZeroSTestMS = getMSTimerCount(); } + else if ( TRUE == didTimeout( bloodLeakGPIOCmd.cmdStartTimeMS, BLOOD_LEAK_ZERO_CMD_TIMEOUT_MS ) ) + { + // Zero command timed out +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_ALARM ) != SW_CONFIG_ENABLE_VALUE ) +#endif + { + activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_ZERO_CMD_FAULT ); + } + // Get back to init state + state = BLOOD_LEAK_INIT_STATE; + } else { - if ( TRUE == didTimeout( bloodLeakZeroStartTime, BLOOD_LEAK_TIMEOUT_MS ) ) + // Update the previous status with the current zero status since the low to high edge has been observed yet + bloodLeakGPIOCmd.cmdPrevStatus = bloodLeakZeroStatus; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleBloodLeakPrepForSelfTestCmdState function handles the blood leak + * prepare for self test command state. + * @details Inputs: bloodLeakGPIOCmd + * @details Outputs: bloodLeakGPIOCmd + * @return next state + *************************************************************************/ +static BLOOD_LEAK_STATE_T handleBloodLeakPrepForSelfTestCmdState( void ) +{ + BLOOD_LEAK_STATE_T state = BLOOD_LEAK_PREP_FOR_SELF_TEST_CMD_STATE; + U08 selfTestCmdStatus = getFPGABloodLeakSelfTestErrorCounter() & BLOOD_LEAK_SELF_TEST_CMD_STATUS_READY; + + // Check if the self test command status is ready and self test status bit is low (0) + if ( ( BLOOD_LEAK_SELF_TEST_CMD_STATUS_READY == selfTestCmdStatus ) && ( BLOOD_LEAK_STATUS_BIT_LOW == getFPGABloodLeakStatus() ) ) + { + // Check if the delay in between the zero command and the self test command has been elapsed + if ( TRUE == didTimeout( bloodLeakGPIOCmd.cmdWaitBtwnZeroSTestMS, BLOOD_LEAK_BETWEEN_ZERO_ST_WAIT_MS ) ) { + // Update the variables and set the self test + state = BLOOD_LEAK_SELF_TEST_STATE; + bloodLeakGPIOCmd.cmdStartTimeMS = getMSTimerCount(); + bloodLeakGPIOCmd.cmdPrevStatus = BLOOD_LEAK_STATUS_BIT_LOW; + setFPGABloodLeakSelfTest(); + } + } + else if ( TRUE == didTimeout( bloodLeakGPIOCmd.cmdStartTimeMS, BLOOD_LEAK_SELF_TEST_CMD_TIMEOUT_MS ) ) + { #ifndef _RELEASE_ - if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_ALARM ) != SW_CONFIG_ENABLE_VALUE ) + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_ALARM ) != SW_CONFIG_ENABLE_VALUE ) #endif - { - activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_FAULT ); - } + { + activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_SELF_TEST_SEND_TIMEOUT ); } + // Self test command failed + state = BLOOD_LEAK_INIT_STATE; } return state; @@ -669,29 +788,33 @@ *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakSelfTestState( void ) { - BLOOD_LEAK_STATE_T state = BLOOD_LEAK_SELF_TEST_STATE; + BLOOD_LEAK_STATE_T state = BLOOD_LEAK_SELF_TEST_STATE; + U08 bloodLeakSelfTestStatus = getFPGABloodLeakStatus(); - if ( SELF_TEST_STATUS_IN_PROGRESS == bloodLeakSelfTestStatus ) + // Check if the previous status bit was a high (1) and the current status bit is a low (0). This means that the self test was + // successfully finished + if ( ( BLOOD_LEAK_STATUS_BIT_HIGH == bloodLeakGPIOCmd.cmdPrevStatus ) && ( BLOOD_LEAK_STATUS_BIT_LOW == bloodLeakSelfTestStatus ) ) { - if ( FALSE == noFPGABloodLeakDetected() ) // Faked blood leak caused by independent MCU board + // Clear the self test command since it is done + clearFPGABloodLeakSelfTest(); + state = BLOOD_LEAK_NORMAL_STATE; + bloodLeakSelfTestStatus = SELF_TEST_STATUS_PASSED; + } + else if ( TRUE == didTimeout( bloodLeakGPIOCmd.cmdStartTimeMS, BLOOD_LEAK_SELF_TEST_CMD_TIMEOUT_MS ) ) + { +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_ALARM ) != SW_CONFIG_ENABLE_VALUE ) +#endif { - bloodLeakSelfTestStatus = SELF_TEST_STATUS_PASSED; - clearFPGABloodLeakSelfTest(); + activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_SELF_TEST_FAULT ); } - else if ( TRUE == didTimeout( bloodLeakSelfTestStartTime, BLOOD_LEAK_TIMEOUT_MS ) ) - { - bloodLeakSelfTestStatus = SELF_TEST_STATUS_FAILED; - - activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_SELF_TEST_FAILURE ); - } + // Self test failed due to timeout + state = BLOOD_LEAK_INIT_STATE; + bloodLeakSelfTestStatus = SELF_TEST_STATUS_FAILED; } else { - // Blood leak self-test finished, wait for self-test faked blood leak clear - if ( TRUE == noFPGABloodLeakDetected() ) - { - state = BLOOD_LEAK_NORMAL_STATE; - } + bloodLeakGPIOCmd.cmdPrevStatus = bloodLeakSelfTestStatus; } return state; @@ -709,15 +832,19 @@ { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_NORMAL_STATE; - if ( TRUE == noFPGABloodLeakDetected() ) + // TODO remove + /*if ( TRUE == noFPGABloodLeakDetected() ) // TODO remove noFPGABloodLeakDetected() { bloodLeakStatus.data = BLOOD_LEAK_NOT_DETECTED; } else { bloodLeakStatus.data = BLOOD_LEAK_DETECTED; - } + }*/ + // If the blood leak status bit is low (0) it means blood has not been detected, otherwise, blood has been detected + bloodLeakStatus.data = ( BLOOD_LEAK_STATUS_BIT_LOW == getFPGABloodLeakStatus() ? BLOOD_LEAK_NOT_DETECTED : BLOOD_LEAK_DETECTED ); + // Check status reading and act upon if ( BLOOD_LEAK_DETECTED == getBloodLeakStatus() ) { @@ -749,21 +876,16 @@ } } - if ( TRUE == bloodLeakZeroRequested ) - { - state = BLOOD_LEAK_ZERO_STATE; - bloodLeakZeroRequested = FALSE; - - setFPGABloodLeakZero(); - bloodLeakZeroStartTime = getMSTimerCount(); - } - if ( TRUE == bloodLeakExitNormalRequested ) { state = BLOOD_LEAK_INIT_STATE; - bloodLeakZeroRequested = FALSE; bloodLeakExitNormalRequested = FALSE; } + else if ( TRUE == hasZeroBloodLeakBeenRequested() ) + { + // Check whether zeroing the sensor has been requested or not if yes, transition to zero command state otherwise, stay in this state + state = BLOOD_LEAK_PREP_FOR_ZERO_CMD_STATE; + } return state; } @@ -850,38 +972,60 @@ static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandState( void ) { BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; + U08 command = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].commandASCII; - U08 test = getFPGABloodLeakTxFIFOCount(); - switch( bloodLeakEmbModeRqstedCmd ) { - case NU_EMB_MODE_CMD: - // Null command do nothing - break; + case NU_EMB_MODE_CMD: + // Null command do nothing + break; - case CS_EMB_MODE_CMD: - case T_EMB_MODE_CMD: - case G_EMB_MODE_CMD: - case I_EMB_MODE_CMD: - case V_EMB_MODE_CMD: - case Z_EMB_MODE_CMD: - case Q_EMB_MODE_CMD: - case D_EMB_MODE_CMD: - case C_EMB_MODE_CMD: - // The requested command is not set point and so update the command sequence buffer. - // The first index of calibration command sequence is the requested command in ASCII. - bloodLeakEmbModeCmdSquence[ 0 ] = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].commandASCII; - bloodLeakUARTCmdIndex = 0; - bloodLeakEmbModeNumOfCmdTries = 0; - state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; - break; + case CS_EMB_MODE_CMD: + case T_EMB_MODE_CMD: + case G_EMB_MODE_CMD: + case I_EMB_MODE_CMD: + case V_EMB_MODE_CMD: + case Z_EMB_MODE_CMD: + case Q_EMB_MODE_CMD: + case D_EMB_MODE_CMD: + case C_EMB_MODE_CMD: + // First clear the buffer from the older data + memset( bloodLeakEmbModeCmdSquence, 0x0, 2 * BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); + // Set the command sequence + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_RESET_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_RESET; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_RESET_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_RESET_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_RESET_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_CMD_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = command; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_CMD_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_STOP_WRITE_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_STOP_WRITE_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_HIGH; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; - case SP_EMB_MODE_CMD: - prepareSetPointSeq( bloodLeakEmbModeSetPoint ); - - bloodLeakEmbModeNumOfCmdTries = 0; - state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; + // Set the variables for the next state + bloodLeakUARTCmdIndex = 0; + bloodLeakEmbModeRespIndex = 0; + bloodLeakEmbModeCmdSeqLength = BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH; + bloodLeakEmbModeOpsStartTime = getMSTimerCount(); + state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; + // Clear the response buffer to able to receive fresh data + memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); break; + + case SP_EMB_MODE_CMD: + prepareSetPointSeq( bloodLeakEmbModeSetPoint ); + bloodLeakEmbModeRespIndex = 0; + bloodLeakEmbModeOpsStartTime = getMSTimerCount(); + state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; + // Clear the command sequence buffer in case it is needed to send byte read request. The byte + // read requests are sent using this buffer while the set point is set using the set point buffer + memset( bloodLeakEmbModeCmdSquence, 0x0, 2 * BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); + // Clear the response buffer to able to receive fresh data + memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); + break; } return state; @@ -898,10 +1042,9 @@ *************************************************************************/ static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakSendCommandState( void ) { - U32 command; - + U08 command; BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; - BOOL isUARTTxDone = FALSE; + BOOL isUARTCtrlCmd = FALSE; BOOL isUARTCtrlDone = TRUE; switch ( bloodLeakEmbModeRqstedCmd ) @@ -915,53 +1058,56 @@ case Q_EMB_MODE_CMD: case D_EMB_MODE_CMD: case C_EMB_MODE_CMD: - command = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ]; - isUARTTxDone = ( bloodLeakUARTCmdIndex <= BLOOD_LEAK_EMB_MODE_STOP_INDEX ? FALSE : TRUE ); - isUARTCtrlDone = ( bloodLeakUARTCmdIndex > ( BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH - 1 ) ? TRUE : FALSE ); - + command = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; + isUARTCtrlCmd = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; + isUARTCtrlDone = ( bloodLeakUARTCmdIndex > ( bloodLeakEmbModeCmdSeqLength - 1 ) ? TRUE : FALSE ); bloodLeakUARTCmdIndex++; break; case SP_EMB_MODE_CMD: - // Check if the current buffer index is less than the buffer length - if( bloodLeakUARTCmdIndex < bloodLeakSetPointSeqLength ) + // Check if the first element in the command sequence buffer is the read request. If it is, the set point command sequence has already been sent + // and we are requesting the buffer to read and get its response back so use this buffer to send data to the sensor + // Otherwise, send the set point command sequence to the sensor since the set point is sent prior to reading the response back from the sensor + if ( BLOOD_LEAK_EMB_MODE_COMM_READ_REQST == bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] ) { - // The active high index is the length - 2 they are the last two elements - U32 activeHighIndex = bloodLeakSetPointSeqLength - 2; - command = bloodLeakSetPointSequence[ bloodLeakUARTCmdIndex ]; - isUARTTxDone = ( bloodLeakUARTCmdIndex >= activeHighIndex ? TRUE : FALSE ); - isUARTCtrlDone = ( bloodLeakUARTCmdIndex > bloodLeakSetPointSeqLength ? TRUE : FALSE ); - - bloodLeakUARTCmdIndex++; + command = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; + isUARTCtrlCmd = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; + isUARTCtrlDone = ( bloodLeakUARTCmdIndex > ( bloodLeakEmbModeCmdSeqLength - 1 ) ? TRUE : FALSE ); } + else + { + command = bloodLeakSetPointSequence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; + isUARTCtrlCmd = bloodLeakSetPointSequence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; + isUARTCtrlDone = ( bloodLeakUARTCmdIndex > ( bloodLeakSetPointSeqLength - 1 ) ? TRUE : FALSE ); + } + bloodLeakUARTCmdIndex++; break; + } + if ( ( bloodLeakEmbModeRqstedCmd != CS_EMB_MODE_CMD ) && ( bloodLeakUARTCmdIndex - 1 > BLOOD_LEAK_EMB_MODE_RESET_INDEX ) && + ( bloodLeakUARTCmdIndex - 1 <= BLOOD_LEAK_EMB_MODE_RESET_INDEX + 1 ) ) + { + if ( BLOOD_LEAK_EMB_MODE_RX_BUFFER_EMPTY == getFPGABloodLeakRxFIFOCount() ) + { + // TODO do nothing right now. I case it was decided to use the terminal mode again, make sure the reset went through prior to sending the + // reset of the command sequence + } } // Check if the current index towards the end of the buffer which are FIFO set and FIFO reset if ( FALSE == isUARTCtrlDone ) { - // TODO test this - //FALSE == isUARTTxDone ? setFPGABloodLeakUARTTransmit( (U08)command ) : setFPGABloodLeakUARTControl( (U08)command ); - - if( FALSE == isUARTTxDone ) - { - setFPGABloodLeakUARTTransmit( (U08)command ); - } - else - { - setFPGABloodLeakUARTControl( (U08)command ); - } + FALSE == isUARTCtrlCmd ? setFPGABloodLeakUARTTransmit( command ) : setFPGABloodLeakUARTControl( command ); } else { - // Reset the variables for the next - bloodLeakEmbModeOpsStartTime = getMSTimerCount(); - bloodLeakUARTCmdIndex = 0; - bloodLeakEmbModeRespIndex = 0; - state = BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE; - - memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); + // If the element in the first index of the command sequence buffer is the read a byte request, set the variable to TRUE so the + // wait for data to receive state knows that the request has been sent and it can read the byte. + U08 commandInIndex0 = bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; + bloodLeakEmbModeHasRxRqstBeenSent = ( BLOOD_LEAK_EMB_MODE_COMM_READ_REQST == commandInIndex0 ? TRUE : FALSE ); + bloodLeakUARTCmdIndex = 0; + bloodLeakEmbModeCmdSeqLength = 0; + state = BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE; } return state; @@ -971,122 +1117,48 @@ * @brief * The handleCalBloodLeakWaitForCommandResponseState function handles the * wait for command responses state. The state receives data in the buffer. - * @details Inputs: TODO fill up - * @details Outputs: TODo fill up + * @details Inputs: bloodLeakEmbModeCmd, bloodLeakEmbModeRespIndex + * @details Outputs: bloodLeakEmbModeRespBuffer, bloodLeakEmbModeRespIndex * @return next state *************************************************************************/ static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandResponseState( void ) { BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE; U08 rxFIFOCount = getFPGABloodLeakRxFIFOCount(); - U08 length = 0; + BOOL hasCharBeenReceived = FALSE; + U32 commandTimeoutMS = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].timeoutMS; + U32 length = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].length; - if ( rxFIFOCount > 0 ) + if ( TRUE == bloodLeakEmbModeHasRxRqstBeenSent ) { - /* - * There are 3 types of data that can be received from the the sensor: - * 1. It could be a start character and the length (i.e. VXXXX) - * 2. It could be two discrete characters (i.e. P, F) - * 3. It could be none of the two characters (i.e. XXXX) - */ - length = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].length; - U08 data = getFPGABloodLeakRxFIFODataOut(); - U08 expChar1 = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar1; - U08 expChar2 = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar2; - U08 command = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].commandASCII; + // If the read request sequence has been sent already, read the next byte in the buffer and process it + U08 data = getFPGABloodLeakRxFIFODataOut(); + hasCharBeenReceived = TRUE; + bloodLeakEmbModeHasRxRqstBeenSent = FALSE; + processReceivedEmbModeChar( data ); + } + else if ( ( rxFIFOCount > 0 ) && ( FALSE == bloodLeakEmbModeHasRxRqstBeenSent ) ) + { + // If there is still more data in the buffer and a read sequence has not been sent, create the sequence and send it + // First clear the buffer from the older data. Set to 2 times the length because the array is 2D + memset( bloodLeakEmbModeCmdSquence, 0x0, 2 * BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_READ_REQST; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + bloodLeakEmbModeCmdSquence[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; - if ( ( expChar1 != NU_EMB_MODE_CMD ) && ( NU_EMB_MODE_CMD == expChar2 ) ) - { - // This is the case that there is a start character. If current character buffer index is less than the - // length of the expected response of the command. - if ( bloodLeakEmbModeRespIndex < length ) - { - // Check if the expected char is received and the response buffer is empty because the index is 0, - // insert the buffer data - if ( ( expChar1 == data ) && ( 0 == bloodLeakEmbModeRespIndex ) ) - { - bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; - - bloodLeakEmbModeRespIndex++; - } - // Check if the buffer index is > 0 so the first char has been inserted and the rest is data but it is not the echo of the command - // For instance, V has been inserted and XXXX is inserted that is followed by V. So V123 and not VVV12. - else if ( ( bloodLeakEmbModeRespIndex > 0 ) && ( data != expChar1 ) ) - { - bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; - - bloodLeakEmbModeRespIndex++; - } - } - } - else if ( ( expChar1 != NU_EMB_MODE_CMD ) && ( expChar2 != NU_EMB_MODE_CMD ) ) - { - // This is the case that both expected chars are not null. Either of the chars are accepted like P or F - if ( bloodLeakEmbModeRespIndex < length ) - { - // Check if either of the expected chars are received and if they are insert it into the response buffer - if ( ( expChar1 == data ) || ( expChar2 == data ) ) - { - bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; - - bloodLeakEmbModeRespIndex++; - } - } - - if ( BLOOD_LEAK_SET_POINT_START_CHAR_ASCII == command ) - { - // There is an exception in this case which is the set point command. - // The set point command can either receive X for timeout or F if the command failed. - // But if the command was received properly, the response is XXXX. For example if set point is 200, the response is 0200 - // The response buffer length of a successful set point is 4 characters (XXXX) - if ( bloodLeakEmbModeRespIndex < BLOOD_LEAK_EMB_MODE_SET_PNT_RESP_LEN ) - { - U08 spResponse = bloodLeakEmbModeRespBuffer[ 0 ]; - length = BLOOD_LEAK_EMB_MODE_SET_PNT_RESP_LEN; - - if ( ( spResponse != expChar1 ) && ( spResponse != expChar2 ) ) - { - // Check if the failed and timeout characters are not inserted - // Check if the response buffer has not been filled and the current received data is a number in between 0 to 9 - if ( ( data >= BLOOD_LEAK_EMB_MODE_0_NUM_ASCII ) && ( data <= BLOOD_LEAK_EMB_MODE_9_NUM_ASCII ) ) - { - bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; - - bloodLeakEmbModeRespIndex++; - } - } - } - } - } - else if ( ( NU_EMB_MODE_CMD == expChar1 ) && ( NU_EMB_MODE_CMD == expChar2 ) ) - { - // This is the case that there are no expected characters and the received value are numbers - if ( bloodLeakEmbModeRespIndex < length ) - { - // If the received character is in the range of numbers chars (0 to 9), then insert them into the response buffer - if ( ( data >= BLOOD_LEAK_EMB_MODE_0_NUM_ASCII ) && ( data <= BLOOD_LEAK_EMB_MODE_9_NUM_ASCII ) ) - { - bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; - - bloodLeakEmbModeRespIndex++; - } - } - } + // Set the variables for the next state + bloodLeakUARTCmdIndex = 0; + bloodLeakEmbModeCmdSeqLength = BLOOD_LEAK_EMB_MODE_RQST_RX_LENGTH; + state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; } // If wait for the receive FIFO has timed out or all there is no buffer left in the Rx FIFO transition back to wait for command state for the next command - if ( ( TRUE == didTimeout( bloodLeakEmbModeOpsStartTime, BLOOD_LEAK_EMB_MODE_RX_TIMEOUT_MS ) ) || ( BLOOD_LEAK_EMB_MODE_RX_BUFFER_EMPTY == rxFIFOCount ) ) + if ( TRUE == hasCharBeenReceived ) { - // Check if the first element of the response buffer is null and the number of tries has not exceeded. When the response buffer is - // null but it is the end of the receive buffer it means no response has been received back - if ( ( NU_EMB_MODE_CMD == bloodLeakEmbModeRespBuffer[ 0 ] ) && ( ++bloodLeakEmbModeNumOfCmdTries < BLOOD_LEAK_EMB_MODE_MAX_NUM_CMD_TRIES ) ) + if ( bloodLeakEmbModeRespIndex >= length ) { - state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; - } - else - { U08 i; - BOOL isNull = FALSE; for ( i = 0; i < length; i++ ) @@ -1100,25 +1172,123 @@ // it failed set the embedded mode request to false so the other commands cannot be sent again bloodLeakSignalEmbModeReq = ( ( CS_EMB_MODE_CMD == bloodLeakEmbModeRqstedCmd ) && ( NU_EMB_MODE_CMD == bloodLeakEmbModeRespBuffer[ 0 ] ) ? FALSE : TRUE ); - if ( ( TRUE == isNull ) && ( ++bloodLeakEmbModeNumOfCmdTries < BLOOD_LEAK_EMB_MODE_MAX_NUM_CMD_TRIES ) ) + if ( TRUE == isNull ) { - state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; + // There is null in the characters that were supposed to be received and not be null but null was found + // Clear the response buffer and write the ASCII fail in the first element of the response buffer + // Set the length to be 1 because there is only 1 character (fail) is in the buffer + memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); + length = 1; + bloodLeakEmbModeRespBuffer[ 0 ] = BLOOD_LEAK_EMB_MODE_FAIL_ASCII; } - else + else if ( CS_EMB_MODE_CMD == bloodLeakEmbModeRqstedCmd ) { - bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; - state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; - - handleSendBloodLeakEmbeddedModeCommandResponse( length, bloodLeakEmbModeRespBuffer ); + memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); + length = 1; + bloodLeakEmbModeRespBuffer[ 0 ] = BLOOD_LEAK_EMB_MODE_PASS_ASCII; } + else if ( 1 == length ) + { + U08 passChar = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar1; + U08 data = bloodLeakEmbModeRespBuffer[ 0 ]; + bloodLeakEmbModeRespBuffer[ 0 ] = ( passChar == data ? BLOOD_LEAK_EMB_MODE_PASS_ASCII : BLOOD_LEAK_EMB_MODE_FAIL_ASCII ); + } + + // Done with receiving the data + bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; + state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; + handleSendBloodLeakEmbeddedModeCommandResponse( length, bloodLeakEmbModeRespBuffer ); } } + if ( TRUE == didTimeout( bloodLeakEmbModeOpsStartTime, commandTimeoutMS ) ) + { + // Command timed out. Clear the receive buffer from any data and put a Fail in there to be sent up + memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); + // Only F (fail) will be sent so the length of the buffer is 1 + length = 1; + bloodLeakEmbModeRespBuffer[ 0 ] = BLOOD_LEAK_EMB_MODE_FAIL_ASCII; + bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; + state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; + handleSendBloodLeakEmbeddedModeCommandResponse( length, bloodLeakEmbModeRespBuffer ); + } + return state; } /*********************************************************************//** * @brief + * The processReceivedEmbModeChar function processes the character that + * has been received. + * @details Inputs: bloodLeakEmbModeCmd, bloodLeakEmbModeRespIndex + * @details Outputs: bloodLeakEmbModeRespBuffer, bloodLeakEmbModeRespIndex + * @param data which is the data that has been received from the BLD + * @return none + *************************************************************************/ +static void processReceivedEmbModeChar( U08 data ) +{ + /* + * There are 3 types of data that can be received from the the sensor: + * 1. It could be a start character and the length (i.e. VXXXX) + * 2. It could be two discrete characters (i.e. P, F) + * 3. It could be none of the two characters (i.e. XXXX) + */ + U08 length = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].length; + U08 expChar1 = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar1; + U08 expChar2 = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar2; + + if ( ( expChar1 != NU_EMB_MODE_CMD ) && ( NU_EMB_MODE_CMD == expChar2 ) ) + { + // This is the case that there is a start character. If current character buffer index is less than the + // length of the expected response of the command. + if ( bloodLeakEmbModeRespIndex < length ) + { + // Check if the expected char is received and the response buffer is empty because the index is 0, + // insert the buffer data + if ( ( expChar1 == data ) && ( 0 == bloodLeakEmbModeRespIndex ) ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + bloodLeakEmbModeRespIndex++; + } + // Check if the buffer index is > 0 so the first char has been inserted and the rest is data but it is not the echo of the command + // For instance, V has been inserted and XXXX is inserted that is followed by V. So V123 and not VVV12. + else if ( ( bloodLeakEmbModeRespIndex > 0 ) && ( data != expChar1 ) ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + bloodLeakEmbModeRespIndex++; + } + } + } + else if ( ( expChar1 != NU_EMB_MODE_CMD ) && ( expChar2 != NU_EMB_MODE_CMD ) ) + { + // This is the case that both expected chars are not null. Either of the chars are accepted like P or F + if ( bloodLeakEmbModeRespIndex < length ) + { + // Check if either of the expected chars are received and if they are insert it into the response buffer + if ( ( expChar1 == data ) || ( expChar2 == data ) ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + bloodLeakEmbModeRespIndex++; + } + } + } + else if ( ( NU_EMB_MODE_CMD == expChar1 ) && ( NU_EMB_MODE_CMD == expChar2 ) ) + { + // This is the case that there are no expected characters and the received value are numbers + if ( bloodLeakEmbModeRespIndex < length ) + { + // If the received character is in the range of numbers chars (0 to 9), then insert them into the response buffer + if ( ( data >= BLOOD_LEAK_EMB_MODE_0_NUM_ASCII ) && ( data <= BLOOD_LEAK_EMB_MODE_9_NUM_ASCII ) ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + bloodLeakEmbModeRespIndex++; + } + } + } +} + +/*********************************************************************//** + * @brief * The prepareSetPointSeq function prepares the set point sequence to be * written to the blood leak sensor. * @details Inputs: none @@ -1131,7 +1301,7 @@ U08 i; U32 digitCount; char tempCharBuffer[ BLOOD_LEAK_SET_POINT_MAX_CHAR_LENGTH ]; - + U08 command; U32 bufferIndex = BLOOD_LEAK_SET_POINT_START_CHAR_INDEX; memset( tempCharBuffer, 0x0, BLOOD_LEAK_SET_POINT_MAX_CHAR_LENGTH ); @@ -1142,47 +1312,62 @@ // Calculate the length of the character buffer. strlen does not count the null character. digitCount = strlen( tempCharBuffer ); + command = ( TRUE == bloodLeakSignalEmbModeReq ? BLOOD_LEAK_EMB_MODE_COMM_RESET : BLOOD_LEAK_RESET_TX_FIFO ); + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = command; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bufferIndex++; + + command = ( TRUE == bloodLeakSignalEmbModeReq ? BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW : BLOOD_LEAK_UART_COMM_ACTIVE_LOW ); + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = command; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bufferIndex++; + // Set the first item to the ASCII character of S. The format to set the set point is // SXXXCR10. It starts with S followed by the characters up to 3 digits, carriage return and a 1 and a 0 to write to the buffer. - bloodLeakSetPointSequence[ bufferIndex ] = BLOOD_LEAK_SET_POINT_START_CHAR_ASCII; - - // Increment the buffer index + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_SET_POINT_START_CHAR_ASCII; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; bufferIndex++; // Loop through the number of digits and get each ASCII value for ( i = 0; i < digitCount; i++ ) { // Write the characters - bloodLeakSetPointSequence[ bufferIndex ] = tempCharBuffer[ i ]; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = tempCharBuffer[ i ]; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; bufferIndex++; } // After the characters, insert the carriage return into the buffer - bloodLeakSetPointSequence[ bufferIndex ] = BLOOD_LEAK_CARRIAGE_RETURN_ASCII; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_CARRIAGE_RETURN_ASCII; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; bufferIndex++; // After the characters, insert the stop write to FIFO character which is number 0 - bloodLeakSetPointSequence[ bufferIndex ] = BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; bufferIndex++; - // Set active high and active low into the buffer - bloodLeakSetPointSequence[ bufferIndex ] = ( TRUE == bloodLeakSignalEmbModeReq ? BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_HIGH : BLOOD_LEAK_UART_COMM_ACTIVE_HIGH ); + // Set active high into the buffer. + // If the mode is embedded mode, the active high (and active low) values are different than in the Ctrl U mode since the bit values are different + command = ( TRUE == bloodLeakSignalEmbModeReq ? BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_HIGH : BLOOD_LEAK_UART_COMM_ACTIVE_HIGH ); + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = command; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; bufferIndex++; - bloodLeakSetPointSequence[ bufferIndex ] = ( TRUE == bloodLeakSignalEmbModeReq ? BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW : BLOOD_LEAK_UART_COMM_ACTIVE_LOW ); + command = ( TRUE == bloodLeakSignalEmbModeReq ? BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW : BLOOD_LEAK_UART_COMM_ACTIVE_LOW ); + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = command; + bloodLeakSetPointSequence[ bufferIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; // Update the sequence length for writing to the sensor bloodLeakSetPointSeqLength = bufferIndex + 1; - - // Get ready for the next write to the sensor bloodLeakUARTCmdIndex = 0; } /*********************************************************************//** * @brief * The publishBloodLeakData function publishes blood leak data at the set interval. * @details Inputs: bloodLeakDataPublicationTimerCounter - * @details Outputs: bloodLeakDataPublicationTimerCounter + * @details Outputs: bloodLeakDataPublicatimerCouonTinter * @return none *************************************************************************/ static void publishBloodLeakData( void ) @@ -1191,7 +1376,6 @@ if ( ++bloodLeakDataPublicationTimerCounter >= getU32OverrideValue( &bloodLeakDataPublishInterval ) ) { BLOOD_LEAK_DATA_T data; - data.bloodLeakStatus = (U32)getBloodLeakStatus(); data.bloodLeakState = (U32)bloodLeakState; data.bloodLeakZeroStatusCounter = (U32)getFPGABloodLeakZeroStatusCounter(); @@ -1223,69 +1407,103 @@ bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].expChar1 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].length = 0; + bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].timeoutMS = 0; // Control S command bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].commandASCII = 19; // ASCII for Control S bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].expChar1 = 69; // ASCII for E (Embedded ...) bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].length = 5; + bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; // Set point command bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].commandASCII = 83; // ASCII for S - bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].expChar1 = 88; // ASCII for X (Timeout) - bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].expChar2 = 70; // ASCII for F (Fail) - bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].length = 1; + bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].expChar1 = 32; // For space (Set point is returned by a space at the beginning of returning the set point value) + bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; + bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].length = 5; + bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].timeoutMS = 10 * MS_PER_SECOND; // Self test command bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].commandASCII = 84; // ASCII for T bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].expChar1 = 80; // ASCII for P bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].expChar2 = 70; // ASCII for F bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].length = 1; + bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; // Get self test command bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].commandASCII = 71; // ASCII for G bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].expChar1 = 71; bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].length = 5; + bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].timeoutMS = 10 * MS_PER_SECOND; // Intensity command bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].commandASCII = 73; // ASCII for I bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].expChar1 = 73; bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].length = 5; + bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; // Blood detection command bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].commandASCII = 86; // ASCII for V bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].expChar1 = 86; bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].length = 5; + bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; // Zero sensor command bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].commandASCII = 90; // ASCII for Z bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].expChar1 = 89; // ASCII for Y bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].length = 1; + bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].timeoutMS = 10 * MS_PER_SECOND; // Zero confirm command bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].commandASCII = 81; // ASCII for Q bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].expChar1 = 80; // ASCII for P bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].expChar2 = 70; // ASCII for F bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].length = 1; + bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; // Display blood detection command bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].commandASCII = 68; bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].expChar1 = 68; // ASCII for D bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].length = 5; + bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; // Calibrate command bloodLeakEmbModeCmd[ C_EMB_MODE_CMD ].commandASCII = 67; bloodLeakEmbModeCmd[ C_EMB_MODE_CMD ].expChar1 = 67; // ASCII for C bloodLeakEmbModeCmd[ C_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ C_EMB_MODE_CMD ].length = 4; + bloodLeakEmbModeCmd[ C_EMB_MODE_CMD ].timeoutMS = 5 * MS_PER_SECOND; } +/*********************************************************************//** + * @brief + * The hasZeroBloodLeakBeenRequested function checks whether zeroing blood + * leak has been requested or not. + * @details Inputs: bloodLeakCmd + * @details Outputs: bloodLeakCmd + * @return TURE if request otherwise, FLASE + *************************************************************************/ +static BOOL hasZeroBloodLeakBeenRequested( void ) +{ + BOOL status = FALSE; + if ( TRUE == bloodLeakGPIOCmd.cmdZeroRequested ) + { + status = TRUE; + bloodLeakGPIOCmd.cmdZeroRequested = FALSE; + bloodLeakGPIOCmd.cmdStartTimeMS = getMSTimerCount(); + clearFPGABloodLeakZero(); + } + + return status; +} + + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -1306,8 +1524,7 @@ if ( TRUE == isTestingActivated() ) { - U32 intvl = value / TASK_PRIORITY_INTERVAL; - + U32 intvl = value / TASK_PRIORITY_INTERVAL; result = TRUE; bloodLeakDataPublishInterval.ovData = intvl; bloodLeakDataPublishInterval.override = OVERRIDE_KEY;