From 45a99cabcecc98030b1048576ae6cad9ebcc9922 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Thu, 11 Sep 2025 09:29:34 +0200 Subject: [PATCH] bump spacepackets --- satrs-example/src/acs/mgm.rs | 2 +- satrs-example/src/eps/pcdu.rs | 2 +- satrs-example/src/hk.rs | 2 +- satrs-example/src/interface/udp.rs | 7 ++- satrs-example/src/pus/action.rs | 11 +++-- satrs-example/src/pus/mode.rs | 10 +++- satrs-example/src/tmtc/tm_sink.rs | 5 +- satrs/src/encoding/ccsds.rs | 30 ++++++++--- satrs/src/hal/std/tcp_spacepackets_server.rs | 52 +++++++++++++++----- satrs/src/hal/std/udp_server.rs | 6 ++- satrs/src/pus/event.rs | 12 ++--- satrs/src/pus/event_man.rs | 3 +- satrs/src/pus/event_srv.rs | 17 ++++--- satrs/src/pus/scheduler.rs | 25 ++++++---- satrs/src/pus/scheduler_srv.rs | 17 ++++--- satrs/src/pus/test.rs | 23 ++++++--- satrs/src/pus/verification.rs | 26 +++++----- satrs/src/request.rs | 20 +++++--- satrs/src/tmtc/tm_helper.rs | 12 +++-- satrs/tests/hk_helpers.rs | 2 +- satrs/tests/pus_events.rs | 9 ++-- satrs/tests/pus_verification.rs | 12 +++-- satrs/tests/tcp_servers.rs | 13 ++--- 23 files changed, 207 insertions(+), 111 deletions(-) diff --git a/satrs-example/src/acs/mgm.rs b/satrs-example/src/acs/mgm.rs index e8963e1..b8c19fc 100644 --- a/satrs-example/src/acs/mgm.rs +++ b/satrs-example/src/acs/mgm.rs @@ -574,7 +574,7 @@ mod tests { let (request_tx, request_rx) = mpsc::sync_channel(5); let (reply_tx_to_pus, reply_rx_to_pus) = mpsc::sync_channel(5); let (reply_tx_to_parent, reply_rx_to_parent) = mpsc::sync_channel(5); - let id = UniqueApidTargetId::new(Apid::Acs as u16, 1); + let id = UniqueApidTargetId::new(Apid::Acs.raw_value(), 1); let mode_node = ModeRequestHandlerMpscBounded::new(id.into(), request_rx); let (composite_request_tx, composite_request_rx) = mpsc::channel(); let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10); diff --git a/satrs-example/src/eps/pcdu.rs b/satrs-example/src/eps/pcdu.rs index 8995248..c6b83d7 100644 --- a/satrs-example/src/eps/pcdu.rs +++ b/satrs-example/src/eps/pcdu.rs @@ -572,7 +572,7 @@ mod tests { let (switch_request_tx, switch_reqest_rx) = mpsc::channel(); let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default())); let mut handler = PcduHandler::new( - UniqueApidTargetId::new(Apid::Eps as u16, 0), + UniqueApidTargetId::new(Apid::Eps.raw_value(), 0), "TEST_PCDU", mode_node, composite_request_rx, diff --git a/satrs-example/src/hk.rs b/satrs-example/src/hk.rs index f00438f..44adbfb 100644 --- a/satrs-example/src/hk.rs +++ b/satrs-example/src/hk.rs @@ -1,8 +1,8 @@ use derive_new::new; use satrs::hk::UniqueId; use satrs::request::UniqueApidTargetId; -use satrs::spacepackets::ecss::{hk, CreatorConfig}; use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; +use satrs::spacepackets::ecss::{hk, CreatorConfig}; use satrs::spacepackets::{ByteConversionError, SpHeader}; #[derive(Debug, new, Copy, Clone)] diff --git a/satrs-example/src/interface/udp.rs b/satrs-example/src/interface/udp.rs index bfbee6f..ca13e81 100644 --- a/satrs-example/src/interface/udp.rs +++ b/satrs-example/src/interface/udp.rs @@ -113,6 +113,9 @@ mod tests { sync::{Arc, Mutex}, }; + use arbitrary_int::traits::Integer as _; + use arbitrary_int::u14; + use satrs::spacepackets::ecss::CreatorConfig; use satrs::{ spacepackets::{ ecss::{tc::PusTcCreator, WritablePusPacket}, @@ -177,8 +180,8 @@ mod tests { udp_tc_server, tm_handler, }; - let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus as u16, 0, 0); - let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true) + let sph = SpHeader::new_for_unseg_tc(ids::Apid::GenericPus.raw_value(), u14::ZERO, 0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default()) .to_vec() .unwrap(); let client = UdpSocket::bind("127.0.0.1:0").expect("Connecting to UDP server failed"); diff --git a/satrs-example/src/pus/action.rs b/satrs-example/src/pus/action.rs index b5fcc81..ab6027e 100644 --- a/satrs-example/src/pus/action.rs +++ b/satrs-example/src/pus/action.rs @@ -276,6 +276,7 @@ mod tests { use satrs::pus::verification::test_util::TestVerificationReporter; use satrs::pus::{verification, EcssTcVecCacher}; use satrs::request::MessageMetadata; + use satrs::spacepackets::ecss::CreatorConfig; use satrs::tmtc::PacketAsVec; use satrs::ComponentId; use satrs::{ @@ -453,7 +454,9 @@ mod tests { let mut app_data: [u8; 8] = [0; 8]; app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.to_be_bytes()); app_data[4..8].copy_from_slice(&action_id.to_be_bytes()); - let pus8_packet = PusTcCreator::new(sp_header, sec_header, &app_data, true); + let pus8_packet = + PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default()); + testbench.add_tc(&pus8_packet); let time_stamp: [u8; 7] = [0; 7]; testbench.verify_next_tc_is_handled_properly(&time_stamp); @@ -499,7 +502,7 @@ mod tests { SpHeader::new_from_apid(TEST_APID), sec_header, &app_data, - true, + CreatorConfig::default(), ); testbench.add_tc(&pus8_packet); let time_stamp: [u8; 7] = [0; 7]; @@ -525,7 +528,7 @@ mod tests { SpHeader::new_from_apid(TEST_APID), sec_header, &app_data, - true, + CreatorConfig::default(), ); let token = testbench.add_tc(&pus8_packet); let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0); @@ -564,7 +567,7 @@ mod tests { SpHeader::new_from_apid(TEST_APID), sec_header, &app_data, - true, + CreatorConfig::default(), ); let token = testbench.add_tc(&pus8_packet); let result = testbench.convert(token, &[], TEST_APID, TEST_UNIQUE_ID_0); diff --git a/satrs-example/src/pus/mode.rs b/satrs-example/src/pus/mode.rs index 66bc8a9..d944564 100644 --- a/satrs-example/src/pus/mode.rs +++ b/satrs-example/src/pus/mode.rs @@ -79,10 +79,16 @@ impl PusReplyHandler for ModeReplyHandler { .write_to_be_bytes(&mut source_data) .expect("writing mode reply failed"); let req_id = verification::RequestId::from(reply.request_id()); - let sp_header = SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), u14::new(0), 0); + let sp_header = + SpHeader::new_for_unseg_tm(req_id.packet_id().apid(), u14::new(0), 0); let sec_header = PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp); - let pus_tm = PusTmCreator::new(sp_header, sec_header, &source_data, CreatorConfig::default()); + let pus_tm = PusTmCreator::new( + sp_header, + sec_header, + &source_data, + CreatorConfig::default(), + ); tm_sender.send_tm(self.owner_id, PusTmVariant::Direct(pus_tm))?; verification_handler.completion_success(tm_sender, started_token, time_stamp)?; } diff --git a/satrs-example/src/tmtc/tm_sink.rs b/satrs-example/src/tmtc/tm_sink.rs index d92dcf6..09a0793 100644 --- a/satrs-example/src/tmtc/tm_sink.rs +++ b/satrs-example/src/tmtc/tm_sink.rs @@ -157,8 +157,9 @@ impl TmSinkDynamic { if let Ok(mut tm) = self.tm_funnel_rx.recv() { // Read the TM, set sequence counter and message counter, and finally update // the CRC. - let zero_copy_writer = PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN, true) - .expect("Creating TM zero copy writer failed"); + let zero_copy_writer = + PusTmZeroCopyWriter::new(&mut tm.packet, MIN_CDS_FIELD_LEN, true) + .expect("Creating TM zero copy writer failed"); self.common.apply_packet_processing(zero_copy_writer); self.common.sync_tm_tcp_source.add_tm(&tm.packet); self.tm_server_tx diff --git a/satrs/src/encoding/ccsds.rs b/satrs/src/encoding/ccsds.rs index c1ed634..1037003 100644 --- a/satrs/src/encoding/ccsds.rs +++ b/satrs/src/encoding/ccsds.rs @@ -91,7 +91,8 @@ pub fn parse_buffer_for_ccsds_space_packets( mod tests { use arbitrary_int::{u11, u14}; use spacepackets::{ - ecss::{tc::PusTcCreator, CreatorConfig}, CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader + CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader, + ecss::{CreatorConfig, tc::PusTcCreator}, }; use crate::{ComponentId, encoding::tests::TcCacher}; @@ -221,10 +222,20 @@ mod tests { #[test] fn test_split_packet_multi() { - let ping_tc = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], CreatorConfig::default()); - let action_tc = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], CreatorConfig::default()); + let ping_tc = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_0), + 17, + 1, + &[], + CreatorConfig::default(), + ); + let action_tc = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_1), + 8, + 0, + &[], + CreatorConfig::default(), + ); let mut buffer: [u8; 32] = [0; 32]; let packet_len_ping = ping_tc .write_to_bytes(&mut buffer) @@ -255,8 +266,13 @@ mod tests { #[test] fn test_one_split_packet() { - let ping_tc = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], CreatorConfig::default()); + let ping_tc = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_0), + 17, + 1, + &[], + CreatorConfig::default(), + ); let mut buffer: [u8; 32] = [0; 32]; let packet_len_ping = ping_tc .write_to_bytes(&mut buffer) diff --git a/satrs/src/hal/std/tcp_spacepackets_server.rs b/satrs/src/hal/std/tcp_spacepackets_server.rs index f049e3e..282589a 100644 --- a/satrs/src/hal/std/tcp_spacepackets_server.rs +++ b/satrs/src/hal/std/tcp_spacepackets_server.rs @@ -183,10 +183,11 @@ mod tests { }; use alloc::sync::Arc; + use arbitrary_int::u11; use hashbrown::HashSet; use spacepackets::{ CcsdsPacket, PacketId, SpHeader, - ecss::{WritablePusPacket, tc::PusTcCreator}, + ecss::{CreatorConfig, WritablePusPacket, tc::PusTcCreator}, }; use crate::{ @@ -203,9 +204,9 @@ mod tests { use super::TcpSpacepacketsServer; const TCP_SERVER_ID: ComponentId = 0x05; - const TEST_APID_0: u16 = 0x02; + const TEST_APID_0: u11 = u11::new(0x02); const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0); - const TEST_APID_1: u16 = 0x10; + const TEST_APID_1: u11 = u11::new(0x10); const TEST_PACKET_ID_1: PacketId = PacketId::new_for_tc(true, TEST_APID_1); #[derive(Default)] @@ -283,8 +284,13 @@ mod tests { .check_no_connections_left(); set_if_done.store(true, Ordering::Relaxed); }); - let ping_tc = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); + let ping_tc = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_0), + 17, + 1, + &[], + CreatorConfig::default(), + ); let tc_0 = ping_tc.to_vec().expect("packet generation failed"); let mut stream = TcpStream::connect(dest_addr).expect("connecting to TCP server failed"); stream @@ -314,13 +320,23 @@ mod tests { // Add telemetry let mut total_tm_len = 0; - let verif_tm = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 1, 1, &[], true); + let verif_tm = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_0), + 1, + 1, + &[], + CreatorConfig::default(), + ); let tm_0 = verif_tm.to_vec().expect("writing packet failed"); total_tm_len += tm_0.len(); tm_source.add_tm(&tm_0); - let verif_tm = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 1, 3, &[], true); + let verif_tm = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_1), + 1, + 3, + &[], + CreatorConfig::default(), + ); let tm_1 = verif_tm.to_vec().expect("writing packet failed"); total_tm_len += tm_1.len(); tm_source.add_tm(&tm_1); @@ -366,14 +382,24 @@ mod tests { .expect("setting reas timeout failed"); // Send telecommands - let ping_tc = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_0), 17, 1, &[], true); + let ping_tc = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_0), + 17, + 1, + &[], + CreatorConfig::default(), + ); let tc_0 = ping_tc.to_vec().expect("ping tc creation failed"); stream .write_all(&tc_0) .expect("writing to TCP server failed"); - let action_tc = - PusTcCreator::new_simple(SpHeader::new_from_apid(TEST_APID_1), 8, 0, &[], true); + let action_tc = PusTcCreator::new_simple( + SpHeader::new_from_apid(TEST_APID_1), + 8, + 0, + &[], + CreatorConfig::default(), + ); let tc_1 = action_tc.to_vec().expect("action tc creation failed"); stream .write_all(&tc_1) diff --git a/satrs/src/hal/std/udp_server.rs b/satrs/src/hal/std/udp_server.rs index cbb54c0..e26eef4 100644 --- a/satrs/src/hal/std/udp_server.rs +++ b/satrs/src/hal/std/udp_server.rs @@ -127,8 +127,10 @@ mod tests { use crate::hal::std::udp_server::{ReceiveResult, UdpTcServer}; use crate::queue::GenericSendError; use crate::tmtc::PacketSenderRaw; + use arbitrary_int::u11; use core::cell::RefCell; use spacepackets::SpHeader; + use spacepackets::ecss::CreatorConfig; use spacepackets::ecss::tc::PusTcCreator; use std::collections::VecDeque; use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket}; @@ -165,8 +167,8 @@ mod tests { let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, ping_receiver) .expect("Creating UDP TMTC server failed"); is_send(&udp_tc_server); - let sph = SpHeader::new_from_apid(0x02); - let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); + let sph = SpHeader::new_from_apid(u11::new(0x02)); + let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default()); let len = pus_tc .write_to_bytes(&mut buf) .expect("Error writing PUS TC packet"); diff --git a/satrs/src/pus/event.rs b/satrs/src/pus/event.rs index ba367aa..480fa37 100644 --- a/satrs/src/pus/event.rs +++ b/satrs/src/pus/event.rs @@ -1,9 +1,9 @@ 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::SpHeader; +use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; +use spacepackets::ecss::{CreatorConfig, EcssEnumeration}; #[cfg(feature = "alloc")] pub use alloc_mod::*; @@ -121,7 +121,7 @@ impl EventReportCreator { SpHeader::new_from_apid(self.apid), sec_header, &src_data_buf[0..current_idx], - CreatorConfig::default() + CreatorConfig::default(), )) } } @@ -129,8 +129,8 @@ impl EventReportCreator { #[cfg(feature = "alloc")] mod alloc_mod { use super::*; - use crate::pus::{EcssTmSender, EcssTmtcError}; use crate::ComponentId; + use crate::pus::{EcssTmSender, EcssTmtcError}; use alloc::vec; use alloc::vec::Vec; use core::cell::RefCell; @@ -262,13 +262,13 @@ mod alloc_mod { #[cfg(test)] mod tests { use super::*; + use crate::ComponentId; use crate::events::{EventU32, Severity}; use crate::pus::test_util::TEST_COMPONENT_ID_0; use crate::pus::tests::CommonTmInfo; use crate::pus::{ChannelWithId, EcssTmSender, EcssTmtcError, PusTmVariant}; - use crate::ComponentId; - use spacepackets::ecss::PusError; use spacepackets::ByteConversionError; + use spacepackets::ecss::PusError; use std::cell::RefCell; use std::collections::VecDeque; use std::vec::Vec; diff --git a/satrs/src/pus/event_man.rs b/satrs/src/pus/event_man.rs index 501bb44..4a94a94 100644 --- a/satrs/src/pus/event_man.rs +++ b/satrs/src/pus/event_man.rs @@ -311,6 +311,7 @@ pub mod alloc_mod { mod tests { use alloc::string::{String, ToString}; use alloc::vec; + use arbitrary_int::u11; use spacepackets::ecss::PusPacket; use spacepackets::ecss::event::Subservice; use spacepackets::ecss::tm::PusTmReader; @@ -323,7 +324,7 @@ mod tests { const INFO_EVENT: EventU32TypedSev = EventU32TypedSev::::new(1, 0); const LOW_SEV_EVENT: EventU32 = EventU32::new(Severity::Low, 1, 5); const EMPTY_STAMP: [u8; 7] = [0; 7]; - const TEST_APID: u16 = 0x02; + const TEST_APID: u11 = u11::new(0x02); const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05); fn create_basic_man_1() -> DefaultPusEventU32TmCreator { diff --git a/satrs/src/pus/event_srv.rs b/satrs/src/pus/event_srv.rs index 8bd6794..63cd62b 100644 --- a/satrs/src/pus/event_srv.rs +++ b/satrs/src/pus/event_srv.rs @@ -144,7 +144,10 @@ impl< #[cfg(test)] mod tests { + use arbitrary_int::traits::Integer as _; + use arbitrary_int::u14; use delegate::delegate; + use spacepackets::ecss::CreatorConfig; use spacepackets::ecss::event::Subservice; use spacepackets::time::{TimeWriter, cds}; use spacepackets::util::UnsignedEnum; @@ -242,13 +245,13 @@ mod tests { expected_event_req: EventRequest, event_req_receiver: mpsc::Receiver, ) { - let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0); let sec_header = PusTcSecondaryHeader::new_simple(5, subservice as u8); let mut app_data = [0; 4]; TEST_EVENT_0 .write_to_be_bytes(&mut app_data) .expect("writing test event failed"); - let ping_tc = PusTcCreator::new(sp_header, sec_header, &app_data, true); + let ping_tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default()); let token = test_harness.start_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let request_id = token.request_id(); @@ -307,9 +310,10 @@ mod tests { fn test_sending_custom_subservice() { let (event_request_tx, _) = mpsc::channel(); let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx); - let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0); let sec_header = PusTcSecondaryHeader::new_simple(5, 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); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); @@ -326,10 +330,11 @@ mod tests { fn test_sending_invalid_app_data() { let (event_request_tx, _) = mpsc::channel(); let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx); - let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); + let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0); let sec_header = PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8); - let ping_tc = PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], true); + let ping_tc = + PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], CreatorConfig::default()); let token = test_harness.start_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); diff --git a/satrs/src/pus/scheduler.rs b/satrs/src/pus/scheduler.rs index ea86622..bf2e95d 100644 --- a/satrs/src/pus/scheduler.rs +++ b/satrs/src/pus/scheduler.rs @@ -347,8 +347,8 @@ pub fn generate_insert_telecommand_app_data( pub mod alloc_mod { use alloc::{ collections::{ - btree_map::{Entry, Range}, BTreeMap, + btree_map::{Entry, Range}, }, vec::Vec, }; @@ -865,7 +865,7 @@ mod tests { use arbitrary_int::traits::Integer as _; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::{CreatorConfig, WritablePusPacket}; - use spacepackets::time::{cds, TimeWriter, UnixTime}; + use spacepackets::time::{TimeWriter, UnixTime, cds}; use spacepackets::{PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader}; use std::time::Duration; use std::vec::Vec; @@ -1919,8 +1919,10 @@ mod tests { )); let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5)); 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, ZERO_SEQ, 100); - let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150); + 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, ZERO_SEQ, 150); assert_eq!(scheduler.num_scheduled_telecommands(), 3); let start_stamp = cds::CdsTime::from_unix_time_with_u16_days( &UnixTime::new_only_secs(100), @@ -1943,8 +1945,10 @@ mod tests { false, )); 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, ZERO_SEQ, 50); - let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 100); + 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, ZERO_SEQ, 100); insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150); assert_eq!(scheduler.num_scheduled_telecommands(), 3); @@ -1969,9 +1973,12 @@ mod tests { false, )); 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, ZERO_SEQ, 50); - 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, ZERO_SEQ, 150); + 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, ZERO_SEQ, 100); + let cmd_1_to_delete = + insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 150); let cmd_out_of_range_1 = insert_command_with_release_time(&mut pool, &mut scheduler, ZERO_SEQ, 200); assert_eq!(scheduler.num_scheduled_telecommands(), 4); diff --git a/satrs/src/pus/scheduler_srv.rs b/satrs/src/pus/scheduler_srv.rs index 7f4658a..8a75e47 100644 --- a/satrs/src/pus/scheduler_srv.rs +++ b/satrs/src/pus/scheduler_srv.rs @@ -260,11 +260,13 @@ mod tests { }; use crate::tmtc::PacketSenderWithSharedPool; use alloc::collections::VecDeque; + use arbitrary_int::traits::Integer; + use arbitrary_int::u14; use delegate::delegate; use spacepackets::SpHeader; - use spacepackets::ecss::WritablePusPacket; use spacepackets::ecss::scheduling::Subservice; use spacepackets::ecss::tc::PusTcSecondaryHeader; + use spacepackets::ecss::{CreatorConfig, WritablePusPacket}; use spacepackets::time::TimeWriter; use spacepackets::{ ecss::{tc::PusTcCreator, tm::PusTmReader}, @@ -386,9 +388,10 @@ mod tests { test_harness: &mut Pus11HandlerWithStoreTester, subservice: Subservice, ) { - let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, 0, 0); + let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, u14::ZERO, 0); let tc_header = PusTcSecondaryHeader::new_simple(11, subservice as u8); - let enable_scheduling = PusTcCreator::new(reply_header, tc_header, &[0; 7], true); + let enable_scheduling = + PusTcCreator::new(reply_header, tc_header, &[0; 7], CreatorConfig::default()); let token = test_harness.start_verification(&enable_scheduling); test_harness.send_tc(&token, &enable_scheduling); @@ -433,9 +436,9 @@ mod tests { #[test] fn test_insert_activity_tc() { let mut test_harness = Pus11HandlerWithStoreTester::new(); - let mut reply_header = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); + let mut reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0); let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new(reply_header, sec_header, &[], true); + let ping_tc = PusTcCreator::new(reply_header, sec_header, &[], CreatorConfig::default()); let req_id_ping_tc = scheduler::RequestId::from_tc(&ping_tc); let stamper = cds::CdsTime::now_with_u16_days().expect("time provider failed"); let mut sched_app_data: [u8; 64] = [0; 64]; @@ -443,13 +446,13 @@ mod tests { let ping_raw = ping_tc.to_vec().expect("generating raw tc failed"); sched_app_data[written_len..written_len + ping_raw.len()].copy_from_slice(&ping_raw); written_len += ping_raw.len(); - reply_header = SpHeader::new_for_unseg_tc(TEST_APID, 1, 0); + reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(1), 0); sec_header = PusTcSecondaryHeader::new_simple(11, Subservice::TcInsertActivity as u8); let enable_scheduling = PusTcCreator::new( reply_header, sec_header, &sched_app_data[..written_len], - true, + CreatorConfig::default(), ); let token = test_harness.start_verification(&enable_scheduling); test_harness.send_tc(&token, &enable_scheduling); diff --git a/satrs/src/pus/test.rs b/satrs/src/pus/test.rs index 4bea1f0..9bb40b3 100644 --- a/satrs/src/pus/test.rs +++ b/satrs/src/pus/test.rs @@ -4,8 +4,8 @@ use crate::pus::{ use crate::tmtc::{PacketAsVec, PacketSenderWithSharedPool}; use arbitrary_int::u14; use spacepackets::SpHeader; -use spacepackets::ecss::{CreatorConfig, PusPacket}; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; +use spacepackets::ecss::{CreatorConfig, PusPacket}; use std::sync::mpsc; use super::verification::{VerificationReporter, VerificationReportingProvider}; @@ -76,10 +76,14 @@ impl< // Sequence count will be handled centrally in TM funnel. // It is assumed that the verification reporter was built with a valid APID, so we use // the unchecked API here. - let reply_header = - SpHeader::new_for_unseg_tm(self.service_helper.verif_reporter().apid(), u14::new(0), 0); + let reply_header = 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 ping_reply = PusTmCreator::new(reply_header, tc_header, &[], CreatorConfig::default()); + let ping_reply = + PusTmCreator::new(reply_header, tc_header, &[], CreatorConfig::default()); if let Err(e) = self .service_helper .common @@ -152,9 +156,9 @@ mod tests { use arbitrary_int::u14; use delegate::delegate; use spacepackets::SpHeader; - use spacepackets::ecss::{CreatorConfig, PusPacket}; use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader}; use spacepackets::ecss::tm::PusTmReader; + use spacepackets::ecss::{CreatorConfig, PusPacket}; use spacepackets::time::{TimeWriter, cds}; use super::PusService17TestHandler; @@ -287,7 +291,8 @@ mod tests { // Create a ping TC, verify acceptance. let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0); let sec_header = PusTcSecondaryHeader::new_simple(17, 1); - let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default()); + let ping_tc = + PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default()); let token = test_harness.start_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let request_id = token.request_id(); @@ -342,7 +347,8 @@ mod tests { let mut test_harness = Pus17HandlerWithStoreTester::new(0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0); let sec_header = PusTcSecondaryHeader::new_simple(3, 1); - let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default()); + let ping_tc = + PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default()); let token = test_harness.start_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); @@ -363,7 +369,8 @@ mod tests { let mut test_harness = Pus17HandlerWithStoreTester::new(0); let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(0), 0); let sec_header = PusTcSecondaryHeader::new_simple(17, 200); - let ping_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default()); + let ping_tc = + PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default()); let token = test_harness.start_verification(&ping_tc); test_harness.send_tc(&token, &ping_tc); let result = test_harness.handle_one_tc(); diff --git a/satrs/src/pus/verification.rs b/satrs/src/pus/verification.rs index 7b4aa5b..a6f0b18 100644 --- a/satrs/src/pus/verification.rs +++ b/satrs/src/pus/verification.rs @@ -81,9 +81,9 @@ //! for the verification module contains examples how this module could be used in a more complex //! context involving multiple threads use crate::params::{Params, WritableToBeBytes}; -use crate::pus::{source_buffer_large_enough, EcssTmSender, EcssTmtcError}; +use crate::pus::{EcssTmSender, EcssTmtcError, source_buffer_large_enough}; use arbitrary_int::traits::Integer as _; -use arbitrary_int::{u11, u14, u3}; +use arbitrary_int::{u3, u11, u14}; use core::fmt::{Debug, Display, Formatter}; use core::hash::{Hash, Hasher}; use core::marker::PhantomData; @@ -96,15 +96,15 @@ use spacepackets::ecss::tc::IsPusTelecommand; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use spacepackets::ecss::{CreatorConfig, EcssEnumeration}; use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl}; -use spacepackets::{SpHeader, MAX_APID}; +use spacepackets::{MAX_APID, SpHeader}; pub use spacepackets::ecss::verification::*; #[cfg(feature = "alloc")] pub use alloc_mod::*; -use crate::request::Apid; use crate::ComponentId; +use crate::request::Apid; /// This is a request identifier as specified in 5.4.11.2 c. of the PUS standard. /// @@ -1712,26 +1712,26 @@ pub mod test_util { #[cfg(test)] pub mod tests { + use crate::ComponentId; use crate::params::Params; use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig}; use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0}; use crate::pus::tests::CommonTmInfo; use crate::pus::verification::{ - handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams, - FailParamsWithStep, RequestId, TcStateNone, VerificationReporter, - VerificationReporterConfig, VerificationToken, + EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone, + VerificationReporter, VerificationReporterConfig, VerificationToken, + handle_step_failure_with_generic_params, }; use crate::pus::{ChannelWithId, PusTmVariant}; use crate::request::MessageMetadata; use crate::spacepackets::seq_count::{SequenceCounter, SequenceCounterCcsdsSimple}; use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool}; - use crate::ComponentId; use alloc::format; use alloc::string::ToString; use arbitrary_int::{u11, u14}; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::{ - CreatorConfig, EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket, + CreatorConfig, EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket, WritablePusPacket, }; use spacepackets::seq_count::SequenceCounterSimple; @@ -1739,14 +1739,14 @@ pub mod tests { use spacepackets::{ByteConversionError, SpHeader}; use std::cell::RefCell; use std::collections::VecDeque; - use std::sync::{mpsc, RwLock}; + use std::sync::{RwLock, mpsc}; use std::vec; use std::vec::Vec; use super::{ - handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper, - TcStateAccepted, TcStateStarted, VerificationHook, VerificationReportingProvider, - WasAtLeastAccepted, + DummyVerificationHook, FailParamHelper, TcStateAccepted, TcStateStarted, VerificationHook, + VerificationReportingProvider, WasAtLeastAccepted, + handle_completion_failure_with_generic_params, }; fn is_send(_: &T) {} diff --git a/satrs/src/request.rs b/satrs/src/request.rs index 824f237..360aa4a 100644 --- a/satrs/src/request.rs +++ b/satrs/src/request.rs @@ -1,5 +1,5 @@ -use core::{fmt, marker::PhantomData}; use arbitrary_int::{traits::Integer as _, u11}; +use core::{fmt, marker::PhantomData}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; @@ -496,15 +496,19 @@ pub mod std_mod { mod tests { use std::sync::mpsc; - use alloc::string::ToString; - use arbitrary_int::{u11, u14}; - use spacepackets::{ - ecss::{tc::{PusTcCreator, PusTcSecondaryHeader}, CreatorConfig}, ByteConversionError, SpHeader - }; use crate::{ queue::{GenericReceiveError, GenericSendError}, request::{MessageMetadata, MessageSenderMap, MessageSenderStoreProvider}, }; + use alloc::string::ToString; + use arbitrary_int::{u11, u14}; + use spacepackets::{ + ByteConversionError, SpHeader, + ecss::{ + CreatorConfig, + tc::{PusTcCreator, PusTcSecondaryHeader}, + }, + }; use super::{GenericMessage, MessageReceiverWithId, UniqueApidTargetId}; @@ -533,7 +537,9 @@ mod tests { #[test] fn test_basic_target_id_with_apid_from_pus_tc() { let sp_header = SpHeader::new_for_unseg_tc(u11::new(0x111), u14::new(5), 0); - let pus_tc = PusTcCreator::new_simple(sp_header, 17, 1, &[], CreatorConfig::default()); + let app_data = 1_u32.to_be_bytes(); + let pus_tc = + PusTcCreator::new_simple(sp_header, 17, 1, &app_data, CreatorConfig::default()); let id = UniqueApidTargetId::from_pus_tc(&pus_tc).unwrap(); assert_eq!(id.apid.value(), 0x111); assert_eq!(id.unique_id, 1); diff --git a/satrs/src/tmtc/tm_helper.rs b/satrs/src/tmtc/tm_helper.rs index 25923f7..c7cd559 100644 --- a/satrs/src/tmtc/tm_helper.rs +++ b/satrs/src/tmtc/tm_helper.rs @@ -1,6 +1,6 @@ use arbitrary_int::{u11, u14}; -use spacepackets::ecss::CreatorConfig; use spacepackets::SpHeader; +use spacepackets::ecss::CreatorConfig; use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader}; use spacepackets::time::cds::CdsTime; @@ -51,7 +51,12 @@ impl PusTmWithCdsShortHelper { ) -> PusTmCreator<'_, 'data> { 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); - PusTmCreator::new(reply_header, tc_header, source_data, CreatorConfig::default()) + PusTmCreator::new( + reply_header, + tc_header, + source_data, + CreatorConfig::default(), + ) } } @@ -65,7 +70,8 @@ mod tests { fn test_helper_with_stamper() { let mut pus_tm_helper = PusTmWithCdsShortHelper::new(u11::new(0x123)); 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, u14::new(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.subservice(), 1); assert_eq!(tm.user_data(), &[1, 2, 3, 4]); diff --git a/satrs/tests/hk_helpers.rs b/satrs/tests/hk_helpers.rs index d1b545e..65711e3 100644 --- a/satrs/tests/hk_helpers.rs +++ b/satrs/tests/hk_helpers.rs @@ -2,8 +2,8 @@ use core::mem::size_of; use serde::{Deserialize, Serialize}; use spacepackets::ecss::{PfcReal, PfcUnsigned, Ptc}; +use spacepackets::time::CcsdsTimeProvider; use spacepackets::time::cds::CdsTime; -use spacepackets::time::{CcsdsTimeProvider, TimeWriter}; enum NumOfParamsInfo { /// The parameter entry is a scalar field diff --git a/satrs/tests/pus_events.rs b/satrs/tests/pus_events.rs index cda2225..869dc71 100644 --- a/satrs/tests/pus_events.rs +++ b/satrs/tests/pus_events.rs @@ -1,3 +1,4 @@ +use arbitrary_int::u11; use satrs::event_man::{ EventManagerWithMpsc, EventMessage, EventMessageU32, EventRoutingError, EventSendProvider, EventU32SenderMpsc, @@ -8,15 +9,15 @@ use satrs::params::{Params, ParamsHeapless, WritableToBeBytes}; use satrs::pus::event_man::{DefaultPusEventReportingMap, EventReporter, PusEventTmCreatorWithMap}; use satrs::request::UniqueApidTargetId; use satrs::tmtc::PacketAsVec; +use spacepackets::ecss::PusError; use spacepackets::ecss::tm::PusTmReader; -use spacepackets::ecss::{PusError, PusPacket}; use std::sync::mpsc::{self, SendError, TryRecvError}; use std::thread; const INFO_EVENT: EventU32TypedSev = EventU32TypedSev::::new(1, 0); const LOW_SEV_EVENT: EventU32 = EventU32::new(Severity::Low, 1, 5); const EMPTY_STAMP: [u8; 7] = [0; 7]; -const TEST_APID: u16 = 0x02; +const TEST_APID: u11 = u11::new(0x02); const TEST_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05); #[derive(Debug, Clone)] @@ -35,8 +36,8 @@ fn test_threaded_usage() { event_man.subscribe_all(pus_event_man_send_provider.target_id()); event_man.add_sender(pus_event_man_send_provider); let (event_packet_tx, event_packet_rx) = mpsc::channel::(); - let reporter = - EventReporter::new(TEST_ID.raw(), 0x02, 0, 128).expect("Creating event reporter failed"); + let reporter = EventReporter::new(TEST_ID.raw(), u11::new(0x02), 0, 128) + .expect("Creating event reporter failed"); let pus_event_man = PusEventTmCreatorWithMap::new(reporter, DefaultPusEventReportingMap::default()); let error_handler = |event_msg: &EventMessageU32, error: EventRoutingError| { diff --git a/satrs/tests/pus_verification.rs b/satrs/tests/pus_verification.rs index 64358db..4a8dba4 100644 --- a/satrs/tests/pus_verification.rs +++ b/satrs/tests/pus_verification.rs @@ -1,5 +1,7 @@ #[cfg(feature = "crossbeam")] pub mod crossbeam_test { + use arbitrary_int::traits::Integer as _; + use arbitrary_int::u14; use hashbrown::HashMap; use satrs::pool::{PoolProvider, PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig}; use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0}; @@ -11,7 +13,7 @@ pub mod crossbeam_test { use spacepackets::SpHeader; use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader}; use spacepackets::ecss::tm::PusTmReader; - use spacepackets::ecss::{EcssEnumU8, EcssEnumU16, PusPacket, WritablePusPacket}; + use spacepackets::ecss::{CreatorConfig, EcssEnumU8, EcssEnumU16, WritablePusPacket}; use std::sync::RwLock; use std::thread; use std::time::Duration; @@ -57,9 +59,9 @@ pub mod crossbeam_test { let (tx_tc_1, rx_tc_1) = crossbeam_channel::bounded(3); { let mut tc_guard = shared_tc_pool.write().unwrap(); - let sph = SpHeader::new_for_unseg_tc(TEST_APID, 0, 0); + let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0); let tc_header = PusTcSecondaryHeader::new_simple(17, 1); - let pus_tc_0 = PusTcCreator::new_no_app_data(sph, tc_header, true); + let pus_tc_0 = PusTcCreator::new_no_app_data(sph, tc_header, CreatorConfig::default()); req_id_0 = RequestId::new(&pus_tc_0); let addr = tc_guard .free_element(pus_tc_0.len_written(), |buf| { @@ -67,9 +69,9 @@ pub mod crossbeam_test { }) .unwrap(); tx_tc_0.send(addr).unwrap(); - let sph = SpHeader::new_for_unseg_tc(TEST_APID, 1, 0); + let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(1), 0); let tc_header = PusTcSecondaryHeader::new_simple(5, 1); - let pus_tc_1 = PusTcCreator::new_no_app_data(sph, tc_header, true); + let pus_tc_1 = PusTcCreator::new_no_app_data(sph, tc_header, CreatorConfig::default()); req_id_1 = RequestId::new(&pus_tc_1); let addr = tc_guard .free_element(pus_tc_0.len_written(), |buf| { diff --git a/satrs/tests/tcp_servers.rs b/satrs/tests/tcp_servers.rs index 43b0423..bc9a2f6 100644 --- a/satrs/tests/tcp_servers.rs +++ b/satrs/tests/tcp_servers.rs @@ -21,6 +21,7 @@ use std::{ thread, }; +use arbitrary_int::{traits::Integer, u11, u14}; use hashbrown::HashSet; use satrs::{ ComponentId, @@ -36,7 +37,7 @@ use satrs::{ }; use spacepackets::{ CcsdsPacket, PacketId, SpHeader, - ecss::{WritablePusPacket, tc::PusTcCreator}, + ecss::{CreatorConfig, WritablePusPacket, tc::PusTcCreator}, }; use std::{collections::VecDeque, sync::Arc, vec::Vec}; @@ -192,7 +193,7 @@ fn test_cobs_server() { matches!(tc_receiver.try_recv(), Err(mpsc::TryRecvError::Empty)); } -const TEST_APID_0: u16 = 0x02; +const TEST_APID_0: u11 = u11::new(0x02); const TEST_PACKET_ID_0: PacketId = PacketId::new_for_tc(true, TEST_APID_0); #[derive(Default)] @@ -217,8 +218,8 @@ impl SpacePacketValidator for SimpleVerificator { fn test_ccsds_server() { let (tc_sender, tc_receiver) = mpsc::channel(); let mut tm_source = SyncTmSource::default(); - let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0); - let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], true); + let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, u14::new(0), 0); + let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], CreatorConfig::default()); let tm_0 = verif_tm.to_vec().expect("tm generation failed"); tm_source.add_tm(&tm_0); let mut packet_id_lookup = SimpleVerificator::default(); @@ -267,8 +268,8 @@ fn test_ccsds_server() { .expect("setting reas timeout failed"); // Send ping telecommand. - let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, 0, 0); - let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], true); + let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, u14::ZERO, 0); + let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default()); let tc_0 = ping_tc.to_vec().expect("packet creation failed"); stream .write_all(&tc_0)