Index: firmware/App/Controllers/BloodLeak.c =================================================================== diff -u -r47af9ee07565cde6b0ac062eacd7e40bc1be8d9f -ra67030b162e759b0c9e350344112bbf26af794be --- firmware/App/Controllers/BloodLeak.c (.../BloodLeak.c) (revision 47af9ee07565cde6b0ac062eacd7e40bc1be8d9f) +++ firmware/App/Controllers/BloodLeak.c (.../BloodLeak.c) (revision a67030b162e759b0c9e350344112bbf26af794be) @@ -8,14 +8,15 @@ * @file BloodLeak.c * * @author (last) Dara Navaei -* @date (last) 23-May-2022 +* @date (last) 04-Aug-2022 * * @author (original) Peman Montazemi * @date (original) 18-Mar-2021 * ***************************************************************************/ #include // For sprintf and strlen +#include #include "AlarmMgmt.h" #include "BloodLeak.h" @@ -36,34 +37,23 @@ #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_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. #define BLOOD_LEAK_UART_COMM_ACTIVE_LOW 0 ///< Blood leak UART communication active low command. #define BLOOD_LEAK_UART_COMM_ACTIVE_HIGH 1 ///< Blood leak UART communication active high command. -#define BLOOD_LEAK_STARTUP_SEQ_LENGTH 6 ///< Blood leak start up sequence array length. -#define BLOOD_LEAK_START_FIFO_CTRL_U_INDEX 2 ///< Blood leak start communication sequence ^U index. -#define BLOOD_LEAK_START_FIFO_STOP_INDEX 3 ///< Blood leak start communication sequence stop write to FIFO index. - #define BLOOD_LEAK_SET_POINT_MAX_CHAR_LENGTH 11 ///< Blood leak set point maximum character length. #define BLOOD_LEAK_SET_POINT_START_CHAR_ASCII 83 ///< Blood leak set point sequence start character in ASCII (letter S). #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 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. // Embedded mode defines @@ -75,7 +65,7 @@ #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_MAX_NUM_CMD_TRIES 3 ///< 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. @@ -89,35 +79,29 @@ #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. +#define BLOOD_LEAK_EMB_MODE_CMD_Q_MAX_SIZE 10 ///< Blood leak embedded mode command queue maximum size. /// Defined states for the blood leak detector state machine. typedef enum BloodLeakStates { BLOOD_LEAK_WAIT_FOR_POST_STATE = 0, ///< Wait for post state. - BLOOD_LEAK_START_UP_STATE, ///< Start up state. - BLOOD_LEAK_CHECK_COMM_STATE, ///< Check communication (Control U) state. 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_CHECK_ZERO_AND_SELF_TEST_STATE, ///< Blood leak check for zero and self test commands state. BLOOD_LEAK_NORMAL_STATE, ///< Normal state. - BLOOD_LEAK_CALIBRATION_STATE, ///< Calibration state. NUM_OF_BLOOD_LEAK_STATES ///< Number of blood leak detector states. } BLOOD_LEAK_STATE_T; /// Defined embedded states typedef enum EmbStates { - BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE = 0, ///< Blood leak calibration state wait for command state. - BLOOD_LEAK_CAL_SEND_COMMAND_STATE, ///< Blood leak calibration state send command state. - BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE, ///< Blood leak calibration state wait for command response state. - NUM_CAL_STATES ///< Number of blood leak calibration states. + BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMAND_STATE = 0, ///< Blood leak embedded mode state wait for command state. + BLOOD_LEAK_EMB_MODE_SEND_COMMAND_STATE, ///< Blood leak embedded mode state send command state. + BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMMAND_RESPONSE_STATE, ///< Blood leak embedded mode state wait for command response state. + NUM_OF_BLOOD_LEAK_EMB_MODE_STATES ///< Number of blood leak embedded mode states. } BLOOD_LEAK_EMB_MODE_STATE_T; -enum EmbCommands +typedef enum EmbCommands { NU_EMB_MODE_CMD = 0, ///< Null command. CS_EMB_MODE_CMD, ///< Control S command to switch to embedded mode. @@ -131,7 +115,7 @@ D_EMB_MODE_CMD, ///< Display blood detection command. C_EMB_MODE_CMD, ///< Calibration sensor command. NUM_OF_EMB_CMDS, ///< Number of embedded mode commands. -}; +} BLOOD_LEAK_EMB_MODE_CMD_T; /// Embedded mode commands specifications typedef struct @@ -141,24 +125,16 @@ U08 expChar2; ///< Blood leak sensor expected response in character. U32 length; ///< Blood leak sensor expected response length in bytes. U32 timeoutMS; ///< Blood leak sensor receive timeout in milliseconds. + U32 commandResp; ///< Blood leak sensor command response back. + U08 commandRetryCount; ///< Blood leak sensor command retry count. + BOOL isCmdRespRdy; ///< Blood leak sensor is command response ready flag. } 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 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, @@ -167,75 +143,67 @@ 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 ][ 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, - BLOOD_LEAK_UART_COMM_ACTIVE_LOW, - BLOOD_LEAK_START_COMM_CTRL_U_ASCII, - BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND, - BLOOD_LEAK_UART_COMM_ACTIVE_HIGH, - BLOOD_LEAK_UART_COMM_ACTIVE_LOW }; // 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 ][ 2 ]; ///< Blood leak embedded mode command sequence. +static U08 bloodLeakEmbModeCmdSeq[ 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 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 bloodLeakEmbModeCmdSeqLength; ///< Blood leak embedded mode command sequence length. static BOOL bloodLeakEmbModeHasRxRqstBeenSent; ///< Blood leak embedded mode Rx request has been sent signal. +static U08 bloodLeakEmbModeCmdQ[ BLOOD_LEAK_EMB_MODE_CMD_Q_MAX_SIZE ]; ///< Blood leak embedded mode command queue. +static U08 bloodLeakEmbModeCmdQRearIndex; ///< Blood leak embedded mode command queue rear index. +static U08 bloodLeakEmbModeCmdQFrontIndex; ///< Blood leak embedded mode command queue front index. +static U08 bloodLeakEmbModeCmdQCount; ///< Blood leak embedded mode command queue count. +static BOOL bloodLeakEmbModeHasZeroBeenRqustd; ///< Blood leak embedded mode flag to indicate zero has been requested. // ********** private function prototypes ********** static BLOOD_LEAK_STATE_T handleBloodLeakWaitForPostState( void ); -static BLOOD_LEAK_STATE_T handleBloodLeakStartupState( void ); -static BLOOD_LEAK_STATE_T handleBloodLeakCheckCommState( void ); 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 handleBloodLeakCheckZeroAndSelfTestState( void ); static BLOOD_LEAK_STATE_T handleBloodLeakNormalState( void ); -static BLOOD_LEAK_STATE_T handleBloodLeakCalibrationState( void ); -static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandState( void ); -static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakSendCommandState( void ); -static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandResponseState( void ); +static BLOOD_LEAK_EMB_MODE_STATE_T handleBloodLeakEmbModeWaitForCommandState( void ); +static BLOOD_LEAK_EMB_MODE_STATE_T handleBloodLeakEmbModeSendCommandState( void ); +static BLOOD_LEAK_EMB_MODE_STATE_T handleBloodLeakEmbModeWaitForCommandResponseState( void ); static void processReceivedEmbModeChar( U08 data ); +static void convertString2Integer( U08 cmd, U32 respLength ); static void prepareSetPointSeq( U16 setPoint ); static void publishBloodLeakData( void ); static void initEmbModeSpecs( void ); -static BOOL hasZeroBloodLeakBeenRequested( void ); +static void enqueueEmbModeCmd( U08 cmd ); +static U08 dequeueEmbModeCmd( void ); +static BOOL isEmbModeCmdQueueEmpty( void ); /*********************************************************************//** * @brief * The initBloodLeak function initializes the Blood Leak module. * @details Inputs: none * @details Outputs: bloodLeakState, bloodLeakStatus, bloodLeakSelfTestStatus, - * bloodLeakUARTCmdIndex, bloodLeakSetPointSequence, bloodLeakPrevFPGARegisterCount - * bloodLeakWait2ReadResponseCounter, bloodLeakDataPublicationTimerCounter, - * bloodLeakCommandWriteTryCount, bloodLeakGetCalStartTime, bloodLeakEmbModeSubstate - * bloodLeakIsPOSTComplete, bloodLeakPersistenceCtr, bloodLeakSignalEmbModeReq, + * bloodLeakUARTCmdIndex, bloodLeakSetPointSequence + * bloodLeakDataPublicationTimerCounter, bloodLeakEmbModeHasZeroBeenRqustd + * bloodLeakEmbModeSubstate + * bloodLeakPersistenceCtr, bloodLeakSignalEmbModeReq, * bloodLeakEmbModeRqstedCmd, bloodLeakEmbModeOpsStartTime, bloodLeakEmbModeRespBuffer, * bloodLeakEmbModeRespIndex, bloodLeakExitNormalRequested, * bloodLeakEmbModeCmdSeqLength, bloodLeakEmbModeHasRxRqstBeenSent * @return none *************************************************************************/ void initBloodLeak( void ) { + // Initialize the embedded mode specifications + initEmbModeSpecs(); + bloodLeakDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; bloodLeakState = BLOOD_LEAK_WAIT_FOR_POST_STATE; bloodLeakStatus.data = BLOOD_LEAK_NOT_DETECTED; @@ -245,133 +213,109 @@ bloodLeakSelfTestStatus = SELF_TEST_STATUS_IN_PROGRESS; bloodLeakUARTCmdIndex = 0; bloodLeakSetPointSeqLength = 0; - bloodLeakWait2ReadResponseCounter = 0; - bloodLeakCommandWriteTryCount = 0; - bloodLeakGetCalStartTime = getMSTimerCount(); - bloodLeakIsPOSTComplete = FALSE; - bloodLeakPrevFPGARegisterCount = 0; bloodLeakPersistenceCtr = 0; bloodLeakSignalEmbModeReq = FALSE; bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; - bloodLeakEmbModeSubstate = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; + bloodLeakEmbModeSubstate = BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMAND_STATE; bloodLeakEmbModeOpsStartTime = 0; bloodLeakEmbModeRespIndex = 0; bloodLeakExitNormalRequested = FALSE; bloodLeakEmbModeCmdSeqLength = 0; bloodLeakEmbModeHasRxRqstBeenSent = FALSE; + bloodLeakEmbModeCmdQFrontIndex = 0; + bloodLeakEmbModeCmdQRearIndex = 0; + bloodLeakEmbModeCmdQCount = 0; + bloodLeakEmbModeHasZeroBeenRqustd = FALSE; + // Set the blood leak embedded mode command queue to zero + memset( bloodLeakEmbModeCmdQ, 0x0, BLOOD_LEAK_EMB_MODE_CMD_Q_MAX_SIZE ); + // 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 embedded mode command sequence - memset( bloodLeakEmbModeCmdSquence, 0x0, BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); + memset( bloodLeakEmbModeCmdSeq, 0x0, BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); - // Initialize the embedded mode specifications - initEmbModeSpecs(); + // Enqueue the commands to set the embedded mode and request the set point of the blood leak sensor + enqueueEmbModeCmd( CS_EMB_MODE_CMD ); + enqueueEmbModeCmd( D_EMB_MODE_CMD ); } /*********************************************************************//** * @brief * The execBloodLeak function executes the blood leak detector driver. - * @details Inputs: bloodLeakGetCalStartTime, bloodLeakSignalEmbeddedModeReq - * @details Outputs: bloodLeakStatus, bloodLeakGetCalStartTime + * @details Inputs: bloodLeakState + * @details Outputs: bloodLeakCalRecord, bloodLeakState * @return none *************************************************************************/ void execBloodLeak( void ) { - // Check if there is a new calibration data available and whether there has been sufficient time elapsed from the last data calibration get - // The elapsed time is used to make sure the prepare buffer is not called several time when the new calibration signal is TRUE for one second - // otherwise, the prepareSetPointSeq is called multiple time and zeros the start index. In the mean time, the state might have changed to set - // the set point and with the start index being reset to 0, it keeps sending the first character of the set point ('S'). - if ( ( TRUE == isNewCalibrationRecordAvailable() ) && ( calcTimeSince( bloodLeakGetCalStartTime ) > BLOOD_LEAK_MIN_WAIT_TIME_2_GET_CAL_MS ) ) + if ( TRUE == isNewCalibrationRecordAvailable() ) { U32 length = sizeof( HD_BLOOD_LEAK_SENSOR_CAL_RECORD_T ); getNVRecord2Driver( GET_CAL_BLOOD_LEAK_SENSOR, (U08*)&bloodLeakCalRecord, length, 0, ALARM_ID_HD_BLOOD_LEAK_INVALID_CAL_RECORD ); - prepareSetPointSeq( bloodLeakCalRecord.setPoint ); - - // Force the state machine to go back to set the set point that has been received from - // the calibration data - bloodLeakState = BLOOD_LEAK_SET_SET_POINT_STATE; - - // Set the calibration start time to make sure the prepare buffer is not set multiple times in a row - bloodLeakGetCalStartTime = getMSTimerCount(); } - // If a request to transition to embedded mode has been made, change the state to calibration state, and request a transition to service mode. - // This type of work can only be done in the service mode and then the user has to restart the device to return to the normal operations of BLD. - if ( TRUE == bloodLeakSignalEmbModeReq ) + switch( bloodLeakState ) { - bloodLeakState = BLOOD_LEAK_CALIBRATION_STATE; + case BLOOD_LEAK_WAIT_FOR_POST_STATE: + bloodLeakState = handleBloodLeakWaitForPostState(); + break; - requestNewOperationMode( MODE_SERV ); - } + case BLOOD_LEAK_CHECK_SET_POINT_STATE: + bloodLeakState = handleBloodLeakCheckSetPointState(); + break; - // Check if the mode is not in init and then run the sensor - if ( getCurrentOperationMode() != MODE_INIT ) - { - switch( bloodLeakState ) - { - case BLOOD_LEAK_WAIT_FOR_POST_STATE: - bloodLeakState = handleBloodLeakWaitForPostState(); - break; + case BLOOD_LEAK_INIT_STATE: + bloodLeakState = handleBloodLeakInitState(); + break; - case BLOOD_LEAK_START_UP_STATE: - bloodLeakState = handleBloodLeakStartupState(); - break; + case BLOOD_LEAK_CHECK_ZERO_AND_SELF_TEST_STATE: + bloodLeakState = handleBloodLeakCheckZeroAndSelfTestState(); + break; - case BLOOD_LEAK_CHECK_COMM_STATE: - bloodLeakState = handleBloodLeakCheckCommState(); - break; + case BLOOD_LEAK_NORMAL_STATE: + bloodLeakState = handleBloodLeakNormalState(); + break; - case BLOOD_LEAK_CHECK_SET_POINT_STATE: - bloodLeakState = handleBloodLeakCheckSetPointState(); - break; + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_BLOOD_LEAK_STATE, bloodLeakState ) + bloodLeakState = BLOOD_LEAK_INIT_STATE; + break; + } - case BLOOD_LEAK_SET_SET_POINT_STATE: - bloodLeakState = handleBloodLeakSetSetPointState(); - break; + // Publish blood leak data if due + publishBloodLeakData(); +} - case BLOOD_LEAK_INIT_STATE: - bloodLeakState = handleBloodLeakInitState(); - break; +/*********************************************************************//** + * @brief + * The execBloodLeakEmbModeCommand function executes the blood leak embedded + * mode command. + * @details Inputs: bloodLeakEmbModeSubstate + * @details Outputs: bloodLeakEmbModeSubstate + * @return none + *************************************************************************/ +void execBloodLeakEmbModeCommand( void ) +{ + switch ( bloodLeakEmbModeSubstate ) + { + case BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMAND_STATE: + bloodLeakEmbModeSubstate = handleBloodLeakEmbModeWaitForCommandState(); + break; - case BLOOD_LEAK_PREP_FOR_ZERO_CMD_STATE: - bloodLeakState = handleBloodLeakPrepForZeroCmdState(); - break; + case BLOOD_LEAK_EMB_MODE_SEND_COMMAND_STATE: + bloodLeakEmbModeSubstate = handleBloodLeakEmbModeSendCommandState(); + 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; - - case BLOOD_LEAK_NORMAL_STATE: - bloodLeakState = handleBloodLeakNormalState(); - break; - - case BLOOD_LEAK_CALIBRATION_STATE: - bloodLeakState = handleBloodLeakCalibrationState(); - break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_BLOOD_LEAK_STATE, bloodLeakState ) - bloodLeakState = BLOOD_LEAK_INIT_STATE; - break; - } + case BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMMAND_RESPONSE_STATE: + bloodLeakEmbModeSubstate = handleBloodLeakEmbModeWaitForCommandResponseState(); + break; } - - // Publish blood leak data if due - publishBloodLeakData(); } /*********************************************************************//** @@ -384,8 +328,14 @@ *************************************************************************/ void zeroBloodLeak( void ) { - bloodLeakGPIOCmd.cmdZeroRequested = TRUE; - bloodLeakUARTCmdIndex = 0; + bloodLeakEmbModeHasZeroBeenRqustd = TRUE; + + // Enqueue the zero and self test sequence (Z->G->Z->Q->T) + enqueueEmbModeCmd( Z_EMB_MODE_CMD ); + enqueueEmbModeCmd( G_EMB_MODE_CMD ); + enqueueEmbModeCmd( Z_EMB_MODE_CMD ); + enqueueEmbModeCmd( Q_EMB_MODE_CMD ); + enqueueEmbModeCmd( T_EMB_MODE_CMD ); } /*********************************************************************//** @@ -421,8 +371,7 @@ if ( TRUE == calStatus ) { - result = SELF_TEST_STATUS_PASSED; - bloodLeakIsPOSTComplete = TRUE; + result = SELF_TEST_STATUS_PASSED; } else { @@ -436,139 +385,72 @@ * @brief * The handleBloodLeakWaitForPostState function handles the wait for POST * state of the of blood leak state machine. - * @details Inputs: bloodLeakIsPOSTComplete, bloodLeakPrevFPGARegisterCount - * @details Outputs: none + * @details Inputs: bloodLeakEmbModeCmd + * @details Outputs: bloodLeakEmbModeCmd * @return next state *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakWaitForPostState( void ) { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_WAIT_FOR_POST_STATE; + BOOL isEmbModeReady = FALSE; + U32 cmdResp = bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].commandResp; - if ( TRUE == bloodLeakIsPOSTComplete ) + if ( BLOOD_LEAK_EMB_MODE_PASS_ASCII == cmdResp ) { - // 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(); - // 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; + isEmbModeReady = TRUE; } - - return state; -} - -/*********************************************************************//** - * @brief - * The handleBloodLeakStartupState function handles the startup state of the - * of blood leak state machine. - * @details Inputs: bloodLeakUARTCmdIndex - * @details Outputs: bloodLeakUARTCmdIndex - * @return next state - *************************************************************************/ -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 ]; - - // Check if ^U index <= index <= 0 to Tx index. If the current value is either ^U or the 0 to command the FIFO to stop writing - // use the transmit function otherwise, use the UART control. - if ( ( bloodLeakUARTCmdIndex >= BLOOD_LEAK_START_FIFO_CTRL_U_INDEX ) && ( bloodLeakUARTCmdIndex <= BLOOD_LEAK_START_FIFO_STOP_INDEX ) ) + else if ( ( TRUE == bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].isCmdRespRdy ) && ( BLOOD_LEAK_EMB_MODE_FAIL_ASCII == cmdResp ) ) { - setFPGABloodLeakUARTTransmit( (U08)command ); - } - else - { - setFPGABloodLeakUARTControl( (U08)command ); - } - - // Done with writing all the commands, reset the index and transition - if ( bloodLeakUARTCmdIndex >= ( BLOOD_LEAK_STARTUP_SEQ_LENGTH - 1 ) ) - { - // Wait for the sensor to start communication - if ( ++bloodLeakWait2ReadResponseCounter > BLOOD_LEAK_WAIT_2_READ_CTRL_U ) + if ( bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].commandRetryCount < BLOOD_LEAK_EMB_MODE_MAX_NUM_CMD_TRIES ) { - bloodLeakUARTCmdIndex = 0; - state = BLOOD_LEAK_CHECK_COMM_STATE; - } - } - else - { - bloodLeakUARTCmdIndex++; - } + // Enqueue the commands to set the embedded mode and request the set point of the blood leak sensor + // Since set point was requested in the init function as well, both are requested here because we have to be + // in the embedded mode first + enqueueEmbModeCmd( CS_EMB_MODE_CMD ); + enqueueEmbModeCmd( D_EMB_MODE_CMD ); - return state; -} - -/*********************************************************************//** - * @brief - * The handleBloodLeakCheckCommState function handles the check communication - * state to ensure the sensor is communicating. - * @details Inputs: bloodLeakCommandWriteTryCount, bloodLeakPrevFPGARegisterCount - * @details Outputs: bloodLeakCommandWriteTryCount, bloodLeakPrevFPGARegisterCount - * @return next state - *************************************************************************/ -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 - BOOL isBloodLeakCommunicating = ( bloodLeakPrevFPGARegisterCount != getFPGABloodLeakRegisterCounter() ? TRUE : FALSE ); - - // The sensor is communicating move on - if ( TRUE == isBloodLeakCommunicating ) - { - state = BLOOD_LEAK_CHECK_SET_POINT_STATE; - bloodLeakCommandWriteTryCount = 0; - } - else - { - // If the sensor is not communicating, and the number of writes has not exceeded try again, otherwise alarm - if ( bloodLeakCommandWriteTryCount < BLOOD_LEAK_MAX_CTRL_U_WRITE_TRIALS ) - { - bloodLeakCommandWriteTryCount++; - - bloodLeakPrevFPGARegisterCount = getFPGABloodLeakRegisterCounter(); - state = BLOOD_LEAK_START_UP_STATE; + bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].commandRetryCount++; } else { - // TODO alarm. Should we check the BLD communications all the time like in the monitor? +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_BLOOD_LEAK_ALARM ) != SW_CONFIG_ENABLE_VALUE ) +#endif + { + activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_SENSOR_EMBEDDED_MODE_FAILURE ); + } } } + if ( ( getCurrentOperationMode() != MODE_INIT ) && ( TRUE == isEmbModeReady ) ) + { + state = BLOOD_LEAK_CHECK_SET_POINT_STATE; + } + return state; } /*********************************************************************//** * @brief * The handleBloodLeakCheckSetPointState function handles the check set point * state to ensure the set point is set correctly. - * @details Inputs: none - * @details Outputs: bloodLeakUARTCmdIndex + * @details Inputs: bloodLeakCalRecord + * @details Outputs: bloodLeakCalRecord * @return next state *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakCheckSetPointState( void ) { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_CHECK_SET_POINT_STATE; + U16 bloodLeakSetPoint = bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].commandResp; + BOOL isCommandRespReady = bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].isCmdRespRdy; - 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 - bloodLeakCalRecord.setPoint = 20; -#endif - - if ( bloodLeakSetPoint != bloodLeakCalRecord.setPoint ) + if ( ( bloodLeakSetPoint != bloodLeakCalRecord.setPoint ) && ( TRUE == isCommandRespReady ) ) { - if ( bloodLeakCommandWriteTryCount < BLOOD_LEAK_MAX_SET_POINT_WRITE_TRIALS ) + if ( bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].commandRetryCount < BLOOD_LEAK_EMB_MODE_MAX_NUM_CMD_TRIES ) { - prepareSetPointSeq( bloodLeakCalRecord.setPoint ); - bloodLeakCommandWriteTryCount++; - state = BLOOD_LEAK_SET_SET_POINT_STATE; + enqueueEmbModeCmd( D_EMB_MODE_CMD ); + + bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].commandRetryCount++; } else { @@ -580,66 +462,19 @@ } } } - else + else if ( TRUE == isCommandRespReady ) { - state = BLOOD_LEAK_INIT_STATE; - bloodLeakCommandWriteTryCount = 0; + state = BLOOD_LEAK_INIT_STATE; } return state; } /*********************************************************************//** * @brief - * The handleBloodLeakSetSetPointState function handles the set set point state. - * @details Inputs: bloodLeakUARTCmdIndex - * @details Outputs: bloodLeakUARTCmdIndex, bloodLeakSetPointSeqLength - * @return next state - *************************************************************************/ -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 ][ 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; - - // Check if the current index towards the end of the buffer which are FIFO set and FIFO reset - if( activeHighIndex > bloodLeakUARTCmdIndex ) - { - setFPGABloodLeakUARTTransmit( (U08)command ); - } - else - { - setFPGABloodLeakUARTControl( (U08)command ); - } - - bloodLeakUARTCmdIndex++; - } - else - { - if ( ++bloodLeakWait2ReadResponseCounter > BLOOD_LEAK_WAIT_2_READ_SET_POINT ) - { - bloodLeakWait2ReadResponseCounter = 0; - bloodLeakUARTCmdIndex = 0; - // Done with writing the set point - state = BLOOD_LEAK_CHECK_SET_POINT_STATE; - } - } - - return state; -} - -/*********************************************************************//** - * @brief * The handleBloodLeakInitState function handles the Blood Leak module in init * state. - * @details Inputs: none + * @details Inputs: bloodLeakEmbModeHasZeroBeenRqustd * @details Outputs: none * @return next state *************************************************************************/ @@ -648,174 +483,91 @@ BLOOD_LEAK_STATE_T state = BLOOD_LEAK_INIT_STATE; // 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() ) ) + if ( TRUE == bloodLeakEmbModeHasZeroBeenRqustd ) { - // 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(); + state = BLOOD_LEAK_CHECK_ZERO_AND_SELF_TEST_STATE; } - 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; } /*********************************************************************//** * @brief - * The handleBloodLeakZeroState function handles the Blood Leak module in zeroing - * state. - * @details Inputs: none - * @details Outputs: Blood Leak module zeroing. + * The handleBloodLeakCheckZeroAndSelfTestState function handles the blood + * leak check zero and self test state. + * @details Inputs: bloodLeakEmbModeCmd + * @details Outputs: bloodLeakEmbModeCmd * @return next state *************************************************************************/ -static BLOOD_LEAK_STATE_T handleBloodLeakZeroState( void ) +static BLOOD_LEAK_STATE_T handleBloodLeakCheckZeroAndSelfTestState( void ) { - BLOOD_LEAK_STATE_T state = BLOOD_LEAK_ZERO_STATE; - U08 bloodLeakZeroStatus = getFPGABloodLeakZeroStatus(); + U08 i; + BLOOD_LEAK_STATE_T state = BLOOD_LEAK_CHECK_ZERO_AND_SELF_TEST_STATE; + BOOL areCommandsReady = TRUE; + bloodLeakEmbModeHasZeroBeenRqustd = FALSE; - // 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 ) ) + for ( i = 0; i < NUM_OF_EMB_CMDS; i++ ) { - // Clear the zero command since it is done and clear the self test since we are getting ready to do a self test. - clearFPGABloodLeakZero(); - 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 + switch( i ) { - activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_ZERO_CMD_FAULT ); + case Z_EMB_MODE_CMD: + case G_EMB_MODE_CMD: + case Q_EMB_MODE_CMD: + case T_EMB_MODE_CMD: + // All the commands shall be processed and have data prior to checking the results + areCommandsReady &= bloodLeakEmbModeCmd[ i ].isCmdRespRdy; + break; } - // Get back to init state - state = BLOOD_LEAK_INIT_STATE; } - else + + if ( TRUE == areCommandsReady ) { - // Update the previous status with the current zero status since the low to high edge has been observed yet - bloodLeakGPIOCmd.cmdPrevStatus = bloodLeakZeroStatus; - } + // Enqueue the zero and self test sequence (Z->G->Z->Q->T) + BOOL hasCmdSqncFailed = FALSE; + BOOL hasCurrCmdFailed = FALSE; + U08 failedCmd; - return state; -} + for ( i = 0; i < NUM_OF_EMB_CMDS; i++ ) + { + switch( i ) + { + case Z_EMB_MODE_CMD: + case Q_EMB_MODE_CMD: + case T_EMB_MODE_CMD: + // Check to see if any of the command responses failed + hasCurrCmdFailed = ( BLOOD_LEAK_EMB_MODE_FAIL_ASCII == bloodLeakEmbModeCmd[ i ].commandResp ? TRUE : FALSE ); + hasCmdSqncFailed |= hasCurrCmdFailed; + failedCmd = ( TRUE == hasCurrCmdFailed ? i : NU_EMB_MODE_CMD ); + break; -/*********************************************************************//** - * @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; + case G_EMB_MODE_CMD: + // G command will return a value that has to be greater than 0 + hasCurrCmdFailed = ( bloodLeakEmbModeCmd[ i ].commandResp > 0 ? FALSE : TRUE ); + hasCmdSqncFailed |= hasCurrCmdFailed; + failedCmd = ( TRUE == hasCurrCmdFailed ? i : NU_EMB_MODE_CMD ); + break; + } + } - // 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 ) ) + if ( FALSE == hasCmdSqncFailed ) { - // 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(); + state = BLOOD_LEAK_NORMAL_STATE; } - } - 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 + else if ( bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].commandRetryCount < BLOOD_LEAK_EMB_MODE_MAX_NUM_CMD_TRIES ) { - activateAlarmNoData( ALARM_ID_HD_BLOOD_LEAK_SELF_TEST_SEND_TIMEOUT ); + // Zero sequence failed, try again + zeroBloodLeak(); } - // Self test command failed - state = BLOOD_LEAK_INIT_STATE; - } - - return state; -} - -/*********************************************************************//** - * @brief - * The handleBloodLeakSelfTestState function handles the Blood Leak module - * in self-test state. - * @details Inputs: none - * @details Outputs: Blood Leak module self test. - * @return next state - *************************************************************************/ -static BLOOD_LEAK_STATE_T handleBloodLeakSelfTestState( void ) -{ - BLOOD_LEAK_STATE_T state = BLOOD_LEAK_SELF_TEST_STATE; - U08 bloodLeakSelfTestStatus = getFPGABloodLeakStatus(); - - // 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 ) ) - { - // 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 ) ) - { + else + { #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_SELF_TEST_FAULT ); + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_BLOOD_LEAK_SENSOR_ZERO_SEQUENCE_FAILED, failedCmd ); + } } - // Self test failed due to timeout - state = BLOOD_LEAK_INIT_STATE; - bloodLeakSelfTestStatus = SELF_TEST_STATUS_FAILED; } - else - { - bloodLeakGPIOCmd.cmdPrevStatus = bloodLeakSelfTestStatus; - } return state; } @@ -824,24 +576,16 @@ * @brief * The handleBloodLeakNormalState function handles the Blood Leak module * in normal state. - * @details Inputs: none - * @details Outputs: Blood Leak module normal. + * @details Inputs: bloodLeakStatus, bloodLeakPersistenceCtr, + * bloodLeakExitNormalRequested + * @details Outputs: bloodLeakStatus, bloodLeakPersistenceCtr, + * bloodLeakExitNormalRequested, bloodLeakEmbModeHasZeroBeenRqustd * @return next state *************************************************************************/ static BLOOD_LEAK_STATE_T handleBloodLeakNormalState( void ) { BLOOD_LEAK_STATE_T state = BLOOD_LEAK_NORMAL_STATE; - // 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 ); @@ -878,50 +622,20 @@ if ( TRUE == bloodLeakExitNormalRequested ) { - state = BLOOD_LEAK_INIT_STATE; bloodLeakExitNormalRequested = FALSE; + state = BLOOD_LEAK_INIT_STATE; } - else if ( TRUE == hasZeroBloodLeakBeenRequested() ) + else if ( TRUE == bloodLeakEmbModeHasZeroBeenRqustd ) { // 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; + state = BLOOD_LEAK_CHECK_ZERO_AND_SELF_TEST_STATE; } return state; } /*********************************************************************//** * @brief - * The handleBloodLeakCalibrationState function handles the Blood leak - * calibration state. - * @details Inputs: bloodLeakCalSubstate - * @details Outputs: bloodLeakCalSubstate - * @return next state - *************************************************************************/ -static BLOOD_LEAK_STATE_T handleBloodLeakCalibrationState( void ) -{ - BLOOD_LEAK_STATE_T state = BLOOD_LEAK_CALIBRATION_STATE; - - switch ( bloodLeakEmbModeSubstate ) - { - case BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE: - bloodLeakEmbModeSubstate = handleCalBloodLeakWaitForCommandState(); - break; - - case BLOOD_LEAK_CAL_SEND_COMMAND_STATE: - bloodLeakEmbModeSubstate = handleCalBloodLeakSendCommandState(); - break; - - case BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE: - bloodLeakEmbModeSubstate = handleCalBloodLeakWaitForCommandResponseState(); - break; - } - - return state; -} - -/*********************************************************************//** - * @brief * The getBloodLeakStatus function gets the current reading for the blood * leak detector. * @details Inputs: bloodLeakStatus @@ -962,88 +676,99 @@ /*********************************************************************//** * @brief - * The handleCalBloodLeakWaitForCommandState function handles the wait for + * The handleBloodLeakEmbModeWaitForCommandState function handles the wait for * command state. The state prepares the message to be sent to the blood leak * sensor. - * @details Inputs: bloodLeakCalCharacter - * @details Outputs: bloodLeakCalCommandSquence, bloodLeakUARTCmdIndex + * @details Inputs: bloodLeakEmbModeRqstedCmd, bloodLeakEmbModeCmd + * @details Outputs: bloodLeakEmbModeRqstedCmd, bloodLeakEmbModeCmdSeq, + * bloodLeakUARTCmdIndex, bloodLeakEmbModeRespIndex, bloodLeakEmbModeCmdSeqLength, + * bloodLeakEmbModeOpsStartTime, bloodLeakEmbModeSetPoint, bloodLeakEmbModeRespBuffer * @return next state *************************************************************************/ -static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandState( void ) +static BLOOD_LEAK_EMB_MODE_STATE_T handleBloodLeakEmbModeWaitForCommandState( void ) { - BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; - U08 command = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].commandASCII; + BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMAND_STATE; - switch( bloodLeakEmbModeRqstedCmd ) + if ( FALSE == isEmbModeCmdQueueEmpty() ) { - case NU_EMB_MODE_CMD: - // Null command do nothing - break; + bloodLeakEmbModeRqstedCmd = dequeueEmbModeCmd(); + U08 commandASCII = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].commandASCII; - 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; + switch( bloodLeakEmbModeRqstedCmd ) + { + case NU_EMB_MODE_CMD: + // Null command do nothing + break; - // 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 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( bloodLeakEmbModeCmdSeq, 0x0, 2 * BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); - 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; + // Set the command sequence + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_RESET_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_RESET; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_RESET_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_RESET_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_RESET_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_CMD_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = commandASCII; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_CMD_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_STOP_WRITE_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_STOP_WRITE_FIFO_COMMAND; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_STOP_WRITE_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = FALSE; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_HIGH; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_ACTIVE_HIGH_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + + // Set the variables for the next state + bloodLeakUARTCmdIndex = 0; + bloodLeakEmbModeRespIndex = 0; + bloodLeakEmbModeCmdSeqLength = BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH; + bloodLeakEmbModeOpsStartTime = getMSTimerCount(); + state = BLOOD_LEAK_EMB_MODE_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_EMB_MODE_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( bloodLeakEmbModeCmdSeq, 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; } /*********************************************************************//** * @brief - * The handleCalBloodLeakSendCommandState function handles the send command - * state. The state sends the command sequence to the blood leak sensor one by - * one. - * @details Inputs: bloodLeakCalCharacter, bloodLeakUARTCmdIndex - * @details Outputs: bloodLeakCalCommandSquence, bloodLeakUARTCmdIndex + * The handleBloodLeakEmbModeSendCommandState function handles the send command + * state. The state sends the command sequence to the blood leak sensor one by one. + * @details Inputs: bloodLeakEmbModeRqstedCmd, bloodLeakCalCharacter, bloodLeakUARTCmdIndex + * bloodLeakEmbModeCmdSeqLength + * @details Outputs: bloodLeakEmbModeRqstedCmd, bloodLeakCalCommandSquence, + * bloodLeakUARTCmdIndex, bloodLeakEmbModeCmdSeqLength, bloodLeakEmbModeCmdSeqLength, + * bloodLeakSetPointSequence * @return next state *************************************************************************/ -static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakSendCommandState( void ) +static BLOOD_LEAK_EMB_MODE_STATE_T handleBloodLeakEmbModeSendCommandState( void ) { U08 command; - BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; + BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_EMB_MODE_SEND_COMMAND_STATE; BOOL isUARTCtrlCmd = FALSE; BOOL isUARTCtrlDone = TRUE; @@ -1058,8 +783,8 @@ case Q_EMB_MODE_CMD: case D_EMB_MODE_CMD: case C_EMB_MODE_CMD: - command = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; - isUARTCtrlCmd = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; + command = bloodLeakEmbModeCmdSeq[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; + isUARTCtrlCmd = bloodLeakEmbModeCmdSeq[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; isUARTCtrlDone = ( bloodLeakUARTCmdIndex > ( bloodLeakEmbModeCmdSeqLength - 1 ) ? TRUE : FALSE ); bloodLeakUARTCmdIndex++; break; @@ -1068,10 +793,10 @@ // 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 ] ) + if ( BLOOD_LEAK_EMB_MODE_COMM_READ_REQST == bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] ) { - command = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; - isUARTCtrlCmd = bloodLeakEmbModeCmdSquence[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; + command = bloodLeakEmbModeCmdSeq[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ]; + isUARTCtrlCmd = bloodLeakEmbModeCmdSeq[ bloodLeakUARTCmdIndex ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ]; isUARTCtrlDone = ( bloodLeakUARTCmdIndex > ( bloodLeakEmbModeCmdSeqLength - 1 ) ? TRUE : FALSE ); } else @@ -1097,33 +822,42 @@ // Check if the current index towards the end of the buffer which are FIFO set and FIFO reset if ( FALSE == isUARTCtrlDone ) { - FALSE == isUARTCtrlCmd ? setFPGABloodLeakUARTTransmit( command ) : setFPGABloodLeakUARTControl( command ); + if ( FALSE == isUARTCtrlCmd ) + { + setFPGABloodLeakUARTTransmit( command ); + } + else + { + setFPGABloodLeakUARTControl( command ); + } } else { // 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 ]; + U08 commandInIndex0 = bloodLeakEmbModeCmdSeq[ 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; + state = BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMMAND_RESPONSE_STATE; } return state; } /*********************************************************************//** * @brief - * The handleCalBloodLeakWaitForCommandResponseState function handles the + * The handleBloodLeakEmbModeWaitForCommandResponseState function handles the * wait for command responses state. The state receives data in the buffer. - * @details Inputs: bloodLeakEmbModeCmd, bloodLeakEmbModeRespIndex - * @details Outputs: bloodLeakEmbModeRespBuffer, bloodLeakEmbModeRespIndex + * @details Inputs: bloodLeakEmbModeHasRxRqstBeenSent, bloodLeakEmbModeRespBuffer, + * bloodLeakEmbModeRespIndex, bloodLeakEmbModeRqstedCmd, bloodLeakEmbModeOpsStartTime + * @details Outputs: bloodLeakEmbModeCmd, bloodLeakEmbModeRqstedCmd, + * bloodLeakEmbModeCmdSeq, bloodLeakEmbModeRespBuffer * @return next state *************************************************************************/ -static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandResponseState( void ) +static BLOOD_LEAK_EMB_MODE_STATE_T handleBloodLeakEmbModeWaitForCommandResponseState( void ) { - BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE; + BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMMAND_RESPONSE_STATE; U08 rxFIFOCount = getFPGABloodLeakRxFIFOCount(); BOOL hasCharBeenReceived = FALSE; U32 commandTimeoutMS = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].timeoutMS; @@ -1141,76 +875,83 @@ { // 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; + memset( bloodLeakEmbModeCmdSeq, 0x0, 2 * BLOOD_LEAK_EMB_MODE_CMD_SEQ_LENGTH ); + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_READ_REQST; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_CMD_COL_INDEX ] = BLOOD_LEAK_EMB_MODE_COMM_ACTIVE_LOW; + bloodLeakEmbModeCmdSeq[ BLOOD_LEAK_EMB_MODE_REQUEST_RX_INDEX + 1 ][ BLOOD_LEAK_EMB_MODE_IS_UART_COL_INDEX ] = TRUE; // Set the variables for the next state bloodLeakUARTCmdIndex = 0; bloodLeakEmbModeCmdSeqLength = BLOOD_LEAK_EMB_MODE_RQST_RX_LENGTH; - state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; + state = BLOOD_LEAK_EMB_MODE_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 == hasCharBeenReceived ) + if ( ( TRUE == hasCharBeenReceived ) && ( bloodLeakEmbModeRespIndex >= length ) ) { - if ( bloodLeakEmbModeRespIndex >= length ) + U08 i; + BOOL isNull = FALSE; + + for ( i = 0; i < length; i++ ) { - U08 i; - BOOL isNull = FALSE; + // Loop through the elements of the buffer and make sure none of the elements are not NULL. + // The elements are checked until the specified length that is expected for a command + isNull |= ( bloodLeakEmbModeRespBuffer[ i ] != NU_EMB_MODE_CMD ? FALSE : TRUE ); + } - for ( i = 0; i < length; i++ ) - { - // Loop through the elements of the buffer and make sure none of the elements are not NULL. - // The elements are checked until the specified length that is expected for a command - isNull |= ( bloodLeakEmbModeRespBuffer[ i ] != NU_EMB_MODE_CMD ? FALSE : TRUE ); - } + // Check if the failed command is Control S which is switch to embedded mode and if + // 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 ); - // Check if the failed command is Control S which is switch to embedded mode and if - // 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 ) + { + // 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 ); - if ( TRUE == isNull ) - { - // 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 if ( CS_EMB_MODE_CMD == bloodLeakEmbModeRqstedCmd ) - { - 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 ); - } + length = 1; + bloodLeakEmbModeRespBuffer[ 0 ] = BLOOD_LEAK_EMB_MODE_FAIL_ASCII; + } + else if ( CS_EMB_MODE_CMD == bloodLeakEmbModeRqstedCmd ) + { + memset( bloodLeakEmbModeRespBuffer, 0x0, BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN ); - // Done with receiving the data - bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; - state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; - handleSendBloodLeakEmbeddedModeCommandResponse( length, bloodLeakEmbModeRespBuffer ); + 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 ); + } + + convertString2Integer( bloodLeakEmbModeRqstedCmd, length ); + + // Done with receiving the data + bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; + state = BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMAND_STATE; + + sendBloodLeakEmbeddedModeCommandResponse( 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 ); + + convertString2Integer( bloodLeakEmbModeRqstedCmd, length ); + + bloodLeakEmbModeRqstedCmd = NU_EMB_MODE_CMD; + state = BLOOD_LEAK_EMB_MODE_WAIT_FOR_COMAND_STATE; + + sendBloodLeakEmbeddedModeCommandResponse( length, bloodLeakEmbModeRespBuffer ); } return state; @@ -1289,6 +1030,51 @@ /*********************************************************************//** * @brief + * The convertString2Integer function converts the buffer of the answers in + * string (ASCII) to integer. + * @details Inputs: bloodLeakEmbModeCmd + * @details Outputs: bloodLeakEmbModeRespBuffer, bloodLeakEmbModeCmd + * @param cmd which is the embedded mode command + * @param respLength the length of the received response from the sensor + * @return none + *************************************************************************/ +static void convertString2Integer( U08 cmd, U32 respLength ) +{ + if ( 1 == respLength ) + { + bloodLeakEmbModeCmd[ cmd ].commandResp = bloodLeakEmbModeRespBuffer[ 0 ]; + } + else + { + U08 i; + U32 bufferValue; + U32 respExpectedLength = bloodLeakEmbModeCmd[ cmd ].length; + // Reset the command response + bloodLeakEmbModeCmd[ cmd ].commandResp = 0; + + for ( i = 0; i < respExpectedLength; i++ ) + { + // The last value is inserted into the response buffer (i.e. S030) + // So the buffer array is used from the last element of the array + bufferValue = bloodLeakEmbModeRespBuffer[ respExpectedLength - 1 - i ]; + + if ( ( bufferValue >= BLOOD_LEAK_EMB_MODE_0_NUM_ASCII ) && ( bufferValue <= BLOOD_LEAK_EMB_MODE_9_NUM_ASCII ) ) + { + // If the value in the response buffer is within the ASCII values of 0 (ASCII 48) to 9 (ASCII 57) then it is a number and needs to be converted to integer + // Subtract the buffer value from ASCII 48 to get the offset (i.e. buffer = 50 - 48 = 2) + // Add the offset value to the command response in the right order (i.e. if i = 1, then it is 2 x 10 ^1 = 20) + bufferValue -= BLOOD_LEAK_EMB_MODE_0_NUM_ASCII; + bloodLeakEmbModeCmd[ cmd ].commandResp += ( bufferValue * pow( 10, i ) ); + } + } + } + + // Set the command response ready + bloodLeakEmbModeCmd[ cmd ].isCmdRespRdy = TRUE; +} + +/*********************************************************************//** + * @brief * The prepareSetPointSeq function prepares the set point sequence to be * written to the blood leak sensor. * @details Inputs: none @@ -1376,6 +1162,7 @@ if ( ++bloodLeakDataPublicationTimerCounter >= getU32OverrideValue( &bloodLeakDataPublishInterval ) ) { BLOOD_LEAK_DATA_T data; + data.bloodLeakStatus = (U32)getBloodLeakStatus(); data.bloodLeakState = (U32)bloodLeakState; data.bloodLeakZeroStatusCounter = (U32)getFPGABloodLeakZeroStatusCounter(); @@ -1408,102 +1195,165 @@ bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].expChar2 = NU_EMB_MODE_CMD; bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].length = 0; bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].timeoutMS = 0; + bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ NU_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // Set point command bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].commandASCII = 83; // ASCII for S 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; + bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ SP_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ T_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ G_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ I_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ V_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ Z_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ Q_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ D_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].isCmdRespRdy = FALSE; // 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; + bloodLeakEmbModeCmd[ C_EMB_MODE_CMD ].commandResp = 0; + bloodLeakEmbModeCmd[ CS_EMB_MODE_CMD ].isCmdRespRdy = FALSE; } /*********************************************************************//** * @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 + * The enqueueEmbModeCmd function enqueues an embedded mode command. + * @details Inputs: none + * @details Outputs: bloodLeakEmbModeCmdQRearIndex, bloodLeakEmbModeCmdQCount + * bloodLeakEmbModeCmdQ, bloodLeakEmbModeCmd + * @return none *************************************************************************/ -static BOOL hasZeroBloodLeakBeenRequested( void ) +static void enqueueEmbModeCmd( U08 cmd ) { - BOOL status = FALSE; + // Enqueue the command and increment the rear embedded mode index + // Set the command response to be false so the command was just queued to be read + bloodLeakEmbModeCmdQ[ bloodLeakEmbModeCmdQRearIndex ] = cmd; + bloodLeakEmbModeCmdQRearIndex = INC_WRAP( bloodLeakEmbModeCmdQRearIndex, 0, BLOOD_LEAK_EMB_MODE_CMD_Q_MAX_SIZE - 1 ); + bloodLeakEmbModeCmd[ cmd ].isCmdRespRdy = FALSE; + bloodLeakEmbModeCmdQCount++; +} - if ( TRUE == bloodLeakGPIOCmd.cmdZeroRequested ) +/*********************************************************************//** + * @brief + * The dequeueEmbModeCmd function dequeues the embedded mode command. + * @details Inputs: none + * @details Outputs: bloodLeakEmbModeCmdQFrontIndex, bloodLeakEmbModeCmdQCount + * @return command that is dequeued + *************************************************************************/ +static U08 dequeueEmbModeCmd( void ) +{ + U08 command; + U08 tempIndex; + + _disable_IRQ(); + tempIndex = bloodLeakEmbModeCmdQFrontIndex; + + if ( FALSE == isEmbModeCmdQueueEmpty() ) { - status = TRUE; - bloodLeakGPIOCmd.cmdZeroRequested = FALSE; - bloodLeakGPIOCmd.cmdStartTimeMS = getMSTimerCount(); - clearFPGABloodLeakZero(); + bloodLeakEmbModeCmdQFrontIndex = INC_WRAP( bloodLeakEmbModeCmdQFrontIndex, 0, BLOOD_LEAK_EMB_MODE_CMD_Q_MAX_SIZE - 1 ); + command = bloodLeakEmbModeCmdQ[ tempIndex ]; + bloodLeakEmbModeCmdQCount--; } + _enable_IRQ(); - return status; + return command; } +/*********************************************************************//** + * @brief + * The isEmbModeCmdQueueEmpty function checks whether the embedded mode command + * queue is empty or not. + * @details Inputs: bloodLeakEmbModeCmdQCount + * @details Outputs: none + * @return TRUE if the queue is empty otherwise, FALSE + *************************************************************************/ +static BOOL isEmbModeCmdQueueEmpty( void ) +{ + BOOL isEmpty = TRUE; + if ( bloodLeakEmbModeCmdQCount > 0 ) + { + isEmpty = FALSE; + } + + return isEmpty; +} + + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -1638,8 +1488,8 @@ * @brief * The testSetBloodLeakEmbeddedModeCommand function sets the blood leak * calibration command. - * @details Inputs: bloodLeakSignalEmbeddedModeReq, bloodLeakCalSubstate - * @details Outputs: bloodLeakCalASCIIChar + * @details Inputs: none + * @details Outputs: bloodLeakEmbModeSetPoint * @param command the command ID to be sent to blood leak in embedded mode * @param setpointPayload the set point value that is sent with the set point * command. This value is 0 with other commands since they do not have a payload @@ -1651,14 +1501,10 @@ if ( ( TRUE == isTestingActivated() ) && ( command < NUM_OF_EMB_CMDS ) ) { - // If the HD is already in service mode and in the blood leak is in the embedded mode and the sensor is waiting for another command - if ( ( MODE_SERV == getCurrentOperationMode() ) && ( TRUE == bloodLeakSignalEmbModeReq ) && - ( BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE == bloodLeakEmbModeSubstate ) ) - { - bloodLeakEmbModeRqstedCmd = command; - bloodLeakEmbModeSetPoint = setPointPayload; - result = TRUE; - } + enqueueEmbModeCmd( command ); + + bloodLeakEmbModeSetPoint = setPointPayload; + result = TRUE; } return result;