rust/sat-rs
6
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 27 Wiki Activity

update all the code

Browse Source
This commit is contained in:
Robin Mueller
2025-09-10 19:01:44 +02:00
parent 2e58a311c8
commit ab44e3312c
22 changed files with 418 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
satrs-example/Cargo.toml
View File

@@ -11,6 +11,8 @@ repository = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
fern = "0.7" fern = "0.7"
chrono = "0.4" chrono = "0.4"
log = "0.4" log = "0.4"
arbitrary-int = "2"
bitbybit = "1.4"
crossbeam-channel = "0.5" crossbeam-channel = "0.5"
delegate = "0.13" delegate = "0.13"
zerocopy = "0.8" zerocopy = "0.8"

12
satrs-example/src/bin/simpleclient.rs
View File

@@ -1,7 +1,9 @@
use arbitrary_int::u11;
use satrs::pus::verification::RequestId; use satrs::pus::verification::RequestId;
use satrs::spacepackets::ecss::tc::PusTcCreator; use satrs::spacepackets::ecss::tc::PusTcCreator;
use satrs::spacepackets::ecss::tm::PusTmReader; use satrs::spacepackets::ecss::tm::PusTmReader;
use satrs::{spacepackets::ecss::PusPacket, spacepackets::SpHeader}; use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::SpHeader;
use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT}; use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
use std::net::{IpAddr, SocketAddr, UdpSocket}; use std::net::{IpAddr, SocketAddr, UdpSocket};
use std::time::Duration; use std::time::Duration;
@@ -9,7 +11,13 @@ use std::time::Duration;
fn main() { fn main() {
let mut buf = [0; 32]; let mut buf = [0; 32];
let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT); let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
let pus_tc = PusTcCreator::new_simple(SpHeader::new_from_apid(0x02), 17, 1, &[], true); let pus_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(u11::new(0x02)),
17,
1,
&[],
CreatorConfig::default(),
);
let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed"); let client = UdpSocket::bind("127.0.0.1:7302").expect("Connecting to UDP server failed");
let tc_req_id = RequestId::new(&pus_tc); let tc_req_id = RequestId::new(&pus_tc);
println!("Packing and sending PUS ping command TC[17,1] with request ID {tc_req_id}"); println!("Packing and sending PUS ping command TC[17,1] with request ID {tc_req_id}");

2
satrs-example/src/config.rs
View File

@@ -44,7 +44,7 @@ lazy_static! {
pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = { pub static ref PACKET_ID_VALIDATOR: HashSet<PacketId> = {
let mut set = HashSet::new(); let mut set = HashSet::new();
for id in crate::ids::Apid::iter() { for id in crate::ids::Apid::iter() {
set.insert(PacketId::new(PacketType::Tc, true, id as u16)); set.insert(PacketId::new(PacketType::Tc, true, id.raw_value()));
} }
set set
}; };

15
satrs-example/src/events.rs
View File

@@ -1,6 +1,7 @@
use std::sync::mpsc::{self}; use std::sync::mpsc::{self};
use crate::pus::create_verification_reporter; use crate::pus::create_verification_reporter;
use arbitrary_int::u11;
use satrs::event_man::{EventMessageU32, EventRoutingError}; use satrs::event_man::{EventMessageU32, EventRoutingError};
use satrs::pus::event::EventTmHook; use satrs::pus::event::EventTmHook;
use satrs::pus::verification::VerificationReporter; use satrs::pus::verification::VerificationReporter;
@@ -23,7 +24,7 @@ use crate::update_time;
// This helper sets the APID of the event sender for the PUS telemetry. // This helper sets the APID of the event sender for the PUS telemetry.
#[derive(Default)] #[derive(Default)]
pub struct EventApidSetter { pub struct EventApidSetter {
pub next_apid: u16, pub next_apid: u11,
} }
impl EventTmHook for EventApidSetter { impl EventTmHook for EventApidSetter {
@@ -59,7 +60,7 @@ impl<TmSender: EcssTmSender> PusEventHandler<TmSender> {
// telemetry for each event. // telemetry for each event.
let event_reporter = EventReporter::new_with_hook( let event_reporter = EventReporter::new_with_hook(
PUS_EVENT_MANAGEMENT.raw(), PUS_EVENT_MANAGEMENT.raw(),
0, u11::new(0),
0, 0,
128, 128,
EventApidSetter::default(), EventApidSetter::default(),
@@ -220,16 +221,13 @@ mod tests {
use satrs::{ use satrs::{
events::EventU32, events::EventU32,
pus::verification::VerificationReporterConfig, pus::verification::VerificationReporterConfig,
spacepackets::{ spacepackets::ecss::{tm::PusTmReader, PusPacket},
ecss::{tm::PusTmReader, PusPacket},
CcsdsPacket,
},
tmtc::PacketAsVec, tmtc::PacketAsVec,
}; };
use super::*; use super::*;
const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(1, 2); const TEST_CREATOR_ID: UniqueApidTargetId = UniqueApidTargetId::new(u11::new(1), 2);
const TEST_EVENT: EventU32 = EventU32::new(satrs::events::Severity::Info, 1, 1); const TEST_EVENT: EventU32 = EventU32::new(satrs::events::Severity::Info, 1, 1);
pub struct EventManagementTestbench { pub struct EventManagementTestbench {
@@ -244,7 +242,8 @@ mod tests {
let (event_tx, event_rx) = mpsc::sync_channel(10); let (event_tx, event_rx) = mpsc::sync_channel(10);
let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10); let (_event_req_tx, event_req_rx) = mpsc::sync_channel(10);
let (tm_sender, tm_receiver) = mpsc::channel(); let (tm_sender, tm_receiver) = mpsc::channel();
let verif_reporter_cfg = VerificationReporterConfig::new(0x05, 2, 2, 128).unwrap(); let verif_reporter_cfg =
VerificationReporterConfig::new(u11::new(0x05), 2, 2, 128).unwrap();
let verif_reporter = let verif_reporter =
VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg); VerificationReporter::new(PUS_EVENT_MANAGEMENT.id(), &verif_reporter_cfg);
let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx); let mut event_manager = EventManagerWithBoundedMpsc::new(event_rx);

4
satrs-example/src/hk.rs
View File

@@ -1,7 +1,7 @@
use derive_new::new; use derive_new::new;
use satrs::hk::UniqueId; use satrs::hk::UniqueId;
use satrs::request::UniqueApidTargetId; use satrs::request::UniqueApidTargetId;
use satrs::spacepackets::ecss::hk; use satrs::spacepackets::ecss::{hk, CreatorConfig};
use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use satrs::spacepackets::{ByteConversionError, SpHeader}; use satrs::spacepackets::{ByteConversionError, SpHeader};
@@ -63,7 +63,7 @@ impl PusHkHelper {
SpHeader::new_from_apid(self.component_id.apid), SpHeader::new_from_apid(self.component_id.apid),
sec_header, sec_header,
&buf[0..8 + hk_data_len], &buf[0..8 + hk_data_len],
true, CreatorConfig::default(),
)) ))
} }
} }

33
satrs-example/src/ids.rs
View File

@@ -1,7 +1,8 @@
//! This is an auto-generated configuration module. //! This is an auto-generated configuration module.
use satrs::request::UniqueApidTargetId; use satrs::request::UniqueApidTargetId;
#[derive(Debug, Copy, Clone, PartialEq, Eq, strum::EnumIter)] #[derive(Debug, PartialEq, Eq, strum::EnumIter)]
#[bitbybit::bitenum(u11, exhaustive = false)]
pub enum Apid { pub enum Apid {
Sched = 1, Sched = 1,
GenericPus = 2, GenericPus = 2,
@@ -21,13 +22,13 @@ pub mod acs {
} }
pub const SUBSYSTEM: super::UniqueApidTargetId = pub const SUBSYSTEM: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Subsystem as u32); super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Subsystem as u32);
pub const ASSEMBLY: super::UniqueApidTargetId = pub const ASSEMBLY: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Assembly as u32); super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Assembly as u32);
pub const MGM0: super::UniqueApidTargetId = pub const MGM0: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm0 as u32); super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Mgm0 as u32);
pub const MGM1: super::UniqueApidTargetId = pub const MGM1: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Acs as u16, Id::Mgm1 as u32); super::UniqueApidTargetId::new(super::Apid::Acs.raw_value(), Id::Mgm1 as u32);
} }
pub mod eps { pub mod eps {
@@ -38,9 +39,9 @@ pub mod eps {
} }
pub const PCDU: super::UniqueApidTargetId = pub const PCDU: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Pcdu as u32); super::UniqueApidTargetId::new(super::Apid::Eps.raw_value(), Id::Pcdu as u32);
pub const SUBSYSTEM: super::UniqueApidTargetId = pub const SUBSYSTEM: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Eps as u16, Id::Subsystem as u32); super::UniqueApidTargetId::new(super::Apid::Eps.raw_value(), Id::Subsystem as u32);
} }
pub mod generic_pus { pub mod generic_pus {
@@ -55,19 +56,19 @@ pub mod generic_pus {
} }
pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new( pub const PUS_EVENT_MANAGEMENT: super::UniqueApidTargetId = super::UniqueApidTargetId::new(
super::Apid::GenericPus as u16, super::Apid::GenericPus.raw_value(),
Id::PusEventManagement as u32, Id::PusEventManagement as u32,
); );
pub const PUS_ROUTING: super::UniqueApidTargetId = pub const PUS_ROUTING: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusRouting as u32); super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusRouting as u32);
pub const PUS_TEST: super::UniqueApidTargetId = pub const PUS_TEST: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusTest as u32); super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusTest as u32);
pub const PUS_ACTION: super::UniqueApidTargetId = pub const PUS_ACTION: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusAction as u32); super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusAction as u32);
pub const PUS_MODE: super::UniqueApidTargetId = pub const PUS_MODE: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusMode as u32); super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusMode as u32);
pub const PUS_HK: super::UniqueApidTargetId = pub const PUS_HK: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::GenericPus as u16, Id::PusHk as u32); super::UniqueApidTargetId::new(super::Apid::GenericPus.raw_value(), Id::PusHk as u32);
} }
pub mod sched { pub mod sched {
@@ -77,7 +78,7 @@ pub mod sched {
} }
pub const PUS_SCHED: super::UniqueApidTargetId = pub const PUS_SCHED: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Sched as u16, Id::PusSched as u32); super::UniqueApidTargetId::new(super::Apid::Sched.raw_value(), Id::PusSched as u32);
} }
pub mod tmtc { pub mod tmtc {
@@ -88,7 +89,7 @@ pub mod tmtc {
} }
pub const UDP_SERVER: super::UniqueApidTargetId = pub const UDP_SERVER: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::UdpServer as u32); super::UniqueApidTargetId::new(super::Apid::Tmtc.raw_value(), Id::UdpServer as u32);
pub const TCP_SERVER: super::UniqueApidTargetId = pub const TCP_SERVER: super::UniqueApidTargetId =
super::UniqueApidTargetId::new(super::Apid::Tmtc as u16, Id::TcpServer as u32); super::UniqueApidTargetId::new(super::Apid::Tmtc.raw_value(), Id::TcpServer as u32);
} }

2
satrs-example/src/lib.rs
View File

@@ -1,4 +1,4 @@
use satrs::spacepackets::time::{cds::CdsTime, TimeWriter}; use satrs::spacepackets::time::cds::CdsTime;
pub mod config; pub mod config;
pub mod ids; pub mod ids;

2
satrs-example/src/main.rs
View File

@@ -35,7 +35,7 @@ use satrs::{
mode_tree::connect_mode_nodes, mode_tree::connect_mode_nodes,
pus::{event_man::EventRequestWithToken, EcssTcCacher, HandlingStatus}, pus::{event_man::EventRequestWithToken, EcssTcCacher, HandlingStatus},
request::{GenericMessage, MessageMetadata}, request::{GenericMessage, MessageMetadata},
spacepackets::time::{cds::CdsTime, TimeWriter}, spacepackets::time::cds::CdsTime,
}; };
use satrs_example::{ use satrs_example::{
config::{ config::{

26
satrs-example/src/pus/hk.rs
View File

@@ -302,10 +302,13 @@ impl TargetedPusService for HkServiceWrapper {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use arbitrary_int::traits::Integer;
use arbitrary_int::u14;
use satrs::pus::test_util::{ use satrs::pus::test_util::{
TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1, TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
}; };
use satrs::request::MessageMetadata; use satrs::request::MessageMetadata;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::{ use satrs::{
hk::HkRequestVariant, hk::HkRequestVariant,
pus::test_util::TEST_APID, pus::test_util::TEST_APID,
@@ -324,11 +327,12 @@ mod tests {
use super::{HkReply, HkReplyHandler, HkRequestConverter}; use super::{HkReply, HkReplyHandler, HkRequestConverter};
pub const ZERO_SEQ: u14 = u14::ZERO;
#[test] #[test]
fn hk_converter_one_shot_req() { fn hk_converter_one_shot_req() {
let mut hk_bench = let mut hk_bench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
let target_id = TEST_UNIQUE_ID_0; let target_id = TEST_UNIQUE_ID_0;
let unique_id = 5_u32; let unique_id = 5_u32;
let mut app_data: [u8; 8] = [0; 8]; let mut app_data: [u8; 8] = [0; 8];
@@ -340,7 +344,7 @@ mod tests {
3, 3,
Subservice::TcGenerateOneShotHk as u8, Subservice::TcGenerateOneShotHk as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
let accepted_token = hk_bench.add_tc(&hk_req); let accepted_token = hk_bench.add_tc(&hk_req);
let (_active_req, req) = hk_bench let (_active_req, req) = hk_bench
@@ -358,7 +362,7 @@ mod tests {
fn hk_converter_enable_periodic_generation() { fn hk_converter_enable_periodic_generation() {
let mut hk_bench = let mut hk_bench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
let target_id = TEST_UNIQUE_ID_0; let target_id = TEST_UNIQUE_ID_0;
let unique_id = 5_u32; let unique_id = 5_u32;
let mut app_data: [u8; 8] = [0; 8]; let mut app_data: [u8; 8] = [0; 8];
@@ -380,7 +384,7 @@ mod tests {
3, 3,
Subservice::TcEnableHkGeneration as u8, Subservice::TcEnableHkGeneration as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
generic_check(&tc0); generic_check(&tc0);
let tc1 = PusTcCreator::new_simple( let tc1 = PusTcCreator::new_simple(
@@ -388,7 +392,7 @@ mod tests {
3, 3,
Subservice::TcEnableDiagGeneration as u8, Subservice::TcEnableDiagGeneration as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
generic_check(&tc1); generic_check(&tc1);
} }
@@ -397,7 +401,7 @@ mod tests {
fn hk_conversion_disable_periodic_generation() { fn hk_conversion_disable_periodic_generation() {
let mut hk_bench = let mut hk_bench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
let target_id = TEST_UNIQUE_ID_0; let target_id = TEST_UNIQUE_ID_0;
let unique_id = 5_u32; let unique_id = 5_u32;
let mut app_data: [u8; 8] = [0; 8]; let mut app_data: [u8; 8] = [0; 8];
@@ -419,7 +423,7 @@ mod tests {
3, 3,
Subservice::TcDisableHkGeneration as u8, Subservice::TcDisableHkGeneration as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
generic_check(&tc0); generic_check(&tc0);
let tc1 = PusTcCreator::new_simple( let tc1 = PusTcCreator::new_simple(
@@ -427,7 +431,7 @@ mod tests {
3, 3,
Subservice::TcDisableDiagGeneration as u8, Subservice::TcDisableDiagGeneration as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
generic_check(&tc1); generic_check(&tc1);
} }
@@ -436,7 +440,7 @@ mod tests {
fn hk_conversion_modify_interval() { fn hk_conversion_modify_interval() {
let mut hk_bench = let mut hk_bench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), HkRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, ZERO_SEQ, 0);
let target_id = TEST_UNIQUE_ID_0; let target_id = TEST_UNIQUE_ID_0;
let unique_id = 5_u32; let unique_id = 5_u32;
let mut app_data: [u8; 12] = [0; 12]; let mut app_data: [u8; 12] = [0; 12];
@@ -462,7 +466,7 @@ mod tests {
3, 3,
Subservice::TcModifyHkCollectionInterval as u8, Subservice::TcModifyHkCollectionInterval as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
generic_check(&tc0); generic_check(&tc0);
let tc1 = PusTcCreator::new_simple( let tc1 = PusTcCreator::new_simple(
@@ -470,7 +474,7 @@ mod tests {
3, 3,
Subservice::TcModifyDiagCollectionInterval as u8, Subservice::TcModifyDiagCollectionInterval as u8,
&app_data, &app_data,
true, CreatorConfig::default(),
); );
generic_check(&tc1); generic_check(&tc1);
} }

8
satrs-example/src/pus/mod.rs
View File

@@ -531,9 +531,11 @@ pub fn generic_pus_request_timeout_handler(
pub(crate) mod tests { pub(crate) mod tests {
use std::time::Duration; use std::time::Duration;
use arbitrary_int::u11;
use satrs::pus::test_util::TEST_COMPONENT_ID_0; use satrs::pus::test_util::TEST_COMPONENT_ID_0;
use satrs::pus::{MpscTmAsVecSender, PusTmVariant}; use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
use satrs::request::RequestId; use satrs::request::RequestId;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::{ use satrs::{
pus::{ pus::{
verification::test_util::TestVerificationReporter, ActivePusRequestStd, verification::test_util::TestVerificationReporter, ActivePusRequestStd,
@@ -590,7 +592,7 @@ pub(crate) mod tests {
pub fn add_tc( pub fn add_tc(
&mut self, &mut self,
apid: u16, apid: u11,
apid_target: u32, apid_target: u32,
time_stamp: &[u8], time_stamp: &[u8],
) -> (verification::RequestId, ActivePusRequestStd) { ) -> (verification::RequestId, ActivePusRequestStd) {
@@ -600,7 +602,7 @@ pub(crate) mod tests {
sp_header, sp_header,
sec_header_dummy, sec_header_dummy,
&[], &[],
true, CreatorConfig::default(),
)); ));
let accepted = self let accepted = self
.verif_reporter .verif_reporter
@@ -719,7 +721,7 @@ pub(crate) mod tests {
&mut self, &mut self,
token: VerificationToken<TcStateAccepted>, token: VerificationToken<TcStateAccepted>,
time_stamp: &[u8], time_stamp: &[u8],
expected_apid: u16, expected_apid: u11,
expected_apid_target: u32, expected_apid_target: u32,
) -> Result<(ActiveRequestInfo, Request), Converter::Error> { ) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
if self.current_packet.is_none() { if self.current_packet.is_none() {

24
satrs-example/src/pus/mode.rs
View File

@@ -1,5 +1,7 @@
use arbitrary_int::u14;
use derive_new::new; use derive_new::new;
use satrs::mode_tree::{ModeNode, ModeParent}; use satrs::mode_tree::{ModeNode, ModeParent};
use satrs::spacepackets::ecss::CreatorConfig;
use satrs_example::ids; use satrs_example::ids;
use std::sync::mpsc; use std::sync::mpsc;
use std::time::Duration; use std::time::Duration;
@@ -77,10 +79,10 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> for ModeReplyHandler {
.write_to_be_bytes(&mut source_data) .write_to_be_bytes(&mut source_data)
.expect("writing mode reply failed"); .expect("writing mode reply failed");
let req_id = verification::RequestId::from(reply.request_id()); let req_id = verification::RequestId::from(reply.request_id());
let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), 0, 0); let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), u14::new(0), 0);
let sec_header = let sec_header =
PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp); PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp);
let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, true); let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, CreatorConfig::default());
tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?; tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?;
verification_handler.completion_success(tm_sender, started_token, time_stamp)?; verification_handler.completion_success(tm_sender, started_token, time_stamp)?;
} }
@@ -290,8 +292,10 @@ impl TargetedPusService for ModeServiceWrapper {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use arbitrary_int::u14;
use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0}; use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
use satrs::request::MessageMetadata; use satrs::request::MessageMetadata;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::{ use satrs::{
mode::{ModeAndSubmode, ModeReply, ModeRequest}, mode::{ModeAndSubmode, ModeReply, ModeRequest},
pus::mode::Subservice, pus::mode::Subservice,
@@ -314,11 +318,11 @@ mod tests {
fn mode_converter_read_mode_request() { fn mode_converter_read_mode_request() {
let mut testbench = let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcReadMode as u8); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcReadMode as u8);
let mut app_data: [u8; 4] = [0; 4]; let mut app_data: [u8; 4] = [0; 4];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
let token = testbench.add_tc(&tc); let token = testbench.add_tc(&tc);
let (_active_req, req) = testbench let (_active_req, req) = testbench
.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -330,7 +334,7 @@ mod tests {
fn mode_converter_set_mode_request() { fn mode_converter_set_mode_request() {
let mut testbench = let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcSetMode as u8); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcSetMode as u8);
let mut app_data: [u8; 4 + ModeAndSubmode::RAW_LEN] = [0; 4 + ModeAndSubmode::RAW_LEN]; let mut app_data: [u8; 4 + ModeAndSubmode::RAW_LEN] = [0; 4 + ModeAndSubmode::RAW_LEN];
let mode_and_submode = ModeAndSubmode::new(2, 1); let mode_and_submode = ModeAndSubmode::new(2, 1);
@@ -338,7 +342,7 @@ mod tests {
mode_and_submode mode_and_submode
.write_to_be_bytes(&mut app_data[4..]) .write_to_be_bytes(&mut app_data[4..])
.unwrap(); .unwrap();
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
let token = testbench.add_tc(&tc); let token = testbench.add_tc(&tc);
let (_active_req, req) = testbench let (_active_req, req) = testbench
.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -356,11 +360,11 @@ mod tests {
fn mode_converter_announce_mode() { fn mode_converter_announce_mode() {
let mut testbench = let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceMode as u8); let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceMode as u8);
let mut app_data: [u8; 4] = [0; 4]; let mut app_data: [u8; 4] = [0; 4];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
let token = testbench.add_tc(&tc); let token = testbench.add_tc(&tc);
let (_active_req, req) = testbench let (_active_req, req) = testbench
.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)
@@ -372,12 +376,12 @@ mod tests {
fn mode_converter_announce_mode_recursively() { fn mode_converter_announce_mode_recursively() {
let mut testbench = let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default()); PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = let sec_header =
PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8); PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8);
let mut app_data: [u8; 4] = [0; 4]; let mut app_data: [u8; 4] = [0; 4];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes()); app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.to_be_bytes());
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
let token = testbench.add_tc(&tc); let token = testbench.add_tc(&tc);
let (_active_req, req) = testbench let (_active_req, req) = testbench
.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0) .convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0)

17
satrs-example/src/tmtc/tm_sink.rs
View File

@@ -3,18 +3,19 @@ use std::{
sync::mpsc::{self}, sync::mpsc::{self},
}; };
use arbitrary_int::{u11, u14};
use log::info; use log::info;
use satrs::{ use satrs::{
pool::PoolProvider, pool::PoolProvider,
spacepackets::{ spacepackets::{
ecss::{tm::PusTmZeroCopyWriter, PusPacket}, ecss::{tm::PusTmZeroCopyWriter, PusPacket},
seq_count::CcsdsSimpleSeqCountProvider, seq_count::SequenceCounterCcsdsSimple,
time::cds::MIN_CDS_FIELD_LEN, time::cds::MIN_CDS_FIELD_LEN,
CcsdsPacket, CcsdsPacket,
}, },
}; };
use satrs::{ use satrs::{
spacepackets::seq_count::SequenceCountProvider, spacepackets::seq_count::SequenceCounter,
tmtc::{PacketAsVec, PacketInPool, SharedPacketPool}, tmtc::{PacketAsVec, PacketInPool, SharedPacketPool},
}; };
@@ -22,14 +23,16 @@ use crate::interface::tcp::SyncTcpTmSource;
#[derive(Default)] #[derive(Default)]
pub struct CcsdsSeqCounterMap { pub struct CcsdsSeqCounterMap {
apid_seq_counter_map: HashMap<u16, CcsdsSimpleSeqCountProvider>, apid_seq_counter_map: HashMap<u11, SequenceCounterCcsdsSimple>,
} }
impl CcsdsSeqCounterMap { impl CcsdsSeqCounterMap {
pub fn get_and_increment(&mut self, apid: u16) -> u16 { pub fn get_and_increment(&mut self, apid: u11) -> u14 {
u14::new(
self.apid_seq_counter_map self.apid_seq_counter_map
.entry(apid) .entry(apid)
.or_default() .or_default()
.get_and_increment() .get_and_increment(),
)
} }
} }
@@ -114,7 +117,7 @@ impl TmSinkStatic {
let mut tm_copy = Vec::new(); let mut tm_copy = Vec::new();
pool_guard pool_guard
.modify(&pus_tm_in_pool.store_addr, |buf| { .modify(&pus_tm_in_pool.store_addr, |buf| {
let zero_copy_writer = PusTmZeroCopyWriter::new(buf, MIN_CDS_FIELD_LEN) let zero_copy_writer = PusTmZeroCopyWriter::new(buf, MIN_CDS_FIELD_LEN, true)
.expect("Creating TM zero copy writer failed"); .expect("Creating TM zero copy writer failed");
self.common.apply_packet_processing(zero_copy_writer); self.common.apply_packet_processing(zero_copy_writer);
tm_copy = buf.to_vec() tm_copy = buf.to_vec()
@@ -154,7 +157,7 @@ impl TmSinkDynamic {
if let Ok(mut tm) = self.tm_funnel_rx.recv() { if let Ok(mut tm) = self.tm_funnel_rx.recv() {
// Read the TM, set sequence counter and message counter, and finally update // Read the TM, set sequence counter and message counter, and finally update
// the CRC. // the CRC.
let zero_copy_writer = PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN) let zero_copy_writer = PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN, true)
.expect("Creating TM zero copy writer failed"); .expect("Creating TM zero copy writer failed");
self.common.apply_packet_processing(zero_copy_writer); self.common.apply_packet_processing(zero_copy_writer);
self.common.sync_tm_tcp_source.add_tm(&tm.packet); self.common.sync_tm_tcp_source.add_tm(&tm.packet);

2
satrs-shared/Cargo.toml
View File

@@ -11,7 +11,7 @@ license = "Apache-2.0"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
spacepackets = { version = ">=0.14, <=0.15", default-features = false } spacepackets = { git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", version = ">=0.14, <=0.16", default-features = false }
[dependencies.serde] [dependencies.serde]
version = "1" version = "1"

3
satrs/Cargo.toml
View File

@@ -14,8 +14,9 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup
[dependencies] [dependencies]
satrs-shared = { version = "0.2", path = "../satrs-shared" } satrs-shared = { version = "0.2", path = "../satrs-shared" }
spacepackets = { version = ">=0.14, <=0.15", default-features = false } spacepackets = { git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", version = "0.16", default-features = false }
arbitrary-int = "2"
delegate = ">0.7, <=0.13" delegate = ">0.7, <=0.13"
paste = "1" paste = "1"
derive-new = ">=0.6, <=0.7" derive-new = ">=0.6, <=0.7"

30
satrs/src/encoding/ccsds.rs
View File

@@ -63,7 +63,7 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
let sp_header = SpHeader::from_be_bytes(&buf[current_idx..]).unwrap().0; let sp_header = SpHeader::from_be_bytes(&buf[current_idx..]).unwrap().0;
match packet_validator.validate(&sp_header, &buf[current_idx..]) { match packet_validator.validate(&sp_header, &buf[current_idx..]) {
SpValidity::Valid => { SpValidity::Valid => {
let packet_size = sp_header.total_len(); let packet_size = sp_header.packet_len();
if (current_idx + packet_size) <= buf_len { if (current_idx + packet_size) <= buf_len {
packet_sender packet_sender
.send_packet(sender_id, &buf[current_idx..current_idx + packet_size])?; .send_packet(sender_id, &buf[current_idx..current_idx + packet_size])?;
@@ -76,7 +76,7 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
continue; continue;
} }
SpValidity::Skip => { SpValidity::Skip => {
current_idx += sp_header.total_len(); current_idx += sp_header.packet_len();
} }
// We might have lost sync. Try to find the start of a new space packet header. // We might have lost sync. Try to find the start of a new space packet header.
SpValidity::Invalid => { SpValidity::Invalid => {
@@ -89,9 +89,9 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use arbitrary_int::{u11, u14};
use spacepackets::{ use spacepackets::{
CcsdsPacket, PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader, ecss::{tc::PusTcCreator, CreatorConfig}, CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader
ecss::tc::PusTcCreator,
}; };
use crate::{ComponentId, encoding::tests::TcCacher}; use crate::{ComponentId, encoding::tests::TcCacher};
@@ -99,8 +99,8 @@ mod tests {
use super::{SpValidity, SpacePacketValidator, parse_buffer_for_ccsds_space_packets}; use super::{SpValidity, SpacePacketValidator, parse_buffer_for_ccsds_space_packets};
const PARSER_ID: ComponentId = 0x05; const PARSER_ID: ComponentId = 0x05;
const TEST_APID_0: u16 = 0x02; const TEST_APID_0: u11 = u11::new(0x02);
const TEST_APID_1: u16 = 0x10; const TEST_APID_1: u11 = u11::new(0x10);
const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0); const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0);
const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1); const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1);
@@ -131,7 +131,7 @@ mod tests {
#[test] #[test]
fn test_basic() { fn test_basic() {
let sph = SpHeader::new_from_apid(TEST_APID_0); let sph = SpHeader::new_from_apid(TEST_APID_0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32]; let mut buffer: [u8; 32] = [0; 32];
let packet_len = ping_tc let packet_len = ping_tc
.write_to_bytes(&mut buffer) .write_to_bytes(&mut buffer)
@@ -156,8 +156,8 @@ mod tests {
#[test] #[test]
fn test_multi_packet() { fn test_multi_packet() {
let sph = SpHeader::new_from_apid(TEST_APID_0); let sph = SpHeader::new_from_apid(TEST_APID_0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true); let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32]; let mut buffer: [u8; 32] = [0; 32];
let packet_len_ping = ping_tc let packet_len_ping = ping_tc
.write_to_bytes(&mut buffer) .write_to_bytes(&mut buffer)
@@ -191,9 +191,9 @@ mod tests {
#[test] #[test]
fn test_multi_apid() { fn test_multi_apid() {
let sph = SpHeader::new_from_apid(TEST_APID_0); let sph = SpHeader::new_from_apid(TEST_APID_0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let sph = SpHeader::new_from_apid(TEST_APID_1); let sph = SpHeader::new_from_apid(TEST_APID_1);
let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], true); let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32]; let mut buffer: [u8; 32] = [0; 32];
let packet_len_ping = ping_tc let packet_len_ping = ping_tc
.write_to_bytes(&mut buffer) .write_to_bytes(&mut buffer)
@@ -222,9 +222,9 @@ mod tests {
#[test] #[test]
fn test_split_packet_multi() { fn test_split_packet_multi() {
let ping_tc = let ping_tc =
PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], CreatorConfig::default());
let action_tc = let action_tc =
PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true); PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32]; let mut buffer: [u8; 32] = [0; 32];
let packet_len_ping = ping_tc let packet_len_ping = ping_tc
.write_to_bytes(&mut buffer) .write_to_bytes(&mut buffer)
@@ -256,7 +256,7 @@ mod tests {
#[test] #[test]
fn test_one_split_packet() { fn test_one_split_packet() {
let ping_tc = let ping_tc =
PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32]; let mut buffer: [u8; 32] = [0; 32];
let packet_len_ping = ping_tc let packet_len_ping = ping_tc
.write_to_bytes(&mut buffer) .write_to_bytes(&mut buffer)
@@ -281,7 +281,7 @@ mod tests {
fn test_smallest_packet() { fn test_smallest_packet() {
let ccsds_header_only = SpHeader::new( let ccsds_header_only = SpHeader::new(
PacketId::new(PacketType::Tc, true, TEST_APID_0), PacketId::new(PacketType::Tc, true, TEST_APID_0),
PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 0), PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(0)),
0, 0,
); );
let mut buf: [u8; 7] = [0; 7]; let mut buf: [u8; 7] = [0; 7];

35
satrs/src/pus/event.rs
View File

@@ -1,9 +1,9 @@
use crate::pus::source_buffer_large_enough; use crate::pus::source_buffer_large_enough;
use arbitrary_int::u11;
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
use spacepackets::ByteConversionError; use spacepackets::ByteConversionError;
use spacepackets::ecss::EcssEnumeration; use spacepackets::SpHeader;
use spacepackets::ecss::tm::PusTmCreator;
use spacepackets::ecss::tm::PusTmSecondaryHeader;
use spacepackets::{MAX_APID, SpHeader};
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub use alloc_mod::*; pub use alloc_mod::*;
@@ -11,16 +11,13 @@ pub use alloc_mod::*;
pub use spacepackets::ecss::event::*; pub use spacepackets::ecss::event::*;
pub struct EventReportCreator { pub struct EventReportCreator {
apid: u16, apid: u11,
pub dest_id: u16, pub dest_id: u16,
} }
impl EventReportCreator { impl EventReportCreator {
pub fn new(apid: u16, dest_id: u16) -> Option<Self> { pub fn new(apid: u11, dest_id: u16) -> Self {
if apid > MAX_APID { Self { dest_id, apid }
return None;
}
Some(Self { dest_id, apid })
} }
pub fn event_info<'time, 'src_data>( pub fn event_info<'time, 'src_data>(
@@ -124,7 +121,7 @@ impl EventReportCreator {
SpHeader::new_from_apid(self.apid), SpHeader::new_from_apid(self.apid),
sec_header, sec_header,
&src_data_buf[0..current_idx], &src_data_buf[0..current_idx],
true, CreatorConfig::default()
)) ))
} }
} }
@@ -132,8 +129,8 @@ impl EventReportCreator {
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
mod alloc_mod { mod alloc_mod {
use super::*; use super::*;
use crate::ComponentId;
use crate::pus::{EcssTmSender, EcssTmtcError}; use crate::pus::{EcssTmSender, EcssTmtcError};
use crate::ComponentId;
use alloc::vec; use alloc::vec;
use alloc::vec::Vec; use alloc::vec::Vec;
use core::cell::RefCell; use core::cell::RefCell;
@@ -162,11 +159,11 @@ mod alloc_mod {
impl EventReporter<DummyEventHook> { impl EventReporter<DummyEventHook> {
pub fn new( pub fn new(
id: ComponentId, id: ComponentId,
default_apid: u16, default_apid: u11,
default_dest_id: u16, default_dest_id: u16,
max_event_id_and_aux_data_size: usize, max_event_id_and_aux_data_size: usize,
) -> Option<Self> { ) -> Option<Self> {
let reporter = EventReportCreator::new(default_apid, default_dest_id)?; let reporter = EventReportCreator::new(default_apid, default_dest_id);
Some(Self { Some(Self {
id, id,
source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]), source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
@@ -178,12 +175,12 @@ mod alloc_mod {
impl<EventTmHookInstance: EventTmHook> EventReporter<EventTmHookInstance> { impl<EventTmHookInstance: EventTmHook> EventReporter<EventTmHookInstance> {
pub fn new_with_hook( pub fn new_with_hook(
id: ComponentId, id: ComponentId,
default_apid: u16, default_apid: u11,
default_dest_id: u16, default_dest_id: u16,
max_event_id_and_aux_data_size: usize, max_event_id_and_aux_data_size: usize,
tm_hook: EventTmHookInstance, tm_hook: EventTmHookInstance,
) -> Option<Self> { ) -> Option<Self> {
let reporter = EventReportCreator::new(default_apid, default_dest_id)?; let reporter = EventReportCreator::new(default_apid, default_dest_id);
Some(Self { Some(Self {
id, id,
source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]), source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
@@ -265,18 +262,18 @@ mod alloc_mod {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::ComponentId;
use crate::events::{EventU32, Severity}; use crate::events::{EventU32, Severity};
use crate::pus::test_util::TEST_COMPONENT_ID_0; use crate::pus::test_util::TEST_COMPONENT_ID_0;
use crate::pus::tests::CommonTmInfo; use crate::pus::tests::CommonTmInfo;
use crate::pus::{ChannelWithId, EcssTmSender, EcssTmtcError, PusTmVariant}; use crate::pus::{ChannelWithId, EcssTmSender, EcssTmtcError, PusTmVariant};
use spacepackets::ByteConversionError; use crate::ComponentId;
use spacepackets::ecss::PusError; use spacepackets::ecss::PusError;
use spacepackets::ByteConversionError;
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::VecDeque; use std::collections::VecDeque;
use std::vec::Vec; use std::vec::Vec;
const EXAMPLE_APID: u16 = 0xee; const EXAMPLE_APID: u11 = u11::new(0xee);
const EXAMPLE_GROUP_ID: u16 = 2; const EXAMPLE_GROUP_ID: u16 = 2;
const EXAMPLE_EVENT_ID_0: u16 = 1; const EXAMPLE_EVENT_ID_0: u16 = 1;
#[allow(dead_code)] #[allow(dead_code)]

16
satrs/src/pus/mod.rs
View File

@@ -1258,6 +1258,7 @@ pub(crate) fn source_buffer_large_enough(
#[cfg(any(feature = "test_util", test))] #[cfg(any(feature = "test_util", test))]
pub mod test_util { pub mod test_util {
use arbitrary_int::u11;
use spacepackets::ecss::{tc::PusTcCreator, tm::PusTmReader}; use spacepackets::ecss::{tc::PusTcCreator, tm::PusTmReader};
use crate::request::UniqueApidTargetId; use crate::request::UniqueApidTargetId;
@@ -1267,7 +1268,7 @@ pub mod test_util {
verification::{self, TcStateAccepted, VerificationToken}, verification::{self, TcStateAccepted, VerificationToken},
}; };
pub const TEST_APID: u16 = 0x101; pub const TEST_APID: u11 = u11::new(0x101);
pub const TEST_UNIQUE_ID_0: u32 = 0x05; pub const TEST_UNIQUE_ID_0: u32 = 0x05;
pub const TEST_UNIQUE_ID_1: u32 = 0x06; pub const TEST_UNIQUE_ID_1: u32 = 0x06;
@@ -1302,6 +1303,7 @@ pub mod tests {
use alloc::collections::VecDeque; use alloc::collections::VecDeque;
use alloc::vec::Vec; use alloc::vec::Vec;
use arbitrary_int::{u11, u14};
use satrs_shared::res_code::ResultU16; use satrs_shared::res_code::ResultU16;
use spacepackets::CcsdsPacket; use spacepackets::CcsdsPacket;
use spacepackets::ecss::tc::{PusTcCreator, PusTcReader}; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader};
@@ -1324,8 +1326,8 @@ pub mod tests {
#[derive(Debug, Eq, PartialEq, Clone)] #[derive(Debug, Eq, PartialEq, Clone)]
pub(crate) struct CommonTmInfo { pub(crate) struct CommonTmInfo {
pub subservice: u8, pub subservice: u8,
pub apid: u16, pub apid: u11,
pub seq_count: u16, pub seq_count: u14,
pub msg_counter: u16, pub msg_counter: u16,
pub dest_id: u16, pub dest_id: u16,
pub timestamp: Vec<u8>, pub timestamp: Vec<u8>,
@@ -1334,8 +1336,8 @@ pub mod tests {
impl CommonTmInfo { impl CommonTmInfo {
pub fn new( pub fn new(
subservice: u8, subservice: u8,
apid: u16, apid: u11,
seq_count: u16, seq_count: u14,
msg_counter: u16, msg_counter: u16,
dest_id: u16, dest_id: u16,
timestamp: &[u8], timestamp: &[u8],
@@ -1351,11 +1353,11 @@ pub mod tests {
} }
pub fn new_zero_seq_count( pub fn new_zero_seq_count(
subservice: u8, subservice: u8,
apid: u16, apid: u11,
dest_id: u16, dest_id: u16,
timestamp: &[u8], timestamp: &[u8],
) -> Self { ) -> Self {
Self::new(subservice, apid, 0, 0, dest_id, timestamp) Self::new(subservice, apid, u14::new(0), 0, dest_id, timestamp)
} }
pub fn new_from_tm(tm: &PusTmCreator) -> Self { pub fn new_from_tm(tm: &PusTmCreator) -> Self {

218
satrs/src/pus/scheduler.rs
View File

@@ -2,6 +2,7 @@
//! //!
//! The core data structure of this module is the [PusScheduler]. This structure can be used //! The core data structure of this module is the [PusScheduler]. This structure can be used
//! to perform the scheduling of telecommands like specified in the ECSS standard. //! to perform the scheduling of telecommands like specified in the ECSS standard.
use arbitrary_int::{u11, u14};
use core::fmt::{Debug, Display, Formatter}; use core::fmt::{Debug, Display, Formatter};
use core::time::Duration; use core::time::Duration;
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
@@ -26,20 +27,23 @@ pub use alloc_mod::*;
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct RequestId { pub struct RequestId {
pub(crate) source_id: u16, pub(crate) source_id: u16,
pub(crate) apid: u16, pub(crate) apid: u11,
pub(crate) seq_count: u16, pub(crate) seq_count: u14,
} }
impl RequestId { impl RequestId {
pub fn source_id(&self) -> u16 { #[inline]
pub const fn source_id(&self) -> u16 {
self.source_id self.source_id
} }
pub fn apid(&self) -> u16 { #[inline]
pub const fn apid(&self) -> u11 {
self.apid self.apid
} }
pub fn seq_count(&self) -> u16 { #[inline]
pub const fn seq_count(&self) -> u14 {
self.seq_count self.seq_count
} }
@@ -53,8 +57,11 @@ impl RequestId {
} }
} }
pub fn as_u64(&self) -> u64 { #[inline]
((self.source_id as u64) << 32) | ((self.apid as u64) << 16) | self.seq_count as u64 pub const fn as_u64(&self) -> u64 {
((self.source_id as u64) << 32)
| ((self.apid.value() as u64) << 16)
| self.seq_count.value() as u64
} }
} }
@@ -340,8 +347,8 @@ pub fn generate_insert_telecommand_app_data(
pub mod alloc_mod { pub mod alloc_mod {
use alloc::{ use alloc::{
collections::{ collections::{
BTreeMap,
btree_map::{Entry, Range}, btree_map::{Entry, Range},
BTreeMap,
}, },
vec::Vec, vec::Vec,
}; };
@@ -855,42 +862,45 @@ mod tests {
PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig, PoolAddr, PoolError, PoolProvider, StaticMemoryPool, StaticPoolAddr, StaticPoolConfig,
}; };
use alloc::collections::btree_map::Range; use alloc::collections::btree_map::Range;
use spacepackets::ecss::WritablePusPacket; use arbitrary_int::traits::Integer as _;
use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
use spacepackets::time::{TimeWriter, UnixTime, cds}; use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
use spacepackets::{PacketId, PacketSequenceCtrl, PacketType, SequenceFlags, SpHeader}; use spacepackets::time::{cds, TimeWriter, UnixTime};
use spacepackets::{PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader};
use std::time::Duration; use std::time::Duration;
use std::vec::Vec; use std::vec::Vec;
#[allow(unused_imports)] #[allow(unused_imports)]
use std::{println, vec}; use std::{println, vec};
const ZERO_SEQ: u14 = u14::ZERO;
fn pus_tc_base(timestamp: UnixTime, buf: &mut [u8]) -> (SpHeader, usize) { fn pus_tc_base(timestamp: UnixTime, buf: &mut [u8]) -> (SpHeader, usize) {
let cds_time = let cds_time =
cds::CdsTime::from_unix_time_with_u16_days(&timestamp, cds::SubmillisPrecision::Absent) cds::CdsTime::from_unix_time_with_u16_days(&timestamp, cds::SubmillisPrecision::Absent)
.unwrap(); .unwrap();
let len_time_stamp = cds_time.write_to_bytes(buf).unwrap(); let len_time_stamp = cds_time.write_to_bytes(buf).unwrap();
let len_packet = base_ping_tc_simple_ctor(0, &[]) let len_packet = base_ping_tc_simple_ctor(u14::new(0), &[])
.write_to_bytes(&mut buf[len_time_stamp..]) .write_to_bytes(&mut buf[len_time_stamp..])
.unwrap(); .unwrap();
( (
SpHeader::new_for_unseg_tc(0x02, 0x34, len_packet as u16), SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(0x34), len_packet as u16),
len_packet + len_time_stamp, len_packet + len_time_stamp,
) )
} }
fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> { fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
let (sph, len_app_data) = pus_tc_base(timestamp, buf); let (sph, len_app_data) = pus_tc_base(timestamp, buf);
PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], true) PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], CreatorConfig::default())
} }
fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> { fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
let (sph, len_app_data) = pus_tc_base(timestamp, buf); let (sph, len_app_data) = pus_tc_base(timestamp, buf);
PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], true) PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], CreatorConfig::default())
} }
fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> { fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
let (sph, len_app_data) = pus_tc_base(timestamp, buf); let (sph, len_app_data) = pus_tc_base(timestamp, buf);
PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], true) PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], CreatorConfig::default())
} }
fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> { fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
@@ -898,30 +908,37 @@ mod tests {
cds::CdsTime::from_unix_time_with_u16_days(&timestamp, cds::SubmillisPrecision::Absent) cds::CdsTime::from_unix_time_with_u16_days(&timestamp, cds::SubmillisPrecision::Absent)
.unwrap(); .unwrap();
let len_time_stamp = cds_time.write_to_bytes(buf).unwrap(); let len_time_stamp = cds_time.write_to_bytes(buf).unwrap();
let sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 0); let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(0x34), 0);
// app data should not matter, double wrapped time-tagged commands should be rejected right // app data should not matter, double wrapped time-tagged commands should be rejected right
// away // away
let inner_time_tagged_tc = PusTcCreator::new_simple(sph, 11, 4, &[], true); let inner_time_tagged_tc =
PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default());
let packet_len = inner_time_tagged_tc let packet_len = inner_time_tagged_tc
.write_to_bytes(&mut buf[len_time_stamp..]) .write_to_bytes(&mut buf[len_time_stamp..])
.expect("writing inner time tagged tc failed"); .expect("writing inner time tagged tc failed");
PusTcCreator::new_simple(sph, 11, 4, &buf[..len_time_stamp + packet_len], true) PusTcCreator::new_simple(
sph,
11,
4,
&buf[..len_time_stamp + packet_len],
CreatorConfig::default(),
)
} }
fn invalid_time_tagged_cmd() -> PusTcCreator<'static> { fn invalid_time_tagged_cmd() -> PusTcCreator<'static> {
let sph = SpHeader::new_for_unseg_tc(0x02, 0x34, 1); let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(0x34), 1);
PusTcCreator::new_simple(sph, 11, 4, &[], true) PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default())
} }
fn base_ping_tc_simple_ctor(seq_count: u16, app_data: &'static [u8]) -> PusTcCreator<'static> { fn base_ping_tc_simple_ctor(seq_count: u14, app_data: &'static [u8]) -> PusTcCreator<'static> {
let sph = SpHeader::new_for_unseg_tc(0x02, seq_count, 0); let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), seq_count, 0);
PusTcCreator::new_simple(sph, 17, 1, app_data, true) PusTcCreator::new_simple(sph, 17, 1, app_data, CreatorConfig::default())
} }
fn ping_tc_to_store( fn ping_tc_to_store(
pool: &mut StaticMemoryPool, pool: &mut StaticMemoryPool,
buf: &mut [u8], buf: &mut [u8],
seq_count: u16, seq_count: u14,
app_data: &'static [u8], app_data: &'static [u8],
) -> TcInfo { ) -> TcInfo {
let ping_tc = base_ping_tc_simple_ctor(seq_count, app_data); let ping_tc = base_ping_tc_simple_ctor(seq_count, app_data);
@@ -949,7 +966,7 @@ mod tests {
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc( .insert_unwrapped_and_stored_tc(
@@ -959,7 +976,7 @@ mod tests {
.unwrap(); .unwrap();
let app_data = &[0, 1, 2]; let app_data = &[0, 1, 2];
let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, app_data); let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), app_data);
scheduler scheduler
.insert_unwrapped_and_stored_tc( .insert_unwrapped_and_stored_tc(
UnixTime::new_only_secs(200), UnixTime::new_only_secs(200),
@@ -968,7 +985,7 @@ mod tests {
.unwrap(); .unwrap();
let app_data = &[0, 1, 2]; let app_data = &[0, 1, 2];
let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, app_data); let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, u14::new(2), app_data);
scheduler scheduler
.insert_unwrapped_and_stored_tc( .insert_unwrapped_and_stored_tc(
UnixTime::new_only_secs(300), UnixTime::new_only_secs(300),
@@ -999,8 +1016,8 @@ mod tests {
packet_idx: 1, packet_idx: 1,
}), }),
RequestId { RequestId {
seq_count: 1, seq_count: u14::new(1),
apid: 0, apid: u11::new(0),
source_id: 0, source_id: 0,
}, },
), ),
@@ -1016,8 +1033,8 @@ mod tests {
packet_idx: 2, packet_idx: 2,
}), }),
RequestId { RequestId {
seq_count: 2, seq_count: u14::new(2),
apid: 1, apid: u11::new(1),
source_id: 5, source_id: 5,
}, },
), ),
@@ -1035,8 +1052,8 @@ mod tests {
.into(), .into(),
RequestId { RequestId {
source_id: 10, source_id: 10,
seq_count: 20, seq_count: u14::new(20),
apid: 23, apid: u11::new(23),
}, },
), ),
) )
@@ -1079,14 +1096,15 @@ mod tests {
let src_id_to_set = 12; let src_id_to_set = 12;
let apid_to_set = 0x22; let apid_to_set = 0x22;
let seq_count = 105; let seq_count = 105;
let sp_header = SpHeader::new_for_unseg_tc(apid_to_set, 105, 0); let sp_header = SpHeader::new_for_unseg_tc(u11::new(apid_to_set), u14::new(105), 0);
let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1); let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1);
sec_header.source_id = src_id_to_set; sec_header.source_id = src_id_to_set;
let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let ping_tc =
PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let req_id = RequestId::from_tc(&ping_tc); let req_id = RequestId::from_tc(&ping_tc);
assert_eq!(req_id.source_id(), src_id_to_set); assert_eq!(req_id.source_id(), src_id_to_set);
assert_eq!(req_id.apid(), apid_to_set); assert_eq!(req_id.apid().value(), apid_to_set);
assert_eq!(req_id.seq_count(), seq_count); assert_eq!(req_id.seq_count().value(), seq_count);
assert_eq!( assert_eq!(
req_id.as_u64(), req_id.as_u64(),
((src_id_to_set as u64) << 32) | (apid_to_set as u64) << 16 | seq_count as u64 ((src_id_to_set as u64) << 32) | (apid_to_set as u64) << 16 | seq_count as u64
@@ -1101,13 +1119,13 @@ mod tests {
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("insertion failed"); .expect("insertion failed");
let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1)
.expect("insertion failed"); .expect("insertion failed");
@@ -1169,13 +1187,13 @@ mod tests {
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("insertion failed"); .expect("insertion failed");
let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1)
.expect("insertion failed"); .expect("insertion failed");
@@ -1231,13 +1249,13 @@ mod tests {
scheduler.disable(); scheduler.disable();
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("insertion failed"); .expect("insertion failed");
let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1)
.expect("insertion failed"); .expect("insertion failed");
@@ -1298,7 +1316,7 @@ mod tests {
false, false,
)); ));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
let info = scheduler let info = scheduler
.insert_unwrapped_tc( .insert_unwrapped_tc(
@@ -1313,7 +1331,7 @@ mod tests {
let mut read_buf: [u8; 64] = [0; 64]; let mut read_buf: [u8; 64] = [0; 64];
pool.read(&tc_info_0.addr(), &mut read_buf).unwrap(); pool.read(&tc_info_0.addr(), &mut read_buf).unwrap();
let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data"); let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data");
assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[])); assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));
assert_eq!(scheduler.num_scheduled_telecommands(), 1); assert_eq!(scheduler.num_scheduled_telecommands(), 1);
@@ -1335,8 +1353,8 @@ mod tests {
let read_len = pool.read(&addr_vec[0], &mut read_buf).unwrap(); let read_len = pool.read(&addr_vec[0], &mut read_buf).unwrap();
let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data"); let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data");
assert_eq!(read_len, check_tc.total_len()); assert_eq!(read_len, check_tc.packet_len());
assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[])); assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));
} }
#[test] #[test]
@@ -1362,8 +1380,8 @@ mod tests {
let read_len = pool.read(&info.addr, &mut buf).unwrap(); let read_len = pool.read(&info.addr, &mut buf).unwrap();
let check_tc = PusTcReader::new(&buf).expect("incorrect Pus tc raw data"); let check_tc = PusTcReader::new(&buf).expect("incorrect Pus tc raw data");
assert_eq!(read_len, check_tc.total_len()); assert_eq!(read_len, check_tc.packet_len());
assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[])); assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));
assert_eq!(scheduler.num_scheduled_telecommands(), 1); assert_eq!(scheduler.num_scheduled_telecommands(), 1);
@@ -1387,8 +1405,8 @@ mod tests {
let read_len = pool.read(&addr_vec[0], &mut buf).unwrap(); let read_len = pool.read(&addr_vec[0], &mut buf).unwrap();
let check_tc = PusTcReader::new(&buf).expect("incorrect PUS tc raw data"); let check_tc = PusTcReader::new(&buf).expect("incorrect PUS tc raw data");
assert_eq!(read_len, check_tc.total_len()); assert_eq!(read_len, check_tc.packet_len());
assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[])); assert_eq!(check_tc, base_ping_tc_simple_ctor(u14::new(0), &[]));
} }
#[test] #[test]
@@ -1531,7 +1549,7 @@ mod tests {
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("insertion failed"); .expect("insertion failed");
@@ -1568,7 +1586,7 @@ mod tests {
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("insertion failed"); .expect("insertion failed");
@@ -1594,7 +1612,7 @@ mod tests {
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("inserting tc failed"); .expect("inserting tc failed");
@@ -1615,7 +1633,7 @@ mod tests {
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("inserting tc failed"); .expect("inserting tc failed");
@@ -1636,15 +1654,15 @@ mod tests {
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("inserting tc failed"); .expect("inserting tc failed");
let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_1)
.expect("inserting tc failed"); .expect("inserting tc failed");
let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, 2, &[]); let tc_info_2 = ping_tc_to_store(&mut pool, &mut buf, u14::new(2), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_2) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_2)
.expect("inserting tc failed"); .expect("inserting tc failed");
@@ -1703,7 +1721,7 @@ mod tests {
fn insert_command_with_release_time( fn insert_command_with_release_time(
pool: &mut StaticMemoryPool, pool: &mut StaticMemoryPool,
scheduler: &mut PusScheduler, scheduler: &mut PusScheduler,
seq_count: u16, seq_count: u14,
release_secs: u64, release_secs: u64,
) -> TcInfo { ) -> TcInfo {
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
@@ -1722,8 +1740,10 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); let tc_info_0 =
let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 50);
let tc_info_1 =
insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 100);
assert_eq!(scheduler.num_scheduled_telecommands(), 2); assert_eq!(scheduler.num_scheduled_telecommands(), 2);
let check_range = |range: Range<UnixTime, Vec<TcInfo>>| { let check_range = |range: Range<UnixTime, Vec<TcInfo>>| {
let mut tcs_in_range = 0; let mut tcs_in_range = 0;
@@ -1754,9 +1774,11 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 50);
let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); let tc_info_1 =
let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150); insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 100);
let tc_info_2 =
insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 150);
let start_stamp = cds::CdsTime::from_unix_time_with_u16_days( let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
&UnixTime::new_only_secs(100), &UnixTime::new_only_secs(100),
cds::SubmillisPrecision::Absent, cds::SubmillisPrecision::Absent,
@@ -1789,9 +1811,11 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); let tc_info_0 =
let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 50);
let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150); let tc_info_1 =
insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 100);
let _ = insert_command_with_release_time(&mut pool, &mut scheduler, u14::new(0), 150);
assert_eq!(scheduler.num_scheduled_telecommands(), 3); assert_eq!(scheduler.num_scheduled_telecommands(), 3);
let end_stamp = cds::CdsTime::from_unix_time_with_u16_days( let end_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1824,10 +1848,10 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); let _ = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150); let tc_info_2 = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 200); let _ = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 200);
assert_eq!(scheduler.num_scheduled_telecommands(), 4); assert_eq!(scheduler.num_scheduled_telecommands(), 4);
let start_stamp = cds::CdsTime::from_unix_time_with_u16_days( let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1865,8 +1889,8 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
assert_eq!(scheduler.num_scheduled_telecommands(), 2); assert_eq!(scheduler.num_scheduled_telecommands(), 2);
let del_res = scheduler.delete_all(&mut pool); let del_res = scheduler.delete_all(&mut pool);
assert!(del_res.is_ok()); assert!(del_res.is_ok());
@@ -1875,8 +1899,8 @@ mod tests {
// Contrary to reset, this does not disable the scheduler. // Contrary to reset, this does not disable the scheduler.
assert!(scheduler.is_enabled()); assert!(scheduler.is_enabled());
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
assert_eq!(scheduler.num_scheduled_telecommands(), 2); assert_eq!(scheduler.num_scheduled_telecommands(), 2);
let del_res = scheduler let del_res = scheduler
.delete_by_time_filter(TimeWindow::<cds::CdsTime>::new_select_all(), &mut pool); .delete_by_time_filter(TimeWindow::<cds::CdsTime>::new_select_all(), &mut pool);
@@ -1894,9 +1918,9 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150); let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
assert_eq!(scheduler.num_scheduled_telecommands(), 3); assert_eq!(scheduler.num_scheduled_telecommands(), 3);
let start_stamp = cds::CdsTime::from_unix_time_with_u16_days( let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
&UnixTime::new_only_secs(100), &UnixTime::new_only_secs(100),
@@ -1919,9 +1943,9 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
assert_eq!(scheduler.num_scheduled_telecommands(), 3); assert_eq!(scheduler.num_scheduled_telecommands(), 3);
let end_stamp = cds::CdsTime::from_unix_time_with_u16_days( let end_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1945,11 +1969,11 @@ mod tests {
false, false,
)); ));
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let cmd_out_of_range_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50); let cmd_out_of_range_0 = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 50);
let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100); let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100);
let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 150); let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150);
let cmd_out_of_range_1 = let cmd_out_of_range_1 =
insert_command_with_release_time(&mut pool, &mut scheduler, 0, 200); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 200);
assert_eq!(scheduler.num_scheduled_telecommands(), 4); assert_eq!(scheduler.num_scheduled_telecommands(), 4);
let start_stamp = cds::CdsTime::from_unix_time_with_u16_days( let start_stamp = cds::CdsTime::from_unix_time_with_u16_days(
@@ -1982,13 +2006,13 @@ mod tests {
let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
let mut buf: [u8; 32] = [0; 32]; let mut buf: [u8; 32] = [0; 32];
let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]); let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, u14::new(0), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(100), tc_info_0)
.expect("insertion failed"); .expect("insertion failed");
let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, 1, &[]); let tc_info_1 = ping_tc_to_store(&mut pool, &mut buf, u14::new(1), &[]);
scheduler scheduler
.insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1) .insert_unwrapped_and_stored_tc(UnixTime::new_only_secs(200), tc_info_1)
.expect("insertion failed"); .expect("insertion failed");
@@ -2017,12 +2041,12 @@ mod tests {
fn test_generic_insert_app_data_test() { fn test_generic_insert_app_data_test() {
let time_writer = cds::CdsTime::new_with_u16_days(1, 1); let time_writer = cds::CdsTime::new_with_u16_days(1, 1);
let sph = SpHeader::new( let sph = SpHeader::new(
PacketId::new(PacketType::Tc, true, 0x002), PacketId::new(PacketType::Tc, true, u11::new(0x002)),
PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5), PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
0, 0,
); );
let sec_header = PusTcSecondaryHeader::new_simple(17, 1); let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true); let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
let mut buf: [u8; 64] = [0; 64]; let mut buf: [u8; 64] = [0; 64];
let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc); let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc);
assert!(result.is_ok()); assert!(result.is_ok());
@@ -2039,12 +2063,12 @@ mod tests {
fn test_generic_insert_app_data_test_byte_conv_error() { fn test_generic_insert_app_data_test_byte_conv_error() {
let time_writer = cds::CdsTime::new_with_u16_days(1, 1); let time_writer = cds::CdsTime::new_with_u16_days(1, 1);
let sph = SpHeader::new( let sph = SpHeader::new(
PacketId::new(PacketType::Tc, true, 0x002), PacketId::new(PacketType::Tc, true, u11::new(0x002)),
PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5), PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
0, 0,
); );
let sec_header = PusTcSecondaryHeader::new_simple(17, 1); let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true); let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
let mut buf: [u8; 16] = [0; 16]; let mut buf: [u8; 16] = [0; 16];
let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc); let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc);
assert!(result.is_err()); assert!(result.is_err());
@@ -2068,12 +2092,12 @@ mod tests {
fn test_generic_insert_app_data_test_as_vec() { fn test_generic_insert_app_data_test_as_vec() {
let time_writer = cds::CdsTime::new_with_u16_days(1, 1); let time_writer = cds::CdsTime::new_with_u16_days(1, 1);
let sph = SpHeader::new( let sph = SpHeader::new(
PacketId::new(PacketType::Tc, true, 0x002), PacketId::new(PacketType::Tc, true, u11::new(0x002)),
PacketSequenceCtrl::new(SequenceFlags::Unsegmented, 5), PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
0, 0,
); );
let sec_header = PusTcSecondaryHeader::new_simple(17, 1); let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, true); let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
let mut buf: [u8; 64] = [0; 64]; let mut buf: [u8; 64] = [0; 64];
generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc).unwrap(); generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc).unwrap();
let vec = generate_insert_telecommand_app_data_as_vec(&time_writer, &ping_tc) let vec = generate_insert_telecommand_app_data_as_vec(&time_writer, &ping_tc)

22
satrs/src/pus/test.rs
View File

@@ -2,8 +2,9 @@ use crate::pus::{
DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant, DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError, PusTmVariant,
}; };
use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool}; use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool};
use arbitrary_int::u14;
use spacepackets::SpHeader; use spacepackets::SpHeader;
use spacepackets::ecss::PusPacket; use spacepackets::ecss::{CreatorConfig, PusPacket};
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use std::sync::mpsc; use std::sync::mpsc;
@@ -76,9 +77,9 @@ impl<
// It is assumed that the verification reporter was built with a valid APID, so we use // It is assumed that the verification reporter was built with a valid APID, so we use
// the unchecked API here. // the unchecked API here.
let reply_header = let reply_header =
SpHeader::new_for_unseg_tm(self.service_helper.verif_reporter().apid(), 0, 0); SpHeader::new_for_unseg_tm(self.service_helper.verif_reporter().apid(), u14::new(0), 0);
let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp); let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp);
let ping_reply = PusTmCreator::new(reply_header, tc_header, &[], true); let ping_reply = PusTmCreator::new(reply_header, tc_header, &[], CreatorConfig::default());
if let Err(e) = self if let Err(e) = self
.service_helper .service_helper
.common .common
@@ -148,9 +149,10 @@ mod tests {
PartialPusHandlingError, PusPacketHandlingError, PartialPusHandlingError, PusPacketHandlingError,
}; };
use crate::tmtc::PacketSenderWithSharedPool; use crate::tmtc::PacketSenderWithSharedPool;
use arbitrary_int::u14;
use delegate::delegate; use delegate::delegate;
use spacepackets::SpHeader; use spacepackets::SpHeader;
use spacepackets::ecss::PusPacket; use spacepackets::ecss::{CreatorConfig, PusPacket};
use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader}; use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
use spacepackets::ecss::tm::PusTmReader; use spacepackets::ecss::tm::PusTmReader;
use spacepackets::time::{TimeWriter, cds}; use spacepackets::time::{TimeWriter, cds};
@@ -283,9 +285,9 @@ mod tests {
fn ping_test(test_harness: &mut (impl PusTestHarness + SimplePusPacketHandler)) { fn ping_test(test_harness: &mut (impl PusTestHarness + SimplePusPacketHandler)) {
// Create a ping TC, verify acceptance. // Create a ping TC, verify acceptance.
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = PusTcSecondaryHeader::new_simple(17, 1); let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc); let token = test_harness.start_verification(&ping_tc);
test_harness.send_tc(&token, &ping_tc); test_harness.send_tc(&token, &ping_tc);
let request_id = token.request_id(); let request_id = token.request_id();
@@ -338,9 +340,9 @@ mod tests {
#[test] #[test]
fn test_sending_unsupported_service() { fn test_sending_unsupported_service() {
let mut test_harness = Pus17HandlerWithStoreTester::new(0); let mut test_harness = Pus17HandlerWithStoreTester::new(0);
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = PusTcSecondaryHeader::new_simple(3, 1); let sec_header = PusTcSecondaryHeader::new_simple(3, 1);
let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc); let token = test_harness.start_verification(&ping_tc);
test_harness.send_tc(&token, &ping_tc); test_harness.send_tc(&token, &ping_tc);
let result = test_harness.handle_one_tc(); let result = test_harness.handle_one_tc();
@@ -359,9 +361,9 @@ mod tests {
#[test] #[test]
fn test_sending_custom_subservice() { fn test_sending_custom_subservice() {
let mut test_harness = Pus17HandlerWithStoreTester::new(0); let mut test_harness = Pus17HandlerWithStoreTester::new(0);
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0);
let sec_header = PusTcSecondaryHeader::new_simple(17, 200); let sec_header = PusTcSecondaryHeader::new_simple(17, 200);
let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc); let token = test_harness.start_verification(&ping_tc);
test_harness.send_tc(&token, &ping_tc); test_harness.send_tc(&token, &ping_tc);
let result = test_harness.handle_one_tc(); let result = test_harness.handle_one_tc();

208
satrs/src/pus/verification.rs
View File

@@ -81,7 +81,9 @@
//! for the verification module contains examples how this module could be used in a more complex //! for the verification module contains examples how this module could be used in a more complex
//! context involving multiple threads //! context involving multiple threads
use crate::params::{Params, WritableToBeBytes}; use crate::params::{Params, WritableToBeBytes};
use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough}; use crate::pus::{source_buffer_large_enough, EcssTmSender, EcssTmtcError};
use arbitrary_int::traits::Integer as _;
use arbitrary_int::{u11, u14, u3};
use core::fmt::{Debug, Display, Formatter}; use core::fmt::{Debug, Display, Formatter};
use core::hash::{Hash, Hasher}; use core::hash::{Hash, Hasher};
use core::marker::PhantomData; use core::marker::PhantomData;
@@ -90,20 +92,19 @@ use core::mem::size_of;
use delegate::delegate; use delegate::delegate;
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use spacepackets::ecss::EcssEnumeration;
use spacepackets::ecss::tc::IsPusTelecommand; use spacepackets::ecss::tc::IsPusTelecommand;
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceCtrl}; use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
use spacepackets::{MAX_APID, SpHeader}; use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl};
use spacepackets::{SpHeader, MAX_APID};
pub use spacepackets::ecss::verification::*; pub use spacepackets::ecss::verification::*;
pub use spacepackets::seq_count::SeqCountProviderSimple;
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub use alloc_mod::*; pub use alloc_mod::*;
use crate::ComponentId;
use crate::request::Apid; use crate::request::Apid;
use crate::ComponentId;
/// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard. /// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard.
/// ///
@@ -113,9 +114,9 @@ use crate::request::Apid;
#[derive(Debug, Eq, Copy, Clone)] #[derive(Debug, Eq, Copy, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct RequestId { pub struct RequestId {
version_number: u8, version_number: u3,
packet_id: PacketId, packet_id: PacketId,
psc: PacketSequenceCtrl, psc: PacketSequenceControl,
} }
impl Display for RequestId { impl Display for RequestId {
@@ -157,7 +158,7 @@ impl RequestId {
} }
pub fn raw(&self) -> u32 { pub fn raw(&self) -> u32 {
((self.version_number as u32) << 29) ((self.version_number.as_u32()) << 29)
| ((self.packet_id.raw() as u32) << 16) | ((self.packet_id.raw() as u32) << 16)
| self.psc.raw() as u32 | self.psc.raw() as u32
} }
@@ -166,7 +167,7 @@ impl RequestId {
self.packet_id self.packet_id
} }
pub fn packet_seq_ctrl(&self) -> PacketSequenceCtrl { pub fn packet_sequence_control(&self) -> PacketSequenceControl {
self.psc self.psc
} }
@@ -181,9 +182,9 @@ impl RequestId {
} }
let raw = u32::from_be_bytes(buf[0..Self::SIZE_AS_BYTES].try_into().unwrap()); let raw = u32::from_be_bytes(buf[0..Self::SIZE_AS_BYTES].try_into().unwrap());
Some(Self { Some(Self {
version_number: ((raw >> 29) & 0b111) as u8, version_number: u3::new(((raw >> 29) & 0b111) as u8),
packet_id: PacketId::from(((raw >> 16) & 0xffff) as u16), packet_id: PacketId::from(((raw >> 16) & 0xffff) as u16),
psc: PacketSequenceCtrl::from((raw & 0xffff) as u16), psc: PacketSequenceControl::from((raw & 0xffff) as u16),
}) })
} }
} }
@@ -191,9 +192,9 @@ impl RequestId {
impl From<u32> for RequestId { impl From<u32> for RequestId {
fn from(value: u32) -> Self { fn from(value: u32) -> Self {
Self { Self {
version_number: ((value >> 29) & 0b111) as u8, version_number: u3::new(((value >> 29) & 0b111) as u8),
packet_id: PacketId::from(((value >> 16) & 0xffff) as u16), packet_id: PacketId::from(((value >> 16) & 0xffff) as u16),
psc: PacketSequenceCtrl::from((value & 0xffff) as u16), psc: PacketSequenceControl::from((value & 0xffff) as u16),
} }
} }
} }
@@ -480,26 +481,19 @@ pub trait VerificationReportingProvider {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct VerificationReportCreator { pub struct VerificationReportCreator {
pub dest_id: u16, pub dest_id: u16,
apid: u16, apid: u11,
} }
impl VerificationReportCreator { impl VerificationReportCreator {
pub fn new(apid: u16) -> Option<Self> { pub fn new(apid: u11) -> Self {
if apid > MAX_APID { Self { apid, dest_id: 0 }
return None;
}
Some(Self { apid, dest_id: 0 })
} }
pub fn set_apid(&mut self, apid: u16) -> bool { pub fn set_apid(&mut self, apid: u11) {
if apid > MAX_APID {
return false;
}
self.apid = apid; self.apid = apid;
true
} }
pub fn apid(&self) -> u16 { pub fn apid(&self) -> u11 {
self.apid self.apid
} }
@@ -522,7 +516,7 @@ impl VerificationReportCreator {
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
subservice: u8, subservice: u8,
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
time_stamp: &'time [u8], time_stamp: &'time [u8],
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -545,7 +539,7 @@ impl VerificationReportCreator {
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
subservice: u8, subservice: u8,
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
step: Option<&(impl EcssEnumeration + ?Sized)>, step: Option<&(impl EcssEnumeration + ?Sized)>,
params: &FailParams<'time, '_>, params: &FailParams<'time, '_>,
@@ -567,7 +561,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
time_stamp: &'time [u8], time_stamp: &'time [u8],
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -587,7 +581,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
params: FailParams<'time, '_>, params: FailParams<'time, '_>,
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -609,7 +603,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
time_stamp: &'time [u8], time_stamp: &'time [u8],
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -632,7 +626,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
params: FailParams<'time, '_>, params: FailParams<'time, '_>,
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -654,7 +648,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
time_stamp: &'time [u8], time_stamp: &'time [u8],
step: impl EcssEnumeration, step: impl EcssEnumeration,
@@ -678,7 +672,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
token: VerificationToken<TcStateStarted>, token: VerificationToken<TcStateStarted>,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
params: FailParamsWithStep<'time, '_>, params: FailParamsWithStep<'time, '_>,
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -701,7 +695,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_counter: u16, seq_counter: u14,
msg_counter: u16, msg_counter: u16,
time_stamp: &'time [u8], time_stamp: &'time [u8],
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -723,7 +717,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
request_id: &RequestId, request_id: &RequestId,
seq_count: u16, seq_count: u14,
msg_count: u16, msg_count: u16,
params: FailParams<'time, '_>, params: FailParams<'time, '_>,
) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> { ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
@@ -744,7 +738,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
subservice: u8, subservice: u8,
seq_count: u16, seq_count: u14,
msg_counter: u16, msg_counter: u16,
req_id: &RequestId, req_id: &RequestId,
time_stamp: &'time [u8], time_stamp: &'time [u8],
@@ -780,7 +774,7 @@ impl VerificationReportCreator {
&self, &self,
src_data_buf: &'src_data mut [u8], src_data_buf: &'src_data mut [u8],
subservice: u8, subservice: u8,
seq_count: u16, seq_count: u14,
msg_counter: u16, msg_counter: u16,
req_id: &RequestId, req_id: &RequestId,
step: Option<&(impl EcssEnumeration + ?Sized)>, step: Option<&(impl EcssEnumeration + ?Sized)>,
@@ -832,13 +826,14 @@ impl VerificationReportCreator {
sp_header, sp_header,
tm_sec_header, tm_sec_header,
&src_data_buf[0..source_data_len], &src_data_buf[0..source_data_len],
true, CreatorConfig::default(),
) )
} }
} }
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
pub mod alloc_mod { pub mod alloc_mod {
use arbitrary_int::u11;
use spacepackets::ecss::PusError; use spacepackets::ecss::PusError;
use super::*; use super::*;
@@ -847,7 +842,7 @@ pub mod alloc_mod {
#[derive(Clone)] #[derive(Clone)]
pub struct VerificationReporterConfig { pub struct VerificationReporterConfig {
apid: u16, apid: u11,
pub step_field_width: usize, pub step_field_width: usize,
pub fail_code_field_width: usize, pub fail_code_field_width: usize,
pub max_fail_data_len: usize, pub max_fail_data_len: usize,
@@ -855,7 +850,7 @@ pub mod alloc_mod {
impl VerificationReporterConfig { impl VerificationReporterConfig {
pub fn new( pub fn new(
apid: u16, apid: u11,
step_field_width: usize, step_field_width: usize,
fail_code_field_width: usize, fail_code_field_width: usize,
max_fail_data_len: usize, max_fail_data_len: usize,
@@ -909,7 +904,7 @@ pub mod alloc_mod {
impl VerificationReporter<DummyVerificationHook> { impl VerificationReporter<DummyVerificationHook> {
pub fn new(owner_id: ComponentId, cfg: &VerificationReporterConfig) -> Self { pub fn new(owner_id: ComponentId, cfg: &VerificationReporterConfig) -> Self {
let reporter = VerificationReportCreator::new(cfg.apid).unwrap(); let reporter = VerificationReportCreator::new(cfg.apid);
Self { Self {
owner_id, owner_id,
source_data_buf: RefCell::new(alloc::vec![ source_data_buf: RefCell::new(alloc::vec![
@@ -933,7 +928,7 @@ pub mod alloc_mod {
cfg: &VerificationReporterConfig, cfg: &VerificationReporterConfig,
tm_hook: VerificationHookInstance, tm_hook: VerificationHookInstance,
) -> Self { ) -> Self {
let reporter = VerificationReportCreator::new(cfg.apid).unwrap(); let reporter = VerificationReportCreator::new(cfg.apid);
Self { Self {
owner_id, owner_id,
source_data_buf: RefCell::new(alloc::vec![ source_data_buf: RefCell::new(alloc::vec![
@@ -966,8 +961,8 @@ pub mod alloc_mod {
delegate!( delegate!(
to self.reporter_creator { to self.reporter_creator {
pub fn set_apid(&mut self, apid: u16) -> bool; pub fn set_apid(&mut self, apid: u11);
pub fn apid(&self) -> u16; pub fn apid(&self) -> u11;
pub fn dest_id(&self) -> u16; pub fn dest_id(&self) -> u16;
pub fn set_dest_id(&mut self, dest_id: u16); pub fn set_dest_id(&mut self, dest_id: u16);
} }
@@ -1012,7 +1007,7 @@ pub mod alloc_mod {
.acceptance_success( .acceptance_success(
source_data_buf.as_mut_slice(), source_data_buf.as_mut_slice(),
&token.request_id(), &token.request_id(),
0, u14::new(0),
0, 0,
time_stamp, time_stamp,
) )
@@ -1032,7 +1027,13 @@ pub mod alloc_mod {
let mut buf = self.source_data_buf.borrow_mut(); let mut buf = self.source_data_buf.borrow_mut();
let mut tm_creator = self let mut tm_creator = self
.reporter_creator .reporter_creator
.acceptance_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params) .acceptance_failure(
buf.as_mut_slice(),
&token.request_id(),
u14::new(0),
0,
params,
)
.map_err(PusError::ByteConversion)?; .map_err(PusError::ByteConversion)?;
self.tm_hook.modify_tm(&mut tm_creator); self.tm_hook.modify_tm(&mut tm_creator);
sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?; sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1051,7 +1052,13 @@ pub mod alloc_mod {
let mut buf = self.source_data_buf.borrow_mut(); let mut buf = self.source_data_buf.borrow_mut();
let mut tm_creator = self let mut tm_creator = self
.reporter_creator .reporter_creator
.start_success(buf.as_mut_slice(), &token.request_id(), 0, 0, time_stamp) .start_success(
buf.as_mut_slice(),
&token.request_id(),
u14::new(0),
0,
time_stamp,
)
.map_err(PusError::ByteConversion)?; .map_err(PusError::ByteConversion)?;
self.tm_hook.modify_tm(&mut tm_creator); self.tm_hook.modify_tm(&mut tm_creator);
sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?; sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1071,7 +1078,13 @@ pub mod alloc_mod {
let mut buf = self.source_data_buf.borrow_mut(); let mut buf = self.source_data_buf.borrow_mut();
let mut tm_creator = self let mut tm_creator = self
.reporter_creator .reporter_creator
.start_failure(buf.as_mut_slice(), &token.request_id(), 0, 0, params) .start_failure(
buf.as_mut_slice(),
&token.request_id(),
u14::new(0),
0,
params,
)
.map_err(PusError::ByteConversion)?; .map_err(PusError::ByteConversion)?;
self.tm_hook.modify_tm(&mut tm_creator); self.tm_hook.modify_tm(&mut tm_creator);
sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?; sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1094,7 +1107,7 @@ pub mod alloc_mod {
.step_success( .step_success(
buf.as_mut_slice(), buf.as_mut_slice(),
&token.request_id(), &token.request_id(),
0, u14::new(0),
0, 0,
time_stamp, time_stamp,
step, step,
@@ -1118,7 +1131,7 @@ pub mod alloc_mod {
let mut buf = self.source_data_buf.borrow_mut(); let mut buf = self.source_data_buf.borrow_mut();
let mut tm_creator = self let mut tm_creator = self
.reporter_creator .reporter_creator
.step_failure(buf.as_mut_slice(), token, 0, 0, params) .step_failure(buf.as_mut_slice(), token, u14::new(0), 0, params)
.map_err(PusError::ByteConversion)?; .map_err(PusError::ByteConversion)?;
self.tm_hook.modify_tm(&mut tm_creator); self.tm_hook.modify_tm(&mut tm_creator);
sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?; sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1139,7 +1152,13 @@ pub mod alloc_mod {
let mut buf = self.source_data_buf.borrow_mut(); let mut buf = self.source_data_buf.borrow_mut();
let mut tm_creator = self let mut tm_creator = self
.reporter_creator .reporter_creator
.completion_success(buf.as_mut_slice(), &token.request_id(), 0, 0, time_stamp) .completion_success(
buf.as_mut_slice(),
&token.request_id(),
u14::new(0),
0,
time_stamp,
)
.map_err(PusError::ByteConversion)?; .map_err(PusError::ByteConversion)?;
self.tm_hook.modify_tm(&mut tm_creator); self.tm_hook.modify_tm(&mut tm_creator);
sender.send_tm(self.owner_id, PusTmVariant::Direct(tm_creator))?; sender.send_tm(self.owner_id, PusTmVariant::Direct(tm_creator))?;
@@ -1159,7 +1178,13 @@ pub mod alloc_mod {
let mut buf = self.source_data_buf.borrow_mut(); let mut buf = self.source_data_buf.borrow_mut();
let mut tm_creator = self let mut tm_creator = self
.reporter_creator .reporter_creator
.completion_failure(buf.as_mut_slice(), &token.request_id(), 0, 00, params) .completion_failure(
buf.as_mut_slice(),
&token.request_id(),
u14::new(0),
0,
params,
)
.map_err(PusError::ByteConversion)?; .map_err(PusError::ByteConversion)?;
self.tm_hook.modify_tm(&mut tm_creator); self.tm_hook.modify_tm(&mut tm_creator);
sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?; sender.send_tm(self.owner_id(), PusTmVariant::Direct(tm_creator))?;
@@ -1309,6 +1334,7 @@ pub fn handle_step_failure_with_generic_params(
#[cfg(any(feature = "test_util", test))] #[cfg(any(feature = "test_util", test))]
pub mod test_util { pub mod test_util {
use alloc::vec::Vec; use alloc::vec::Vec;
use arbitrary_int::u11;
use core::cell::RefCell; use core::cell::RefCell;
use std::collections::VecDeque; use std::collections::VecDeque;
@@ -1370,7 +1396,7 @@ pub mod test_util {
fn set_apid(&mut self, _apid: Apid) {} fn set_apid(&mut self, _apid: Apid) {}
fn apid(&self) -> Apid { fn apid(&self) -> Apid {
0 u11::new(0)
} }
fn acceptance_success( fn acceptance_success(
@@ -1686,39 +1712,41 @@ pub mod test_util {
#[cfg(test)] #[cfg(test)]
pub mod tests { pub mod tests {
use crate::ComponentId;
use crate::params::Params; use crate::params::Params;
use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig}; use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig};
use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0}; use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
use crate::pus::tests::CommonTmInfo; use crate::pus::tests::CommonTmInfo;
use crate::pus::verification::{ use crate::pus::verification::{
EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone, handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams,
VerificationReporter, VerificationReporterConfig, VerificationToken, FailParamsWithStep, RequestId, TcStateNone, VerificationReporter,
handle_step_failure_with_generic_params, VerificationReporterConfig, VerificationToken,
}; };
use crate::pus::{ChannelWithId, PusTmVariant}; use crate::pus::{ChannelWithId, PusTmVariant};
use crate::request::MessageMetadata; use crate::request::MessageMetadata;
use crate::spacepackets::seq_count::{CcsdsSimpleSeqCountProvider, SequenceCountProvider}; use crate::spacepackets::seq_count::{SequenceCounter, SequenceCounterCcsdsSimple};
use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool}; use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
use crate::ComponentId;
use alloc::format; use alloc::format;
use alloc::string::ToString; use alloc::string::ToString;
use arbitrary_int::{u11, u14};
use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
use spacepackets::ecss::{ use spacepackets::ecss::{
EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket, CreatorConfig, EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket,
WritablePusPacket, WritablePusPacket,
}; };
use spacepackets::seq_count::SequenceCounterSimple;
use spacepackets::util::UnsignedEnum; use spacepackets::util::UnsignedEnum;
use spacepackets::{ByteConversionError, SpHeader}; use spacepackets::{ByteConversionError, SpHeader};
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::VecDeque; use std::collections::VecDeque;
use std::sync::{RwLock, mpsc}; use std::sync::{mpsc, RwLock};
use std::vec; use std::vec;
use std::vec::Vec; use std::vec::Vec;
use super::{ use super::{
DummyVerificationHook, FailParamHelper, SeqCountProviderSimple, TcStateAccepted, handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper,
TcStateStarted, VerificationHook, VerificationReportingProvider, WasAtLeastAccepted, TcStateAccepted, TcStateStarted, VerificationHook, VerificationReportingProvider,
handle_completion_failure_with_generic_params, WasAtLeastAccepted,
}; };
fn is_send<T: Send>(_: &T) {} fn is_send<T: Send>(_: &T) {}
@@ -1783,13 +1811,13 @@ pub mod tests {
#[derive(Default)] #[derive(Default)]
pub struct SequenceCounterHook { pub struct SequenceCounterHook {
pub seq_counter: CcsdsSimpleSeqCountProvider, pub seq_counter: SequenceCounterCcsdsSimple,
pub msg_counter: SeqCountProviderSimple<u16>, pub msg_counter: SequenceCounterSimple<u16>,
} }
impl VerificationHook for SequenceCounterHook { impl VerificationHook for SequenceCounterHook {
fn modify_tm(&self, tm: &mut spacepackets::ecss::tm::PusTmCreator) { fn modify_tm(&self, tm: &mut spacepackets::ecss::tm::PusTmCreator) {
tm.set_seq_count(self.seq_counter.get_and_increment()); tm.set_seq_count(u14::new(self.seq_counter.get_and_increment()));
tm.set_msg_counter(self.msg_counter.get_and_increment()); tm.set_msg_counter(self.msg_counter.get_and_increment());
} }
} }
@@ -1912,7 +1940,14 @@ pub mod tests {
fn check_acceptance_success(&self, timestamp: &[u8; 7]) { fn check_acceptance_success(&self, timestamp: &[u8; 7]) {
let cmp_info = TmInfo { let cmp_info = TmInfo {
requestor: MessageMetadata::new(self.request_id.into(), self.id), requestor: MessageMetadata::new(self.request_id.into(), self.id),
common: CommonTmInfo::new(1, TEST_APID, 0, 0, self.reporter.dest_id(), timestamp), common: CommonTmInfo::new(
1,
TEST_APID,
u14::new(0),
0,
self.reporter.dest_id(),
timestamp,
),
additional_data: None, additional_data: None,
}; };
let mut service_queue = self.sender.service_queue.borrow_mut(); let mut service_queue = self.sender.service_queue.borrow_mut();
@@ -1921,7 +1956,7 @@ pub mod tests {
assert_eq!(info, cmp_info); assert_eq!(info, cmp_info);
} }
fn check_start_success(&mut self, seq_count: u16, msg_counter: u16, timestamp: &[u8]) { fn check_start_success(&mut self, seq_count: u14, msg_counter: u16, timestamp: &[u8]) {
let mut srv_queue = self.sender.service_queue.borrow_mut(); let mut srv_queue = self.sender.service_queue.borrow_mut();
let cmp_info = TmInfo { let cmp_info = TmInfo {
requestor: MessageMetadata::new(self.request_id.into(), self.id), requestor: MessageMetadata::new(self.request_id.into(), self.id),
@@ -1939,7 +1974,7 @@ pub mod tests {
assert_eq!(info, cmp_info); assert_eq!(info, cmp_info);
} }
fn check_completion_success(&mut self, seq_count: u16, msg_counter: u16) { fn check_completion_success(&mut self, seq_count: u14, msg_counter: u16) {
let cmp_info = TmInfo { let cmp_info = TmInfo {
requestor: MessageMetadata::new(self.request_id.into(), self.id), requestor: MessageMetadata::new(self.request_id.into(), self.id),
common: CommonTmInfo::new( common: CommonTmInfo::new(
@@ -1972,7 +2007,14 @@ pub mod tests {
fn check_acceptance_failure(&mut self, timestamp: &[u8; 7]) { fn check_acceptance_failure(&mut self, timestamp: &[u8; 7]) {
let cmp_info = TmInfo { let cmp_info = TmInfo {
requestor: MessageMetadata::new(self.request_id.into(), self.id), requestor: MessageMetadata::new(self.request_id.into(), self.id),
common: CommonTmInfo::new(2, TEST_APID, 0, 0, self.reporter.dest_id(), timestamp), common: CommonTmInfo::new(
2,
TEST_APID,
u14::new(0),
0,
self.reporter.dest_id(),
timestamp,
),
additional_data: Some([0, 2].to_vec()), additional_data: Some([0, 2].to_vec()),
}; };
let service_queue = self.sender.service_queue.get_mut(); let service_queue = self.sender.service_queue.get_mut();
@@ -2060,9 +2102,9 @@ pub mod tests {
} }
fn create_generic_ping() -> PusTcCreator<'static> { fn create_generic_ping() -> PusTcCreator<'static> {
let sph = SpHeader::new_for_unseg_tc(TEST_APID, 0x34, 0); let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0x34), 0);
let tc_header = PusTcSecondaryHeader::new_simple(17, 1); let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
PusTcCreator::new(sph, tc_header, &[], true) PusTcCreator::new(sph, tc_header, &[], CreatorConfig::default())
} }
#[test] #[test]
@@ -2082,8 +2124,8 @@ pub mod tests {
fn test_state() { fn test_state() {
let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16); let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
assert_eq!(testbench.reporter.apid(), TEST_APID); assert_eq!(testbench.reporter.apid(), TEST_APID);
testbench.reporter.set_apid(TEST_APID + 1); testbench.reporter.set_apid(u11::new(TEST_APID.value() + 1));
assert_eq!(testbench.reporter.apid(), TEST_APID + 1); assert_eq!(testbench.reporter.apid().value(), TEST_APID.value() + 1);
} }
#[test] #[test]
@@ -2233,7 +2275,7 @@ pub mod tests {
.expect("step 1 failed"); .expect("step 1 failed");
assert_eq!(testbench.sender.service_queue.borrow().len(), 4); assert_eq!(testbench.sender.service_queue.borrow().len(), 4);
testbench.check_acceptance_success(&EMPTY_STAMP); testbench.check_acceptance_success(&EMPTY_STAMP);
testbench.check_start_success(0, 0, &EMPTY_STAMP); testbench.check_start_success(u14::new(0), 0, &EMPTY_STAMP);
testbench.check_step_success(0, &EMPTY_STAMP); testbench.check_step_success(0, &EMPTY_STAMP);
testbench.check_step_success(1, &EMPTY_STAMP); testbench.check_step_success(1, &EMPTY_STAMP);
} }
@@ -2267,7 +2309,7 @@ pub mod tests {
.step_failure(started_token, fail_params) .step_failure(started_token, fail_params)
.expect("Step failure failed"); .expect("Step failure failed");
testbench.check_acceptance_success(&EMPTY_STAMP); testbench.check_acceptance_success(&EMPTY_STAMP);
testbench.check_start_success(0, 0, DUMMY_STAMP); testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);
testbench.check_step_success(0, &EMPTY_STAMP); testbench.check_step_success(0, &EMPTY_STAMP);
testbench.check_step_failure(&fail_step, &fail_code, &fail_data_raw); testbench.check_step_failure(&fail_step, &fail_code, &fail_data_raw);
} }
@@ -2289,7 +2331,7 @@ pub mod tests {
.completion_failure(started_token, fail_params) .completion_failure(started_token, fail_params)
.expect("Completion failure"); .expect("Completion failure");
testbench.check_acceptance_success(&EMPTY_STAMP); testbench.check_acceptance_success(&EMPTY_STAMP);
testbench.check_start_success(0, 0, DUMMY_STAMP); testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);
testbench.check_completion_failure(&fail_code, &[]); testbench.check_completion_failure(&fail_code, &[]);
} }
@@ -2309,8 +2351,8 @@ pub mod tests {
.completion_success(started_token, &EMPTY_STAMP) .completion_success(started_token, &EMPTY_STAMP)
.expect("Sending completion success failed"); .expect("Sending completion success failed");
testbench.check_acceptance_success(&EMPTY_STAMP); testbench.check_acceptance_success(&EMPTY_STAMP);
testbench.check_start_success(0, 0, DUMMY_STAMP); testbench.check_start_success(u14::new(0), 0, DUMMY_STAMP);
testbench.check_completion_success(0, 0); testbench.check_completion_success(u14::new(0), 0);
} }
#[test] #[test]
@@ -2331,8 +2373,8 @@ pub mod tests {
.completion_success(started_token, &EMPTY_STAMP) .completion_success(started_token, &EMPTY_STAMP)
.expect("Sending completion success failed"); .expect("Sending completion success failed");
testbench.check_acceptance_success(&EMPTY_STAMP); testbench.check_acceptance_success(&EMPTY_STAMP);
testbench.check_start_success(1, 1, DUMMY_STAMP); testbench.check_start_success(u14::new(1), 1, DUMMY_STAMP);
testbench.check_completion_success(2, 2); testbench.check_completion_success(u14::new(2), 2);
} }
#[test] #[test]
@@ -2391,7 +2433,7 @@ pub mod tests {
); );
assert!(result.unwrap()); assert!(result.unwrap());
testbench.check_acceptance_success(&EMPTY_STAMP); testbench.check_acceptance_success(&EMPTY_STAMP);
testbench.check_start_success(0, 0, &EMPTY_STAMP); testbench.check_start_success(u14::new(0), 0, &EMPTY_STAMP);
testbench.check_step_failure(&step, &fail_code, fail_data.as_bytes()); testbench.check_step_failure(&step, &fail_code, fail_data.as_bytes());
} }

29
satrs/src/request.rs
View File

@@ -1,4 +1,5 @@
use core::{fmt, marker::PhantomData}; use core::{fmt, marker::PhantomData};
use arbitrary_int::{traits::Integer as _, u11};
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@@ -22,8 +23,8 @@ use crate::{
/// for them. This can be useful for tasks like tracking their progress. /// for them. This can be useful for tasks like tracking their progress.
pub type RequestId = u32; pub type RequestId = u32;
/// CCSDS APID type definition. Please note that the APID is a 14 bit value. /// CCSDS APID type definition. Please note that the APID is a 11 bit value.
pub type Apid = u16; pub type Apid = u11;
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub struct UniqueApidTargetId { pub struct UniqueApidTargetId {
@@ -40,7 +41,7 @@ impl UniqueApidTargetId {
} }
pub fn raw(&self) -> ComponentId { pub fn raw(&self) -> ComponentId {
((self.apid as u64) << 32) | (self.unique_id as u64) ((self.apid.as_u64()) << 32) | (self.unique_id as u64)
} }
pub fn id(&self) -> ComponentId { pub fn id(&self) -> ComponentId {
@@ -68,7 +69,7 @@ impl UniqueApidTargetId {
impl From<u64> for UniqueApidTargetId { impl From<u64> for UniqueApidTargetId {
fn from(raw: u64) -> Self { fn from(raw: u64) -> Self {
Self { Self {
apid: (raw >> 32) as u16, apid: u11::new((raw >> 32) as u16),
unique_id: raw as u32, unique_id: raw as u32,
} }
} }
@@ -496,11 +497,10 @@ mod tests {
use std::sync::mpsc; use std::sync::mpsc;
use alloc::string::ToString; use alloc::string::ToString;
use arbitrary_int::{u11, u14};
use spacepackets::{ use spacepackets::{
ByteConversionError, SpHeader, ecss::{tc::{PusTcCreator, PusTcSecondaryHeader}, CreatorConfig}, ByteConversionError, SpHeader
ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
}; };
use crate::{ use crate::{
queue::{GenericReceiveError, GenericSendError}, queue::{GenericReceiveError, GenericSendError},
request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider}, request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider},
@@ -514,8 +514,8 @@ mod tests {
#[test] #[test]
fn test_basic_target_id_with_apid() { fn test_basic_target_id_with_apid() {
let id = UniqueApidTargetId::new(0x111, 0x01); let id = UniqueApidTargetId::new(u11::new(0x111), 0x01);
assert_eq!(id.apid, 0x111); assert_eq!(id.apid.value(), 0x111);
assert_eq!(id.unique_id, 0x01); assert_eq!(id.unique_id, 0x01);
assert_eq!(id.id(), id.raw()); assert_eq!(id.id(), id.raw());
assert_eq!(u64::from(id), id.raw()); assert_eq!(u64::from(id), id.raw());
@@ -532,19 +532,18 @@ mod tests {
#[test] #[test]
fn test_basic_target_id_with_apid_from_pus_tc() { fn test_basic_target_id_with_apid_from_pus_tc() {
let sp_header = SpHeader::new_for_unseg_tc(0x111, 5, 0); let sp_header = SpHeader::new_for_unseg_tc(u11::new(0x111), u14::new(5), 0);
let app_data = 1_u32.to_be_bytes(); let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &[], CreatorConfig::default());
let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &app_data, true);
let id = UniqueApidTargetId::from_pus_tc(&pus_tc).unwrap(); let id = UniqueApidTargetId::from_pus_tc(&pus_tc).unwrap();
assert_eq!(id.apid, 0x111); assert_eq!(id.apid.value(), 0x111);
assert_eq!(id.unique_id, 1); assert_eq!(id.unique_id, 1);
} }
#[test] #[test]
fn test_basic_target_id_with_apid_from_pus_tc_invalid_app_data() { fn test_basic_target_id_with_apid_from_pus_tc_invalid_app_data() {
let sp_header = SpHeader::new_for_unseg_tc(0x111, 5, 0); let sp_header = SpHeader::new_for_unseg_tc(u11::new(0x111), u14::new(5), 0);
let sec_header = PusTcSecondaryHeader::new_simple(17, 1); let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let pus_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, true); let pus_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let error = UniqueApidTargetId::from_pus_tc(&pus_tc); let error = UniqueApidTargetId::from_pus_tc(&pus_tc);
assert!(error.is_err()); assert!(error.is_err());
let error = error.unwrap_err(); let error = error.unwrap_err();

29
satrs/src/tmtc/tm_helper.rs
View File

@@ -1,15 +1,16 @@
use arbitrary_int::{u11, u14};
use spacepackets::ecss::CreatorConfig;
use spacepackets::SpHeader; use spacepackets::SpHeader;
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use spacepackets::time::TimeWriter;
use spacepackets::time::cds::CdsTime; use spacepackets::time::cds::CdsTime;
pub struct PusTmWithCdsShortHelper { pub struct PusTmWithCdsShortHelper {
apid: u16, apid: u11,
cds_short_buf: [u8; 7], cds_short_buf: [u8; 7],
} }
impl PusTmWithCdsShortHelper { impl PusTmWithCdsShortHelper {
pub fn new(apid: u16) -> Self { pub fn new(apid: u11) -> Self {
Self { Self {
apid, apid,
cds_short_buf: [0; 7], cds_short_buf: [0; 7],
@@ -22,7 +23,7 @@ impl PusTmWithCdsShortHelper {
service: u8, service: u8,
subservice: u8, subservice: u8,
source_data: &'data [u8], source_data: &'data [u8],
seq_count: u16, seq_count: u14,
) -> PusTmCreator<'_, 'data> { ) -> PusTmCreator<'_, 'data> {
let time_stamp = CdsTime::now_with_u16_days().unwrap(); let time_stamp = CdsTime::now_with_u16_days().unwrap();
time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap(); time_stamp.write_to_bytes(&mut self.cds_short_buf).unwrap();
@@ -35,7 +36,7 @@ impl PusTmWithCdsShortHelper {
subservice: u8, subservice: u8,
source_data: &'data [u8], source_data: &'data [u8],
stamper: &CdsTime, stamper: &CdsTime,
seq_count: u16, seq_count: u14,
) -> PusTmCreator<'_, 'data> { ) -> PusTmCreator<'_, 'data> {
stamper.write_to_bytes(&mut self.cds_short_buf).unwrap(); stamper.write_to_bytes(&mut self.cds_short_buf).unwrap();
self.create_pus_tm_common(service, subservice, source_data, seq_count) self.create_pus_tm_common(service, subservice, source_data, seq_count)
@@ -46,11 +47,11 @@ impl PusTmWithCdsShortHelper {
service: u8, service: u8,
subservice: u8, subservice: u8,
source_data: &'data [u8], source_data: &'data [u8],
seq_count: u16, seq_count: u14,
) -> PusTmCreator<'_, 'data> { ) -> PusTmCreator<'_, 'data> {
let reply_header = SpHeader::new_for_unseg_tm(self.apid, seq_count, 0); let reply_header = SpHeader::new_for_unseg_tm(self.apid, seq_count, 0);
let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf); let tc_header = PusTmSecondaryHeader::new_simple(service, subservice, &self.cds_short_buf);
PusTmCreator::new(reply_header, tc_header, source_data, true) PusTmCreator::new(reply_header, tc_header, source_data, CreatorConfig::default())
} }
} }
@@ -58,28 +59,28 @@ impl PusTmWithCdsShortHelper {
mod tests { mod tests {
use spacepackets::{CcsdsPacket, ecss::PusPacket, time::cds::CdsTime}; use spacepackets::{CcsdsPacket, ecss::PusPacket, time::cds::CdsTime};
use super::PusTmWithCdsShortHelper; use super::*;
#[test] #[test]
fn test_helper_with_stamper() { fn test_helper_with_stamper() {
let mut pus_tm_helper = PusTmWithCdsShortHelper::new(0x123); let mut pus_tm_helper = PusTmWithCdsShortHelper::new(u11::new(0x123));
let stamper = CdsTime::new_with_u16_days(0, 0); let stamper = CdsTime::new_with_u16_days(0, 0);
let tm = pus_tm_helper.create_pus_tm_with_stamper(17, 1, &[1, 2, 3, 4], &stamper, 25); let tm = pus_tm_helper.create_pus_tm_with_stamper(17, 1, &[1, 2, 3, 4], &stamper, u14::new(25));
assert_eq!(tm.service(), 17); assert_eq!(tm.service(), 17);
assert_eq!(tm.subservice(), 1); assert_eq!(tm.subservice(), 1);
assert_eq!(tm.user_data(), &[1, 2, 3, 4]); assert_eq!(tm.user_data(), &[1, 2, 3, 4]);
assert_eq!(tm.seq_count(), 25); assert_eq!(tm.seq_count().value(), 25);
assert_eq!(tm.timestamp(), [64, 0, 0, 0, 0, 0, 0]) assert_eq!(tm.timestamp(), [64, 0, 0, 0, 0, 0, 0])
} }
#[test] #[test]
fn test_helper_from_now() { fn test_helper_from_now() {
let mut pus_tm_helper = PusTmWithCdsShortHelper::new(0x123); let mut pus_tm_helper = PusTmWithCdsShortHelper::new(u11::new(0x123));
let tm = pus_tm_helper.create_pus_tm_timestamp_now(17, 1, &[1, 2, 3, 4], 25); let tm = pus_tm_helper.create_pus_tm_timestamp_now(17, 1, &[1, 2, 3, 4], u14::new(25));
assert_eq!(tm.service(), 17); assert_eq!(tm.service(), 17);
assert_eq!(tm.subservice(), 1); assert_eq!(tm.subservice(), 1);
assert_eq!(tm.user_data(), &[1, 2, 3, 4]); assert_eq!(tm.user_data(), &[1, 2, 3, 4]);
assert_eq!(tm.seq_count(), 25); assert_eq!(tm.seq_count().value(), 25);
assert_eq!(tm.timestamp().len(), 7); assert_eq!(tm.timestamp().len(), 7);
} }
} }