Index: tests/dg_tests.py =================================================================== diff -u -rd35f88b19a29e12c617b00bcd2b340a5ada8ffcc -r7a5d111bbe111ee305ab9da5ee85b98beabe20f4 --- tests/dg_tests.py (.../dg_tests.py) (revision d35f88b19a29e12c617b00bcd2b340a5ada8ffcc) +++ tests/dg_tests.py (.../dg_tests.py) (revision 7a5d111bbe111ee305ab9da5ee85b98beabe20f4) @@ -1,22 +1,24 @@ ########################################################################### # -# 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) 17-Apr-2023 +# @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, NelsonSupportModes @@ -47,8 +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 @@ -72,14 +76,13 @@ 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, {}, ' + 'Total_rinse_count, {}, Top_alarm, {}, chem_acid_avg_cond, {:5.3f}, ' .format(state, overall_elapsed_time, state_elapsed_time, - dg.chemical_disinfect.chemical_disinfect_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_flush.rinse_count, 0, - #dg.chemical_disinfect_flush.target_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 @@ -128,6 +131,19 @@ 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, @@ -252,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, @@ -261,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 @@ -319,15 +337,16 @@ 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, @@ -344,8 +363,11 @@ def get_blood_leak_info(): - info = ('Blood_leak_state, {}, Blood_leak_status, {}, ' - .format(hd.blood_leak.get_blood_leak_state(), hd.blood_leak.get_blood_leak_status())) + 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.blood_leak_intensity, hd.blood_leak.blood_leak_blood_detect, + hd.blood_leak.blood_leak_intensity_moving_average)) return info @@ -376,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 @@ -394,63 +416,6 @@ 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") - - 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(): address = os.path.join(os.getcwd(), "treatment_run.log") f = open(address, "w") @@ -465,7 +430,6 @@ dg.dialysate_fill.cmd_used_bicarb_volume_override(3700.0) sleep(1) """ - counter = 1 start = False sleep_time = 1 @@ -476,11 +440,30 @@ #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: @@ -517,18 +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 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.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() @@ -548,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 @@ -570,10 +585,13 @@ 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() + 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: @@ -665,41 +683,80 @@ # print(event) +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))) + + 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() + + 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) + + 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() 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() + #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() - while True: - print(hex(dg.test_configs.cmd_get_test_config_status( - DGTestConfigOptions.TEST_CONFIG_ENABLE_MIXING_WITH_WATER.value))) - sleep(1) + #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() #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() + #collect_treatment_data() + #run_ro_permeate_sample() + #collect_hd_treatment() #run_nelson_support_modes() @@ -722,8 +779,18 @@ #hd.ui.cmd_set_ro_only_mode_status(1) - #while True: - # print(get_dg_voltages_info()) - # sleep(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)