import enum import logging import struct import time from typing import Optional from eive_tmtc.config.definitions import CustomServiceList from eive_tmtc.pus_tm.defs import PrintWrapper from tmtccmd.config import TmtcDefinitionWrapper from tmtccmd.config.tmtc import OpCodeEntry, tmtc_definitions_provider from tmtccmd.tmtc import DefaultPusQueueHelper from tmtccmd.pus.tc.s3_fsfw_hk import ( make_sid, generate_one_diag_command, enable_periodic_hk_command_with_interval, disable_periodic_hk_command, ) from tmtccmd.pus.s11_tc_sched import ( create_enable_tc_sched_cmd, create_time_tagged_cmd, ) from tmtccmd.pus.s200_fsfw_mode import Subservice, pack_mode_data, Mode from tmtccmd.pus.s20_fsfw_param import ( create_scalar_double_parameter, create_load_param_cmd, create_scalar_boolean_parameter, ) from spacepackets.ecss.tc import PusTelecommand from eive_tmtc.config.object_ids import PL_PCDU_ID from tmtccmd.fsfw.tmtc_printer import FsfwTmTcPrinter _LOGGER = logging.getLogger(__name__) class OpCode: SWITCH_HPA_ON_PROC = ["0", "proc_hpa"] SWITCH_ON = "on" SWITCH_OFF = "off" NORMAL_SSR = "nml_ssr" NORMAL_DRO = "nml_dro" NORMAL_X8 = "nml_x8" NORMAL_TX = "nml_tx" NORMAL_MPA = "nml_mpa" NORMAL_HPA = "nml_hpa" NORMAL_CUSTOM = "nml_custom" ENABLE_HK = "enable_hk" DISABLE_HK = "disable_hk" REQ_OS_HK = "hk_os" DISABLE_ORDER_CHECKING = "disable_order_checking" ENABLE_ORDER_CHECKING = "enable_order_checking" UPDATE_I_UPPER_LIMIT = "update_i_upper_limit" UPDATE_V_LOWER_LIMIT = "update_v_lower_limit" UPDATE_V_UPPER_LIMIT = "update_v_upper_limit" INJECT_SSR_TO_DRO_FAILURE = "inject_ssr_dro_fault" INJECT_DRO_TO_X8_FAILURE = "inject_dro_x8_fault" INJECT_X8_TO_TX_FAILURE = "inject_x8_tx_fault" INJECT_TX_TO_MPA_FAILURE = "inject_tx_mpa_fault" INJECT_MPA_TO_HPA_FAILURE = "inject_mpa_hpa_fault" INJECT_ALL_ON_FAILURE = "inject_all_on_fault" class Info: NORMAL = "ADC modules normal" SWITCH_ON = "Switching on" SWITCH_OFF = "Switching 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" NORMAL_CUSTOM = f"{NORMAL}, Custom Channel Settings" REQ_OS_HK = "Request One Shot HK" SWITCH_HPA_ON_PROC = "Switch HPA on procedure" ENABLE_HK = "Enable HK" DISABLE_HK = "Disable HK" UPDATE_I_UPPER_LIMIT = "Update upper current parameter" UPDATE_V_LOWER_LIMIT = "Update lower voltage parameter" UPDATE_V_UPPER_LIMIT = "Update upper voltage parameter" DISABLE_ORDER_CHECKING = "Disable order checks" ENABLE_ORDER_CHECKING = "Enable order checks" class SetId(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 SubmodeForNormalMode(enum.IntEnum): NONE = 0 SSR_ON = 1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON DRO_ON = 1 << NormalSubmodesMask.DRO_ON | ( 1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON ) X8_ON = ( 1 << NormalSubmodesMask.DRO_ON | (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON) | (1 << NormalSubmodesMask.X8_ON) ) TX_ON = ( 1 << NormalSubmodesMask.DRO_ON | (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON) | (1 << NormalSubmodesMask.X8_ON) | (1 << NormalSubmodesMask.TX_ON) ) MPA_ON = ( 1 << NormalSubmodesMask.DRO_ON | (1 << NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON) | (1 << NormalSubmodesMask.X8_ON) | (1 << NormalSubmodesMask.TX_ON) | (1 << NormalSubmodesMask.MPA_ON) ) HPA_ON = ( 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) ) class ParamId(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 DISABLE_ORDER_CHECK_CHANNELS = 40 class DevSelect(enum.IntEnum): SSR_NEG_V = 0 DRO = 1 X8 = 2 TX = 3 MPA = 4 HPA = 5 @tmtc_definitions_provider def add_pl_pcdu_cmds(defs: TmtcDefinitionWrapper): oce = OpCodeEntry() oce.add(keys=OpCode.SWITCH_HPA_ON_PROC, info=Info.SWITCH_HPA_ON_PROC) oce.add(keys=OpCode.SWITCH_ON, info=Info.SWITCH_ON) oce.add(keys=OpCode.SWITCH_OFF, info=Info.SWITCH_OFF) oce.add(keys=OpCode.NORMAL_SSR, info=Info.NORMAL_SSR) oce.add(keys=OpCode.NORMAL_DRO, info=Info.NORMAL_DRO) oce.add(keys=OpCode.NORMAL_X8, info=Info.NORMAL_X8) oce.add(keys=OpCode.NORMAL_TX, info=Info.NORMAL_TX) oce.add(keys=OpCode.NORMAL_MPA, info=Info.NORMAL_MPA) oce.add(keys=OpCode.NORMAL_HPA, info=Info.NORMAL_HPA) oce.add(keys=OpCode.NORMAL_CUSTOM, info=Info.NORMAL_CUSTOM) oce.add(keys=OpCode.REQ_OS_HK, info=Info.REQ_OS_HK) oce.add(keys=OpCode.ENABLE_HK, info=Info.ENABLE_HK) oce.add(keys=OpCode.UPDATE_V_LOWER_LIMIT, info=Info.UPDATE_V_LOWER_LIMIT) oce.add(keys=OpCode.UPDATE_V_UPPER_LIMIT, info=Info.UPDATE_V_UPPER_LIMIT) oce.add(keys=OpCode.UPDATE_I_UPPER_LIMIT, info=Info.UPDATE_I_UPPER_LIMIT) oce.add( keys=OpCode.INJECT_SSR_TO_DRO_FAILURE, info="Inject failure SSR to DRO transition", ) oce.add( keys=OpCode.INJECT_DRO_TO_X8_FAILURE, info="Inject failure in DRO to X8 transition", ) oce.add( keys=OpCode.INJECT_X8_TO_TX_FAILURE, info="Inject failure in X8 to TX transition", ) oce.add( keys=OpCode.INJECT_TX_TO_MPA_FAILURE, info="Inject failure in TX to MPA transition", ) oce.add( keys=OpCode.INJECT_MPA_TO_HPA_FAILURE, info="Inject failure in MPA to HPA transition", ) oce.add(keys=OpCode.INJECT_ALL_ON_FAILURE, info="Inject failure in all on mode") oce.add(keys=OpCode.DISABLE_ORDER_CHECKING, info=Info.DISABLE_ORDER_CHECKING) oce.add(keys=OpCode.ENABLE_ORDER_CHECKING, info=Info.ENABLE_ORDER_CHECKING) defs.add_service(CustomServiceList.PL_PCDU.value, "PL PCDU", oce) def pack_pl_pcdu_commands( # noqa C901: Complexity is okay here. q: DefaultPusQueueHelper, op_code: str ): # noqa C901: Complexity is okay here. if op_code == OpCode.SWITCH_ON: pack_pl_pcdu_mode_cmd(q=q, info=Info.SWITCH_ON, mode=Mode.ON, submode=0) if op_code == OpCode.SWITCH_OFF: pack_pl_pcdu_mode_cmd(q=q, info=Info.SWITCH_OFF, mode=Mode.OFF, submode=0) if op_code in OpCode.ENABLE_HK: interval = float( input("Please enter HK collection interval in floating point seconds: ") ) cmds = enable_periodic_hk_command_with_interval( diag=True, sid=make_sid(PL_PCDU_ID, SetId.ADC), interval_seconds=interval ) q.add_log_cmd(f"Enable PL PCDU HK with interval of {interval} seconds") for cmd in cmds: q.add_pus_tc(cmd) if op_code == OpCode.DISABLE_HK: cmd = disable_periodic_hk_command( diag=True, sid=make_sid(PL_PCDU_ID, SetId.ADC) ) q.add_log_cmd("Disabling PL PCDU HK") q.add_pus_tc(cmd) if op_code == OpCode.NORMAL_SSR: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_SSR, mode=Mode.NORMAL, submode=submode_mask_to_submode( NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON ), ) if op_code == OpCode.NORMAL_DRO: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_DRO, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.DRO_ON), ) if op_code == OpCode.NORMAL_X8: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_X8, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.X8_ON), ) if op_code == OpCode.NORMAL_TX: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_TX, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.TX_ON), ) if op_code == OpCode.NORMAL_MPA: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_MPA, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.MPA_ON), ) if op_code == OpCode.NORMAL_HPA: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_HPA, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.HPA_ON), ) if op_code == OpCode.NORMAL_CUSTOM: pack_pl_pcdu_mode_cmd( q=q, info=Info.NORMAL_CUSTOM, mode=Mode.NORMAL, submode=prompt_custom_normal_submode(), ) if op_code == OpCode.REQ_OS_HK: q.add_log_cmd(f"PL PCDU: {Info.REQ_OS_HK}") q.add_pus_tc( generate_one_diag_command( sid=make_sid(object_id=PL_PCDU_ID, set_id=SetId.ADC) ) ) if op_code == OpCode.DISABLE_ORDER_CHECKING: q.add_log_cmd(Info.DISABLE_ORDER_CHECKING) q.add_pus_tc( create_load_param_cmd( create_scalar_boolean_parameter( PL_PCDU_ID, 0, ParamId.DISABLE_ORDER_CHECK_CHANNELS, True ) ) ) if op_code == OpCode.ENABLE_ORDER_CHECKING: q.add_log_cmd(Info.ENABLE_ORDER_CHECKING) q.add_pus_tc( create_load_param_cmd( create_scalar_boolean_parameter( PL_PCDU_ID, 0, ParamId.DISABLE_ORDER_CHECK_CHANNELS, False ) ) ) if op_code == OpCode.UPDATE_I_UPPER_LIMIT: q.add_log_cmd(Info.UPDATE_I_UPPER_LIMIT) print("Select device to update lower current limit for: ") param_id = dev_select_to_upper_i_update_param_id(dev_select_prompt(True)) new_param_value = float( input("Please specify new parameter value as a double: ") ) q.add_pus_tc( create_load_param_cmd( create_scalar_double_parameter(PL_PCDU_ID, 0, param_id, new_param_value) ) ) if op_code == OpCode.UPDATE_V_LOWER_LIMIT: q.add_log_cmd(Info.UPDATE_V_LOWER_LIMIT) print("Select device to update lower voltage limit for: ") param_id = dev_select_to_lower_u_update_param_id(dev_select_prompt(False)) new_param_value = float( input("Please specify new parameter value as a double: ") ) q.add_pus_tc( create_load_param_cmd( create_scalar_double_parameter(PL_PCDU_ID, 0, param_id, new_param_value) ) ) if op_code == OpCode.UPDATE_V_UPPER_LIMIT: q.add_log_cmd(Info.UPDATE_V_UPPER_LIMIT) print("Select device to update upper voltage limit for: ") param_id = dev_select_to_upper_u_update_param_id(dev_select_prompt(False)) new_param_value = float( input("Please specify new parameter value as a double: ") ) q.add_pus_tc( create_load_param_cmd( create_scalar_double_parameter(PL_PCDU_ID, 0, param_id, new_param_value) ) ) if op_code == OpCode.SWITCH_HPA_ON_PROC: hpa_on_procedure(q) if op_code == OpCode.INJECT_ALL_ON_FAILURE: pack_failure_injection_cmd( q=q, param_id=ParamId.INJECT_ALL_ON_FAILURE, print_str="All On", ) def hpa_on_procedure(q: DefaultPusQueueHelper): delay_dro_to_x8 = request_wait_time() if delay_dro_to_x8 is None: delay_dro_to_x8 = 900 q.add_log_cmd( "Starting procedure to switch on PL PCDU HPA with DRO to X8 " f"delay of {delay_dro_to_x8} seconds" ) pl_pcdu_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data(object_id=PL_PCDU_ID, mode=Mode.ON, submode=0), ) ssr_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data( object_id=PL_PCDU_ID, mode=Mode.NORMAL, submode=submode_mask_to_submode( NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON ), ), ) dro_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data( object_id=PL_PCDU_ID, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.DRO_ON), ), ) x8_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data( object_id=PL_PCDU_ID, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.X8_ON), ), ) tx_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data( object_id=PL_PCDU_ID, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.TX_ON), ), ) mpa_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data( object_id=PL_PCDU_ID, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.MPA_ON), ), ) hpa_on = PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=pack_mode_data( object_id=PL_PCDU_ID, mode=Mode.NORMAL, submode=submode_mask_to_submode(NormalSubmodesMask.HPA_ON), ), ) current_time = time.time() enb_sched = create_enable_tc_sched_cmd() sched_time = int(round(current_time + 10)) q.add_pus_tc(enb_sched) tagged_on_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=pl_pcdu_on, ) q.add_pus_tc(tagged_on_cmd) sched_time += 5 tagged_ssr_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=ssr_on, ) q.add_pus_tc(tagged_ssr_cmd) sched_time += 5 tagged_dro_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=dro_on ) q.add_pus_tc(tagged_dro_cmd) sched_time += delay_dro_to_x8 sched_time = int(round(sched_time)) tagged_x8_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=x8_on ) q.add_pus_tc(tagged_x8_cmd) sched_time += 5 tagged_tx_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=tx_on ) q.add_pus_tc(tagged_tx_cmd) sched_time += 5 tagged_mpa_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=mpa_on ) q.add_pus_tc(tagged_mpa_cmd) sched_time += 5 tagged_hpa_cmd = create_time_tagged_cmd( release_time=struct.pack("!I", sched_time), tc_to_insert=hpa_on ) q.add_pus_tc(tagged_hpa_cmd) 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 SubmodeForNormalMode.SSR_ON if on_tgt == NormalSubmodesMask.DRO_ON: return SubmodeForNormalMode.DRO_ON if on_tgt == NormalSubmodesMask.X8_ON: return SubmodeForNormalMode.X8_ON if on_tgt == NormalSubmodesMask.TX_ON: return SubmodeForNormalMode.TX_ON if on_tgt == NormalSubmodesMask.MPA_ON: return SubmodeForNormalMode.MPA_ON if on_tgt == NormalSubmodesMask.HPA_ON: return SubmodeForNormalMode.HPA_ON def pack_wait_time_cmd(q: DefaultPusQueueHelper, param_id: int, print_str: str): wait_time = request_wait_time() q.add_log_cmd(f"Updating {print_str} wait time to {wait_time}") if wait_time is None: return param_data = create_scalar_double_parameter( object_id=PL_PCDU_ID, domain_id=0, unique_id=param_id, parameter=wait_time, ) q.add_pus_tc(create_load_param_cmd(param_data)) def pack_failure_injection_cmd(q: DefaultPusQueueHelper, param_id: int, print_str: str): q.add_log_cmd(f"Inserting {print_str} error") param_data = create_scalar_boolean_parameter( object_id=PL_PCDU_ID, domain_id=0, unique_id=param_id, parameter=True ) q.add_pus_tc(create_load_param_cmd(param_data)) def pack_pl_pcdu_mode_cmd( q: DefaultPusQueueHelper, info: str, mode: Mode, submode: int ): q.add_log_cmd(info) mode_data = pack_mode_data(object_id=PL_PCDU_ID, mode=mode, submode=submode) q.add_pus_tc( PusTelecommand( service=200, subservice=Subservice.TC_MODE_COMMAND, app_data=mode_data ) ) ADC_CHANNELS_NAMED = [ "U BAT DIV 6 [V]", "U NEG V FB [V]", "I HPA [mA]", "U HPA DIV 6 [V]", "I MPA [mA]", "U MPA DIV 6 [V]", "I TX [mA]", "U TX DIV 6 [V]", "I X8 [mA]", "U X8 DIV 6 [V]", "I DRO [mA]", "U DRO DIV 6 [V]", ] def handle_plpcdu_hk(pw: PrintWrapper, set_id: int, hk_data: bytes): if set_id == SetId.ADC: current_idx = 0 pw.dlog("Received PL PCDU ADC HK data") channels = [] ch_print = "Channels Raw (hex): [" for i in range(12): channels.append( struct.unpack("!H", hk_data[current_idx : current_idx + 2])[0] ) if i < 11: ch_print += f"{channels[i]:06x}," else: ch_print += f"{channels[i]:06x}]" current_idx += 2 processed_vals = [] for i in range(12): processed_vals.append( struct.unpack("!f", hk_data[current_idx : current_idx + 4])[0] ) current_idx += 4 temp = struct.unpack("!f", hk_data[current_idx : current_idx + 4])[0] current_idx += 4 pw.dlog(f"Temperature: {temp} C") pw.dlog(ch_print) for i in range(12): pw.dlog(f"{ADC_CHANNELS_NAMED[i].ljust(24)} | {processed_vals[i]}") FsfwTmTcPrinter.get_validity_buffer( validity_buffer=hk_data[current_idx:], num_vars=3 ) def dev_select_prompt(skip_ssr: bool) -> DevSelect: while True: for dev in DevSelect: if skip_ssr and dev == DevSelect.SSR_NEG_V: continue print(f"{dev}: {dev.name}") dev_select = int(input("Select device by index: ")) try: return DevSelect(dev_select) except IndexError: _LOGGER.warn("Invalid paramter index, try again.") continue def dev_select_to_upper_i_update_param_id(dev_select: DevSelect) -> ParamId: param_id = None if dev_select == DevSelect.DRO: param_id = ParamId.DRO_I_UPPER_BOUND elif dev_select == DevSelect.X8: param_id = ParamId.X8_I_UPPER_BOUND elif dev_select == DevSelect.TX: param_id = ParamId.TX_I_UPPER_BOUND elif dev_select == DevSelect.MPA: param_id = ParamId.MPA_I_UPPER_BOUND elif dev_select == DevSelect.HPA: param_id = ParamId.HPA_I_UPPER_BOUND if param_id is None: raise ValueError("invalid parameter ID") return param_id def dev_select_to_lower_u_update_param_id(dev_select: DevSelect) -> ParamId: param_id = None if dev_select == DevSelect.SSR_NEG_V: param_id = ParamId.NEG_V_LOWER_BOUND if dev_select == DevSelect.DRO: param_id = ParamId.DRO_U_LOWER_BOUND elif dev_select == DevSelect.X8: param_id = ParamId.X8_U_LOWER_BOUND elif dev_select == DevSelect.TX: param_id = ParamId.TX_U_LOWER_BOUND elif dev_select == DevSelect.MPA: param_id = ParamId.MPA_U_LOWER_BOUND elif dev_select == DevSelect.HPA: param_id = ParamId.HPA_U_LOWER_BOUND if param_id is None: raise ValueError("invalid parameter ID") return param_id def dev_select_to_upper_u_update_param_id(dev_select: DevSelect) -> ParamId: param_id = None if dev_select == DevSelect.SSR_NEG_V: param_id = ParamId.NEG_V_UPPER_BOUND if dev_select == DevSelect.DRO: param_id = ParamId.DRO_U_UPPER_BOUND elif dev_select == DevSelect.X8: param_id = ParamId.X8_U_UPPER_BOUND elif dev_select == DevSelect.TX: param_id = ParamId.TX_U_UPPER_BOUND elif dev_select == DevSelect.MPA: param_id = ParamId.MPA_U_UPPER_BOUND elif dev_select == DevSelect.HPA: param_id = ParamId.HPA_U_UPPER_BOUND if param_id is None: raise ValueError("invalid parameter ID") return param_id def prompt_custom_normal_submode() -> int: print("Prompting custom submode.") submode = 0 def prompt_channel(submode: int, channel_str: str, mask: NormalSubmodesMask) -> int: while True: channel_on = input(f" {channel_str} ON? [y/n]: ") if channel_on in ["y", "1", "yes"]: submode |= 1 << mask elif channel_on in ["n", "0", "no"]: pass else: _LOGGER.warning("invalid input, try again") continue break return submode submode = prompt_channel( submode, "SSR", NormalSubmodesMask.SOLID_STATE_RELAYS_ADC_ON ) submode = prompt_channel(submode, "DRO", NormalSubmodesMask.DRO_ON) submode = prompt_channel(submode, "X8", NormalSubmodesMask.X8_ON) submode = prompt_channel(submode, "TX", NormalSubmodesMask.TX_ON) submode = prompt_channel(submode, "MPA", NormalSubmodesMask.MPA_ON) submode = prompt_channel(submode, "HPA", NormalSubmodesMask.HPA_ON) return submode