221 lines
7.2 KiB
Python
221 lines
7.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""
|
|
@file gomspace_common.py
|
|
@brief PDU2 tests
|
|
@details All functions and classes common for all gomspace devices are defined in this file.
|
|
@author J. Meier
|
|
@date 17.12.2020
|
|
"""
|
|
import enum
|
|
import struct
|
|
from typing import Union
|
|
|
|
from spacepackets.ecss import PusTelecommand
|
|
from tmtccmd.tc import DefaultPusQueueHelper
|
|
from tmtccmd.tc.pus_8_funccmd import make_fsfw_action_cmd
|
|
from tmtccmd.util import ObjectIdU32, ObjectIdBase
|
|
|
|
|
|
class GomspaceDeviceActionIds(enum.IntEnum):
|
|
PING = 1
|
|
REBOOT = 4
|
|
PARAM_GET = 0
|
|
PARAM_SET = 255
|
|
WDT_RESET = 9
|
|
REQUEST_HK_TABLE = 16
|
|
REQUEST_CONFIG_TABLE = 17
|
|
SAVE_TABLE = 18
|
|
SAVE_TABLE_DEFAULT = 19
|
|
PRINT_SWITCH_V_I = 32
|
|
PRINT_LATCHUPS = 33
|
|
|
|
|
|
class GomspaceOpCodes:
|
|
# Request HK
|
|
REQUEST_CORE_HK_ONCE = ["hk_core"]
|
|
REQUEST_AUX_HK_ONCE = ["hk_aux"]
|
|
PRINT_SWITCH_V_I = ["print_switch_vi"]
|
|
PRINT_LATCHUPS = ["print_latchups"]
|
|
GET_PARAM = ["get_param"]
|
|
SET_PARAM = ["set_param"]
|
|
SAVE_TABLE = ["save_table"]
|
|
RESET_GND_WATCHDOG = ["reset_gnd_wdt"]
|
|
SAVE_TABLE_DEFAULT = ["save_table_default"]
|
|
REQUEST_CONFIG_TABLE = ["cfg_table"]
|
|
|
|
|
|
class GsInfo:
|
|
REQUEST_CORE_HK_ONCE = "Requesting Core HK once"
|
|
REQUEST_AUX_HK_ONCE = "Requesting Aux HK once"
|
|
PRINT_SWITCH_V_I = "Print Switch V I Info"
|
|
PRINT_LATCHUPS = "Print latchups"
|
|
GET_PARAMETER = "Get parameter"
|
|
SET_PARAMETER = "Set parameter"
|
|
REQUEST_CONFIG_TABLE = "Request Config Table"
|
|
RESET_GND_WATCHDOG = "Reset GND watchdog"
|
|
SAVE_TABLE = "Save table non-volatile (file)"
|
|
SAVE_TABLE_DEFAULT = "Save table non-volatile (default)"
|
|
|
|
|
|
class SetIds:
|
|
PDU_1_CORE = 1
|
|
PDU_1_AUX = 2
|
|
PDU_2_CORE = 3
|
|
PDU_2_AUX = 4
|
|
P60_CORE = 5
|
|
P60_AUX = 6
|
|
ACU_CORE = 7
|
|
ACU_AUX = 8
|
|
|
|
|
|
class TableIds:
|
|
config = 1
|
|
hk = 4
|
|
|
|
|
|
class TableEntry:
|
|
uint8_size = 1
|
|
uint16_size = 2
|
|
uint32_size = 4
|
|
|
|
def __init__(self, parameter_address: bytearray, parameter_size):
|
|
self.parameter_address = parameter_address
|
|
self.parameter_size = parameter_size
|
|
|
|
|
|
class Channel:
|
|
on = 1
|
|
off = 0
|
|
|
|
|
|
def pack_request_config_command(object_id: bytes) -> PusTelecommand:
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id, action_id=GomspaceDeviceActionIds.REQUEST_CONFIG_TABLE
|
|
)
|
|
|
|
|
|
def pack_get_param_command(
|
|
object_id: bytes,
|
|
table_id: int,
|
|
memory_address: Union[int, bytes],
|
|
parameter_size: int,
|
|
) -> PusTelecommand:
|
|
"""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 table_id: The table id of the gomspace device
|
|
@param memory_address: Address offset within table of the value to read.
|
|
@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.
|
|
"""
|
|
app_data = struct.pack("!B", table_id)
|
|
if isinstance(memory_address, int):
|
|
app_data += struct.pack("!H", memory_address)
|
|
else:
|
|
app_data += memory_address
|
|
app_data += struct.pack("!B", parameter_size)
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id,
|
|
action_id=GomspaceDeviceActionIds.PARAM_GET,
|
|
user_data=app_data,
|
|
)
|
|
|
|
|
|
def pack_set_param_command(
|
|
object_id: bytes, memory_address: bytes, parameter_size: int, parameter: int
|
|
) -> PusTelecommand:
|
|
"""Function to generate a command to set a parameter
|
|
:param object_id: The object id of the gomspace device handler.
|
|
:param memory_address: Address offset within table of the value to set.
|
|
:param parameter: The parameter value to set.
|
|
:param parameter_size: Size of the value to set. There are uint8_t, uint16_t and uint32_t
|
|
in the device tables.
|
|
:return: The command as bytearray.
|
|
"""
|
|
action_id = GomspaceDeviceActionIds.PARAM_SET
|
|
app_data = bytearray()
|
|
app_data += memory_address
|
|
app_data.append(parameter_size)
|
|
if parameter_size == 1:
|
|
app_data.append(parameter)
|
|
elif parameter_size == 2:
|
|
app_data += struct.pack("!H", parameter)
|
|
elif parameter_size == 4:
|
|
byte_one = 0xFF000000 & parameter >> 24
|
|
byte_two = 0xFF0000 & parameter >> 16
|
|
byte_three = 0xFF00 & parameter >> 8
|
|
byte_four = 0xFF & parameter
|
|
app_data.append(byte_one)
|
|
app_data.append(byte_two)
|
|
app_data.append(byte_three)
|
|
app_data.append(byte_four)
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id, action_id=action_id, user_data=app_data
|
|
)
|
|
|
|
|
|
def prompt_and_pack_get_param_command(q: DefaultPusQueueHelper, object_id: ObjectIdU32):
|
|
table_id = int(input("Specify table ID: "))
|
|
memory_address = int(input("Specify memory address: 0x"), 16)
|
|
parameter_size = int(input("Specify parameter size: "))
|
|
q.add_pus_tc(
|
|
pack_get_param_command(
|
|
object_id.as_bytes, table_id, memory_address, parameter_size
|
|
)
|
|
)
|
|
|
|
|
|
def prompt_and_pack_set_param_command(q: DefaultPusQueueHelper, object_id: ObjectIdU32):
|
|
memory_address = int(input("Specify memory address: 0x"), 16)
|
|
memory_address = struct.pack("!H", memory_address)
|
|
parameter_size = int(input("Specify parameter size: "))
|
|
parameter = int(input("Specify parameter: "))
|
|
q.add_pus_tc(
|
|
pack_set_param_command(
|
|
object_id.as_bytes, memory_address, parameter_size, parameter
|
|
)
|
|
)
|
|
|
|
|
|
def pack_ping_command(object_id: ObjectIdU32, data: bytearray) -> PusTelecommand:
|
|
""" " Function to generate the command to ping a gomspace device
|
|
@param object_id Object Id of the gomspace device handler.
|
|
@param data Bytearray containing the bytes to send to the gomspace device. For now the on board software
|
|
supports only the handling of up to 33 bytes.
|
|
@note The ping request sends the specified data to a gompsace device. These
|
|
data are simply copied by the device and then sent back.
|
|
"""
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id.as_bytes,
|
|
action_id=GomspaceDeviceActionIds.PING,
|
|
user_data=data,
|
|
)
|
|
|
|
|
|
def pack_gnd_wdt_reset_command(object_id: ObjectIdBase) -> PusTelecommand:
|
|
""" " Function to generate the command to reset the watchdog of a gomspace device.
|
|
@param object_id Object Id of the gomspace device handler.
|
|
"""
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id.as_bytes, action_id=GomspaceDeviceActionIds.WDT_RESET
|
|
)
|
|
|
|
|
|
def pack_reboot_command(object_id: ObjectIdU32) -> PusTelecommand:
|
|
"""Function to generate the command which triggers a reboot of a gomspace device
|
|
@param object_id The object id of the gomspace device handler.
|
|
"""
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id.as_bytes, action_id=GomspaceDeviceActionIds.REBOOT
|
|
)
|
|
|
|
|
|
def pack_request_full_hk_table_command(object_id: ObjectIdU32) -> PusTelecommand:
|
|
"""Function to generate the command to request the full housekeeping table from a gomspace
|
|
device.
|
|
@param object_id The object id of the gomspace device handler.
|
|
"""
|
|
return make_fsfw_action_cmd(
|
|
object_id=object_id.as_bytes, action_id=GomspaceDeviceActionIds.REQUEST_HK_TABLE
|
|
)
|