550 lines
22 KiB
GDScript
550 lines
22 KiB
GDScript
extends "res://scenes/контроль/прибор.gd"
|
||
|
||
const Constants = {
|
||
"IN_BLANK_PRD": 1,
|
||
"OUT_BLANK_PRD": 13,
|
||
"CI_1_OT_FS": 8,
|
||
"CI_6_OT_FS": 13,
|
||
"CI_7_OT_FS": 14,
|
||
"CI_1_B_UF": 3,
|
||
"CI_6_B_UF": 4,
|
||
"CI_7_B_UF": 5,
|
||
"CONST_MIN_TEMP": -25,
|
||
"MAXIMUM_CODE_ADC": 3796,
|
||
"MINIMUM_CODE_AD": 2660,
|
||
"TEMPERATURE_UKP_1": 47,
|
||
"TEMPERATURE_UKP_2": 79,
|
||
"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": 70,
|
||
"POWER_THRESHOLD": 40,
|
||
"TIMER_DELAY": 5.0,
|
||
"dou_ray_nuber": 0x3,
|
||
"attenutor_um_1": 0x7,
|
||
"attenutor_um_2": 0x7,
|
||
"attenutor_um_3": 0x7,
|
||
"POWER_UM": 75,
|
||
}
|
||
enum STATE_VAL { NONE = 0, GOOD = 1, ERROR = 2 }
|
||
enum STATE_MASHINE { INIT,
|
||
FS_1_TURN_ON,
|
||
FS_6_TURN_ON,
|
||
FS_7_TURN_ON,
|
||
FS_1_WORK,
|
||
FS_6_WORK,
|
||
FS_7_WORK,
|
||
UM_RUN_1,
|
||
UM_RUN_6,
|
||
UM_RUN_7,
|
||
FS_1_TURN_OFF,
|
||
FS_6_TURN_OFF,
|
||
FS_7_TURN_OFF,
|
||
STOP_CONTROL_1,
|
||
STOP_CONTROL_6,
|
||
STOP_CONTROL_7 }
|
||
# Основные переменные
|
||
var state: int = STATE_MASHINE.INIT
|
||
var count_packet_1:int = 0
|
||
var count_packet_6:int = 0
|
||
var count_packet_7:int = 0
|
||
var power_array_1: Array = []
|
||
var power_array_2: Array = []
|
||
var ug_work_1: int
|
||
var ug_work_2: int
|
||
var ug_work_3: int
|
||
# Флаги и таймеры
|
||
var control_timer: Timer = Timer.new()
|
||
var mashine_timer: Timer = Timer.new()
|
||
var flag_timer_started: bool = false
|
||
var flag_check_dkm_1: bool = false
|
||
var flag_check_dkm_6: bool = false
|
||
var flag_check_dkm_7: bool = false
|
||
var pribor: String
|
||
# Результаты контроля
|
||
var _control_results: Dictionary = {
|
||
"block_ip": false, # Проверка касет П1 и ИП МА2000
|
||
"temperature": true, # Проверка температур УМ
|
||
"dkm_1": false, # Проверка ДКМ 1
|
||
"dkm_6": false, # Проверка ДКМ 6
|
||
"dkm_7": false, # Проверка ДКМ 7
|
||
"power_ukp": false, # Мощность от УКП
|
||
"fs_1": false, # Проверка ФС 1
|
||
"fs_6": false, # Проверка ФС 6
|
||
"fs_7": false, # Проверка ФС 7
|
||
}
|
||
|
||
|
||
func _ready() -> void:
|
||
initialize_connections()
|
||
setup_timer()
|
||
set_default_state()
|
||
|
||
|
||
func on_state_mashine() -> void:
|
||
match state:
|
||
STATE_MASHINE.INIT:
|
||
state = STATE_MASHINE.FS_1_TURN_ON
|
||
|
||
STATE_MASHINE.FS_6_TURN_ON:
|
||
_on_control_fs(true)
|
||
control_timer.wait_time = Constants.TIMER_DELAY
|
||
control_timer.start()
|
||
state = STATE_MASHINE.FS_6_WORK
|
||
|
||
STATE_MASHINE.FS_6_WORK:
|
||
if flag_check_dkm_6 and not flag_timer_started:
|
||
state = STATE_MASHINE.UM_RUN_6
|
||
|
||
STATE_MASHINE.UM_RUN_6:
|
||
var unit_key = settings.get_unit_key(get_meta('unit_name')[0])
|
||
var unit_prd = network.units[unit_key]
|
||
var prd_module = prd.prd_dict[unit_prd.name]
|
||
prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.BASE_ADDR_EMS_G, 6666]])
|
||
flag_timer_started = true
|
||
state = STATE_MASHINE.FS_6_WORK
|
||
|
||
STATE_MASHINE.FS_6_TURN_OFF:
|
||
_on_control_fs(false)
|
||
power_control_result()
|
||
state = STATE_MASHINE.STOP_CONTROL_6
|
||
|
||
STATE_MASHINE.FS_7_TURN_ON:
|
||
_on_control_fs(true)
|
||
control_timer.wait_time = Constants.TIMER_DELAY
|
||
control_timer.start()
|
||
state = STATE_MASHINE.FS_7_WORK
|
||
|
||
STATE_MASHINE.FS_7_WORK:
|
||
if flag_check_dkm_7 and not flag_timer_started:
|
||
state = STATE_MASHINE.UM_RUN_7
|
||
|
||
STATE_MASHINE.UM_RUN_7:
|
||
var unit_key = settings.get_unit_key(get_meta('unit_name')[0])
|
||
var unit_prd = network.units[unit_key]
|
||
var prd_module = prd.prd_dict[unit_prd.name]
|
||
prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.BASE_ADDR_EMS_G, 6666]])
|
||
flag_timer_started = true
|
||
state = STATE_MASHINE.FS_7_WORK
|
||
|
||
STATE_MASHINE.FS_7_TURN_OFF:
|
||
_on_control_fs(false)
|
||
power_control_result()
|
||
on_control_result()
|
||
state = STATE_MASHINE.STOP_CONTROL_7
|
||
|
||
STATE_MASHINE.FS_1_TURN_ON:
|
||
_on_control_fs(true)
|
||
control_timer.wait_time = Constants.TIMER_DELAY
|
||
control_timer.start()
|
||
state = STATE_MASHINE.FS_1_WORK
|
||
|
||
STATE_MASHINE.FS_1_WORK:
|
||
if not flag_timer_started:
|
||
state = STATE_MASHINE.UM_RUN_1
|
||
|
||
STATE_MASHINE.UM_RUN_1:
|
||
var unit_key = settings.get_unit_key(get_meta('unit_name')[0])
|
||
var unit_prd = network.units[unit_key]
|
||
var prd_module = prd.prd_dict[unit_prd.name]
|
||
prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.BASE_ADDR_EMS_G, 6666]])
|
||
flag_timer_started = true
|
||
state = STATE_MASHINE.FS_1_WORK
|
||
|
||
STATE_MASHINE.FS_1_TURN_OFF:
|
||
_on_control_fs(false)
|
||
power_control_result()
|
||
state = STATE_MASHINE.STOP_CONTROL_1
|
||
|
||
STATE_MASHINE.STOP_CONTROL_1:
|
||
flag_timer_started = false
|
||
state = STATE_MASHINE.FS_6_TURN_ON
|
||
STATE_MASHINE.STOP_CONTROL_6:
|
||
flag_timer_started = false
|
||
state = STATE_MASHINE.FS_7_TURN_ON
|
||
STATE_MASHINE.STOP_CONTROL_7:
|
||
flag_timer_started = false
|
||
|
||
|
||
func initialize_connections() -> void:
|
||
signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state'))
|
||
var unit_key = settings.get_unit_key(get_meta('unit_name')[0])
|
||
var unit_prd = network.units[unit_key]
|
||
var currecnt_unit = unit_prd.name
|
||
var parts = currecnt_unit.split('-')
|
||
pribor = parts[-1]
|
||
unit_prd.connect('data_received', Callable(self, 'on_data_received'))
|
||
unit_prd.connect('line_changed', Callable(self, 'on_line_changed'))
|
||
|
||
|
||
func setup_timer() -> void:
|
||
add_child(mashine_timer)
|
||
mashine_timer.connect('timeout', Callable(self, 'on_state_mashine'))
|
||
mashine_timer.wait_time = 0.5
|
||
mashine_timer.start()
|
||
|
||
add_child(control_timer)
|
||
control_timer.connect('timeout', Callable(self, 'on_stop_control'))
|
||
control_timer.one_shot = true
|
||
control_timer.wait_time = 10.0
|
||
control_timer.start()
|
||
|
||
|
||
func set_default_state() -> void:
|
||
for group in get_tree().get_nodes_in_group('default_reset'):
|
||
group.state = STATE_VAL.NONE
|
||
|
||
for group in get_tree().get_nodes_in_group('power_amplifier'):
|
||
group.state = STATE_VAL.NONE
|
||
|
||
|
||
func _enter_tree() -> void:
|
||
$control_result.text = ''
|
||
signaller.connect('режим_работа', Callable(self, 'on_mode_changed').bind(false))
|
||
|
||
|
||
func _exit_tree() -> void:
|
||
var unit_key = settings.get_unit_key(get_meta('unit_name')[0])
|
||
var unit_prd = network.units[unit_key]
|
||
var prd_module = prd.prd_dict[unit_prd.name]
|
||
|
||
prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.ADDR_UG_LITERA_1, ug_work_1, Constants.ADDR_UG_LITERA_2, ug_work_2]])
|
||
|
||
|
||
func on_line_changed(unit_prd: Object) -> void:
|
||
if not unit_prd.online:
|
||
set_default_state()
|
||
|
||
|
||
func on_data_received(unit_prd: Object) -> void:
|
||
if not is_inside_tree():
|
||
return
|
||
|
||
var status = unit_prd.status
|
||
check_block_ip(status)
|
||
check_temperature_um(status)
|
||
# Обработка данных ЭМС
|
||
_process_ems_data(status)
|
||
|
||
flag_check_dkm_1 = check_dkm(status, Constants.DKM_BIT_1)
|
||
flag_check_dkm_6 = check_dkm(status, Constants.DKM_BIT_6)
|
||
flag_check_dkm_7 = check_dkm(status, Constants.DKM_BIT_7)
|
||
if flag_check_dkm_1 or flag_check_dkm_6 or flag_check_dkm_7:
|
||
_process_ukp_power(status)
|
||
|
||
|
||
# Обрабатывает данные ЭМС и обновляет UI панели
|
||
func _process_ems_data(status: PackedByteArray) -> void:
|
||
## Контроль ЭМС
|
||
var in_blank: int = status.decode_u16(Constants.IN_BLANK_PRD)
|
||
var out_blank: int = status.decode_u16(Constants.OUT_BLANK_PRD)
|
||
|
||
# Обновление фреймов для входных сигналов
|
||
$Monitoring_panel/in_fs_1.frame = (in_blank >> Constants.CI_6_OT_FS) & 1
|
||
$Monitoring_panel/in_fs_2.frame = (in_blank >> Constants.CI_7_OT_FS) & 1
|
||
$Monitoring_panel/in_fs_3.frame = (in_blank >> Constants.CI_1_OT_FS) & 1
|
||
|
||
# Обновление фреймов для выходных сигналов ЭМС
|
||
$Monitoring_panel/out_ems_1.frame = (out_blank >> Constants.CI_6_B_UF) & 1
|
||
$Monitoring_panel/out_ems_2.frame = (out_blank >> Constants.CI_7_B_UF) & 1
|
||
$Monitoring_panel/out_ems_3.frame = (out_blank >> Constants.CI_1_B_UF) & 1
|
||
|
||
|
||
## Проверка касет П1 и ИП МА2000
|
||
func check_block_ip(status_prd: PackedByteArray) -> void :
|
||
var ug_online: bool = (status_prd[0] >> 1) & 1
|
||
if ug_online:
|
||
const BYTE_DRY_CONTACT: int = 27
|
||
const BIT_MAA2000_1: int = 0
|
||
const BIT_MAA2000_2: int = 1
|
||
const BIT_IP9_50_1: int = 2
|
||
const BIT_IP9_50_2: int = 3
|
||
const BIT_IP12_50_1: int = 4
|
||
const BIT_IP9_50_3: int = 5
|
||
const BIT_IP12_50_2: int = 6
|
||
|
||
var maa2000_1 = status_prd[BYTE_DRY_CONTACT] >> BIT_MAA2000_1 & 1
|
||
var maa2000_2 = status_prd[BYTE_DRY_CONTACT] >> BIT_MAA2000_2 & 1
|
||
var ip9_50_1 = status_prd[BYTE_DRY_CONTACT] >> BIT_IP9_50_1 & 1
|
||
var ip9_50_2 = status_prd[BYTE_DRY_CONTACT] >> BIT_IP9_50_2 & 1
|
||
var ip12_50_1 = status_prd[BYTE_DRY_CONTACT] >> BIT_IP12_50_1 & 1
|
||
var ip9_50_3 = status_prd[BYTE_DRY_CONTACT] >> BIT_IP9_50_3 & 1
|
||
var ip12_50_2 = status_prd[BYTE_DRY_CONTACT] >> BIT_IP12_50_2 & 1
|
||
|
||
$maa2000_A23.state = STATE_VAL.ERROR if maa2000_1 else STATE_VAL.GOOD
|
||
$maa2000_A22.state = STATE_VAL.ERROR if maa2000_2 else STATE_VAL.GOOD
|
||
$kasseta_p_1/ref_A26.state = STATE_VAL.ERROR if ip9_50_1 else STATE_VAL.GOOD
|
||
$kasseta_p_1/ref_A23.state = STATE_VAL.ERROR if ip9_50_2 else STATE_VAL.GOOD
|
||
$kasseta_p_1/ref_A24.state = STATE_VAL.ERROR if ip12_50_1 else STATE_VAL.GOOD
|
||
$kasseta_p_2/ref_A26.state = STATE_VAL.ERROR if ip9_50_3 else STATE_VAL.GOOD
|
||
$kasseta_p_2/ref_A23.state = STATE_VAL.ERROR if ip12_50_2 else STATE_VAL.GOOD
|
||
else:
|
||
$maa2000_A23.state = STATE_VAL.NONE
|
||
$maa2000_A22.state = STATE_VAL.NONE
|
||
$kasseta_p_1/ref_A26.state = STATE_VAL.NONE
|
||
$kasseta_p_1/ref_A23.state = STATE_VAL.NONE
|
||
$kasseta_p_1/ref_A24.state = STATE_VAL.NONE
|
||
$kasseta_p_2/ref_A26.state = STATE_VAL.NONE
|
||
$kasseta_p_2/ref_A23.state = STATE_VAL.NONE
|
||
|
||
_control_results["block_ip"] = (
|
||
$maa2000_A23.state == STATE_VAL.GOOD and
|
||
$maa2000_A22.state == STATE_VAL.GOOD and
|
||
$kasseta_p_1/ref_A26.state == STATE_VAL.GOOD and
|
||
$kasseta_p_1/ref_A23.state == STATE_VAL.GOOD and
|
||
$kasseta_p_1/ref_A24.state == STATE_VAL.GOOD and
|
||
$kasseta_p_2/ref_A26.state == STATE_VAL.GOOD and
|
||
$kasseta_p_2/ref_A23.state == STATE_VAL.GOOD
|
||
)
|
||
|
||
|
||
## Проверка температур УМ от УКП
|
||
func check_temperature_um(status_prd: PackedByteArray) -> void:
|
||
var power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
|
||
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 range(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 range(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
|
||
|
||
|
||
## Проверка ДКМ
|
||
func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool:
|
||
const DKM: int = 28
|
||
|
||
var status_dkm = status_prd[DKM] >> bit_dkm & 1
|
||
if bit_dkm == 5 and state == STATE_MASHINE.FS_6_WORK:
|
||
$dou6_A7.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
|
||
$kasseta_fs_kd/ref_A4.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
|
||
_control_results["dkm_6"] = status_dkm
|
||
elif bit_dkm == 6 and state == STATE_MASHINE.FS_7_WORK:
|
||
$dou7_A8.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
|
||
$kasseta_fs_kd/ref_A7.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
|
||
_control_results["dkm_7"] = status_dkm
|
||
elif bit_dkm == 0 and state == STATE_MASHINE.FS_1_WORK:
|
||
$kasseta_fs_kd/ref_A2.state = STATE_VAL.GOOD if status_dkm else STATE_VAL.ERROR
|
||
_control_results["dkm_1"] = status_dkm
|
||
return status_dkm
|
||
|
||
|
||
func _process_ukp_power(status: PackedByteArray) -> void:
|
||
var power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
|
||
if state == STATE_MASHINE.FS_1_WORK:
|
||
## Мощность от УМ (УКП) литеры 1
|
||
var arr_power_ukp_1: Array = []
|
||
var power_ukp_1: int
|
||
power_ukp_1 = status.decode_u16(Constants.POWER_UKP_1 + 2 * 7)
|
||
arr_power_ukp_1.append(power_ukp_1)
|
||
|
||
if count_packet_1 == 0:
|
||
power_array_1 = arr_power_ukp_1
|
||
else:
|
||
for i in arr_power_ukp_1.size():
|
||
if arr_power_ukp_1[i] > power_array_1[i]:
|
||
power_array_1[i] = arr_power_ukp_1[i]
|
||
|
||
power_amplifier[6].value1 = '%d' % power_array_1[0]
|
||
power_amplifier[6].state = STATE_VAL.GOOD if power_array_1[0] > Constants.TEMP_THRESHOLD else STATE_VAL.ERROR
|
||
|
||
count_packet_1 += 1
|
||
|
||
elif state == STATE_MASHINE.FS_6_WORK:
|
||
## Мощность УМ от УКП 1
|
||
var arr_power_ukp_1: Array = []
|
||
if (status[0] >> 2) & 1:
|
||
var power_ukp_1: int
|
||
for i_power in range(6):
|
||
power_ukp_1 = status.decode_u16(Constants.POWER_UKP_1 + 2 * i_power)
|
||
arr_power_ukp_1.append(power_ukp_1)
|
||
|
||
if count_packet_6 == 0:
|
||
power_array_1 = arr_power_ukp_1
|
||
else:
|
||
for i in arr_power_ukp_1.size():
|
||
if arr_power_ukp_1[i] > power_array_1[i]:
|
||
power_array_1[i] = arr_power_ukp_1[i]
|
||
|
||
for i in 6:
|
||
power_amplifier[i].value1 = '%d' % power_array_1[i]
|
||
power_amplifier[i].state = STATE_VAL.GOOD if power_array_1[i] > Constants.TEMP_THRESHOLD else STATE_VAL.ERROR
|
||
count_packet_6 += 1
|
||
|
||
elif state == STATE_MASHINE.FS_7_WORK:
|
||
## Мощность УМ от УКП 2
|
||
var arr_power_ukp_2: Array = []
|
||
if (status[0] >> 2) & 1:
|
||
for i_power in range(6):
|
||
var power_ukp_2 = status.decode_u16(Constants.POWER_UKP_2 + 2 * i_power)
|
||
arr_power_ukp_2.append(power_ukp_2)
|
||
|
||
if count_packet_7 == 0:
|
||
power_array_2 = arr_power_ukp_2
|
||
else:
|
||
for i in arr_power_ukp_2.size():
|
||
if arr_power_ukp_2[i] > power_array_2[i]:
|
||
power_array_2[i] = arr_power_ukp_2[i]
|
||
|
||
for i in 6:
|
||
power_amplifier[i+7].value1 = '%d' % power_array_2[i]
|
||
power_amplifier[i+7].state = STATE_VAL.GOOD if power_array_2[i] > Constants.TEMP_THRESHOLD else STATE_VAL.ERROR
|
||
|
||
count_packet_7 += 1
|
||
|
||
|
||
func power_control_result() -> void:
|
||
var power_amplifier: Array = get_tree().get_nodes_in_group('power_amplifier')
|
||
_control_results["power_ukp"] = true
|
||
for amp in power_amplifier:
|
||
if amp.state != STATE_VAL.GOOD:
|
||
_control_results["power_ukp"] = false
|
||
break
|
||
|
||
|
||
func _on_control_fs(mode: bool) -> void:
|
||
var angle: float = 0.0
|
||
var sector_1: float = 0
|
||
var sector_2: float = 20
|
||
var sector_3: float = 24
|
||
if pribor == '2к':
|
||
angle = 90.0
|
||
sector_1 = 3
|
||
sector_2 = 23
|
||
sector_3 = 27
|
||
elif pribor == '3к':
|
||
angle = 180.0
|
||
sector_1 = 2
|
||
sector_2 = 22
|
||
sector_3 = 26
|
||
elif pribor == '4к':
|
||
angle = 270.0
|
||
sector_1 = 1
|
||
sector_2 = 21
|
||
sector_3 = 25
|
||
|
||
var interfer_name: String = 'k1' if mode else 'off'
|
||
var freq_1: float = 450.0 # ФС_1
|
||
var freq_2: float = 2450.0 # ФС_2
|
||
var freq_3: float = 5800.0 # ФС_3
|
||
var width_1: float = 80.0 # ФС_1
|
||
var width_2: float = 110.0 # ФС_2
|
||
var width_3: float = 110.0 # ФС_3
|
||
|
||
var fs_arr: Array = []
|
||
if state == STATE_MASHINE.FS_1_TURN_ON or state == STATE_MASHINE.FS_1_TURN_OFF:
|
||
fs_arr.append([angle, freq_1, width_1, sector_1])
|
||
elif state == STATE_MASHINE.FS_6_TURN_ON or state == STATE_MASHINE.FS_6_TURN_OFF:
|
||
fs_arr.append([angle, freq_2, width_2, sector_2])
|
||
elif STATE_MASHINE.FS_7_TURN_ON or state == STATE_MASHINE.FS_7_TURN_OFF:
|
||
fs_arr.append([angle, freq_3, width_3, sector_3])
|
||
signaller.emit_signal('interfer_init', interfer_name, fs_arr, Constants.POWER_UM)
|
||
|
||
|
||
func on_stop_control() -> void:
|
||
if state == STATE_MASHINE.FS_1_WORK:
|
||
state = STATE_MASHINE.FS_1_TURN_OFF
|
||
elif state == STATE_MASHINE.FS_6_WORK:
|
||
state = STATE_MASHINE.FS_6_TURN_OFF
|
||
elif state == STATE_MASHINE.FS_7_WORK:
|
||
state = STATE_MASHINE.FS_7_TURN_OFF
|
||
|
||
|
||
func on_fs_update_state(packet_type_7: Dictionary) -> void:
|
||
# Словарь для маппинга: ключ - номер FS, значение - целевая нода и условие прибора
|
||
var fs_mapping = {
|
||
0: { "node": $kasseta_fs_kd/ref_A3, "condition": pribor == '1к' },
|
||
1: { "node": $kasseta_fs_kd/ref_A3, "condition": pribor == '4к' },
|
||
2: { "node": $kasseta_fs_kd/ref_A3, "condition": pribor == '3к' },
|
||
3: { "node": $kasseta_fs_kd/ref_A3, "condition": pribor == '2к' },
|
||
20: { "node": $kasseta_fs_kd/ref_A6, "condition": pribor == '1к' },
|
||
21: { "node": $kasseta_fs_kd/ref_A6, "condition": pribor == '4к' },
|
||
22: { "node": $kasseta_fs_kd/ref_A6, "condition": pribor == '3к' },
|
||
23: { "node": $kasseta_fs_kd/ref_A6, "condition": pribor == '2к' },
|
||
24: { "node": $kasseta_fs_kd/ref_A5, "condition": pribor == '1к' },
|
||
25: { "node": $kasseta_fs_kd/ref_A5, "condition": pribor == '4к' },
|
||
26: { "node": $kasseta_fs_kd/ref_A5, "condition": pribor == '3к' },
|
||
27: { "node": $kasseta_fs_kd/ref_A5, "condition": pribor == '2к' },
|
||
}
|
||
for fs in packet_type_7:
|
||
if fs in fs_mapping and fs_mapping[fs]["condition"]:
|
||
var data = packet_type_7[fs]
|
||
var state_fs = STATE_VAL.GOOD if data.isg == 1 else STATE_VAL.ERROR if data.isg == 0 else STATE_VAL.NONE
|
||
fs_mapping[fs]["node"].state = state_fs
|
||
if fs < 4:
|
||
_control_results["fs_1"] = (data.isg == 1)
|
||
elif fs <24:
|
||
_control_results["fs_6"] = (data.isg == 1)
|
||
else:
|
||
_control_results["fs_7"] = (data.isg == 1)
|
||
|
||
|
||
func on_ug_setting() -> void:
|
||
var unit_key = settings.get_unit_key(get_meta('unit_name')[0])
|
||
var unit_prd = network.units[unit_key]
|
||
|
||
if unit_prd.isa_ports.has(Constants.ADDR_UG_LITERA_1):
|
||
ug_work_1 = unit_prd.isa_ports[Constants.ADDR_UG_LITERA_1]
|
||
if unit_prd.isa_ports.has(Constants.ADDR_UG_LITERA_2):
|
||
ug_work_2 = unit_prd.isa_ports[Constants.ADDR_UG_LITERA_2]
|
||
if unit_prd.isa_ports.has(Constants.ADDR_UG_LITERA_3):
|
||
ug_work_3 = unit_prd.isa_ports[Constants.ADDR_UG_LITERA_3]
|
||
|
||
var result_1 = ((Constants.attenutor_um_1 & 0x07) << 3) | (Constants.dou_ray_nuber & 0x07)
|
||
var result_2 = ((Constants.attenutor_um_2 & 0x07) << 3) | (Constants.dou_ray_nuber & 0x07)
|
||
var prd_module = prd.prd_dict[unit_prd.name]
|
||
prd_module.cmd_array.append([unit_prd.CmdCode.WRITE_ISA, [Constants.ADDR_UG_LITERA_1, result_1,
|
||
Constants.ADDR_UG_LITERA_2, result_2,
|
||
Constants.ADDR_UG_LITERA_3, Constants.attenutor_um_3,
|
||
Constants.BASE_ADDR_EMS_G, 6666]])
|
||
|
||
prd_module.cmd_array.append([unit_prd.CmdCode.READ_ISA, [Constants.ADDR_UG_LITERA_1, Constants.ADDR_UG_LITERA_2, Constants.ADDR_UG_LITERA_3]])
|
||
|
||
|
||
func on_mode_changed(in_tree: bool) -> void:
|
||
if not in_tree:
|
||
queue_free()
|
||
|
||
|
||
func on_control_result() -> void:
|
||
var result: bool = true
|
||
|
||
for key in _control_results:
|
||
if not _control_results[key]:
|
||
if key == 'fs_1':
|
||
$kasseta_fs_kd/ref_A3.state = STATE_VAL.ERROR
|
||
if key == 'fs_6':
|
||
$kasseta_fs_kd/ref_A6.state = STATE_VAL.ERROR
|
||
if key == 'fs_7':
|
||
$kasseta_fs_kd/ref_A5.state = STATE_VAL.ERROR
|
||
result = false
|
||
#print_debug('%s false' % key)
|
||
|
||
if result:
|
||
$control_result.text = 'Прибор ПРД-%s исправен' % pribor
|
||
$control_result.add_theme_color_override("font_color", Color.AQUAMARINE)
|
||
else:
|
||
$control_result.text = 'Прибор ПРД-%s неисправен' % pribor
|
||
$control_result.add_theme_color_override("font_color", Color.CRIMSON)
|
||
await get_tree().create_timer(Constants.TIMER_DELAY).timeout
|
||
flag_timer_started = false
|