maxim/uarep-ctl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: maxim:5eb44fd20a2db24488a28f15e8d194e0bba2919b
Branches Tags
maxim:master maxim:master-afsp maxim:prd-control maxim:MAD_CAT maxim:sasha
...
compare: maxim:0c8f02bc77d8ae4748a0464a36d86487d5a8d95f
Branches Tags
maxim:master maxim:master-afsp maxim:prd-control maxim:MAD_CAT maxim:sasha

2 Commits
5eb44fd20a ... 0c8f02bc77

Author SHA1 Message Date
TotMaxim
0c8f02bc77 Доработка интегрального контроля (в процессе) 2025-11-25 20:36:47 +03:00
TotMaxim
bfb9d3a4e8 Доработка работы с ecms в контроле + форматирование пробелов 2025-11-25 12:31:45 +03:00
13 changed files with 602 additions and 351 deletions
Expand all files Collapse all files

23
config/setting_prd_control.json
View File

@@ -30,7 +30,6 @@
"3": {"freq": 1157.0, "width": 100.0}
},
"start_litera": 2,
"progress_max": 20
},
"PRD_V": {
"constants": {
@@ -62,7 +61,6 @@
"5": {"freq": 1575.0, "width": 110.0}
},
"start_litera": 4,
"progress_max": 20
},
"PRD_K": {
"constants": {
@@ -97,7 +95,6 @@
"7": {"freq": 4750.0, "width": 110.0}
},
"start_litera": 1,
"progress_max": 30
}
},
"base_configs": {
@@ -122,28 +119,32 @@
"block_ip": "base",
"block_kasseta": "base",
"control_results": {
"block_kasseta":false,
"block_ip": false,
"temperature": true,
"dkm_2": false,
"dkm_3": false,
"dou_2": false,
"dou_3": false,
"fs_2": 0,
"fs_3": 0
"fs_2": false,
"fs_3": false,
"is_over_control": false,
}
},
"PRD_V": {
"block_ip": "base",
"block_kasseta": "base",
"control_results": {
"block_kasseta":false,
"block_ip": false,
"temperature": true,
"dkm_4": false,
"dkm_5": false,
"dou_4": false,
"dou_5": false,
"fs_4": 0,
"fs_5": 0
"fs_4": false,
"fs_5": false,
"is_over_control": false,
}
},
"PRD_K": {
@@ -159,6 +160,7 @@
},
"block_kasseta": "base",
"control_results": {
"block_kasseta":false,
"block_ip": false,
"temperature": true,
"dkm_1": false,
@@ -166,9 +168,10 @@
"dkm_7": false,
"dou_6": false,
"dou_7": false,
"fs_1": 0,
"fs_6": 0,
"fs_7": 0
"fs_1": false,
"fs_6": false,
"fs_7": false,
"is_over_control": false,
}
}
},

8
scenes/frame-ecm-list/scroll-ecm-list.gd
View File

@@ -119,9 +119,13 @@ func on_interfer_new(ecm, table_index):
$table.set_row_editable(i_row, false)
$table.set_node_user_data(0, i_row, ecm)
table_index[ecm.ispp] = i_row
$table.cleanup_invalid_selectors()
# Будем надеяться, что отложенные вызовы производятся в том же порядке
$table.call_deferred('clear_rows_selected')
$table.call_deferred('set_row_selected', i_row, true)
var selected_rows = []
$table.get_selected_rows(selected_rows)
for old_row in selected_rows:
$table.set_row_selected(old_row, false)
$table.set_row_selected(i_row, true)
if not interfer.auto_enabled:
signaller.emit_signal('interfer_selected', ecm)

2
scenes/frame-threats/scroll-threats.gd
View File

@@ -75,7 +75,7 @@ func on_threat_update(th, table_index: Dictionary):
elif th.emit_state == 2:
emit_txr.visible = true
emit_txr.self_modulate = Color.RED
## Обрабатывает сигнал [b]threat_lost[/b].

7
scenes/pribor-prd-k/pribor-prd-k.gd
View File

@@ -44,6 +44,7 @@ func _on_start_control() -> void:
set_default_state(get_tree().get_nodes_in_group('default_reset'))
set_default_state(get_tree().get_nodes_in_group('power_amplifier'))
find_labels(self)
await get_tree().create_timer(1.0).timeout
on_press_device(unit_prd_k.self_name)
@@ -98,7 +99,7 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi
if i_p >= 1:
all_below_one = false
break
if all_below_one:
status = STATE_VAL.NONE
else:
@@ -164,7 +165,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
if power_supply.state == STATE_VAL.ERROR:
all_y5_good = false
if not for_result_dic.control_is_over:
if not for_result_dic.control_is_over:
set_default_state(for_result_dic.default_reset_array_node)
set_default_state(for_result_dic.power_amplifier)
return
@@ -185,7 +186,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
if result_dic.fs_7 == 1 and block_kasseta_y5_prd_config_k['yau07']:
for_result_dic.module_fs_7.state = STATE_VAL.GOOD if result_dic.dkm_7 else STATE_VAL.ERROR
for_result_dic.dou_7.state = STATE_VAL.GOOD if result_dic.dou_7 else STATE_VAL.ERROR
if block_kasseta_y5_prd_config_k['yau07']:
power_fill(for_result_dic.power_dic, for_result_dic.result_dic, for_result_dic.power_amplifier, for_result_dic.POWER_THRESHOLD)

15
scenes/pribor-prd-n/pribor-prd-n.gd
View File

@@ -44,6 +44,7 @@ func _on_start_control() -> void:
for um in get_tree().get_nodes_in_group('power_amplifier'):
um.value0 = [0, 0, 0, 0, 0, 0]
find_labels(self)
await get_tree().create_timer(1.0).timeout
on_press_device(unit_prd_n.self_name)
@@ -87,16 +88,16 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi
if i_p >= 1:
all_below_one = false
break
if all_below_one:
i_node_powapm.state = STATE_VAL.NONE
continue
var count_above_threshold = 0
for i_p in pow_dic[powamp_meta]:
if i_p >= POWER_THRESHOLD:
count_above_threshold += 1
status = STATE_VAL.GOOD if count_above_threshold >= 3 else STATE_VAL.ERROR
i_node_powapm.state = status
@@ -142,7 +143,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
# Проверяем состояние после установки
if node_y5.state == STATE_VAL.ERROR:
all_y5_good = false
var block_ip_config_n: Dictionary = for_result_dic.block_ip_config
for power_supply in for_result_dic.node_ip_power_arr:
var meta_ip = power_supply.get_meta('ip')
@@ -153,8 +154,8 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
# Проверяем состояние после установки
if power_supply.state == STATE_VAL.ERROR:
all_y5_good = false
if not for_result_dic.control_is_over:
if not for_result_dic.control_is_over:
set_default_state(for_result_dic.default_reset_array_node)
set_default_state(for_result_dic.power_amplifier)
return
@@ -172,7 +173,7 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
if result_dic.fs_3 == 1 and block_kasseta_y5_prd_config_n['yau07']:
for_result_dic.module_fs_3.state = STATE_VAL.GOOD if result_dic.dkm_3 else STATE_VAL.ERROR
for_result_dic.dou_3.state = STATE_VAL.GOOD if result_dic.dou_3 else STATE_VAL.ERROR
if block_kasseta_y5_prd_config_n['yau07']:
power_fill(for_result_dic.power_dic, for_result_dic.result_dic, for_result_dic.power_amplifier, for_result_dic.POWER_THRESHOLD)

16
scenes/pribor-prd-v/pribor-prd-v.gd
View File

@@ -44,6 +44,7 @@ func _on_start_control() -> void:
for um in get_tree().get_nodes_in_group('power_amplifier'):
um.value0 = [0, 0, 0, 0, 0, 0]
find_labels(self)
await get_tree().create_timer(1.0).timeout
on_press_device(unit_prd_v.self_name)
@@ -62,11 +63,10 @@ func _enter_tree() -> void:
func _exit_tree() -> void:
if Engine.is_editor_hint():
return
#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]])
static func temperature_fill(temperature_arr_node: Array, temperature_dic: Dictionary)->void:
for i_node_temperature in temperature_arr_node:
for i_node_temperature in temperature_arr_node:
var temperature_meta: String = i_node_temperature.get_meta('um')
if not temperature_dic.has(temperature_meta): return
i_node_temperature.value1 = temperature_dic[temperature_meta] if temperature_dic[temperature_meta] < 361 else -40
@@ -87,7 +87,7 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi
if i_p >= 1:
all_below_one = false
break
if all_below_one:
i_node_powapm.state = STATE_VAL.NONE
continue
@@ -95,7 +95,7 @@ static func power_fill(pow_dic: Dictionary, fs_result: Dictionary, power_amplifi
for i_p in pow_dic[powamp_meta]:
if i_p >= POWER_THRESHOLD:
count_above_threshold += 1
status = STATE_VAL.GOOD if count_above_threshold >= 3 else STATE_VAL.ERROR
i_node_powapm.state = status
@@ -138,7 +138,6 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
node_y5.state = STATE_VAL.ERROR if meta_y5 == 'yau07' else STATE_VAL.NONE
else:
node_y5.state = STATE_VAL.GOOD if block_kasseta_y5_prd_config_v[meta_y5] else STATE_VAL.ERROR
# Проверяем состояние после установки
if node_y5.state == STATE_VAL.ERROR:
all_y5_good = false
@@ -149,11 +148,10 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
power_supply.state = STATE_VAL.GOOD if block_ip_config_v[meta_ip][1] else STATE_VAL.ERROR
else:
power_supply.state = STATE_VAL.NONE
# Проверяем состояние после установки
if power_supply.state == STATE_VAL.ERROR:
all_y5_good = false
if not for_result_dic.control_is_over:
if not for_result_dic.control_is_over:
set_default_state(for_result_dic.default_reset_array_node)
set_default_state(for_result_dic.power_amplifier)
return
@@ -167,11 +165,11 @@ static func on_control_result(for_result_dic: Dictionary) -> void:
if result_dic.fs_5 == 1 and block_kasseta_y5_prd_config_v['yau07']:
for_result_dic.module_fs_5.state = STATE_VAL.GOOD if result_dic.dkm_5 else STATE_VAL.ERROR
for_result_dic.dou_5.state = STATE_VAL.GOOD if result_dic.dou_5 else STATE_VAL.ERROR
if result_dic.fs_4 == 1 and block_kasseta_y5_prd_config_v['yau07']:
for_result_dic.module_fs_4.state = STATE_VAL.GOOD if result_dic.dkm_4 else STATE_VAL.ERROR
for_result_dic.dou_4.state = STATE_VAL.GOOD if result_dic.dou_4 else STATE_VAL.ERROR
if block_kasseta_y5_prd_config_v['yau07']:
power_fill(for_result_dic.power_dic, for_result_dic.result_dic, for_result_dic.power_amplifier, for_result_dic.POWER_THRESHOLD)

2
scenes/pribor-uf/pribor-uf.gd
View File

@@ -20,9 +20,9 @@ func _ready() -> void:
func on_timer(unit_name: StringName):
var unit_uf = network.get_unit_instance(unit_name)
status_uf() # отслеживание состояния прибора
if unit_uf.online: # проверка ЯУ, внутреннего коммутатора и ИП-5Б
control_ems(unit_uf.status) # проверка ЭМС ячеек
status_uf() # отслеживание состояния прибора
func on_line_changed(unit_uf):

234
scenes/tabs-switch/lbl_ready.gd
View File

@@ -1,48 +1,208 @@
extends Label
# Используем более понятные имена переменных
const STATUS_GOOD := {"text": "Исправно", "color": Color.GREEN, "font_color": Color.BLACK}
const STATUS_BAD := {"text": "Отказ", "color": Color.RED, "font_color": Color.WHITE}
var _is_uf_status_initialized: bool = false
var is_prd_operational: bool = true
var is_uf_operational: bool = true
enum PRD_STATE {
NONE, # Нет связи
GOOD, # Исправно
ERR # Отказ
}
enum DEVICE_STATUS {
ONLINE, # Связь есть
STATUS, # Статус исправности
CONTROL # Контроль завершен
}
const STATUS_CONFIG := {
PRD_STATE.NONE: {"text": "Нет связи", "color": Color.WHITE, "font_color": Color.BLACK},
PRD_STATE.GOOD: {"text": "Исправно", "color": Color.GREEN, "font_color": Color.BLACK},
PRD_STATE.ERR: {"text": "Отказ", "color": Color.RED, "font_color": Color.WHITE}
}
class DeviceObserver:
var device_name: String
var status: Array = [false, false, false] # [online, operational, control_complete]
var last_results: Dictionary = {}
func update_online_state(online: bool) -> bool:
if status[DEVICE_STATUS.ONLINE] != online:
status[DEVICE_STATUS.ONLINE] = online
return true
return false
func update_control_results(results: Dictionary) -> bool:
var changed := false
last_results = results.duplicate()
if results.get('is_over_control', false):
# Контроль завершен - проверяем все результаты
var all_ok := true
for key in results:
if key != 'is_over_control' and not results[key]:
all_ok = false
break
if status[DEVICE_STATUS.STATUS] != all_ok or status[DEVICE_STATUS.CONTROL] != true:
status[DEVICE_STATUS.STATUS] = all_ok
status[DEVICE_STATUS.CONTROL] = true
changed = true
else:
# Контроль в процессе - проверяем базовые параметры
var basic_ok: bool = results.get('block_kasseta', false) and \
results.get('block_ip', false) and \
results.get('temperature', true)
if status[DEVICE_STATUS.STATUS] != basic_ok or status[DEVICE_STATUS.CONTROL] != false:
status[DEVICE_STATUS.STATUS] = basic_ok
status[DEVICE_STATUS.CONTROL] = false
changed = true
return changed
var device_observers: Dictionary = {}
var overall_prd_state: PRD_STATE = PRD_STATE.NONE
func _ready() -> void:
tooltip_text = 'Нет связи с приборами комплекса'
for prd_module in prd.prd_dict.values():
prd_module.connect('update_serviceability', Callable(self, 'on_serviceability_changed').bind(prd_module))
var unit_uf: = network.get_unit_instance('уарэп-эмс')
unit_uf.connect('data_received', Callable(self, 'on_uf_status_receive'))
add_theme_color_override("font_color", Color.BLACK)
func on_serviceability_changed(unit_prd_module: Object) -> void:
var check_service: bool = true
# Инициализация наблюдателей
_initialize_observers()
# Подписка на сигналы ПРД модулей
for prd_module in prd.prd_dict.values():
if prd_module.unit_yau07.online:
if not unit_prd_module.serviceability:
check_service = false
if check_service != is_prd_operational:
is_prd_operational = check_service
_update_serviceability_display()
# Подключаемся к контролю ПРД
if prd_module.unit_control:
prd_module.unit_control.connect('control_results_updated', Callable(self, '_on_prd_control_results').bind(prd_module))
# Подключаемся к онлайн-статусу ЯУ-07
if prd_module.unit_yau07:
prd_module.unit_yau07.connect('line_changed', Callable(self, '_on_prd_online_changed').bind(prd_module))
# Подписка на УФ
var unit_uf = network.get_unit_instance('уарэп-эмс')
if unit_uf:
unit_uf.data_received.connect(Callable(self, '_on_uf_status_receive'))
# Инициализация начального состояния
_recalculate_overall_state()
func _update_serviceability_display() -> void:
var status := STATUS_GOOD if (is_uf_operational and is_prd_operational) else STATUS_BAD
text = status.text
modulate = status.color
tooltip_text = 'Результаты обобщенного признака работоспособности изделия'
add_theme_color_override("font_color", status.font_color)
func _initialize_observers() -> void:
var device_names := [
'уарэп-яу07-1н', 'уарэп-яу07-1в', 'уарэп-яу07-1к',
'уарэп-яу07-2н', 'уарэп-яу07-2в', 'уарэп-яу07-2к',
'уарэп-яу07-3н', 'уарэп-яу07-3в', 'уарэп-яу07-3к',
'уарэп-яу07-4н', 'уарэп-яу07-4в', 'уарэп-яу07-4к'
]
for device_name in device_names:
device_observers[device_name] = DeviceObserver.new()
device_observers[device_name].device_name = device_name
func on_uf_status_receive(unit_uf: Object) -> void:
var KEMS_B = ((unit_uf.status[0] >> 0) & 1) and ((unit_uf.status[0] >> 3) & 1)
var EMS_B_1 = ((unit_uf.status[0] >> 1) & 1) and ((unit_uf.status[0] >> 4) & 1)
var EMS_B_2 = ((unit_uf.status[0] >> 2) & 1) and ((unit_uf.status[0] >> 5) & 1)
var IP27B = ((unit_uf.status[2] >> 6) & 1)
var check_service: bool = KEMS_B and EMS_B_1 and EMS_B_2 and IP27B
if not _is_uf_status_initialized or check_service != is_uf_operational:
is_uf_operational = check_service
_update_serviceability_display()
signaller.emit_signal('update_uf_serviceability', check_service)
_is_uf_status_initialized = true
func _on_prd_online_changed(line_status: Object, prd_module: Object) -> void:
var online: bool = line_status.online
var observer: DeviceObserver = device_observers.get(prd_module.prd_name)
if observer and observer.update_online_state(online):
_recalculate_overall_state()
func _on_prd_control_results(results: Dictionary, prd_module: Object) -> void:
var observer: DeviceObserver = device_observers.get(prd_module.prd_name)
if observer and observer.update_control_results(results):
_recalculate_overall_state()
func _on_uf_status_receive(_unit_uf: Object) -> void:
# Логика для УФ (раскомментируй если нужно)
# var KEMS_B = ((unit_uf.status[0] >> 0) & 1) and ((unit_uf.status[0] >> 3) & 1)
# var EMS_B_1 = ((unit_uf.status[0] >> 1) & 1) and ((unit_uf.status[0] >> 4) & 1)
# var EMS_B_2 = ((unit_uf.status[0] >> 2) & 1) and ((unit_uf.status[0] >> 5) & 1)
# var IP27B = ((unit_uf.status[2] >> 6) & 1)
# var uf_operational = KEMS_B and EMS_B_1 and EMS_B_2 and IP27B
# signaller.emit_signal('update_uf_serviceability', uf_operational)
pass
func _recalculate_overall_state() -> void:
var new_state := PRD_STATE.NONE
var has_online_devices := false
var all_operational := true
for observer in device_observers.values():
if observer.status[DEVICE_STATUS.ONLINE]:
has_online_devices = true
if observer.status[DEVICE_STATUS.CONTROL]:
# Если контроль завершен - строгая проверка
if not observer.status[DEVICE_STATUS.STATUS]:
all_operational = false
break
else:
# Если контроль в процессе - мягкая проверка
if not observer.status[DEVICE_STATUS.STATUS]:
all_operational = false
# Не прерываем, чтобы проверить все устройства
if has_online_devices:
new_state = PRD_STATE.GOOD if all_operational else PRD_STATE.ERR
else:
new_state = PRD_STATE.NONE
if overall_prd_state != new_state:
overall_prd_state = new_state
_update_display()
func _update_display() -> void:
var config: Dictionary = STATUS_CONFIG[overall_prd_state].duplicate()
text = config.text
modulate = config.color
add_theme_color_override("font_color", config.font_color)
tooltip_text = _get_tooltip_text()
func _get_tooltip_text() -> String:
match overall_prd_state:
PRD_STATE.NONE:
return "Нет связи с приборами комплекса"
PRD_STATE.GOOD:
return "Все приборы комплекса исправны"
PRD_STATE.ERR:
return "Обнаружены неисправности в комплексе"
_:
return "Неизвестное состояние"
# Публичные методы для получения информации
func get_device_status(device_name: String) -> Dictionary:
var observer: DeviceObserver = device_observers.get(device_name)
if observer:
return {
"online": observer.status[DEVICE_STATUS.ONLINE],
"operational": observer.status[DEVICE_STATUS.STATUS],
"control_complete": observer.status[DEVICE_STATUS.CONTROL],
"last_results": observer.last_results.duplicate()
}
return {}
func get_overall_status() -> Dictionary:
var online_count := 0
var operational_count := 0
var control_complete_count := 0
for observer in device_observers.values():
if observer.status[DEVICE_STATUS.ONLINE]:
online_count += 1
if observer.status[DEVICE_STATUS.STATUS]:
operational_count += 1
if observer.status[DEVICE_STATUS.CONTROL]:
control_complete_count += 1
return {
"overall_state": overall_prd_state,
"online_devices": online_count,
"operational_devices": operational_count,
"total_devices": device_observers.size(),
"control_complete_devices": control_complete_count
}

82
scenes/контроль/контроль.tscn
View File

@@ -67,6 +67,8 @@ func on_serv_changed(u, pribor_node, _pribor_meta): pribor_node.state = int(u.se
func on_mode_changed():
clean_pribor_items()
reset_pribor_buttons()
$chk_show_functional.visible = false
$chk_show_functional.button_pressed = false
func reset_pribor_buttons():
@@ -99,7 +101,7 @@ func _ready():
for item in unit_names:
if prd.prd_dict.has(item):
var prd_module = prd.prd_dict[item]
prd_module.connect('update_serviceability', Callable(self, 'on_serviceability_changed').bind(prd_module, pribor_node))
prd_module.connect('update_serviceability', Callable(self, 'on_serviceability_changed').bind(pribor_node))
prd_module.unit_control.connect('update_progress', Callable(self, 'on_update_progress').bind(pribor_node))
prd_module.unit_control.connect('update_max_value_progress', Callable(self, 'on_update_max_value_progress').bind(pribor_node))
prd_module.unit_control.connect('control_is_over', Callable(self, 'on_control_is_over'))
@@ -139,7 +141,7 @@ func clean_pribor_items():
func on_pribor_press(pribor_path, header_text, pribor_node):
if cur_pribor_node:
cur_pribor_node.show_functional = false
$lbl_header/chk_show_functional.button_pressed = false
$chk_show_functional.button_pressed = false
cur_pribor_node = pribor_node
clean_pribor_items()
var pribor_obj = load(pribor_path)
@@ -151,6 +153,7 @@ func on_pribor_press(pribor_path, header_text, pribor_node):
push_error('экземпляр не создан: \\\"%s\\\" (%s)' % [pribor_path, header_text])
return
$lbl_header.text = header_text
$chk_show_functional.visible = true
var meta_list = pribor_node.get_meta_list()
if meta_list.find('unit_name') > -1:
var unit_name = pribor_node.get_meta('unit_name')
@@ -160,37 +163,9 @@ func on_pribor_press(pribor_path, header_text, pribor_node):
update_pribor_items_visibility()
enum STATE_DEVICE {
NONE,
GOOD,
ERROR
}
func on_serviceability_changed(prd_module: Object, prd_pribor:Node)-> void:
if not prd_module.unit_yau07.online:
prd_pribor.state = STATE_DEVICE.NONE
return
print([prd_pribor.get_meta('unit_name'), prd_module.unit_control.current_status])
if prd_module.unit_control.flag_control_is_over:
var control_results = prd_module.unit_control.get_control_results()
var result_dic = control_results.result_dic
# Проверяем только основные устройства
var critical_devices = ['fs_1', 'fs_2', 'fs_3', 'fs_4', 'fs_5', 'fs_6', 'fs_7',
'dkm_1', 'dkm_2', 'dkm_3', 'dkm_4', 'dkm_5', 'dkm_6', 'dkm_7',
'block_ip', 'dou_2', 'dou_3', 'dou_4', 'dou_5', 'dou_6', 'dou_7']
# Проверяем результаты контроля напрямую
var all_ok: bool = true
for device_key in critical_devices:
if result_dic.has(device_key) and result_dic[device_key] is bool:
if not result_dic[device_key]:
all_ok = false
break
prd_pribor.state = STATE_DEVICE.GOOD if all_ok else STATE_DEVICE.ERROR
elif not prd_module.serviceability:
prd_pribor.state = STATE_DEVICE.ERROR
else:
prd_pribor.state = STATE_DEVICE.NONE
## Прием сигналов о текущем состояниях приборах
func on_serviceability_changed(state: int, prd_pribor_node: Node)-> void:
prd_pribor_node.state = state
func on_update_uf_serviceability(uf_serviceaability: bool, uf_pribor: Node)-> void:
@@ -205,7 +180,7 @@ func _on_chk_show_functional_toggled(toggled_on: bool) -> void:
func _on_control_prd_pressed() -> void:
check_ready_control = {}
for pribor in get_tree().get_nodes_in_group('pribor_buttons'):
pribor.state = STATE_DEVICE.NONE
pribor.state = 0 # NONE
signaller.emit_signal('start_contol_device')
@@ -240,10 +215,18 @@ func _is_all_control_complete() -> bool:
return true
# TODO: Решить что делать с подключением
func _on_gui_input(_event: InputEvent) -> void:
pass
#print_debug('Увидел подключение, но не нашел куда сигнал подключается')
func _on_gui_input(event: InputEvent) -> void:
if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
if cur_pribor_node:
cur_pribor_node.show_functional = false
var pribor_buttons := get_tree().get_nodes_in_group('pribor_buttons')
for node in pribor_buttons:
node.button_pressed = false
clean_pribor_items()
cur_pribor_node = null
$chk_show_functional.button_pressed = false
$chk_show_functional.visible = false
$lbl_header.text = \"\"
func on_control_button_pressed(state: bool) -> void:
@@ -509,6 +492,7 @@ patch_margin_right = 16
patch_margin_bottom = 16
[node name="connect_pribor" type="AnimatedSprite2D" parent="pribor_prd_n_1"]
visible = false
light_mask = 3
position = Vector2(35, -10)
scale = Vector2(0.625, 0.625)
@@ -551,6 +535,14 @@ offset_bottom = 830.0
scale = Vector2(0.97094, 0.97094)
texture = ExtResource("9_qe1go")
[node name="connect_pribor2" type="AnimatedSprite2D" parent="pribor_prd_n_1"]
light_mask = 3
position = Vector2(35, -10)
scale = Vector2(0.625, 0.625)
sprite_frames = SubResource("SpriteFrames_foasq")
frame_progress = 0.72355
script = ExtResource("11_u7tym")
[node name="pribor_uf" type="TextureButton" parent="." groups=["pribor_buttons"]]
editor_description = "Кнопка для выбора прибора."
layout_mode = 0
@@ -1044,6 +1036,7 @@ patch_margin_right = 16
patch_margin_bottom = 16
[node name="connect_pribor" type="AnimatedSprite2D" parent="pribor_prd_n_2"]
visible = false
light_mask = 3
position = Vector2(37, -10)
scale = Vector2(0.625, 0.625)
@@ -1934,12 +1927,13 @@ text = "Контроль исправности прибора"
horizontal_alignment = 1
vertical_alignment = 1
[node name="chk_show_functional" type="CheckButton" parent="lbl_header"]
[node name="chk_show_functional" type="CheckButton" parent="."]
visible = false
layout_mode = 0
offset_left = 940.0
offset_top = -1.0
offset_right = 1319.0
offset_bottom = 33.0
offset_left = 1028.0
offset_top = 26.0
offset_right = 1407.0
offset_bottom = 60.0
theme_override_font_sizes/font_size = 22
text = "Показть функциональную схему Э2"
flat = true
@@ -2037,5 +2031,5 @@ texture = ExtResource("22_1s34a")
[connection signal="toggled" from="pribor_prd_v_4" to="pribor_prd_v_4" method="_on_toggled"]
[connection signal="toggled" from="pribor_prd_n_4" to="pribor_prd_n_4" method="_on_toggled"]
[connection signal="toggled" from="pribor_prd_k_4" to="pribor_prd_k_4" method="_on_toggled"]
[connection signal="toggled" from="lbl_header/chk_show_functional" to="." method="_on_chk_show_functional_toggled"]
[connection signal="toggled" from="chk_show_functional" to="." method="_on_chk_show_functional_toggled"]
[connection signal="pressed" from="control_prd_button" to="." method="_on_control_prd_pressed"]

14
scripts/prd-ctl-config.gd
View File

@@ -78,15 +78,15 @@ func get_data_index(key: String) -> int:
#region PRIVATE_METHODS
## Загружает конфигурацию из JSON файла
func _load_configuration() -> void:
if not _ensure_config_exists():
if not _ensure_config_exists():
_is_loaded = false
return
var config_file = FileAccess.open(CONFIG_PATH, FileAccess.READ)
if config_file:
var json_text = config_file.get_as_text()
config_file.close()
var json = JSON.new()
var parse_result = json.parse(json_text)
if parse_result == OK:
@@ -139,21 +139,21 @@ static func _convert_numbers(value):
func _ensure_config_exists() -> bool:
# Создаем папку конфигурации если не существует
DirAccess.make_dir_recursive_absolute("user://config")
# Если файл уже существует - все ок
if FileAccess.file_exists(CONFIG_PATH):
return true
# Если дефолтного файла нет - ошибка
if not FileAccess.file_exists(DEFAULT_CONFIG_PATH):
return false
# Копируем дефолтный конфиг в user директорию
var src := FileAccess.open(DEFAULT_CONFIG_PATH, FileAccess.READ)
var dst := FileAccess.open(CONFIG_PATH, FileAccess.WRITE)
if src == null or dst == null:
return false
dst.store_string(src.get_as_text())
src.close()
dst.close()

108
scripts/prd.gd
View File

@@ -151,17 +151,26 @@ class Fs:
class PRD:
enum STATE_DEVICE {
NONE,
GOOD,
ERROR
}
var prd_name: String ## Имя прибора
var unit_yau07 ## Юнит эмс
var unit_yau07: Object ## Юнит эмс
var unit_control: Object ## Класс проверки прибора ПРД
var fs_dic: Dictionary ## Массив блоков ФС
var yemsg_board: yemsboards.EmsBoard ## Плата ЭМС-Г
var state = PrdState.WORK
var cmd_array: Array ## Очередь команд
var ug_online: bool = false ## Состояние ячейки УГ
var serviceability: bool = false
var set_ug_state: bool = true ## Необходимо ли записать в УГ настройки
signal update_serviceability()
signal update_serviceability(state: int) ## Сообщает изменение текущего состояния юнита ПРД
var serviceability: int:
set(v):
if v != serviceability:
serviceability = v
emit_signal('update_serviceability', v)
func _init(u_name, u_yau07):
prd_name = u_name
@@ -201,11 +210,11 @@ class PRD:
func on_line_changed(unit_ems):
emit_signal('update_serviceability')
if not unit_ems.online:
yemsg_board.ems_load = yemsg_board.LoadState.NOT_DEFINED
yemsg_board.set_wait()
set_ug_state = true
serviceability = STATE_DEVICE.NONE
func on_data_received(_u):
set_prd_status()
@@ -222,33 +231,79 @@ class PRD:
execute_cmd()
return
execute_cmd()
func set_prd_status():
## Мониторинг состояния юнита прд
func set_prd_status() -> void:
# Обновление статуса платы ЯУ-07
yemsg_board.set_status(unit_yau07.status)
# Проверка онлайн-статусов основных модулей
ug_online = (unit_yau07.status[0] >> 1) & 1
if not ug_online:
set_ug_state = true
var ukp_1_online = (unit_yau07.status[0] >> 2) & 1
var ukp_2_online = (unit_yau07.status[0] >> 3) & 1
var ems_g_online = (unit_yau07.status[0] & 1) & 1
var bit_ip_config: Array = [0, 1, 2, 3, 4, 5, 6, 7]
var ip_online: bool = true
var is_k_type: bool = prd_name in ['уарэп-яу07-1к', 'уарэп-яу07-2к', 'уарэп-яу07-3к', 'уарэп-яу07-4к']
var ems_g_online = (unit_yau07.status[0] & 1) & 1
# Установка флага состояния УГ
if not ug_online:
set_ug_state = true
# Проверка источников питания
var ip_online: bool = _check_dry_contact(unit_yau07.status, prd_name)
var check_temperature_um: bool = unit_control.flags.temperature_ok
var check_dic: Dictionary = {
'ukp_1_online': ukp_1_online,
'ukp_2_online': ukp_2_online,
'ems_g_online': ems_g_online,
'ip_online': ip_online,
'ug_online': ug_online,
'temperature_um': check_temperature_um
}
# Определение состояния обслуживания
if unit_control:
if unit_control.flags.control_is_over:
serviceability = _set_serviceability_from_control_results(unit_control)
else:
serviceability = _set_serviceability_from_online_status(check_dic)
## Проверка онлайн-статуса сухих контактов
static func _check_dry_contact(unit_yau07_status: PackedByteArray, self_name: String) -> bool:
var bit_ip_config: Array = [0, 1, 2, 3, 4, 5, 6, 7]
var is_k_type: bool = self_name in ['уарэп-яу07-1к', 'уарэп-яу07-2к', 'уарэп-яу07-3к', 'уарэп-яу07-4к']
for bit in bit_ip_config:
var status: bool = unit_yau07.status[27] >> bit & 1
# Игнорируем биты 5 и 6 для всех приборов, кроме типа "к"
if not is_k_type and (bit == 5 or bit == 6):
if not is_k_type and bit in [5, 6]: # Игнорируем биты 5 и 6 для всех приборов, кроме типа "к"
continue
var status: bool = unit_yau07_status[27] >> bit & 1
if status:
ip_online = false
return false
return true
## Установка состояния обслуживания на основе результатов контроля
static func _set_serviceability_from_control_results(unit_ctrl: Object) -> int:
var control_results = unit_ctrl.get_control_results()
var result_dic = control_results.result_dic
const CRITICAL_DEVICES: Array = [
'fs_1', 'fs_2', 'fs_3', 'fs_4', 'fs_5', 'fs_6', 'fs_7',
'dkm_1', 'dkm_2', 'dkm_3', 'dkm_4', 'dkm_5', 'dkm_6', 'dkm_7',
'block_ip', 'dou_2', 'dou_3', 'dou_4', 'dou_5', 'dou_6', 'dou_7'
]
var all_ok: bool = true
for device_key in CRITICAL_DEVICES:
if result_dic.has(device_key) and result_dic[device_key] is bool:
if not result_dic[device_key]:
all_ok = false
break
return STATE_DEVICE.GOOD if all_ok else STATE_DEVICE.ERROR
## Установка состояния обслуживания на основе онлайн-статусов
static func _set_serviceability_from_online_status(check_dic: Dictionary) -> int:
var all_online: bool = true
for status in check_dic:
if not check_dic[status]:
all_online = false
break
var check_serviceability = ug_online and ukp_1_online and ukp_2_online and ems_g_online and ip_online
if serviceability != check_serviceability:
serviceability = check_serviceability
emit_signal('update_serviceability')
return STATE_DEVICE.NONE if all_online else STATE_DEVICE.ERROR
func execute_cmd():
if not len(cmd_array): return
if unit_yau07.cmd_state != unit_yau07.CmdState.DONE: return
@@ -289,9 +344,7 @@ class PRD:
func set_um(data_arr):
cmd_array.append([unit_yau07.CmdCode.WRITE_ISA, data_arr])
func _on_control_completed(_unit_control_name: String)->void:
emit_signal('update_serviceability')
func _ready() -> void:
@@ -303,14 +356,13 @@ func _ready() -> void:
var unit_control = TestPRD.new({'unit_prd': unit_prd}, new_prd.cmd_array)
add_child(unit_control)
new_prd.unit_control = unit_control
unit_control.control_is_over.connect(new_prd._on_control_completed) # Прямая подписка на метод new_prd
for key in FS_PRD.keys():
var fs = Fs.new(key, FS_PRD[key][0])
fs_dict[key] = fs
if prd_dict.has(fs.prd_name):
prd_dict[fs.prd_name].fs_dic[key] = fs
fs.connect('update_modulation', prd_dict[fs.prd_name].on_update_modulation.bind(fs.index))
for key in FS_PRD.keys():
fs_caps_id[FS_PRD[key][1]] = key
var unit_caps = network.get_unit_instance('уарэп-капсрпб')

430
scripts/pribor-prd.gd
View File

@@ -17,7 +17,7 @@ const PROGRESS_COMPLETE: float = 100.0
const RAY_MASK = 0x07
const SPECIAL_LITERAS = [3, 5, 7]
const RAY_m5: String = 'RAY_m5'
const RAY_5: String = 'RAY_5'
const RAY_5: String = 'RAY_5'
const RAY_15: String = 'RAY_15'
const RAY_25: String = 'RAY_25'
const RAY_35: String = 'RAY_35'
@@ -33,7 +33,21 @@ const RAY_CONFIG = {
5: { 'state': 'UG_SET_RAY_5', 'name': '45°'},
6: { 'state': 'UG_SET_RAY_0', 'name': 'Контроль'} # ДКМ
}
# Таблица соответствий: device_name -> (current_lit -> nmfs в ecms)
const LITER_TO_NMFS: Dictionary = {
'1к': {1: 11, 6: 16, 7: 17},
'2к': {1: 21, 6: 26, 7: 27},
'3к': {1: 31, 6: 36, 7: 37},
'4к': {1: 41, 6: 46, 7: 47},
'1н': {2: 12, 3: 13},
'2н': {2: 22, 3: 23},
'3н': {2: 32, 3: 33},
'4н': {2: 42, 3: 43},
'1в': {4: 14, 5: 15},
'2в': {4: 24, 5: 25},
'3в': {4: 34, 5: 35},
'4в': {4: 44, 5: 45}
}
const RAY_TYPES := [RAY_m5, RAY_5, RAY_15, RAY_25, RAY_35, RAY_45]
const DATA_EXIT_CONTOL_ISA: int = 0
@@ -91,31 +105,35 @@ var _fs_rules: Array
## Основные переменные класса
var config_manager: PRDConfigManager
var unit_prd: Object
var control_results: Dictionary
var power_result: Dictionary
var constants: Dictionary
var pribor_config: Dictionary
var fs_parameters: Dictionary
var block_ip_config: Dictionary
var block_kasseta_y5_config: Dictionary
var temperature_um: Dictionary
var control_results: Dictionary
var power_result: Dictionary
var ecms: Dictionary
var power_for_litera: Dictionary
var self_name: String
var state: int = STATE_MACHINE.INIT
var current_litera: int
var count_packets_power: int = 0
var current_ecm_key: int
## Флаги состояния системы
var flag_write_isa: bool = false
var flag_fs_status_ok: bool = false
var flag_si_fs_input: bool = false
var flag_si_fs_output: bool = false
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 flag_temperature_ok: bool = true
var flags: Dictionary = {
'write_isa': false,
'fs_status_ok': false,
'si_fs_input': false,
'si_fs_output': false,
'in_control': false,
'control_is_over': false,
'no_trust_yau07': false,
'only_fs': false,
'ecm_is_comming': false,
'temperature_ok': true,
}
## Таймеры контроля
var control_timer: Timer = Timer.new()
@@ -134,9 +152,10 @@ var current_fs_progress: float = 0.0
var current_status: String = 'Ожидание запуска контроля'
## Сигналы класса
signal control_is_over(device_name: String) # Когда контроль завершен
signal status_updated(status_text: String) # Сигнал для обновления статуса
signal update_progress(progress_value: float) # Обновление статуса выполнения контроля
signal control_is_over(device_name: String) # Когда контроль завершен
signal status_updated(status_text: String) # Сигнал для обновления статуса
signal control_results_updated(control_results: Dictionary) # Обновление результатов контроля
signal update_progress(progress_value: float) # Обновление статуса выполнения контроля
signal update_max_value_progress(max_progress_value: int) # Установка максимального значения для прогресс бара
## Свойство прогресса с автоматическим emit сигнала
@@ -163,42 +182,36 @@ func _init(init_data: Dictionary, cmd_array_from_prd: Array) -> void:
func _initialize_default_states() -> void:
_default_states = {
# Флаги состояния системы
'flag_write_isa': flag_write_isa,
'flag_fs_status_ok': flag_fs_status_ok,
'flag_si_fs_input': flag_si_fs_input,
'flag_si_fs_output': flag_si_fs_output,
'flag_control_is_over': flag_control_is_over,
'flag_no_trust_yau07': flag_no_trust_yau07,
'flag_only_fs': flag_only_fs,
'flags': flags.duplicate(true),
# Состояние машины и литеры
'state': state,
'current_litera': current_litera,
# Переменные прогресса
'progress_value': progress_value,
'current_status': current_status,
'total_fs_to_check': total_fs_to_check,
'completed_fs_count': completed_fs_count,
'current_fs_progress': current_fs_progress,
# Счетчики
'cc': cc,
# Сокеты ЭМС-Г
'ems_g_sock_dic': ems_g_sock_dic.duplicate(true),
# Структуры данных (глубокое копирование)
'power_for_litera': _deep_copy_power_structure(),
'control_results': control_results.duplicate(true),
'power_result': power_result.duplicate(true),
'temperature_um': temperature_um.duplicate(true),
'ecms': ecms.duplicate(true),
# Конфигурации блоков
'block_ip_config': block_ip_config.duplicate(true),
'block_kasseta_y5_config': block_kasseta_y5_config.duplicate(true),
# Конфигурация устройства
'self_name': self_name,
'constants': constants.duplicate(true),
@@ -212,7 +225,7 @@ func _initialize_config_from_manager() -> void:
if not config_manager.is_loaded():
push_error('ConfigManager не загружен!')
return
_device_constants = config_manager.get_device_constants()
_base_configs = config_manager.get_base_configs()
_device_configs = config_manager.get_device_configs()
@@ -244,13 +257,13 @@ func _ready() -> void:
## Инициализация маппинга состояний лучей
func _initialize_ray_mapping() -> void:
_ray_state_mapping = {
STATE_MACHINE.UG_SET_RAY_0: 'RAY_m5',
STATE_MACHINE.UG_SET_RAY_1: 'RAY_5',
STATE_MACHINE.UG_SET_RAY_2: 'RAY_15',
STATE_MACHINE.UG_SET_RAY_3: 'RAY_25',
STATE_MACHINE.UG_SET_RAY_4: 'RAY_35',
STATE_MACHINE.UG_SET_RAY_5: 'RAY_45',
STATE_MACHINE.UG_SET_RAY_CTRL: 'RAY_CTRL',
STATE_MACHINE.UG_SET_RAY_0: 'RAY_CTRL',
STATE_MACHINE.UG_SET_RAY_1: 'RAY_m5',
STATE_MACHINE.UG_SET_RAY_2: 'RAY_5',
STATE_MACHINE.UG_SET_RAY_3: 'RAY_15',
STATE_MACHINE.UG_SET_RAY_4: 'RAY_25',
STATE_MACHINE.UG_SET_RAY_5: 'RAY_35',
STATE_MACHINE.UG_SET_RAY_CTRL: 'RAY_45',
}
@@ -270,25 +283,19 @@ func _process(_delta: float) -> void:
## Обработка данных от ЯУ-07
func on_data_received(unit_pribor: Object) -> void:
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
socket_status_ems_g(status)
block_ip_config = check_block_ip(status, block_ip_config)
temperature_um = check_temperature_um(status)
flag_temperature_ok = check_overheating(temperature_um)
if machine_timer.is_stopped():
return
flags.temperature_ok = check_overheating(temperature_um)
block_ip_config = check_block_ip(status, block_ip_config)
block_kasseta_y5_config = check_block_kasseta_y5(status, block_kasseta_y5_config, flags.no_trust_yau07)
_set_control_result('block_kasseta', on_y5_control_result(block_kasseta_y5_config))
_set_control_result('temperature', flags.temperature_ok)
_set_control_result('block_ip', on_dry_control_result(block_ip_config))
if not flags.in_control: return
if machine_timer.is_stopped(): return
if flags.no_trust_yau07: return
socket_status_ems_g(status)
_process_dkm_status(status)
# Формирование мощностей в литерах
if current_litera != 0:
var tek_litera: Dictionary = power_for_litera[current_litera]
@@ -314,20 +321,20 @@ 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_lit_1 = (packet_form_yau_07.decode_u16(config_manager.get_data_index('OUT_BLANK_PRD')) & (1 << 3)) != 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
@@ -335,14 +342,14 @@ func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void:
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
flags.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
flags.si_fs_output = (out_blank & (1 << number_socket_output)) != 0
#endregion
@@ -351,10 +358,10 @@ func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void:
func state_control_machine() -> void:
match 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() # Проверка Кассеты У5
STATE_MACHINE.CHEK_BLOCK_IP: _handle_check_block_ip_state() # Проверка ИП
STATE_MACHINE.FS_TURN_ON: _handle_fs_turn_on_state()
STATE_MACHINE.FS_WORK: _handle_fs_work_state()
STATE_MACHINE.READ_ISA: _handle_read_isa_state()
STATE_MACHINE.UG_SET_RAY_CTRL: _handle_ray_operation(6)
STATE_MACHINE.UG_SET_RAY: _handle_ray_operation() # Режим чтения
@@ -368,37 +375,27 @@ func state_control_machine() -> void:
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:
if block_kasseta_y5_config['yau07'] or flags.no_trust_yau07:
progressbar_status()
## Обработка состояния 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
if _get_current_ecm(): return
state = STATE_MACHINE.CHEK_KASSETA_Y5
else:
if _get_current_ecm(): return
# Завершение контроля если литеры закончились
flag_control_is_over = true
control_results = on_control_result(block_ip_config, control_results)
flags.control_is_over = true
power_result = prep_power(power_for_litera, self_name)
machine_timer.stop()
_set_control_result('is_over_control', flags.control_is_over)
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', self_name)
@@ -406,27 +403,31 @@ func _handle_init_state() -> void:
## Обработка состояния 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)
manage_fs(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
static func take_ecm_id(ecm_dic: Dictionary, device_name: String, current_lit: int) -> int:
# Получаем целевой nmfs из таблицы
var target_nmfs: int = LITER_TO_NMFS.get(device_name, {}).get(current_lit, -1)
if target_nmfs == -1:
return 0
# Ищем ECM с соответствующим nmfs
for ecm_id in ecm_dic:
if ecm_dic[ecm_id].nmfs == target_nmfs:
return ecm_id
return 0
## Обработка состояния FS_WORK - проверка работы ФС
func _handle_fs_work_state() -> void:
var flag_ecm: bool = false
_set_status('Проверка связи сервиса КАПС РПБ')
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:
if not flags.ecm_is_comming: return
if current_ecm_key != 0 and flags.fs_status_ok:
_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 \
@@ -434,7 +435,14 @@ func _handle_fs_work_state() -> void:
(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
if not block_kasseta_y5_config['yau07']:
_set_status('Ожидание данных от ЯУ-07...')
return # НЕ переходим дальше пока нет данных от сервиса МП550
if flags.only_fs:
state = STATE_MACHINE.IN_EMS_STOP
else:
state = STATE_MACHINE.UG_SET_RAY_5 if current_litera == 1 else STATE_MACHINE.UG_SET_RAY_CTRL
## Обработка состояния CHECK_KASSETA - проверка кассеты Y5
@@ -445,15 +453,16 @@ func _handle_check_kasseta_state() -> void:
if not block_kasseta_y5_config[case]:
block_kasseta_y5 = false
if block_kasseta_y5:
if flag_temperature_ok:
if flags.temperature_ok:
ems_6666_timer.start()
state = STATE_MACHINE.CHEK_BLOCK_IP
else:
_set_status('Перегрев УМ')
state = STATE_MACHINE.IN_EMS_STOP
else:
flag_only_fs = true
state = STATE_MACHINE.IN_EMS_STOP
flags.flag_only_fs = true
_set_status('Касета У5: ERROR, Проверка ФС.')
state = STATE_MACHINE.FS_TURN_ON
## Обработка состояния CHECK_BLOCK_IP - проверка кассеты Y5
@@ -463,20 +472,15 @@ func _handle_check_block_ip_state() -> void:
for ip in block_ip_config:
if not block_ip_config[ip][1]:
block_ip = false
if block_ip:
if current_litera == 1:
state = STATE_MACHINE.UG_SET_RAY_5
else:
state = STATE_MACHINE.UG_SET_RAY_CTRL
elif flag_only_fs:
state = STATE_MACHINE.IN_EMS_STOP
state = STATE_MACHINE.FS_TURN_ON if block_ip else STATE_MACHINE.IN_EMS_STOP
## Обработка состояния 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
flags.write_isa = false
state = STATE_MACHINE.UG_SET_RAY
@@ -488,10 +492,11 @@ func _handle_ems_stop_state() -> void:
## Обработка состояния FS_TURN_OFF - выключение ФС
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)
state = STATE_MACHINE.STOP_CONTROL
if not _get_current_ecm(): return
_set_status('Отключение ФС-%s' % current_litera)
flags.fs_status_ok = false
signaller.emit_signal('interfer_off', ecms[current_ecm_key])
## Обработка состояния STOP_CONTROL - завершение контроля
@@ -499,9 +504,10 @@ func _handle_stop_control_state() -> void:
_set_status('Завершение контроля ФС-%s' % current_litera)
completed_fs_count += 1
_advance_to_next_fs()
flags.ecm_is_comming = false
state = STATE_MACHINE.INIT
if flag_no_trust_yau07:
if flags.no_trust_yau07:
state = STATE_MACHINE.STOP_CONTROL
@@ -515,7 +521,6 @@ func _advance_to_next_fs() -> void:
5: current_litera = 0
6: current_litera = 7
7: current_litera = 0
#endregion
@@ -535,7 +540,7 @@ 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)
@@ -549,10 +554,13 @@ func _handle_ray_write_mode(ray_num: int) -> void:
if ray_num == 0:
control_timer.stop()
# Ожидание пяти пакетов от ЯУ-07
if count_packets_power < 5: return
if ray_num == 6:
if count_packets_power < 20: return
elif count_packets_power < 10: return
# Установка луча
_handle_ug_set_state(ray_num)
flag_write_isa = true
flags.write_isa = true
state = STATE_MACHINE.READ_ISA
@@ -578,10 +586,10 @@ func _can_process_ray_state(addr: int) -> bool:
## Проверка возможности записи луча
func _can_write_ray() -> bool:
if flag_write_isa:
if flags.write_isa:
return false
if not flag_si_fs_input:
if not flags.si_fs_input:
_set_status('Ожидание сигнала излучения от ФС-%s' % current_litera )
return false
else:
@@ -607,7 +615,7 @@ func _handle_ug_set_state(RAY_DOU_NUM: int) -> void:
'ATT_UM_3': def_att,
'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
@@ -619,7 +627,7 @@ 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)
flags.write_isa = on_ug_setting(unit_prd, dic_att, cmd_array)
count_packets_power = 0
@@ -637,9 +645,9 @@ func progressbar_status() -> void:
await get_tree().create_timer(0.5).timeout
progress_value = 0
return
var base_progress: float = 0.0
# Базовый прогресс в зависимости от состояния
match state:
STATE_MACHINE.INIT: base_progress = PROGRESS_INIT
@@ -653,14 +661,14 @@ func progressbar_status() -> void:
STATE_MACHINE.UG_SET_RAY_4: base_progress = PROGRESS_RAY_STATES + 20
STATE_MACHINE.UG_SET_RAY_5: base_progress = PROGRESS_RAY_STATES + 25
STATE_MACHINE.IN_EMS_STOP: base_progress = PROGRESS_COMPLETE
STATE_MACHINE.FS_TURN_OFF: base_progress = PROGRESS_COMPLETE
STATE_MACHINE.STOP_CONTROL: base_progress = PROGRESS_COMPLETE
STATE_MACHINE.FS_TURN_OFF: base_progress = PROGRESS_COMPLETE + 5
STATE_MACHINE.STOP_CONTROL: base_progress = PROGRESS_COMPLETE + 10
# Плавное заполнение во время ожидания таймера
if control_timer.time_left > 0 and state != STATE_MACHINE.STOP_CONTROL:
var timer_progress = (control_timer.wait_time - control_timer.time_left) / control_timer.wait_time
base_progress = lerp(base_progress - 5.0, base_progress, timer_progress)
# Учитываем прогресс по лучам внутри UG_SET_RAY состояния
if state == STATE_MACHINE.UG_SET_RAY:
var addr: int = _get_ug_address()
@@ -669,7 +677,7 @@ func progressbar_status() -> void:
var max_ray_value = 5.0 # максимальное значение луча для прогресса
var ray_progress = float(ray_value) / max_ray_value * 40.0
base_progress += ray_progress
# Распределяем прогресс по ФС
if total_fs_to_check > 0:
var progress_per_fs = (PROGRESS_COMPLETE - PROGRESS_INIT) / total_fs_to_check
@@ -677,7 +685,7 @@ func progressbar_status() -> void:
prog_back = fs_base_progress + (base_progress * progress_per_fs / PROGRESS_COMPLETE)
else:
prog_back = base_progress
if control_timer.time_left > 0 and not control_timer.is_stopped():
prog_back += (control_timer.wait_time - control_timer.time_left) + 10
@@ -725,9 +733,9 @@ func on_state_mashine():
## Обработка таймаута контроля
func on_stop_control() -> void:
_handle_fs_turn_off_state()
if state == STATE_MACHINE.UG_SET_RAY:
flag_no_trust_yau07 = true
flags.no_trust_yau07 = true
state = STATE_MACHINE.IN_EMS_STOP
#endregion
@@ -735,37 +743,37 @@ func on_stop_control() -> void:
#region DEVICE_CONFIGURATION
## Определение имени и конфигурации устройства
func _determine_self_name() -> void:
flag_no_trust_yau07 = false
flag_only_fs = false
flags.no_trust_yau07 = false
flags.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():
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к':
@@ -774,7 +782,7 @@ func _determine_self_name() -> void:
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
@@ -793,11 +801,11 @@ func _load_block_config(config, config_type: String) -> Dictionary:
## Определение типа устройства по имени
func _get_device_type() -> String:
if self_name.ends_with('н'):
if self_name.ends_with('н'):
return 'PRD_N'
elif self_name.ends_with('в'):
elif self_name.ends_with('в'):
return 'PRD_V'
elif self_name.ends_with('к'):
elif self_name.ends_with('к'):
return 'PRD_K'
return ''
#endregion
@@ -812,7 +820,7 @@ func initialize_connections() -> void:
interfer.connect('interfer_resized', Callable(self, 'on_interfer_resized'))
unit_prd.connect('data_received', Callable(self, 'on_data_received'))
unit_prd.connect('line_changed', Callable(self, 'on_line_changed_yau07'))
# Подключение сигналов режимов работы
var mode_signals = ['режим_работа', 'режим_журнал', 'режим_эмс', 'режим_настройки']
for signal_name in mode_signals:
@@ -829,34 +837,38 @@ func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> vo
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
flags.fs_status_ok = control_results[fs_key] == 1
## Обработка изменения размера интерферометра
func on_interfer_resized(ecms_dic: Dictionary) -> void:
ecms = ecms_dic
current_ecm_key = take_ecm_id(ecms, self_name, current_litera)
flags.ecm_is_comming = (current_ecm_key != 0) # Явное установление состояния
## Обработка запуска контроля устройства
func _on_start_contol_device()-> void:
_set_status('Подготовка к контролю')
restore_default_states()
flags.in_control = true
machine_timer.wait_time = constants.STATE_MASHINE_TIMER
machine_timer.start()
## Обработка изменения режима работы
func on_mode_changed(in_tree: bool) -> void:
flag_in_control = in_tree
flags.in_control = in_tree
if not in_tree: ## При нажатии выхода из режима контроль
_set_status('Ожидание запуска контроля')
cmd_array.append([unit_prd.CmdCode.WRITE_ISA,[
cmd_array.append([unit_prd.CmdCode.WRITE_ISA,[
constants.ADDR_UG_LITERA_1, DATA_EXIT_CONTOL_ISA,
constants.ADDR_UG_LITERA_2, DATA_EXIT_CONTOL_ISA,
constants.ADDR_UG_LITERA_3, DATA_EXIT_CONTOL_ISA]])
flag_control_is_over = false
flag_no_trust_yau07 = false
flag_only_fs = false
flags.control_is_over = false
flags.no_trust_yau07 = false
flags.only_fs = false
flags.ecm_is_comming = false
progress_value = 0
machine_timer.stop()
state = STATE_MACHINE.INIT
@@ -869,30 +881,39 @@ func on_mode_changed(in_tree: bool) -> void:
# Вызывается при смене связи я ячейков ЯУ-07Б
func on_line_changed_yau07(_status: Object)->void:
_set_status('Ожидание запуска контроля')
flag_control_is_over = false
flag_no_trust_yau07 = false
flag_only_fs = false
flags.control_is_over = false
flags.no_trust_yau07 = false
flags.only_fs = false
restore_default_states()
#endregion
#region ECMS
## Универсальная проверка доступа к ecms:
func _get_current_ecm() -> Variant:
if current_ecm_key != 0 and ecms.has(current_ecm_key):
return ecms[current_ecm_key]
return null
#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
@@ -939,7 +960,7 @@ func get_current_status() -> String:
## Геттер для результатов контроля
func get_control_results() -> Dictionary:
return {
'control_is_over': flag_control_is_over,
'control_is_over': flags.control_is_over,
'result_dic': control_results,
'power_dic': power_result,
'block_kasseta_y5_config': block_kasseta_y5_config,
@@ -953,13 +974,21 @@ func get_control_results() -> Dictionary:
#region STATIC_UTILITY_METHODS
## Итоговое заключение по результатам контроля всех ИП
static func on_control_result(ip_config: Dictionary, ctrl_results: Dictionary) -> Dictionary:
static func on_dry_control_result(ip_config: Dictionary) -> bool:
var all_blocks_ip_ok = true
for block in ip_config:
if not ip_config[block][1]:
all_blocks_ip_ok = false
ctrl_results['block_ip'] = all_blocks_ip_ok
return ctrl_results
return all_blocks_ip_ok
## Итоговое заключение по результатам контроля кассеты у5
static func on_y5_control_result(block_kasseta: Dictionary) -> bool:
var all_blocks_y5_ok = true
for block in block_kasseta:
if not block_kasseta[block]:
all_blocks_y5_ok = false
return all_blocks_y5_ok
## Установка угла и аттенюации для УМ
@@ -980,12 +1009,11 @@ static func _handle_read_isa(prd_unit: Object, read_isa_ports: Array, prd_cmd_ar
## Управление модулем ФС (включить/отключить излучение)
static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, litera: int, power_um: int) -> void:
static func manage_fs(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 interfer_name: String = 'k1'
var fs_arr: Array = []
if litera in fs_params:
@@ -996,8 +1024,7 @@ 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('interfer_init', interfer_name, fs_arr, power_um)
signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um)
## Проверка кассет П1 и ИП МА2000
@@ -1037,7 +1064,7 @@ static func check_temperature_um(status_prd: PackedByteArray) -> Dictionary:
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
@@ -1045,28 +1072,33 @@ static func check_temperature_um(status_prd: PackedByteArray) -> Dictionary:
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
else:
for i_temp in 8:
return_dic_temp[arr_um[i_temp]] = -999 # Заполняем нулями если УКП нет на связи
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
else:
for i_temp in 8:
return_dic_temp[arr_um[i_temp+8]] = -999 # Заполняем -999 если УКП нет на связи
return return_dic_temp
static func check_overheating(temperature_data: Dictionary) -> bool:
const MAX_TEMP: int = 55
const MIN_VALID_TEMP: int = -1500
const MAX_VALID_TEMP: int = 150
const MAX_VALID_TEMP: int = 130
for key in temperature_data:
var temp = temperature_data[key]
# Пропускаем невалидные значения
if temp < MIN_VALID_TEMP or temp > MAX_VALID_TEMP:
continue
# Проверяем превышение температуры
if temp > MAX_TEMP:
return false
@@ -1083,13 +1115,13 @@ static func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool:
## Распределение номеров ФС по приборам
static func _create_fs_mapping(s_name: String) -> Dictionary:
var suffixes: Dictionary = {
0: '1к', 1: '4к', 2: '3к', 3: '2к',
4: '1н', 5: '4н', 6: '3н', 7: '2н',
8: '1н', 9: '4н', 10: '3н', 11: '2н',
12: '1в', 13: '4в', 14: '3в', 15: '2в',
16: '1в', 17: '4в', 18: '3в', 19: '2в',
20: '1к', 21: '4к', 22: '3к', 23: '2к',
24: '1к', 25: '4к', 26: '3к', 27: '2к',
0: '1к', 1: '4к', 2: '3к', 3: '2к',
4: '1н', 5: '4н', 6: '3н', 7: '2н',
8: '1н', 9: '4н', 10: '3н', 11: '2н',
12: '1в', 13: '4в', 14: '3в', 15: '2в',
16: '1в', 17: '4в', 18: '3в', 19: '2в',
20: '1к', 21: '4к', 22: '3к', 23: '2к',
24: '1к', 25: '4к', 26: '3к', 27: '2к',
}
var mapping: Dictionary = {}
@@ -1256,7 +1288,7 @@ static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pri
ray_dic[RAY_45].size() == 0:
control_dic[dou] = false
return control_dic
# Подсчет значений ниже порога по позициям
var low_power_by_position: Array = [0, 0, 0, 0, 0, 0] # Счетчики для 6 позиций
for ray_key in [RAY_m5, RAY_5, RAY_15, RAY_25, RAY_35, RAY_45]:
@@ -1264,7 +1296,7 @@ static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pri
for i in range(power_array.size()):
if power_array[i] < cnst.POWER_THRESHOLD:
low_power_by_position[i] += 1
# Проверяем, нет ли позиции где много низких значений
var limit_power_um: int = 2
var good_positions: int = 0
@@ -1289,27 +1321,20 @@ func _deep_copy_power_structure() -> Dictionary:
func restore_default_states() -> void:
if _default_states.is_empty():
_initialize_default_states()
# Восстановление простых переменных
flag_write_isa = _default_states['flag_write_isa']
flag_fs_status_ok = _default_states['flag_fs_status_ok']
flag_si_fs_input = _default_states['flag_si_fs_input']
flag_si_fs_output = _default_states['flag_si_fs_output']
flag_control_is_over = _default_states['flag_control_is_over']
flag_no_trust_yau07 = _default_states['flag_no_trust_yau07']
flag_only_fs = _default_states['flag_only_fs']
flags = _default_states['flags'].duplicate(true)
state = _default_states['state']
current_litera = _default_states['current_litera']
progress_value = _default_states['progress_value']
current_status = _default_states['current_status']
total_fs_to_check = _default_states['total_fs_to_check']
completed_fs_count = _default_states['completed_fs_count']
current_fs_progress = _default_states['current_fs_progress']
cc = _default_states['cc']
# Восстановление словарей (глубокое копирование)
ems_g_sock_dic = _default_states['ems_g_sock_dic'].duplicate(true)
power_for_litera = _default_states['power_for_litera'].duplicate(true)
@@ -1318,28 +1343,18 @@ func restore_default_states() -> void:
temperature_um = _default_states['temperature_um'].duplicate(true)
ecms = _default_states['ecms'].duplicate(true)
block_ip_config = _default_states['block_ip_config'].duplicate(true)
block_kasseta_y5_config = _default_states['block_kasseta_y5_config'].duplicate(true)
# Остановка таймеров
control_timer.stop()
ems_6666_timer.stop()
machine_timer.stop()
_set_status('Состояния сброшены к значениям по умолчанию')
## Получение текущих состояний для отладки
func get_current_states() -> Dictionary:
return {
'flags': {
'write_isa': flag_write_isa,
'fs_status_ok': flag_fs_status_ok,
'si_fs_input': flag_si_fs_input,
'si_fs_output': flag_si_fs_output,
'in_control': flag_in_control,
'control_is_over': flag_control_is_over,
'no_trust_yau07': flag_no_trust_yau07,
'only_fs': flag_only_fs
},
'flags': flags.duplicate(true),
'state_machine': {
'state': state,
'current_litera': current_litera
@@ -1362,3 +1377,16 @@ func get_current_states() -> Dictionary:
}
}
#endregion
#region setters
func _set_control_result(key: String, status: bool)-> void:
var old_value = control_results.get(key)
if key == 'is_over_control' or old_value != status:
control_results[key] = status
emit_signal('control_results_updated', control_results)
print_debug('control_results_updated: ',[key, status])
func _get_control_result(key: String) -> bool:
return control_results[key]
#endregion

12
table/table.gd
View File

@@ -301,6 +301,16 @@ func default_selector_size_proc(i_row: int, rect: Array) -> void:
rect[3] += node_gap.y
## Очищает в словаре nodes от невалидных ссылок
func cleanup_invalid_selectors():
var keys_to_remove = []
for key in nodes:
if key.begins_with(SLCT_PREFIX) and not is_instance_valid(nodes[key]):
keys_to_remove.append(key)
for key in keys_to_remove:
nodes.erase(key)
print_debug("Удален невалидный селектор: ", key)
##
func clear_rows_selected():
var rows_count: = get_rows_count()
@@ -323,7 +333,6 @@ func _set_row_selected(i_row: int, selected: bool = true) -> void:
return
if nodes.has(selector_key) and (not selected):
var selector = nodes[selector_key]
nodes.erase(selector_key)
if is_instance_valid(selector):
var prnt = selector.get_parent_control()
if prnt:
@@ -331,6 +340,7 @@ func _set_row_selected(i_row: int, selected: bool = true) -> void:
selector.queue_free()
else:
push_warning('обращение к удалённому элементу \"%s\"' % selector_key)
nodes.erase(selector_key)
elif (not nodes.has(selector_key)) and selected:
var selector = ScnSelector.instantiate()
var rect: = [0, 0, 0, 0]