Index: firmware/App/Controllers/Valves.c =================================================================== diff -u -r229341f9eb23fec730cdf9b1f8f3960de2daf384 -rae31b4c999dccae70fb40fb9d98a4380ce2c7415 --- firmware/App/Controllers/Valves.c (.../Valves.c) (revision 229341f9eb23fec730cdf9b1f8f3960de2daf384) +++ firmware/App/Controllers/Valves.c (.../Valves.c) (revision ae31b4c999dccae70fb40fb9d98a4380ce2c7415) @@ -1,17 +1,17 @@ /************************************************************************** * -* Copyright (c) 2024-2024 Diality Inc. - All Rights Reserved. +* Copyright (c) 2024-2026 Diality Inc. - All Rights Reserved. * * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. * -* @file ValvesDD.c +* @file Valves.c * -* @author (last) Vinayakam Mani -* @date (last) 14-Aug-2024 +* @author (last) Raghu Kallala +* @date (last) 23-Feb-2026 * * @author (original) Vinayakam Mani -* @date (original) 14-Aug-2024 +* @date (original) 26-Aug-2024 * ***************************************************************************/ @@ -35,30 +35,39 @@ #define ENERGIZED 1 ///< 1 for energized valve. #define ALL_VALVES_DEENERGIZED 0x0000 ///< 0 in U16 bit field for all valves. +#define VALVE_PWM_PERIOD 500 ///< Valve PWM Period in 0.1 us res ( 20kHz ) +#define VALVE_PWM_LOW ( VALVE_PWM_PERIOD * 0.2 ) ///< Valve low PWM percentage +#define VALVE_PWM_PULL_IN 100 ///< Valve 'strike' period at 100% PWM in ms + #define MAX_VALVE_STATE_MISMATCH_TIMER_COUNT (100 / TASK_PRIORITY_INTERVAL ) ///< Maximum time commanded valves state can fail to match read back valve states in a row. #define VALVES_STATE_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval ( ms / task time) at which valves states are published on CAN bus. #define DATA_PUBLISH_COUNTER_START_COUNT 50 ///< Data publish counter start count. /// Payload record structure for valve open/close request typedef struct { - U32 valveID; ///< ValveID ( valid range 0 to 28 ) - U32 valveState; ///< Valve state ( Open : 0, closed :1) + U32 valveID; ///< ValveID ( valid range 0 to 28 ) + U32 valveState; ///< Valve state ( Open : 0, closed :1) } VALVE_CMD_PAYLOAD_T; // ********** private data ********** static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. +static U32 fpValveStatesPublicationTimerCounter; ///< Timer counter used to schedule IOFP valve state publication to CAN bus. static U16 commandedValvesStates; ///< Initialize commanded valves states bit field. static U08 commandedBCValveStates; ///< Initialize balancing chamber commanded valves states bit field. -static U08 commandedUFValveStates; ///< Initialize ultra filtration commanded valves states bit field. +static U08 commandedSpareValveStates; ///< Initialize commanded spare valves states bit field. +static U08 commandedIOValveStates; ///< Initialize commanded IO valves states bit field. +static U08 commandedFPValveStates; ///< Initialize commanded FP valves states bit field. static U32 valveStateMismatchTimerCounter; ///< Initialize valve state mismatch timer. static U32 pendingValveStateChanges[ DD_NUM_OF_VALVES ]; ///< Delayed (pending) valve state changes. static U32 pendingValveStateChangeCountDowns[ DD_NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). +static RECOVERY_STATE_T recoveryState; ///< IOFP valve recovery setting. static OVERRIDE_U32_T valveStates[ DD_NUM_OF_VALVES ]; ///< Currently commanded valves states. static OVERRIDE_U32_T valveSensedStates[ DD_NUM_OF_VALVES ]; ///< Valve sensed states override. -static OVERRIDE_U32_T valvesStatesPublishInterval = { VALVES_STATE_PUB_INTERVAL, VALVES_STATE_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. +static OVERRIDE_U32_T valvesStatesPublishInterval; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. +static OVERRIDE_U32_T fpValveStatesPublishInterval; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. // ********** private function prototypes ********** @@ -67,51 +76,126 @@ static BOOL checkValveStateName( DD_VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ); static U32 convertValveStateNameToValveState( VALVE_STATE_NAMES_T valveStateName ); static U32 getValveState( U32 valveID ); +static void setFPGAPWMConfigurations( void ); /*********************************************************************//** * @brief * The initValves function initializes the Valves unit. * @details \b Inputs: none - * @details \b Outputs: valveStates, pendingValveStateChanges, valveSensedStates, - * pendingValveStateChangeCountDowns, valveStateMismatchCounter, - * commandedValvesStates + * @details \b Outputs: Valves unit initialized. * @return none *************************************************************************/ void initValves( void ) { U32 i; - // initialize commanded valve states + // Initialize publish interval overrides + valvesStatesPublishInterval.data = VALVES_STATE_PUB_INTERVAL; + valvesStatesPublishInterval.ovData = VALVES_STATE_PUB_INTERVAL; + valvesStatesPublishInterval.ovInitData = 0; + valvesStatesPublishInterval.override = OVERRIDE_RESET; + fpValveStatesPublishInterval.data = VALVES_STATE_PUB_INTERVAL; + fpValveStatesPublishInterval.ovData = VALVES_STATE_PUB_INTERVAL; + fpValveStatesPublishInterval.ovInitData = 0; + fpValveStatesPublishInterval.override = OVERRIDE_RESET; + recoveryState = MAX_RECOVERY; + + // Initialize commanded valve states for ( i = 0; i < DD_NUM_OF_VALVES; i++ ) { valveStates[ i ].data = DEENERGIZED; valveStates[ i ].ovInitData = DEENERGIZED; valveStates[ i ].ovData = DEENERGIZED; valveStates[ i ].override = OVERRIDE_RESET; - pendingValveStateChanges[ i ] = DEENERGIZED; - pendingValveStateChangeCountDowns[ i ] = 0; valveSensedStates[ i ].data = DEENERGIZED; valveSensedStates[ i ].ovInitData = DEENERGIZED; valveSensedStates[ i ].ovData = DEENERGIZED; valveSensedStates[ i ].override = OVERRIDE_RESET; + pendingValveStateChanges[ i ] = DEENERGIZED; + pendingValveStateChangeCountDowns[ i ] = 0; } - //Initialize the commanded valve states + // Initialize the commanded valve states commandedValvesStates = ALL_VALVES_DEENERGIZED; commandedBCValveStates = ALL_VALVES_DEENERGIZED; - commandedUFValveStates = ALL_VALVES_DEENERGIZED; + commandedSpareValveStates = ALL_VALVES_DEENERGIZED; + commandedIOValveStates = ALL_VALVES_DEENERGIZED; + commandedFPValveStates = ALL_VALVES_DEENERGIZED; valveStateMismatchTimerCounter = 0; valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer - + fpValveStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer readCommandedValveStates(); + + // TODO set FPGA PWM after finalizing the decision on valve strike and hold behavior + // initially set valve PWM configuration and enable + //setFPGAPWMConfigurations(); + // initially set all valves to de-energized state via FPGA - setFPGAValveStates( commandedValvesStates ); + setFPGADDValveStates( commandedValvesStates ); setFPGABCValveStates( commandedBCValveStates ); - setFPGAUFValveStates( commandedUFValveStates ); + setFPGASpareValveStates( commandedSpareValveStates ); + setFPGAFPValveStates( commandedFPValveStates ); + setFPGAIOValveStates( commandedIOValveStates ); } /*********************************************************************//** * @brief + * The setFPGAPWMConfigurations function sets the FPGA for Valve PWM control. + * @details \b Inputs: none + * @details \b Outputs: Valves PWM timing set and enabled. + * @return none + *************************************************************************/ +static void setFPGAPWMConfigurations( void ) +{ + // Balancing Chamber valves are not PWM configured. + U32 i; + U16 valveDDBits = 0; + U08 valveSPBits = 0; + U08 valveIOBits = 0; + U08 valveFPBits = 0; + + // set timing values + setFPGAValveDDPWMPullIn( VALVE_PWM_PULL_IN ); + setFPGAValveDDPWMLow( VALVE_PWM_LOW ); + setFPGAValveDDPWMPeriod( VALVE_PWM_PERIOD ); + + setFPGAValveSPPWMPullIn( VALVE_PWM_PULL_IN ); + setFPGAValveSPPWMLow( VALVE_PWM_LOW ); + setFPGAValveSPPWMPeriod( VALVE_PWM_PERIOD ); + + setFPGAValveIOFPPWMPullIn( VALVE_PWM_PULL_IN ); + setFPGAValveIOFPPWMLow( VALVE_PWM_LOW ); + setFPGAValveIOFPPWMPeriod( VALVE_PWM_PERIOD ); + + for ( i = FIRST_HYD_VALVE; i <= LAST_HYD_VALVE; i++ ) + { + valveDDBits |= 0x01 << i; + } + + for ( i = FIRST_SP_VALVE; i <= LAST_SP_VALVE; i++ ) + { + valveSPBits |= 0x01 << ( i - FIRST_SP_VALVE ); + } + + for ( i = FIRST_IO_VALVE; i <= LAST_IO_VALVE; i++ ) + { + valveIOBits |= 0x01 << ( i - FIRST_IO_VALVE ); + } + + for ( i = FIRST_FP_VALVE; i <= LAST_FP_VALVE; i++ ) + { + valveFPBits |= 0x01 << ( i - FIRST_FP_VALVE ); + } + + // set enable + setFPGAValveDDPWMEnable( valveDDBits ); + setFPGAValveSPPWMEnable( valveSPBits ); + setFPGAValveIOPWMEnable( valveIOBits ); + setFPGAValveFPPWMEnable( valveFPBits ); +} + +/*********************************************************************//** + * @brief * The execValves function executes the valves driver. * @details \b Inputs: valvesStates, valveStateMismatchCounter * pendingValveStateChangeCountDowns, commandedValvesStates, @@ -125,15 +209,18 @@ void execValves( void ) { U32 i; - // get valves states from FPGA - U16 readValvesStates = getFPGAValveStates(); - U08 readValveBCStates = getFPGAValveBCStates(); - U08 readValveUFStates = getFPGAValveUFStates(); + U16 readValvesStates = getFPGADDValveStates(); + U08 readValveBCStates = getFPGAValveBCStates(); + U08 readValveSpStates = getFPGAValveSpStates(); + U08 readValveIOStates = getFPGAIOValveStates(); + U08 readValveFPStates = getFPGAFPValveStates(); // Verify read back FPGA valve states match last commanded valve states - if ( ( readValvesStates != commandedValvesStates ) || + if ( ( readValvesStates != commandedValvesStates ) || ( readValveBCStates != commandedBCValveStates ) || - ( readValveUFStates != commandedUFValveStates ) ) + ( readValveSpStates != commandedSpareValveStates ) || + ( readValveIOStates != commandedIOValveStates ) || + ( readValveFPStates != commandedFPValveStates )) { valveStateMismatchTimerCounter++; // increment valve state mismatch counter by 1 if ( valveStateMismatchTimerCounter > MAX_VALVE_STATE_MISMATCH_TIMER_COUNT ) @@ -162,123 +249,18 @@ // Set valves states (via FPGA) to currently commanded states readCommandedValveStates(); - setFPGAValveStates( commandedValvesStates ); + setFPGADDValveStates( commandedValvesStates ); setFPGABCValveStates( commandedBCValveStates ); - setFPGAUFValveStates( commandedUFValveStates ); + setFPGASpareValveStates( commandedSpareValveStates ); + setFPGAFPValveStates( commandedFPValveStates ); + setFPGAIOValveStates( commandedIOValveStates ); // Publish valve states on interval publishValvesStates(); } /*********************************************************************//** * @brief - * The readCommandedValveStates function gets the hydraulics, Balancing chamber - * and Ultrafiltration valvesStates that can be passed to FPGA for setting valves. - * @details \b Inputs: valveStates[] - * @details \b Outputs: commandedValvesStates,commandedBCValveStates, - * commandedUFValveStates - * @return converted U16 and U08 bit field for currently commanded valve states - *************************************************************************/ -static void readCommandedValveStates( void ) -{ - U32 i; - - // Initiliaze before updating commanded states - commandedValvesStates = ALL_VALVES_DEENERGIZED; - commandedBCValveStates = ALL_VALVES_DEENERGIZED; - commandedUFValveStates = ALL_VALVES_DEENERGIZED; - - // flag hydraulics valves that are currently commanded to be energized - for ( i = FIRST_HYD_VALVE; i <= LAST_HYD_VALVE; i++ ) - { - commandedValvesStates |= ( getValveState( i ) == ENERGIZED ? 0x0001 << i : 0 ); - } - - // flag Balancing chamber valves that are currently commanded to be energized - for ( i = FIRST_BC_VALVE; i <= LAST_BC_VALVE; i++ ) - { - commandedBCValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_BC_VALVE ) : 0 ); - } - - // flag Ultrafiltration valves that are currently commanded to be energized - for ( i = FIRST_UF_VALVE; i <= LAST_UF_VALVE; i++ ) - { - commandedUFValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_UF_VALVE ) : 0 ); - } -} - -/*********************************************************************//** - * @brief - * The checkValveStateName function checks the validity of requested valve - * state name for given valve. - * @details \b Inputs: none - * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. - * @param valveID ID of valve to check a valve state name for - * @param valveStateName valve state name to check for given valve ID - * @return TRUE if given valveStateName is appropriate for given valve ID, FALSE if not. - *************************************************************************/ -static BOOL checkValveStateName( DD_VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ) -{ - BOOL result = FALSE; // initialize result flag to FALSE - - switch ( valveStateName ) - { - case VALVE_STATE_OPEN: - case VALVE_STATE_CLOSED: - if ( ( D53_VALV == valveID ) || ( D52_VALV == valveID ) || ( D8_VALV == valveID ) || ( D54_VALV == valveID ) || ( D14_VALV == valveID ) || - ( D65_VALV == valveID ) || ( D64_VALV == valveID ) || ( D31_VALV == valveID ) || ( D34_VALV == valveID ) || ( D35_VALV == valveID ) || - ( D40_VALV == valveID ) || ( D47_VALV == valveID ) || ( D3_VALV == valveID ) || ( DD_M4_VALV == valveID ) || ( D23_VALV == valveID ) || - ( D19_VALV == valveID ) || ( D25_VALV == valveID ) || ( D21_VALV == valveID ) || ( D24_VALV == valveID ) || ( D20_VALV == valveID ) || - ( D26_VALV == valveID ) || ( D22_VALV == valveID ) || ( D69_VALV == valveID ) || ( D70_VALV == valveID ) || ( D71_VALV == valveID ) || - ( D72_VALV == valveID ) ) - { - result = TRUE; - } - break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) - break; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The convertValveStateNameToValveState function converts valve state \n - * name to its corresponding de-energized (0) or energized (1) valve state. - * @details \b Inputs: none - * @details \b Outputs: none - * @details \b Alarm : ALARM_ID_DD_SOFTWARE_FAULT when invalid valve state name passed - * @param valveStateName valve state name enumeration to convert to energized/de-energized - * @return converted valve state for given valve state name - *************************************************************************/ -static U32 convertValveStateNameToValveState( VALVE_STATE_NAMES_T valveStateName ) -{ - U32 vState = DEENERGIZED; // initialize valve state to de-energized - - switch ( valveStateName ) - { - case VALVE_STATE_OPEN: - vState = ENERGIZED; - break; - - case VALVE_STATE_CLOSED: - vState = DEENERGIZED; - break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) - break; - } - - return vState; -} - -/*********************************************************************//** - * @brief * The setValveState function sets the valve state for given valve. * @details \b Inputs: none * @details \b Outputs: valveStates[], pendingValveStateChanges[], pendingValveStateChangeCountDowns[] @@ -377,8 +359,149 @@ return name; } + /*********************************************************************//** * @brief + * The setHydValvesStatetoClosedState function sets all Hydraulics / DD + * valves to close state except balancing chamber, UF and Inlet water control. + * @details \b Inputs: none + * @details \b Outputs: valve states + * @return none. + *************************************************************************/ +void setHydValvesStatetoClosedState( void ) +{ + DD_VALVES_T valve; + + // Set all Hydraulics valves to closed state + for ( valve = FIRST_HYD_VALVE; valve <= LAST_HYD_VALVE; valve++ ) + { + setValveState( valve, VALVE_STATE_CLOSED ); + } +} + +/*********************************************************************//** + * @brief + * The readCommandedValveStates function gets the hydraulics, Balancing chamber + * and Ultrafiltration valvesStates that can be passed to FPGA for setting valves. + * @details \b Inputs: valveStates[] + * @details \b Outputs: commandedValvesStates,commandedBCValveStates, + * commandedUFValveStates + * @return converted U16 and U08 bit field for currently commanded valve states + *************************************************************************/ +static void readCommandedValveStates( void ) +{ + U32 i; + + // Initiliaze before updating commanded states + commandedValvesStates = ALL_VALVES_DEENERGIZED; + commandedBCValveStates = ALL_VALVES_DEENERGIZED; + commandedSpareValveStates = ALL_VALVES_DEENERGIZED; + commandedIOValveStates = ALL_VALVES_DEENERGIZED; + commandedFPValveStates = ALL_VALVES_DEENERGIZED; + + // flag hydraulics valves that are currently commanded to be energized + for ( i = FIRST_HYD_VALVE; i <= LAST_HYD_VALVE; i++ ) + { + commandedValvesStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << i : 0 ); + } + + // flag Balancing chamber valves that are currently commanded to be energized + for ( i = FIRST_BC_VALVE; i <= LAST_BC_VALVE; i++ ) + { + commandedBCValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_BC_VALVE ) : 0 ); + } + + // flag spare valves that are currently commanded to be energized + for ( i = FIRST_SP_VALVE; i <= LAST_SP_VALVE; i++ ) + { + commandedSpareValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_SP_VALVE ) : 0 ); + } + + // flag IO valves that are currently commanded to be energized + for ( i = FIRST_IO_VALVE; i <= LAST_IO_VALVE; i++ ) + { + commandedIOValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_IO_VALVE ) : 0 ); + } + // flag FP valves that are currently commanded to be energized + for ( i = FIRST_FP_VALVE; i <= LAST_FP_VALVE; i++ ) + { + commandedFPValveStates |= ( getValveState( i ) == ENERGIZED ? 0x01 << ( i - FIRST_FP_VALVE ) : 0 ); + } +} + +/*********************************************************************//** + * @brief + * The checkValveStateName function checks the validity of requested valve + * state name for given valve. + * @details \b Inputs: none + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. + * @param valveID ID of valve to check a valve state name for + * @param valveStateName valve state name to check for given valve ID + * @return TRUE if given valveStateName is appropriate for given valve ID, FALSE if not. + *************************************************************************/ +static BOOL checkValveStateName( DD_VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ) +{ + BOOL result = FALSE; // initialize result flag to FALSE + + switch ( valveStateName ) + { + case VALVE_STATE_OPEN: + case VALVE_STATE_CLOSED: + if ( ( D53_VALV == valveID ) || ( D52_VALV == valveID ) || ( D8_VALV == valveID ) || ( D54_VALV == valveID ) || ( D14_VALV == valveID ) || + ( D65_VALV == valveID ) || ( D64_VALV == valveID ) || ( D31_VALV == valveID ) || ( D34_VALV == valveID ) || ( D35_VALV == valveID ) || + ( D40_VALV == valveID ) || ( D47_VALV == valveID ) || ( D3_VALV == valveID ) || ( M4_VALV == valveID ) || ( D23_VALV == valveID ) || + ( D19_VALV == valveID ) || ( D25_VALV == valveID ) || ( D21_VALV == valveID ) || ( D24_VALV == valveID ) || ( D20_VALV == valveID ) || + ( D26_VALV == valveID ) || ( D22_VALV == valveID ) || ( D80_VALV == valveID ) || ( D81_VALV == valveID ) || ( D88_79_VALV == valveID ) || + ( P11_VALV == valveID ) || ( P33_VALV == valveID ) || ( P34_VALV == valveID ) || ( P37_VALV == valveID ) || ( P6_VALV == valveID ) || + ( M12_VALV == valveID ) || ( P39_VALV == valveID ) || ( D83_VALV == valveID ) || ( D91_VALV == valveID ) || ( D100_VALV == valveID ) || ( D85_VALV == valveID ) ) + { + result = TRUE; + } + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) + break; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The convertValveStateNameToValveState function converts valve state \n + * name to its corresponding de-energized (0) or energized (1) valve state. + * @details \b Inputs: none + * @details \b Outputs: none + * @details \b Alarm : ALARM_ID_DD_SOFTWARE_FAULT when invalid valve state name passed + * @param valveStateName valve state name enumeration to convert to energized/de-energized + * @return converted valve state for given valve state name + *************************************************************************/ +static U32 convertValveStateNameToValveState( VALVE_STATE_NAMES_T valveStateName ) +{ + U32 vState = DEENERGIZED; // initialize valve state to de-energized + + switch ( valveStateName ) + { + case VALVE_STATE_OPEN: + vState = ENERGIZED; + break; + + case VALVE_STATE_CLOSED: + vState = DEENERGIZED; + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) + break; + } + + return vState; +} + +/*********************************************************************//** + * @brief * The getValveState function gets the current valve state for given valve. * @details \b Inputs: valveStates[] * @details \b Outputs: none @@ -404,40 +527,55 @@ /*********************************************************************//** * @brief - * The setHydValvesStatetoClosedState function sets all Hydraulics / DD - * valves to close state except balancing chamber, UF and Inlet water control. + * The setRecoveryValvesConfig function sets all recovery valves per + * recovery configuration from institutional record. * @details \b Inputs: none - * @details \b Outputs: valve states + * @details \b Outputs: P33, P34 and P37 recovery valve states * @return none. *************************************************************************/ -void setHydValvesStatetoClosedState( void ) +void setRecoveryValvesConfig( void ) { - DD_VALVES_T valve; + // TODO define hdInstitutionalRecord and get the NVData when it's ready +// RECOVERY_STATE_T recoveryState = (RECOVERY_STATE_T)hdInstitutionalRecord.recoveryConfig; + RECOVERY_STATE_T recoveryState = MAX_RECOVERY; - // Set all Hydraulics valves to closed state - for ( valve = FIRST_HYD_VALVE; valve < LAST_HYD_VALVE; valve++ ) + // Set all P33, P34 and P37 valves per recovery configuration + switch( recoveryState ) { - setValveState( valve, VALVE_STATE_CLOSED ); + case NO_RECOVERY: + setValveState( P33_VALV, VALVE_STATE_CLOSED ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + break; + + case MEDIUM_RECOVERY: + setValveState( P33_VALV, VALVE_STATE_OPEN ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_OPEN ); + break; + + case MAX_RECOVERY: + setValveState( P33_VALV, VALVE_STATE_OPEN ); + setValveState( P34_VALV, VALVE_STATE_CLOSED ); + setValveState( P37_VALV, VALVE_STATE_CLOSED ); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, FP_FAULT_ID_FP_INVALID_RECOVERY_VALVE_STATE, recoveryState ) + break; } } /*********************************************************************//** * @brief - * The setUFValvesStatetoClosedState function sets all UF valves - * to close state. - * @details \b Inputs: none - * @details \b Outputs: valve states - * @return none. + * The getRecoveryState function gets the current valve recovery state. + * @details \b Inputs: recoveryState + * @details \b Outputs: recoveryState + * @return the current valve recovery state. *************************************************************************/ -void setUFValvesStatetoClosedState( void ) +RECOVERY_STATE_T getRecoveryState( void ) { - DD_VALVES_T valve; - - // Set all UF valves to closed state - for ( valve = FIRST_UF_VALVE; valve <= LAST_UF_VALVE; valve++ ) - { - setValveState( valve, VALVE_STATE_CLOSED ); - } + return recoveryState; } /*********************************************************************//** @@ -450,17 +588,17 @@ *************************************************************************/ static void publishValvesStates( void ) { - // publish valve state on interval + // publish DD valve states on interval if ( ++valvesStatesPublicationTimerCounter >= getU32OverrideValue( &valvesStatesPublishInterval ) ) { DD_VALVES_DATA_T data; U32 i; - data.valvesStatus = getFPGAValveStates(); - data.valvesBCStatus = getFPGAValveBCStates(); - data.valvesUFStatus = getFPGAValveUFStates(); + data.valvesStatus = commandedValvesStates; + data.valvesBCStatus = commandedBCValveStates; + data.valveSPStatus = commandedSpareValveStates; - for ( i = 0; i < DD_NUM_OF_VALVES; i++ ) + for ( i = 0; i <= LAST_DD_VALVE; i++ ) { data.valvesSensedState[ i ] = (U08)getValveStateName( (DD_VALVES_T)i ); } @@ -469,6 +607,24 @@ valvesStatesPublicationTimerCounter = 0; } + + // publish IOFP valve states on interval + if ( ++fpValveStatesPublicationTimerCounter >= getU32OverrideValue( &fpValveStatesPublishInterval ) ) + { + FP_VALVES_DATA_T data; + U32 i; + + data.valvesIOState = commandedIOValveStates; + data.valvesFPState = commandedFPValveStates; + for ( i = FIRST_IO_VALVE; i <= LAST_FP_VALVE; i++ ) + { + data.valvesSensedState[ i - FIRST_IO_VALVE ] = (U08)getValveStateName( (DD_VALVES_T)i ); + } + + broadcastData( MSG_ID_FP_VALVES_STATES_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( FP_VALVES_DATA_T ) ); + + fpValveStatesPublicationTimerCounter = 0; + } } @@ -506,8 +662,15 @@ *************************************************************************/ BOOL testValveStateOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &valveStates[0], DD_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( payload.index <= LAST_DD_VALVE ) + { + result = u32ArrayOverride( message, &valveStates[0], DD_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); + } + return result; } @@ -526,15 +689,35 @@ { DD_BC_VALVE_OVERRIDE_PAYLOAD_T payload; DD_VALVES_T valve; - BOOL result = FALSE; + U32 mask; + VALVE_STATE_NAMES_T pos; + OVERRIDE_TYPE_T ovType = OVERRIDE_INVALID; + BOOL result = FALSE; memcpy( (U08*)(&payload), message->payload, sizeof( DD_BC_VALVE_OVERRIDE_PAYLOAD_T ) ); - for ( valve = FIRST_BC_VALVE; valve <= LAST_BC_VALVE; valve++ ) + ovType = ( TRUE == payload.reset ? OVERRIDE_RESET_OVERRIDE : OVERRIDE_OVERRIDE ); + + // Verify tester has logged in with f/w and override type is valid + if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) { - U32 mask = 0x1 << (valve - FIRST_BC_VALVE); - VALVE_STATE_NAMES_T pos = ( ( ( payload.valveStatesBits & mask ) != 0 ) ? VALVE_STATE_OPEN : VALVE_STATE_CLOSED ); + for ( valve = FIRST_BC_VALVE; valve <= LAST_BC_VALVE; valve++ ) + { + mask = ( 0x1 << ( valve - FIRST_BC_VALVE ) ); + pos = ( ( ( payload.valveStatesBits & mask ) != 0 ) ? VALVE_STATE_OPEN : VALVE_STATE_CLOSED); - result = setValveState( valve, pos ); + if ( OVERRIDE_OVERRIDE == ovType ) + { + result = TRUE; + valveStates[ valve ].ovData = convertValveStateNameToValveState( pos ); + valveStates[ valve ].override = OVERRIDE_KEY; + } + else + { + result = TRUE; + valveStates[ valve ].override = OVERRIDE_RESET; + valveStates[ valve ].ovData = valveStates[ valve ].ovInitData; + } + } } return result; @@ -552,8 +735,15 @@ *************************************************************************/ BOOL testValveSensedStateOverride( MESSAGE_T *message ) { - BOOL result = u32ArrayOverride( message, &valveSensedStates[0], DD_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + if ( payload.index <= LAST_DD_VALVE ) + { + result = u32ArrayOverride( message, &valveSensedStates[0], DD_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); + } + return result; } @@ -582,7 +772,7 @@ memcpy( &payload, message->payload, sizeof(VALVE_CMD_PAYLOAD_T) ); if ( ( (DD_VALVES_T)payload.valveID < DD_NUM_OF_VALVES ) && - ( (VALVE_STATE_NAMES_T)payload.valveState < NUM_OF_VALVE_STATES ) ) + ( (VALVE_STATE_NAMES_T)payload.valveState < NUM_OF_VALVE_STATES ) ) { setValveState( (DD_VALVES_T)payload.valveID, (VALVE_STATE_NAMES_T)payload.valveState ); result = TRUE; @@ -593,4 +783,69 @@ return result; } +/*********************************************************************//** + * @brief + * The testIOFPValvesStatesPublishIntervalOverride function overrides the + * IOFP valves states publish interval. + * @details \b Inputs: none + * @details \b Outputs: valvesStatesPublishInterval + * @param message Override message from Dialin which includes the value + * that override valves states publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testIOFPValvesStatesPublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = u32BroadcastIntervalOverride( message, &fpValveStatesPublishInterval, TASK_PRIORITY_INTERVAL ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testIOFPValveStateOverride function overrides the value of the + * specified IOFP valve with a given value. + * @details \b Inputs: none + * @details \b Outputs: valveStates[] + * @param message Override message from Dialin which includes an ID of + * the valve to override and the state to override the valve to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testIOFPValveStateOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + + if ( ( payload.index >= FIRST_IO_VALVE ) && ( payload.index <= LAST_FP_VALVE ) ) + { + result = u32ArrayOverride( message, &valveStates[0], DD_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testIOFPValveSensedStateOverride function overrides the value of the + * specified sensed state of an IOFP valve with a given value. + * @details \b Inputs: none + * @details \b Outputs: valveSensedStates[] + * @param message Override message from Dialin which includes an ID of + * the valve to override and the state to override the valve to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testIOFPValveSensedStateOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &payload ); + + if ( ( payload.index >= FIRST_IO_VALVE ) && ( payload.index <= LAST_FP_VALVE ) ) + { + result = u32ArrayOverride( message, &valveSensedStates[0], DD_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); + } + + return result; +} + /**@}*/