/************************************************************************** * * 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 DDDefs.h * * @author (last) Vinayakam Mani * @date (last) 30-Jul-2024 * * @author (original) Vinayakam Mani * @date (original) 30-Jul-2024 * ***************************************************************************/ #ifndef __DD_DEFS_H__ #define __DD_DEFS_H__ // ********** public definitions ********** /** * @addtogroup DDOperationModes * @{ */ /// Enumeration of DD operation modes. These are in order of priority (highest to lowest). enum DD_Op_Modes { DD_MODE_FAUL = 0, ///< Fault mode DD_MODE_SERV, ///< Service mode DD_MODE_INIT, ///< Initialization & POST mode DD_MODE_STAN, ///< Standby mode DD_MODE_GEND, ///< Generate Dialysate mode DD_MODE_HEAT, ///< Heat Disinfect mode DD_MODE_HCOL, ///< Heat Disinfect cooling mode DD_MODE_ROPS, ///< RO permeate sample mode DD_MODE_NLEG, ///< Not legal - an illegal mode transition occurred NUM_OF_DD_MODES ///< Number of DD operation modes }; typedef enum DD_Op_Modes DD_OP_MODE_T; ///< Type for DD operation modes enumeration /**@}*/ /** * @addtogroup DDInitAndPOSTMode * @{ */ /// Enumeration of init & POST mode states. enum DD_POST_States { DD_POST_STATE_START = 0, ///< Start initialize & POST mode state DD_POST_STATE_FW_COMPATIBILITY, ///< Run firmware compatibility test state DD_POST_STATE_FW_INTEGRITY, ///< Run firmware image integrity test state DD_POST_STATE_FPGA, ///< FPGA POST test state DD_POST_STATE_RTC, ///< RTC POST test state DD_POST_STATE_NVDATAMGMT, ///< Non-volatile data management POST state DD_POST_STATE_TEMPERATURE_SENSORS, ///< Temperature Sensors POST state DD_POST_STATE_ACCELEROMETER, ///< Accelerometer POST state DD_POST_STATE_PRESSURES, ///< Pressure sensors POST state DD_POST_STATE_DRAIN_PUMP, ///< Drain pump POST state DD_POST_STATE_CONCENTRATE_PUMPS, ///< Concentrate pumps POST state DD_POST_STATE_CONDUCTIVITY_SENSORS, ///< Conductivity sensors POST state DD_POST_STATE_RESERVOIRS, ///< Reservoirs POST state DD_POST_STATE_UV_REACTORS, ///< UV reactors POST state DD_POST_STATE_THERMISTORS, ///< Thermistors POST state DD_POST_STATE_FANS, ///< Fans POST state DD_POST_STATE_FLOW_SENSORS, ///< Flow sensors POST state DD_POST_STATE_WATCHDOG, ///< Watchdog POST test state DD_POST_STATE_SAFETY_SHUTDOWN, ///< Safety shutdown POST test state DD_POST_STATE_LOAD_CELL, ///< Load cells POST state DD_POST_STATE_COMPLETED, ///< POST completed successfully state DD_POST_STATE_FAILED, ///< POST failed state NUM_OF_DD_POST_STATES ///< Number of initialize & POST mode states }; typedef enum DD_POST_States DD_POST_STATE_T; ///< Type for DD POST states enumeration /**@}*/ /** * @addtogroup DDFaultMode * @{ */ /// Enumeration of fault mode states. enum DD_Fault_States { DD_FAULT_STATE_START = 0, ///< DD fault start state DD_FAULT_STATE_RUN_NV_POSTS, ///< DD fault run RTC and NV data management posts DD_FAULT_STATE_COMPLETE, ///< DD fault complete NUM_OF_DD_FAULT_STATES ///< Number of fault mode states }; typedef enum DD_Fault_States DD_FAULT_STATE_T; ///< Type for DD fault states enumeration /**@}*/ /** * @addtogroup DDStandbyMode * @{ */ /// Enumeration of standby mode states. enum DD_Standby_Mode_States { DD_STANDBY_MODE_STATE_IDLE = 0, ///< Idle standby mode state DD_STANDBY_MODE_STATE_FLUSH_FILTER, ///< Sample water flush filter state DD_STANDBY_MODE_STATE_FLUSH_FILTER_IDLE, ///< Sample water flush filter idle state DD_STANDBY_MODE_STATE_SAMPLE_WATER, ///< Sample water state DD_STANDBY_MODE_STATE_PAUSE, ///< Pause state NUM_OF_DD_STANDBY_MODE_STATES ///< Number of standby mode states }; typedef enum DD_Standby_Mode_States DD_STANDBY_MODE_STATE_T; ///< Type for DD standby mode states enumeration /// Sub-mode states while in standby mode disinfect enum DD_Disinfect_States { DD_DISINFECT_FLUSH_STATE = 0, ///< DD disinfect flush DD_DISINFECT_HEAT_STATE, ///< DD disinfect heat DD_DISINFECT_RO_PERMEATE_SAMPLE_STATE, ///< DD disinfect RO permeate sample DD_DISINFECT_NOT_RUNNING_STATE, ///< DD disinfect not running NUM_OF_DD_DISINFECT_STATES ///< Number of DD disinfect states }; typedef enum DD_Disinfect_States DD_DISINFECT_STATE_T; ///< Type for DD disinfect states that are broadcast to UI /**@}*/ /** * @addtogroup DDFlushMode * @{ */ /// Enumeration of flush mode states. enum DD_Flush_States { DD_FLUSH_STATE_START = 0, ///< Flush, start mode state DD_FLUSH_STATE_DRAIN_R1, ///< Flush, drain reservoir 1 state DD_FLUSH_STATE_DRAIN_R2, ///< Flush, drain reservoir 2 state DD_FLUSH_STATE_FLUSH_DRAIN, ///< Flush, flush drain state DD_FLUSH_STATE_FLUSH_DIALYSATE, ///< Flush, flush dialysate state DD_FLUSH_STATE_FLUSH_CONCENTRATE_STRAWS, ///< Flush, flush concentrate straws state DD_FLUSH_STATE_FLUSH_R1_TO_R2, ///< Flush, flush reservoir 1 to reservoir 2 state DD_FLUSH_STATE_FLUSH_R2_AND_DRAIN_R1, ///< Flush, flush reservoir 2 and drain reservoir 1 state DD_FLUSH_STATE_FLUSH_CIRCULATION_DRAIN_LINE, ///< Flush, flush circulation drain line state DD_FLUSH_STATE_FLUSH_CIRCULATION, ///< Flush, flush circulation state DD_FLUSH_STATE_FLUSH_WITH_FRESH_WATER, ///< Flush, flush with fresh water DD_FLUSH_STATE_CANCEL_BASIC_PATH, ///< Flush, cancel basic path state DD_FLUSH_STATE_CANCEL_WATER_PATH, ///< Flush, cancel water path state DD_FLUSH_STATE_COMPLETE, ///< Flush, complete mode state NUM_OF_DD_FLUSH_STATES ///< Number of flush mode states }; typedef enum DD_Flush_States DD_FLUSH_STATE_T; ///< Type for DD flush mode states enumeration /// Enumeration of flush mode UI states. enum DD_Flush_UI_States { FLUSH_UI_STATE_NOT_RUNNING = 0, ///< Flush UI, not running state FLUSH_UI_STATE_DRAIN_DEVICE, ///< Flush UI, drain device state FLUSH_UI_STATE_FLUSH_RESERVOIRS, ///< Flush UI, flush reservoirs FLUSH_UI_STATE_DRAIN_RESERVOIRS, ///< Flush UI, drain reservoirs FLUSH_UI_STATE_FLUSH_RECIRCULATION_PATH, ///< Flush UI, flush recirculation path FLUSH_UI_STATE_CANCEL_FLUSH, ///< Flush UI, cancel flush state FLUSH_UI_STATE_COMPLETE, ///< Flush UI, complete state NUM_OF_FLUSH_UI_STATES ///< Number of flush UI states }; typedef enum DD_Flush_UI_States DD_FLUSH_UI_STATE_T; ///< Type for DD flush mode UI states enumeration #if defined(_TD_) || defined(_DD_) /// Flush mode data publish struct typedef struct { U32 flushState; ///< Flush state. U32 overallElapsedTime; ///< Overall elapsed time in flush mode. U32 stateElapsedTime; ///< Current flush elapsed time. F32 drainLineVolume; ///< Drain line volume. U32 flushUIState; ///< Flush UI state. } MODE_FLUSH_DATA_T; #endif /**@}*/ /** * @addtogroup DDHeatDisinfectMode * @{ */ /// Enumeration of heat disinfect mode states. enum DD_Heat_States { DD_HEAT_DISINFECT_STATE_START = 0, ///< Heat disinfect, start mode state DD_HEAT_DISINFECT_STATE_DRAIN_R1, ///< Heat disinfect, drain R1 state DD_HEAT_DISINFECT_STATE_DRAIN_R2, ///< Heat disinfect, drain R2 state DD_HEAT_DISINFECT_STATE_FLUSH_DRAIN, ///< Heat disinfect, flush drain state DD_HEAT_DISINFECT_STATE_FLUSH_CIRCULATION, ///< Heat disinfect, flush circulation state DD_HEAT_DISINFECT_STATE_FLUSH_R1_AND_R2, ///< Heat disinfect, flush R1 and R2 state DD_HEAT_DISINFECT_STATE_FLUSH_R2_AND_DRAIN_R1, ///< Heat disinfect, flush R2 and drain R1 state DD_HEAT_DISINFECT_STATE_FLUSH_DRAIN_R2, ///< Heat disinfect, flush drain R2 state DD_HEAT_DISINFECT_STATE_FLUSH_DRAIN_R1, ///< Heat disinfect, flush drain R1 state DD_HEAT_DISINFECT_STATE_FILL_WITH_WATER, ///< Heat disinfect, fill with water state DD_HEAT_DISINFECT_STATE_DISINFECT_R1_TO_R2, ///< Heat disinfect, disinfect R1 to R2 state DD_HEAT_DISINFECT_STATE_PREPARE_FOR_HOT_WATER_TRANSITION, ///< Heat disinfect, prepare for hot water transition DD_HEAT_DISINFECT_STATE_FILL_R2_WITH_HOT_WATER, ///< Heat disinfect, fill R2 with hot water state DD_HEAT_DISINFECT_STATE_DISINFECT_R2_TO_R1, ///< Heat disinfect, disinfect R2 to R1 state DD_HEAT_DISINFECT_STATE_COOL_DOWN_HEATERS, ///< Heat disinfect, cool down heaters state DD_HEAT_DISINFECT_STATE_MIX_DRAIN_R1, ///< Heat disinfect, mix drain R1 state DD_HEAT_DISINFECT_STATE_MIX_DRAIN_R2, ///< Heat disinfect, mix drain R2 state DD_HEAT_DISINFECT_STATE_CANCEL_BASIC_PATH, ///< Heat disinfect, cancel mode basic path state DD_HEAT_DISINFECT_STATE_CANCEL_WATER_PATH, ///< Heat disinfect, cancel mode water path state DD_HEAT_DISINFECT_STATE_COMPLETE, ///< Heat disinfect, complete state #ifndef _RELEASE_ DD_NELSON_HEAT_DISINFECT_STATE_FILL_R1_WITH_WATER, #endif NUM_OF_DD_HEAT_DISINFECT_STATES ///< Number of heat disinfect mode states }; typedef enum DD_Heat_States DD_HEAT_DISINFECT_STATE_T; ///< Type for DD heat disinfect states enumeration /// Enumeration of heat disinfect mode states. enum DD_Heat_UI_States { HEAT_DISINFECT_UI_STATE_NOT_RUNNING = 0, ///< Heat disinfect UI, not running state HEAT_DISINFECT_UI_STATE_FLUSH_BEFORE_DISINFECT, ///< Heat disinfect UI, flush before disinfect state HEAT_DISINFECT_UI_STATE_HEAT_UP_WATER, ///< Heat disinfect UI, heat up water state HEAT_DISINFECT_UI_STATE_DISINFECT_RESERVOIR_1, ///< Heat disinfect UI, disinfect reservoir 1 state HEAT_DISINFECT_UI_STATE_TRANSITION_HOT_WATER, ///< Heat disinfect UI, transition hot water state HEAT_DISINFECT_UI_STATE_DISINFECT_RESERVOIR_2, ///< Heat disinfect UI, disinfect reservoir 2 state HEAT_DISINFECT_UI_STATE_COOL_DOWN_DEVICE, ///< Heat disinfect UI, cool down device state HEAT_DISINFECT_UI_STATE_FLUSH_AFTER_DISINFECT, ///< Heat disinfect UI, flush after disinfect state HEAT_DISINFECT_UI_STATE_CANCEL_DISINFECT, ///< Heat disinfect UI, cancel disinfect state HEAT_DISINFECT_UI_STATE_COMPLETE, ///< Heat disinfect UI, complete state NUM_OF_HEAT_DISINFECT_UI_STATES ///< Number of heat disinfect mode UI states }; typedef enum DD_Heat_UI_States DD_HEAT_DISINFECT_UI_STATE_T; ///< Type for DD heat disinfect UI states enumeration #if defined(_TD_) || defined(_DD_) /// Heat disinfect data publish struct typedef struct { U32 heatDisinfectState; ///< Heat disinfect state. U32 overallElapsedTime; ///< Overall elapsed time in heat disinfect mode. U32 stateElapsedTime; ///< Current heat disinfect elapsed time. U32 cancellationMode; ///< Heat disinfect cancellation mode. F32 R1FillLevel; ///< Reservoir 1 level upon starting the heat disinfect. F32 R2FillLevel; ///< Reservoir 2 level upon starting the heat disinfect. U32 heatDisinfectUIState; ///< Heat disinfect UI state. } MODE_HEAT_DISINFECT_DATA_T; #endif /// Cancellation paths typedef enum Cancellation_modes { CANCELLATION_MODE_NONE = 0, ///< Cancellation mode none. CANCELLATION_MODE_BASIC, ///< Cancellation mode basic. CANCELLATION_MODE_HOT, ///< Cancellation mode hot. CANCELLATION_MODE_COLD, ///< Cancellation mode cold. CANCELLATION_MODE_WATER, ///< Cancellation mode water. NUM_OF_CANCELLATION_MODES ///< Number of cancellation modes. } CANCELLATION_MODE_T; /**@}*/ /** * @addtogroup DDHeatDisinfectActiveCoolMode * @{ */ /// Enumeration of heat disinfect active cool mode states. enum DD_Heat_Cool_States { DD_HEAT_DISINFECT_ACTIVE_COOL_STATE_START = 0, ///< Heat disinfect active cool, start mode state. DD_HEAT_DISINFECT_ACITVE_COOL_MIX_DRAIN_R1_STATE, ///< Heat disinfect active cool, mix drain R1 state. DD_HEAT_DISINFECT_ACTIVE_COOL_MIX_DRAIN_R2_STATE, ///< Heat disinfect active cool, mix drain R2 state. DD_HEAT_DISINFECT_ACTIVE_COOL_FILL_R1_STATE, ///< Heat disinfect active cool, fill R1 state. DD_HEAT_DISINFECT_ACTIVE_COOL_FILL_R2_STATE, ///< Heat disinfect active cool, fill R2 state. DD_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R2_FILL_R1_TO_R2_STATE, ///< Heat disinfect active cool, drain R2 fill R1 to R2 state. DD_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R1_FILL_R2_TO_R1_STATE, ///< Heat disinfect active cool, drain R1 fill R2 to R1 state. DD_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R1_STATE, ///< Heat disinfect active cool, drain R1 state. DD_HEAT_DISINFECT_ACTIVE_COOL_DRAIN_R2_STATE, ///< Heat disinfect active cool, drain R2 state. DD_HEAT_DISINFECT_ACTIVE_COOL_CANCEL_WATER_PATH_STATE, ///< Heat disinfect active cool, cancel water path state. DD_HEAT_DISINFECT_ACTIVE_COOL_CANCEL_BASIC_PATH_STATE, ///< Heat disinfect active cool, cancel basic path state. DD_HEAT_DISINFECT_ACTIVE_COOL_STATE_COMPLETE, ///< Heat disinfect active cool, complete state. NUM_OF_DD_HEAT_DISINFECT_ACTIVE_COOL_STATES ///< Number of heat disinfect mode states. }; typedef enum DD_Heat_Cool_States DD_HEAT_DISINFECT_ACTIVE_COOL_STATE_T; ///< Type for DD heat disinfect active cool states enumeration /**@}*/ /** * @addtogroup DDROPermeateSampleMode * @{ */ /// Enumeration of RO permeate mode. enum DD_RO_Permeate_States { DD_RO_PERM_SAMPLE_STATE_START = 0, ///< RO Permeate Sample, start mode state DD_RO_PERM_SAMPLE_STATE_DRAIN_R1, ///< RO Permeate Sample, drain reservoir 1 state DD_RO_PERM_SAMPLE_STATE_DRAIN_R2, ///< RO Permeate Sample, drain reservoir 2 state DD_RO_PERM_SAMPLE_STATE_FLUSH_DRAIN, ///< RO Permeate Sample, flush drain state DD_RO_PERM_SAMPLE_STATE_FLUSH_DIALYSATE, ///< RO Permeate Sample, flush dialysate state DD_RO_PERM_SAMPLE_STATE_FLUSH_CONCENTRATE_STRAWS, ///< RO Permeate Sample, flush concentrate straws state DD_RO_PERM_SAMPLE_STATE_FLUSH_R2_TO_R1_AND_DRAIN_R1, ///< RO Permeate Sample, flush R2 to R1 and drain R1 state DD_RO_PERM_SAMPLE_STATE_COLLECT_SAMPLE, ///< RO Permeate Sample, collect sample state DD_RO_PERM_SAMPLE_STATE_CANCEL_BASIC_PATH, ///< RO Permeate Sample, cancel basic path state DD_RO_PERM_SAMPLE_STATE_CANCEL_WATER_PATH, ///< RO Permeate Sample, cancel water path state DD_RO_PERM_SAMPLE_STATE_COMPLETE, ///< RO Permeate Sample, complete mode state NUM_OF_DD_RO_PERM_STATES ///< Number of RO permeate mode states }; typedef enum DD_RO_Permeate_States DD_RO_PERM_STATE_T; ///< Type for DD RO Permeate states enumeration /**@}*/ /** * @addtogroup DDServiceMode * @{ */ /// Enumeration of service mode states. enum DD_Service_States { DD_SERVICE_STATE_START = 0, ///< Start service mode state NUM_OF_DD_SERVICE_STATES ///< Number of service mode states }; typedef enum DD_Service_States DD_SERVICE_STATE_T; ///< Type for DD service states enumeration /**@}*/ /** * @addtogroup DDInterface * @{ */ /// Enumeration of available DD commands. enum DD_Command { DD_CMD_NONE = 0, ///< Not a command NUM_OF_DD_COMMANDS ///< Number of DD commands }; typedef enum DD_Command DD_COMMAND_T; ///< Type for DD commands enumeration /// Enumeration of sample water command parameters. enum Sample_Water_Commands { SAMPLE_WATER_CMD_STOP = 0, ///< Stop sample water command SAMPLE_WATER_CMD_START, ///< Start sample water command SAMPLE_WATER_CMD_FLUSH, ///< Flush the filter sample water command SAMPLE_WATER_CMD_END, ///< End sample water command NUM_OF_SAMPLE_WATER_CMDS ///< Number of sample water command parameters }; typedef enum Sample_Water_Commands SAMPLE_WATER_CMD_T; ///< Type for sample water enum. /// Enumeration of sample water command parameters. enum DD_General_Commands { DD_CMD_STOP = 0, ///< DD general stop command DD_CMD_START = 1, ///< DD general start command NUM_OF_DD_CMDS ///< Number of DD general commands }; typedef enum DD_General_Commands DD_GENERAL_COMMAND_T; ///< Type for DD general command enum. /**@}*/ /** * @addtogroup CommonHeader * @{ */ /// Enumeration of DD event IDs. enum DD_Event_List { DD_EVENT_STARTUP = 0, ///< DD startup event DD_EVENT_OP_MODE_CHANGE, ///< DD Op mode change event DD_EVENT_SUB_MODE_CHANGE, ///< DD Op sub-mode change event DD_EVENT_CONCENTRATE_CAP_SWITCH_CHANGE, ///< DD concentrate cap switch change DD_EVENT_DIALYSATE_CAP_SWITCH_CHANGE, ///< DD dialysate cap switch change DD_EVENT_CPU_RAM_ERROR_STATUS, ///< DD processor RAM error DD_EVENT_CAL_RECORD_UPDATE, ///< DD new calibration record updated DD_EVENT_SYSTEM_RECORD_UPDATE, ///< DD new system record has been updated DD_EVENT_SERVICE_UPDATE, ///< DD new service record has been updated DD_EVENT_USAGE_INFO_UPDATE, ///< DD new usage information has been updated DD_EVENT_SW_CONFIG_UPDATE, ///< DD new software configuration has been updated DD_EVENT_SCHEDULED_RUNS_UPDATE, ///< DD new scheduled runs information has been updated DD_EVENT_HEATERS_INFO_UPDATE, ///< DD new heaters information has been updated DD_EVENT_AVG_DIALYSATE_FILL_COND_VALUES, ///< DD average dialysate fill conductivity values DD_EVENT_RESERVOIR_FILL_VALUES, ///< DD reservoir fill values DD_EVENT_OPERATION_STATUS, ///< DD operation status event DD_EVENT_TEMPERATURE_DRIFT, ///< DD temperature drift event DD_EVENT_BICARB_CHECK_RESULT, ///< DD bicarb check result DD_EVENT_ACID_CHECK_RESULT, ///< DD acid check result DD_EVENT_COND1_VS_COND2_DIFF_RESULT, ///< DD CD1 (acid) vs. CD2 (bicarb) different result NUM_OF_DD_EVENT_IDS ///< Total number of DD events }; typedef enum DD_Event_List DD_EVENT_ID_T; ///< Type for DD event list enumeration /**@}*/ /** * @addtogroup HeatersState * @{ */ /// Heaters exec states typedef enum Heaters_Exec_States { HEATER_EXEC_STATE_OFF = 0, ///< Heater exec state off. HEATER_EXEC_STATE_PRIMARY_RAMP_TO_TARGET, ///< Heater exec state primary ramp to target. HEATER_EXEC_STATE_PRIMARY_CONTROL_TO_TARGET, ///< Heater exec state primary control to target. HEATER_EXEC_STATE_CONTROL_TO_DISINFECT_TARGET, ///< Heater exec state control to disinfect (heat) target. HEATER_EXEC_STATE_TRIMMER_RAMP_TO_TARGET, ///< Heater exec state trimmer ramp to target. HEATER_EXEC_STATE_TRIMMER_CONTROL_TO_TARGET, ///< Heater exec state trimmer control to target. NUM_OF_HEATERS_STATE, ///< Number of heaters state. } HEATERS_STATE_T; /**@}*/ #ifndef _RELEASE_ // Nelson lab disinfect efficacy support typedef enum Nelson_States { NELSON_NONE = 0, // Nelson none. NELSON_INOCULATE, // Nelson inoculate. NELSON_HEAT_DISINFECT, // Nelson heat disinfect. NELSON_POS_CONTROL_HEAT_DISINFECT, // Nelson positive control heat disinfect. NELSON_DRAIN_SAMPLES, // Nelson drain sample. NUM_OF_NELSON_SUPPORT // Number of Nelson supports. } NELSON_SUPPORT_T; #endif #endif