extends Node # ЯУ-07 Блок var unit = Yau07.YaU07.new('ЯУ-07Б') var soc_unicast: Socket var soc_brodcast: Socket var ip_address_yau: String = Constants.ADDRESSES[0][1] var ip_port_yau: int = Constants.ADDRESSES[0][2] var timeout: float = Yau07.ONLINE_TIMEOUT var last_update_time_yau07: float = 0.0 var last_update_time_fs: float = 0.0 var broadcast_packet: PackedByteArray var state = Constants.STATE.WAIT var send_array: Array = [] # ФС Блок var ip_fs_1: String = Constants.ADDRESSES[0][4] var command_stack: Array var state_fs = Constants.STATE.IDLE var client_fs_1: StreamPeer var peerstream: PacketPeer signal yau_status_line(_status) ## Вызывается когда меняется состояние связи с ячейкой signal yau_receive(_data_from_yau) signal yau_read_isa(_unit_isa_ports) signal data_send() signal data_received(data:PackedByteArray) signal port_opened(port_name: String) signal port_closed(port_name: String) signal port_error(error_str: String) ## Класс для отправки данных в сокет class Socket extends PacketPeerUDP: func send_to(addr: String, port: int, data: PackedByteArray): self.set_dest_address(addr, port) self.put_packet(data) func poll_receive_yau07(sock: Socket) -> bool: ## Приёмник if timeout - last_update_time_yau07 > 0: while sock.get_available_packet_count() > 0: broadcast_packet = sock.get_packet() var addr_receive = sock.get_packet_ip() var port_receive = sock.get_packet_port() if (ip_address_yau == addr_receive) and (ip_port_yau == port_receive): last_update_time_yau07 = 0.0 unit.parse(broadcast_packet) var data_from_yau_07 = unit.status emit_signal('yau_receive', data_from_yau_07) else: if sock.get_available_packet_count(): last_update_time_yau07 = 0.0 return false func poll_receive_fs(client: StreamPeerTCP): client.poll() var peer = peerstream.get_stream_peer() # Проверяем, существует ли соединение if not peer: emit_signal("port_error", ip_fs_1) return # Проверяем состояние подключения if client.get_status() != StreamPeerTCP.STATUS_CONNECTED: emit_signal("port_closed", ip_fs_1) 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_received", rx_data) emit_signal("port_opened", ip_fs_1) if state_fs == Constants.STATE.SEND: state_fs = Constants.STATE.DONE func _ready() -> void: # Привязка для принятия широковещательного канала soc_brodcast = Socket.new() var rc = soc_brodcast.bind(Constants.BROADCAST_PORT, '*') if rc != OK: print_debug('Ошибка: Неудачная привязка широковещательного адреса') soc_unicast = Socket.new() rc = soc_unicast.bind(Constants.UNICAST_PORT, Constants.UNICAST_ADDRESS) if rc != OK: print_debug('Ошибка: неудачная привязка адреса: ', ip_address_yau) unit.connect('line_changed', Callable(self, 'on_line_changed')) unit.connect('command_fail', Callable(self, 'on_command_fail')) connect_fs() read_port_isa([0x106, 0x108]) func _process(delta: float) -> void: last_update_time_yau07 += delta last_update_time_fs += delta if client_fs_1: poll_receive_fs(client_fs_1) poll_receive_yau07(soc_brodcast) poll_receive_yau07(soc_unicast) state_machine_yau07() state_machine_fs() 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('Ошибка отправки данных') func state_machine_yau07(): var fl_done = (unit.cmd_state == unit.CmdState.DONE or unit.cmd_state == unit.CmdState.FAIL) ## Режим ожидания match state: Constants.STATE.WAIT: if fl_done and send_array.size(): state = Constants.STATE.READ_ISA if send_array[0][0] == 'rd' else Constants.STATE.WRITE_ISA ## Режим чтения из ИСА Constants.STATE.READ_ISA: if fl_done: var ports_read = send_array.pop_front() unit.send_isa(unit.CmdCode.READ_ISA, ports_read[1]) state = Constants.STATE.DONE ## Режим записи в ИСА Constants.STATE.WRITE_ISA: if fl_done: var ports_write = send_array.pop_front() var key = ports_write[1].keys() unit.send_isa(unit.CmdCode.WRITE_ISA, [key[0], ports_write[1][key[0]]]) state = Constants.STATE.WAIT Constants.STATE.DONE: if fl_done: emit_signal('yau_read_isa', unit.isa_ports) state = Constants.STATE.WAIT # Записать команду в ИСА func read_port_isa(read_ports: Array) -> void: send_array.append(['rd', read_ports]) # Прочитать данные из порта от ИСА func write_port_isa(port_isa: int, data_isa: int) -> void: var write_data: Dictionary = {port_isa: data_isa} send_array.append(['wr', write_data]) func on_line_changed(_unit) -> void: emit_signal('yau_status_line', unit.online) ## Ессли отсутствует подключение к ячейке ЯУ-07 func on_command_fail(_unit) -> void: print_debug('Command send fail') func on_command_change_device(meta_device): ip_address_yau = meta_device[0] ip_port_yau = meta_device[1] ip_fs_1 = meta_device[3] #ip_fs_2 = meta_device[4] #ip_fs_3 = meta_device[5] connect_fs() func state_machine_fs(): 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_data(pack) state_fs = Constants.STATE.SEND # Подключится к модулю ФС func connect_fs(): if client_fs_1: disconnect_fs(client_fs_1) client_fs_1 = StreamPeerTCP.new() peerstream = PacketPeerStream.new() var rc = client_fs_1.connect_to_host(ip_fs_1, Constants.PORT_FS) if rc!= Error.OK: emit_signal("port_error", ip_fs_1) else: peerstream.set_stream_peer(client_fs_1) # Отправить команду для ФС func send_data(data_to_sand: PackedByteArray): if client_fs_1.get_status() == 2: var peer = peerstream.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 = []