Доработка, отладка общего файла

scenes/pribor-prd-k/pribor-prd-k.gd

@@ -34,14 +34,14 @@ const Constants: Dictionary = {
     'POWER_UM': 75,
 }
 # Конфигурация параметров для каждого прибора
-const PRIBOR_CONFIG  := {
+const PRIBOR_CONFIG := {
         '1к': {'angle': 0.0, 'sectors': [0, 20, 24]},
         '2к': {'angle': 90.0, 'sectors': [3, 23, 27]},
         '3к': {'angle': 180.0, 'sectors': [2, 22, 26]},
         '4к': {'angle': 270.0, 'sectors': [1, 21, 25]},
 }
 # Конфигурация частот и ширин для каждого ФС
-const FS_PARAMS  := {
+const FS_PARAMS := {
         1: {'freq': 450.0, 'width': 80.0},
         6: {'freq': 2450.0, 'width': 110.0},
         7: {'freq': 4750.0, 'width': 110.0}
@@ -58,7 +58,7 @@ enum STATE_MASHINE {
         STOP_CONTROL,
         AWAIT
     }
-var block_config_k := {
+var block_ip_config_k := {
         'maa2000_1': [0, false],
         'maa2000_2': [1, false],
         'ip9_50_1':  [2, false],
@@ -86,101 +86,81 @@ var ug_work_3: int = 0
 var control_timer: Timer = Timer.new()
 var mashine_timer: Timer = Timer.new()
 var pribor: String
+var prd_module: Object
+var unit_prd: Object
 # Результаты контроля
-var _control_results: Dictionary = {
+var control_results: Dictionary = {
     'block_ip': false,     # Проверка касет П1 и ИП МА2000
     'temperature': true,   # Проверка температур УМ
     'dkm_1': false,        # Проверка ДКМ 1
     'dkm_6': false,        # Проверка ДКМ 6
     'dkm_7': false,        # Проверка ДКМ 7
-    'power_ip': false,    # Мощность от УКП
+    'power_um': false,    # Мощность от УКП
     'fs_1': false,         # Проверка ФС 1
     'fs_6': false,         # Проверка ФС 6
     'fs_7': false,         # Проверка ФС 7
 }
 
 static var node_common_func = load('res://scripts/pribor-prd.gd')
+var test = preload('res://scripts/pribor-prd.gd')
+var control_prd
 
 
 func _ready() -> void:
     if Engine.is_editor_hint():
         return
+
     initialize_connections()
     setup_timer()
     set_default_state()
 
 
 func on_state_mashine() -> void:
-    match state:
-        STATE_MASHINE.INIT:
-            if current_fs == 1 or current_fs == 6 or current_fs == 7:
-                state = STATE_MASHINE.FS_TURN_ON
-            else:
-                on_control_result()
-                state = STATE_MASHINE.AWAIT
-
-        STATE_MASHINE.FS_TURN_ON:
-            node_common_func.manage_fs(true, pribor, PRIBOR_CONFIG, FS_PARAMS, current_fs, Constants.POWER_UM)
-            control_timer.wait_time = Constants.TIMER_DELAY
-            control_timer.start()
-            state = STATE_MASHINE.FS_WORK
-
-        STATE_MASHINE.FS_WORK:
-            if (current_fs == 6 and flag_check_dkm and not flag_timer_started) or \
-               (current_fs == 7 and flag_check_dkm and not flag_timer_started) or \
-               (current_fs == 1 and not flag_timer_started):
-                state = STATE_MASHINE.UM_RUN
-
-        STATE_MASHINE.UM_RUN:
-            var unit_name = get_meta('unit_name')[0]
-            var unit_prd = network.get_unit_instance(unit_name)
-            var prd_module = prd.prd_dict[unit_prd.name]
-            prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.BASE_ADDR_EMS_G, 6666]])
-            flag_timer_started = true
-            state = STATE_MASHINE.UG_SET
-
-        STATE_MASHINE.UG_SET:
-            on_ug_setting()
-            state = STATE_MASHINE.FS_WORK
-
-        STATE_MASHINE.FS_TURN_OFF:
-            node_common_func.manage_fs(false, pribor, PRIBOR_CONFIG, FS_PARAMS, current_fs, Constants.POWER_UM)
-            power_control_result()
-            state = STATE_MASHINE.STOP_CONTROL
-
-        STATE_MASHINE.STOP_CONTROL:
-            flag_timer_started = false
-            flag_check_dkm = false
-            match current_fs:
-                1: current_fs = 6
-                6: current_fs = 7
-                7: current_fs = 0
-            state = STATE_MASHINE.INIT
+    control_prd.state_control_machine()
+    
+    block_ip_config_k = control_prd.block_config
+    var node_ip_power_arr: Array = get_tree().get_nodes_in_group('power_supply')
+    for power_supply in node_ip_power_arr:
+        var meta_ip  = power_supply.get_meta('ip')
+        if block_ip_config_k.has(meta_ip):
+            power_supply.state = STATE_VAL.GOOD if block_ip_config_k[meta_ip][1] else STATE_VAL.ERROR
+    
+    control_results = control_prd.control_results
+    if control_prd.current_fs == 1:
+        $kasseta_fs_kd/ref_A2.state = STATE_VAL.GOOD if control_results.dkm_1 else STATE_VAL.ERROR
+    elif control_prd.current_fs == 6:
+        $kasseta_fs_kd/ref_A4.state = STATE_VAL.GOOD if control_results.dkm_6 else STATE_VAL.ERROR
+    elif control_prd.current_fs == 7:
+        $kasseta_fs_kd/ref_A7.state = STATE_VAL.GOOD if control_results.dkm_7 else STATE_VAL.ERROR
+    
+    print(control_prd.power_result)
+    if not control_prd.power_result['ray_25_1'] or not control_prd.power_result['ray_25_6'] or not control_prd.power_result['ray_25_7']:
+        return
+        
+    var node_arr_power: Array = get_tree().get_nodes_in_group('power_amplifier')
+    for i_pow in node_arr_power.size():
+        if i_pow < 1:
+            var pw = node_arr_power[i_pow]
+            pw.value1  = str(control_prd.power_result['ray_25_1'][i_pow])
+        elif i_pow < 7:
+            var pw = node_arr_power[i_pow]
+            pw.value1  = str(control_prd.power_result['ray_25_6'][i_pow-1])
+        elif i_pow < 13:
+            var pw = node_arr_power[i_pow]
+            pw.value1  = str(control_prd.power_result['ray_25_7'][i_pow-7])
 
 
 func initialize_connections() -> void:
     var unit_name = get_meta('unit_name')[0]
-    var unit_prd = network.get_unit_instance(unit_name)
-    var current_unit = unit_prd.name
-    var parts = current_unit.split('-')
-    pribor = parts[-1]
-    fs_mapping_k = {
-        0: { 'node': 'kasseta_fs_kd/ref_A3', 'condition': pribor == '1к' },
-        1: { 'node': 'kasseta_fs_kd/ref_A3', 'condition': pribor == '4к' },
-        2: { 'node': 'kasseta_fs_kd/ref_A3', 'condition': pribor == '3к' },
-        3: { 'node': 'kasseta_fs_kd/ref_A3', 'condition': pribor == '2к' },
-        20: { 'node': 'kasseta_fs_kd/ref_A6', 'condition': pribor == '1к' },
-        21: { 'node': 'kasseta_fs_kd/ref_A6', 'condition': pribor == '4к' },
-        22: { 'node': 'kasseta_fs_kd/ref_A6', 'condition': pribor == '3к' },
-        23: { 'node': 'kasseta_fs_kd/ref_A6', 'condition': pribor == '2к' },
-        24: { 'node': 'kasseta_fs_kd/ref_A5', 'condition': pribor == '1к' },
-        25: { 'node': 'kasseta_fs_kd/ref_A5', 'condition': pribor == '4к' },
-        26: { 'node': 'kasseta_fs_kd/ref_A5', 'condition': pribor == '3к' },
-        27: { 'node': 'kasseta_fs_kd/ref_A5', 'condition': pribor == '2к' },
-    }
-    unit_prd.connect('data_received', Callable(self, 'on_data_received'))
+    prd_module = prd.prd_dict[unit_name]
+    unit_prd = prd_module.unit_yau07
+
+    #signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping_k))
     unit_prd.connect('line_changed', Callable(self, 'on_line_changed'))
-    signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping_k))
+    var array_power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
+    var fs_node_array: Array = get_tree().get_nodes_in_group('fs_group')
+    control_prd = test.TestPRD.new($control_result, unit_prd, prd_module, Constants, PRIBOR_CONFIG, FS_PARAMS, block_ip_config_k, array_power_amplifier, control_results, fs_node_array)
+    add_child(control_prd)
 
 
 func setup_timer() -> void:
@@ -189,12 +169,6 @@ func setup_timer() -> void:
     mashine_timer.wait_time = 0.5
     mashine_timer.start()
 
-    add_child(control_timer)
-    control_timer.connect('timeout', Callable(self, 'on_stop_control'))
-    control_timer.one_shot = true
-    control_timer.wait_time = 10.0
-    control_timer.start()
-
 
 func set_default_state() -> void:
     for group in get_tree().get_nodes_in_group('default_reset'):
@@ -207,204 +181,75 @@ func set_default_state() -> void:
 func _enter_tree() -> void:
     if Engine.is_editor_hint():
         return
-    $control_result.text = ''
+    $control_result.text = 'Выполняется ...'
+    $control_result.add_theme_color_override('font_color', Color.ALICE_BLUE)
     signaller.connect('режим_работа', Callable(self, 'on_mode_changed').bind(false))
 
 
 func _exit_tree() -> void:
-    var unit_name = get_meta('unit_name')[0]
-    var unit_prd = network.get_unit_instance(unit_name)
-    var prd_module = prd.prd_dict[unit_prd.name]
     prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.ADDR_UG_LITERA_1, ug_work_1, Constants.ADDR_UG_LITERA_2, ug_work_2, Constants.ADDR_UG_LITERA_3, ug_work_3]])
 
 
-func on_line_changed(unit_prd: Object) -> void:
-    if not unit_prd.online:
+func on_line_changed(unit_pribor: Object) -> void:
+    if not unit_pribor.online:
         set_default_state()
 
 
-func on_data_received(unit_prd: Object) -> void:
-    if not is_inside_tree():
-        return
-
-    var status: PackedByteArray = unit_prd.status
-    # 1. Обновляем статусы блоков
-    block_config_k = node_common_func.check_block_ip(status, block_config_k)
-    # 2. Обновляем ноды power_supply
-    var node_power_arr = get_tree().get_nodes_in_group('power_supply')
-    for power_supply in node_power_arr:
-        var meta_ip  = power_supply.get_meta('ip')
-        if block_config_k.has(meta_ip):
-            power_supply.state = STATE_VAL.GOOD if block_config_k[meta_ip][1] else STATE_VAL.ERROR
-
-    node_common_func.check_temperature_um(status, get_tree().get_nodes_in_group('power_amplifier'))
-    # Обработка данных ЭМС
-    #_process_ems_data(status)
-
-    if current_fs == 1 and _control_results.fs_1:
-        flag_check_dkm = check_dkm(status, Constants.DKM_BIT_1)
-    elif current_fs == 6 and _control_results.fs_6:
-        flag_check_dkm = check_dkm(status, Constants.DKM_BIT_6)
-    elif current_fs == 7 and _control_results.fs_7:
-        flag_check_dkm = check_dkm(status, Constants.DKM_BIT_7)
-    
-    if flag_check_dkm:
-        _process_ukp_power(status)
-
-
-## Обрабатывает данные ЭМС и обновляет UI панели
-#func _process_ems_data(status: PackedByteArray) -> void:
-    ### Контроль ЭМС
-    #var in_blank: int = status.decode_u16(Constants.IN_BLANK_PRD)
-    #var out_blank: int = status.decode_u16(Constants.OUT_BLANK_PRD)
+#func on_data_received(unit_pribor: Object) -> void:
+    #if not is_inside_tree():
+        #return
 #
-    ## Обновление фреймов для входных сигналов
-    #$Monitoring_panel/in_fs_1.frame = (in_blank >> Constants.CI_6_OT_FS) & 1
-    #$Monitoring_panel/in_fs_2.frame = (in_blank >> Constants.CI_7_OT_FS) & 1
-    #$Monitoring_panel/in_fs_3.frame = (in_blank >> Constants.CI_1_OT_FS) & 1
+    #var status: PackedByteArray = unit_pribor.status
+    ## 1. Обновляем статусы блоков
+    #block_config_k = node_common_func.check_block_ip(status, block_config_k)
+    ## 2. Обновляем ноды power_supply
+    #var node_power_arr = get_tree().get_nodes_in_group('power_supply')
+    #for power_supply in node_power_arr:
+        #var meta_ip  = power_supply.get_meta('ip')
+        #if block_config_k.has(meta_ip):
+            #power_supply.state = STATE_VAL.GOOD if block_config_k[meta_ip][1] else STATE_VAL.ERROR
 #
-    ## Обновление фреймов для выходных сигналов ЭМС
-    #$Monitoring_panel/out_ems_1.frame = (out_blank >> Constants.CI_6_B_UF) & 1
-    #$Monitoring_panel/out_ems_2.frame = (out_blank >> Constants.CI_7_B_UF) & 1
-    #$Monitoring_panel/out_ems_3.frame = (out_blank >> Constants.CI_1_B_UF) & 1
+    #node_common_func.check_temperature_um(status, get_tree().get_nodes_in_group('power_amplifier'))
+#
+    #if current_fs == 1 and control_results.fs_1:
+        #control_results = node_common_func.check_dkm(status, Constants.DKM_BIT_1, control_results)
+        #flag_check_dkm = control_results.dkm_1
+    #elif current_fs == 6 and control_results.fs_6:
+        #control_results = node_common_func.check_dkm(status, Constants.DKM_BIT_6, control_results)
+        #flag_check_dkm = control_results.fs_6
+    #elif current_fs == 7 and control_results.fs_7:
+        #control_results = node_common_func.check_dkm(status, Constants.DKM_BIT_7, control_results)
+        #flag_check_dkm = control_results.dkm_7
+#
+    #var power_result: Dictionary = {'ray_25' : []}
+#
+    #if flag_check_dkm:
+        #power_result = node_common_func.power_um_ukp(status, current_fs, power_result)
 
 
-## Проверка ДКМ
-func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool:
-    const DKM: int = 28
-
-    var status_dkm = status_prd[DKM] >> bit_dkm & 1
-    print(status_prd[DKM])
-    if bit_dkm == 5:
-        $dou6_A7.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
-        $kasseta_fs_kd/ref_A4.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
-        _control_results['dkm_6'] = status_dkm
-    elif bit_dkm == 6:
-        $dou7_A8.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
-        $kasseta_fs_kd/ref_A7.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
-        _control_results['dkm_7'] = status_dkm
-    elif bit_dkm == 0:
-        $kasseta_fs_kd/ref_A2.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
-        _control_results['dkm_1'] = status_dkm
-    return status_dkm
+#func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> void:
+    #var fs_result: Dictionary
+    #if current_fs == 1:
+         #fs_result = {'fs_1': STATE_VAL.NONE}
+    #elif current_fs == 6:
+        #fs_result = {'fs_6': STATE_VAL.NONE}
+    #elif current_fs == 7:
+        #fs_result = {'fs_7': STATE_VAL.NONE}
+    #fs_result = node_common_func.on_fs_state(packet_type_7, fs_mapping, fs_result)
+#
+    #var fs_array: Array = get_tree().get_nodes_in_group('fs')
+    #for fs in fs_array:
+        #var fs_meta: String = fs.get_meta('fs')
+        #fs.state = fs_result[fs_meta]
 
 
-func _process_ukp_power(status: PackedByteArray) -> void:
-    var power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
-    if current_fs == 1:
-        ## Мощность от УМ (УКП) литеры 1
-        var arr_power_ukp_1: Array = []
-        var power_ukp_1: int
-        power_ukp_1 = status.decode_u16(Constants.POWER_UKP_1 + 2 * 7)
-        arr_power_ukp_1.append(power_ukp_1)
-
-        if count_packet_1 == 0:
-            power_array_1 = arr_power_ukp_1
-        else:
-            for i in arr_power_ukp_1.size():
-                if arr_power_ukp_1[i] > power_array_1[i]:
-                    power_array_1[i] = arr_power_ukp_1[i]
-
-        power_amplifier[6].value1 = '%d' % power_array_1[0]
-        power_amplifier[6].state = STATE_VAL.GOOD if power_array_1[0] > Constants.TEMP_THRESHOLD else STATE_VAL.ERROR
-
-        count_packet_1 += 1
-
-    elif current_fs == 6:
-        ## Мощность УМ от УКП 1
-        var arr_power_ukp_1: Array = []
-        if (status[0] >> 2) & 1:
-            var power_ukp_1: int
-            for i_power in range(6):
-                power_ukp_1 = status.decode_u16(Constants.POWER_UKP_1 + 2 * i_power)
-                arr_power_ukp_1.append(power_ukp_1)
-
-            if count_packet_6 == 0:
-                power_array_1 = arr_power_ukp_1
-            else:
-                for i in arr_power_ukp_1.size():
-                    if arr_power_ukp_1[i] > power_array_1[i]:
-                        power_array_1[i] = arr_power_ukp_1[i]
-
-        for i in 6:
-            power_amplifier[i].value1 = '%d' % power_array_1[i]
-            power_amplifier[i].state = STATE_VAL.GOOD if power_array_1[i] > Constants.TEMP_THRESHOLD else STATE_VAL.ERROR
-        count_packet_6 += 1
-
-    elif current_fs == 7:
-        ## Мощность УМ от УКП 2
-        var arr_power_ukp_2: Array = []
-        if (status[0] >> 2) & 1:
-            for i_power in range(6):
-                var power_ukp_2 = status.decode_u16(Constants.POWER_UKP_2 + 2 * i_power)
-                arr_power_ukp_2.append(power_ukp_2)
-
-            if count_packet_7 == 0:
-                power_array_2 = arr_power_ukp_2
-            else:
-                for i in arr_power_ukp_2.size():
-                    if arr_power_ukp_2[i] > power_array_2[i]:
-                        power_array_2[i] = arr_power_ukp_2[i]
-
-        for i in 6:
-            power_amplifier[i+7].value1 = '%d' % power_array_2[i]
-            power_amplifier[i+7].state = STATE_VAL.GOOD if power_array_2[i] > Constants.TEMP_THRESHOLD else STATE_VAL.ERROR
-
-        count_packet_7 += 1
-
-
-func power_control_result() -> void:
-    var power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
-    _control_results['power_ukp'] = true
-    for amp in power_amplifier:
-        if amp.state != STATE_VAL.GOOD:
-            _control_results['power_ukp'] = false
-            break
-
-
-func on_stop_control() -> void:
-    state = STATE_MASHINE.FS_TURN_OFF
-
-
-func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> void:
-    # Словарь для маппинга: ключ - номер FS, значение - целевая нода и условие прибора
-    var fs_mapper: Array = get_tree().get_nodes_in_group('fs')
-
-    for fs in packet_type_7:
-        if fs in fs_mapping and fs_mapping[fs]['condition']:
-            var data = packet_type_7[fs]
-            if fs < 4 and current_fs == 1:
-                _control_results['fs_1'] = (data.isg == 1)
-                var state_fs = STATE_VAL.GOOD if data.isg == 1 else STATE_VAL.ERROR if data.isg == 0 else STATE_VAL.NONE
-                var node_name = fs_mapping[fs]['node']
-                var node = get_node(node_name)
-                node.state = state_fs
-            elif fs < 24 and current_fs == 6:
-                _control_results['fs_6'] = (data.isg == 1)
-                var state_fs = STATE_VAL.GOOD if data.isg == 1 else STATE_VAL.ERROR if data.isg == 0 else STATE_VAL.NONE
-                var node_name = fs_mapping[fs]['node']
-                var node = get_node(node_name)
-                node.state = state_fs
-            elif fs > 23 and current_fs == 7:
-                _control_results['fs_7'] = (data.isg == 1)
-                var state_fs = STATE_VAL.GOOD if data.isg == 1 else STATE_VAL.ERROR if data.isg == 0 else STATE_VAL.NONE
-                var node_name = fs_mapping[fs]['node']
-                var node = get_node(node_name)
-                node.state = state_fs
-
-
-func on_ug_setting() -> void:
-    var unit_name = get_meta('unit_name')[0]
-    var unit_prd = network.units[unit_name]
-
-    var result_1 = ((Constants.attenutor_um_1 & 0x07) << 3) | (Constants.dou_ray_nuber & 0x07)
-    var result_2 = ((Constants.attenutor_um_2 & 0x07) << 3) | (Constants.dou_ray_nuber & 0x07)
-    var prd_module = prd.prd_dict[unit_prd.name]
-    prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.ADDR_UG_LITERA_1, result_1,
-                                                              Constants.ADDR_UG_LITERA_2, result_2,
-                                                              Constants.ADDR_UG_LITERA_3, Constants.attenutor_um_3]])
-
-    prd_module.cmd_array.append([unit_prd.CmdCode.READ_ISA, [Constants.ADDR_UG_LITERA_1, Constants.ADDR_UG_LITERA_2, Constants.ADDR_UG_LITERA_3]])
+#func power_um_control_result() -> void:
+    #var power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
+    #control_results['power_um'] = true
+    #for amp in power_amplifier:
+        #if amp.state != STATE_VAL.GOOD:
+            #control_results['power_um'] = false
+            #break
 
 
 func on_mode_changed(in_tree: bool) -> void:
@@ -413,13 +258,13 @@ func on_mode_changed(in_tree: bool) -> void:
 
 
 func on_control_result() -> void:
-    #Обновляем _control_results['block_ip'] на основе block_config_k
+    #Обновляем control_results['block_ip'] на основе block_config_k
     var all_blocks_ok = true
-    for block in block_config_k:
-        if not block_config_k[block][1]:  # Если хоть один блок false
+    for block in block_ip_config_k:
+        if not block_ip_config_k[block][1]:  # Если хоть один блок false
             all_blocks_ok = false
             break
-    _control_results['block_ip'] = all_blocks_ok
+    control_results['block_ip'] = all_blocks_ok
 
     # Словарь соответствия ключей ошибок и нод
     var error_nodes := {
@@ -429,18 +274,18 @@ func on_control_result() -> void:
     }
     # Проверка результатов и установка состояний
     var result: bool = true
-    for key in _control_results:
-        if not _control_results[key]:
+    for key in control_results:
+        if not control_results[key]:
             result = false
             if error_nodes.has(key):
                 error_nodes[key].state = STATE_VAL.ERROR
 
     # Установка текста и цвета результата
     var status_text := 'неисправен'
-    var status_color := Color.CRIMSON
+    var status_color := Color.RED
     if result:
         status_text = 'исправен'
-        status_color = Color.AQUAMARINE
+        status_color = Color.GREEN
 
     $control_result.text = 'Прибор ПРД-%s %s' % [pribor, status_text]
     $control_result.add_theme_color_override('font_color', status_color)

scenes/pribor-prd-n/pribor-prd-n.gd

@@ -72,7 +72,7 @@ func _ready() -> void:
 func on_state_mashine() -> void:
     match state:
         STATE_MASHINE.INIT:
-            print('Текущий запуск current_fs: ', current_fs)
+            print_debug('Текущий запуск current_fs: ', current_fs)
             if current_fs == 2 or current_fs == 3:
                 state = STATE_MASHINE.FS_TURN_ON
             else:

scenes/pribor-prd-v/pribor-prd-v.gd

@@ -1,3 +1,4 @@
+@tool
 extends 'res://scenes/контроль/прибор.gd'
 
 const Constants = {

scenes/настройки/настройки.gd

@@ -165,7 +165,7 @@ func setting_tab():
         var tootip_text = tbl_row[3]
         name_to_line_index[param_name] = i
         $scroll_set/table.add_row([node_label, node_value])
-        var label_instance = $scroll_set/table.get_node2(0, i)  
+        var label_instance = $scroll_set/table.get_node2(0, i)
         label_instance.text = param_name
         label_instance.tooltip_text = tootip_text
         $scroll_set/table.set_node_editable(0, i, false)

scripts/pribor-prd.gd

@@ -1,68 +1,351 @@
-extends Node
-
-
-static func manage_fs(mode: bool, pribor: String, pribor_config: Dictionary, fs_params: Dictionary, current_fs: int, power_um: int) -> void:
-    # Получаем конфигурацию для текущего прибора
-    var config: Dictionary = pribor_config[pribor]
-    var angle: float = config.angle
-    var sectors: Array = config.sectors
-
-    # Формируем выходные данные
-    var interfer_name: String = 'k1' if mode else 'off'
-    var fs_arr: Array = []
-
-    if current_fs in fs_params:
-        var params = fs_params[current_fs]
-        fs_arr.append([
-            angle,
-            params.freq,
-            params.width,
-            sectors[current_fs - 1] if current_fs == 1 else sectors[current_fs - 5]
-        ])
-
-    signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um)
-    print_debug(['interfer_init: ', interfer_name, fs_arr])
-
-
-## Проверка касет П1 и ИП МА2000
-static func check_block_ip(status_prd: PackedByteArray, block_config: Dictionary) -> Dictionary:
-    # Конфигурация проверяемых блоков
-    var byte_dry: int = 27
-    var ug_online: bool = (status_prd[0] >> 1) & 1
-    for block in block_config:
-        var bit: int = block_config[block][0]
-        if ug_online:
-            var status = status_prd[byte_dry] >> bit & 1
-            block_config[block][1] = false if status else true
-    return block_config
-
-
-## Проверка температур УМ от УКП
-static func check_temperature_um(status_prd: PackedByteArray, power_amplifier: Array) -> void:
-    const Constants: Dictionary = {
-            'CONST_MIN_TEMP': -25,
-            'MAXIMUM_CODE_ADC': 3796,
-            'MINIMUM_CODE_AD': 2660,
-            'TEMPERATURE_UKP_1': 47,
-            'TEMPERATURE_UKP_2': 79,
+class TestPRD extends Node:
+    enum STATE_VAL { NONE = 0, GOOD = 1, ERROR = 2 }
+    # Конфигурация параметров для каждого прибора
+    enum STATE_MASHINE {
+        INIT,
+        FS_TURN_ON,
+        FS_WORK,
+        UG_SET,
+        UM_RUN,
+        FS_TURN_OFF,
+        STOP_CONTROL,
+        AWAIT
     }
-    const TEMP: float = 115.0 / (Constants.MAXIMUM_CODE_ADC - Constants.MINIMUM_CODE_AD)
-    var ukp1_online: int = (status_prd[0] >> 2) & 1
-    if ukp1_online:
-        var tmp_1: int
-        var temperature_ukp_1: int
-        for i_temp in 6:
-            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)
-            power_amplifier[i_temp].value0 = tmp_1
-        # Темпуратура от УМ литеры 1
-        temperature_ukp_1 = status_prd.decode_u16(Constants.TEMPERATURE_UKP_1 + 2 * 7)
-        tmp_1 = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_1) * TEMP + 3)
-        power_amplifier[6].value0 = tmp_1
+    var cur_ray: String = 'ray_25_1'
+    var power_result: Dictionary = {
+        'ray_25_1': [],
+        'ray_25_6': [],
+        'ray_25_7' : [],
+    }
+    var constants: Dictionary
+    var pribor_config: Dictionary
+    var fs_parameters: Dictionary
+    var block_config: Dictionary
+    var control_results: Dictionary
+    var self_name: String
+    var state: int = STATE_MASHINE.INIT
+    var control_label: Label
+    var current_fs: int = 1
+    var flag_check_dkm: bool
+    var flag_timer_started: bool
+    var unit_prd: Object
+    var module_prd: Object
+    var power_amplify: Array
+    var fs_array_node: Array
 
-    var ukp2_online = (status_prd[0] >> 3) & 1
-    if ukp2_online:
-        for i_temp in 6:
-            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)
-            power_amplifier[i_temp+7].value0 = tmp_2
+    var control_timer: Timer = Timer.new()
+
+    func _init(ctrlabel, u_prd,  m_prd, constant, prd_config, fs_params, block_prd_config, power_amp, ctrl_results, fs_arr_node) -> void:
+        self.control_label = ctrlabel
+        self.unit_prd = u_prd
+        self.module_prd = m_prd
+        self.pribor_config = prd_config
+        self.fs_parameters = fs_params
+        self.constants = constant
+        self.block_config = block_prd_config
+        self.power_amplify = power_amp
+        self.control_results = ctrl_results
+        self.fs_array_node = fs_arr_node
+
+    func _ready() -> void:
+        initialize_connections()
+        setup_timer()
+
+    func _process(_delta: float) -> void:
+        pass
+    
+    func on_data_received(unit_pribor: Object) -> void:
+        if not is_inside_tree():
+            return
+        
+        var status: PackedByteArray = unit_pribor.status
+
+        block_config = check_block_ip(status, block_config)
+
+        check_temperature_um(status, power_amplify)
+        
+        if current_fs == 1 and control_results.fs_1:
+            control_results = check_dkm(status, constants.DKM_BIT_1, control_results)
+            flag_check_dkm = control_results.dkm_1
+        elif current_fs == 6 and control_results.fs_6:
+            control_results = check_dkm(status, constants.DKM_BIT_6, control_results)
+            flag_check_dkm = control_results.fs_6
+        elif current_fs == 7 and control_results.fs_7:
+            control_results = check_dkm(status, constants.DKM_BIT_7, control_results)
+            flag_check_dkm = control_results.dkm_7
+        
+        if control_results.dkm_1 and current_fs == 1:
+            power_result['ray_25_1'] = power_um_ukp(status, current_fs, power_result['ray_25_1'])
+        if control_results.dkm_6 and current_fs == 6:
+            power_result['ray_25_6'] = power_um_ukp(status, current_fs, power_result['ray_25_6'])
+        if control_results.dkm_7 and current_fs == 7:
+            power_result['ray_25_7'] = power_um_ukp(status, current_fs, power_result['ray_25_7'])
+        
+    
+    func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary, fs_array: Array) -> void:
+        var fs_result: Dictionary
+        if current_fs == 1:
+            fs_result = {'fs_1': STATE_VAL.NONE}
+        elif current_fs == 6:
+            fs_result = {'fs_6': STATE_VAL.NONE}
+        elif current_fs == 7:
+            fs_result = {'fs_7': STATE_VAL.NONE}
+        fs_result = on_fs_state(packet_type_7, fs_mapping, fs_result)
+        for fs in fs_array:
+            var fs_meta: String = fs.get_meta('fs')
+            if fs_result.has(fs_meta):
+                fs.state = fs_result[fs_meta]
+                control_results[fs_meta] = fs_result[fs_meta]
+    
+
+    func state_control_machine() -> void:
+        match state:
+            STATE_MASHINE.INIT:
+                control_label.text = 'Выполняется инициализация ФС-%s' % current_fs
+                if current_fs == 1 or current_fs == 6 or current_fs == 7:
+                    state = STATE_MASHINE.FS_TURN_ON
+                else:
+                    on_control_result()
+                    state = STATE_MASHINE.AWAIT
+            
+            STATE_MASHINE.FS_TURN_ON:
+                control_label.text = 'Выполняется включение ФС-%s' % current_fs
+                manage_fs(true, self_name, pribor_config, fs_parameters, current_fs, constants.POWER_UM)
+                control_timer.wait_time = constants.TIMER_DELAY
+                control_timer.start()
+                state = STATE_MASHINE.FS_WORK
+            
+            STATE_MASHINE.FS_WORK:
+                control_label.text = 'Выполняется проверка ФС-%s' % current_fs
+                if  (current_fs == 6 and flag_check_dkm and not flag_timer_started) or \
+                    (current_fs == 7 and flag_check_dkm and not flag_timer_started) or \
+                    (current_fs == 1 and not flag_timer_started):
+                        state = STATE_MASHINE.UG_SET
+            
+            STATE_MASHINE.UG_SET:
+                control_label.text = 'Выполняется настройка угла (%s) и атт (%s, %s, %s)' % [constants.dou_ray_nuber, constants.attenutor_um_1, constants.attenutor_um_2, constants.attenutor_um_3]
+                on_ug_setting()
+                state = STATE_MASHINE.UM_RUN
+
+            STATE_MASHINE.UM_RUN:
+                control_label.text = 'Выполняется настройка ЭМС'
+                module_prd.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [constants.BASE_ADDR_EMS_G, 6666]])
+                flag_timer_started = true
+                state = STATE_MASHINE.FS_WORK
+            
+            STATE_MASHINE.FS_TURN_OFF:
+                control_label.text = 'Выполняется отключение ФС-%s' % current_fs
+                manage_fs(false, self_name, pribor_config, fs_parameters, current_fs, constants.POWER_UM)
+                state = STATE_MASHINE.STOP_CONTROL
+            
+            STATE_MASHINE.STOP_CONTROL:
+                control_label.text = 'Выполняется завершение проверки ФС-%s' % current_fs
+                power_um_control_result()
+                flag_timer_started = false
+                flag_check_dkm = false
+                match current_fs:
+                    1: current_fs = 6
+                    6: current_fs = 7
+                    7: current_fs = 0
+                state = STATE_MASHINE.INIT
+    
+    
+    func initialize_connections() -> void:
+        var current_unit = unit_prd.name
+        var parts = current_unit.split('-')
+        self_name = parts[-1]
+        var fs_mapping = {
+            0: { 'condition': self_name == '1к' },
+            1: { 'condition': self_name == '4к' },
+            2: { 'condition': self_name == '3к' },
+            3: { 'condition': self_name == '2к' },
+            20: { 'condition':self_name == '1к' },
+            21: { 'condition': self_name == '4к' },
+            22: { 'condition': self_name == '3к' },
+            23: { 'condition': self_name == '2к' },
+            24: { 'condition': self_name == '1к' },
+            25: { 'condition': self_name == '4к' },
+            26: { 'condition': self_name == '3к' },
+            27: { 'condition': self_name == '2к' },
+        }
+        signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping, fs_array_node))
+        unit_prd.connect('data_received', Callable(self, 'on_data_received'))
+
+
+    func setup_timer() -> void:
+        add_child(control_timer)
+        control_timer.timeout.connect(on_stop_control)
+        control_timer.one_shot = true
+        control_timer.wait_time = 10.0
+        control_timer.start()
+
+
+    func on_control_result() -> void:
+        print('on_control_result')
+    
+
+    func on_stop_control() -> void:
+        state = STATE_MASHINE.FS_TURN_OFF
+    
+    
+    func on_ug_setting() -> void:
+        var result_1 = ((constants.attenutor_um_1 & 0x07) << 3) | (constants.dou_ray_nuber & 0x07)
+        var result_2 = ((constants.attenutor_um_2 & 0x07) << 3) | (constants.dou_ray_nuber & 0x07)
+
+        module_prd.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [constants.ADDR_UG_LITERA_1, result_1,
+                                                                constants.ADDR_UG_LITERA_2, result_2,
+                                                                constants.ADDR_UG_LITERA_3, constants.attenutor_um_3]])
+
+        module_prd.cmd_array.append([unit_prd.CmdCode.READ_ISA, [constants.ADDR_UG_LITERA_1, constants.ADDR_UG_LITERA_2, constants.ADDR_UG_LITERA_3]])
+
+    
+    func power_um_control_result() -> void:
+        control_results['power_um'] = true
+        for amp in power_result[cur_ray]:
+            if amp > constants.TEMP_THRESHOLD:
+                control_results['power_um'] = false
+                break
+    
+    
+    static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, cur_fs: 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 fs_arr: Array = []
+
+        if cur_fs in fs_params:
+            var params = fs_params[cur_fs]
+            fs_arr.append([
+                angle,
+                params.freq,
+                params.width,
+                sectors[cur_fs - 1] if cur_fs == 1 else sectors[cur_fs - 5]
+            ])
+
+        signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um)
+    
+    ## Проверка касет П1 и ИП МА2000
+    static func check_block_ip(status_prd: PackedByteArray, block_ip_config: Dictionary) -> Dictionary:
+        # Конфигурация проверяемых блоков
+        var byte_dry: int = 27
+        var ug_online: bool = (status_prd[0] >> 1) & 1
+        for block in block_ip_config:
+            var bit: int = block_ip_config[block][0]
+            if ug_online:
+                var status = status_prd[byte_dry] >> bit & 1
+                block_ip_config[block][1] = false if status else true
+        return block_ip_config
+    
+        ## Проверка температур УМ от УКП
+    static func check_temperature_um(status_prd: PackedByteArray, power_amplifier: Array) -> void:
+        const Constants: Dictionary = {
+                'CONST_MIN_TEMP': -25,
+                'MAXIMUM_CODE_ADC': 3796,
+                'MINIMUM_CODE_AD': 2660,
+                'TEMPERATURE_UKP_1': 47,
+                'TEMPERATURE_UKP_2': 79,
+        }
+        const TEMP: float = 115.0 / (Constants.MAXIMUM_CODE_ADC - Constants.MINIMUM_CODE_AD)
+        var ukp1_online: int = (status_prd[0] >> 2) & 1
+        if ukp1_online:
+            var tmp_1: int
+            var temperature_ukp_1: int
+            for i_temp in 6:
+                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)
+                power_amplifier[i_temp].value0 = tmp_1
+            # Темпуратура от УМ литеры 1
+            temperature_ukp_1 = status_prd.decode_u16(Constants.TEMPERATURE_UKP_1 + 2 * 7)
+            tmp_1 = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_1) * TEMP + 3)
+            power_amplifier[6].value0 = tmp_1
+
+        var ukp2_online = (status_prd[0] >> 3) & 1
+        if ukp2_online:
+            for i_temp in 6:
+                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)
+                power_amplifier[i_temp+7].value0 = tmp_2
+    
+    
+    ## Проверка ДКМ
+    static func check_dkm(status_prd: PackedByteArray, bit_dkm: int, dkm_result: Dictionary) -> Dictionary:
+        var dkm: int = 28
+        var status_dkm = status_prd[dkm] >> bit_dkm & 1
+        if bit_dkm == 0:
+            dkm_result['dkm_1'] = status_dkm
+        elif bit_dkm == 5:
+            dkm_result['dkm_6'] = status_dkm
+        elif bit_dkm == 6:
+            dkm_result['dkm_7'] = status_dkm
+        return dkm_result
+
+
+    static func on_fs_state(packet_type_7: Dictionary, fs_mapping: Dictionary, fs_results: Dictionary) -> Dictionary:
+        for fs in packet_type_7:
+            if fs in fs_mapping and fs_mapping[fs]['condition']:
+                var data = packet_type_7[fs]
+                if fs < 4 and fs_results.has('fs_1'):
+                    fs_results['fs_1'] = data.isg
+                elif fs < 24 and fs_results.has('fs_6'):
+                    fs_results['fs_6'] = data.isg
+                elif fs > 23 and fs_results.has('fs_7'):
+                    fs_results['fs_7'] = data.isg
+        return fs_results
+
+
+    static func power_um_ukp(status: PackedByteArray, crnt_fs: int, pwr_result: Array) -> Array:
+        const Constants: Dictionary = {'POWER_UKP_1' : 31, 'POWER_UKP_2': 63, 'TEMP_THRESHOLD': 40}
+        var power_values: Array = []
+        var base_offset = 0
+        var is_data_valid = false
+        var iteration: int = 6
+
+        match crnt_fs:
+            1:
+                # Обработка для current_fs = 1 (одно значение)
+                var value = status.decode_u16(Constants.POWER_UKP_1 + 2 * 7)
+                power_values = [value]
+                is_data_valid = true
+
+            6:
+                # Обработка для current_fs = 6 (6 значений из УКП1)
+                base_offset = Constants.POWER_UKP_1
+                is_data_valid = (status[0] >> 2) & 1
+                if is_data_valid:
+                    for i in iteration:
+                        power_values.append(status.decode_u16(base_offset + 2 * i))
+
+            7:
+                # Обработка для current_fs = 7 (6 значений из УКП2)
+                base_offset = Constants.POWER_UKP_2
+                is_data_valid = (status[0] >> 2) & 1
+                if is_data_valid:
+                    for i in iteration:
+                        power_values.append(status.decode_u16(base_offset + 2 * i))
+
+        power_values = update_max_power_values(power_values, pwr_result)
+
+        return power_values
+
+
+    ## Обновление максимальных значений
+    static func update_max_power_values(power_data: Array, max_power_values: Array) -> Array:
+        if power_data.size() != 6:
+            if max_power_values.is_empty():
+                max_power_values = power_data.duplicate()
+            elif power_data[0] > max_power_values[0]:
+                max_power_values = power_data.duplicate()
+            return max_power_values
+
+        if max_power_values.is_empty():
+            max_power_values = power_data.duplicate()
+        else:
+            for i in 6:
+                if power_data[i] > max_power_values[i]:
+                    max_power_values[i] = power_data[i]
+
+        return max_power_values.duplicate()