From bf6c0463cc809b83a227e10fe24def5b3c80b120 Mon Sep 17 00:00:00 2001 From: Maxim Date: Tue, 12 Aug 2025 23:11:51 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=BA=D0=B0,=20=D0=BE=D1=82=D0=BB=D0=B0=D0=B4=D0=BA=D0=B0=20?= =?UTF-8?q?=D0=BE=D0=B1=D1=89=D0=B5=D0=B3=D0=BE=20=D1=84=D0=B0=D0=B9=D0=BB?= =?UTF-8?q?=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scenes/pribor-prd-k/pribor-prd-k.gd | 377 ++++++++----------------- scenes/pribor-prd-n/pribor-prd-n.gd | 2 +- scenes/pribor-prd-v/pribor-prd-v.gd | 1 + scenes/настройки/настройки.gd | 2 +- scripts/pribor-prd.gd | 415 +++++++++++++++++++++++----- 5 files changed, 463 insertions(+), 334 deletions(-) diff --git a/scenes/pribor-prd-k/pribor-prd-k.gd b/scenes/pribor-prd-k/pribor-prd-k.gd index 45f323a..67d3754 100644 --- a/scenes/pribor-prd-k/pribor-prd-k.gd +++ b/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) diff --git a/scenes/pribor-prd-n/pribor-prd-n.gd b/scenes/pribor-prd-n/pribor-prd-n.gd index 0aca3e9..7469577 100644 --- a/scenes/pribor-prd-n/pribor-prd-n.gd +++ b/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: diff --git a/scenes/pribor-prd-v/pribor-prd-v.gd b/scenes/pribor-prd-v/pribor-prd-v.gd index 8c159cb..954c6ca 100644 --- a/scenes/pribor-prd-v/pribor-prd-v.gd +++ b/scenes/pribor-prd-v/pribor-prd-v.gd @@ -1,3 +1,4 @@ +@tool extends 'res://scenes/контроль/прибор.gd' const Constants = { diff --git a/scenes/настройки/настройки.gd b/scenes/настройки/настройки.gd index 4e07d7e..29564b2 100644 --- a/scenes/настройки/настройки.gd +++ b/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) diff --git a/scripts/pribor-prd.gd b/scripts/pribor-prd.gd index 4b3be6f..cf96eb7 100644 --- a/scripts/pribor-prd.gd +++ b/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()