Index: tests/dg_tests.py =================================================================== diff -u -rffe7108e083bf2d9c34818a126f8c97ec9a21c1d -r7a5d111bbe111ee305ab9da5ee85b98beabe20f4 --- tests/dg_tests.py (.../dg_tests.py) (revision ffe7108e083bf2d9c34818a126f8c97ec9a21c1d) +++ tests/dg_tests.py (.../dg_tests.py) (revision 7a5d111bbe111ee305ab9da5ee85b98beabe20f4) @@ -1,29 +1,31 @@ ########################################################################### # -# Copyright (c) 2022-2023 Diality Inc. - All Rights Reserved. +# Copyright (c) 2022-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 dg_tests.py # # @author (last) Dara Navaei -# @date (last) 21-Dec-2022 +# @date (last) 24-Oct-2024 # @author (original) Dara Navaei # @date (original) 16-Jan-2022 # ############################################################################ +import os +import time - from dialin.dg.dialysate_generator import DG from dialin.hd.hemodialysis_device import HD +from dialin.dg.load_cells import DGLoadCellNames 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 @@ -47,7 +49,10 @@ 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, DGHeatDisinfectActiveCoolStates +from dialin.common.dg_defs import DGFlushStates, DGHeatDisinfectActiveCoolStates, DGROPermeateSampleStates +from dialin.dg.ro_permeate_sample import ROPermeateDispenseMsgStatus +from dialin.common.test_config_defs import DGTestConfigOptions, HDTestConfigOptions +from dialin.hd.blood_leak import EmbModeCommands from time import sleep from datetime import datetime import sys @@ -56,29 +61,53 @@ 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, - dg.chemical_disinfect.chemical_disinfect_elapsed_time, + 'Total_rinse_count, {}, Top_alarm, {}, chem_acid_avg_cond, {:5.3f}, ' + .format(state, overall_elapsed_time, state_elapsed_time, + dg.chemical_disinfect.chemical_disinfect_target_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, - DGChemDisinfectUIStates(dg.chemical_disinfect.chemical_disinfect_ui_state).name, - hd.alarms.alarm_top)) + dg.chemical_disinfect.r2_level, dg.chemical_disinfect_flush.rinse_count, + dg.chemical_disinfect_flush.rinse_count, hd.alarms.alarm_top, + dg.chemical_disinfect.acid_average_cond_us_per_cm)) 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(DGChemDisinfectFlushStates(dg.chemical_disinfect_flush.flush_state).name, - dg.chemical_disinfect_flush.overall_elapsed_time, dg.chemical_disinfect_flush.state_elapsed_time, + '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(): state = 0 state_elapsed_time = 0 @@ -92,21 +121,36 @@ 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_elapsed_time, {}, ' - 'R1_level, {:5.3f}, R2_level, {:5.3f}, Top_alarm, {}, UI_state, {}, ' - .format(state, overall_elapsed_time, 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.heat_disinfect.heat_disinfect_ui_state).name)) + 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_ro_permeate_sample_mode_info(): + state = DGROPermeateSampleStates(dg.ro_permeate_sample.ro_permeate_sample_state).name + overall_elapsed_time = dg.ro_permeate_sample.overall_elapsed_time + state_elapsed_time = dg.ro_permeate_sample.state_elapsed_time + + info = ('State, {}, Overall_elapsed_time, {}, State_elapsed_time, {}, dispense_vol_ml, {:5.3f}, dispense_msg, {}, ' + 'dg_op_mode, {}, ' + .format(state, overall_elapsed_time, state_elapsed_time, dg.ro_permeate_sample.dispensed_volume_ml, + ROPermeateDispenseMsgStatus(dg.ro_permeate_sample.ro_permeate_dispense_message_status).name, + dg.dg_operation_mode)) + 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, {}, ' @@ -124,9 +168,9 @@ def get_hd_occlusion_pressures_info(): - info = ('Art_pres, {:5.3f}, Venous_pres, {:5.3f}, Blood_pump_pres, {:5.3f}, 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 @@ -151,7 +195,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 @@ -182,12 +225,14 @@ 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, {}, Target_flow_lpm, {:5.3f}, ' + '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.target_drain_pump_outlet_flow_lpm)) + 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 @@ -223,6 +268,7 @@ 'Primary_target_temp, {:5.3f}, Trimmer_target_temp, {:5.3f}, Primary_eff, {:5.3f}, ' 'Primary_calc_temp, {:5.3f}, Trimmer_calc_temp, {:5.3f}, Primary_power, {:5.3f}, ' 'Primary_volt, {:5.3f}, Primary_sec_volt, {:5.3f}, Trimmer_volt, {:5.3f}, Trimmer_use_last_dc, {}, ' + 'previous_flow , {:5.3f}, trimmer_ctrl_cntr, {}, ' .format(dg.heaters.main_primary_heater_duty_cycle, dg.heaters.primary_heater_state, dg.heaters.trimmer_heater_duty_cycle, dg.heaters.trimmer_heater_state, dg.heaters.primary_heaters_target_temperature, dg.heaters.trimmer_heater_target_temperature, @@ -232,21 +278,22 @@ dg.voltages.monitored_voltages[DGMonitoredVoltages.MONITORED_LINE_24V_GND_MAIN_PRIM_HTR_V.value], dg.voltages.monitored_voltages[DGMonitoredVoltages.MONITORED_LINE_24V_GND_SMALL_PRIM_HTR_V.value], dg.voltages.monitored_voltages[DGMonitoredVoltages.MONITORED_LINE_24V_GND_TRIM_HTR_V.value], - dg.heaters.trimmer_use_last_duty_cycle)) + dg.heaters.trimmer_use_last_duty_cycle, dg.heaters.previous_flow, dg.heaters.control_counter)) return info def get_temperature_sensors_info(): info = ('TPi, {:5.3f}, THd, {:5.3f}, TPo, {:5.3f}, TD1, {:5.3f}, TD2, {:5.3f}, TRo, {:5.3f}, TDi, {:5.3f}, ' - 'Baro_temp, {:5.3f}, ' + 'Baro_temp, {:5.3f}, TDi_mving_avg, {:5.3f}, TRo_mving_avg, {:5.3f}, ' .format(dg.temperatures.temperatures[DGTemperaturesNames.INLET_PRIMARY_HEATER.name], dg.temperatures.temperatures[DGTemperaturesNames.HEAT_DISINFECT.name], dg.temperatures.temperatures[DGTemperaturesNames.OUTLET_PRIMARY_HEATER.name], dg.temperatures.temperatures[DGTemperaturesNames.CONDUCTIVITY_SENSOR_1.name], dg.temperatures.temperatures[DGTemperaturesNames.CONDUCTIVITY_SENSOR_2.name], dg.temperatures.temperatures[DGTemperaturesNames.OUTLET_DIALYSATE_REDUNDANT.name], dg.temperatures.temperatures[DGTemperaturesNames.INLET_DIALYSATE.name], - dg.temperatures.temperatures[DGTemperaturesNames.BARO_TEMP_SENSOR.name])) + dg.temperatures.temperatures[DGTemperaturesNames.BARO_TEMP_SENSOR.name], + dg.temperatures.dialysate_inlet_moving_avg, dg.temperatures.redundant_outlet_moving_avg)) return info @@ -282,22 +329,24 @@ 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}, CP1_parked, {}, CP1_park_fault, {}, CP2_parked, {}, CP2_park_fault, {}, ' + 'CPi, {: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}, 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, dg.concentrate_pumps.concentrate_pump_cp1_measured_speed, - dg.conductivity_sensors.conductivity_sensor_cpo, - dg.conductivity_sensors.conductivity_sensor_cd1, + dg.conductivity_sensors.conductivity_sensor_cpi, + dg.conductivity_sensors.conductivity_sensor_cpo, dg.conductivity_sensors.conductivity_sensor_cd1, dg.conductivity_sensors.conductivity_sensor_cd2, DGConcentratePumpsStates(dg.concentrate_pumps.concentrate_pump_cp1_current_state).name, DGConcentratePumpsStates(dg.concentrate_pumps.concentrate_pump_cp2_current_state).name, @@ -314,11 +363,11 @@ 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, {}, ' + info = ('Blood_leak_state, {}, Blood_leak_status, {}, Blood_leak_intensity, {}, Blood_leak_detect, {}, ' + 'Blood_leak_int_mv_avg, {}, ' .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())) + hd.blood_leak.blood_leak_intensity, hd.blood_leak.blood_leak_blood_detect, + hd.blood_leak.blood_leak_intensity_moving_average)) return info @@ -349,7 +398,7 @@ def get_dg_idle_bad_fill_info(): info = ('Bad_fill_state, {}, ' - .format(DGGenIdleModeBadFillSubStates(dg.gen_idle.sub_state).name)) + .format(DGGenIdleModeBadFillSubStates(dg.gen_idle.bad_fill_state).name)) return info @@ -360,65 +409,16 @@ return info -def run_dg(): - counter = 1 - timer = 0.1 - sleep_time = 1 - run_number = 1 - recirc_delay = 1 - f = open("/home/fw/projects/dialin/tests/run_dg.log", "w") +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 - dg.hd_proxy.cmd_start_stop_dg() - sleep(1) - dg.heaters.cmd_start_stop_primary_heater() - sleep(0.1) - - try: - while True: - dg_run = get_dg_run_info() - temperature = get_temperature_sensors_info() - heaters = get_heaters_with_no_temp_info() - load_cell = get_load_cells_info() - drain = get_drain_states_info() - ro = get_ro_info() - dg_rsrvrs = get_dg_reservoirs_info() - fans = get_dg_fans_info() - conc = get_concentrate_pumps_info() - valves = get_dg_valves_states() - - var = str(datetime.now()) + ', ' + dg_run + \ - temperature + heaters + load_cell + drain + ro + dg_rsrvrs + conc + fans + valves + '\r' - - print(var) - f.write(var) - - if DGOperationModes(dg.dg_operation_mode).name == DGOperationModes.DG_OP_MODE_GEN_IDLE.name and \ - dg.dg_operation_sub_mode == 2 and counter == 1: - dg.hd_proxy.cmd_drain(tare_load_cell=True) - counter += 1 - timer = 1 - - elif DGOperationModes(dg.dg_operation_mode).name == DGOperationModes.DG_OP_MODE_GEN_IDLE.name and \ - dg.dg_operation_sub_mode == 2 and counter == 2: - counter += 1 - dg.hd_proxy.cmd_fill() - - elif DGOperationModes(dg.dg_operation_mode).name == DGOperationModes.DG_OP_MODE_GEN_IDLE.name and \ - dg.dg_operation_sub_mode == 2 and counter == 3: - counter = 1 - run_number += 1 - - sleep(sleep_time) - - except KeyboardInterrupt: - dg.hd_proxy.cmd_start_stop_dg(start=False) - f.close() - pass - - 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) @@ -430,21 +430,40 @@ dg.dialysate_fill.cmd_used_bicarb_volume_override(3700.0) sleep(1) """ - counter = 1 start = False sleep_time = 1 #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) - + """ + dg.test_configs.cmd_set_test_config(DGTestConfigOptions.TEST_CONFIG_MIX_WITH_WATER.value) + sleep(0.5) + hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_USE_WET_CARTRIDGE.value) + sleep(0.5) + hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_SKIP_DISINFECT_AND_SERVICE_TX_BLOCKERS.value) + sleep(0.5) + hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_DISABLE_WET_SELFTEST_DISPLACEMENT_CHECK.value) + sleep(0.5) + hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_USE_WORN_CARTRIDGE.value) + sleep(0.5) + dg.test_configs.cmd_set_test_config(DGTestConfigOptions.TEST_CONFIG_DISABLE_INLET_WATER_TEMP_CHECK.value) + sleep(0.5) + hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_SKIP_DISINFECT_AND_SERVICE_TX_BLOCKERS.value) + """ #dg.hd_proxy.cmd_start_stop_dg() - #sleep(1) + #sleep(4) #dg.hd_proxy.cmd_fill() + hd.cmd_hd_set_operation_mode(4) + sleep(1) + dg.hd_proxy.cmd_start_stop_dg() + sleep(1) + dg.dialysate_fill.cmd_set_mode_fill_cal_check_state(2) try: while True: @@ -463,10 +482,10 @@ 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 = get_hd_occlusion_pressures_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 + \ @@ -481,17 +500,50 @@ f.close() +def run_ro_permeate_sample(): + complete_counter = 1 + address = os.path.join(os.getcwd(), "ro_permeate_sample.log") + f = open(address, "w") + #dg.hd_proxy.cmd_start_stop_dg_ro_permeate_sample() + + #dg.temperatures.cmd_temperatures_value_override(0, 49) + + try: + while True: + ro_perm = get_ro_permeate_sample_mode_info() + drain = get_drain_states_info() + load_cell = get_load_cells_info() + valves = get_dg_valves_states() + ro = get_ro_info() + temp = get_temperature_sensors_info() + heaters = get_heaters_info() + uv = get_uv_reactors_info() + dg_fans = get_dg_fans_info() + hd_fans = get_hd_fans_info() + conc = get_concentrate_pumps_info() + + var = ro_perm + load_cell + drain + ro + temp + heaters + uv + dg_fans + hd_fans + valves + conc + '\r' + + print(var) + f.write(var) + sleep(1) + except KeyboardInterrupt: + dg.hd_proxy.cmd_start_stop_dg_ro_permeate_sample(start=False) + f.close() + + def run_heat_disinfect(): complete_counter = 1 - f = open("/home/fw/projects/dialin/tests/Heat_disinfect.log", "w") - #dg.heaters.cmd_heaters_broadcast_interval_override(50) - #sleep(1) - dg.hd_proxy.cmd_start_stop_dg_heat_disinfect() + 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() + dg.hd_proxy.cmd_start_stop_dg_passive_cool_heat_disinfect() try: while True: - disinfect = get_heat_disinfect_mode_info() drain = get_drain_states_info() load_cell = get_load_cells_info() @@ -511,14 +563,14 @@ sleep(1) # If the mode came back to standby or standby solo - #if dg.dg_operation_mode == 3 or dg.dg_operation_mode == 4: - # If it is the first call, stop heat disinfect + # if dg.dg_operation_mode == 3 or dg.dg_operation_mode == 4: + # If it is the first call, stop heat disinfect # if complete_counter == 1: # dg.hd_proxy.cmd_start_stop_dg_heat_disinfect(start=False) - # Write a few more complete states to make sure the complete state items are recorded + # Write a few more complete states to make sure the complete state items are recorded # elif complete_counter == 3: - # pass + # pass # f.close() # break @@ -533,9 +585,13 @@ def run_chemical_disinfect(): complete_counter = 1 - f = open("/home/fw/projects/dialin/tests/chemical_disinfect.log", "w") + base_dir = os.getcwd() + f = open(os.path.join(base_dir, "chemical_disinfect.log"), "w") dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect() + #dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect_flush() + dg.test_configs.cmd_set_test_config(DGTestConfigOptions.TEST_CONFIG_MIX_WITH_WATER.value) + try: while True: @@ -569,49 +625,8 @@ except KeyboardInterrupt: dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect(start=False) - f.close() - -def run_chem_disinfect_flush_mode(): - complete_counter = 1 - f = open("/home/fw/projects/dialin/tests/chem_disinfect_flush_mode.log", "w") - dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect_flush() - #dg.cmd_dg_software_reset_request() - - try: - while True: - flush = get_chemical_disinfect_flush_mode_info() - load_cell = get_load_cells_info() - drain = get_drain_states_info() - ro = get_ro_info() - temp = get_temperature_sensors_info() - conc = get_concentrate_pumps_info() - valves = get_dg_valves_states() - - var = flush + load_cell + drain + ro + + temp + conc + valves + '\r' - - print(var) - f.write(var) - sleep(1) - - # If the mode came back to standby or standby solo - if dg.dg_operation_mode == 3 or dg.dg_operation_mode == 4: - - # Write a few more complete states to make sure the complete state items are recorded - if complete_counter == 3: - f.close() - #events = dg.events.get_dg_events(2, 60) - #for event in events: - # print(event) - break - - complete_counter += 1 - - except KeyboardInterrupt: dg.hd_proxy.cmd_start_stop_dg_chemical_disinfect_flush(start=False) f.close() - #events = dg.events.get_dg_events(2, 50) - #for event in events: - # print(event) def cmd_set_disinfect_ui_screen(): @@ -668,32 +683,39 @@ # 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 run_test_configs(): + counter = 1 + reset_val = 0 + print(hex(dg.test_configs.cmd_get_test_config_status(DGTestConfigOptions.TEST_CONFIG_MIX_WITH_WATER.value))) -def test_hd_valves(): while True: + if counter == 1: + dg.test_configs.cmd_set_test_config(DGTestConfigOptions.TEST_CONFIG_MIX_WITH_WATER.value, reset=reset_val) + counter += 1 + if counter > 10: + #hd.test_configs.cmd_request_test_config_status_from_fw() + dg.test_configs.cmd_request_test_config_status_from_fw() - #VALVE_POSITION_A_INSERT_EJECT = 1 - #VALVE_POSITION_B_OPEN = 2 - #VALVE_POSITION_C_CLOSE = 3 - # + while True: + #print(hex(hd.test_configs.hd_test_configs[HDTestConfigOptions.TEST_CONFIG_USE_WORN_CARTRIDGE.name])) + print(hex(dg.test_configs.dg_test_configs[DGTestConfigOptions.TEST_CONFIG_MIX_WITH_WATER.name]), reset_val) + #print((dg.test_configs.dg_test_configs), reset_val) - 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 counter > 20: + if reset_val == 1: + reset_val = 0 + else: + reset_val = 1 + counter = 1 + break + counter += 1 + sleep(0.1) + sleep(0.1) + + if __name__ == "__main__": dg = DG(log_level='DEBUG') dg.cmd_log_in_to_dg() @@ -702,22 +724,43 @@ hd.cmd_log_in_to_hd() sleep(1) - run_heat_disinfect() + #hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_USE_WET_CARTRIDGE.value) + #sleep(1) + #hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_DISABLE_WET_SELFTEST_DISPLACEMENT_CHECK.value) + #dg.load_cells.cmd_get_load_cells_tare_values() + #dg.test_configs.cmd_set_recover_from_mode_fault_signal() + + #while True: + # print(dg.load_cells.load_cells_tare_values) + # sleep(0.5) + # if dg.load_cells.load_cells_tare_values[DGLoadCellNames.LOAD_CELL_RESERVOIR_1_PRIMARY.name] != 0.0: + # dg.load_cells.cmd_set_load_cells_tare_values() + # break + + #run_test_configs() + + #run_heat_disinfect() + #run_flush_mode() #run_chemical_disinfect() - #run_chem_disinfect_flush_mode() + #hd.alarms.cmd_alarm_state_override(319, 1) + #dg.ro_permeate_sample.cmd_send_hd_dg_is_ready_to_dispense() #run_dg() # cmd_set_disinfect_ui_screen() #collect_treatment_data() + #run_ro_permeate_sample() + #collect_hd_treatment() + #run_nelson_support_modes() + #while True: # print(get_hd_fans_info(), get_dg_fans_info(), get_temperature_sensors_info()) # print(get_dg_valves_states()) @@ -727,20 +770,27 @@ # print(dg.rtc.get_rtc_epoch(), hd.rtc.get_rtc_epoch()) # sleep(1) - #test_dg_fans_alarms() - - #test_dvt_drain_pump() - - #test_conc_pumps() - #ui = HDSimulator() #ui.cmd_send_hd_operation_mode(3, 1) - #test_hd_valves() - #hd.ui.cmd_ui_set_dg_service_time() - #dg.heaters.cmd_heater_duty_cycle_override(1, 10, reset=1) - #hd.cmd_hd_software_reset_request() + #hd.ui.cmd_set_ro_only_mode_status(1) + + #hd.blood_leak.cmd_blood_leak_emb_mode_info_cmds_override(EmbModeCommands.I.value, 1000, reset=1) + hd.blood_leak.cmd_blood_leak_intensity_moving_average_override(1100.3, reset=1) + + while True: + # print(dg.switches.dg_switches_status) + print(time.time(), get_blood_leak_info()) + sleep(1) + #dg.hd_proxy.cmd_start_stop_dg_heat_disinfect() + #while True: + # print(hd.alarms.get_alarm_state(286), hd.alarms.get_alarm_state(289), dg.alarms.get_alarm_state(286), + # dg.alarms.get_alarm_state(289)) + # sleep(0.5) + #hd.test_configs.cmd_set_test_config(HDTestConfigOptions.TEST_CONFIG_SKIP_DISINFECT_AND_SERVICE_TX_BLOCKERS.value) + #dg.cmd_dg_set_operation_mode(3) + #hd.cmd_hd_set_operation_mode(1)