Index: firmware/App/Controllers/Valves.c =================================================================== diff -u -rf64e547824dbb2ade04b700b319d92206f7d0b6d -r62db7c6218b47db4ef80e1b528228a8887545aad --- firmware/App/Controllers/Valves.c (.../Valves.c) (revision f64e547824dbb2ade04b700b319d92206f7d0b6d) +++ firmware/App/Controllers/Valves.c (.../Valves.c) (revision 62db7c6218b47db4ef80e1b528228a8887545aad) @@ -1,9 +1,3 @@ -/* - * Valves.c - * - * Created on: Aug 7, 2020 - * Author: fw - */ #include "Valves.h" #include "FPGA.h" @@ -28,76 +22,118 @@ #define VDO_ENABLE_PID_INTERFACE 0x0040 #define VDO_ENABLE_BYPASS_INTERFACE 0x00BF +#define VDO_INITIALIZATION_STATUS_BIT_MASK 0x0200 +#define VDO_ENABLE_PID_STATUS_BIT_MASK 0x0400 +#define VDO_ENABLE_BYPASS_STATUS_BIT_MASK 0x0800 + // Valve blood arterial defines #define VBA_ENABLE_PID_INTERFACE 0x0001 #define VBA_ENABLE_BYPASS_INTERFACE 0x00FE +#define VBA_INITIALIZATION_STATUS_BIT_MASK 0x0001 +#define VBA_ENABLE_PID_STATUS_BIT_MASK 0x0002 +#define VBA_ENABLE_BYPASS_STATUS_BIT_MASK 0x0004 + // Valve blood venous defines #define VBV_ENABLE_PID_INTERFACE 0x0004 #define VBV_ENABLE_BYPASS_INTERFACE 0x00FB -#define INITIAL_OFFSET_READ_COUNT 100 -#define INITIAL_DEENERGIZED_POSITION ( 0 - INITIAL_OFFSET_READ_COUNT ) -#define INITIAL_ENERGIZED_POSITION (12000 + INITIAL_OFFSET_READ_COUNT ) +#define VBV_INITIALIZATION_STATUS_BIT_MASK 0x0008 +#define VBV_ENABLE_PID_STATUS_BIT_MASK 0x0010 +#define VBV_ENABLE_BYPASS_STATUS_BIT_MASK 0x0020 -#define MAX_ALLOWED_POSITION_DEVIATION_FROM_TARGET 100U //TODO test this tolerance -#define VALVE_TRANSITION_TIMEOUT_MS 50U //TODO test the timeout +#define INITIAL_EDGE_OFFSET_READ_COUNT 100 +#define INITIAL_DEENERGIZED_POSITION ( 0 - INITIAL_EDGE_OFFSET_READ_COUNT ) +#define INITIAL_ENERGIZED_POSITION (12000 + INITIAL_EDGE_OFFSET_READ_COUNT ) +#define CONTINUOUS_CLOSED_DOOR_TIME_MS 1000U +#define STEP_CHANGE_IN_COUNTS 100U +#define MAX_POS_DEVIATION_FROM_TARGET_COUNTS 1000U //TODO test this tolerance +#define VALVE_TRANSITION_TIMEOUT_MS 50U //TODO test the timeout +#define MAX_POSITION_DEVIATION_FROM_EDGES_COUNTS 50U +#define MAX_ALLOWED_FAILED_HOMINGS 3U + // ********** private data ********** -/// Valve States -typedef enum valveStates +/// Exec valve self test states +typedef enum valves_Self_Test_States { + VALVE_SELF_TEST_ENABLE_VALVES = 0, + VALVE_SELF_TEST_CONFIRM_ENABLE, + VALVE_SELF_TEST_COMPLETE, + NUM_OF_VALVE_SELF_TEST_STATES +} VALVE_SELF_TEST_STATE_T; + +/// Exec valve states +typedef enum valve_Exec_States +{ VALVE_STATE_WAIT_FOR_POST = 0, VALVE_STATE_IDLE, VALVE_STATE_IN_TRANSITION, - VALVE_STATE_HOMING_START, + VALVE_STATE_HOMING_NOT_STARTED, VALVE_STATE_HOMING_FIND_ENERGIZED_EDGE, VALVE_STATE_HOMING_FIND_DEENERGIZED_EDGE, + VALVE_STATE_HOMING_TRANISTION_TO_POS_A, NUM_OF_VALVE_STATES, } VALVE_STATE_T; + typedef enum homingStatus { HOMING_NOT_STARTED = 0, HOMING_IN_PROGRESS, HOMING_COMPLETE, NUM_OF_HOMING_STATES -} HOMING_STATUS_T; +} HOMING_STATUS_T; //TODO remove typedef struct { VALVE_POSITION_T commandedPosition; VALVE_POSITION_T currentPosition; + S16 currentPositionInCounts; + S16 previousPositionInCounts; BOOL hasTransitionBeenRequested; - HOMING_STATUS_T homingStatus; - BOOL hasPIDBeenEnabled; //TODO remove + HOMING_STATUS_T homingStatus; //TODO remove? + BOOL hasHomingBeenRequested; - U16 PIDEnableBit; - S16 insertEjectPositionA; - S16 openPositionB; - S16 closedPositionC; + S16 positions[ NUM_OF_VALVE_POSITIONS ]; + U32 numberOfFailedHoming; U32 transitionStartTime; } VALVE_STATUS_T; -static VALVE_STATE_T dialyzerInletValveState = VALVE_STATE_WAIT_FOR_POST; +static VALVE_STATE_T dialyzerInletValveState = VALVE_STATE_WAIT_FOR_POST; //TODO Remove these variables? static VALVE_STATE_T dialyzerOutletValveState = VALVE_STATE_WAIT_FOR_POST; static VALVE_STATE_T bloodArterialValveState = VALVE_STATE_WAIT_FOR_POST; static VALVE_STATE_T bloodVenousValveState = VALVE_STATE_WAIT_FOR_POST; -static VALVE_STATUS_T valvesStatus [ NUM_OF_VALVE_POSITIONS ]; +static VALVE_SELF_TEST_STATE_T valveSelfTestState = VALVE_SELF_TEST_ENABLE_VALVES; +static SELF_TEST_STATUS_T valvesSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; -static void execMonitorValves( VALVE_T valve ); +static VALVE_STATUS_T valvesStatus[ NUM_OF_VALVE_POSITIONS ]; +static BOOL isDoorBeingChecked = FALSE; +static U32 generalTimer = 0; -static void processSetPosition( VALVE_T valve, VALVE_POSITION_T position ); +static void execMonitorValves( void ); +static BOOL areValvesEnabled( void ); +static BOOL isDoorClosed( void ); +// Self test function prototypes +static VALVE_SELF_TEST_STATE_T handleValveSelfTestEnableValves( void ); +static VALVE_SELF_TEST_STATE_T handleValveSelfTestConfirmEnable( void ); + +// Exec function prototypes static VALVE_STATE_T handleValveStateWaitForPost( VALVE_T valve ); static VALVE_STATE_T handleValveStateIdle( VALVE_T valve ); static VALVE_STATE_T handleValveStateInTransition( VALVE_T valve ); -static VALVE_STATE_T handleValveStateHomingStart( VALVE_T valve ); +static VALVE_STATE_T handleValveStateHomingNotStarted( VALVE_T valve ); static VALVE_STATE_T handleValveStateHomingFindEnergizedEdge( VALVE_T valve ); static VALVE_STATE_T handleValveStateHomingFindDeenergizedEdge( VALVE_T valve ); +static VALVE_STATE_T handleValveStateHomingTransitionToPosA( VALVE_T valve ); +static VALVE_STATE_T processHomingEnergizedState( VALVE_T valve ); +static VALVE_STATE_T processHomingDeenergizedState( VALVE_T valve ); +static VALVE_STATE_T processTransitionToPositions( VALVE_T valve ); // Use this to the last state of homing and transition states + void initValves( void ) { U08 i; @@ -106,34 +142,44 @@ dialyzerOutletValveState = VALVE_STATE_WAIT_FOR_POST; bloodArterialValveState = VALVE_STATE_WAIT_FOR_POST; bloodVenousValveState = VALVE_STATE_WAIT_FOR_POST; + valveSelfTestState = VALVE_SELF_TEST_ENABLE_VALVES; + valvesSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; - // Set the PID enable for the valves. - valvesStatus[ VDI ].PIDEnableBit = VDI_ENABLE_PID_INTERFACE; - valvesStatus[ VDO ].PIDEnableBit = VDO_ENABLE_PID_INTERFACE; - valvesStatus[ VBA ].PIDEnableBit = VBA_ENABLE_PID_INTERFACE; - valvesStatus[ VBV ].PIDEnableBit = VBV_ENABLE_PID_INTERFACE; - - // Enable the PID controller of all of the valves - enableValvesPIDControl( VDI_ENABLE_PID_INTERFACE ); - enableValvesPIDControl( VDO_ENABLE_PID_INTERFACE ); - enableValvesPIDControl( VBA_ENABLE_PID_INTERFACE ); - enableValvesPIDControl( VBV_ENABLE_PID_INTERFACE ); - // Initialize some of the variables for ( i = 0; i < NUM_OF_VALVE_POSITIONS; i++ ) { valvesStatus[ i ].homingStatus = HOMING_NOT_STARTED; - valvesStatus[ i ].hasPIDBeenEnabled = TRUE; } } SELF_TEST_STATUS_T execValvesSelfTest( void ) { + switch( valveSelfTestState ) + { + case VALVE_SELF_TEST_ENABLE_VALVES: + valveSelfTestState = handleValveSelfTestEnableValves(); + break; + case VALVE_SELF_TEST_CONFIRM_ENABLE: + valveSelfTestState = handleValveSelfTestConfirmEnable(); + break; + + case VALVE_SELF_TEST_COMPLETE: + // Do nothing POST completed + break; + + default: + //TODO alarm + valveSelfTestState = VALVE_SELF_TEST_COMPLETE; + } + + return valvesSelfTestResult; } void execValves( void ) { + execMonitorValves(); + // VDi state machine switch ( dialyzerInletValveState ) { @@ -152,9 +198,9 @@ dialyzerInletValveState = handleValveStateInTransition( VDI ); break; - case VALVE_STATE_HOMING_START: + case VALVE_STATE_HOMING_NOT_STARTED: - dialyzerInletValveState = handleValveStateHomingStart( VDI ); + dialyzerInletValveState = handleValveStateHomingNotStarted( VDI ); break; case VALVE_STATE_HOMING_FIND_ENERGIZED_EDGE: @@ -176,7 +222,7 @@ { BOOL result = FALSE; - valvesStatus [ valve ].hasHomingBeenRequested = TRUE; + valvesStatus[ valve ].hasHomingBeenRequested = TRUE; return result; } @@ -194,19 +240,37 @@ } -BOOL setValveBloodTrap( VALVE_BLOOD_TRAP_STATE_T state ) +BOOL setValveBloodTrap( OPN_CLS_STATE_T state ) { } -static void execMonitorValves( VALVE_T valve ) +static void execMonitorValves( void ) { // TODO check current sense // TODO check enable status - // TODO check timeout and out of tolerance here instead of in each state? + + // Get the current position of the valves in counts and store them + valvesStatus [ VDI ].currentPositionInCounts = getFPGAValveDialyzerInletPosition(); + valvesStatus [ VDO ].currentPositionInCounts = getFPGAValveDialyzerOutletPosition(); + valvesStatus [ VBA ].currentPositionInCounts = getFPGAValveBloodArterialPosition(); + valvesStatus [ VBV ].currentPositionInCounts = getFPGAValveBloodVenousPosition(); +} + + +static VALVE_STATE_T handleValveStateWaitForPost( VALVE_T valve ) +{ + VALVE_STATE_T state = VALVE_STATE_WAIT_FOR_POST; + switch ( valve ) { case VDI: + + if ( valveSelfTestState == VALVE_SELF_TEST_COMPLETE ) + { + state = VALVE_STATE_HOMING_NOT_STARTED; + } + break; case VDO: @@ -221,32 +285,34 @@ default: break; } + + return state; } - -static VALVE_STATE_T handleValveStateWaitForPost( VALVE_T valve ) +static VALVE_SELF_TEST_STATE_T handleValveSelfTestEnableValves( void ) { - VALVE_STATE_T state = VALVE_STATE_WAIT_FOR_POST; + VALVE_SELF_TEST_STATE_T state = VALVE_SELF_TEST_CONFIRM_ENABLE; - switch ( valve ) - { - case VDI: - //TODO change this to keep waiting - state = VALVE_STATE_IDLE; - // FOR TESTING ONLY - break; + valvesSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; - case VDO: - break; + // Enable the PID controller of all of the valves + enableFPGAValvesPIDControl( VDI_ENABLE_PID_INTERFACE ); + enableFPGAValvesPIDControl( VDO_ENABLE_PID_INTERFACE ); + enableFPGAValvesPIDControl( VBA_ENABLE_PID_INTERFACE ); + enableFPGAValvesPIDControl( VBV_ENABLE_PID_INTERFACE ); - case VBA: - break; + return state; +} - case VBV: - break; +static VALVE_SELF_TEST_STATE_T handleValveSelfTestConfirmEnable( void ) +{ + VALVE_SELF_TEST_STATE_T state = VALVE_SELF_TEST_CONFIRM_ENABLE; - default: - break; + // TODO do we need to wait for 50ms? + if ( areValvesEnabled() ) + { + valvesSelfTestResult = SELF_TEST_STATUS_PASSED; + state = VALVE_SELF_TEST_COMPLETE; } return state; @@ -258,14 +324,14 @@ if ( valvesStatus[ valve ].hasHomingBeenRequested ) { - state = VALVE_STATE_HOMING_START; + state = VALVE_STATE_HOMING_NOT_STARTED; } else if ( valvesStatus[ valve ].homingStatus == HOMING_COMPLETE && valvesStatus[ valve ].hasTransitionBeenRequested ) { if ( valvesStatus[ valve ].currentPosition != valvesStatus[ valve ].commandedPosition ) { - processSetPosition( valve, valvesStatus[ valve ].commandedPosition ); + //processHomingEnergizedState( valve, valvesStatus[ valve ].commandedPosition ); } } @@ -275,20 +341,28 @@ static VALVE_STATE_T handleValveStateInTransition( VALVE_T valve ) { + } -static VALVE_STATE_T handleValveStateHomingStart( VALVE_T valve ) +static VALVE_STATE_T handleValveStateHomingNotStarted( VALVE_T valve ) { - VALVE_STATE_T state = VALVE_STATE_HOMING_START; + VALVE_STATE_T state = VALVE_STATE_HOMING_NOT_STARTED; switch ( valve ) { case VDI: - setValveDialyzerInletPosition( INITIAL_ENERGIZED_POSITION ); - valvesStatus[ valve ].homingStatus = HOMING_IN_PROGRESS; - valvesStatus[ valve ].transitionStartTime = getMSTimerCount(); + // If homing has been requested or POST is completed and the door has been close for the specified + // period of time, start the homing + if ( ( valvesStatus[ valve ].hasHomingBeenRequested || valveSelfTestState == VALVE_SELF_TEST_COMPLETE ) + && isDoorClosed() ) + { + setFPGAValveDialyzerInletPosition( STEP_CHANGE_IN_COUNTS ); + valvesStatus[ valve ].transitionStartTime = getMSTimerCount(); + state = VALVE_STATE_HOMING_FIND_ENERGIZED_EDGE; + } + break; case VDO: @@ -307,36 +381,17 @@ return state; } + + static VALVE_STATE_T handleValveStateHomingFindEnergizedEdge( VALVE_T valve ) { VALVE_STATE_T state = VALVE_STATE_HOMING_FIND_ENERGIZED_EDGE; - S16 position = 0; - switch ( valve ) { case VDI: - // Read the energized position back - position = getValveDialyzerInletPosition(); - - if ( fabs( position - INITIAL_ENERGIZED_POSITION ) <= MAX_ALLOWED_POSITION_DEVIATION_FROM_TARGET ) - { - // Fully de-energized state which is closed position - valvesStatus[ valve ].closedPositionC = position; - // Reset the timer for the next state - valvesStatus[ valve ].transitionStartTime = getMSTimerCount(); - - setValveDialyzerInletPosition( INITIAL_DEENERGIZED_POSITION ); - state = VALVE_STATE_HOMING_FIND_DEENERGIZED_EDGE; - } - else if ( didTimeout( valvesStatus[ valve ].transitionStartTime, VALVE_TRANSITION_TIMEOUT_MS ) ) - { - // TODO Fault alarm - valvesStatus[ valve ].homingStatus = HOMING_COMPLETE; - // Homing failed, go back to start - state = VALVE_STATE_HOMING_START; - } + state = processHomingEnergizedState( valve ); break; case VDO: @@ -358,38 +413,12 @@ static VALVE_STATE_T handleValveStateHomingFindDeenergizedEdge( VALVE_T valve ) { VALVE_STATE_T state = VALVE_STATE_HOMING_FIND_DEENERGIZED_EDGE; - S16 position = 0; - S16 avgPosition = 0; switch ( valve ) { case VDI: - // Read the energized position back - position = getValveDialyzerInletPosition(); - - if ( fabs( position - INITIAL_DEENERGIZED_POSITION ) <= MAX_ALLOWED_POSITION_DEVIATION_FROM_TARGET ) - { - // Fully energized state which is open - valvesStatus[ valve ].openPositionB = position; - - // Insert/eject position which is the average of the fully energized and de-energized states - avgPosition = ( position + valvesStatus[ valve ].insertEjectPositionA ) / 2; - - // This is the homing value - valvesStatus[ valve ].insertEjectPositionA = avgPosition; - valvesStatus[ valve ].homingStatus = HOMING_COMPLETE; - // Turn off the homing flag - valvesStatus[ valve ].hasHomingBeenRequested = FALSE; - // Done with homing - state = VALVE_STATE_IDLE; - } - else if ( didTimeout( valvesStatus[ valve ].transitionStartTime, VALVE_TRANSITION_TIMEOUT_MS ) ) - { - // TODO alarm - valvesStatus[ valve ].homingStatus = HOMING_COMPLETE; - state = VALVE_STATE_HOMING_START; - } + state = processHomingDeenergizedState( valve ); break; case VDO: @@ -408,48 +437,211 @@ return state; } -static void processSetPosition( VALVE_T valve, VALVE_POSITION_T position ) +static VALVE_STATE_T processHomingEnergizedState( VALVE_T valve ) { - S16 setPoint = 0; + VALVE_STATE_T state = VALVE_STATE_HOMING_FIND_ENERGIZED_EDGE; - switch ( position ) + S16 currentPosition = 0; + S16 previousPosition = 0; + U32 elapsedTime = 0; + BOOL hasTimeElapsed = FALSE; + + // Read the energized position back + currentPosition = fabs( valvesStatus[ valve ].currentPositionInCounts ); + previousPosition = fabs( valvesStatus[ valve ].previousPositionInCounts ); + elapsedTime = valvesStatus[ valve ].transitionStartTime; //TODO this is wrong + hasTimeElapsed = didTimeout( elapsedTime, VALVE_TRANSITION_TIMEOUT_MS ); //TODO use the right timeout + + //TODO get the timing right (50ms should be started correctly) + if ( fabs( currentPosition - previousPosition ) <= MAX_POSITION_DEVIATION_FROM_EDGES_COUNTS ) { - case VALVE_POSITION_A_INSERT_EJECT: + if( fabs( currentPosition - INITIAL_ENERGIZED_POSITION ) <= MAX_POS_DEVIATION_FROM_TARGET_COUNTS ) + { + // Current position (positive or negative) will be stored in the Position B of the current valve + // Do not use the above variables because they absolute valves using fabs + valvesStatus[ valve ].positions[ VALVE_POSITION_B_OPEN ] = valvesStatus[ valve ].currentPositionInCounts; + // Reset the current time and transition to the next state + valvesStatus[ valve ].transitionStartTime = getMSTimerCount(); + state = VALVE_STATE_HOMING_FIND_DEENERGIZED_EDGE; + } + } + else if ( didTimeout( valvesStatus[ valve ].transitionStartTime, VALVE_TRANSITION_TIMEOUT_MS ) ) + { + U32 failedHomingCount = valvesStatus[ valve ].numberOfFailedHoming; - setPoint = valvesStatus[ valve ].insertEjectPositionA; - break; + if ( failedHomingCount >= MAX_ALLOWED_FAILED_HOMINGS ) + { + //TODO fault alarm + } - case VALVE_POSITION_B_OPEN: + state = VALVE_STATE_HOMING_NOT_STARTED; + } + else + { + S16 nextStep = valvesStatus[ valve ].currentPositionInCounts + STEP_CHANGE_IN_COUNTS; + setFPGAValveDialyzerInletPosition ( nextStep ); + } - setPoint = valvesStatus[ valve ].openPositionB; - break; + return state; +} - case VALVE_POSITION_C_CLOSE: +static VALVE_STATE_T processHomingDeenergizedState( VALVE_T valve ) +{ + VALVE_STATE_T state = VALVE_STATE_HOMING_FIND_DEENERGIZED_EDGE; - setPoint = valvesStatus[ valve ].closedPositionC; - break; + S16 currentPosition = 0; + S16 previousPosition = 0; + U32 elapsedTime = 0; + BOOL hasTimeElapsed = FALSE; + + // Read the energized position back + currentPosition = fabs( valvesStatus[ valve ].currentPositionInCounts ); + previousPosition = fabs( valvesStatus[ valve ].previousPositionInCounts ); + elapsedTime = valvesStatus[ valve ].transitionStartTime; //TODO this is wrong + hasTimeElapsed = didTimeout( elapsedTime, VALVE_TRANSITION_TIMEOUT_MS ); //TODO use the right timeout + + //TODO get the timing right (50ms should be started correctly) + if ( fabs( currentPosition - previousPosition ) <= MAX_POSITION_DEVIATION_FROM_EDGES_COUNTS ) + { + if( fabs( currentPosition - INITIAL_DEENERGIZED_POSITION ) <= MAX_POS_DEVIATION_FROM_TARGET_COUNTS ) + { + S16 positionB = valvesStatus[ valve ].positions[ VALVE_POSITION_B_OPEN ]; + // Position A is the average of the Position B that was read last time and position C that was + // the target of this state + S16 positionA = ( valvesStatus[ valve ].currentPositionInCounts + positionB ) / 2; + valvesStatus[ valve ].positions[ VALVE_POSITION_A_INSERT_EJECT ] = positionA; + + // Positions B and C will have an offset from the edge to make sure each time the valve will not + // hit the edge + valvesStatus[ valve ].positions[ VALVE_POSITION_B_OPEN ] = positionB - INITIAL_EDGE_OFFSET_READ_COUNT; + + valvesStatus[ valve ].positions[ VALVE_POSITION_C_CLOSE ] = valvesStatus[ valve ].currentPositionInCounts - + INITIAL_EDGE_OFFSET_READ_COUNT; + + // Reset the number of failed homing for the next homing sequence + valvesStatus[ valve ].numberOfFailedHoming = 0; + + // Reset the current time and transition to the next state + valvesStatus[ valve ].transitionStartTime = getMSTimerCount(); + state = VALVE_STATE_HOMING_TRANISTION_TO_POS_A; + } } + else if ( didTimeout( valvesStatus[ valve ].transitionStartTime, VALVE_TRANSITION_TIMEOUT_MS ) ) + { + U32 failedHomingCount = valvesStatus[ valve ].numberOfFailedHoming; + if ( failedHomingCount >= MAX_ALLOWED_FAILED_HOMINGS ) + { + //TODO fault alarm + } - switch ( valve ) + state = VALVE_STATE_HOMING_NOT_STARTED; + } + else { - case VDI: + S16 nextStep = valvesStatus[ valve ].currentPositionInCounts - STEP_CHANGE_IN_COUNTS; + setFPGAValveDialyzerInletPosition ( nextStep ); + } - setValveDialyzerInletPosition ( setPoint ); - break; + return state; +} - case VDO: - break; - case VBA: - break; - case VBV: - break; +static BOOL areValvesEnabled( void ) +{ + //TODO alarm for the valve status + BOOL result = TRUE; - default: - break; + U16 status = getFPGAValvesStatus(); + + // VDi status + if ( ! status & VDI_INITIALIZATION_STATUS_BIT_MASK ) + { + result = FALSE; } + if ( ! status & VDI_ENABLE_PID_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( status & VDI_ENABLE_BYPASS_STATUS_BIT_MASK ) + { + result = FALSE; + } + // VDo status + if ( ! status & VDO_INITIALIZATION_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( ! status & VDO_ENABLE_PID_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( status & VDO_ENABLE_BYPASS_STATUS_BIT_MASK ) + { + result = FALSE; + } + + // VBA status + if ( ! status & VBA_INITIALIZATION_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( ! status & VBA_ENABLE_PID_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( status & VBA_ENABLE_BYPASS_STATUS_BIT_MASK ) + { + result = FALSE; + } + + // VBV status + if ( ! status & VBV_INITIALIZATION_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( ! status & VBV_ENABLE_PID_STATUS_BIT_MASK ) + { + result = FALSE; + } + if ( status & VBV_ENABLE_BYPASS_STATUS_BIT_MASK ) + { + result = FALSE; + } + + return result; } +static BOOL isDoorClosed( void ) +{ + BOOL result = FALSE; + + // TODO change this real door status + // Check the door status + BOOL doorStatus = TRUE; + + // Checking the doors status for the first time + if ( isDoorBeingChecked == FALSE ) + { + generalTimer = getMSTimerCount(); + isDoorBeingChecked = TRUE; + } + else + { + // If the door status is true and the time has elapsed + if ( doorStatus && didTimeout( generalTimer, CONTINUOUS_CLOSED_DOOR_TIME_MS ) ) + { + isDoorBeingChecked = FALSE; + result = TRUE; + } + // If door status is not true, then we should exit and reset + else if ( doorStatus == FALSE ) + { + isDoorBeingChecked = FALSE; + } + } + + return result; +}