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

bump spacepackets

Browse Source
This commit is contained in:
Robin Mueller
2025-09-11 09:29:34 +02:00
parent ab44e3312c
commit 45a99cabce
23 changed files with 207 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
satrs-example/src/acs/mgm.rs
View File

@@ -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);

2
satrs-example/src/eps/pcdu.rs
View File

@@ -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,

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

@@ -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)]

7
satrs-example/src/interface/udp.rs
View File

@@ -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");

11
satrs-example/src/pus/action.rs
View File

@@ -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);

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

@@ -79,10 +79,16 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> 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)?;
}

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

@@ -157,7 +157,8 @@ 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)
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);

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

@@ -91,7 +91,8 @@ pub fn parse_buffer_for_ccsds_space_packets<SendError>(
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)

52
satrs/src/hal/std/tcp_spacepackets_server.rs
View File

@@ -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)

6
satrs/src/hal/std/udp_server.rs
View File

@@ -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");

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

@@ -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;

3
satrs/src/pus/event_man.rs
View File

@@ -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<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::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 {

17
satrs/src/pus/event_srv.rs
View File

@@ -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<EventRequestWithToken>,
) {
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();

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

@@ -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);

17
satrs/src/pus/scheduler_srv.rs
View File

@@ -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);

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

@@ -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();

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

@@ -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: Send>(_: &T) {}

20
satrs/src/request.rs
View File

@@ -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);

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

@@ -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]);

2
satrs/tests/hk_helpers.rs
View File

@@ -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

9
satrs/tests/pus_events.rs
View File

@@ -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<SeverityInfo> = EventU32TypedSev::<SeverityInfo>::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::<PacketAsVec>();
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| {

12
satrs/tests/pus_verification.rs
View File

@@ -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| {

13
satrs/tests/tcp_servers.rs
View File

@@ -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)