485 lines
15 KiB
Python
485 lines
15 KiB
Python
import enum
|
|
import struct
|
|
import time
|
|
from typing import Optional
|
|
|
|
from config.definitions import CustomServiceList
|
|
from tmtccmd.config import (
|
|
QueueCommands,
|
|
ServiceOpCodeDictT,
|
|
add_op_code_entry,
|
|
add_service_op_code_entry,
|
|
)
|
|
from tmtccmd.tc.definitions import TcQueueT
|
|
from tmtccmd.tc.pus_3_fsfw_hk import (
|
|
generate_one_hk_command,
|
|
make_sid,
|
|
generate_one_diag_command,
|
|
)
|
|
from tmtccmd.tc.pus_11_tc_sched import (
|
|
generate_enable_tc_sched_cmd,
|
|
generate_time_tagged_cmd,
|
|
)
|
|
from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes, Subservices
|
|
from tmtccmd.tc.pus_20_params import (
|
|
pack_scalar_double_param_app_data,
|
|
pack_fsfw_load_param_cmd,
|
|
pack_boolean_parameter_app_data,
|
|
)
|
|
from tmtccmd.logging import get_console_logger
|
|
from spacepackets.ecss.tc import PusTelecommand
|
|
from config.object_ids import PL_PCDU_ID
|
|
|
|
LOGGER = get_console_logger()
|
|
|
|
|
|
class OpCodes:
|
|
SWITCH_HPA_ON_PROC = ["0", "proc-hpa"]
|
|
SWITCH_ON = ["2", "on"]
|
|
SWITCH_OFF = ["3", "off"]
|
|
NORMAL_SSR = ["4", "nml-ssr"]
|
|
NORMAL_DRO = ["5", "nml-dro"]
|
|
NORMAL_X8 = ["6", "nml-x8"]
|
|
NORMAL_TX = ["7", "nml-tx"]
|
|
NORMAL_MPA = ["8", "nml-mpa"]
|
|
NORMAL_HPA = ["9", "nml-hpa"]
|
|
|
|
REQ_OS_HK = ["8", "hk-os"]
|
|
|
|
INJECT_SSR_TO_DRO_FAILURE = ["10", "inject-ssr-dro-fault"]
|
|
INJECT_DRO_TO_X8_FAILURE = ["11", "inject-dro-x8-fault"]
|
|
INJECT_X8_TO_TX_FAILURE = ["12", "inject-x8-tx-fault"]
|
|
INJECT_TX_TO_MPA_FAILURE = ["13", "inject-tx-mpa-fault"]
|
|
INJECT_MPA_TO_HPA_FAILURE = ["14", "inject-mpa-hpa-fault"]
|
|
INJECT_ALL_ON_FAILURE = ["15", "inject-all-on-fault"]
|
|
|
|
|
|
class Info:
|
|
NORMAL = "PL PCDU ADC modules normal"
|
|
SWITCH_ON = "Switching PL PCDU on"
|
|
SWITCH_OFF = "Switching PL PCDU off"
|
|
NORMAL_SSR = f"{NORMAL}, SSR on"
|
|
NORMAL_DRO = f"{NORMAL},DRO on"
|
|
NORMAL_X8 = f"{NORMAL}, X8 on"
|
|
NORMAL_TX = f"{NORMAL}, TX on"
|
|
NORMAL_MPA = f"{NORMAL}, MPA on"
|
|
NORMAL_HPA = f"{NORMAL}, HPA on"
|
|
REQ_OS_HK = "Request One Shot HK"
|
|
|
|
|
|
class SetIds(enum.IntEnum):
|
|
ADC = 0
|
|
|
|
|
|
class NormalSubmodesMask(enum.IntEnum):
|
|
SOLID_STATE_RELAYS_ADC_ON = 0
|
|
DRO_ON = 1
|
|
X8_ON = 2
|
|
TX_ON = 3
|
|
MPA_ON = 4
|
|
HPA_ON = 5
|
|
|
|
|
|
class ParamIds(enum.IntEnum):
|
|
NEG_V_LOWER_BOUND = 0
|
|
NEG_V_UPPER_BOUND = 1
|
|
|
|
DRO_U_LOWER_BOUND = 2
|
|
DRO_U_UPPER_BOUND = 3
|
|
DRO_I_UPPER_BOUND = 4
|
|
|
|
X8_U_LOWER_BOUND = 5
|
|
X8_U_UPPER_BOUND = 6
|
|
X8_I_UPPER_BOUND = 7
|
|
|
|
TX_U_LOWER_BOUND = 8
|
|
TX_U_UPPER_BOUND = 9
|
|
TX_I_UPPER_BOUND = 10
|
|
|
|
MPA_U_LOWER_BOUND = 11
|
|
MPA_U_UPPER_BOUND = 12
|
|
MPA_I_UPPER_BOUND = 13
|
|
|
|
HPA_U_LOWER_BOUND = 14
|
|
HPA_U_UPPER_BOUND = 15
|
|
HPA_I_UPPER_BOUND = 16
|
|
|
|
SSR_TO_DRO_WAIT_TIME = 17
|
|
DRO_TO_X8_WAIT_TIME = 18
|
|
X8_TO_TX_WAIT_TIME = 19
|
|
TX_TO_MPA_WAIT_TIME = 20
|
|
MPA_TO_HPA_WAIT_TIME = 21
|
|
|
|
INJECT_SSR_TO_DRO_FAILURE = 30
|
|
INJECT_DRO_TO_X8_FAILURE = 31
|
|
INJECT_X8_TO_TX_FAILURE = 32
|
|
INJECT_TX_TO_MPA_FAILURE = 33
|
|
INJECT_MPA_TO_HPA_FAILURE = 34
|
|
INJECT_ALL_ON_FAILURE = 35
|
|
|
|
|
|
def add_pl_pcdu_cmds(cmd_dict: ServiceOpCodeDictT):
|
|
op_code_dict = dict()
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict, keys=OpCodes.SWITCH_ON, info=Info.SWITCH_ON
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict, keys=OpCodes.SWITCH_OFF, info=Info.SWITCH_OFF
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.NORMAL_SSR,
|
|
info=Info.NORMAL_SSR,
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.NORMAL_DRO,
|
|
info=Info.NORMAL_DRO,
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.NORMAL_X8,
|
|
info=Info.NORMAL_X8,
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.NORMAL_TX,
|
|
info=Info.NORMAL_TX,
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.NORMAL_MPA,
|
|
info=Info.NORMAL_MPA,
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.NORMAL_HPA,
|
|
info=Info.NORMAL_HPA,
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict, keys=OpCodes.REQ_OS_HK, info=Info.REQ_OS_HK
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.INJECT_SSR_TO_DRO_FAILURE,
|
|
info="Inject failure SSR to DRO transition",
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.INJECT_DRO_TO_X8_FAILURE,
|
|
info="Inject failure in DRO to X8 transition",
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.INJECT_X8_TO_TX_FAILURE,
|
|
info="Inject failure in X8 to TX transition",
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.INJECT_TX_TO_MPA_FAILURE,
|
|
info="Inject failure in TX to MPA transition",
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.INJECT_MPA_TO_HPA_FAILURE,
|
|
info="Inject failure in MPA to HPA transition",
|
|
)
|
|
add_op_code_entry(
|
|
op_code_dict=op_code_dict,
|
|
keys=OpCodes.INJECT_ALL_ON_FAILURE,
|
|
info="Inject failure in all on mode",
|
|
)
|
|
add_service_op_code_entry(
|
|
srv_op_code_dict=cmd_dict,
|
|
name=CustomServiceList.PL_PCDU.value,
|
|
info="PL PCDU",
|
|
op_code_entry=op_code_dict,
|
|
)
|
|
|
|
|
|
def pack_pl_pcdu_commands(tc_queue: TcQueueT, op_code: str):
|
|
if op_code in OpCodes.SWITCH_ON:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue, info=Info.SWITCH_ON, mode=Modes.ON, submode=0
|
|
)
|
|
if op_code in OpCodes.SWITCH_OFF:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue, info=Info.SWITCH_OFF, mode=Modes.OFF, submode=0
|
|
)
|
|
if op_code in OpCodes.NORMAL_SSR:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue,
|
|
info=Info.NORMAL_SSR,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(
|
|
NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON
|
|
),
|
|
)
|
|
if op_code in OpCodes.NORMAL_DRO:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue,
|
|
info=Info.NORMAL_DRO,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.DRO_ON),
|
|
)
|
|
if op_code in OpCodes.NORMAL_X8:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue,
|
|
info=Info.NORMAL_X8,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.X8_ON),
|
|
)
|
|
if op_code in OpCodes.NORMAL_TX:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue,
|
|
info=Info.NORMAL_TX,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.TX_ON),
|
|
)
|
|
if op_code in OpCodes.NORMAL_MPA:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue,
|
|
info=Info.NORMAL_MPA,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.MPA_ON),
|
|
)
|
|
if op_code in OpCodes.NORMAL_HPA:
|
|
pack_pl_pcdu_mode_cmd(
|
|
tc_queue=tc_queue,
|
|
info=Info.NORMAL_HPA,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.HPA_ON),
|
|
)
|
|
if op_code in OpCodes.REQ_OS_HK:
|
|
tc_queue.appendleft((QueueCommands.PRINT, f"PL PCDU: {Info.REQ_OS_HK}"))
|
|
cmd = generate_one_diag_command(
|
|
sid=make_sid(object_id=PL_PCDU_ID, set_id=SetIds.ADC), ssc=0
|
|
)
|
|
tc_queue.appendleft(cmd.pack_command_tuple())
|
|
if op_code in OpCodes.SWITCH_HPA_ON_PROC:
|
|
hpa_on_procedure(tc_queue)
|
|
if op_code in OpCodes.INJECT_ALL_ON_FAILURE:
|
|
pack_failure_injection_cmd(
|
|
tc_queue=tc_queue,
|
|
param_id=ParamIds.INJECT_ALL_ON_FAILURE,
|
|
print_str="All On",
|
|
)
|
|
|
|
|
|
def hpa_on_procedure(tc_queue: TcQueueT):
|
|
delay_dro_to_x8 = request_wait_time()
|
|
if delay_dro_to_x8 is None:
|
|
delay_dro_to_x8 = 900
|
|
tc_queue.appendleft(
|
|
(
|
|
QueueCommands.PRINT,
|
|
f"Starting procedure to switch on PL PCDU HPA with DRO to X8 delay of {delay_dro_to_x8} seconds",
|
|
)
|
|
)
|
|
pl_pcdu_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(object_id=PL_PCDU_ID, mode=Modes.ON, submode=0),
|
|
)
|
|
ssr_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(
|
|
object_id=PL_PCDU_ID,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(
|
|
NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON
|
|
),
|
|
),
|
|
)
|
|
dro_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(
|
|
object_id=PL_PCDU_ID,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.DRO_ON),
|
|
),
|
|
)
|
|
x8_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(
|
|
object_id=PL_PCDU_ID,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.X8_ON),
|
|
),
|
|
)
|
|
tx_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(
|
|
object_id=PL_PCDU_ID,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.TX_ON),
|
|
),
|
|
)
|
|
mpa_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(
|
|
object_id=PL_PCDU_ID,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.MPA_ON),
|
|
),
|
|
)
|
|
hpa_on = PusTelecommand(
|
|
service=200,
|
|
subservice=Subservices.TC_MODE_COMMAND,
|
|
app_data=pack_mode_data(
|
|
object_id=PL_PCDU_ID,
|
|
mode=Modes.NORMAL,
|
|
submode=submode_mask_to_submode(NormalSubmodesMask.HPA_ON),
|
|
),
|
|
)
|
|
current_time = time.time()
|
|
|
|
enb_sched = generate_enable_tc_sched_cmd(ssc=0)
|
|
|
|
sched_time = current_time + 10
|
|
tc_queue.appendleft(enb_sched.pack_command_tuple())
|
|
tagged_on_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time),
|
|
tc_to_insert=pl_pcdu_on,
|
|
ssc=1,
|
|
)
|
|
tc_queue.appendleft(tagged_on_cmd.pack_command_tuple())
|
|
|
|
sched_time += 5
|
|
tagged_ssr_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time),
|
|
tc_to_insert=ssr_on,
|
|
ssc=2,
|
|
)
|
|
tc_queue.appendleft(tagged_ssr_cmd.pack_command_tuple())
|
|
|
|
sched_time += 5
|
|
tagged_dro_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time), tc_to_insert=dro_on, ssc=3
|
|
)
|
|
tc_queue.appendleft(tagged_dro_cmd.pack_command_tuple())
|
|
|
|
sched_time += delay_dro_to_x8
|
|
tagged_x8_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time), tc_to_insert=x8_on, ssc=4
|
|
)
|
|
tc_queue.appendleft(tagged_x8_cmd.pack_command_tuple())
|
|
|
|
sched_time += 5
|
|
tagged_tx_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time), tc_to_insert=tx_on, ssc=5
|
|
)
|
|
tc_queue.appendleft(tagged_tx_cmd.pack_command_tuple())
|
|
|
|
sched_time += 5
|
|
tagged_mpa_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time), tc_to_insert=mpa_on, ssc=6
|
|
)
|
|
tc_queue.appendleft(tagged_mpa_cmd.pack_command_tuple())
|
|
|
|
sched_time += 5
|
|
tagged_hpa_cmd = generate_time_tagged_cmd(
|
|
release_time=struct.pack("!I", sched_time), tc_to_insert=hpa_on, ssc=7
|
|
)
|
|
tc_queue.appendleft(tagged_hpa_cmd.pack_command_tuple())
|
|
|
|
|
|
def request_wait_time() -> Optional[float]:
|
|
while True:
|
|
wait_time = input("Please enter DRO to X8 wait time in seconds, x to cancel: ")
|
|
if wait_time.lower() == "x":
|
|
return None
|
|
try:
|
|
wait_time = float(wait_time)
|
|
except ValueError:
|
|
LOGGER.warning("Invalid input")
|
|
continue
|
|
if wait_time <= 0:
|
|
LOGGER.warning("Invalid input")
|
|
else:
|
|
return wait_time
|
|
|
|
|
|
def submode_mask_to_submode(on_tgt: NormalSubmodesMask) -> int:
|
|
if on_tgt == NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON:
|
|
return 1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON
|
|
if on_tgt == NormalSubmodesMask.DRO_ON:
|
|
return 1 << NormalSubmodesMask.DRO_ON | (
|
|
1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON
|
|
)
|
|
if on_tgt == NormalSubmodesMask.X8_ON:
|
|
return (
|
|
1 << NormalSubmodesMask.DRO_ON
|
|
| (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON)
|
|
| (1 << NormalSubmodesMask.X8_ON)
|
|
)
|
|
if on_tgt == NormalSubmodesMask.TX_ON:
|
|
return (
|
|
1 << NormalSubmodesMask.DRO_ON
|
|
| (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON)
|
|
| (1 << NormalSubmodesMask.X8_ON)
|
|
| (1 << NormalSubmodesMask.TX_ON)
|
|
)
|
|
if on_tgt == NormalSubmodesMask.MPA_ON:
|
|
return (
|
|
1 << NormalSubmodesMask.DRO_ON
|
|
| (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON)
|
|
| (1 << NormalSubmodesMask.X8_ON)
|
|
| (1 << NormalSubmodesMask.TX_ON)
|
|
| (1 << NormalSubmodesMask.MPA_ON)
|
|
)
|
|
if on_tgt == NormalSubmodesMask.HPA_ON:
|
|
return (
|
|
1 << NormalSubmodesMask.DRO_ON
|
|
| (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON)
|
|
| (1 << NormalSubmodesMask.X8_ON)
|
|
| (1 << NormalSubmodesMask.TX_ON)
|
|
| (1 << NormalSubmodesMask.MPA_ON)
|
|
| (1 << NormalSubmodesMask.HPA_ON)
|
|
)
|
|
|
|
|
|
def pack_wait_time_cmd(tc_queue: TcQueueT, param_id: int, print_str: str):
|
|
wait_time = request_wait_time()
|
|
tc_queue.appendleft(
|
|
(QueueCommands.PRINT, f"Updating {print_str} wait time to {wait_time}")
|
|
)
|
|
if wait_time is None:
|
|
return
|
|
param_data = pack_scalar_double_param_app_data(
|
|
object_id=PL_PCDU_ID,
|
|
domain_id=0,
|
|
unique_id=param_id,
|
|
parameter=wait_time,
|
|
)
|
|
cmd = pack_fsfw_load_param_cmd(ssc=0, app_data=param_data)
|
|
tc_queue.appendleft(cmd.pack_command_tuple())
|
|
|
|
|
|
def pack_failure_injection_cmd(tc_queue: TcQueueT, param_id: int, print_str: str):
|
|
tc_queue.appendleft((QueueCommands.PRINT, f"Inserting {print_str} error"))
|
|
param_data = pack_boolean_parameter_app_data(
|
|
object_id=PL_PCDU_ID, domain_id=0, unique_id=param_id, parameter=True
|
|
)
|
|
cmd = pack_fsfw_load_param_cmd(ssc=0, app_data=param_data)
|
|
tc_queue.appendleft(cmd.pack_command_tuple())
|
|
|
|
|
|
def pack_pl_pcdu_mode_cmd(tc_queue: TcQueueT, info: str, mode: Modes, submode: int):
|
|
tc_queue.appendleft(
|
|
(
|
|
QueueCommands.PRINT,
|
|
info,
|
|
)
|
|
)
|
|
mode_data = pack_mode_data(object_id=PL_PCDU_ID, mode=mode, submode=submode)
|
|
mode_cmd = PusTelecommand(
|
|
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=mode_data
|
|
)
|
|
tc_queue.appendleft(mode_cmd.pack_command_tuple())
|