maxim/PRD_TU_MP550
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

module fs 4

Browse Source
This commit is contained in:
Maxim
2025-02-07 04:14:27 +03:00
parent 2f93972202
commit c342115adf
5 changed files with 1150 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1003
PRD57EF.tmp Normal file
View File

File diff suppressed because it is too large Load Diff

91
scripts/FS.gd
View File

@@ -66,6 +66,7 @@ class FGOS:
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D] 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D]
const INDEX_SIZE: int = 0xC const INDEX_SIZE: int = 0xC
const GROUP_OFFSET: int = 0x0 const GROUP_OFFSET: int = 0x0
const CMD_OFFSET: int = 0x1 const CMD_OFFSET: int = 0x1
@@ -76,7 +77,6 @@ class FGOS:
signal line_changed(unit: FGOS) ## Вызывается когда меняется состояние связи с ячейкой signal line_changed(unit: FGOS) ## Вызывается когда меняется состояние связи с ячейкой
var counter: int = 0
var online: bool = false ## Состояние связи с ячейкой var online: bool = false ## Состояние связи с ячейкой
var status: = PackedByteArray() ## Поле "состояние прибора" var status: = PackedByteArray() ## Поле "состояние прибора"
#var fgos_data = {} ## Результат выполнения команды "читать порт" #var fgos_data = {} ## Результат выполнения команды "читать порт"
@@ -92,7 +92,7 @@ class FGOS:
return final_crc 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() var packet = PackedByteArray()
packet.resize(index_size) packet.resize(index_size)
packet.encode_u8(GROUP_OFFSET, group) packet.encode_u8(GROUP_OFFSET, group)
@@ -108,79 +108,80 @@ class FGOS:
var crc = crc32(packet) var crc = crc32(packet)
packet.resize(packet.size() + 4) packet.resize(packet.size() + 4)
packet.encode_u32(packet.size() - 4, crc) packet.encode_u32(packet.size() - 4, crc)
#Network.command_stack.append(packet) Network.command_stack.append(packet)
Network.command_stack_2.append(packet)
func send_fs_data(data_to_sand: PackedByteArray, client_fs: StreamPeer, peerstream_fs: PacketPeer):
func _parse(rx_data: PackedByteArray): if client_fs.get_status() == 2:
var peer = peerstream_fs.get_stream_peer()
if not online: if peer:
online = true peer.put_data(data_to_sand)
emit_signal('line_changed', self) else:
print_debug('client_fs.get_status != 2 !!!')
var status_len = rx_data.decode_u16(6) # Длина массива байтового "состояние прибора"
#func _parse(rx_data: PackedByteArray):
var i: = 0 #if not online:
var len_rx_data: = rx_data.size() #online = true
status.resize(status_len) #emit_signal('line_changed', self)
while i < status_len: #
var byte_i = i + 8 #var status_len = rx_data.decode_u16(6) # Длина массива байтового "состояние прибора"
if byte_i < len_rx_data: #
status[i] = rx_data[byte_i] # Массив байтовый "состояние прибора" #var i: = 0
i += 1 #var len_rx_data: = rx_data.size()
emit_signal('data_received', self) #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(): func start_session(counter: int):
counter = 0 var packet = _form_packet(GROUP.BASE, CmdCode.START_SESSION, INDEX_SIZE, counter)
var packet = _form_packet(GROUP.BASE, CmdCode.START_SESSION, 0xC)
_send_packet(packet) _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 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_u16(0x8, 0x0010)
packet.encode_u32(0xC, button_state) ## MODE GEN STATUS packet.encode_u32(0xC, button_state) ## MODE GEN STATUS
_send_packet(packet) _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 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_u16(0x8, 0x10)
packet.encode_u64(0xC, installation_frequency) ## uint64_t freq low dword/high dword packet.encode_u64(0xC, installation_frequency) ## uint64_t freq low dword/high dword
_send_packet(packet) _send_packet(packet)
func set_att_batch(attenuation: float): func set_att_batch(attenuation: float, counter: int):
var index_size = 0x1C 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_u16(0x8, 0x10)
packet.encode_float(0x18, attenuation) packet.encode_float(0x18, attenuation)
_send_packet(packet) _send_packet(packet)
func get_carrier(): func get_carrier(counter: int):
var packet = _form_packet(GROUP.BASE, CmdCode.READ_CARRIER, INDEX_SIZE) var packet = _form_packet(GROUP.BASE, CmdCode.READ_CARRIER, INDEX_SIZE, counter)
_send_packet(packet) _send_packet(packet)
func get_att_batch(): func get_att_batch(counter: int):
var packet = _form_packet(GROUP.RF, CmdCode.READ_ATT, INDEX_SIZE) var packet = _form_packet(GROUP.RF, CmdCode.READ_ATT, INDEX_SIZE, counter)
_send_packet(packet) _send_packet(packet)
func get_gen_state(): func get_gen_state(counter: int):
var packet = _form_packet(GROUP.GENERATOR, CmdCode.READ_GEN_STATUS, INDEX_SIZE) var packet = _form_packet(GROUP.GENERATOR, CmdCode.READ_GEN_STATUS, INDEX_SIZE, counter)
_send_packet(packet) _send_packet(packet)
func base_get_current_temp(): func base_get_current_temp(counter: int):
var packet = _form_packet(GROUP.BASE, CmdCode.BASE_GET_CURRENT_TEMP, INDEX_SIZE) var packet = _form_packet(GROUP.BASE, CmdCode.BASE_GET_CURRENT_TEMP, INDEX_SIZE, counter)
_send_packet(packet) _send_packet(packet)

4
scripts/PRD.gd
View File

@@ -420,8 +420,8 @@ func on_btn_select(intem_from_sector: int) -> void:
Network.on_command_change_device(meta) Network.on_command_change_device(meta)
flag_mode = meta[2] flag_mode = meta[2]
draw_control_panel_prd(flag_mode) draw_control_panel_prd(flag_mode)
#_on_start_fs_1() _on_start_fs_1()
_on_start_fs_2() #_on_start_fs_2()
func _on_zapret1(toggled_on: bool) -> void: func _on_zapret1(toggled_on: bool) -> void:

16
scripts/modul_fs.gd
View File

@@ -58,29 +58,29 @@ func _on_data_send():
func _on_send_pressed() -> void: func _on_send_pressed() -> void:
unit_fs.get_carrier() unit_fs.get_carrier(counter)
func _on_get_att() -> void: func _on_get_att() -> void:
unit_fs.get_att_batch() unit_fs.get_att_batch(counter)
func _on_start(): func _on_start():
unit_fs.start_session() unit_fs.start_session(counter)
unit_fs.base_get_current_temp() unit_fs.base_get_current_temp(counter)
func _on_get_status(toggled_btn): func _on_get_status(toggled_btn):
var inverted_state = not toggled_btn var inverted_state = not toggled_btn
unit_fs.set_gen_state(inverted_state) unit_fs.set_gen_state(inverted_state, counter)
unit_fs.get_gen_state() unit_fs.get_gen_state(counter)
func _on_set_ferq(): func _on_set_ferq():
var freq = int($set_space/write_to_set_freq.get_text()) * 1_000_000 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(): func _on_set_att():
var att = float($set_space/write_to_set_att.get_text()) var att = float($set_space/write_to_set_att.get_text())
unit_fs.set_att_batch(att) unit_fs.set_att_batch(att, counter)

180
scripts/network.gd
View File

@@ -2,8 +2,8 @@ extends Node
# ЯУ-07 Блок # ЯУ-07 Блок
var unit = Yau07.YaU07.new('ЯУ-07Б') var unit = Yau07.YaU07.new('ЯУ-07Б')
#var unit_fs_1 = Fs.FGOS.new() var unit_fs_1 = Fs.FGOS.new()
var unit_fs_2 = Fs.FGOS.new() #var unit_fs_2 = Fs.FGOS.new()
var soc_unicast: Socket var soc_unicast: Socket
var soc_brodcast: Socket var soc_brodcast: Socket
var ip_address_yau: String = Constants.ADDRESSES[0][1] 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 peerstream_fs_1: PacketPeer
var state_fs = Constants.STATE.IDLE var state_fs = Constants.STATE.IDLE
var command_stack: Array var command_stack: Array
var counter_fs_1: int = 0
## 2 ФС ## 2 ФС
var client_fs_2: StreamPeer var client_fs_2: StreamPeer
@@ -28,6 +29,7 @@ var ip_fs_2: String = Constants.ADDRESSES[0][5]
var peerstream_fs_2: PacketPeer var peerstream_fs_2: PacketPeer
var state_fs_2 = Constants.STATE.IDLE var state_fs_2 = Constants.STATE.IDLE
var command_stack_2: Array var command_stack_2: Array
var counter_fs_2: int = 0
# Яу-07б # Яу-07б
signal yau_status_line(_status) ## Вызывается когда меняется состояние связи с ячейкой 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: if peer.get_available_bytes() > 0:
var rx_data: PackedByteArray var rx_data: PackedByteArray
rx_data.append_array(peer.get_data(peer.get_available_bytes())[1]) rx_data.append_array(peer.get_data(peer.get_available_bytes())[1])
emit_signal("data_from_fs_1", rx_data) if client == client_fs_1:
#emit_signal("data_from_fs_2", rx_data) emit_signal("data_from_fs_1", rx_data)
emit_signal("port_fs_opened_1", ip_fs) emit_signal("port_fs_opened_1", ip_fs)
if state_fs == Constants.STATE.SEND: if state_fs == Constants.STATE.SEND:
state_fs = Constants.STATE.DONE 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: func _ready() -> void:
@@ -103,7 +110,7 @@ func _ready() -> void:
unit.connect('line_changed', Callable(self, 'on_line_changed')) unit.connect('line_changed', Callable(self, 'on_line_changed'))
unit.connect('command_fail', Callable(self, 'on_command_fail')) unit.connect('command_fail', Callable(self, 'on_command_fail'))
#connect_fs_1() connect_fs_1()
connect_fs_2() connect_fs_2()
read_port_isa([0x106, 0x108]) read_port_isa([0x106, 0x108])
@@ -115,16 +122,16 @@ func _process(delta: float) -> void:
if client_fs_1: if client_fs_1:
poll_receive_fs(client_fs_1, peerstream_fs_1, ip_fs_1) poll_receive_fs(client_fs_1, peerstream_fs_1, ip_fs_1)
state_machine_fs()
if client_fs_2: 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_brodcast)
poll_receive_yau07(soc_unicast) poll_receive_yau07(soc_unicast)
state_machine_yau07() state_machine_yau07()
#state_machine_fs()
state_machine_fs_2()
match unit.process(delta): 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.OK: soc_unicast.send_to(ip_address_yau, ip_port_yau, unit.tx_data.slice(0, unit.tx_len))
Error.FAILED: print_debug('Ошибка отправки данных') Error.FAILED: print_debug('Ошибка отправки данных')
@@ -182,18 +189,24 @@ func on_command_change_device(meta_device):
ip_fs_1 = meta_device[3] ip_fs_1 = meta_device[3]
ip_fs_2 = meta_device[4] ip_fs_2 = meta_device[4]
#ip_fs_3 = meta_device[5] #ip_fs_3 = meta_device[5]
#connect_fs_1() connect_fs_1()
connect_fs_2() #connect_fs_2()
func state_machine_fs(): func state_machine_fs():
## State fs machine
if client_fs_1: if client_fs_1:
## State fs machine
if (state_fs == Constants.STATE.IDLE) or (state_fs == Constants.STATE.DONE): if (state_fs == Constants.STATE.IDLE) or (state_fs == Constants.STATE.DONE):
if command_stack: if command_stack:
var pack: Array = command_stack.pop_front() 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 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) 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): func disconnect_fs(client_for_leave):
client_for_leave.disconnect_from_host() client_for_leave.disconnect_from_host()
state_fs = Constants.STATE.IDLE state_fs = Constants.STATE.IDLE
command_stack = [] command_stack = []
#
#func start_work_fs(): func start_work_fs():
#unit_fs_1.start_session() counter_fs_1 = 0
#unit_fs_1.base_get_current_temp() unit_fs_1.start_session(counter_fs_1)
# counter_fs_1 += 1
# unit_fs_1.get_gen_state(counter_fs_1)
#func get_fs_gen_status(state_gen): counter_fs_1 += 1
#unit_fs_1.set_gen_state(state_gen) unit_fs_1.get_att_batch(counter_fs_1)
#unit_fs_1.get_gen_state() counter_fs_1 += 1
#unit_fs_1.base_get_current_temp() unit_fs_1.get_carrier(counter_fs_1)
# counter_fs_1 += 1
# unit_fs_1.base_get_current_temp(counter_fs_1)
#func set_fs_ferq_carrier(freq: int): counter_fs_1 += 1
#unit_fs_1.set_carrier(freq)
#unit_fs_1.base_get_current_temp()
#unit_fs_1.get_carrier() func get_fs_gen_status(state_gen):
# unit_fs_1.set_gen_state(state_gen, counter_fs_1)
# counter_fs_1 += 1
#func set_fs_attenuation(attenuation: float): unit_fs_1.get_gen_state(counter_fs_1)
#unit_fs_1.set_att_batch(attenuation) counter_fs_1 += 1
#unit_fs_1.get_att_batch() unit_fs_1.base_get_current_temp(counter_fs_1)
#unit_fs_1.base_get_current_temp() 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 ФС коннект ## 2 ФС коннект
@@ -289,45 +311,25 @@ func state_machine_fs_2():
state_fs_2 = Constants.STATE.SEND state_fs_2 = Constants.STATE.SEND
func poll_receive_fs_2(client: StreamPeerTCP, peerstream: PacketPeer, ip_fs: String): #
client.poll() #func start_work_fs_2():
var peer = peerstream.get_stream_peer() #unit_fs_2.start_session()
# Проверяем, существует ли соединение #unit_fs_2.base_get_current_temp()
if not peer: #
emit_signal("port_error", ip_fs) #
return #func get_fs_gen_status_2(state_gen):
# Проверяем состояние подключения #unit_fs_2.set_gen_state(state_gen)
if client.get_status() != StreamPeerTCP.STATUS_CONNECTED: #unit_fs_2.get_gen_state()
emit_signal("port_closed", ip_fs) #unit_fs_2.base_get_current_temp()
return #
#
if peer.get_available_bytes() > 0: #func set_fs_ferq_carrier_2(freq: int):
var rx_data: PackedByteArray #unit_fs_2.set_carrier(freq)
rx_data.append_array(peer.get_data(peer.get_available_bytes())[1]) #unit_fs_2.base_get_current_temp()
emit_signal("data_from_fs_2", rx_data) #unit_fs_2.get_carrier()
emit_signal("port_fs_opened_2", ip_fs) #
if state_fs_2 == Constants.STATE.SEND: #
state_fs_2 = Constants.STATE.DONE #func set_fs_attenuation_2(attenuation: float):
#unit_fs_2.set_att_batch(attenuation)
#unit_fs_2.get_att_batch()
func start_work_fs_2(): #unit_fs_2.base_get_current_temp()
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()