Init spacepackets crate

src/ecss.rs

@@ -0,0 +1,37 @@
+use crate::{CcsdsPacket, PacketError};
+use core::mem::size_of;
+use crc::{Crc, CRC_16_IBM_3740};
+use serde::{Deserialize, Serialize};
+
+/// CRC algorithm used by the PUS standard
+pub const CRC_CCITT_FALSE: Crc<u16> = Crc::<u16>::new(&CRC_16_IBM_3740);
+pub const CCSDS_HEADER_LEN: usize = size_of::<crate::zc::SpHeader>();
+
+/// All PUS versions. Only PUS C is supported by this library
+#[derive(PartialEq, Copy, Clone, Serialize, Deserialize, Debug)]
+pub enum PusVersion {
+    EsaPus = 0,
+    PusA = 1,
+    PusC = 2,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum PusError {
+    VersionNotSupported(PusVersion),
+    IncorrectCrc(u16),
+    RawDataTooShort(usize),
+    NoRawData,
+    /// CRC16 needs to be calculated first
+    CrcCalculationMissing,
+    OtherPacketError(PacketError),
+}
+
+pub trait PusPacket: CcsdsPacket {
+    const PUS_VERSION: PusVersion = PusVersion::PusC;
+
+    fn service(&self) -> u8;
+    fn subservice(&self) -> u8;
+
+    fn user_data(&self) -> Option<&[u8]>;
+    fn crc16(&self) -> Option<u16>;
+}

src/lib.rs

@@ -0,0 +1,586 @@
+//! # Space related components including CCSDS and ECSS packet standards
+#![no_std]
+extern crate alloc;
+
+use crate::ecss::CCSDS_HEADER_LEN;
+use serde::{Deserialize, Serialize};
+
+pub mod ecss;
+pub mod tc;
+pub mod tm;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum PacketError {
+    /// The passed slice is too small. Returns the required size of the failed size chgeck
+    ToBytesSliceTooSmall(usize),
+    /// The [zerocopy] library failed to write to bytes
+    ToBytesZeroCopyError,
+    FromBytesZeroCopyError,
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Copy, Clone)]
+pub enum PacketType {
+    Tm = 0,
+    Tc = 1,
+}
+
+impl TryFrom<u8> for PacketType {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            x if x == PacketType::Tm as u8 => Ok(PacketType::Tm),
+            x if x == PacketType::Tc as u8 => Ok(PacketType::Tc),
+            _ => Err(()),
+        }
+    }
+}
+
+pub fn packet_type_in_raw_packet_id(packet_id: u16) -> PacketType {
+    PacketType::try_from((packet_id >> 12) as u8 & 0b1).unwrap()
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Copy, Clone)]
+pub enum SequenceFlags {
+    ContinuationSegment = 0b00,
+    FirstSegment = 0b01,
+    LastSegment = 0b10,
+    Unsegmented = 0b11,
+}
+
+impl TryFrom<u8> for SequenceFlags {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            x if x == SequenceFlags::ContinuationSegment as u8 => {
+                Ok(SequenceFlags::ContinuationSegment)
+            }
+            x if x == SequenceFlags::FirstSegment as u8 => Ok(SequenceFlags::FirstSegment),
+            x if x == SequenceFlags::LastSegment as u8 => Ok(SequenceFlags::LastSegment),
+            x if x == SequenceFlags::Unsegmented as u8 => Ok(SequenceFlags::Unsegmented),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Copy, Clone)]
+pub struct PacketId {
+    pub ptype: PacketType,
+    pub sec_header_flag: bool,
+    apid: u16,
+}
+
+impl PacketId {
+    pub fn new(ptype: PacketType, sec_header_flag: bool, apid: u16) -> Option<PacketId> {
+        let mut pid = PacketId {
+            ptype,
+            sec_header_flag,
+            apid: 0,
+        };
+        pid.set_apid(apid).then(|| pid)
+    }
+
+    pub fn set_apid(&mut self, apid: u16) -> bool {
+        if apid > num::pow(2, 11) - 1 {
+            return false;
+        }
+        self.apid = apid;
+        true
+    }
+
+    pub fn apid(&self) -> u16 {
+        self.apid
+    }
+
+    pub fn raw(&self) -> u16 {
+        ((self.ptype as u16) << 12) | ((self.sec_header_flag as u16) << 11) | self.apid
+    }
+}
+
+impl From<u16> for PacketId {
+    fn from(raw_id: u16) -> Self {
+        PacketId {
+            ptype: PacketType::try_from(((raw_id >> 12) & 0b1) as u8).unwrap(),
+            sec_header_flag: ((raw_id >> 11) & 0b1) != 0,
+            apid: raw_id & 0x7FF,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Copy, Clone)]
+pub struct PacketSequenceCtrl {
+    pub seq_flags: SequenceFlags,
+    ssc: u16,
+}
+
+impl PacketSequenceCtrl {
+    pub fn new(seq_flags: SequenceFlags, ssc: u16) -> Option<PacketSequenceCtrl> {
+        let mut psc = PacketSequenceCtrl { seq_flags, ssc: 0 };
+        psc.set_ssc(ssc).then(|| psc)
+    }
+    pub fn raw(&self) -> u16 {
+        ((self.seq_flags as u16) << 14) | self.ssc
+    }
+
+    pub fn set_ssc(&mut self, ssc: u16) -> bool {
+        if ssc > num::pow(2, 14) - 1 {
+            return false;
+        }
+        self.ssc = ssc;
+        true
+    }
+
+    pub fn ssc(&self) -> u16 {
+        self.ssc
+    }
+}
+
+impl From<u16> for PacketSequenceCtrl {
+    fn from(raw_id: u16) -> Self {
+        PacketSequenceCtrl {
+            seq_flags: SequenceFlags::try_from(((raw_id >> 14) & 0b11) as u8).unwrap(),
+            ssc: raw_id & SSC_MASK,
+        }
+    }
+}
+
+macro_rules! sph_from_other {
+    ($Self: path, $other: path) => {
+        impl From<$other> for $Self {
+            fn from(other: $other) -> Self {
+                Self::from_composite_fields(
+                    other.packet_id(),
+                    other.psc(),
+                    other.data_len(),
+                    Some(other.ccsds_version()),
+                )
+            }
+        }
+    };
+}
+
+const SSC_MASK: u16 = 0x3FFF;
+const VERSION_MASK: u16 = 0xE000;
+
+/// Generic trait to access fields of a CCSDS space packet header according to CCSDS 133.0-B-2
+pub trait CcsdsPacket {
+    fn ccsds_version(&self) -> u8;
+    fn packet_id(&self) -> PacketId;
+    fn psc(&self) -> PacketSequenceCtrl;
+
+    /// Retrieve data length field
+    fn data_len(&self) -> u16;
+    /// Retrieve the total packet size based on the data length field
+    fn total_len(&self) -> usize {
+        usize::from(self.data_len()) + CCSDS_HEADER_LEN + 1
+    }
+
+    /// Retrieve 13 bit Packet Identification field. Can usually be retrieved with a bitwise AND
+    /// of the first 2 bytes with 0x1FFF
+    #[inline]
+    fn packet_id_raw(&self) -> u16 {
+        self.packet_id().raw()
+    }
+    /// Retrieve Packet Sequence Count
+    #[inline]
+    fn psc_raw(&self) -> u16 {
+        self.psc().raw()
+    }
+
+    #[inline]
+    /// Retrieve Packet Type (TM: 0, TC: 1)
+    fn ptype(&self) -> PacketType {
+        // This call should never fail because only 0 and 1 can be passed to the try_from call
+        self.packet_id().ptype
+    }
+
+    #[inline]
+    fn is_tm(&self) -> bool {
+        self.ptype() == PacketType::Tm
+    }
+
+    #[inline]
+    fn is_tc(&self) -> bool {
+        self.ptype() == PacketType::Tc
+    }
+
+    /// Retrieve the secondary header flag. Returns true if a secondary header is present
+    /// and false if it is not
+    #[inline]
+    fn sec_header_flag(&self) -> bool {
+        self.packet_id().sec_header_flag
+    }
+
+    /// Retrieve Application Process ID
+    #[inline]
+    fn apid(&self) -> u16 {
+        self.packet_id().apid
+    }
+
+    #[inline]
+    fn ssc(&self) -> u16 {
+        self.psc().ssc
+    }
+
+    #[inline]
+    fn sequence_flags(&self) -> SequenceFlags {
+        // This call should never fail because the mask ensures that only valid values are passed
+        // into the try_from function
+        self.psc().seq_flags
+    }
+}
+
+pub trait CcsdsPrimaryHeader {
+    fn from_composite_fields(
+        packet_id: PacketId,
+        psc: PacketSequenceCtrl,
+        data_len: u16,
+        version: Option<u8>,
+    ) -> Self;
+}
+
+pub mod ser {
+    use crate::{
+        CcsdsPacket, CcsdsPrimaryHeader, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags,
+    };
+
+    /// Space Packet Primary Header according to CCSDS 133.0-B-2
+    #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Copy, Clone)]
+    pub struct SpHeader {
+        pub version: u8,
+        pub packet_id: PacketId,
+        pub psc: PacketSequenceCtrl,
+        pub data_len: u16,
+    }
+    impl Default for SpHeader {
+        fn default() -> Self {
+            SpHeader {
+                version: 0,
+                packet_id: PacketId {
+                    ptype: PacketType::Tm,
+                    apid: 0,
+                    sec_header_flag: true,
+                },
+                psc: PacketSequenceCtrl {
+                    seq_flags: SequenceFlags::Unsegmented,
+                    ssc: 0,
+                },
+                data_len: 0,
+            }
+        }
+    }
+    impl SpHeader {
+        pub fn new(apid: u16, ptype: PacketType, ssc: u16, data_len: u16) -> Option<Self> {
+            if ssc > num::pow(2, 14) - 1 || apid > num::pow(2, 11) - 1 {
+                return None;
+            }
+            let mut header = SpHeader::default();
+            header.packet_id.apid = apid;
+            header.packet_id.ptype = ptype;
+            header.psc.ssc = ssc;
+            header.data_len = data_len;
+            Some(header)
+        }
+
+        pub fn tm(apid: u16, ssc: u16, data_len: u16) -> Option<Self> {
+            Self::new(apid, PacketType::Tm, ssc, data_len)
+        }
+
+        pub fn tc(apid: u16, ssc: u16, data_len: u16) -> Option<Self> {
+            Self::new(apid, PacketType::Tc, ssc, data_len)
+        }
+    }
+
+    impl CcsdsPacket for SpHeader {
+        #[inline]
+        fn ccsds_version(&self) -> u8 {
+            self.version
+        }
+
+        #[inline]
+        fn packet_id(&self) -> PacketId {
+            self.packet_id
+        }
+
+        #[inline]
+        fn psc(&self) -> PacketSequenceCtrl {
+            self.psc
+        }
+
+        #[inline]
+        fn data_len(&self) -> u16 {
+            self.data_len
+        }
+    }
+
+    impl CcsdsPrimaryHeader for SpHeader {
+        fn from_composite_fields(
+            packet_id: PacketId,
+            psc: PacketSequenceCtrl,
+            data_len: u16,
+            version: Option<u8>,
+        ) -> Self {
+            let mut version_to_set = 0b000;
+            if let Some(version) = version {
+                version_to_set = version;
+            }
+            SpHeader {
+                version: version_to_set,
+                packet_id,
+                psc,
+                data_len,
+            }
+        }
+    }
+
+    sph_from_other!(SpHeader, crate::zc::SpHeader);
+}
+
+pub mod zc {
+    use crate::{CcsdsPacket, CcsdsPrimaryHeader, PacketId, PacketSequenceCtrl, VERSION_MASK};
+    use zerocopy::byteorder::NetworkEndian;
+    use zerocopy::{AsBytes, FromBytes, Unaligned, U16};
+
+    #[derive(FromBytes, AsBytes, Unaligned, Debug)]
+    #[repr(C)]
+    pub struct SpHeader {
+        version_packet_id: U16<NetworkEndian>,
+        psc: U16<NetworkEndian>,
+        data_len: U16<NetworkEndian>,
+    }
+
+    impl SpHeader {
+        pub fn new(
+            packet_id: PacketId,
+            psc: PacketSequenceCtrl,
+            data_len: u16,
+            version: Option<u8>,
+        ) -> Self {
+            let mut version_packet_id = packet_id.raw();
+            if let Some(version) = version {
+                version_packet_id = ((version as u16) << 13) | packet_id.raw()
+            }
+            SpHeader {
+                version_packet_id: U16::from(version_packet_id),
+                psc: U16::from(psc.raw()),
+                data_len: U16::from(data_len),
+            }
+        }
+
+        pub fn from_bytes(slice: &(impl AsRef<[u8]> + ?Sized)) -> Option<Self> {
+            SpHeader::read_from(slice.as_ref())
+        }
+
+        pub fn to_bytes(&self, slice: &mut (impl AsMut<[u8]> + ?Sized)) -> Option<()> {
+            self.write_to(slice.as_mut())
+        }
+    }
+
+    impl CcsdsPacket for SpHeader {
+        #[inline]
+        fn ccsds_version(&self) -> u8 {
+            ((self.version_packet_id.get() >> 13) as u8) & 0b111
+        }
+
+        fn packet_id(&self) -> PacketId {
+            PacketId::from(self.packet_id_raw())
+        }
+        fn psc(&self) -> PacketSequenceCtrl {
+            PacketSequenceCtrl::from(self.psc_raw())
+        }
+
+        #[inline]
+        fn data_len(&self) -> u16 {
+            self.data_len.get()
+        }
+
+        fn packet_id_raw(&self) -> u16 {
+            self.version_packet_id.get() & (!VERSION_MASK)
+        }
+
+        fn psc_raw(&self) -> u16 {
+            self.psc.get()
+        }
+    }
+
+    impl CcsdsPrimaryHeader for SpHeader {
+        fn from_composite_fields(
+            packet_id: PacketId,
+            psc: PacketSequenceCtrl,
+            data_len: u16,
+            version: Option<u8>,
+        ) -> Self {
+            SpHeader::new(packet_id, psc, data_len, version)
+        }
+    }
+
+    sph_from_other!(SpHeader, crate::ser::SpHeader);
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ser::SpHeader;
+    use crate::{
+        packet_type_in_raw_packet_id, zc, CcsdsPacket, CcsdsPrimaryHeader, PacketId,
+        PacketSequenceCtrl, PacketType, SequenceFlags,
+    };
+    use alloc::vec;
+    use postcard::{from_bytes, to_stdvec};
+
+    #[test]
+    fn test_helpers() {
+        assert_eq!(
+            SequenceFlags::try_from(0b00).expect("SEQ flag creation failed"),
+            SequenceFlags::ContinuationSegment
+        );
+        assert_eq!(
+            SequenceFlags::try_from(0b01).expect("SEQ flag creation failed"),
+            SequenceFlags::FirstSegment
+        );
+        assert_eq!(
+            SequenceFlags::try_from(0b10).expect("SEQ flag creation failed"),
+            SequenceFlags::LastSegment
+        );
+        assert_eq!(
+            SequenceFlags::try_from(0b11).expect("SEQ flag creation failed"),
+            SequenceFlags::Unsegmented
+        );
+        assert!(SequenceFlags::try_from(0b100).is_err());
+        assert!(PacketType::try_from(0b10).is_err());
+        let packet_id =
+            PacketId::new(PacketType::Tm, false, 0x42).expect("Packet ID creation failed");
+        assert_eq!(packet_id.raw(), 0x0042);
+        let packet_id_from_raw = PacketId::from(packet_id.raw());
+        assert_eq!(
+            packet_type_in_raw_packet_id(packet_id.raw()),
+            PacketType::Tm
+        );
+        assert_eq!(packet_id_from_raw, packet_id);
+
+        let packet_id_invalid = PacketId::new(PacketType::Tc, true, 0xFFFF);
+        assert!(packet_id_invalid.is_none());
+        let packet_id_from_new = PacketId::new(PacketType::Tm, false, 0x42).unwrap();
+        assert_eq!(packet_id_from_new, packet_id);
+        let mut psc = PacketSequenceCtrl::new(SequenceFlags::ContinuationSegment, 77)
+            .expect("PSC creation failed");
+        assert_eq!(psc.raw(), 77);
+        let psc_from_raw = PacketSequenceCtrl::from(psc.raw());
+        assert_eq!(psc_from_raw, psc);
+        // Fails because SSC is limited to 14 bits
+        assert!(!psc.set_ssc(num::pow(2, 15)));
+        assert_eq!(psc.raw(), 77);
+
+        let psc_invalid = PacketSequenceCtrl::new(SequenceFlags::FirstSegment, 0xFFFF);
+        assert!(psc_invalid.is_none());
+        let psc_from_new = PacketSequenceCtrl::new(SequenceFlags::ContinuationSegment, 77).unwrap();
+        assert_eq!(psc_from_new, psc);
+    }
+
+    #[test]
+    fn test_serde_sph() {
+        let sp_header = SpHeader::tc(0x42, 12, 0).expect("Error creating SP header");
+        assert_eq!(sp_header.ccsds_version(), 0b000);
+        assert!(sp_header.is_tc());
+        assert!(sp_header.sec_header_flag());
+        assert_eq!(sp_header.ptype(), PacketType::Tc);
+        assert_eq!(sp_header.ssc(), 12);
+        assert_eq!(sp_header.apid(), 0x42);
+        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
+        assert_eq!(sp_header.data_len(), 0);
+        let output = to_stdvec(&sp_header).unwrap();
+        let sp_header: SpHeader = from_bytes(&output).unwrap();
+        assert_eq!(sp_header.version, 0b000);
+        assert!(sp_header.packet_id.sec_header_flag);
+        assert_eq!(sp_header.ptype(), PacketType::Tc);
+        assert_eq!(sp_header.ssc(), 12);
+        assert_eq!(sp_header.apid(), 0x42);
+        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
+        assert_eq!(sp_header.packet_id_raw(), 0x1842);
+        assert_eq!(sp_header.psc_raw(), 0xC00C);
+        assert_eq!(sp_header.ccsds_version(), 0b000);
+        assert_eq!(sp_header.data_len, 0);
+
+        let sp_header = SpHeader::tm(0x7, 22, 36).expect("Error creating SP header");
+        assert_eq!(sp_header.ccsds_version(), 0b000);
+        assert!(sp_header.is_tm());
+        assert!(sp_header.sec_header_flag());
+        assert_eq!(sp_header.ptype(), PacketType::Tm);
+        assert_eq!(sp_header.ssc(), 22);
+        assert_eq!(sp_header.apid(), 0x07);
+        assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
+        assert_eq!(sp_header.packet_id_raw(), 0x0807);
+        assert_eq!(sp_header.psc_raw(), 0xC016);
+        assert_eq!(sp_header.data_len(), 36);
+        assert_eq!(sp_header.ccsds_version(), 0b000);
+
+        let from_comp_fields = SpHeader::from_composite_fields(
+            PacketId::new(PacketType::Tc, true, 0x42).unwrap(),
+            PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 0x7).unwrap(),
+            0,
+            None,
+        );
+        assert_eq!(from_comp_fields.ptype(), PacketType::Tc);
+        assert_eq!(from_comp_fields.apid(), 0x42);
+        assert!(from_comp_fields.sec_header_flag());
+        assert_eq!(
+            from_comp_fields.sequence_flags(),
+            SequenceFlags::Unsegmented
+        );
+        assert_eq!(from_comp_fields.ssc(), 0x7);
+        assert_eq!(from_comp_fields.data_len(), 0);
+    }
+
+    #[test]
+    fn test_zc_sph() {
+        use zerocopy::AsBytes;
+
+        let sp_header =
+            SpHeader::tc(0x7FF, num::pow(2, 14) - 1, 0).expect("Error creating SP header");
+        assert_eq!(sp_header.ptype(), PacketType::Tc);
+        assert_eq!(sp_header.apid(), 0x7FF);
+        assert_eq!(sp_header.data_len(), 0);
+        assert_eq!(sp_header.ccsds_version(), 0b000);
+        assert!(sp_header.is_tc());
+        let sp_header_zc = zc::SpHeader::from(sp_header);
+        let slice = sp_header_zc.as_bytes();
+        assert_eq!(slice.len(), 6);
+        assert_eq!(slice[0], 0x1F);
+        assert_eq!(slice[1], 0xFF);
+        assert_eq!(slice[2], 0xFF);
+        assert_eq!(slice[3], 0xFF);
+        assert_eq!(slice[4], 0x00);
+        assert_eq!(slice[5], 0x00);
+
+        let mut slice = [0; 6];
+        sp_header_zc.write_to(slice.as_mut_slice());
+        assert_eq!(slice.len(), 6);
+        assert_eq!(slice[0], 0x1F);
+        assert_eq!(slice[1], 0xFF);
+        assert_eq!(slice[2], 0xFF);
+        assert_eq!(slice[3], 0xFF);
+        assert_eq!(slice[4], 0x00);
+        assert_eq!(slice[5], 0x00);
+
+        let mut test_vec = vec![0_u8; 6];
+        let slice = test_vec.as_mut_slice();
+        sp_header_zc.write_to(slice);
+        let slice = test_vec.as_slice();
+        assert_eq!(slice.len(), 6);
+        assert_eq!(slice[0], 0x1F);
+        assert_eq!(slice[1], 0xFF);
+        assert_eq!(slice[2], 0xFF);
+        assert_eq!(slice[3], 0xFF);
+        assert_eq!(slice[4], 0x00);
+        assert_eq!(slice[5], 0x00);
+
+        let sp_header = zc::SpHeader::from_bytes(slice);
+        assert!(sp_header.is_some());
+        let sp_header = sp_header.unwrap();
+        assert_eq!(sp_header.ccsds_version(), 0b000);
+        assert_eq!(sp_header.packet_id_raw(), 0x1FFF);
+        assert_eq!(sp_header.apid(), 0x7FF);
+        assert_eq!(sp_header.ptype(), PacketType::Tc);
+        assert_eq!(sp_header.data_len(), 0);
+    }
+}

src/tc.rs

@@ -0,0 +1,476 @@
+use crate::ecss::PusVersion;
+use crate::CCSDS_HEADER_LEN;
+use core::mem::size_of;
+
+type CrcType = u16;
+
+/// PUS C secondary header length is fixed
+pub const PUC_TC_SECONDARY_HEADER_LEN: usize = size_of::<zc::PusTcDataFieldHeader>();
+pub const PUS_TC_MIN_LEN_WITHOUT_APP_DATA: usize =
+    CCSDS_HEADER_LEN + PUC_TC_SECONDARY_HEADER_LEN + size_of::<CrcType>();
+const PUS_VERSION: PusVersion = PusVersion::PusC;
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+enum AckOpts {
+    Acceptance = 0b1000,
+    Start = 0b0100,
+    Progress = 0b0010,
+    Completion = 0b0001,
+}
+
+pub const ACK_ALL: u8 = AckOpts::Acceptance as u8
+    | AckOpts::Start as u8
+    | AckOpts::Progress as u8
+    | AckOpts::Completion as u8;
+
+pub trait PusTcSecondaryHeader {
+    fn ack_flags(&self) -> u8;
+    fn service(&self) -> u8;
+    fn subservice(&self) -> u8;
+    fn source_id(&self) -> u16;
+}
+
+pub mod zc {
+    use crate::ecss::{PusError, PusVersion};
+    use crate::tc::{ser, PusTcSecondaryHeader};
+    use zerocopy::{AsBytes, FromBytes, NetworkEndian, Unaligned, U16};
+
+    #[derive(FromBytes, AsBytes, Unaligned)]
+    #[repr(C)]
+    pub struct PusTcDataFieldHeader {
+        version_ack: u8,
+        service: u8,
+        subservice: u8,
+        source_id: U16<NetworkEndian>,
+    }
+
+    impl TryFrom<ser::PusTcDataFieldHeader> for PusTcDataFieldHeader {
+        type Error = PusError;
+        fn try_from(value: ser::PusTcDataFieldHeader) -> Result<Self, Self::Error> {
+            if value.version != PusVersion::PusC {
+                return Err(PusError::VersionNotSupported(value.version));
+            }
+            Ok(PusTcDataFieldHeader {
+                version_ack: ((value.version as u8) << 4) | value.ack,
+                service: value.service,
+                subservice: value.subservice,
+                source_id: U16::from(value.source_id),
+            })
+        }
+    }
+
+    impl PusTcSecondaryHeader for PusTcDataFieldHeader {
+        fn ack_flags(&self) -> u8 {
+            self.version_ack & 0b1111
+        }
+
+        fn service(&self) -> u8 {
+            self.service
+        }
+
+        fn subservice(&self) -> u8 {
+            self.subservice
+        }
+
+        fn source_id(&self) -> u16 {
+            self.source_id.get()
+        }
+    }
+
+    impl PusTcDataFieldHeader {
+        pub fn to_bytes(&self, slice: &mut (impl AsMut<[u8]> + ?Sized)) -> Option<()> {
+            self.write_to(slice.as_mut())
+        }
+
+        pub fn from_bytes(slice: &(impl AsRef<[u8]> + ?Sized)) -> Option<Self> {
+            Self::read_from(slice.as_ref())
+        }
+    }
+}
+
+pub mod ser {
+    use crate::ecss::{PusError, PusPacket, PusVersion, CRC_CCITT_FALSE};
+    use crate::ser::SpHeader;
+    use crate::tc::{
+        PusTcSecondaryHeader, ACK_ALL, PUC_TC_SECONDARY_HEADER_LEN,
+        PUS_TC_MIN_LEN_WITHOUT_APP_DATA, PUS_VERSION,
+    };
+    use crate::{zc, CcsdsPacket, PacketError, PacketId, PacketSequenceCtrl, PacketType};
+    use alloc::vec::Vec;
+    use core::mem::size_of;
+    use delegate::delegate;
+    use serde::{Deserialize, Serialize};
+    use zerocopy::AsBytes;
+
+    #[derive(PartialEq, Copy, Clone, Serialize, Deserialize)]
+    pub struct PusTcDataFieldHeader {
+        pub service: u8,
+        pub subservice: u8,
+        pub source_id: u16,
+        pub ack: u8,
+        pub version: PusVersion,
+    }
+
+    impl PusTcSecondaryHeader for PusTcDataFieldHeader {
+        fn ack_flags(&self) -> u8 {
+            self.ack
+        }
+
+        fn service(&self) -> u8 {
+            self.service
+        }
+
+        fn subservice(&self) -> u8 {
+            self.subservice
+        }
+
+        fn source_id(&self) -> u16 {
+            self.source_id
+        }
+    }
+    impl TryFrom<super::zc::PusTcDataFieldHeader> for PusTcDataFieldHeader {
+        type Error = ();
+
+        fn try_from(value: super::zc::PusTcDataFieldHeader) -> Result<Self, Self::Error> {
+            Ok(PusTcDataFieldHeader {
+                service: value.service(),
+                subservice: value.subservice(),
+                source_id: value.source_id(),
+                ack: value.ack_flags(),
+                version: PUS_VERSION,
+            })
+        }
+    }
+
+    impl PusTcDataFieldHeader {
+        pub fn new(service: u8, subservice: u8, ack: u8) -> Self {
+            PusTcDataFieldHeader {
+                service,
+                subservice,
+                ack: ack & 0b1111,
+                source_id: 0,
+                version: PusVersion::PusC,
+            }
+        }
+    }
+
+    #[derive(PartialEq, Copy, Clone, Serialize, Deserialize)]
+    pub struct PusTc<'slice> {
+        pub sph: SpHeader,
+        pub data_field_header: PusTcDataFieldHeader,
+        #[serde(skip)]
+        raw_data: Option<&'slice [u8]>,
+        app_data: Option<&'slice [u8]>,
+        crc16: Option<u16>,
+    }
+
+    impl<'slice> PusTc<'slice> {
+        pub fn new(
+            sph: &mut SpHeader,
+            service: u8,
+            subservice: u8,
+            app_data: Option<&'slice [u8]>,
+        ) -> Self {
+            sph.packet_id.ptype = PacketType::Tc;
+            PusTc {
+                sph: *sph,
+                raw_data: None,
+                app_data,
+                data_field_header: PusTcDataFieldHeader::new(service, subservice, ACK_ALL),
+                crc16: None,
+            }
+        }
+
+        pub fn len_packed(&self) -> usize {
+            let mut length = super::PUS_TC_MIN_LEN_WITHOUT_APP_DATA;
+            if let Some(app_data) = self.app_data {
+                length += app_data.len();
+            }
+            length
+        }
+
+        /// Calculate the CCSDS space packet data length field and sets it
+        pub fn set_ccsds_data_len(&mut self) {
+            self.sph.data_len =
+                self.len_packed() as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
+        }
+
+        fn crc_from_raw_data(&self) -> Result<u16, PusError> {
+            if let Some(raw_data) = self.raw_data {
+                if raw_data.len() < 2 {
+                    return Err(PusError::RawDataTooShort(raw_data.len()));
+                }
+                return Ok(u16::from_be_bytes(
+                    raw_data[raw_data.len() - 2..raw_data.len()]
+                        .try_into()
+                        .unwrap(),
+                ));
+            }
+            Err(PusError::NoRawData)
+        }
+
+        pub fn calc_crc16(&mut self) {
+            let mut digest = CRC_CCITT_FALSE.digest();
+            let sph_zc = crate::zc::SpHeader::from(self.sph);
+            digest.update(sph_zc.as_bytes());
+            let pus_tc_header =
+                super::zc::PusTcDataFieldHeader::try_from(self.data_field_header).unwrap();
+            digest.update(pus_tc_header.as_bytes());
+            if let Some(app_data) = self.app_data {
+                digest.update(app_data);
+            }
+            self.crc16 = Some(digest.finalize())
+        }
+
+        /// This function updates two important internal fields: The CCSDS packet length in the
+        /// space packet header and the CRC16 field. This function should be called before
+        /// the TC packet is serialized
+        pub fn update_packet_fields(&mut self) {
+            self.set_ccsds_data_len();
+            self.calc_crc16();
+        }
+
+        pub fn copy_to_buf(
+            &self,
+            slice: &mut (impl AsMut<[u8]> + ?Sized),
+        ) -> Result<usize, PusError> {
+            if self.crc16.is_none() {
+                return Err(PusError::CrcCalculationMissing);
+            }
+            let mut_slice = slice.as_mut();
+            let mut curr_idx = 0;
+            let sph_zc = crate::zc::SpHeader::from(self.sph);
+            let tc_header_len = size_of::<super::zc::PusTcDataFieldHeader>();
+            let mut total_size = super::PUS_TC_MIN_LEN_WITHOUT_APP_DATA;
+            if let Some(app_data) = self.app_data {
+                total_size += app_data.len();
+            };
+            if total_size > mut_slice.len() {
+                return Err(PusError::OtherPacketError(
+                    PacketError::ToBytesSliceTooSmall(total_size),
+                ));
+            }
+            sph_zc
+                .to_bytes(&mut mut_slice[curr_idx..curr_idx + 6])
+                .ok_or(PusError::OtherPacketError(
+                    PacketError::ToBytesZeroCopyError,
+                ))?;
+            curr_idx += 6;
+            // The PUS version is hardcoded to PUS C
+            let pus_tc_header =
+                super::zc::PusTcDataFieldHeader::try_from(self.data_field_header).unwrap();
+
+            pus_tc_header
+                .to_bytes(&mut mut_slice[curr_idx..curr_idx + tc_header_len])
+                .ok_or(PusError::OtherPacketError(
+                    PacketError::ToBytesZeroCopyError,
+                ))?;
+            curr_idx += tc_header_len;
+            if let Some(app_data) = self.app_data {
+                mut_slice[curr_idx..curr_idx + app_data.len()].copy_from_slice(app_data);
+                curr_idx += app_data.len();
+            }
+            mut_slice[curr_idx..curr_idx + 2]
+                .copy_from_slice(self.crc16.unwrap().to_be_bytes().as_slice());
+            curr_idx += 2;
+            Ok(curr_idx)
+        }
+
+        pub fn append_to_vec(&self, vec: &mut Vec<u8>) -> Result<usize, PusError> {
+            if self.crc16.is_none() {
+                return Err(PusError::CrcCalculationMissing);
+            }
+            let sph_zc = crate::zc::SpHeader::from(self.sph);
+            let mut appended_len = super::PUS_TC_MIN_LEN_WITHOUT_APP_DATA;
+            if let Some(app_data) = self.app_data {
+                appended_len += app_data.len();
+            };
+            vec.extend_from_slice(sph_zc.as_bytes());
+            // The PUS version is hardcoded to PUS C
+            let pus_tc_header =
+                super::zc::PusTcDataFieldHeader::try_from(self.data_field_header).unwrap();
+            vec.extend_from_slice(pus_tc_header.as_bytes());
+            if let Some(app_data) = self.app_data {
+                vec.extend_from_slice(app_data);
+            }
+            vec.extend_from_slice(self.crc16.unwrap().to_be_bytes().as_slice());
+            Ok(appended_len)
+        }
+
+        pub fn new_from_raw_slice(
+            slice: &'slice (impl AsRef<[u8]> + ?Sized),
+        ) -> Result<(Self, usize), PusError> {
+            let slice_ref = slice.as_ref();
+            let raw_data_len = slice_ref.len();
+            if raw_data_len < PUS_TC_MIN_LEN_WITHOUT_APP_DATA {
+                return Err(PusError::RawDataTooShort(raw_data_len));
+            }
+            let mut current_idx = 0;
+            let sph = zc::SpHeader::from_bytes(&slice_ref[current_idx..current_idx + 6]).ok_or(
+                PusError::OtherPacketError(PacketError::FromBytesZeroCopyError),
+            )?;
+            current_idx += 6;
+            let total_len = sph.total_len();
+            if raw_data_len < total_len || total_len < PUS_TC_MIN_LEN_WITHOUT_APP_DATA {
+                return Err(PusError::RawDataTooShort(raw_data_len));
+            }
+            let sec_header = crate::tc::zc::PusTcDataFieldHeader::from_bytes(
+                &slice_ref[current_idx..current_idx + PUC_TC_SECONDARY_HEADER_LEN],
+            )
+            .ok_or(PusError::OtherPacketError(
+                PacketError::FromBytesZeroCopyError,
+            ))?;
+            current_idx += PUC_TC_SECONDARY_HEADER_LEN;
+            let mut pus_tc = PusTc {
+                sph: SpHeader::from(sph),
+                data_field_header: PusTcDataFieldHeader::try_from(sec_header).unwrap(),
+                raw_data: Some(slice_ref),
+                app_data: match current_idx {
+                    _ if current_idx == total_len - 2 => None,
+                    _ if current_idx > total_len - 2 => {
+                        return Err(PusError::RawDataTooShort(raw_data_len))
+                    }
+                    _ => Some(&slice_ref[current_idx..total_len - 2]),
+                },
+                crc16: None,
+            };
+            pus_tc.crc_from_raw_data()?;
+            pus_tc.verify()?;
+            Ok((pus_tc, total_len))
+        }
+
+        fn verify(&mut self) -> Result<(), PusError> {
+            let mut digest = CRC_CCITT_FALSE.digest();
+            if self.raw_data.is_none() {
+                return Err(PusError::NoRawData);
+            }
+            let raw_data = self.raw_data.unwrap();
+            digest.update(raw_data.as_ref());
+            if digest.finalize() == 0 {
+                return Ok(());
+            }
+            let crc16 = self.crc_from_raw_data()?;
+            Err(PusError::IncorrectCrc(crc16))
+        }
+    }
+
+    //noinspection RsTraitImplementation
+    impl CcsdsPacket for PusTc<'_> {
+        delegate!(to self.sph {
+            fn ccsds_version(&self) -> u8;
+            fn packet_id(&self) -> PacketId;
+            fn psc(&self) -> PacketSequenceCtrl;
+            fn data_len(&self) -> u16;
+        });
+    }
+
+    //noinspection RsTraitImplementation
+    impl PusPacket for PusTc<'_> {
+        delegate!(to self.data_field_header {
+            fn service(&self) -> u8;
+            fn subservice(&self) -> u8;
+        });
+
+        fn user_data(&self) -> Option<&[u8]> {
+            self.app_data
+        }
+
+        fn crc16(&self) -> Option<u16> {
+            self.crc16
+        }
+    }
+
+    //noinspection RsTraitImplementation
+    impl PusTcSecondaryHeader for PusTc<'_> {
+        delegate!(to self.data_field_header {
+            fn service(&self) -> u8;
+            fn subservice(&self) -> u8;
+            fn source_id(&self) -> u16;
+            fn ack_flags(&self) -> u8;
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ecss::PusPacket;
+    use crate::ser::SpHeader;
+    use crate::tc::ser::PusTc;
+    use crate::tc::PusTcSecondaryHeader;
+    use crate::tc::ACK_ALL;
+    use crate::{CcsdsPacket, PacketType};
+    use alloc::vec::Vec;
+    use postcard::to_stdvec;
+
+    #[test]
+    fn test_tc() {
+        let mut sph = SpHeader::tc(0x01, 0, 0).unwrap();
+        let mut pus_tc = PusTc::new(&mut sph, 17, 1, None);
+        let _out = to_stdvec(&pus_tc).unwrap();
+        assert_eq!(pus_tc.crc16(), None);
+        let mut test_buf: [u8; 32] = [0; 32];
+        pus_tc.update_packet_fields();
+        verify_test_tc(&pus_tc);
+        assert_eq!(pus_tc.len_packed(), 13);
+        let size = pus_tc
+            .copy_to_buf(test_buf.as_mut_slice())
+            .expect("Error writing TC to buffer");
+        assert_eq!(size, 13);
+        let (tc_from_raw, mut size) = PusTc::new_from_raw_slice(&test_buf)
+            .expect("Creating PUS TC struct from raw buffer failed");
+        assert_eq!(size, 13);
+        verify_test_tc(&tc_from_raw);
+        verify_test_tc_raw(PacketType::Tm, &test_buf);
+
+        let mut test_vec = Vec::new();
+        size = pus_tc
+            .append_to_vec(&mut test_vec)
+            .expect("Error writing TC to vector");
+        assert_eq!(size, 13);
+        assert_eq!(&test_buf[0..pus_tc.len_packed()], test_vec.as_slice());
+        verify_test_tc_raw(PacketType::Tm, &test_vec.as_slice());
+    }
+
+    fn verify_test_tc(tc: &PusTc) {
+        assert_eq!(PusPacket::service(tc), 17);
+        assert_eq!(PusPacket::subservice(tc), 1);
+        assert_eq!(tc.user_data(), None);
+        assert_eq!(tc.source_id(), 0);
+        assert_eq!(tc.apid(), 0x01);
+        assert_eq!(tc.ack_flags(), ACK_ALL);
+        assert_eq!(tc.sph, SpHeader::tc(0x01, 0, 6).unwrap());
+    }
+
+    fn verify_test_tc_raw(ptype: PacketType, slice: &impl AsRef<[u8]>) {
+        // Reference comparison implementation:
+        // https://github.com/robamu-org/py-spacepackets/blob/main/examples/example_pus.py
+        let slice = slice.as_ref();
+        // 0x1801 is the generic
+        if ptype == PacketType::Tm {
+            assert_eq!(slice[0], 0x18);
+        } else {
+            assert_eq!(slice[0], 0x08);
+        }
+        // APID is 0x01
+        assert_eq!(slice[1], 0x01);
+        // Unsegmented packets
+        assert_eq!(slice[2], 0xc0);
+        // Sequence count 0
+        assert_eq!(slice[3], 0x00);
+        assert_eq!(slice[4], 0x00);
+        // Space data length of 6 equals total packet length of 13
+        assert_eq!(slice[5], 0x06);
+        // PUS Version C 0b0010 and ACK flags 0b1111
+        assert_eq!(slice[6], 0x2f);
+        // Service 17
+        assert_eq!(slice[7], 0x11);
+        // Subservice 1
+        assert_eq!(slice[8], 0x01);
+        // Source ID 0
+        assert_eq!(slice[9], 0x00);
+        assert_eq!(slice[10], 0x00);
+        // CRC first byte assuming big endian format is 0x16 and 0x1d
+        assert_eq!(slice[11], 0x16);
+        assert_eq!(slice[12], 0x1d);
+    }
+}

src/tm.rs

@@ -0,0 +1 @@
+