spacepackets/src/tm.rs

822 lines
29 KiB
Rust
Raw Normal View History

2022-07-31 13:31:14 +02:00
//! This module contains all components required to create a ECSS PUS C telemetry packets according
//! to [ECSS-E-ST-70-41C](https://ecss.nl/standard/ecss-e-st-70-41c-space-engineering-telemetry-and-telecommand-packet-utilization-15-april-2016/).
use crate::ecss::{
2023-07-05 19:07:31 +02:00
calc_pus_crc16, ccsds_impl, crc_from_raw_data, crc_procedure, sp_header_impls,
user_data_from_raw, verify_crc16_ccitt_false_from_raw_to_pus_error, CrcType, PusError,
PusPacket, PusVersion, SerializablePusPacket,
2022-07-31 14:24:16 +02:00
};
use crate::{
ByteConversionError, CcsdsPacket, PacketType, SequenceFlags, SizeMissmatch, SpHeader,
2023-07-05 19:25:05 +02:00
CCSDS_HEADER_LEN, CRC_CCITT_FALSE, MAX_APID, MAX_SEQ_COUNT,
2022-07-31 13:31:14 +02:00
};
2022-07-31 02:27:27 +02:00
use core::mem::size_of;
2022-12-04 12:17:36 +01:00
#[cfg(feature = "serde")]
2022-07-31 02:27:27 +02:00
use serde::{Deserialize, Serialize};
use zerocopy::AsBytes;
2022-06-18 22:48:51 +02:00
2022-07-31 11:38:58 +02:00
#[cfg(feature = "alloc")]
use alloc::vec::Vec;
2022-07-31 13:31:14 +02:00
use delegate::delegate;
2022-07-31 11:38:58 +02:00
2022-07-31 02:27:27 +02:00
/// Length without timestamp
pub const PUC_TM_MIN_SEC_HEADER_LEN: usize = 7;
pub const PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA: usize =
CCSDS_HEADER_LEN + PUC_TM_MIN_SEC_HEADER_LEN + size_of::<CrcType>();
2022-12-04 17:11:44 +01:00
pub trait GenericPusTmSecondaryHeader {
2022-07-31 13:31:14 +02:00
fn pus_version(&self) -> PusVersion;
fn sc_time_ref_status(&self) -> u8;
fn service(&self) -> u8;
fn subservice(&self) -> u8;
fn msg_counter(&self) -> u16;
fn dest_id(&self) -> u16;
}
2022-07-31 02:27:27 +02:00
pub mod zc {
2022-12-04 17:11:44 +01:00
use super::GenericPusTmSecondaryHeader;
2022-07-31 02:27:27 +02:00
use crate::ecss::{PusError, PusVersion};
use zerocopy::{AsBytes, FromBytes, NetworkEndian, Unaligned, U16};
#[derive(FromBytes, AsBytes, Unaligned)]
#[repr(C)]
pub struct PusTmSecHeaderWithoutTimestamp {
pus_version_and_sc_time_ref_status: u8,
service: u8,
subservice: u8,
msg_counter: U16<NetworkEndian>,
dest_id: U16<NetworkEndian>,
}
2022-07-31 13:31:14 +02:00
pub struct PusTmSecHeader<'slice> {
pub(crate) zc_header: PusTmSecHeaderWithoutTimestamp,
2023-01-16 11:56:25 +01:00
pub(crate) timestamp: Option<&'slice [u8]>,
2022-07-31 13:31:14 +02:00
}
2022-07-31 02:27:27 +02:00
impl TryFrom<crate::tm::PusTmSecondaryHeader<'_>> for PusTmSecHeaderWithoutTimestamp {
type Error = PusError;
fn try_from(header: crate::tm::PusTmSecondaryHeader) -> Result<Self, Self::Error> {
if header.pus_version != PusVersion::PusC {
return Err(PusError::VersionNotSupported(header.pus_version));
}
Ok(PusTmSecHeaderWithoutTimestamp {
pus_version_and_sc_time_ref_status: ((header.pus_version as u8) << 4)
| header.sc_time_ref_status,
service: header.service,
subservice: header.subservice,
msg_counter: U16::from(header.msg_counter),
dest_id: U16::from(header.dest_id),
})
}
}
impl PusTmSecHeaderWithoutTimestamp {
2022-09-11 20:50:46 +02:00
pub fn write_to_bytes(&self, slice: &mut [u8]) -> Option<()> {
2022-07-31 02:27:27 +02:00
self.write_to(slice)
}
pub fn from_bytes(slice: &[u8]) -> Option<Self> {
Self::read_from(slice)
}
}
2022-07-31 13:31:14 +02:00
2022-12-04 17:11:44 +01:00
impl GenericPusTmSecondaryHeader for PusTmSecHeaderWithoutTimestamp {
2022-07-31 13:31:14 +02:00
fn pus_version(&self) -> PusVersion {
PusVersion::try_from(self.pus_version_and_sc_time_ref_status >> 4 & 0b1111)
.unwrap_or(PusVersion::Invalid)
}
fn sc_time_ref_status(&self) -> u8 {
self.pus_version_and_sc_time_ref_status & 0b1111
}
fn service(&self) -> u8 {
self.service
}
fn subservice(&self) -> u8 {
self.subservice
}
fn msg_counter(&self) -> u16 {
self.msg_counter.get()
}
fn dest_id(&self) -> u16 {
self.dest_id.get()
}
}
2022-07-31 02:27:27 +02:00
}
2022-12-04 12:17:36 +01:00
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2023-01-10 16:19:21 +01:00
pub struct PusTmSecondaryHeader<'stamp> {
2022-07-31 02:27:27 +02:00
pus_version: PusVersion,
pub sc_time_ref_status: u8,
pub service: u8,
pub subservice: u8,
pub msg_counter: u16,
pub dest_id: u16,
2023-01-16 11:56:25 +01:00
pub timestamp: Option<&'stamp [u8]>,
2022-07-31 02:27:27 +02:00
}
2023-01-10 16:19:21 +01:00
impl<'stamp> PusTmSecondaryHeader<'stamp> {
2023-01-16 11:56:25 +01:00
pub fn new_simple(service: u8, subservice: u8, timestamp: &'stamp [u8]) -> Self {
Self::new(service, subservice, 0, 0, Some(timestamp))
}
2023-01-20 19:46:26 +01:00
/// Like [Self::new_simple] but without a timestamp.
2023-01-16 11:56:25 +01:00
pub fn new_simple_no_timestamp(service: u8, subservice: u8) -> Self {
Self::new(service, subservice, 0, 0, None)
2022-07-31 02:27:27 +02:00
}
pub fn new(
service: u8,
subservice: u8,
msg_counter: u16,
dest_id: u16,
2023-01-16 11:56:25 +01:00
timestamp: Option<&'stamp [u8]>,
2022-07-31 02:27:27 +02:00
) -> Self {
PusTmSecondaryHeader {
pus_version: PusVersion::PusC,
sc_time_ref_status: 0,
service,
subservice,
msg_counter,
dest_id,
2023-01-16 11:56:25 +01:00
timestamp,
2022-07-31 02:27:27 +02:00
}
}
}
2022-12-04 17:11:44 +01:00
impl GenericPusTmSecondaryHeader for PusTmSecondaryHeader<'_> {
2022-07-31 13:31:14 +02:00
fn pus_version(&self) -> PusVersion {
self.pus_version
}
fn sc_time_ref_status(&self) -> u8 {
self.sc_time_ref_status
}
fn service(&self) -> u8 {
self.service
}
fn subservice(&self) -> u8 {
self.subservice
}
fn msg_counter(&self) -> u16 {
self.msg_counter
}
fn dest_id(&self) -> u16 {
self.dest_id
}
}
impl<'slice> TryFrom<zc::PusTmSecHeader<'slice>> for PusTmSecondaryHeader<'slice> {
type Error = ();
fn try_from(sec_header: zc::PusTmSecHeader<'slice>) -> Result<Self, Self::Error> {
Ok(PusTmSecondaryHeader {
pus_version: sec_header.zc_header.pus_version(),
sc_time_ref_status: sec_header.zc_header.sc_time_ref_status(),
service: sec_header.zc_header.service(),
subservice: sec_header.zc_header.subservice(),
msg_counter: sec_header.zc_header.msg_counter(),
dest_id: sec_header.zc_header.dest_id(),
2023-01-16 11:56:25 +01:00
timestamp: sec_header.timestamp,
2022-07-31 13:31:14 +02:00
})
}
}
2023-01-22 18:26:38 +01:00
/// This class models the PUS C telemetry packet. It is the primary data structure to generate the
/// raw byte representation of PUS telemetry or to deserialize from one from raw bytes.
2022-07-31 02:27:27 +02:00
///
2022-12-05 09:03:40 +01:00
/// This class also derives the [serde::Serialize] and [serde::Deserialize] trait if the [serde]
/// feature is used which allows to send around TM packets in a raw byte format using a serde
/// provider like [postcard](https://docs.rs/postcard/latest/postcard/).
2022-07-31 13:31:14 +02:00
///
2022-07-31 02:27:27 +02:00
/// There is no spare bytes support yet.
2023-01-10 16:20:50 +01:00
///
/// # Lifetimes
///
2023-01-26 21:28:39 +01:00
/// * `'raw_data` - If the TM is not constructed from a raw slice, this will be the life time of
/// a buffer where the user provided time stamp and source data will be serialized into. If it
/// is, this is the lifetime of the raw byte slice it is constructed from.
2023-01-26 19:24:41 +01:00
#[derive(Eq, Debug, Copy, Clone)]
2022-12-04 12:17:36 +01:00
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
2023-01-26 21:28:39 +01:00
pub struct PusTm<'raw_data> {
2022-07-31 02:27:27 +02:00
pub sp_header: SpHeader,
2023-01-26 21:28:39 +01:00
pub sec_header: PusTmSecondaryHeader<'raw_data>,
2022-07-31 02:27:27 +02:00
/// If this is set to false, a manual call to [PusTm::calc_own_crc16] or
/// [PusTm::update_packet_fields] is necessary for the serialized or cached CRC16 to be valid.
pub calc_crc_on_serialization: bool,
2022-12-04 12:17:36 +01:00
#[cfg_attr(feature = "serde", serde(skip))]
2023-01-26 21:28:39 +01:00
raw_data: Option<&'raw_data [u8]>,
source_data: Option<&'raw_data [u8]>,
2022-07-31 02:27:27 +02:00
crc16: Option<u16>,
}
2023-01-26 21:28:39 +01:00
impl<'raw_data> PusTm<'raw_data> {
2022-07-31 02:27:27 +02:00
/// Generates a new struct instance.
///
/// # Arguments
///
/// * `sp_header` - Space packet header information. The correct packet type will be set
/// automatically
2022-07-31 13:31:14 +02:00
/// * `sec_header` - Information contained in the secondary header, including the service
2022-07-31 02:27:27 +02:00
/// and subservice type
2022-07-31 13:31:14 +02:00
/// * `app_data` - Custom application data
2022-07-31 02:27:27 +02:00
/// * `set_ccsds_len` - Can be used to automatically update the CCSDS space packet data length
/// field. If this is not set to true, [PusTm::update_ccsds_data_len] can be called to set
/// the correct value to this field manually
pub fn new(
sp_header: &mut SpHeader,
2023-01-26 21:28:39 +01:00
sec_header: PusTmSecondaryHeader<'raw_data>,
source_data: Option<&'raw_data [u8]>,
2022-07-31 02:27:27 +02:00
set_ccsds_len: bool,
) -> Self {
2022-07-31 11:38:58 +02:00
sp_header.set_packet_type(PacketType::Tm);
sp_header.set_sec_header_flag();
2022-07-31 02:27:27 +02:00
let mut pus_tm = PusTm {
sp_header: *sp_header,
raw_data: None,
source_data,
sec_header,
calc_crc_on_serialization: true,
crc16: None,
};
if set_ccsds_len {
pus_tm.update_ccsds_data_len();
}
pus_tm
}
2023-01-26 21:28:39 +01:00
pub fn timestamp(&self) -> Option<&'raw_data [u8]> {
2023-01-16 11:56:25 +01:00
self.sec_header.timestamp
2022-07-31 13:43:40 +02:00
}
2023-01-26 21:28:39 +01:00
pub fn source_data(&self) -> Option<&'raw_data [u8]> {
self.source_data
}
2022-07-31 14:24:16 +02:00
pub fn set_dest_id(&mut self, dest_id: u16) {
self.sec_header.dest_id = dest_id;
}
pub fn set_msg_counter(&mut self, msg_counter: u16) {
self.sec_header.msg_counter = msg_counter
}
pub fn set_sc_time_ref_status(&mut self, sc_time_ref_status: u8) {
self.sec_header.sc_time_ref_status = sc_time_ref_status & 0b1111;
}
sp_header_impls!();
2022-07-31 13:31:14 +02:00
/// This is called automatically if the `set_ccsds_len` argument in the [PusTm::new] call was
/// used.
2022-07-31 02:27:27 +02:00
/// If this was not done or the time stamp or source data is set or changed after construction,
/// this function needs to be called to ensure that the data length field of the CCSDS header
/// is set correctly
pub fn update_ccsds_data_len(&mut self) {
self.sp_header.data_len =
self.len_packed() as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
}
/// This function should be called before the TM packet is serialized if
2022-07-31 13:31:14 +02:00
/// [PusTm.calc_crc_on_serialization] is set to False. It will calculate and cache the CRC16.
2022-07-31 02:27:27 +02:00
pub fn calc_own_crc16(&mut self) {
let mut digest = CRC_CCITT_FALSE.digest();
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
digest.update(sph_zc.as_bytes());
let pus_tc_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();
digest.update(pus_tc_header.as_bytes());
2023-01-16 11:56:25 +01:00
if let Some(stamp) = self.sec_header.timestamp {
digest.update(stamp);
}
2022-07-31 02:27:27 +02:00
if let Some(src_data) = self.source_data {
digest.update(src_data);
}
self.crc16 = Some(digest.finalize())
}
2022-07-31 13:31:14 +02:00
/// This helper function calls both [PusTm.update_ccsds_data_len] and [PusTm.calc_own_crc16]
2022-07-31 02:27:27 +02:00
pub fn update_packet_fields(&mut self) {
self.update_ccsds_data_len();
self.calc_own_crc16();
}
2022-07-31 13:31:14 +02:00
/// Append the raw PUS byte representation to a provided [alloc::vec::Vec]
2022-07-31 11:38:58 +02:00
#[cfg(feature = "alloc")]
2022-10-26 00:22:56 +02:00
#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
2022-07-31 11:38:58 +02:00
pub fn append_to_vec(&self, vec: &mut Vec<u8>) -> Result<usize, PusError> {
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
2023-01-16 11:56:25 +01:00
let mut appended_len = PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA;
if let Some(timestamp) = self.sec_header.timestamp {
appended_len += timestamp.len();
}
2022-07-31 11:38:58 +02:00
if let Some(src_data) = self.source_data {
appended_len += src_data.len();
};
let start_idx = vec.len();
2022-08-01 01:08:06 +02:00
let mut ser_len = 0;
2022-07-31 11:38:58 +02:00
vec.extend_from_slice(sph_zc.as_bytes());
2022-08-01 01:08:06 +02:00
ser_len += sph_zc.as_bytes().len();
2022-07-31 11:38:58 +02:00
// The PUS version is hardcoded to PUS C
let sec_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();
vec.extend_from_slice(sec_header.as_bytes());
2022-08-01 01:08:06 +02:00
ser_len += sec_header.as_bytes().len();
2023-01-16 11:56:25 +01:00
if let Some(timestamp) = self.sec_header.timestamp {
ser_len += timestamp.len();
vec.extend_from_slice(timestamp);
}
2022-07-31 11:38:58 +02:00
if let Some(src_data) = self.source_data {
vec.extend_from_slice(src_data);
2022-08-01 01:08:06 +02:00
ser_len += src_data.len();
2022-07-31 11:38:58 +02:00
}
let crc16 = crc_procedure(
self.calc_crc_on_serialization,
&self.crc16,
2022-08-01 01:08:06 +02:00
start_idx,
ser_len,
&vec[start_idx..start_idx + ser_len],
2022-07-31 11:38:58 +02:00
)?;
vec.extend_from_slice(crc16.to_be_bytes().as_slice());
Ok(appended_len)
}
2022-07-31 13:31:14 +02:00
/// Create a [PusTm] instance from a raw slice. On success, it returns a tuple containing
/// the instance and the found byte length of the packet. The timestamp length needs to be
/// known beforehand.
2022-09-13 10:28:20 +02:00
pub fn from_bytes(
2023-01-26 21:28:39 +01:00
slice: &'raw_data [u8],
2022-07-31 13:31:14 +02:00
timestamp_len: usize,
) -> Result<(Self, usize), PusError> {
let raw_data_len = slice.len();
if raw_data_len < PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA {
return Err(PusError::RawDataTooShort(raw_data_len));
}
let mut current_idx = 0;
2022-12-05 01:41:35 +01:00
let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?;
2022-07-31 13:31:14 +02:00
current_idx += 6;
2022-12-05 01:41:35 +01:00
let total_len = sp_header.total_len();
2022-07-31 13:31:14 +02:00
if raw_data_len < total_len || total_len < PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA {
return Err(PusError::RawDataTooShort(raw_data_len));
}
let sec_header_zc = zc::PusTmSecHeaderWithoutTimestamp::from_bytes(
&slice[current_idx..current_idx + PUC_TM_MIN_SEC_HEADER_LEN],
)
2022-09-13 09:52:59 +02:00
.ok_or(ByteConversionError::ZeroCopyFromError)?;
2022-07-31 13:31:14 +02:00
current_idx += PUC_TM_MIN_SEC_HEADER_LEN;
2023-01-16 11:56:25 +01:00
let mut timestamp = None;
if timestamp_len > 0 {
timestamp = Some(&slice[current_idx..current_idx + timestamp_len]);
}
2022-07-31 13:31:14 +02:00
let zc_sec_header_wrapper = zc::PusTmSecHeader {
zc_header: sec_header_zc,
2023-01-16 11:56:25 +01:00
timestamp,
2022-07-31 13:31:14 +02:00
};
current_idx += timestamp_len;
let raw_data = &slice[0..total_len];
let pus_tm = PusTm {
2022-12-05 01:41:35 +01:00
sp_header,
2022-07-31 13:31:14 +02:00
sec_header: PusTmSecondaryHeader::try_from(zc_sec_header_wrapper).unwrap(),
raw_data: Some(&slice[0..total_len]),
source_data: user_data_from_raw(current_idx, total_len, raw_data_len, slice)?,
calc_crc_on_serialization: false,
crc16: Some(crc_from_raw_data(raw_data)?),
};
2023-07-05 19:07:31 +02:00
verify_crc16_ccitt_false_from_raw_to_pus_error(
raw_data,
pus_tm.crc16.expect("CRC16 invalid"),
)?;
2022-07-31 13:31:14 +02:00
Ok((pus_tm, total_len))
}
2023-01-26 21:28:39 +01:00
/// If [Self] was constructed [Self::from_bytes], this function will return the slice it was
/// constructed from. Otherwise, [None] will be returned.
pub fn raw_bytes(&self) -> Option<&'raw_data [u8]> {
self.raw_data
}
2022-07-31 13:31:14 +02:00
}
2023-07-05 19:07:31 +02:00
/// This is a helper class to update certain fields in a raw PUS telemetry packet directly in place.
/// This can be more efficient than creating a full [PusTm], modifying the fields and then writing
/// it back to another buffer.
///
/// Please note that the [Self::finish] method has to be called for the PUS TM CRC16 to be valid
/// after changing fields of the TM packet. Furthermore, the constructor of this class will not
/// do any checks except a length check to ensure that all relevant fields can be updated without
/// a panic. If a full validity check of the PUS TM packet is required, it is recommended
/// to construct a full [PusTm] object from the raw bytestream first.
pub struct PusTmZeroCopyWriter<'raw> {
raw_tm: &'raw mut [u8],
}
impl<'raw> PusTmZeroCopyWriter<'raw> {
/// This function will not do any other checks on the raw data other than a length check
/// for all internal fields which can be updated. It is the responsibility of the user to ensure
/// the raw slice contains a valid telemetry packet. The slice should have the exact length
/// of the telemetry packet for this class to work properly.
pub fn new(raw_tm: &'raw mut [u8]) -> Option<Self> {
if raw_tm.len() < 13 {
return None;
}
Some(Self { raw_tm })
}
2023-07-05 19:28:43 +02:00
pub fn service(&self) -> u8 {
self.raw_tm[7]
}
pub fn subservice(&self) -> u8 {
self.raw_tm[8]
}
2023-07-05 19:25:05 +02:00
/// Set the sequence count. Returns false and does not update the value if the passed value
/// exceeds [MAX_APID].
pub fn set_apid(&mut self, apid: u16) -> bool {
if apid > MAX_APID {
return false;
}
// Clear APID part of the raw packet ID
let updated_apid =
((((self.raw_tm[0] as u16) << 8) | self.raw_tm[1] as u16) & !MAX_APID) | apid;
self.raw_tm[0..2].copy_from_slice(&updated_apid.to_be_bytes());
true
}
2023-07-05 19:07:31 +02:00
/// This function sets the message counter in the PUS TM secondary header.
pub fn set_msg_count(&mut self, msg_count: u16) {
self.raw_tm[9..11].copy_from_slice(&msg_count.to_be_bytes());
}
/// This function sets the destination ID in the PUS TM secondary header.
pub fn set_destination_id(&mut self, dest_id: u16) {
self.raw_tm[11..13].copy_from_slice(&dest_id.to_be_bytes())
}
/// Set the sequence count. Returns false and does not update the value if the passed value
/// exceeds [MAX_SEQ_COUNT].
2023-07-05 19:26:22 +02:00
pub fn set_seq_count(&mut self, seq_count: u16) -> bool {
2023-07-05 19:07:31 +02:00
if seq_count > MAX_SEQ_COUNT {
return false;
}
let new_psc =
(u16::from_be_bytes(self.raw_tm[2..4].try_into().unwrap()) & 0xC000) | seq_count;
self.raw_tm[2..4].copy_from_slice(&new_psc.to_be_bytes());
true
}
/// This method has to be called after modifying fields to ensure the CRC16 of the telemetry
/// packet remains valid.
pub fn finish(self) {
let slice_len = self.raw_tm.len();
let crc16 = calc_pus_crc16(&self.raw_tm[..slice_len - 2]);
self.raw_tm[slice_len - 2..].copy_from_slice(&crc16.to_be_bytes());
}
}
2023-07-02 18:38:18 +02:00
impl SerializablePusPacket for PusTm<'_> {
2023-07-03 00:54:21 +02:00
fn len_packed(&self) -> usize {
let mut length = PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA;
if let Some(timestamp) = self.sec_header.timestamp {
length += timestamp.len();
}
if let Some(src_data) = self.source_data {
length += src_data.len();
}
length
}
2023-07-02 18:38:18 +02:00
/// Write the raw PUS byte representation to a provided buffer.
fn write_to_bytes(&self, slice: &mut [u8]) -> Result<usize, PusError> {
let mut curr_idx = 0;
let total_size = self.len_packed();
if total_size > slice.len() {
return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
found: slice.len(),
expected: total_size,
})
.into());
}
self.sp_header
.write_to_be_bytes(&mut slice[0..CCSDS_HEADER_LEN])?;
curr_idx += CCSDS_HEADER_LEN;
let sec_header_len = size_of::<zc::PusTmSecHeaderWithoutTimestamp>();
let sec_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap();
sec_header
.write_to_bytes(&mut slice[curr_idx..curr_idx + sec_header_len])
.ok_or(ByteConversionError::ZeroCopyToError)?;
curr_idx += sec_header_len;
if let Some(timestamp) = self.sec_header.timestamp {
let timestamp_len = timestamp.len();
slice[curr_idx..curr_idx + timestamp_len].copy_from_slice(timestamp);
curr_idx += timestamp_len;
}
if let Some(src_data) = self.source_data {
slice[curr_idx..curr_idx + src_data.len()].copy_from_slice(src_data);
curr_idx += src_data.len();
}
let crc16 = crc_procedure(
self.calc_crc_on_serialization,
&self.crc16,
0,
curr_idx,
slice,
)?;
slice[curr_idx..curr_idx + 2].copy_from_slice(crc16.to_be_bytes().as_slice());
curr_idx += 2;
Ok(curr_idx)
}
}
2023-01-26 19:24:41 +01:00
impl PartialEq for PusTm<'_> {
fn eq(&self, other: &Self) -> bool {
self.sp_header == other.sp_header
&& self.sec_header == other.sec_header
&& self.source_data == other.source_data
}
}
2022-07-31 13:31:14 +02:00
//noinspection RsTraitImplementation
impl CcsdsPacket for PusTm<'_> {
ccsds_impl!();
}
//noinspection RsTraitImplementation
impl PusPacket for PusTm<'_> {
delegate!(to self.sec_header {
fn pus_version(&self) -> PusVersion;
fn service(&self) -> u8;
fn subservice(&self) -> u8;
});
fn user_data(&self) -> Option<&[u8]> {
self.source_data
}
fn crc16(&self) -> Option<u16> {
self.crc16
}
2022-07-31 02:27:27 +02:00
}
2022-07-31 14:24:16 +02:00
//noinspection RsTraitImplementation
2022-12-04 17:11:44 +01:00
impl GenericPusTmSecondaryHeader for PusTm<'_> {
2022-07-31 14:24:16 +02:00
delegate!(to self.sec_header {
fn pus_version(&self) -> PusVersion;
fn service(&self) -> u8;
fn subservice(&self) -> u8;
fn dest_id(&self) -> u16;
fn msg_counter(&self) -> u16;
fn sc_time_ref_status(&self) -> u8;
});
}
2022-07-31 02:27:27 +02:00
#[cfg(test)]
2022-07-31 13:43:40 +02:00
mod tests {
use super::*;
2022-07-31 14:24:16 +02:00
use crate::ecss::PusVersion::PusC;
2022-07-31 13:43:40 +02:00
use crate::SpHeader;
2023-01-16 11:56:25 +01:00
fn base_ping_reply_full_ctor(timestamp: &[u8]) -> PusTm {
let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap();
2023-01-26 19:24:41 +01:00
let tm_header = PusTmSecondaryHeader::new_simple(17, 2, &timestamp);
PusTm::new(&mut sph, tm_header, None, true)
2022-07-31 13:43:40 +02:00
}
2023-01-16 11:56:25 +01:00
fn base_hk_reply<'a>(timestamp: &'a [u8], src_data: &'a [u8]) -> PusTm<'a> {
let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap();
2023-01-16 11:56:25 +01:00
let tc_header = PusTmSecondaryHeader::new_simple(3, 5, &timestamp);
2022-08-01 01:08:06 +02:00
PusTm::new(&mut sph, tc_header, Some(src_data), true)
}
2023-01-16 11:56:25 +01:00
fn dummy_timestamp() -> &'static [u8] {
2022-08-01 00:20:11 +02:00
return &[0, 1, 2, 3, 4, 5, 6];
2022-07-31 13:43:40 +02:00
}
2022-07-31 14:24:16 +02:00
2022-07-31 13:43:40 +02:00
#[test]
fn test_basic() {
2023-01-16 11:56:25 +01:00
let timestamp = dummy_timestamp();
let pus_tm = base_ping_reply_full_ctor(&timestamp);
verify_ping_reply(&pus_tm, false, 22, dummy_timestamp());
2022-07-31 14:24:16 +02:00
}
#[test]
fn test_serialization_no_source_data() {
2023-01-16 11:56:25 +01:00
let timestamp = dummy_timestamp();
let pus_tm = base_ping_reply_full_ctor(&timestamp);
2022-07-31 14:24:16 +02:00
let mut buf: [u8; 32] = [0; 32];
2022-09-11 20:50:46 +02:00
let ser_len = pus_tm
.write_to_bytes(&mut buf)
.expect("Serialization failed");
2022-07-31 14:24:16 +02:00
assert_eq!(ser_len, 22);
2022-08-01 01:08:06 +02:00
verify_raw_ping_reply(&buf);
}
#[test]
fn test_serialization_with_source_data() {
let src_data = [1, 2, 3];
2023-01-16 11:56:25 +01:00
let hk_reply = base_hk_reply(dummy_timestamp(), &src_data);
2022-08-01 01:08:06 +02:00
let mut buf: [u8; 32] = [0; 32];
2022-09-11 20:50:46 +02:00
let ser_len = hk_reply
.write_to_bytes(&mut buf)
.expect("Serialization failed");
2022-08-01 01:08:06 +02:00
assert_eq!(ser_len, 25);
assert_eq!(buf[20], 1);
assert_eq!(buf[21], 2);
assert_eq!(buf[22], 3);
}
#[test]
fn test_setters() {
2023-01-16 11:56:25 +01:00
let timestamp = dummy_timestamp();
let mut pus_tm = base_ping_reply_full_ctor(&timestamp);
2022-08-01 01:08:06 +02:00
pus_tm.set_sc_time_ref_status(0b1010);
pus_tm.set_dest_id(0x7fff);
pus_tm.set_msg_counter(0x1f1f);
assert_eq!(pus_tm.sc_time_ref_status(), 0b1010);
assert_eq!(pus_tm.dest_id(), 0x7fff);
assert_eq!(pus_tm.msg_counter(), 0x1f1f);
2022-08-05 00:24:29 +02:00
assert!(pus_tm.set_apid(0x7ff));
assert_eq!(pus_tm.apid(), 0x7ff);
2022-08-01 01:08:06 +02:00
}
#[test]
fn test_deserialization_no_source_data() {
2023-01-16 11:56:25 +01:00
let timestamp = dummy_timestamp();
let pus_tm = base_ping_reply_full_ctor(&timestamp);
2022-08-01 01:08:06 +02:00
let mut buf: [u8; 32] = [0; 32];
2022-09-11 20:50:46 +02:00
let ser_len = pus_tm
.write_to_bytes(&mut buf)
.expect("Serialization failed");
2022-08-01 01:08:06 +02:00
assert_eq!(ser_len, 22);
2022-09-13 10:29:09 +02:00
let (tm_deserialized, size) = PusTm::from_bytes(&buf, 7).expect("Deserialization failed");
2022-08-01 01:08:06 +02:00
assert_eq!(ser_len, size);
2023-01-16 11:56:25 +01:00
verify_ping_reply(&tm_deserialized, false, 22, dummy_timestamp());
2022-08-01 01:08:06 +02:00
}
#[test]
fn test_manual_field_update() {
let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap();
2023-01-16 11:56:25 +01:00
let tc_header = PusTmSecondaryHeader::new_simple(17, 2, dummy_timestamp());
2022-08-01 01:08:06 +02:00
let mut tm = PusTm::new(&mut sph, tc_header, None, false);
tm.calc_crc_on_serialization = false;
assert_eq!(tm.data_len(), 0x00);
let mut buf: [u8; 32] = [0; 32];
2022-09-11 20:50:46 +02:00
let res = tm.write_to_bytes(&mut buf);
2022-08-01 01:08:06 +02:00
assert!(res.is_err());
assert!(matches!(res.unwrap_err(), PusError::CrcCalculationMissing));
tm.update_ccsds_data_len();
assert_eq!(tm.data_len(), 15);
tm.calc_own_crc16();
2022-09-11 20:50:46 +02:00
let res = tm.write_to_bytes(&mut buf);
2022-08-01 01:08:06 +02:00
assert!(res.is_ok());
tm.sp_header.data_len = 0;
tm.update_packet_fields();
assert_eq!(tm.data_len(), 15);
}
#[test]
fn test_target_buf_too_small() {
2023-01-16 11:56:25 +01:00
let timestamp = dummy_timestamp();
let pus_tm = base_ping_reply_full_ctor(&timestamp);
2022-08-01 01:08:06 +02:00
let mut buf: [u8; 16] = [0; 16];
2022-09-11 20:50:46 +02:00
let res = pus_tm.write_to_bytes(&mut buf);
2022-08-01 01:08:06 +02:00
assert!(res.is_err());
let error = res.unwrap_err();
2022-09-13 09:52:59 +02:00
assert!(matches!(error, PusError::ByteConversionError { .. }));
2022-08-01 01:08:06 +02:00
match error {
2022-09-13 09:52:59 +02:00
PusError::ByteConversionError(err) => match err {
ByteConversionError::ToSliceTooSmall(size_missmatch) => {
2022-08-01 01:08:06 +02:00
assert_eq!(size_missmatch.expected, 22);
assert_eq!(size_missmatch.found, 16);
}
_ => panic!("Invalid PUS error {:?}", err),
},
_ => {
panic!("Invalid error {:?}", error);
}
}
}
#[test]
#[cfg(feature = "alloc")]
fn test_append_to_vec() {
2023-01-16 11:56:25 +01:00
let timestamp = dummy_timestamp();
let pus_tm = base_ping_reply_full_ctor(&timestamp);
2022-08-01 01:08:06 +02:00
let mut vec = Vec::new();
let res = pus_tm.append_to_vec(&mut vec);
assert!(res.is_ok());
assert_eq!(res.unwrap(), 22);
verify_raw_ping_reply(vec.as_slice());
}
#[test]
#[cfg(feature = "alloc")]
fn test_append_to_vec_with_src_data() {
let src_data = [1, 2, 3];
2023-01-16 11:56:25 +01:00
let hk_reply = base_hk_reply(dummy_timestamp(), &src_data);
2022-08-01 01:08:06 +02:00
let mut vec = Vec::new();
vec.push(4);
let res = hk_reply.append_to_vec(&mut vec);
assert!(res.is_ok());
assert_eq!(res.unwrap(), 25);
assert_eq!(vec.len(), 26);
}
fn verify_raw_ping_reply(buf: &[u8]) {
2022-08-01 00:20:11 +02:00
// Secondary header is set -> 0b0000_1001 , APID occupies last bit of first byte
assert_eq!(buf[0], 0x09);
// Rest of APID 0x123
assert_eq!(buf[1], 0x23);
// Unsegmented is the default, and first byte of 0x234 occupies this byte as well
assert_eq!(buf[2], 0xc2);
assert_eq!(buf[3], 0x34);
assert_eq!(((buf[4] as u16) << 8) | buf[5] as u16, 15);
// SC time ref status is 0
assert_eq!(buf[6], (PusC as u8) << 4);
assert_eq!(buf[7], 17);
assert_eq!(buf[8], 2);
// MSG counter 0
assert_eq!(buf[9], 0x00);
assert_eq!(buf[10], 0x00);
// Destination ID
assert_eq!(buf[11], 0x00);
assert_eq!(buf[12], 0x00);
// Timestamp
2023-01-16 11:56:25 +01:00
assert_eq!(&buf[13..20], dummy_timestamp());
2022-08-01 00:20:11 +02:00
let mut digest = CRC_CCITT_FALSE.digest();
digest.update(&buf[0..20]);
let crc16 = digest.finalize();
assert_eq!(((crc16 >> 8) & 0xff) as u8, buf[20]);
assert_eq!((crc16 & 0xff) as u8, buf[21]);
2022-07-31 14:24:16 +02:00
}
2022-08-01 01:08:06 +02:00
fn verify_ping_reply(
2022-07-31 14:24:16 +02:00
tm: &PusTm,
has_user_data: bool,
exp_full_len: usize,
2023-01-16 11:56:25 +01:00
exp_timestamp: &[u8],
2022-07-31 14:24:16 +02:00
) {
2022-07-31 13:43:40 +02:00
assert!(tm.is_tm());
2022-07-31 14:24:16 +02:00
assert_eq!(PusPacket::service(tm), 17);
assert_eq!(PusPacket::subservice(tm), 2);
2022-07-31 13:43:40 +02:00
assert!(tm.sec_header_flag());
assert_eq!(tm.len_packed(), exp_full_len);
2023-01-16 11:56:25 +01:00
assert_eq!(tm.timestamp().unwrap(), exp_timestamp);
2022-07-31 13:43:40 +02:00
if has_user_data {
assert!(!tm.user_data().is_none());
}
2022-07-31 14:24:16 +02:00
assert_eq!(PusPacket::pus_version(tm), PusC);
2022-08-01 00:20:11 +02:00
assert_eq!(tm.apid(), 0x123);
assert_eq!(tm.seq_count(), 0x234);
2022-07-31 14:24:16 +02:00
assert_eq!(tm.data_len(), exp_full_len as u16 - 7);
assert_eq!(tm.dest_id(), 0x0000);
assert_eq!(tm.msg_counter(), 0x0000);
assert_eq!(tm.sc_time_ref_status(), 0b0000);
2022-07-31 13:43:40 +02:00
}
2023-01-26 19:24:41 +01:00
#[test]
2023-01-26 21:11:03 +01:00
fn partial_eq_pus_tm() {
2023-01-26 19:24:41 +01:00
let timestamp = dummy_timestamp();
2023-01-26 21:11:03 +01:00
let pus_tm_1 = base_ping_reply_full_ctor(timestamp);
let pus_tm_2 = base_ping_reply_full_ctor(timestamp);
assert_eq!(pus_tm_1, pus_tm_2);
2023-01-26 19:24:41 +01:00
}
#[test]
fn partial_eq_serialized_vs_derialized() {
let timestamp = dummy_timestamp();
let pus_tm = base_ping_reply_full_ctor(timestamp);
let mut buf = [0; 32];
2023-01-26 21:11:03 +01:00
pus_tm.write_to_bytes(&mut buf).unwrap();
2023-01-26 19:24:41 +01:00
assert_eq!(pus_tm, PusTm::from_bytes(&buf, timestamp.len()).unwrap().0);
}
2023-07-05 19:07:31 +02:00
#[test]
fn test_zero_copy_writer() {
let ping_tm = base_ping_reply_full_ctor(dummy_timestamp());
let mut buf: [u8; 64] = [0; 64];
let tm_size = ping_tm
.write_to_bytes(&mut buf)
.expect("writing PUS ping TM failed");
let mut writer = PusTmZeroCopyWriter::new(&mut buf[..tm_size])
.expect("Creating zero copy writer failed");
writer.set_destination_id(55);
writer.set_msg_count(100);
2023-07-06 01:24:40 +02:00
writer.set_seq_count(MAX_SEQ_COUNT);
2023-07-05 19:25:05 +02:00
writer.set_apid(MAX_APID);
writer.finish();
2023-07-05 19:07:31 +02:00
// This performs all necessary checks, including the CRC check.
let (tm_read_back, tm_size_read_back) =
PusTm::from_bytes(&buf, 7).expect("Re-creating PUS TM failed");
assert_eq!(tm_size_read_back, tm_size);
assert_eq!(tm_read_back.msg_counter(), 100);
assert_eq!(tm_read_back.dest_id(), 55);
2023-07-05 19:25:05 +02:00
assert_eq!(tm_read_back.seq_count(), MAX_SEQ_COUNT);
assert_eq!(tm_read_back.apid(), MAX_APID);
2023-07-05 19:07:31 +02:00
}
2022-07-31 13:43:40 +02:00
}