Index: firmware/App/Controllers/BloodLeak.c =================================================================== diff -u -r208ceefa8e8b1cc30feb93be771ced6d313e6995 -rea3922a0b9f1cec5becaa26e2ba5f34ab4579209 --- firmware/App/Controllers/BloodLeak.c (.../BloodLeak.c) (revision 208ceefa8e8b1cc30feb93be771ced6d313e6995) +++ firmware/App/Controllers/BloodLeak.c (.../BloodLeak.c) (revision ea3922a0b9f1cec5becaa26e2ba5f34ab4579209) @@ -68,7 +68,7 @@ #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_RX_BUFFER_EMPTY 0x80 ///< Blood leak embedded mode buffer empty value. -#define BLOOD_LEAK_EMB_MODE_NUM_OF_CMDS 10 // TODO remove ///< Blood leak embedded mode number of commands. +#define BLOOD_LEAK_EMB_MODE_RESP_BUFFER_LEN 5 ///< Blood leak embedded mode number of commands. /// Defined states for the blood leak detector state machine. typedef enum BloodLeakStates @@ -91,12 +91,13 @@ { 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_EMB_WAIT_FOR_COMMAND_TO_SETTLE_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_STATE_T; /// Defined embedded commands -typedef enum EmbCommands +/*typedef enum EmbCommands { NU = 0, ///< Null command. CS = 19, ///< Control S command to switch to embedded mode. @@ -110,15 +111,32 @@ D = 68, ///< Display blood detection command. C = 67, ///< Calibration sensor command. NUM_OF_EMB_CMDS, ///< Number of embedded mode commands. -} EMB_MODE_CMD_T; +} EMB_MODE_CMD_T;*/ -/// +enum EmbCommands +{ + NU = 0, ///< Null command. + CS, ///< Control S command to switch to embedded mode. + SP, ///< Set point command to set the set point. + T, ///< Self test command. + G, ///< Get self test command. + I, ///< Intensity command. + V, ///< Blood detection level command. + Z, ///< Zero sensor command. + Q, ///< Zero sensor confirm command. + D, ///< Display blood detection command. + C, ///< Calibration sensor command. + NUM_OF_EMB_CMDS, ///< Number of embedded mode commands. +}; + +/// Embedded mode commands specifications typedef struct { + U08 commandASCII; U08 expChar1; U08 expChar2; U08 length; -}; +} EMB_MODE_CMD_T; // ********** private data ********** @@ -154,11 +172,14 @@ BLOOD_LEAK_UART_COMM_ACTIVE_LOW }; // Embedded mode variables static BOOL bloodLeakSignalEmbModeReq; ///< Blood leak signal embedded mode has been requested. -static EMB_MODE_CMD_T bloodLeakEmbModeASCIICmd; ///< Blood leak signal embedded mode ASCII command. +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 BLOOD_LEAK_EMB_MODE_STATE_T bloodLeakEmbModeSubstate; ///< Blood leak embedded mode state. -static U32 bloodLeakEmbModeRxTimeout; ///< Blood leak embedded mode receive timeout. +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. // ********** private function prototypes ********** @@ -175,10 +196,12 @@ 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 handleCalBloodLeakWaitForCommandToSettleState( void ); static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandResponseState( void ); static void prepareSetPointSeq( U16 setPoint ); static void publishBloodLeakData( void ); +static void initEmbModeSpecs( void ); /*********************************************************************//** * @brief @@ -190,7 +213,8 @@ * bloodLeakWait2ReadResponseCounter, bloodLeakDataPublicationTimerCounter, * bloodLeakCommandWriteTryCount, bloodLeakGetCalStartTime, bloodLeakEmbModeSubstate * bloodLeakIsPOSTComplete, bloodLeakPersistenceCtr, bloodLeakSignalEmbModeReq, - * bloodLeakEmbModeASCIICmd, bloodLeakEmbModeRxTimeout + * bloodLeakEmbModeRqstedCmd, bloodLeakEmbModeOpsStartTime, bloodLeakEmbModeRespBuffer, + * bloodLeakEmbModeRespIndex * @return none *************************************************************************/ void initBloodLeak( void ) @@ -214,20 +238,27 @@ bloodLeakPrevFPGARegisterCount = 0; bloodLeakPersistenceCtr = 0; bloodLeakSignalEmbModeReq = FALSE; - bloodLeakEmbModeASCIICmd = NU; + bloodLeakEmbModeRqstedCmd = NU; bloodLeakEmbModeSubstate = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; - bloodLeakEmbModeRxTimeout = 0; + bloodLeakEmbModeOpsStartTime = 0; + bloodLeakEmbModeRespIndex = 0; // 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 reset 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 embedded mode specifications + initEmbModeSpecs(); } /*********************************************************************//** @@ -747,6 +778,10 @@ bloodLeakEmbModeSubstate = handleCalBloodLeakSendCommandState(); break; + case BLOOD_LEAK_EMB_WAIT_FOR_COMMAND_TO_SETTLE_STATE: + bloodLeakEmbModeSubstate = handleCalBloodLeakWaitForCommandToSettleState(); + break; + case BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE: bloodLeakEmbModeSubstate = handleCalBloodLeakWaitForCommandResponseState(); break; @@ -808,7 +843,7 @@ { BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; - switch( bloodLeakEmbModeASCIICmd ) + switch( bloodLeakEmbModeRqstedCmd ) { case NU: // Null command do nothing @@ -825,7 +860,7 @@ case C: // 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 ] = bloodLeakEmbModeASCIICmd; + bloodLeakEmbModeCmdSquence[ 0 ] = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].commandASCII; bloodLeakUARTCmdIndex = 0; state = BLOOD_LEAK_CAL_SEND_COMMAND_STATE; break; @@ -856,7 +891,7 @@ BOOL isUARTTxDone = FALSE; BOOL isUARTCtrlDone = TRUE; - switch ( bloodLeakEmbModeASCIICmd ) + switch ( bloodLeakEmbModeRqstedCmd ) { case CS: case T: @@ -905,15 +940,30 @@ else { // Reset the variables for the next - bloodLeakEmbModeRxTimeout = getMSTimerCount(); - bloodLeakEmbModeASCIICmd = NU; - bloodLeakUARTCmdIndex = 0; - state = BLOOD_LEAK_CAL_WAIT_FOR_COMMAND_RESPONSE_STATE; + bloodLeakEmbModeOpsStartTime = getMSTimerCount(); + state = BLOOD_LEAK_EMB_WAIT_FOR_COMMAND_TO_SETTLE_STATE; } return state; } +static BLOOD_LEAK_EMB_MODE_STATE_T handleCalBloodLeakWaitForCommandToSettleState( void ) +{ + BLOOD_LEAK_EMB_MODE_STATE_T state = BLOOD_LEAK_EMB_WAIT_FOR_COMMAND_TO_SETTLE_STATE; + + if ( TRUE == didTimeout( bloodLeakEmbModeOpsStartTime, 20 ) ) + { + 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 ); + } + + return state; +} + /*********************************************************************//** * @brief * The handleCalBloodLeakWaitForCommandResponseState function handles the @@ -929,16 +979,56 @@ if ( rxFIFOCount > 0 ) { - U08 data = getFPGABloodLeakRxFIFODataOut(); + /* + * 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 data = getFPGABloodLeakRxFIFODataOut(); + U08 expChar1 = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar1; + U08 expChar2 = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].expChar2; + U08 length = bloodLeakEmbModeCmd[ bloodLeakEmbModeRqstedCmd ].length; + if ( ( expChar1 != NU ) && ( NU == expChar2 ) ) + { + if ( bloodLeakEmbModeRespIndex < length ) + { + if ( ( expChar1 == data ) && ( 0 == bloodLeakEmbModeRespIndex ) ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + + bloodLeakEmbModeRespIndex++; + } + else if ( bloodLeakEmbModeRespIndex > 0 ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + + bloodLeakEmbModeRespIndex++; + } + } + } + else if ( ( expChar1 != NU ) && ( expChar2 != NU ) ) + { + if ( bloodLeakEmbModeRespIndex < length ) + { + if ( ( expChar1 == data ) || ( expChar2 == data ) ) + { + bloodLeakEmbModeRespBuffer[ bloodLeakEmbModeRespIndex ] = data; + + bloodLeakEmbModeRespIndex++; + } + } + } + BOOL test = FALSE; } // 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( bloodLeakEmbModeRxTimeout, BLOOD_LEAK_EMB_MODE_RX_TIMEOUT_MS ) ) || ( BLOOD_LEAK_EMB_MODE_RX_BUFFER_EMPTY == rxFIFOCount ) ) + if ( ( TRUE == didTimeout( bloodLeakEmbModeOpsStartTime, BLOOD_LEAK_EMB_MODE_RX_TIMEOUT_MS ) ) || ( BLOOD_LEAK_EMB_MODE_RX_BUFFER_EMPTY == rxFIFOCount ) ) { - state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; + bloodLeakEmbModeRqstedCmd = NU; + state = BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE; } return state; @@ -1036,7 +1126,73 @@ } } +/*********************************************************************//** + * @brief + * The initEmbModeSpecs function initializes the embedded mode specifications + * structure. + * @details Inputs: bloodLeakEmbModeCmd + * @details Outputs: bloodLeakEmbModeCmd + * @return none + *************************************************************************/ +static void initEmbModeSpecs( void ) +{ + bloodLeakEmbModeCmd[ NU ].commandASCII = 0; + bloodLeakEmbModeCmd[ NU ].expChar1 = 0; + bloodLeakEmbModeCmd[ NU ].expChar2 = 0; + bloodLeakEmbModeCmd[ NU ].length = 0; + bloodLeakEmbModeCmd[ CS ].commandASCII = 19; + bloodLeakEmbModeCmd[ CS ].expChar1 = 69; // ASCII for E (Embedded ...) + bloodLeakEmbModeCmd[ CS ].expChar2 = NU; + bloodLeakEmbModeCmd[ CS ].length = 5; + + bloodLeakEmbModeCmd[ SP ].commandASCII = 83; + bloodLeakEmbModeCmd[ SP ].expChar1 = 88; // ASCII for X (Timeout) + bloodLeakEmbModeCmd[ SP ].expChar2 = 70; // ASCII for F (Fail) + bloodLeakEmbModeCmd[ SP ].length = 0; + + bloodLeakEmbModeCmd[ T ].commandASCII = 84; + bloodLeakEmbModeCmd[ T ].expChar1 = 80; // ASCII for P + bloodLeakEmbModeCmd[ T ].expChar2 = 70; // ASCII for F + bloodLeakEmbModeCmd[ T ].length = 1; + + bloodLeakEmbModeCmd[ G ].commandASCII = 71; + bloodLeakEmbModeCmd[ G ].expChar1 = 0; + bloodLeakEmbModeCmd[ G ].expChar2 = 0; + bloodLeakEmbModeCmd[ G ].length = 3; + + bloodLeakEmbModeCmd[ I ].commandASCII = 73; + bloodLeakEmbModeCmd[ I ].expChar1 = 0; + bloodLeakEmbModeCmd[ I ].expChar2 = 0; + bloodLeakEmbModeCmd[ I ].length = 3; + + bloodLeakEmbModeCmd[ V ].commandASCII = 86; + bloodLeakEmbModeCmd[ V ].expChar1 = 86; + bloodLeakEmbModeCmd[ V ].expChar2 = 0; + bloodLeakEmbModeCmd[ V ].length = 5; + + bloodLeakEmbModeCmd[ Z ].commandASCII = 90; + bloodLeakEmbModeCmd[ Z ].expChar1 = 89; // ASCII for Y + bloodLeakEmbModeCmd[ Z ].expChar2 = 0; + bloodLeakEmbModeCmd[ Z ].length = 1; + + bloodLeakEmbModeCmd[ Q ].commandASCII = 81; + bloodLeakEmbModeCmd[ Q ].expChar1 = 80; // ASCII for P + bloodLeakEmbModeCmd[ Q ].expChar2 = 70; // ASCII for F + bloodLeakEmbModeCmd[ Q ].length = 1; + + bloodLeakEmbModeCmd[ D ].commandASCII = 68; + bloodLeakEmbModeCmd[ D ].expChar1 = 68; // ASCII for D + bloodLeakEmbModeCmd[ D ].expChar2 = 0; + bloodLeakEmbModeCmd[ D ].length = 5; + + bloodLeakEmbModeCmd[ C ].commandASCII = 67; + bloodLeakEmbModeCmd[ C ].expChar1 = 67; // ASCII for C + bloodLeakEmbModeCmd[ C ].expChar2 = 0; + bloodLeakEmbModeCmd[ C ].length = 4; +} + + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -1160,7 +1316,7 @@ if ( ( MODE_FAUL == mode ) || ( MODE_SERV == mode ) || ( MODE_STAN == mode ) ) { bloodLeakSignalEmbModeReq = TRUE; - bloodLeakEmbModeASCIICmd = CS; + bloodLeakEmbModeRqstedCmd = CS; result = TRUE; } } @@ -1186,7 +1342,7 @@ if ( ( MODE_SERV == getCurrentOperationMode() ) && ( TRUE == bloodLeakSignalEmbModeReq ) && ( BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE == bloodLeakEmbModeSubstate ) ) { - bloodLeakEmbModeASCIICmd = (EMB_MODE_CMD_T)command; + bloodLeakEmbModeRqstedCmd = command; } } @@ -1211,7 +1367,7 @@ if ( ( MODE_SERV == getCurrentOperationMode() ) && ( TRUE == bloodLeakSignalEmbModeReq ) && ( BLOOD_LEAK_CAL_WAIT_FOR_COMAND_STATE == bloodLeakEmbModeSubstate ) ) { - bloodLeakEmbModeASCIICmd = SP; + bloodLeakEmbModeRqstedCmd = SP; bloodLeakEmbModeSetPoint = setPoint; } }