352 lines
15 KiB
GDScript
352 lines
15 KiB
GDScript
class TestPRD extends Node:
|
||
enum STATE_VAL { NONE = 0, GOOD = 1, ERROR = 2 }
|
||
# Конфигурация параметров для каждого прибора
|
||
enum STATE_MASHINE {
|
||
INIT,
|
||
FS_TURN_ON,
|
||
FS_WORK,
|
||
UG_SET,
|
||
UM_RUN,
|
||
FS_TURN_OFF,
|
||
STOP_CONTROL,
|
||
AWAIT
|
||
}
|
||
var cur_ray: String = 'ray_25_1'
|
||
var power_result: Dictionary = {
|
||
'ray_25_1': [],
|
||
'ray_25_6': [],
|
||
'ray_25_7' : [],
|
||
}
|
||
var constants: Dictionary
|
||
var pribor_config: Dictionary
|
||
var fs_parameters: Dictionary
|
||
var block_config: Dictionary
|
||
var control_results: Dictionary
|
||
var self_name: String
|
||
var state: int = STATE_MASHINE.INIT
|
||
var control_label: Label
|
||
var current_fs: int = 1
|
||
var flag_check_dkm: bool
|
||
var flag_timer_started: bool
|
||
var unit_prd: Object
|
||
var module_prd: Object
|
||
var power_amplify: Array
|
||
var fs_array_node: Array
|
||
|
||
var control_timer: Timer = Timer.new()
|
||
|
||
func _init(ctrlabel, u_prd, m_prd, constant, prd_config, fs_params, block_prd_config, power_amp, ctrl_results, fs_arr_node) -> void:
|
||
self.control_label = ctrlabel
|
||
self.unit_prd = u_prd
|
||
self.module_prd = m_prd
|
||
self.pribor_config = prd_config
|
||
self.fs_parameters = fs_params
|
||
self.constants = constant
|
||
self.block_config = block_prd_config
|
||
self.power_amplify = power_amp
|
||
self.control_results = ctrl_results
|
||
self.fs_array_node = fs_arr_node
|
||
|
||
func _ready() -> void:
|
||
initialize_connections()
|
||
setup_timer()
|
||
|
||
func _process(_delta: float) -> void:
|
||
pass
|
||
|
||
func on_data_received(unit_pribor: Object) -> void:
|
||
if not is_inside_tree():
|
||
return
|
||
|
||
var status: PackedByteArray = unit_pribor.status
|
||
|
||
block_config = check_block_ip(status, block_config)
|
||
|
||
check_temperature_um(status, power_amplify)
|
||
|
||
if current_fs == 1 and control_results.fs_1:
|
||
control_results = check_dkm(status, constants.DKM_BIT_1, control_results)
|
||
flag_check_dkm = control_results.dkm_1
|
||
elif current_fs == 6 and control_results.fs_6:
|
||
control_results = check_dkm(status, constants.DKM_BIT_6, control_results)
|
||
flag_check_dkm = control_results.fs_6
|
||
elif current_fs == 7 and control_results.fs_7:
|
||
control_results = check_dkm(status, constants.DKM_BIT_7, control_results)
|
||
flag_check_dkm = control_results.dkm_7
|
||
|
||
if control_results.dkm_1 and current_fs == 1:
|
||
power_result['ray_25_1'] = power_um_ukp(status, current_fs, power_result['ray_25_1'])
|
||
if control_results.dkm_6 and current_fs == 6:
|
||
power_result['ray_25_6'] = power_um_ukp(status, current_fs, power_result['ray_25_6'])
|
||
if control_results.dkm_7 and current_fs == 7:
|
||
power_result['ray_25_7'] = power_um_ukp(status, current_fs, power_result['ray_25_7'])
|
||
|
||
|
||
func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary, fs_array: Array) -> void:
|
||
var fs_result: Dictionary
|
||
if current_fs == 1:
|
||
fs_result = {'fs_1': STATE_VAL.NONE}
|
||
elif current_fs == 6:
|
||
fs_result = {'fs_6': STATE_VAL.NONE}
|
||
elif current_fs == 7:
|
||
fs_result = {'fs_7': STATE_VAL.NONE}
|
||
fs_result = on_fs_state(packet_type_7, fs_mapping, fs_result)
|
||
for fs in fs_array:
|
||
var fs_meta: String = fs.get_meta('fs')
|
||
if fs_result.has(fs_meta):
|
||
fs.state = fs_result[fs_meta]
|
||
control_results[fs_meta] = fs_result[fs_meta]
|
||
|
||
|
||
func state_control_machine() -> void:
|
||
match state:
|
||
STATE_MASHINE.INIT:
|
||
control_label.text = 'Выполняется инициализация ФС-%s' % current_fs
|
||
if current_fs == 1 or current_fs == 6 or current_fs == 7:
|
||
state = STATE_MASHINE.FS_TURN_ON
|
||
else:
|
||
on_control_result()
|
||
state = STATE_MASHINE.AWAIT
|
||
|
||
STATE_MASHINE.FS_TURN_ON:
|
||
control_label.text = 'Выполняется включение ФС-%s' % current_fs
|
||
manage_fs(true, self_name, pribor_config, fs_parameters, current_fs, constants.POWER_UM)
|
||
control_timer.wait_time = constants.TIMER_DELAY
|
||
control_timer.start()
|
||
state = STATE_MASHINE.FS_WORK
|
||
|
||
STATE_MASHINE.FS_WORK:
|
||
control_label.text = 'Выполняется проверка ФС-%s' % current_fs
|
||
if (current_fs == 6 and flag_check_dkm and not flag_timer_started) or \
|
||
(current_fs == 7 and flag_check_dkm and not flag_timer_started) or \
|
||
(current_fs == 1 and not flag_timer_started):
|
||
state = STATE_MASHINE.UG_SET
|
||
|
||
STATE_MASHINE.UG_SET:
|
||
control_label.text = 'Выполняется настройка угла (%s) и атт (%s, %s, %s)' % [constants.dou_ray_nuber, constants.attenutor_um_1, constants.attenutor_um_2, constants.attenutor_um_3]
|
||
on_ug_setting()
|
||
state = STATE_MASHINE.UM_RUN
|
||
|
||
STATE_MASHINE.UM_RUN:
|
||
control_label.text = 'Выполняется настройка ЭМС'
|
||
module_prd.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [constants.BASE_ADDR_EMS_G, 6666]])
|
||
flag_timer_started = true
|
||
state = STATE_MASHINE.FS_WORK
|
||
|
||
STATE_MASHINE.FS_TURN_OFF:
|
||
control_label.text = 'Выполняется отключение ФС-%s' % current_fs
|
||
manage_fs(false, self_name, pribor_config, fs_parameters, current_fs, constants.POWER_UM)
|
||
state = STATE_MASHINE.STOP_CONTROL
|
||
|
||
STATE_MASHINE.STOP_CONTROL:
|
||
control_label.text = 'Выполняется завершение проверки ФС-%s' % current_fs
|
||
power_um_control_result()
|
||
flag_timer_started = false
|
||
flag_check_dkm = false
|
||
match current_fs:
|
||
1: current_fs = 6
|
||
6: current_fs = 7
|
||
7: current_fs = 0
|
||
state = STATE_MASHINE.INIT
|
||
|
||
|
||
func initialize_connections() -> void:
|
||
var current_unit = unit_prd.name
|
||
var parts = current_unit.split('-')
|
||
self_name = parts[-1]
|
||
var fs_mapping = {
|
||
0: { 'condition': self_name == '1к' },
|
||
1: { 'condition': self_name == '4к' },
|
||
2: { 'condition': self_name == '3к' },
|
||
3: { 'condition': self_name == '2к' },
|
||
20: { 'condition':self_name == '1к' },
|
||
21: { 'condition': self_name == '4к' },
|
||
22: { 'condition': self_name == '3к' },
|
||
23: { 'condition': self_name == '2к' },
|
||
24: { 'condition': self_name == '1к' },
|
||
25: { 'condition': self_name == '4к' },
|
||
26: { 'condition': self_name == '3к' },
|
||
27: { 'condition': self_name == '2к' },
|
||
}
|
||
signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping, fs_array_node))
|
||
unit_prd.connect('data_received', Callable(self, 'on_data_received'))
|
||
|
||
|
||
func setup_timer() -> void:
|
||
add_child(control_timer)
|
||
control_timer.timeout.connect(on_stop_control)
|
||
control_timer.one_shot = true
|
||
control_timer.wait_time = 10.0
|
||
control_timer.start()
|
||
|
||
|
||
func on_control_result() -> void:
|
||
print('on_control_result')
|
||
|
||
|
||
func on_stop_control() -> void:
|
||
state = STATE_MASHINE.FS_TURN_OFF
|
||
|
||
|
||
func on_ug_setting() -> void:
|
||
var result_1 = ((constants.attenutor_um_1 & 0x07) << 3) | (constants.dou_ray_nuber & 0x07)
|
||
var result_2 = ((constants.attenutor_um_2 & 0x07) << 3) | (constants.dou_ray_nuber & 0x07)
|
||
|
||
module_prd.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [constants.ADDR_UG_LITERA_1, result_1,
|
||
constants.ADDR_UG_LITERA_2, result_2,
|
||
constants.ADDR_UG_LITERA_3, constants.attenutor_um_3]])
|
||
|
||
module_prd.cmd_array.append([unit_prd.CmdCode.READ_ISA, [constants.ADDR_UG_LITERA_1, constants.ADDR_UG_LITERA_2, constants.ADDR_UG_LITERA_3]])
|
||
|
||
|
||
func power_um_control_result() -> void:
|
||
control_results['power_um'] = true
|
||
for amp in power_result[cur_ray]:
|
||
if amp > constants.TEMP_THRESHOLD:
|
||
control_results['power_um'] = false
|
||
break
|
||
|
||
|
||
static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, cur_fs: int, power_um: int) -> void:
|
||
# Получаем конфигурацию для текущего прибора
|
||
var config: Dictionary = p_conf[pribor]
|
||
var angle: float = config.angle
|
||
var sectors: Array = config.sectors
|
||
|
||
# Формируем выходные данные
|
||
var interfer_name: String = 'k1' if mode else 'off'
|
||
var fs_arr: Array = []
|
||
|
||
if cur_fs in fs_params:
|
||
var params = fs_params[cur_fs]
|
||
fs_arr.append([
|
||
angle,
|
||
params.freq,
|
||
params.width,
|
||
sectors[cur_fs - 1] if cur_fs == 1 else sectors[cur_fs - 5]
|
||
])
|
||
|
||
signaller.emit_signal('interfer_init', interfer_name, fs_arr, power_um)
|
||
|
||
## Проверка касет П1 и ИП МА2000
|
||
static func check_block_ip(status_prd: PackedByteArray, block_ip_config: Dictionary) -> Dictionary:
|
||
# Конфигурация проверяемых блоков
|
||
var byte_dry: int = 27
|
||
var ug_online: bool = (status_prd[0] >> 1) & 1
|
||
for block in block_ip_config:
|
||
var bit: int = block_ip_config[block][0]
|
||
if ug_online:
|
||
var status = status_prd[byte_dry] >> bit & 1
|
||
block_ip_config[block][1] = false if status else true
|
||
return block_ip_config
|
||
|
||
## Проверка температур УМ от УКП
|
||
static func check_temperature_um(status_prd: PackedByteArray, power_amplifier: Array) -> void:
|
||
const Constants: Dictionary = {
|
||
'CONST_MIN_TEMP': -25,
|
||
'MAXIMUM_CODE_ADC': 3796,
|
||
'MINIMUM_CODE_AD': 2660,
|
||
'TEMPERATURE_UKP_1': 47,
|
||
'TEMPERATURE_UKP_2': 79,
|
||
}
|
||
const TEMP: float = 115.0 / (Constants.MAXIMUM_CODE_ADC - Constants.MINIMUM_CODE_AD)
|
||
var ukp1_online: int = (status_prd[0] >> 2) & 1
|
||
if ukp1_online:
|
||
var tmp_1: int
|
||
var temperature_ukp_1: int
|
||
for i_temp in 6:
|
||
temperature_ukp_1 = status_prd.decode_u16(Constants.TEMPERATURE_UKP_1 + 2 * i_temp)
|
||
tmp_1 = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_1) * TEMP + 3)
|
||
power_amplifier[i_temp].value0 = tmp_1
|
||
# Темпуратура от УМ литеры 1
|
||
temperature_ukp_1 = status_prd.decode_u16(Constants.TEMPERATURE_UKP_1 + 2 * 7)
|
||
tmp_1 = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_1) * TEMP + 3)
|
||
power_amplifier[6].value0 = tmp_1
|
||
|
||
var ukp2_online = (status_prd[0] >> 3) & 1
|
||
if ukp2_online:
|
||
for i_temp in 6:
|
||
var temperature_ukp_2: int = status_prd.decode_u16(Constants.TEMPERATURE_UKP_2 + 2 * i_temp)
|
||
var tmp_2: int = round(Constants.CONST_MIN_TEMP + (Constants.MAXIMUM_CODE_ADC - temperature_ukp_2) * TEMP + 3)
|
||
power_amplifier[i_temp+7].value0 = tmp_2
|
||
|
||
|
||
## Проверка ДКМ
|
||
static func check_dkm(status_prd: PackedByteArray, bit_dkm: int, dkm_result: Dictionary) -> Dictionary:
|
||
var dkm: int = 28
|
||
var status_dkm = status_prd[dkm] >> bit_dkm & 1
|
||
if bit_dkm == 0:
|
||
dkm_result['dkm_1'] = status_dkm
|
||
elif bit_dkm == 5:
|
||
dkm_result['dkm_6'] = status_dkm
|
||
elif bit_dkm == 6:
|
||
dkm_result['dkm_7'] = status_dkm
|
||
return dkm_result
|
||
|
||
|
||
static func on_fs_state(packet_type_7: Dictionary, fs_mapping: Dictionary, fs_results: Dictionary) -> Dictionary:
|
||
for fs in packet_type_7:
|
||
if fs in fs_mapping and fs_mapping[fs]['condition']:
|
||
var data = packet_type_7[fs]
|
||
if fs < 4 and fs_results.has('fs_1'):
|
||
fs_results['fs_1'] = data.isg
|
||
elif fs < 24 and fs_results.has('fs_6'):
|
||
fs_results['fs_6'] = data.isg
|
||
elif fs > 23 and fs_results.has('fs_7'):
|
||
fs_results['fs_7'] = data.isg
|
||
return fs_results
|
||
|
||
|
||
static func power_um_ukp(status: PackedByteArray, crnt_fs: int, pwr_result: Array) -> Array:
|
||
const Constants: Dictionary = {'POWER_UKP_1' : 31, 'POWER_UKP_2': 63, 'TEMP_THRESHOLD': 40}
|
||
var power_values: Array = []
|
||
var base_offset = 0
|
||
var is_data_valid = false
|
||
var iteration: int = 6
|
||
|
||
match crnt_fs:
|
||
1:
|
||
# Обработка для current_fs = 1 (одно значение)
|
||
var value = status.decode_u16(Constants.POWER_UKP_1 + 2 * 7)
|
||
power_values = [value]
|
||
is_data_valid = true
|
||
|
||
6:
|
||
# Обработка для current_fs = 6 (6 значений из УКП1)
|
||
base_offset = Constants.POWER_UKP_1
|
||
is_data_valid = (status[0] >> 2) & 1
|
||
if is_data_valid:
|
||
for i in iteration:
|
||
power_values.append(status.decode_u16(base_offset + 2 * i))
|
||
|
||
7:
|
||
# Обработка для current_fs = 7 (6 значений из УКП2)
|
||
base_offset = Constants.POWER_UKP_2
|
||
is_data_valid = (status[0] >> 2) & 1
|
||
if is_data_valid:
|
||
for i in iteration:
|
||
power_values.append(status.decode_u16(base_offset + 2 * i))
|
||
|
||
power_values = update_max_power_values(power_values, pwr_result)
|
||
|
||
return power_values
|
||
|
||
|
||
## Обновление максимальных значений
|
||
static func update_max_power_values(power_data: Array, max_power_values: Array) -> Array:
|
||
if power_data.size() != 6:
|
||
if max_power_values.is_empty():
|
||
max_power_values = power_data.duplicate()
|
||
elif power_data[0] > max_power_values[0]:
|
||
max_power_values = power_data.duplicate()
|
||
return max_power_values
|
||
|
||
if max_power_values.is_empty():
|
||
max_power_values = power_data.duplicate()
|
||
else:
|
||
for i in 6:
|
||
if power_data[i] > max_power_values[i]:
|
||
max_power_values[i] = power_data[i]
|
||
|
||
return max_power_values.duplicate()
|