module fs 4

2025-02-07 04:14:27 +03:00
parent 2f93972202
commit c342115adf
5 changed files with 1150 additions and 144 deletions
--- a/PRD57EF.tmp
+++ b/PRD57EF.tmp
--- a/scripts/FS.gd
+++ b/scripts/FS.gd
@@ -66,6 +66,7 @@ class FGOS:
        0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
        0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
        0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D]
+        
    const INDEX_SIZE: int = 0xC
    const GROUP_OFFSET: int = 0x0
    const CMD_OFFSET: int = 0x1
@@ -76,7 +77,6 @@ class FGOS:
    
    signal line_changed(unit: FGOS)  ## Вызывается когда меняется состояние связи с ячейкой
    
-    var counter: int = 0
    var online: bool = false                ## Состояние связи с ячейкой
    var status: = PackedByteArray()         ## Поле "состояние прибора"
    #var fgos_data   = {}                   ## Результат выполнения команды "читать порт"
@@ -92,7 +92,7 @@ class FGOS:
        return final_crc
    
    
-    func _form_packet(group: int, cmd: int, index_size: int, data = null):
+    func _form_packet(group: int, cmd: int, index_size: int, counter: int, data = null):
        var packet = PackedByteArray()
        packet.resize(index_size)
        packet.encode_u8(GROUP_OFFSET, group)
@@ -108,79 +108,80 @@ class FGOS:
        var crc = crc32(packet)
        packet.resize(packet.size() + 4)
        packet.encode_u32(packet.size() - 4, crc)
-        #Network.command_stack.append(packet)
-        Network.command_stack_2.append(packet)
-
-
-    func _parse(rx_data: PackedByteArray):
-        
-        if not online:
-            online = true
-            emit_signal('line_changed', self)
-        
-        
-        var status_len = rx_data.decode_u16(6)   # Длина массива байтового "состояние прибора"
-
-        var i: = 0
-        var len_rx_data: = rx_data.size()
-        status.resize(status_len)
-        while i < status_len:
-            var byte_i = i + 8
-            if byte_i < len_rx_data:
-                status[i] = rx_data[byte_i]                 # Массив байтовый "состояние прибора"
-            i += 1
-        emit_signal('data_received', self)
+        Network.command_stack.append(packet)
+    
+    
+    func send_fs_data(data_to_sand: PackedByteArray, client_fs: StreamPeer, peerstream_fs: PacketPeer):
+        if client_fs.get_status() == 2:
+            var peer = peerstream_fs.get_stream_peer()
+            if peer:
+                peer.put_data(data_to_sand)
+        else:
+            print_debug('client_fs.get_status != 2 !!!')
+    
+    
+    #func _parse(rx_data: PackedByteArray):
+        #if not online:
+            #online = true
+            #emit_signal('line_changed', self)
+        #
+        #var status_len = rx_data.decode_u16(6)   # Длина массива байтового "состояние прибора"
+#
+        #var i: = 0
+        #var len_rx_data: = rx_data.size()
+        #status.resize(status_len)
+        #while i < status_len:
+            #var byte_i = i + 8
+            #if byte_i < len_rx_data:
+                #status[i] = rx_data[byte_i]  # Массив байтовый "состояние прибора"
+            #i += 1
+        #emit_signal('data_received', self)
        

-    func start_session():
-        counter = 0
-        var packet = _form_packet(GROUP.BASE, CmdCode.START_SESSION, 0xC)
+    func start_session(counter: int):
+        var packet = _form_packet(GROUP.BASE, CmdCode.START_SESSION, INDEX_SIZE, counter)
        _send_packet(packet)
-        get_gen_state()
-        get_att_batch()
-        get_carrier()


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


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


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


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


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

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


-    func base_get_current_temp():
-        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_GET_CURRENT_TEMP, INDEX_SIZE)
+    func base_get_current_temp(counter: int):
+        var packet = _form_packet(GROUP.BASE, CmdCode.BASE_GET_CURRENT_TEMP, INDEX_SIZE, counter)
        _send_packet(packet)
--- a/scripts/PRD.gd
+++ b/scripts/PRD.gd
@@ -420,8 +420,8 @@ func on_btn_select(intem_from_sector: int) -> void:
    Network.on_command_change_device(meta)
    flag_mode = meta[2]
    draw_control_panel_prd(flag_mode)
-    #_on_start_fs_1()
-    _on_start_fs_2()
+    _on_start_fs_1()
+    #_on_start_fs_2()


 func _on_zapret1(toggled_on: bool) -> void:
--- a/scripts/modul_fs.gd
+++ b/scripts/modul_fs.gd
@@ -58,29 +58,29 @@ func _on_data_send():


 func _on_send_pressed() -> void:
-    unit_fs.get_carrier()
+    unit_fs.get_carrier(counter)


 func _on_get_att() -> void:
-    unit_fs.get_att_batch()
+    unit_fs.get_att_batch(counter)


 func _on_start():
-    unit_fs.start_session()
-    unit_fs.base_get_current_temp()
+    unit_fs.start_session(counter)
+    unit_fs.base_get_current_temp(counter)


 func _on_get_status(toggled_btn):
    var inverted_state = not toggled_btn
-    unit_fs.set_gen_state(inverted_state)
-    unit_fs.get_gen_state()
+    unit_fs.set_gen_state(inverted_state, counter)
+    unit_fs.get_gen_state(counter)


 func _on_set_ferq():
    var freq = int($set_space/write_to_set_freq.get_text()) * 1_000_000
-    unit_fs.set_carrier(freq)
+    unit_fs.set_carrier(freq, counter)


 func _on_set_att():
    var att = float($set_space/write_to_set_att.get_text())
-    unit_fs.set_att_batch(att)
+    unit_fs.set_att_batch(att, counter)
--- a/scripts/network.gd
+++ b/scripts/network.gd
@@ -2,8 +2,8 @@ extends Node

 # ЯУ-07 Блок
 var unit = Yau07.YaU07.new('ЯУ-07Б')
-#var unit_fs_1 = Fs.FGOS.new()
-var unit_fs_2 = Fs.FGOS.new()
+var unit_fs_1 = Fs.FGOS.new()
+#var unit_fs_2 = Fs.FGOS.new()
 var soc_unicast: Socket
 var soc_brodcast: Socket
 var ip_address_yau: String = Constants.ADDRESSES[0][1]
@@ -21,6 +21,7 @@ var ip_fs_1: String = Constants.ADDRESSES[0][4]
 var peerstream_fs_1: PacketPeer
 var state_fs = Constants.STATE.IDLE
 var command_stack: Array
+var counter_fs_1: int = 0

 ## 2 ФС
 var client_fs_2: StreamPeer
@@ -28,6 +29,7 @@ var ip_fs_2: String = Constants.ADDRESSES[0][5]
 var peerstream_fs_2: PacketPeer
 var state_fs_2 = Constants.STATE.IDLE
 var command_stack_2: Array
+var counter_fs_2: int = 0

 # Яу-07б
 signal yau_status_line(_status)  ## Вызывается когда меняется состояние связи с ячейкой
@@ -82,11 +84,16 @@ func poll_receive_fs(client: StreamPeerTCP, peerstream: PacketPeer, ip_fs: Strin
    if peer.get_available_bytes() > 0:
        var rx_data: PackedByteArray
        rx_data.append_array(peer.get_data(peer.get_available_bytes())[1])
-        emit_signal("data_from_fs_1", rx_data)
-        #emit_signal("data_from_fs_2", rx_data)
-        emit_signal("port_fs_opened_1", ip_fs)
-        if state_fs == Constants.STATE.SEND:
-            state_fs = Constants.STATE.DONE
+        if client == client_fs_1:
+            emit_signal("data_from_fs_1", rx_data)
+            emit_signal("port_fs_opened_1", ip_fs)
+            if state_fs == Constants.STATE.SEND:
+                state_fs = Constants.STATE.DONE
+        elif client == client_fs_2:
+            emit_signal("data_from_fs_2", rx_data)
+            emit_signal("port_fs_opened_2", ip_fs)
+            if state_fs_2 == Constants.STATE.SEND:
+                state_fs_2 = Constants.STATE.DONE


 func _ready() -> void:
@@ -103,7 +110,7 @@ func _ready() -> void:

    unit.connect('line_changed', Callable(self, 'on_line_changed'))
    unit.connect('command_fail', Callable(self, 'on_command_fail'))
-    #connect_fs_1()
+    connect_fs_1()
    connect_fs_2()
    read_port_isa([0x106, 0x108])

@@ -115,16 +122,16 @@ func _process(delta: float) -> void:
    
    if client_fs_1:
        poll_receive_fs(client_fs_1, peerstream_fs_1, ip_fs_1)
+        state_machine_fs()
    if client_fs_2:
-        poll_receive_fs_2(client_fs_2, peerstream_fs_2, ip_fs_2)
+        poll_receive_fs(client_fs_2, peerstream_fs_2, ip_fs_2)
+        state_machine_fs_2()
    
    poll_receive_yau07(soc_brodcast)
    poll_receive_yau07(soc_unicast)
    
    state_machine_yau07()
-    #state_machine_fs()
-    state_machine_fs_2()
-    
+
    match unit.process(delta):
        Error.OK: soc_unicast.send_to(ip_address_yau, ip_port_yau, unit.tx_data.slice(0, unit.tx_len))
        Error.FAILED: print_debug('Ошибка отправки данных')
@@ -182,18 +189,24 @@ func on_command_change_device(meta_device):
    ip_fs_1 = meta_device[3]
    ip_fs_2 = meta_device[4]
    #ip_fs_3 = meta_device[5]
-    #connect_fs_1()
-    connect_fs_2()
+    connect_fs_1()
+    #connect_fs_2()


 func state_machine_fs():
+    ## State fs machine
    if client_fs_1:
-        ## State fs machine
        if (state_fs == Constants.STATE.IDLE) or (state_fs == Constants.STATE.DONE):
            if command_stack:
                var pack: Array = command_stack.pop_front()
-                send_fs_data_1(pack)
+                unit_fs_1.send_fs_data(pack, client_fs_1, peerstream_fs_1)
                state_fs = Constants.STATE.SEND
+    if client_fs_2:
+        if (state_fs_2 == Constants.STATE.IDLE) or (state_fs_2 == Constants.STATE.DONE):
+            if command_stack_2:
+                var pack: Array = command_stack_2.pop_front()
+                unit_fs_1.send_fs_data(pack, client_fs_2, peerstream_fs_2)
+                state_fs_2 = Constants.STATE.SEND


 # Подключится к модулю ФС
@@ -210,43 +223,52 @@ func connect_fs_1():
        peerstream_fs_1.set_stream_peer(client_fs_1)


-# Отправить команду для ФС
-func send_fs_data_1(data_to_sand: PackedByteArray):
-    if client_fs_1.get_status() == 2:
-        var peer = peerstream_fs_1.get_stream_peer()
-        if peer:
-            peer.put_data(data_to_sand)
-            emit_signal("data_send") 
-
-
 # Разорвать соединение с ФС
 func disconnect_fs(client_for_leave):
    client_for_leave.disconnect_from_host()
    state_fs = Constants.STATE.IDLE
    command_stack = []

-#
-#func start_work_fs():
-    #unit_fs_1.start_session()
-    #unit_fs_1.base_get_current_temp()
-#
-#
-#func get_fs_gen_status(state_gen):
-    #unit_fs_1.set_gen_state(state_gen)
-    #unit_fs_1.get_gen_state()
-    #unit_fs_1.base_get_current_temp()
-#
-#
-#func set_fs_ferq_carrier(freq: int):
-    #unit_fs_1.set_carrier(freq)
-    #unit_fs_1.base_get_current_temp()
-    #unit_fs_1.get_carrier()
-#
-#
-#func set_fs_attenuation(attenuation: float):
-    #unit_fs_1.set_att_batch(attenuation)
-    #unit_fs_1.get_att_batch()
-    #unit_fs_1.base_get_current_temp()
+
+func start_work_fs():
+    counter_fs_1 = 0
+    unit_fs_1.start_session(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.get_gen_state(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.get_att_batch(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.get_carrier(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.base_get_current_temp(counter_fs_1)
+    counter_fs_1 += 1
+
+
+func get_fs_gen_status(state_gen):
+    unit_fs_1.set_gen_state(state_gen, counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.get_gen_state(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.base_get_current_temp(counter_fs_1)
+    counter_fs_1 += 1
+
+
+func set_fs_ferq_carrier(freq: int):
+    unit_fs_1.set_carrier(freq, counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.base_get_current_temp(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.get_carrier(counter_fs_1)
+    counter_fs_1 += 1
+
+
+func set_fs_attenuation(attenuation: float):
+    unit_fs_1.set_att_batch(attenuation, counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.get_att_batch(counter_fs_1)
+    counter_fs_1 += 1
+    unit_fs_1.base_get_current_temp(counter_fs_1)
+    counter_fs_1 += 1


 ## 2 ФС коннект
@@ -289,45 +311,25 @@ func state_machine_fs_2():
                state_fs_2 = Constants.STATE.SEND


-func poll_receive_fs_2(client: StreamPeerTCP, peerstream: PacketPeer, ip_fs: String):
-    client.poll()
-    var peer = peerstream.get_stream_peer()
-    # Проверяем, существует ли соединение
-    if not peer:
-        emit_signal("port_error", ip_fs)
-        return
-    # Проверяем состояние подключения
-    if client.get_status() != StreamPeerTCP.STATUS_CONNECTED:
-        emit_signal("port_closed", ip_fs)
-        return
-    
-    if peer.get_available_bytes() > 0:
-        var rx_data: PackedByteArray
-        rx_data.append_array(peer.get_data(peer.get_available_bytes())[1])
-        emit_signal("data_from_fs_2", rx_data)
-        emit_signal("port_fs_opened_2", ip_fs)
-        if state_fs_2 == Constants.STATE.SEND:
-            state_fs_2 = Constants.STATE.DONE
-
-
-func start_work_fs_2():
-    unit_fs_2.start_session()
-    unit_fs_2.base_get_current_temp()
-
-
-func get_fs_gen_status_2(state_gen):
-    unit_fs_2.set_gen_state(state_gen)
-    unit_fs_2.get_gen_state()
-    unit_fs_2.base_get_current_temp()
-
-
-func set_fs_ferq_carrier_2(freq: int):
-    unit_fs_2.set_carrier(freq)
-    unit_fs_2.base_get_current_temp()
-    unit_fs_2.get_carrier()
-
-
-func set_fs_attenuation_2(attenuation: float):
-    unit_fs_2.set_att_batch(attenuation)
-    unit_fs_2.get_att_batch()
-    unit_fs_2.base_get_current_temp()
+#
+#func start_work_fs_2():
+    #unit_fs_2.start_session()
+    #unit_fs_2.base_get_current_temp()
+#
+#
+#func get_fs_gen_status_2(state_gen):
+    #unit_fs_2.set_gen_state(state_gen)
+    #unit_fs_2.get_gen_state()
+    #unit_fs_2.base_get_current_temp()
+#
+#
+#func set_fs_ferq_carrier_2(freq: int):
+    #unit_fs_2.set_carrier(freq)
+    #unit_fs_2.base_get_current_temp()
+    #unit_fs_2.get_carrier()
+#
+#
+#func set_fs_attenuation_2(attenuation: float):
+    #unit_fs_2.set_att_batch(attenuation)
+    #unit_fs_2.get_att_batch()
+    #unit_fs_2.base_get_current_temp()