fprime-gds 3.6.1__py3-none-any.whl → 4.0.0__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/adapters/uart.py

@@ -59,7 +59,7 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         4000000,
     ]
 
-    def __init__(self, device, baud):
+    def __init__(self, device, baud, skip_check):
         """
         Initialize the serial adapter using the default settings. This does not open the serial port, but sets up all
         the internal variables used when opening the device.
@@ -77,9 +77,14 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         Opens the serial port based on previously supplied settings. If the port is already open, then close it first.
         Then open the port up again.
         """
-        self.close()
-        self.serial = serial.Serial(self.device, self.baud)
-        return self.serial is not None
+        try:
+            self.close()
+            self.serial = serial.Serial(self.device, self.baud)
+            return self.serial is not None
+        except serial.serialutil.SerialException as exc:
+            LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
+            self.close()
+            return False
 
     def close(self):
         """
@@ -100,12 +105,11 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         :return: True, when data was sent through the UART. False otherwise.
         """
         try:
-            if self.serial is None:
-                self.open()
-            written = self.serial.write(frame)
-            # Not believed to be possible to not send everything without getting a timeout exception
-            assert written == len(frame)
-            return True
+            if self.serial is not None or self.open():
+                written = self.serial.write(frame)
+                # Not believed to be possible to not send everything without getting a timeout exception
+                assert written == len(frame)
+                return True
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -121,17 +125,16 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         """
         data = b""
         try:
-            if self.serial is None:
-                self.open()
-            # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
-            # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
-            # order to block this function while data is incoming.
-            self.serial.timeout = timeout
-            data = self.serial.read(1)  # Force a block for at least 1 character
-            while self.serial.in_waiting:
-                data += self.serial.read(
-                    self.serial.in_waiting
-                )  # Drain the incoming data queue
+            if self.serial is not None or self.open():                
+                # Read as much data as possible, while ensuring to block if no data is available at this time. Note: as much
+                # data is read as possible to avoid a long-return time to this call. Minimum data to read is one byte in
+                # order to block this function while data is incoming.
+                self.serial.timeout = timeout
+                data = self.serial.read(1)  # Force a block for at least 1 character
+                while self.serial.in_waiting:
+                    data += self.serial.read(
+                        self.serial.in_waiting
+                    )  # Drain the incoming data queue
         except serial.serialutil.SerialException as exc:
             LOGGER.warning("Serial exception caught: %s. Reconnecting.", (str(exc)))
             self.close()
@@ -161,6 +164,12 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
                 "default": 9600,
                 "help": "Baud rate of the serial device.",
             },
+            ("--uart-skip-port-check",): {
+                "dest": "skip_check",
+                "default": False,
+                "action": "store_true",
+                "help": "Skip checking that the port exists"
+            }
         }
 
     @classmethod
@@ -175,20 +184,20 @@ class SerialAdapter(fprime_gds.common.communication.adapters.base.BaseAdapter):
         return cls
 
     @classmethod
-    def check_arguments(cls, device, baud):
+    def check_arguments(cls, device, baud, skip_check):
         """
         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.
 
         :param args: arguments as dictionary
         """
-        ports = map(lambda info: info.device, list_ports.comports(include_links=True))
-        if device not in ports:
+        ports = list(map(lambda info: info.device, list_ports.comports(include_links=True)))
+        if not skip_check and device not in ports:
             msg = f"Serial port '{device}' not valid. Available ports: {ports}"
             raise ValueError(
                 msg
             )
-        # Note: baud rate may not *always* work. These are a superset
+        # Note: baud rate may not *always* work. These are a superset.
         try:
             baud = int(baud)
         except ValueError:

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