cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/spw.py

@@ -1,1479 +0,0 @@
-"""
-This module defines classes and functions to work with SpaceWire packets.
-"""
-import logging
-import os
-import struct
-from enum import IntEnum
-from typing import Tuple
-from typing import Union
-
-import numpy as np
-
-from egse.bits import clear_bit
-from egse.bits import crc_calc
-from egse.bits import set_bit
-from egse.exceptions import Error
-from egse.setup import SetupError
-from egse.state import GlobalState
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-try:
-    _ = os.environ["PLATO_CAMERA_IS_EM"]
-    TWOS_COMPLEMENT_OFFSET = 32768 if _.capitalize() in ("1", "True", "Yes") else 0
-except KeyError:
-    TWOS_COMPLEMENT_OFFSET = 0
-
-# RMAP Error Codes and Constants -------------------------------------------------------------------
-
-RMAP_PROTOCOL_ID = 0x01
-RMAP_TARGET_LOGICAL_ADDRESS_DEFAULT = 0xFE
-RMAP_TARGET_KEY = 0xD1
-
-# Error and Status Codes
-
-RMAP_SUCCESS = 0
-RMAP_GENERAL_ERROR = 1
-RMAP_UNUSED_PACKET_TYPE_COMMAND_CODE = 2
-RMAP_INVALID_KEY = 3
-RMAP_INVALID_DATA_CRC = 4
-RMAP_EARLY_EOP = 5
-RMAP_TOO_MUCH_DATA = 6
-RMAP_EEP = 7
-RMAP_RESERVED = 8
-RMAP_VERIFY_BUFFER_OVERRUN = 9
-RMAP_NOT_IMPLEMENTED_AUTHORISED = 10
-RMAP_RMW_DATA_LENGTH_ERROR = 11
-RMAP_INVALID_TARGET_LOGICAL_ADDRESS = 12
-
-# Memory Map layout --------------------------------------------------------------------------------
-
-# NOTE: These memory areas are currently equal for N-FEE and F-FEE. Don't know if this will
-#       change in the future.
-
-CRITICAL_AREA_START = 0x0000_0000
-CRITICAL_AREA_END = 0x0000_00FC
-GENERAL_AREA_START = 0x0000_0100
-GENERAL_AREA_END = 0x0000_06FC
-HK_AREA_START = 0x0000_0700
-HK_AREA_END = 0x0000_07FC
-WINDOWING_AREA_START = 0x0080_0000
-WINDOWING_AREA_END = 0x00FF_FFFC
-
-class RMAPError(Error):
-    """An RMAP specific Error."""
-    pass
-
-
-class CheckError(RMAPError):
-    """
-    Raised when a check fails and you want to pass a status values along with the message.
-    """
-
-    def __init__(self, message, status):
-        self.message = message
-        self.status = status
-
-
-def update_transaction_identifier(tid: int) -> int:
-    """
-    Updates the transaction identifier and returns the new value.
-
-    FIXME: document more about this identifier, where is it used, when is it checked,
-           when does it need to be incremented, who initializes the identifier and
-           who updates it, ...
-
-    Args:
-        tid (int): The current transaction identifier
-
-    Returns:
-        the updated transaction identifier (int).
-    """
-    tid = (tid + 1) & 0xFFFF
-    return tid
-
-
-def create_rmap_read_request_packet(address: int, length: int, tid: int, strict: bool = True) -> bytes:
-    """
-    Creates an RMAP Read Request SpaceWire packet.
-
-    The read request is an RMAP command that read a number of bytes from the FEE register memory.
-
-    The function returns a ``ctypes`` character array (which is basically a bytes array) that
-    can be passed into the EtherSpaceLink library function ``esl_write_packet()``.
-
-    Address shall be within the 0x0000_0000 and 0x00FF_FFFC. The memory map (register) is divided
-    in the following areas:
-
-        0x0000_0000 - 0x0000_00FC   Critical Configuration Area (verified write)
-        0x0000_0100 - 0x0000_06FC   General Configuration Area (unverified write)
-        0x0000_0700 - 0x0000_07FC   Housekeeping area
-        0x0000_0800 - 0x007F_FFFC   Not Supported
-        0x0080_0000 - 0x00FF_FFFC   Windowing Area (unverified write)
-        0x0010_0000 - 0xFFFF_FFFC   Not Supported
-
-    All read requests to the critical area shall have a fixed data length of 4 bytes.
-    All read requests to a general area shall have a maximum data length of 256 bytes.
-    All read requests to the housekeeping area shall have a maximum data length of 256 bytes.
-    All read requests to the windowing area shall have a maximum data length of 4096 bytes.
-
-    The transaction identifier shall be incremented for each read request. This shall be done by
-    the calling function!
-
-    Args:
-        address (int): the FEE register memory address
-        length (int): the data length
-        tid (int): transaction identifier
-        strict (bool): perform strict checking of address and length
-
-    Returns:
-        a bytes object containing the full RMAP Read Request packet.
-    """
-
-    check_address_and_data_length(address, length, strict=strict)
-
-    buf = bytearray(16)
-
-    # NOTE: The first bytes would each carry the target SpW address or a destination port,
-    #       but this is not used for point-to-point connections, so we're safe.
-
-    buf[0] = 0x51  # Target N-FEE or F-FEE
-    buf[1] = 0x01  # RMAP Protocol ID
-    buf[2] = 0x4C  # Instruction: 0b1001100, RMAP Request, Read, Incrementing address, reply address
-    buf[3] = 0xD1  # Destination Key
-    buf[4] = 0x50  # Initiator is always the DPU
-    buf[5] = (tid >> 8) & 0xFF  # MSB of the Transition ID
-    buf[6] = tid & 0xFF  # LSB of the Transition ID
-    buf[7] = 0x00  # Extended address is not used
-    buf[8] = (address >> 24) & 0xFF  # address (MSB)
-    buf[9] = (address >> 16) & 0xFF  # address
-    buf[10] = (address >> 8) & 0xFF  # address
-    buf[11] = address & 0xFF  # address (LSB)
-    buf[12] = (length >> 16) & 0xFF  # data length (MSB)
-    buf[13] = (length >> 8) & 0xFF  # data length
-    buf[14] = length & 0xFF  # data length (LSB)
-    buf[15] = rmap_crc_check(buf, 0, 15) & 0xFF
-    return bytes(buf)
-
-
-def create_rmap_read_request_reply_packet(
-        instruction_field: int, tid: int, status: int, buffer: bytes, buffer_length: int) -> bytes:
-    """
-    Creates an RMAP Reply to a RMAP Read Request packet.
-
-    The function returns a ``ctypes`` character array (which is basically a bytes array) that
-    can be passed into the EtherSpaceLink library function ``esl_write_packet()``.
-
-    Args:
-        instruction_field (int): the instruction field of the RMAP read request packet
-        tid (int): the transaction identifier of the read request packet
-        status (int): the status field, 0 on success
-        buffer (bytes): the data that was read as indicated by the read request
-        buffer_length (int): the data length
-
-    Returns:
-        packet: a bytes object containing the full RMAP Reply packet.
-    """
-
-    buf = bytearray(12 + buffer_length + 1)
-
-    buf[0] = 0x50  # Initiator address N-DPU or F-DPU
-    buf[1] = 0x01  # RMAP Protocol ID
-    buf[2] = instruction_field & 0x3F  # Clear the command bit as this is a reply
-    buf[3] = status & 0xFF  # Status field: 0 on success
-    buf[4] = 0x51  # Target address is always the N-FEE or F-FEE
-    buf[5] = (tid >> 8) & 0xFF  # MSB of the Transition ID
-    buf[6] = tid & 0xFF  # LSB of the Transition ID
-    buf[7] = 0x00  # Reserved
-    buf[8] = (buffer_length >> 16) & 0xFF  # data length (MSB)
-    buf[9] = (buffer_length >> 8) & 0xFF  # data length
-    buf[10] = buffer_length & 0xFF  # data length (LSB)
-    buf[11] = rmap_crc_check(buf, 0, 11) & 0xFF  # Header CRC
-
-    # Note that we assume here that len(buffer) == buffer_length.
-
-    if len(buffer) != buffer_length:
-        MODULE_LOGGER.warning(
-            f"While creating an RMAP read reply packet, the length of the buffer ({len(buffer)}) "
-            f"not equals the buffer_length ({buffer_length})"
-        )
-
-    for idx, value in enumerate(buffer):
-        buf[12 + idx] = value
-
-    buf[12 + buffer_length] = rmap_crc_check(buffer, 0, buffer_length) & 0xFF  # data CRC
-
-    return bytes(buf)
-
-
-def create_rmap_verified_write_packet(address: int, data: bytes, tid: int) -> bytes:
-    """
-    Create an RMAP packet for a verified write request on the FEE. The length of the data is
-    by convention always 4 bytes and therefore not passed as an argument.
-
-    Args:
-        address: the start memory address on the FEE register map
-        data: the data to be written in the register map at address [4 bytes]
-        tid (int): transaction identifier
-
-    Returns:
-        packet: a bytes object containing the SpaceWire packet.
-    """
-
-    if len(data) < 4:
-        raise ValueError(
-            f"The data argument should be at least 4 bytes, but it is only {len(data)} bytes: {data=}.")
-
-    if address > CRITICAL_AREA_END:
-        raise ValueError("The address range for critical configuration is [0x00 - 0xFC].")
-
-    tid = update_transaction_identifier(tid)
-
-    # Buffer length is fixed at 24 bytes since the data length is fixed
-    # at 4 bytes (32 bit addressing)
-
-    buf = bytearray(21)
-
-    # The values below are taken from the PLATO N-FEE to N-DPU
-    # Interface Requirements Document [PLATO-DLR-PL-ICD-0010]
-
-    buf[0] = 0x51  # Logical Address
-    buf[1] = 0x01  # Protocol ID
-    buf[2] = 0x7C  # Instruction
-    buf[3] = 0xD1  # Key
-    buf[4] = 0x50  # Initiator Address
-    buf[5] = (tid >> 8) & 0xFF  # MSB of the Transition ID
-    buf[6] = tid & 0xFF  # LSB of the Transition ID
-    buf[7] = 0x00  # Extended address
-    buf[8] = (address >> 24) & 0xFF  # address (MSB)
-    buf[9] = (address >> 16) & 0xFF  # address
-    buf[10] = (address >> 8) & 0xFF  # address
-    buf[11] = address & 0xFF  # address (LSB)
-    buf[12] = 0x00  # data length (MSB)
-    buf[13] = 0x00  # data length
-    buf[14] = 0x04  # data length (LSB)
-    buf[15] = rmap_crc_check(buf, 0, 15) & 0xFF  # header CRC
-    buf[16] = data[0]
-    buf[17] = data[1]
-    buf[18] = data[2]
-    buf[19] = data[3]
-    buf[20] = rmap_crc_check(buf, 16, 4) & 0xFF  # data CRC
-
-    return bytes(buf)
-
-
-def create_rmap_unverified_write_packet(address: int, data: bytes, length: int, tid: int) -> bytes:
-    """
-    Create an RMAP packet for a unverified write request on the FEE.
-
-    Args:
-        address: the start memory address on the FEE register map
-        data: the data to be written in the register map at address
-        length: the length of the data
-        tid (int): transaction identifier
-
-    Returns:
-        packet: a bytes object containing the SpaceWire packet.
-    """
-
-    # We can only handle data for which the length >= the given length argument.
-
-    if len(data) < length:
-        raise ValueError(
-            f"The length of the data argument ({len(data)}) is smaller than "
-            f"the given length argument ({length})."
-        )
-
-    if len(data) > length:
-        MODULE_LOGGER.warning(
-            f"The length of the data argument ({len(data)}) is larger than "
-            f"the given length argument ({length}). The data will be truncated "
-            f"when copied into the packet."
-        )
-
-    if address <= CRITICAL_AREA_END:
-        raise ValueError(
-            f"The given address (0x{address:08X}) is in the range for critical configuration is "
-            f"[0x00 - 0xFC]. Use the verified write function for this."
-        )
-
-    tid = update_transaction_identifier(tid)
-
-    # Buffer length is fixed at 24 bytes since the data length
-    # is fixed at 4 bytes (32 bit addressing)
-
-    buf = bytearray(16 + length + 1)
-    offset = 0
-
-    buf[offset + 0] = 0x51  # Logical Address
-    buf[offset + 1] = 0x01  # Protocol ID
-    buf[offset + 2] = 0x6C  # Instruction
-    buf[offset + 3] = 0xD1  # Key
-    buf[offset + 4] = 0x50  # Initiator Address
-    buf[offset + 5] = (tid >> 8) & 0xFF  # MSB of the Transition ID
-    buf[offset + 6] = tid & 0xFF  # LSB of the Transition ID
-    buf[offset + 7] = 0x00  # Extended address
-    buf[offset + 8] = (address >> 24) & 0xFF  # address (MSB)
-    buf[offset + 9] = (address >> 16) & 0xFF  # address
-    buf[offset + 10] = (address >> 8) & 0xFF  # address
-    buf[offset + 11] = address & 0xFF  # address (LSB)
-    buf[offset + 12] = (length >> 16) & 0xFF  # data length (MSB)
-    buf[offset + 13] = (length >> 8) & 0xFF  # data length
-    buf[offset + 14] = length & 0xFF  # data length (LSB)
-    buf[offset + 15] = rmap_crc_check(buf, 0, 15) & 0xFF  # header CRC
-
-    offset += 16
-
-    for idx, value in enumerate(data):
-        buf[offset + idx] = value
-
-    buf[offset + length] = rmap_crc_check(buf, offset, length) & 0xFF  # data CRC
-
-    return bytes(buf)
-
-
-def create_rmap_write_request_reply_packet(instruction_field: int, tid: int, status: int) -> bytes:
-    buf = bytearray(8)
-
-    buf[0] = 0x50  # Initiator address N-DPU or F-DPU
-    buf[1] = 0x01  # RMAP Protocol ID
-    buf[2] = instruction_field & 0x3F  # Clear the command bit as this is a reply
-    buf[3] = status & 0xFF  # Status field: 0 on success
-    buf[4] = 0x51  # Target address is always the N-FEE or F-FEE
-    buf[5] = (tid >> 8) & 0xFF  # MSB of the Transition ID
-    buf[6] = tid & 0xFF  # LSB of the Transition ID
-    buf[7] = rmap_crc_check(buf, 0, 7) & 0xFF  # Header CRC
-
-    return bytes(buf)
-
-
-def check_address_and_data_length(address: int, length: int, strict: bool = True) -> None:
-    """
-    Checks the address and length in the range of memory areas used by the FEE.
-
-    The ranges are taken from the PLATO-DLR-PL-ICD-0010 N-FEE to N-DPU IRD.
-
-    Args:
-        address (int): the memory address of the FEE Register
-        length (int): the number of bytes requested
-        strict (bool): strictly apply the rules
-
-    Raises:
-        RMAPError: when address + length fall outside any specified area.
-    """
-
-    if not strict:
-        # All these restrictions have been relaxed on the N-FEE.
-        # We are returning here immediately instead of removing or commenting out the code.
-        # These reason is that we can then bring back restriction easier and gradually.
-
-        MODULE_LOGGER.warning(
-            "Address and data length checks have been disabled, because the N-FEE "
-            "does not enforce restrictions in the critical memory area.")
-        return
-
-    if length % 4:
-        raise RMAPError(
-            "The requested data length shall be a multiple of 4 bytes.", address, length
-        )
-
-    if address % 4:
-        raise RMAPError("The address shall be a multiple of 4 bytes.", address, length)
-
-    # Note that when checking the given data length, at the defined area end,
-    # we can still read 4 bytes.
-
-    if CRITICAL_AREA_START <= address <= CRITICAL_AREA_END:
-        if length != 4:
-            raise RMAPError(
-                "Read requests to the critical area have a fixed data length of 4 bytes.",
-                address, length
-            )
-    elif GENERAL_AREA_START <= address <= GENERAL_AREA_END:
-        if length > 256:
-            raise RMAPError(
-                "Read requests to the general area have a maximum data length of 256 bytes.",
-                address, length
-            )
-        if address + length > GENERAL_AREA_END + 4:
-            raise RMAPError(
-                "The requested data length for the general area is too large. "
-                "The address + length exceeds the general area boundaries.",
-                address, length
-            )
-
-    elif HK_AREA_START <= address <= HK_AREA_END:
-        if length > 256:
-            raise RMAPError(
-                "Read requests to the housekeeping area have a maximum data length of 256 bytes.",
-                address, length
-            )
-        if address + length > HK_AREA_END + 4:
-            raise RMAPError(
-                "The requested data length for the housekeeping area is too large. "
-                "The address + length exceeds the housekeeping area boundaries.",
-                address, length
-            )
-
-    elif WINDOWING_AREA_START <= address <= WINDOWING_AREA_END:
-        if length > 4096:
-            raise RMAPError(
-                "Read requests to the windowing area have a maximum data length of 4096 bytes.",
-                address, length
-            )
-        if address + length > WINDOWING_AREA_END + 4:
-            raise RMAPError(
-                "The requested data length for the windowing area is too large. "
-                "The address + length exceeds the windowing area boundaries.", address, length
-            )
-
-    else:
-        raise RMAPError("Register address for RMAP read requests is invalid.", address, length)
-
-
-class PacketType(IntEnum):
-    """Enumeration type that defines the SpaceWire packet type."""
-
-    DATA_PACKET = 0
-    OVERSCAN_DATA = 1
-    HOUSEKEEPING_DATA = 2  # N-FEE
-    DEB_HOUSEKEEPING_DATA = 2  # F-FEE
-    AEB_HOUSEKEEPING_DATA = 3  # F-FEE
-
-
-class DataPacketType:
-    """
-    Defines the Data Packet Field: Type, which is a bit-field of 16 bits.
-
-    Properties:
-      * value: returns the data type as an integer
-      * packet_type: the type of data packet, defined in PacketType enum.
-      * mode: the FEE mode, defined in n_fee_mode and f_fee_mode enum
-      * last_packet: flag which defines the last packet of a type in the current readout cycle
-      * ccd_side: 0 for E-side (left), 1 for F-side (right), see egse.fee.fee_side
-      * ccd_number: CCD number [0, 3]
-      * frame_number: the frame number after sync
-    """
-
-    def __init__(self, data_type: int = 0):
-        self._data_type: int = data_type
-        # self.n_fee_side = GlobalState.setup.camera.fee.ccd_sides.enum
-
-    @property
-    def value(self) -> int:
-        """Returns the data packet type as an int."""
-        return self._data_type
-
-    @property
-    def packet_type(self):
-        """Returns the packet type: 0 = data packet, 1 = overscan data, 2 = housekeeping packet."""
-        return self._data_type & 0b0011
-
-    @packet_type.setter
-    def packet_type(self, value):
-        if not 0 <= value < 3:
-            raise ValueError(f"Packet Type can only have the value 0, 1, or 2, {value=} given.")
-        x = self._data_type
-        for idx, bit in enumerate([0, 1]):
-            x = set_bit(x, bit) if value & (1 << idx) else clear_bit(x, bit)
-        self._data_type = x
-
-    @property
-    def mode(self) -> int:
-        return (self._data_type & 0b1111_0000_0000) >> 8
-
-    @mode.setter
-    def mode(self, value: int):
-        x = self._data_type
-        for idx, bit in enumerate([8, 9, 10, 11]):
-            x = set_bit(x, bit) if value & (1 << idx) else clear_bit(x, bit)
-        self._data_type = x
-
-    @property
-    def last_packet(self) -> bool:
-        return bool(self._data_type & 0b1000_0000)
-
-    @last_packet.setter
-    def last_packet(self, flag: bool):
-        self._data_type = set_bit(self._data_type, 7) if flag else clear_bit(self._data_type, 7)
-
-    @property
-    def ccd_side(self) -> int:
-        return (self._data_type & 0b0100_0000) >> 6
-
-    @ccd_side.setter
-    def ccd_side(self, value: int):
-        self._data_type = set_bit(self._data_type, 6) if value & 0b0001 else clear_bit(self._data_type, 6)
-
-    @property
-    def ccd_number(self) -> int:
-        return (self._data_type & 0b0011_0000) >> 4
-
-    @ccd_number.setter
-    def ccd_number(self, value):
-        x = self._data_type
-        for idx, bit in enumerate([4, 5]):
-            x = set_bit(x, bit) if value & (1 << idx) else clear_bit(x, bit)
-        self._data_type = x
-
-    @property
-    def frame_number(self) -> int:
-        return (self._data_type & 0b1100) >> 2
-
-    @frame_number.setter
-    def frame_number(self, value):
-        x = self._data_type
-        for idx, bit in enumerate([2, 3]):
-            x = set_bit(x, bit) if value & (1 << idx) else clear_bit(x, bit)
-        self._data_type = x
-
-    def __str__(self) -> str:
-        from egse.fee import n_fee_mode
-        n_fee_side = GlobalState.setup.camera.fee.ccd_sides.enum
-
-        return (
-            f"mode:{n_fee_mode(self.mode).name}, last_packet:{self.last_packet}, "
-            f"CCD side:{n_fee_side(self.ccd_side).name}, CCD number:{self.ccd_number}, "
-            f"Frame number:{self.frame_number}, Packet Type:{PacketType(self.packet_type).name}"
-        )
-
-
-def to_string(data: Union[DataPacketType]) -> str:
-    """Returns a 'user-oriented' string representation of the SpW DataPacketType.
-
-    The purpose of this function is to represent the N-FEE information in a user-oriented way.
-    That means for certain values that they will be converted into the form the a user understands
-    and that may be different or reverse from the original N-FEE definition. An example is the
-    CCD number which is different from the user perspective with respect to the N-FEE.
-
-    If any other object type is passed, the data.__str__() method will be returned without
-    processing or conversion.
-
-    Args:
-        data: a DataPacketType
-    """
-    from egse.fee import n_fee_mode
-    n_fee_side = GlobalState.setup.camera.fee.ccd_sides.enum
-
-    if isinstance(data, DataPacketType):
-        try:
-            ccd_bin_to_id = GlobalState.setup.camera.fee.ccd_numbering.CCD_BIN_TO_ID
-        except AttributeError:
-            raise SetupError("No entry in the setup for camera.fee.ccd_numbering.CCD_BIN_TO_ID")
-        return (
-            f"mode:{n_fee_mode(data.mode).name}, last_packet:{data.last_packet}, "
-            f"CCD side:{n_fee_side(data.ccd_side).name}, CCD number:"
-            f"{ccd_bin_to_id[data.ccd_number]}, "
-            f"Frame number:{data.frame_number}, Packet Type:{PacketType(data.packet_type).name}"
-        )
-    else:
-        return data.__str__()
-
-
-class DataPacketHeader:
-    """
-    Defines the header of a data packet.
-
-    The full header can be retrieved as a bytes object with the `data_as_bytes()` method.
-
-    Properties:
-      * logical_address: fixed value of  0x50
-      * protocol_id: fixed value of 0xF0
-      * length: length of the data part of the packet, i.e. the packet length - size of the header
-      * type: data packet type as defined by DataPacketType
-      * frame_counter:
-      * sequence_counter: a packet sequence counter per CCD
-    """
-    def __init__(self, header_data: bytes = None):
-        self.header_data = bytearray(
-            header_data or bytes([0x50, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
-
-        if len(self.header_data) != 10:
-            raise ValueError(f"The length of the header for a data packet shall be 10 bytes, "
-                             f"got {len(self.header_data)}.")
-
-        self.n_fee_side = GlobalState.setup.camera.fee.ccd_sides.enum
-
-    def data_as_bytes(self) -> bytes:
-        """Returns the full header as a bytes object."""
-        return bytes(self.header_data)
-
-    @property
-    def logical_address(self) -> int:
-        return self.header_data[0]
-
-    @logical_address.setter
-    def logical_address(self, value: int):
-        self.header_data[0] = value
-
-    @property
-    def protocol_id(self) -> int:
-        return self.header_data[1]
-
-    @protocol_id.setter
-    def protocol_id(self, value: int):
-        self.header_data[1] = value
-
-    @property
-    def length(self) -> int:
-        return int.from_bytes(self.header_data[2:4], byteorder='big')
-
-    @length.setter
-    def length(self, value: int):
-        self.header_data[2:4] = value.to_bytes(2, 'big')
-
-    @property
-    def type(self):
-        return int.from_bytes(self.header_data[4:6], byteorder='big')
-
-    @type.setter
-    def type(self, value: Union[int, bytes, DataPacketType]):
-        if isinstance(value, bytes):
-            self.header_data[4:6] = value
-        elif isinstance(value, DataPacketType):
-            self.header_data[4:6] = value.value.to_bytes(2, 'big')
-        else:
-            self.header_data[4:6] = value.to_bytes(2, 'big')
-
-    @property
-    def type_as_object(self):
-        return DataPacketType(self.type)
-
-    @property
-    def packet_type(self):
-        return self.type_as_object.packet_type
-
-    @packet_type.setter
-    def packet_type(self, value: int):
-        type_obj = self.type_as_object
-        type_obj.packet_type = value
-        self.type = type_obj
-
-    @property
-    def last_packet(self):
-        return self.type_as_object.last_packet
-
-    @last_packet.setter
-    def last_packet(self, flag: bool):
-        type_obj = self.type_as_object
-        type_obj.last_packet = flag
-        self.type = type_obj
-
-    @property
-    def frame_counter(self):
-        return int.from_bytes(self.header_data[6:8], byteorder='big')
-
-    @frame_counter.setter
-    def frame_counter(self, value):
-        self.header_data[6:8] = value.to_bytes(2, 'big')
-
-    @property
-    def sequence_counter(self):
-        return int.from_bytes(self.header_data[8:10], byteorder='big')
-
-    @sequence_counter.setter
-    def sequence_counter(self, value):
-        self.header_data[8:10] = value.to_bytes(2, 'big')
-
-    def as_dict(self):
-        from egse.fee import n_fee_mode
-
-        data_packet_type = DataPacketType(self.type)
-        return dict(
-            logical_address=f"0x{self.logical_address:02X}",
-            protocol_id=f"0x{self.protocol_id:02X}",
-            length=self.length,
-            type=f"0x{self.type:04X}",
-            frame_counter=self.frame_counter,
-            sequence_counter=self.sequence_counter,
-            packet_type=data_packet_type.packet_type,
-            frame_number=data_packet_type.frame_number,
-            ccd_number=data_packet_type.ccd_number,
-            ccd_side=self.n_fee_side(data_packet_type.ccd_side).name,
-            last_packet=data_packet_type.last_packet,
-            mode=n_fee_mode(data_packet_type.mode).name,
-        )
-
-
-class SpaceWirePacket:
-    """Base class for any packet transmitted over a SpaceWire cable."""
-
-    # these settings are used by this class and its sub-classes to configure the print options
-    # for the numpy arrays.
-
-    _threshold = 300  # sys.maxsize
-    _edgeitems = 10
-    _linewidth = 120
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        """
-        Args:
-            data: a bytes object or a numpy array of type np.uint8 (not enforced)
-        """
-        self._bytes = bytes(data)
-
-    def __repr__(self):
-        options = np.get_printoptions()
-        np.set_printoptions(
-            formatter={"int": lambda x: f"0x{x:02x}"},
-            threshold=self._threshold,
-            edgeitems=self._edgeitems,
-            linewidth=self._linewidth,
-        )
-        msg = f"{self.__class__.__name__}({self._bytes})"
-        np.set_printoptions(**options)
-        return msg
-
-    @property
-    def packet_as_bytes(self):
-        return self._bytes
-
-    @property
-    def packet_as_ndarray(self):
-        return np.frombuffer(self._bytes, dtype=np.uint8)
-
-    @property
-    def logical_address(self):
-        # TODO: what about a timecode, that has no logical address?
-        return self._bytes[0]
-
-    @property
-    def protocol_id(self):
-        # TODO: what about a timecode, that has no protocol id?
-        return self._bytes[1]
-
-    def header_as_bytes(self) -> bytes:
-        # TODO: what about timecode, this has no header, except maybe the first byte: 0x91
-        raise NotImplementedError
-
-    @staticmethod
-    def create_packet(data: Union[bytes, np.ndarray]):
-        """
-        Factory method that returns a SpaceWire packet of the correct type based on the information
-        in the header.
-        """
-        if TimecodePacket.is_timecode_packet(data):
-            return TimecodePacket(data)
-        if HousekeepingPacket.is_housekeeping_packet(data):
-            return HousekeepingPacket(data)
-        if DataDataPacket.is_data_data_packet(data):
-            return DataDataPacket(data)
-        if OverscanDataPacket.is_overscan_data_packet(data):
-            return OverscanDataPacket(data)
-        if WriteRequest.is_write_request(data):
-            return WriteRequest(data)
-        if WriteRequestReply.is_write_reply(data):
-            return WriteRequestReply(data)
-        if ReadRequest.is_read_request(data):
-            return ReadRequest(data)
-        if ReadRequestReply.is_read_reply(data):
-            return ReadRequestReply(data)
-        return SpaceWirePacket(data)
-
-
-class DataPacket(SpaceWirePacket):
-    """
-    Base class for proprietary SpaceWire data packets that are exchanged between FEE and DPU.
-
-    .. note::
-        This class should not be instantiated directly. Use the SpaceWirePacket.create_packet()
-        factory method or the constructors of one of the sub-classes of this DataPacket class.
-    """
-
-    DATA_HEADER_LENGTH = 10
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        """
-        Args:
-            data: a bytes object or a numpy array
-        """
-        if not self.is_data_packet(data):
-            raise ValueError(
-                f"Can not create a DataPacket from the given data {[f'0x{x:02x}' for x in data]}"
-            )
-
-        super().__init__(data)
-
-        if (data[2] == 0x00 and data[3] == 0x00) or len(data) == self.DATA_HEADER_LENGTH:
-            MODULE_LOGGER.warning(
-                f"SpaceWire data packet without data found, packet={[f'0x{x:02x}' for x in data]}"
-            )
-
-        self._length = (data[2] << 8) + data[3]
-
-        if len(data) != self._length + self.DATA_HEADER_LENGTH:
-            MODULE_LOGGER.warning(
-                f"The length of the data argument ({len(data)}) given to "
-                f"the constructor of {self.__class__.__name__} (or sub-classes) is inconsistent "
-                f"with the length data field ({self._length} + 10) in the packet header."
-            )
-            raise ValueError(
-                f"{self.__class__.__name__} header: data-length field ({self._length}) not "
-                f"consistent with packet length ({len(data)}). Difference should be "
-                f"{self.DATA_HEADER_LENGTH}."
-            )
-
-        self._type = DataPacketType((data[4] << 8) + data[5])
-        self._data = None  # lazy loading of data from self._bytes
-
-    @property
-    def length(self) -> int:
-        """Returns the data length in bytes.
-
-        .. note:: length == len(data_nd_array) * 2
-            This length property returns the length of the data area in bytes. This value is
-            taken  from the header of the data packet. If you want to compare this with the size
-            of the data_as_ndarray property, multiply the length by 2 because the data is 16-bit
-            integers, not bytes.
-
-        Returns:
-            the size of the data area of the packet in bytes.
-        """
-        return self._length
-
-    @property
-    def data_as_ndarray(self):
-        """
-        Returns the data from this data packet as a 16-bit integer Numpy array.
-
-        .. note::
-            The data has been converted from the 8-bit packet data into 16-bit integers. That
-            means the length of this data array will be half the length of the data field the
-            packet, i.e. ``len(data) == length // 2``.
-            The reason for this is that pixel data has a size of 16-bit.
-
-        .. todo::
-            check if the data-length of HK packets should also be a multiple of 16.
-
-        Returns:
-            data: Numpy array with the data from this packet (type is np.uint16)
-
-        """
-
-        # We decided to lazy load/construct the data array. The reason is that the packet may be
-        # created / transferred without the need to unpack the data field into a 16-bit numpy array.
-
-        if self._data is None:
-            # The data is in two's-complement. The most significant bit (msb) shall be inverted
-            # according to Sampie Smit. That is done in the following line where the msb in each
-            # byte on an even index is inverted.
-
-            # data = [toggle_bit(b, 7) if not idx % 2 else b for idx, b in enumerate(self._bytes)]
-            # data = bytearray(data)
-            # data_1 = np.frombuffer(data, offset=10, dtype='>u2')
-
-            # Needs further confirmation, but the following line should have the same effect as
-            # the previous three lines.
-            data_2 = np.frombuffer(self._bytes, offset=10, dtype='>i2') + TWOS_COMPLEMENT_OFFSET
-
-            # Test if the results are identical, left the code in until we are fully confident
-            # if diff := np.sum(np.cumsum(data_1 - data_2)):
-            #     MODULE_LOGGER.info(f"cumsum={diff}")
-
-            self._data = data_2.astype('uint16')
-        return self._data
-
-    @property
-    def data(self) -> bytes:
-        return self._bytes[10: 10 + self._length]
-
-    @property
-    def type(self) -> DataPacketType:
-        return self._type
-
-    @property
-    def frame_counter(self):
-        return (self._bytes[6] << 8) + self._bytes[7]
-
-    @property
-    def sequence_counter(self):
-        return (self._bytes[8] << 8) + self._bytes[9]
-
-    @property
-    def header(self) -> DataPacketHeader:
-        return DataPacketHeader(self.header_as_bytes())
-
-    def header_as_bytes(self):
-        return self._bytes[:10]
-
-    @classmethod
-    def is_data_packet(cls, data: np.ndarray) -> bool:
-        if len(data) < 10 or data[0] != 0x50 or data[1] != 0xF0:
-            return False
-        return True
-
-    def __str__(self):
-        options = np.get_printoptions()
-        np.set_printoptions(
-            formatter={"int": lambda x: f"0x{x:04x}"},
-            threshold=super()._threshold,
-            edgeitems=super()._edgeitems,
-            linewidth=super()._linewidth,
-        )
-        msg = (
-            f"{self.__class__.__name__}:\n"
-            f"  Logical Address = 0x{self.logical_address:02X}\n"
-            f"  Protocol ID = 0x{self.protocol_id:02X}\n"
-            f"  Length = {self.length}\n"
-            f"  Type = {self._type}\n"
-            f"  Frame Counter = {self.frame_counter}\n"
-            f"  Sequence Counter = {self.sequence_counter}\n"
-            f"  Data = \n{self.data}"
-        )
-        np.set_printoptions(**options)
-        return msg
-
-
-class DataDataPacket(DataPacket):
-    """Proprietary Data Packet for N-FEE and F-FEE CCD image data."""
-
-    @classmethod
-    def is_data_data_packet(cls, data: Union[bytes, np.ndarray]) -> bool:
-        if len(data) <= 10:
-            return False
-        if data[0] != 0x50:
-            return False
-        if data[1] != 0xF0:
-            return False
-        type_ = DataPacketType((data[4] << 8) + data[5])
-        if type_.packet_type == PacketType.DATA_PACKET:
-            return True
-        return False
-
-
-class OverscanDataPacket(DataPacket):
-    """Proprietary Overscan Data Packet for N-FEE and F-FEE CCD image data."""
-
-    @classmethod
-    def is_overscan_data_packet(cls, data: Union[bytes, np.ndarray]) -> bool:
-        if len(data) <= 10:
-            return False
-        if data[0] != 0x50:
-            return False
-        if data[1] != 0xF0:
-            return False
-        type_ = DataPacketType((data[4] << 8) + data[5])
-        if type_.packet_type == PacketType.OVERSCAN_DATA:
-            return True
-        return False
-
-
-class HousekeepingPacket(DataPacket):
-    """Proprietary Housekeeping data packet for the N-FEE and F-FEE."""
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        """
-        Args:
-            data: a numpy array of type np.uint8 (not enforced)
-        """
-        if not self.is_housekeeping_packet(data):
-            raise ValueError(f"Can not create a HousekeepingPacket from the given data {data}")
-
-        # The __init__ method of DataPacket already checks e.g. data-length against packet length,
-        # so there is no need for these tests here.
-
-        super().__init__(data)
-
-    @classmethod
-    def is_housekeeping_packet(cls, data: Union[bytes, np.ndarray]) -> bool:
-        if len(data) <= 10:
-            return False
-        if data[0] != 0x50:
-            return False
-        if data[1] != 0xF0:
-            return False
-        type_ = DataPacketType((data[4] << 8) + data[5])
-        if type_.packet_type == PacketType.HOUSEKEEPING_DATA:
-            return True
-        return False
-
-
-class TimecodePacket(SpaceWirePacket):
-    """A Timecode Packet.
-
-    This packet really is an extended packet which is generated by the Diagnostic SpaceWire
-    Interface (DSI) to forward a SpaceWire timecode over the Ethernet connection.
-    """
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        super().__init__(data)
-
-    @property
-    def timecode(self) -> int:
-        return self._bytes[1] & 0x3F
-
-    def header_as_bytes(self) -> bytes:
-        return self._bytes[0:1]
-
-    @classmethod
-    def is_timecode_packet(cls, data: Union[bytes, np.ndarray]) -> bool:
-        return data[0] == 0x91
-
-    def __str__(self):
-        return f"Timecode Packet: timecode = 0x{self.timecode:x}"
-
-
-class RMAPPacket(SpaceWirePacket):
-    """Base class for RMAP SpaceWire packets."""
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        if not self.is_rmap_packet(data):
-            raise ValueError(f"Can not create a RMAPPacket from the given data {data}")
-        super().__init__(data)
-
-    def __str__(self):
-        return (
-            f"{self.__class__.__name__}:\n"
-            f"  Logical Address = 0x{self.logical_address:02X}\n"
-            f"  Data = {self.data}\n"
-        )
-
-    @property
-    def instruction(self):
-        return get_instruction_field(self._bytes)
-
-    @property
-    def transaction_id(self):
-        return get_transaction_identifier(self._bytes)
-
-    @classmethod
-    def is_rmap_packet(cls, data: Union[bytes, np.ndarray]):
-        if data[1] == 0x01:  # Protocol ID
-            return True
-        return False
-
-
-class WriteRequest(RMAPPacket):
-    """A Write Request SpaceWire RMAP Packet."""
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        super().__init__(data)
-
-    def is_verified(self):
-        return self._bytes[2] == 0x7C
-
-    def is_unverified(self):
-        return self._bytes[2] == 0x6C
-
-    @property
-    def address(self):
-        return get_address(self._bytes)
-
-    @property
-    def data_length(self):
-        return get_data_length(self._bytes)
-
-    @property
-    def data(self) -> bytes:
-        return get_data(self._bytes)
-
-    @classmethod
-    def is_write_request(cls, data: Union[bytes, np.ndarray]):
-        if not RMAPPacket.is_rmap_packet(data):
-            return False
-        if data[0] != 0x51:
-            return False
-        if (data[2] == 0x7C or data[2] == 0x6C) and data[3] == 0xD1:
-            return True
-        return False
-
-    def __str__(self):
-        prefix = "Verified" if self.is_verified() else "Unverified"
-        return f"{prefix} Write Request: {self.transaction_id=}, data=0x{self.data.hex()}"
-
-
-class WriteRequestReply(RMAPPacket):
-    """An RMAP Reply packet to a Write Request."""
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        super().__init__(data)
-        self._status = data[3]
-
-    @classmethod
-    def is_write_reply(cls, data: Union[bytes, np.ndarray]):
-        if not RMAPPacket.is_rmap_packet(data):
-            return False
-        if data[0] != 0x50:
-            return False
-        if (data[2] == 0x3C or data[2] == 0x2C) and data[4] == 0x51:
-            return True
-
-    @property
-    def status(self):
-        return self._status
-
-    def __str__(self):
-        return f"Write Request Reply: status={self.status}"
-
-
-class ReadRequest(RMAPPacket):
-    """A Read Request SpaceWire RMAP Packet."""
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        super().__init__(data)
-
-    @classmethod
-    def is_read_request(cls, data: Union[bytes, np.ndarray]):
-        if not RMAPPacket.is_rmap_packet(data):
-            return False
-        if data[0] != 0x51:
-            return False
-        if data[2] == 0x4C and data[3] == 0xD1:
-            return True
-        return False
-
-    @property
-    def address(self):
-        return get_address(self._bytes)
-
-    @property
-    def data_length(self):
-        return get_data_length(self._bytes)
-
-    def __str__(self):
-        return (
-            f"Read Request: tid={self.transaction_id}, address=0x{self.address:04x}, "
-            f"data length={self.data_length}"
-        )
-
-
-class ReadRequestReply(RMAPPacket):
-    """An RMAP Reply packet to a Read Request."""
-
-    def __init__(self, data: Union[bytes, np.ndarray]):
-        super().__init__(data)
-
-    @classmethod
-    def is_read_reply(cls, data: Union[bytes, np.ndarray]):
-        if not RMAPPacket.is_rmap_packet(data):
-            return False
-        if data[0] != 0x50:
-            return False
-        if data[2] == 0x0C and data[4] == 0x51:
-            return True
-
-    @property
-    def data(self) -> bytes:
-        return get_data(self._bytes)
-
-    @property
-    def data_length(self):
-        return get_data_length(self._bytes)
-
-    def __str__(self):
-        data_length = self.data_length
-        return f"Read Request Reply: data length={data_length}, data={self.data[:20]} " \
-               f"{'(data is cut to max 20 bytes)' if data_length > 20 else ''}\n"
-
-
-class SpaceWireInterface:
-    """
-    This interface defines methods that are used by the DPU to communicate with the FEE over
-    SpaceWire.
-    """
-
-    def __enter__(self):
-        self.connect()
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.disconnect()
-
-    def connect(self):
-        raise NotImplementedError
-
-    def disconnect(self):
-        raise NotImplementedError
-
-    def configure(self):
-        raise NotImplementedError
-
-    def flush(self):
-        raise NotImplementedError
-
-    def send_timecode(self, timecode: int):
-        raise NotImplementedError
-
-    def read_packet(self, timeout: int = None) -> Tuple[int, bytes]:
-        """
-        Read a full packet from the SpaceWire transport layer.
-
-        Args:
-            timeout (int): timeout in milliseconds [default=None]
-        Returns:
-            A tuple with the terminator value and a bytes object containing the packet.
-        """
-        raise NotImplementedError
-
-    def write_packet(self, packet: bytes):
-        """
-        Write a full packet to the SpaceWire transport layer.
-
-        Args:
-            packet (bytes): a bytes object containing the SpaceWire packet
-
-        Returns:
-            None.
-        """
-        raise NotImplementedError
-
-    def read_register(self, address: int, length: int = 4, strict: bool = True) -> bytes:
-        """
-        Reads the data for the given register from the FEE memory map.
-
-        This function sends an RMAP read request for the register to the FEE.
-
-        Args:
-            address: the start address (32-bit aligned) in the remote memory
-            length: the number of bytes to read from the remote memory [default = 4]
-            strict: perform strict checking of address and length
-
-        Returns:
-            data: the 32-bit data that was read from the FEE.
-        """
-        raise NotImplementedError
-
-    def write_register(self, address: int, data: bytes):
-        """
-        Writes the data from the given register to the N-FEE memory map.
-
-        The function reads the data for the registry from the local register map
-        and then sends an RMAP write request for the register to the N-FEE.
-
-        .. note:: it is assumed that the local register map is up-to-date.
-
-        Args:
-            address: the start address (32-bit aligned) in the remote memory
-            data: the data that will be written into the remote memory
-
-        Raises:
-            RMAPError: when data can not be written on the target, i.e. the N-FEE.
-        """
-
-        raise NotImplementedError
-
-    def read_memory_map(self, address: int, size: int):
-        """
-        Read (part of) the memory map from the N-FEE.
-
-        Args:
-            address: start address
-            size: number of bytes to read
-
-        Returns:
-            a bytes object containing the requested memory map.
-        """
-
-        raise NotImplementedError
-
-
-# General RMAP helper functions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-def rmap_crc_check(data, start, length) -> int:
-    """Calculate the checksum for the given data."""
-    return crc_calc(data, start, length)
-
-
-def get_protocol_id(data: bytes) -> int:
-    """
-    Returns the protocol identifier field. The protocol ID is 1 (0x01) for the RMAP protocol.
-    """
-    return data[1]
-
-
-def get_reply_address_field_length(rx_buffer) -> int:
-    """Returns the size of reply address field.
-
-    This function returns the actual size of the reply address field. It doesn't return
-    the content of the reply address length field. If you need that information, use the
-    reply_address_length() function that work on the instruction field.
-
-    Returns:
-         length: the size of the reply address field.
-    """
-    instruction = get_instruction_field(rx_buffer)
-    return reply_address_length(instruction) * 4
-
-
-def get_data(rxbuf) -> bytes:
-    """
-    Return the data from the RMAP packet.
-
-    Raises:
-        ValueError: if there is no data section in the packet (TODO: not yet implemented)
-    """
-    instruction_field = get_instruction_field(rxbuf)
-    address_length = get_reply_address_field_length(rxbuf)
-    data_length = get_data_length(rxbuf)
-
-    offset = 12 if is_read(instruction_field) else 16
-
-    return rxbuf[offset + address_length:offset + address_length + data_length]
-
-
-def check_data_crc(rxbuf):
-    instruction_field = get_instruction_field(rxbuf)
-    address_length = get_reply_address_field_length(rxbuf)
-    data_length = get_data_length(rxbuf)
-
-    offset = 12 if is_read(instruction_field) else 16
-    idx = offset + address_length
-
-    d_crc = rxbuf[idx + data_length]
-    c_crc = rmap_crc_check(rxbuf, idx, data_length) & 0xFF
-    if d_crc != c_crc:
-        raise CheckError(
-            f"Data CRC doesn't match calculated CRC, d_crc=0x{d_crc:02X} & c_crc=0x{c_crc:02X}",
-            RMAP_GENERAL_ERROR
-        )
-
-
-def check_header_crc(rxbuf):
-    instruction_field = get_instruction_field(rxbuf)
-    if is_command(instruction_field):
-        offset = 15
-    elif is_write(instruction_field):
-        offset = 7
-    else:
-        offset = 11
-
-    idx = offset + get_reply_address_field_length(rxbuf)
-    h_crc = rxbuf[idx]
-    c_crc = rmap_crc_check(rxbuf, 0, idx)
-    if h_crc != c_crc:
-        raise CheckError(
-            f"Header CRC doesn't match calculated CRC, h_crc=0x{h_crc:02X} & c_crc=0x{c_crc:02X}",
-            RMAP_GENERAL_ERROR
-        )
-
-
-def get_data_length(rxbuf) -> int:
-    """
-    Returns the length of the data in bytes.
-
-    Raises:
-        TypeError: when this method is used on a Write Request Reply packet (which has no
-            data length).
-    """
-    instruction_field = get_instruction_field(rxbuf)
-
-    if not is_command(instruction_field) and is_write(instruction_field):
-        raise TypeError("There is no data length field for Write Request Reply packets, "
-                        "asking for the data length is an invalid operation.")
-
-    offset = 12 if is_command(instruction_field) else 8
-    idx = offset + get_reply_address_field_length(rxbuf)
-
-    # We could use two alternative decoding methods here:
-    #   int.from_bytes(rxbuf[idx:idx+3], byteorder='big')    (timeit=1.166s)
-    #   struct.unpack('>L', b'\x00' + rxbuf[idx:idx+3])[0]   (timeit=0.670s)
-    data_length = struct.unpack('>L', b'\x00' + rxbuf[idx:idx + 3])[0]
-    return data_length
-
-
-def get_address(rxbuf) -> int:
-    """
-    Returns the address field (including the extended address field if the address is 40-bits).
-
-    Raises:
-        TypeError: when this method is used on a Reply packet (which has no address field).
-    """
-    instruction_field = get_instruction_field(rxbuf)
-
-    if not is_command(instruction_field):
-        raise TypeError("There is no address field for Reply packets, asking for the address is "
-                        "an invalid operation.")
-
-    idx = 7 + get_reply_address_field_length(rxbuf)
-    extended_address = rxbuf[idx]
-    idx += 1
-    address = struct.unpack('>L', rxbuf[idx:idx + 4])[0]
-    if extended_address:
-        address = address + (extended_address << 32)
-    return address
-
-
-def get_instruction_field(rxbuf):
-    idx = 2
-    return rxbuf[idx]
-
-
-def get_transaction_identifier(rxbuf):
-    idx = 5 + get_reply_address_field_length(rxbuf)
-    tid = struct.unpack('>h', rxbuf[idx:idx + 2])[0]
-    return tid
-
-
-# Functions to interpret the Instrument Field
-
-def is_reserved(instruction):
-    """The reserved bit of the 2-bit packet type field from the instruction field.
-
-    For PLATO this bit shall be zero as the 0b10 and 0b11 packet field values are reserved.
-
-    Returns:
-        bit value: 1 or 0.
-    """
-    return (instruction & 0b10000000) >> 7
-
-
-def is_command(instruction):
-    """Returns True if the RMAP packet is a command packet."""
-    return (instruction & 0b01000000) >> 6
-
-
-def is_reply(instruction):
-    """Returns True if the RMAP packet is a reply to a previous command packet."""
-    return not is_command(instruction)
-
-
-def is_write(instruction):
-    """Returns True if the RMAP packet is a write request command packet."""
-    return (instruction & 0b00100000) >> 5
-
-
-def is_read(instruction):
-    """Returns True if the RMAP packet is a read request command packet."""
-    return not is_write(instruction)
-
-
-def is_verify(instruction):
-    """Returns True if the RMAP packet needs to do a verify before write."""
-    return (instruction & 0b00010000) >> 4
-
-
-def is_reply_required(instruction):
-    """Returns True if the reply bit is set in the instruction field.
-
-    Args:
-        instruction (int): the instruction field of an RMAP packet
-
-    .. note:: the name of this function might be confusing.
-
-        This function does **not** test if the packet is a reply packet, but it checks
-        if the command requests a reply from the target. If you need to test if the
-        packet is a command or a reply, use the is_command() or is_reply() function.
-
-    """
-    return (instruction & 0b00001000) >> 3
-
-
-def is_increment(instruction):
-    """Returns True if the data is written to sequential memory addresses."""
-    return (instruction & 0b00000100) >> 2
-
-
-def reply_address_length(instruction):
-    """Returns the content of the reply address length field.
-
-    The size of the reply address field is then decoded from the following table:
-
-        Address Field Length  |  Size of Address Field
-        ----------------------+-----------------------
-             0b00             |      0 bytes
-             0b01             |      4 bytes
-             0b10             |      8 bytes
-             0b11             |     12 bytes
-
-    """
-    return (instruction & 0b00000011) << 2