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

загрузка json

Browse Source
This commit is contained in:
TotMaxim
2025-11-16 16:43:32 +03:00
parent 9727eb04a9
commit de86d281ca
2 changed files with 783 additions and 948 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
scripts/prd.gd
View File

@@ -285,8 +285,7 @@ func _ready() -> void:
var unit_prd = network.get_unit_instance(prd_name)
var new_prd = PRD.new(prd_name, unit_prd)
prd_dict[prd_name] = new_prd
var control_pribor_prd = preload('res://scripts/pribor-prd.gd')
var unit_control = control_pribor_prd.TestPRD.new({'unit_prd': unit_prd}, new_prd.cmd_array)
var unit_control = TestPRD.new({'unit_prd': unit_prd}, new_prd.cmd_array)
add_child(unit_control)
new_prd.unit_control = unit_control
for key in FS_PRD.keys():

572
scripts/pribor-prd.gd
View File

@@ -1,254 +1,31 @@
class TestPRD extends Node:
const DEVICE_CONSTANT: Dictionary = {
'PRD_N': {
CONSTANTS = {
'POWER_UKP_1': 31,
'POWER_UKP_2': 63,
'DKM_BIT_2': 1,
'DKM_BIT_3': 2,
'BASE_ADDR_EMS_G': 0x120,
'ADDR_UG_LITERA_1': 0x106,
'ADDR_UG_LITERA_2': 0x108,
'ADDR_UG_LITERA_3': 0x10A,
'TEMP_THRESHOLD': 70,
'POWER_THRESHOLD': 40,
'RAY_DOU_NUM': 0x3,
'ATT_UM_2': 0x2,
'ATT_UM_3': 0x3,
'POWER_UM': 100,
'TIMER_DELAY': 10.0,
'STATE_MASHINE_TIMER': 0.3,
},
PRIBOR_CONFIG = {
'1н': {'angle': 0.0, 'sectors': [4, 8]},
'2н': {'angle': 90.0, 'sectors': [7, 11]},
'3н': {'angle': 180.0, 'sectors': [6, 10]},
'4н': {'angle': 270.0, 'sectors': [5, 9]},
},
FS_PARAMS = {
2: {'freq': 932.0, 'width': 100.0},
3: {'freq': 1157.0, 'width': 100.0}
},
START_LITERA = 2
},
'PRD_V': {
CONSTANTS = {
'POWER_UKP_1': 31,
'POWER_UKP_2': 63,
'DKM_BIT_4': 3,
'DKM_BIT_5': 4,
'BASE_ADDR_EMS_G': 0x120,
'ADDR_UG_LITERA_1': 0x106,
'ADDR_UG_LITERA_2': 0x108,
'ADDR_UG_LITERA_3': 0x10A,
'TEMP_THRESHOLD': 70,
'POWER_THRESHOLD': 40,
'RAY_DOU_NUM': 0x3,
'ATT_UM_4': 0x2,
'ATT_UM_5': 0x3,
'POWER_UM': 100,
'TIMER_DELAY': 10.0,
'STATE_MASHINE_TIMER': 0.3,
},
PRIBOR_CONFIG = {
'1в': {'angle': 0.0, 'sectors': [12, 16]},
'2в': {'angle': 90.0, 'sectors': [15, 19]},
'3в': {'angle': 180.0, 'sectors': [14, 18]},
'4в': {'angle': 270.0, 'sectors': [13, 17]},
},
FS_PARAMS = {
4: {'freq': 1227.0, 'width': 100.0},
5: {'freq': 1575.0, 'width': 110.0},
},
START_LITERA = 4
},
'PRD_K': {
CONSTANTS = {
'POWER_UKP_1': 31,
'POWER_UKP_2': 63,
'DKM_BIT_1': 0,
'DKM_BIT_6': 5,
'DKM_BIT_7': 6,
'BASE_ADDR_EMS_G': 0x120,
'ADDR_UG_LITERA_1': 0x106,
'ADDR_UG_LITERA_2': 0x108,
'ADDR_UG_LITERA_3': 0x10A,
'TEMP_THRESHOLD': 40,
'POWER_THRESHOLD': 40,
'RAY_DOU_NUM': 0x3,
'ATT_UM_1': 0x0,
'ATT_UM_6': 0x3,
'ATT_UM_7': 0x2,
'POWER_UM': 100,
'TIMER_DELAY': 10.0,
'STATE_MASHINE_TIMER': 0.3,
},
PRIBOR_CONFIG = { # Конфигурация параметров для каждого прибора
'1к': {'angle': 0.0, 'sectors': [0, 20, 24]},
'2к': {'angle': 90.0, 'sectors': [3, 23, 27]},
'3к': {'angle': 180.0, 'sectors': [2, 22, 26]},
'4к': {'angle': 270.0, 'sectors': [1, 21, 25]},
},
FS_PARAMS = { # Конфигурация частот и ширин для каждого ФС
1: {'freq': 450.0, 'width': 80.0},
6: {'freq': 2450.0, 'width': 110.0},
7: {'freq': 4750.0, 'width': 110.0}
},
START_LITERA = 1
}
}
class_name TestPRD
extends Node
# Константы
const CONFIG_PATH = "user://config/setting_prd_control.json"
var block_ip_config_n:= {
'maa2000_1': [0, false],
'maa2000_2': [1, false],
'ip9_50_1': [2, false],
'ip9_50_2': [3, false],
'ip12_50_1': [4, false],
'ip5_25': [7, false],
}
var block_kasseta_y5_prd_config_n: = {
'yau07': false,
'ems': false,
'ug': false,
'ukp1': false,
'ukp2': false,
}
const RAY_m5: String = "RAY_m5"
const RAY_5: String = "RAY_5"
const RAY_15: String = "RAY_15"
const RAY_25: String = "RAY_25"
const RAY_35: String = "RAY_35"
const RAY_45: String = "RAY_45"
# Результаты контроля
var control_results_n: Dictionary = {
'block_ip': false, # Проверка касет П1 и ИП МА2000
'temperature': true, # Проверка температур УМ
'dkm_2': false,
'dkm_3': false,
'dou_2': false,
'dou_3': false,
'fs_2': 0,
'fs_3': 0,
}
####
var block_ip_config_v := {
'maa2000_1': [0, false],
'maa2000_2': [1, false],
'ip9_50_1': [2, false],
'ip9_50_2': [3, false],
'ip12_50_1': [4, false],
'ip5_25': [7, false],
}
var block_kasseta_y5_prd_config_v: = {
'yau07': false,
'ems': false,
'ug': false,
'ukp1': false,
'ukp2': false,
}
var control_results_v: Dictionary = {
'block_ip': false, # Проверка касет П1 и ИП МА2000
'temperature': true, # Проверка температур УМ
'dkm_4': false,
'dkm_5': false,
'dou_4': false,
'dou_5': false,
'fs_4': 0,
'fs_5': 0,
}
####
var block_kasseta_y5_prd_config_k: = {
'yau07': false,
'ems': false,
'ug': false,
'ukp1': false,
'ukp2': false,
}
var control_results_k: Dictionary = {
'block_ip': false, # Проверка касет П1 и ИП МА2000
'temperature': true,
'dkm_1': false,
'dkm_6': false,
'dkm_7': false,
'dou_6': false,
'dou_7': false,
'fs_1': 0,
'fs_6': 0,
'fs_7': 0,
}
var block_ip_config_k := {
'maa2000_1': [0, false],
'maa2000_2': [1, false],
'ip9_50_1': [2, false],
'ip9_50_2': [3, false],
'ip12_50_1': [4, false],
'ip9_50_3': [5, false],
'ip12_50_2': [6, false],
'ip5_25': [7, false],
}
####
const RAY_TYPES := [RAY_m5, RAY_5, RAY_15, RAY_25, RAY_35, RAY_45]
const RAY_m5:= 'RAY_m5'
const RAY_5:= 'RAY_5'
const RAY_15:= 'RAY_15'
const RAY_25:= 'RAY_25'
const RAY_35:= 'RAY_35'
const RAY_45:= 'RAY_45'
enum DataIndices {
STATUS_BOARD = 0,
IN_BLANK_PRD = 1,
IN_IMPULS_PRD = 7,
OUT_BLANK_PRD = 13,
OUT_IMPULS_PRD = 19,
DRY_CONTACT = 27,
DKM = 28,
POWER_UKP_1 = 31,
TEMPERATURE_UKP_1 = 47,
POWER_UKP_2 = 63,
TEMPERATURE_UKP_2 = 79,
}
# Загруженные конфигурации
var config_data: Dictionary
var device_constants: Dictionary
var base_configs: Dictionary
var device_configs: Dictionary
var data_indices: Dictionary
var state_machine_enum: Dictionary
var fs_keys: Dictionary
var temperature_constants: Dictionary
var ems_input_bits_config: Dictionary
var fs_rules: Array
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
}
const FS_KEYS := {
1: 'fs_1',
2: 'fs_2',
3: 'fs_3',
4: 'fs_4',
5: 'fs_5',
6: 'fs_6',
7: 'fs_7'
}
const TEMPERATURE_CONSTANTS := {
'CONST_MIN_TEMP': -25,
'MAXIMUM_CODE_ADC': 3796,
'MINIMUM_CODE_AD': 2660,
'TEMPERATURE_UKP_1': 47,
'TEMPERATURE_UKP_2': 79,
}
var power_for_litera: Dictionary = {
1: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
2: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
3: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
4: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
5: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
6: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
7: {RAY_m5: [], RAY_5: [], RAY_15: [], RAY_25: [], RAY_35: [], RAY_45: [],},
}
var _ray_state_mapping: Dictionary
# Переменные класса
var constants: Dictionary
var pribor_config: Dictionary
var fs_parameters: Dictionary
@@ -256,7 +33,7 @@ class TestPRD extends Node:
var block_kasseta_y5_config: Dictionary
var control_results: Dictionary
var self_name: String
var state: int = STATE_MACHINE.INIT
var state: int = 0
var current_litera: int
var flag_write_isa: bool = false
var flag_fs_status_ok: bool = false
@@ -280,13 +57,25 @@ class TestPRD extends Node:
progress_value = v
call_deferred('emit_signal', 'update_progress', v)
var ecms: Dictionary
var power_for_litera: Dictionary
var ecms: Dictionary ## Словарь помеховых воздействий
## Инициализация аргуметнов
func _init(init_data: Dictionary, cmd_array_from_prd: Array) -> void:
unit_prd = init_data['unit_prd']
cmd_array = cmd_array_from_prd
_load_configuration()
_initialize_ray_mapping()
_initialize_power_structure()
func _initialize_power_structure() -> void:
power_for_litera = {}
for litera in range(1, 8):
power_for_litera[litera] = {}
for ray_type in RAY_TYPES:
power_for_litera[litera][ray_type] = []
func _ready() -> void:
@@ -295,6 +84,50 @@ class TestPRD extends Node:
setup_timer()
func _get_ray_key(machine_state: int) -> String:
return _ray_state_mapping.get(machine_state, "")
func _load_configuration() -> void:
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:
config_data = json.data
_parse_config_data()
else:
push_error("Failed to parse JSON config: " + json.get_error_message())
else:
push_error("Failed to load config file: " + CONFIG_PATH)
func _parse_config_data() -> void:
device_constants = config_data.get("device_constants", {})
base_configs = config_data.get("base_configs", {})
device_configs = config_data.get("device_configs", {})
data_indices = config_data.get("data_indices", {})
state_machine_enum = config_data.get("state_machine", {})
fs_keys = config_data.get("fs_keys", {})
temperature_constants = config_data.get("temperature_constants", {})
ems_input_bits_config = config_data.get("ems_input_bits_config", {})
fs_rules = config_data.get("fs_rules", [])
func _initialize_ray_mapping() -> void:
_ray_state_mapping = {
state_machine_enum.get("UG_SET_RAY_0", 7): RAY_m5,
state_machine_enum.get("UG_SET_RAY_1", 8): RAY_5,
state_machine_enum.get("UG_SET_RAY_2", 9): RAY_15,
state_machine_enum.get("UG_SET_RAY_3", 10): RAY_25,
state_machine_enum.get("UG_SET_RAY_4", 11): RAY_35,
state_machine_enum.get("UG_SET_RAY_5", 12): RAY_45
}
func _process(_delta: float) -> void:
pass
@@ -303,12 +136,12 @@ class TestPRD extends Node:
func on_data_received(unit_pribor: Object) -> void:
var status: PackedByteArray = unit_pribor.status
socket_status_ems_g(status)
if machine_timer.is_stopped():
return
block_kasseta_y5_config = check_block_kasseta_y5(status, block_kasseta_y5_config)
block_ip_config = check_block_ip(status, block_ip_config)
if machine_timer.is_stopped():
return
_process_dkm_status(status)
if current_litera != 0:
var tek_litera: Dictionary = power_for_litera[current_litera]
@@ -324,57 +157,61 @@ class TestPRD extends Node:
var ems_output_2: int
var ems_output_lit_1: int
# Методы для работы с DataIndices из JSON
func _get_data_index(key: String) -> int:
return data_indices.get(key, -1)
func socket_status_ems_g(packet_form_yau_07: PackedByteArray) -> void:
if self_name in ['1н', '2н', '3н', '4н']:
ems_input_1 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 9)) != 0
ems_input_2 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 10)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 9)) != 0
ems_input_2 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 10)) != 0
if self_name in ['1в', '2в', '3в', '4в']:
ems_input_1 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 11)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 12)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 11)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 12)) != 0
if self_name in ['1к', '2к', '3к', '4к']:
ems_input_1 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 13)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 14)) != 0
ems_input_lit_1 = (packet_form_yau_07.decode_u16(DataIndices.IN_BLANK_PRD) & (1 << 8)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 13)) != 0
ems_input_1 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 14)) != 0
ems_input_lit_1 = (packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD')) & (1 << 8)) != 0
ems_output_1 = (packet_form_yau_07.decode_u16(DataIndices.OUT_BLANK_PRD) & (1 << 4)) != 0
ems_output_2 = (packet_form_yau_07.decode_u16(DataIndices.OUT_BLANK_PRD) & (1 << 5)) != 0
ems_output_lit_1 = (packet_form_yau_07.decode_u16(DataIndices.OUT_BLANK_PRD) & (1 << 3)) != 0
ems_output_1 = (packet_form_yau_07.decode_u16(_get_data_index('OUT_BLANK_PRD')) & (1 << 4)) != 0
ems_output_2 = (packet_form_yau_07.decode_u16(_get_data_index('OUT_BLANK_PRD')) & (1 << 5)) != 0
ems_output_lit_1 = (packet_form_yau_07.decode_u16(_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(DataIndices.IN_BLANK_PRD)
var in_blank: int = packet_form_yau_07.decode_u16(_get_data_index('IN_BLANK_PRD'))
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(DataIndices.OUT_BLANK_PRD)
var out_blank: int = packet_form_yau_07.decode_u16(_get_data_index('OUT_BLANK_PRD'))
flag_si_fs_output = (out_blank & (1 << number_socket_output)) != 0 ## Флаг Модуляции УМ ЭМС-Г для текущей литеры
## Пакеты от MP550Service
func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> void:
var fs_key: String = FS_KEYS.get(current_litera, '')
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_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 state_control_machine() -> void:
match state:
STATE_MACHINE.INIT:
state_machine_enum.INIT:
print("Start control for %s device %s litera" % [self_name, current_litera])
_handle_init_state()
STATE_MACHINE.FS_TURN_ON:
state_machine_enum.FS_TURN_ON:
_handle_fs_turn_on_state()
state = STATE_MACHINE.FS_WORK
STATE_MACHINE.FS_WORK:
state = state_machine_enum.FS_WORK
state_machine_enum.FS_WORK:
var flag_ecm: bool = false
for key in ecms:
var params = ecms[key].params.freq
@@ -385,76 +222,76 @@ class TestPRD extends Node:
if flag_ecm and flag_fs_status_ok:
ems_6666_timer.start()
_handle_fs_work_state()
STATE_MACHINE.CHEK_KASSETA_Y5:
state_machine_enum.CHEK_KASSETA_Y5:
if block_kasseta_y5_config['yau07']:
state = STATE_MACHINE.WRITE_ISA
STATE_MACHINE.WRITE_ISA:
state = state_machine_enum.WRITE_ISA
state_machine_enum.WRITE_ISA:
if not flag_write_isa:
_handle_ug_set_state(0x6)
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.READ_ISA:
state = state_machine_enum.READ_ISA
state_machine_enum.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:
state = state_machine_enum.UG_SET_RAY
state_machine_enum.UG_SET_RAY:
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 unit_prd.isa_ports.has(addr) and (unit_prd.cmd_state == unit_prd.CmdState.DONE):
if unit_prd.isa_ports[addr] & 0x07 == 0:
state = STATE_MACHINE.UG_SET_RAY_1
state = state_machine_enum.UG_SET_RAY_1
elif unit_prd.isa_ports[addr] & 0x07 == 1:
state = STATE_MACHINE.UG_SET_RAY_2
state = state_machine_enum.UG_SET_RAY_2
elif unit_prd.isa_ports[addr] & 0x07 == 2:
state = STATE_MACHINE.UG_SET_RAY_3
state = state_machine_enum.UG_SET_RAY_3
elif unit_prd.isa_ports[addr] & 0x07 == 3:
state = STATE_MACHINE.UG_SET_RAY_4
state = state_machine_enum.UG_SET_RAY_4
elif unit_prd.isa_ports[addr] & 0x07 == 4:
state = STATE_MACHINE.UG_SET_RAY_5
state = state_machine_enum.UG_SET_RAY_5
elif unit_prd.isa_ports[addr] & 0x07 == 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
state = state_machine_enum.IN_EMS_STOP
elif unit_prd.isa_ports[addr] & 0x07 == 6:
state = STATE_MACHINE.UG_SET_RAY_0
state = state_machine_enum.UG_SET_RAY_0
STATE_MACHINE.UG_SET_RAY_0:
state_machine_enum.UG_SET_RAY_0:
if flag_si_fs_input and not flag_write_isa:
control_timer.stop()
_handle_ug_set_state(0x0)
await get_tree().create_timer(0.5).timeout
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.UG_SET_RAY_1:
state = state_machine_enum.READ_ISA
state_machine_enum.UG_SET_RAY_1:
if not flag_write_isa:
_handle_ug_set_state(0x1)
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.UG_SET_RAY_2:
state = state_machine_enum.READ_ISA
state_machine_enum.UG_SET_RAY_2:
if not flag_write_isa:
_handle_ug_set_state(0x2)
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.UG_SET_RAY_3:
state = state_machine_enum.READ_ISA
state_machine_enum.UG_SET_RAY_3:
if not flag_write_isa:
_handle_ug_set_state(0x3)
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.UG_SET_RAY_4:
state = state_machine_enum.READ_ISA
state_machine_enum.UG_SET_RAY_4:
if not flag_write_isa:
_handle_ug_set_state(0x4)
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.UG_SET_RAY_5:
state = state_machine_enum.READ_ISA
state_machine_enum.UG_SET_RAY_5:
if not flag_write_isa:
_handle_ug_set_state(0x5)
state = STATE_MACHINE.READ_ISA
STATE_MACHINE.IN_EMS_STOP:
state = state_machine_enum.READ_ISA
state_machine_enum.IN_EMS_STOP:
ems_6666_timer.stop()
state = STATE_MACHINE.FS_TURN_OFF
STATE_MACHINE.FS_TURN_OFF:
state = state_machine_enum.FS_TURN_OFF
state_machine_enum.FS_TURN_OFF:
ems_6666_timer.stop()
_handle_fs_turn_off_state()
state = STATE_MACHINE.STOP_CONTROL
STATE_MACHINE.STOP_CONTROL:
state = state_machine_enum.STOP_CONTROL
state_machine_enum.STOP_CONTROL:
_handle_stop_control_state()
## В машине состояний вызов изменения состояния контроля
## В машине состояний вызов изменения состояния прогресс бара контроля
progressbar_status()
@@ -462,7 +299,7 @@ class TestPRD extends Node:
func _handle_init_state() -> void:
if current_litera in [1, 2, 3, 4, 5, 6, 7]:
if not ecms.size():
state = STATE_MACHINE.FS_TURN_ON
state = state_machine_enum.FS_TURN_ON
else:
control_results = on_control_result(block_ip_config, control_results)
power_result = prep_power(power_for_litera, self_name)
@@ -486,7 +323,7 @@ class TestPRD extends Node:
(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
state = state_machine_enum.CHEK_KASSETA_Y5
func _handle_ug_set_state(RAY_DOU_NUM: int) -> void:
@@ -523,7 +360,7 @@ class TestPRD extends Node:
func progressbar_status() -> void:
match state:
STATE_MACHINE.INIT:
state_machine_enum.INIT:
cc += 10 if current_litera in [3, 5, 6, 7] else 0
if control_timer.get_time_left() > 0:
progress_value = cc + control_timer.get_wait_time() - control_timer.get_time_left()
@@ -540,7 +377,7 @@ class TestPRD extends Node:
##'Выполняется завершение проверки ФС-%s' % current_litera
func _handle_stop_control_state() -> void:
_advance_to_next_fs()
state = STATE_MACHINE.INIT
state = state_machine_enum.INIT
func _advance_to_next_fs() -> void:
@@ -561,10 +398,10 @@ class TestPRD extends Node:
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'))
signaller.connect('режим_работа', Callable(self, 'on_mode_changed').bind(false))
signaller.connect('режим_журнал', Callable(self, 'on_mode_changed').bind(false))
signaller.connect('режим_эмс', Callable(self, 'on_mode_changed').bind(false))
signaller.connect('режим_настройки', Callable(self, 'on_mode_changed').bind(false))
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))
@@ -580,47 +417,58 @@ class TestPRD extends Node:
func _determine_self_name() -> void:
cc = 0
state = STATE_MACHINE.INIT
state = state_machine_enum.get("INIT", 0)
var current_unit = unit_prd.name
var parts = current_unit.split('-')
self_name = parts[-1]
if self_name == '1н' or self_name == '2н' or self_name == '3н' or self_name == '4н':
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)
progress_value = 0
call_deferred('emit_signal', 'update_max_value_progress', 20)
constants = DEVICE_CONSTANT.PRD_N.CONSTANTS
pribor_config = DEVICE_CONSTANT.PRD_N.PRIBOR_CONFIG
fs_parameters = DEVICE_CONSTANT.PRD_N.FS_PARAMS
block_ip_config = block_ip_config_n
block_kasseta_y5_config = block_kasseta_y5_prd_config_n
control_results = control_results_n
current_litera = DEVICE_CONSTANT.PRD_N.START_LITERA
if self_name == '1в' or self_name == '2в' or self_name == '3в' or self_name == '4в':
progress_value = 0
call_deferred('emit_signal', 'update_max_value_progress', 20)
constants = DEVICE_CONSTANT.PRD_V.CONSTANTS
pribor_config = DEVICE_CONSTANT.PRD_V.PRIBOR_CONFIG
fs_parameters = DEVICE_CONSTANT.PRD_V.FS_PARAMS
block_ip_config = block_ip_config_v
block_kasseta_y5_config = block_kasseta_y5_prd_config_v
control_results = control_results_v
current_litera = DEVICE_CONSTANT.PRD_V.START_LITERA
if self_name == '1к' or self_name == '2к' or self_name == '3к' or self_name == '4к':
progress_value = 0
call_deferred('emit_signal', 'update_max_value_progress', 30)
constants = DEVICE_CONSTANT.PRD_K.CONSTANTS
pribor_config = DEVICE_CONSTANT.PRD_K.PRIBOR_CONFIG
fs_parameters = DEVICE_CONSTANT.PRD_K.FS_PARAMS
block_ip_config = block_ip_config_k
block_kasseta_y5_config = block_kasseta_y5_prd_config_n
control_results = control_results_k
current_litera = DEVICE_CONSTANT.PRD_K.START_LITERA
call_deferred('emit_signal', 'update_max_value_progress', device_config.get("progress_max", 20))
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 ''
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.TIMER_DELAY
control_timer.wait_time = constants.get("TIMER_DELAY", 10.0)
add_child(ems_6666_timer)
ems_6666_timer.timeout.connect(_on_ems_6666_timer)
@@ -634,7 +482,7 @@ class TestPRD extends Node:
if not in_tree: ## TODO: Дополнительная проверка если контроль идет, если нет, то смысла вызывать нет
progress_value = 0
machine_timer.stop()
state = STATE_MACHINE.INIT
state = state_machine_enum.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:
@@ -670,7 +518,7 @@ class TestPRD extends Node:
func _get_current_fs_key() -> String:
return FS_KEYS.get(current_litera, '')
return fs_keys.get(str(current_litera), '')
static func _get_dkm_bit_for_current_fs(litera: int, constants_dic: Dictionary) -> int:
@@ -685,20 +533,9 @@ class TestPRD extends Node:
_: return -1
static func _get_ray_key(machine_state: int) -> String:
match machine_state:
STATE_MACHINE.UG_SET_RAY_0: return RAY_m5
STATE_MACHINE.UG_SET_RAY_1: return RAY_5
STATE_MACHINE.UG_SET_RAY_2: return RAY_15
STATE_MACHINE.UG_SET_RAY_3: return RAY_25
STATE_MACHINE.UG_SET_RAY_4: return RAY_35
STATE_MACHINE.UG_SET_RAY_5: return RAY_45
_: return ''
func on_stop_control() -> void:
_handle_fs_turn_off_state()
state = STATE_MACHINE.FS_TURN_OFF
state = state_machine_enum.FS_TURN_OFF
static func on_control_result(ip_config: Dictionary, ctrl_results: Dictionary) -> Dictionary:
@@ -773,6 +610,16 @@ class TestPRD extends Node:
return y5_config
## Мониторинг температуры
static func check_temperature(status_prd: PackedByteArray, y5_config: Dictionary) -> Dictionary:
y5_config.yau07 = true
y5_config.ems = (status_prd[0] & 1) and ((status_prd[0] >> 4) & 1)
y5_config.ug = (status_prd[0] >> 1) & 1
y5_config.ukp1 = (status_prd[0] >> 2) & 1
y5_config.ukp2 = (status_prd[0] >> 3) & 1
return y5_config
## Проверка ДКМ
static func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool:
var dkm: int = 28
@@ -799,24 +646,13 @@ class TestPRD extends Node:
##
static func on_fs_state(packet_type_7: Dictionary, fs_mapping: Dictionary, fs_results: Dictionary) -> Dictionary:
var FS_RULES = [
{'key': 'fs_1', 'min': 0, 'max': 4},
{'key': 'fs_2', 'min': 4, 'max': 8},
{'key': 'fs_3', 'min': 8, 'max': 12},
{'key': 'fs_4', 'min': 12, 'max': 16},
{'key': 'fs_5', 'min': 16, 'max': 20},
{'key': 'fs_6', 'min': 20, 'max': 24},
{'key': 'fs_7', 'min': 24, 'max': 27}
]
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:
if not (fs_num in fs_mapping and fs_mapping[fs_num]['condition']):
continue
var fs_data = packet_type_7[fs_num]
for rule_key in FS_RULES.size():
var rule: Dictionary = FS_RULES[rule_key]
for rule in fs_rules_config:
if _should_apply_rule(fs_num, rule, updated_results):
updated_results[rule.key] = fs_data.isg
break