rust/spacepackets
6
1
Fork 0
Code Issues Pull Requests Projects Releases 33 Wiki Activity

Merge pull request 'improvement for naming' (#135) from naming-improvement into main

Browse Source 
Reviewed-on: #135
This commit was merged in pull request #135.
This commit is contained in:
Robin Müller
2025-08-26 16:22:19 +02:00
parent 8eccf1fa29 160b1dedf9
commit b8ae26c302
7 changed files with 45 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
to make it more flexible.
- `pus_version` API now returns a `Result<PusVersion, u8>` instead of a `PusVersion` to allow
modelling invalid version numbers properly.
- Renamed `CcsdsPacket::total_len` to `CcsdsPacket::packet_len`
## Removed

6
src/ecss/mod.rs
View File

@@ -227,7 +227,8 @@ pub fn verify_crc16_ccitt_false_from_raw_to_pus_error_no_table(
.ok_or(PusError::ChecksumFailure(crc16))
}
pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
/// Verify the CRC16 of a raw packet.
pub fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
let mut digest = CRC_CCITT_FALSE.digest();
digest.update(raw_data);
if digest.finalize() == 0 {
@@ -236,7 +237,8 @@ pub(crate) fn verify_crc16_ccitt_false_from_raw(raw_data: &[u8]) -> bool {
false
}
pub(crate) fn verify_crc16_ccitt_false_from_raw_no_table(raw_data: &[u8]) -> bool {
/// Verify the CRC16 of a raw packet, using the table-less implementation.
pub fn verify_crc16_ccitt_false_from_raw_no_table(raw_data: &[u8]) -> bool {
let mut digest = CRC_CCITT_FALSE_NO_TABLE.digest();
digest.update(raw_data);
if digest.finalize() == 0 {

14
src/ecss/tc.rs
View File

@@ -660,7 +660,7 @@ impl<'raw_data> PusTcReader<'raw_data> {
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();
let total_len = sp_header.packet_len();
if raw_data_len < total_len {
return Err(ByteConversionError::FromSliceTooSmall {
found: raw_data_len,
@@ -702,7 +702,7 @@ impl<'raw_data> PusTcReader<'raw_data> {
#[inline]
pub fn len_packed(&self) -> usize {
self.sp_header.total_len()
self.sp_header.packet_len()
}
#[inline]
@@ -902,7 +902,7 @@ mod tests {
assert_eq!(size, 13);
let tc_from_raw =
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 13);
assert_eq!(tc_from_raw.packet_len(), 13);
verify_test_tc_with_reader(&tc_from_raw, false, 13);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&test_buf);
@@ -924,7 +924,7 @@ mod tests {
assert_eq!(size, 13);
let tc_from_raw =
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 13);
assert_eq!(tc_from_raw.packet_len(), 13);
verify_test_tc_with_reader(&tc_from_raw, false, 13);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&test_buf);
@@ -941,7 +941,7 @@ mod tests {
assert_eq!(size, 13);
let tc_from_raw = PusTcReader::new_crc_no_table(&test_buf)
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 13);
assert_eq!(tc_from_raw.packet_len(), 13);
verify_test_tc_with_reader(&tc_from_raw, false, 13);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&test_buf);
@@ -955,7 +955,7 @@ mod tests {
assert_eq!(tc_vec.len(), 13);
let tc_from_raw = PusTcReader::new(tc_vec.as_slice())
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 13);
assert_eq!(tc_from_raw.packet_len(), 13);
verify_test_tc_with_reader(&tc_from_raw, false, 13);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&tc_vec);
@@ -981,7 +981,7 @@ mod tests {
assert_eq!(size, 16);
let tc_from_raw =
PusTcReader::new(&test_buf).expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 16);
assert_eq!(tc_from_raw.packet_len(), 16);
verify_test_tc_with_reader(&tc_from_raw, true, 16);
let user_data = tc_from_raw.user_data();
assert_eq!(tc_from_raw.user_data(), tc_from_raw.app_data());

14
src/ecss/tc_pus_a.rs
View File

@@ -716,7 +716,7 @@ impl<'raw_data> PusTcReader<'raw_data> {
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();
let total_len = sp_header.packet_len();
if raw_data_len < total_len {
return Err(ByteConversionError::FromSliceTooSmall {
found: raw_data_len,
@@ -750,7 +750,7 @@ impl<'raw_data> PusTcReader<'raw_data> {
#[inline]
pub fn len_packed(&self) -> usize {
self.sp_header.total_len()
self.sp_header.packet_len()
}
#[inline]
@@ -954,7 +954,7 @@ mod tests {
assert_eq!(size, 11);
let tc_from_raw = PusTcReader::new(&test_buf, None, 0)
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 11);
assert_eq!(tc_from_raw.packet_len(), 11);
verify_test_tc_with_reader(&tc_from_raw, false, 11);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&test_buf);
@@ -976,7 +976,7 @@ mod tests {
assert_eq!(size, 11);
let tc_from_raw = PusTcReader::new(&test_buf, None, 0)
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 11);
assert_eq!(tc_from_raw.packet_len(), 11);
verify_test_tc_with_reader(&tc_from_raw, false, 11);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&test_buf);
@@ -993,7 +993,7 @@ mod tests {
assert_eq!(size, 11);
let tc_from_raw = PusTcReader::new_crc_no_table(&test_buf, None, 0)
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 11);
assert_eq!(tc_from_raw.packet_len(), 11);
verify_test_tc_with_reader(&tc_from_raw, false, 11);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&test_buf);
@@ -1007,7 +1007,7 @@ mod tests {
assert_eq!(tc_vec.len(), 11);
let tc_from_raw = PusTcReader::new(tc_vec.as_slice(), None, 0)
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 11);
assert_eq!(tc_from_raw.packet_len(), 11);
verify_test_tc_with_reader(&tc_from_raw, false, 11);
assert!(tc_from_raw.user_data().is_empty());
verify_test_tc_raw(&tc_vec);
@@ -1033,7 +1033,7 @@ mod tests {
assert_eq!(size, 14);
let tc_from_raw = PusTcReader::new(&test_buf, None, 0)
.expect("Creating PUS TC struct from raw buffer failed");
assert_eq!(tc_from_raw.total_len(), 14);
assert_eq!(tc_from_raw.packet_len(), 14);
verify_test_tc_with_reader(&tc_from_raw, true, 14);
let user_data = tc_from_raw.user_data();
assert_eq!(tc_from_raw.user_data(), tc_from_raw.app_data());

24
src/ecss/tm.rs
View File

@@ -36,7 +36,7 @@
//!
//! // Deserialize from the raw byte representation
//! let ping_tm_reader = PusTmReader::new(&test_buf, 7).expect("Deserialization failed");
//! assert_eq!(written_size, ping_tm_reader.total_len());
//! assert_eq!(written_size, ping_tm_reader.packet_len());
//! assert_eq!(ping_tm_reader.service(), 17);
//! assert_eq!(ping_tm_reader.subservice(), 2);
//! assert_eq!(ping_tm_reader.apid(), 0x02);
@@ -725,7 +725,7 @@ impl<'raw_data> PusTmReader<'raw_data> {
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();
let total_len = sp_header.packet_len();
if raw_data_len < total_len {
return Err(ByteConversionError::FromSliceTooSmall {
found: raw_data_len,
@@ -762,7 +762,7 @@ impl<'raw_data> PusTmReader<'raw_data> {
#[inline]
pub fn len_packed(&self) -> usize {
self.sp_header.total_len()
self.sp_header.packet_len()
}
#[inline]
@@ -883,11 +883,11 @@ impl<'raw> PusTmZeroCopyWriter<'raw> {
return None;
}
let sp_header = crate::zc::SpHeader::read_from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap();
if raw_tm_len < sp_header.total_len() {
if raw_tm_len < sp_header.packet_len() {
return None;
}
let writer = Self {
raw_tm: &mut raw_tm[..sp_header.total_len()],
raw_tm: &mut raw_tm[..sp_header.packet_len()],
timestamp_len,
};
Some(writer)
@@ -1000,13 +1000,13 @@ impl PusPacket for PusTmZeroCopyWriter<'_> {
#[inline]
fn user_data(&self) -> &[u8] {
&self.raw_tm[CCSDS_HEADER_LEN + PUS_TM_MIN_SEC_HEADER_LEN + self.timestamp_len
..self.sp_header().total_len() - 2]
..self.sp_header().packet_len() - 2]
}
#[inline]
fn opt_crc16(&self) -> Option<u16> {
Some(u16::from_be_bytes(
self.raw_tm[self.sp_header().total_len() - 2..self.sp_header().total_len()]
self.raw_tm[self.sp_header().packet_len() - 2..self.sp_header().packet_len()]
.try_into()
.unwrap(),
))
@@ -1238,7 +1238,7 @@ mod tests {
assert_eq!(tm_vec.len(), 22);
let tm_deserialized =
PusTmReader::new(tm_vec.as_slice(), 7).expect("Deserialization failed");
assert_eq!(tm_vec.len(), tm_deserialized.total_len());
assert_eq!(tm_vec.len(), tm_deserialized.packet_len());
verify_ping_reply_with_reader(&tm_deserialized, false, 22, dummy_timestamp());
}
@@ -1252,7 +1252,7 @@ mod tests {
.expect("Serialization failed");
assert_eq!(ser_len, 22);
let tm_deserialized = PusTmReader::new(&buf, 7).expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1268,7 +1268,7 @@ mod tests {
WritablePusPacket::write_to_bytes(&pus_tm, &mut buf).expect("Serialization failed");
assert_eq!(ser_len, 22);
let tm_deserialized = PusTmReader::new(&buf, 7).expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1286,7 +1286,7 @@ mod tests {
assert_eq!(ser_len, 22);
let tm_deserialized =
PusTmReader::new_crc_no_table(&buf, 7).expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1497,7 +1497,7 @@ mod tests {
writer.finish();
// This performs all necessary checks, including the CRC check.
let tm_read_back = PusTmReader::new(&buf, 7).expect("Re-creating PUS TM failed");
assert_eq!(tm_read_back.total_len(), tm_size);
assert_eq!(tm_read_back.packet_len(), tm_size);
assert_eq!(tm_read_back.msg_counter(), 100);
assert_eq!(tm_read_back.dest_id(), 55);
assert_eq!(tm_read_back.seq_count(), MAX_SEQ_COUNT);

26
src/ecss/tm_pus_a.rs
View File

@@ -40,7 +40,7 @@
//!
//! // Deserialize from the raw byte representation
//! let ping_tm_reader = PusTmReader::new(&test_buf, &SecondaryHeaderParameters::new_minimal(7)).expect("deserialization failed");
//! assert_eq!(written_size, ping_tm_reader.total_len());
//! assert_eq!(written_size, ping_tm_reader.packet_len());
//! assert_eq!(ping_tm_reader.service(), 17);
//! assert_eq!(ping_tm_reader.subservice(), 2);
//! assert_eq!(ping_tm_reader.apid(), 0x02);
@@ -766,7 +766,7 @@ impl<'raw_data> PusTmReader<'raw_data> {
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();
let total_len = sp_header.packet_len();
if raw_data_len < total_len {
return Err(ByteConversionError::FromSliceTooSmall {
found: raw_data_len,
@@ -796,7 +796,7 @@ impl<'raw_data> PusTmReader<'raw_data> {
#[inline]
pub fn len_packed(&self) -> usize {
self.sp_header.total_len()
self.sp_header.packet_len()
}
#[inline]
@@ -939,11 +939,11 @@ impl<'raw> PusTmZeroCopyWriter<'raw> {
return None;
}
let sp_header = crate::zc::SpHeader::read_from_bytes(&raw_tm[0..CCSDS_HEADER_LEN]).unwrap();
if raw_tm_len < sp_header.total_len() {
if raw_tm_len < sp_header.packet_len() {
return None;
}
let writer = Self {
raw_tm: &mut raw_tm[..sp_header.total_len()],
raw_tm: &mut raw_tm[..sp_header.packet_len()],
sec_header_params: *sec_header_params,
};
Some(writer)
@@ -1113,13 +1113,13 @@ impl PusPacket for PusTmZeroCopyWriter<'_> {
&self.raw_tm[CCSDS_HEADER_LEN
+ PUS_TM_MIN_SEC_HEADER_LEN
+ self.sec_header_params.timestamp_len
..self.sp_header().total_len() - 2]
..self.sp_header().packet_len() - 2]
}
#[inline]
fn opt_crc16(&self) -> Option<u16> {
Some(u16::from_be_bytes(
self.raw_tm[self.sp_header().total_len() - 2..self.sp_header().total_len()]
self.raw_tm[self.sp_header().packet_len() - 2..self.sp_header().packet_len()]
.try_into()
.unwrap(),
))
@@ -1433,7 +1433,7 @@ mod tests {
assert_eq!(tm_vec.len(), 18);
let tm_deserialized = PusTmReader::new(tm_vec.as_slice(), &MIN_SEC_HEADER_PARAMS)
.expect("Deserialization failed");
assert_eq!(tm_vec.len(), tm_deserialized.total_len());
assert_eq!(tm_vec.len(), tm_deserialized.packet_len());
verify_ping_reply_with_reader(&tm_deserialized, false, 18, dummy_timestamp(), None, None);
}
@@ -1448,7 +1448,7 @@ mod tests {
assert_eq!(ser_len, 18);
let tm_deserialized =
PusTmReader::new(&buf, &MIN_SEC_HEADER_PARAMS).expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1479,7 +1479,7 @@ mod tests {
},
)
.expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1551,7 +1551,7 @@ mod tests {
assert_eq!(ser_len, 18);
let tm_deserialized =
PusTmReader::new(&buf, &MIN_SEC_HEADER_PARAMS).expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1569,7 +1569,7 @@ mod tests {
assert_eq!(ser_len, 18);
let tm_deserialized = PusTmReader::new_crc_no_table(&buf, &MIN_SEC_HEADER_PARAMS)
.expect("Deserialization failed");
assert_eq!(ser_len, tm_deserialized.total_len());
assert_eq!(ser_len, tm_deserialized.packet_len());
assert_eq!(tm_deserialized.user_data(), tm_deserialized.source_data());
assert_eq!(tm_deserialized.raw_data(), &buf[..ser_len]);
assert_eq!(tm_deserialized.crc16(), pus_tm.opt_crc16().unwrap());
@@ -1811,7 +1811,7 @@ mod tests {
// This performs all necessary checks, including the CRC check.
let tm_read_back =
PusTmReader::new(&buf, &MIN_SEC_HEADER_PARAMS).expect("Re-creating PUS TM failed");
assert_eq!(tm_read_back.total_len(), tm_size);
assert_eq!(tm_read_back.packet_len(), tm_size);
assert!(tm_read_back.msg_counter().is_none());
assert!(tm_read_back.dest_id().is_none());
assert_eq!(tm_read_back.seq_count(), MAX_SEQ_COUNT);

2
src/lib.rs
View File

@@ -376,7 +376,7 @@ pub trait CcsdsPacket {
fn data_len(&self) -> u16;
/// Retrieve the total packet size based on the data length field
#[inline]
fn total_len(&self) -> usize {
fn packet_len(&self) -> usize {
usize::from(self.data_len()) + CCSDS_HEADER_LEN + 1
}