Index: tests/dg_tests.py =================================================================== diff -u -r378d2f935051b641851a82de253885bea4700af3 -r428c5c0a653129867b1cb32b5e64f89f68191c4b --- tests/dg_tests.py (.../dg_tests.py) (revision 378d2f935051b641851a82de253885bea4700af3) +++ tests/dg_tests.py (.../dg_tests.py) (revision 428c5c0a653129867b1cb32b5e64f89f68191c4b) @@ -1,35 +1,37 @@ ########################################################################### # -# Copyright (c) 2022-2022 Diality Inc. - All Rights Reserved. +# Copyright (c) 2022-2023 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 dg_tests.py # # @author (last) Dara Navaei -# @date (last) 19-Oct-2022 +# @date (last) 27-Apr-2023 # @author (original) Dara Navaei # @date (original) 16-Jan-2022 # ############################################################################ +import os - from dialin.dg.dialysate_generator import DG from dialin.hd.hemodialysis_device import HD from dialin.ui.hd_simulator import HDSimulator from dialin.common.dg_defs import DGHeatDisinfectStates, DGHeatDisinfectUIStates -from dialin.dg.heat_disinfect import HeatCancellationModes +from dialin.dg.heat_disinfect import HeatCancellationModes, NelsonSupportModes from dialin.common.dg_defs import DGChemicalDisinfectStates, DGChemDisinfectUIStates +from dialin.common.dg_defs import DGChemDisinfectFlushStates, DGChemDisinfectFlushUIStates from dialin.dg.chemical_disinfect import ChemCancellationModes -from dialin.dg.drain_pump import DrainPumpStates +from dialin.dg.drain_pump import DrainPumpStates, DrainPumpRPMFeedBackSensors from dialin.dg.thermistors import ThermistorsNames from dialin.dg.temperatures import DGTemperaturesNames from dialin.dg.dialysate_generator import DGOperationModes from dialin.hd.temperatures import HDTemperaturesNames from dialin.dg.concentrate_pumps import DGConcentratePumpsStates from dialin.dg.uv_reactors import ReactorsNames -from dialin.common.hd_defs import HDOpModes, HDStandbyStates, PreTreatmentWetSelfTestStates, PostTreatmentStates +from dialin.common.hd_defs import HDOpModes, HDStandbyStates, PreTreatmentWetSelfTestStates, PostTreatmentStates, \ + PreTreatmentDrySelfTestsStates from dialin.hd.post_treatment import HDPostTreatmentDrainStates from dialin.common.dg_defs import DGEventList from dialin.common.hd_defs import HDEventList @@ -41,10 +43,12 @@ from dialin.dg.pressures import DGPressures from dialin.dg.conductivity_sensors import ConductivitySensorsEnum from dialin.dg.voltages import DGMonitoredVoltages +from dialin.dg.valves import DGValveNames from dialin.hd.valves import HDValves from dialin.hd.voltages import HDMonitoredVoltages from dialin.hd.pretreatment import PreTreatmentRsrvrState -from dialin.common.dg_defs import DGFlushStates +from dialin.common.dg_defs import DGFlushStates, DGHeatDisinfectActiveCoolStates +from dialin.common.test_config_defs import DGTestConfigOptions, HDTestConfigOptions from time import sleep from datetime import datetime import sys @@ -53,57 +57,104 @@ def get_chemical_disinfect_mode_info(): + state = 0 + state_elapsed_time = 0 + overall_elapsed_time = 0 + + if dg.dg_operation_mode == 10: + state = DGChemicalDisinfectStates(dg.chemical_disinfect.chemical_disinfect_state).name + overall_elapsed_time = dg.chemical_disinfect.overall_elapsed_time + state_elapsed_time = dg.chemical_disinfect.state_elapsed_time + elif dg.dg_operation_mode == 11: + state = DGChemDisinfectFlushStates(dg.chemical_disinfect_flush.flush_state).name + overall_elapsed_time = dg.chemical_disinfect_flush.overall_elapsed_time + state_elapsed_time = dg.chemical_disinfect_flush.state_elapsed_time + info = ('State, {}, Overall_elapsed_time, {}, State_elapsed_time, {}, Disinfect_elapsed_time, {}, ' 'Cancellation_mode, {}, R1_level, {:5.3f}, R2_level, {:5.3f}, Current_rinse_count, {}, ' 'Total_rinse_count, {}, UI_state, {}, Top_alarm, {}, ' - .format(DGChemicalDisinfectStates(dg.chemical_disinfect.chemical_disinfect_state).name, - dg.chemical_disinfect.overall_elapsed_time, dg.chemical_disinfect.state_elapsed_time, + .format(state, overall_elapsed_time, state_elapsed_time, dg.chemical_disinfect.chemical_disinfect_elapsed_time, ChemCancellationModes(dg.chemical_disinfect.cancellation_mode).name, dg.chemical_disinfect.r1_level, - dg.chemical_disinfect.r2_level, dg.chemical_disinfect.current_post_rinse_count, - dg.chemical_disinfect.target_post_rinse_count, + dg.chemical_disinfect.r2_level, dg.chemical_disinfect_flush.rinse_count, 0, + #dg.chemical_disinfect_flush.target_rinse_count, DGChemDisinfectUIStates(dg.chemical_disinfect.chemical_disinfect_ui_state).name, hd.alarms.alarm_top)) return info +def get_chemical_disinfect_flush_mode_info(): + state = 0 + state_elapsed_time = 0 + overall_elapsed_time = 0 + if dg.dg_operation_mode == 10: + state = DGChemDisinfectFlushStates(dg.chemical_disinfect_flush.flush_state).name + overall_elapsed_time = dg.chemical_disinfect.overall_elapsed_time + state_elapsed_time = dg.chemical_disinfect.state_elapsed_time + elif dg.dg_operation_mode == 11: + state = DGHeatDisinfectActiveCoolStates(dg.heat_disinfect_active_cool.heat_disinfect_active_cool_state).name + overall_elapsed_time = dg.heat_disinfect_active_cool.overall_elapsed_time + state_elapsed_time = dg.heat_disinfect_active_cool.state_elapsed_time + + info = ('State, {}, Overall_elapsed_time, {}, State_elapsed_time, {}, r1, {:5.1f}, r2, {:5.1f}, ' + 'Target_rinse_count, {}, Rinse_count, {}, Top_alarm, {}, UI_state, {},' + .format(state, overall_elapsed_time, state_elapsed_time, + dg.chemical_disinfect_flush.r1, dg.chemical_disinfect_flush.r2, + dg.chemical_disinfect_flush.target_rinse_count, dg.chemical_disinfect_flush.rinse_count, + hd.alarms.alarm_top, dg.chemical_disinfect_flush.flush_UI_state)) + return info + + def get_heat_disinfect_mode_info(): - info = ('State, {}, Overall_elapsed_time, {}, State_elapsed_time, {}, Disinfect_elapsed_time, {}, ' - 'R1_level, {:5.3f}, R2_level, {:5.3f}, Top_alarm, {}, UI_state, {}, ' - .format(DGHeatDisinfectStates(dg.heat_disinfect.heat_disinfect_state).name, - dg.heat_disinfect.overall_elapsed_time, dg.heat_disinfect.state_elapsed_time, - dg.heat_disinfect.heat_disinfect_count_down_time, dg.heat_disinfect.r1_level, - dg.heat_disinfect.r2_level, hd.alarms.alarm_top, - DGHeatDisinfectUIStates(dg.chemical_disinfect.chemical_disinfect_ui_state).name)) + state = 0 + state_elapsed_time = 0 + overall_elapsed_time = 0 + if dg.dg_operation_mode == 9: + state = DGHeatDisinfectStates(dg.heat_disinfect.heat_disinfect_state).name + overall_elapsed_time = dg.heat_disinfect.overall_elapsed_time + state_elapsed_time = dg.heat_disinfect.state_elapsed_time + elif dg.dg_operation_mode == 12: + state = DGHeatDisinfectActiveCoolStates(dg.heat_disinfect_active_cool.heat_disinfect_active_cool_state).name + overall_elapsed_time = dg.heat_disinfect_active_cool.overall_elapsed_time + state_elapsed_time = dg.heat_disinfect_active_cool.state_elapsed_time + + info = ('State, {}, Overall_elapsed_time, {}, State_elapsed_time, {}, Disinfect_RO_77, {}, Disinfect_RO_82, {}, ' + 'Disinfect_R_77, {}, Disinfect_R_82, {}, R1_level, {:5.3f}, R2_level, {:5.3f}, Top_alarm, {}, UI_state, {},' + ' ' + .format(state, overall_elapsed_time, state_elapsed_time, dg.heat_disinfect.disinfect_ro_77_time_s, + dg.heat_disinfect.disinfect_ro_82_time_s, dg.heat_disinfect.disinfect_r_77_time_s, + dg.heat_disinfect.disinfect_r_82_time_s, dg.heat_disinfect.r1_level, dg.heat_disinfect.r2_level, + hd.alarms.alarm_top, DGHeatDisinfectUIStates(dg.heat_disinfect.heat_disinfect_ui_state).name)) return info def get_flush_mode_info(): info = ('State, {}, Overall_elapsed_time, {}, State_elapsed_time, {}, Drain_vol, {:5.3f}, Top_alarm, {}, ' .format(DGFlushStates(dg.flush.flush_state).name, dg.flush.overall_elapsed_time, dg.flush.state_elapsed_time, dg.flush.flush_drain_line_volume_l, hd.alarms.alarm_top)) - return info def get_hd_run_info(): info = ('HD_op_mode, {}, HD_sub_mode, {}, Top_alarm, {}, Target_UF_ml, {:5.3f}, Meas_UF_ml, {:5.3f}, ' 'Wet_test_state, {}, Post_tx_state, {}, Post_tx_drain_state, {}, Prime_state, {}, Pre_Tx_rsrvr_state, {}, ' + 'Pre_Tx_dry_state, {}, ' .format(HDOpModes(hd.hd_operation_mode).name, hd.hd_operation_sub_mode, hd.alarms.alarm_top, hd.dialysate_outlet_flow.reference_dialysate_outlet_uf_volume, hd.dialysate_outlet_flow.measured_dialysate_outlet_uf_volume, PreTreatmentWetSelfTestStates(hd.pretreatment.pre_treatment_wet_self_test_state).name, PostTreatmentStates(hd.post_treatment.post_treatment_sub_mode).name, HDPostTreatmentDrainStates(hd.post_treatment.post_treatment_drain_state).name, hd.pretreatment.pre_treatment_prime_state, - PreTreatmentRsrvrState(hd.pretreatment.pre_treatment_reservoir_state).name)) + PreTreatmentRsrvrState(hd.pretreatment.pre_treatment_reservoir_state).name, + PreTreatmentDrySelfTestsStates(hd.pretreatment.pre_treatment_dry_self_test_state).name)) return info def get_hd_occlusion_pressures_info(): - info = ('Art_pres, {:5.3f}, Venous_pres, {:5.3f}, Blood_pump_pres, {}, DialIn_pres, {}, DialOut_pres, {}, ' + info = ('Art_pres, {:5.3f}, Venous_pres, {:5.3f}, Blood_pump_pres, {:5.3f}, DialOut_pres, {}, ' .format(hd.pressure_occlusion.arterial_pressure, hd.pressure_occlusion.venous_pressure, - hd.pressure_occlusion.blood_pump_occlusion, hd.pressure_occlusion.dialysate_inlet_pump_occlusion, + hd.pressure_occlusion.blood_pump_occlusion, hd.pressure_occlusion.dialysate_outlet_pump_occlusion)) return info @@ -128,7 +179,6 @@ dg.reservoirs.time_uf_decay, dg.reservoirs.temp_uf_fill, dg.reservoirs.temp_reservoir_use_actual, dg.reservoirs.temp_reservoir_end_fill, dg.reservoirs.temp_avg_fill, dg.reservoirs.temp_last_fill, dg.reservoirs.time_rsrvr_fill)) - return info @@ -140,39 +190,40 @@ def get_dg_valves_states(): - info = ('VPi, {}, VSP, {}, VPd, {}, VBf, {}, VPo, {}, VDr, {}, VRc, {}, VRo, {}, VRd, {}, VRi, {}, VRf, {}, ' + info = ('VPi, {}, VSP, {}, VPd, {}, VBf, {}, VPo, {}, VDr, {}, VRc, {}, VRo, {}, VRi, {}, VRf, {}, ' 'VRD1, {}, VRD2, {}, ' - .format(dg.valves.valve_states_enum[dg.valves.VALVE_PRESSURE_INLET], - dg.valves.valve_states_enum[dg.valves.VALVE_SAMPLING_PORT], - dg.valves.valve_states_enum[dg.valves.VALVE_PRODUCTION_DRAIN], - dg.valves.valve_states_enum[dg.valves.VALVE_BYPASS_FILTER], - dg.valves.valve_states_enum[dg.valves.VALVE_PRESSURE_OUTLET], - dg.valves.valve_states_enum[dg.valves.VALVE_DRAIN], - dg.valves.valve_states_enum[dg.valves.VALVE_RECIRCULATE], - dg.valves.valve_states_enum[dg.valves.VALVE_RESERVOIR_OUTLET], - dg.valves.valve_states_enum[dg.valves.VALVE_RESERVOIR_DRAIN], - dg.valves.valve_states_enum[dg.valves.VALVE_RESERVOIR_INLET], - dg.valves.valve_states_enum[dg.valves.VALVE_RESERVOIR_FILL], - dg.valves.valve_states_enum[dg.valves.VALVE_RESERVOIR_DRAIN_1], - dg.valves.valve_states_enum[dg.valves.VALVE_RESERVOIR_DRAIN_2])) + .format(dg.valves.valve_states_enum[DGValveNames.VALVE_PRESSURE_INLET.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_SAMPLING_PORT.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_PRODUCTION_DRAIN.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_BYPASS_FILTER.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_PRESSURE_OUTLET.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_DRAIN.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_RECIRCULATE.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_RESERVOIR_OUTLET.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_RESERVOIR_INLET.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_RESERVOIR_FILL.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_RESERVOIR_DRAIN_1.value], + dg.valves.valve_states_enum[DGValveNames.VALVE_RESERVOIR_DRAIN_2.value])) return info def get_drain_states_info(): info = ('Drain, {}, DAC, {}, Tgt_RPM, {}, Curr_RPM, {}, PRd, {:5.3f}, PDr, {:5.3f}, Baro, {:5.3f}, ' - 'Drain_curr_A, {:5.3f}, Drain_dir, {}, ' + 'Drain_curr_A, {:5.3f}, Drain_dir, {}, Target_flow_lpm, {:5.3f}, Maxon_rpm, {}, ' .format(DrainPumpStates(dg.drain_pump.drain_pump_state).name, dg.drain_pump.dac_value, - dg.drain_pump.target_drain_pump_rpm, dg.drain_pump.current_drain_pump_rpm, + dg.drain_pump.target_drain_pump_rpm, + dg.drain_pump.current_drain_pump_rpm[DrainPumpRPMFeedBackSensors.DRAIN_PUMP_HALL_SNSR_FB.name], dg.pressures.drain_pump_inlet_pressure, dg.pressures.drain_pump_outlet_pressure, dg.pressures.barometric_pressure, dg.drain_pump.drain_pump_current_A, - dg.drain_pump.drain_pump_direction)) + dg.drain_pump.drain_pump_direction, dg.drain_pump.target_drain_pump_outlet_flow_lpm, + dg.drain_pump.current_drain_pump_rpm[DrainPumpRPMFeedBackSensors.DRAIN_PUMP_MAXON_SNSR_FB.name])) return info def get_load_cells_info(): - info = ('A1, {:5.3f}, A2, {:5.3f}, B1, {:5.3f}, B2, {:5.3f}, '. - format(dg.load_cells.load_cell_A1, dg.load_cells.load_cell_A2, dg.load_cells.load_cell_B1, - dg.load_cells.load_cell_B2)) + info = ('A1, {:5.3f}, A2, {:5.3f}, B1, {:5.3f}, B2, {:5.3f}, ' + .format(dg.load_cells.load_cell_A1, dg.load_cells.load_cell_A2, dg.load_cells.load_cell_B1, + dg.load_cells.load_cell_B2)) return info @@ -260,16 +311,17 @@ def get_uv_reactors_info(): - info = ('Inlet_status, {}, Outlet_status, {}, ' - .format(dg.uv_reactors.inlet_uv_reactor_state, dg.uv_reactors.outlet_uv_reactor_state)) + info = ('Inlet_status, {}, Outlet_status, {}, Inlet_health, {}, Outlet_health, {}, ' + .format(dg.uv_reactors.inlet_uv_reactor_state, dg.uv_reactors.outlet_uv_reactor_state, + dg.uv_reactors.inlet_uv_reactor_health, dg.uv_reactors.outlet_uv_reactor_health)) return info def get_concentrate_pumps_info(): info = ('Bicarb_curr_speed, {:5.3f}, Bicarb_speed, {:5.3f}, Acid_curr_speed, {:5.3f}, Acid_speed, {:5.3f}, ' 'CPo, {:5.3f}, CD1, {:5.3f}, CD2, {:5.3f}, CP1_state, {}, CP2_state, {}, CPi_status, {}, CPo_status, {}, ' 'CD1_status, {}, CD2_status, {}, CP1_pulse, {:5.3f}, CP2_pulse, {:5.3f}, Acid_tgt_speed, {:5.3f}, ' - 'Bicarb_tgt_speed, {:5.3f}, ' + 'Bicarb_tgt_speed, {:5.3f}, CP1_parked, {}, CP1_park_fault, {}, CP2_parked, {}, CP2_park_fault, {}, ' .format(dg.concentrate_pumps.concentrate_pump_cp2_current_set_speed, dg.concentrate_pumps.concentrate_pump_cp2_measured_speed, dg.concentrate_pumps.concentrate_pump_cp1_current_set_speed, @@ -283,16 +335,17 @@ dg.conductivity_sensors.cd1_sensor_status, dg.conductivity_sensors.cd2_sensor_status, dg.concentrate_pumps.cp1_temp_pulse, dg.concentrate_pumps.cp2_temp_pulse, dg.concentrate_pumps.concentrate_pump_cp1_target_speed, - dg.concentrate_pumps.concentrate_pump_cp2_target_speed)) + dg.concentrate_pumps.concentrate_pump_cp2_target_speed, + dg.concentrate_pumps.concentrate_pump_cp1_parked, + dg.concentrate_pumps.concentrate_pump_cp1_park_fault, + dg.concentrate_pumps.concentrate_pump_cp2_parked, + dg.concentrate_pumps.concentrate_pump_cp2_park_fault)) return info def get_blood_leak_info(): - info = ('Blood_leak_state, {}, Blood_leak_status, {}, Blood_leak_detect_set_point, {}, Blood_leak_detect_level, {},' - ' Blood_leak_led_intensity, {}, ' - .format(hd.blood_leak.get_blood_leak_state(), hd.blood_leak.get_blood_leak_status(), - hd.blood_leak.get_blood_leak_detect_set_point(), hd.blood_leak.get_blood_leak_detect_level(), - hd.blood_leak.get_blood_leak_led_intensity())) + info = ('Blood_leak_state, {}, Blood_leak_status, {}, ' + .format(hd.blood_leak.get_blood_leak_state(), hd.blood_leak.get_blood_leak_status())) return info @@ -314,8 +367,11 @@ return info -def get_hd_valves_info(): - info = ('Air_trap' ) +def get_hd_air_trap_info(): + info = ('Air_trap_high_level, {}, Air_trap_low_level, {}, Air_trap_valve, {}, Air_bubble_status, {}, ' + .format(hd.air_trap.upper_level, hd.air_trap.lower_level, hd.valves.hd_air_trap_status, + hd.air_bubbles.air_bubbles_status)) + return info def get_dg_idle_bad_fill_info(): @@ -331,6 +387,13 @@ return info +def get_dg_voltages_info(): + info = ('DG_24, {:5.3f}, DG_24_non-iso, {:5.3f}, '. + format(dg.voltages.monitored_voltages[DGMonitoredVoltages.MONITORED_LINE_24V_MAIN.value], + dg.voltages.monitored_voltages[DGMonitoredVoltages.MONITORED_LINE_NON_ISOLATED_24_V_MAIN.value])) + return info + + def run_dg(): counter = 1 timer = 0.1 @@ -389,7 +452,8 @@ def collect_treatment_data(): - f = open("/home/fw/projects/dialin/tests/treatment_run.log", "w") + address = os.path.join(os.getcwd(), "treatment_run.log") + f = open(address, "w") #dg.conductivity_sensors.cmd_conductivity_sensor_override(ConductivitySensorsEnum.CPI.value, 1500.00) #sleep(1) @@ -407,6 +471,7 @@ #dg.heaters.cmd_heaters_broadcast_interval_override(50) #sleep(1) + #dg.uv_reactors.cmd_uv_reactors_data_broadcast_interval_override(50) #dg.voltages.cmd_monitored_voltages_broadcast_interval_override(50) #dg.concentrate_pumps.cmd_concentrate_pump_broadcast_interval_override(50) #sleep(1) @@ -433,34 +498,16 @@ blood_leak = get_blood_leak_info() hd_pumps = get_hd_pumps_info() fill_info = get_dg_fill_info() - idle_bad_fill = get_dg_idle_bad_fill_info() + idle_bad_fill = '0,' #get_dg_idle_bad_fill_info() uv = get_uv_reactors_info() hd_fans = get_hd_fans_info() + hd_pressures = '0' #get_hd_occlusion_pressures_info() + air_trap = get_hd_air_trap_info() var = str(datetime.now()) + ', ' + hd_run + dg_run + hd_rsrvrs + dg_rsrvrs + load_cell + drain + ro + \ - temp + heaters + conc_pumps + dg_fans + valves + blood_leak + hd_pumps + fill_info + uv + hd_fans + '\r' + temp + heaters + conc_pumps + dg_fans + valves + blood_leak + hd_pumps + fill_info + uv + hd_fans + \ + hd_pressures + air_trap + '\r' - if hd.alarms.get_alarm_state(97) and start is False: - dg.conductivity_sensors.cmd_conductivity_sensor_override(ConductivitySensorsEnum.CD2.value, 13700.00) - sleep(0.2) - dg.conductivity_sensors.cmd_conductivity_sensor_override(ConductivitySensorsEnum.CD1.value, 11600.00) - start = True - - """ - var = str(datetime.now()) + ', ' + hd_run + dg_run + load_cell + drain + ro + conc_pumps + valves + \ - idle_bad_fill + fill_info + '\r' - - if dg.dg_operation_mode == 6 and dg.dg_operation_sub_mode == 4 and start is False: - #dg.conductivity_sensors.cmd_conductivity_sensor_override(ConductivitySensorsEnum.CD2.value, 12000.00) - dg.pressures.cmd_pressure_override(dg.pressures.PRESSURE_SENSOR_RO_PUMP_INLET, 14) - start = True - - if start is True: - counter += 1 - - if 10 < counter < 14: - dg.pressures.cmd_pressure_override(dg.pressures.PRESSURE_SENSOR_RO_PUMP_INLET, 14, reset=1) - """ print(var) f.write(var) sleep(sleep_time) @@ -469,36 +516,14 @@ f.close() -def collect_hd_treatment(): - f = open("/home/fw/projects/dialin/tests/treatment_run_hd.log", "w") - - #hd.cmd_hd_software_reset_request() - - hd.dialysate_inlet_flow.cmd_dialysate_inlet_flow_broadcast_interval_override(50) - sleep(1) - hd.dialysate_outlet_flow.cmd_dialysate_outlet_flow_broadcast_interval_override(50) - sleep(1) - hd.voltages.cmd_monitored_voltages_broadcast_interval_override(50) - - try: - while True: - hd_run = get_hd_run_info() - pumps_info = get_hd_pumps_info() - voltages = get_voltages_info() - var = hd_run + pumps_info + voltages + '\r' - print(var) - f.write(var) - sleep(0.05) - except KeyboardInterrupt: - f.close() - - def run_heat_disinfect(): complete_counter = 1 - f = open("/home/fw/projects/dialin/tests/Heat_disinfect.log", "w") + address = os.path.join(os.getcwd(), "heat_disinfect.log") + f = open(address, "w") #dg.heaters.cmd_heaters_broadcast_interval_override(50) #sleep(1) dg.hd_proxy.cmd_start_stop_dg_heat_disinfect() + #dg.hd_proxy.cmd_start_stop_dg_heat_disinfect_active_cool() try: while True: @@ -537,13 +562,16 @@ except KeyboardInterrupt: dg.hd_proxy.cmd_start_stop_dg_heat_disinfect(start=False) + sleep(0.2) + dg.hd_proxy.cmd_start_stop_dg_heat_disinfect_active_cool(start=False) f.close() def run_chemical_disinfect(): complete_counter = 1 f = open("/home/fw/projects/dialin/tests/chemical_disinfect.log", "w") - dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect() + #dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect() + #dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect_flush() try: while True: @@ -556,9 +584,10 @@ ro = get_ro_info() temp = get_temperature_sensors_info() heaters = get_heaters_info() - fans = get_dg_fans_info() + #fans = get_dg_fans_info() - var = disinfect + load_cell + conc + drain + ro + temp + heaters + fans + valves + '\r' + #var = disinfect + load_cell + conc + drain + ro + temp + heaters + fans + valves + '\r' + var = disinfect + load_cell + conc + drain + ro + temp + heaters + valves + '\r' print(var) f.write(var) @@ -577,6 +606,7 @@ except KeyboardInterrupt: dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect(start=False) + dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect_flush(start=False) f.close() @@ -607,7 +637,6 @@ valves = get_dg_valves_states() var = flush + uv_reactors + load_cell + drain + ro + conc + valves + '\r' - print(var) f.write(var) sleep(1) @@ -635,65 +664,35 @@ # print(event) -def test_dvt_drain_pump(): - dg.drain_pump.cmd_drain_pump_set_rpm(2000) - try: - while True: - print(get_drain_states_info(), get_temperature_sensors_info(), get_dg_fans_info()) - sleep(1) - except KeyboardInterrupt: - dg.drain_pump.cmd_drain_pump_set_rpm(0) - - -def test_conc_pumps(): - dg.concentrate_pumps.cmd_concentrate_pump_state_change_request(0, True) - sleep(1) - #dg.concentrate_pumps.cmd_concentrate_pump_state_change_request(1, True) - # sleep(1) - dg.concentrate_pumps.cmd_concentrate_pump_target_speed_override(0, 35) - #sleep(1) - #dg.concentrate_pumps.cmd_concentrate_pump_target_speed_override(1, 20) - - try: - while True: - print(get_concentrate_pumps_info()) - sleep(1) - except KeyboardInterrupt: - dg.concentrate_pumps.cmd_concentrate_pump_state_change_request(0, False) - sleep(0.5) - dg.concentrate_pumps.cmd_concentrate_pump_state_change_request(1, False) - - -def test_hd_valves(): - while True: - - #VALVE_POSITION_A_INSERT_EJECT = 1 - #VALVE_POSITION_B_OPEN = 2 - #VALVE_POSITION_C_CLOSE = 3 - # - - hd.valves.cmd_set_hd_valve_position(3,3) - sleep(2) - hd.valves.cmd_set_hd_valve_position(3,2) - sleep(2) - hd.valves.cmd_set_hd_valve_position(3,1) - sleep(2) - - if __name__ == "__main__": dg = DG(log_level='DEBUG') dg.cmd_log_in_to_dg() sleep(1) hd = HD(log_level='DEBUG') hd.cmd_log_in_to_hd() sleep(1) + """ + print(dg.test_configs.dg_test_configs) + print(hex(dg.test_configs.cmd_get_test_config_status(DGTestConfigOptions.TEST_CONFIG_ENABLE_MIXING_WITH_WATER.value))) + dg.test_configs.cmd_set_test_config(DGTestConfigOptions.TEST_CONFIG_ENABLE_MIXING_WITH_WATER.value, reset=0) + sleep(1) + """ + dg.test_configs.cmd_request_test_config_status_from_fw() + + while True: + print(hex(dg.test_configs.cmd_get_test_config_status( + DGTestConfigOptions.TEST_CONFIG_ENABLE_MIXING_WITH_WATER.value))) + sleep(1) + #run_heat_disinfect() #run_flush_mode() #run_chemical_disinfect() + #hd.alarms.cmd_alarm_state_override(319, 1) + #run_dg() # cmd_set_disinfect_ui_screen() @@ -702,43 +701,28 @@ #collect_hd_treatment() + #run_nelson_support_modes() + #while True: - # print(get_hd_fans_info(), get_dg_fans_info()) + # print(get_hd_fans_info(), get_dg_fans_info(), get_temperature_sensors_info()) + # print(get_dg_valves_states()) # sleep(1) #while True: # print(dg.rtc.get_rtc_epoch(), hd.rtc.get_rtc_epoch()) # sleep(1) - #test_dg_fans_alarms() - - #test_dvt_drain_pump() - - #test_conc_pumps() - - #while True: - # print(get_concentrate_pumps_info()) - # sleep(1) - #ui = HDSimulator() #ui.cmd_send_hd_operation_mode(3, 1) - #test_hd_valves() + #hd.ui.cmd_ui_set_dg_service_time() - #while True: - # print(get_heaters_info()) - # sleep(1) + #hd.cmd_hd_software_reset_request() - #dg.flow_sensors.cmd_measured_flow_sensor_value_lpm_override(1, 0.8, reset=1) + #hd.ui.cmd_set_ro_only_mode_status(1) - #dg.heaters.cmd_set_primary_and_trimmer_heaters_target_temperature(primary_target_temp=40, trimmer_target_temp=52) - #sleep(1) - #dg.heaters.cmd_start_stop_trimmer_heater(0) - - #dg.valves.cmd_valve_sensed_state_override(4, 1, reset=0) - #while True: - # print(get_dg_valves_states()) + # print(get_dg_voltages_info()) # sleep(1)