From 8f2a6b031bbaf1cc1eaa922a59ba4304b4530c85 Mon Sep 17 00:00:00 2001 From: TotMaxim Date: Sat, 22 Nov 2025 16:03:56 +0300 Subject: [PATCH] =?UTF-8?q?=D1=80=D0=B5=D1=84=D0=B0=D0=BA=D1=82=D0=BE?= =?UTF-8?q?=D1=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scripts/pribor-prd.gd | 905 +++++++++++++++++++++++------------------- 1 file changed, 498 insertions(+), 407 deletions(-) diff --git a/scripts/pribor-prd.gd b/scripts/pribor-prd.gd index 1bb9cecb..9f444475 100644 --- a/scripts/pribor-prd.gd +++ b/scripts/pribor-prd.gd @@ -1,7 +1,8 @@ class_name TestPRD extends Node -# Добавляем константы для прогресса +#region CONSTANTS +## Константы прогресса для визуализации выполнения контроля const PROGRESS_INIT: float = 5.0 const PROGRESS_FS_TURN_ON: float = 10.0 const PROGRESS_FS_WORK: float = 20.0 @@ -12,8 +13,7 @@ const PROGRESS_UG_SET_RAY: float = 40.0 const PROGRESS_RAY_STATES: float = 50.0 const PROGRESS_COMPLETE: float = 100.0 -# Для маппинга (Возможно уберу в будущем, но это не точно) -# Константы для работы с лучами +## Константы для работы с лучами управления const RAY_MASK = 0x07 const SPECIAL_LITERAS = [3, 5, 7] const RAY_m5: String = "RAY_m5" @@ -22,7 +22,8 @@ const RAY_15: String = "RAY_15" const RAY_25: String = "RAY_25" const RAY_35: String = "RAY_35" const RAY_45: String = "RAY_45" -# Маппинг значений лучей на состояния и названия + +## Конфигурация лучей: состояния, названия, задержки и требования const RAY_CONFIG = { 0: { "state": "UG_SET_RAY_0", "name": "-5°", "delay": 0.5, "requires_si_fs": true }, 1: { "state": "UG_SET_RAY_1", "name": "5°", "delay": 0.0, "requires_si_fs": false }, @@ -34,26 +35,33 @@ const RAY_CONFIG = { } const RAY_TYPES := [RAY_m5, RAY_5, RAY_15, RAY_25, RAY_35, RAY_45] + +## Перечисление состояний машины контроля ПРД enum STATE_MACHINE { - INIT, - FS_TURN_ON, - FS_WORK, - WRITE_ISA, - READ_ISA, - CHEK_KASSETA_Y5, - UG_SET_RAY, - UG_SET_RAY_0, - UG_SET_RAY_1, - UG_SET_RAY_2, - UG_SET_RAY_3, - UG_SET_RAY_4, - UG_SET_RAY_5, - IN_EMS_RUN, - IN_EMS_STOP, - FS_TURN_OFF, - STOP_CONTROL, - AWAIT - } + INIT, + FS_TURN_ON, + FS_WORK, + WRITE_ISA, + READ_ISA, + CHEK_KASSETA_Y5, + UG_SET_RAY, + UG_SET_RAY_0, + UG_SET_RAY_1, + UG_SET_RAY_2, + UG_SET_RAY_3, + UG_SET_RAY_4, + UG_SET_RAY_5, + IN_EMS_RUN, + IN_EMS_STOP, + FS_TURN_OFF, + STOP_CONTROL, + AWAIT +} +#endregion + + +#region VARIABLES +## Словарь состояния сокетов ЭМС-Г var ems_g_sock_dic: Dictionary = { 'ems_input_1': 0, 'ems_input_2': 0, @@ -62,9 +70,12 @@ var ems_g_sock_dic: Dictionary = { 'ems_output_2': 0, 'ems_output_lit_1': 0, } + +## Маппинги состояний лучей var _ray_state_mapping: Dictionary var _ray_state_enums: Dictionary = {} -# Загруженные конфигурации (приватные) + +## Загруженные конфигурации (приватные) var _device_constants: Dictionary var _base_configs: Dictionary var _device_configs: Dictionary @@ -73,7 +84,8 @@ var _fs_keys: Dictionary var _temperature_constants: Dictionary var _ems_input_bits_config: Dictionary var _fs_rules: Array -# Переменные класса + +## Основные переменные класса var config_manager: PRDConfigManager var unit_prd: Object var constants: Dictionary @@ -89,6 +101,8 @@ var power_for_litera: Dictionary var self_name: String var state: int = STATE_MACHINE.INIT var current_litera: int + +## Флаги состояния системы var flag_write_isa: bool = false var flag_fs_status_ok: bool = false var flag_si_fs_input: bool = false @@ -97,33 +111,39 @@ var flag_in_control: bool = false var flag_control_is_over: bool = false var flag_no_trust_yau07: bool = false var flag_only_fs: bool = false + +## Таймеры контроля var control_timer: Timer = Timer.new() var ems_6666_timer: Timer = Timer.new() var machine_timer: Timer = Timer.new() + +## Счетчики и команды var cc: int = 0 var cmd_array: Array -# Добавляем переменные для отслеживания прогресса +## Переменные для отслеживания прогресса var total_fs_to_check: int = 0 var completed_fs_count: int = 0 var current_fs_progress: float = 0.0 -# Переменная для текущего статуса var current_status: String = "Ожидание запуска контроля" -# Сигналы Класса -signal control_is_over() # Когда контроль все! +## Сигналы класса +signal control_is_over() # Когда контроль завершен signal status_updated(status_text: String) # Сигнал для обновления статуса signal update_progress(progress_value: float) signal update_max_value_progress(max_progress_value: int) +## Свойство прогресса с автоматическим emit сигнала var progress_value: float: set(v): if progress_value != v: progress_value = v call_deferred('emit_signal', 'update_progress', v) +#endregion -## Инициализация аргуметнов +#region INITIALIZATION +## Инициализация объекта контроля ПРД func _init(init_data: Dictionary, cmd_array_from_prd: Array) -> void: unit_prd = init_data['unit_prd'] cmd_array = cmd_array_from_prd @@ -133,6 +153,7 @@ func _init(init_data: Dictionary, cmd_array_from_prd: Array) -> void: _initialize_power_structure() +## Инициализация конфигурации из менеджера func _initialize_config_from_manager() -> void: if not config_manager.is_loaded(): push_error("ConfigManager не загружен!") @@ -148,6 +169,7 @@ func _initialize_config_from_manager() -> void: _fs_rules = config_manager.get_fs_rules() +## Инициализация структуры данных для хранения мощностей func _initialize_power_structure() -> void: power_for_litera = {} for litera in range(1, 8): @@ -156,6 +178,7 @@ func _initialize_power_structure() -> void: power_for_litera[litera][ray_type] = [] +## Инициализация при готовности узла func _ready() -> void: _determine_self_name() initialize_connections() @@ -163,10 +186,7 @@ func _ready() -> void: _initialize_ray_state_enums() -func _get_ray_key(machine_state: int) -> String: - return _ray_state_mapping.get(machine_state, "") - - +## Инициализация маппинга состояний лучей func _initialize_ray_mapping() -> void: _ray_state_mapping = { STATE_MACHINE.UG_SET_RAY_0: "RAY_m5", @@ -178,24 +198,42 @@ func _initialize_ray_mapping() -> void: } +## Инициализация enum значений для состояний лучей +func _initialize_ray_state_enums() -> void: + for ray_value in RAY_CONFIG: + var state_name = RAY_CONFIG[ray_value].state + _ray_state_enums[state_name] = STATE_MACHINE.get(state_name) +#endregion + + +#region PROCESS_METHODS +## Основной процесс (не используется, но оставлен для совместимости) func _process(_delta: float) -> void: pass -## Пакеты от ЯУ-07 +## Обработка данных от ЯУ-07 func on_data_received(unit_pribor: Object) -> void: - if not flag_in_control: return + if not flag_in_control: + return + var status: PackedByteArray = unit_pribor.status block_kasseta_y5_config = check_block_kasseta_y5(status, block_kasseta_y5_config, flag_no_trust_yau07) - if flag_no_trust_yau07: return + + if flag_no_trust_yau07: + return + socket_status_ems_g(status) block_ip_config = check_block_ip(status, block_ip_config) temperature_um = check_temperature_um(status) + if machine_timer.is_stopped(): return _process_dkm_status(status) - if current_litera != 0: # Формирование мощностей в литерах + + # Формирование мощностей в литерах + if current_litera != 0: var tek_litera: Dictionary = power_for_litera[current_litera] var interes = _get_ray_key(state) if interes != '': @@ -203,169 +241,295 @@ func on_data_received(unit_pribor: Object) -> void: power_for_litera[current_litera] = tek_litera +## Получение ключа луча по состоянию машины +func _get_ray_key(machine_state: int) -> String: + return _ray_state_mapping.get(machine_state, "") +#endregion + + +#region EMS_SOCKET_HANDLING +## Обработка статуса сокетов ЭМС-Г из пакета ЯУ-07 func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void: + # Обработка для разных типов приборов if self_name in ['1н', '2н', '3н', '4н']: ems_g_sock_dic.ems_input_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 9)) != 0 ems_g_sock_dic.ems_input_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 10)) != 0 + if self_name in ['1в', '2в', '3в', '4в']: ems_g_sock_dic.ems_input_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 11)) != 0 ems_g_sock_dic.ems_input_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 12)) != 0 + if self_name in ['1к', '2к', '3к', '4к']: ems_g_sock_dic.ems_input_lit_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 8)) != 0 ems_g_sock_dic.ems_input_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 13)) != 0 ems_g_sock_dic.ems_input_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) & (1 << 14)) != 0 + # Обработка выходных сокетов ems_g_sock_dic.ems_output_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 4)) != 0 ems_g_sock_dic.ems_output_2 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 5)) != 0 ems_g_sock_dic.ems_output_lit_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 3)) != 0 + # Определение флагов СИ ФС входа var number_socket_input: int if current_litera >= 1 and current_litera <= 7: number_socket_input = current_litera + 7 var in_blank: int = packet_form_yau_07.decode_u16(config_manager.get_data_index('IN_BLANK_PRD')) - flag_si_fs_input = (in_blank & (1 << number_socket_input)) != 0 ## Флаг СИ от ФС входа в ЭМС-Г для текущей литеры + flag_si_fs_input = (in_blank & (1 << number_socket_input)) != 0 + # Определение флагов СИ ФС выхода var number_socket_output: int number_socket_output = 4 if current_litera in [2, 4, 6] else 3 if current_litera == 1 else 5 var out_blank: int = packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) - flag_si_fs_output = (out_blank & (1 << number_socket_output)) != 0 ## Флаг Модуляции УМ ЭМС-Г для текущей литеры + flag_si_fs_output = (out_blank & (1 << number_socket_output)) != 0 +#endregion -## Пакеты от MP550Service -func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> void: - var fs_key: String = _fs_keys.get(str(current_litera), '') - if fs_key.is_empty(): - return - - var fs_result := {fs_key: 0} - fs_result = on_fs_state(packet_type_7, fs_mapping, fs_result, _fs_rules) - control_results[fs_key] = fs_result[fs_key] - flag_fs_status_ok = control_results[fs_key] == 1 - - -# Обновленная машина состояний +#region STATE_MACHINE +## Основная машина состояний контроля ПРД func state_control_machine() -> void: match state: - STATE_MACHINE.INIT: - _handle_init_state() - STATE_MACHINE.FS_TURN_ON: - _handle_fs_turn_on_state() - state = STATE_MACHINE.FS_WORK - STATE_MACHINE.FS_WORK: - var flag_ecm: bool = false - for key in ecms: - var params = ecms[key].params.freq - if fs_parameters[current_litera].freq == params: - var kni = ecms[key].kni - if pribor_config[self_name].angle == kni: - flag_ecm = true - if flag_ecm and flag_fs_status_ok: - ems_6666_timer.start() - _handle_fs_work_state() - STATE_MACHINE.CHEK_KASSETA_Y5: - if block_kasseta_y5_config['yau07']: - state = STATE_MACHINE.WRITE_ISA - elif flag_only_fs: - state = STATE_MACHINE.IN_EMS_STOP - STATE_MACHINE.WRITE_ISA: - if not flag_write_isa: - _handle_ug_set_state(0x6) - state = STATE_MACHINE.READ_ISA - STATE_MACHINE.READ_ISA: - if (unit_prd.cmd_state == unit_prd.CmdState.DONE) or (unit_prd.cmd_state == unit_prd.CmdState.FAIL): - _handle_read_isa(unit_prd, [constants.ADDR_UG_LITERA_1, constants.ADDR_UG_LITERA_2, constants.ADDR_UG_LITERA_3], cmd_array) - flag_write_isa = false - state = STATE_MACHINE.UG_SET_RAY - - # Упрощенные состояния лучей - STATE_MACHINE.UG_SET_RAY: - _handle_ray_operation() # Режим чтения - - STATE_MACHINE.UG_SET_RAY_0: - _handle_ray_operation(0) - - STATE_MACHINE.UG_SET_RAY_1: - _handle_ray_operation(1) - - STATE_MACHINE.UG_SET_RAY_2: - _handle_ray_operation(2) - - STATE_MACHINE.UG_SET_RAY_3: - _handle_ray_operation(3) - - STATE_MACHINE.UG_SET_RAY_4: - _handle_ray_operation(4) - - STATE_MACHINE.UG_SET_RAY_5: - _handle_ray_operation(5) - - STATE_MACHINE.IN_EMS_STOP: - ems_6666_timer.stop() - state = STATE_MACHINE.FS_TURN_OFF - - STATE_MACHINE.FS_TURN_OFF: - ems_6666_timer.stop() - _handle_fs_turn_off_state() - state = STATE_MACHINE.STOP_CONTROL - - STATE_MACHINE.STOP_CONTROL: - _handle_stop_control_state() - - # Обновление прогресс-бара + STATE_MACHINE.INIT: _handle_init_state() + STATE_MACHINE.FS_TURN_ON: _handle_fs_turn_on_state() + STATE_MACHINE.FS_WORK: _handle_fs_work_state() + STATE_MACHINE.CHEK_KASSETA_Y5: _handle_check_kasseta_state() + STATE_MACHINE.WRITE_ISA: _handle_write_isa_state() + STATE_MACHINE.READ_ISA: _handle_read_isa_state() + STATE_MACHINE.UG_SET_RAY: _handle_ray_operation() # Режим чтения + STATE_MACHINE.UG_SET_RAY_0: _handle_ray_operation(0) + STATE_MACHINE.UG_SET_RAY_1: _handle_ray_operation(1) + STATE_MACHINE.UG_SET_RAY_2: _handle_ray_operation(2) + STATE_MACHINE.UG_SET_RAY_3: _handle_ray_operation(3) + STATE_MACHINE.UG_SET_RAY_4: _handle_ray_operation(4) + STATE_MACHINE.UG_SET_RAY_5: _handle_ray_operation(5) + STATE_MACHINE.IN_EMS_STOP: _handle_ems_stop_state() + STATE_MACHINE.FS_TURN_OFF: _handle_fs_turn_off_state() + STATE_MACHINE.STOP_CONTROL: _handle_stop_control_state() + # Обновление прогресс-бара после обработки состояния if block_kasseta_y5_config['yau07'] or flag_no_trust_yau07: progressbar_status() - -## 'Выполняется инициализация ФС-%s' % current_litera +## Обработка состояния INIT - инициализация ФС func _handle_init_state() -> void: if current_litera in [1, 2, 3, 4, 5, 6, 7]: _set_status("Инициализация ФС-%s" % current_litera) var flag_ecm: bool = false + + # Проверка доступности ЭМС для текущей литеры for key in ecms: var params = ecms[key].params.freq if fs_parameters[current_litera].freq == params: var kni = ecms[key].kni if pribor_config[self_name].angle == kni: flag_ecm = true + if not flag_ecm: state = STATE_MACHINE.FS_TURN_ON else: + # Завершение контроля если литеры закончились flag_control_is_over = true control_results = on_control_result(block_ip_config, control_results) power_result = prep_power(power_for_litera, self_name) machine_timer.stop() + var result: bool = true for device in control_results.values(): if not device: result = false + _set_status("Прибор ПРД-%s: %s" % [self_name, ['неисправен', 'исправен'][int(result)]]) emit_signal('control_is_over') -##'Выполняется включение ФС-%s' % current_litera +## Обработка состояния FS_TURN_ON - включение ФС func _handle_fs_turn_on_state() -> void: _set_status("Включение ФС-%s" % current_litera) manage_fs(true, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM) control_timer.wait_time = constants.TIMER_DELAY control_timer.start() + state = STATE_MACHINE.FS_WORK -##'Выполняется проверка ФС-%s' % current_litera +## Обработка состояния FS_WORK - проверка работы ФС func _handle_fs_work_state() -> void: - _set_status("Проверка ФС-%s" % current_litera) - if (current_litera == 2 and control_results.fs_2) or \ - (current_litera == 3 and control_results.fs_3) or \ - (current_litera == 4 and control_results.fs_4) or \ - (current_litera == 5 and control_results.fs_5) or \ - (current_litera == 6 and control_results.fs_6) or \ - (current_litera == 7 and control_results.fs_7) or \ - (current_litera == 1 and control_results.fs_1): - state = STATE_MACHINE.CHEK_KASSETA_Y5 + var flag_ecm: bool = false + + # Проверка соответствия ЭМС + for key in ecms: + var params = ecms[key].params.freq + if fs_parameters[current_litera].freq == params: + var kni = ecms[key].kni + if pribor_config[self_name].angle == kni: + flag_ecm = true + + # Если ЭМС доступна и ФС в порядке - запускаем таймер ЭМС + if flag_ecm and flag_fs_status_ok: + ems_6666_timer.start() + _set_status("Проверка ФС-%s" % current_litera) + + # Проверка завершения работы ФС + if (current_litera == 2 and control_results.fs_2) or \ + (current_litera == 3 and control_results.fs_3) or \ + (current_litera == 4 and control_results.fs_4) or \ + (current_litera == 5 and control_results.fs_5) or \ + (current_litera == 6 and control_results.fs_6) or \ + (current_litera == 7 and control_results.fs_7) or \ + (current_litera == 1 and control_results.fs_1): + state = STATE_MACHINE.CHEK_KASSETA_Y5 -## Подготовка к настройки и записи в УГ +## Обработка состояния CHECK_KASSETA - проверка кассеты Y5 +func _handle_check_kasseta_state() -> void: + if block_kasseta_y5_config['yau07']: + state = STATE_MACHINE.WRITE_ISA + elif flag_only_fs: + state = STATE_MACHINE.IN_EMS_STOP + + +## Обработка состояния WRITE_ISA - запись в УГ +func _handle_write_isa_state() -> void: + if not flag_write_isa: + _handle_ug_set_state(0x6) + state = STATE_MACHINE.READ_ISA + + +## Обработка состояния READ_ISA - чтение из УГ +func _handle_read_isa_state() -> void: + if (unit_prd.cmd_state == unit_prd.CmdState.DONE) or (unit_prd.cmd_state == unit_prd.CmdState.FAIL): + _handle_read_isa(unit_prd, [constants.ADDR_UG_LITERA_1, constants.ADDR_UG_LITERA_2, constants.ADDR_UG_LITERA_3], cmd_array) + flag_write_isa = false + state = STATE_MACHINE.UG_SET_RAY + + +## Обработка состояния EMS_STOP - остановка ЭМС +func _handle_ems_stop_state() -> void: + ems_6666_timer.stop() + state = STATE_MACHINE.FS_TURN_OFF + + +## Обработка состояния FS_TURN_OFF - выключение ФС +func _handle_fs_turn_off_state() -> void: + ems_6666_timer.stop() + _set_status("Отключение ФС-%s" % current_litera) + flag_fs_status_ok = false + manage_fs(false, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM) + state = STATE_MACHINE.STOP_CONTROL + + +## Обработка состояния STOP_CONTROL - завершение контроля +func _handle_stop_control_state() -> void: + _set_status("Завершение контроля ФС-%s" % current_litera) + completed_fs_count += 1 + _advance_to_next_fs() + state = STATE_MACHINE.INIT + + if flag_no_trust_yau07: + state = STATE_MACHINE.STOP_CONTROL + + +## Переход к следующей литере контроля +func _advance_to_next_fs() -> void: + match current_litera: + 1: current_litera = 6 + 2: current_litera = 3 + 3: current_litera = 0 + 4: current_litera = 5 + 5: current_litera = 0 + 6: current_litera = 7 + 7: current_litera = 0 + + # Сброс прогресса при переходе к следующей ФС + if current_litera != 0: + current_fs_progress = 0.0 +#endregion + + +#region RAY_OPERATIONS +## Универсальный обработчик операций с лучами +func _handle_ray_operation(ray_num: int = -1) -> void: + if ray_num == -1: + # Режим чтения - определение текущего луча + _handle_ray_read_mode() + else: + # Режим записи - установка конкретного луча + _handle_ray_write_mode(ray_num) + + +## Обработка чтения состояния луча +func _handle_ray_read_mode() -> void: + var addr: int = _get_ug_address() + if not _can_process_ray_state(addr): + return + + var ray_value = unit_prd.isa_ports[addr] & RAY_MASK + _process_ray_value(ray_value) + + +## Обработка записи состояния луча +func _handle_ray_write_mode(ray_num: int) -> void: + if not _can_write_ray(ray_num): + return + + var ray_config = RAY_CONFIG[ray_num] + + # Особые условия для луча 0 + if ray_num == 0: + control_timer.stop() + + # Задержка если требуется + if ray_config.delay > 0: + await get_tree().create_timer(ray_config.delay).timeout + + # Установка луча + _handle_ug_set_state(ray_num) + flag_write_isa = true + state = STATE_MACHINE.READ_ISA + + +## Обработка значения луча из UG_SET_RAY состояния +func _process_ray_value(ray_value: int) -> void: + match ray_value: + 0, 1, 2, 3, 4: + var next_ray = ray_value + 1 + if next_ray in RAY_CONFIG: + state = _ray_state_enums[RAY_CONFIG[next_ray].state] + 5: + if not current_litera == 1: + control_results = check_dou_result(control_results, power_for_litera, self_name, current_litera, constants) + state = STATE_MACHINE.IN_EMS_STOP + 6: + state = STATE_MACHINE.UG_SET_RAY_0 + if current_litera == 1: + state = STATE_MACHINE.UG_SET_RAY_5 + + +## Проверка возможности обработки состояния луча +func _can_process_ray_state(addr: int) -> bool: + return unit_prd.isa_ports.has(addr) and (unit_prd.cmd_state == unit_prd.CmdState.DONE) + + +## Проверка возможности записи луча +func _can_write_ray(ray_num: int) -> bool: + if flag_write_isa: + return false + + var ray_config = RAY_CONFIG[ray_num] + # Для луча 0 требуется flag_si_fs_input, для остальных - нет + if ray_num == 0: + return ray_config.requires_si_fs and flag_si_fs_input + + return true + + +## Получение адреса UG для текущей литеры +func _get_ug_address() -> int: + return constants.ADDR_UG_LITERA_2 if current_litera in SPECIAL_LITERAS else constants.ADDR_UG_LITERA_1 +#endregion + + +#region UG_OPERATIONS +## Подготовка к настройке и записи в УГ func _handle_ug_set_state(RAY_DOU_NUM: int) -> void: _set_status("Настройка угла %s" % _get_ray_name(RAY_DOU_NUM)) var dic_att := { @@ -376,6 +540,8 @@ func _handle_ug_set_state(RAY_DOU_NUM: int) -> void: 'ATT_UM_3': 0x00, 'BASE_EMS_G': constants.BASE_ADDR_EMS_G } + + # Конфигурация аттенюаторов для разных типов приборов if self_name == '1к' or self_name == '2к' or self_name == '3к' or self_name == '4к': dic_att['ATT_UM_1'] = constants.ATT_UM_6 dic_att['ATT_UM_2'] = constants.ATT_UM_7 @@ -386,11 +552,18 @@ func _handle_ug_set_state(RAY_DOU_NUM: int) -> void: elif self_name == '1н' or self_name == '2н' or self_name == '3н' or self_name == '4н': dic_att['ATT_UM_1'] = constants.ATT_UM_2 dic_att['ATT_UM_2'] = constants.ATT_UM_3 + flag_write_isa = on_ug_setting(unit_prd, dic_att, cmd_array) -## Функция для продвижения статуса прогресс бара -# Обновленный прогресс-бар с учетом новой структуры +## Получение имени луча по номеру +func _get_ray_name(ray_num: int) -> String: + return RAY_CONFIG.get(ray_num, {}).get("name", "неизвестный угол") +#endregion + + +#region PROGRESS_MANAGEMENT +## Обновление статуса прогресс-бара func progressbar_status() -> void: if current_litera == 0: progress_value = PROGRESS_COMPLETE @@ -400,6 +573,7 @@ func progressbar_status() -> void: var base_progress: float = 0.0 + # Базовый прогресс в зависимости от состояния match state: STATE_MACHINE.INIT: base_progress = PROGRESS_INIT @@ -417,7 +591,6 @@ func progressbar_status() -> void: base_progress = PROGRESS_UG_SET_RAY STATE_MACHINE.UG_SET_RAY_0, STATE_MACHINE.UG_SET_RAY_1, STATE_MACHINE.UG_SET_RAY_2, \ STATE_MACHINE.UG_SET_RAY_3, STATE_MACHINE.UG_SET_RAY_4, STATE_MACHINE.UG_SET_RAY_5: - # Для всех состояний лучей используем одинаковый прогресс base_progress = PROGRESS_RAY_STATES STATE_MACHINE.IN_EMS_STOP, STATE_MACHINE.FS_TURN_OFF, STATE_MACHINE.STOP_CONTROL: base_progress = PROGRESS_COMPLETE @@ -432,7 +605,6 @@ func progressbar_status() -> void: var addr: int = _get_ug_address() if _can_process_ray_state(addr): var ray_value = unit_prd.isa_ports[addr] & RAY_MASK - # Используем маппинг из RAY_CONFIG для более точного прогресса var max_ray_value = 5.0 # максимальное значение луча для прогресса var ray_progress = float(ray_value) / max_ray_value * 40.0 base_progress += ray_progress @@ -448,151 +620,29 @@ func progressbar_status() -> void: progress_value = clamp(progress_value, 0.0, PROGRESS_COMPLETE) -##'Выполняется отключение ФС-%s' % current_litera -func _handle_fs_turn_off_state() -> void: - _set_status("Отключение ФС-%s" % current_litera) - flag_fs_status_ok = false - manage_fs(false, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM) +## Установка нового статуса с emit сигнала +func _set_status(new_status: String) -> void: + if current_status != new_status: + current_status = new_status + call_deferred('emit_signal', 'status_updated', new_status) +#endregion -##'Выполняется завершение проверки ФС-%s' % current_litera -func _handle_stop_control_state() -> void: - _set_status("Завершение контроля ФС-%s" % current_litera) - # Увеличиваем счетчик завершенных ФС - completed_fs_count += 1 - - _advance_to_next_fs() - state = STATE_MACHINE.INIT - if current_litera == 0: return - if flag_no_trust_yau07: - state = STATE_MACHINE.STOP_CONTROL - - -## Переходит на следующую литеру, если 0 то считай закончил выполнения контроля -func _advance_to_next_fs() -> void: - match current_litera: - 1: current_litera = 6 - 2: current_litera = 3 - 3: current_litera = 0 - 4: current_litera = 5 - 5: current_litera = 0 - 6: current_litera = 7 - 7: current_litera = 0 - # Сбрасываем прогресс текущей ФС при переходе к следующей - if current_litera != 0: - current_fs_progress = 0.0 - - -###################################### -func initialize_connections() -> void: - var fs_mapping = _create_fs_mapping(self_name) - signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping)) - signaller.conn(signaller.start_contol_device, Callable(self, '_on_start_contol_device')) - interfer.connect('interfer_resized', Callable(self, 'on_interfer_resized')) - unit_prd.connect('data_received', Callable(self, 'on_data_received')) - - var mode_signals = ['режим_работа', 'режим_журнал', 'режим_эмс', 'режим_настройки'] - for signal_name in mode_signals: - signaller.connect(signal_name, Callable(self, 'on_mode_changed').bind(false)) - signaller.connect('режим_контроль', Callable(self, 'on_mode_changed').bind(true)) - - -# Инициализация маппинга имен состояний в enum значения -func _initialize_ray_state_enums() -> void: - for ray_value in RAY_CONFIG: - var state_name = RAY_CONFIG[ray_value].state - _ray_state_enums[state_name] = STATE_MACHINE.get(state_name) - - -func on_interfer_resized(ecms_dic: Dictionary) -> void: - ecms = ecms_dic - - -func _on_start_contol_device()-> void: - _set_status("Подготовка к контролю") - _determine_self_name() - machine_timer.wait_time = constants.STATE_MASHINE_TIMER - machine_timer.start() - - -func _determine_self_name() -> void: - flag_no_trust_yau07 = false - flag_only_fs = false - cc = 0 - state = STATE_MACHINE.get("INIT", 0) - var current_unit = unit_prd.name - var parts = current_unit.split('-') - self_name = parts[-1] - - var device_type: String = _get_device_type() - if device_type.is_empty(): - return - - var device_config = _device_constants.get(device_type, {}) - var device_data_config = _device_configs.get(device_type, {}) - - # Загружаем конфигурацию устройства - constants = device_config.get("constants", {}) - pribor_config = device_config.get("pribor_config", {}) - - # Конвертируем fs_params ключи в int - var raw_fs_params = device_config.get("fs_params", {}) - fs_parameters = {} - for key in raw_fs_params: - fs_parameters[int(key)] = raw_fs_params[key] - - # Загружаем конфигурации блоков - block_ip_config = _load_block_config(device_data_config.get("block_ip", {}), "block_ip") - block_kasseta_y5_config = _load_block_config(device_data_config.get("block_kasseta", {}), "block_kasseta") - control_results = device_data_config.get("control_results", {}) - current_litera = device_config.get("start_litera", 0) - - # Определяем общее количество ФС для контроля - match self_name: - '1к', '2к', '3к', '4к': - total_fs_to_check = 3 # Литеры 1, 6, 7 - '1н', '2н', '3н', '4н': - total_fs_to_check = 2 # Литеры 2, 3 - '1в', '2в', '3в', '4в': - total_fs_to_check = 2 # Литеры 4, 5 - - progress_value = 0 - completed_fs_count = 0 - current_fs_progress = 0.0 - call_deferred('emit_signal', 'update_max_value_progress', 100) - - -func _load_block_config(config, config_type: String) -> Dictionary: - if config is String and config == "base": - return _base_configs.get(config_type, {}).duplicate(true) - elif config is Dictionary: - return config.duplicate(true) - return {} - - -func _get_device_type() -> String: - if self_name.ends_with('н'): return 'PRD_N' - elif self_name.ends_with('в'): return 'PRD_V' - elif self_name.ends_with('к'): return 'PRD_K' - return '' - - -# Получение адреса UG для текущей литеры -func _get_ug_address() -> int: - return constants.ADDR_UG_LITERA_2 if current_litera in SPECIAL_LITERAS else constants.ADDR_UG_LITERA_1 - - -## Настройка таймеров +#region TIMER_MANAGEMENT +## Настройка таймеров контроля func setup_timer() -> void: + # Таймер контроля add_child(control_timer) control_timer.timeout.connect(on_stop_control) control_timer.one_shot = true control_timer.wait_time = constants.get("TIMER_DELAY", 10.0) + # Таймер ЭМС-Г add_child(ems_6666_timer) ems_6666_timer.timeout.connect(_on_ems_6666_timer) ems_6666_timer.wait_time = 1.0 + # Таймер машины состояний add_child(machine_timer) machine_timer.connect('timeout', Callable(self, 'on_state_mashine')) @@ -607,7 +657,7 @@ func on_state_mashine(): state_control_machine() -## При таймауте таймера ожидания выполнения команды и перехода на следующий шаг машины состояний +## Обработка таймаута контроля func on_stop_control() -> void: _handle_fs_turn_off_state() @@ -616,81 +666,124 @@ func on_stop_control() -> void: elif state == STATE_MACHINE.CHEK_KASSETA_Y5: flag_only_fs = true state = STATE_MACHINE.FS_TURN_OFF +#endregion -# Обработка значения луча из UG_SET_RAY состояния -func _process_ray_value(ray_value: int) -> void: - match ray_value: - 0, 1, 2, 3, 4: - var next_ray = ray_value + 1 - if next_ray in RAY_CONFIG: # ← Добавить проверку - state = _ray_state_enums[RAY_CONFIG[next_ray].state] - 5: - if not current_litera == 1: - control_results = check_dou_result(control_results, power_for_litera, self_name, current_litera, constants) - state = STATE_MACHINE.IN_EMS_STOP - 6: - state = STATE_MACHINE.UG_SET_RAY_0 - if current_litera == 1: - state = STATE_MACHINE.UG_SET_RAY_5 - - -# Универсальный обработчик для всех операций с лучами -func _handle_ray_operation(ray_num: int = -1) -> void: - if ray_num == -1: - # Режим чтения - определение текущего луча - _handle_ray_read_mode() - else: - # Режим записи - установка конкретного луча - _handle_ray_write_mode(ray_num) - - -# Обработка чтения состояния луча -func _handle_ray_read_mode() -> void: - var addr: int = _get_ug_address() - if not _can_process_ray_state(addr): +#region DEVICE_CONFIGURATION +## Определение имени и конфигурации устройства +func _determine_self_name() -> void: + flag_no_trust_yau07 = false + flag_only_fs = false + cc = 0 + state = STATE_MACHINE.get("INIT", 0) + var current_unit = unit_prd.name + var parts = current_unit.split('-') + self_name = parts[-1] + + var device_type: String = _get_device_type() + if device_type.is_empty(): return - var ray_value = unit_prd.isa_ports[addr] & RAY_MASK - _process_ray_value(ray_value) + + # Загрузка конфигурации устройства + var device_config = _device_constants.get(device_type, {}) + var device_data_config = _device_configs.get(device_type, {}) + + constants = device_config.get("constants", {}) + pribor_config = device_config.get("pribor_config", {}) + + # Конвертация fs_params ключей в int + var raw_fs_params = device_config.get("fs_params", {}) + fs_parameters = {} + for key in raw_fs_params: + fs_parameters[int(key)] = raw_fs_params[key] + + # Загрузка конфигураций блоков + block_ip_config = _load_block_config(device_data_config.get("block_ip", {}), "block_ip") + block_kasseta_y5_config = _load_block_config(device_data_config.get("block_kasseta", {}), "block_kasseta") + control_results = device_data_config.get("control_results", {}) + current_litera = device_config.get("start_litera", 0) + + # Определение общего количества ФС для контроля + match self_name: + '1к', '2к', '3к', '4к': + total_fs_to_check = 3 # Литеры 1, 6, 7 + '1н', '2н', '3н', '4н': + total_fs_to_check = 2 # Литеры 2, 3 + '1в', '2в', '3в', '4в': + total_fs_to_check = 2 # Литеры 4, 5 + + progress_value = 0 + completed_fs_count = 0 + current_fs_progress = 0.0 + call_deferred('emit_signal', 'update_max_value_progress', 100) -# Проверка возможности обработки состояния луча -func _can_process_ray_state(addr: int) -> bool: - return unit_prd.isa_ports.has(addr) and (unit_prd.cmd_state == unit_prd.CmdState.DONE) +## Загрузка конфигурации блока +func _load_block_config(config, config_type: String) -> Dictionary: + if config is String and config == "base": + return _base_configs.get(config_type, {}).duplicate(true) + elif config is Dictionary: + return config.duplicate(true) + return {} -# Обработка записи состояния луча -func _handle_ray_write_mode(ray_num: int) -> void: - if not _can_write_ray(ray_num): +## Определение типа устройства по имени +func _get_device_type() -> String: + if self_name.ends_with('н'): + return 'PRD_N' + elif self_name.ends_with('в'): + return 'PRD_V' + elif self_name.ends_with('к'): + return 'PRD_K' + return '' +#endregion + + +#region CONNECTIONS_MANAGEMENT +## Инициализация соединений и сигналов +func initialize_connections() -> void: + var fs_mapping = _create_fs_mapping(self_name) + signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping)) + signaller.conn(signaller.start_contol_device, Callable(self, '_on_start_contol_device')) + interfer.connect('interfer_resized', Callable(self, 'on_interfer_resized')) + unit_prd.connect('data_received', Callable(self, 'on_data_received')) + + # Подключение сигналов режимов работы + var mode_signals = ['режим_работа', 'режим_журнал', 'режим_эмс', 'режим_настройки'] + for signal_name in mode_signals: + signaller.connect(signal_name, Callable(self, 'on_mode_changed').bind(false)) + signaller.connect('режим_контроль', Callable(self, 'on_mode_changed').bind(true)) + + +## Обработка обновления состояния ФС от MP550Service +func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> void: + var fs_key: String = _fs_keys.get(str(current_litera), '') + if fs_key.is_empty(): return - var ray_config = RAY_CONFIG[ray_num] - # Особые условия для луча 0 - if ray_num == 0: - control_timer.stop() - # Задержка если требуется - if ray_config.delay > 0: - await get_tree().create_timer(ray_config.delay).timeout - # Установка луча - _handle_ug_set_state(ray_num) - flag_write_isa = true - state = STATE_MACHINE.READ_ISA + + var fs_result := {fs_key: 0} + fs_result = on_fs_state(packet_type_7, fs_mapping, fs_result, _fs_rules) + control_results[fs_key] = fs_result[fs_key] + flag_fs_status_ok = control_results[fs_key] == 1 -# Проверка возможности записи луча -func _can_write_ray(ray_num: int) -> bool: - if flag_write_isa: - return false - var ray_config = RAY_CONFIG[ray_num] - # Для луча 0 требуется flag_si_fs_input, для остальных - нет - if ray_num == 0: - return ray_config.requires_si_fs and flag_si_fs_input - return true +## Обработка изменения размера интерферометра +func on_interfer_resized(ecms_dic: Dictionary) -> void: + ecms = ecms_dic -## Срабатывает при выходе или входе в режим контроль +## Обработка запуска контроля устройства +func _on_start_contol_device()-> void: + _set_status("Подготовка к контролю") + _determine_self_name() + machine_timer.wait_time = constants.STATE_MASHINE_TIMER + machine_timer.start() + + +## Обработка изменения режима работы func on_mode_changed(in_tree: bool) -> void: flag_in_control = in_tree - if not in_tree: ## TODO: Дополнительная проверка если контроль идет, если нет, то смысла вызывать нет + if not in_tree: _set_status("Ожидание запуска контроля") flag_control_is_over = false flag_no_trust_yau07 = false @@ -699,24 +792,32 @@ func on_mode_changed(in_tree: bool) -> void: machine_timer.stop() state = STATE_MACHINE.INIT _handle_fs_turn_off_state() - #prd_v_module.cmd_array.append([unit_prd_v.CmdCode.WRITE_ISA, [constants_v.ADDR_UG_LITERA_1, ug_work_1, constants_v.ADDR_UG_LITERA_2, ug_work_2]]) else: _set_status("Ожидание запуска контроля") +#endregion +#region DKM_PROCESSING +## Обработка статуса ДКМ из пакета ЯУ-07 func _process_dkm_status(status: PackedByteArray) -> void: if not control_results.has(_get_current_fs_key(current_litera, _fs_keys)): return + var dkm_bit = _get_dkm_bit_for_current_fs(current_litera, constants) if dkm_bit == 0: control_results['dkm_1'] = check_dkm(status, dkm_bit) + var addr: int = constants.ADDR_UG_LITERA_1 if current_litera == 3 or current_litera == 5 or current_litera == 7: addr = constants.ADDR_UG_LITERA_2 + if not unit_prd.isa_ports.has(addr) or not (unit_prd.cmd_state == unit_prd.CmdState.DONE): return - if not unit_prd.isa_ports[addr] & 0x07 == 6: return + + if not unit_prd.isa_ports[addr] & 0x07 == 6: + return + # Обработка битов ДКМ в зависимости от текущей литеры if dkm_bit == 1: control_results['dkm_2'] = check_dkm(status, dkm_bit) elif dkm_bit == 2: @@ -731,6 +832,7 @@ func _process_dkm_status(status: PackedByteArray) -> void: control_results['dkm_7'] = check_dkm(status, dkm_bit) +## Получение ключа текущей ФС static func _get_current_fs_key(litera: int, fs_keys_dic: Dictionary) -> String: return fs_keys_dic.get(str(litera), '') @@ -746,9 +848,32 @@ static func _get_dkm_bit_for_current_fs(litera: int, constants_dic: Dictionary) 6: return constants_dic.DKM_BIT_6 7: return constants_dic.DKM_BIT_7 _: return -1 +#endregion -## Итоговое заключение по результам контроля всех ИП +#region PUBLIC_API +## Геттер для текущего статуса +func get_current_status() -> String: + return current_status + + +## Геттер для результатов контроля +func get_control_results() -> Dictionary: + return { + 'control_is_over': flag_control_is_over, + 'result_dic': control_results, + 'power_dic': power_result, + 'block_kasseta_y5_config': block_kasseta_y5_config, + 'block_ip_config': block_ip_config, + 'temperature_um': temperature_um, + 'POWER_THRESHOLD': constants.POWER_THRESHOLD, + 'name_prd': self_name + } +#endregion + + +#region STATIC_UTILITY_METHODS +## Итоговое заключение по результатам контроля всех ИП static func on_control_result(ip_config: Dictionary, ctrl_results: Dictionary) -> Dictionary: var all_blocks_ip_ok = true for block in ip_config: @@ -770,18 +895,17 @@ static func on_ug_setting(prd_unit: Object, settings_ug: Dictionary, prd_cmd_arr return true +## Обработка чтения ISA портов static func _handle_read_isa(prd_unit: Object, read_isa_ports: Array, prd_cmd_array) -> void: prd_cmd_array.append([prd_unit.CmdCode.READ_ISA, read_isa_ports]) -## Управаление модулем фс (включить/отключить излучение) +## Управление модулем ФС (включить/отключить излучение) static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, litera: 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 = [] @@ -793,13 +917,12 @@ static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: params.width, sectors[litera - 1] if litera == 1 else sectors[litera - 5] if litera > 5 else sectors[litera - 4] if litera > 3 else sectors[litera - 2] ]) - #signaller.emit_signal('emit_changed', mode) TODO: не отключаю подавление (даже если при входе в контроль он был отключен) + signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um) -## Проверка касет П1 и ИП МА2000 +## Проверка кассет П1 и ИП МА2000 static func check_block_ip(status_prd: PackedByteArray, ip_config: Dictionary) -> Dictionary: - # Конфигурация проверяемых блоков var byte_dry: int = 27 var ug_valid: bool = (status_prd[0] >> 1) & 1 for block in ip_config: @@ -821,33 +944,36 @@ static func check_block_kasseta_y5(status_prd: PackedByteArray, y5_config: Dicti return y5_config -## Мониторинг температуры +## Мониторинг температуры УМ static func check_temperature_um(status_prd: PackedByteArray) -> Dictionary: - const Constants: Dictionary = { - 'CONST_MIN_TEMP': -25, - 'MAXIMUM_CODE_ADC': 3796, - 'MINIMUM_CODE_AD': 2660, - 'TEMPERATURE_UKP_1': 47, - 'TEMPERATURE_UKP_2': 79, - } - const arr_um: Array = ['um_1', 'um_2', 'um_3', 'um_4', 'um_5', 'um_6', 'um_7', 'um_8', 'um_9', 'um_10', 'um_11', 'um_12', 'um_13', 'um_14', 'um_15', 'um_16'] - const TEMP: float = 115.0 / (Constants.MAXIMUM_CODE_ADC - Constants.MINIMUM_CODE_AD) - var return_dic_temp: Dictionary - var ukp1_online: int = (status_prd[0] >> 2) & 1 - var ukp2_online = (status_prd[0] >> 3) & 1 - if ukp1_online: - var tmp_1: int - var temperature_ukp_1: int - for i_temp in 8: - 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) - return_dic_temp[arr_um[i_temp]] = tmp_1 - if ukp2_online: - for i_temp in 8: - 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) - return_dic_temp[arr_um[i_temp+8]] = tmp_2 - return return_dic_temp + const Constants: Dictionary = { + 'CONST_MIN_TEMP': -25, + 'MAXIMUM_CODE_ADC': 3796, + 'MINIMUM_CODE_AD': 2660, + 'TEMPERATURE_UKP_1': 47, + 'TEMPERATURE_UKP_2': 79, + } + const arr_um: Array = ['um_1', 'um_2', 'um_3', 'um_4', 'um_5', 'um_6', 'um_7', 'um_8', 'um_9', 'um_10', 'um_11', 'um_12', 'um_13', 'um_14', 'um_15', 'um_16'] + const TEMP: float = 115.0 / (Constants.MAXIMUM_CODE_ADC - Constants.MINIMUM_CODE_AD) + var return_dic_temp: Dictionary + var ukp1_online: int = (status_prd[0] >> 2) & 1 + var ukp2_online = (status_prd[0] >> 3) & 1 + + if ukp1_online: + var tmp_1: int + var temperature_ukp_1: int + for i_temp in 8: + 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) + return_dic_temp[arr_um[i_temp]] = tmp_1 + + if ukp2_online: + for i_temp in 8: + 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) + return_dic_temp[arr_um[i_temp+8]] = tmp_2 + + return return_dic_temp ## Проверка ДКМ @@ -857,7 +983,7 @@ static func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool: return status_dkm -## Распределения номеров ФС по пирборам +## Распределение номеров ФС по приборам static func _create_fs_mapping(s_name: String) -> Dictionary: var suffixes: Dictionary = { 0: '1к', 1: '4к', 2: '3к', 3: '2к', @@ -875,7 +1001,7 @@ static func _create_fs_mapping(s_name: String) -> Dictionary: return mapping -## Получения статуса ФС +## Получение статуса ФС static func on_fs_state(packet_type_7: Dictionary, fs_mapping: Dictionary, fs_results: Dictionary, fs_rules_config: Array) -> Dictionary: var updated_results := fs_results.duplicate() for fs_num in packet_type_7: @@ -904,42 +1030,35 @@ static func power_um_ukp(status: PackedByteArray, litera: int, pwr_result: Array match litera: 1: - # Обработка для current_fs = 1 (одно значение) var value = status.decode_u16(Constants.POWER_UKP_1 + 2 * 7) if ug_valid: power_values = [value] 2: - # Обработка для current_fs = 2 (6 значений из УКП1) base_offset = Constants.POWER_UKP_1 if ug_valid: for i in iteration: power_values.append(status.decode_u16(base_offset + 2 * i)) 3: - # Обработка для current_fs = 3 (6 значений из УКП2) base_offset = Constants.POWER_UKP_2 if ug_valid: for i in iteration: power_values.append(status.decode_u16(base_offset + 2 * i)) 4: - # Обработка для current_fs = 4 (6 значений из УКП1) base_offset = Constants.POWER_UKP_1 if ug_valid: for i in iteration: power_values.append(status.decode_u16(base_offset + 2 * i)) 5: - # Обработка для current_fs = 5 (6 значений из УКП2) base_offset = Constants.POWER_UKP_2 if ug_valid: for i in iteration: power_values.append(status.decode_u16(base_offset + 2 * i)) 6: - # Обработка для current_fs = 6 (6 значений из УКП1) base_offset = Constants.POWER_UKP_1 if ug_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 if ug_valid: for i in iteration: @@ -949,7 +1068,7 @@ static func power_um_ukp(status: PackedByteArray, litera: int, pwr_result: Array 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(): @@ -1022,6 +1141,7 @@ static func prep_power(power_dic: Dictionary, prd_name: String)-> Dictionary: return prep_pow_dic +## Проверка результатов ДОУ static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pribor: String, litera: int, cnst: Dictionary) -> Dictionary: var all_dou_ok = true var dou: String = 'dou_2' if litera == 2 else 'dou_3' @@ -1047,33 +1167,4 @@ static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pri control_dic[dou] = all_dou_ok return control_dic - - -# Сеттер для статуса -func _set_status(new_status: String) -> void: - if current_status != new_status: - current_status = new_status - call_deferred('emit_signal', 'status_updated', new_status) - - -# Геттер для текущего статуса (чтобы можно было забрать в любой момент) -func get_current_status() -> String: - return current_status - - -func _get_ray_name(ray_num: int) -> String: - return RAY_CONFIG.get(ray_num, {}).get("name", "неизвестный угол") - - -# Геттер для результатов контроля -func get_control_results() -> Dictionary: - return { - 'control_is_over': flag_control_is_over, - 'result_dic': control_results, - 'power_dic': power_result, - 'block_kasseta_y5_config': block_kasseta_y5_config, - 'block_ip_config': block_ip_config, - 'temperature_um': temperature_um, - 'POWER_THRESHOLD': constants.POWER_THRESHOLD, - 'name_prd': self_name - } +#endregion