Доработка работы с ecms в контроле + форматирование пробелов

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)
 

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)
 
 

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)
 
 

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)
 
 

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):

scenes/контроль/контроль.tscn

@@ -171,7 +171,7 @@ 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
         # Проверяем только основные устройства

scripts/pribor-prd.gd

@@ -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,13 +181,7 @@ 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,
@@ -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,20 +282,18 @@ 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
 
@@ -325,9 +335,9 @@ func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void:
         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,28 +378,19 @@ 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()
@@ -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
 
 
@@ -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:
@@ -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
 
 
@@ -653,8 +669,8 @@ 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:
@@ -727,7 +743,7 @@ 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,8 +751,8 @@ 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
@@ -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,[
             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,13 +889,22 @@ 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:
@@ -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
@@ -1058,7 +1085,7 @@ static func check_temperature_um(status_prd: PackedByteArray) -> Dictionary:
 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]
@@ -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 = {}
@@ -1291,14 +1318,7 @@ func restore_default_states() -> void:
         _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']
 
@@ -1318,7 +1338,6 @@ 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()
@@ -1330,16 +1349,7 @@ func restore_default_states() -> void:
 ## Получение текущих состояний для отладки
 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

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]