/************************************************************************** * * Copyright (c) 2024-2024 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 Valves.c * * @author (last) Sean Nash * @date (last) 09-Nov-2024 * * @author (original) Sean Nash * @date (original) 09-Nov-2024 * ***************************************************************************/ #include // For memcpy #include "FpgaFP.h" #include "MessageSupport.h" #include "Messaging.h" #include "TaskPriority.h" #include "Timers.h" #include "Valves.h" /** * @addtogroup Valves * @{ */ // ********** private definitions ********** #define DEENERGIZED 0 ///< 0 for de-energized valve. #define ENERGIZED 1 ///< 1 for energized valve. #define ALL_VALVES_DEENERGIZED 0x0000 ///< 0 in U16 bit field for all valves. #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. /// Bits associated with RO valves when interfacing with FPGA to command a valve position. 1=energized, 0=de-energized. static const U16 ValveBits[ FP_NUM_OF_VALVES ] = { 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 0x0200, }; // ********** private data ********** static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. static U16 commandedValvesStates; ///< Initialize commanded valves states bit field. static U32 valveStateMismatchTimerCounter; ///< Initialize valve state mismatch timer. static U32 pendingValveStateChanges[ FP_NUM_OF_VALVES ]; ///< Delayed (pending) valve state changes. static U32 pendingValveStateChangeCountDowns[ FP_NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). static OVERRIDE_U32_T valveStates[ FP_NUM_OF_VALVES ]; ///< Currently commanded valves states. static OVERRIDE_U32_T valveSensedStates[ FP_NUM_OF_VALVES ]; ///< Valve sensed states override. static OVERRIDE_U32_T valvesStatesPublishInterval; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. // ********** private function prototypes ********** static void publishValvesStates( void ); static void updateValveStates( U16 readValveStates ); static U32 convertValveStateNameToValveState( VALVE_STATE_NAMES_T valveStateName ); static U32 getValveState( U32 valveID ); /*********************************************************************//** * @brief * The initValves function initializes the Valves unit. * @details \b Inputs: none * @details \b Outputs: Valves unit initialized * @return none *************************************************************************/ void initValves( void ) { FP_VALVES_T valve; // initialize valve states for ( valve = FP_FIRST_VALVE; valve < FP_NUM_OF_VALVES; valve++ ) { valveStates[ valve ].data = DEENERGIZED; valveStates[ valve ].ovInitData = DEENERGIZED; valveStates[ valve ].ovData = DEENERGIZED; valveStates[ valve ].override = OVERRIDE_RESET; pendingValveStateChanges[ valve ] = DEENERGIZED; pendingValveStateChangeCountDowns[ valve ] = 0; valveSensedStates[ valve ].data = DEENERGIZED; valveSensedStates[ valve ].ovInitData = DEENERGIZED; valveSensedStates[ valve ].ovData = DEENERGIZED; valveSensedStates[ valve ].override = OVERRIDE_RESET; } // initialize time intervals and timer counters valveStateMismatchTimerCounter = 0; valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer valvesStatesPublishInterval.data = VALVES_STATE_PUB_INTERVAL; valvesStatesPublishInterval.ovData = VALVES_STATE_PUB_INTERVAL; valvesStatesPublishInterval.ovInitData = 0; valvesStatesPublishInterval.override = OVERRIDE_RESET; // initially set all valves to de-energized state via FPGA updateValveStates( ALL_VALVES_DEENERGIZED ); setFPGAValveStates( commandedValvesStates ); } /*********************************************************************//** * @brief * The execValves function executes the valves controller. * @details \b Inputs: valvesStates, valveStateMismatchCounter * pendingValveStateChangeCountDowns, commandedValvesStates * @details \b Outputs: valvesStates, valveStateMismatchCounter * pendingValveStateChanges, valve controls * @details \b Alarm: ALARM_ID_RO_VALVE_CONTROL_FAILURE when FPGA read back * valve state mismatches with the commanded valve state after defined time (100ms). * @return none *************************************************************************/ void execValves( void ) { U32 valve; U16 readValvesStates = getFPGAValveStates(); // get valves states from FPGA // Verify read back FPGA valve states match last commanded valve states if ( readValvesStates != commandedValvesStates ) { valveStateMismatchTimerCounter++; // increment valve state mismatch counter by 1 if ( valveStateMismatchTimerCounter > MAX_VALVE_STATE_MISMATCH_TIMER_COUNT ) { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_VALVE_CONTROL_FAILURE, (U32)readValvesStates, (U32)commandedValvesStates ) } } else { valveStateMismatchTimerCounter = 0; } // Handle pending delayed valve state changes for ( valve = 0; valve < FP_NUM_OF_VALVES; valve++ ) { if ( pendingValveStateChangeCountDowns[ valve ] > 0 ) { pendingValveStateChangeCountDowns[ valve ]--; if ( 0 == pendingValveStateChangeCountDowns[ valve ] ) { valveStates[ valve ].data = pendingValveStateChanges[ valve ]; pendingValveStateChanges[ valve ] = DEENERGIZED; } } } // Set valves states (via FPGA) to currently commanded states updateValveStates( readValvesStates ); setFPGAValveStates( commandedValvesStates ); // Publish valve states on interval publishValvesStates(); } /*********************************************************************//** * @brief * The updateValveStates function updates the sensed valve states from FPGA * and sends latest commanded valve states to FPGA. * @details \b Inputs: valveStates[], ValveBits[] * @details \b Outputs: commandedValvesStates, valveSensedStates[] * @param readValveStates bits indicating read valve states * @return none *************************************************************************/ static void updateValveStates( U16 readValveStates ) { U32 valve; // Initialize before updating commanded states commandedValvesStates = ALL_VALVES_DEENERGIZED; // Update sensed valve states from FPGA and commanded valve state bits to FPGA for ( valve = FP_FIRST_VALVE; valve < FP_NUM_OF_VALVES; valve++ ) { valveSensedStates[ valve ].data = ( ( readValveStates & ValveBits[ valve ] ) != 0 ? VALVE_STATE_OPEN : VALVE_STATE_CLOSED ); commandedValvesStates |= ( getValveState( valve ) == ENERGIZED ? ValveBits[ valve ] : 0 ); } } /*********************************************************************//** * @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_RO_SOFTWARE_FAULT when invalid valve state name given * @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 if ( valveStateName < NUM_OF_VALVE_STATES ) { if ( VALVE_STATE_OPEN == valveStateName ) { vState = ENERGIZED; } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, (U32)valveStateName ) } return vState; } /*********************************************************************//** * @brief * The setValveState function sets the valve state for given valve. * @details \b Inputs: none * @details \b Outputs: valveStates[], pendingValveStateChanges[], pendingValveStateChangeCountDowns[] * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID or * valve state given. * @param valveID ID of valve to set state for * @param valveStateName name of valve state to set given valve to * @return TRUE if new valve state is set for given valve ID, FALSE if not. *************************************************************************/ BOOL setValveState( FP_VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ) { BOOL result = FALSE; // initialize result flag to FALSE if ( valveID < FP_NUM_OF_VALVES ) { if ( valveStateName < NUM_OF_VALVE_STATES ) { valveStates[ valveID ].data = convertValveStateNameToValveState( valveStateName ); result = TRUE; // If a delayed state change is pending for this valve, cancel it pendingValveStateChanges[ valveID ] = DEENERGIZED; pendingValveStateChangeCountDowns[ valveID ] = 0; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE1, valveID ) } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID1, valveID ) } return result; } /*********************************************************************//** * @brief * The setValveStateDelayed function sets the valve state for given valve * after a given delay. * @details \b Inputs: pendingValveStateChangeCountDowns[] * @details \b Outputs: pendingValveStateChangeCountDowns[], pendingValveStateChangeCountDowns[] * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID or * valve state given. * @param valveID ID of valve to set state for * @param valveStateName name of valve state to set given valve to * @param delayMs delay duration (in ms) before actuation * @return TRUE if new valve state is set for given valve ID, FALSE if not. *************************************************************************/ BOOL setValveStateDelayed( FP_VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName, U32 delayMs ) { BOOL result = FALSE; // initialize result flag to FALSE if ( valveID < FP_NUM_OF_VALVES ) { if ( valveStateName < NUM_OF_VALVE_STATES ) { // If a delayed state change is already pending for this valve, execute it now before setting a new delayed state change if ( pendingValveStateChangeCountDowns[ valveID ] > 0 ) { valveStates[ valveID ].data = pendingValveStateChanges[ valveID ]; } // Set delayed valve state change pendingValveStateChanges[ valveID ] = convertValveStateNameToValveState( valveStateName ); pendingValveStateChangeCountDowns[ valveID ] = delayMs / TASK_PRIORITY_INTERVAL; result = TRUE; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE2, valveID ) } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID2, valveID ) } return result; } /*********************************************************************//** * @brief * The getValveStateName function gets the current valve state enum for a * given valve. * @details \b Inputs: valveStates[] * @details \b Outputs: none * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID given. * @param valveID ID of valve to get state for * @return the current valve state for given valve in enum *************************************************************************/ VALVE_STATE_NAMES_T getValveStateName( FP_VALVES_T valveID ) { // Initialized per CppCheck. VALVE_STATE_NAMES_T name = NUM_OF_VALVE_STATES; if ( valveID < FP_NUM_OF_VALVES ) { U32 valveState = getU32OverrideValue( &valveSensedStates[ valveID ] ); name = ( ENERGIZED == valveState ? VALVE_STATE_OPEN : VALVE_STATE_CLOSED ); } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID3, valveID ) } return name; } /*********************************************************************//** * @brief * The getValveState function gets the current valve state for given valve. * @details \b Inputs: valveStates[] * @details \b Outputs: none * @details \b Alarm : ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID passed * @param valveID ID of valve to get state for * @return the current valve state for given valve *************************************************************************/ static U32 getValveState( U32 valveID ) { U32 valveState = DEENERGIZED; if ( valveID < FP_NUM_OF_VALVES ) { valveState = getU32OverrideValue( &valveStates[ valveID ] ); } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID4, valveID ) } return valveState; } /*********************************************************************//** * @brief * The publishValvesStates function publishes RO valves states at the set interval. * @details \b Inputs: valvesStatesPublicationTimerCounter * @details \b Outputs: valvesStatesPublicationTimerCounter * @details \b Message \b Sent: MSG_ID_RO_VALVES_STATES_DATA to publish FPGA read valve states. * @return none *************************************************************************/ static void publishValvesStates( void ) { // publish valve state on interval if ( ++valvesStatesPublicationTimerCounter >= getU32OverrideValue( &valvesStatesPublishInterval ) ) { RO_VALVES_DATA_T data; U32 valve; data.valvesCmdState = commandedValvesStates; for ( valve = 0; valve < FP_NUM_OF_VALVES; valve++ ) { data.valvesSensedState[ valve ] = (U08)getValveStateName( (FP_VALVES_T)valve ); } broadcastData( MSG_ID_FP_VALVES_STATES_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( RO_VALVES_DATA_T ) ); valvesStatesPublicationTimerCounter = 0; } } /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ /*********************************************************************//** * @brief * The testValvesStatesPublishIntervalOverride function overrides the * 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 testValvesStatesPublishIntervalOverride( MESSAGE_T *message ) { BOOL result = u32BroadcastIntervalOverride( message, &valvesStatesPublishInterval, TASK_PRIORITY_INTERVAL ); return result; } /*********************************************************************//** * @brief * The testValveStateOverride function overrides the value of the * specified 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 testValveStateOverride( MESSAGE_T *message ) { BOOL result = u32ArrayOverride( message, &valveStates[0], FP_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); return result; } /*********************************************************************//** * @brief * The testValveSensedStateOverride function overrides the value of the * specified sensed state 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 testValveSensedStateOverride( MESSAGE_T *message ) { BOOL result = u32ArrayOverride( message, &valveSensedStates[0], FP_NUM_OF_VALVES - 1, 0, NUM_OF_VALVE_STATES - 1 ); return result; } /**@}*/