Index: firmware/.settings/org.eclipse.core.resources.prefs =================================================================== diff -u -r52ded7b22d4b413aa8182f1343e4fbb78e8c3b0a -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/.settings/org.eclipse.core.resources.prefs (.../org.eclipse.core.resources.prefs) (revision 52ded7b22d4b413aa8182f1343e4fbb78e8c3b0a) +++ firmware/.settings/org.eclipse.core.resources.prefs (.../org.eclipse.core.resources.prefs) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -1,4 +1,6 @@ eclipse.preferences.version=1 +encoding//Debug/App/Controllers/subdir_rules.mk=UTF-8 +encoding//Debug/App/Controllers/subdir_vars.mk=UTF-8 encoding//Debug/App/Drivers/subdir_rules.mk=UTF-8 encoding//Debug/App/Drivers/subdir_vars.mk=UTF-8 encoding//Debug/App/Modes/subdir_rules.mk=UTF-8 Index: firmware/App/Controllers/ValvesDD.c =================================================================== diff -u --- firmware/App/Controllers/ValvesDD.c (revision 0) +++ firmware/App/Controllers/ValvesDD.c (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -0,0 +1,444 @@ +/************************************************************************** +* +* 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 ValvesDD.c +* +* @author (last) Vinayakam Mani +* @date (last) 14-Aug-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 14-Aug-2024 +* +***************************************************************************/ +#include // For memcpy +#include "Valves.h" +#include "ValvesDD.h" +#include "FPGADD.h" +#include "MessageSupport.h" +#include "Messaging.h" +#include "TaskPriority.h" +#include "Timers.h" + +/** + * @addtogroup Valves + * @{ + */ + +// ********** private definitions ********** + +#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. + +#define VPI_MIN_OPEN_TO_SKIP_DISINFECT_FLUSH_MS ( 2 * SEC_PER_MIN * MS_PER_SECOND ) ///< VPi minimum required time to be open to skip disinfects flush state in milliseconds. +#define VPI_MAX_OPEN_WINDOW_TO_SKIP_DISINFECT_FLUSH_MS ( 30 * SEC_PER_MIN * MS_PER_SECOND ) ///< VPi maximum allowed time window that VPi could have been open in milliseconds. + +/// VPi open/close time status for disinfects +typedef struct +{ + U32 vpiOpenStartTimeMS; ///< VPi open start time in milliseconds. + U32 vpiOpenDurationMS; ///< VPi duration that is has been open in milliseconds. + U32 vpiClosedStartTimeMS; ///< VPi closed start time in milliseconds. +} VPI_OPEN_CLOSE_TIME_T; + +// ********** private data ********** + +static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. +static U16 commandedValvesStates = ALL_VALVES_DEENERGIZED; ///< Initialize commanded valves states bit field. +static U32 valveStateMismatchTimerCounter; ///< Initialize valve state mismatch timer. +static U32 pendingValveStateChanges[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state changes. +static U32 pendingValveStateChangeCountDowns[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). + +static OVERRIDE_U32_T valveStates[ NUM_OF_VALVES ]; ///< Currently commanded valves states. +static OVERRIDE_U32_T valveSensedStates[ 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 VPI_OPEN_CLOSE_TIME_T vpiTime; ///< VPi open/close time structure. + +// ********** private function prototypes ********** + +static void publishValvesStates( void ); +static void checkVPiTimeStatus( void ); + +/*********************************************************************//** + * @brief + * The initValves function initializes the Valves module. + * @details \b Inputs: none + * @details \b Outputs: valveStates, pendingValveStateChanges, valveSensedStates, + * pendingValveStateChangeCountDowns, valveStateMismatchCounter, + * commandedValvesStates + * @return none + *************************************************************************/ + +void initValvesDD( void ) +{ + //generic valves initialization + initValves( valveStates, valveSensedStates, pendingValveStateChanges, pendingValveStateChangeCountDowns, (U32)NUM_OF_VALVES ); + + // initialize specific to DD module + memset( &vpiTime, 0, sizeof( VPI_OPEN_CLOSE_TIME_T ) ); + + valveStateMismatchTimerCounter = 0; + commandedValvesStates = fromU32ArrayToU16(); + setFPGAValveStates( commandedValvesStates ); // initially set all valves to de-energized state via FPGA + + valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer +} + +/*********************************************************************//** + * @brief + * The execValves function executes the valves driver. + * @details \b Inputs: valvesStates, valveStateMismatchCounter + * @details \b Outputs: valvesStates, valveStateMismatchCounter + * @details \b Alarm: ALARM_ID_DD_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 i; + 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 ) + { + activateAlarmNoData( ALARM_ID_DD_VALVE_CONTROL_FAILURE ); + } + } + else + { + valveStateMismatchTimerCounter = 0; + } + + // Handle pending delayed valve state changes + for ( i = 0; i < NUM_OF_VALVES; i++ ) + { + if ( pendingValveStateChangeCountDowns[ i ] > 0 ) + { + pendingValveStateChangeCountDowns[ i ]--; + if ( 0 == pendingValveStateChangeCountDowns[ i ] ) + { + valveStates[ i ].data = pendingValveStateChanges[ i ]; + pendingValveStateChanges[ i ] = DEENERGIZED; + } + } + } + + // Set valves states (via FPGA) to currently commanded states + commandedValvesStates = fromU32ArrayToU16(); + setFPGAValveStates( commandedValvesStates ); + + checkVPiTimeStatus(); + + // Publish valve states on interval + publishValvesStates(); +} + +/*********************************************************************//** + * @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. + *************************************************************************/ +BOOL checkValveStateName( VALVES_T valveID, VALVE_STATE_NAMES_T valveStateName ) +{ + BOOL result = FALSE; // initialize result flag to FALSE + + switch ( valveStateName ) + { + case VALVE_STATE_OPEN: + if ( ( valveID == VPI ) || ( valveID == VBF ) || ( valveID == VSP ) || ( VRD1 == valveID ) || ( VRD2 == valveID ) ) + { + result = TRUE; + } + break; + + case VALVE_STATE_CLOSED: + if ( ( valveID == VPI ) || ( valveID == VBF ) || ( valveID == VSP ) || ( VRD1 == valveID ) || ( VRD2 == valveID ) ) + { + result = TRUE; + } + break; + +// case VALVE_STATE_OPEN_C_TO_NC: +// if ( VPD == valveID ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_NOFILL_C_TO_NO: +// if ( valveID == VPO ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_FILL_C_TO_NC: +// if ( valveID == VPO ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_DRAIN_C_TO_NO: +// if ( ( valveID == VDR ) || ( valveID == VRC ) || ( VPD == valveID ) ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_RECIRC_C_TO_NC: +// if ( ( valveID == VDR ) || ( valveID == VRC ) ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_R1_C_TO_NO: +// if ( ( valveID == VRO ) || ( valveID == VRI ) ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_R1_C_TO_NC: +// if ( ( valveID == VRF ) ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_R2_C_TO_NO: +// if ( ( valveID == VRF ) ) +// { +// result = TRUE; +// } +// break; +// +// case VALVE_STATE_R2_C_TO_NC: +// if ( ( valveID == VRO ) || ( valveID == VRI ) ) +// { +// 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 getValveStateName function gets the current valve state enum for given valve. + * @details \b Inputs: valveStates[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid valve ID passed. + * @param valveID ID of valve to get state for + * @return the current valve state for given valve in enum + *************************************************************************/ +VALVE_STATE_NAMES_T getValveStateName( VALVES_T valveID ) +{ + // Initialized per CppCheck. + VALVE_STATE_NAMES_T name = NUM_OF_VALVE_STATES; + + if ( valveID < NUM_OF_VALVES ) + { + U32 valveState = getU32OverrideValue( &valveStates[ valveID ] ); + + if ( OVERRIDE_KEY == valveSensedStates[ valveID ].override ) + { + valveState = valveSensedStates[ valveID ].ovData; + } + + // Convert the bit status of the valve to the valve name + switch ( valveID ) + { + case VPI: + case VBF: + case VRD1: + case VRD2: + case VSP: + name = ( DEENERGIZED == valveState ? VALVE_STATE_CLOSED : VALVE_STATE_OPEN ); + break; + +// case VPD: +// name = ( DEENERGIZED == valveState ? VALVE_STATE_DRAIN_C_TO_NO : VALVE_STATE_OPEN_C_TO_NC ); +// break; +// +// case VPO: +// name = ( DEENERGIZED == valveState ? VALVE_STATE_NOFILL_C_TO_NO : VALVE_STATE_FILL_C_TO_NC ); +// break; +// +// case VDR: +// case VRC: +// name = ( DEENERGIZED == valveState ? VALVE_STATE_DRAIN_C_TO_NO : VALVE_STATE_RECIRC_C_TO_NC ); +// break; +// +// case VRI: +// case VRO: +// name = ( DEENERGIZED == valveState ? VALVE_STATE_R1_C_TO_NO : VALVE_STATE_R2_C_TO_NC ); +// break; +// +// case VRF: +// name = ( DEENERGIZED == valveState ? VALVE_STATE_R2_C_TO_NO : VALVE_STATE_R1_C_TO_NC ); +// break; + +#ifndef _VECTORCAST_ + default: + name = ( DEENERGIZED == valveState ? VALVE_STATE_CLOSED : VALVE_STATE_OPEN ); + break; +#endif + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) + } + + return name; +} + +/*********************************************************************//** + * @brief + * The isFliterFlushRequired function checks whether filter flush is required in + * cleaning modes. + * @details \b Inputs: vpiTime + * @details \b Outputs: none + * @return TRUE if filter flush is required otherwise, FALSE + *************************************************************************/ +BOOL isFliterFlushRequired( void ) +{ + BOOL status = TRUE; + + if ( vpiTime.vpiOpenDurationMS >= VPI_MIN_OPEN_TO_SKIP_DISINFECT_FLUSH_MS ) + { + status = ( calcTimeSince( vpiTime.vpiClosedStartTimeMS ) <= VPI_MAX_OPEN_WINDOW_TO_SKIP_DISINFECT_FLUSH_MS ? FALSE : TRUE ); + } + + return status; +} + +/*********************************************************************//** + * @brief + * The publishValvesStates function publishes DG valves states at the set interval. + * @details \b Inputs: valvesStatesPublicationTimerCounter + * @details \b Outputs: valvesStatesPublicationTimerCounter + * @details \b Messages: MSG_ID_DD_VALVES_STATES_DATA to publish FPGA read valve states. + * @return none + *************************************************************************/ +static void publishValvesStates( void ) +{ + // publish valve state on interval + if ( ++valvesStatesPublicationTimerCounter >= getU32OverrideValue( &valvesStatesPublishInterval ) ) + { + DD_VALVES_DATA_T data; + U32 i; + + data.valvesStatus = getFPGAValveStates(); + + for ( i = 0; i < NUM_OF_VALVES; i++ ) + { + data.valvesSensedState[ i ] = (U08)getValveStateName( (VALVES_T)i ); + } + + //broadcastData( MSG_ID_DD_VALVES_STATES_DATA, COMM_BUFFER_OUT_CAN_DG_BROADCAST, (U08*)&data, sizeof( DD_VALVES_DATA_T ) ); + + valvesStatesPublicationTimerCounter = 0; + } +} + +/*********************************************************************//** + * @brief + * The checkVPiTimeStatus function checks the status of the VPi to see if + * it was open or closed. + * @details \b Inputs: vpiTime + * @details \b Outputs: vpiTime + * @return none + *************************************************************************/ +static void checkVPiTimeStatus( void ) +{ + if ( ( VALVE_STATE_OPEN == getValveStateName( VPI ) ) && ( 0 == vpiTime.vpiOpenStartTimeMS ) ) + { + vpiTime.vpiOpenStartTimeMS = getMSTimerCount(); + vpiTime.vpiClosedStartTimeMS = 0; + } + else if ( ( VALVE_STATE_CLOSED == getValveStateName( VPI ) ) && ( 0 == vpiTime.vpiClosedStartTimeMS ) ) + { + vpiTime.vpiOpenDurationMS = calcTimeSince( vpiTime.vpiOpenStartTimeMS ); + vpiTime.vpiOpenStartTimeMS = 0; + vpiTime.vpiClosedStartTimeMS = getMSTimerCount(); + } +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testSetValvesStatesPublishIntervalOverride function overrides the + * valves states publish interval. + * @details \b Inputs: none + * @details \b Outputs: valvesStatesPublishInterval + * @param value override valves states publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetValvesStatesPublishIntervalOverride( U32 value ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + U32 intvl = value / TASK_PRIORITY_INTERVAL; + + result = TRUE; + valvesStatesPublishInterval.ovData = intvl; + valvesStatesPublishInterval.override = OVERRIDE_KEY; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetValvesStatesPublishIntervalOverride function resets the override + * of the valves states publish interval. + * @details \b Inputs: none + * @details \b Outputs: valvesStatesPublishInterval + * @return TRUE if override reset successful, FALSE if not + *************************************************************************/ +BOOL testResetValvesStatesPublishIntervalOverride( void ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + valvesStatesPublishInterval.override = OVERRIDE_RESET; + valvesStatesPublishInterval.ovData = valvesStatesPublishInterval.ovInitData; + } + + return result; +} + +/**@}*/ Index: firmware/App/Controllers/ValvesDD.h =================================================================== diff -u --- firmware/App/Controllers/ValvesDD.h (revision 0) +++ firmware/App/Controllers/ValvesDD.h (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -0,0 +1,91 @@ +/************************************************************************** +* +* 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 ValvesDD.h +* +* @author (last) Vinayakam Mani +* @date (last) 14-Aug-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 14-Aug-2024 +* +***************************************************************************/ + +#ifndef __VALVES_DD_H__ +#define __VALVES_DD_H__ + +#include "DDCommon.h" + +/** + * @defgroup Valves Valves + * @brief Valves driver module. Controls valves. + * + * @addtogroup Valves + * @{ + */ +/// Enumeration of valves. +typedef enum Valves +{ + VRF = 0, ///< Valve Reservoir Fill + VRI, ///< Valve Reservoir Inlet + RSRVD_SPACE, ///< This space has been reserved + VRO, ///< Valve Reservoir Outlet + VPO, ///< Valve Pressure Outlet + VBF, ///< Valve Bypass Filter + VRC, ///< Valve Recirculate + VDR, ///< Valve Drain + VPI, ///< Valve Pressure Inlet + VSP, ///< Valve Sampling Port + VRD1, ///< Valve Reservoir 1 Drain + VRD2, ///< Valve Reservoir 2 Drain + VPD, ///< Valve Production Drain + NUM_OF_VALVES ///< Number of valves +} VALVES_T; + +/// Enumeration of available valve state names per valve type (from SA and DG SRS documents). +// TODO : clean up the unwanted valve positions that are no longer needed. +typedef enum ValveStateNames +{ + VALVE_STATE_OPEN = 0, ///< Open valve state, used only for VPi, VBf, VRD1, VRD2, and VSP + VALVE_STATE_CLOSED, ///< Closed valve state, used only for VPi, VBf, VRD1, VRD2, and VSP +// VALVE_STATE_OPEN_C_TO_NC, ///< Open Common to Normally Closed valve state, used only for VPd +// VALVE_STATE_NOFILL_C_TO_NO, ///< No Fill Common to Normally Open valve state, used only for VPo +// VALVE_STATE_FILL_C_TO_NC, ///< Fill Common to Normally Closed valve state, used only for VPo +// VALVE_STATE_DRAIN_C_TO_NO, ///< Drain Common to Normally Open valve state, used only for VDr and VRc. It is also used for VPd in V3 +// VALVE_STATE_RECIRC_C_TO_NC, ///< Recirculate Common to Normally Closed valve state, used only for VDr and VRc +// VALVE_STATE_R1_C_TO_NO, ///< Reservoir 1 Common to Normally Open valve state, used only for VRo and VRi +// VALVE_STATE_R1_C_TO_NC, ///< Reservoir 1 Common to Normally Closed valve state, used only for VRf +// VALVE_STATE_R2_C_TO_NO, ///< Reservoir 2 Common to Normally Open valve state, used only for VRf +// VALVE_STATE_R2_C_TO_NC, ///< Reservoir 2 Common to Normally Closed valve state, used only for VRo and VRi + NUM_OF_VALVE_STATES ///< number of valve states +} VALVE_STATE_NAMES_T; + +#pragma pack(push, 1) +/// Valves publish structure +typedef struct +{ + U16 valvesStatus; ///< DG valves status. + U08 valvesSensedState[ NUM_OF_VALVES ]; ///< DG valves sensed states. +} DD_VALVES_DATA_T; +#pragma pack(pop) + +// ********** public function prototypes ********** + +void initValvesDD( void ); +void execValves( void ); + +VALVE_STATE_NAMES_T getValveStateName( VALVES_T valveID ); +BOOL isFliterFlushRequired( void ); +BOOL checkValveStateName( VALVES_T valve, VALVE_STATE_NAMES_T valveStateName ); + +BOOL testSetValvesStatesPublishIntervalOverride( U32 value ); +BOOL testResetValvesStatesPublishIntervalOverride( void ); + + +/**@}*/ + +#endif Index: firmware/App/Drivers/InternalADC.c =================================================================== diff -u --- firmware/App/Drivers/InternalADC.c (revision 0) +++ firmware/App/Drivers/InternalADC.c (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -0,0 +1,246 @@ +/************************************************************************** +* +* 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 InternalADC.c +* +* @author (last) Vinayakam Mani +* @date (last) 13-Aug-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 13-Aug-2024 +* +***************************************************************************/ + +#include "adc.h" + +#include "InternalADC.h" + +/** + * @addtogroup InternalADC + * @{ + */ + +// ********** private definitions ********** + +#define MAX_ADC_CHANNELS 24 ///< DG internal ADC supports up to 24 channels. +#define SIZE_OF_ROLLING_AVG 16 ///< Number of DG internal ADC samples in rolling average calculations for each channel. +#define ROLLING_AVG_SHIFT_DIVIDER 4 ///< Rolling average shift divider for DG internal ADC readings. + +/// ADC channel number to ADC channel ID (enumeration) look-up table. +const INT_ADC_CHANNEL_T adcChannelNum2ChannelId[ MAX_ADC_CHANNELS ] = +{ + INT_ADC_RO_PUMP_INLET_PRESSURE, // 0 + INT_ADC_RO_PUMP_OUTLET_PRESSURE, // 1 + INT_ADC_DRAIN_PUMP_OUTLET_PRESSURE, // 2 + INT_ADC_DRAIN_PUMP_INLET_PRESSURE, // 3 + INT_ADC_MAIN_24_VOLTS, // 4 + INT_ADC_FPGA_1_8_VOLTS, // 5 + INT_ADC_FPGA_1_VOLT, // 6 + INT_ADC_SENSORS_3_3_VOLTS, // 7 + INT_ADC_PROCESSOR_1_8_VOLTS, // 8 + INT_ADC_POWER_SUPPLY_GATE_DRIVER, // 9 + INT_ADC_SENSORS_5_VOLTS, // 10 + INT_ADC_LOGIC_5_VOLTS, // 11 + INT_ADC_3_3_VOLTS, // 12 + INT_ADC_RO_PUMP_FEEDBACK_DUTY_CYCLE, // 13 + INT_ADC_AVAILABLE_CHANNEL, // 14 + INT_ADC_PROCESSOR_1_2_VOLTS, // 15 + INT_ADC_REFERENCE_VOLTAGE, // 16 + INT_ADC_TRIMMER_HEATER_24_VOLTS, // 17 + INT_ADC_SECONDARY_HEATER_24_VOLTS, // 18 + INT_ADC_REF_IN1, // 19 + INT_ADC_REF_IN2, // 20 + INT_ADC_BOARD_THERMISTOR, // 21 + INT_ADC_POWER_SUPPLY_1_THERMISTOR, // 22 + INT_ADC_MAIN_NON_ISOLATED_24_VOLTS, // 23 +}; + +const F32 ADC_CHANNEL_READ_TO_UNITS[ NUM_OF_INT_ADC_CHANNELS ] = +{ + 0.0, // - INT_ADC_NOT_USED + 0.06438104, // PSIA- INT_ADC_RO_PUMP_INLET_PRESSURE + 0.06438104, // PSIA- INT_ADC_RO_PUMP_OUTLET_PRESSURE + 0.06438104, // PSIA- INT_ADC_DRAIN_PUMP_OUTLET_PRESSURE + 0.06438104, // PSIA- INT_ADC_DRAIN_PUMP_INLET_PRESSURE + 0.00073242, // V - INT_ADC_RO_PUMP_FEEDBACK_DUTY_CYCLE + 1.0, // ? - INT_ADC_AVAILABLE_CHANNEL + 0.00763285, // V - INT_ADC_TRIMMER_HEATER_24_VOLTS (varies inversely with PWM) + 0.00700441, // V - INT_ADC_SECONDARY_HEATER_24_VOLTS (varies inversely with PWM for secondary element) + 0.001221, // V - INT_ADC_BOARD_THERMISTOR + 0.0007326, // V - INT_ADC_FPGA_1_8_VOLTS + 0.0007326, // V - INT_ADC_FPGA_1_VOLT + 0.0007326, // V - INT_ADC_PROCESSOR_1_8_VOLTS + 0.0007326, // V - INT_ADC_PROCESSOR_1_2_VOLTS + 0.00117296, // V - INT_ADC_SENSORS_3_3_VOLTS + 0.0014652, // V - INT_ADC_SENSORS_5_VOLTS + 0.00700441, // V - INT_ADC_MAIN_24_VOLTS + 0.0014652, // V - INT_ADC_LOGIC_5_VOLTS + 0.00117296, // V - INT_ADC_3_3_VOLTS + 0.00117296, // V - INT_ADC_REFERENCE_VOLTAGE (3V) + 0.0014652, // V - INT_ADC_REF_IN1 (3V) + 0.0014652, // V - INT_ADC_REF_IN2 (3V) + 0.001221, // V - INT_ADC_POWER_SUPPLY_1_THERMISTOR + 0.00700441, // V - INT_ADC_MAIN_NON_ISOLATED_24_VOLTS + 0.00304608 // V - INT_ADC_POWER_SUPPLY_GATE_DRIVER (5V) +}; + +// ********** private data ********** + +static adcData_t adcRawReadings[ NUM_OF_INT_ADC_CHANNELS ]; ///< Buffer holds latest adc channel readings. +static U32 adcRawReadingsCount = 0; ///< Readings count for raw readings buffer. + +static U16 adcReadings[ NUM_OF_INT_ADC_CHANNELS ][ SIZE_OF_ROLLING_AVG ]; ///< Buffer holds samples for each channel for a rolling average. +static U32 adcReadingsIdx[ NUM_OF_INT_ADC_CHANNELS ]; ///< Index for next reading in each rolling average buffer. +static U32 adcReadingsTotals[ NUM_OF_INT_ADC_CHANNELS ]; ///< Rolling sum for each ADC channel - used to calc average. +static U32 adcReadingsAvgs[ NUM_OF_INT_ADC_CHANNELS ]; ///< Rolling average for each ADC channel. + +/*********************************************************************//** + * @brief + * The initInternalADC function initializes the InternalADC module. + * @details \b Inputs: none + * @details \b Outputs: InternalADC module is initialized. + * @return none + *************************************************************************/ +void initInternalADC( void ) +{ + U32 c,r; + + // zero all adc values and stats + adcRawReadingsCount = 0; + for ( c = 0; c < NUM_OF_INT_ADC_CHANNELS; c++ ) + { + adcRawReadings[ c ].id = 0; + adcRawReadings[ c ].value = 0; + adcReadingsIdx[ c ] = 0; + adcReadingsTotals[ c ] = 0; + adcReadingsAvgs[ c ] = 0; + for ( r = 0; r < SIZE_OF_ROLLING_AVG; r++ ) + { + adcReadings[ c ][ r ] = 0; + } + } + + // enable interrupt when all channels converted + adcEnableNotification( adcREG1, adcGROUP1 ); +} + +/*********************************************************************//** + * @brief + * The adcNotification function handles an ADC conversion complete interrupt. + * All channel readings in the FIFO are retrieved. + * @details \b Inputs: ADC FIFO + * @details \b Outputs: adcRawReadingsCount, adcRawReadings[] + * @param adc pointer to the ADC1 controller + * @param group ADC channel group ID + * @return none + *************************************************************************/ +void adcNotification( adcBASE_t *adc, uint32 group ) +{ + if ( adcGROUP1 == group ) + { + adcRawReadingsCount = adcGetData( adcREG1, adcGROUP1, adcRawReadings ); + } +} + +/*********************************************************************//** + * @brief + * The execInternalADC function processes the last set of raw ADC channel + * readings and kicks off the next conversion of ADC channels. + * @details \b Inputs: adcRawReadingsCount, adcRawReadings[] + * @details \b Outputs: adcReadings[][], adcReadingsIdx[], adcReadingsTotals[], adcReadingsAvgs[] + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid ADC channel number + * processed. + * @param adc pointer to the ADC1 controller + * @param group ADC channel group ID + * @return none + *************************************************************************/ +void execInternalADC( void ) +{ + U32 i; + + if ( adcRawReadingsCount < NUM_OF_INT_ADC_CHANNELS ) + { + // process readings from last conversion + for ( i = 0; i < adcRawReadingsCount; i++ ) + { + if ( adcRawReadings[ i ].id < NUM_OF_INT_ADC_CHANNELS ) + { + U32 ch = adcChannelNum2ChannelId[ adcRawReadings[ i ].id ]; + + adcReadingsTotals[ ch ] -= adcReadings[ ch ][ adcReadingsIdx[ ch ] ]; + adcReadings[ ch ][ adcReadingsIdx[ ch ] ] = adcRawReadings[i].value; + adcReadingsTotals[ ch ] += adcRawReadings[ i ].value; + adcReadingsAvgs[ ch ] = adcReadingsTotals[ ch ] >> ROLLING_AVG_SHIFT_DIVIDER; + adcReadingsIdx[ ch ] = INC_WRAP( adcReadingsIdx[ ch ], 0, SIZE_OF_ROLLING_AVG - 1 ); + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_INT_ADC_CHANNEL_NUMBER, adcRawReadings[ i ].id ) + } + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_DATA_OVERRUN, adcRawReadingsCount ) + } + + // start an adc channel group conversion + adcStartConversion( adcREG1, adcGROUP1 ); +} + +/*********************************************************************//** + * @brief + * The getIntADCReading function gets the latest average reading for a given channel. + * @details \b Inputs: adcReadingsAvgs[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid ADC channel requested. + * @param channel adc channel to retrieve a reading for + * @return average reading for the given channel + *************************************************************************/ +U16 getIntADCReading( INT_ADC_CHANNEL_T channel ) +{ + U16 result = 0; + + if ( channel < NUM_OF_INT_ADC_CHANNELS ) + { + result = adcReadingsAvgs[ channel ]; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED, channel ) + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getIntADCVoltageConverted function gets the latest average voltage + * (converted per transfer function) for a given channel. + * @details \b Inputs: adcReadingsAvgs[], ADC_CHANNEL_READ_TO_UNITS[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when invalid ADC channel requested. + * @param channel adc channel to retrieve a converted voltage for + * @return average converted voltage for the given channel + *************************************************************************/ +F32 getIntADCVoltageConverted( INT_ADC_CHANNEL_T channel ) +{ + F32 result = 0.0; + + if ( channel < NUM_OF_INT_ADC_CHANNELS ) + { + result = (F32)adcReadingsAvgs[ channel ] * ADC_CHANNEL_READ_TO_UNITS[ channel ]; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED, channel ) + } + + return result; +} + +/**@}*/ Index: firmware/App/Drivers/InternalADC.h =================================================================== diff -u --- firmware/App/Drivers/InternalADC.h (revision 0) +++ firmware/App/Drivers/InternalADC.h (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -0,0 +1,77 @@ +/************************************************************************** +* +* 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 InternalADC.h +* +* @author (last) Vinayakam Mani +* @date (last) 13-Aug-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 13-Aug-2024 +* +***************************************************************************/ + +#ifndef __INT_ADC_H__ +#define __INT_ADC_H__ + +#include "DDCommon.h" + +/** + * @defgroup InternalADC InternalADC + * @brief DD internal ADC module. + * + * @addtogroup InternalADC + * @{ + */ + +// ********** public definitions ********** + +#define INT_ADC_BITS_PER_CHANNEL 12 ///< DD internal ADC bits per channel. +#define INT_ADC_FULL_SCALE_BITS 4095 ///< DD internal ADC full scale range. +#define INT_ADC_REF_V 3.0F ///< DD internal ADC reference voltage. + +/// Enumeration of DD internal ADC channels. +typedef enum Int_ADC_Channels +{ + INT_ADC_NOT_USED = 0, ///< DD internal ADC channel not used + INT_ADC_RO_PUMP_INLET_PRESSURE, ///< DD internal ADC RO pump inlet pressure channel + INT_ADC_RO_PUMP_OUTLET_PRESSURE, ///< DD internal ADC RO pump outlet pressure channel + INT_ADC_DRAIN_PUMP_OUTLET_PRESSURE, ///< DD internal ADC drain pump outlet pressure channel + INT_ADC_DRAIN_PUMP_INLET_PRESSURE, ///< DD internal ADC drain pump inlet pressure channel + INT_ADC_RO_PUMP_FEEDBACK_DUTY_CYCLE, ///< DD internal ADC RO pump feedback duty cycle channel + INT_ADC_AVAILABLE_CHANNEL, ///< DD internal ADC available channel + INT_ADC_SECONDARY_HEATER_24_VOLTS, ///< DD internal ADC secondary heater 24 volt supply channel + INT_ADC_TRIMMER_HEATER_24_VOLTS, ///< DD internal ADC trimmer heater 24 volt supply channel + INT_ADC_BOARD_THERMISTOR, ///< DD internal ADC DD board thermistor channel + INT_ADC_FPGA_1_8_VOLTS, ///< DD internal ADC DD FPGA 1.8 volt supply channel + INT_ADC_FPGA_1_VOLT, ///< DD internal ADC DD FPGA 1 volt supply channel + INT_ADC_PROCESSOR_1_8_VOLTS, ///< DD internal ADC DD processor 1.8 volt supply channel + INT_ADC_PROCESSOR_1_2_VOLTS, ///< DD internal ADC DD processor 1.2 volt supply channel + INT_ADC_SENSORS_3_3_VOLTS, ///< DD internal ADC DD sensors 3.3 volt supply channel + INT_ADC_SENSORS_5_VOLTS, ///< DD internal ADC DD sensors 5 volt supply channel + INT_ADC_MAIN_24_VOLTS, ///< DD internal ADC DD 24 volt supply channel + INT_ADC_LOGIC_5_VOLTS, ///< DD internal ADC DD logic 5 volt supply channel + INT_ADC_3_3_VOLTS, ///< DD internal ADC DD 3.3 volt supply channel + INT_ADC_REFERENCE_VOLTAGE, ///< DD internal ADC reference voltage channel + INT_ADC_REF_IN1, ///< DD internal ADC external ADC1 reference voltage channel + INT_ADC_REF_IN2, ///< DD internal ADC external ADC2 reference voltage channel + INT_ADC_POWER_SUPPLY_1_THERMISTOR, ///< DD internal ADC DD power supply 1 thermistor + INT_ADC_MAIN_NON_ISOLATED_24_VOLTS, ///< DD internal ADC DD 24 volts non-isolated voltage channel + INT_ADC_POWER_SUPPLY_GATE_DRIVER, ///< DD internal ADC DD power supply gate driver + NUM_OF_INT_ADC_CHANNELS ///< Number of DD internal ADC channels +} INT_ADC_CHANNEL_T; + +// ********** public function prototypes ********** + +void initInternalADC( void ); +void execInternalADC( void ); +U16 getIntADCReading( INT_ADC_CHANNEL_T channel ); +F32 getIntADCVoltageConverted( INT_ADC_CHANNEL_T channel ); + +/**@}*/ + +#endif Index: firmware/App/Modes/ModeFault.c =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Modes/ModeFault.c (.../ModeFault.c) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Modes/ModeFault.c (.../ModeFault.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -23,7 +23,7 @@ /** - * @addtogroup DGFaultMode + * @addtogroup DDFaultMode * @{ */ @@ -33,13 +33,13 @@ // ********** private data ********** -static DG_FAULT_STATE_T faultState; ///< Currently active fault state. +static DD_FAULT_STATE_T faultState; ///< Currently active fault state. static SELF_TEST_STATUS_T faultPOSTSelfTestResult; ///< Fault POST self test result. // ********** private function prototypes ********** -static DG_FAULT_STATE_T handleFaultStartState( void ); -static DG_FAULT_STATE_T handleFaultRunNVPOSTsState( void ); +static DD_FAULT_STATE_T handleFaultStartState( void ); +static DD_FAULT_STATE_T handleFaultRunNVPOSTsState( void ); /*********************************************************************//** * @brief @@ -50,7 +50,7 @@ *************************************************************************/ void initFaultMode( void ) { - faultState = DG_FAULT_STATE_START; + faultState = DD_FAULT_STATE_START; faultPOSTSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; } @@ -103,15 +103,15 @@ // execute current fault state switch ( faultState ) { - case DG_FAULT_STATE_START: + case DD_FAULT_STATE_START: faultState = handleFaultStartState(); break; - case DG_FAULT_STATE_RUN_NV_POSTS: + case DD_FAULT_STATE_RUN_NV_POSTS: faultState = handleFaultRunNVPOSTsState(); break; - case DG_FAULT_STATE_COMPLETE: + case DD_FAULT_STATE_COMPLETE: // Do nothing unless the test configuration to recover treatment is enabled if ( ( TRUE == getTestConfigStatus( TEST_CONFIG_RECOVER_TREATMENT ) ) && ( TRUE == hasRecoverFromFaultModeBeenSet() ) ) { @@ -122,7 +122,7 @@ break; default: - faultState = DG_FAULT_STATE_COMPLETE; + faultState = DD_FAULT_STATE_COMPLETE; break; } @@ -136,7 +136,7 @@ * @details \b Outputs: none * @return current state of fault mode *************************************************************************/ -DG_FAULT_STATE_T getCurrentFaultState( void ) +DD_FAULT_STATE_T getCurrentFaultState( void ) { return faultState; } @@ -174,8 +174,8 @@ // requestConcentratePumpOff( CONCENTRATEPUMPS_CP2_BICARB, parkPumps ); // signalROPumpHardStop(); // signalDrainPumpHardStop(); -// stopHeater( DG_PRIMARY_HEATER ); -// stopHeater( DG_TRIMMER_HEATER ); +// stopHeater( DD_PRIMARY_HEATER ); +// stopHeater( DD_TRIMMER_HEATER ); } /*********************************************************************//** @@ -185,9 +185,9 @@ * @details \b Outputs: none * @return next state *************************************************************************/ -static DG_FAULT_STATE_T handleFaultStartState( void ) +static DD_FAULT_STATE_T handleFaultStartState( void ) { - DG_FAULT_STATE_T state = DG_FAULT_STATE_START; + DD_FAULT_STATE_T state = DD_FAULT_STATE_START; //NVDATAMGMT_RECORDS_READ_STATUS_T status = getNVRecordsReadStatus(); // switch ( status ) @@ -196,12 +196,12 @@ // // their CRCs. // case NVDATAMGMT_RECORDS_QUEUED: // case NVDATAMGMT_RECORDS_READ: -// state = DG_FAULT_STATE_RUN_NV_POSTS; +// state = DD_FAULT_STATE_RUN_NV_POSTS; // break; // // // If the NV post was completed prior to transitioning to fault mode, do nothing // case NVDATAMGMT_RECORDS_CRC_CHECKED: -// state = DG_FAULT_STATE_COMPLETE; +// state = DD_FAULT_STATE_COMPLETE; // break; // } @@ -215,16 +215,16 @@ * @details \b Outputs: faultPOSTSelfTestResult * @return next state *************************************************************************/ -static DG_FAULT_STATE_T handleFaultRunNVPOSTsState( void ) +static DD_FAULT_STATE_T handleFaultRunNVPOSTsState( void ) { - DG_FAULT_STATE_T state = DG_FAULT_STATE_RUN_NV_POSTS; + DD_FAULT_STATE_T state = DD_FAULT_STATE_RUN_NV_POSTS; // faultPOSTSelfTestResult = execNVDataMgmtSelfTest(); // // // Regardless of the status of the NV POST transition to the complete state. // if ( ( SELF_TEST_STATUS_PASSED == faultPOSTSelfTestResult ) || ( SELF_TEST_STATUS_FAILED == faultPOSTSelfTestResult ) ) // { -// state = DG_FAULT_STATE_COMPLETE; +// state = DD_FAULT_STATE_COMPLETE; // } return state; Index: firmware/App/Modes/ModeFault.h =================================================================== diff -u -r8b8fff67b95805272f37855346d600599aaec03d -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Modes/ModeFault.h (.../ModeFault.h) (revision 8b8fff67b95805272f37855346d600599aaec03d) +++ firmware/App/Modes/ModeFault.h (.../ModeFault.h) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -37,7 +37,7 @@ U32 transitionToFaultMode( void ); // prepares for transition to fault mode U32 execFaultMode( void ); // execute the fault mode state machine (call from OperationModes) -DG_FAULT_STATE_T getCurrentFaultState( void ); // get the current state of the fault mode. +DD_FAULT_STATE_T getCurrentFaultState( void ); // get the current state of the fault mode. void deenergizeActuators( BOOL parkPumps ); Index: firmware/App/Modes/ModeInitPOST.c =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Modes/ModeInitPOST.c (.../ModeInitPOST.c) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Modes/ModeInitPOST.c (.../ModeInitPOST.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -43,7 +43,7 @@ #include "WatchdogMgmt.h" /** - * @addtogroup DGInitAndPOSTMode + * @addtogroup DDInitAndPOSTMode * @{ */ @@ -76,7 +76,7 @@ *************************************************************************/ void initInitAndPOSTMode( void ) { - postState = DG_POST_STATE_START; + postState = DD_POST_STATE_START; postCompleted = FALSE; postPassed = FALSE; tempPOSTPassed = TRUE; @@ -123,51 +123,51 @@ // execute current POST state switch ( postState ) { - case DG_POST_STATE_START: + case DD_POST_STATE_START: postState = handlePOSTStateStart(); #ifdef BOARD_WITH_NO_HARDWARE - postState = DG_POST_STATE_RTC; + postState = DD_POST_STATE_RTC; #endif break; - case DG_POST_STATE_FW_COMPATIBILITY: + case DD_POST_STATE_FW_COMPATIBILITY: //testStatus = execFWCompatibilityTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_FW_INTEGRITY: + case DD_POST_STATE_FW_INTEGRITY: //testStatus = execIntegrityTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_FPGA: + case DD_POST_STATE_FPGA: //testStatus = execFPGATest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_RTC: + case DD_POST_STATE_RTC: //testStatus = execRTCSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_NVDATAMGMT: + case DD_POST_STATE_NVDATAMGMT: //testStatus = execNVDataMgmtSelfTest(); postState = handlePOSTStatus( testStatus ); break; // NOTE: all the actuators and sensors must execute their POST after NVDataMgmt // NVDataMgmt must load all the calibration data into RAM so the actuators // can query their corresponding calibration values successfully - case DG_POST_STATE_TEMPERATURE_SENSORS: + case DD_POST_STATE_TEMPERATURE_SENSORS: #ifndef BOARD_WITH_NO_HARDWARE //testStatus = execTemperatureSensorsSelfTest(); postState = handlePOSTStatus( testStatus ); #else - postState = DG_POST_STATE_COMPLETED; + postState = DD_POST_STATE_COMPLETED; #endif break; - case DG_POST_STATE_ACCELEROMETER: + case DD_POST_STATE_ACCELEROMETER: #ifndef _RELEASE_ //if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_ACCELS ) != SW_CONFIG_ENABLE_VALUE ) #endif @@ -183,32 +183,32 @@ postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_PRESSURES: + case DD_POST_STATE_PRESSURES: //testStatus = execPressureSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_DRAIN_PUMP: + case DD_POST_STATE_DRAIN_PUMP: //testStatus = execDrainPumpSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_CONCENTRATE_PUMPS: + case DD_POST_STATE_CONCENTRATE_PUMPS: //testStatus = execConcenratePumpsSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_CONDUCTIVITY_SENSORS: + case DD_POST_STATE_CONDUCTIVITY_SENSORS: //testStatus = execConductivitySensorsSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_RESERVOIRS: + case DD_POST_STATE_RESERVOIRS: //testStatus = execReservoirsSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_UV_REACTORS: + case DD_POST_STATE_UV_REACTORS: #ifndef _RELEASE_ //if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_UV_REACTORS ) != SW_CONFIG_ENABLE_VALUE ) #endif @@ -224,47 +224,47 @@ postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_THERMISTORS: + case DD_POST_STATE_THERMISTORS: //testStatus = execThermistorsSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_FANS: + case DD_POST_STATE_FANS: //testStatus = execFansSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_FLOW_SENSORS: + case DD_POST_STATE_FLOW_SENSORS: //testStatus = execFlowSensorsSelfTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_WATCHDOG: + case DD_POST_STATE_WATCHDOG: //testStatus = execWatchdogTest(); postState = handlePOSTStatus( testStatus ); break; - case DG_POST_STATE_SAFETY_SHUTDOWN: + case DD_POST_STATE_SAFETY_SHUTDOWN: //testStatus = execSafetyShutdownTest(); postState = handlePOSTStatus( testStatus ); break; // Should be last POST (and last POST test must be a test that completes in a single call) - case DG_POST_STATE_LOAD_CELL: + case DD_POST_STATE_LOAD_CELL: //testStatus = execLoadCellsSelfTest(); handlePOSTStatus( testStatus ); // Ignoring return value because last test if ( TRUE == tempPOSTPassed ) { - postState = DG_POST_STATE_COMPLETED; + postState = DD_POST_STATE_COMPLETED; } else { - postState = DG_POST_STATE_FAILED; + postState = DD_POST_STATE_FAILED; } break; - case DG_POST_STATE_COMPLETED: + case DD_POST_STATE_COMPLETED: // Set overall HD POST status to "passed" postPassed = TRUE; // Set overall HD POST completed status to TRUE @@ -277,11 +277,11 @@ requestNewOperationMode( DD_MODE_STAN ); break; - case DG_POST_STATE_FAILED: + case DD_POST_STATE_FAILED: // Should not get here - any failed post test should have already triggered a fault and taken us to fault m default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_INIT_POST_INVALID_POST_STATE, postState ) - postState = DG_POST_STATE_FAILED; + postState = DD_POST_STATE_FAILED; break; } @@ -290,7 +290,7 @@ /*********************************************************************//** * @brief - * The isPOSTCompleted function determines whether all DG POST have been run + * The isPOSTCompleted function determines whether all DD POST have been run * and completed. If true, call the isPOSTPassed() to see final result (pass/fail). * @details \b Inputs: postCompleted * @details \b Outputs: none @@ -352,7 +352,7 @@ *************************************************************************/ static DD_POST_STATE_T handlePOSTStateStart( void ) { - DD_POST_STATE_T state = DG_POST_STATE_START; + DD_POST_STATE_T state = DD_POST_STATE_START; // There is a delay before starting POST to make sure the CAN bus is up and listening so // when the event data can be sent @@ -363,12 +363,12 @@ systemREG1->SYSESR = systemREG1->SYSESR; // clear reset bit(s) after logging event so subsequent resets can be properly identified as not being power-on resets. // Send the startup event - SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_STARTUP, systemREG1->DEV, 0x12345678 ) // log startup event w/ device ID bits - SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_STARTUP, resetReason, systemREG1->GBLSTAT ) // log startup event w/ reset reason(s) bits + SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_STARTUP, systemREG1->DEV, 0x12345678 ) // log startup event w/ device ID bits + SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_STARTUP, resetReason, systemREG1->GBLSTAT ) // log startup event w/ reset reason(s) bits // Send the first submode change event. It is the mode Init and it does not start from a previous // mode previous and current are both published as Init - SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_OP_MODE_CHANGE, DD_MODE_INIT, DD_MODE_INIT ) - state = DG_POST_STATE_FW_COMPATIBILITY; + SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_OP_MODE_CHANGE, DD_MODE_INIT, DD_MODE_INIT ) + state = DD_POST_STATE_FW_COMPATIBILITY; startPOSTDelayCounter = 0; } Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -20,7 +20,6 @@ //#include "CPLD.h" //#include "DrainPump.h" //#include "Heaters.h" -#include "MessageSupport.h" //#include "ModeChemicalDisinfect.h" #include "ModeFault.h" //#include "ModeHeatDisinfect.h" @@ -34,11 +33,12 @@ #include "SystemCommDD.h" #include "Messaging.h" #include "TaskGeneral.h" +#include "MessageSupport.h" //#include "Timers.h" //#include "Valves.h" /** - * @addtogroup DGStandbyMode + * @addtogroup DDStandbyMode * @{ */ @@ -51,22 +51,22 @@ // ********** private data ********** -static DG_STANDBY_MODE_STATE_T standbyState; ///< Currently active standby state. +static DD_STANDBY_MODE_STATE_T standbyState; ///< Currently active standby state. //static BOOL stopSampleWaterRequest; ///< Flag indicating HD has requested to stop sample water //static BOOL startSampleWaterRequest; ///< Flag indicating HD has requested to start sample water //static BOOL flushFilterRequest; ///< Flag indicating HD has requested to flush filters //static BOOL endSampleWaterRequest; ///< Flag indicating HD has requested to end sample water // -//static BOOL pendingStartDGRequest; ///< Flag indicating HD has requested DG start (go to generation idle mode). +//static BOOL pendingStartDGRequest; ///< Flag indicating HD has requested DD start (go to generation idle mode). //static U32 waterSampleStartTime; ///< Time stamp for start of water sample state. //static U32 filterFlushStartTime; ///< Time stamp for start of filter flush state. //static U32 filterFlushPublishTimerCounter; ///< Filter flush data publish timer counter. -//static BOOL pendingStartDGFlushRequest; ///< Flag indicating HD has requested DG start flush. -//static BOOL pendingStartDGHeatDisinfectRequest; ///< Flag indicating HD has requested DG start heat disinfect. -//static BOOL pendingStartDGChemicalDisinfectRequest; ///< Flag indicating HD has requested DG start chemical disinfect. -//static BOOL pendingStartDGHeatDisinfectActiveCoolRequest; ///< Flag indicating HD has requested DG start heat disinfect active cool. -//static BOOL pendingStartDGChemicalDisinfectFlushRequest; ///< Flag indicating HD has requested DG start chemical disinfect flush. -//static BOOL pendingStartDGROPermeateSampleRequest; ///< Flag indicating HD has requested DG start RO permeate sample. +//static BOOL pendingStartDGFlushRequest; ///< Flag indicating HD has requested DD start flush. +//static BOOL pendingStartDGHeatDisinfectRequest; ///< Flag indicating HD has requested DD start heat disinfect. +//static BOOL pendingStartDGChemicalDisinfectRequest; ///< Flag indicating HD has requested DD start chemical disinfect. +//static BOOL pendingStartDGHeatDisinfectActiveCoolRequest; ///< Flag indicating HD has requested DD start heat disinfect active cool. +//static BOOL pendingStartDGChemicalDisinfectFlushRequest; ///< Flag indicating HD has requested DD start chemical disinfect flush. +//static BOOL pendingStartDGROPermeateSampleRequest; ///< Flag indicating HD has requested DD start RO permeate sample. static OVERRIDE_U32_T filterFlushTimePeriod = { FILTER_FLUSH_TIME_MS, FILTER_FLUSH_TIME_MS, 0, 0 }; ///< Filter flush time period in ms. @@ -75,11 +75,11 @@ static BOOL areInletWaterConditionsAlarmsActive( void ); -static DG_STANDBY_MODE_STATE_T handleStandbyIdleState( void ); -static DG_STANDBY_MODE_STATE_T handleStandbyFlushFilterState( void ); -static DG_STANDBY_MODE_STATE_T handleStandbyFlushFilterIdleState( void ); -static DG_STANDBY_MODE_STATE_T handleStandbySampleWaterState( void ); -static DG_STANDBY_MODE_STATE_T handleStandbyPauseState( void ); +static DD_STANDBY_MODE_STATE_T handleStandbyIdleState( void ); +static DD_STANDBY_MODE_STATE_T handleStandbyFlushFilterState( void ); +static DD_STANDBY_MODE_STATE_T handleStandbyFlushFilterIdleState( void ); +static DD_STANDBY_MODE_STATE_T handleStandbySampleWaterState( void ); +static DD_STANDBY_MODE_STATE_T handleStandbyPauseState( void ); /*********************************************************************//** * @brief @@ -94,7 +94,7 @@ *************************************************************************/ void initStandbyMode( void ) { - standbyState = DG_STANDBY_MODE_STATE_IDLE; + standbyState = DD_STANDBY_MODE_STATE_IDLE; // stopSampleWaterRequest = FALSE; // startSampleWaterRequest = FALSE; // flushFilterRequest = FALSE; @@ -169,35 +169,35 @@ if ( TRUE == areInletWaterConditionsAlarmsActive() ) { //setValveState( VSP, VALVE_STATE_CLOSED ); - standbyState = DG_STANDBY_MODE_STATE_PAUSE; + standbyState = DD_STANDBY_MODE_STATE_PAUSE; } // execute current Standby state switch ( standbyState ) { - case DG_STANDBY_MODE_STATE_IDLE: + case DD_STANDBY_MODE_STATE_IDLE: standbyState = handleStandbyIdleState(); break; - case DG_STANDBY_MODE_STATE_FLUSH_FILTER: + case DD_STANDBY_MODE_STATE_FLUSH_FILTER: standbyState = handleStandbyFlushFilterState(); break; - case DG_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE: + case DD_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE: standbyState = handleStandbyFlushFilterIdleState(); break; - case DG_STANDBY_MODE_STATE_SAMPLE_WATER: + case DD_STANDBY_MODE_STATE_SAMPLE_WATER: standbyState = handleStandbySampleWaterState(); break; - case DG_STANDBY_MODE_STATE_PAUSE: + case DD_STANDBY_MODE_STATE_PAUSE: standbyState = handleStandbyPauseState(); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_STANDBY_MODE_INVALID_EXEC_STATE, standbyState ) - standbyState = DG_STANDBY_MODE_STATE_IDLE; + standbyState = DD_STANDBY_MODE_STATE_IDLE; break; } @@ -244,9 +244,9 @@ * pendingStartDGChemicalDisinfectRequest * @return the next state *************************************************************************/ -static DG_STANDBY_MODE_STATE_T handleStandbyIdleState( void ) +static DD_STANDBY_MODE_STATE_T handleStandbyIdleState( void ) { - DG_STANDBY_MODE_STATE_T state = DG_STANDBY_MODE_STATE_IDLE; + DD_STANDBY_MODE_STATE_T state = DD_STANDBY_MODE_STATE_IDLE; // go to standby solo mode if HD is turned off or stops communicating. if ( FALSE == isTDCommunicating() ) @@ -259,13 +259,13 @@ // setValveState( VPI, VALVE_STATE_OPEN ); // flushFilterRequest = FALSE; // filterFlushStartTime = getMSTimerCount(); -// state = DG_STANDBY_MODE_STATE_FLUSH_FILTER; +// state = DD_STANDBY_MODE_STATE_FLUSH_FILTER; // } // else if ( TRUE == pendingStartDGRequest ) // { // pendingStartDGRequest = FALSE; // signalSyncToHD(); -// requestNewOperationMode( DG_MODE_GENE ); +// requestNewOperationMode( DD_MODE_GENE ); // } // else if ( TRUE == pendingStartDGFlushRequest ) // { @@ -280,7 +280,7 @@ // else if ( TRUE == pendingStartDGChemicalDisinfectRequest ) // { // pendingStartDGChemicalDisinfectRequest = FALSE; -// requestNewOperationMode( DG_MODE_CHEM ); +// requestNewOperationMode( DD_MODE_CHEM ); // } // else if ( TRUE == pendingStartDGHeatDisinfectActiveCoolRequest ) // { @@ -291,7 +291,7 @@ // else if ( TRUE == pendingStartDGChemicalDisinfectFlushRequest ) // { // pendingStartDGChemicalDisinfectFlushRequest = FALSE; -// requestNewOperationMode( DG_MODE_CHFL ); +// requestNewOperationMode( DD_MODE_CHFL ); // } // else if ( TRUE == pendingStartDGROPermeateSampleRequest ) // { @@ -310,15 +310,15 @@ * @details \b Outputs: Flushed the filters * @return the next state *************************************************************************/ -static DG_STANDBY_MODE_STATE_T handleStandbyFlushFilterState( void ) +static DD_STANDBY_MODE_STATE_T handleStandbyFlushFilterState( void ) { - DG_STANDBY_MODE_STATE_T state = DG_STANDBY_MODE_STATE_FLUSH_FILTER; + DD_STANDBY_MODE_STATE_T state = DD_STANDBY_MODE_STATE_FLUSH_FILTER; // U32 filterFlushTimePeriod_ms = getU32OverrideValue( &filterFlushTimePeriod ); // // if ( TRUE == didTimeout( filterFlushStartTime, filterFlushTimePeriod_ms ) ) // { // setValveState( VPI, VALVE_STATE_CLOSED ); -// state = DG_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE; +// state = DD_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE; // } // // if ( ++filterFlushPublishTimerCounter >= FILTER_FLUSH_DATA_PUBLISH_INTERVAL ) @@ -329,14 +329,14 @@ // data.countdown = data.timeout - ( calcTimeSince( filterFlushStartTime ) / MS_PER_SECOND ); // filterFlushPublishTimerCounter = 0; // -// broadcastData( MSG_ID_DG_FILTER_FLUSH_PROGRESS_DATA, COMM_BUFFER_OUT_CAN_DG_BROADCAST, (U08*)&data, sizeof( STANDBY_MODE_DATA_T ) ); +// broadcastData( MSG_ID_DD_FILTER_FLUSH_PROGRESS_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( STANDBY_MODE_DATA_T ) ); // } // // if ( TRUE == endSampleWaterRequest ) // { // endSampleWaterRequest = FALSE; // setValveState( VPI, VALVE_STATE_CLOSED ); -// state = DG_STANDBY_MODE_STATE_IDLE; +// state = DD_STANDBY_MODE_STATE_IDLE; // } return state; @@ -351,23 +351,23 @@ * waterSampleStartTime * @return the next state *************************************************************************/ -static DG_STANDBY_MODE_STATE_T handleStandbyFlushFilterIdleState( void ) +static DD_STANDBY_MODE_STATE_T handleStandbyFlushFilterIdleState( void ) { - DG_STANDBY_MODE_STATE_T state = DG_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE; + DD_STANDBY_MODE_STATE_T state = DD_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE; // if ( TRUE == startSampleWaterRequest ) // { // waterSampleStartTime = getMSTimerCount(); // setValveState( VPI, VALVE_STATE_OPEN ); // setValveState( VSP, VALVE_STATE_OPEN ); -// state = DG_STANDBY_MODE_STATE_SAMPLE_WATER; +// state = DD_STANDBY_MODE_STATE_SAMPLE_WATER; // } // // if ( TRUE == endSampleWaterRequest ) // { // endSampleWaterRequest = FALSE; // setValveState( VPI, VALVE_STATE_CLOSED ); -// state = DG_STANDBY_MODE_STATE_IDLE; +// state = DD_STANDBY_MODE_STATE_IDLE; // } // // startSampleWaterRequest = FALSE; @@ -383,17 +383,17 @@ * @details \b Outputs: Finished sample water and closed valve * @return the next state *************************************************************************/ -static DG_STANDBY_MODE_STATE_T handleStandbySampleWaterState( void ) +static DD_STANDBY_MODE_STATE_T handleStandbySampleWaterState( void ) { - DG_STANDBY_MODE_STATE_T state = DG_STANDBY_MODE_STATE_SAMPLE_WATER; + DD_STANDBY_MODE_STATE_T state = DD_STANDBY_MODE_STATE_SAMPLE_WATER; // // After HD requests to stop or 10 seconds has elapsed, close and return to idle state // if ( ( TRUE == stopSampleWaterRequest ) || ( TRUE == didTimeout( waterSampleStartTime, MAX_WATER_SAMPLE_TIME_MS ) ) ) // { // stopSampleWaterRequest = FALSE; // setValveState( VSP, VALVE_STATE_CLOSED ); // setValveState( VPI, VALVE_STATE_CLOSED ); -// state = DG_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE; +// state = DD_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE; // } return state; @@ -406,14 +406,14 @@ * @details \b Outputs: filterFlushStartTime * @return the next state *************************************************************************/ -static DG_STANDBY_MODE_STATE_T handleStandbyPauseState( void ) +static DD_STANDBY_MODE_STATE_T handleStandbyPauseState( void ) { - DG_STANDBY_MODE_STATE_T state = DG_STANDBY_MODE_STATE_PAUSE; + DD_STANDBY_MODE_STATE_T state = DD_STANDBY_MODE_STATE_PAUSE; // if ( FALSE == areInletWaterConditionsAlarmsActive() ) // { // filterFlushStartTime = getMSTimerCount(); -// state = DG_STANDBY_MODE_STATE_FLUSH_FILTER; +// state = DD_STANDBY_MODE_STATE_FLUSH_FILTER; // } return state; @@ -428,38 +428,38 @@ *************************************************************************/ void waterSampleCommandHandler( SAMPLE_WATER_CMD_T sampleWaterCmd ) { -// DG_CMD_RESPONSE_T cmdResponse; +// DD_CMD_RESPONSE_T cmdResponse; // -// cmdResponse.commandID = DG_CMD_SAMPLE_WATER; +// cmdResponse.commandID = DD_CMD_SAMPLE_WATER; // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_INVALID_MODE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_INVALID_MODE; // // switch ( sampleWaterCmd ) // { // case SAMPLE_WATER_CMD_STOP: -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_SAMPLE_WATER == standbyState ) ) +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_SAMPLE_WATER == standbyState ) ) // { // stopSampleWaterRequest = TRUE; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // } // break; // // case SAMPLE_WATER_CMD_START: -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE == standbyState ) ) +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE == standbyState ) ) // { // startSampleWaterRequest = TRUE; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // } // break; // // case SAMPLE_WATER_CMD_FLUSH: -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) ) +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) ) // { // flushFilterRequest = TRUE; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // } // break; // @@ -468,12 +468,12 @@ // { // endSampleWaterRequest = TRUE; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // } // break; // // default: -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_INVALID_PARAMETER; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_INVALID_PARAMETER; // break; // } // @@ -482,16 +482,16 @@ /*********************************************************************//** * @brief - * The requestDGStart function handles an HD request to start (go to generation idle mode). + * The requestDDStart function handles an HD request to start (go to generation idle mode). * @details \b Inputs: standbyState * @details \b Outputs: pendingSampleWaterRequest * @return TRUE if request accepted, FALSE if not. *************************************************************************/ -BOOL requestDGStart( void ) +BOOL requestDDStart( void ) { BOOL result = FALSE; - if ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) + if ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) { result = TRUE; //pendingStartDGRequest = TRUE; @@ -515,7 +515,7 @@ { BOOL result = FALSE; - if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( standbyState != DG_STANDBY_MODE_STATE_IDLE ) ) + if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( standbyState != DD_STANDBY_MODE_STATE_IDLE ) ) { result = TRUE; initStandbyMode(); @@ -528,28 +528,28 @@ /*********************************************************************//** * @brief - * The startDGFlush function starts DG flush mode. + * The startDDFlush function starts DD flush mode. * @details \b Inputs: standbyState * @details \b Outputs: none * @return: TRUE if the switch was successful, otherwise FALSE *************************************************************************/ -BOOL startDGFlush( void ) +BOOL startDDFlush( void ) { BOOL result = FALSE; -// // If DG is in standby mode or in the solo mode and the standby mode is in Idle state, request DG flush -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) || ( DG_MODE_SOLO == getCurrentOperationMode() ) ) +// // If DD is in standby mode or in the solo mode and the standby mode is in Idle state, request DD flush +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) || ( DD_MODE_SOLO == getCurrentOperationMode() ) ) // { -// DG_CMD_RESPONSE_T cmdResponse; -// DG_USAGE_INFO_RECORD_T usageInfo; +// DD_CMD_RESPONSE_T cmdResponse; +// DD_USAGE_INFO_RECORD_T usageInfo; // -// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DG_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); +// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DD_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); // // OPN_CLS_STATE_T concCap = getSwitchStatus( CONCENTRATE_CAP ); // OPN_CLS_STATE_T diaCap = getSwitchStatus( DIALYSATE_CAP ); -// cmdResponse.commandID = DG_CMD_START_FLUSH; +// cmdResponse.commandID = DD_CMD_START_FLUSH; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // //#ifndef _RELEASE_ // if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_CAPS_MONITOR ) ) @@ -566,17 +566,17 @@ // if ( ( STATE_OPEN == concCap ) || ( STATE_OPEN == diaCap ) ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN : -// REQUEST_REJECT_REASON_DG_CONCENTRATE_CAP_OPEN ); +// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN : +// REQUEST_REJECT_REASON_DD_CONCENTRATE_CAP_OPEN ); // } // else if ( usageInfo.lastChemDisFlushCompleteDateEpoch < usageInfo.lastChemDisStartDateEpoch ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_CHEM_FLUSH_NOT_COMPLETED; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_CHEM_FLUSH_NOT_COMPLETED; // } // else // { -// pendingStartDGFlushRequest = TRUE; +// pendingStartDDFlushRequest = TRUE; // result = TRUE; // } // @@ -588,28 +588,28 @@ /*********************************************************************//** * @brief - * The startDGHeatDisinfect function starts heat disinfect mode. + * The startDDHeatDisinfect function starts heat disinfect mode. * @details \b Inputs: standbyState * @details \b Outputs: none * @return: TRUE if the switch was successful *************************************************************************/ -BOOL startDGHeatDisinfect( void ) +BOOL startDDHeatDisinfect( void ) { BOOL status = FALSE; -// // If DG is in standby mode and the standby mode is in Idle state or if DG is in solo mode, request DG heat disinfect -// if ( ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) ) || ( DG_MODE_SOLO == getCurrentOperationMode() ) ) +// // If DD is in standby mode and the standby mode is in Idle state or if DD is in solo mode, request DD heat disinfect +// if ( ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) ) || ( DD_MODE_SOLO == getCurrentOperationMode() ) ) // { -// DG_CMD_RESPONSE_T cmdResponse; -// DG_USAGE_INFO_RECORD_T usageInfo; +// DD_CMD_RESPONSE_T cmdResponse; +// DD_USAGE_INFO_RECORD_T usageInfo; // OPN_CLS_STATE_T concCap = getSwitchStatus( CONCENTRATE_CAP ); // OPN_CLS_STATE_T diaCap = getSwitchStatus( DIALYSATE_CAP ); // -// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DG_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); +// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DD_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); // -// cmdResponse.commandID = DG_CMD_START_HEAT_DISINFECT; +// cmdResponse.commandID = DD_CMD_START_HEAT_DISINFECT; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // //#ifndef _RELEASE_ // if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_CAPS_MONITOR ) ) @@ -626,17 +626,17 @@ // if ( ( STATE_OPEN == concCap ) || ( STATE_OPEN == diaCap ) ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN : -// REQUEST_REJECT_REASON_DG_CONCENTRATE_CAP_OPEN ); +// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN : +// REQUEST_REJECT_REASON_DD_CONCENTRATE_CAP_OPEN ); // } // else if ( usageInfo.lastChemDisFlushCompleteDateEpoch < usageInfo.lastChemDisStartDateEpoch ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_CHEM_FLUSH_NOT_COMPLETED; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_CHEM_FLUSH_NOT_COMPLETED; // } // else // { -// pendingStartDGHeatDisinfectRequest = TRUE; +// pendingStartDDHeatDisinfectRequest = TRUE; // status = TRUE; // } // @@ -648,29 +648,29 @@ /*********************************************************************//** * @brief - * The startDGHeatDisinfectActiveCool function starts heat disinfect active + * The startDDHeatDisinfectActiveCool function starts heat disinfect active * cool mode. * @details \b Inputs: standbyState * @details \b Outputs: none * @return: TRUE if the switch was successful *************************************************************************/ -BOOL startDGHeatDisinfectActiveCool( void ) +BOOL startDDHeatDisinfectActiveCool( void ) { BOOL status = FALSE; -// // If DG is in standby mode and the standby mode is in Idle state or if DG is in solo mode, request DG heat disinfect -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) || ( DG_MODE_SOLO == getCurrentOperationMode() ) ) +// // If DD is in standby mode and the standby mode is in Idle state or if DD is in solo mode, request DD heat disinfect +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) || ( DD_MODE_SOLO == getCurrentOperationMode() ) ) // { -// DG_CMD_RESPONSE_T cmdResponse; -// DG_USAGE_INFO_RECORD_T usageInfo; +// DD_CMD_RESPONSE_T cmdResponse; +// DD_USAGE_INFO_RECORD_T usageInfo; // OPN_CLS_STATE_T concCap = getSwitchStatus( CONCENTRATE_CAP ); // OPN_CLS_STATE_T diaCap = getSwitchStatus( DIALYSATE_CAP ); // -// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DG_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); +// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DD_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); // -// cmdResponse.commandID = DG_CMD_START_HEAT_DISINFECT; +// cmdResponse.commandID = DD_CMD_START_HEAT_DISINFECT; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // //#ifndef _RELEASE_ // if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_CAPS_MONITOR ) ) @@ -687,17 +687,17 @@ // if ( ( STATE_OPEN == concCap ) || ( STATE_OPEN == diaCap ) ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN : -// REQUEST_REJECT_REASON_DG_CONCENTRATE_CAP_OPEN ); +// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN : +// REQUEST_REJECT_REASON_DD_CONCENTRATE_CAP_OPEN ); // } // else if ( usageInfo.lastChemDisFlushCompleteDateEpoch < usageInfo.lastChemDisStartDateEpoch ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_CHEM_FLUSH_NOT_COMPLETED; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_CHEM_FLUSH_NOT_COMPLETED; // } // else // { -// pendingStartDGHeatDisinfectActiveCoolRequest = TRUE; +// pendingStartDDHeatDisinfectActiveCoolRequest = TRUE; // status = TRUE; // } // @@ -709,24 +709,24 @@ /*********************************************************************//** * @brief - * The startDGChemicalDisinfect function starts chemical disinfect mode. + * The startDDChemicalDisinfect function starts chemical disinfect mode. * @details \b Inputs: standbyState * @details \b Outputs: none * @return: TRUE if the switch was successful *************************************************************************/ -BOOL startDGChemicalDisinfect( void ) +BOOL startDDChemicalDisinfect( void ) { BOOL status = FALSE; -// // If DG is in standby mode and the standby mode is in Idle, request chemical disinfect +// // If DD is in standby mode and the standby mode is in Idle, request chemical disinfect // // Chemical disinfect cannot be run in solo mode because the user has to confirm that the acid is inserted or removed -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) ) +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) ) // { -// DG_CMD_RESPONSE_T cmdResponse; +// DD_CMD_RESPONSE_T cmdResponse; // -// cmdResponse.commandID = DG_CMD_START_CHEM_DISINFECT; +// cmdResponse.commandID = DD_CMD_START_CHEM_DISINFECT; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // OPN_CLS_STATE_T diaCap = getSwitchStatus( DIALYSATE_CAP ); // //#ifndef _RELEASE_ @@ -740,11 +740,11 @@ // if ( STATE_OPEN == diaCap ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN; // } // else // { -// pendingStartDGChemicalDisinfectRequest = TRUE; +// pendingStartDDChemicalDisinfectRequest = TRUE; // status = TRUE; // } // @@ -756,23 +756,23 @@ /*********************************************************************//** * @brief - * The startDGChemicalDisinfectFlush function starts chemical disinfect flush mode. + * The startDDChemicalDisinfectFlush function starts chemical disinfect flush mode. * @details \b Inputs: standbyState * @details \b Outputs: none * @return: TRUE if the switch was successful *************************************************************************/ -BOOL startDGChemicalDisinfectFlush( void ) +BOOL startDDChemicalDisinfectFlush( void ) { BOOL status = FALSE; -// DG_CMD_RESPONSE_T cmdResponse; +// DD_CMD_RESPONSE_T cmdResponse; // -// cmdResponse.commandID = DG_CMD_START_CHEM_DISINFECT_FLUSH; +// cmdResponse.commandID = DD_CMD_START_CHEM_DISINFECT_FLUSH; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // -// // If DG is in standby mode and the standby mode is in Idle, request chemical disinfect flush +// // If DD is in standby mode and the standby mode is in Idle, request chemical disinfect flush // // Chemical disinfect flush cannot be run in solo mode because the user has to confirm that the acid is inserted or removed -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) ) +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) ) // { // OPN_CLS_STATE_T concCap = getSwitchStatus( CONCENTRATE_CAP ); // OPN_CLS_STATE_T diaCap = getSwitchStatus( DIALYSATE_CAP ); @@ -788,19 +788,19 @@ // if ( ( STATE_OPEN == concCap ) || ( STATE_OPEN == diaCap ) ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN : -// REQUEST_REJECT_REASON_DG_CONCENTRATE_CAP_OPEN ); +// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN : +// REQUEST_REJECT_REASON_DD_CONCENTRATE_CAP_OPEN ); // } // else // { -// pendingStartDGChemicalDisinfectFlushRequest = TRUE; +// pendingStartDDChemicalDisinfectFlushRequest = TRUE; // status = TRUE; // } // } // else // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_NOT_IN_STANDBY_IDLE_STATE; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_NOT_IN_STANDBY_IDLE_STATE; // } // // sendCommandResponseMsg( &cmdResponse ); @@ -810,28 +810,28 @@ /*********************************************************************//** * @brief - * The startDGROPermeateSample function starts RO permeate sample mode. + * The startDDROPermeateSample function starts RO permeate sample mode. * @details \b Inputs: standbyState - * @details \b Outputs: pendingStartDGChemicalDisinfectFlushRequest + * @details \b Outputs: pendingStartDDChemicalDisinfectFlushRequest * @return: TRUE if the switch was successful *************************************************************************/ -BOOL startDGROPermeateSample( void ) +BOOL startDDROPermeateSample( void ) { BOOL status = FALSE; -// DG_CMD_RESPONSE_T cmdResponse; +// DD_CMD_RESPONSE_T cmdResponse; // -// cmdResponse.commandID = DG_CMD_START_RO_PERMEATE_SAMPLE; +// cmdResponse.commandID = DD_CMD_START_RO_PERMEATE_SAMPLE; // cmdResponse.rejected = FALSE; -// cmdResponse.rejectCode = DG_CMD_REQUEST_REJECT_REASON_NONE; +// cmdResponse.rejectCode = DD_CMD_REQUEST_REJECT_REASON_NONE; // -// // If DG is in standby mode and the standby mode is in Idle, request RO permeate sample -// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DG_STANDBY_MODE_STATE_IDLE == standbyState ) ) +// // If DD is in standby mode and the standby mode is in Idle, request RO permeate sample +// if ( ( DD_MODE_STAN == getCurrentOperationMode() ) && ( DD_STANDBY_MODE_STATE_IDLE == standbyState ) ) // { -// DG_USAGE_INFO_RECORD_T usageInfo; +// DD_USAGE_INFO_RECORD_T usageInfo; // OPN_CLS_STATE_T concCap = getSwitchStatus( CONCENTRATE_CAP ); // OPN_CLS_STATE_T diaCap = getSwitchStatus( DIALYSATE_CAP ); // -// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DG_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); +// getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageInfo, sizeof( DD_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); // //#ifndef _RELEASE_ // if ( SW_CONFIG_ENABLE_VALUE == getSoftwareConfigStatus( SW_CONFIG_DISABLE_CAPS_MONITOR ) ) @@ -848,24 +848,24 @@ // if ( ( STATE_OPEN == concCap ) || ( STATE_OPEN == diaCap ) ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DG_DIALYSATE_CAP_OPEN : -// REQUEST_REJECT_REASON_DG_CONCENTRATE_CAP_OPEN ); +// cmdResponse.rejectCode = ( STATE_OPEN == getSwitchStatus( DIALYSATE_CAP ) ? REQUEST_REJECT_REASON_DD_DIALYSATE_CAP_OPEN : +// REQUEST_REJECT_REASON_DD_CONCENTRATE_CAP_OPEN ); // } // else if ( usageInfo.lastChemDisFlushCompleteDateEpoch < usageInfo.lastChemDisStartDateEpoch ) // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_CHEM_FLUSH_NOT_COMPLETED; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_CHEM_FLUSH_NOT_COMPLETED; // } // else // { -// pendingStartDGROPermeateSampleRequest = TRUE; +// pendingStartDDROPermeateSampleRequest = TRUE; // status = TRUE; // } // } // else // { // cmdResponse.rejected = TRUE; -// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DG_NOT_IN_STANDBY_IDLE_STATE; +// cmdResponse.rejectCode = REQUEST_REJECT_REASON_DD_NOT_IN_STANDBY_IDLE_STATE; // } // // sendCommandResponseMsg( &cmdResponse ); @@ -880,7 +880,7 @@ * @details \b Outputs: none * @return the current state of standby mode. *************************************************************************/ -DG_STANDBY_MODE_STATE_T getCurrentStandbyState( void ) +DD_STANDBY_MODE_STATE_T getCurrentStandbyState( void ) { return standbyState; } Index: firmware/App/Modes/ModeStandby.h =================================================================== diff -u -r8b8fff67b95805272f37855346d600599aaec03d -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Modes/ModeStandby.h (.../ModeStandby.h) (revision 8b8fff67b95805272f37855346d600599aaec03d) +++ firmware/App/Modes/ModeStandby.h (.../ModeStandby.h) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -22,10 +22,10 @@ #include "DDDefs.h" /** - * @defgroup DGStandbyMode DGStandbyMode + * @defgroup DDStandbyMode DDStandbyMode * @brief Standby mode module. Manages standby mode functions via a state machine. * - * @addtogroup DGStandbyMode + * @addtogroup DDStandbyMode * @{ */ @@ -45,18 +45,18 @@ U32 execStandbyMode( void ); // execute the standby mode state machine (call from OperationModes) void waterSampleCommandHandler( SAMPLE_WATER_CMD_T sampleWaterCmd ); // handle water sample command -BOOL requestDGStart( void ); // HD requests DG start (go to generation idle mode) +BOOL requestDDStart( void ); // HD requests DD start (go to generation idle mode) BOOL signalAbortWaterSampling( void ); // HD signal to abort water sampling. -BOOL startDGFlush( void ); // HD start flush mode -BOOL startDGHeatDisinfect( void ); // HD start heat disinfect mode -BOOL startDGHeatDisinfectActiveCool( void ); -DG_STANDBY_MODE_STATE_T getCurrentStandbyState( void ); // get the current state of the standby mode. +BOOL startDDFlush( void ); // HD start flush mode +BOOL startDDHeatDisinfect( void ); // HD start heat disinfect mode +BOOL startDDHeatDisinfectActiveCool( void ); +DD_STANDBY_MODE_STATE_T getCurrentStandbyState( void ); // get the current state of the standby mode. -BOOL startDGChemicalDisinfect( void ); // HD start chemical disinfect mode -BOOL startDGChemicalDisinfectFlush( void ); // HD start chemical disinfect flush mode +BOOL startDDChemicalDisinfect( void ); // HD start chemical disinfect mode +BOOL startDDChemicalDisinfectFlush( void ); // HD start chemical disinfect flush mode -BOOL startDGROPermeateSample( void ); // HD start RO permeate sample +BOOL startDDROPermeateSample( void ); // HD start RO permeate sample BOOL testSetFilterFlushTimePeriodOverride( U32 value ); // set filter flush time period override. BOOL testResetFilterFlushTimePeriodOverride( void ); // reset filter flush time period override. Index: firmware/App/Modes/OperationModes.c =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Modes/OperationModes.c (.../OperationModes.c) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Modes/OperationModes.c (.../OperationModes.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -17,7 +17,6 @@ #include "gio.h" -#include "MessageSupport.h" //#include "ModeChemicalDisinfect.h" //#include "ModeChemicalDisinfectFlush.h" //#include "ModeDrain.h" @@ -37,6 +36,7 @@ //#include "ROPump.h" #include "Messaging.h" #include "TaskGeneral.h" +#include "MessageSupport.h" /** * @addtogroup DDOperationModes @@ -248,7 +248,7 @@ #endif { sendOperationStatusEvent(); - SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) + SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) } // publish op mode on interval @@ -365,7 +365,7 @@ { U32 priorSubMode = currentSubMode; - SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_OP_MODE_CHANGE, lastMode, newMode ) + SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_OP_MODE_CHANGE, lastMode, newMode ) // setup for new operating mode switch ( newMode ) @@ -420,7 +420,7 @@ // Send sub-mode change event when appropriate if ( priorSubMode != currentSubMode ) { - SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) + SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) } } @@ -502,7 +502,7 @@ dat1.dataType = EVENT_DATA_TYPE_U32; dat1.data.uInt.data = opData; - sendEvent( DG_EVENT_OPERATION_STATUS, dat1, dat2 ); + sendEvent( DD_EVENT_OPERATION_STATUS, dat1, dat2 ); } /*********************************************************************//** Index: firmware/App/Services/CommBuffers.c =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Services/CommBuffers.c (.../CommBuffers.c) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Services/CommBuffers.c (.../CommBuffers.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -17,9 +17,9 @@ #include // for memcpy() -#include "CommBuffers.h" +//#include "CommBuffers.h" +#include "Messaging.h" #include "SystemCommDD.h" -#include "SystemComm.h" #include "Timers.h" /** Index: firmware/App/Services/Messaging.c =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Services/Messaging.c (.../Messaging.c) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Services/Messaging.c (.../Messaging.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -319,7 +319,7 @@ * @param dat2 Second data associated with event * @return TRUE if msg successfully queued for transmit, FALSE if not *************************************************************************/ -BOOL sendEvent( DG_EVENT_ID_T event, EVENT_DATA_T dat1, EVENT_DATA_T dat2 ) +BOOL sendEvent( DD_EVENT_ID_T event, EVENT_DATA_T dat1, EVENT_DATA_T dat2 ) { BOOL result; MESSAGE_T msg; Index: firmware/App/Services/Messaging.h =================================================================== diff -u -r090cfb22a7c0b4738299c3fb411ca77aaba8d968 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Services/Messaging.h (.../Messaging.h) (revision 090cfb22a7c0b4738299c3fb411ca77aaba8d968) +++ firmware/App/Services/Messaging.h (.../Messaging.h) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -73,7 +73,7 @@ BOOL isTestingActivated( void ); void setTesterStatusToLoggedOut( void ); -BOOL sendEvent( DG_EVENT_ID_T event, EVENT_DATA_T dat1, EVENT_DATA_T dat2 ); +BOOL sendEvent( DD_EVENT_ID_T event, EVENT_DATA_T dat1, EVENT_DATA_T dat2 ); BOOL handleTesterLogInRequest( MESSAGE_T *message ); BOOL handleDDSoftwareResetRequest( MESSAGE_T *message ); Index: firmware/App/Services/MsgQueues.h =================================================================== diff -u -rcd3af1ebb7396ba3b2bec1d779510d29c30014f4 -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/App/Services/MsgQueues.h (.../MsgQueues.h) (revision cd3af1ebb7396ba3b2bec1d779510d29c30014f4) +++ firmware/App/Services/MsgQueues.h (.../MsgQueues.h) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -19,7 +19,8 @@ #define __MSG_QUEUES_H__ #include "DDCommon.h" -#include "CommBuffers.h" +#include "CommBuffers.h" +#include "MessageSupport.h" /** * @defgroup MsgQueues MsgQueues @@ -32,42 +33,13 @@ // ********** public definitions ********** -#define MAX_MSG_PAYLOAD_SIZE 250 ///< Maximum message payload size in bytes. - /// List of message queues. typedef enum Msg_Queues { MSG_Q_IN = 0, ///< Incoming message queue NUM_OF_MSG_QUEUES ///< Number of message queues } MSG_QUEUE_T; -#pragma pack(push,1) -/// Message header struct. -typedef struct -{ - S16 seqNo; ///< Sequence number (and ACK required bit) of message - U16 msgID; ///< ID of message - U08 payloadLen; ///< Length of payload in bytes -} MESSAGE_HEADER_T; - -/// Message struct. -typedef struct -{ - COMM_BUFFER_T in_buffer; ///< Message received into this channel buffer - MESSAGE_HEADER_T hdr; ///< Message header - U08 payload[ MAX_MSG_PAYLOAD_SIZE ]; ///< Message payload -} MESSAGE_T; - -/// Message wrapper struct. -typedef struct -{ - MESSAGE_T msg; ///< Message struct - U08 crc; ///< Message's crc -} MESSAGE_WRAPPER_T; -#pragma pack(pop) - -#define MESSAGE_OVERHEAD_SIZE (sizeof(MESSAGE_HEADER_T) + sizeof(U08)) ///< Message overhead size - // ********** public function prototypes ********** void initMsgQueues( void ); Index: firmware/source/sys_main.c =================================================================== diff -u -r8b8fff67b95805272f37855346d600599aaec03d -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/source/sys_main.c (.../sys_main.c) (revision 8b8fff67b95805272f37855346d600599aaec03d) +++ firmware/source/sys_main.c (.../sys_main.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -62,7 +62,6 @@ #include "rti.h" #include "DDCommon.h" -//#include "Accel.h" #include "AlarmMgmt.h" #include "CommBuffers.h" //#include "ConductivitySensors.h" @@ -78,15 +77,13 @@ //#include "Integrity.h" //#include "InternalADC.h" #include "Interrupts.h" -//#include "LoadCell.h" #include "MsgQueues.h" //#include "NVDataMgmt.h" #include "OperationModes.h" //#include "Pressures.h" -//#include "Reservoirs.h" //#include "ROPump.h" //#include "RTC.h" -//#include "SafetyShutdown.h" +#include "SafetyShutdown.h" //#include "Switches.h" #include "SystemComm.h" #include "TaskBG.h" @@ -174,12 +171,12 @@ { initSemaphores(); initTimers(); - //initSafetyShutdown(); - //initCPLD(); + initSafetyShutdown(); initAlarmMgmtDD(); initWatchdogMgmt(); initInterrupts(); initFPGADD(); + //initCPLD(); //initInternalADC(); //initFlowSensors(); //initPressures(); @@ -195,15 +192,10 @@ //initVoltagesMonitor(); //initROPump(); //initDrainPump(); - //initUVReactors(); - //initAccel(); - //initRTC(); //initSwitches(); - //initCommBuffers(); + initCommBuffers(); initMsgQueues(); initSystemComm(); - //initReservoirs(); - //initFluidLeak(); initOperationModes(); //initIntegrity(); initTestConfigs(); Index: firmware/source/sys_selftest.c =================================================================== diff -u -r52ded7b22d4b413aa8182f1343e4fbb78e8c3b0a -r4fb1e15d35f6b968bab5620909c30baec98bfd4e --- firmware/source/sys_selftest.c (.../sys_selftest.c) (revision 52ded7b22d4b413aa8182f1343e4fbb78e8c3b0a) +++ firmware/source/sys_selftest.c (.../sys_selftest.c) (revision 4fb1e15d35f6b968bab5620909c30baec98bfd4e) @@ -45,7 +45,7 @@ /* USER CODE BEGIN (0) */ #include "Common.h" #include "DDDefs.h" -//#include "SystemCommMessages.h" +#include "Messaging.h" #define LR_OFFSET_WORD_IN_STACK 22 ///< Offset of the link register from the STACK_MARKER #define STACK_MARKER 0xCAFECAFE ///< Location in the stack to determine the offset in word from the Link Register