Compare commits
2 Commits
v0.13.0
...
ce9ca14b8f
Author | SHA1 | Date | |
---|---|---|---|
ce9ca14b8f
|
|||
1426cb514b
|
@ -34,6 +34,7 @@ to check all the API changes in the **Changed** chapter.
|
||||
- `UnixTimestamp` renamed to `UnixTime`
|
||||
- `UnixTime` seconds are now private and can be retrieved using the `secs` member method.
|
||||
- `UnixTime::new` renamed to `UnixTime::new_checked`.
|
||||
- `UnixTime::secs` renamed to `UnixTime::as_secs`.
|
||||
- `UnixTime` now has a nanosecond subsecond precision. The `new` constructor now expects
|
||||
nanoseconds as the second argument.
|
||||
- Added new `UnixTime::new_subsec_millis` and `UnixTime::new_subsec_millis_checked` API
|
||||
@ -46,6 +47,13 @@ to check all the API changes in the **Changed** chapter.
|
||||
- Error handling for ECSS and time module is more granular now, with a new
|
||||
`DateBeforeCcsdsEpochError` error and a `DateBeforeCcsdsEpoch` enum variant for both
|
||||
`CdsError` and `CucError`.
|
||||
- `PusTmCreator` now has two lifetimes: One for the raw source data buffer and one for the
|
||||
raw timestamp.
|
||||
- Time API `from_now*` API renamed to `now*`.
|
||||
|
||||
## Removed
|
||||
|
||||
- Legacy `PusTm` and `PusTc` objects.
|
||||
|
||||
# [v0.11.0-rc.0] 2024-03-04
|
||||
|
||||
|
@ -225,24 +225,6 @@ pub(crate) fn calc_pus_crc16(bytes: &[u8]) -> u16 {
|
||||
digest.finalize()
|
||||
}
|
||||
|
||||
pub(crate) fn crc_procedure(
|
||||
calc_on_serialization: bool,
|
||||
cached_crc16: &Option<u16>,
|
||||
start_idx: usize,
|
||||
curr_idx: usize,
|
||||
slice: &[u8],
|
||||
) -> Result<u16, PusError> {
|
||||
let crc16;
|
||||
if calc_on_serialization {
|
||||
crc16 = calc_pus_crc16(&slice[start_idx..curr_idx])
|
||||
} else if cached_crc16.is_none() {
|
||||
return Err(PusError::CrcCalculationMissing);
|
||||
} else {
|
||||
crc16 = cached_crc16.unwrap();
|
||||
}
|
||||
Ok(crc16)
|
||||
}
|
||||
|
||||
pub(crate) fn user_data_from_raw(
|
||||
current_idx: usize,
|
||||
total_len: usize,
|
||||
|
337
src/ecss/tc.rs
337
src/ecss/tc.rs
@ -48,8 +48,6 @@ use zerocopy::AsBytes;
|
||||
#[cfg(feature = "alloc")]
|
||||
use alloc::vec::Vec;
|
||||
|
||||
pub use legacy_tc::*;
|
||||
|
||||
/// PUS C secondary header length is fixed
|
||||
pub const PUC_TC_SECONDARY_HEADER_LEN: usize = size_of::<zc::PusTcSecondaryHeader>();
|
||||
pub const PUS_TC_MIN_LEN_WITHOUT_APP_DATA: usize =
|
||||
@ -212,332 +210,6 @@ impl PusTcSecondaryHeader {
|
||||
}
|
||||
}
|
||||
|
||||
pub mod legacy_tc {
|
||||
use crate::ecss::tc::{
|
||||
zc, GenericPusTcSecondaryHeader, IsPusTelecommand, PusTcSecondaryHeader, ACK_ALL,
|
||||
PUC_TC_SECONDARY_HEADER_LEN, PUS_TC_MIN_LEN_WITHOUT_APP_DATA,
|
||||
};
|
||||
use crate::ecss::{
|
||||
ccsds_impl, crc_from_raw_data, crc_procedure, sp_header_impls,
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error, PusError, PusPacket, WritablePusPacket,
|
||||
CCSDS_HEADER_LEN,
|
||||
};
|
||||
use crate::ecss::{user_data_from_raw, PusVersion};
|
||||
use crate::SequenceFlags;
|
||||
use crate::{ByteConversionError, CcsdsPacket, PacketType, SpHeader, CRC_CCITT_FALSE};
|
||||
use core::mem::size_of;
|
||||
use delegate::delegate;
|
||||
use zerocopy::AsBytes;
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
use alloc::vec::Vec;
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// This class models the PUS C telecommand packet. It is the primary data structure to generate the
|
||||
/// raw byte representation of a PUS telecommand or to deserialize from one from raw bytes.
|
||||
///
|
||||
/// This class also derives the [serde::Serialize] and [serde::Deserialize] trait if the
|
||||
/// [serde] feature is used, which allows to send around TC packets in a raw byte format using a
|
||||
/// serde provider like [postcard](https://docs.rs/postcard/latest/postcard/).
|
||||
///
|
||||
/// There is no spare bytes support yet.
|
||||
///
|
||||
/// # Lifetimes
|
||||
///
|
||||
/// * `'raw_data` - If the TC is not constructed from a raw slice, this will be the life time of
|
||||
/// a buffer where the user provided application data will be serialized into. If it
|
||||
/// is, this is the lifetime of the raw byte slice it is constructed from.
|
||||
#[derive(Eq, Copy, Clone, Debug)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
pub struct PusTc<'raw_data> {
|
||||
sp_header: SpHeader,
|
||||
pub sec_header: PusTcSecondaryHeader,
|
||||
/// If this is set to false, a manual call to [PusTc::calc_own_crc16] or
|
||||
/// [PusTc::update_packet_fields] is necessary for the serialized or cached CRC16 to be valid.
|
||||
pub calc_crc_on_serialization: bool,
|
||||
#[cfg_attr(feature = "serde", serde(skip))]
|
||||
raw_data: Option<&'raw_data [u8]>,
|
||||
app_data: &'raw_data [u8],
|
||||
crc16: Option<u16>,
|
||||
}
|
||||
|
||||
impl<'raw_data> PusTc<'raw_data> {
|
||||
/// Generates a new struct instance.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `sp_header` - Space packet header information. The correct packet type will be set
|
||||
/// automatically
|
||||
/// * `sec_header` - Information contained in the data field header, including the service
|
||||
/// and subservice type
|
||||
/// * `app_data` - Custom application data
|
||||
/// * `set_ccsds_len` - Can be used to automatically update the CCSDS space packet data length
|
||||
/// field. If this is not set to true, [PusTc::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
#[deprecated(
|
||||
since = "0.7.0",
|
||||
note = "Use specialized PusTcCreator or PusTcReader classes instead"
|
||||
)]
|
||||
pub fn new(
|
||||
sp_header: &mut SpHeader,
|
||||
sec_header: PusTcSecondaryHeader,
|
||||
app_data: Option<&'raw_data [u8]>,
|
||||
set_ccsds_len: bool,
|
||||
) -> Self {
|
||||
sp_header.set_packet_type(PacketType::Tc);
|
||||
sp_header.set_sec_header_flag();
|
||||
let mut pus_tc = Self {
|
||||
sp_header: *sp_header,
|
||||
raw_data: None,
|
||||
app_data: app_data.unwrap_or(&[]),
|
||||
sec_header,
|
||||
calc_crc_on_serialization: true,
|
||||
crc16: None,
|
||||
};
|
||||
if set_ccsds_len {
|
||||
pus_tc.update_ccsds_data_len();
|
||||
}
|
||||
pus_tc
|
||||
}
|
||||
|
||||
/// Simplified version of the [PusTc::new] function which allows to only specify service and
|
||||
/// subservice instead of the full PUS TC secondary header.
|
||||
#[deprecated(
|
||||
since = "0.7.0",
|
||||
note = "Use specialized PusTcCreator or PusTcReader classes instead"
|
||||
)]
|
||||
pub fn new_simple(
|
||||
sph: &mut SpHeader,
|
||||
service: u8,
|
||||
subservice: u8,
|
||||
app_data: Option<&'raw_data [u8]>,
|
||||
set_ccsds_len: bool,
|
||||
) -> Self {
|
||||
#[allow(deprecated)]
|
||||
Self::new(
|
||||
sph,
|
||||
PusTcSecondaryHeader::new(service, subservice, ACK_ALL, 0),
|
||||
app_data,
|
||||
set_ccsds_len,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn sp_header(&self) -> &SpHeader {
|
||||
&self.sp_header
|
||||
}
|
||||
|
||||
pub fn set_ack_field(&mut self, ack: u8) -> bool {
|
||||
if ack > 0b1111 {
|
||||
return false;
|
||||
}
|
||||
self.sec_header.ack = ack & 0b1111;
|
||||
true
|
||||
}
|
||||
|
||||
pub fn set_source_id(&mut self, source_id: u16) {
|
||||
self.sec_header.source_id = source_id;
|
||||
}
|
||||
|
||||
sp_header_impls!();
|
||||
|
||||
/// Calculate the CCSDS space packet data length field and sets it
|
||||
/// This is called automatically if the `set_ccsds_len` argument in the [PusTc::new] call was
|
||||
/// used.
|
||||
/// If this was not done or the application 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_written() as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
|
||||
}
|
||||
|
||||
/// This function should be called before the TC packet is serialized if
|
||||
/// [PusTc::calc_crc_on_serialization] is set to False. It will calculate and cache the CRC16.
|
||||
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::PusTcSecondaryHeader::try_from(self.sec_header).unwrap();
|
||||
digest.update(pus_tc_header.as_bytes());
|
||||
if !self.app_data.is_empty() {
|
||||
digest.update(self.app_data);
|
||||
}
|
||||
self.crc16 = Some(digest.finalize())
|
||||
}
|
||||
|
||||
/// This helper function calls both [PusTc::update_ccsds_data_len] and [PusTc::calc_own_crc16].
|
||||
pub fn update_packet_fields(&mut self) {
|
||||
self.update_ccsds_data_len();
|
||||
self.calc_own_crc16();
|
||||
}
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
pub fn append_to_vec(&self, vec: &mut Vec<u8>) -> Result<usize, PusError> {
|
||||
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
|
||||
let appended_len = PUS_TC_MIN_LEN_WITHOUT_APP_DATA + self.app_data.len();
|
||||
let start_idx = vec.len();
|
||||
let mut ser_len = 0;
|
||||
vec.extend_from_slice(sph_zc.as_bytes());
|
||||
ser_len += sph_zc.as_bytes().len();
|
||||
// The PUS version is hardcoded to PUS C
|
||||
let pus_tc_header = zc::PusTcSecondaryHeader::try_from(self.sec_header).unwrap();
|
||||
vec.extend_from_slice(pus_tc_header.as_bytes());
|
||||
ser_len += pus_tc_header.as_bytes().len();
|
||||
vec.extend_from_slice(self.app_data);
|
||||
ser_len += self.app_data.len();
|
||||
let crc16 = crc_procedure(
|
||||
self.calc_crc_on_serialization,
|
||||
&self.crc16,
|
||||
start_idx,
|
||||
ser_len,
|
||||
&vec[start_idx..ser_len],
|
||||
)?;
|
||||
vec.extend_from_slice(crc16.to_be_bytes().as_slice());
|
||||
Ok(appended_len)
|
||||
}
|
||||
|
||||
/// Create a [PusTc] instance from a raw slice. On success, it returns a tuple containing
|
||||
/// the instance and the found byte length of the packet.
|
||||
#[deprecated(
|
||||
since = "0.7.0",
|
||||
note = "Use specialized PusTcCreator or PusTcReader classes instead"
|
||||
)]
|
||||
pub fn from_bytes(slice: &'raw_data [u8]) -> Result<(Self, usize), PusError> {
|
||||
let raw_data_len = slice.len();
|
||||
if raw_data_len < PUS_TC_MIN_LEN_WITHOUT_APP_DATA {
|
||||
return Err(ByteConversionError::FromSliceTooSmall {
|
||||
found: raw_data_len,
|
||||
expected: PUS_TC_MIN_LEN_WITHOUT_APP_DATA,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let mut current_idx = 0;
|
||||
let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?;
|
||||
current_idx += CCSDS_HEADER_LEN;
|
||||
let total_len = sp_header.total_len();
|
||||
if raw_data_len < total_len || total_len < PUS_TC_MIN_LEN_WITHOUT_APP_DATA {
|
||||
return Err(ByteConversionError::FromSliceTooSmall {
|
||||
found: raw_data_len,
|
||||
expected: total_len,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let sec_header = zc::PusTcSecondaryHeader::from_bytes(
|
||||
&slice[current_idx..current_idx + PUC_TC_SECONDARY_HEADER_LEN],
|
||||
)
|
||||
.ok_or(ByteConversionError::ZeroCopyFromError)?;
|
||||
current_idx += PUC_TC_SECONDARY_HEADER_LEN;
|
||||
let raw_data = &slice[0..total_len];
|
||||
let pus_tc = Self {
|
||||
sp_header,
|
||||
sec_header: PusTcSecondaryHeader::try_from(sec_header).unwrap(),
|
||||
raw_data: Some(raw_data),
|
||||
app_data: user_data_from_raw(current_idx, total_len, slice)?,
|
||||
calc_crc_on_serialization: false,
|
||||
crc16: Some(crc_from_raw_data(raw_data)?),
|
||||
};
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error(
|
||||
raw_data,
|
||||
pus_tc.crc16.expect("CRC16 invalid"),
|
||||
)?;
|
||||
Ok((pus_tc, total_len))
|
||||
}
|
||||
|
||||
#[deprecated(since = "0.5.2", note = "use raw_bytes() instead")]
|
||||
pub fn raw(&self) -> Option<&'raw_data [u8]> {
|
||||
self.raw_bytes()
|
||||
}
|
||||
|
||||
/// 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
|
||||
}
|
||||
}
|
||||
|
||||
impl WritablePusPacket for PusTc<'_> {
|
||||
fn len_written(&self) -> usize {
|
||||
PUS_TC_MIN_LEN_WITHOUT_APP_DATA + self.app_data.len()
|
||||
}
|
||||
|
||||
/// 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 tc_header_len = size_of::<zc::PusTcSecondaryHeader>();
|
||||
let total_size = self.len_written();
|
||||
if total_size > slice.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
found: slice.len(),
|
||||
expected: total_size,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
self.sp_header.write_to_be_bytes(slice)?;
|
||||
curr_idx += CCSDS_HEADER_LEN;
|
||||
let sec_header = zc::PusTcSecondaryHeader::try_from(self.sec_header).unwrap();
|
||||
sec_header
|
||||
.write_to_bytes(&mut slice[curr_idx..curr_idx + tc_header_len])
|
||||
.ok_or(ByteConversionError::ZeroCopyToError)?;
|
||||
|
||||
curr_idx += tc_header_len;
|
||||
slice[curr_idx..curr_idx + self.app_data.len()].copy_from_slice(self.app_data);
|
||||
curr_idx += self.app_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)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for PusTc<'_> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.sp_header == other.sp_header
|
||||
&& self.sec_header == other.sec_header
|
||||
&& self.app_data == other.app_data
|
||||
}
|
||||
}
|
||||
|
||||
impl CcsdsPacket for PusTc<'_> {
|
||||
ccsds_impl!();
|
||||
}
|
||||
|
||||
impl PusPacket for PusTc<'_> {
|
||||
delegate!(to self.sec_header {
|
||||
fn pus_version(&self) -> PusVersion;
|
||||
fn service(&self) -> u8;
|
||||
fn subservice(&self) -> u8;
|
||||
});
|
||||
|
||||
fn user_data(&self) -> &[u8] {
|
||||
self.app_data
|
||||
}
|
||||
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
self.crc16
|
||||
}
|
||||
}
|
||||
|
||||
impl GenericPusTcSecondaryHeader for PusTc<'_> {
|
||||
delegate!(to self.sec_header {
|
||||
fn pus_version(&self) -> PusVersion;
|
||||
fn service(&self) -> u8;
|
||||
fn subservice(&self) -> u8;
|
||||
fn source_id(&self) -> u16;
|
||||
fn ack_flags(&self) -> u8;
|
||||
});
|
||||
}
|
||||
|
||||
impl IsPusTelecommand for PusTc<'_> {}
|
||||
}
|
||||
|
||||
/// This class can be used to create PUS C telecommand packet. It is the primary data structure to
|
||||
/// generate the raw byte representation of a PUS telecommand.
|
||||
///
|
||||
@ -565,7 +237,7 @@ impl<'raw_data> PusTcCreator<'raw_data> {
|
||||
/// and subservice type
|
||||
/// * `app_data` - Custom application data
|
||||
/// * `set_ccsds_len` - Can be used to automatically update the CCSDS space packet data length
|
||||
/// field. If this is not set to true, [PusTc::update_ccsds_data_len] can be called to set
|
||||
/// field. If this is not set to true, [Self::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
pub fn new(
|
||||
sp_header: &mut SpHeader,
|
||||
@ -586,7 +258,7 @@ impl<'raw_data> PusTcCreator<'raw_data> {
|
||||
pus_tc
|
||||
}
|
||||
|
||||
/// Simplified version of the [PusTcCreator::new] function which allows to only specify service
|
||||
/// Simplified version of the [Self::new] function which allows to only specify service
|
||||
/// and subservice instead of the full PUS TC secondary header.
|
||||
pub fn new_simple(
|
||||
sph: &mut SpHeader,
|
||||
@ -630,7 +302,7 @@ impl<'raw_data> PusTcCreator<'raw_data> {
|
||||
sp_header_impls!();
|
||||
|
||||
/// Calculate the CCSDS space packet data length field and sets it
|
||||
/// This is called automatically if the `set_ccsds_len` argument in the [PusTc::new] call was
|
||||
/// This is called automatically if the `set_ccsds_len` argument in the [Self::new] call was
|
||||
/// used.
|
||||
/// If this was not done or the application data is set or changed after construction,
|
||||
/// this function needs to be called to ensure that the data length field of the CCSDS header
|
||||
@ -640,8 +312,7 @@ impl<'raw_data> PusTcCreator<'raw_data> {
|
||||
self.len_written() as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
|
||||
}
|
||||
|
||||
/// This function should be called before the TC packet is serialized if
|
||||
/// [PusTc::calc_crc_on_serialization] is set to False. It will calculate and cache the CRC16.
|
||||
/// This function calculates and returns the CRC16 for the current packet.
|
||||
pub fn calc_own_crc16(&self) -> u16 {
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
|
||||
|
374
src/ecss/tm.rs
374
src/ecss/tm.rs
@ -19,7 +19,6 @@ use alloc::vec::Vec;
|
||||
use delegate::delegate;
|
||||
|
||||
use crate::time::{TimeWriter, TimestampError};
|
||||
pub use legacy_tm::*;
|
||||
|
||||
use self::zc::PusTmSecHeaderWithoutTimestamp;
|
||||
|
||||
@ -197,334 +196,6 @@ impl<'slice> TryFrom<zc::PusTmSecHeader<'slice>> for PusTmSecondaryHeader<'slice
|
||||
}
|
||||
}
|
||||
|
||||
pub mod legacy_tm {
|
||||
use crate::ecss::tm::{
|
||||
zc, GenericPusTmSecondaryHeader, IsPusTelemetry, PusTmSecondaryHeader,
|
||||
PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA, PUS_TM_MIN_SEC_HEADER_LEN,
|
||||
};
|
||||
use crate::ecss::PusVersion;
|
||||
use crate::ecss::{
|
||||
ccsds_impl, crc_from_raw_data, crc_procedure, sp_header_impls, user_data_from_raw,
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error, PusError, PusPacket, WritablePusPacket,
|
||||
CCSDS_HEADER_LEN,
|
||||
};
|
||||
use crate::SequenceFlags;
|
||||
use crate::{ByteConversionError, CcsdsPacket, PacketType, SpHeader, CRC_CCITT_FALSE};
|
||||
use core::mem::size_of;
|
||||
use zerocopy::AsBytes;
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[cfg(feature = "alloc")]
|
||||
use alloc::vec::Vec;
|
||||
use delegate::delegate;
|
||||
|
||||
/// 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.
|
||||
///
|
||||
/// 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/).
|
||||
///
|
||||
/// There is no spare bytes support yet.
|
||||
///
|
||||
/// # Lifetimes
|
||||
///
|
||||
/// * `'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.
|
||||
#[derive(Eq, Debug, Copy, Clone)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
pub struct PusTm<'raw_data> {
|
||||
pub sp_header: SpHeader,
|
||||
pub sec_header: PusTmSecondaryHeader<'raw_data>,
|
||||
/// 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,
|
||||
#[cfg_attr(feature = "serde", serde(skip))]
|
||||
raw_data: Option<&'raw_data [u8]>,
|
||||
source_data: &'raw_data [u8],
|
||||
crc16: Option<u16>,
|
||||
}
|
||||
|
||||
impl<'raw_data> PusTm<'raw_data> {
|
||||
/// Generates a new struct instance.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `sp_header` - Space packet header information. The correct packet type will be set
|
||||
/// automatically
|
||||
/// * `sec_header` - Information contained in the secondary header, including the service
|
||||
/// and subservice type
|
||||
/// * `app_data` - Custom application data
|
||||
/// * `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
|
||||
#[deprecated(
|
||||
since = "0.7.0",
|
||||
note = "Use specialized PusTmCreator or PusTmReader classes instead"
|
||||
)]
|
||||
pub fn new(
|
||||
sp_header: &mut SpHeader,
|
||||
sec_header: PusTmSecondaryHeader<'raw_data>,
|
||||
source_data: Option<&'raw_data [u8]>,
|
||||
set_ccsds_len: bool,
|
||||
) -> Self {
|
||||
sp_header.set_packet_type(PacketType::Tm);
|
||||
sp_header.set_sec_header_flag();
|
||||
let mut pus_tm = PusTm {
|
||||
sp_header: *sp_header,
|
||||
raw_data: None,
|
||||
source_data: source_data.unwrap_or(&[]),
|
||||
sec_header,
|
||||
calc_crc_on_serialization: true,
|
||||
crc16: None,
|
||||
};
|
||||
if set_ccsds_len {
|
||||
pus_tm.update_ccsds_data_len();
|
||||
}
|
||||
pus_tm
|
||||
}
|
||||
|
||||
pub fn timestamp(&self) -> &[u8] {
|
||||
self.sec_header.timestamp
|
||||
}
|
||||
|
||||
pub fn source_data(&self) -> &[u8] {
|
||||
self.source_data
|
||||
}
|
||||
|
||||
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!();
|
||||
|
||||
/// This is called automatically if the `set_ccsds_len` argument in the [PusTm::new] call was
|
||||
/// used.
|
||||
/// 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_written() as u16 - size_of::<crate::zc::SpHeader>() as u16 - 1;
|
||||
}
|
||||
|
||||
/// This function should be called before the TM packet is serialized if
|
||||
/// [PusTm.calc_crc_on_serialization] is set to False. It will calculate and cache the CRC16.
|
||||
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());
|
||||
digest.update(self.sec_header.timestamp);
|
||||
digest.update(self.source_data);
|
||||
self.crc16 = Some(digest.finalize())
|
||||
}
|
||||
|
||||
/// This helper function calls both [PusTm.update_ccsds_data_len] and [PusTm.calc_own_crc16]
|
||||
pub fn update_packet_fields(&mut self) {
|
||||
self.update_ccsds_data_len();
|
||||
self.calc_own_crc16();
|
||||
}
|
||||
|
||||
/// Append the raw PUS byte representation to a provided [alloc::vec::Vec]
|
||||
#[cfg(feature = "alloc")]
|
||||
pub fn append_to_vec(&self, vec: &mut Vec<u8>) -> Result<usize, PusError> {
|
||||
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
|
||||
let mut appended_len = PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA;
|
||||
appended_len += self.sec_header.timestamp.len();
|
||||
appended_len += self.source_data.len();
|
||||
let start_idx = vec.len();
|
||||
let mut ser_len = 0;
|
||||
vec.extend_from_slice(sph_zc.as_bytes());
|
||||
ser_len += sph_zc.as_bytes().len();
|
||||
// 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());
|
||||
ser_len += sec_header.as_bytes().len();
|
||||
ser_len += self.sec_header.timestamp.len();
|
||||
vec.extend_from_slice(self.sec_header.timestamp);
|
||||
vec.extend_from_slice(self.source_data);
|
||||
ser_len += self.source_data.len();
|
||||
let crc16 = crc_procedure(
|
||||
self.calc_crc_on_serialization,
|
||||
&self.crc16,
|
||||
start_idx,
|
||||
ser_len,
|
||||
&vec[start_idx..start_idx + ser_len],
|
||||
)?;
|
||||
vec.extend_from_slice(crc16.to_be_bytes().as_slice());
|
||||
Ok(appended_len)
|
||||
}
|
||||
|
||||
/// 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.
|
||||
#[deprecated(
|
||||
since = "0.7.0",
|
||||
note = "Use specialized PusTmCreator or PusTmReader classes instead"
|
||||
)]
|
||||
pub fn from_bytes(
|
||||
slice: &'raw_data [u8],
|
||||
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(ByteConversionError::FromSliceTooSmall {
|
||||
found: raw_data_len,
|
||||
expected: PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let mut current_idx = 0;
|
||||
let (sp_header, _) = SpHeader::from_be_bytes(&slice[0..CCSDS_HEADER_LEN])?;
|
||||
current_idx += 6;
|
||||
let total_len = sp_header.total_len();
|
||||
if raw_data_len < total_len {
|
||||
return Err(ByteConversionError::FromSliceTooSmall {
|
||||
found: raw_data_len,
|
||||
expected: PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
if total_len < PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA {
|
||||
return Err(ByteConversionError::FromSliceTooSmall {
|
||||
found: total_len,
|
||||
expected: PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA,
|
||||
}
|
||||
.into());
|
||||
}
|
||||
let sec_header_zc = zc::PusTmSecHeaderWithoutTimestamp::from_bytes(
|
||||
&slice[current_idx..current_idx + PUS_TM_MIN_SEC_HEADER_LEN],
|
||||
)
|
||||
.ok_or(ByteConversionError::ZeroCopyFromError)?;
|
||||
current_idx += PUS_TM_MIN_SEC_HEADER_LEN;
|
||||
let zc_sec_header_wrapper = zc::PusTmSecHeader {
|
||||
zc_header: sec_header_zc,
|
||||
timestamp: &slice[current_idx..current_idx + timestamp_len],
|
||||
};
|
||||
current_idx += timestamp_len;
|
||||
let raw_data = &slice[0..total_len];
|
||||
let pus_tm = PusTm {
|
||||
sp_header,
|
||||
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, slice)?,
|
||||
calc_crc_on_serialization: false,
|
||||
crc16: Some(crc_from_raw_data(raw_data)?),
|
||||
};
|
||||
verify_crc16_ccitt_false_from_raw_to_pus_error(
|
||||
raw_data,
|
||||
pus_tm.crc16.expect("CRC16 invalid"),
|
||||
)?;
|
||||
Ok((pus_tm, total_len))
|
||||
}
|
||||
|
||||
/// 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
|
||||
}
|
||||
}
|
||||
|
||||
impl WritablePusPacket for PusTm<'_> {
|
||||
fn len_written(&self) -> usize {
|
||||
PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA
|
||||
+ self.sec_header.timestamp.len()
|
||||
+ self.source_data.len()
|
||||
}
|
||||
/// 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_written();
|
||||
if total_size > slice.len() {
|
||||
return Err(ByteConversionError::ToSliceTooSmall {
|
||||
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;
|
||||
slice[curr_idx..curr_idx + self.sec_header.timestamp.len()]
|
||||
.copy_from_slice(self.sec_header.timestamp);
|
||||
curr_idx += self.sec_header.timestamp.len();
|
||||
slice[curr_idx..curr_idx + self.source_data.len()].copy_from_slice(self.source_data);
|
||||
curr_idx += self.source_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)
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
impl CcsdsPacket for PusTm<'_> {
|
||||
ccsds_impl!();
|
||||
}
|
||||
|
||||
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) -> &[u8] {
|
||||
self.source_data
|
||||
}
|
||||
|
||||
fn crc16(&self) -> Option<u16> {
|
||||
self.crc16
|
||||
}
|
||||
}
|
||||
|
||||
impl GenericPusTmSecondaryHeader for PusTm<'_> {
|
||||
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;
|
||||
});
|
||||
}
|
||||
|
||||
impl IsPusTelemetry for PusTm<'_> {}
|
||||
}
|
||||
|
||||
/// This class models the PUS C telemetry packet. It is the primary data structure to generate the
|
||||
/// raw byte representation of PUS telemetry.
|
||||
///
|
||||
@ -539,16 +210,17 @@ pub mod legacy_tm {
|
||||
/// * `'raw_data` - This is the lifetime of the user provided time stamp and source data.
|
||||
#[derive(Eq, Debug, Copy, Clone)]
|
||||
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
||||
pub struct PusTmCreator<'raw_data> {
|
||||
pub struct PusTmCreator<'time, 'raw_data> {
|
||||
pub sp_header: SpHeader,
|
||||
pub sec_header: PusTmSecondaryHeader<'raw_data>,
|
||||
#[cfg_attr(feature="serde", serde(borrow))]
|
||||
pub sec_header: PusTmSecondaryHeader<'time>,
|
||||
source_data: &'raw_data [u8],
|
||||
/// 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.
|
||||
/// If this is set to false, a manual call to [Self::calc_own_crc16] or
|
||||
/// [Self::update_packet_fields] is necessary for the serialized or cached CRC16 to be valid.
|
||||
pub calc_crc_on_serialization: bool,
|
||||
}
|
||||
|
||||
impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
impl<'time, 'raw_data> PusTmCreator<'time, 'raw_data> {
|
||||
/// Generates a new struct instance.
|
||||
///
|
||||
/// # Arguments
|
||||
@ -559,11 +231,11 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
/// and subservice type
|
||||
/// * `source_data` - Custom application data
|
||||
/// * `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
|
||||
/// field. If this is not set to true, [Self::update_ccsds_data_len] can be called to set
|
||||
/// the correct value to this field manually
|
||||
pub fn new(
|
||||
sp_header: &mut SpHeader,
|
||||
sec_header: PusTmSecondaryHeader<'raw_data>,
|
||||
sec_header: PusTmSecondaryHeader<'time>,
|
||||
source_data: &'raw_data [u8],
|
||||
set_ccsds_len: bool,
|
||||
) -> Self {
|
||||
@ -586,7 +258,7 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
service: u8,
|
||||
subservice: u8,
|
||||
time_provider: &impl TimeWriter,
|
||||
stamp_buf: &'raw_data mut [u8],
|
||||
stamp_buf: &'time mut [u8],
|
||||
source_data: Option<&'raw_data [u8]>,
|
||||
set_ccsds_len: bool,
|
||||
) -> Result<Self, TimestampError> {
|
||||
@ -603,7 +275,7 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
|
||||
pub fn new_no_source_data(
|
||||
sp_header: &mut SpHeader,
|
||||
sec_header: PusTmSecondaryHeader<'raw_data>,
|
||||
sec_header: PusTmSecondaryHeader<'time>,
|
||||
set_ccsds_len: bool,
|
||||
) -> Self {
|
||||
Self::new(sp_header, sec_header, &[], set_ccsds_len)
|
||||
@ -631,7 +303,7 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
|
||||
sp_header_impls!();
|
||||
|
||||
/// This is called automatically if the `set_ccsds_len` argument in the [PusTm::new] call was
|
||||
/// This is called automatically if the `set_ccsds_len` argument in the [Self::new] call was
|
||||
/// used.
|
||||
/// 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
|
||||
@ -642,7 +314,7 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
}
|
||||
|
||||
/// This function should be called before the TM packet is serialized if
|
||||
/// [PusTm.calc_crc_on_serialization] is set to False. It will calculate and cache the CRC16.
|
||||
/// [Self::calc_crc_on_serialization] is set to False. It will calculate and cache the CRC16.
|
||||
pub fn calc_own_crc16(&self) -> u16 {
|
||||
let mut digest = CRC_CCITT_FALSE.digest();
|
||||
let sph_zc = crate::zc::SpHeader::from(self.sp_header);
|
||||
@ -654,7 +326,7 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
digest.finalize()
|
||||
}
|
||||
|
||||
/// This helper function calls both [PusTm.update_ccsds_data_len] and [PusTm.calc_own_crc16]
|
||||
/// This helper function calls both [Self::update_ccsds_data_len] and [Self::calc_own_crc16]
|
||||
pub fn update_packet_fields(&mut self) {
|
||||
self.update_ccsds_data_len();
|
||||
}
|
||||
@ -710,7 +382,7 @@ impl<'raw_data> PusTmCreator<'raw_data> {
|
||||
}
|
||||
}
|
||||
|
||||
impl WritablePusPacket for PusTmCreator<'_> {
|
||||
impl WritablePusPacket for PusTmCreator<'_, '_> {
|
||||
fn len_written(&self) -> usize {
|
||||
PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA
|
||||
+ self.sec_header.timestamp.len()
|
||||
@ -722,7 +394,7 @@ impl WritablePusPacket for PusTmCreator<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq for PusTmCreator<'_> {
|
||||
impl PartialEq for PusTmCreator<'_, '_> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.sp_header == other.sp_header
|
||||
&& self.sec_header == other.sec_header
|
||||
@ -730,11 +402,11 @@ impl PartialEq for PusTmCreator<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl CcsdsPacket for PusTmCreator<'_> {
|
||||
impl CcsdsPacket for PusTmCreator<'_, '_> {
|
||||
ccsds_impl!();
|
||||
}
|
||||
|
||||
impl PusPacket for PusTmCreator<'_> {
|
||||
impl PusPacket for PusTmCreator<'_, '_> {
|
||||
delegate!(to self.sec_header {
|
||||
fn pus_version(&self) -> PusVersion;
|
||||
fn service(&self) -> u8;
|
||||
@ -750,7 +422,7 @@ impl PusPacket for PusTmCreator<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl GenericPusTmSecondaryHeader for PusTmCreator<'_> {
|
||||
impl GenericPusTmSecondaryHeader for PusTmCreator<'_, '_> {
|
||||
delegate!(to self.sec_header {
|
||||
fn pus_version(&self) -> PusVersion;
|
||||
fn service(&self) -> u8;
|
||||
@ -761,7 +433,7 @@ impl GenericPusTmSecondaryHeader for PusTmCreator<'_> {
|
||||
});
|
||||
}
|
||||
|
||||
impl IsPusTelemetry for PusTmCreator<'_> {}
|
||||
impl IsPusTelemetry for PusTmCreator<'_, '_> {}
|
||||
|
||||
/// This class models the PUS C telemetry packet. It is the primary data structure to read
|
||||
/// a telemetry packet from raw bytes.
|
||||
@ -902,15 +574,15 @@ impl GenericPusTmSecondaryHeader for PusTmReader<'_> {
|
||||
|
||||
impl IsPusTelemetry for PusTmReader<'_> {}
|
||||
|
||||
impl PartialEq<PusTmCreator<'_>> for PusTmReader<'_> {
|
||||
fn eq(&self, other: &PusTmCreator<'_>) -> bool {
|
||||
impl PartialEq<PusTmCreator<'_, '_>> for PusTmReader<'_> {
|
||||
fn eq(&self, other: &PusTmCreator<'_, '_>) -> bool {
|
||||
self.sp_header == other.sp_header
|
||||
&& self.sec_header == other.sec_header
|
||||
&& self.source_data == other.source_data
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<PusTmReader<'_>> for PusTmCreator<'_> {
|
||||
impl PartialEq<PusTmReader<'_>> for PusTmCreator<'_, '_> {
|
||||
fn eq(&self, other: &PusTmReader<'_>) -> bool {
|
||||
self.sp_header == other.sp_header
|
||||
&& self.sec_header == other.sec_header
|
||||
@ -1122,7 +794,7 @@ mod tests {
|
||||
PusTmCreator::new(&mut sph, tm_header, DUMMY_DATA, true)
|
||||
}
|
||||
|
||||
fn base_hk_reply<'a>(timestamp: &'a [u8], src_data: &'a [u8]) -> PusTmCreator<'a> {
|
||||
fn base_hk_reply<'a, 'b>(timestamp: &'a [u8], src_data: &'b [u8]) -> PusTmCreator<'a, 'b> {
|
||||
let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap();
|
||||
let tc_header = PusTmSecondaryHeader::new_simple(3, 5, timestamp);
|
||||
PusTmCreator::new(&mut sph, tc_header, src_data, true)
|
||||
|
@ -176,7 +176,7 @@ pub fn precision_from_pfield(pfield: u8) -> SubmillisPrecision {
|
||||
/// use spacepackets::time::cds::{CdsTime, length_of_day_segment_from_pfield, LengthOfDaySegment};
|
||||
/// use spacepackets::time::{TimeWriter, CcsdsTimeCode, CcsdsTimeProvider};
|
||||
///
|
||||
/// let timestamp_now = CdsTime::from_now_with_u16_days().unwrap();
|
||||
/// let timestamp_now = CdsTime::now_with_u16_days().unwrap();
|
||||
/// let mut raw_stamp = [0; 7];
|
||||
/// {
|
||||
/// let written = timestamp_now.write_to_bytes(&mut raw_stamp).unwrap();
|
||||
@ -727,14 +727,14 @@ impl<ProvidesDaysLen: ProvidesDaysLength> CdsTime<ProvidesDaysLen> {
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
fn from_now_generic(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {
|
||||
fn now_generic(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {
|
||||
let conversion_from_now = ConversionFromNow::new()?;
|
||||
Self::generic_from_conversion(days_len, conversion_from_now)
|
||||
.map_err(|e| StdTimestampError::Timestamp(TimestampError::from(e)))
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
fn from_now_generic_us_prec(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {
|
||||
fn now_generic_with_us_prec(days_len: LengthOfDaySegment) -> Result<Self, StdTimestampError> {
|
||||
let conversion_from_now = ConversionFromNow::new_with_submillis_us_prec()?;
|
||||
Self::generic_from_conversion(days_len, conversion_from_now)
|
||||
.map_err(|e| StdTimestampError::Timestamp(TimestampError::from(e)))
|
||||
@ -822,8 +822,8 @@ impl CdsTime<DaysLen24Bits> {
|
||||
|
||||
/// Generate a time stamp from the current time using the system clock.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now_with_u24_days() -> Result<Self, StdTimestampError> {
|
||||
Self::from_now_generic(LengthOfDaySegment::Long24Bits)
|
||||
pub fn now_with_u24_days() -> Result<Self, StdTimestampError> {
|
||||
Self::now_generic(LengthOfDaySegment::Long24Bits)
|
||||
}
|
||||
|
||||
/// Create a provider from a [`chrono::DateTime<chrono::Utc>`] struct.
|
||||
@ -845,7 +845,7 @@ impl CdsTime<DaysLen24Bits> {
|
||||
/// This function will return [CdsError::DateBeforeCcsdsEpoch] if the time is before the CCSDS
|
||||
/// epoch (1958-01-01T00:00:00+00:00) or the CCSDS days value exceeds the allowed bit width
|
||||
/// (24 bits).
|
||||
pub fn from_unix_stamp_with_u24_days(
|
||||
pub fn from_unix_time_with_u24_day(
|
||||
unix_stamp: &UnixTime,
|
||||
submillis_prec: SubmillisPrecision,
|
||||
) -> Result<Self, CdsError> {
|
||||
@ -868,16 +868,16 @@ impl CdsTime<DaysLen24Bits> {
|
||||
Self::from_dt_generic_ps_prec(dt, LengthOfDaySegment::Long24Bits)
|
||||
}
|
||||
|
||||
/// Like [Self::from_now_with_u24_days] but with microsecond sub-millisecond precision.
|
||||
/// Like [Self::now_with_u24_days] but with microsecond sub-millisecond precision.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now_with_u24_days_us_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::from_now_generic_us_prec(LengthOfDaySegment::Long24Bits)
|
||||
pub fn now_with_u24_days_us_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::now_generic_with_us_prec(LengthOfDaySegment::Long24Bits)
|
||||
}
|
||||
|
||||
/// Like [Self::from_now_with_u24_days] but with picoseconds sub-millisecond precision.
|
||||
/// Like [Self::now_with_u24_days] but with picoseconds sub-millisecond precision.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now_with_u24_days_ps_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::from_now_generic_us_prec(LengthOfDaySegment::Long24Bits)
|
||||
pub fn now_with_u24_days_ps_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::now_generic_with_us_prec(LengthOfDaySegment::Long24Bits)
|
||||
}
|
||||
|
||||
pub fn from_bytes_with_u24_days(buf: &[u8]) -> Result<Self, TimestampError> {
|
||||
@ -926,8 +926,8 @@ impl CdsTime<DaysLen16Bits> {
|
||||
|
||||
/// Generate a time stamp from the current time using the system clock.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now_with_u16_days() -> Result<Self, StdTimestampError> {
|
||||
Self::from_now_generic(LengthOfDaySegment::Short16Bits)
|
||||
pub fn now_with_u16_days() -> Result<Self, StdTimestampError> {
|
||||
Self::now_generic(LengthOfDaySegment::Short16Bits)
|
||||
}
|
||||
|
||||
/// Create a provider from a generic UNIX timestamp (seconds since 1970-01-01T00:00:00+00:00).
|
||||
@ -937,7 +937,7 @@ impl CdsTime<DaysLen16Bits> {
|
||||
/// This function will return [CdsError::DateBeforeCcsdsEpoch] if the time is before the CCSDS
|
||||
/// epoch (1958-01-01T00:00:00+00:00) or the CCSDS days value exceeds the allowed bit width
|
||||
/// (24 bits).
|
||||
pub fn from_unix_stamp_with_u16_days(
|
||||
pub fn from_unix_time_with_u16_days(
|
||||
unix_stamp: &UnixTime,
|
||||
submillis_prec: SubmillisPrecision,
|
||||
) -> Result<Self, CdsError> {
|
||||
@ -960,13 +960,13 @@ impl CdsTime<DaysLen16Bits> {
|
||||
Self::from_dt_generic_ps_prec(dt, LengthOfDaySegment::Short16Bits)
|
||||
}
|
||||
|
||||
/// Like [Self::from_now_with_u16_days] but with microsecond sub-millisecond precision.
|
||||
/// Like [Self::now_with_u16_days] but with microsecond sub-millisecond precision.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now_with_u16_days_us_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::from_now_generic_us_prec(LengthOfDaySegment::Short16Bits)
|
||||
pub fn now_with_u16_days_us_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::now_generic_with_us_prec(LengthOfDaySegment::Short16Bits)
|
||||
}
|
||||
|
||||
/// Like [Self::from_now_with_u16_days] but with picosecond sub-millisecond precision.
|
||||
/// Like [Self::now_with_u16_days] but with picosecond sub-millisecond precision.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now_with_u16_days_ps_precision() -> Result<Self, StdTimestampError> {
|
||||
Self::from_now_generic_ps_prec(LengthOfDaySegment::Short16Bits)
|
||||
@ -1608,14 +1608,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_time_now() {
|
||||
let timestamp_now = CdsTime::from_now_with_u16_days().unwrap();
|
||||
let timestamp_now = CdsTime::now_with_u16_days().unwrap();
|
||||
let compare_stamp = chrono::Utc::now();
|
||||
generic_now_test(timestamp_now, compare_stamp);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_time_now_us_prec() {
|
||||
let timestamp_now = CdsTime::from_now_with_u16_days_us_precision().unwrap();
|
||||
let timestamp_now = CdsTime::now_with_u16_days_us_precision().unwrap();
|
||||
let compare_stamp = chrono::Utc::now();
|
||||
generic_now_test(timestamp_now, compare_stamp);
|
||||
}
|
||||
@ -1636,7 +1636,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_time_now_ps_prec_u24_days() {
|
||||
let timestamp_now = CdsTime::from_now_with_u24_days_ps_precision().unwrap();
|
||||
let timestamp_now = CdsTime::now_with_u24_days_ps_precision().unwrap();
|
||||
let compare_stamp = chrono::Utc::now();
|
||||
generic_now_test(timestamp_now, compare_stamp);
|
||||
}
|
||||
@ -1921,7 +1921,7 @@ mod tests {
|
||||
fn test_creation_from_unix_stamp_0_u16_days() {
|
||||
let unix_secs = 0;
|
||||
let subsec_millis = 0;
|
||||
let time_provider = CdsTime::from_unix_stamp_with_u16_days(
|
||||
let time_provider = CdsTime::from_unix_time_with_u16_days(
|
||||
&UnixTime::new(unix_secs, subsec_millis),
|
||||
SubmillisPrecision::Absent,
|
||||
)
|
||||
@ -1933,7 +1933,7 @@ mod tests {
|
||||
fn test_creation_from_unix_stamp_0_u24_days() {
|
||||
let unix_secs = 0;
|
||||
let subsec_millis = 0;
|
||||
let time_provider = CdsTime::from_unix_stamp_with_u24_days(
|
||||
let time_provider = CdsTime::from_unix_time_with_u24_day(
|
||||
&UnixTime::new(unix_secs, subsec_millis),
|
||||
SubmillisPrecision::Absent,
|
||||
)
|
||||
@ -1950,11 +1950,9 @@ mod tests {
|
||||
.unwrap()
|
||||
.and_local_timezone(chrono::Utc)
|
||||
.unwrap();
|
||||
let time_provider = CdsTime::from_unix_stamp_with_u16_days(
|
||||
&datetime_utc.into(),
|
||||
SubmillisPrecision::Absent,
|
||||
)
|
||||
.expect("creating provider from unix stamp failed");
|
||||
let time_provider =
|
||||
CdsTime::from_unix_time_with_u16_days(&datetime_utc.into(), SubmillisPrecision::Absent)
|
||||
.expect("creating provider from unix stamp failed");
|
||||
// https://www.timeanddate.com/date/durationresult.html?d1=01&m1=01&y1=1958&d2=14&m2=01&y2=2023
|
||||
// Leap years need to be accounted for as well.
|
||||
assert_eq!(time_provider.ccsds_days, 23754);
|
||||
@ -1970,7 +1968,7 @@ mod tests {
|
||||
fn test_creation_0_ccsds_days() {
|
||||
let unix_secs = DAYS_CCSDS_TO_UNIX as i64 * SECONDS_PER_DAY as i64;
|
||||
let subsec_millis = 0;
|
||||
let time_provider = CdsTime::from_unix_stamp_with_u16_days(
|
||||
let time_provider = CdsTime::from_unix_time_with_u16_days(
|
||||
&UnixTime::new(unix_secs, subsec_millis),
|
||||
SubmillisPrecision::Absent,
|
||||
)
|
||||
@ -1982,7 +1980,7 @@ mod tests {
|
||||
fn test_invalid_creation_from_unix_stamp_days_too_large() {
|
||||
let invalid_unix_secs: i64 = (u16::MAX as i64 + 1) * SECONDS_PER_DAY as i64;
|
||||
let subsec_millis = 0;
|
||||
match CdsTime::from_unix_stamp_with_u16_days(
|
||||
match CdsTime::from_unix_time_with_u16_days(
|
||||
&UnixTime::new(invalid_unix_secs, subsec_millis),
|
||||
SubmillisPrecision::Absent,
|
||||
) {
|
||||
@ -2009,7 +2007,7 @@ mod tests {
|
||||
// precisely 31-12-1957 23:59:55
|
||||
let unix_secs = DAYS_CCSDS_TO_UNIX * SECONDS_PER_DAY as i32 - 5;
|
||||
let subsec_millis = 0;
|
||||
match CdsTime::from_unix_stamp_with_u16_days(
|
||||
match CdsTime::from_unix_time_with_u16_days(
|
||||
&UnixTime::new(unix_secs as i64, subsec_millis),
|
||||
SubmillisPrecision::Absent,
|
||||
) {
|
||||
@ -2309,7 +2307,7 @@ mod tests {
|
||||
#[test]
|
||||
#[cfg(feature = "serde")]
|
||||
fn test_serialization() {
|
||||
let stamp_now = CdsTime::from_now_with_u16_days().expect("Error retrieving time");
|
||||
let stamp_now = CdsTime::now_with_u16_days().expect("Error retrieving time");
|
||||
let val = to_allocvec(&stamp_now).expect("Serializing timestamp failed");
|
||||
assert!(val.len() > 0);
|
||||
let stamp_deser: CdsTime = from_bytes(&val).expect("Stamp deserialization failed");
|
||||
|
@ -249,7 +249,7 @@ impl FractionalPart {
|
||||
/// const LEAP_SECONDS: u32 = 37;
|
||||
///
|
||||
/// // Highest fractional resolution
|
||||
/// let timestamp_now = CucTime::from_now(FractionalResolution::SixtyNs, LEAP_SECONDS)
|
||||
/// let timestamp_now = CucTime::now(FractionalResolution::SixtyNs, LEAP_SECONDS)
|
||||
/// .expect("creating cuc stamp failed");
|
||||
/// let mut raw_stamp = [0; 16];
|
||||
/// {
|
||||
@ -359,7 +359,7 @@ impl CucTime {
|
||||
/// must be applied on top of the UTC based time retrieved from the system in addition to the
|
||||
/// conversion to the CCSDS epoch.
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now(
|
||||
pub fn now(
|
||||
fraction_resolution: FractionalResolution,
|
||||
leap_seconds: u32,
|
||||
) -> Result<Self, StdTimestampError> {
|
||||
@ -430,15 +430,15 @@ impl CucTime {
|
||||
|
||||
/// Generates a CUC timestamp from a UNIX timestamp with a width of 4. This width is able
|
||||
/// to accomodate all possible UNIX timestamp values.
|
||||
pub fn from_unix_stamp(
|
||||
unix_stamp: &UnixTime,
|
||||
pub fn from_unix_time(
|
||||
unix_time: &UnixTime,
|
||||
res: FractionalResolution,
|
||||
leap_seconds: u32,
|
||||
) -> Result<Self, CucError> {
|
||||
let counter = unix_epoch_to_ccsds_epoch(unix_stamp.secs);
|
||||
let counter = unix_epoch_to_ccsds_epoch(unix_time.secs);
|
||||
// Negative CCSDS epoch is invalid.
|
||||
if counter < 0 {
|
||||
return Err(DateBeforeCcsdsEpochError(*unix_stamp).into());
|
||||
return Err(DateBeforeCcsdsEpochError(*unix_time).into());
|
||||
}
|
||||
// We already excluded negative values, so the conversion to u64 should always work.
|
||||
let mut counter = u32::try_from(counter).map_err(|_| CucError::InvalidCounter {
|
||||
@ -449,7 +449,7 @@ impl CucTime {
|
||||
.checked_add(leap_seconds)
|
||||
.ok_or(CucError::LeapSecondCorrectionError)?;
|
||||
let fractions =
|
||||
fractional_part_from_subsec_ns(res, unix_stamp.subsec_millis() as u64 * 10_u64.pow(6));
|
||||
fractional_part_from_subsec_ns(res, unix_time.subsec_millis() as u64 * 10_u64.pow(6));
|
||||
Self::new_generic(WidthCounterPair(4, counter as u32), fractions)
|
||||
}
|
||||
|
||||
@ -913,7 +913,7 @@ mod tests {
|
||||
#[test]
|
||||
fn test_datetime_now() {
|
||||
let now = chrono::Utc::now();
|
||||
let cuc_now = CucTime::from_now(FractionalResolution::SixtyNs, LEAP_SECONDS);
|
||||
let cuc_now = CucTime::now(FractionalResolution::SixtyNs, LEAP_SECONDS);
|
||||
assert!(cuc_now.is_ok());
|
||||
let cuc_now = cuc_now.unwrap();
|
||||
let ccsds_cuc = cuc_now.to_leap_sec_helper(LEAP_SECONDS);
|
||||
@ -1251,6 +1251,7 @@ mod tests {
|
||||
);
|
||||
assert_eq!(stamp.fractions().counter(), 0);
|
||||
let res = stamp.update_from_now(LEAP_SECONDS);
|
||||
|
||||
assert!(res.is_ok());
|
||||
}
|
||||
|
||||
@ -1382,9 +1383,8 @@ mod tests {
|
||||
#[test]
|
||||
fn from_unix_stamp() {
|
||||
let unix_stamp = UnixTime::new(0, 0);
|
||||
let cuc =
|
||||
CucTime::from_unix_stamp(&unix_stamp, FractionalResolution::Seconds, LEAP_SECONDS)
|
||||
.expect("failed to create cuc from unix stamp");
|
||||
let cuc = CucTime::from_unix_time(&unix_stamp, FractionalResolution::Seconds, LEAP_SECONDS)
|
||||
.expect("failed to create cuc from unix stamp");
|
||||
assert_eq!(
|
||||
cuc.counter(),
|
||||
(-DAYS_CCSDS_TO_UNIX * SECONDS_PER_DAY as i32) as u32 + LEAP_SECONDS
|
||||
|
@ -345,7 +345,7 @@ impl UnixTime {
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
pub fn from_now() -> Result<Self, SystemTimeError> {
|
||||
pub fn now() -> Result<Self, SystemTimeError> {
|
||||
let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH)?;
|
||||
let epoch = now.as_secs();
|
||||
Ok(Self::new(epoch as i64, now.subsec_nanos()))
|
||||
@ -356,7 +356,7 @@ impl UnixTime {
|
||||
self.secs as f64 + (self.subsec_nanos as f64 / 1_000_000_000.0)
|
||||
}
|
||||
|
||||
pub fn secs(&self) -> i64 {
|
||||
pub fn as_secs(&self) -> i64 {
|
||||
self.secs
|
||||
}
|
||||
|
||||
@ -367,7 +367,7 @@ impl UnixTime {
|
||||
|
||||
#[cfg(feature = "timelib")]
|
||||
pub fn timelib_date_time(&self) -> Result<time::OffsetDateTime, time::error::ComponentRange> {
|
||||
Ok(time::OffsetDateTime::from_unix_timestamp(self.secs())?
|
||||
Ok(time::OffsetDateTime::from_unix_timestamp(self.as_secs())?
|
||||
+ time::Duration::nanoseconds(self.subsec_nanos().into()))
|
||||
}
|
||||
|
||||
@ -649,7 +649,7 @@ mod tests {
|
||||
fn test_addition() {
|
||||
let mut stamp0 = UnixTime::new_only_secs(1);
|
||||
stamp0 += Duration::from_secs(5);
|
||||
assert_eq!(stamp0.secs(), 6);
|
||||
assert_eq!(stamp0.as_secs(), 6);
|
||||
assert_eq!(stamp0.subsec_millis(), 0);
|
||||
let stamp1 = stamp0 + Duration::from_millis(500);
|
||||
assert_eq!(stamp1.secs, 6);
|
||||
@ -678,7 +678,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_from_now() {
|
||||
let stamp_now = UnixTime::from_now().unwrap();
|
||||
let stamp_now = UnixTime::now().unwrap();
|
||||
let dt_now = stamp_now.chrono_date_time().unwrap();
|
||||
assert!(dt_now.year() >= 2020);
|
||||
}
|
||||
|
Reference in New Issue
Block a user