eive/eive-tmtc
eive
/
eive-tmtc
13
0
Fork 0
Code Issues Pull Requests 3 Projects Releases 96 Wiki Activity

starting changing code to new API

This commit is contained in:
Robin Müller 2022-07-04 15:22:53 +02:00
parent fd5b946810
commit 27edcbd71d
No known key found for this signature in database
GPG Key ID: 71B58F8A3CDFA9AC
34 changed files with 1472 additions and 1737 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.run/Unittests_in_tmtccmd.run.xml → .run/Python tests in tests.run.xml
View File

@ -1,17 +1,16 @@
<component name="ProjectRunConfigurationManager"> <component name="ProjectRunConfigurationManager">
<configuration default="false" name="Unittests in tmtccmd" type="tests" factoryName="Unittests"> <configuration default="false" name="Python tests in tmtccmd" type="tests" factoryName="Autodetect">
<module name="tmtc" /> <module name="tmtc" />
<option name="INTERPRETER_OPTIONS" value="" /> <option name="INTERPRETER_OPTIONS" value="" />
<option name="PARENT_ENVS" value="true" /> <option name="PARENT_ENVS" value="true" />
<option name="SDK_HOME" value="" /> <option name="SDK_HOME" value="" />
<option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/tmtccmd/src/tests" /> <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/deps/tmtccmd/tests" />
<option name="IS_MODULE_SDK" value="true" /> <option name="IS_MODULE_SDK" value="true" />
<option name="ADD_CONTENT_ROOTS" value="true" /> <option name="ADD_CONTENT_ROOTS" value="true" />
<option name="ADD_SOURCE_ROOTS" value="true" /> <option name="ADD_SOURCE_ROOTS" value="true" />
<EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" /> <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
<option name="_new_pattern" value="&quot;&quot;" />
<option name="_new_additionalArguments" value="&quot;&quot;" /> <option name="_new_additionalArguments" value="&quot;&quot;" />
<option name="_new_target" value="&quot;$PROJECT_DIR$/tmtccmd/src/tests&quot;" /> <option name="_new_target" value="&quot;$PROJECT_DIR$/deps/tmtccmd/tests&quot;" />
<option name="_new_targetType" value="&quot;PATH&quot;" /> <option name="_new_targetType" value="&quot;PATH&quot;" />
<method v="2" /> <method v="2" />
</configuration> </configuration>

18
.run/Unittests_in_spacepackets.run.xml
View File

@ -1,18 +0,0 @@
<component name="ProjectRunConfigurationManager">
<configuration default="false" name="Unittests in spacepackets" type="tests" factoryName="Unittests">
<module name="tmtc" />
<option name="INTERPRETER_OPTIONS" value="" />
<option name="PARENT_ENVS" value="true" />
<option name="SDK_HOME" value="" />
<option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/spacepackets/tests" />
<option name="IS_MODULE_SDK" value="true" />
<option name="ADD_CONTENT_ROOTS" value="true" />
<option name="ADD_SOURCE_ROOTS" value="true" />
<EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
<option name="_new_pattern" value="&quot;&quot;" />
<option name="_new_additionalArguments" value="&quot;&quot;" />
<option name="_new_target" value="&quot;$PROJECT_DIR$/spacepackets/tests&quot;" />
<option name="_new_targetType" value="&quot;PATH&quot;" />
<method v="2" />
</configuration>
</component>

2
config/hook_implementations.py
View File

@ -39,7 +39,7 @@ class EiveHookObject(TmTcHookBase):
custom_mode_operation(mode=mode, tmtc_backend=tmtc_backend) custom_mode_operation(mode=mode, tmtc_backend=tmtc_backend)
def pack_service_queue(self, service: int, op_code: str, service_queue: TcQueueT): def pack_service_queue(self, service: int, op_code: str, service_queue: TcQueueT):
from pus_tc.tc_packer_hook import pack_service_queue_user from pus_tc.procedure_packer import pack_service_queue_user
pack_service_queue_user( pack_service_queue_user(
service=service, op_code=op_code, service_queue=service_queue service=service, op_code=op_code, service_queue=service_queue

2
deps/tmtccmd vendored

@ -1 +1 @@
Subproject commit 82962b95ebda8fc5200fe999319abb3bdb7fcd90 Subproject commit e5d12ca4c0da06338e575701972aaf4180b49635

19
gomspace/gomspace_common.py
View File

@ -8,6 +8,7 @@
""" """
import enum import enum
import struct import struct
from typing import Union
from tmtccmd.tc.pus_8_funccmd import generate_action_command from tmtccmd.tc.pus_8_funccmd import generate_action_command
from tmtccmd.tc.definitions import PusTelecommand from tmtccmd.tc.definitions import PusTelecommand
@ -74,7 +75,10 @@ class Channel:
def pack_get_param_command( def pack_get_param_command(
object_id: bytes, table_id: int, memory_address: bytearray, parameter_size: int object_id: bytes,
table_id: int,
memory_address: Union[int, bytes],
parameter_size: int,
) -> PusTelecommand: ) -> PusTelecommand:
"""Function to generate a command to retrieve parameters like the temperature from a gomspace device. """Function to generate a command to retrieve parameters like the temperature from a gomspace device.
@param object_id: The object id of the gomspace device handler. @param object_id: The object id of the gomspace device handler.
@ -83,9 +87,12 @@ def pack_get_param_command(
@param parameter_size: Size of the value to read. E.g. temperature is uint16_t and thus parameter_size is 2 @param parameter_size: Size of the value to read. E.g. temperature is uint16_t and thus parameter_size is 2
@return: The command as bytearray. @return: The command as bytearray.
""" """
app_data = struct.pack('!B', table_id) app_data = struct.pack("!B", table_id)
app_data += struct.pack('!H', memory_address) if isinstance(memory_address, int):
app_data += struct.pack('!B', parameter_size) app_data += struct.pack("!H", memory_address)
else:
app_data += memory_address
app_data += struct.pack("!B", parameter_size)
return generate_action_command( return generate_action_command(
object_id=object_id, object_id=object_id,
action_id=GomspaceDeviceActionIds.PARAM_GET, action_id=GomspaceDeviceActionIds.PARAM_GET,
@ -95,7 +102,7 @@ def pack_get_param_command(
def pack_set_param_command( def pack_set_param_command(
object_id: bytes, object_id: bytes,
memory_address: bytearray, memory_address: bytes,
parameter_size: int, parameter_size: int,
parameter: int, parameter: int,
ssc: int = 0, ssc: int = 0,
@ -116,7 +123,7 @@ def pack_set_param_command(
if parameter_size == 1: if parameter_size == 1:
app_data.append(parameter) app_data.append(parameter)
elif parameter_size == 2: elif parameter_size == 2:
app_data += struct.pack('!H', parameter) app_data += struct.pack("!H", parameter)
elif parameter_size == 4: elif parameter_size == 4:
byte_one = 0xFF000000 & parameter >> 24 byte_one = 0xFF000000 & parameter >> 24
byte_two = 0xFF0000 & parameter >> 16 byte_two = 0xFF0000 & parameter >> 16

197
pus_tc/devs/acu.py
View File

@ -6,9 +6,8 @@
import struct import struct
from config.definitions import CustomServiceList from config.definitions import CustomServiceList
from tmtccmd.config import add_op_code_entry, add_service_op_code_entry
from tmtccmd.tc.packer import TcQueueT from tmtccmd.tc import QueueHelper
from tmtccmd.config.definitions import QueueCommands, ServiceOpCodeDictT
from tmtccmd.tc.pus_3_fsfw_hk import ( from tmtccmd.tc.pus_3_fsfw_hk import (
make_sid, make_sid,
generate_one_diag_command, generate_one_diag_command,
@ -84,53 +83,48 @@ def add_acu_cmds(cmd_dict: ServiceOpCodeDictT):
) )
def pack_acu_commands( def pack_acu_commands(object_id: ObjectId, q: QueueHelper, op_code: str) -> TcQueueT:
object_id: ObjectId, tc_queue: TcQueueT, op_code: str q.add_log_cmd("Handling ACU command")
) -> TcQueueT:
tc_queue.appendleft((QueueCommands.PRINT, "Handling ACU command"))
if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I: if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Print channel stats")) q.add_log_cmd("ACU: Print channel stats")
command = generate_action_command( q.add_pus_tc(
object_id=object_id.as_bytes, generate_action_command(
action_id=gs.GomspaceDeviceActionIds.PRINT_SWITCH_V_I, object_id=object_id.as_bytes,
action_id=gs.GomspaceDeviceActionIds.PRINT_SWITCH_V_I,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE:
tc_queue.appendleft( q.add_log_cmd(f"PDU1: {GsInfo.REQUEST_CORE_HK_ONCE}")
(QueueCommands.PRINT, f"PDU1: {GsInfo.REQUEST_CORE_HK_ONCE}")
)
hk_sid = make_sid(object_id=object_id.as_bytes, set_id=gs.SetIds.ACU_CORE) hk_sid = make_sid(object_id=object_id.as_bytes, set_id=gs.SetIds.ACU_CORE)
command = generate_one_diag_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_diag_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE:
tc_queue.appendleft( q.add_log_cmd(f"PDU1: {GsInfo.REQUEST_AUX_HK_ONCE}")
(QueueCommands.PRINT, f"PDU1: {GsInfo.REQUEST_AUX_HK_ONCE}")
)
hk_sid = make_sid(object_id=object_id.as_bytes, set_id=gs.SetIds.ACU_AUX) hk_sid = make_sid(object_id=object_id.as_bytes, set_id=gs.SetIds.ACU_AUX)
command = generate_one_hk_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.GET_PARAM: if op_code in GomspaceOpCodes.GET_PARAM:
tc_queue.appendleft( q.add_log_cmd(f"PDU1: {GsInfo.GET_PARAMETER}")
(QueueCommands.PRINT, f"PDU1: {GsInfo.GET_PARAMETER}")
)
table_id = int(input("Specify table ID: ")) table_id = int(input("Specify table ID: "))
memory_address = int(input("Specify memory address: 0x"), 16) memory_address = int(input("Specify memory address: 0x"), 16)
parameter_size = int(input("Specify parameter size: ")) parameter_size = int(input("Specify parameter size: "))
command = gs.pack_get_param_command(object_id.as_bytes, table_id, memory_address, parameter_size) q.add_pus_tc(
tc_queue.appendleft(command.pack_command_tuple()) gs.pack_get_param_command(
if op_code in GomspaceOpCodes.SET_PARAM: object_id.as_bytes, table_id, memory_address, parameter_size
tc_queue.appendleft( )
(QueueCommands.PRINT, f"PDU1: {GsInfo.SET_PARAMETER}")
) )
if op_code in GomspaceOpCodes.SET_PARAM:
q.add_log_cmd(f"PDU1: {GsInfo.SET_PARAMETER}")
memory_address = int(input("Specify memory address: 0x"), 16) memory_address = int(input("Specify memory address: 0x"), 16)
memory_address = struct.pack('!H', memory_address) memory_address = struct.pack("!H", memory_address)
parameter_size = int(input("Specify parameter size: ")) parameter_size = int(input("Specify parameter size: "))
parameter = int(input("Specify parameter: ")) parameter = int(input("Specify parameter: "))
command = gs.pack_set_param_command(object_id.as_bytes, memory_address, parameter_size, parameter) q.add_pus_tc(
tc_queue.appendleft(command.pack_command_tuple()) gs.pack_set_param_command(
pack_test_cmds(object_id=object_id, tc_queue=tc_queue) object_id.as_bytes, memory_address, parameter_size, parameter
)
)
pack_test_cmds(object_id=object_id, q=q)
return tc_queue return q
class ACUTestProcedure: class ACUTestProcedure:
@ -156,91 +150,84 @@ class ACUTestProcedure:
off = False off = False
def pack_test_cmds(object_id: ObjectId, tc_queue: TcQueueT): def pack_test_cmds(object_id: ObjectId, q: QueueHelper):
if ACUTestProcedure.all or ACUTestProcedure.reboot: if ACUTestProcedure.all or ACUTestProcedure.reboot:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Reboot")) q.add_log_cmd("ACU: Reboot")
command = gs.pack_reboot_command(object_id) q.add_pus_tc(gs.pack_reboot_command(object_id))
# command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.read_gnd_wdt: if ACUTestProcedure.all or ACUTestProcedure.read_gnd_wdt:
tc_queue.appendleft( q.add_log_cmd("ACU: Reading ground watchdog timer value")
(QueueCommands.PRINT, "ACU: Reading ground watchdog timer value") q.add_pus_tc(
gs.pack_get_param_command(
object_id.as_bytes,
gs.TableIds.hk,
ACUHkTable.wdt_gnd_left.parameter_address,
ACUHkTable.wdt_gnd_left.parameter_size,
)
) )
command = gs.pack_get_param_command(
object_id.as_bytes,
gs.TableIds.hk,
ACUHkTable.wdt_gnd_left.parameter_address,
ACUHkTable.wdt_gnd_left.parameter_size,
)
# command = PusTelecommand(service=8, subservice=128, ssc=20, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.gnd_wdt_reset: if ACUTestProcedure.all or ACUTestProcedure.gnd_wdt_reset:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Testing ground watchdog reset")) q.add_log_cmd("ACU: Testing ground watchdog reset")
command = gs.pack_gnd_wdt_reset_command(object_id) q.add_pus_tc(gs.pack_gnd_wdt_reset_command(object_id))
# command = PusTelecommand(service=8, subservice=128, ssc=21, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.ping: if ACUTestProcedure.all or ACUTestProcedure.ping:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Ping Test")) q.add_log_cmd("ACU: Ping Test")
ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
command = gs.pack_ping_command(object_id, ping_data) q.add_pus_tc(gs.pack_ping_command(object_id, ping_data))
# command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.read_temperature3: if ACUTestProcedure.all or ACUTestProcedure.read_temperature3:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Reading temperature 3")) q.add_log_cmd("ACU: Reading temperature 3")
command = gs.pack_get_param_command( q.add_pus_tc(
object_id.as_bytes, gs.pack_get_param_command(
gs.TableIds.hk, object_id.as_bytes,
ACUHkTable.temperature3.parameter_address, gs.TableIds.hk,
ACUHkTable.temperature3.parameter_size, ACUHkTable.temperature3.parameter_address,
ACUHkTable.temperature3.parameter_size,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.read_vboost: if ACUTestProcedure.all or ACUTestProcedure.read_vboost:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Reading vboost value")) q.add_log_cmd("ACU: Reading vboost value")
command = gs.pack_get_param_command( q.add_pus_tc(
object_id.as_bytes, gs.pack_get_param_command(
gs.TableIds.config, object_id.as_bytes,
ACUConfigTable.vboost.parameter_address, gs.TableIds.config,
ACUConfigTable.vboost.parameter_size, ACUConfigTable.vboost.parameter_address,
ACUConfigTable.vboost.parameter_size,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.read_vbat_max_hi: if ACUTestProcedure.all or ACUTestProcedure.read_vbat_max_hi:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Reading vbat_max_hi")) q.add_log_cmd("ACU: Reading vbat_max_hi")
command = gs.pack_get_param_command( q.add_pus_tc(
object_id.as_bytes, gs.pack_get_param_command(
gs.TableIds.config, object_id.as_bytes,
ACUConfigTable.vbat_max_hi.parameter_address, gs.TableIds.config,
ACUConfigTable.vbat_max_hi.parameter_size, ACUConfigTable.vbat_max_hi.parameter_address,
ACUConfigTable.vbat_max_hi.parameter_size,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.read_vbat_max_lo: if ACUTestProcedure.all or ACUTestProcedure.read_vbat_max_lo:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Reading vbat_max_lo")) q.add_log_cmd("ACU: Reading vbat_max_lo")
command = gs.pack_get_param_command( q.add_pus_tc(
object_id.as_bytes, gs.pack_get_param_command(
gs.TableIds.config, object_id.as_bytes,
ACUConfigTable.vbat_max_lo.parameter_address, gs.TableIds.config,
ACUConfigTable.vbat_max_lo.parameter_size, ACUConfigTable.vbat_max_lo.parameter_address,
ACUConfigTable.vbat_max_lo.parameter_size,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.read_ov_mode: if ACUTestProcedure.all or ACUTestProcedure.read_ov_mode:
tc_queue.appendleft((QueueCommands.PRINT, "ACU: Reading ov_mode")) q.add_log_cmd("ACU: Reading ov_mode")
command = gs.pack_get_param_command( q.add_pus_tc(
object_id.as_bytes, gs.pack_get_param_command(
gs.TableIds.config, object_id.as_bytes,
ACUConfigTable.ov_mode.parameter_address, gs.TableIds.config,
ACUConfigTable.ov_mode.parameter_size, ACUConfigTable.ov_mode.parameter_address,
ACUConfigTable.ov_mode.parameter_size,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if ACUTestProcedure.all or ACUTestProcedure.off: if ACUTestProcedure.all or ACUTestProcedure.off:
tc_queue.appendleft((QueueCommands.PRINT, "P60 Dock: Turning off ACU")) q.add_log_cmd("P60 Dock: Turning off ACU")
command = gs.pack_set_param_command( q.add_pus_tc(
ACU_HANDLER_ID, gs.pack_set_param_command(
P60DockConfigTable.out_en_0.parameter_address, ACU_HANDLER_ID,
P60DockConfigTable.out_en_0.parameter_size, P60DockConfigTable.out_en_0.parameter_address,
gs.Channel.off, P60DockConfigTable.out_en_0.parameter_size,
gs.Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())

42
pus_tc/devs/bpx_batt.py
View File

@ -1,5 +1,5 @@
from tmtccmd.tc.definitions import TcQueueT, QueueCommands
from config.object_ids import BPX_HANDLER_ID from config.object_ids import BPX_HANDLER_ID
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_8_funccmd import generate_action_command from tmtccmd.tc.pus_8_funccmd import generate_action_command
from tmtccmd.tc.pus_3_fsfw_hk import generate_one_hk_command, make_sid from tmtccmd.tc.pus_3_fsfw_hk import generate_one_hk_command, make_sid
@ -24,33 +24,33 @@ class BpxOpCodes:
REBOOT = ["4", "reboot"] REBOOT = ["4", "reboot"]
def pack_bpx_commands(tc_queue: TcQueueT, op_code: str): def pack_bpx_commands(q: QueueHelper, op_code: str):
if op_code in BpxOpCodes.HK: if op_code in BpxOpCodes.HK:
tc_queue.appendleft((QueueCommands.PRINT, "Requesting BPX battery HK set")) q.add_log_cmd("Requesting BPX battery HK set")
sid = make_sid(object_id=BPX_HANDLER_ID, set_id=BpxSetIds.GET_HK_SET) sid = make_sid(object_id=BPX_HANDLER_ID, set_id=BpxSetIds.GET_HK_SET)
cmd = generate_one_hk_command(sid=sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=sid))
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in BpxOpCodes.RST_BOOT_CNT: if op_code in BpxOpCodes.RST_BOOT_CNT:
tc_queue.appendleft((QueueCommands.PRINT, "Resetting reboot counters")) q.add_log_cmd("Resetting reboot counters")
cmd = generate_action_command( q.add_pus_tc(
object_id=BPX_HANDLER_ID, action_id=BpxActionIds.RESET_COUNTERS generate_action_command(
object_id=BPX_HANDLER_ID, action_id=BpxActionIds.RESET_COUNTERS
)
) )
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in BpxOpCodes.REQUEST_CFG: if op_code in BpxOpCodes.REQUEST_CFG:
tc_queue.appendleft((QueueCommands.PRINT, "Requesting configuration struct")) q.add_log_cmd("Requesting configuration struct")
cmd = generate_action_command( q.add_pus_tc(
object_id=BPX_HANDLER_ID, action_id=BpxActionIds.GET_CFG generate_action_command(
object_id=BPX_HANDLER_ID, action_id=BpxActionIds.GET_CFG
)
) )
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in BpxOpCodes.REQUEST_CFG_HK: if op_code in BpxOpCodes.REQUEST_CFG_HK:
tc_queue.appendleft((QueueCommands.PRINT, "Requesting configuration struct HK")) q.add_log_cmd("Requesting configuration struct HK")
sid = make_sid(object_id=BPX_HANDLER_ID, set_id=BpxSetIds.GET_CFG_SET) sid = make_sid(object_id=BPX_HANDLER_ID, set_id=BpxSetIds.GET_CFG_SET)
cmd = generate_one_hk_command(sid=sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=sid))
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in BpxOpCodes.REBOOT: if op_code in BpxOpCodes.REBOOT:
tc_queue.appendleft((QueueCommands.PRINT, "Rebooting BPX battery")) q.add_log_cmd("Rebooting BPX battery")
cmd = generate_action_command( q.add_pus_tc(
object_id=BPX_HANDLER_ID, action_id=BpxActionIds.REBOOT generate_action_command(
object_id=BPX_HANDLER_ID, action_id=BpxActionIds.REBOOT
)
) )
tc_queue.appendleft(cmd.pack_command_tuple())
pass

35
pus_tc/devs/heater.py
View File

@ -7,16 +7,14 @@ import enum
from config.definitions import CustomServiceList from config.definitions import CustomServiceList
from config.object_ids import get_object_ids from config.object_ids import get_object_ids
from tmtccmd.tc import QueueHelper
from tmtccmd.utility.obj_id import ObjectId from tmtccmd.utility.obj_id import ObjectId
from tmtccmd.config.definitions import QueueCommands, ServiceOpCodeDictT
from tmtccmd.tc.pus_201_fsfw_health import ( from tmtccmd.tc.pus_201_fsfw_health import (
pack_set_health_cmd_data, pack_set_health_cmd_data,
FsfwHealth, FsfwHealth,
Subservices, Subservices,
) )
from tmtccmd.tc.pus_8_funccmd import generate_action_command from tmtccmd.tc.pus_8_funccmd import generate_action_command
from tmtccmd.config.globals import add_service_op_code_entry, add_op_code_entry
from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
@ -82,9 +80,9 @@ def add_heater_cmds(cmd_dict: ServiceOpCodeDictT):
) )
def pack_heater_cmds(object_id: bytearray, op_code: str, tc_queue: TcQueueT): def pack_heater_cmds(object_id: bytearray, op_code: str, q: QueueHelper):
if op_code in OpCodes.HEATER_CMD: if op_code in OpCodes.HEATER_CMD:
tc_queue.appendleft((QueueCommands.PRINT, "Heater Switching")) q.add_log_cmd("Heater Switching")
heater_number = prompt_heater() heater_number = prompt_heater()
while True: while True:
action = input("Turn switch on or off? (0 - off, 1 - on): ") action = input("Turn switch on or off? (0 - off, 1 - on): ")
@ -101,14 +99,13 @@ def pack_heater_cmds(object_id: bytearray, op_code: str, tc_queue: TcQueueT):
else: else:
act_str = "off" act_str = "off"
debug_string = f"Switching heater {heater_number} {act_str}" debug_string = f"Switching heater {heater_number} {act_str}"
tc_queue.appendleft((QueueCommands.PRINT, debug_string)) q.add_log_cmd(debug_string)
command = pack_switch_heater_command(object_id, heater_number, action) q.add_pus_tc(pack_switch_heater_command(object_id, heater_number, action))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodes.HEATER_EXT_CTRL: if op_code in OpCodes.HEATER_EXT_CTRL:
heater_number = prompt_heater() heater_number = prompt_heater()
obj_id = heater_idx_to_obj(heater_number) obj_id = heater_idx_to_obj(heater_number)
health_cmd( health_cmd(
tc_queue=tc_queue, q=q,
object_id=obj_id, object_id=obj_id,
health=FsfwHealth.EXTERNAL_CTRL, health=FsfwHealth.EXTERNAL_CTRL,
health_str="External Control", health_str="External Control",
@ -118,7 +115,7 @@ def pack_heater_cmds(object_id: bytearray, op_code: str, tc_queue: TcQueueT):
heater_number = prompt_heater() heater_number = prompt_heater()
obj_id = heater_idx_to_obj(heater_number) obj_id = heater_idx_to_obj(heater_number)
health_cmd( health_cmd(
tc_queue=tc_queue, q=q,
object_id=obj_id, object_id=obj_id,
health=FsfwHealth.FAULTY, health=FsfwHealth.FAULTY,
health_str="Faulty", health_str="Faulty",
@ -128,7 +125,7 @@ def pack_heater_cmds(object_id: bytearray, op_code: str, tc_queue: TcQueueT):
heater_number = prompt_heater() heater_number = prompt_heater()
obj_id = heater_idx_to_obj(heater_number) obj_id = heater_idx_to_obj(heater_number)
health_cmd( health_cmd(
tc_queue=tc_queue, q=q,
object_id=obj_id, object_id=obj_id,
health=FsfwHealth.HEALTHY, health=FsfwHealth.HEALTHY,
health_str="Healthy", health_str="Healthy",
@ -188,23 +185,19 @@ def prompt_heater() -> int:
def health_cmd( def health_cmd(
tc_queue: TcQueueT, q: QueueHelper,
heater_idx: int, heater_idx: int,
object_id: ObjectId, object_id: ObjectId,
health: FsfwHealth, health: FsfwHealth,
health_str: str, health_str: str,
): ):
tc_queue.appendleft( q.add_log_cmd(f"Setting Heater {heater_idx} {object_id} to {health_str}")
( app_data = pack_set_health_cmd_data(object_id=object_id.as_bytes, health=health)
QueueCommands.PRINT, q.add_pus_tc(
f"Setting Heater {heater_idx} {object_id} to {health_str}", PusTelecommand(
service=201, subservice=Subservices.TC_SET_HEALTH, app_data=app_data
) )
) )
app_data = pack_set_health_cmd_data(object_id=object_id.as_bytes, health=health)
cmd = PusTelecommand(
service=201, subservice=Subservices.TC_SET_HEALTH, app_data=app_data
)
tc_queue.appendleft(cmd.pack_command_tuple())
def pack_switch_heater_command( def pack_switch_heater_command(

293
pus_tc/devs/imtq.py
View File

@ -7,16 +7,15 @@
""" """
import struct import struct
from tmtccmd.config.definitions import QueueCommands
from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_3_fsfw_hk import ( from tmtccmd.tc.pus_3_fsfw_hk import (
make_sid, make_sid,
generate_one_diag_command, generate_one_diag_command,
generate_one_hk_command, generate_one_hk_command,
) )
from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes
from tmtccmd.utility import ObjectId
class ImtqSetIds: class ImtqSetIds:
@ -40,233 +39,149 @@ class ImtqActionIds:
perform_negative_y_test = bytearray([0x0, 0x0, 0x0, 0x0A]) perform_negative_y_test = bytearray([0x0, 0x0, 0x0, 0x0A])
perform_positive_z_test = bytearray([0x0, 0x0, 0x0, 0x0B]) perform_positive_z_test = bytearray([0x0, 0x0, 0x0, 0x0B])
perform_negative_z_test = bytearray([0x0, 0x0, 0x0, 0x0C]) perform_negative_z_test = bytearray([0x0, 0x0, 0x0, 0x0C])
# Initiates the reading of the last performed self test. After sending this command the results can be downlinked # Initiates the reading of the last performed self test. After sending this command the results
# via the housekeeping service by using the appropriate set ids listed above. # can be downlinked via the housekeeping service by using the appropriate set ids listed above.
read_self_test_results = bytearray([0x0, 0x0, 0x0, 0x0D]) read_self_test_results = bytearray([0x0, 0x0, 0x0, 0x0D])
def pack_imtq_test_into( def pack_imtq_test_into(object_id: ObjectId, q: QueueHelper, op_code: str):
object_id: bytearray, tc_queue: TcQueueT, op_code: str q.add_log_cmd(
) -> TcQueueT: f"Testing ISIS IMTQ handler with object id: {object_id.as_hex_string}"
tc_queue.appendleft(
(
QueueCommands.PRINT,
"Testing ISIS IMTQ handler with object id: 0x" + object_id.hex(),
)
) )
if op_code == "0": if op_code == "0":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Set mode off")) q.add_log_cmd("IMTQ: Set mode off")
command = pack_mode_data(object_id, Modes.OFF, 0) command = pack_mode_data(object_id.as_bytes, Modes.OFF, 0)
command = PusTelecommand(service=200, subservice=1, ssc=9, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "1": if op_code == "1":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Set mode on")) q.add_log_cmd("IMTQ: Set mode on")
command = pack_mode_data(object_id, Modes.ON, 0) command = pack_mode_data(object_id.as_bytes, Modes.ON, 0)
command = PusTelecommand(service=200, subservice=1, ssc=10, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "2": if op_code == "2":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Mode Normal")) q.add_log_cmd("IMTQ: Mode Normal")
command = pack_mode_data(object_id, Modes.NORMAL, 0) command = pack_mode_data(object_id.as_bytes, Modes.NORMAL, 0)
command = PusTelecommand(service=200, subservice=1, ssc=11, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "3": if op_code == "3":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Perform positive x self test")) q.add_log_cmd("IMTQ: Perform positive x self test")
command = object_id + ImtqActionIds.perform_positive_x_test command = object_id.as_bytes + ImtqActionIds.perform_positive_x_test
command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft( q.add_log_cmd("IMTQ: Initiate reading of positive x self test results")
( command = object_id.as_bytes + ImtqActionIds.read_self_test_results
QueueCommands.PRINT, q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
"IMTQ: Initiate reading of positive x self test results",
)
)
command = object_id + ImtqActionIds.read_self_test_results
command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft( q.add_log_cmd("IMTQ: Request dataset with positive x self test results")
( sid = make_sid(object_id.as_bytes, ImtqSetIds.POSITIVE_X_TEST)
QueueCommands.PRINT, q.add_pus_tc(generate_one_hk_command(sid))
"IMTQ: Request dataset with positive x self test results",
)
)
sid = make_sid(object_id, ImtqSetIds.POSITIVE_X_TEST)
command = generate_one_hk_command(sid, 24)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "4": if op_code == "4":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Perform negative x self test")) q.add_log_cmd("IMTQ: Perform negative x self test")
command = object_id + ImtqActionIds.perform_negative_x_test command = object_id.as_bytes + ImtqActionIds.perform_negative_x_test
command = PusTelecommand(service=8, subservice=128, ssc=25, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("IMTQ: Initiate reading of negative x self test results")
command = object_id.as_bytes + ImtqActionIds.read_self_test_results
tc_queue.appendleft( q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
( q.add_log_cmd("IMTQ: Request dataset with negative x self test results")
QueueCommands.PRINT, sid = make_sid(object_id.as_bytes, ImtqSetIds.NEGATIVE_X_TEST)
"IMTQ: Initiate reading of negative x self test results", q.add_pus_tc(generate_one_hk_command(sid))
)
)
command = object_id + ImtqActionIds.read_self_test_results
command = PusTelecommand(service=8, subservice=128, ssc=26, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft(
(
QueueCommands.PRINT,
"IMTQ: Request dataset with negative x self test results",
)
)
sid = make_sid(object_id, ImtqSetIds.NEGATIVE_X_TEST)
command = generate_one_hk_command(sid, 27)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "5": if op_code == "5":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Perform positive y self test")) q.add_log_cmd("IMTQ: Perform positive y self test")
command = object_id + ImtqActionIds.perform_positive_y_test command = object_id.as_bytes + ImtqActionIds.perform_positive_y_test
command = PusTelecommand(service=8, subservice=128, ssc=28, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("IMTQ: Initiate reading of positive y self test results")
command = object_id.as_bytes + ImtqActionIds.read_self_test_results
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft( q.add_log_cmd("IMTQ: Request dataset with positive y self test results")
( sid = make_sid(object_id.as_bytes, ImtqSetIds.POSITIVE_Y_TEST)
QueueCommands.PRINT, q.add_pus_tc(generate_one_hk_command(sid))
"IMTQ: Initiate reading of positive y self test results",
)
)
command = object_id + ImtqActionIds.read_self_test_results
command = PusTelecommand(service=8, subservice=128, ssc=29, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft(
(
QueueCommands.PRINT,
"IMTQ: Request dataset with positive y self test results",
)
)
sid = make_sid(object_id, ImtqSetIds.POSITIVE_Y_TEST)
command = generate_one_hk_command(sid, 30)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "6": if op_code == "6":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Perform negative y self test")) q.add_log_cmd("IMTQ: Perform negative y self test")
command = object_id + ImtqActionIds.perform_negative_y_test command = object_id.as_bytes + ImtqActionIds.perform_negative_y_test
command = PusTelecommand(service=8, subservice=128, ssc=31, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft( q.add_log_cmd("IMTQ: Initiate reading of negative y self test results")
( command = object_id.as_bytes + ImtqActionIds.read_self_test_results
QueueCommands.PRINT, q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
"IMTQ: Initiate reading of negative y self test results",
)
)
command = object_id + ImtqActionIds.read_self_test_results
command = PusTelecommand(service=8, subservice=128, ssc=32, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft( q.add_log_cmd("IMTQ: Request dataset with negative y self test results")
( sid = make_sid(object_id.as_bytes, ImtqSetIds.NEGATIVE_Y_TEST)
QueueCommands.PRINT, q.add_pus_tc(generate_one_hk_command(sid))
"IMTQ: Request dataset with negative y self test results",
)
)
sid = make_sid(object_id, ImtqSetIds.NEGATIVE_Y_TEST)
command = generate_one_hk_command(sid, 33)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "7": if op_code == "7":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Perform positive z self test")) q.add_log_cmd("IMTQ: Perform positive z self test")
command = object_id + ImtqActionIds.perform_positive_z_test command = object_id.as_bytes + ImtqActionIds.perform_positive_z_test
command = PusTelecommand(service=8, subservice=128, ssc=34, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft( q.add_log_cmd("IMTQ: Initiate reading of positive z self test results")
( command = object_id.as_bytes + ImtqActionIds.read_self_test_results
QueueCommands.PRINT, q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
"IMTQ: Initiate reading of positive z self test results",
)
)
command = object_id + ImtqActionIds.read_self_test_results
command = PusTelecommand(service=8, subservice=128, ssc=35, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft( q.add_log_cmd("IMTQ: Request dataset with positive z self test results")
( sid = make_sid(object_id.as_bytes, ImtqSetIds.POSITIVE_Y_TEST)
QueueCommands.PRINT, q.add_pus_tc(generate_one_hk_command(sid))
"IMTQ: Request dataset with positive z self test results",
)
)
sid = make_sid(object_id, ImtqSetIds.POSITIVE_Y_TEST)
command = generate_one_hk_command(sid, 36)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "8": if op_code == "8":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Perform negative z self test")) q.add_log_cmd("IMTQ: Perform negative z self test")
command = object_id + ImtqActionIds.perform_negative_z_test command = object_id.as_bytes + ImtqActionIds.perform_negative_z_test
command = PusTelecommand(service=8, subservice=128, ssc=35, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("IMTQ: Initiate reading of negative z self test results")
command = object_id.as_bytes + ImtqActionIds.read_self_test_results
tc_queue.appendleft( q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
( q.add_log_cmd("IMTQ: Request dataset with negative z self test results")
QueueCommands.PRINT, sid = make_sid(object_id.as_bytes, ImtqSetIds.NEGATIVE_Z_TEST)
"IMTQ: Initiate reading of negative z self test results", q.add_pus_tc(generate_one_hk_command(sid))
)
)
command = object_id + ImtqActionIds.read_self_test_results
command = PusTelecommand(service=8, subservice=128, ssc=36, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft(
(
QueueCommands.PRINT,
"IMTQ: Request dataset with negative z self test results",
)
)
sid = make_sid(object_id, ImtqSetIds.NEGATIVE_Z_TEST)
command = generate_one_hk_command(sid, 37)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "9": if op_code == "9":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Commanding dipole")) q.add_log_cmd("IMTQ: Commanding dipole")
x_dipole = 0 x_dipole = 0
y_dipole = 0 y_dipole = 0
z_dipole = 0 z_dipole = 0
duration = 0 # ms duration = 0 # ms
command = pack_dipole_command(object_id, x_dipole, y_dipole, z_dipole, duration) q.add_pus_tc(
tc_queue.appendleft(command.pack_command_tuple()) pack_dipole_command(
object_id.as_bytes, x_dipole, y_dipole, z_dipole, duration
)
)
if op_code == "10": if op_code == "10":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Get commanded dipole")) q.add_log_cmd("IMTQ: Get commanded dipole")
command = object_id + ImtqActionIds.get_commanded_dipole command = object_id.as_bytes + ImtqActionIds.get_commanded_dipole
command = PusTelecommand(service=8, subservice=128, ssc=21, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "11": if op_code == "11":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Get engineering hk set")) q.add_log_cmd("IMTQ: Get engineering hk set")
command = generate_one_diag_command( q.add_pus_tc(
sid=make_sid(object_id=object_id, set_id=ImtqSetIds.ENG_HK_SET), ssc=0 generate_one_diag_command(
sid=make_sid(object_id=object_id.as_bytes, set_id=ImtqSetIds.ENG_HK_SET)
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "12": if op_code == "12":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Get calibrated MTM hk set")) q.add_log_cmd("IMTQ: Get calibrated MTM hk set")
command = generate_one_diag_command( q.add_pus_tc(
sid=make_sid(object_id=object_id, set_id=ImtqSetIds.CAL_MTM_SET), ssc=0 generate_one_diag_command(
sid=make_sid(
object_id=object_id.as_bytes, set_id=ImtqSetIds.CAL_MTM_SET
)
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "13": if op_code == "13":
tc_queue.appendleft((QueueCommands.PRINT, "IMTQ: Get raw MTM hk set")) q.add_log_cmd("IMTQ: Get raw MTM hk set")
command = generate_one_diag_command( q.add_pus_tc(
sid=make_sid(object_id=object_id, set_id=ImtqSetIds.RAW_MTM_SET), ssc=0 generate_one_diag_command(
sid=make_sid(
object_id=object_id.as_bytes, set_id=ImtqSetIds.RAW_MTM_SET
)
)
) )
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue
def pack_dipole_command( def pack_dipole_command(
object_id: bytearray, x_dipole: int, y_dipole: int, z_dipole: int, duration: int object_id: bytes, x_dipole: int, y_dipole: int, z_dipole: int, duration: int
) -> PusTelecommand: ) -> PusTelecommand:
"""This function packs the command causing the ISIS IMTQ to generate a dipole. """This function packs the command causing the ISIS IMTQ to generate a dipole.
@param object_id The object id of the IMTQ handler. @param object_id The object id of the IMTQ handler.
@ -279,9 +194,9 @@ def pack_dipole_command(
""" """
action_id = ImtqActionIds.start_actuation_dipole action_id = ImtqActionIds.start_actuation_dipole
command = object_id + action_id command = object_id + action_id
command += struct.pack('!h', x_dipole) command += struct.pack("!h", x_dipole)
command += struct.pack('!h', y_dipole) command += struct.pack("!h", y_dipole)
command += struct.pack('!h', z_dipole) command += struct.pack("!h", z_dipole)
command += struct.pack('!h', duration) command += struct.pack("!h", duration)
command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command) command = PusTelecommand(service=8, subservice=128, app_data=command)
return command return command

323
pus_tc/devs/p60dock.py
View File

@ -7,6 +7,8 @@
""" """
from tmtccmd.config.definitions import QueueCommands from tmtccmd.config.definitions import QueueCommands
from tmtccmd.tc.packer import TcQueueT from tmtccmd.tc.packer import TcQueueT
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_3_fsfw_hk import ( from tmtccmd.tc.pus_3_fsfw_hk import (
generate_one_hk_command, generate_one_hk_command,
make_sid, make_sid,
@ -87,240 +89,193 @@ class P60DockHkTable:
wdt_gnd_left = TableEntry(bytearray([0x00, 0xA8]), TableEntry.uint32_size) wdt_gnd_left = TableEntry(bytearray([0x00, 0xA8]), TableEntry.uint32_size)
def pack_p60dock_cmds(object_id: ObjectId, tc_queue: TcQueueT, op_code: str): def pack_p60dock_cmds(object_id: ObjectId, q: QueueHelper, op_code: str):
objb = object_id.as_bytes objb = object_id.as_bytes
if op_code in P60OpCodes.STACK_3V3_ON: if op_code in P60OpCodes.STACK_3V3_ON:
tc_queue.appendleft((QueueCommands.PRINT, Info.STACK_3V3_ON)) q.add_log_cmd(Info.STACK_3V3_ON)
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
P60DockConfigTable.out_en_9.parameter_address, objb,
P60DockConfigTable.out_en_9.parameter_size, P60DockConfigTable.out_en_9.parameter_address,
Channel.on, P60DockConfigTable.out_en_9.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in P60OpCodes.STACK_3V3_OFF: if op_code in P60OpCodes.STACK_3V3_OFF:
tc_queue.appendleft((QueueCommands.PRINT, Info.STACK_3V3_OFF)) q.add_log_cmd(Info.STACK_3V3_OFF)
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
P60DockConfigTable.out_en_9.parameter_address, objb,
P60DockConfigTable.out_en_9.parameter_size, P60DockConfigTable.out_en_9.parameter_address,
Channel.off, P60DockConfigTable.out_en_9.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in P60OpCodes.STACK_5V_ON: if op_code in P60OpCodes.STACK_5V_ON:
tc_queue.appendleft((QueueCommands.PRINT, Info.STACK_5V_ON)) q.add_log_cmd(Info.STACK_5V_ON)
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
P60DockConfigTable.out_en_10.parameter_address, objb,
P60DockConfigTable.out_en_10.parameter_size, P60DockConfigTable.out_en_10.parameter_address,
Channel.on, P60DockConfigTable.out_en_10.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in P60OpCodes.STACK_5V_OFF: if op_code in P60OpCodes.STACK_5V_OFF:
tc_queue.appendleft((QueueCommands.PRINT, Info.STACK_5V_OFF)) q.add_log_cmd(Info.STACK_5V_OFF)
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
P60DockConfigTable.out_en_10.parameter_address, objb,
P60DockConfigTable.out_en_10.parameter_size, P60DockConfigTable.out_en_10.parameter_address,
Channel.off, P60DockConfigTable.out_en_10.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Requesting HK Core HK Once")
(QueueCommands.PRINT, "P60 Dock: Requesting HK Core HK Once")
)
hk_sid = make_sid(object_id=P60_DOCK_HANDLER, set_id=SetIds.P60_CORE) hk_sid = make_sid(object_id=P60_DOCK_HANDLER, set_id=SetIds.P60_CORE)
command = generate_one_hk_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Requesting HK Aux HK Once")
(QueueCommands.PRINT, "P60 Dock: Requesting HK Aux HK Once")
)
hk_sid = make_sid(object_id=P60_DOCK_HANDLER, set_id=SetIds.P60_AUX) hk_sid = make_sid(object_id=P60_DOCK_HANDLER, set_id=SetIds.P60_AUX)
command = generate_one_hk_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I: if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Print Switches, Voltages, Currents")
(QueueCommands.PRINT, "P60 Dock: Print Switches, Voltages, Currents") q.add_pus_tc(
generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_SWITCH_V_I
)
) )
command = generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_SWITCH_V_I
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.PRINT_LATCHUPS: if op_code in GomspaceOpCodes.PRINT_LATCHUPS:
tc_queue.appendleft((QueueCommands.PRINT, "P60 Dock: Print Latchups")) q.add_log_cmd("P60 Dock: Print Latchups")
command = generate_action_command( q.add_pus_tc(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_LATCHUPS generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_LATCHUPS
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.reboot: if P60DockTestProcedure.all or P60DockTestProcedure.reboot:
tc_queue.appendleft((QueueCommands.PRINT, "P60 Dock: Reboot")) q.add_log_cmd("P60 Dock: Reboot")
command = pack_reboot_command(object_id) q.add_pus_tc(pack_reboot_command(object_id))
# command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.read_gnd_wdt: if P60DockTestProcedure.all or P60DockTestProcedure.read_gnd_wdt:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Reading ground watchdog timer value")
(QueueCommands.PRINT, "P60 Dock: Reading ground watchdog timer value") q.add_pus_tc(
pack_get_param_command(
objb,
TableIds.hk,
P60DockHkTable.wdt_gnd_left.parameter_address,
P60DockHkTable.wdt_gnd_left.parameter_size,
)
) )
command = pack_get_param_command(
objb,
TableIds.hk,
P60DockHkTable.wdt_gnd_left.parameter_address,
P60DockHkTable.wdt_gnd_left.parameter_size,
)
# command = PusTelecommand(service=8, subservice=128, ssc=20, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.gnd_wdt_reset: if P60DockTestProcedure.all or P60DockTestProcedure.gnd_wdt_reset:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing ground watchdog reset")
(QueueCommands.PRINT, "P60 Dock: Testing ground watchdog reset") q.add_pus_tc(pack_gnd_wdt_reset_command(object_id))
)
command = pack_gnd_wdt_reset_command(object_id)
# command = PusTelecommand(service=8, subservice=128, ssc=21, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.ping: if P60DockTestProcedure.all or P60DockTestProcedure.ping:
tc_queue.appendleft((QueueCommands.PRINT, "P60 Dock: Ping")) q.add_log_cmd("P60 Dock: Ping")
ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
command = pack_ping_command(object_id, ping_data) q.add_pus_tc(pack_ping_command(object_id, ping_data))
# command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.channel_3_off: if P60DockTestProcedure.all or P60DockTestProcedure.channel_3_off:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing setting output channel 3 off")
(QueueCommands.PRINT, "P60 Dock: Testing setting output channel 3 off")
)
parameter = 0 # set channel off parameter = 0 # set channel off
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
P60DockConfigTable.out_en_3.parameter_address, objb,
P60DockConfigTable.out_en_3.parameter_size, P60DockConfigTable.out_en_3.parameter_address,
parameter, P60DockConfigTable.out_en_3.parameter_size,
parameter,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.read_temperature1: if P60DockTestProcedure.all or P60DockTestProcedure.read_temperature1:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing temperature reading")
(QueueCommands.PRINT, "P60 Dock: Testing temperature reading") q.add_pus_tc(
pack_get_param_command(
objb,
TableIds.hk,
P60DockHkTable.temperature1.parameter_address,
P60DockHkTable.temperature1.parameter_size,
)
) )
command = pack_get_param_command(
objb,
TableIds.hk,
P60DockHkTable.temperature1.parameter_address,
P60DockHkTable.temperature1.parameter_size,
)
# command = PusTelecommand(service=8, subservice=128, ssc=24, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.channel_3_on: if P60DockTestProcedure.all or P60DockTestProcedure.channel_3_on:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing Output Channel 3 state (PDU2)")
(QueueCommands.PRINT, "P60 Dock: Testing Output Channel 3 state (PDU2)") q.add_pus_tc(
pack_get_param_command(
objb,
TableIds.config,
P60DockConfigTable.out_en_3.parameter_address,
P60DockConfigTable.out_en_3.parameter_size,
)
) )
command = pack_get_param_command(
objb,
TableIds.config,
P60DockConfigTable.out_en_3.parameter_address,
P60DockConfigTable.out_en_3.parameter_size,
)
# command = PusTelecommand(service=8, subservice=128, ssc=25, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.read_cur_lu_lim_0: if P60DockTestProcedure.all or P60DockTestProcedure.read_cur_lu_lim_0:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Reading current limit value of output channel 0")
( q.add_pus_tc(
QueueCommands.PRINT, pack_get_param_command(
"P60 Dock: Reading current limit value of output channel 0", objb,
TableIds.config,
P60DockConfigTable.cur_lu_lim_0.parameter_address,
P60DockConfigTable.cur_lu_lim_0.parameter_size,
) )
) )
command = pack_get_param_command(
objb,
TableIds.config,
P60DockConfigTable.cur_lu_lim_0.parameter_address,
P60DockConfigTable.cur_lu_lim_0.parameter_size,
)
# command = PusTelecommand(service=8, subservice=128, ssc=26, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.channel_3_on: if P60DockTestProcedure.all or P60DockTestProcedure.channel_3_on:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing setting output channel 3 on")
(QueueCommands.PRINT, "P60 Dock: Testing setting output channel 3 on")
)
parameter = 1 # set channel on parameter = 1 # set channel on
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
P60DockConfigTable.out_en_3.parameter_address, objb,
P60DockConfigTable.out_en_3.parameter_size, P60DockConfigTable.out_en_3.parameter_address,
parameter, P60DockConfigTable.out_en_3.parameter_size,
parameter,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=27, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.invalid_table_id_test: if P60DockTestProcedure.all or P60DockTestProcedure.invalid_table_id_test:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing invalid table id handling")
(QueueCommands.PRINT, "P60 Dock: Testing invalid table id handling")
)
table_id_invalid = 5 table_id_invalid = 5
command = pack_get_param_command( q.add_pus_tc(
objb, pack_get_param_command(
table_id_invalid, objb,
P60DockHkTable.temperature1.parameter_address, table_id_invalid,
P60DockHkTable.temperature1.parameter_size, P60DockHkTable.temperature1.parameter_address,
P60DockHkTable.temperature1.parameter_size,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=28, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.invalid_address_test: if P60DockTestProcedure.all or P60DockTestProcedure.invalid_address_test:
tc_queue.appendleft( q.add_log_cmd("P60 Dock: Testing invalid address handling in get param command")
(
QueueCommands.PRINT,
"P60 Dock: Testing invalid address handling in get param command",
)
)
invalid_address = bytearray([0x01, 0xF4]) invalid_address = bytearray([0x01, 0xF4])
command = pack_get_param_command( q.add_pus_tc(
objb, pack_get_param_command(
TableIds.hk, objb,
invalid_address, TableIds.hk,
P60DockHkTable.temperature1.parameter_size, invalid_address,
) P60DockHkTable.temperature1.parameter_size,
# command = PusTelecommand(service=8, subservice=128, ssc=29, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft(
(
QueueCommands.PRINT,
"P60 Dock: Testing invalid address handling in set param command",
) )
) )
q.add_log_cmd("P60 Dock: Testing invalid address handling in set param command")
invalid_address = bytearray([0x01, 0xF4]) invalid_address = bytearray([0x01, 0xF4])
parameter_size = 2 parameter_size = 2
parameter = 1 parameter = 1
command = pack_set_param_command( q.add_pus_tc(
objb, invalid_address, parameter_size, parameter pack_set_param_command(objb, invalid_address, parameter_size, parameter)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=30, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if P60DockTestProcedure.all or P60DockTestProcedure.invalid_parameter_size_test: if P60DockTestProcedure.all or P60DockTestProcedure.invalid_parameter_size_test:
tc_queue.appendleft( q.add_log_cmd(
( "P60 Dock: Testing handling of invalid parameter sizes in get-param command"
QueueCommands.PRINT,
"P60 Dock: Testing handling of invalid parameter sizes in get-param command",
)
) )
invalid_size = 5 invalid_size = 5
command = pack_get_param_command( q.add_pus_tc(
objb, pack_get_param_command(
TableIds.hk, objb,
P60DockHkTable.temperature1.parameter_address, TableIds.hk,
invalid_size, P60DockHkTable.temperature1.parameter_address,
) invalid_size,
# command = PusTelecommand(service=8, subservice=128, ssc=31, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
tc_queue.appendleft(
(
QueueCommands.PRINT,
"P60 Dock: Testing handling of invalid parameter size in set-param command",
) )
) )
parameter = 1 q.add_log_cmd(
command = pack_set_param_command( "P60 Dock: Testing handling of invalid parameter size in set-param command"
objb, )
P60DockConfigTable.out_en_3.parameter_address, parameter = 1
invalid_size, q.add_pus_tc(
parameter, pack_set_param_command(
objb,
P60DockConfigTable.out_en_3.parameter_address,
invalid_size,
parameter,
)
) )
# command = PusTelecommand(service=8, subservice=128, ssc=32, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue

26
pus_tc/devs/pdec_handler.py
View File

@ -5,9 +5,8 @@
@author J. Meier @author J. Meier
@date 22.11.2021 @date 22.11.2021
""" """
from tmtccmd.config.definitions import QueueCommands
from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from tmtccmd.tc import QueueHelper
class CommandIds: class CommandIds:
@ -17,24 +16,13 @@ class CommandIds:
PRINT_PDEC_MON = bytearray([0x0, 0x0, 0x0, 0x1]) PRINT_PDEC_MON = bytearray([0x0, 0x0, 0x0, 0x1])
def pack_pdec_handler_test(object_id: bytearray, tc_queue: TcQueueT, op_code: str): def pack_pdec_handler_test(object_id: bytearray, q: QueueHelper, op_code: str):
tc_queue.appendleft( q.add_log_cmd(f"Testing PDEC handler with object id: {object_id.hex()}")
(
QueueCommands.PRINT,
"Testing PDEC handler with object id: 0x" + object_id.hex(),
)
)
if op_code == "0": if op_code == "0":
tc_queue.appendleft((QueueCommands.PRINT, "PDEC Handler: Print CLCW")) q.add_log_cmd("PDEC Handler: Print CLCW")
command = object_id + CommandIds.PRINT_CLCW command = object_id + CommandIds.PRINT_CLCW
command = PusTelecommand(service=8, subservice=128, ssc=30, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "1": if op_code == "1":
tc_queue.appendleft( q.add_log_cmd("PDEC Handler: Print PDEC monitor register")
(QueueCommands.PRINT, "PDEC Handler: Print PDEC monitor register")
)
command = object_id + CommandIds.PRINT_PDEC_MON command = object_id + CommandIds.PRINT_PDEC_MON
command = PusTelecommand(service=8, subservice=128, ssc=31, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())

394
pus_tc/devs/pdu1.py
View File

@ -4,8 +4,8 @@
@date 17.12.2020 @date 17.12.2020
""" """
import gomspace.gomspace_common as gs import gomspace.gomspace_common as gs
from tmtccmd.config.definitions import QueueCommands
from tmtccmd.tc.packer import TcQueueT from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_3_fsfw_hk import ( from tmtccmd.tc.pus_3_fsfw_hk import (
generate_one_hk_command, generate_one_hk_command,
make_sid, make_sid,
@ -55,251 +55,263 @@ class PDU1TestProcedure:
turn_channel_3_off = False turn_channel_3_off = False
def pack_pdu1_commands(object_id: ObjectId, tc_queue: TcQueueT, op_code: str): def pack_pdu1_commands(object_id: ObjectId, q: QueueHelper, op_code: str):
tc_queue.appendleft((QueueCommands.PRINT, "Commanding PDU1")) q.add_log_cmd("Commanding PDU1")
objb = object_id.as_bytes objb = object_id.as_bytes
if op_code == Pdu1OpCodes.TCS_BOARD_ON.value: if op_code == Pdu1OpCodes.TCS_BOARD_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn TCS board on")) q.add_log_cmd("PDU1: Turn TCS board on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_0.parameter_address, objb,
PDUConfigTable.out_en_0.parameter_size, PDUConfigTable.out_en_0.parameter_address,
Channel.on, PDUConfigTable.out_en_0.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.TCS_BOARD_OFF.value: if op_code == Pdu1OpCodes.TCS_BOARD_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn TCS board off")) q.add_log_cmd("PDU1: Turn TCS board off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_0.parameter_address, objb,
PDUConfigTable.out_en_0.parameter_size, PDUConfigTable.out_en_0.parameter_address,
Channel.off, PDUConfigTable.out_en_0.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.STAR_TRACKER_ON.value: if op_code == Pdu1OpCodes.STAR_TRACKER_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn star tracker on")) q.add_log_cmd("PDU1: Turn star tracker on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_2.parameter_address, objb,
PDUConfigTable.out_en_2.parameter_size, PDUConfigTable.out_en_2.parameter_address,
Channel.on, PDUConfigTable.out_en_2.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.STAR_TRACKER_OFF.value: if op_code == Pdu1OpCodes.STAR_TRACKER_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn star tracker off")) q.add_log_cmd("PDU1: Turn star tracker off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_2.parameter_address, objb,
PDUConfigTable.out_en_2.parameter_size, PDUConfigTable.out_en_2.parameter_address,
Channel.off, PDUConfigTable.out_en_2.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SUS_NOMINAL_ON.value: if op_code == Pdu1OpCodes.SUS_NOMINAL_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn SUS nominal on")) q.add_log_cmd("PDU1: Turn SUS nominal on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_4.parameter_address, objb,
PDUConfigTable.out_en_4.parameter_size, PDUConfigTable.out_en_4.parameter_address,
Channel.on, PDUConfigTable.out_en_4.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SUS_NOMINAL_OFF.value: if op_code == Pdu1OpCodes.SUS_NOMINAL_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn SUS nominal off")) q.add_log_cmd("PDU1: Turn SUS nominal off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_4.parameter_address, objb,
PDUConfigTable.out_en_4.parameter_size, PDUConfigTable.out_en_4.parameter_address,
Channel.off, PDUConfigTable.out_en_4.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.ACS_A_SIDE_ON.value: if op_code == Pdu1OpCodes.ACS_A_SIDE_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn ACS Side A on")) q.add_log_cmd("PDU1: Turn ACS Side A on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_7.parameter_address, objb,
PDUConfigTable.out_en_7.parameter_size, PDUConfigTable.out_en_7.parameter_address,
Channel.on, PDUConfigTable.out_en_7.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.ACS_A_SIDE_OFF.value: if op_code == Pdu1OpCodes.ACS_A_SIDE_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn ACS Side A off")) q.add_log_cmd("PDU1: Turn ACS Side A off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_7.parameter_address, objb,
PDUConfigTable.out_en_7.parameter_size, PDUConfigTable.out_en_7.parameter_address,
Channel.off, PDUConfigTable.out_en_7.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SUS_NOMINAL_OFF.value: if op_code == Pdu1OpCodes.SUS_NOMINAL_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn SUS nominal off")) q.add_log_cmd("PDU1: Turn SUS nominal off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_4.parameter_address, objb,
PDUConfigTable.out_en_4.parameter_size, PDUConfigTable.out_en_4.parameter_address,
Channel.off, PDUConfigTable.out_en_4.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SCEX_ON.value: if op_code == Pdu1OpCodes.SCEX_ON.value:
tc_queue.appendleft( q.add_log_cmd("PDU1: Turn Solar Cell Experiment on")
(QueueCommands.PRINT, "PDU1: Turn Solar Cell Experiment on") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.on,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.on,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SCEX_OFF.value: if op_code == Pdu1OpCodes.SCEX_OFF.value:
tc_queue.appendleft( q.add_log_cmd("PDU1: Turn Solar Cell Experiment off")
(QueueCommands.PRINT, "PDU1: Turn Solar Cell Experiment off") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SYRLINKS_ON.value: if op_code == Pdu1OpCodes.SYRLINKS_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn Syrlinks on")) q.add_log_cmd("PDU1: Turn Syrlinks on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_1.parameter_address, objb,
PDUConfigTable.out_en_1.parameter_size, PDUConfigTable.out_en_1.parameter_address,
Channel.on, PDUConfigTable.out_en_1.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.SYRLINKS_OFF.value: if op_code == Pdu1OpCodes.SYRLINKS_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn Syrlinks off")) q.add_log_cmd("PDU1: Turn Syrlinks off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_1.parameter_address, objb,
PDUConfigTable.out_en_1.parameter_size, PDUConfigTable.out_en_1.parameter_address,
Channel.off, PDUConfigTable.out_en_1.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.MGT_ON.value: if op_code == Pdu1OpCodes.MGT_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn MGT on")) q.add_log_cmd("PDU1: Turn MGT on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_3.parameter_address, objb,
PDUConfigTable.out_en_3.parameter_size, PDUConfigTable.out_en_3.parameter_address,
Channel.on, PDUConfigTable.out_en_3.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.MGT_OFF.value: if op_code == Pdu1OpCodes.MGT_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn MGT off")) q.add_log_cmd("PDU1: Turn MGT off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_3.parameter_address, objb,
PDUConfigTable.out_en_3.parameter_size, PDUConfigTable.out_en_3.parameter_address,
Channel.off, PDUConfigTable.out_en_3.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.PLOC_ON.value: if op_code == Pdu1OpCodes.PLOC_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn PLOC on")) q.add_log_cmd("PDU1: Turn PLOC on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_6.parameter_address, objb,
PDUConfigTable.out_en_6.parameter_size, PDUConfigTable.out_en_6.parameter_address,
Channel.on, PDUConfigTable.out_en_6.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu1OpCodes.PLOC_OFF.value: if op_code == Pdu1OpCodes.PLOC_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn PLOC off")) q.add_log_cmd("PDU1: Turn PLOC off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_6.parameter_address, objb,
PDUConfigTable.out_en_6.parameter_size, PDUConfigTable.out_en_6.parameter_address,
Channel.off, PDUConfigTable.out_en_6.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE:
tc_queue.appendleft((QueueCommands.PRINT, f"PDU1: {Info.REQUEST_CORE_HK_ONCE}")) q.add_log_cmd(f"PDU1: {Info.REQUEST_CORE_HK_ONCE}")
hk_sid = make_sid(object_id=PDU_1_HANDLER_ID, set_id=SetIds.PDU_1_CORE) hk_sid = make_sid(object_id=PDU_1_HANDLER_ID, set_id=SetIds.PDU_1_CORE)
command = generate_one_diag_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_diag_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE:
tc_queue.appendleft((QueueCommands.PRINT, f"PDU1: {Info.REQUEST_AUX_HK_ONCE}")) q.add_log_cmd(f"PDU1: {Info.REQUEST_AUX_HK_ONCE}")
hk_sid = make_sid(object_id=PDU_1_HANDLER_ID, set_id=SetIds.PDU_1_AUX) hk_sid = make_sid(object_id=PDU_1_HANDLER_ID, set_id=SetIds.PDU_1_AUX)
command = generate_one_hk_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I: if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I:
tc_queue.appendleft( q.add_log_cmd("PDU1: Print Switches, Voltages, Currents")
(QueueCommands.PRINT, "PDU1: Print Switches, Voltages, Currents") q.add_pus_tc(
generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_SWITCH_V_I
)
) )
command = generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_SWITCH_V_I
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.PRINT_LATCHUPS: if op_code in GomspaceOpCodes.PRINT_LATCHUPS:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Print Latchups")) q.add_log_cmd("PDU1: Print Latchups")
command = generate_action_command( q.add_pus_tc(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_LATCHUPS generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_LATCHUPS
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if PDU1TestProcedure.all or PDU1TestProcedure.ping: if PDU1TestProcedure.all or PDU1TestProcedure.ping:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Ping Test")) q.add_log_cmd("PDU1: Ping Test")
ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
command = pack_ping_command(object_id, ping_data) q.add_pus_tc(pack_ping_command(object_id, ping_data))
tc_queue.appendleft(command.pack_command_tuple())
if PDU1TestProcedure.all or PDU1TestProcedure.read_temperature: if PDU1TestProcedure.all or PDU1TestProcedure.read_temperature:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Testing temperature reading")) q.add_log_cmd("PDU1: Testing temperature reading")
command = pack_get_param_command( q.add_pus_tc(
objb, pack_get_param_command(
TableIds.hk, objb,
PDUHkTable.temperature.parameter_address, TableIds.hk,
PDUHkTable.temperature.parameter_size, PDUHkTable.temperature.parameter_address,
PDUHkTable.temperature.parameter_size,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_2_on: if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_2_on:
tc_queue.appendleft( q.add_log_cmd("PDU1: Turn channel 2 on (Star Tracker)")
(QueueCommands.PRINT, "PDU1: Turn channel 2 on (Star Tracker)") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.on,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.on,
)
tc_queue.appendleft(command.pack_command_tuple())
if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_2_off: if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_2_off:
tc_queue.appendleft( q.add_log_cmd("PDU1: Turn channel 2 off (Star Tracker)")
(QueueCommands.PRINT, "PDU1: Turn channel 2 off (Star Tracker)") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_3_on: if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_3_on:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn channel 3 on (MTQ)")) q.add_log_cmd("PDU1: Turn channel 3 on (MTQ)")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_3.parameter_address, objb,
PDUConfigTable.out_en_3.parameter_size, PDUConfigTable.out_en_3.parameter_address,
Channel.on, PDUConfigTable.out_en_3.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_3_off: if PDU1TestProcedure.all or PDU1TestProcedure.turn_channel_3_off:
tc_queue.appendleft((QueueCommands.PRINT, "PDU1: Turn channel 3 off (MTQ)")) q.add_log_cmd("PDU1: Turn channel 3 off (MTQ)")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_3.parameter_address, objb,
PDUConfigTable.out_en_3.parameter_size, PDUConfigTable.out_en_3.parameter_address,
Channel.off, PDUConfigTable.out_en_3.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.SET_PARAM: if op_code in GomspaceOpCodes.SET_PARAM:
tc_queue.appendleft( q.add_log_cmd(f"PDU1: {Info.SET_PARAMETER}")
(QueueCommands.PRINT, f"PDU1: {Info.SET_PARAMETER}")
)
memory_address = int(input("Specify memory address: 0x"), 16) memory_address = int(input("Specify memory address: 0x"), 16)
memory_address = struct.pack('!H', memory_address) memory_address = struct.pack("!H", memory_address)
parameter_size = int(input("Specify parameter size: ")) parameter_size = int(input("Specify parameter size: "))
parameter = int(input("Specify parameter: ")) parameter = int(input("Specify parameter: "))
command = gs.pack_set_param_command(object_id.as_bytes, memory_address, parameter_size, parameter) q.add_pus_tc(
tc_queue.appendleft(command.pack_command_tuple()) gs.pack_set_param_command(
object_id.as_bytes, memory_address, parameter_size, parameter
)
)

438
pus_tc/devs/pdu2.py
View File

@ -6,8 +6,7 @@
@author J. Meier @author J. Meier
@date 17.12.2020 @date 17.12.2020
""" """
from tmtccmd.config.definitions import QueueCommands from tmtccmd.tc import QueueHelper
from tmtccmd.tc.packer import TcQueueT
from tmtccmd.tc.pus_3_fsfw_hk import ( from tmtccmd.tc.pus_3_fsfw_hk import (
generate_one_hk_command, generate_one_hk_command,
generate_one_diag_command, generate_one_diag_command,
@ -66,288 +65,271 @@ class PDU2TestProcedure:
request_hk_table = False request_hk_table = False
def pack_pdu2_commands(object_id: ObjectId, tc_queue: TcQueueT, op_code: str): def pack_pdu2_commands(object_id: ObjectId, q: QueueHelper, op_code: str):
tc_queue.appendleft((QueueCommands.PRINT, "Testing PDU2")) q.add_log_cmd("Testing PDU2")
objb = object_id.as_bytes objb = object_id.as_bytes
if op_code == Pdu2OpCodes.ACS_SIDE_B_ON.value: if op_code == Pdu2OpCodes.ACS_SIDE_B_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn ACS Side B on")) q.add_log_cmd("PDU2: Turn ACS Side B on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_7.parameter_address, objb,
PDUConfigTable.out_en_7.parameter_size, PDUConfigTable.out_en_7.parameter_address,
Channel.on, PDUConfigTable.out_en_7.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue
if op_code == Pdu2OpCodes.ACS_SIDE_B_OFF.value: if op_code == Pdu2OpCodes.ACS_SIDE_B_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn ACS Side B off")) q.add_log_cmd("PDU2: Turn ACS Side B off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_7.parameter_address, objb,
PDUConfigTable.out_en_7.parameter_size, PDUConfigTable.out_en_7.parameter_address,
Channel.off, PDUConfigTable.out_en_7.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue
if op_code == Pdu2OpCodes.Q7S_OFF.value: if op_code == Pdu2OpCodes.Q7S_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "Turning off Q7S OBC")) q.add_log_cmd("Turning off Q7S OBC")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_0.parameter_address, objb,
PDUConfigTable.out_en_0.parameter_size, PDUConfigTable.out_en_0.parameter_address,
Channel.off, PDUConfigTable.out_en_0.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.SUS_REDUNDANT_ON.value: if op_code == Pdu2OpCodes.SUS_REDUNDANT_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn SUS redundant on")) q.add_log_cmd("PDU2: Turn SUS redundant on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_4.parameter_address, objb,
PDUConfigTable.out_en_4.parameter_size, PDUConfigTable.out_en_4.parameter_address,
Channel.on, PDUConfigTable.out_en_4.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.SUS_REDUNDANT_OFF.value: if op_code == Pdu2OpCodes.SUS_REDUNDANT_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn SUS redundant off")) q.add_log_cmd("PDU2: Turn SUS redundant off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_4.parameter_address, objb,
PDUConfigTable.out_en_4.parameter_size, PDUConfigTable.out_en_4.parameter_address,
Channel.off, PDUConfigTable.out_en_4.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.RW_ON.value: if op_code == Pdu2OpCodes.RW_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn reaction wheels on")) q.add_log_cmd("PDU2: Turn reaction wheels on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_2.parameter_address, objb,
PDUConfigTable.out_en_2.parameter_size, PDUConfigTable.out_en_2.parameter_address,
Channel.on, PDUConfigTable.out_en_2.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.RW_OFF.value: if op_code == Pdu2OpCodes.RW_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn reaction wheels off")) q.add_log_cmd("PDU2: Turn reaction wheels off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_2.parameter_address, objb,
PDUConfigTable.out_en_2.parameter_size, PDUConfigTable.out_en_2.parameter_address,
Channel.off, PDUConfigTable.out_en_2.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.PL_PCDU_VBAT_NOM_ON.value: if op_code == Pdu2OpCodes.PL_PCDU_VBAT_NOM_ON.value:
tc_queue.appendleft( q.add_log_cmd("PDU2: Turn PDU2 PL PCDU Channel 1 on")
(QueueCommands.PRINT, "PDU2: Turn PDU2 PL PCDU Channel 1 on") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_1.parameter_address,
PDUConfigTable.out_en_1.parameter_size,
Channel.on,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_1.parameter_address,
PDUConfigTable.out_en_1.parameter_size,
Channel.on,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.PL_PCDU_VBAT_NOM_OFF.value: if op_code == Pdu2OpCodes.PL_PCDU_VBAT_NOM_OFF.value:
tc_queue.appendleft( q.add_log_cmd("PDU2: Turn PDU2 PL PCDU Channel 1 off")
(QueueCommands.PRINT, "PDU2: Turn PDU2 PL PCDU Channel 1 off") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_1.parameter_address,
PDUConfigTable.out_en_1.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_1.parameter_address,
PDUConfigTable.out_en_1.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.PL_PCDU_VBAT_RED_ON.value: if op_code == Pdu2OpCodes.PL_PCDU_VBAT_RED_ON.value:
tc_queue.appendleft( q.add_log_cmd("PDU2: Turn PDU2 PL PCDU Channel 6 on")
(QueueCommands.PRINT, "PDU2: Turn PDU2 PL PCDU Channel 6 on") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_6.parameter_address,
PDUConfigTable.out_en_6.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_6.parameter_address,
PDUConfigTable.out_en_6.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.PL_PCDU_VBAT_RED_OFF.value: if op_code == Pdu2OpCodes.PL_PCDU_VBAT_RED_OFF.value:
tc_queue.appendleft( q.add_log_cmd("PDU2: Turn PDU2 PL PCDU Channel 6 off")
(QueueCommands.PRINT, "PDU2: Turn PDU2 PL PCDU Channel 6 off") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_6.parameter_address,
PDUConfigTable.out_en_6.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_6.parameter_address,
PDUConfigTable.out_en_6.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.TCS_HEATER_IN_ON.value: if op_code == Pdu2OpCodes.TCS_HEATER_IN_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn TCS Heater Input on")) q.add_log_cmd("PDU2: Turn TCS Heater Input on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_3.parameter_address, objb,
PDUConfigTable.out_en_3.parameter_size, PDUConfigTable.out_en_3.parameter_address,
Channel.on, PDUConfigTable.out_en_3.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.TCS_HEATER_IN_OFF.value: if op_code == Pdu2OpCodes.TCS_HEATER_IN_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn TCS Heater Input off")) q.add_log_cmd("PDU2: Turn TCS Heater Input off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_3.parameter_address, objb,
PDUConfigTable.out_en_3.parameter_size, PDUConfigTable.out_en_3.parameter_address,
Channel.off, PDUConfigTable.out_en_3.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.SOLAR_ARRAY_DEPL_ON.value: if op_code == Pdu2OpCodes.SOLAR_ARRAY_DEPL_ON.value:
tc_queue.appendleft( q.add_log_cmd("PDU2: Turn Solar Array Deployment On")
(QueueCommands.PRINT, "PDU2: Turn Solar Array Deployment On") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.on,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.on,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.SOLAR_ARRAY_DEPL_OFF.value: if op_code == Pdu2OpCodes.SOLAR_ARRAY_DEPL_OFF.value:
tc_queue.appendleft( q.add_log_cmd("PDU2: Turn Solar Array Deployment Off")
(QueueCommands.PRINT, "PDU2: Turn Solar Array Deployment Off") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_5.parameter_address,
PDUConfigTable.out_en_5.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.PL_CAMERA_ON.value: if op_code == Pdu2OpCodes.PL_CAMERA_ON.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn payload camera on")) q.add_log_cmd("PDU2: Turn payload camera on")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_8.parameter_address, objb,
PDUConfigTable.out_en_8.parameter_size, PDUConfigTable.out_en_8.parameter_address,
Channel.on, PDUConfigTable.out_en_8.parameter_size,
Channel.on,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code == Pdu2OpCodes.PL_CAMERA_OFF.value: if op_code == Pdu2OpCodes.PL_CAMERA_OFF.value:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Turn payload camera off")) q.add_log_cmd("PDU2: Turn payload camera off")
command = pack_set_param_command( q.add_pus_tc(
objb, pack_set_param_command(
PDUConfigTable.out_en_8.parameter_address, objb,
PDUConfigTable.out_en_8.parameter_size, PDUConfigTable.out_en_8.parameter_address,
Channel.off, PDUConfigTable.out_en_8.parameter_size,
Channel.off,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_CORE_HK_ONCE:
tc_queue.appendleft((QueueCommands.PRINT, f"PDU2: {Info.REQUEST_CORE_HK_ONCE}")) q.add_log_cmd(f"PDU2: {Info.REQUEST_CORE_HK_ONCE}")
hk_sid = make_sid(object_id=PDU_2_HANDLER_ID, set_id=SetIds.PDU_2_CORE) hk_sid = make_sid(object_id=PDU_2_HANDLER_ID, set_id=SetIds.PDU_2_CORE)
command = generate_one_diag_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_diag_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE: if op_code in GomspaceOpCodes.REQUEST_AUX_HK_ONCE:
tc_queue.appendleft((QueueCommands.PRINT, f"PDU2: {Info.REQUEST_AUX_HK_ONCE}")) q.add_log_cmd(f"PDU2: {Info.REQUEST_AUX_HK_ONCE}")
hk_sid = make_sid(object_id=PDU_2_HANDLER_ID, set_id=SetIds.PDU_2_AUX) hk_sid = make_sid(object_id=PDU_2_HANDLER_ID, set_id=SetIds.PDU_2_AUX)
command = generate_one_hk_command(sid=hk_sid, ssc=0) q.add_pus_tc(generate_one_hk_command(sid=hk_sid))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I: if op_code in GomspaceOpCodes.PRINT_SWITCH_V_I:
tc_queue.appendleft( q.add_log_cmd("PDU2: Print Switches, Currents, Voltahes")
(QueueCommands.PRINT, "PDU2: Print Switches, Currents, Voltahes") q.add_pus_tc(
generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_SWITCH_V_I
)
) )
command = generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_SWITCH_V_I
)
tc_queue.appendleft(command.pack_command_tuple())
if op_code in GomspaceOpCodes.PRINT_LATCHUPS: if op_code in GomspaceOpCodes.PRINT_LATCHUPS:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Print Latchups")) q.add_log_cmd("PDU2: Print Latchups")
command = generate_action_command( q.add_pus_tc(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_LATCHUPS generate_action_command(
object_id=objb, action_id=GomspaceDeviceActionIds.PRINT_LATCHUPS
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.reboot: if PDU2TestProcedure.all or PDU2TestProcedure.reboot:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Reboot")) q.add_log_cmd("PDU2: Reboot")
command = pack_reboot_command(object_id) q.add_pus_tc(pack_reboot_command(object_id))
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.read_gnd_wdt: if PDU2TestProcedure.all or PDU2TestProcedure.read_gnd_wdt:
tc_queue.appendleft( q.add_log_cmd("PDU2: Reading ground watchdog timer value")
(QueueCommands.PRINT, "PDU2: Reading ground watchdog timer value") q.add_pus_tc(
pack_get_param_command(
objb,
TableIds.hk,
PDUHkTable.wdt_gnd_left.parameter_address,
PDUHkTable.wdt_gnd_left.parameter_size,
)
) )
command = pack_get_param_command(
objb,
TableIds.hk,
PDUHkTable.wdt_gnd_left.parameter_address,
PDUHkTable.wdt_gnd_left.parameter_size,
)
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.gnd_wdt_reset: if PDU2TestProcedure.all or PDU2TestProcedure.gnd_wdt_reset:
tc_queue.appendleft( q.add_log_cmd("PDU2: Testing ground watchdog reset")
(QueueCommands.PRINT, "PDU2: Testing ground watchdog reset") q.add_pus_tc(pack_gnd_wdt_reset_command(object_id))
)
command = pack_gnd_wdt_reset_command(object_id)
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.ping: if PDU2TestProcedure.all or PDU2TestProcedure.ping:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Ping Test")) q.add_log_cmd("PDU2: Ping Test")
ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) ping_data = bytearray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
command = pack_ping_command(object_id, ping_data) q.add_pus_tc(pack_ping_command(object_id, ping_data))
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.channel_2_on: if PDU2TestProcedure.all or PDU2TestProcedure.channel_2_on:
tc_queue.appendleft( q.add_log_cmd("PDU2: Testing setting output channel 2 on (TCS Heater)")
( q.add_pus_tc(
QueueCommands.PRINT, pack_set_param_command(
"PDU2: Testing setting output channel 2 on (TCS Heater)", objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.on,
) )
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.on,
)
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.read_temperature: if PDU2TestProcedure.all or PDU2TestProcedure.read_temperature:
tc_queue.appendleft((QueueCommands.PRINT, "PDU2: Testing temperature reading")) q.add_log_cmd("PDU2: Testing temperature reading")
command = pack_get_param_command( q.add_pus_tc(
objb, pack_get_param_command(
TableIds.hk, objb,
PDUHkTable.temperature.parameter_address, TableIds.hk,
PDUHkTable.temperature.parameter_size, PDUHkTable.temperature.parameter_address,
) PDUHkTable.temperature.parameter_size,
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.read_channel_2_state:
tc_queue.appendleft(
(QueueCommands.PRINT, "PDU2: Reading output channel 2 state (TCS Heater)")
)
command = pack_get_param_command(
objb,
TableIds.config,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
)
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.read_cur_lu_lim_0:
tc_queue.appendleft(
(
QueueCommands.PRINT,
"PDU2: Reading current limit value of output channel 0 (OBC)",
) )
) )
command = pack_get_param_command( if PDU2TestProcedure.all or PDU2TestProcedure.read_channel_2_state:
objb, q.add_log_cmd("PDU2: Reading output channel 2 state (TCS Heater)")
TableIds.config, q.add_pus_tc(
PDUConfigTable.cur_lu_lim_0.parameter_address, pack_get_param_command(
PDUConfigTable.cur_lu_lim_0.parameter_size, objb,
TableIds.config,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
)
)
if PDU2TestProcedure.all or PDU2TestProcedure.read_cur_lu_lim_0:
q.add_log_cmd("PDU2: Reading current limit value of output channel 0 (OBC)")
q.add_pus_tc(
pack_get_param_command(
objb,
TableIds.config,
PDUConfigTable.cur_lu_lim_0.parameter_address,
PDUConfigTable.cur_lu_lim_0.parameter_size,
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.channel_2_off: if PDU2TestProcedure.all or PDU2TestProcedure.channel_2_off:
tc_queue.appendleft( q.add_log_cmd("PDU2: Testing setting output channel 2 off")
(QueueCommands.PRINT, "PDU2: Testing setting output channel 2 off") q.add_pus_tc(
pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.off,
)
) )
command = pack_set_param_command(
objb,
PDUConfigTable.out_en_2.parameter_address,
PDUConfigTable.out_en_2.parameter_size,
Channel.off,
)
tc_queue.appendleft(command.pack_command_tuple())
if PDU2TestProcedure.all or PDU2TestProcedure.request_hk_table: if PDU2TestProcedure.all or PDU2TestProcedure.request_hk_table:
tc_queue.appendleft( q.add_log_cmd("PDU2: Requesting housekeeping table")
(QueueCommands.PRINT, "PDU2: Requesting housekeeping table") q.add_pus_tc(pack_request_full_hk_table_command(object_id))
)
command = pack_request_full_hk_table_command(object_id)
tc_queue.appendleft(command.pack_command_tuple())

225
pus_tc/devs/ploc_mpsoc.py
View File

@ -13,6 +13,8 @@ from tmtccmd.config.definitions import QueueCommands
from tmtccmd.logging import get_console_logger from tmtccmd.logging import get_console_logger
from tmtccmd.tc.packer import TcQueueT from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from tmtccmd.tc import QueueHelper
from tmtccmd.utility import ObjectId
from utility.input_helper import InputHelper from utility.input_helper import InputHelper
from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes
@ -67,142 +69,119 @@ class PlocReplyIds(enum.IntEnum):
def pack_ploc_mpsoc_commands( def pack_ploc_mpsoc_commands(
object_id: bytearray, tc_queue: TcQueueT, op_code: str object_id: ObjectId, q: QueueHelper, op_code: str
) -> TcQueueT: ) -> TcQueueT:
tc_queue.appendleft( q.add_log_cmd(
( f"Generate command for PLOC MPSoC with object id: {object_id.as_hex_string}"
QueueCommands.PRINT,
"Generate command for PLOC MPSoC with object id: 0x" + object_id.hex(),
)
) )
obyt = object_id.as_bytes
if op_code == "0": if op_code == "0":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Set mode off")) q.add_log_cmd("PLOC MPSoC: Set mode off")
command = pack_mode_data(object_id, Modes.OFF, 0) command = pack_mode_data(obyt, Modes.OFF, 0)
command = PusTelecommand(service=200, subservice=1, ssc=9, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "1": if op_code == "1":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Set mode on")) q.add_log_cmd("PLOC MPSoC: Set mode on")
command = pack_mode_data(object_id, Modes.ON, 0) data = pack_mode_data(obyt, Modes.ON, 0)
command = PusTelecommand(service=200, subservice=1, ssc=10, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=data))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "2": if op_code == "2":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Mode Normal")) q.add_log_cmd("PLOC MPSoC: Mode Normal")
command = pack_mode_data(object_id, Modes.NORMAL, 0) data = pack_mode_data(object_id.as_bytes, Modes.NORMAL, 0)
command = PusTelecommand(service=200, subservice=1, ssc=11, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=data))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "3": if op_code == "3":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: TC mem write test")) q.add_log_cmd("PLOC MPSoC: TC mem write test")
memory_address = int( memory_address = int(
input("PLOC MPSoC: Tc Mem Write: Type memory address: 0x"), 16 input("PLOC MPSoC: Tc Mem Write: Type memory address: 0x"), 16
) )
memory_data = int(input("PLOC MPSoC: Tc Mem Write: Type memory data: 0x"), 16) memory_data = int(input("PLOC MPSoC: Tc Mem Write: Type memory data: 0x"), 16)
# TODO: implement variable length mem write command # TODO: implement variable length mem write command
mem_len = 1 # 1 32-bit word mem_len = 1 # 1 32-bit word
command = generate_write_mem_command( data = generate_write_mem_command(
object_id, memory_address, memory_data, mem_len object_id.as_bytes, memory_address, memory_data, mem_len
) )
command = PusTelecommand(service=8, subservice=128, ssc=20, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "4":
elif op_code == "4": q.add_log_cmd("PLOC MPSoC: TC mem read test")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: TC mem read test")) data = prepare_mem_read_command(object_id=object_id.as_bytes)
command = prepare_mem_read_command(object_id) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = PusTelecommand(service=8, subservice=128, ssc=21, app_data=command) if op_code == "5":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC MPSoC: Flash write")
elif op_code == "5": data = prepare_flash_write_cmd(object_id.as_bytes)
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Flash write")) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = prepare_flash_write_cmd(object_id) if op_code == "6":
command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command) q.add_log_cmd("PLOC MPSoC: Flash delete")
tc_queue.appendleft(command.pack_command_tuple()) data = prepare_flash_delete_cmd(object_id.as_bytes)
elif op_code == "6": q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Flash delete")) if op_code == "7":
command = prepare_flash_delete_cmd(object_id) q.add_log_cmd("PLOC MPSoC: Replay start")
command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command) data = prepare_replay_start_cmd(object_id.as_bytes)
tc_queue.appendleft(command.pack_command_tuple()) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
elif op_code == "7": if op_code == "8":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Replay start")) q.add_log_cmd("PLOC MPSoC: Replay stop")
command = prepare_replay_start_cmd(object_id) data = object_id.as_bytes + struct.pack("!I", CommandIds.TC_REPLAY_STOP)
command = PusTelecommand(service=8, subservice=128, ssc=24, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "9":
elif op_code == "8": q.add_log_cmd("PLOC MPSoC: Downlink pwr on")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Replay stop")) data = prepare_downlink_pwr_on_cmd(object_id.as_bytes)
command = object_id + struct.pack("!I", CommandIds.TC_REPLAY_STOP) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = PusTelecommand(service=8, subservice=128, ssc=25, app_data=command) if op_code == "10":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC MPSoC: Downlink pwr off")
elif op_code == "9": data = object_id.as_bytes + struct.pack("!I", CommandIds.TC_DOWNLINK_PWR_OFF)
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Downlink pwr on")) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = prepare_downlink_pwr_on_cmd(object_id) if op_code == "11":
command = PusTelecommand(service=8, subservice=128, ssc=26, app_data=command) q.add_log_cmd("PLOC MPSoC: Replay write sequence")
tc_queue.appendleft(command.pack_command_tuple()) data = prepare_replay_write_sequence_cmd(object_id.as_bytes)
elif op_code == "10": q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Downlink pwr off")) if op_code == "12":
command = object_id + struct.pack("!I", CommandIds.TC_DOWNLINK_PWR_OFF) q.add_log_cmd("PLOC MPSoC: Reset OBSW sequence count")
command = PusTelecommand(service=8, subservice=128, ssc=26, app_data=command) data = object_id.as_bytes + struct.pack("!I", CommandIds.OBSW_RESET_SEQ_COUNT)
tc_queue.appendleft(command.pack_command_tuple()) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
elif op_code == "11": if op_code == "13":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Replay write sequence"))
command = prepare_replay_write_sequence_cmd(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=27, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "12":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC MPSoC: Reset OBSW sequence count")
)
command = object_id + struct.pack("!I", CommandIds.OBSW_RESET_SEQ_COUNT)
command = PusTelecommand(service=8, subservice=128, ssc=28, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "13":
num_words = 1 num_words = 1
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Read DEADBEEF address")) q.add_log_cmd("PLOC MPSoC: Read DEADBEEF address")
command = ( data = (
object_id object_id.as_bytes
+ struct.pack("!I", CommandIds.TC_MEM_READ) + struct.pack("!I", CommandIds.TC_MEM_READ)
+ struct.pack("!I", MemAddresses.DEADBEEF) + struct.pack("!I", MemAddresses.DEADBEEF)
+ struct.pack("!H", num_words) + struct.pack("!H", num_words)
) )
command = PusTelecommand(service=8, subservice=128, ssc=29, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "14":
elif op_code == "14": q.add_log_cmd("PLOC MPSoC: Tc mode replay")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Tc mode replay")) data = object_id.as_bytes + struct.pack("!I", CommandIds.TC_MODE_REPLAY)
command = object_id + struct.pack("!I", CommandIds.TC_MODE_REPLAY) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = PusTelecommand(service=8, subservice=128, ssc=30, app_data=command) if op_code == "15":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC MPSoC: Tc mode idle")
elif op_code == "15": data = object_id.as_bytes + struct.pack("!I", CommandIds.TC_MODE_IDLE)
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Tc mode idle")) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = object_id + struct.pack("!I", CommandIds.TC_MODE_IDLE) if op_code == "16":
command = PusTelecommand(service=8, subservice=128, ssc=31, app_data=command) q.add_log_cmd("PLOC MPSoC: Tc cam command send")
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "16":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Tc cam command send"))
cam_cmd = input("Specify cam command string: ") cam_cmd = input("Specify cam command string: ")
command = ( data = (
object_id object_id.as_bytes
+ struct.pack("!I", CommandIds.TC_CAM_CMD_SEND) + struct.pack("!I", CommandIds.TC_CAM_CMD_SEND)
+ bytearray(cam_cmd, "utf-8") + bytearray(cam_cmd, "utf-8")
) )
command = PusTelecommand(service=8, subservice=128, ssc=32, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "17":
elif op_code == "17": q.add_log_cmd("PLOC MPSoC: Set UART TX tristate")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Set UART TX tristate")) data = object_id.as_bytes + struct.pack("!I", CommandIds.SET_UART_TX_TRISTATE)
command = object_id + struct.pack("!I", CommandIds.SET_UART_TX_TRISTATE) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = PusTelecommand(service=8, subservice=128, ssc=33, app_data=command) if op_code == "18":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC MPSoC: Release UART TX")
elif op_code == "18": data = object_id.as_bytes + struct.pack("!I", CommandIds.RELEASE_UART_TX)
tc_queue.appendleft((QueueCommands.PRINT, "PLOC MPSoC: Release UART TX")) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=data))
command = object_id + struct.pack("!I", CommandIds.RELEASE_UART_TX)
command = PusTelecommand(service=8, subservice=128, ssc=33, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue
def generate_write_mem_command( def generate_write_mem_command(
object_id: bytearray, memory_address: int, memory_data: int, mem_len: int object_id: bytes, memory_address: int, memory_data: int, mem_len: int
) -> bytearray: ) -> bytearray:
"""This function generates the command to write to a memory address within the PLOC """This function generates the command to write to a memory address within the PLOC.
@param object_id The object id of the PlocHandler
@param memory_address The PLOC memory address where to write to. :param object_id: The object id of the PlocHandler
@param memory_data The data to write to the memory address specified by the bytearray memory_address. :param memory_address: The PLOC memory address where to write to.
:param memory_data: The data to write to the memory address specified by the
bytearray memory_address.
:param mem_len:
""" """
command = ( command = (
object_id object_id
@ -211,10 +190,10 @@ def generate_write_mem_command(
+ struct.pack("!H", mem_len) + struct.pack("!H", mem_len)
+ struct.pack("!I", memory_data) + struct.pack("!I", memory_data)
) )
return command return bytearray(command)
def prepare_mem_read_command(object_id: bytearray) -> bytearray: def prepare_mem_read_command(object_id: bytes) -> bytearray:
memory_address = int(input("PLOC MPSoC Tc Mem Read: Type memory address: 0x"), 16) memory_address = int(input("PLOC MPSoC Tc Mem Read: Type memory address: 0x"), 16)
num_words = int(input("PLOC MPSoC specify number of words (32-bit) to read: ")) num_words = int(input("PLOC MPSoC specify number of words (32-bit) to read: "))
command = ( command = (
@ -223,10 +202,10 @@ def prepare_mem_read_command(object_id: bytearray) -> bytearray:
+ struct.pack("!I", memory_address) + struct.pack("!I", memory_address)
+ struct.pack("!H", num_words) + struct.pack("!H", num_words)
) )
return command return bytearray(command)
def prepare_flash_write_cmd(object_id: bytearray) -> bytearray: def prepare_flash_write_cmd(object_id: bytes) -> bytearray:
obcFile = get_obc_file() obcFile = get_obc_file()
mpsocFile = get_mpsoc_file() mpsocFile = get_mpsoc_file()
command = ( command = (
@ -235,30 +214,30 @@ def prepare_flash_write_cmd(object_id: bytearray) -> bytearray:
+ bytearray(obcFile, "utf-8") + bytearray(obcFile, "utf-8")
+ bytearray(mpsocFile, "utf-8") + bytearray(mpsocFile, "utf-8")
) )
return command return bytearray(command)
def prepare_flash_delete_cmd(object_id: bytearray) -> bytearray: def prepare_flash_delete_cmd(object_id: bytes) -> bytearray:
file = get_mpsoc_file() file = get_mpsoc_file()
command = ( command = (
object_id object_id
+ struct.pack("!I", CommandIds.TC_FLASH_DELETE) + struct.pack("!I", CommandIds.TC_FLASH_DELETE)
+ bytearray(file, "utf-8") + bytearray(file, "utf-8")
) )
return command return bytearray(command)
def prepare_replay_start_cmd(object_id: bytearray) -> bytearray: def prepare_replay_start_cmd(object_id: bytes) -> bytearray:
replay = int(input("Specify replay mode (0 - once, 1 - repeated): ")) replay = int(input("Specify replay mode (0 - once, 1 - repeated): "))
command = ( command = (
object_id object_id
+ struct.pack("!I", CommandIds.TC_REPLAY_START) + struct.pack("!I", CommandIds.TC_REPLAY_START)
+ struct.pack("!B", replay) + struct.pack("!B", replay)
) )
return command return bytearray(command)
def prepare_downlink_pwr_on_cmd(object_id: bytearray) -> bytearray: def prepare_downlink_pwr_on_cmd(object_id: bytes) -> bytearray:
mode = int(input("Specify JESD mode (0 - 5): ")) mode = int(input("Specify JESD mode (0 - 5): "))
lane_rate = int(input("Specify lane rate (0 - 9): ")) lane_rate = int(input("Specify lane rate (0 - 9): "))
command = ( command = (
@ -267,10 +246,10 @@ def prepare_downlink_pwr_on_cmd(object_id: bytearray) -> bytearray:
+ struct.pack("!B", mode) + struct.pack("!B", mode)
+ struct.pack("!B", lane_rate) + struct.pack("!B", lane_rate)
) )
return command return bytearray(command)
def prepare_replay_write_sequence_cmd(object_id: bytearray) -> bytearray: def prepare_replay_write_sequence_cmd(object_id: bytes) -> bytearray:
null_terminator = 0 null_terminator = 0
use_decoding = int(input("Use decoding (set to 1): ")) use_decoding = int(input("Use decoding (set to 1): "))
file = get_sequence_file() file = get_sequence_file()
@ -280,7 +259,7 @@ def prepare_replay_write_sequence_cmd(object_id: bytearray) -> bytearray:
+ struct.pack("!B", use_decoding) + struct.pack("!B", use_decoding)
+ bytearray(file, "utf-8") + bytearray(file, "utf-8")
) )
return command return bytearray(command)
def get_obc_file() -> str: def get_obc_file() -> str:

516
pus_tc/devs/ploc_supervisor.py
View File

@ -9,10 +9,10 @@
import struct import struct
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from tmtccmd.config.definitions import QueueCommands
from tmtccmd.tc.packer import TcQueueT
from tmtccmd.logging import get_console_logger from tmtccmd.logging import get_console_logger
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes
from tmtccmd.utility import ObjectId
from utility.input_helper import InputHelper from utility.input_helper import InputHelper
LOGGER = get_console_logger() LOGGER = get_console_logger()
@ -107,308 +107,235 @@ class SupvHkIds:
def pack_ploc_supv_commands( def pack_ploc_supv_commands(
object_id: bytearray, tc_queue: TcQueueT, op_code: str object_id: ObjectId, q: QueueHelper, op_code: str
) -> TcQueueT: ) -> TcQueueT:
tc_queue.appendleft( q.add_log_cmd(f"Testing PLOC Supervisor with object id: {object_id.as_hex_string}")
( obyt = object_id.as_bytes
QueueCommands.PRINT,
"Testing PLOC Supervisor with object id: 0x" + object_id.hex(),
)
)
if op_code == "0": if op_code == "0":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Set mode off")) q.add_log_cmd("PLOC Supervisor: Set mode off")
command = pack_mode_data(object_id, Modes.OFF, 0) command = pack_mode_data(object_id.as_bytes, Modes.OFF, 0)
command = PusTelecommand(service=200, subservice=1, ssc=9, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "1": if op_code == "1":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Set mode on")) q.add_log_cmd("PLOC Supervisor: Set mode on")
command = pack_mode_data(object_id, Modes.ON, 0) command = pack_mode_data(object_id.as_bytes, Modes.ON, 0)
command = PusTelecommand(service=200, subservice=1, ssc=10, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "2": if op_code == "2":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Mode Normal")) q.add_log_cmd("PLOC Supervisor: Mode Normal")
command = pack_mode_data(object_id, Modes.NORMAL, 0) command = pack_mode_data(object_id.as_bytes, Modes.NORMAL, 0)
command = PusTelecommand(service=200, subservice=1, ssc=11, app_data=command) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code == "3": if op_code == "3":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: TC Get Hk Report")) q.add_log_cmd("PLOC Supervisor: TC Get Hk Report")
command = object_id + struct.pack("!I", SupvActionIds.HK_REPORT) command = obyt + struct.pack("!I", SupvActionIds.HK_REPORT)
command = PusTelecommand(service=8, subservice=128, ssc=20, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "5": elif op_code == "5":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Start MPSoC")) q.add_log_cmd("PLOC Supervisor: Start MPSoC")
command = object_id + struct.pack("!I", SupvActionIds.START_MPSOC) command = obyt + struct.pack("!I", SupvActionIds.START_MPSOC)
command = PusTelecommand(service=8, subservice=128, ssc=22, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "6":
elif op_code == "6": q.add_log_cmd("PLOC Supervisor: Shutdown MPSoC")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Shutdown MPSoC")) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.SHUTWOWN_MPSOC)
command = object_id + struct.pack("!I", SupvActionIds.SHUTWOWN_MPSOC) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command) if op_code == "7":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Select MPSoC boot image")
elif op_code == "7":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Select MPSoC boot image")
)
mem = int(input("MEM (NVM0 - 0 or NVM1 - 1): ")) mem = int(input("MEM (NVM0 - 0 or NVM1 - 1): "))
bp0 = int(input("BP0 (0 or 1): ")) bp0 = int(input("BP0 (0 or 1): "))
bp1 = int(input("BP1 (0 or 1): ")) bp1 = int(input("BP1 (0 or 1): "))
bp2 = int(input("BP2 (0 or 1): ")) bp2 = int(input("BP2 (0 or 1): "))
command = pack_sel_boot_image_cmd(object_id, mem, bp0, bp1, bp2) command = pack_sel_boot_image_cmd(object_id.as_bytes, mem, bp0, bp1, bp2)
command = PusTelecommand(service=8, subservice=128, ssc=24, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "8":
elif op_code == "8": q.add_log_cmd("PLOC Supervisor: Set max restart tries")
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Set max restart tries")
)
restart_tries = int(input("Specify maximum restart tries: ")) restart_tries = int(input("Specify maximum restart tries: "))
command = ( command = (
object_id object_id.as_bytes
+ struct.pack("!I", SupvActionIds.SET_MAX_RESTART_TRIES) + struct.pack("!I", SupvActionIds.SET_MAX_RESTART_TRIES)
+ struct.pack("!B", restart_tries) + struct.pack("!B", restart_tries)
) )
command = PusTelecommand(service=8, subservice=128, ssc=25, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "9":
elif op_code == "9": q.add_log_cmd("PLOC Supervisor: Reset MPSoC")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Reset MPSoC")) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.RESET_MPSOC)
command = object_id + struct.pack("!I", SupvActionIds.RESET_MPSOC) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=26, app_data=command) if op_code == "10":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Set time reference")
elif op_code == "10": command = object_id.as_bytes + struct.pack("!I", SupvActionIds.SET_TIME_REF)
tc_queue.appendleft( q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
(QueueCommands.PRINT, "PLOC Supervisor: Set time reference") if op_code == "11":
) q.add_log_cmd("PLOC Supervisor: Set boot timeout")
command = object_id + struct.pack("!I", SupvActionIds.SET_TIME_REF)
command = PusTelecommand(service=8, subservice=128, ssc=27, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "11":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Set boot timeout"))
boot_timeout = int(input("Specify boot timeout [ms]: ")) boot_timeout = int(input("Specify boot timeout [ms]: "))
command = ( command = (
object_id object_id.as_bytes
+ struct.pack("!I", SupvActionIds.SET_BOOT_TIMEOUT) + struct.pack("!I", SupvActionIds.SET_BOOT_TIMEOUT)
+ struct.pack("!I", boot_timeout) + struct.pack("!I", boot_timeout)
) )
command = PusTelecommand(service=8, subservice=128, ssc=28, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "12":
elif op_code == "12": q.add_log_cmd("PLOC Supervisor: Disable HK")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Disable HK")) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.DISABLE_HK)
command = object_id + struct.pack("!I", SupvActionIds.DISABLE_HK) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=29, app_data=command) if op_code == "13":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Request boot status report")
elif op_code == "13": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft( "!I", SupvActionIds.GET_BOOT_STATUS_REPORT
(QueueCommands.PRINT, "PLOC Supervisor: Request boot status report")
) )
command = object_id + struct.pack("!I", SupvActionIds.GET_BOOT_STATUS_REPORT) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=30, app_data=command) if op_code == "17":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Enable latchup alert")
elif op_code == "17": command = pack_lachtup_alert_cmd(object_id.as_bytes, True)
tc_queue.appendleft( q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
(QueueCommands.PRINT, "PLOC Supervisor: Enable latchup alert") if op_code == "18":
q.add_log_cmd("PLOC Supervisor: Disable latchup alert")
command = pack_lachtup_alert_cmd(object_id.as_bytes, False)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "20":
q.add_log_cmd("PLOC Supervisor: Set alert limit")
command = pack_set_alert_limit_cmd(object_id.as_bytes)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "23":
q.add_log_cmd("PLOC Supervisor: Set ADC enabled channels")
command = pack_set_adc_enabled_channels_cmd(object_id.as_bytes)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "24":
q.add_log_cmd("PLOC Supervisor: Set ADC window and stride")
command = pack_set_adc_window_and_stride_cmd(object_id.as_bytes)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "25":
q.add_log_cmd("PLOC Supervisor: Set ADC threshold")
command = pack_set_adc_threshold_cmd(object_id.as_bytes)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "26":
q.add_log_cmd("PLOC Supervisor: Request latchup status report")
command = object_id.as_bytes + struct.pack(
"!I", SupvActionIds.GET_LATCHUP_STATUS_REPORT
) )
command = pack_lachtup_alert_cmd(object_id, True) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=34, app_data=command) if op_code == "27":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Copy ADC data to MRAM")
elif op_code == "18": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft( "!I", SupvActionIds.COPY_ADC_DATA_TO_MRAM
(QueueCommands.PRINT, "PLOC Supervisor: Disable latchup alert")
) )
command = pack_lachtup_alert_cmd(object_id, False) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=35, app_data=command) if op_code == "30":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Run auto EM tests")
elif op_code == "20": command = pack_auto_em_tests_cmd(object_id.as_bytes)
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Set alert limit")) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = pack_set_alert_limit_cmd(object_id) if op_code == "31":
command = PusTelecommand(service=8, subservice=128, ssc=37, app_data=command) q.add_log_cmd("PLOC Supervisor: Wipe MRAM")
tc_queue.appendleft(command.pack_command_tuple()) command = pack_mram_wipe_cmd(object_id.as_bytes)
elif op_code == "23": q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft( if op_code == "35":
(QueueCommands.PRINT, "PLOC Supervisor: Set ADC enabled channels") q.add_log_cmd("PLOC Supervisor: Set GPIO command")
command = pack_set_gpio_cmd(object_id.as_bytes)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "36":
q.add_log_cmd("PLOC Supervisor: Read GPIO command")
command = pack_read_gpio_cmd(object_id.as_bytes)
q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "37":
q.add_log_cmd("PLOC Supervisor: Restart supervisor")
command = object_id.as_bytes + struct.pack(
"!I", SupvActionIds.RESTART_SUPERVISOR
) )
command = pack_set_adc_enabled_channels_cmd(object_id) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=40, app_data=command) if op_code == "38":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Factory reset clear all")
elif op_code == "24": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft( "!I", SupvActionIds.FACTORY_RESET_CLEAR_ALL
(QueueCommands.PRINT, "PLOC Supervisor: Set ADC window and stride")
) )
command = pack_set_adc_window_and_stride_cmd(object_id) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=41, app_data=command) if op_code == "39":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Factory reset clear mirror entries")
elif op_code == "25": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Set ADC threshold"))
command = pack_set_adc_threshold_cmd(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=42, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "26":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Request latchup status report")
)
command = object_id + struct.pack("!I", SupvActionIds.GET_LATCHUP_STATUS_REPORT)
command = PusTelecommand(service=8, subservice=128, ssc=43, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "27":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Copy ADC data to MRAM")
)
command = object_id + struct.pack("!I", SupvActionIds.COPY_ADC_DATA_TO_MRAM)
command = PusTelecommand(service=8, subservice=128, ssc=44, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "30":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Run auto EM tests"))
command = pack_auto_em_tests_cmd(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=45, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "31":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Wipe MRAM"))
command = pack_mram_wipe_cmd(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=46, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "35":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Set GPIO command"))
command = pack_set_gpio_cmd(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=50, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "36":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Read GPIO command"))
command = pack_read_gpio_cmd(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=51, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "37":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Restart supervisor")
)
command = object_id + struct.pack("!I", SupvActionIds.RESTART_SUPERVISOR)
command = PusTelecommand(service=8, subservice=128, ssc=52, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "38":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Factory reset clear all")
)
command = object_id + struct.pack("!I", SupvActionIds.FACTORY_RESET_CLEAR_ALL)
command = PusTelecommand(service=8, subservice=128, ssc=53, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "39":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Factory reset clear mirror entries")
)
command = object_id + struct.pack(
"!I", SupvActionIds.FACTORY_RESET_CLEAR_MIRROR "!I", SupvActionIds.FACTORY_RESET_CLEAR_MIRROR
) )
command = PusTelecommand(service=8, subservice=128, ssc=54, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "40":
elif op_code == "40": q.add_log_cmd("PLOC Supervisor: Factory reset clear circular entries")
tc_queue.appendleft( command = object_id.as_bytes + struct.pack(
(
QueueCommands.PRINT,
"PLOC Supervisor: Factory reset clear circular entries",
)
)
command = object_id + struct.pack(
"!I", SupvActionIds.FACTORY_RESET_CLEAR_CIRCULAR "!I", SupvActionIds.FACTORY_RESET_CLEAR_CIRCULAR
) )
command = PusTelecommand(service=8, subservice=128, ssc=55, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "42":
elif op_code == "42": q.add_log_cmd("PLOC Supervisor: Perform update")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Perform update")) command = pack_update_command(object_id.as_bytes)
command = pack_update_command(object_id) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=57, app_data=command) if op_code == "43":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Terminate supervisor process")
elif op_code == "43": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft( "!I", SupvActionIds.TERMINATE_SUPV_HELPER
(QueueCommands.PRINT, "PLOC Supervisor: Terminate supervisor process")
) )
command = object_id + struct.pack("!I", SupvActionIds.TERMINATE_SUPV_HELPER) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=58, app_data=command) if op_code == "44":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Start MPSoC quiet")
elif op_code == "44": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Start MPSoC quiet")) "!I", SupvActionIds.START_MPSOC_QUIET
command = object_id + struct.pack("!I", SupvActionIds.START_MPSOC_QUIET)
command = PusTelecommand(service=8, subservice=128, ssc=59, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "45":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Set shutdown timeout")
) )
command = pack_set_shutdown_timeout_command(object_id) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=60, app_data=command) if op_code == "45":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Set shutdown timeout")
elif op_code == "46": command = pack_set_shutdown_timeout_command(object_id.as_bytes)
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Factory flash")) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = object_id + struct.pack("!I", SupvActionIds.FACTORY_FLASH) if op_code == "46":
command = PusTelecommand(service=8, subservice=128, ssc=61, app_data=command) q.add_log_cmd("PLOC Supervisor: Factory flash")
tc_queue.appendleft(command.pack_command_tuple()) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.FACTORY_FLASH)
elif op_code == "47": q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Enable auto TM")) if op_code == "47":
command = object_id + struct.pack("!I", SupvActionIds.ENABLE_AUTO_TM) q.add_log_cmd("PLOC Supervisor: Enable auto TM")
command = PusTelecommand(service=8, subservice=128, ssc=62, app_data=command) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.ENABLE_AUTO_TM)
tc_queue.appendleft(command.pack_command_tuple()) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
elif op_code == "48": if op_code == "48":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Disable auto TM")) q.add_log_cmd("PLOC Supervisor: Disable auto TM")
command = object_id + struct.pack("!I", SupvActionIds.DISABLE_AUTO_TM) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.DISABLE_AUTO_TM)
command = PusTelecommand(service=8, subservice=128, ssc=63, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "51":
elif op_code == "51": q.add_log_cmd("PLOC Supervisor: Logging request event buffers")
tc_queue.appendleft( command = pack_logging_buffer_request(object_id.as_bytes)
(QueueCommands.PRINT, "PLOC Supervisor: Logging request event buffers") q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
if op_code == "52":
q.add_log_cmd("PLOC Supervisor: Logging clear counters")
command = object_id.as_bytes + struct.pack(
"!I", SupvActionIds.LOGGING_CLEAR_COUNTERS
) )
command = pack_logging_buffer_request(object_id) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=66, app_data=command) if op_code == "53":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Logging set topic")
elif op_code == "52": command = pack_logging_set_topic(object_id.as_bytes)
tc_queue.appendleft( q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
(QueueCommands.PRINT, "PLOC Supervisor: Logging clear counters") if op_code == "54":
q.add_log_cmd("PLOC Supervisor: Logging request counters")
command = object_id.as_bytes + struct.pack(
"!I", SupvActionIds.LOGGING_REQUEST_COUNTERS
) )
command = object_id + struct.pack("!I", SupvActionIds.LOGGING_CLEAR_COUNTERS) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=67, app_data=command) if op_code == "55":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Request ADC report")
elif op_code == "53": command = object_id.as_bytes + struct.pack(
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Logging set topic")) "!I", SupvActionIds.REQUEST_ADC_REPORT
command = pack_logging_set_topic(object_id)
command = PusTelecommand(service=8, subservice=128, ssc=68, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "54":
tc_queue.appendleft(
(QueueCommands.PRINT, "PLOC Supervisor: Logging request counters")
) )
command = object_id + struct.pack("!I", SupvActionIds.LOGGING_REQUEST_COUNTERS) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=69, app_data=command) if op_code == "56":
tc_queue.appendleft(command.pack_command_tuple()) q.add_log_cmd("PLOC Supervisor: Reset PL")
elif op_code == "55": command = object_id.as_bytes + struct.pack("!I", SupvActionIds.RESET_PL)
tc_queue.appendleft( q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
(QueueCommands.PRINT, "PLOC Supervisor: Request ADC report") if op_code == "57":
) q.add_log_cmd("PLOC Supervisor: Enable NVMs")
command = object_id + struct.pack("!I", SupvActionIds.REQUEST_ADC_REPORT)
command = PusTelecommand(service=8, subservice=128, ssc=70, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "56":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Reset PL"))
command = object_id + struct.pack("!I", SupvActionIds.RESET_PL)
command = PusTelecommand(service=8, subservice=128, ssc=71, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
elif op_code == "57":
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Enable NVMs"))
nvm01 = int(input("Enable (1) or disable(0) NVM 0 and 1: ")) nvm01 = int(input("Enable (1) or disable(0) NVM 0 and 1: "))
nvm3 = int(input("Enable (1) or disable(0) NVM 3: ")) nvm3 = int(input("Enable (1) or disable(0) NVM 3: "))
command = ( command = (
object_id object_id.as_bytes
+ struct.pack("!I", SupvActionIds.ENABLE_NVMS) + struct.pack("!I", SupvActionIds.ENABLE_NVMS)
+ struct.pack("B", nvm01) + struct.pack("B", nvm01)
+ struct.pack("B", nvm3) + struct.pack("B", nvm3)
) )
command = PusTelecommand(service=8, subservice=128, ssc=72, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple()) if op_code == "58":
elif op_code == "58": q.add_log_cmd("PLOC Supervisor: Continue update")
tc_queue.appendleft((QueueCommands.PRINT, "PLOC Supervisor: Continue update")) command = object_id.as_bytes + struct.pack("!I", SupvActionIds.CONTINUE_UPDATE)
command = object_id + struct.pack("!I", SupvActionIds.CONTINUE_UPDATE) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = PusTelecommand(service=8, subservice=128, ssc=73, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue
def pack_sel_boot_image_cmd( def pack_sel_boot_image_cmd(
object_id: bytearray, mem: int, bp0: int, bp1: int, bp2: int object_id: bytes, mem: int, bp0: int, bp1: int, bp2: int
) -> bytearray: ) -> bytearray:
"""This function can be used to generate the command to select the image from which the MPSoC will boot """This function can be used to generate the command to select the image from which the MPSoC will boot
@param object_id The object id of the PLOC supervisor handler. @param object_id The object id of the PLOC supervisor handler.
@ -422,10 +349,10 @@ def pack_sel_boot_image_cmd(
command = command + struct.pack("!B", bp0) command = command + struct.pack("!B", bp0)
command = command + struct.pack("!B", bp1) command = command + struct.pack("!B", bp1)
command = command + struct.pack("!B", bp2) command = command + struct.pack("!B", bp2)
return command return bytearray(command)
def pack_update_available_cmd(object_id: bytearray) -> bytearray: def pack_update_available_cmd(object_id: bytes) -> bytearray:
""" """
@brief This function packs the udpate availabe command. @brief This function packs the udpate availabe command.
@param object_id The object id of the PLOC supervisor handler. @param object_id The object id of the PLOC supervisor handler.
@ -441,10 +368,10 @@ def pack_update_available_cmd(object_id: bytearray) -> bytearray:
command = command + struct.pack("!I", image_size) command = command + struct.pack("!I", image_size)
command = command + struct.pack("!I", image_crc) command = command + struct.pack("!I", image_crc)
command = command + struct.pack("!I", number_of_packets) command = command + struct.pack("!I", number_of_packets)
return command return bytearray(command)
def pack_watchdogs_enable_cmd(object_id: bytearray) -> bytearray: def pack_watchdogs_enable_cmd(object_id: bytes) -> bytearray:
""" """
@brief This function packs the command to enable or disable watchdogs on the PLOC. @brief This function packs the command to enable or disable watchdogs on the PLOC.
@param object_id The object id of the PLOC supervisor handler. @param object_id The object id of the PLOC supervisor handler.
@ -458,7 +385,7 @@ def pack_watchdogs_enable_cmd(object_id: bytearray) -> bytearray:
command = command + struct.pack("!B", watchdog_ps) command = command + struct.pack("!B", watchdog_ps)
command = command + struct.pack("!B", watchdog_pl) command = command + struct.pack("!B", watchdog_pl)
command = command + struct.pack("!B", watchdog_int) command = command + struct.pack("!B", watchdog_int)
return command return bytearray(command)
def pack_watchdog_config_timeout_cmd(object_id: bytearray) -> bytearray: def pack_watchdog_config_timeout_cmd(object_id: bytearray) -> bytearray:
@ -475,7 +402,7 @@ def pack_watchdog_config_timeout_cmd(object_id: bytearray) -> bytearray:
return command return command
def pack_lachtup_alert_cmd(object_id: bytearray, state: bool) -> bytearray: def pack_lachtup_alert_cmd(object_id: bytes, state: bool) -> bytearray:
""" """
@brief This function packs the command to enable or disable a certain latchup alerts. @brief This function packs the command to enable or disable a certain latchup alerts.
@param object_id The object id of the PLOC supervisor handler. @param object_id The object id of the PLOC supervisor handler.
@ -488,7 +415,7 @@ def pack_lachtup_alert_cmd(object_id: bytearray, state: bool) -> bytearray:
else: else:
command = object_id + struct.pack("!I", SupvActionIds.DISABLE_LATCHUP_ALERT) command = object_id + struct.pack("!I", SupvActionIds.DISABLE_LATCHUP_ALERT)
command = command + struct.pack("!B", latchup_id) command = command + struct.pack("!B", latchup_id)
return command return bytearray(command)
def pack_auto_calibrate_alert_cmd(object_id: bytearray) -> bytearray: def pack_auto_calibrate_alert_cmd(object_id: bytearray) -> bytearray:
@ -521,7 +448,7 @@ def get_latchup_id() -> int:
return int(input("Specify latchup ID: ")) return int(input("Specify latchup ID: "))
def pack_set_alert_limit_cmd(object_id: bytearray) -> bytearray: def pack_set_alert_limit_cmd(object_id: bytes) -> bytearray:
""" """
@brief This function packs the command to set the limit of a latchup alert. @brief This function packs the command to set the limit of a latchup alert.
@param object_id The object id of the PLOC supervisor handler. @param object_id The object id of the PLOC supervisor handler.
@ -532,10 +459,10 @@ def pack_set_alert_limit_cmd(object_id: bytearray) -> bytearray:
command = object_id + struct.pack("!I", SupvActionIds.SET_ALERT_LIMIT) command = object_id + struct.pack("!I", SupvActionIds.SET_ALERT_LIMIT)
command = command + struct.pack("!B", latchup_id) command = command + struct.pack("!B", latchup_id)
command = command + struct.pack("!I", dutycycle) command = command + struct.pack("!I", dutycycle)
return command return bytearray(command)
def pack_set_adc_enabled_channels_cmd(object_id: bytearray) -> bytearray: def pack_set_adc_enabled_channels_cmd(object_id: bytes) -> bytearray:
""" """
@brief This function packs the command to enable or disable channels of the ADC. @brief This function packs the command to enable or disable channels of the ADC.
@param object_id The object id of the PLOC supervisor handler. @param object_id The object id of the PLOC supervisor handler.
@ -543,54 +470,49 @@ def pack_set_adc_enabled_channels_cmd(object_id: bytearray) -> bytearray:
ch = int(input("Specify ch: 0x"), 16) ch = int(input("Specify ch: 0x"), 16)
cmd = object_id + struct.pack("!I", SupvActionIds.SET_ADC_ENABLED_CHANNELS) cmd = object_id + struct.pack("!I", SupvActionIds.SET_ADC_ENABLED_CHANNELS)
cmd = cmd + struct.pack("!H", ch) cmd = cmd + struct.pack("!H", ch)
return cmd return bytearray(cmd)
def pack_set_adc_window_and_stride_cmd(object_id: bytearray) -> bytearray: def pack_set_adc_window_and_stride_cmd(object_id: bytes) -> bytearray:
window_size = int(input("Specify window size: ")) window_size = int(input("Specify window size: "))
striding_step_size = int(input("Specify striding step size: ")) striding_step_size = int(input("Specify striding step size: "))
command = bytearray()
command = object_id + struct.pack("!I", SupvActionIds.SET_ADC_WINDOW_AND_STRIDE) command = object_id + struct.pack("!I", SupvActionIds.SET_ADC_WINDOW_AND_STRIDE)
command = command + struct.pack("!H", window_size) command = command + struct.pack("!H", window_size)
command = command + struct.pack("!H", striding_step_size) command = command + struct.pack("!H", striding_step_size)
return command return bytearray(command)
def pack_set_adc_threshold_cmd(object_id: bytearray) -> bytearray: def pack_set_adc_threshold_cmd(object_id: bytes) -> bytearray:
threshold = int(input("Specify threshold: ")) threshold = int(input("Specify threshold: "))
command = bytearray()
command = object_id + struct.pack("!I", SupvActionIds.SET_ADC_THRESHOLD) command = object_id + struct.pack("!I", SupvActionIds.SET_ADC_THRESHOLD)
command = command + struct.pack("!I", threshold) command = command + struct.pack("!I", threshold)
return command return bytearray(command)
def pack_select_nvm_cmd(object_id: bytearray) -> bytearray: def pack_select_nvm_cmd(object_id: bytes) -> bytearray:
mem = int(input("Specify NVM (0 - NVM0, 1 - MVM1): ")) mem = int(input("Specify NVM (0 - NVM0, 1 - MVM1): "))
command = bytearray()
command = object_id + struct.pack("!I", SupvActionIds.SELECT_NVM) command = object_id + struct.pack("!I", SupvActionIds.SELECT_NVM)
command = command + struct.pack("!B", mem) command = command + struct.pack("!B", mem)
return command return bytearray(command)
def pack_auto_em_tests_cmd(object_id: bytearray) -> bytearray: def pack_auto_em_tests_cmd(object_id: bytes) -> bytearray:
test = int(input("Specify test (1 - complete, 2 - short): ")) test = int(input("Specify test (1 - complete, 2 - short): "))
command = bytearray()
command = object_id + struct.pack("!I", SupvActionIds.RUN_AUTO_EM_TESTS) command = object_id + struct.pack("!I", SupvActionIds.RUN_AUTO_EM_TESTS)
command = command + struct.pack("!B", test) command = command + struct.pack("!B", test)
return command return bytearray(command)
def pack_mram_wipe_cmd(object_id: bytearray) -> bytearray: def pack_mram_wipe_cmd(object_id: bytes) -> bytearray:
start = int(input("Start address: 0x"), 16) start = int(input("Start address: 0x"), 16)
stop = int(input("Stop address: 0x"), 16) stop = int(input("Stop address: 0x"), 16)
command = bytearray()
command = object_id + struct.pack("!I", SupvActionIds.WIPE_MRAM) command = object_id + struct.pack("!I", SupvActionIds.WIPE_MRAM)
command = command + struct.pack("!I", start) command = command + struct.pack("!I", start)
command = command + struct.pack("!I", stop) command = command + struct.pack("!I", stop)
return command return bytearray(command)
def pack_update_command(object_id: bytearray) -> bytearray: def pack_update_command(object_id: bytes) -> bytearray:
command = bytearray() command = bytearray()
memory_id = int(input("Specify memory ID: ")) memory_id = int(input("Specify memory ID: "))
start_address = int(input("Specify start address: 0x"), 16) start_address = int(input("Specify start address: 0x"), 16)
@ -602,10 +524,10 @@ def pack_update_command(object_id: bytearray) -> bytearray:
command += struct.pack("!B", 0) command += struct.pack("!B", 0)
command += struct.pack("!B", memory_id) command += struct.pack("!B", memory_id)
command += struct.pack("!I", start_address) command += struct.pack("!I", start_address)
return command return bytearray(command)
def pack_set_shutdown_timeout_command(object_id: bytearray) -> bytearray: def pack_set_shutdown_timeout_command(object_id: bytes) -> bytearray:
command = bytearray() command = bytearray()
command += object_id command += object_id
command += struct.pack("!I", SupvActionIds.SET_SHUTDOWN_TIMEOUT) command += struct.pack("!I", SupvActionIds.SET_SHUTDOWN_TIMEOUT)
@ -614,7 +536,7 @@ def pack_set_shutdown_timeout_command(object_id: bytearray) -> bytearray:
return command return command
def pack_logging_buffer_request(object_id: bytearray) -> bytearray: def pack_logging_buffer_request(object_id: bytes) -> bytearray:
command = bytearray() command = bytearray()
command += object_id command += object_id
command += struct.pack("!I", SupvActionIds.LOGGING_REQUEST_EVENT_BUFFERS) command += struct.pack("!I", SupvActionIds.LOGGING_REQUEST_EVENT_BUFFERS)
@ -623,7 +545,7 @@ def pack_logging_buffer_request(object_id: bytearray) -> bytearray:
return command return command
def pack_set_gpio_cmd(object_id: bytearray) -> bytearray: def pack_set_gpio_cmd(object_id: bytes) -> bytearray:
port = int(input("Specify port: 0x"), 16) port = int(input("Specify port: 0x"), 16)
pin = int(input("Specify pin: 0x"), 16) pin = int(input("Specify pin: 0x"), 16)
val = int(input("Specify val: 0x"), 16) val = int(input("Specify val: 0x"), 16)
@ -631,23 +553,23 @@ def pack_set_gpio_cmd(object_id: bytearray) -> bytearray:
command = command + struct.pack("!B", port) command = command + struct.pack("!B", port)
command = command + struct.pack("!B", pin) command = command + struct.pack("!B", pin)
command = command + struct.pack("!B", val) command = command + struct.pack("!B", val)
return command return bytearray(command)
def pack_read_gpio_cmd(object_id: bytearray) -> bytearray: def pack_read_gpio_cmd(object_id: bytes) -> bytearray:
port = int(input("Specify port: 0x"), 16) port = int(input("Specify port: 0x"), 16)
pin = int(input("Specify pin: 0x"), 16) pin = int(input("Specify pin: 0x"), 16)
command = object_id + struct.pack("!I", SupvActionIds.READ_GPIO) command = object_id + struct.pack("!I", SupvActionIds.READ_GPIO)
command = command + struct.pack("!B", port) command = command + struct.pack("!B", port)
command = command + struct.pack("!B", pin) command = command + struct.pack("!B", pin)
return command return bytearray(command)
def pack_logging_set_topic(objetc_id: bytearray) -> bytearray: def pack_logging_set_topic(object_id: bytes) -> bytearray:
command = objetc_id + struct.pack("!I", SupvActionIds.LOGGING_SET_TOPIC) command = object_id + struct.pack("!I", SupvActionIds.LOGGING_SET_TOPIC)
tpc = int(input("Specify logging topic: ")) tpc = int(input("Specify logging topic: "))
command += struct.pack("!B", tpc) command += struct.pack("!B", tpc)
return command return bytearray(command)
def get_update_file() -> str: def get_update_file() -> str:

42
pus_tc/devs/rad_sensor.py
View File

@ -8,12 +8,10 @@
import struct import struct
from config.definitions import CustomServiceList from config.definitions import CustomServiceList
from tmtccmd.config import add_op_code_entry, add_service_op_code_entry
from tmtccmd.config.definitions import QueueCommands, ServiceOpCodeDictT, OpCodeDictKeys
from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from pus_tc.service_200_mode import pack_mode_data, Modes from pus_tc.service_200_mode import pack_mode_data, Modes
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_3_fsfw_hk import generate_one_hk_command, make_sid from tmtccmd.tc.pus_3_fsfw_hk import generate_one_hk_command, make_sid
from tmtccmd.utility import ObjectId from tmtccmd.utility import ObjectId
@ -70,41 +68,33 @@ def add_rad_sens_cmds(cmd_dict: ServiceOpCodeDictT):
) )
def pack_rad_sensor_test_into(object_id: ObjectId, tc_queue: TcQueueT, op_code: str): def pack_rad_sensor_test_into(object_id: ObjectId, q: QueueHelper, op_code: str):
tc_queue.appendleft( q.add_log_cmd(f"Commanding Radiation sensor handler {object_id}")
(QueueCommands.PRINT, f"Commanding Radiation sensor handler {object_id}")
)
if op_code in OpCodes.ON: if op_code in OpCodes.ON:
rad_sensor_mode_cmd(object_id, Modes.ON, Info.ON, tc_queue) rad_sensor_mode_cmd(object_id, Modes.ON, Info.ON, q)
if op_code in OpCodes.NORMAL: if op_code in OpCodes.NORMAL:
rad_sensor_mode_cmd(object_id, Modes.NORMAL, Info.NORMAL, tc_queue) rad_sensor_mode_cmd(object_id, Modes.NORMAL, Info.NORMAL, q)
if op_code in OpCodes.OFF: if op_code in OpCodes.OFF:
rad_sensor_mode_cmd(object_id, Modes.OFF, Info.OFF, tc_queue) rad_sensor_mode_cmd(object_id, Modes.OFF, Info.OFF, q)
if op_code in OpCodes.REQ_HK_ONCE: if op_code in OpCodes.REQ_HK_ONCE:
tc_queue.appendleft((QueueCommands.PRINT, f"Rad sensor: {Info.REQ_OS_HK}")) q.add_log_cmd(f"Rad sensor: {Info.REQ_OS_HK}")
cmd = generate_one_hk_command( q.add_pus_tc(
sid=make_sid(object_id.as_bytes, set_id=SetIds.HK), ssc=0 generate_one_hk_command(sid=make_sid(object_id.as_bytes, set_id=SetIds.HK))
) )
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in OpCodes.DEBUG_ON: if op_code in OpCodes.DEBUG_ON:
tc_queue.appendleft((QueueCommands.PRINT, f"Rad sensor: {Info.DEBUG_ON}")) q.add_log_cmd(f"Rad sensor: {Info.DEBUG_ON}")
command = object_id.as_bytes + struct.pack("!I", CommandIds.ENABLE_DEBUG_OUTPUT) command = object_id.as_bytes + struct.pack("!I", CommandIds.ENABLE_DEBUG_OUTPUT)
command = PusTelecommand(service=8, subservice=128, ssc=45, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodes.DEBUG_OFF: if op_code in OpCodes.DEBUG_OFF:
tc_queue.appendleft((QueueCommands.PRINT, f"Rad sensor: {Info.DEBUG_OFF}")) q.add_log_cmd(f"Rad sensor: {Info.DEBUG_OFF}")
command = object_id.as_bytes + struct.pack( command = object_id.as_bytes + struct.pack(
"!I", CommandIds.DISABLE_DEBUG_OUTPUT "!I", CommandIds.DISABLE_DEBUG_OUTPUT
) )
command = PusTelecommand(service=8, subservice=128, ssc=45, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
def rad_sensor_mode_cmd( def rad_sensor_mode_cmd(object_id: ObjectId, mode: Modes, info: str, q: QueueHelper):
object_id: ObjectId, mode: Modes, info: str, tc_queue: TcQueueT q.add_log_cmd(f"Rad sensor: {info}")
):
tc_queue.appendleft((QueueCommands.PRINT, f"Rad sensor: {info}"))
mode_data = pack_mode_data(object_id.as_bytes, mode, 0) mode_data = pack_mode_data(object_id.as_bytes, mode, 0)
command = PusTelecommand(service=200, subservice=1, ssc=41, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())

54
pus_tc/devs/reaction_wheels.py
View File

@ -5,14 +5,13 @@
@date 20.06.2021 @date 20.06.2021
""" """
import struct import struct
from tmtccmd.config.definitions import QueueCommands, ServiceOpCodeDictT
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_3_fsfw_hk import ( from tmtccmd.tc.pus_3_fsfw_hk import (
generate_one_hk_command, generate_one_hk_command,
generate_one_diag_command, generate_one_diag_command,
make_sid, make_sid,
) )
from tmtccmd.config.globals import add_op_code_entry, add_service_op_code_entry
from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes, Subservices from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes, Subservices
from config.definitions import CustomServiceList from config.definitions import CustomServiceList
@ -130,48 +129,44 @@ def add_rw_cmds(cmd_dict: ServiceOpCodeDictT):
def pack_single_rw_test_into( def pack_single_rw_test_into(
object_id: bytes, rw_idx: int, tc_queue: TcQueueT, op_code: str object_id: bytes, rw_idx: int, q: QueueHelper, op_code: str
) -> TcQueueT: ) -> TcQueueT:
if op_code in OpCodesDevs.SPEED: if op_code in OpCodesDevs.SPEED:
speed = int(input("Specify speed [0.1 RPM]: ")) speed = int(input("Specify speed [0.1 RPM]: "))
ramp_time = int(input("Specify ramp time [ms]: ")) ramp_time = int(input("Specify ramp time [ms]: "))
tc_queue.appendleft((QueueCommands.PRINT, f"RW {rw_idx}: {InfoDevs.SPEED}")) q.add_log_cmd(f"RW {rw_idx}: {InfoDevs.SPEED}")
command = pack_set_speed_command(object_id, speed, ramp_time, 40) q.add_pus_tc(pack_set_speed_command(object_id, speed, ramp_time))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodesDevs.ON: if op_code in OpCodesDevs.ON:
tc_queue.appendleft((QueueCommands.PRINT, f"RW {rw_idx}: {InfoDevs.ON}")) q.add_log_cmd(f"RW {rw_idx}: {InfoDevs.ON}")
mode_data = pack_mode_data(object_id, Modes.ON, 0) mode_data = pack_mode_data(object_id, Modes.ON, 0)
command = PusTelecommand(service=200, subservice=1, ssc=41, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodesDevs.NML: if op_code in OpCodesDevs.NML:
tc_queue.appendleft((QueueCommands.PRINT, f"RW {rw_idx}: {InfoDevs.NML}")) q.add_log_cmd(f"RW {rw_idx}: {InfoDevs.NML}")
mode_data = pack_mode_data(object_id, Modes.NORMAL, 0) mode_data = pack_mode_data(object_id, Modes.NORMAL, 0)
command = PusTelecommand(service=200, subservice=1, ssc=42, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodesDevs.OFF: if op_code in OpCodesDevs.OFF:
tc_queue.appendleft((QueueCommands.PRINT, f"RW {rw_idx}: {InfoDevs.OFF}")) q.add_log_cmd(f"RW {rw_idx}: {InfoDevs.OFF}")
mode_data = pack_mode_data(object_id, Modes.OFF, 0) mode_data = pack_mode_data(object_id, Modes.OFF, 0)
command = PusTelecommand(service=200, subservice=1, ssc=43, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodesDevs.GET_TM: if op_code in OpCodesDevs.GET_TM:
tc_queue.appendleft((QueueCommands.PRINT, f"RW {rw_idx}: {InfoDevs.GET_TM}")) q.add_log_cmd(f"RW {rw_idx}: {InfoDevs.GET_TM}")
command = generate_one_hk_command( q.add_pus_tc(
sid=make_sid(object_id=object_id, set_id=RwSetIds.TM_SET), ssc=0 generate_one_hk_command(
sid=make_sid(object_id=object_id, set_id=RwSetIds.TM_SET)
)
) )
tc_queue.appendleft(command.pack_command_tuple())
if op_code in OpCodesDevs.GET_STATUS: if op_code in OpCodesDevs.GET_STATUS:
tc_queue.appendleft( q.add_log_cmd(f"RW {rw_idx}: {InfoDevs.GET_STATUS}")
(QueueCommands.PRINT, f"RW {rw_idx}: {InfoDevs.GET_STATUS}") q.add_pus_tc(
generate_one_diag_command(
sid=make_sid(object_id=object_id, set_id=RwSetIds.STATUS_SET_ID)
)
) )
command = generate_one_diag_command( return q
sid=make_sid(object_id=object_id, set_id=RwSetIds.STATUS_SET_ID), ssc=0
)
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue
def pack_rw_ass_cmds(tc_queue: TcQueueT, object_id: bytes, op_code: str): def pack_rw_ass_cmds(tc_queue: TcQueueT, object_id: bytes, op_code: str):
@ -196,7 +191,7 @@ def pack_rw_ass_cmds(tc_queue: TcQueueT, object_id: bytes, op_code: str):
def pack_set_speed_command( def pack_set_speed_command(
object_id: bytes, speed: int, ramp_time_ms: int, ssc: int object_id: bytes, speed: int, ramp_time_ms: int
) -> PusTelecommand: ) -> PusTelecommand:
"""With this function a command is packed to set the speed of a reaction wheel """With this function a command is packed to set the speed of a reaction wheel
:param object_id: The object id of the reaction wheel handler. :param object_id: The object id of the reaction wheel handler.
@ -204,7 +199,6 @@ def pack_set_speed_command(
specified in 0.1 * RPM specified in 0.1 * RPM
:param ramp_time_ms: The time after which the reaction wheel will reach the commanded speed. :param ramp_time_ms: The time after which the reaction wheel will reach the commanded speed.
Valid times are 10 - 10000 ms Valid times are 10 - 10000 ms
:param ssc: Source sequence count
""" """
if speed > 0: if speed > 0:
if speed < 1000 or speed > 65000: if speed < 1000 or speed > 65000:
@ -231,5 +225,5 @@ def pack_set_speed_command(
command += object_id + command_id command += object_id + command_id
command = command + struct.pack("!i", speed) command = command + struct.pack("!i", speed)
command = command + ramp_time_ms.to_bytes(length=2, byteorder="big") command = command + ramp_time_ms.to_bytes(length=2, byteorder="big")
command = PusTelecommand(service=8, subservice=128, ssc=ssc, app_data=command) command = PusTelecommand(service=8, subservice=128, app_data=command)
return command return command

37
pus_tc/devs/rtd.py
View File

@ -1,13 +1,10 @@
from typing import Optional from typing import Optional
from config.definitions import CustomServiceList from config.definitions import CustomServiceList
from pus_tc.devs.pdec_handler import CommandIds
from spacepackets.ecss import PusTelecommand from spacepackets.ecss import PusTelecommand
from tmtccmd.config import (
ServiceOpCodeDictT, from tmtccmd.tc import QueueHelper
add_op_code_entry,
add_service_op_code_entry,
)
from tmtccmd.tc.definitions import TcQueueT
from tmtccmd.utility import ObjectId from tmtccmd.utility import ObjectId
from tmtccmd.tc.pus_200_fsfw_modes import Modes, pack_mode_data, Subservices from tmtccmd.tc.pus_200_fsfw_modes import Modes, pack_mode_data, Subservices
import config.object_ids as oids import config.object_ids as oids
@ -60,7 +57,7 @@ def specify_rtd_cmds(cmd_dict: ServiceOpCodeDictT):
) )
def pack_rtd_commands(op_code: str, object_id: Optional[ObjectId], tc_queue: TcQueueT): def pack_rtd_commands(op_code: str, object_id: Optional[ObjectId], q: QueueHelper):
if object_id is not None and object_id not in RTD_IDS: if object_id is not None and object_id not in RTD_IDS:
print("Specified object ID not a valid RTD ID") print("Specified object ID not a valid RTD ID")
object_id = None object_id = None
@ -72,30 +69,32 @@ def pack_rtd_commands(op_code: str, object_id: Optional[ObjectId], tc_queue: TcQ
app_data = pack_mode_data( app_data = pack_mode_data(
object_id=object_id.as_bytes, mode=Modes.ON, submode=0 object_id=object_id.as_bytes, mode=Modes.ON, submode=0
) )
cmd = PusTelecommand( q.add_pus_tc(
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=app_data PusTelecommand(
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=app_data
)
) )
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in OpCodes.NORMAL: if op_code in OpCodes.NORMAL:
app_data = pack_mode_data( app_data = pack_mode_data(
object_id=object_id.as_bytes, mode=Modes.NORMAL, submode=0 object_id=object_id.as_bytes, mode=Modes.NORMAL, submode=0
) )
cmd = PusTelecommand( q.add_pus_tc(
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=app_data PusTelecommand(
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=app_data
)
) )
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in OpCodes.OFF: if op_code in OpCodes.OFF:
app_data = pack_mode_data( app_data = pack_mode_data(
object_id=object_id.as_bytes, mode=Modes.OFF, submode=0 object_id=object_id.as_bytes, mode=Modes.OFF, submode=0
) )
cmd = PusTelecommand( q.add_pus_tc(
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=app_data PusTelecommand(
service=200, subservice=Subservices.TC_MODE_COMMAND, app_data=app_data
)
) )
tc_queue.appendleft(cmd.pack_command_tuple())
if op_code in OpCodes.CONFIG_CMD: if op_code in OpCodes.CONFIG_CMD:
command = object_id + CommandIds.PRINT_CLCW command = object_id.as_bytes + CommandIds.PRINT_CLCW
command = PusTelecommand(service=8, subservice=128, ssc=30, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
def prompt_rtd_idx(): def prompt_rtd_idx():

53
pus_tc/devs/tmp1075.py
View File

@ -5,11 +5,11 @@
@author J. Meier @author J. Meier
@date 06.01.2021 @date 06.01.2021
""" """
from tmtccmd.config.definitions import QueueCommands
from tmtccmd.tc.packer import TcQueueT
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from pus_tc.service_200_mode import pack_mode_data from pus_tc.service_200_mode import pack_mode_data
from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_200_fsfw_modes import Modes
from tmtccmd.utility import ObjectId
class Tmp1075TestProcedure: class Tmp1075TestProcedure:
@ -33,41 +33,28 @@ class Tmp1075ActionIds:
start_adc_conversion = bytearray([0x0, 0x0, 0x0, 0x02]) start_adc_conversion = bytearray([0x0, 0x0, 0x0, 0x02])
def pack_tmp1075_test_into( def pack_tmp1075_test_into(object_id: ObjectId, op_code: str, q: QueueHelper):
object_id: bytearray, op_code: str, tc_queue: TcQueueT q.add_log_cmd(
) -> TcQueueT: f"Testing Tmp1075 Temperature Sensor Handler with object id: {object_id.as_hex_string}"
tc_queue.appendleft(
(
QueueCommands.PRINT,
"Testing Tmp1075 Temperature Sensor Handler with object id: 0x"
+ object_id.hex(),
)
) )
obyt = object_id.as_bytes
if Tmp1075TestProcedure.all or Tmp1075TestProcedure.start_adc_conversion: if Tmp1075TestProcedure.all or Tmp1075TestProcedure.start_adc_conversion:
tc_queue.appendleft( q.add_log_cmd("TMP1075: Starting new temperature conversion")
(QueueCommands.PRINT, "TMP1075: Starting new temperature conversion") command = obyt + Tmp1075ActionIds.start_adc_conversion
) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
command = object_id + Tmp1075ActionIds.start_adc_conversion
command = PusTelecommand(service=8, subservice=128, ssc=23, app_data=command)
tc_queue.appendleft(command.pack_command_tuple())
if Tmp1075TestProcedure.all or Tmp1075TestProcedure.get_temp: if Tmp1075TestProcedure.all or Tmp1075TestProcedure.get_temp:
tc_queue.appendleft((QueueCommands.PRINT, "TMP1075: Read temperature")) q.add_log_cmd("TMP1075: Read temperature")
command = object_id + Tmp1075ActionIds.get_temp command = obyt + Tmp1075ActionIds.get_temp
command = PusTelecommand(service=8, subservice=128, ssc=24, app_data=command) q.add_pus_tc(PusTelecommand(service=8, subservice=128, app_data=command))
tc_queue.appendleft(command.pack_command_tuple())
if Tmp1075TestProcedure.set_mode_normal: if Tmp1075TestProcedure.set_mode_normal:
tc_queue.appendleft((QueueCommands.PRINT, "TMP1075: Set Mode Normal")) q.add_log_cmd("TMP1075: Set Mode Normal")
mode_data = pack_mode_data(object_id, 2, 0) mode_data = pack_mode_data(obyt, Modes.NORMAL, 0)
command = PusTelecommand(service=200, subservice=1, ssc=220, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
if Tmp1075TestProcedure.set_mode_on: if Tmp1075TestProcedure.set_mode_on:
tc_queue.appendleft((QueueCommands.PRINT, "TMP1075: Set Mode On")) q.add_log_cmd("TMP1075: Set Mode On")
mode_data = pack_mode_data(object_id, 1, 0) mode_data = pack_mode_data(obyt, Modes.ON, 0)
command = PusTelecommand(service=200, subservice=1, ssc=221, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue return q

121
pus_tc/tc_packer_hook.py → pus_tc/procedure_packer.py
View File

@ -7,12 +7,14 @@ from typing import Union
from pus_tc.devs.rtd import pack_rtd_commands from pus_tc.devs.rtd import pack_rtd_commands
from spacepackets.ecss import PusTelecommand from spacepackets.ecss import PusTelecommand
from tmtccmd.com_if.com_interface_base import CommunicationInterface from tmtccmd import DefaultProcedureInfo
from tmtccmd.config.definitions import CoreServiceList, QueueCommands from tmtccmd.config import CoreServiceList
from tmtccmd.logging import get_console_logger from tmtccmd.logging import get_console_logger
from tmtccmd.logging.pus import log_raw_pus_tc from tmtccmd.tc import FeedWrapper
from tmtccmd.tc.definitions import TcQueueT from tmtccmd.tc.pus_5_event import (
from tmtccmd.tc.pus_5_event import pack_generic_service5_test_into pack_generic_service5_test_into,
pack_generic_service_5_test_into,
)
from tmtccmd.pus.pus_17_test import pack_service_17_ping_command from tmtccmd.pus.pus_17_test import pack_service_17_ping_command
from tmtccmd.logging import get_current_time_string from tmtccmd.logging import get_current_time_string
@ -77,114 +79,79 @@ import config.object_ids as oids
LOGGER = get_console_logger() LOGGER = get_console_logger()
def pre_tc_send_cb( def handle_default_procedure(info: DefaultProcedureInfo, wrapper: FeedWrapper):
queue_entry: Union[bytes, QueueCommands], queue_helper = wrapper.queue_helper
com_if: CommunicationInterface, service = info.service
queue_info: Union[PusTelecommand, any], op_code = info.op_code
file_logger: logging.Logger,
):
if isinstance(queue_entry, bytes) or isinstance(queue_entry, bytearray):
log_raw_pus_tc(
packet=queue_entry,
srv_subservice=(queue_info.service, queue_info.subservice),
)
tc_info_string = f"Sent {queue_info}"
LOGGER.info(tc_info_string)
file_logger.info(f"{get_current_time_string(True)}: {tc_info_string}")
com_if.send(data=queue_entry)
elif isinstance(queue_entry, QueueCommands):
if queue_entry == QueueCommands.PRINT:
file_logger.info(queue_info)
def pack_service_queue_user(
service: Union[str, int], op_code: str, service_queue: TcQueueT
):
obj_id_man = get_object_ids() obj_id_man = get_object_ids()
if service == CoreServiceList.SERVICE_5.value: if service == CoreServiceList.SERVICE_5.value:
return pack_generic_service5_test_into(tc_queue=service_queue) return pack_generic_service_5_test_into(q=queue_helper)
if service == CoreServiceList.SERVICE_17.value: if service == CoreServiceList.SERVICE_17.value:
return service_queue.appendleft( queue_helper.add_pus_tc(pack_service_17_ping_command())
pack_service_17_ping_command(ssc=1700).pack_command_tuple()
)
if service == CoreServiceList.SERVICE_200.value: if service == CoreServiceList.SERVICE_200.value:
return pack_service200_test_into(tc_queue=service_queue) return pack_service200_test_into(q=queue_helper)
if service == CustomServiceList.P60DOCK.value: if service == CustomServiceList.P60DOCK.value:
object_id = obj_id_man.get(P60_DOCK_HANDLER) object_id = obj_id_man.get(P60_DOCK_HANDLER)
return pack_p60dock_cmds( return pack_p60dock_cmds(object_id=object_id, q=queue_helper, op_code=op_code)
object_id=object_id, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.RTD.value: if service == CustomServiceList.RTD.value:
return pack_rtd_commands( return pack_rtd_commands(object_id=None, q=queue_helper, op_code=op_code)
object_id=None, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.PDU1.value: if service == CustomServiceList.PDU1.value:
object_id = obj_id_man.get(PDU_1_HANDLER_ID) object_id = obj_id_man.get(PDU_1_HANDLER_ID)
return pack_pdu1_commands( return pack_pdu1_commands(object_id=object_id, q=queue_helper, op_code=op_code)
object_id=object_id, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.PDU2.value: if service == CustomServiceList.PDU2.value:
object_id = obj_id_man.get(PDU_2_HANDLER_ID) object_id = obj_id_man.get(PDU_2_HANDLER_ID)
return pack_pdu2_commands( return pack_pdu2_commands(object_id=object_id, q=queue_helper, op_code=op_code)
object_id=object_id, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.ACU.value: if service == CustomServiceList.ACU.value:
object_id = obj_id_man.get(ACU_HANDLER_ID) object_id = obj_id_man.get(ACU_HANDLER_ID)
return pack_acu_commands( return pack_acu_commands(object_id=object_id, q=queue_helper, op_code=op_code)
object_id=object_id, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.BPX_BATTERY.value: if service == CustomServiceList.BPX_BATTERY.value:
return pack_bpx_commands(tc_queue=service_queue, op_code=op_code) return pack_bpx_commands(q=queue_helper, op_code=op_code)
if service == CustomServiceList.TMP1075_1.value: if service == CustomServiceList.TMP1075_1.value:
object_id = TMP_1075_1_HANDLER_ID object_id = TMP_1075_1_HANDLER_ID
return pack_tmp1075_test_into( return pack_tmp1075_test_into(
object_id=object_id, tc_queue=service_queue, op_code=op_code object_id=object_id, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.TMP1075_2.value: if service == CustomServiceList.TMP1075_2.value:
object_id = TMP_1075_2_HANDLER_ID object_id = TMP_1075_2_HANDLER_ID
return pack_tmp1075_test_into( return pack_tmp1075_test_into(
object_id=object_id, tc_queue=service_queue, op_code=op_code object_id=object_id, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.HEATER.value: if service == CustomServiceList.HEATER.value:
object_id = HEATER_ID object_id = HEATER_ID
return pack_heater_cmds( return pack_heater_cmds(object_id=object_id, q=queue_helper, op_code=op_code)
object_id=object_id, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.IMTQ.value: if service == CustomServiceList.IMTQ.value:
object_id = IMTQ_HANDLER_ID object_id = IMTQ_HANDLER_ID
return pack_imtq_test_into( return pack_imtq_test_into(object_id=object_id, q=queue_helper, op_code=op_code)
object_id=object_id, tc_queue=service_queue, op_code=op_code
)
if service == CustomServiceList.PLOC_MPSOC.value: if service == CustomServiceList.PLOC_MPSOC.value:
object_id = PLOC_MPSOC_ID object_id = PLOC_MPSOC_ID
return pack_ploc_mpsoc_commands( return pack_ploc_mpsoc_commands(
object_id=object_id, tc_queue=service_queue, op_code=op_code object_id=object_id, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.REACTION_WHEEL_1.value: if service == CustomServiceList.REACTION_WHEEL_1.value:
return pack_single_rw_test_into( return pack_single_rw_test_into(
object_id=RW1_ID, rw_idx=1, tc_queue=service_queue, op_code=op_code object_id=RW1_ID, rw_idx=1, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.REACTION_WHEEL_2.value: if service == CustomServiceList.REACTION_WHEEL_2.value:
return pack_single_rw_test_into( return pack_single_rw_test_into(
object_id=RW2_ID, rw_idx=2, tc_queue=service_queue, op_code=op_code object_id=RW2_ID, rw_idx=2, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.REACTION_WHEEL_3.value: if service == CustomServiceList.REACTION_WHEEL_3.value:
return pack_single_rw_test_into( return pack_single_rw_test_into(
object_id=RW3_ID, rw_idx=3, tc_queue=service_queue, op_code=op_code object_id=RW3_ID, rw_idx=3, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.REACTION_WHEEL_4.value: if service == CustomServiceList.REACTION_WHEEL_4.value:
return pack_single_rw_test_into( return pack_single_rw_test_into(
object_id=RW4_ID, rw_idx=4, tc_queue=service_queue, op_code=op_code object_id=RW4_ID, rw_idx=4, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.RAD_SENSOR.value: if service == CustomServiceList.RAD_SENSOR.value:
object_id = obj_id_man.get(RAD_SENSOR_ID) object_id = obj_id_man.get(RAD_SENSOR_ID)
return pack_rad_sensor_test_into( return pack_rad_sensor_test_into(
object_id=object_id, tc_queue=service_queue, op_code=op_code object_id=object_id, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.PLOC_SUPV.value: if service == CustomServiceList.PLOC_SUPV.value:
object_id = PLOC_SUPV_ID object_id = PLOC_SUPV_ID
return pack_ploc_supv_commands( return pack_ploc_supv_commands(
object_id=object_id, tc_queue=service_queue, op_code=op_code object_id=object_id, q=queue_helper, op_code=op_code
) )
if service == CustomServiceList.STAR_TRACKER.value: if service == CustomServiceList.STAR_TRACKER.value:
object_id = STAR_TRACKER_ID object_id = STAR_TRACKER_ID
@ -246,6 +213,32 @@ def pack_service_queue_user(
LOGGER.warning(f"Invalid Service {service}") LOGGER.warning(f"Invalid Service {service}")
def pre_tc_send_cb(
queue_entry: Union[bytes, QueueCommands],
com_if: CommunicationInterface,
queue_info: Union[PusTelecommand, any],
file_logger: logging.Logger,
):
if isinstance(queue_entry, bytes) or isinstance(queue_entry, bytearray):
log_raw_pus_tc(
packet=queue_entry,
srv_subservice=(queue_info.service, queue_info.subservice),
)
tc_info_string = f"Sent {queue_info}"
LOGGER.info(tc_info_string)
file_logger.info(f"{get_current_time_string(True)}: {tc_info_string}")
com_if.send(data=queue_entry)
elif isinstance(queue_entry, QueueCommands):
if queue_entry == QueueCommands.PRINT:
file_logger.info(queue_info)
def pack_service_queue_user(
service: Union[str, int], op_code: str, service_queue: TcQueueT
):
pass
def create_total_tc_queue_user() -> TcQueueT: def create_total_tc_queue_user() -> TcQueueT:
if not os.path.exists("log"): if not os.path.exists("log"):
os.mkdir("log") os.mkdir("log")

28
pus_tc/service_200_mode.py
View File

@ -5,37 +5,31 @@
@author R. Mueller @author R. Mueller
@date 02.05.2020 @date 02.05.2020
""" """
from tmtccmd.config.definitions import QueueCommands
from spacepackets.ecss.tc import PusTelecommand from spacepackets.ecss.tc import PusTelecommand
from tmtccmd.tc.packer import TcQueueT from tmtccmd.tc import QueueHelper
from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes from tmtccmd.tc.pus_200_fsfw_modes import pack_mode_data, Modes
from config.object_ids import TEST_DEVICE_ID from config.object_ids import TEST_DEVICE_ID
TEST_DEVICE_OBJ_ID = TEST_DEVICE_ID TEST_DEVICE_OBJ_ID = TEST_DEVICE_ID
def pack_service200_test_into(tc_queue: TcQueueT) -> TcQueueT: def pack_service200_test_into(q: QueueHelper):
tc_queue.appendleft((QueueCommands.PRINT, "Testing Service 200")) q.add_log_cmd("Testing Service 200")
# Object ID: Dummy Device # Object ID: Dummy Device
obj_id = TEST_DEVICE_OBJ_ID obj_id = TEST_DEVICE_OBJ_ID
# Set On Mode # Set On Mode
tc_queue.appendleft((QueueCommands.PRINT, "Testing Service 200: Set Mode On")) q.add_log_cmd("Testing Service 200: Set Mode On")
mode_data = pack_mode_data(obj_id, Modes.ON, 0) mode_data = pack_mode_data(obj_id, Modes.ON, 0)
command = PusTelecommand(service=200, subservice=1, ssc=2000, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
# Set Normal mode # Set Normal mode
tc_queue.appendleft((QueueCommands.PRINT, "Testing Service 200: Set Mode Normal")) q.add_log_cmd("Testing Service 200: Set Mode Normal")
mode_data = pack_mode_data(obj_id, Modes.NORMAL, 0) mode_data = pack_mode_data(obj_id, Modes.NORMAL, 0)
command = PusTelecommand(service=200, subservice=1, ssc=2010, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
# Set Raw Mode # Set Raw Mode
tc_queue.appendleft((QueueCommands.PRINT, "Testing Service 200: Set Mode Raw")) q.add_log_cmd("Testing Service 200: Set Mode Raw")
mode_data = pack_mode_data(obj_id, Modes.RAW, 0) mode_data = pack_mode_data(obj_id, Modes.RAW, 0)
command = PusTelecommand(service=200, subservice=1, ssc=2020, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
# Set Off Mode # Set Off Mode
tc_queue.appendleft((QueueCommands.PRINT, "Testing Service 200: Set Mode Off")) q.add_log_cmd("Testing Service 200: Set Mode Off")
mode_data = pack_mode_data(obj_id, Modes.OFF, 0) mode_data = pack_mode_data(obj_id, Modes.OFF, 0)
command = PusTelecommand(service=200, subservice=1, ssc=2030, app_data=mode_data) q.add_pus_tc(PusTelecommand(service=200, subservice=1, app_data=mode_data))
tc_queue.appendleft(command.pack_command_tuple())
return tc_queue

41
pus_tc/system/proc.py
View File

@ -82,7 +82,12 @@ class KeyAndInfo:
KAI = KeyAndInfo KAI = KeyAndInfo
PROC_INFO_DICT = { PROC_INFO_DICT = {
KAI.TV_SETUP_TCS_FT_ON[0]: [OpCodes.TV_SETUP_TCS_FT_ON, KAI.TV_SETUP_TCS_FT_ON[1], 120.0, 10.0], KAI.TV_SETUP_TCS_FT_ON[0]: [
OpCodes.TV_SETUP_TCS_FT_ON,
KAI.TV_SETUP_TCS_FT_ON[1],
120.0,
10.0,
],
KAI.TV_TEARDOWN_TCS_FT_OFF[0]: [ KAI.TV_TEARDOWN_TCS_FT_OFF[0]: [
OpCodes.TV_TEARDOWN_TCS_FT_OFF, OpCodes.TV_TEARDOWN_TCS_FT_OFF,
KAI.TV_TEARDOWN_TCS_FT_OFF[1], KAI.TV_TEARDOWN_TCS_FT_OFF[1],
@ -327,13 +332,7 @@ def pack_proc_commands(tc_queue: TcQueueT, op_code: str):
(oids.GPS_CONTROLLER, GpsSetIds.HK), (oids.GPS_CONTROLLER, GpsSetIds.HK),
] ]
d_side_pairs = a_side_pairs + b_side_pairs d_side_pairs = a_side_pairs + b_side_pairs
diag_list = [ diag_list = [False, False, True, False, False]
False,
False,
True,
False,
False
]
pack_acs_command(tc_queue=tc_queue, op_code="acs-a") pack_acs_command(tc_queue=tc_queue, op_code="acs-a")
for a_side_dev in a_side_pairs: for a_side_dev in a_side_pairs:
@ -353,13 +352,7 @@ def pack_proc_commands(tc_queue: TcQueueT, op_code: str):
pack_acs_command(tc_queue=tc_queue, op_code="acs-b") pack_acs_command(tc_queue=tc_queue, op_code="acs-b")
sid_list.clear() sid_list.clear()
diag_list = [ diag_list = [False, False, True, False, False]
False,
False,
True,
False,
False
]
for b_side_dev in b_side_pairs: for b_side_dev in b_side_pairs:
oid = b_side_dev[0] oid = b_side_dev[0]
@ -419,20 +412,24 @@ def pack_proc_commands(tc_queue: TcQueueT, op_code: str):
] ]
# Command MGT to mode on # Command MGT to mode on
pack_imtq_test_into(oids.IMTQ_HANDLER_ID, tc_queue=tc_queue, op_code="1") pack_imtq_test_into(oids.IMTQ_HANDLER_ID, q=tc_queue, op_code="1")
tc_queue.appendleft((QueueCommands.WAIT, 5)) tc_queue.appendleft((QueueCommands.WAIT, 5))
# Command MGT to normal mode # Command MGT to normal mode
pack_imtq_test_into(oids.IMTQ_HANDLER_ID, tc_queue=tc_queue, op_code="2") pack_imtq_test_into(oids.IMTQ_HANDLER_ID, q=tc_queue, op_code="2")
for imtq_dev in imtq_pairs: for imtq_dev in imtq_pairs:
oid = imtq_dev[0] oid = imtq_dev[0]
set_id = imtq_dev[1] set_id = imtq_dev[1]
sid_list.append(make_sid(oid, set_id)) sid_list.append(make_sid(oid, set_id))
pack_generic_hk_listening_cmds( pack_generic_hk_listening_cmds(
tc_queue=tc_queue, proc_key=key, sid_list=sid_list, diag_list=diag_list, cfg=GenericHkListeningCfg.default() tc_queue=tc_queue,
proc_key=key,
sid_list=sid_list,
diag_list=diag_list,
cfg=GenericHkListeningCfg.default(),
) )
pack_imtq_test_into(oids.IMTQ_HANDLER_ID, tc_queue=tc_queue, op_code="0") pack_imtq_test_into(oids.IMTQ_HANDLER_ID, q=tc_queue, op_code="0")
if op_code in OpCodes.MGT_FT_DP: if op_code in OpCodes.MGT_FT_DP:
key = KAI.MGT_FT_DP[0] key = KAI.MGT_FT_DP[0]
@ -473,10 +470,10 @@ def pack_proc_commands(tc_queue: TcQueueT, op_code: str):
] ]
pack_acs_command(tc_queue=tc_queue, op_code="acs-d") pack_acs_command(tc_queue=tc_queue, op_code="acs-d")
# Command MGT to mode on # Command MGT to mode on
pack_imtq_test_into(oids.IMTQ_HANDLER_ID, tc_queue=tc_queue, op_code="1") pack_imtq_test_into(oids.IMTQ_HANDLER_ID, q=tc_queue, op_code="1")
tc_queue.appendleft((QueueCommands.WAIT, 20)) tc_queue.appendleft((QueueCommands.WAIT, 20))
# Command MGT to normal mode # Command MGT to normal mode
pack_imtq_test_into(oids.IMTQ_HANDLER_ID, tc_queue=tc_queue, op_code="2") pack_imtq_test_into(oids.IMTQ_HANDLER_ID, q=tc_queue, op_code="2")
for d_side_and_imtq_dev in d_side_and_imtq_pairs: for d_side_and_imtq_dev in d_side_and_imtq_pairs:
oid = d_side_and_imtq_dev[0] oid = d_side_and_imtq_dev[0]
@ -493,7 +490,7 @@ def pack_proc_commands(tc_queue: TcQueueT, op_code: str):
cfg=cfg, cfg=cfg,
) )
pack_imtq_test_into(oids.IMTQ_HANDLER_ID, tc_queue=tc_queue, op_code="0") pack_imtq_test_into(oids.IMTQ_HANDLER_ID, q=tc_queue, op_code="0")
pack_acs_command(tc_queue=tc_queue, op_code="acs-off") pack_acs_command(tc_queue=tc_queue, op_code="acs-off")
if op_code in OpCodes.SUS_FT: if op_code in OpCodes.SUS_FT:

10
pus_tm/action_reply_handler.py
View File

@ -132,14 +132,14 @@ def handle_acu_replies(
): ):
if action_id == GomspaceDeviceActionIds.PARAM_GET: if action_id == GomspaceDeviceActionIds.PARAM_GET:
header_list = [ header_list = [
"Gomspace action ID" "Gomspace action ID" "Table ID",
"Table ID",
"Memory Address", "Memory Address",
"Payload length" "Payload length" "Payload",
"Payload"
] ]
fmt_str = "!BBHH" fmt_str = "!BBHH"
(action, table_id, address, payload_length) = struct.unpack(fmt_str, custom_data[:6]) (action, table_id, address, payload_length) = struct.unpack(
fmt_str, custom_data[:6]
)
content_list = [ content_list = [
action, action,
table_id, table_id,

12
pus_tm/devs/mgms.py
View File

@ -10,9 +10,15 @@ import config.object_ids as obj_ids
def handle_mgm_hk_data( def handle_mgm_hk_data(
object_id: ObjectId, printer: FsfwTmTcPrinter, set_id: int, hk_data: bytes object_id: ObjectId, printer: FsfwTmTcPrinter, set_id: int, hk_data: bytes
): ):
if object_id.as_bytes in [obj_ids.MGM_0_LIS3_HANDLER_ID, obj_ids.MGM_2_LIS3_HANDLER_ID]: if object_id.as_bytes in [
obj_ids.MGM_0_LIS3_HANDLER_ID,
obj_ids.MGM_2_LIS3_HANDLER_ID,
]:
handle_mgm_lis3_hk_data(object_id, printer, set_id, hk_data) handle_mgm_lis3_hk_data(object_id, printer, set_id, hk_data)
elif object_id.as_bytes in [obj_ids.MGM_1_RM3100_HANDLER_ID, obj_ids.MGM_3_RM3100_HANDLER_ID]: elif object_id.as_bytes in [
obj_ids.MGM_1_RM3100_HANDLER_ID,
obj_ids.MGM_3_RM3100_HANDLER_ID,
]:
handle_mgm_rm3100_hk_data(object_id, printer, set_id, hk_data) handle_mgm_rm3100_hk_data(object_id, printer, set_id, hk_data)
pass pass
@ -25,7 +31,7 @@ def handle_mgm_lis3_hk_data(
fmt_str = "!ffff" fmt_str = "!ffff"
inc_len = struct.calcsize(fmt_str) inc_len = struct.calcsize(fmt_str)
(field_x, field_y, field_z, temp) = struct.unpack( (field_x, field_y, field_z, temp) = struct.unpack(
fmt_str, hk_data[0: 0 + inc_len] fmt_str, hk_data[0 : 0 + inc_len]
) )
pw.dlog(f"Received MGM LIS3 from object {object_id}") pw.dlog(f"Received MGM LIS3 from object {object_id}")
pw.dlog( pw.dlog(

6
pus_tm/devs/pcdu.py
View File

@ -180,13 +180,13 @@ def handle_pdu_data(
current_list = [] current_list = []
for idx in range(len(PDU1_CHANNELS_NAMES)): for idx in range(len(PDU1_CHANNELS_NAMES)):
current_list.append( current_list.append(
struct.unpack("!h", hk_data[current_idx: current_idx + 2])[0] struct.unpack("!h", hk_data[current_idx : current_idx + 2])[0]
) )
current_idx += 2 current_idx += 2
voltage_list = [] voltage_list = []
for idx in range(len(PDU1_CHANNELS_NAMES)): for idx in range(len(PDU1_CHANNELS_NAMES)):
voltage_list.append( voltage_list.append(
struct.unpack("!H", hk_data[current_idx: current_idx + 2])[0] struct.unpack("!H", hk_data[current_idx : current_idx + 2])[0]
) )
current_idx += 2 current_idx += 2
output_enb_list = [] output_enb_list = []
@ -205,7 +205,7 @@ def handle_pdu_data(
fmt_str = "!IBf" fmt_str = "!IBf"
inc_len = struct.calcsize(fmt_str) inc_len = struct.calcsize(fmt_str)
(boot_count, batt_mode, temperature) = struct.unpack( (boot_count, batt_mode, temperature) = struct.unpack(
fmt_str, hk_data[current_idx: current_idx + inc_len] fmt_str, hk_data[current_idx : current_idx + inc_len]
) )
info = ( info = (
f"Boot Count {boot_count} | Battery Mode {batt_mode} | " f"Boot Count {boot_count} | Battery Mode {batt_mode} | "

4
pus_tm/event_handler.py
View File

@ -40,8 +40,8 @@ def handle_event_packet(
obj_ids = get_object_ids() obj_ids = get_object_ids()
obj_id_obj = obj_ids.get(tm.reporter_id.as_bytes) obj_id_obj = obj_ids.get(tm.reporter_id.as_bytes)
if obj_id_obj is None: if obj_id_obj is None:
LOGGER.warning(f"Object ID 0x{tm.reporter_id.as_string} has no name") LOGGER.warning(f"Object ID 0x{tm.reporter_id.as_hex_string} has no name")
obj_name = tm.reporter_id.as_string obj_name = tm.reporter_id.as_hex_string
else: else:
obj_name = obj_id_obj.name obj_name = obj_id_obj.name
generic_event_string = ( generic_event_string = (

115
pus_tm/factory_hook.py
View File

@ -1,21 +1,14 @@
"""Core EIVE TM handler module """Core EIVE TM handler module
""" """
from spacepackets.ecss.tm import PusTelemetry
from tmtccmd.logging import get_console_logger
from tmtccmd.logging.pus import (
log_raw_pus_tm,
log_raw_unknown_packet,
PacketTypes,
create_tmtc_logger,
)
from tmtccmd.tm.pus_17_test import Service17TMExtended
from tmtccmd.tm.pus_20_fsfw_parameters import Service20FsfwTm
from tmtccmd.tm.pus_200_fsfw_modes import Service200FsfwTm
from tmtccmd.utility.tmtc_printer import PrintFormats, FsfwTmTcPrinter
from config.definitions import PUS_APID
from config.object_ids import get_object_ids from config.object_ids import get_object_ids
from spacepackets.ecss import PusTelemetry
from spacepackets.util import PrintFormats
from tmtccmd import get_console_logger
from tmtccmd.logging.pus import RawTmtcTimedLogWrapper
from tmtccmd.pus import VerificationWrapper
from tmtccmd.tm import Service20FsfwTm, Service200FsfwTm
from tmtccmd.tm.pus_17_test import Service17TmExtended
from tmtccmd.utility.tmtc_printer import FsfwTmTcPrinter
from .event_handler import handle_event_packet from .event_handler import handle_event_packet
from .verification_handler import handle_service_1_packet from .verification_handler import handle_service_1_packet
@ -25,60 +18,46 @@ from .action_reply_handler import handle_action_reply
LOGGER = get_console_logger() LOGGER = get_console_logger()
FSFW_PRINTER = FsfwTmTcPrinter(file_logger=create_tmtc_logger()) def pus_factory_hook(
packet: bytes,
verif_wrapper: VerificationWrapper,
def ccsds_tm_handler(apid: int, raw_tm_packet: bytes, _user_args: any) -> None: printer: FsfwTmTcPrinter,
if apid == PUS_APID: raw_logger: RawTmtcTimedLogWrapper,
pus_factory_hook(raw_tm_packet=raw_tm_packet) ):
if len(packet) < 8:
def pus_factory_hook(raw_tm_packet: bytes):
if len(raw_tm_packet) < 8:
LOGGER.warning("Detected packet shorter than 8 bytes!") LOGGER.warning("Detected packet shorter than 8 bytes!")
return return
service_type = raw_tm_packet[7] try:
subservice_type = raw_tm_packet[8] tm_packet = PusTelemetry.unpack(packet)
file_logger = FSFW_PRINTER.file_logger except ValueError:
LOGGER.warning("Could not generate PUS TM object from raw data")
LOGGER.warning(f"Raw Packet: [{packet.hex(sep=',')}], REPR: {packet!r}")
return
service = tm_packet.service
file_logger = printer.file_logger
obj_id_dict = get_object_ids() obj_id_dict = get_object_ids()
dedicated_handler = True dedicated_handler = True
try: if service == 1:
tm_packet = None handle_service_1_packet(wrapper=verif_wrapper, raw_tm=packet)
if service_type == 1: elif service == 3:
handle_service_1_packet(printer=FSFW_PRINTER, raw_tm=raw_tm_packet) handle_hk_packet(printer=printer, raw_tm=packet, obj_id_dict=obj_id_dict)
elif service_type == 3: elif service == 5:
handle_hk_packet( handle_event_packet(raw_tm=packet, printer=printer, file_logger=file_logger)
printer=FSFW_PRINTER, raw_tm=raw_tm_packet, obj_id_dict=obj_id_dict elif service == 8:
) handle_action_reply(raw_tm=packet, printer=printer, obj_id_dict=obj_id_dict)
elif service_type == 5: elif service == 17:
handle_event_packet( tm_packet = Service17TmExtended.unpack(raw_telemetry=packet)
raw_tm=raw_tm_packet, printer=FSFW_PRINTER, file_logger=file_logger dedicated_handler = False
) elif service == 20:
elif service_type == 8: tm_packet = Service20FsfwTm.unpack(raw_telemetry=packet)
handle_action_reply( dedicated_handler = False
raw_tm=raw_tm_packet, printer=FSFW_PRINTER, obj_id_dict=obj_id_dict elif service == 200:
) tm_packet = Service200FsfwTm.unpack(raw_telemetry=packet)
elif service_type == 17: dedicated_handler = False
tm_packet = Service17TMExtended.unpack(raw_telemetry=raw_tm_packet) else:
dedicated_handler = False LOGGER.info(f"The service {service} is not implemented in Telemetry Factory")
elif service_type == 20: tm_packet.print_source_data(PrintFormats.HEX)
tm_packet = Service20FsfwTm.unpack(raw_telemetry=raw_tm_packet) dedicated_handler = True
dedicated_handler = False if not dedicated_handler and tm_packet is not None:
elif service_type == 200: printer.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet)
tm_packet = Service200FsfwTm.unpack(raw_telemetry=raw_tm_packet) raw_logger.log_tm(tm_packet)
dedicated_handler = False
else:
LOGGER.info(
f"The service {service_type} is not implemented in Telemetry Factory"
)
tm_packet = PusTelemetry.unpack(raw_telemetry=raw_tm_packet)
tm_packet.print_source_data(PrintFormats.HEX)
dedicated_handler = True
if not dedicated_handler and tm_packet is not None:
FSFW_PRINTER.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet)
log_raw_pus_tm(
packet=raw_tm_packet, srv_subservice=(service_type, subservice_type)
)
except ValueError:
LOGGER.warning("Invalid packet format detected")
log_raw_unknown_packet(packet=raw_tm_packet, packet_type=PacketTypes.TM)

39
pus_tm/system/tcs.py
View File

@ -21,17 +21,32 @@ def handle_thermal_controller_hk_data(
pw.dlog("Received sensor temperature data") pw.dlog("Received sensor temperature data")
# get all the floats # get all the floats
tm_data = struct.unpack("!ffffffffffffffffff", hk_data[:18 * 4]) tm_data = struct.unpack("!ffffffffffffffffff", hk_data[: 18 * 4])
parsed_data = {"SENSOR_PLOC_HEATSPREADER": tm_data[0], "SENSOR_PLOC_MISSIONBOARD": tm_data[1], parsed_data = {
"SENSOR_4K_CAMERA": tm_data[2], "SENSOR_DAC_HEATSPREADER": tm_data[3], "SENSOR_PLOC_HEATSPREADER": tm_data[0],
"SENSOR_STARTRACKER": tm_data[4], "SENSOR_RW1": tm_data[5], "SENSOR_DRO": tm_data[6], "SENSOR_PLOC_MISSIONBOARD": tm_data[1],
"SENSOR_SCEX": tm_data[7], "SENSOR_X8": tm_data[8], "SENSOR_HPA": tm_data[9], "SENSOR_4K_CAMERA": tm_data[2],
"SENSOR_TX_MODUL": tm_data[10], "SENSOR_MPA": tm_data[11], "SENSOR_ACU": tm_data[12], "SENSOR_DAC_HEATSPREADER": tm_data[3],
"SENSOR_PLPCDU_HEATSPREADER": tm_data[13], "SENSOR_TCS_BOARD": tm_data[14], "SENSOR_STARTRACKER": tm_data[4],
"SENSOR_MAGNETTORQUER": tm_data[15], "TMP1075 1": tm_data[16], "TMP1075 2": tm_data[17]} "SENSOR_RW1": tm_data[5],
"SENSOR_DRO": tm_data[6],
"SENSOR_SCEX": tm_data[7],
"SENSOR_X8": tm_data[8],
"SENSOR_HPA": tm_data[9],
"SENSOR_TX_MODUL": tm_data[10],
"SENSOR_MPA": tm_data[11],
"SENSOR_ACU": tm_data[12],
"SENSOR_PLPCDU_HEATSPREADER": tm_data[13],
"SENSOR_TCS_BOARD": tm_data[14],
"SENSOR_MAGNETTORQUER": tm_data[15],
"TMP1075 1": tm_data[16],
"TMP1075 2": tm_data[17],
}
# print(parsed_data) # print(parsed_data)
tcp_server_sensor_temperatures.report_parsed_hk_data(object_id, set_id, parsed_data) tcp_server_sensor_temperatures.report_parsed_hk_data(
object_id, set_id, parsed_data
)
elif set_id == SetIds.DEVICE_TEMPERATURE_SET: elif set_id == SetIds.DEVICE_TEMPERATURE_SET:
pw = PrintWrapper(printer) pw = PrintWrapper(printer)
pw.dlog("Received device temperature data") pw.dlog("Received device temperature data")
@ -67,7 +82,9 @@ def handle_thermal_controller_hk_data(
"ADC_PL_PCDU_TEMPERATURE": tm_data[26], "ADC_PL_PCDU_TEMPERATURE": tm_data[26],
} }
# print(parsed_data) # print(parsed_data)
tcp_server_device_temperatures.report_parsed_hk_data(object_id, set_id, parsed_data) tcp_server_device_temperatures.report_parsed_hk_data(
object_id, set_id, parsed_data
)
elif set_id == SetIds.SUS_TEMPERATURE_SET: elif set_id == SetIds.SUS_TEMPERATURE_SET:
pass pass
# pw = PrintWrapper(printer) # pw = PrintWrapper(printer)
@ -90,5 +107,3 @@ def handle_thermal_controller_hk_data(
# } # }
# print(parsed_data) # print(parsed_data)
# TODO: Forward data to space simulator # TODO: Forward data to space simulator

5
pus_tm/tm_tcp_server.py
View File

@ -11,7 +11,6 @@ LOGGER = get_console_logger()
class TmTcpServer: class TmTcpServer:
def __init__(self, ip_address: str, port: int): def __init__(self, ip_address: str, port: int):
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@ -70,7 +69,7 @@ class TmTcpServer:
data_dict = { data_dict = {
"type": "TM", "type": "TM",
"tmType": "Raw HK", "tmType": "Raw HK",
"objectId": object_id.as_string, "objectId": object_id.as_hex_string,
"setId": set_id, "setId": set_id,
"rawData": base64.b64encode(hk_data).decode(), "rawData": base64.b64encode(hk_data).decode(),
} }
@ -81,7 +80,7 @@ class TmTcpServer:
data_dict = { data_dict = {
"type": "TM", "type": "TM",
"tmType": "Parsed HK", "tmType": "Parsed HK",
"objectId": object_id.as_string, "objectId": object_id.as_hex_string,
"setId": set_id, "setId": set_id,
"content": data_dictionary, "content": data_dictionary,
} }

39
pus_tm/verification_handler.py
View File

@ -1,28 +1,39 @@
from typing import cast from spacepackets.ecss.pus_1_verification import UnpackParams
from tmtccmd.tm.pus_1_verification import Service1TMExtended
from tmtccmd.logging import get_console_logger from tmtccmd.logging import get_console_logger
from tmtccmd.utility.tmtc_printer import FsfwTmTcPrinter from tmtccmd.pus import VerificationWrapper
from tmtccmd.tm.pus_1_verification import Service1TmExtended
from config.retvals import get_retval_dict from config.retvals import get_retval_dict
LOGGER = get_console_logger() LOGGER = get_console_logger()
def handle_service_1_packet(printer: FsfwTmTcPrinter, raw_tm: bytes): def handle_service_1_packet(wrapper: VerificationWrapper, raw_tm: bytes):
tm_packet = Service1TMExtended.unpack(raw_telemetry=raw_tm) if wrapper.console_logger is None or wrapper.file_logger is None:
printer.handle_long_tm_print(packet_if=tm_packet, info_if=tm_packet) raise ValueError(
srv1_packet = cast(Service1TMExtended, tm_packet) "Console logger or file logger not valid. Please set a valid one"
)
tm_packet = Service1TmExtended.unpack(data=raw_tm, params=UnpackParams(1, 1))
res = wrapper.verificator.add_tm(tm_packet)
if res is None:
LOGGER.info(
f"Received Verification TM[{tm_packet.service}, {tm_packet.subservice}] "
f"with Request ID {tm_packet.tc_req_id.as_u32():#08x}"
)
LOGGER.warning(f"No matching telecommand found for {tm_packet.tc_req_id}")
else:
wrapper.log_to_console(tm_packet, res)
wrapper.log_to_file(tm_packet, res)
retval_dict = get_retval_dict() retval_dict = get_retval_dict()
if srv1_packet.has_tc_error_code: if tm_packet.has_failure_notice:
retval_info = retval_dict.get(srv1_packet.error_code) retval_info = retval_dict.get(tm_packet.error_code.val)
if retval_info is None: if retval_info is None:
LOGGER.info( LOGGER.info(
f"No returnvalue information found for error code {srv1_packet.error_code}" f"No returnvalue information found for error code {tm_packet.error_code}"
) )
else: else:
retval_string = ( retval_string = (
f"Error Code information for code {srv1_packet.error_code} | " f"Error Code information for code {tm_packet.error_code} | "
f"Name: {retval_info.name} | Info: {retval_info.info}" f"Name: {retval_info.name} | Info: {retval_info.info}"
) )
LOGGER.info(retval_string) wrapper.console_logger.info(retval_string)
printer.file_logger.info(retval_string) wrapper.file_logger.info(retval_string)

58
tmtcc.py
View File

@ -1,10 +1,21 @@
import argparse import argparse
import logging
import sys import sys
import traceback import traceback
from typing import Optional from typing import Optional
from tmtccmd.config.definitions import CoreModeList from tmtccmd.config.definitions import CoreModeList
from spacepackets.ecss import PusVerificator
from tmtccmd import get_console_logger, TcHandlerBase
from tmtccmd.config.globals import update_global, CoreGlobalIds from tmtccmd.config.globals import update_global, CoreGlobalIds
from deps.tmtccmd.tmtccmd.logging.pus import RawTmtcTimedLogWrapper
from deps.tmtccmd.tmtccmd.pus import VerificationWrapper
from deps.tmtccmd.tmtccmd.tm import SpecificApidHandlerBase, GenericApidHandlerBase
from deps.tmtccmd.tmtccmd.utility.tmtc_printer import FsfwTmTcPrinter
from tmtccmd.pus import FileSeqCountProvider
from tmtccmd.tc import ProcedureHelper, FeedWrapper, TcProcedureType
try: try:
import spacepackets import spacepackets
except ImportError as error: except ImportError as error:
@ -36,8 +47,51 @@ except ImportError as error:
from config import __version__ from config import __version__
from config.definitions import PUS_APID from config.definitions import PUS_APID
from config.hook_implementations import EiveHookObject from config.hook_implementations import EiveHookObject
from pus_tm.factory_hook import ccsds_tm_handler from pus_tm.factory_hook import pus_factory_hook
from pus_tc.tc_packer_hook import pre_tc_send_cb from pus_tc.procedure_packer import pre_tc_send_cb
LOGGER = get_console_logger()
class PusHandler(SpecificApidHandlerBase):
def __init__(
self,
wrapper: VerificationWrapper,
printer: FsfwTmTcPrinter,
raw_logger: RawTmtcTimedLogWrapper,
):
super().__init__(PUS_APID, None)
self.printer = printer
self.verif_wrapper = wrapper
self.raw_logger = raw_logger
def handle_tm(self, packet: bytes, _user_args: any):
pus_factory_hook(packet, self.verif_wrapper, self.printer, self.raw_logger)
class UnknownApidHandler(GenericApidHandlerBase):
def handle_tm(self, apid: int, _packet: bytes, _user_args: any):
LOGGER.warning(f"Packet with unknwon APID {apid} detected")
class TcHandler(TcHandlerBase):
def __init__(
self,
seq_count_provider: FileSeqCountProvider,
pus_verificator: PusVerificator,
file_logger: logging.Logger,
raw_logger: RawTmtcTimedLogWrapper,
):
super().__init__()
self.seq_count_provider = seq_count_provider
self.pus_verificator = pus_verificator
self.file_logger = file_logger
self.raw_logger = raw_logger
def feed_cb(self, info: ProcedureHelper, wrapper: FeedWrapper):
if info.proc_type == TcProcedureType.DEFAULT:
handle_default_procedure(info.to_def_procedure(), wrapper)
def tmtcc_pre_args() -> EiveHookObject: def tmtcc_pre_args() -> EiveHookObject:

1
tmtccli.py
View File

@ -5,7 +5,6 @@ from tmtcc import (
tmtcc_pre_args, tmtcc_pre_args,
create_default_args_parser, create_default_args_parser,
add_default_tmtccmd_args, add_default_tmtccmd_args,
parse_default_input_arguments,
) )

5
tmtcgui.py
View File

@ -1,9 +1,6 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""TMTC commander for EIVE""" """TMTC commander for EIVE"""
from tmtcc import ( from tmtcc import tmtcc_post_args, tmtcc_pre_args
tmtcc_post_args,
tmtcc_pre_args
)
def main(): def main():

2
tmtcloop.py
View File

@ -35,7 +35,7 @@ except ImportError as error:
sys.exit(1) sys.exit(1)
from config.definitions import PUS_APID from config.definitions import PUS_APID
from pus_tc.tc_packer_hook import pre_tc_send_cb from pus_tc.procedure_packer import pre_tc_send_cb
from pus_tm.factory_hook import ccsds_tm_handler from pus_tm.factory_hook import ccsds_tm_handler
from tmtcc import tmtcc_pre_args from tmtcc import tmtcc_pre_args