spacepackets/src/lib.rs

982 lines
32 KiB
Rust
Raw Normal View History

2022-07-31 13:31:14 +02:00
//! # CCSDS and ECSS packet standards implementations
//!
//! This crate contains generic implementations for various
//! CCSDS (Consultative Committee for Space Data Systems) and
//! ECSS (European Cooperation for Space Standardization) packet standards.
//! Currently, this includes the following components:
//!
2022-08-16 10:43:32 +02:00
//! - Space Packet implementation according to
//! [CCSDS Blue Book 133.0-B-2](https://public.ccsds.org/Pubs/133x0b2e1.pdf)
//! - PUS Telecommand and PUS Telemetry implementation according to the
//! [ECSS-E-ST-70-41C standard](https://ecss.nl/standard/ecss-e-st-70-41c-space-engineering-telemetry-and-telecommand-packet-utilization-15-april-2016/).
//! - CDS Short Time Code implementation according to
//! [CCSDS CCSDS 301.0-B-4](https://public.ccsds.org/Pubs/301x0b4e1.pdf)
2022-07-31 13:31:14 +02:00
//!
2022-08-16 10:43:32 +02:00
//! ## Features
//!
2022-09-13 10:21:52 +02:00
//! `spacepackets` supports various runtime environments and is also suitable for `no_std` environments.
2022-08-16 10:43:32 +02:00
//!
2022-12-05 00:17:37 +01:00
//! It also offers optional support for [`serde`](https://serde.rs/). This allows serializing and
2022-08-16 10:43:32 +02:00
//! deserializing them with an appropriate `serde` provider like
//! [`postcard`](https://github.com/jamesmunns/postcard).
//!
//! Default features:
//!
2022-08-16 10:51:40 +02:00
//! - [`std`](https://doc.rust-lang.org/std/): Enables functionality relying on the standard library.
2022-08-16 10:43:32 +02:00
//! - [`alloc`](https://doc.rust-lang.org/alloc/): Enables features which operate on containers
//! like [`alloc::vec::Vec`](https://doc.rust-lang.org/beta/alloc/vec/struct.Vec.html).
2022-08-16 11:03:51 +02:00
//! Enabled by the `std` feature.
2022-12-04 18:26:38 +01:00
//! - [`serde`](https://serde.rs/): Adds `serde` support for most types by adding `Serialize` and
//! `Deserialize` `derive`s
2022-08-16 10:43:32 +02:00
//!
//! ## Module
2022-07-31 13:31:14 +02:00
//!
//! This module contains helpers and data structures to generate Space Packets according to the
//! [CCSDS 133.0-B-2](https://public.ccsds.org/Pubs/133x0b2e1.pdf). This includes the
//! [SpHeader] class to generate the Space Packet Header component common to all space packets.
2022-07-31 13:31:14 +02:00
//!
2022-08-16 10:43:32 +02:00
//! ## Example
2022-07-31 13:31:14 +02:00
//!
//! ```rust
//! use spacepackets::SpHeader;
2022-12-05 01:44:53 +01:00
//! let sp_header = SpHeader::tc_unseg(0x42, 12, 1).expect("Error creating CCSDS TC header");
2022-07-31 13:31:14 +02:00
//! println!("{:?}", sp_header);
2022-12-05 01:44:28 +01:00
//! let mut ccsds_buf: [u8; 32] = [0; 32];
//! sp_header.write_to_be_bytes(&mut ccsds_buf).expect("Writing CCSDS TC header failed");
//! println!("{:x?}", &ccsds_buf[0..6]);
2022-07-31 13:31:14 +02:00
//! ```
2022-06-18 22:48:51 +02:00
#![no_std]
#![cfg_attr(doc_cfg, feature(doc_cfg))]
2022-08-16 10:11:49 +02:00
#[cfg(feature = "alloc")]
2022-06-18 22:48:51 +02:00
extern crate alloc;
2022-08-20 23:19:38 +02:00
#[cfg(any(feature = "std", test))]
2022-07-25 01:06:52 +02:00
extern crate std;
2022-06-18 22:48:51 +02:00
use crate::ecss::CCSDS_HEADER_LEN;
2022-07-31 13:31:14 +02:00
use delegate::delegate;
2022-08-16 10:11:49 +02:00
2022-12-04 12:17:36 +01:00
#[cfg(feature = "serde")]
2022-06-18 22:48:51 +02:00
use serde::{Deserialize, Serialize};
pub mod ecss;
pub mod tc;
2022-07-25 01:06:52 +02:00
pub mod time;
2022-06-18 22:48:51 +02:00
pub mod tm;
2022-09-11 20:50:46 +02:00
pub const MAX_APID: u16 = 2u16.pow(11) - 1;
pub const MAX_SEQ_COUNT: u16 = 2u16.pow(14) - 1;
2022-09-11 20:50:46 +02:00
2022-08-16 11:12:47 +02:00
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2022-12-04 12:17:36 +01:00
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct SizeMissmatch {
2022-08-08 02:02:54 +02:00
pub found: usize,
pub expected: usize,
}
2022-10-26 00:22:56 +02:00
2022-08-16 11:12:47 +02:00
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2022-12-04 12:17:36 +01:00
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum ByteConversionError {
2022-11-02 00:38:59 +01:00
/// The passed slice is too small. Returns the passed slice length and expected minimum size
ToSliceTooSmall(SizeMissmatch),
2022-11-02 00:38:59 +01:00
/// The provider buffer is too small. Returns the passed slice length and expected minimum size
FromSliceTooSmall(SizeMissmatch),
2022-06-18 22:48:51 +02:00
/// The [zerocopy] library failed to write to bytes
ZeroCopyToError,
ZeroCopyFromError,
2022-06-18 22:48:51 +02:00
}
2022-12-04 12:17:36 +01:00
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2022-06-18 22:48:51 +02:00
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()
}
2022-12-04 12:17:36 +01:00
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2022-06-18 22:48:51 +02:00
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(()),
}
}
}
2022-12-04 12:17:36 +01:00
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2022-06-18 22:48:51 +02:00
pub struct PacketId {
pub ptype: PacketType,
pub sec_header_flag: bool,
apid: u16,
}
impl Default for PacketId {
fn default() -> Self {
PacketId {
ptype: PacketType::Tm,
sec_header_flag: false,
2022-12-04 20:00:49 +01:00
apid: 0,
}
}
}
2022-06-18 22:48:51 +02:00
impl PacketId {
pub const fn const_tc(sec_header: bool, apid: u16) -> Self {
Self::const_new(PacketType::Tc, sec_header, apid)
}
pub const fn const_tm(sec_header: bool, apid: u16) -> Self {
Self::const_new(PacketType::Tm, sec_header, apid)
}
pub fn tc(sec_header: bool, apid: u16) -> Option<Self> {
Self::new(PacketType::Tc, sec_header, apid)
}
pub fn tm(sec_header: bool, apid: u16) -> Option<Self> {
Self::new(PacketType::Tm, sec_header, apid)
}
pub const fn const_new(ptype: PacketType, sec_header: bool, apid: u16) -> Self {
2022-12-04 17:11:44 +01:00
if apid > MAX_APID {
panic!("APID too large");
}
PacketId {
2022-06-18 22:48:51 +02:00
ptype,
sec_header_flag: sec_header,
2022-12-04 17:11:44 +01:00
apid,
}
}
pub fn new(ptype: PacketType, sec_header_flag: bool, apid: u16) -> Option<PacketId> {
if apid > MAX_APID {
return None;
}
Some(PacketId::const_new(ptype, sec_header_flag, apid))
2022-06-18 22:48:51 +02:00
}
2022-07-24 17:23:44 +02:00
/// Set a new Application Process ID (APID). If the passed number is invalid, the APID will
/// not be set and false will be returned. The maximum allowed value for the 11-bit field is
/// 2047
2022-06-18 22:48:51 +02:00
pub fn set_apid(&mut self, apid: u16) -> bool {
2022-09-11 20:50:46 +02:00
if apid > MAX_APID {
2022-06-18 22:48:51 +02:00
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,
}
}
}
2022-12-04 12:17:36 +01:00
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2022-06-18 22:48:51 +02:00
pub struct PacketSequenceCtrl {
pub seq_flags: SequenceFlags,
2022-07-24 15:19:05 +02:00
seq_count: u16,
2022-06-18 22:48:51 +02:00
}
impl PacketSequenceCtrl {
2022-12-04 17:11:44 +01:00
/// const variant of [PacketSequenceCtrl::new], but panics if the sequence count exceeds
/// [MAX_SEQ_COUNT].
const fn const_new(seq_flags: SequenceFlags, seq_count: u16) -> PacketSequenceCtrl {
if seq_count > MAX_SEQ_COUNT {
panic!("Sequence count too large");
}
PacketSequenceCtrl {
2022-07-24 15:19:05 +02:00
seq_flags,
2022-12-04 17:11:44 +01:00
seq_count,
}
}
/// Returns [None] if the passed sequence count exceeds [MAX_SEQ_COUNT].
pub fn new(seq_flags: SequenceFlags, seq_count: u16) -> Option<PacketSequenceCtrl> {
if seq_count > MAX_SEQ_COUNT {
return None;
}
Some(PacketSequenceCtrl::const_new(seq_flags, seq_count))
2022-06-18 22:48:51 +02:00
}
pub fn raw(&self) -> u16 {
2022-07-24 15:19:05 +02:00
((self.seq_flags as u16) << 14) | self.seq_count
2022-06-18 22:48:51 +02:00
}
2022-07-24 17:23:44 +02:00
/// Set a new sequence count. If the passed number is invalid, the sequence count will not be
2022-12-04 17:11:44 +01:00
/// set and false will be returned. The maximum allowed value for the 14-bit field is 16383.
2022-07-24 15:19:05 +02:00
pub fn set_seq_count(&mut self, ssc: u16) -> bool {
if ssc > MAX_SEQ_COUNT {
2022-06-18 22:48:51 +02:00
return false;
}
2022-07-24 15:19:05 +02:00
self.seq_count = ssc;
2022-06-18 22:48:51 +02:00
true
}
pub fn seq_count(&self) -> u16 {
2022-07-24 15:19:05 +02:00
self.seq_count
2022-06-18 22:48:51 +02:00
}
}
impl From<u16> for PacketSequenceCtrl {
fn from(raw_id: u16) -> Self {
PacketSequenceCtrl {
seq_flags: SequenceFlags::try_from(((raw_id >> 14) & 0b11) as u8).unwrap(),
2022-07-24 15:19:05 +02:00
seq_count: raw_id & SSC_MASK,
2022-06-18 22:48:51 +02:00
}
}
}
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;
2022-12-04 17:11:44 +01:00
/// Generic trait to access fields of a CCSDS space packet header according to CCSDS 133.0-B-2.
2022-06-18 22:48:51 +02:00
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
2022-12-04 17:11:44 +01:00
/// of the first 2 bytes with 0x1FFF.
2022-06-18 22:48:51 +02:00
#[inline]
fn packet_id_raw(&self) -> u16 {
self.packet_id().raw()
}
/// Retrieve Packet Sequence Count
#[inline]
fn psc_raw(&self) -> u16 {
self.psc().raw()
}
2022-12-04 17:11:44 +01:00
/// Retrieve Packet Type (TM: 0, TC: 1).
2022-06-18 22:48:51 +02:00
#[inline]
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
2022-12-04 17:11:44 +01:00
/// and false if it is not.
2022-06-18 22:48:51 +02:00
#[inline]
fn sec_header_flag(&self) -> bool {
self.packet_id().sec_header_flag
}
2022-12-04 17:11:44 +01:00
/// Retrieve Application Process ID.
2022-06-18 22:48:51 +02:00
#[inline]
fn apid(&self) -> u16 {
self.packet_id().apid
}
#[inline]
2022-07-24 15:19:05 +02:00
fn seq_count(&self) -> u16 {
self.psc().seq_count
2022-06-18 22:48:51 +02:00
}
#[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;
}
2022-12-04 17:11:44 +01:00
/// Space Packet Primary Header according to CCSDS 133.0-B-2.
2022-07-31 13:31:14 +02:00
///
/// # Arguments
///
/// * `version` - CCSDS version field, occupies the first 3 bits of the raw header. Will generally
/// be set to 0b000 in all constructors provided by this crate.
2022-07-31 13:31:14 +02:00
/// * `packet_id` - Packet Identifier, which can also be used as a start marker. Occupies the last
/// 13 bits of the first two bytes of the raw header
/// * `psc` - Packet Sequence Control, occupies the third and fourth byte of the raw header
/// * `data_len` - Data length field occupies the fifth and the sixth byte of the raw header
2022-12-04 12:17:36 +01:00
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2022-07-31 11:38:58 +02:00
pub struct SpHeader {
pub version: u8,
pub packet_id: PacketId,
pub psc: PacketSequenceCtrl,
pub data_len: u16,
}
2022-07-31 11:38:58 +02:00
impl Default for SpHeader {
/// The default function sets the sequence flag field to [SequenceFlags::Unsegmented]. The data
/// length field is set to 1, which denotes an empty space packets.
2022-07-31 11:38:58 +02:00
fn default() -> Self {
SpHeader {
version: 0,
packet_id: PacketId::default(),
2022-07-31 11:38:58 +02:00
psc: PacketSequenceCtrl {
seq_flags: SequenceFlags::Unsegmented,
seq_count: 0,
},
data_len: 1,
2022-06-18 22:48:51 +02:00
}
}
2022-07-31 11:38:58 +02:00
}
2022-12-04 17:11:44 +01:00
2022-07-31 11:38:58 +02:00
impl SpHeader {
2022-12-04 20:00:49 +01:00
pub const fn new(packet_id: PacketId, psc: PacketSequenceCtrl, data_len: u16) -> Self {
Self {
version: 0,
packet_id,
psc,
2022-12-04 20:00:49 +01:00
data_len,
}
}
/// const variant of the [SpHeader::new_fron_single_fields] function. Panics if the passed
/// APID exceeds [MAX_APID] or the passed packet sequence count exceeds [MAX_SEQ_COUNT].
const fn const_new_from_single_fields(
ptype: PacketType,
sec_header: bool,
apid: u16,
seq_flags: SequenceFlags,
seq_count: u16,
2022-12-04 20:00:49 +01:00
data_len: u16,
) -> Self {
if seq_count > MAX_SEQ_COUNT {
panic!("Sequence count is too large");
}
if apid > MAX_APID {
panic!("APID is too large");
}
Self {
psc: PacketSequenceCtrl::const_new(seq_flags, seq_count),
packet_id: PacketId::const_new(ptype, sec_header, apid),
data_len,
2022-12-04 20:00:49 +01:00
version: 0,
}
}
/// Create a new Space Packet Header instance which can be used to create generic
/// Space Packets. This will return [None] if the APID or sequence count argument
/// exceed [MAX_APID] or [MAX_SEQ_COUNT] respectively. The version field is set to 0b000.
pub fn new_from_single_fields(
2022-07-31 13:31:14 +02:00
ptype: PacketType,
sec_header: bool,
apid: u16,
seq_flags: SequenceFlags,
seq_count: u16,
2022-07-31 13:31:14 +02:00
data_len: u16,
) -> Option<Self> {
if seq_count > MAX_SEQ_COUNT || apid > MAX_APID {
2022-07-31 11:38:58 +02:00
return None;
2022-06-18 22:48:51 +02:00
}
2022-12-04 20:00:49 +01:00
Some(SpHeader::const_new_from_single_fields(
ptype, sec_header, apid, seq_flags, seq_count, data_len,
))
2022-07-31 11:38:58 +02:00
}
2022-06-18 22:48:51 +02:00
/// Helper function for telemetry space packet headers. The packet type field will be
/// set accordingly. The secondary header flag field is set to false.
pub fn tm(apid: u16, seq_flags: SequenceFlags, seq_count: u16, data_len: u16) -> Option<Self> {
Self::new_from_single_fields(PacketType::Tm, false, apid, seq_flags, seq_count, data_len)
2022-07-31 11:38:58 +02:00
}
2022-06-18 22:48:51 +02:00
/// Helper function for telemetry space packet headers. The packet type field will be
/// set accordingly. The secondary header flag field is set to false.
pub fn tc(apid: u16, seq_flags: SequenceFlags, seq_count: u16, data_len: u16) -> Option<Self> {
Self::new_from_single_fields(PacketType::Tc, false, apid, seq_flags, seq_count, data_len)
}
/// Variant of [SpHeader::tm] which sets the sequence flag field to [SequenceFlags::Unsegmented]
pub fn tm_unseg(apid: u16, seq_count: u16, data_len: u16) -> Option<Self> {
Self::tm(apid, SequenceFlags::Unsegmented, seq_count, data_len)
}
/// Variant of [SpHeader::tc] which sets the sequence flag field to [SequenceFlags::Unsegmented]
pub fn tc_unseg(apid: u16, seq_count: u16, data_len: u16) -> Option<Self> {
Self::tc(apid, SequenceFlags::Unsegmented, seq_count, data_len)
2022-06-18 22:48:51 +02:00
}
2022-07-31 11:38:58 +02:00
//noinspection RsTraitImplementation
delegate!(to self.packet_id {
2022-12-05 09:03:40 +01:00
/// Returns [false] and fails if the APID exceeds [MAX_APID]
2022-07-31 11:38:58 +02:00
pub fn set_apid(&mut self, apid: u16) -> bool;
});
2022-06-18 22:48:51 +02:00
2022-07-31 11:38:58 +02:00
delegate!(to self.psc {
2022-12-05 09:03:40 +01:00
/// Returns [false] and fails if the sequence count exceeds [MAX_SEQ_COUNT]
2022-07-31 11:38:58 +02:00
pub fn set_seq_count(&mut self, seq_count: u16) -> bool;
});
2022-06-18 22:48:51 +02:00
2022-07-31 11:38:58 +02:00
pub fn set_seq_flags(&mut self, seq_flags: SequenceFlags) {
self.psc.seq_flags = seq_flags;
}
2022-06-18 22:48:51 +02:00
2022-07-31 11:38:58 +02:00
pub fn set_sec_header_flag(&mut self) {
self.packet_id.sec_header_flag = true;
2022-06-18 22:48:51 +02:00
}
2022-07-31 11:38:58 +02:00
pub fn clear_sec_header_flag(&mut self) {
self.packet_id.sec_header_flag = false;
}
pub fn set_packet_type(&mut self, packet_type: PacketType) {
self.packet_id.ptype = packet_type;
2022-06-18 22:48:51 +02:00
}
2022-08-08 01:23:38 +02:00
2022-12-05 01:41:35 +01:00
/// Create a struct from a raw slice where the fields have network endianness (big).
2022-12-05 08:55:24 +01:00
/// This function also returns the remaining part of the passed slice starting past the read
/// CCSDS header.
2022-12-05 01:41:35 +01:00
pub fn from_be_bytes(buf: &[u8]) -> Result<(Self, &[u8]), ByteConversionError> {
if buf.len() < CCSDS_HEADER_LEN {
return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
2022-08-08 01:23:38 +02:00
found: buf.len(),
2022-12-05 01:41:35 +01:00
expected: CCSDS_HEADER_LEN,
2022-08-08 01:23:38 +02:00
}));
}
2022-08-08 11:16:55 +02:00
let zc_header = zc::SpHeader::from_bytes(&buf[0..CCSDS_HEADER_LEN])
.ok_or(ByteConversionError::ZeroCopyFromError)?;
2022-12-05 01:41:35 +01:00
Ok((Self::from(zc_header), &buf[CCSDS_HEADER_LEN..]))
}
/// Write the header to a raw buffer using big endian format. This function returns the
/// remaining part of the passed slice starting past the written CCSDS header.
pub fn write_to_be_bytes<'a>(
&self,
buf: &'a mut [u8],
) -> Result<&'a mut [u8], ByteConversionError> {
if buf.len() < CCSDS_HEADER_LEN {
return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
found: buf.len(),
expected: CCSDS_HEADER_LEN,
}));
}
let zc_header: zc::SpHeader = zc::SpHeader::from(*self);
zc_header
.to_bytes(&mut buf[0..CCSDS_HEADER_LEN])
.ok_or(ByteConversionError::ZeroCopyToError)?;
Ok(&mut buf[CCSDS_HEADER_LEN..])
2022-08-08 01:23:38 +02:00
}
2022-07-31 11:38:58 +02:00
}
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
}
}
2022-06-18 22:48:51 +02:00
2022-07-31 11:38:58 +02:00
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,
}
}
2022-06-18 22:48:51 +02:00
}
2022-07-31 11:38:58 +02:00
sph_from_other!(SpHeader, crate::zc::SpHeader);
2022-06-18 22:48:51 +02:00
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),
}
}
2022-08-08 01:23:38 +02:00
pub fn from_bytes(slice: &[u8]) -> Option<Self> {
SpHeader::read_from(slice)
2022-06-18 22:48:51 +02:00
}
2022-08-08 01:23:38 +02:00
pub fn to_bytes(&self, slice: &mut [u8]) -> Option<()> {
self.write_to(slice)
2022-06-18 22:48:51 +02:00
}
}
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)
}
}
2022-07-31 11:38:58 +02:00
sph_from_other!(SpHeader, crate::SpHeader);
2022-06-18 22:48:51 +02:00
}
2022-12-04 17:11:44 +01:00
#[cfg(all(test, feature = "std"))]
2022-06-18 22:48:51 +02:00
mod tests {
2022-12-04 17:11:44 +01:00
#[cfg(feature = "serde")]
2022-08-16 10:11:49 +02:00
use crate::CcsdsPrimaryHeader;
2022-06-18 22:48:51 +02:00
use crate::{
2022-08-16 10:11:49 +02:00
packet_type_in_raw_packet_id, zc, CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType,
2022-06-18 22:48:51 +02:00
};
2022-12-04 20:00:49 +01:00
use crate::{SequenceFlags, SpHeader};
2022-06-18 22:48:51 +02:00
use alloc::vec;
2022-08-16 10:11:49 +02:00
use num_traits::pow;
2022-12-04 17:11:44 +01:00
#[cfg(feature = "serde")]
use postcard::{from_bytes, to_allocvec};
2022-06-18 22:48:51 +02:00
const CONST_SP: SpHeader = SpHeader::new(
PacketId::const_tc(true, 0x36),
PacketSequenceCtrl::const_new(SequenceFlags::ContinuationSegment, 0x88),
2022-12-04 20:00:49 +01:00
0x90,
);
2022-12-04 19:56:21 +01:00
const PACKET_ID_TM: PacketId = PacketId::const_tm(true, 0x22);
#[test]
fn verify_const_packet_id() {
assert_eq!(PACKET_ID_TM.apid(), 0x22);
assert_eq!(PACKET_ID_TM.sec_header_flag, true);
assert_eq!(PACKET_ID_TM.ptype, PacketType::Tm);
let const_tc_id = PacketId::const_tc(true, 0x23);
assert_eq!(const_tc_id.ptype, PacketType::Tc);
}
#[test]
fn test_default_packet_id() {
let id_default = PacketId::default();
assert_eq!(id_default.ptype, PacketType::Tm);
assert_eq!(id_default.apid, 0x000);
assert_eq!(id_default.sec_header_flag, false);
}
#[test]
fn test_packet_id_ctors() {
let packet_id = PacketId::new(PacketType::Tc, true, 0x1ff);
assert!(packet_id.is_some());
let packet_id = packet_id.unwrap();
assert_eq!(packet_id.apid(), 0x1ff);
assert_eq!(packet_id.ptype, PacketType::Tc);
assert_eq!(packet_id.sec_header_flag, true);
let packet_id_tc = PacketId::tc(true, 0x1ff);
assert!(packet_id_tc.is_some());
let packet_id_tc = packet_id_tc.unwrap();
assert_eq!(packet_id_tc, packet_id);
let packet_id_tm = PacketId::tm(true, 0x2ff);
assert!(packet_id_tm.is_some());
let packet_id_tm = packet_id_tm.unwrap();
assert_eq!(packet_id_tm.sec_header_flag, true);
assert_eq!(packet_id_tm.ptype, PacketType::Tm);
assert_eq!(packet_id_tm.apid, 0x2ff);
}
#[test]
fn verify_const_sp_header() {
assert_eq!(CONST_SP.sec_header_flag(), true);
assert_eq!(CONST_SP.apid(), 0x36);
2022-12-04 20:00:49 +01:00
assert_eq!(
CONST_SP.sequence_flags(),
SequenceFlags::ContinuationSegment
);
assert_eq!(CONST_SP.seq_count(), 0x88);
assert_eq!(CONST_SP.data_len, 0x90);
}
2022-06-18 22:48:51 +02:00
#[test]
2022-07-24 17:23:44 +02:00
fn test_seq_flag_helpers() {
2022-06-18 22:48:51 +02:00
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());
2022-07-24 17:23:44 +02:00
}
#[test]
fn test_packet_type_helper() {
assert_eq!(PacketType::try_from(0b00).unwrap(), PacketType::Tm);
assert_eq!(PacketType::try_from(0b01).unwrap(), PacketType::Tc);
2022-06-18 22:48:51 +02:00
assert!(PacketType::try_from(0b10).is_err());
2022-07-24 17:23:44 +02:00
}
#[test]
fn test_packet_id() {
2022-06-18 22:48:51 +02:00
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);
2022-07-24 17:23:44 +02:00
let packet_id_from_new = PacketId::new(PacketType::Tm, false, 0x42).unwrap();
assert_eq!(packet_id_from_new, packet_id);
}
2022-06-18 22:48:51 +02:00
2022-07-24 17:23:44 +02:00
#[test]
fn test_invalid_packet_id() {
2022-06-18 22:48:51 +02:00
let packet_id_invalid = PacketId::new(PacketType::Tc, true, 0xFFFF);
assert!(packet_id_invalid.is_none());
2022-07-24 17:23:44 +02:00
}
#[test]
fn test_invalid_apid_setter() {
let mut packet_id =
PacketId::new(PacketType::Tm, false, 0x42).expect("Packet ID creation failed");
assert!(!packet_id.set_apid(0xffff));
}
#[test]
fn test_invalid_seq_count() {
let mut psc = PacketSequenceCtrl::new(SequenceFlags::ContinuationSegment, 77)
.expect("PSC creation failed");
assert!(!psc.set_seq_count(0xffff));
}
#[test]
fn test_packet_seq_ctrl() {
2022-06-18 22:48:51 +02:00
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
2022-08-16 10:11:49 +02:00
assert!(!psc.set_seq_count(2u16.pow(15)));
2022-06-18 22:48:51 +02:00
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]
2022-12-04 17:11:44 +01:00
#[cfg(feature = "serde")]
2022-06-18 22:48:51 +02:00
fn test_serde_sph() {
let sp_header = SpHeader::tc_unseg(0x42, 12, 0).expect("Error creating SP header");
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.ccsds_version(), 0b000);
assert!(sp_header.is_tc());
2022-07-31 11:38:58 +02:00
assert!(!sp_header.sec_header_flag());
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.ptype(), PacketType::Tc);
2022-07-24 15:19:05 +02:00
assert_eq!(sp_header.seq_count(), 12);
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.apid(), 0x42);
assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
assert_eq!(sp_header.data_len(), 0);
2022-08-16 10:11:49 +02:00
let output = to_allocvec(&sp_header).unwrap();
2022-06-18 22:48:51 +02:00
let sp_header: SpHeader = from_bytes(&output).unwrap();
assert_eq!(sp_header.version, 0b000);
2022-07-31 11:38:58 +02:00
assert!(!sp_header.packet_id.sec_header_flag);
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.ptype(), PacketType::Tc);
2022-07-24 15:19:05 +02:00
assert_eq!(sp_header.seq_count(), 12);
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.apid(), 0x42);
assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
2022-07-31 11:38:58 +02:00
assert_eq!(sp_header.packet_id_raw(), 0x1042);
2022-06-18 22:48:51 +02:00
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_unseg(0x7, 22, 36).expect("Error creating SP header");
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.ccsds_version(), 0b000);
assert!(sp_header.is_tm());
2022-07-31 11:38:58 +02:00
assert!(!sp_header.sec_header_flag());
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.ptype(), PacketType::Tm);
2022-07-24 15:19:05 +02:00
assert_eq!(sp_header.seq_count(), 22);
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.apid(), 0x07);
assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
2022-07-31 11:38:58 +02:00
assert_eq!(sp_header.packet_id_raw(), 0x0007);
2022-06-18 22:48:51 +02:00
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
);
2022-07-24 15:19:05 +02:00
assert_eq!(from_comp_fields.seq_count(), 0x7);
2022-06-18 22:48:51 +02:00
assert_eq!(from_comp_fields.data_len(), 0);
}
2022-07-31 11:38:58 +02:00
#[test]
fn test_setters() {
let sp_header = SpHeader::tc(0x42, SequenceFlags::Unsegmented, 25, 0);
assert!(sp_header.is_some());
let mut sp_header = sp_header.unwrap();
2022-07-31 11:38:58 +02:00
sp_header.set_apid(0x12);
assert_eq!(sp_header.apid(), 0x12);
sp_header.set_sec_header_flag();
assert!(sp_header.sec_header_flag());
sp_header.clear_sec_header_flag();
assert!(!sp_header.sec_header_flag());
assert_eq!(sp_header.ptype(), PacketType::Tc);
sp_header.set_packet_type(PacketType::Tm);
assert_eq!(sp_header.ptype(), PacketType::Tm);
sp_header.set_seq_count(0x45);
assert_eq!(sp_header.seq_count(), 0x45);
}
#[test]
fn test_tc_ctor() {
let sp_header = SpHeader::tc(0x42, SequenceFlags::Unsegmented, 25, 0);
assert!(sp_header.is_some());
let sp_header = sp_header.unwrap();
verify_sp_fields(PacketType::Tc, &sp_header);
}
#[test]
fn test_tc_ctor_unseg() {
let sp_header = SpHeader::tc_unseg(0x42, 25, 0);
assert!(sp_header.is_some());
let sp_header = sp_header.unwrap();
verify_sp_fields(PacketType::Tc, &sp_header);
}
#[test]
fn test_tm_ctor() {
let sp_header = SpHeader::tm(0x42, SequenceFlags::Unsegmented, 25, 0);
assert!(sp_header.is_some());
let sp_header = sp_header.unwrap();
verify_sp_fields(PacketType::Tm, &sp_header);
}
#[test]
fn test_tm_ctor_unseg() {
let sp_header = SpHeader::tm_unseg(0x42, 25, 0);
assert!(sp_header.is_some());
let sp_header = sp_header.unwrap();
verify_sp_fields(PacketType::Tm, &sp_header);
}
fn verify_sp_fields(ptype: PacketType, sp_header: &SpHeader) {
assert_eq!(sp_header.ptype(), ptype);
assert_eq!(sp_header.sequence_flags(), SequenceFlags::Unsegmented);
assert_eq!(sp_header.apid(), 0x42);
assert_eq!(sp_header.seq_count(), 25);
assert_eq!(sp_header.data_len(), 0);
2022-07-31 11:38:58 +02:00
}
2022-06-18 22:48:51 +02:00
#[test]
fn test_zc_sph() {
use zerocopy::AsBytes;
2022-12-04 20:00:49 +01:00
let sp_header =
SpHeader::tc_unseg(0x7FF, pow(2, 14) - 1, 0).expect("Error creating SP header");
2022-06-18 22:48:51 +02:00
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);
2022-07-31 11:45:35 +02:00
assert_eq!(slice[0], 0x17);
2022-06-18 22:48:51 +02:00
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);
2022-07-31 11:45:35 +02:00
assert_eq!(slice[0], 0x17);
2022-06-18 22:48:51 +02:00
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);
2022-07-31 11:45:35 +02:00
assert_eq!(slice[0], 0x17);
2022-06-18 22:48:51 +02:00
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);
2022-07-31 11:45:35 +02:00
assert_eq!(sp_header.packet_id_raw(), 0x17FF);
2022-06-18 22:48:51 +02:00
assert_eq!(sp_header.apid(), 0x7FF);
assert_eq!(sp_header.ptype(), PacketType::Tc);
assert_eq!(sp_header.data_len(), 0);
}
}