eive-tmtc/eive_tmtc/tmtc/acs/acs_ctrl.py

826 lines
32 KiB
Python
Raw Normal View History

import enum
2023-02-01 11:17:04 +01:00
import logging
2022-08-17 11:19:23 +02:00
import socket
2022-08-16 12:51:31 +02:00
import struct
2022-08-17 11:19:23 +02:00
from socket import AF_INET
2022-10-10 10:44:45 +02:00
from typing import Tuple
2022-11-29 16:53:29 +01:00
from eive_tmtc.config.definitions import CustomServiceList
from eive_tmtc.config.object_ids import ACS_CONTROLLER
from eive_tmtc.pus_tm.defs import PrintWrapper
2022-08-16 12:51:31 +02:00
from tmtccmd.config.tmtc import (
tmtc_definitions_provider,
TmtcDefinitionWrapper,
OpCodeEntry,
)
2022-08-18 14:08:05 +02:00
from tmtccmd.tc import service_provider
2023-01-31 12:56:13 +01:00
from tmtccmd.tc.pus_200_fsfw_mode import Mode, pack_mode_command
2022-08-18 14:08:05 +02:00
from tmtccmd.tc.decorator import ServiceProviderParams
2022-08-17 11:19:23 +02:00
from tmtccmd.tc.pus_3_fsfw_hk import (
generate_one_hk_command,
make_sid,
enable_periodic_hk_command_with_interval,
disable_periodic_hk_command,
2023-02-03 13:39:05 +01:00
create_request_one_diag_command,
2022-08-17 11:19:23 +02:00
)
2022-08-16 12:51:31 +02:00
from tmtccmd.util.tmtc_printer import FsfwTmTcPrinter
2022-12-02 18:03:10 +01:00
2023-01-16 13:22:41 +01:00
class SetId(enum.IntEnum):
2022-12-02 18:03:10 +01:00
MGM_RAW_SET = 0
MGM_PROC_SET = 1
SUS_RAW_SET = 2
SUS_PROC_SET = 3
GYR_RAW_SET = 4
GYR_PROC_SET = 5
GPS_PROC_SET = 6
MEKF_DATA = 7
CTRL_VAL_DATA = 8
ACTUATOR_CMD_DATA = 9
2023-01-20 12:19:57 +01:00
class Submode(enum.IntEnum):
2023-02-10 11:56:00 +01:00
OFF = 0
2023-02-10 11:38:08 +01:00
SAFE = 10
DETUMBLE = 11
IDLE = 12
PTG_NADIR = 13
PTG_TARGET = 14
PTG_TARGET_GS = 15
PTG_INERTIAL = 16
class OpCodes:
2023-01-16 15:05:33 +01:00
OFF = ["off"]
SAFE = ["normal_safe"]
DTBL = ["normal_detumble"]
IDLE = ["normal_idle"]
2022-12-21 15:15:55 +01:00
REQUEST_RAW_MGM_HK = ["0", "mgm_raw_hk"]
ENABLE_RAW_MGM_HK = ["1", "mgm_raw_enable_hk"]
DISABLE_RAW_MGM_HK = ["2", "mgm_raw_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_PROC_MGM_HK = ["3", "mgm_proc_hk"]
ENABLE_PROC_MGM_HK = ["4", "mgm_proc_enable_hk"]
DISABLE_PROC_MGM_HK = ["5", "mgm_proc_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_RAW_SUS_HK = ["6", "sus_raw_hk"]
ENABLE_RAW_SUS_HK = ["7", "sus_raw_enable_hk"]
DISABLE_RAW_SUS_HK = ["8", "sus_raw_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_PROC_SUS_HK = ["9", "sus_proc_hk"]
ENABLE_PROC_SUS_HK = ["10", "sus_proc_enable_hk"]
DISABLE_PROC_SUS_HK = ["11", "sus_proc_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_RAW_GYR_HK = ["12", "gyr_raw_hk"]
ENABLE_RAW_GYR_HK = ["13", "gyr_raw_enable_hk"]
DISABLE_RAW_GYR_HK = ["14", "gyr_raw_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_PROC_GYR_HK = ["15", "gyr_proc_hk"]
ENABLE_PROC_GYR_HK = ["16", "gyr_proc_enable_hk"]
DISABLE_PROC_GYR_HK = ["17", "gyr_proc_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_PROC_GPS_HK = ["18", "gps_proc_hk"]
ENABLE_PROC_GPS_HK = ["19", "gps_proc_enable_hk"]
DISABLE_PROC_GPS_HK = ["20", "gps_proc_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_MEKF_HK = ["21", "mekf_hk"]
ENABLE_MEKF_HK = ["22", "mekf_enable_hk"]
DISABLE_MEKF_HK = ["23", "mekf_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_CTRL_VAL_HK = ["24", "ctrl_val_hk"]
ENABLE_CTRL_VAL_HK = ["25", "ctrl_val_enable_hk"]
DISABLE_CTRL_VAL_HK = ["26", "ctrl_val_disable_hk"]
2022-12-21 15:15:55 +01:00
REQUEST_ACT_CMD_HK = ["27", "act_cmd_hk"]
ENABLE_ACT_CMD_HK = ["28", "act_cmd_enable_hk"]
DISABLE_ACT_CMD_HK = ["29", "act_cmd_disable_hk"]
class Info:
2023-01-16 14:48:12 +01:00
OFF = "Switch ACS CTRL off"
SAFE = "Switch ACS CTRL normal safe"
DTBL = "Switch ACS CTRL normal detumble"
IDLE = "Switch ACS CTRL normal idle"
2022-12-21 15:15:55 +01:00
REQUEST_RAW_MGM_HK = "Request Raw MGM HK once"
ENABLE_RAW_MGM_HK = "Enable Raw MGM HK data generation"
DISABLE_RAW_MGM_HK = "Disable Raw MGM HK data generation"
2022-12-02 18:03:10 +01:00
REQUEST_PROC_MGM_HK = "Request Processed MGM HK"
2022-12-21 15:15:55 +01:00
ENABLE_PROC_MGM_HK = "Enable Processed MGM HK data generation"
DISABLE_PROC_MGM_HK = "Disable Processed MGM HK data generation"
2022-12-02 18:03:10 +01:00
REQUEST_RAW_SUS_HK = "Request Raw SUS HK"
2022-12-21 15:15:55 +01:00
ENABLE_RAW_SUS_HK = "Enable Raw SUS HK data generation"
DISABLE_RAW_SUS_HK = "Disable Raw SUS HK data generation"
2022-12-02 18:03:10 +01:00
REQUEST_PROC_SUS_HK = "Request Processed SUS HK"
2022-12-21 15:15:55 +01:00
ENABLE_PROC_SUS_HK = "Enable Processed SUS HK data generation"
DISABLE_PROC_SUS_HK = "Disable Processed MGM HK data generation"
REQUEST_RAW_GYR_HK = "Request Raw GYR HK"
ENABLE_RAW_GYR_HK = "Enable Raw GYR HK data generation"
DISABLE_RAW_GYR_HK = "Disable Raw GYR HK data generation"
REQUEST_PROC_GYR_HK = "Request Processed GYR HK"
ENABLE_PROC_GYR_HK = "Enable Processed GYR HK data generation"
DISABLE_PROC_GYR_HK = "Disable Processed GYR HK data generation"
REQUEST_PROC_GPS_HK = "Request Processed GPS HK"
ENABLE_PROC_GPS_HK = "Enable Processed GPS HK data generation"
DISABLE_PROC_GPS_HK = "Disable Processed GPS HK data generation"
REQUEST_MEKF_HK = "Request MEKF HK"
ENABLE_MEKF_HK = "Enable MEKF HK data generation"
DISABLE_MEKF_HK = "Disable MEKF HK data generation"
REQUEST_CTRL_VAL_HK = "Request Control Values HK"
ENABLE_CTRL_VAL_HK = "Enable Control Values HK data generation"
DISABLE_CTRL_VAL_HK = "Disable Control Values HK data generation"
REQUEST_ACT_CMD_HK = "Request Actuator Commands HK"
ENABLE_ACT_CMD_HK = "Enable Actuator Commands HK data generation"
DISABLE_ACT_CMD_HK = "Disable Actuator Commands HK data generation"
2022-08-18 11:09:35 +02:00
PERFORM_MGM_CALIBRATION = False
2022-08-17 11:19:23 +02:00
CALIBRATION_SOCKET_HOST = "localhost"
CALIBRATION_SOCKET_PORT = 6677
CALIBRATION_ADDR = (CALIBRATION_SOCKET_HOST, CALIBRATION_SOCKET_PORT)
2022-08-17 15:24:39 +02:00
if PERFORM_MGM_CALIBRATION:
CALIBR_SOCKET = socket.socket(AF_INET, socket.SOCK_STREAM)
CALIBR_SOCKET.setblocking(False)
CALIBR_SOCKET.settimeout(0.2)
CALIBR_SOCKET.connect(CALIBRATION_ADDR)
2022-08-17 11:19:23 +02:00
@tmtc_definitions_provider
def acs_cmd_defs(defs: TmtcDefinitionWrapper):
oce = OpCodeEntry()
2023-01-16 14:48:12 +01:00
oce.add(keys=OpCodes.OFF, info=Info.OFF)
oce.add(keys=OpCodes.SAFE, info=Info.SAFE)
oce.add(keys=OpCodes.DTBL, info=Info.DTBL)
oce.add(keys=OpCodes.IDLE, info=Info.IDLE)
2022-12-21 15:15:55 +01:00
oce.add(keys=OpCodes.REQUEST_RAW_MGM_HK, info=Info.REQUEST_RAW_MGM_HK)
oce.add(keys=OpCodes.ENABLE_RAW_MGM_HK, info=Info.ENABLE_RAW_MGM_HK)
oce.add(keys=OpCodes.DISABLE_RAW_MGM_HK, info=Info.DISABLE_RAW_MGM_HK)
oce.add(keys=OpCodes.REQUEST_PROC_MGM_HK, info=Info.REQUEST_PROC_MGM_HK)
oce.add(keys=OpCodes.ENABLE_PROC_MGM_HK, info=Info.ENABLE_PROC_MGM_HK)
oce.add(keys=OpCodes.DISABLE_PROC_MGM_HK, info=Info.DISABLE_PROC_MGM_HK)
oce.add(keys=OpCodes.REQUEST_RAW_SUS_HK, info=Info.REQUEST_RAW_SUS_HK)
oce.add(keys=OpCodes.ENABLE_RAW_SUS_HK, info=Info.ENABLE_RAW_SUS_HK)
oce.add(keys=OpCodes.DISABLE_RAW_SUS_HK, info=Info.DISABLE_RAW_SUS_HK)
oce.add(keys=OpCodes.REQUEST_PROC_SUS_HK, info=Info.REQUEST_PROC_SUS_HK)
oce.add(keys=OpCodes.ENABLE_PROC_SUS_HK, info=Info.ENABLE_PROC_SUS_HK)
oce.add(keys=OpCodes.DISABLE_PROC_SUS_HK, info=Info.DISABLE_PROC_SUS_HK)
oce.add(keys=OpCodes.REQUEST_RAW_GYR_HK, info=Info.REQUEST_RAW_GYR_HK)
oce.add(keys=OpCodes.ENABLE_RAW_GYR_HK, info=Info.ENABLE_RAW_GYR_HK)
oce.add(keys=OpCodes.DISABLE_RAW_GYR_HK, info=Info.DISABLE_RAW_GYR_HK)
oce.add(keys=OpCodes.REQUEST_PROC_GYR_HK, info=Info.REQUEST_PROC_GYR_HK)
oce.add(keys=OpCodes.ENABLE_PROC_GYR_HK, info=Info.ENABLE_PROC_GYR_HK)
oce.add(keys=OpCodes.DISABLE_PROC_GYR_HK, info=Info.DISABLE_PROC_GYR_HK)
oce.add(keys=OpCodes.REQUEST_PROC_GPS_HK, info=Info.REQUEST_PROC_GPS_HK)
oce.add(keys=OpCodes.ENABLE_PROC_GPS_HK, info=Info.ENABLE_PROC_GPS_HK)
oce.add(keys=OpCodes.DISABLE_PROC_GPS_HK, info=Info.DISABLE_PROC_GPS_HK)
oce.add(keys=OpCodes.REQUEST_MEKF_HK, info=Info.REQUEST_MEKF_HK)
oce.add(keys=OpCodes.ENABLE_MEKF_HK, info=Info.ENABLE_MEKF_HK)
oce.add(keys=OpCodes.DISABLE_MEKF_HK, info=Info.DISABLE_MEKF_HK)
oce.add(keys=OpCodes.REQUEST_CTRL_VAL_HK, info=Info.REQUEST_CTRL_VAL_HK)
oce.add(keys=OpCodes.ENABLE_CTRL_VAL_HK, info=Info.ENABLE_CTRL_VAL_HK)
oce.add(keys=OpCodes.DISABLE_CTRL_VAL_HK, info=Info.DISABLE_CTRL_VAL_HK)
oce.add(keys=OpCodes.REQUEST_ACT_CMD_HK, info=Info.REQUEST_ACT_CMD_HK)
oce.add(keys=OpCodes.ENABLE_ACT_CMD_HK, info=Info.ENABLE_ACT_CMD_HK)
oce.add(keys=OpCodes.DISABLE_ACT_CMD_HK, info=Info.DISABLE_ACT_CMD_HK)
defs.add_service(
2022-08-16 12:51:31 +02:00
name=CustomServiceList.ACS_CTRL.value, info="ACS Controller", op_code_entry=oce
)
@service_provider(CustomServiceList.ACS_CTRL.value)
2022-08-18 14:08:05 +02:00
def pack_acs_ctrl_command(p: ServiceProviderParams):
op_code = p.op_code
q = p.queue_helper
2023-01-16 14:48:12 +01:00
if op_code in OpCodes.OFF:
2023-01-16 15:05:33 +01:00
q.add_log_cmd(f"{Info.OFF}")
q.add_pus_tc(pack_mode_command(ACS_CONTROLLER, Mode.OFF, 0))
elif op_code in OpCodes.SAFE:
q.add_log_cmd(f"{Info.SAFE}")
q.add_pus_tc(pack_mode_command(ACS_CONTROLLER, Mode.NORMAL, Submode.SAFE))
elif op_code in OpCodes.DTBL:
q.add_log_cmd(f"{Info.DTBL}")
2023-01-23 15:35:24 +01:00
q.add_pus_tc(pack_mode_command(ACS_CONTROLLER, Mode.NORMAL, Submode.DETUMBLE))
elif op_code in OpCodes.IDLE:
q.add_log_cmd(f"{Info.IDLE}")
q.add_pus_tc(pack_mode_command(ACS_CONTROLLER, Mode.NORMAL, Submode.IDLE))
elif op_code in OpCodes.REQUEST_RAW_MGM_HK:
2022-12-21 15:15:55 +01:00
q.add_log_cmd(Info.REQUEST_RAW_MGM_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.MGM_RAW_SET))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_RAW_MGM_HK:
q.add_log_cmd(Info.ENABLE_RAW_MGM_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.MGM_RAW_SET), 2.0
2022-12-21 16:07:49 +01:00
)
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.DISABLE_RAW_MGM_HK:
q.add_log_cmd(Info.DISABLE_RAW_MGM_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.MGM_RAW_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_PROC_MGM_HK:
q.add_log_cmd(Info.REQUEST_PROC_MGM_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.MGM_PROC_SET))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_PROC_MGM_HK:
q.add_log_cmd(Info.ENABLE_PROC_MGM_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.MGM_PROC_SET), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_PROC_MGM_HK:
q.add_log_cmd(Info.DISABLE_PROC_MGM_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.MGM_PROC_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_RAW_SUS_HK:
q.add_log_cmd(Info.REQUEST_RAW_SUS_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.SUS_RAW_SET))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_RAW_SUS_HK:
q.add_log_cmd(Info.ENABLE_RAW_SUS_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.SUS_RAW_SET), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_RAW_SUS_HK:
q.add_log_cmd(Info.DISABLE_RAW_SUS_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.SUS_RAW_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_PROC_SUS_HK:
q.add_log_cmd(Info.REQUEST_PROC_SUS_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.SUS_PROC_SET))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_PROC_SUS_HK:
q.add_log_cmd(Info.ENABLE_PROC_SUS_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.SUS_PROC_SET), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_PROC_SUS_HK:
q.add_log_cmd(Info.DISABLE_PROC_SUS_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.SUS_PROC_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_RAW_GYR_HK:
q.add_log_cmd(Info.REQUEST_RAW_GYR_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
create_request_one_diag_command(make_sid(ACS_CONTROLLER, SetId.GYR_RAW_SET))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_RAW_GYR_HK:
q.add_log_cmd(Info.ENABLE_RAW_GYR_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-19 16:41:49 +01:00
True, make_sid(ACS_CONTROLLER, SetId.GYR_RAW_SET), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_RAW_GYR_HK:
q.add_log_cmd(Info.DISABLE_RAW_GYR_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-19 16:41:49 +01:00
True, make_sid(ACS_CONTROLLER, SetId.GYR_RAW_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_PROC_GYR_HK:
q.add_log_cmd(Info.REQUEST_PROC_GYR_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-02-03 13:39:05 +01:00
create_request_one_diag_command(
make_sid(ACS_CONTROLLER, SetId.GYR_PROC_SET)
)
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_PROC_GYR_HK:
q.add_log_cmd(Info.ENABLE_PROC_GYR_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.GYR_PROC_SET), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_PROC_GYR_HK:
q.add_log_cmd(Info.DISABLE_PROC_GYR_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.GYR_PROC_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_PROC_GPS_HK:
q.add_log_cmd(Info.REQUEST_PROC_GPS_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.GPS_PROC_SET))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_PROC_GPS_HK:
q.add_log_cmd(Info.ENABLE_PROC_GPS_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.GPS_PROC_SET), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_PROC_GPS_HK:
q.add_log_cmd(Info.DISABLE_PROC_GPS_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.GPS_PROC_SET)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_MEKF_HK:
q.add_log_cmd(Info.REQUEST_MEKF_HK)
2023-01-16 13:22:41 +01:00
q.add_pus_tc(generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.MEKF_DATA)))
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_MEKF_HK:
q.add_log_cmd(Info.ENABLE_MEKF_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-19 16:41:49 +01:00
True, make_sid(ACS_CONTROLLER, SetId.MEKF_DATA), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_MEKF_HK:
2022-12-21 16:07:49 +01:00
q.add_log_cmd(Info.DISABLE_MEKF_HK)
q.add_pus_tc(
2023-01-20 10:35:30 +01:00
disable_periodic_hk_command(True, make_sid(ACS_CONTROLLER, SetId.MEKF_DATA))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_CTRL_VAL_HK:
2022-12-21 16:07:49 +01:00
q.add_log_cmd(Info.REQUEST_CTRL_VAL_HK)
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.CTRL_VAL_DATA))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_CTRL_VAL_HK:
q.add_log_cmd(Info.ENABLE_CTRL_VAL_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.CTRL_VAL_DATA), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_CTRL_VAL_HK:
q.add_log_cmd(Info.DISABLE_CTRL_VAL_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.CTRL_VAL_DATA)
2022-12-21 16:07:49 +01:00
)
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.REQUEST_ACT_CMD_HK:
q.add_log_cmd(Info.REQUEST_ACT_CMD_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
2023-01-16 13:22:41 +01:00
generate_one_hk_command(make_sid(ACS_CONTROLLER, SetId.ACTUATOR_CMD_DATA))
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
elif op_code in OpCodes.ENABLE_ACT_CMD_HK:
q.add_log_cmd(Info.ENABLE_ACT_CMD_HK)
2022-12-21 16:07:49 +01:00
cmd_tuple = enable_periodic_hk_command_with_interval(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.ACTUATOR_CMD_DATA), 2.0
2022-12-21 16:07:49 +01:00
)
2022-12-21 15:15:55 +01:00
q.add_pus_tc(cmd_tuple[0])
q.add_pus_tc(cmd_tuple[1])
elif op_code in OpCodes.DISABLE_ACT_CMD_HK:
q.add_log_cmd(Info.DISABLE_ACT_CMD_HK)
2022-12-21 16:07:49 +01:00
q.add_pus_tc(
disable_periodic_hk_command(
2023-01-16 13:22:41 +01:00
False, make_sid(ACS_CONTROLLER, SetId.ACTUATOR_CMD_DATA)
2022-12-21 16:07:49 +01:00
)
)
2022-08-16 11:56:06 +02:00
else:
2023-02-01 11:17:04 +01:00
logging.getLogger(__name__).info(f"Unknown op code {op_code}")
2022-08-16 12:51:31 +02:00
2022-12-02 18:03:10 +01:00
def handle_acs_ctrl_hk_data(printer: FsfwTmTcPrinter, set_id: int, hk_data: bytes):
2022-12-02 17:22:15 +01:00
pw = PrintWrapper(printer)
2022-12-21 15:15:55 +01:00
match set_id:
2023-01-16 13:22:41 +01:00
case SetId.MGM_RAW_SET:
2022-12-21 15:15:55 +01:00
handle_raw_mgm_data(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.MGM_PROC_SET:
2022-12-21 15:15:55 +01:00
handle_mgm_data_processed(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.SUS_RAW_SET:
2022-12-21 15:15:55 +01:00
handle_acs_ctrl_sus_raw_data(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.SUS_PROC_SET:
2022-12-21 15:15:55 +01:00
handle_acs_ctrl_sus_processed_data(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.GYR_RAW_SET:
2022-12-21 15:15:55 +01:00
handle_gyr_data_raw(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.GYR_PROC_SET:
2022-12-21 15:15:55 +01:00
handle_gyr_data_processed(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.GPS_PROC_SET:
2022-12-21 15:15:55 +01:00
handle_gps_data_processed(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.MEKF_DATA:
2022-12-21 15:15:55 +01:00
handle_mekf_data(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.CTRL_VAL_DATA:
2022-12-21 15:15:55 +01:00
handle_ctrl_val_data(pw, hk_data)
2023-01-16 13:22:41 +01:00
case SetId.ACTUATOR_CMD_DATA:
2022-12-21 15:15:55 +01:00
handle_act_cmd_data(pw, hk_data)
2022-12-02 18:03:10 +01:00
def handle_acs_ctrl_sus_raw_data(pw: PrintWrapper, hk_data: bytes):
2022-12-02 17:22:15 +01:00
if len(hk_data) < 6 * 2 * 12:
2022-12-02 17:53:42 +01:00
pw.dlog(
f"SUS Raw dataset with size {len(hk_data)} does not have expected size"
f" of {6 * 2 * 12} bytes"
)
2022-12-02 17:22:15 +01:00
return
current_idx = 0
2022-12-21 16:07:49 +01:00
vec_fmt = "["
for _ in range(5):
vec_fmt += "{:#06x}, "
vec_fmt += "{:#06x}]"
2022-12-02 17:22:15 +01:00
for idx in range(12):
fmt_str = "!HHHHHH"
length = struct.calcsize(fmt_str)
2022-12-02 17:53:42 +01:00
sus_list = struct.unpack(fmt_str, hk_data[current_idx : current_idx + length])
2022-12-21 16:07:49 +01:00
sus_list_formatted = vec_fmt.format(*sus_list)
2022-12-02 17:22:15 +01:00
current_idx += length
pw.dlog(f"SUS {idx} RAW: {sus_list_formatted}")
2022-12-21 16:07:49 +01:00
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=12)
2022-12-02 17:22:15 +01:00
2022-12-02 18:03:10 +01:00
def handle_acs_ctrl_sus_processed_data(pw: PrintWrapper, hk_data: bytes):
if len(hk_data) < 3 * 4 * 12 + 3 * 8 * 3:
2022-12-02 17:53:42 +01:00
pw.dlog(
f"SUS Processed dataset with size {len(hk_data)} does not have expected size"
f" of {3 * 4 * 12 + 3 * 8 * 3} bytes"
2022-12-02 17:53:42 +01:00
)
2022-12-02 17:22:15 +01:00
return
current_idx = 0
2023-02-08 21:09:24 +01:00
vec_fmt = "[{:8.3f}, {:8.3f}, {:8.3f}]"
2022-12-02 17:22:15 +01:00
for idx in range(12):
fmt_str = "!fff"
length = struct.calcsize(fmt_str)
2022-12-02 17:53:42 +01:00
sus_list = struct.unpack(fmt_str, hk_data[current_idx : current_idx + length])
2023-02-08 21:09:24 +01:00
sus_list_formatted = vec_fmt.format(*sus_list)
2022-12-02 17:22:15 +01:00
current_idx += length
2023-02-08 21:09:24 +01:00
pw.dlog(f"{f'SUS {idx} CALIB'.ljust(25)}: {sus_list_formatted}")
2022-12-02 17:22:15 +01:00
fmt_str = "!ddd"
inc_len = struct.calcsize(fmt_str)
sus_vec_tot = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 21:09:24 +01:00
sus_vec_tot = vec_fmt.format(*sus_vec_tot)
2022-12-02 17:22:15 +01:00
current_idx += inc_len
2023-02-08 21:09:24 +01:00
pw.dlog(f"{'SUS Vector Total'.ljust(25)}: {sus_vec_tot}")
2022-12-02 17:53:42 +01:00
sus_vec_tot_deriv = struct.unpack(
fmt_str, hk_data[current_idx : current_idx + inc_len]
)
2023-02-08 21:09:24 +01:00
sus_vec_tot_deriv = vec_fmt.format(*sus_vec_tot_deriv)
2022-12-02 17:22:15 +01:00
current_idx += inc_len
2023-02-08 21:09:24 +01:00
pw.dlog(f"{'SUS Vector Derivative'.ljust(25)}: {sus_vec_tot_deriv}")
sun_ijk_model = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 21:09:24 +01:00
sun_ijk_model = vec_fmt.format(*sun_ijk_model)
2022-12-02 17:22:15 +01:00
current_idx += inc_len
2023-02-08 21:09:24 +01:00
pw.dlog(f"{'SUS ijk Model'.ljust(25)}: {sun_ijk_model}")
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=15)
2022-12-02 17:22:15 +01:00
2022-12-02 18:03:10 +01:00
def handle_raw_mgm_data(pw: PrintWrapper, hk_data: bytes):
2022-08-16 12:51:31 +02:00
current_idx = 0
if len(hk_data) < 61:
pw.dlog(
2022-08-16 12:53:05 +02:00
f"ACS CTRL HK: MGM HK data with length {len(hk_data)} shorter than expected 61 bytes"
2022-08-16 12:51:31 +02:00
)
pw.dlog(f"Raw Data: {hk_data.hex(sep=',')}")
return
def unpack_float_tuple(idx: int) -> (tuple, int):
f_tuple = struct.unpack(
float_tuple_fmt_str,
hk_data[idx : idx + struct.calcsize(float_tuple_fmt_str)],
)
idx += struct.calcsize(float_tuple_fmt_str)
return f_tuple, idx
float_tuple_fmt_str = "!fff"
mgm_0_lis3_floats_ut, current_idx = unpack_float_tuple(current_idx)
mgm_1_rm3100_floats_ut, current_idx = unpack_float_tuple(current_idx)
mgm_2_lis3_floats_ut, current_idx = unpack_float_tuple(current_idx)
mgm_3_rm3100_floats_ut, current_idx = unpack_float_tuple(current_idx)
2022-08-18 18:15:48 +02:00
isis_floats_nt, current_idx = unpack_float_tuple(current_idx)
imtq_mgm_ut = tuple(val / 1000.0 for val in isis_floats_nt)
2022-08-16 12:53:05 +02:00
pw.dlog("ACS CTRL HK: MGM values [X,Y,Z] in floating point uT: ")
2022-08-16 12:51:31 +02:00
mgm_lists = [
mgm_0_lis3_floats_ut,
mgm_1_rm3100_floats_ut,
mgm_2_lis3_floats_ut,
mgm_3_rm3100_floats_ut,
imtq_mgm_ut,
]
formatted_list = []
# Reserve 8 decimal digits, use precision 3
float_str_fmt = "[{:8.3f}, {:8.3f}, {:8.3f}]"
for mgm_entry in mgm_lists[0:4]:
formatted_list.append(float_str_fmt.format(*mgm_entry))
formatted_list.append(float_str_fmt.format(*mgm_lists[4]))
formatted_list.append(hk_data[current_idx])
2022-08-16 12:51:31 +02:00
print_str_list = [
"ACS Board MGM 0 LIS3MDL",
"ACS Board MGM 1 RM3100",
"ACS Board MGM 2 LIS3MDL",
"ACS Board MGM 3 RM3100",
"IMTQ MGM:",
2022-12-21 15:15:55 +01:00
"IMTQ Actuation Status:",
2022-08-16 12:51:31 +02:00
]
for entry in zip(print_str_list, formatted_list):
pw.dlog(f"{entry[0].ljust(28)}: {entry[1]}")
current_idx += 1
assert current_idx == 61
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=6)
2022-08-17 11:19:23 +02:00
2022-12-02 17:53:42 +01:00
def handle_mgm_data_processed(pw: PrintWrapper, hk_data: bytes):
pw.dlog("Received Processed MGM Set")
fmt_str = "!fffffddd"
inc_len = struct.calcsize(fmt_str)
if len(hk_data) < inc_len:
pw.dlog("Recieved HK set too small")
return
current_idx = 0
fmt_str = "!fff"
2023-02-08 22:55:22 +01:00
vec_fmt = "[{:8.3f}, {:8.3f}, {:8.3f}]"
inc_len = struct.calcsize(fmt_str)
2023-02-07 15:21:48 +01:00
mgm_0 = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 22:55:22 +01:00
mgm_0_str = vec_fmt.format(*mgm_0)
pw.dlog(f"{'MGM 0 Vec'.ljust(25)}: {mgm_0_str}")
current_idx += inc_len
2023-02-07 15:21:48 +01:00
mgm_1 = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 22:55:22 +01:00
mgm_1_str = vec_fmt.format(*mgm_1)
pw.dlog(f"{'MGM 1 Vec'.ljust(25)}: {mgm_1_str}")
current_idx += inc_len
2023-02-07 15:21:48 +01:00
mgm_2 = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 22:55:22 +01:00
mgm_2_str = vec_fmt.format(*mgm_2)
pw.dlog(f"{'MGM 2 Vec'.ljust(25)}: {mgm_2_str}")
current_idx += inc_len
2023-02-07 15:21:48 +01:00
mgm_3 = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 22:55:22 +01:00
mgm_3_str = vec_fmt.format(*mgm_3)
pw.dlog(f"{'MGM 3 Vec'.ljust(25)}: {mgm_3_str}")
current_idx += inc_len
2023-02-07 15:21:48 +01:00
mgm_4 = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 22:55:22 +01:00
mgm_4_str = vec_fmt.format(*mgm_4)
pw.dlog(f"{'MGM 4 Vec'.ljust(25)}: {mgm_4_str}")
current_idx += inc_len
2022-12-02 17:53:42 +01:00
fmt_str = "!ddd"
inc_len = struct.calcsize(fmt_str)
2023-02-07 15:21:48 +01:00
mgm_vec_tot = struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
2023-02-08 22:55:22 +01:00
mgm_vec_tot = vec_fmt.format(*mgm_vec_tot)
2022-12-02 17:53:42 +01:00
current_idx += inc_len
2023-02-08 22:55:22 +01:00
pw.dlog(f"{'MGM Total Vec'.ljust(25)}: {mgm_vec_tot}")
2022-12-02 17:53:42 +01:00
mgm_vec_tot_deriv = struct.unpack(
2023-02-07 15:21:48 +01:00
fmt_str, hk_data[current_idx : current_idx + inc_len]
2022-12-02 17:53:42 +01:00
)
2023-02-08 22:55:22 +01:00
mgm_vec_tot_deriv = vec_fmt.format(*mgm_vec_tot_deriv)
pw.dlog(f"{'MGM Total Vec Deriv'.ljust(25)}: {mgm_vec_tot_deriv}")
2022-12-02 17:53:42 +01:00
current_idx += inc_len
mag_igrf_model = struct.unpack(
2023-02-07 15:21:48 +01:00
fmt_str, hk_data[current_idx : current_idx + inc_len]
2022-12-02 17:53:42 +01:00
)
2023-02-08 22:55:22 +01:00
mag_igrf_model = vec_fmt.format(*mag_igrf_model)
pw.dlog(f"{'MAG IGRF Model'.ljust(25)}: {mag_igrf_model}")
2022-12-02 17:53:42 +01:00
current_idx += inc_len
if PERFORM_MGM_CALIBRATION:
perform_mgm_calibration(pw, mgm_3)
2022-12-02 17:53:42 +01:00
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=8)
def handle_gyr_data_raw(pw: PrintWrapper, hk_data: bytes):
2022-12-21 15:15:55 +01:00
pw.dlog("Received GYR Raw Set with rotation rates in deg per second")
2022-12-02 17:53:42 +01:00
float_fmt = "!fff"
double_fmt = "!ddd"
inc_len_flt = struct.calcsize(float_fmt)
inc_len_double = struct.calcsize(double_fmt)
if len(hk_data) < 2 * inc_len_double + 2 * inc_len_flt:
pw.dlog("HK data too small")
return
current_idx = 0
2022-12-21 16:07:49 +01:00
float_str_fmt = "[{:8.3f}, {:8.3f}, {:8.3f}]"
gyr_0_adis = struct.unpack(
double_fmt, hk_data[current_idx : current_idx + inc_len_double]
)
2022-12-02 17:53:42 +01:00
current_idx += inc_len_double
2022-12-21 16:07:49 +01:00
gyr_1_l3 = struct.unpack(
float_fmt, hk_data[current_idx : current_idx + inc_len_flt]
)
2022-12-02 17:53:42 +01:00
current_idx += inc_len_flt
2022-12-21 16:07:49 +01:00
gyr_2_adis = struct.unpack(
double_fmt, hk_data[current_idx : current_idx + inc_len_double]
)
current_idx += inc_len_double
gyr_3_l3 = struct.unpack(
float_fmt, hk_data[current_idx : current_idx + inc_len_flt]
)
2022-12-02 17:53:42 +01:00
current_idx += inc_len_flt
2022-12-21 16:07:49 +01:00
pw.dlog(f"{'GYR 0 ADIS'.ljust(15)}: {float_str_fmt.format(*gyr_0_adis)}")
pw.dlog(f"{'GYR 1 L3'.ljust(15)}: {float_str_fmt.format(*gyr_1_l3)}")
pw.dlog(f"{'GYR 2 ADIS'.ljust(15)}: {float_str_fmt.format(*gyr_2_adis)}")
pw.dlog(f"{'GYR 3 L3'.ljust(15)}: {float_str_fmt.format(*gyr_3_l3)}")
2022-12-02 17:53:42 +01:00
pw.printer.print_validity_buffer(hk_data[current_idx:], 4)
2022-12-21 15:15:55 +01:00
GYR_NAMES = ["GYR 0 ADIS", "GYR 1 L3", "GYR 2 ADIS", "GYR 3 L3"]
2022-12-02 17:53:42 +01:00
def handle_gyr_data_processed(pw: PrintWrapper, hk_data: bytes):
2022-12-21 15:15:55 +01:00
pw.dlog("Received GYR Processed Set with rotation rates in deg per second")
2022-12-02 17:53:42 +01:00
fmt_str = "!ddd"
inc_len = struct.calcsize(fmt_str)
current_idx = 0
for i in range(4):
gyr_vec = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_str, hk_data[current_idx : current_idx + inc_len]
)
]
2022-12-21 15:15:55 +01:00
pw.dlog(f"{GYR_NAMES[i]}: {gyr_vec}")
2022-12-02 17:53:42 +01:00
current_idx += inc_len
gyr_vec_tot = [
f"{val:8.3f}"
for val in struct.unpack(fmt_str, hk_data[current_idx : current_idx + inc_len])
]
2022-12-21 15:15:55 +01:00
pw.dlog(f"GYR Vec Total: {gyr_vec_tot}")
2022-12-02 17:53:42 +01:00
current_idx += inc_len
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=5)
2022-12-02 17:53:42 +01:00
2022-12-21 15:15:55 +01:00
def handle_gps_data_processed(pw: PrintWrapper, hk_data: bytes):
pw.dlog("Received GPS Processed Set")
fmt_scalar = "!d"
fmt_vec = "!ddd"
inc_len_scalar = struct.calcsize(fmt_scalar)
inc_len_vec = struct.calcsize(fmt_vec)
if len(hk_data) < 2 * inc_len_scalar + 2 * inc_len_vec:
2022-12-21 15:15:55 +01:00
pw.dlog("Received HK set too small")
return
current_idx = 0
2022-12-21 16:07:49 +01:00
lat = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_scalar, hk_data[current_idx : current_idx + inc_len_scalar]
)
]
2022-12-21 15:15:55 +01:00
current_idx += inc_len_scalar
2022-12-21 16:07:49 +01:00
long = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_scalar, hk_data[current_idx : current_idx + inc_len_scalar]
)
]
2022-12-21 15:15:55 +01:00
current_idx += inc_len_scalar
pos = [
2022-12-21 16:07:49 +01:00
f"{val:8.3f}"
for val in struct.unpack(
fmt_vec, hk_data[current_idx : current_idx + inc_len_vec]
)
]
2023-02-13 15:44:42 +01:00
current_idx += inc_len_vec
velo = [
f"{val:8.3f}"
for val in struct.unpack(
2023-02-02 18:20:50 +01:00
fmt_vec, hk_data[current_idx : current_idx + inc_len_vec]
)
]
current_idx += inc_len_vec
2022-12-21 15:15:55 +01:00
pw.dlog(f"GPS Latitude: {lat} [rad]")
pw.dlog(f"GPS Longitude: {long} [rad]")
pw.dlog(f"GPS Position: {pos} [m]")
2022-12-21 15:15:55 +01:00
pw.dlog(f"GPS Velocity: {velo} [m/s]")
2023-02-13 15:44:42 +01:00
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=4)
2022-12-21 15:15:55 +01:00
2022-12-21 16:07:49 +01:00
2022-12-21 15:15:55 +01:00
def handle_mekf_data(pw: PrintWrapper, hk_data: bytes):
pw.dlog("Received MEKF Set")
fmt_quat = "!dddd"
2023-02-08 22:55:22 +01:00
fmt_str_4 = "[{:8.3f}, {:8.3f}, {:8.3f}, {:8.3f}]"
fmt_str_3 = "[{:8.3f}, {:8.3f}, {:8.3f}]"
2022-12-21 15:15:55 +01:00
fmt_vec = "!ddd"
inc_len_quat = struct.calcsize(fmt_quat)
inc_len_vec = struct.calcsize(fmt_vec)
if len(hk_data) < inc_len_quat + inc_len_vec:
pw.dlog("Received HK set too small")
return
current_idx = 0
2023-02-08 22:55:22 +01:00
quat = struct.unpack(fmt_quat, hk_data[current_idx : current_idx + inc_len_quat])
2022-12-21 15:15:55 +01:00
current_idx += inc_len_quat
2023-02-08 22:55:22 +01:00
rate = struct.unpack(fmt_vec, hk_data[current_idx : current_idx + inc_len_vec])
current_idx += inc_len_vec
2023-02-08 22:55:22 +01:00
pw.dlog(f"{'MEKF Quaternion'.ljust(25)}: {fmt_str_4.format(*quat)}")
pw.dlog(f"{'MEKF Rotational Rate'.ljust(25)}: {fmt_str_3.format(*rate)}")
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=2)
2022-12-21 15:15:55 +01:00
def handle_ctrl_val_data(pw: PrintWrapper, hk_data: bytes):
pw.dlog("Received CTRL Values Set")
fmt_quat = "!dddd"
fmt_scalar = "!d"
inc_len_quat = struct.calcsize(fmt_quat)
inc_len_scalar = struct.calcsize(fmt_scalar)
if len(hk_data) < 2 * inc_len_quat + inc_len_scalar:
pw.dlog("Received HK set too small")
return
current_idx = 0
2022-12-21 16:07:49 +01:00
tgt_quat = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_quat, hk_data[current_idx : current_idx + inc_len_quat]
)
]
2022-12-21 15:15:55 +01:00
current_idx += inc_len_quat
2022-12-21 16:07:49 +01:00
err_quat = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_quat, hk_data[current_idx : current_idx + inc_len_quat]
)
]
2022-12-21 15:15:55 +01:00
current_idx += inc_len_quat
2022-12-21 16:07:49 +01:00
err_ang = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_scalar, hk_data[current_idx : current_idx + inc_len_scalar]
)
]
current_idx += inc_len_scalar
2022-12-21 15:15:55 +01:00
pw.dlog(f"Control Values Target Quaternion: {tgt_quat}")
pw.dlog(f"Control Values Error Quaternion: {err_quat}")
pw.dlog(f"Control Values Error Angle: {err_ang} [rad]")
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=3)
2022-12-21 15:15:55 +01:00
def handle_act_cmd_data(pw: PrintWrapper, hk_data: bytes):
pw.dlog("Received Actuator Command Values Set")
fmt_vec4_double = "!dddd"
fmt_vec4_int32 = "!iiii"
fmt_vec3_int16 = "!hhh"
inc_len_vec4_double = struct.calcsize(fmt_vec4_double)
inc_len_vec4_int32 = struct.calcsize(fmt_vec4_int32)
inc_len_vec3_int16 = struct.calcsize(fmt_vec3_int16)
if len(hk_data) < inc_len_vec4_double + inc_len_vec4_int32 + inc_len_vec3_int16:
pw.dlog("Received HK set too small")
return
current_idx = 0
2022-12-21 16:07:49 +01:00
rw_tgt_torque = [
f"{val:8.3f}"
for val in struct.unpack(
fmt_vec4_double, hk_data[current_idx : current_idx + inc_len_vec4_double]
)
]
2022-12-21 15:15:55 +01:00
current_idx += inc_len_vec4_double
2022-12-21 16:07:49 +01:00
rw_tgt_speed = [
f"{val:d}"
for val in struct.unpack(
fmt_vec4_int32, hk_data[current_idx : current_idx + inc_len_vec4_int32]
)
]
2022-12-21 15:15:55 +01:00
current_idx += inc_len_vec4_int32
2022-12-21 16:07:49 +01:00
mtq_tgt_dipole = [
f"{val:d}"
for val in struct.unpack(
fmt_vec3_int16, hk_data[current_idx : current_idx + inc_len_vec3_int16]
)
]
current_idx += inc_len_vec3_int16
2022-12-21 15:15:55 +01:00
pw.dlog(f"Actuator Commands RW Target Torque: {rw_tgt_torque}")
pw.dlog(f"Actuator Commands RW Target Speed: {rw_tgt_speed}")
pw.dlog(f"Actuator Commands MTQ Target Dipole: {mtq_tgt_dipole}")
pw.printer.print_validity_buffer(hk_data[current_idx:], num_vars=3)
2022-12-21 15:15:55 +01:00
2022-08-17 11:19:23 +02:00
def perform_mgm_calibration(pw: PrintWrapper, mgm_tuple: Tuple):
2022-08-17 15:24:39 +02:00
global CALIBR_SOCKET, CALIBRATION_ADDR
2022-08-17 11:19:23 +02:00
try:
declare_api_cmd = "declare_api_version 2"
2022-08-17 15:24:39 +02:00
CALIBR_SOCKET.sendall(f"{declare_api_cmd}\n".encode())
reply = CALIBR_SOCKET.recv(1024)
if len(reply) != 2:
2022-08-18 11:09:35 +02:00
pw.dlog(
2022-12-02 17:53:42 +01:00
f"MGM calibration: Reply received command {declare_api_cmd} has"
f" invalid length {len(reply)}"
2022-08-18 11:09:35 +02:00
)
2022-08-17 15:24:39 +02:00
return
else:
if str(reply[0]) == "0":
pw.dlog(f"MGM calibration: API version 2 was not accepted")
return
2022-08-17 11:19:23 +02:00
if len(mgm_tuple) != 3:
pw.dlog(f"MGM tuple has invalid length {len(mgm_tuple)}")
2022-08-17 17:25:16 +02:00
mgm_list = [mgm / 1e6 for mgm in mgm_tuple]
2022-08-17 11:19:23 +02:00
command = (
f"magnetometer_field {mgm_list[0]} {mgm_list[1]} {mgm_list[2]}\n".encode()
)
2022-08-17 15:24:39 +02:00
CALIBR_SOCKET.sendall(command)
reply = CALIBR_SOCKET.recv(1024)
if len(reply) != 2:
2022-08-18 11:09:35 +02:00
pw.dlog(
2022-12-02 17:53:42 +01:00
f"MGM calibration: Reply received command magnetometer_field has invalid "
f"length {len(reply)}"
2022-08-18 11:09:35 +02:00
)
2022-08-17 15:24:39 +02:00
return
else:
if str(reply[0]) == "0":
pw.dlog(f"MGM calibration: magnetmeter field format was not accepted")
return
pw.dlog(f"Sent data {mgm_list} to Helmholtz Testbench successfully")
2022-08-17 11:19:23 +02:00
except socket.timeout:
pw.dlog("Socket timeout")
2022-08-17 15:24:39 +02:00
except BlockingIOError as e:
pw.dlog(f"Error {e}")
except ConnectionResetError as e:
pw.dlog("Socket was closed")
2022-08-17 11:19:23 +02:00
except ConnectionRefusedError or OSError:
pw.dlog("Connecting to Calibration Socket on addrss {} failed")