fprime-gds 4.0.0a2__py3-none-any.whl → 4.0.0a4__py3-none-any.whl

fprime_gds/common/communication/adapters/ip.py

@@ -50,13 +50,11 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
     both. This data is concatenated and returned up the stack for processing.
     """
 
-    # Interval to send a KEEPALIVE packet. None will turn off KEEPALIVE.
-    KEEPALIVE_INTERVAL = 0.500
     # Data to send out as part of the KEEPALIVE packet. Should not be null nor empty.
     KEEPALIVE_DATA = b"sitting well"
     MAXIMUM_DATA_SIZE = 4096
 
-    def __init__(self, address, port, server=True):
+    def __init__(self, address, port, server=True, keepalive_interval=0.5):
         """
         Initialize this adapter by creating a handler for UDP and TCP. A thread for the KEEPALIVE application packets
         will be created, if the interval is not none. Handlers are servers unless server=False.
@@ -64,7 +62,8 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         self.address = address
         self.port = port
         self.stop = False
-        self.keepalive = None
+        self.keepalive_thread = None
+        self.keepalive_interval = keepalive_interval
         self.tcp = TcpHandler(address, port, server=server)
         self.udp = UdpHandler(address, port, server=server)
         self.thtcp = None
@@ -91,11 +90,11 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
             self.thudp.daemon = True
             self.thudp.start()
             # Start up a keep-alive ping if desired. This will hit the TCP uplink, and die if the connection is down
-            if IpAdapter.KEEPALIVE_INTERVAL is not None:
-                self.keepalive = threading.Thread(
-                    target=self.th_alive, name="KeepCommAliveThread", args=[float(self.KEEPALIVE_INTERVAL)]
+            if self.keepalive_interval > 0.0:
+                self.keepalive_thread = threading.Thread(
+                    target=self.th_alive, name="KeepCommAliveThread", args=[self.keepalive_interval]
                 )
-                self.keepalive.start()
+                self.keepalive_thread.start()
         except (ValueError, TypeError) as exc:
             LOGGER.error(
                 f"Failed to start keep-alive thread. {type(exc).__name__}: {str(exc)}"
@@ -186,6 +185,12 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "default": True,
                 "help": "Run the IP adapter as the client (connects to FSW running TcpServer)",
             },
+            ("--keepalive-interval",): {
+                "dest": "keepalive_interval",
+                "type": float,
+                "default": 0.5000,
+                "help": "Keep alive packet interval. 0.0 = off, default = 0.5",
+            },
         }
 
     @classmethod
@@ -195,7 +200,7 @@ class IpAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         return cls
 
     @classmethod
-    def check_arguments(cls, address, port, server=True):
+    def check_arguments(cls, address, port, server=True, keepalive_interval=0.5):
         """
         Code that should check arguments of this adapter. If there is a problem with this code, then a "ValueError"
         should be raised describing the problem with these arguments.

fprime_gds/common/communication/ccsds/apid.py

@@ -0,0 +1,19 @@
+""" ccsds.apid: APID mapping functions for F´ data """
+from fprime_gds.common.utils.data_desc_type import DataDescType
+from fprime.common.models.serialize.numerical_types import U32Type
+
+class APID(object):
+    """ APID implementations """
+    #TODO: use the DataDescType configured by loading the dictionary
+
+    @classmethod
+    def from_type(cls, data_type: DataDescType):
+        """ Map from data description type to APID """
+        return data_type.value
+
+    @classmethod
+    def from_data(cls, data):
+        """ Map from data bytes to APID """
+        u32_type = U32Type()
+        u32_type.deserialize(data, offset=0)
+        return cls.from_type(DataDescType(u32_type.val))

fprime_gds/common/communication/ccsds/chain.py

@@ -0,0 +1,106 @@
+""" fprime_encryption.framing.chain: implementation of a chained framer/deframer """
+from abc import ABC, abstractmethod
+from functools import reduce
+from typing import Any, Dict, List, Type
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.common.communication.ccsds.space_data_link import SpaceDataLinkFramerDeframer
+from fprime_gds.common.communication.ccsds.space_packet import SpacePacketFramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin
+
+
+
+class ChainedFramerDeframer(FramerDeframer, ABC):
+    """ Framer/deframer that is a composite of chained framer/deframers
+
+    This Framer/Deframer will wrap a set of framer/deframers where the result of the frame and deframe options will pass
+    from one to the other subsequently. The order is specified via the framing path and deframing will use the reverse
+    order from specified.
+    """
+    def __init__(self, **kwargs):
+        """ Initialize the chained framer/deframer from a framing-ordered set of children """
+        frame_order_framer_deframers = [
+            composite(**self.get_argument_subset(composite, kwargs))
+            for composite in self.get_composites()
+        ]
+        self.framers = frame_order_framer_deframers[::1]
+        self.deframers = frame_order_framer_deframers[::-1]
+
+    @classmethod
+    @abstractmethod
+    def get_composites(cls) -> List[Type[FramerDeframer]]:
+        """ Return a list of composites 
+        Innermost FramerDeframer should be first in the list. """
+        raise NotImplementedError(f"Subclasses of {cls.__name__} must implement get_composites")
+
+    @staticmethod
+    def get_argument_subset(composite: Type[FramerDeframer], argument_dictionary: Dict[str, Any]) -> Dict[str, Any]:
+        """ Get an argument subset that is needed by composite
+
+        For the composite, find the set of arguments that is needed by this composite and pull those out of the complete
+        argument dictionary.
+
+        Args:
+            composite: class of a subtype of FramerDeframer
+            argument_dictionary: dictionary of all input arguments
+        """
+        if not hasattr(composite, "get_arguments"):
+            return {}
+        needed_arguments = composite.get_arguments()
+        needed_argument_destinations = [
+            description["destination"] if "destination" in description else
+                [dash_dash for dash_dash in flag if dash_dash.startswith("--")][0].lstrip("-").replace("-", "_")
+            for flag, description in needed_arguments.items()
+        ]
+        return {name: argument_dictionary[name] for name in needed_argument_destinations}
+
+    @classmethod
+    def get_arguments(cls):
+        """ Arguments to request from the CLI """
+        all_arguments = {}
+        for composite in cls.get_composites():
+            all_arguments.update(composite.get_arguments() if hasattr(composite, "get_arguments") else {})
+        return all_arguments
+
+    @classmethod
+    def check_arguments(cls, **kwargs):
+        """ Check arguments from the CLI """
+        for composite in cls.get_composites():
+            subset_arguments = cls.get_argument_subset(composite, kwargs)
+            if hasattr(composite, "check_arguments"):
+                composite.check_arguments(**subset_arguments)
+
+    def deframe(self, data, no_copy=False):
+        """ Deframe via a chain of children deframers """
+        packet = data[:] if not no_copy else data
+        remaining = None
+        discarded = b""
+
+        for deframer in self.deframers:
+            new_packet, new_remaining, new_discarded = deframer.deframe(packet, True)
+            discarded += new_discarded
+            remaining = new_remaining if remaining is None else remaining
+            packet = new_packet
+        return packet, remaining, discarded
+
+    def frame(self, data):
+        """ Frame via a chain of children framers """
+        return reduce(lambda framed_data, framer: framer.frame(framed_data), self.framers, data)
+
+
+@gds_plugin(FramerDeframer)
+class SpacePacketSpaceDataLinkFramerDeframer(ChainedFramerDeframer):
+    """ Space Data Link Protocol framing and deframing that has a data unit of Space Packets as the central """
+
+    @classmethod
+    def get_composites(cls) -> List[Type[FramerDeframer]]:
+        """ Return the composite list of this chain 
+        Innermost FramerDeframer should be first in the list. """
+        return [
+            SpacePacketFramerDeframer,
+            SpaceDataLinkFramerDeframer
+        ]
+
+    @classmethod
+    def get_name(cls):
+        """ Name of this implementation provided to CLI """
+        return "space-packet-space-data-link"

fprime_gds/common/communication/ccsds/space_data_link.py

@@ -0,0 +1,196 @@
+"""F Prime Framer/Deframer Implementation of the CCSDS Space Data Link (TC/TM) Protocols"""
+import sys
+import struct
+import copy
+
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin_implementation
+
+import crc
+
+
+class SpaceDataLinkFramerDeframer(FramerDeframer):
+    """CCSDS Framer/Deframer Implementation for the TC (uplink / framing) and TM (downlink / deframing)
+    protocols. This FramerDeframer is used for framing TC data for uplink and deframing TM data for downlink.
+    """
+
+    SEQUENCE_NUMBER_MAXIMUM = 256
+    TC_HEADER_SIZE = 5
+    TM_HEADER_SIZE = 6
+    TM_FIXED_FRAME_SIZE = 1024
+    TM_TRAILER_SIZE = 2
+    TC_TRAILER_SIZE = 2
+
+    # As per CCSDS standard, use CRC-16 CCITT config with init value
+    # all 1s and final XOR value of 0x0000
+    CRC_CCITT_CONFIG = crc.Configuration(
+        width=16,
+        polynomial=0x1021,
+        init_value=0xFFFF,
+        final_xor_value=0x0000,
+    )
+    CRC_CALCULATOR = crc.Calculator(CRC_CCITT_CONFIG)
+
+    def __init__(self, scid, vcid):
+        """ """
+        self.scid = scid
+        self.vcid = vcid
+        self.sequence_number = 0
+
+    def frame(self, data):
+        """Frame the supplied data in a TC frame"""
+        space_packet_bytes = data
+        # CCSDS TC protocol defines the length token as number of bytes in full frame, minus 1
+        # so we add to packet size the size of the header and trailer and subtract 1
+        length = (
+            len(space_packet_bytes) + self.TC_HEADER_SIZE + self.TC_TRAILER_SIZE - 1
+        )
+        assert length < (pow(2, 10) - 1), "Length too-large for CCSDS format"
+
+        # CCSDS TC Header:
+        #  2b -  00 - TF version number
+        #  1b - 0/1 - 0 enable FARM checks, 1 bypass FARM
+        #  1b - 0/1 - 0 = data (Type-D), 1 = control information (Type-C)
+        #  2b -  00 - Reserved
+        # 10b -  XX - Spacecraft id
+        #  6b -  XX - Virtual Channel ID
+        # 10b -  XX - Frame length
+        #  8b -  XX - Frame sequence number
+
+        # First 16 bits:
+        header_val1_u16 = (
+            (0 << 14) |  # TF version number (2 bits)
+            (1 << 13) |  # Bypass FARM (1 bit)
+            (0 << 12) |  # Type-D (1 bit)
+            (0 << 10) |  # Reserved (2 bits)
+            ((self.scid & 0x3FF))  # SCID (10 bits)
+        )
+        # Second 16 bits:
+        header_val2_u16 = (
+            ((self.vcid & 0x3F) << 10) |  # VCID (6 bits)
+            (length & 0x3FF)              # Frame length (10 bits)
+        )
+        # 8 bit sequence number - always 0 in bypass FARM mode
+        header_val3_u8 = 0
+        header_bytes = struct.pack(">HHB", header_val1_u16, header_val2_u16, header_val3_u8)
+        full_bytes_no_crc = header_bytes + space_packet_bytes
+        assert (
+            len(header_bytes) == self.TC_HEADER_SIZE
+        ), "CCSDS primary header must be 5 octets long"
+        assert len(full_bytes_no_crc) == self.TC_HEADER_SIZE + len(
+            data
+        ), "Malformed packet generated"
+
+        full_bytes = full_bytes_no_crc + struct.pack(
+            ">H", self.CRC_CALCULATOR.checksum(full_bytes_no_crc)
+        )
+        return full_bytes
+
+    def get_sequence_number(self):
+        """Get the sequence number and increment - used for TM deframing
+
+        This function will return the current sequence number and then increment the sequence number for the next round.
+
+        Return:
+            current sequence number
+        """
+        sequence = self.sequence_number
+        self.sequence_number = (self.sequence_number + 1) % self.SEQUENCE_NUMBER_MAXIMUM
+        return sequence
+
+    def deframe(self, data, no_copy=False):
+        """Deframe TM frames"""
+        discarded = b""
+        if not no_copy:
+            data = copy.copy(data)
+        # Continue until there is not enough data for the header, or until a packet is found (return)
+        while len(data) >= self.TM_FIXED_FRAME_SIZE:
+            # Read header information
+            sc_and_channel_ids = struct.unpack_from(">H", data)
+            spacecraft_id = (sc_and_channel_ids[0] & 0x3FF0) >> 4
+            virtual_channel_id = (sc_and_channel_ids[0] & 0x000E) >> 1
+            # Check if the header is correct with regards to expected spacecraft and VC IDs
+            if spacecraft_id != self.scid or virtual_channel_id != self.vcid:
+                # If the header is invalid, rotate away a Byte and keep processing
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            # Spacecraft ID and Virtual Channel ID match, so we look at end of frame for CRC
+            crc_offset = self.TM_FIXED_FRAME_SIZE - self.TM_TRAILER_SIZE
+            transmitted_crc = struct.unpack_from(">H", data, crc_offset)[0]
+            if transmitted_crc == self.CRC_CALCULATOR.checksum(data[:crc_offset]):
+                # CRC is valid, so we return the deframed data
+                deframed_data_len = (
+                    self.TM_FIXED_FRAME_SIZE
+                    - self.TM_TRAILER_SIZE
+                    - self.TM_HEADER_SIZE
+                )
+                deframed = struct.unpack_from(
+                    f">{deframed_data_len}s", data, self.TM_HEADER_SIZE
+                )[0]
+                # Consume the fixed size frame
+                data = data[self.TM_FIXED_FRAME_SIZE :]
+                return deframed, data, discarded
+
+            print(
+                "[WARNING] Checksum validation failed.",
+                file=sys.stderr,
+            )
+            # Bad checksum, rotate 1 and keep looking for non-garbage
+            discarded += data[0:1]
+            data = data[1:]
+            continue
+        return None, data, discarded
+
+    @classmethod
+    def get_arguments(cls):
+        """Arguments to request from the CLI"""
+        return {
+            ("--scid",): {
+                "type": lambda input_arg: int(input_arg, 0),
+                "help": "Spacecraft ID",
+                "default": 0x44,
+                "required": False,
+            },
+            ("--vcid",): {
+                "type": lambda input_arg: int(input_arg, 0),
+                "help": "Virtual channel ID",
+                "default": 1,
+                "required": False,
+            },
+        }
+
+    @classmethod
+    def check_arguments(cls, scid, vcid):
+        """Check arguments from the CLI
+
+        Confirms that the input arguments are valid for this framer/deframer.
+
+        Args:
+            scid: spacecraft id
+            vcid: virtual channel id
+        """
+        if scid is None:
+            raise TypeError(f"Spacecraft ID not specified")
+        if scid < 0:
+            raise TypeError(f"Spacecraft ID {scid} is negative")
+        if scid > 0x3FF:
+            raise TypeError(f"Spacecraft ID {scid} is larger than {0x3FF}")
+
+        if vcid is None:
+            raise TypeError(f"Virtual Channel ID not specified")
+        if vcid < 0:
+            raise TypeError(f"Virtual Channel ID {vcid} is negative")
+        if vcid > 0x3F:
+            raise TypeError(f"Virtual Channel ID {vcid} is larger than {0x3FF}")
+
+    @classmethod
+    def get_name(cls):
+        """Name of this implementation provided to CLI"""
+        return "raw-space-data-link"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_framing_plugin(cls):
+        """Register the MyPlugin plugin"""
+        return cls

fprime_gds/common/communication/ccsds/space_packet.py

@@ -0,0 +1,129 @@
+"""F Prime Framer/Deframer Implementation of the CCSDS Space Packet Protocol"""
+
+from __future__ import annotations
+
+import struct
+import copy
+
+from spacepackets.ccsds.spacepacket import SpacePacketHeader, PacketType, SpacePacket
+
+from fprime_gds.common.communication.framing import FramerDeframer
+from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin
+from fprime_gds.common.utils.data_desc_type import DataDescType
+
+from .apid import APID
+import logging
+
+LOGGER = logging.getLogger("framing")
+
+
+@gds_plugin(FramerDeframer)
+class SpacePacketFramerDeframer(FramerDeframer):
+    """Concrete implementation of FramerDeframer supporting SpacePacket protocol
+
+    This implementation is registered as a "framing" plugin to support encryption within the GDS layer.
+    """
+
+    SEQUENCE_COUNT_MAXIMUM = 16384  # 2^14
+    HEADER_SIZE = 6
+    IDLE_APID = 0x7FF  # max 11 bit value per protocol specification
+
+    def __init__(self):
+        # self.sequence_number = 0
+        # Map APID to sequence counts
+        self.apid_to_sequence_count_map = dict()
+        for key in DataDescType:
+            self.apid_to_sequence_count_map[key.value] = 0
+
+    def frame(self, data):
+        """Frame the supplied data in Space Packet"""
+        # The protocol defines length token to be number of bytes minus 1
+        data_length_token = len(data) - 1
+        apid = APID.from_data(data)
+        space_header = SpacePacketHeader(
+            packet_type=PacketType.TC,
+            apid=apid,
+            seq_count=self.get_sequence_count(apid),
+            data_len=data_length_token,
+        )
+        space_packet = SpacePacket(space_header, sec_header=None, user_data=data)
+        return space_packet.pack()
+
+    def deframe(self, data, no_copy=False):
+        """Deframe the supplied data according to Space Packet protocol"""
+        discarded = b""
+        if data is None:
+            return None, None, discarded
+        if not no_copy:
+            data = copy.copy(data)
+        # Deframe all packets until there is not enough data for a header
+        while len(data) >= self.HEADER_SIZE:
+            # Read header information including start token and size and check if we have enough for the total size
+            try:
+                sp_header = SpacePacketHeader.unpack(data)
+            except ValueError:
+                # If the header is invalid, rotate away a byte and keep processing
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            if sp_header.ccsds_version != 0 or sp_header.packet_type != PacketType.TM:
+                # Space Packet version is specified as 0 per protocol
+                discarded += data[0:1]
+                data = data[1:]
+                continue
+            # Skip Idle Packets as they are not meaningful
+            if sp_header.apid == self.IDLE_APID:
+                data = data[sp_header.packet_len :]
+                continue
+            # Check sequence count and warn if not expected value (don't drop the packet)
+            if sp_header.seq_count != self.get_sequence_count(sp_header.apid):
+                LOGGER.warning(
+                    f"APID {sp_header.apid} received sequence count: {sp_header.seq_count}"
+                    f" (expected: {self.get_sequence_count(sp_header.apid)})"
+                )
+                # Set the sequence count to the next expected value (consider missing packets have been lost)
+                self.apid_to_sequence_count_map[sp_header.apid] = (
+                    sp_header.seq_count + 1
+                )
+            # If the pool is large enough to read the whole packet, then read it
+            if len(data) >= sp_header.packet_len:
+                deframed = struct.unpack_from(
+                    # data_len is number of bytes minus 1 per SpacePacket spec
+                    f">{sp_header.data_len + 1}s",
+                    data,
+                    self.HEADER_SIZE,
+                )[0]
+                data = data[sp_header.packet_len :]
+                LOGGER.debug(f"Deframed packet: {sp_header}")
+                return deframed, data, discarded
+            else:
+                # If we don't have enough data, then break out of the loop
+                break
+        return None, data, discarded
+
+    def get_sequence_count(self, apid: int):
+        """Get the sequence number and increment
+
+        This function will return the current sequence number and then increment the sequence number for the next round.
+        Should an APID not be registered already, it will be initialized to 0.
+
+        Return:
+            current sequence number
+        """
+        # If APID is not registered, initialize it to 0
+        sequence = self.apid_to_sequence_count_map.get(apid, 0)
+        self.apid_to_sequence_count_map[apid] = (
+            sequence + 1
+        ) % self.SEQUENCE_COUNT_MAXIMUM
+        return sequence
+
+    @classmethod
+    def get_name(cls):
+        """Name of this implementation provided to CLI"""
+        return "raw-space-packet"
+
+    @classmethod
+    @gds_plugin_implementation
+    def register_framing_plugin(cls):
+        """Register the MyPlugin plugin"""
+        return cls

fprime_gds/common/communication/framing.py

@@ -11,6 +11,8 @@ that implement this pattern. The current list of implementation classes are:
 
 @author lestarch
 """
+
+from __future__ import annotations
 import abc
 import copy
 import struct
@@ -18,7 +20,10 @@ import sys
 from typing import Type
 
 from .checksum import calculate_checksum, CHECKSUM_MAPPING
-from fprime_gds.plugin.definitions import gds_plugin_implementation, gds_plugin_specification
+from fprime_gds.plugin.definitions import (
+    gds_plugin_implementation,
+    gds_plugin_specification,
+)
 
 
 class FramerDeframer(abc.ABC):
@@ -28,7 +33,7 @@ class FramerDeframer(abc.ABC):
     """
 
     @abc.abstractmethod
-    def frame(self, data):
+    def frame(self, data: bytes) -> bytes:
         """
         Frames outgoing data in the specified format. Expects incoming raw bytes to frame, and adds on the needed header
         and footer bytes. This new array of bytes is returned from the method.
@@ -38,20 +43,27 @@ class FramerDeframer(abc.ABC):
         """
 
     @abc.abstractmethod
-    def deframe(self, data, no_copy=False):
+    def deframe(
+        self, data: bytes, no_copy=False
+    ) -> tuple[(bytes | None), bytes, bytes]:
         """
-        Deframes the incoming data from the specified format. Produces exactly one packet, and leftover bytes. Users
-        wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
+        Deframes the incoming data from the specified format. 
+        Produces:
+        - One packet, or None if no packet found
+        - leftover bytes (not consumed yet)
+        - Discarded data (consumed and determined not to be valid)
+
+        Users wanting all packets to be deframed should call "deframe_all". If no full packet is available, this method
         returns None. Expects incoming raw bytes to deframe, and returns a deframed packet or None, the leftover
         bytes that were unused, and any bytes discarded from the existing data stream. Will search and discard data up
         until a start token is found. Note: data will be consumed up to the first start token found.
 
         :param data: framed data bytes
         :param no_copy: (optional) will prevent extra copy if True, but "data" input will be destroyed.
-        :return: (packet as array of bytes or None, leftover bytes, any discarded data)
+        :return: (packet as bytes or None, leftover bytes, any discarded data)
         """
 
-    def deframe_all(self, data, no_copy):
+    def deframe_all(self, data: bytes, no_copy: bool):
         """
         Deframes all available packets found in a single set of bytes by calling deframe until a None packet is
         retrieved. This list of packets, and the remaining bytes are returned
@@ -66,11 +78,11 @@ class FramerDeframer(abc.ABC):
         discarded_aggregate = b""
         while True:
             # Deframe and return only on None
-            (packet, data, discarded) = self.deframe(data, no_copy=True)
+            (deframed, data, discarded) = self.deframe(data, no_copy=True)
             discarded_aggregate += discarded
-            if packet is None:
+            if deframed is None: # No more packets available, return aggregate
                 return packets, data, discarded_aggregate
-            packets.append(packet)
+            packets.append(deframed)
 
     @classmethod
     @gds_plugin_specification
@@ -117,7 +129,7 @@ class FpFramerDeframer(FramerDeframer):
     HEADER_FORMAT = None
     START_TOKEN = None
 
-    def __init__(self, checksum_type):
+    def __init__(self, checksum_type="crc32"):
         """Sets constants on construction."""
         # Setup the constants as soon as possible.
         FpFramerDeframer.set_constants()
@@ -197,13 +209,12 @@ class FpFramerDeframer(FramerDeframer):
                 )
                 # If the checksum is valid, return the packet. Otherwise continue to rotate
                 if check == calculate_checksum(
-                    data[: data_size + FpFramerDeframer.HEADER_SIZE],
-                    self.checksum
+                    data[: data_size + FpFramerDeframer.HEADER_SIZE], self.checksum
                 ):
                     data = data[total_size:]
                     return deframed, data, discarded
                 print(
-                    "[WARNING] Checksum validation failed. Have you correctly set '--comm-checksum-type'",
+                    "[WARNING] Checksum validation failed.",
                     file=sys.stderr,
                 )
                 # Bad checksum, rotate 1 and keep looking for non-garbage
@@ -216,29 +227,13 @@ class FpFramerDeframer(FramerDeframer):
 
     @classmethod
     def get_name(cls):
-        """ Get the name of this plugin """
+        """Get the name of this plugin"""
         return "fprime"
 
-    @classmethod
-    def get_arguments(cls):
-        """ Get arguments for the framer/deframer """
-        return {("--comm-checksum-type",): {
-            "dest": "checksum_type",
-            "action": "store",
-            "type": str,
-            "help": "Setup the checksum algorithm. [default: %(default)s]",
-            "choices": [
-                item
-                for item in CHECKSUM_MAPPING.keys()
-                if item != "default"
-            ],
-            "default": "crc32",
-        }}
-
     @classmethod
     @gds_plugin_implementation
     def register_framing_plugin(cls):
-        """ Register a bad plugin """
+        """Register a bad plugin"""
         return cls
 
 

fprime_gds/common/distributor/distributor.py

@@ -199,9 +199,10 @@ class Distributor(DataHandler):
             (length, data_desc, msg) = self.parse_raw_msg_api(raw_msg)
 
             data_desc_key = data_desc_type.DataDescType(data_desc).name
-
             for d in self.__decoders[data_desc_key]:
                 try:
                     d.data_callback(msg)
                 except DecodingException as dexc:
                     LOGGER.warning("Decoding error occurred: %s. Skipping.", dexc)
+            else:
+                LOGGER.warning("No decoder registered for: %s", data_desc_type.DataDescType(data_desc).name)

fprime_gds/common/loaders/pkt_json_loader.py

@@ -19,6 +19,10 @@ class PktJsonLoader(JsonLoader):
     SET_NAME = "name"
     MEMBERS = "members"
 
+    def get_packet_set_names(self, path):
+        """ Get the list of packet sets """
+        return [packet_set[self.SET_NAME] for packet_set in self.json_dict[self.PACKETS_FIELD]]
+
     def get_id_dict(self, path, packet_set_name: str, ch_name_dict: dict):
         if path in self.saved_dicts and packet_set_name in self.saved_dicts[path]:
             (id_dict, name_dict) = self.saved_dicts[path][packet_set_name]

fprime_gds/common/pipeline/dictionaries.py

@@ -128,8 +128,16 @@ class Dictionaries:
             msg = f"[ERROR] Dictionary '{dictionary}' does not exist."
             raise Exception(msg)
         # Check for packet specification
-        if self._metadata["dictionary_type"] == "json" and packet_set_name is not None:
+        if self._metadata["dictionary_type"] == "json":
             packet_loader = fprime_gds.common.loaders.pkt_json_loader.PktJsonLoader(dictionary)
+            if packet_set_name is None:
+                names = packet_loader.get_packet_set_names(None)
+                if len(names) == 0:
+                    self._packet_dict = None
+                    return
+                elif len(names) > 1:
+                    raise Exception("[ERROR] Multiple packet sets, must set --packet-set-name")
+                packet_set_name = names[0]
             self._packet_dict = packet_loader.get_id_dict(
                 None, packet_set_name, self._channel_name_dict
             )

fprime_gds/common/utils/data_desc_type.py

@@ -5,10 +5,13 @@ Defines an enumeration that represents each type of data packet that can be down
 """
 from enum import Enum
 
+
+# TODO: these values should be read from the dictionary instead of hardcoded here
+
 DataDescType = Enum(
     "DataDescType",
-    # Command packet type - incoming
     {
+        # Command packet type - incoming
         "FW_PACKET_COMMAND": 0,
         # Telemetry packet type - outgoing
         "FW_PACKET_TELEM": 1,
@@ -24,5 +27,7 @@ DataDescType = Enum(
         "FW_PACKET_HAND": 0xFE,
         # Unknown packet
         "FW_PACKET_UNKNOWN": 0xFF,
+        # Space Packet Idle APID
+        "CCSDS_SPACE_PACKET_IDLE_APID": 0x7FF,
     },
 )

fprime_gds/executables/cli.py

@@ -558,6 +558,7 @@ class IndividualPluginParser(BareArgumentParser):
                 for key, value in self.extract_arguments(arguments).items()
                 if key != self.disable_flag_destination
             }
+
             plugin_zero_argument_class = functools.partial(
                 self.plugin_class.get_implementor(), **plugin_arguments
             )

fprime_gds/plugin/system.py

@@ -218,6 +218,7 @@ class Plugins(object):
                 FramerDeframer,
                 FpFramerDeframer,
             )
+            from fprime_gds.common.communication.ccsds.chain import SpacePacketSpaceDataLinkFramerDeframer
             from fprime_gds.common.communication.adapters.base import (
                 BaseAdapter,
                 NoneAdapter,
@@ -233,7 +234,7 @@ class Plugins(object):
                 "framing": {
                     "class": FramerDeframer,
                     "type": PluginType.SELECTION,
-                    "built-in": [FpFramerDeframer],
+                    "built-in": [FpFramerDeframer, SpacePacketSpaceDataLinkFramerDeframer],
                 },
                 "communication": {
                     "class": BaseAdapter,

{fprime_gds-4.0.0a2.dist-info → fprime_gds-4.0.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a2
+Version: 4.0.0a4
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 
@@ -216,15 +216,15 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: License :: OSI Approved :: Apache Software License
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: NOTICE.txt
@@ -241,6 +241,8 @@ Requires-Dist: openpyxl>=3.0.10
 Requires-Dist: pyserial>=3.5
 Requires-Dist: pydantic>=2.6
 Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: spacepackets>=0.28.0
+Requires-Dist: crc>=7.0.0
 Dynamic: license-file
 
 # F´ GDS

{fprime_gds-4.0.0a2.dist-info → fprime_gds-4.0.0a4.dist-info}/RECORD

@@ -7,13 +7,18 @@ fprime_gds/common/transport.py,sha256=uYXWkM8TYEYz1vfY4AEn0PF8Gu4tkYmJ5t4w1YY1yW
 fprime_gds/common/zmq_transport.py,sha256=E_iBZ5sA4JKB99MWSOM6XnPrO-mbFyRvD9eQp9te6-Y,12397
 fprime_gds/common/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/communication/checksum.py,sha256=f6W0Tr68U-XGnFmysMqsFzoGYZVE8clKf-VIJja_1YM,741
-fprime_gds/common/communication/framing.py,sha256=TPpVn5JfGJxdc9BuKJzm5LXo6OQKtkSqX695UdN-Ezk,12915
+fprime_gds/common/communication/framing.py,sha256=GnEUgHiTc0dEJ3coaVmcA03NXk8ehHfPaywB7hNnoO8,12658
 fprime_gds/common/communication/ground.py,sha256=9SD3AoyHA43yNE8UYkWnu5nEJt1PgyB3sU3QLDc4eDY,3619
 fprime_gds/common/communication/updown.py,sha256=UhfCIIA2eM5g2FsIhOGJJH6HzHurUPgcKIJ5fsLb2lE,9888
 fprime_gds/common/communication/adapters/__init__.py,sha256=ivGtzUTqhBYuve5mhN9VOHITwgZjNMVv7sxuac2Ll3c,470
 fprime_gds/common/communication/adapters/base.py,sha256=i3mf4HC-4tuf4mNkhdXCKlngRhODyTriia2pw6XBoSQ,3393
-fprime_gds/common/communication/adapters/ip.py,sha256=vCDclpsb3rVRXSxKqdt9UfkM2M6oCxnsKdzbzhMc0kM,17074
+fprime_gds/common/communication/adapters/ip.py,sha256=vxSGbxQYNCC4M0Zp0wvA7VTwsDFQ0i6uqRuOHks1ibA,17322
 fprime_gds/common/communication/adapters/uart.py,sha256=5WkA8xpQ8E7nv2DbN168fibz1l-GddJUKnf6Hcd4hvU,7194
+fprime_gds/common/communication/ccsds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fprime_gds/common/communication/ccsds/apid.py,sha256=Y5K_xHLo1bmpxOlkt-TSLulCXbKIQrbYfa3GXhadqEE,686
+fprime_gds/common/communication/ccsds/chain.py,sha256=Rkhls55BUwFU0cMlRMY183hlFpfqidQJ9ZUE1kdfi38,4637
+fprime_gds/common/communication/ccsds/space_data_link.py,sha256=pDi1JpmYBuKGsDgTX80Wp8PU_CDtDPtkzdnX1FXN5eM,7385
+fprime_gds/common/communication/ccsds/space_packet.py,sha256=27phwn8MfBFfdjS5Vl0Lfe38xfss6xSZnxGkJcQa92g,5190
 fprime_gds/common/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/ch_data.py,sha256=RP9zSyzNcH0nJ3MYyW_IATnmnHYZ6d0KmoJUJantdBI,6111
@@ -30,7 +35,7 @@ fprime_gds/common/decoders/event_decoder.py,sha256=BH1Q_489ZgBhqMutG-WwMGikpXsqi
 fprime_gds/common/decoders/file_decoder.py,sha256=Ky2U8bli3YL6GbT9jSSvI73ySOtf0cdZLK4FXTuWjfA,2542
 fprime_gds/common/decoders/pkt_decoder.py,sha256=kW8k3OSbMy96w6MzsGWp656lAQvwxrIznWkD3Sbi8Ig,3329
 fprime_gds/common/distributor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/distributor/distributor.py,sha256=aQ9zAQJJot9MCllEoCuEK4ILTKEsBMYFBufTTzUtca0,7791
+fprime_gds/common/distributor/distributor.py,sha256=KMQcr4fFncDewCMAUR64Yy5OIRdF2CCzmfGNE5J6wIY,7917
 fprime_gds/common/encoders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/encoders/ch_encoder.py,sha256=TBrTJ7TK4WwCh6KAspozh63WcPxrMImloB8tz7qeulw,2878
 fprime_gds/common/encoders/cmd_encoder.py,sha256=5wG5854ozmxctnYou3q9MdQNkTQEmpCiT4oBVgNRZdE,3499
@@ -69,7 +74,7 @@ fprime_gds/common/loaders/event_json_loader.py,sha256=DPVJQ1wIY3r13rxTWrE9n7i6kS
 fprime_gds/common/loaders/event_xml_loader.py,sha256=Q3Vm7ROTVgolSp5umkNMp0Eh95sir6ZAyAegrSjkiis,2875
 fprime_gds/common/loaders/fw_type_json_loader.py,sha256=Ybtfv0jNnzcTrnmFfi6EujAbLlA4Oocj3EMFBVRXlCM,2048
 fprime_gds/common/loaders/json_loader.py,sha256=YTvNkVRbaeDAKDs79J5RV7Z8zeO7x0_a8aIz5KLq9rA,9300
-fprime_gds/common/loaders/pkt_json_loader.py,sha256=ZTNNeZymdA3G3r7XFO4S7sCYzfMnk4-XRyuOeudwNzM,4897
+fprime_gds/common/loaders/pkt_json_loader.py,sha256=OuHYXE0FP33oAh0z6AScUdLgFg9VzXI8rqPJz5pdTdw,5080
 fprime_gds/common/loaders/pkt_xml_loader.py,sha256=ZS4qchqQnIBx0Tw69ehP8yqm1g_uYSQzmnijR3FxqJg,4795
 fprime_gds/common/loaders/prm_json_loader.py,sha256=YCSg3PhVsJTD1FgY_h0i8wV3TNikcZSrczHCzrTM6JM,2896
 fprime_gds/common/loaders/xml_loader.py,sha256=8AlTTHddJbJqUr6St-zJI8CTqoPuCNtNoRBmdwCorcg,14820
@@ -84,7 +89,7 @@ fprime_gds/common/models/common/event.py,sha256=gSFrCJT9ZddGJfkf3fGCCqk0aMIQV-SN
 fprime_gds/common/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/parsers/seq_file_parser.py,sha256=6DZrA0jmt8IqsutfK7pdLtYn4oVHO593rWgAOH63yRg,9587
 fprime_gds/common/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/pipeline/dictionaries.py,sha256=CfK1umDA3Kg9YEwNu9Tp_iIWjQMdeXqOddpxBfUqXx8,7586
+fprime_gds/common/pipeline/dictionaries.py,sha256=oZwRhGsrSRt9ptlMkUKsbFbxgoumE7MXwf0xkq1dKCg,7943
 fprime_gds/common/pipeline/encoding.py,sha256=PttJ8NmXm75mLXyhlmxOJqE8RFt46q1dThaV19PyAr4,7216
 fprime_gds/common/pipeline/files.py,sha256=J2zm0sucvImtmSnv0iUp5uTpvUO8nlmz2lUdMuMC5aM,2244
 fprime_gds/common/pipeline/histories.py,sha256=7KyboNnm9OARQk4meVPSSeYpeqH0G8RWRiy0BLBL1rw,3671
@@ -107,12 +112,12 @@ fprime_gds/common/tools/params.py,sha256=htnMLlUW9HmBo4Qc7kYhnWr1sO6bK2mckdskLt5
 fprime_gds/common/tools/seqgen.py,sha256=O57igktjWku5OJhBqezhCjPYUmh4GZM-9qKCChqEW7g,6034
 fprime_gds/common/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/utils/config_manager.py,sha256=EurtNdApA9zpIjAXmGSTgFUen0UaVDryH5g9LwMhu1E,5539
-fprime_gds/common/utils/data_desc_type.py,sha256=9GV8hV5q1dDxdfF-1-Wty5MBrFd94EbZ8hpHHkBJKuo,715
+fprime_gds/common/utils/data_desc_type.py,sha256=0AkEMfEa5refd_moovf1hkgKiNakADRzv4soghvf9a4,883
 fprime_gds/common/utils/event_severity.py,sha256=7qPXHrDaM_REJ7sKBUEJTZIE0D4qVnVajsPDUuHg7sI,300
 fprime_gds/common/utils/string_util.py,sha256=u_2iahRG3ROu3lAAt_KVcK226gEByElXqrA8mH8eDpI,3584
 fprime_gds/executables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/executables/apps.py,sha256=iyHloLaHJOkcZF6O3oXZX6YpoS2SBBZVPilf25l0Q98,13138
-fprime_gds/executables/cli.py,sha256=7tqSMgFTSb20g9iMb02LOWrTYhePhX8Qe2kPZCzvquI,50381
+fprime_gds/executables/cli.py,sha256=aNO8saIKuTDQMwWNFlrpIL5HuwIWWei94Wxf3G0lY3k,50382
 fprime_gds/executables/comm.py,sha256=08rO0o0MJgTRngB7Ygu2IL_gEAWKF7WFvFyro1CqReE,5214
 fprime_gds/executables/data_product_writer.py,sha256=aXnQ75hQ8bapz-sr21mrPCrXIfqQblfBuB49GGZrFLg,34965
 fprime_gds/executables/fprime_cli.py,sha256=CMoT7zWNwM8h2mSZW03AR96wl_XnZXoLNiOZN_sDi38,12431
@@ -232,11 +237,11 @@ fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff,sha256=P200iM9lN0
 fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff2,sha256=mDS4KtJuKjdYPSJnahLdLrD-fIA1aiEU0NsaqLOJlTc,78268
 fprime_gds/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/plugin/definitions.py,sha256=QlxW1gNvoiqGMslSJjh3dTFZuv0igFHawN__3XJ0Wns,5355
-fprime_gds/plugin/system.py,sha256=UiNrUqfi-KJOgRIOR8uyFMKdquSPZh_txpNq8eH35-Y,13285
-fprime_gds-4.0.0a2.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-4.0.0a2.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-4.0.0a2.dist-info/METADATA,sha256=8DZ3LB73jYM-qOHVEWFVzK_R2pfh18gkk1zWK0LIHhE,24486
-fprime_gds-4.0.0a2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fprime_gds-4.0.0a2.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
-fprime_gds-4.0.0a2.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-4.0.0a2.dist-info/RECORD,,
+fprime_gds/plugin/system.py,sha256=M9xb-8jBhCUUx3X1z2uAP8Wx_v6NkL8JeaFgGcMnQqY,13432
+fprime_gds-4.0.0a4.dist-info/licenses/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-4.0.0a4.dist-info/licenses/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-4.0.0a4.dist-info/METADATA,sha256=RAq6BEVxVXtPSIGAg-p23Xd4Zdww9JEHJzeO8imSsLc,24549
+fprime_gds-4.0.0a4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fprime_gds-4.0.0a4.dist-info/entry_points.txt,sha256=qFBHIR7CZ5CEeSEdZ-ZVQN9ZfUOZfm0PvvDZAAheuLk,445
+fprime_gds-4.0.0a4.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-4.0.0a4.dist-info/RECORD,,