From bfb9d3a4e83117c9c85381dc1497904bfdffa99d Mon Sep 17 00:00:00 2001 From: TotMaxim Date: Tue, 25 Nov 2025 12:31:45 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=BA=D0=B0=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82=D1=8B=20=D1=81=20?= =?UTF-8?q?ecms=20=D0=B2=20=D0=BA=D0=BE=D0=BD=D1=82=D1=80=D0=BE=D0=BB?= =?UTF-8?q?=D0=B5=20+=20=D1=84=D0=BE=D1=80=D0=BC=D0=B0=D1=82=D0=B8=D1=80?= =?UTF-8?q?=D0=BE=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5=20=D0=BF=D1=80=D0=BE=D0=B1?= =?UTF-8?q?=D0=B5=D0=BB=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scenes/frame-ecm-list/scroll-ecm-list.gd | 8 +- scenes/frame-threats/scroll-threats.gd | 2 +- scenes/pribor-prd-k/pribor-prd-k.gd | 7 +- scenes/pribor-prd-n/pribor-prd-n.gd | 15 +- scenes/pribor-prd-v/pribor-prd-v.gd | 11 +- scenes/pribor-uf/pribor-uf.gd | 2 +- scenes/контроль/контроль.tscn | 6 +- scripts/prd-ctl-config.gd | 14 +- scripts/prd.gd | 8 +- scripts/pribor-prd.gd | 356 ++++++++++++----------- table/table.gd | 12 +- 11 files changed, 234 insertions(+), 207 deletions(-) diff --git a/scenes/frame-ecm-list/scroll-ecm-list.gd b/scenes/frame-ecm-list/scroll-ecm-list.gd index 8ad0a9fd..5dba8124 100644 --- a/scenes/frame-ecm-list/scroll-ecm-list.gd +++ b/scenes/frame-ecm-list/scroll-ecm-list.gd @@ -119,9 +119,13 @@ func on_interfer_new(ecm, table_index): $table.set_row_editable(i_row, false) $table.set_node_user_data(0, i_row, ecm) table_index[ecm.ispp] = i_row + $table.cleanup_invalid_selectors() # Будем надеяться, что отложенные вызовы производятся в том же порядке - $table.call_deferred('clear_rows_selected') - $table.call_deferred('set_row_selected', i_row, true) + var selected_rows = [] + $table.get_selected_rows(selected_rows) + for old_row in selected_rows: + $table.set_row_selected(old_row, false) + $table.set_row_selected(i_row, true) if not interfer.auto_enabled: signaller.emit_signal('interfer_selected', ecm) diff --git a/scenes/frame-threats/scroll-threats.gd b/scenes/frame-threats/scroll-threats.gd index d20ef2da..be9dc979 100644 --- a/scenes/frame-threats/scroll-threats.gd +++ b/scenes/frame-threats/scroll-threats.gd @@ -75,7 +75,7 @@ func on_threat_update(th, table_index: Dictionary): elif th.emit_state == 2: emit_txr.visible = true emit_txr.self_modulate = Color.RED - + ## Обрабатывает сигнал [b]threat_lost[/b]. diff --git a/scenes/pribor-prd-k/pribor-prd-k.gd b/scenes/pribor-prd-k/pribor-prd-k.gd index ebf7d5ae..fb6aae9f 100644 --- a/scenes/pribor-prd-k/pribor-prd-k.gd +++ b/scenes/pribor-prd-k/pribor-prd-k.gd @@ -44,6 +44,7 @@ func _on_start_control() -> void: set_default_state(get_tree().get_nodes_in_group('default_reset')) set_default_state(get_tree().get_nodes_in_group('power_amplifier')) find_labels(self) + await get_tree().create_timer(1.0).timeout on_press_device(unit_prd_k.self_name) @@ -98,7 +99,7 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi if i_p >= 1: all_below_one = false break - + if all_below_one: status = STATE_VAL.NONE else: @@ -164,7 +165,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void: if power_supply.state == STATE_VAL.ERROR: all_y5_good = false - if not for_result_dic.control_is_over: + if not for_result_dic.control_is_over: set_default_state(for_result_dic.default_reset_array_node) set_default_state(for_result_dic.power_amplifier) return @@ -185,7 +186,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void: if result_dic.fs_7 == 1 and block_kasseta_y5_prd_config_k['yau07']: for_result_dic.module_fs_7.state = STATE_VAL.GOOD if result_dic.dkm_7 else STATE_VAL.ERROR for_result_dic.dou_7.state = STATE_VAL.GOOD if result_dic.dou_7 else STATE_VAL.ERROR - + if block_kasseta_y5_prd_config_k['yau07']: power_fill(for_result_dic.power_dic, for_result_dic.result_dic, for_result_dic.power_amplifier, for_result_dic.POWER_THRESHOLD) diff --git a/scenes/pribor-prd-n/pribor-prd-n.gd b/scenes/pribor-prd-n/pribor-prd-n.gd index 0cbe3f15..a8617c1e 100644 --- a/scenes/pribor-prd-n/pribor-prd-n.gd +++ b/scenes/pribor-prd-n/pribor-prd-n.gd @@ -44,6 +44,7 @@ func _on_start_control() -> void: for um in get_tree().get_nodes_in_group('power_amplifier'): um.value0 = [0, 0, 0, 0, 0, 0] find_labels(self) + await get_tree().create_timer(1.0).timeout on_press_device(unit_prd_n.self_name) @@ -87,16 +88,16 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi if i_p >= 1: all_below_one = false break - + if all_below_one: i_node_powapm.state = STATE_VAL.NONE continue - + var count_above_threshold = 0 for i_p in pow_dic[powamp_meta]: if i_p >= POWER_THRESHOLD: count_above_threshold += 1 - + status = STATE_VAL.GOOD if count_above_threshold >= 3 else STATE_VAL.ERROR i_node_powapm.state = status @@ -142,7 +143,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void: # Проверяем состояние после установки if node_y5.state == STATE_VAL.ERROR: all_y5_good = false - + var block_ip_config_n: Dictionary = for_result_dic.block_ip_config for power_supply in for_result_dic.node_ip_power_arr: var meta_ip = power_supply.get_meta('ip') @@ -153,8 +154,8 @@ static func on_control_result(for_result_dic: Dictionary) -> void: # Проверяем состояние после установки if power_supply.state == STATE_VAL.ERROR: all_y5_good = false - - if not for_result_dic.control_is_over: + + if not for_result_dic.control_is_over: set_default_state(for_result_dic.default_reset_array_node) set_default_state(for_result_dic.power_amplifier) return @@ -172,7 +173,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void: if result_dic.fs_3 == 1 and block_kasseta_y5_prd_config_n['yau07']: for_result_dic.module_fs_3.state = STATE_VAL.GOOD if result_dic.dkm_3 else STATE_VAL.ERROR for_result_dic.dou_3.state = STATE_VAL.GOOD if result_dic.dou_3 else STATE_VAL.ERROR - + if block_kasseta_y5_prd_config_n['yau07']: power_fill(for_result_dic.power_dic, for_result_dic.result_dic, for_result_dic.power_amplifier, for_result_dic.POWER_THRESHOLD) diff --git a/scenes/pribor-prd-v/pribor-prd-v.gd b/scenes/pribor-prd-v/pribor-prd-v.gd index fcbadbfc..0b320310 100644 --- a/scenes/pribor-prd-v/pribor-prd-v.gd +++ b/scenes/pribor-prd-v/pribor-prd-v.gd @@ -44,6 +44,7 @@ func _on_start_control() -> void: for um in get_tree().get_nodes_in_group('power_amplifier'): um.value0 = [0, 0, 0, 0, 0, 0] find_labels(self) + await get_tree().create_timer(1.0).timeout on_press_device(unit_prd_v.self_name) @@ -87,7 +88,7 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi if i_p >= 1: all_below_one = false break - + if all_below_one: i_node_powapm.state = STATE_VAL.NONE continue @@ -95,7 +96,7 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi for i_p in pow_dic[powamp_meta]: if i_p >= POWER_THRESHOLD: count_above_threshold += 1 - + status = STATE_VAL.GOOD if count_above_threshold >= 3 else STATE_VAL.ERROR i_node_powapm.state = status @@ -153,7 +154,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void: if power_supply.state == STATE_VAL.ERROR: all_y5_good = false - if not for_result_dic.control_is_over: + if not for_result_dic.control_is_over: set_default_state(for_result_dic.default_reset_array_node) set_default_state(for_result_dic.power_amplifier) return @@ -167,11 +168,11 @@ static func on_control_result(for_result_dic: Dictionary) -> void: if result_dic.fs_5 == 1 and block_kasseta_y5_prd_config_v['yau07']: for_result_dic.module_fs_5.state = STATE_VAL.GOOD if result_dic.dkm_5 else STATE_VAL.ERROR for_result_dic.dou_5.state = STATE_VAL.GOOD if result_dic.dou_5 else STATE_VAL.ERROR - + if result_dic.fs_4 == 1 and block_kasseta_y5_prd_config_v['yau07']: for_result_dic.module_fs_4.state = STATE_VAL.GOOD if result_dic.dkm_4 else STATE_VAL.ERROR for_result_dic.dou_4.state = STATE_VAL.GOOD if result_dic.dou_4 else STATE_VAL.ERROR - + if block_kasseta_y5_prd_config_v['yau07']: power_fill(for_result_dic.power_dic, for_result_dic.result_dic, for_result_dic.power_amplifier, for_result_dic.POWER_THRESHOLD) diff --git a/scenes/pribor-uf/pribor-uf.gd b/scenes/pribor-uf/pribor-uf.gd index 0e45033b..40c729a7 100644 --- a/scenes/pribor-uf/pribor-uf.gd +++ b/scenes/pribor-uf/pribor-uf.gd @@ -20,9 +20,9 @@ func _ready() -> void: func on_timer(unit_name: StringName): var unit_uf = network.get_unit_instance(unit_name) - status_uf() # отслеживание состояния прибора if unit_uf.online: # проверка ЯУ, внутреннего коммутатора и ИП-5Б control_ems(unit_uf.status) # проверка ЭМС ячеек + status_uf() # отслеживание состояния прибора func on_line_changed(unit_uf): diff --git a/scenes/контроль/контроль.tscn b/scenes/контроль/контроль.tscn index 507e09a5..cb8dc49b 100644 --- a/scenes/контроль/контроль.tscn +++ b/scenes/контроль/контроль.tscn @@ -171,11 +171,11 @@ func on_serviceability_changed(prd_module: Object, prd_pribor:Node)-> void: prd_pribor.state = STATE_DEVICE.NONE return print([prd_pribor.get_meta('unit_name'), prd_module.unit_control.current_status]) - if prd_module.unit_control.flag_control_is_over: + if prd_module.unit_control.control_is_over: var control_results = prd_module.unit_control.get_control_results() var result_dic = control_results.result_dic # Проверяем только основные устройства - var critical_devices = ['fs_1', 'fs_2', 'fs_3', 'fs_4', 'fs_5', 'fs_6', 'fs_7', + var critical_devices = ['fs_1', 'fs_2', 'fs_3', 'fs_4', 'fs_5', 'fs_6', 'fs_7', 'dkm_1', 'dkm_2', 'dkm_3', 'dkm_4', 'dkm_5', 'dkm_6', 'dkm_7', 'block_ip', 'dou_2', 'dou_3', 'dou_4', 'dou_5', 'dou_6', 'dou_7'] # Проверяем результаты контроля напрямую @@ -185,7 +185,7 @@ func on_serviceability_changed(prd_module: Object, prd_pribor:Node)-> void: if not result_dic[device_key]: all_ok = false break - + prd_pribor.state = STATE_DEVICE.GOOD if all_ok else STATE_DEVICE.ERROR elif not prd_module.serviceability: prd_pribor.state = STATE_DEVICE.ERROR diff --git a/scripts/prd-ctl-config.gd b/scripts/prd-ctl-config.gd index 11bcb3c8..d6f8462a 100644 --- a/scripts/prd-ctl-config.gd +++ b/scripts/prd-ctl-config.gd @@ -78,15 +78,15 @@ func get_data_index(key: String) -> int: #region PRIVATE_METHODS ## Загружает конфигурацию из JSON файла func _load_configuration() -> void: - if not _ensure_config_exists(): + if not _ensure_config_exists(): _is_loaded = false return - + var config_file = FileAccess.open(CONFIG_PATH, FileAccess.READ) if config_file: var json_text = config_file.get_as_text() config_file.close() - + var json = JSON.new() var parse_result = json.parse(json_text) if parse_result == OK: @@ -139,21 +139,21 @@ static func _convert_numbers(value): func _ensure_config_exists() -> bool: # Создаем папку конфигурации если не существует DirAccess.make_dir_recursive_absolute("user://config") - + # Если файл уже существует - все ок if FileAccess.file_exists(CONFIG_PATH): return true - + # Если дефолтного файла нет - ошибка if not FileAccess.file_exists(DEFAULT_CONFIG_PATH): return false - + # Копируем дефолтный конфиг в user директорию var src := FileAccess.open(DEFAULT_CONFIG_PATH, FileAccess.READ) var dst := FileAccess.open(CONFIG_PATH, FileAccess.WRITE) if src == null or dst == null: return false - + dst.store_string(src.get_as_text()) src.close() dst.close() diff --git a/scripts/prd.gd b/scripts/prd.gd index 336ec252..836a322c 100644 --- a/scripts/prd.gd +++ b/scripts/prd.gd @@ -231,7 +231,7 @@ class PRD: var ukp_1_online = (unit_yau07.status[0] >> 2) & 1 var ukp_2_online = (unit_yau07.status[0] >> 3) & 1 var ems_g_online = (unit_yau07.status[0] & 1) & 1 - var bit_ip_config: Array = [0, 1, 2, 3, 4, 5, 6, 7] + var bit_ip_config: Array = [0, 1, 2, 3, 4, 5, 6, 7] var ip_online: bool = true var is_k_type: bool = prd_name in ['уарэп-яу07-1к', 'уарэп-яу07-2к', 'уарэп-яу07-3к', 'уарэп-яу07-4к'] for bit in bit_ip_config: @@ -242,7 +242,7 @@ class PRD: if status: ip_online = false break - + var check_serviceability = ug_online and ukp_1_online and ukp_2_online and ems_g_online and ip_online if serviceability != check_serviceability: serviceability = check_serviceability @@ -289,7 +289,7 @@ class PRD: func set_um(data_arr): cmd_array.append([unit_yau07.CmdCode.WRITE_ISA, data_arr]) - + func _on_control_completed(_unit_control_name: String)->void: emit_signal('update_serviceability') @@ -310,7 +310,7 @@ func _ready() -> void: if prd_dict.has(fs.prd_name): prd_dict[fs.prd_name].fs_dic[key] = fs fs.connect('update_modulation', prd_dict[fs.prd_name].on_update_modulation.bind(fs.index)) - + for key in FS_PRD.keys(): fs_caps_id[FS_PRD[key][1]] = key var unit_caps = network.get_unit_instance('уарэп-капсрпб') diff --git a/scripts/pribor-prd.gd b/scripts/pribor-prd.gd index 721641d5..aa541ef5 100644 --- a/scripts/pribor-prd.gd +++ b/scripts/pribor-prd.gd @@ -17,7 +17,7 @@ const PROGRESS_COMPLETE: float = 100.0 const RAY_MASK = 0x07 const SPECIAL_LITERAS = [3, 5, 7] const RAY_m5: String = 'RAY_m5' -const RAY_5: String = 'RAY_5' +const RAY_5: String = 'RAY_5' const RAY_15: String = 'RAY_15' const RAY_25: String = 'RAY_25' const RAY_35: String = 'RAY_35' @@ -33,7 +33,21 @@ const RAY_CONFIG = { 5: { 'state': 'UG_SET_RAY_5', 'name': '45°'}, 6: { 'state': 'UG_SET_RAY_0', 'name': 'Контроль'} # ДКМ } - +# Таблица соответствий: device_name -> (current_lit -> nmfs в ecms) +const LITER_TO_NMFS: Dictionary = { + '1к': {1: 11, 6: 16, 7: 17}, + '2к': {1: 21, 6: 26, 7: 27}, + '3к': {1: 31, 6: 36, 7: 37}, + '4к': {1: 41, 6: 46, 7: 47}, + '1н': {2: 12, 3: 13}, + '2н': {2: 22, 3: 23}, + '3н': {2: 32, 3: 33}, + '4н': {2: 42, 3: 43}, + '1в': {4: 14, 5: 15}, + '2в': {4: 24, 5: 25}, + '3в': {4: 34, 5: 35}, + '4в': {4: 44, 5: 45} +} const RAY_TYPES := [RAY_m5, RAY_5, RAY_15, RAY_25, RAY_35, RAY_45] const DATA_EXIT_CONTOL_ISA: int = 0 @@ -105,17 +119,21 @@ var self_name: String var state: int = STATE_MACHINE.INIT var current_litera: int var count_packets_power: int = 0 +var current_ecm_key: int ## Флаги состояния системы -var flag_write_isa: bool = false -var flag_fs_status_ok: bool = false -var flag_si_fs_input: bool = false -var flag_si_fs_output: bool = false -var flag_in_control: bool = false -var flag_control_is_over: bool = false -var flag_no_trust_yau07: bool = false -var flag_only_fs: bool = false -var flag_temperature_ok: bool = true +var flags: Dictionary = { + 'write_isa': false, + 'fs_status_ok': false, + 'si_fs_input': false, + 'si_fs_output': false, + 'in_control': false, + 'control_is_over': false, + 'no_trust_yau07': false, + 'only_fs': false, + 'ecm_is_comming': false, + 'temperature_ok': true, +} ## Таймеры контроля var control_timer: Timer = Timer.new() @@ -163,42 +181,36 @@ func _init(init_data: Dictionary, cmd_array_from_prd: Array) -> void: func _initialize_default_states() -> void: _default_states = { # Флаги состояния системы - 'flag_write_isa': flag_write_isa, - 'flag_fs_status_ok': flag_fs_status_ok, - 'flag_si_fs_input': flag_si_fs_input, - 'flag_si_fs_output': flag_si_fs_output, - 'flag_control_is_over': flag_control_is_over, - 'flag_no_trust_yau07': flag_no_trust_yau07, - 'flag_only_fs': flag_only_fs, - + 'flags': flags.duplicate(true), + # Состояние машины и литеры 'state': state, 'current_litera': current_litera, - + # Переменные прогресса 'progress_value': progress_value, 'current_status': current_status, 'total_fs_to_check': total_fs_to_check, 'completed_fs_count': completed_fs_count, 'current_fs_progress': current_fs_progress, - + # Счетчики 'cc': cc, - + # Сокеты ЭМС-Г 'ems_g_sock_dic': ems_g_sock_dic.duplicate(true), - + # Структуры данных (глубокое копирование) 'power_for_litera': _deep_copy_power_structure(), 'control_results': control_results.duplicate(true), 'power_result': power_result.duplicate(true), 'temperature_um': temperature_um.duplicate(true), 'ecms': ecms.duplicate(true), - + # Конфигурации блоков 'block_ip_config': block_ip_config.duplicate(true), 'block_kasseta_y5_config': block_kasseta_y5_config.duplicate(true), - + # Конфигурация устройства 'self_name': self_name, 'constants': constants.duplicate(true), @@ -212,7 +224,7 @@ func _initialize_config_from_manager() -> void: if not config_manager.is_loaded(): push_error('ConfigManager не загружен!') return - + _device_constants = config_manager.get_device_constants() _base_configs = config_manager.get_base_configs() _device_configs = config_manager.get_device_configs() @@ -244,13 +256,13 @@ func _ready() -> void: ## Инициализация маппинга состояний лучей func _initialize_ray_mapping() -> void: _ray_state_mapping = { - STATE_MACHINE.UG_SET_RAY_0: 'RAY_m5', - STATE_MACHINE.UG_SET_RAY_1: 'RAY_5', - STATE_MACHINE.UG_SET_RAY_2: 'RAY_15', - STATE_MACHINE.UG_SET_RAY_3: 'RAY_25', - STATE_MACHINE.UG_SET_RAY_4: 'RAY_35', - STATE_MACHINE.UG_SET_RAY_5: 'RAY_45', - STATE_MACHINE.UG_SET_RAY_CTRL: 'RAY_CTRL', + STATE_MACHINE.UG_SET_RAY_0: 'RAY_CTRL', + STATE_MACHINE.UG_SET_RAY_1: 'RAY_m5', + STATE_MACHINE.UG_SET_RAY_2: 'RAY_5', + STATE_MACHINE.UG_SET_RAY_3: 'RAY_15', + STATE_MACHINE.UG_SET_RAY_4: 'RAY_25', + STATE_MACHINE.UG_SET_RAY_5: 'RAY_35', + STATE_MACHINE.UG_SET_RAY_CTRL: 'RAY_45', } @@ -270,25 +282,23 @@ func _process(_delta: float) -> void: ## Обработка данных от ЯУ-07 func on_data_received(unit_pribor: Object) -> void: - if not flag_in_control: + if not flags.in_control: return - + var status: PackedByteArray = unit_pribor.status - block_kasseta_y5_config = check_block_kasseta_y5(status, block_kasseta_y5_config, flag_no_trust_yau07) - - if flag_no_trust_yau07: + block_kasseta_y5_config = check_block_kasseta_y5(status, block_kasseta_y5_config, flags.no_trust_yau07) + if flags.no_trust_yau07: return - + socket_status_ems_g(status) block_ip_config = check_block_ip(status, block_ip_config) temperature_um = check_temperature_um(status) - flag_temperature_ok = check_overheating(temperature_um) - + flags.temperature_ok = check_overheating(temperature_um) if machine_timer.is_stopped(): return _process_dkm_status(status) - + # Формирование мощностей в литерах if current_litera != 0: var tek_litera: Dictionary = power_for_litera[current_litera] @@ -314,20 +324,20 @@ func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void: if self_name in ['1н', '2н', '3н', '4н']: ems_g_sock_dic.ems_input_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 9)) != 0 ems_g_sock_dic.ems_input_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 10)) != 0 - + if self_name in ['1в', '2в', '3в', '4в']: ems_g_sock_dic.ems_input_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 11)) != 0 ems_g_sock_dic.ems_input_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 12)) != 0 - + if self_name in ['1к', '2к', '3к', '4к']: ems_g_sock_dic.ems_input_lit_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 8)) != 0 ems_g_sock_dic.ems_input_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 13)) != 0 ems_g_sock_dic.ems_input_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 14)) != 0 # Обработка выходных сокетов + ems_g_sock_dic.ems_output_lit_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 3)) != 0 ems_g_sock_dic.ems_output_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 4)) != 0 ems_g_sock_dic.ems_output_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 5)) != 0 - ems_g_sock_dic.ems_output_lit_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 3)) != 0 # Определение флагов СИ ФС входа var number_socket_input: int @@ -335,14 +345,14 @@ func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void: number_socket_input = current_litera + 7 var in_blank: int = packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) - flag_si_fs_input = (in_blank & (1 << number_socket_input)) != 0 + flags.si_fs_input = (in_blank & (1 << number_socket_input)) != 0 # Определение флагов СИ ФС выхода var number_socket_output: int number_socket_output = 4 if current_litera in [2, 4, 6] else 3 if current_litera == 1 else 5 var out_blank: int = packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) - flag_si_fs_output = (out_blank & (1 << number_socket_output)) != 0 + flags.si_fs_output = (out_blank & (1 << number_socket_output)) != 0 #endregion @@ -368,37 +378,28 @@ func state_control_machine() -> void: STATE_MACHINE.FS_TURN_OFF: _handle_fs_turn_off_state() STATE_MACHINE.STOP_CONTROL: _handle_stop_control_state() # Обновление прогресс-бара после обработки состояния - if block_kasseta_y5_config['yau07'] or flag_no_trust_yau07: + if block_kasseta_y5_config['yau07'] or flags.no_trust_yau07: progressbar_status() ## Обработка состояния INIT - инициализация ФС func _handle_init_state() -> void: if current_litera in [1, 2, 3, 4, 5, 6, 7]: _set_status('Инициализация ФС-%s' % current_litera) - var flag_ecm: bool = false - - # Проверка доступности ЭМС для текущей литеры - for key in ecms: - var params = ecms[key].params.freq - if fs_parameters[current_litera].freq == params: - var kni = ecms[key].kni - if pribor_config[self_name].angle == kni: - flag_ecm = true - - if not flag_ecm: - state = STATE_MACHINE.FS_TURN_ON + if _get_current_ecm(): return + state = STATE_MACHINE.FS_TURN_ON else: + if _get_current_ecm(): return # Завершение контроля если литеры закончились - flag_control_is_over = true + flags.control_is_over = true control_results = on_control_result(block_ip_config, control_results) power_result = prep_power(power_for_litera, self_name) machine_timer.stop() - + var result: bool = true for device in control_results.values(): if not device: result = false - + _set_status('Прибор ПРД-%s: %s' % [self_name, ['неисправен', 'исправен'][int(result)]]) emit_signal('control_is_over', self_name) @@ -406,25 +407,31 @@ func _handle_init_state() -> void: ## Обработка состояния FS_TURN_ON - включение ФС func _handle_fs_turn_on_state() -> void: _set_status('Включение ФС-%s' % current_litera) - manage_fs(true, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM) + manage_fs(self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM) control_timer.wait_time = constants.TIMER_DELAY control_timer.start() state = STATE_MACHINE.FS_WORK +static func take_ecm_id(ecm_dic: Dictionary, device_name: String, current_lit: int) -> int: + # Получаем целевой nmfs из таблицы + var target_nmfs: int = LITER_TO_NMFS.get(device_name, {}).get(current_lit, -1) + if target_nmfs == -1: + return 0 + # Ищем ECM с соответствующим nmfs + for ecm_id in ecm_dic: + if ecm_dic[ecm_id].nmfs == target_nmfs: + return ecm_id + return 0 + + ## Обработка состояния FS_WORK - проверка работы ФС func _handle_fs_work_state() -> void: - var flag_ecm: bool = false _set_status('Проверка связи сервиса КАПС РПБ') - for key in ecms: - var params = ecms[key].params.freq - if fs_parameters[current_litera].freq == params: - var kni = ecms[key].kni - if pribor_config[self_name].angle == kni: - flag_ecm = true - + if not flags.ecm_is_comming: return + #print([self_name, current_ecm_key , ecms[current_ecm_key]]) # Если ЭМС доступна и ФС в порядке - запускаем таймер ЭМС - if flag_ecm and flag_fs_status_ok: + if current_ecm_key != 0 and flags.fs_status_ok: _set_status('Проверка ФС-%s' % current_litera) # Проверка завершения работы ФС if (current_litera == 2 and control_results.fs_2) or \ @@ -434,6 +441,10 @@ func _handle_fs_work_state() -> void: (current_litera == 6 and control_results.fs_6) or \ (current_litera == 7 and control_results.fs_7) or \ (current_litera == 1 and control_results.fs_1): + if not block_kasseta_y5_config['yau07']: + _set_status('Ожидание данных от ЯУ-07...') + return # НЕ переходим дальше пока нет данных + state = STATE_MACHINE.CHEK_KASSETA_Y5 @@ -445,14 +456,15 @@ func _handle_check_kasseta_state() -> void: if not block_kasseta_y5_config[case]: block_kasseta_y5 = false if block_kasseta_y5: - if flag_temperature_ok: + if flags.temperature_ok: ems_6666_timer.start() state = STATE_MACHINE.CHEK_BLOCK_IP else: _set_status('Перегрев УМ') state = STATE_MACHINE.IN_EMS_STOP else: - flag_only_fs = true + #flag_only_fs = true + _set_status('Касета У5: ERROR') state = STATE_MACHINE.IN_EMS_STOP @@ -468,7 +480,7 @@ func _handle_check_block_ip_state() -> void: state = STATE_MACHINE.UG_SET_RAY_5 else: state = STATE_MACHINE.UG_SET_RAY_CTRL - elif flag_only_fs: + elif flags.only_fs: state = STATE_MACHINE.IN_EMS_STOP @@ -476,7 +488,7 @@ func _handle_check_block_ip_state() -> void: func _handle_read_isa_state() -> void: if (unit_prd.cmd_state == unit_prd.CmdState.DONE) or (unit_prd.cmd_state == unit_prd.CmdState.FAIL): _handle_read_isa(unit_prd, [constants.ADDR_UG_LITERA_1, constants.ADDR_UG_LITERA_2, constants.ADDR_UG_LITERA_3], cmd_array) - flag_write_isa = false + flags.write_isa = false state = STATE_MACHINE.UG_SET_RAY @@ -488,10 +500,11 @@ func _handle_ems_stop_state() -> void: ## Обработка состояния FS_TURN_OFF - выключение ФС func _handle_fs_turn_off_state() -> void: - _set_status('Отключение ФС-%s' % current_litera) - flag_fs_status_ok = false - manage_fs(false, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM) state = STATE_MACHINE.STOP_CONTROL + if not _get_current_ecm(): return + _set_status('Отключение ФС-%s' % current_litera) + flags.fs_status_ok = false + signaller.emit_signal('interfer_off', ecms[current_ecm_key]) ## Обработка состояния STOP_CONTROL - завершение контроля @@ -499,9 +512,10 @@ func _handle_stop_control_state() -> void: _set_status('Завершение контроля ФС-%s' % current_litera) completed_fs_count += 1 _advance_to_next_fs() + flags.ecm_is_comming = false state = STATE_MACHINE.INIT - - if flag_no_trust_yau07: + + if flags.no_trust_yau07: state = STATE_MACHINE.STOP_CONTROL @@ -515,7 +529,6 @@ func _advance_to_next_fs() -> void: 5: current_litera = 0 6: current_litera = 7 7: current_litera = 0 - #endregion @@ -535,7 +548,7 @@ func _handle_ray_read_mode() -> void: var addr: int = _get_ug_address() if not _can_process_ray_state(addr): return - + var ray_value = unit_prd.isa_ports[addr] & RAY_MASK _process_ray_value(ray_value) @@ -549,10 +562,13 @@ func _handle_ray_write_mode(ray_num: int) -> void: if ray_num == 0: control_timer.stop() # Ожидание пяти пакетов от ЯУ-07 - if count_packets_power < 5: return + if ray_num == 6: + if count_packets_power < 20: return + elif count_packets_power < 10: return + # Установка луча _handle_ug_set_state(ray_num) - flag_write_isa = true + flags.write_isa = true state = STATE_MACHINE.READ_ISA @@ -578,10 +594,10 @@ func _can_process_ray_state(addr: int) -> bool: ## Проверка возможности записи луча func _can_write_ray() -> bool: - if flag_write_isa: + if flags.write_isa: return false - if not flag_si_fs_input: + if not flags.si_fs_input: _set_status('Ожидание сигнала излучения от ФС-%s' % current_litera ) return false else: @@ -607,7 +623,7 @@ func _handle_ug_set_state(RAY_DOU_NUM: int) -> void: 'ATT_UM_3': def_att, 'BASE_EMS_G': constants.BASE_ADDR_EMS_G } - + # Конфигурация аттенюаторов для разных типов приборов if self_name == '1к' or self_name == '2к' or self_name == '3к' or self_name == '4к': dic_att['ATT_UM_1'] = constants.ATT_UM_6 @@ -619,7 +635,7 @@ func _handle_ug_set_state(RAY_DOU_NUM: int) -> void: elif self_name == '1н' or self_name == '2н' or self_name == '3н' or self_name == '4н': dic_att['ATT_UM_1'] = constants.ATT_UM_2 dic_att['ATT_UM_2'] = constants.ATT_UM_3 - flag_write_isa = on_ug_setting(unit_prd, dic_att, cmd_array) + flags.write_isa = on_ug_setting(unit_prd, dic_att, cmd_array) count_packets_power = 0 @@ -637,9 +653,9 @@ func progressbar_status() -> void: await get_tree().create_timer(0.5).timeout progress_value = 0 return - + var base_progress: float = 0.0 - + # Базовый прогресс в зависимости от состояния match state: STATE_MACHINE.INIT: base_progress = PROGRESS_INIT @@ -653,14 +669,14 @@ func progressbar_status() -> void: STATE_MACHINE.UG_SET_RAY_4: base_progress = PROGRESS_RAY_STATES + 20 STATE_MACHINE.UG_SET_RAY_5: base_progress = PROGRESS_RAY_STATES + 25 STATE_MACHINE.IN_EMS_STOP: base_progress = PROGRESS_COMPLETE - STATE_MACHINE.FS_TURN_OFF: base_progress = PROGRESS_COMPLETE - STATE_MACHINE.STOP_CONTROL: base_progress = PROGRESS_COMPLETE - + STATE_MACHINE.FS_TURN_OFF: base_progress = PROGRESS_COMPLETE + 5 + STATE_MACHINE.STOP_CONTROL: base_progress = PROGRESS_COMPLETE + 10 + # Плавное заполнение во время ожидания таймера if control_timer.time_left > 0 and state != STATE_MACHINE.STOP_CONTROL: var timer_progress = (control_timer.wait_time - control_timer.time_left) / control_timer.wait_time base_progress = lerp(base_progress - 5.0, base_progress, timer_progress) - + # Учитываем прогресс по лучам внутри UG_SET_RAY состояния if state == STATE_MACHINE.UG_SET_RAY: var addr: int = _get_ug_address() @@ -669,7 +685,7 @@ func progressbar_status() -> void: var max_ray_value = 5.0 # максимальное значение луча для прогресса var ray_progress = float(ray_value) / max_ray_value * 40.0 base_progress += ray_progress - + # Распределяем прогресс по ФС if total_fs_to_check > 0: var progress_per_fs = (PROGRESS_COMPLETE - PROGRESS_INIT) / total_fs_to_check @@ -677,7 +693,7 @@ func progressbar_status() -> void: prog_back = fs_base_progress + (base_progress * progress_per_fs / PROGRESS_COMPLETE) else: prog_back = base_progress - + if control_timer.time_left > 0 and not control_timer.is_stopped(): prog_back += (control_timer.wait_time - control_timer.time_left) + 10 @@ -725,9 +741,9 @@ func on_state_mashine(): ## Обработка таймаута контроля func on_stop_control() -> void: _handle_fs_turn_off_state() - + if state == STATE_MACHINE.UG_SET_RAY: - flag_no_trust_yau07 = true + flags.no_trust_yau07 = true state = STATE_MACHINE.IN_EMS_STOP #endregion @@ -735,37 +751,37 @@ func on_stop_control() -> void: #region DEVICE_CONFIGURATION ## Определение имени и конфигурации устройства func _determine_self_name() -> void: - flag_no_trust_yau07 = false - flag_only_fs = false + flags.no_trust_yau07 = false + flags.only_fs = false cc = 0 state = STATE_MACHINE.get('INIT', 0) var current_unit = unit_prd.name var parts = current_unit.split('-') self_name = parts[-1] - + var device_type: String = _get_device_type() - if device_type.is_empty(): + if device_type.is_empty(): return # Загрузка конфигурации устройства var device_config = _device_constants.get(device_type, {}) var device_data_config = _device_configs.get(device_type, {}) - + constants = device_config.get('constants', {}) pribor_config = device_config.get('pribor_config', {}) - + # Конвертация fs_params ключей в int var raw_fs_params = device_config.get('fs_params', {}) fs_parameters = {} for key in raw_fs_params: fs_parameters[int(key)] = raw_fs_params[key] - + # Загрузка конфигураций блоков block_ip_config = _load_block_config(device_data_config.get('block_ip', {}), 'block_ip') block_kasseta_y5_config = _load_block_config(device_data_config.get('block_kasseta', {}), 'block_kasseta') control_results = device_data_config.get('control_results', {}) current_litera = device_config.get('start_litera', 0) - + # Определение общего количества ФС для контроля match self_name: '1к', '2к', '3к', '4к': @@ -774,7 +790,7 @@ func _determine_self_name() -> void: total_fs_to_check = 2 # Литеры 2, 3 '1в', '2в', '3в', '4в': total_fs_to_check = 2 # Литеры 4, 5 - + progress_value = 0 completed_fs_count = 0 current_fs_progress = 0.0 @@ -793,11 +809,11 @@ func _load_block_config(config, config_type: String) -> Dictionary: ## Определение типа устройства по имени func _get_device_type() -> String: - if self_name.ends_with('н'): + if self_name.ends_with('н'): return 'PRD_N' - elif self_name.ends_with('в'): + elif self_name.ends_with('в'): return 'PRD_V' - elif self_name.ends_with('к'): + elif self_name.ends_with('к'): return 'PRD_K' return '' #endregion @@ -812,7 +828,7 @@ func initialize_connections() -> void: interfer.connect('interfer_resized', Callable(self, 'on_interfer_resized')) unit_prd.connect('data_received', Callable(self, 'on_data_received')) unit_prd.connect('line_changed', Callable(self, 'on_line_changed_yau07')) - + # Подключение сигналов режимов работы var mode_signals = ['режим_работа', 'режим_журнал', 'режим_эмс', 'режим_настройки'] for signal_name in mode_signals: @@ -829,34 +845,38 @@ func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> vo var fs_result := {fs_key: 0} fs_result = on_fs_state(packet_type_7, fs_mapping, fs_result, _fs_rules) control_results[fs_key] = fs_result[fs_key] - flag_fs_status_ok = control_results[fs_key] == 1 + flags.fs_status_ok = control_results[fs_key] == 1 ## Обработка изменения размера интерферометра func on_interfer_resized(ecms_dic: Dictionary) -> void: ecms = ecms_dic + current_ecm_key = take_ecm_id(ecms, self_name, current_litera) + flags.ecm_is_comming = (current_ecm_key != 0) # Явное установление состояния ## Обработка запуска контроля устройства func _on_start_contol_device()-> void: _set_status('Подготовка к контролю') restore_default_states() + flags.in_control = true machine_timer.wait_time = constants.STATE_MASHINE_TIMER machine_timer.start() ## Обработка изменения режима работы func on_mode_changed(in_tree: bool) -> void: - flag_in_control = in_tree + flags.in_control = in_tree if not in_tree: ## При нажатии выхода из режима контроль _set_status('Ожидание запуска контроля') - cmd_array.append([unit_prd.CmdCode.WRITE_ISA,[ + cmd_array.append([unit_prd.CmdCode.WRITE_ISA,[ constants.ADDR_UG_LITERA_1, DATA_EXIT_CONTOL_ISA, constants.ADDR_UG_LITERA_2, DATA_EXIT_CONTOL_ISA, constants.ADDR_UG_LITERA_3, DATA_EXIT_CONTOL_ISA]]) - flag_control_is_over = false - flag_no_trust_yau07 = false - flag_only_fs = false + flags.control_is_over = false + flags.no_trust_yau07 = false + flags.only_fs = false + flags.ecm_is_comming = false progress_value = 0 machine_timer.stop() state = STATE_MACHINE.INIT @@ -869,30 +889,39 @@ func on_mode_changed(in_tree: bool) -> void: # Вызывается при смене связи я ячейков ЯУ-07Б func on_line_changed_yau07(_status: Object)->void: _set_status('Ожидание запуска контроля') - flag_control_is_over = false - flag_no_trust_yau07 = false - flag_only_fs = false + flags.control_is_over = false + flags.no_trust_yau07 = false + flags.only_fs = false restore_default_states() #endregion +#region ECMS +## Универсальная проверка доступа к ecms: +func _get_current_ecm() -> Variant: + if current_ecm_key != 0 and ecms.has(current_ecm_key): + return ecms[current_ecm_key] + return null +#endregion + + #region DKM_PROCESSING ## Обработка статуса ДКМ из пакета ЯУ-07 func _process_dkm_status(status: PackedByteArray) -> void: if not control_results.has(_get_current_fs_key(current_litera, _fs_keys)): return - + var dkm_bit = _get_dkm_bit_for_current_fs(current_litera, constants) if dkm_bit == 0: control_results['dkm_1'] = check_dkm(status, dkm_bit) - + var addr: int = constants.ADDR_UG_LITERA_1 if current_litera == 3 or current_litera == 5 or current_litera == 7: addr = constants.ADDR_UG_LITERA_2 - + if not unit_prd.isa_ports.has(addr) or not (unit_prd.cmd_state == unit_prd.CmdState.DONE): return - + if not unit_prd.isa_ports[addr] & 0x07 == 6: return @@ -939,7 +968,7 @@ func get_current_status() -> String: ## Геттер для результатов контроля func get_control_results() -> Dictionary: return { - 'control_is_over': flag_control_is_over, + 'control_is_over': flags.control_is_over, 'result_dic': control_results, 'power_dic': power_result, 'block_kasseta_y5_config': block_kasseta_y5_config, @@ -980,12 +1009,11 @@ static func _handle_read_isa(prd_unit: Object, read_isa_ports: Array, prd_cmd_ar ## Управление модулем ФС (включить/отключить излучение) -static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, litera: int, power_um: int) -> void: +static func manage_fs(pribor: String, p_conf: Dictionary, fs_params: Dictionary, litera: int, power_um: int) -> void: var config: Dictionary = p_conf[pribor] var angle: float = config.angle var sectors: Array = config.sectors - - var interfer_name: String = 'k1' if mode else 'off' + var interfer_name: String = 'k1' var fs_arr: Array = [] if litera in fs_params: @@ -996,8 +1024,7 @@ static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: params.width, sectors[litera - 1] if litera == 1 else sectors[litera - 5] if litera > 5 else sectors[litera - 4] if litera > 3 else sectors[litera - 2] ]) - - signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um) + signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um) ## Проверка кассет П1 и ИП МА2000 @@ -1037,7 +1064,7 @@ static func check_temperature_um(status_prd: PackedByteArray) -> Dictionary: var return_dic_temp: Dictionary var ukp1_online: int = (status_prd[0] >> 2) & 1 var ukp2_online = (status_prd[0] >> 3) & 1 - + if ukp1_online: var tmp_1: int var temperature_ukp_1: int @@ -1045,28 +1072,28 @@ static func check_temperature_um(status_prd: PackedByteArray) -> Dictionary: temperature_ukp_1 = status_prd.decode_u16(Constants.TEMPERATURE_UKP_1 + 2 * i_temp) tmp_1 = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_1) * TEMP + 3) return_dic_temp[arr_um[i_temp]] = tmp_1 - + if ukp2_online: for i_temp in 8: var temperature_ukp_2: int = status_prd.decode_u16(Constants.TEMPERATURE_UKP_2 + 2 * i_temp) var tmp_2: int = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_2) * TEMP + 3) return_dic_temp[arr_um[i_temp+8]] = tmp_2 - + return return_dic_temp static func check_overheating(temperature_data: Dictionary) -> bool: const MAX_TEMP: int = 55 const MIN_VALID_TEMP: int = -1500 - const MAX_VALID_TEMP: int = 150 - + const MAX_VALID_TEMP: int = 130 + for key in temperature_data: var temp = temperature_data[key] - + # Пропускаем невалидные значения if temp < MIN_VALID_TEMP or temp > MAX_VALID_TEMP: continue - + # Проверяем превышение температуры if temp > MAX_TEMP: return false @@ -1083,13 +1110,13 @@ static func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool: ## Распределение номеров ФС по приборам static func _create_fs_mapping(s_name: String) -> Dictionary: var suffixes: Dictionary = { - 0: '1к', 1: '4к', 2: '3к', 3: '2к', - 4: '1н', 5: '4н', 6: '3н', 7: '2н', - 8: '1н', 9: '4н', 10: '3н', 11: '2н', - 12: '1в', 13: '4в', 14: '3в', 15: '2в', - 16: '1в', 17: '4в', 18: '3в', 19: '2в', - 20: '1к', 21: '4к', 22: '3к', 23: '2к', - 24: '1к', 25: '4к', 26: '3к', 27: '2к', + 0: '1к', 1: '4к', 2: '3к', 3: '2к', + 4: '1н', 5: '4н', 6: '3н', 7: '2н', + 8: '1н', 9: '4н', 10: '3н', 11: '2н', + 12: '1в', 13: '4в', 14: '3в', 15: '2в', + 16: '1в', 17: '4в', 18: '3в', 19: '2в', + 20: '1к', 21: '4к', 22: '3к', 23: '2к', + 24: '1к', 25: '4к', 26: '3к', 27: '2к', } var mapping: Dictionary = {} @@ -1256,7 +1283,7 @@ static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pri ray_dic[RAY_45].size() == 0: control_dic[dou] = false return control_dic - + # Подсчет значений ниже порога по позициям var low_power_by_position: Array = [0, 0, 0, 0, 0, 0] # Счетчики для 6 позиций for ray_key in [RAY_m5, RAY_5, RAY_15, RAY_25, RAY_35, RAY_45]: @@ -1264,7 +1291,7 @@ static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pri for i in range(power_array.size()): if power_array[i] < cnst.POWER_THRESHOLD: low_power_by_position[i] += 1 - + # Проверяем, нет ли позиции где много низких значений var limit_power_um: int = 2 var good_positions: int = 0 @@ -1289,27 +1316,20 @@ func _deep_copy_power_structure() -> Dictionary: func restore_default_states() -> void: if _default_states.is_empty(): _initialize_default_states() - + # Восстановление простых переменных - flag_write_isa = _default_states['flag_write_isa'] - flag_fs_status_ok = _default_states['flag_fs_status_ok'] - flag_si_fs_input = _default_states['flag_si_fs_input'] - flag_si_fs_output = _default_states['flag_si_fs_output'] - flag_control_is_over = _default_states['flag_control_is_over'] - flag_no_trust_yau07 = _default_states['flag_no_trust_yau07'] - flag_only_fs = _default_states['flag_only_fs'] - + flags = _default_states['flags'].duplicate(true) state = _default_states['state'] current_litera = _default_states['current_litera'] - + progress_value = _default_states['progress_value'] current_status = _default_states['current_status'] total_fs_to_check = _default_states['total_fs_to_check'] completed_fs_count = _default_states['completed_fs_count'] current_fs_progress = _default_states['current_fs_progress'] - + cc = _default_states['cc'] - + # Восстановление словарей (глубокое копирование) ems_g_sock_dic = _default_states['ems_g_sock_dic'].duplicate(true) power_for_litera = _default_states['power_for_litera'].duplicate(true) @@ -1318,28 +1338,18 @@ func restore_default_states() -> void: temperature_um = _default_states['temperature_um'].duplicate(true) ecms = _default_states['ecms'].duplicate(true) block_ip_config = _default_states['block_ip_config'].duplicate(true) - block_kasseta_y5_config = _default_states['block_kasseta_y5_config'].duplicate(true) - + # Остановка таймеров control_timer.stop() ems_6666_timer.stop() machine_timer.stop() - + _set_status('Состояния сброшены к значениям по умолчанию') ## Получение текущих состояний для отладки func get_current_states() -> Dictionary: return { - 'flags': { - 'write_isa': flag_write_isa, - 'fs_status_ok': flag_fs_status_ok, - 'si_fs_input': flag_si_fs_input, - 'si_fs_output': flag_si_fs_output, - 'in_control': flag_in_control, - 'control_is_over': flag_control_is_over, - 'no_trust_yau07': flag_no_trust_yau07, - 'only_fs': flag_only_fs - }, + 'flags': flags.duplicate(true), 'state_machine': { 'state': state, 'current_litera': current_litera diff --git a/table/table.gd b/table/table.gd index 351fb677..914622a7 100644 --- a/table/table.gd +++ b/table/table.gd @@ -301,6 +301,16 @@ func default_selector_size_proc(i_row: int, rect: Array) -> void: rect[3] += node_gap.y +## Очищает в словаре nodes от невалидных ссылок +func cleanup_invalid_selectors(): + var keys_to_remove = [] + for key in nodes: + if key.begins_with(SLCT_PREFIX) and not is_instance_valid(nodes[key]): + keys_to_remove.append(key) + for key in keys_to_remove: + nodes.erase(key) + print("Удален невалидный селектор: ", key) + ## func clear_rows_selected(): var rows_count: = get_rows_count() @@ -323,7 +333,6 @@ func _set_row_selected(i_row: int, selected: bool = true) -> void: return if nodes.has(selector_key) and (not selected): var selector = nodes[selector_key] - nodes.erase(selector_key) if is_instance_valid(selector): var prnt = selector.get_parent_control() if prnt: @@ -331,6 +340,7 @@ func _set_row_selected(i_row: int, selected: bool = true) -> void: selector.queue_free() else: push_warning('обращение к удалённому элементу \"%s\"' % selector_key) + nodes.erase(selector_key) elif (not nodes.has(selector_key)) and selected: var selector = ScnSelector.instantiate() var rect: = [0, 0, 0, 0]