Add Command Responses (#523)

# Purpose
This PR closes #508 and #528.
This PR adds a command response flow to the app with an additional
command called `CMD_I2C_PROBE`

# New Changes
- Refactored `downlink_encoder.c` to support sending command responses
- Added command responses to the bootloaders
- Updated `app_update.py` to support bootloader command responses
- Implemented command parsing callbacks and classes on python side
- Implemented `packCmdResponse` and `unpackCmdResponse`
- Changed the C++ tests for command responses to reflect the new updates
to the command response infrastructure.
- Implemented python side for command responses with command response
classes and callbacks
- Fixed a ground station cli bug where a help command would exit the
program

# Testing
Explain tests that you ran to verify code functionality.
- [x] I have unit-tested this PR. Otherwise, explain why it cannot be
unit-tested.
- [x] I have tested this PR on a board if the code will run on a board
(Only required for firmware developers).
- [x] I have tested this PR by running the ARO website (Only required if
the code will impact the ARO website).
- [x] I have tested this PR by running the MCC website (Only required if
the code will impact the MCC website).
- [ ] I have included screenshots of the tests performed below.

# Outstanding Changes
 - [x] Add command responses to bootloader once #431 is merged
 - Investigate 'COMMAND_I2C_PROBE'
---------

Co-authored-by: Remote-Flashing-Orbital <flashing!>

Author: Adityya-K

gs/backend/ground_station_cli.py

@@ -6,6 +6,7 @@
 from serial import Serial, SerialException
 
 from gs.backend.obc_utils.command_utils import LOG_PATH, arg_parse, poll, send_command, send_conn_request
+from interfaces.obc_gs_interface.commands import CmdCallbackId
 
 
 class GroundStationShell(Cmd):
@@ -85,7 +86,10 @@ def do_send_command(self, line: str) -> None:
         if self.background_logging is not None:
             self.background_logging.kill()
 
-        send_command(line, self._com_port, 1)
+        cmd_response = send_command(line, self._com_port, 1)
+        print(cmd_response)
+        if cmd_response is not None and cmd_response.cmd_id == CmdCallbackId.CMD_EXEC_OBC_RESET:
+            self._conn_request_sent = False
 
         self._restart_logging()
 

gs/backend/obc_utils/command_utils.py

@@ -9,20 +9,29 @@
 from gs.backend.obc_utils.encode_decode import CommsPipeline
 from interfaces import (
     OBC_UART_BAUD_RATE,
+    RS_DECODED_DATA_SIZE,
 )
 from interfaces.command_framing import command_multi_pack
 from interfaces.obc_gs_interface.commands import (
     CmdCallbackId,
     CmdMsg,
+    CmdResponseErrorCode,
     create_cmd_downlink_logs_next_pass,
     create_cmd_downlink_telem,
+    create_cmd_download_data,
     create_cmd_end_of_frame,
+    create_cmd_erase_app,
     create_cmd_exec_obc_reset,
+    create_cmd_i2c_probe,
     create_cmd_mirco_sd_format,
     create_cmd_ping,
     create_cmd_rtc_sync,
+    create_cmd_set_programming_session,
     create_cmd_uplink_disc,
+    create_cmd_verify_crc,
 )
+from interfaces.obc_gs_interface.commands.command_response_callbacks import parse_command_response
+from interfaces.obc_gs_interface.commands.command_response_classes import CmdRes
 
 # This is a constant value set in the python and OBC side as to what length of I Frame the OBC will be waiting to
 # receive. This must be followed or the obc will not function as expected
@@ -31,7 +40,7 @@
 LOG_PATH: Path = (Path(__file__).parent / "../logs.log").resolve()
 
 
-def send_command(args: str, com_port: str, timeout: int = 0) -> Frame | None:
+def send_command(args: str, com_port: str, timeout: int = 0) -> CmdRes | type[CmdRes] | None:
     """
     A function to send a command up to the cube satellite and awaits a response
 
@@ -40,7 +49,7 @@ def send_command(args: str, com_port: str, timeout: int = 0) -> Frame | None:
     :return: A decoded frame if command is valid and has a response else None
     """
     # Using generate commands, we generate a command based on the arguments passed in
-    command = generate_command(args)
+    command, is_timetagged = generate_command(args)
 
     # We do a check to see if the arguments were properly passed in otherwise we return None
     if command is None:
@@ -76,6 +85,10 @@ def send_command(args: str, com_port: str, timeout: int = 0) -> Frame | None:
         start_index = read_bytes.find(b"\x7e")
         end_index = read_bytes.rfind(b"\x7e")
 
+        if command.id == CmdCallbackId.CMD_EXEC_OBC_RESET.value:
+            print(read_bytes)
+            return CmdRes(CmdCallbackId.CMD_EXEC_OBC_RESET, CmdResponseErrorCode.CMD_RESPONSE_SUCCESS, 0)
+
         # Check if a frame is what is sent back
         if start_index != -1:
             # These are all the bytes from other tasks that are not a part of the frame
@@ -89,10 +102,16 @@ def send_command(args: str, com_port: str, timeout: int = 0) -> Frame | None:
 
             rcv_frame = comms.decode_frame(rcv_frame_bytes)
             # TODO: Handle these return frames
-            return rcv_frame
+            if rcv_frame is not None and not is_timetagged:
+                return parse_command_response(rcv_frame.data[:RS_DECODED_DATA_SIZE])
+            else:
+                return None
+        elif is_timetagged:
+            print("Command is time tagged, enable and check logs for a response")
+            return None
         else:
             # TODO: Handle bootloader recieve
-            return None
+            return parse_command_response(read_bytes[:RS_DECODED_DATA_SIZE])
 
 
 def send_conn_request(com_port: str, timeout: int = 0) -> Frame:
@@ -174,7 +193,7 @@ def parse_cmd_rtc_time_sync() -> ArgumentParser:
     A function to parse the argument for the rtc_time_sync command
     """
     parent_parser = arg_parse()
-    parser = ArgumentParser(parents=[parent_parser], exit_on_error=False)
+    parser = ArgumentParser(parents=[parent_parser], add_help=False, exit_on_error=False)
     parser.add_argument(
         "-rtc",
         "--rtc_sync_time",
@@ -191,7 +210,7 @@ def parse_cmd_downlink_logs_next_pass() -> ArgumentParser:
     A function to parse the argument for the downlink_logs_next_pass command
     """
     parent_parser = arg_parse()
-    parser = ArgumentParser(parents=[parent_parser], exit_on_error=False)
+    parser = ArgumentParser(parents=[parent_parser], add_help=False, exit_on_error=False)
     parser.add_argument(
         "-lnp",
         "--log_next_pass",
@@ -206,7 +225,7 @@ def parse_cmd_downlink_logs_next_pass() -> ArgumentParser:
 # End of specific command parsers
 
 
-def generate_command(args: str) -> CmdMsg | None:
+def generate_command(args: str) -> tuple[CmdMsg | None, bool]:
     """
     A function that parsed command arguments and returns the corresponding command frame
 
@@ -219,6 +238,7 @@ def generate_command(args: str) -> CmdMsg | None:
     # These are a list of parsers for commands that require additional arguments
     # NOTE: Update this list when another command with a specific parser is required
     child_parsers = [parse_cmd_downlink_logs_next_pass, parse_cmd_rtc_time_sync]
+    is_timetagged = False
 
     # A list of Command factories for all commands
     # NOTE: Update these when a command is added and make sure to keep them in the order that the commands are described
@@ -232,6 +252,11 @@ def generate_command(args: str) -> CmdMsg | None:
         create_cmd_ping,
         create_cmd_downlink_telem,
         create_cmd_uplink_disc,
+        create_cmd_set_programming_session,
+        create_cmd_erase_app,
+        create_cmd_download_data,
+        create_cmd_verify_crc,
+        create_cmd_i2c_probe,
     ]
 
     # Loop through each of the specific parses and see if we get a valid parse on any of them
@@ -248,7 +273,7 @@ def generate_command(args: str) -> CmdMsg | None:
             command_enum = CmdCallbackId[command_args.command]
         except KeyError:
             print("Invalid Command")
-            return None
+            return None, False
 
         # We check how many arguments are in the parsed object and call functions accordingly.
         # This is the reason why it's important to use the arg1, arg2, arg3 naming convention when creating
@@ -266,25 +291,31 @@ def generate_command(args: str) -> CmdMsg | None:
             )
         elif hasattr(command_args, "arg1"):
             command = commmand_factories[command_enum.value](command_args.arg1, command_args.timestamp)
-        return command
+
+        if command_args.timestamp is not None and command_args.timestamp > 0:
+            is_timetagged = True
+        return command, is_timetagged
 
     parser = arg_parse()
     # If the command did not pass any of the specific parsers, we try the general one
     try:
         command_args = parser.parse_args(arguments)
     except ArgumentError:
         print("Invalid Commands")
-        return None
+        return None, False
 
     # Same thing as before, we try to convert to a CmdCallbackId Enum to see if the command if valid
     try:
         command_enum = CmdCallbackId[command_args.command]
     except KeyError:
         print("Invalid Command")
-        return None
+        return None, False
 
     command = commmand_factories[command_enum.value](command_args.timestamp)
-    return command
+
+    if command_args.timestamp is not None and command_args.timestamp > 0:
+        is_timetagged = True
+    return command, is_timetagged
 
 
 def poll(com_port: str, file_path: str | Path, timeout: int = 0, print_console: bool = False) -> None:
@@ -295,6 +326,9 @@ def poll(com_port: str, file_path: str | Path, timeout: int = 0, print_console:
     :param print_console: Whether the function should print to console or not. By default, this is set to False. This is
                           useful for the CLI where sometimes we want to print out the received logs from the board
     """
+
+    comms = CommsPipeline()
+
     with (
         Serial(
             com_port,
@@ -306,8 +340,31 @@ def poll(com_port: str, file_path: str | Path, timeout: int = 0, print_console:
         open(file_path, "a") as file,
     ):
         while True:
-            data = ser.read(10000).decode("utf-8")
-            file.write(data)
+            data = ser.read(100000)
+            start_index = data.find(b"\x7e")
+            end_index = data.rfind(b"\x7e")
+
+            # Check if a frame is in what is sent back
+            if start_index != -1:
+                # These are all the bytes from other tasks that are not a part of the frame
+                command_res = None
+                outer_bytes_left = data[:start_index]
+                outer_bytes_right = data[end_index + 1 :]
+
+                # Isolate the frame
+                rcv_frame_bytes = data[start_index : end_index + 1]
+
+                rcv_frame = comms.decode_frame(rcv_frame_bytes)
+                # TODO: Handle these return frames
+                if rcv_frame is not None and rcv_frame.data is not None:
+                    command_res = parse_command_response(bytes(rcv_frame.data[:RS_DECODED_DATA_SIZE]))
+
+                data_string = outer_bytes_left.decode("utf-8") + str(command_res) + outer_bytes_right.decode("utf-8")
+                print("Time Tagged Command Response:")
+            else:
+                data_string = data.decode("utf-8")
+
+            file.write(data_string)
             file.flush()
-            if print_console and len(data) != 0:
-                print(data)
+            if print_console and len(data_string) != 0:
+                print(data_string)

interfaces/obc_gs_interface/commands/__init__.py

@@ -3,7 +3,6 @@
     Structure,
     Union,
     c_bool,
-    c_float,
     c_uint,
     c_uint8,
     c_uint16,
@@ -13,7 +12,7 @@
 from enum import IntEnum
 from typing import Final
 
-from interfaces import MAX_CMD_MSG_SIZE, MAX_REPONSE_PACKED_SIZE, RS_DECODED_DATA_SIZE
+from interfaces import MAX_CMD_MSG_SIZE, RS_DECODED_DATA_SIZE
 from interfaces.obc_gs_interface import interface
 
 # ######################################################################
@@ -113,43 +112,24 @@ def __init__(self, unixtime_of_execution: int | None = None) -> None:
 # ######################################################################
 
 
-# NOTE: Just like the C implementation, this is a sample implementation. Add implemetnations as command responses are
-# made
-class ObcCmdResetResponse(Structure):
-    """
-    The python equivalent class for the obc_cmd_reset_response_t structure in the C implementation
-    NOTE: This is a sample
-    NOTE: This class uses floats which means it has floating point precision. This should not be a problem in most cases
-    """
-
-    _fields_ = [("data1", c_float), ("data2", c_uint32)]
-
-
-# NOTE: This only has the sample response so add more response structures as they get implemented to this union
-class _UR(Union):
-    """
-    The union needed to create the cmd_unpacked_response_t type in python
-    NOTE: Add response structures as they get implemented to this union
-    """
-
-    _fields_ = [("obcResetResponse", ObcCmdResetResponse)]
-
-
 # NOTE: No modifications to this class are necessary when adding new responses
-class CmdUnpackedReponse(Structure):
+class CmdResponseHeader(Structure):
     """
     The python equivalent class for the cmd_unpacked_response_t structure in the C implementation
     """
 
-    _anonymous_ = ("u",)
-    _fields_ = [("errCode", c_uint), ("cmdId", c_uint), ("u", _UR)]
+    _fields_ = [("cmdId", c_uint), ("errCode", c_uint), ("dataLen", c_uint8)]
 
 
-interface.packCommandResponse.argtypes = (POINTER(CmdUnpackedReponse), POINTER(c_uint8 * MAX_REPONSE_PACKED_SIZE))
-interface.packCommandResponse.restype = c_uint
+interface.packCmdResponse.argtypes = (POINTER(CmdResponseHeader), POINTER(c_uint8 * RS_DECODED_DATA_SIZE))
+interface.packCmdResponse.restype = c_uint
 
-interface.unpackCommandResponse.argtypes = (POINTER(c_uint8 * MAX_REPONSE_PACKED_SIZE), POINTER(CmdUnpackedReponse))
-interface.unpackCommandResponse.restype = c_uint
+interface.unpackCmdResponse.argtypes = (
+    POINTER(c_uint8 * RS_DECODED_DATA_SIZE),
+    POINTER(CmdResponseHeader),
+    POINTER(c_uint8 * RS_DECODED_DATA_SIZE),
+)
+interface.unpackCmdResponse.restype = c_uint
 
 
 # ######################################################################
@@ -178,7 +158,8 @@ class CmdCallbackId(IntEnum):
     CMD_ERASE_APP = 9
     CMD_DOWNLOAD_DATA = 10
     CMD_VERIFY_CRC = 11
-    NUM_CMD_CALLBACKS = 12
+    CMD_I2C_PROBE = 12
+    NUM_CMD_CALLBACKS = 13
 
 
 # Path to File: interfaces/obc_gs_interface/commands/obc_gs_commands_response.h
@@ -187,8 +168,8 @@ class CmdResponseErrorCode(IntEnum):
     Enums corresponding to the C implementation of the cmd_response_error_code_t
     """
 
-    CMD_RESPONSE_SUCCESS = 0
-    CMD_RESPONSE_ERROR = 1
+    CMD_RESPONSE_SUCCESS = 0x01
+    CMD_RESPONSE_ERROR = 0x7F
 
 
 class ProgrammingSession(IntEnum):
@@ -398,6 +379,20 @@ def create_cmd_verify_crc(unixtime_of_execution: int | None = None) -> CmdMsg:
     return cmd_msg
 
 
+def create_cmd_i2c_probe(unixtime_of_execution: int | None = None) -> CmdMsg:
+    """
+    Function to create a CmdMsg structure for CMD_I2C_PROBE
+
+    :param unixtime_of_execution: A time of when to execute a certain event,
+                                  by default, it is set to None (i.e. a specific
+                                  time is not needed)
+    :return: CmdMsg structure for CMD_I2C_PROBE
+    """
+    cmd_msg = CmdMsg(unixtime_of_execution)
+    cmd_msg.id = CmdCallbackId.CMD_I2C_PROBE
+    return cmd_msg
+
+
 # ######################################################################
 # ||                                                                  ||
 # ||             Command Pack and Unpack Implementations              ||
@@ -479,14 +474,14 @@ def unpack_command(cmd_msg_packed: bytes) -> tuple[list[CmdMsg], bytes]:
 # ######################################################################
 
 
-def pack_command_response(cmd_msg_response: CmdUnpackedReponse) -> bytes:
+def pack_command_response(cmd_msg_response: CmdResponseHeader) -> bytes:
     """
     This takes a command message reponse to pack it (see the C implementation for more on how that's exactly done)
 
     :param cmd_msg_response: A c-style structure that hold the unpacked command message response
     :return: Bytes of the packed commmand response
     """
-    buffer = (c_uint8 * MAX_REPONSE_PACKED_SIZE)(*([0] * MAX_REPONSE_PACKED_SIZE))
+    buffer = (c_uint8 * RS_DECODED_DATA_SIZE)(*([0] * RS_DECODED_DATA_SIZE))
     res = interface.packCommandResponse(pointer(cmd_msg_response), pointer(buffer))
 
     if res != 0:
@@ -495,24 +490,26 @@ def pack_command_response(cmd_msg_response: CmdUnpackedReponse) -> bytes:
     return bytes(buffer).rstrip(b"\x00")
 
 
-def unpack_command_response(cmd_msg_packed: bytes) -> CmdUnpackedReponse:
+def unpack_command_response(cmd_msg_packed: bytes) -> tuple[CmdResponseHeader, bytes]:
     """
     This takes in a bytes of data to be unpacked into a command response (see the C implementation for more on how
     that's exactly done)
 
     :param cmd_msg_packed: Bytes of an already encoded message
     :return: An unpacked command message in the form of a structure
     """
-    if len(cmd_msg_packed) > MAX_REPONSE_PACKED_SIZE:
+    if len(cmd_msg_packed) > RS_DECODED_DATA_SIZE:
         raise ValueError("The encoded command reponse data to unpack is too long")
 
     buffer_elements = list(cmd_msg_packed)
-    buff = (c_uint8 * MAX_REPONSE_PACKED_SIZE)(*buffer_elements)
-    cmd_msg_response = CmdUnpackedReponse()
+    buff = (c_uint8 * RS_DECODED_DATA_SIZE)(*buffer_elements)
+    data_buffer = (c_uint8 * RS_DECODED_DATA_SIZE)()
+    cmd_msg_response = CmdResponseHeader()
 
-    res = interface.unpackCommandResponse(pointer(buff), pointer(cmd_msg_response))
+    res = interface.unpackCmdResponse(pointer(buff), pointer(cmd_msg_response), pointer(data_buffer))
+    data_bytes = bytes(data_buffer)
 
     if res != 0:
         raise ValueError("Could not unpack command response. OBC Error Code: " + str(res))
 
-    return cmd_msg_response
+    return cmd_msg_response, data_bytes