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

Merge remote-tracking branch 'origin/master-prd'

Browse Source 
# Conflicts:
#	scenes/контроль/контроль.tscn
This commit is contained in:
sasha80
2025-09-02 14:32:37 +03:00
parent 945f621a59 b444bb4d5e
commit 0fb6610b68
13 changed files with 561 additions and 739 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
scripts/interfer.gd
View File

@@ -206,7 +206,6 @@ func on_data_capsrpb_received(unit0: capsrpb.CapsRpb, ecms: Dictionary) -> void:
if not unit0.json_dic.has('msvk'): return
if not (unit0.json_dic['msvk'] is Array): return
var msvk = unit0.json_dic['msvk']
var sz: = ecms.size()
for dic_msvk in msvk:
if not (dic_msvk is Dictionary): continue
if dic_msvk.has('ispp'):
@@ -220,8 +219,6 @@ func on_data_capsrpb_received(unit0: capsrpb.CapsRpb, ecms: Dictionary) -> void:
ecm.set_from_dic(dic_msvk)
ecm.krp = INTERFER_OFF
send_ecm(ecm, unit0)
if sz != ecms.size():
call_deferred('emit_signal', 'interfer_resized', ecms)
## Вызыватся, когда пользователь выбрал помеху и выбраны цели.
@@ -282,6 +279,7 @@ func on_interfer_rcv(interfer_params: Array, unit0, ecms) -> void:
func interfer_create(u, interfer_name, ecms, param, kni, id, dict, source_interfer, power) -> void:
var sz = ecms.size()
var ispp: int = 0
if interfer_name == 'k1':
param['dur'] = 1.0 # Необходимо добавить параметры управления
@@ -326,6 +324,8 @@ func interfer_create(u, interfer_name, ecms, param, kni, id, dict, source_interf
thrs.erase(ispp)
ecm.tick_tx = Time.get_ticks_msec()
send_ecm(ecm, u)
if sz != ecms.size():
call_deferred('emit_signal', 'interfer_resized', ecms)
func send_ecm(ecm, unit0) -> void:

9
scripts/prd.gd
View File

@@ -118,6 +118,7 @@ class Fs:
var pow_caps_rx: float = 0.0 ## Мощность излучения принятая от КАПС РПБ
var freq_caps_rx: float = 0.0 ## Частота принятая от КАПС РПБ
var width_caps_rx: float = 0.0 ## Ширина полосы принятая от КАПС РПБ
var msvk: Array
signal update_modulation(index)
@@ -329,6 +330,7 @@ func update_fs_state(ecms):
for prd_module in prd_dict.values(): ## Отправка команды на исполнение в ПРД
if prd_module.state != PrdState.WORK: continue
if not prd_module.unit_yau07.online: continue
prd_module.cmd_array.append([prd_module.unit_yau07.CmdCode.WRITE_ISA, [prd_module.yemsg_board.base_addr_isa, 6666]])
var um_data_array: Array = []
for fs in prd_module.fs_dic.values():
if not prd_module.ug_online: continue
@@ -352,9 +354,9 @@ func check_dir():
## Производит приём состояния модулей ФС.
func on_data_capsrpb_received(unit0: capsrpb.CapsRpb):
if not unit0.json_dic.has('ts'): return
if unit0.json_dic['ts'] != 7: return
if not unit0.json_dic.has('msfs'): return
if not unit0.json_dic.has('ts'): return
if not unit0.json_dic['ts'] == 7: return
if not unit0.json_dic.has('msfs'): return
var msfs = unit0.json_dic['msfs']
for fs in msfs:
@@ -376,6 +378,7 @@ func on_data_capsrpb_received(unit0: capsrpb.CapsRpb):
fs_module.freq_caps_rx = int(fs['freq'])
if fs.has('width'):
fs_module.width_caps_rx = int(fs['width'])
signaller.emit_signal('fs_update_state', fs_dict)

276
scripts/pribor-prd.gd
View File

@@ -5,7 +5,6 @@ class TestPRD extends Node:
const RAY_25:= 'RAY_25'
const RAY_35:= 'RAY_35'
const RAY_45:= 'RAY_45'
enum STATE_VAL { NONE = 0, GOOD = 1, ERROR = 2 }
enum STATE_MASHINE {
INIT,
FS_TURN_ON,
@@ -56,13 +55,11 @@ class TestPRD extends Node:
var pribor_config: Dictionary
var fs_parameters: Dictionary
var block_ip_config: Dictionary
var block_dkm_config: Dictionary
var block_fs_config: Dictionary
var block_kasseta_y5_config: Dictionary
var control_results: Dictionary
var self_name: String
var state: int = STATE_MASHINE.INIT
var current_fs: int
var current_litera: int
var flag_timer_started: bool = false
var unit_prd: Object
var module_prd: Object
@@ -70,8 +67,10 @@ class TestPRD extends Node:
var control_label: Label
var control_timer: Timer = Timer.new()
var ems_6666_timer: Timer = Timer.new()
signal control_is_over(control_results)
signal control_is_over(control_results, power_result)
var ecms: Dictionary ## Словарь помеховых воздействий
## Инициализация аргуметнов
func _init(init_data: Dictionary) -> void:
@@ -83,11 +82,9 @@ class TestPRD extends Node:
pribor_config = init_data['prd_config']
fs_parameters = init_data['fs_params']
block_ip_config = init_data['block_ip_prd_config']
block_dkm_config = init_data['block_dkm_prd_config']
block_fs_config = init_data['block_fs_prd_config']
block_kasseta_y5_config = init_data['block_kasseta_y5_prd_config']
control_results = init_data['control_results']
current_fs = init_data['current_fs']
current_litera = init_data['current_litera']
func _ready() -> void:
@@ -107,25 +104,25 @@ class TestPRD extends Node:
var status: PackedByteArray = unit_pribor.status
block_kasseta_y5_config = check_block_kasseta_y5(status, block_kasseta_y5_config)
block_ip_config = check_block_ip(status, block_ip_config)
check_temperature_um(status, power_amplify)
control_results.temperature = check_temperature_um(status, power_amplify)
_process_dkm_status(status)
if current_fs != 0:
var tek_litera: Dictionary = power_result[current_fs]
if current_litera != 0:
var tek_litera: Dictionary = power_result[current_litera]
var interes = _get_ray_key(state)
if interes != '':
tek_litera[_get_ray_key(state)] = power_um_ukp(status, current_fs, tek_litera[_get_ray_key(state)])
power_result[current_fs] = tek_litera
tek_litera[_get_ray_key(state)] = power_um_ukp(status, current_litera, tek_litera[_get_ray_key(state)])
power_result[current_litera] = tek_litera
## Пакеты от MP550Service
func on_fs_update_state(packet_type_7: Dictionary, fs_mapping: Dictionary) -> void:
var fs_key: String = FS_KEYS.get(current_fs, '')
var fs_key: String = FS_KEYS.get(current_litera, '')
if fs_key.is_empty():
return
var fs_result := {fs_key: STATE_VAL.NONE}
var fs_result := {fs_key: 0}
fs_result = on_fs_state(packet_type_7, fs_mapping, fs_result)
block_fs_config[fs_key] = fs_result[fs_key]
control_results[fs_key] = fs_result[fs_key]
##
@@ -137,7 +134,7 @@ class TestPRD extends Node:
_handle_fs_turn_on_state()
state = STATE_MASHINE.FS_WORK
STATE_MASHINE.FS_WORK:
if not flag_timer_started:
if ecms.size():
_handle_fs_work_state()
STATE_MASHINE.CHEK_KASSETA_Y5:
if block_kasseta_y5_config['yau07']:
@@ -151,12 +148,12 @@ class TestPRD extends Node:
#ems_6666_timer.start()
#state = STATE_MASHINE.READ_ISA
STATE_MASHINE.READ_ISA:
if (unit_prd.cmd_state == unit_prd.CmdState.DONE) or (unit_prd.cmd_state == unit_prd.CmdState.FALSE):
if (unit_prd.cmd_state == unit_prd.CmdState.DONE) or (unit_prd.cmd_state == unit_prd.CmdState.FAIL):
_handle_read_isa(module_prd, unit_prd, [constants.ADDR_UG_LITERA_1, constants.ADDR_UG_LITERA_2, constants.ADDR_UG_LITERA_3])
state = STATE_MASHINE.UG_SET_RAY
STATE_MASHINE.UG_SET_RAY:
var addr: int = constants.ADDR_UG_LITERA_1
if current_fs == 3 or current_fs == 5 or current_fs == 7:
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):
control_timer.stop()
@@ -171,8 +168,8 @@ class TestPRD extends Node:
elif unit_prd.isa_ports[addr] & 0x07 == 4:
state = STATE_MASHINE.UG_SET_RAY_5
elif unit_prd.isa_ports[addr] & 0x07 == 5:
if not current_fs == 1:
control_results = check_dou_result(control_results, power_result, self_name, current_fs, constants)
if not current_litera == 1:
control_results = check_dou_result(control_results, power_result, self_name, current_litera, constants)
state = STATE_MASHINE.IN_EMS_STOP
elif unit_prd.isa_ports[addr] & 0x07 == 6:
state = STATE_MASHINE.UG_SET_RAY_0
@@ -201,39 +198,39 @@ class TestPRD extends Node:
state = STATE_MASHINE.FS_TURN_OFF
STATE_MASHINE.FS_TURN_OFF:
_handle_fs_turn_off_state()
state = STATE_MASHINE.STOP_CONTROL
STATE_MASHINE.STOP_CONTROL:
_handle_stop_control_state()
func _handle_init_state() -> void:
control_label.text = 'Выполняется инициализация ФС-%s' % current_fs
if current_fs in [1, 2, 3, 4, 5, 6, 7]:
state = STATE_MASHINE.FS_TURN_ON
#state = STATE_MASHINE.STOP_CONTROL
control_label.text = 'Выполняется инициализация ФС-%s' % current_litera
if current_litera in [1, 2, 3, 4, 5, 6, 7]:
if not ecms.size():
state = STATE_MASHINE.FS_TURN_ON
else:
control_results = on_control_result(block_ip_config, block_dkm_config, block_fs_config, control_results)
emit_signal('control_is_over', control_results)
control_results = on_control_result(block_ip_config, control_results)
var send_power_pack = prep_power(power_result, self_name)
emit_signal('control_is_over', control_results, send_power_pack)
state = STATE_MASHINE.AWAIT
func _handle_fs_turn_on_state() -> void:
control_label.text = 'Выполняется включение ФС-%s' % current_fs
manage_fs(true, self_name, pribor_config, fs_parameters, current_fs, constants.POWER_UM)
control_label.text = 'Выполняется включение ФС-%s' % current_litera
manage_fs(true, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM)
control_timer.wait_time = constants.TIMER_DELAY
control_timer.start()
func _handle_fs_work_state() -> void:
control_label.text = 'Выполняется проверка ФС-%s' % current_fs
if not module_prd.unit_yau07.online:
return
if (current_fs == 2 and block_fs_config.fs_2) or \
(current_fs == 3 and block_fs_config.fs_3) or \
(current_fs == 4 and block_fs_config.fs_4) or \
(current_fs == 5 and block_fs_config.fs_5) or \
(current_fs == 6 and block_fs_config.fs_6) or \
(current_fs == 7 and block_fs_config.fs_7) or \
(current_fs == 1 and block_fs_config.fs_1):
control_label.text = 'Выполняется проверка ФС-%s' % current_litera
if (current_litera == 2 and control_results.fs_2) or \
(current_litera == 3 and control_results.fs_3) or \
(current_litera == 4 and control_results.fs_4) or \
(current_litera == 5 and control_results.fs_5) or \
(current_litera == 6 and control_results.fs_6) or \
(current_litera == 7 and control_results.fs_7) or \
(current_litera == 1 and control_results.fs_1):
state = STATE_MASHINE.CHEK_KASSETA_Y5
@@ -271,27 +268,26 @@ class TestPRD extends Node:
func _handle_fs_turn_off_state() -> void:
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
control_label.text = 'Выполняется отключение ФС-%s' % current_litera
manage_fs(false, self_name, pribor_config, fs_parameters, current_litera, constants.POWER_UM)
func _handle_stop_control_state() -> void:
control_label.text = 'Выполняется завершение проверки ФС-%s' % current_fs
control_label.text = 'Выполняется завершение проверки ФС-%s' % current_litera
flag_timer_started = false
_advance_to_next_fs()
state = STATE_MASHINE.INIT
func _advance_to_next_fs() -> void:
match current_fs:
1: current_fs = 6
2: current_fs = 3
3: current_fs = 0
4: current_fs = 5
5: current_fs = 0
6: current_fs = 7
7: current_fs = 0
match current_litera:
1: current_litera = 6
2: current_litera = 3
3: current_litera = 0
4: current_litera = 5
5: current_litera = 0
6: current_litera = 7
7: current_litera = 0
######################################
@@ -299,9 +295,14 @@ class TestPRD extends Node:
_determine_self_name()
var fs_mapping = _create_fs_mapping(self_name)
signaller.conn(signaller.fs_update_state, Callable(self, 'on_fs_update_state').bind(fs_mapping))
interfer.connect('interfer_resized', Callable(self, 'on_interfer_resized'))
unit_prd.connect('data_received', Callable(self, 'on_data_received'))
func on_interfer_resized(ecms_dic: Dictionary) -> void:
ecms = ecms_dic
func _determine_self_name() -> void:
var current_unit = unit_prd.name
var parts = current_unit.split('-')
@@ -321,25 +322,38 @@ class TestPRD extends Node:
func _process_dkm_status(status: PackedByteArray) -> void:
if not block_fs_config.has(_get_current_fs_key()):
if not control_results.has(_get_current_fs_key()):
return
var dkm_bit = _get_dkm_bit_for_current_fs()
block_dkm_config = check_dkm(status, dkm_bit, block_dkm_config)
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)
elif dkm_bit == 1:
control_results['dkm_2'] = check_dkm(status, dkm_bit)
elif dkm_bit == 2:
control_results['dkm_3'] = check_dkm(status, dkm_bit)
elif dkm_bit == 3:
control_results['dkm_4'] = check_dkm(status, dkm_bit)
elif dkm_bit == 4:
control_results['dkm_5'] = check_dkm(status, dkm_bit)
elif dkm_bit == 5:
control_results['dkm_6'] = check_dkm(status, dkm_bit)
elif dkm_bit == 6:
control_results['dkm_7'] = check_dkm(status, dkm_bit)
func _get_current_fs_key() -> String:
return FS_KEYS.get(current_fs, '')
return FS_KEYS.get(current_litera, '')
func _get_dkm_bit_for_current_fs() -> int:
match current_fs:
1: return constants.DKM_BIT_1
2: return constants.DKM_BIT_2
3: return constants.DKM_BIT_3
4: return constants.DKM_BIT_4
5: return constants.DKM_BIT_5
6: return constants.DKM_BIT_6
7: return constants.DKM_BIT_7
static func _get_dkm_bit_for_current_fs(litera: int, constants_dic: Dictionary) -> int:
match litera:
1: return constants_dic.DKM_BIT_1
2: return constants_dic.DKM_BIT_2
3: return constants_dic.DKM_BIT_3
4: return constants_dic.DKM_BIT_4
5: return constants_dic.DKM_BIT_5
6: return constants_dic.DKM_BIT_6
7: return constants_dic.DKM_BIT_7
_: return -1
@@ -355,28 +369,17 @@ class TestPRD extends Node:
func on_stop_control() -> void:
_handle_fs_turn_off_state()
state = STATE_MASHINE.FS_TURN_OFF
static func on_control_result(ip_config: Dictionary, dkm_config: Dictionary, fs_config: Dictionary, ctrl_results: Dictionary) -> Dictionary:
static func on_control_result(ip_config: Dictionary, ctrl_results: Dictionary) -> Dictionary:
var all_blocks_ip_ok = true
var all_blocks_dkm_ok = true
var all_blocks_fs_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
for block in dkm_config:
if not dkm_config[block]:
all_blocks_dkm_ok = false
ctrl_results['dkm'] = all_blocks_dkm_ok
for block in fs_config:
if not fs_config[block]:
all_blocks_fs_ok = false
ctrl_results['fs'] = all_blocks_fs_ok
return ctrl_results
@@ -398,7 +401,7 @@ class TestPRD extends Node:
## Управаление модулем фс (включить/отключить излучение)
static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, cur_fs: int, power_um: int) -> void:
static func manage_fs(mode: bool, pribor: String, p_conf: Dictionary, fs_params: Dictionary, litera: int, power_um: int) -> void:
# Получаем конфигурацию для текущего прибора
var config: Dictionary = p_conf[pribor]
var angle: float = config.angle
@@ -408,13 +411,13 @@ class TestPRD extends Node:
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]
if litera in fs_params:
var params = fs_params[litera]
fs_arr.append([
angle,
params.freq,
params.width,
sectors[cur_fs - 1] if cur_fs == 1 else sectors[cur_fs - 5] if cur_fs > 5 else sectors[cur_fs - 4] if cur_fs > 3 else sectors[cur_fs - 2]
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)
@@ -443,7 +446,7 @@ class TestPRD extends Node:
## Проверка температур УМ от УКП
static func check_temperature_um(status_prd: PackedByteArray, power_amplifier: Array) -> void:
static func check_temperature_um(status_prd: PackedByteArray, power_amplifier: Array) -> bool:
const Constants: Dictionary = {
'CONST_MIN_TEMP': -25,
'MAXIMUM_CODE_ADC': 3796,
@@ -454,6 +457,7 @@ class TestPRD extends Node:
const TEMP: float = 115.0 / (Constants.MAXIMUM_CODE_ADC - Constants.MINIMUM_CODE_AD)
var ukp1_online: int = (status_prd[0] >> 2) & 1
var ukp2_online = (status_prd[0] >> 3) & 1
var all_temp_is_ok: bool = true
if ukp1_online:
var tmp_1: int
@@ -461,42 +465,36 @@ class TestPRD extends Node:
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
power_amplifier[i_temp].value1 = tmp_1
if tmp_1>70:
all_temp_is_ok = false
if power_amplifier.size() > 12: # Темпуратура от УМ литеры 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
power_amplifier[6].value1 = tmp_1
if tmp_1>70:
all_temp_is_ok = false
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)
if power_amplifier.size() > 12:
power_amplifier[i_temp+7].value0 = tmp_2
power_amplifier[i_temp+7].value1 = tmp_2
if tmp_2>70:
all_temp_is_ok = false
else:
power_amplifier[i_temp+6].value0 = tmp_2
power_amplifier[i_temp+6].value1 = tmp_2
if tmp_2>70:
all_temp_is_ok = false
return all_temp_is_ok
## Проверка ДКМ
static func check_dkm(status_prd: PackedByteArray, bit_dkm: int, dkm_result: Dictionary) -> Dictionary:
static func check_dkm(status_prd: PackedByteArray, bit_dkm: int) -> bool:
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 == 1:
dkm_result['dkm_2'] = status_dkm
elif bit_dkm == 2:
dkm_result['dkm_3'] = status_dkm
elif bit_dkm == 3:
dkm_result['dkm_4'] = status_dkm
elif bit_dkm == 4:
dkm_result['dkm_5'] = 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
var status_dkm: bool = status_prd[dkm] >> bit_dkm & 1
return status_dkm
##
@@ -548,14 +546,14 @@ class TestPRD extends Node:
##
static func power_um_ukp(status: PackedByteArray, crnt_fs: int, pwr_result: Array) -> Array:
static func power_um_ukp(status: PackedByteArray, litera: int, pwr_result: Array) -> Array:
const Constants: Dictionary = {'POWER_UKP_1' : 31, 'POWER_UKP_2': 63}
var power_values: Array = []
var base_offset = 0
var iteration: int = 6
var ug_valid: bool = (status[0] >> 2) & 1
match crnt_fs:
match litera:
1:
# Обработка для current_fs = 1 (одно значение)
var value = status.decode_u16(Constants.POWER_UKP_1 + 2 * 7)
@@ -621,15 +619,15 @@ class TestPRD extends Node:
return max_power_values.duplicate()
static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pribor: String, cur_prd: int, cnst: Dictionary) -> Dictionary:
static func check_dou_result(control_dic: Dictionary, power_dic: Dictionary, pribor: String, litera: int, cnst: Dictionary) -> Dictionary:
var all_dou_ok = true
var dou: String = 'dou_2' if cur_prd == 2 else 'dou_3'
var dou: String = 'dou_2' if litera == 2 else 'dou_3'
if pribor == '1к' or pribor == '2к' or pribor == '3к' or pribor == '4к':
dou = 'dou_6' if cur_prd == 6 else 'dou_7'
dou = 'dou_6' if litera == 6 else 'dou_7'
elif pribor == '1в' or pribor == '2в' or pribor == '3в' or pribor == '4в':
dou = 'dou_4' if cur_prd == 5 else 'dou_5'
dou = 'dou_4' if litera == 4 else 'dou_5'
var ray_dic: Dictionary = power_dic[cur_prd]
var ray_dic: Dictionary = power_dic[litera]
if ray_dic[RAY_m5].size() == 0 or \
ray_dic[RAY_5 ].size() == 0 or \
ray_dic[RAY_15].size() == 0 or \
@@ -642,10 +640,62 @@ class TestPRD extends Node:
for i_pow_arr in ray_dic.values():
for i_pow in i_pow_arr.size():
if i_pow_arr[i_pow] < cnst.POWER_THRESHOLD:
print_debug('dou_%s: false' % cur_prd)
#print_debug('dou_%s: false' % litera)
all_dou_ok = false
print([cur_prd, ray_dic])
control_dic[dou] = all_dou_ok
return control_dic
static func prep_power(power_dic: Dictionary, prd_name: String)-> Dictionary:
const RAY_KEYS := ["RAY_m5", "RAY_5", "RAY_15", "RAY_25", "RAY_35", "RAY_45"]
var prep_pow_dic: Dictionary = {}
var arr_litera: Array[int]
match prd_name:
'1н', '2н', '3н', '4н':
arr_litera = [2, 3]
'1в', '2в', '3в', '4в':
arr_litera = [4, 5]
'1к', '2к', '3к', '4к':
arr_litera = [6, 7, 1]
if not arr_litera:
print_debug('Ошибка в prd_name')
return prep_pow_dic
var um_names: Array[Array] = []
if arr_litera.size() != 3:
um_names = [
['um_1', 'um_2', 'um_3', 'um_4', 'um_5', 'um_6'],
['um_7', 'um_8', 'um_9', 'um_10', 'um_11', 'um_12']
]
else:
um_names = [
['um_1', 'um_2', 'um_3', 'um_4', 'um_5', 'um_6'],
['um_8', 'um_9', 'um_10', 'um_11', 'um_12', 'um_13'],
['um_7'] # Особый случай для третьего элемента
]
for litera_index in arr_litera.size():
var litera: int = arr_litera[litera_index]
var litera_data: Dictionary = power_dic.get(litera, {})
var um_data: Array[Array] = [[], [], [], [], [], []]
for i in range(RAY_KEYS.size()):
var ray_key: String = RAY_KEYS[i]
var ray_array: Array = litera_data.get(ray_key, [])
if ray_array.size() == 1:
var single_value = ray_array[0]
for j in range(6):
um_data[j].append(single_value)
else:
for j in range(6):
um_data[j].append(ray_array[j] if j < ray_array.size() else 0)
var current_um_names: Array = um_names[litera_index]
for um_index in range(current_um_names.size()):
prep_pow_dic[current_um_names[um_index]] = um_data[um_index]
return prep_pow_dic

26
scripts/spt25.gd
View File

@@ -13,6 +13,32 @@ class SPT25 extends unit.Unit:
func _to_string() -> String: return String('СПТ-25 %s %s' % [self.name, ['отключен', 'на связи'][int(online)]])
##Вычисление контрольной суммы
func sciCalcFCS(src: PackedByteArray) -> int:
var P_DIV = 0
var ln = src[0]
var FCS = ~((src[2]<<8) + src[1])
for i in range(3, ln):
var C = src[i]
for j in 8:
if C & 1:
if FCS & 1:
FCS = ((FCS >> 1) | 0x8000)^P_DIV
else:
FCS = ((FCS >> 1) | 0x8000)
else:
if FCS & 1:
FCS = (FCS >> 1) ^ P_DIV
else:
FCS = FCS >> 1
C >>= 1
for j in 16:
if FCS & 1:
FCS = (FCS >> 1) ^ P_DIV
else:
FCS = FCS >> 1
return ~FCS
func _init(nm) -> void:
self.name = nm
tx_data.resize(5)