дорабтока отслеживания счетчика команда фс

2025-07-10 17:35:00 +03:00
parent 19af5eafdd
commit 11dd78b904
4 changed files with 138 additions and 98 deletions
--- a/scripts/FS.gd
+++ b/scripts/FS.gd
@@ -93,6 +93,8 @@ class ClientFs extends Node:
    var command_stack: Array
    var status: = PackedByteArray()         ## Поле "состояние прибора"
    var counter: int = 0
+    var send_count: int = 0
+    var missed_packets: int = 0
    var online: bool = false                ## Состояние связи с ФС

    func _init(nm):
@@ -145,6 +147,7 @@ class ClientFs extends Node:
        _status = _stream.STATUS_NONE
        command_stack = []
        counter = 0
+        send_count = 0
        if _stream.connect_to_host(host, port) != OK:
            print_debug("Error connecting to host.")
            emit_signal("error_connect")
@@ -160,6 +163,16 @@ class ClientFs extends Node:
        return final_crc

    func _form_packet(group: int, cmd: int, index_size: int, data = null) -> PackedByteArray:
+        var previous_count = send_count
+        send_count = counter
+        print([self_name, previous_count, counter])
+        if previous_count != 0 && (counter - previous_count) != 1:
+            var skipped = counter - previous_count - 1
+            missed_packets += skipped
+            print_debug("ALARM: Пропущено %d пакетов (было: %d, стало: %d)" % [skipped, previous_count, counter])
+            print_debug("Группа: %d, Команда: %d" % [group, cmd])
+
+        # Формируем пакет
        var packet = PackedByteArray()
        packet.resize(index_size)
        packet.encode_u8(GROUP_OFFSET, group)
@@ -176,6 +189,7 @@ class ClientFs extends Node:
        packet.encode_u32(packet.size() - 4, crc)
        command_stack.append(packet)

+
    func send_fs_data() -> bool:
        if _status != _stream.STATUS_CONNECTED:
            print("Send_fs_data Error: Stream is not currently connected.")
@@ -196,13 +210,14 @@ class ClientFs extends Node:
    func start_session():
        command_stack = []
        counter = 0
-        var packet = _form_packet(GROUP.BASE, CmdCode.START_SESSION, INDEX_SIZE, counter)
+        send_count = 0
+        var packet = _form_packet(GROUP.BASE, CmdCode.START_SESSION, INDEX_SIZE)
        send_packet_to(packet)

 ## MSK модуляция
    func set_configure_state_msk_modul_1()  -> void:
        var index_size = 0x20
-        var packet = _form_packet(GROUP.GENERATOR, CmdCode.SET_CONFIGURE, index_size, counter)
+        var packet = _form_packet(GROUP.GENERATOR, CmdCode.SET_CONFIGURE, index_size)
        packet.encode_u8(0x3, 0x09)
        packet.encode_u16(0x8, 0x0014)
        send_packet_to(packet)
@@ -210,7 +225,7 @@ class ClientFs extends Node:
 ## Constant модуляция
    func set_configure_state_msk_const():
        var index_size = 0x20
-        var packet = _form_packet(GROUP.GENERATOR, CmdCode.SET_CONFIGURE, index_size, counter)
+        var packet = _form_packet(GROUP.GENERATOR, CmdCode.SET_CONFIGURE, index_size)
        packet.encode_u8(0x3, 0x09)
        packet.encode_u16(0x8, 0x0014)
        packet.encode_u8(0x1C, 0x0f)
@@ -218,35 +233,35 @@ class ClientFs extends Node:

    func set_gen_state(button_state: bool):
        var index_size = 0x1C
-        var packet = _form_packet(GROUP.GENERATOR, CmdCode.SET_GEN_STATUS, index_size, counter)
+        var packet = _form_packet(GROUP.GENERATOR, CmdCode.SET_GEN_STATUS, index_size)
        packet.encode_u16(0x8, 0x0010)
        packet.encode_u32(0xC, button_state) ## MODE GEN STATUS
        send_packet_to(packet)

    func status_can_macro_exec(button_state: bool):
        var index_size = 0x1C
-        var packet = _form_packet(GROUP.BASE, CmdCode.STATUS_CAN_MACRO, index_size, counter)
+        var packet = _form_packet(GROUP.BASE, CmdCode.STATUS_CAN_MACRO, index_size)
        packet.encode_u16(0x8, 0x0010)
        packet.encode_u32(0xC, button_state) ## mode can status
        send_packet_to(packet)

    func set_carrier(installation_frequency: int):
        var index_size = 0x1C
-        var packet = _form_packet(GROUP.BASE, CmdCode.SET_CARRIER, index_size, counter)
+        var packet = _form_packet(GROUP.BASE, CmdCode.SET_CARRIER, index_size)
        packet.encode_u16(0x8, 0x10)
        packet.encode_u64(0xC, installation_frequency)  ## uint64_t freq low dword/high dword
        send_packet_to(packet)

    func set_att_batch(attenuation: float):
        var index_size = 0x1C
-        var packet = _form_packet(GROUP.RF, CmdCode.SET_ATT, index_size, counter)
+        var packet = _form_packet(GROUP.RF, CmdCode.SET_ATT, index_size)
        packet.encode_u16(0x8, 0x10)
        packet.encode_float(0x18, attenuation)
        send_packet_to(packet)

    func set_base_can_macro(installation_can_frequency: int):
        var index_size = 0x34
-        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_CAN_MACRO_WRITE, index_size, counter)
+        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_CAN_MACRO_WRITE, index_size)
        packet.encode_u16(0x08, 0x28)
        packet.encode_u8(0x1C, 0x01)
        packet.encode_u8(0x1D, 0x42)
@@ -257,23 +272,23 @@ class ClientFs extends Node:
        send_packet_to(packet)

    func get_carrier():
-        var packet = _form_packet(GROUP.BASE, CmdCode.READ_CARRIER, INDEX_SIZE, counter)
+        var packet = _form_packet(GROUP.BASE, CmdCode.READ_CARRIER, INDEX_SIZE)
        send_packet_to(packet)

    func get_att_batch():
-        var packet = _form_packet(GROUP.RF, CmdCode.READ_ATT, INDEX_SIZE, counter)
+        var packet = _form_packet(GROUP.RF, CmdCode.READ_ATT, INDEX_SIZE)
        send_packet_to(packet)

    func get_gen_state():
-        var packet = _form_packet(GROUP.GENERATOR, CmdCode.READ_GEN_STATUS, INDEX_SIZE, counter)
+        var packet = _form_packet(GROUP.GENERATOR, CmdCode.READ_GEN_STATUS, INDEX_SIZE)
        send_packet_to(packet)

    func get_base_current_temp():
-        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_GET_CURRENT_TEMP, INDEX_SIZE, counter)
+        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_GET_CURRENT_TEMP, INDEX_SIZE)
        send_packet_to(packet)

    func get_base_can_macro():
-        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_CAN_MACRO_READ, INDEX_SIZE, counter)
+        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_CAN_MACRO_READ, INDEX_SIZE)
        send_packet_to(packet)

    # Разорвать соединение с ФС
--- a/scripts/PRD.gd
+++ b/scripts/PRD.gd
@@ -818,7 +818,7 @@ func set_bits(v, a, m):

 ## ФС Connect close
 func _on_port_changed(client_addr: String, unit_fs_client: Node, status) -> void:
-    var loging = 'Соединение ...' if status == Constants.STATE_VAL.NONE else 'Подключено!' if status == Constants.STATE_VAL.GOOD else 'Ошибка'
+    var loging = 'Соединение ...' if status == Constants.STATE_VAL.NONE else 'Подключено' if status == Constants.STATE_VAL.GOOD else 'Ошибка'
    var color = Color.AQUAMARINE if status == Constants.STATE_VAL.GOOD else Color.DARK_GRAY if status == Constants.STATE_VAL.NONE else Color.CRIMSON

    if unit_fs_client == Network.unit_fs_1:
--- a/scripts/control_panel.gd
+++ b/scripts/control_panel.gd
@@ -488,66 +488,68 @@ func _on_start_super_control():
        $soc_y5/yau_07b.state = Constants.STATE_VAL.ERROR
        logger.error("❌ ЯУ-07Б: Нет связи")

-    if flag_continue_control:
-        flag_fs_1_ready = false
-        flag_fs_2_ready = false
-        flag_fs_3_ready = false
-        var fs_freq: Array
-        if Network.unit_fs_1.online:
-            var fs_att_1: float
-            if Constants.CURRENT_MODE == Constants.MODE.PRD_H:
-                fs_freq.append(Constants.FS_FREQ.f2)
-                fs_att_1 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][0]
-            elif Constants.CURRENT_MODE == Constants.MODE.PRD_B:
-                fs_freq.append(Constants.FS_FREQ.f4)
-                fs_att_1 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][0]
-            elif Constants.CURRENT_MODE == Constants.MODE.PRD_K:
-                fs_freq.append(Constants.FS_FREQ.f6)
-                fs_att_1 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][0]
+    if not flag_continue_control:
+        return
+    # Сброс флагов готовности
+    flag_fs_1_ready = false
+    flag_fs_2_ready = false
+    flag_fs_3_ready = false

-                fs_freq.append(Constants.FS_FREQ.f1)
+    var selected_id = self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()
+    var device_key = Constants.ADDRESSES[selected_id][0]

-            logger.info('🛈 Настройка модуля ФС %s Гц, [%s] АТТ' % [str(fs_freq[0]), str(fs_att_1)])
-            fs_setup(Network.unit_fs_1, fs_freq[0], fs_att_1) # Гц
-        else:
-            logger.info('❌ Модуль ФС-1: нет связи')
-            _on_contol_err()
+    if not await _setup_fs_module(Network.unit_fs_1, Constants.CURRENT_MODE, device_key, 0):
+        return
+
+    if not await _setup_fs_module(Network.unit_fs_2, Constants.CURRENT_MODE, device_key, 1):
+        return
+
+    if Constants.CURRENT_MODE == Constants.MODE.PRD_K:
+        if not await _setup_fs_module(Network.unit_fs_3, Constants.CURRENT_MODE, device_key, 2, Constants.FS_FREQ.f1):
            return

-        if Network.unit_fs_2.online:
-            var fs_att_2: float
-            if Constants.CURRENT_MODE == Constants.MODE.PRD_H:
-                fs_freq.append(Constants.FS_FREQ.f3)
-                fs_att_2 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][1]
-            elif Constants.CURRENT_MODE == Constants.MODE.PRD_B:
-                fs_freq.append(Constants.FS_FREQ.f5)
-                fs_att_2 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][1]
-            elif Constants.CURRENT_MODE == Constants.MODE.PRD_K:
-                fs_freq.append(Constants.FS_FREQ.f7)
-                fs_att_2 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][1]
-            logger.info('🛈 Настройка модуля ФС %s Гц, [%s] АТТ' % [str(fs_freq[1]), str(fs_att_2)])
-            await get_tree().create_timer(1.0).timeout
-            fs_setup(Network.unit_fs_2, fs_freq[1], fs_att_2) # Гц
-        else:
-            logger.info('❌ Модуль ФС-2: нет связи')
-            _on_contol_err()
-            return
+    # Запуск таймера
+    timer.set_one_shot(true)
+    timer.set_wait_time(10)
+    timer.start()

-        if Constants.CURRENT_MODE == Constants.MODE.PRD_K:
-            if Network.unit_fs_3.online:
-                var fs_att_3: float
-                fs_att_3 = Constants.FS_ATT[Constants.ADDRESSES[self.get_parent().get_child(0).get_child(1).get_node2(1, 0).get_selected_id()][0]][2]
-                logger.info('🛈 Настройка модуля ФС %s Гц, [%s] АТТ' % [str(fs_freq[2]), str(fs_att_3)])
-                await get_tree().create_timer(1.0).timeout
-                fs_setup(Network.unit_fs_3, fs_freq[2], fs_att_3)
-            else:
-                logger.info('❌ Модуль ФС-3: нет связи')
-                _on_contol_err()
-                return

-        timer.set_one_shot(true)
-        timer.set_wait_time(10)
-        timer.start()
+func _setup_fs_module(unit, mode, device_key, att_index, custom_freq = null) -> bool:
+    if not unit.online:
+        logger.info('❌ Модуль %s: нет связи' % unit.name)
+        _on_contol_err()
+        return false
+
+    var freq: int
+    var att: float
+
+    match mode:
+        Constants.MODE.PRD_H:
+            freq = Constants.FS_FREQ.f2 if att_index == 0 else Constants.FS_FREQ.f3
+            att = Constants.FS_ATT[device_key][att_index]
+
+        Constants.MODE.PRD_B:
+            freq = Constants.FS_FREQ.f4 if att_index == 0 else Constants.FS_FREQ.f5
+            att = Constants.FS_ATT[device_key][att_index]
+
+        Constants.MODE.PRD_K:
+            freq = Constants.FS_FREQ.f6 if att_index == 0 else Constants.FS_FREQ.f7
+            att = Constants.FS_ATT[device_key][att_index]
+            if custom_freq != null:
+                freq = custom_freq
+
+    logger.info('🛈 Настройка модуля %s: %s Гц, [%s] АТТ' % [unit.name, str(freq), str(att)])
+
+    if att > 20:
+        logger.info('❌ Аттенюация выше 20 dB')
+        _on_contol_err()
+        return false
+
+    if att_index > 0:
+        await get_tree().create_timer(1.5).timeout
+
+    fs_setup(unit, freq, att)
+    return true


 func _status_cell(status):
@@ -749,8 +751,13 @@ func _on_timer_03():


 func _on_contol_err():
+    await get_tree().create_timer(1.0).timeout
    logger.warning('❌❌❌')
    flag_continue_control = false
+    command_fs_off(Network.unit_fs_1)
+    command_fs_off(Network.unit_fs_2)
+    if Constants.CURRENT_MODE == Constants.MODE.PRD_K:
+        command_fs_off(Network.unit_fs_3)
    _status_prd()


@@ -764,7 +771,7 @@ func _on_timer():
        if not flag_fs_2_ready:
            $Kasseta_FS/ref_A2.state = Constants.STATE_VAL.ERROR
            logger.warning('❌ Модуль ФС-2: нет связи')
-        if not flag_fs_3_ready:
+        if not flag_fs_3_ready and Constants.CURRENT_MODE == Constants.MODE.PRD_K:
            $Kasseta_FS/FS_PRD_K.state = Constants.STATE_VAL.ERROR
            logger.warning('❌ Модуль ФС-3: нет связи')
        if not flag_fs_1_ready or not flag_fs_2_ready:
@@ -780,7 +787,6 @@ func _on_timer():
                    $soc_y5/ug.state = Constants.STATE_VAL.ERROR
                    logger.warning('❌ Разьем УГ: нет связи')
            _on_contol_err()
-        _on_timer_03()


 func _status_prd():
--- a/scripts/network.gd
+++ b/scripts/network.gd
@@ -152,8 +152,7 @@ func _on_connect_change(unit_state_connect) -> void:
    print_debug("%s" % unit_state_connect)


-func on_command_change_device(meta_device):
-    print(meta_device)
+func on_command_change_device(meta_device: Array):
    send_array = []
    ip_address_yau = meta_device[0]
    ip_port_yau = meta_device[1]
@@ -166,39 +165,59 @@ func on_command_change_device(meta_device):
    unit_fs_2.connect_to_host(meta_device[4], Constants.PORT_FS)

    await get_tree().create_timer(0.1).timeout
-    setup_fs(unit_fs_1, meta_device[2])
-    setup_fs(unit_fs_2, meta_device[2])
+    setup_fs(unit_fs_1, meta_device)
+    setup_fs(unit_fs_2, meta_device)
    #ip_fs_3 = meta_device[5]


-func setup_fs(unit_fs: Node, mode_prd: int) -> void:
+func setup_fs(unit_fs: Node, meta_device: Array) -> void:
+    var mode_prd = meta_device[2]
+    var device: String
    var freq: int
    var att: float

-    if mode_prd == Constants.MODE.PRD_H:
-        freq = Constants.FS_FREQ.f2 if unit_fs == Network.unit_fs_1 else Constants.FS_FREQ.f3
-        att = Constants.FS_ATT['ПРД-Н1'][0] if unit_fs == Network.unit_fs_1 else Constants.FS_ATT['ПРД-Н1'][1]
+    match mode_prd:
+        Constants.MODE.PRD_H:
+            device = _find_device_address(meta_device[0], 0, 4)
+            freq = Constants.FS_FREQ.f2 if unit_fs == Network.unit_fs_1 else Constants.FS_FREQ.f3
+            att = _get_att_value(device, unit_fs == Network.unit_fs_1)
+        Constants.MODE.PRD_B:
+            device = _find_device_address(meta_device[0], 4, 8)
+            freq = Constants.FS_FREQ.f4 if unit_fs == Network.unit_fs_1 else Constants.FS_FREQ.f5
+            att = _get_att_value(device, unit_fs == Network.unit_fs_1)
+        Constants.MODE.PRD_K:
+            device = _find_device_address(meta_device[0], 8, 12)
+            freq = Constants.FS_FREQ.f6 if unit_fs == Network.unit_fs_1 else Constants.FS_FREQ.f7
+            att = _get_att_value(device, unit_fs == Network.unit_fs_1)

-    elif mode_prd == Constants.MODE.PRD_B:
-        freq = Constants.FS_FREQ.f4 if unit_fs == Network.unit_fs_1 else Constants.FS_FREQ.f5
-        att = Constants.FS_ATT['ПРД-В1'][0] if unit_fs == Network.unit_fs_1 else Constants.FS_ATT['ПРД-В1'][1]
+    if not unit_fs.online:
+        return

-    elif mode_prd == Constants.MODE.PRD_K:
-        freq = Constants.FS_FREQ.f6 if unit_fs == Network.unit_fs_1 else Constants.FS_FREQ.f7
-        att = Constants.FS_ATT['ПРД-К1'][0] if unit_fs == Network.unit_fs_1 else Constants.FS_ATT['ПРД-К1'][1]
-    #var freq = Constants.FS_FREQ.f1 if unit_fs = Network.unit_fs_1 else
+    await _setup_fs_device(unit_fs, freq, att)

-    if unit_fs.online:
-        unit_fs.set_gen_state(false)
-        await get_tree().create_timer(0.3).timeout
-        unit_fs.get_gen_state()
-        unit_fs.set_gen_state(true)
-        await get_tree().create_timer(0.3).timeout
-        unit_fs.set_carrier(freq * 1_000_000)
-        unit_fs.set_att_batch(att)

-        unit_fs.get_carrier()
-        unit_fs.get_att_batch()
-        unit_fs.get_base_current_temp()
-        unit_fs.get_base_can_macro()
-        unit_fs.get_gen_state()
+func _find_device_address(address: String, start_idx: int, end_idx: int) -> String:
+    for i_dev in range(start_idx, end_idx):
+        if address == Constants.ADDRESSES[i_dev][1]:
+            return Constants.ADDRESSES[i_dev][0]
+    return ""
+
+
+func _get_att_value(device: String, is_unit_fs1: bool) -> float:
+    return Constants.FS_ATT[device][0] if is_unit_fs1 else Constants.FS_ATT[device][1]
+
+
+# Асинхронная настройка модуля
+func _setup_fs_device(unit_fs: Node, freq: int, att: float) -> void:
+    unit_fs.set_gen_state(false)
+    await get_tree().create_timer(0.3).timeout
+    unit_fs.get_gen_state()
+    unit_fs.set_gen_state(true)
+    await get_tree().create_timer(0.3).timeout
+    unit_fs.set_carrier(freq * 1_000_000)
+    unit_fs.set_att_batch(att)
+    unit_fs.get_carrier()
+    unit_fs.get_att_batch()
+    unit_fs.get_base_current_temp()
+    unit_fs.get_base_can_macro()
+    unit_fs.get_gen_state()