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

update spacepackets

Browse Source
This commit is contained in:
Robin Mueller
2025-10-31 14:23:39 +01:00
parent 3d9b47b92a
commit 9c00b1e5ca
33 changed files with 328 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
embedded-examples/embedded-client/Cargo.toml
View File

@@ -10,6 +10,7 @@ toml = "0.9"
serde = { version = "1", features = ["derive"] }
satrs-stm32f3-disco-rtic = { path = "../stm32f3-disco-rtic" }
spacepackets = { git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", version = "0.17" }
tmtc-utils = { git = "https://egit.irs.uni-stuttgart.de/rust/tmtc-utils.git", version = "0.1" }
postcard = { version = "1", features = ["alloc"] }
cobs = "0.5"
fern = "0.7"

69
embedded-examples/embedded-client/src/main.rs
View File

@@ -8,7 +8,8 @@ use std::{
use clap::Parser;
use cobs::CobsDecoderOwned;
use satrs_stm32f3_disco_rtic::Request;
use spacepackets::{CcsdsPacketCreator, CcsdsPacketReader, SpHeader};
use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
use tmtc_utils::transport::{PacketTransport, serial::PacketTransportSerialCobs};
#[derive(Parser, Debug)]
struct Cli {
@@ -62,65 +63,45 @@ fn main() {
let config: Config = toml::from_str(&toml_str).expect("parsing config.toml file failed");
println!("Connecting to serial port {}", config.interface.serial_port);
let mut serial = serialport::new(config.interface.serial_port, 115200)
let serial = serialport::new(config.interface.serial_port, 115200)
.open()
.expect("opening serial port failed");
let mut transport = PacketTransportSerialCobs::new(serial, CobsDecoderOwned::new(1024));
if cli.ping {
let request = Request::Ping;
let tc_encoded_raw = create_stm32f3_tc(&request);
log::info!("Sending ping request");
serial.write_all(&tc_encoded_raw).unwrap();
let tc = create_stm32f3_tc(&request);
log::info!(
"Sending ping request with TC ID: {:#010x}",
tc.ccsds_packet_id_and_psc().raw()
);
transport.send(&tc.to_vec()).unwrap();
}
if let Some(freq_ms) = cli.set_led_frequency {
let request = Request::ChangeBlinkFrequency(Duration::from_millis(freq_ms as u64));
let tc_encoded_raw = create_stm32f3_tc(&request);
log::info!("Sending change blink frequency request: {:?}", request);
serial.write_all(&tc_encoded_raw).unwrap();
let tc = create_stm32f3_tc(&request);
log::info!(
"Sending change blink frequency request {:?} with TC ID: {:#010x}",
request,
tc.ccsds_packet_id_and_psc().raw()
);
transport.send(&tc.to_vec()).unwrap();
}
let mut cobs_decoder = CobsDecoderOwned::new(1024);
log::info!("Waiting for response...");
loop {
let mut reception_buffer = [0u8; 1024];
let received_bytes = serial.read(&mut reception_buffer);
match received_bytes {
Ok(0) => {
std::thread::sleep(std::time::Duration::from_millis(100));
}
Ok(n) => {
for byte in &reception_buffer[..n] {
match cobs_decoder.feed(*byte) {
Ok(Some(packet_len)) => {
let reader = CcsdsPacketReader::new_with_checksum(
&cobs_decoder.dest()[0..packet_len],
);
log::debug!("Received packet: {:?}", reader);
}
Ok(None) => (),
Err(e) => {
log::error!("COBS decoding error {e}, resetting decoder");
}
}
}
}
Err(e) => {
if e.kind() != std::io::ErrorKind::TimedOut
&& e.kind() != std::io::ErrorKind::WouldBlock
{
log::error!("Error reading from serial port: {:?}", e);
}
std::thread::sleep(std::time::Duration::from_millis(100));
}
}
transport
.receive(|packet: &[u8]| {
let reader = CcsdsPacketReader::new_with_checksum(packet);
log::info!("Received packet: {:?}", reader);
})
.unwrap();
}
}
fn create_stm32f3_tc(request: &Request) -> Vec<u8> {
fn create_stm32f3_tc(request: &Request) -> CcsdsPacketCreatorOwned {
let req_raw = postcard::to_allocvec(&request).unwrap();
let sp_header = SpHeader::new_from_apid(satrs_stm32f3_disco_rtic::APID);
let ccsds_tc_packet = CcsdsPacketCreator::new_tc_with_checksum(sp_header, &req_raw).unwrap();
let tc_raw = ccsds_tc_packet.to_vec();
cobs::encode_vec_including_sentinels(&tc_raw)
CcsdsPacketCreatorOwned::new_tc_with_checksum(sp_header, &req_raw).unwrap()
}

10
embedded-examples/stm32f3-disco-rtic/Cargo.lock generated
View File

@@ -128,9 +128,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]]
name = "cc"
version = "1.2.43"
version = "1.2.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "739eb0f94557554b3ca9a86d2d37bebd49c5e6d0c1d2bda35ba5bdac830befc2"
checksum = "37521ac7aabe3d13122dc382493e20c9416f299d2ccd5b3a5340a2570cdeb0f3"
dependencies = [
"find-msvc-tools",
"shlex",
@@ -1245,7 +1245,7 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
[[package]]
name = "spacepackets"
version = "0.17.0"
source = "git+https://egit.irs.uni-stuttgart.de/rust/spacepackets.git#8e2e0ce632693325bfb971b6b0286933297f34d9"
source = "git+https://egit.irs.uni-stuttgart.de/rust/spacepackets.git#2bc61677105765e69cc96bb1ff9960557c00fa8e"
dependencies = [
"arbitrary-int 2.0.0",
"bitbybit",
@@ -1402,9 +1402,9 @@ dependencies = [
[[package]]
name = "unicode-ident"
version = "1.0.20"
version = "1.0.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06"
checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
[[package]]
name = "valuable"

4
embedded-examples/stm32f3-disco-rtic/src/lib.rs
View File

@@ -6,7 +6,7 @@ use core::time::Duration;
use embassy_stm32::gpio::Output;
use spacepackets::{
ccsds_packet_len_for_user_data_len_with_checksum, CcsdsPacketCreationError,
CcsdsPacketCreatorWithReservedData, SpacePacketHeader,
CcsdsPacketCreatorWithReservedData, CcsdsPacketIdAndPsc, SpacePacketHeader,
};
pub const APID: u11 = u11::new(0x02);
@@ -48,7 +48,7 @@ pub enum Request {
#[derive(Debug, defmt::Format, serde::Serialize, serde::Deserialize)]
pub struct TmHeader {
pub tc_packet_id: Option<spacepackets::CcsdsPacketId>,
pub tc_packet_id: Option<CcsdsPacketIdAndPsc>,
pub uptime_millis: u32,
}

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

@@ -2,7 +2,7 @@ use arbitrary_int::u11;
use satrs::pus::verification::RequestId;
use satrs::spacepackets::ecss::tc::PusTcCreator;
use satrs::spacepackets::ecss::tm::PusTmReader;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs::spacepackets::SpHeader;
use satrs_example::config::{OBSW_SERVER_ADDR, SERVER_PORT};
use std::net::{IpAddr, SocketAddr, UdpSocket};
@@ -13,8 +13,7 @@ fn main() {
let addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
let pus_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(u11::new(0x02)),
17,
1,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
@@ -35,9 +34,9 @@ fn main() {
match res {
Ok(_len) => {
let pus_tm = PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
if pus_tm.service() == 17 && pus_tm.subservice() == 2 {
if pus_tm.service_type_id() == 17 && pus_tm.message_subtype_id() == 2 {
println!("Received PUS Ping Reply TM[17,2]")
} else if pus_tm.service() == 1 {
} else if pus_tm.service_type_id() == 1 {
if pus_tm.source_data().is_empty() {
println!("Invalid verification TM, no source data");
}
@@ -46,28 +45,29 @@ fn main() {
println!("Invalid verification TM source data, less than 4 bytes")
}
let req_id = RequestId::from_bytes(src_data).unwrap();
if pus_tm.subservice() == 1 {
let subtype_id = pus_tm.message_subtype_id();
if subtype_id == 1 {
println!("Received TM[1,1] acceptance success for request ID {req_id}")
} else if pus_tm.subservice() == 2 {
} else if subtype_id == 2 {
println!("Received TM[1,2] acceptance failure for request ID {req_id}")
} else if pus_tm.subservice() == 3 {
} else if subtype_id == 3 {
println!("Received TM[1,3] start success for request ID {req_id}")
} else if pus_tm.subservice() == 4 {
} else if subtype_id == 4 {
println!("Received TM[1,2] start failure for request ID {req_id}")
} else if pus_tm.subservice() == 5 {
} else if subtype_id == 5 {
println!("Received TM[1,5] step success for request ID {req_id}")
} else if pus_tm.subservice() == 6 {
} else if subtype_id == 6 {
println!("Received TM[1,6] step failure for request ID {req_id}")
} else if pus_tm.subservice() == 7 {
} else if subtype_id == 7 {
println!("Received TM[1,7] completion success for request ID {req_id}")
} else if pus_tm.subservice() == 8 {
} else if subtype_id == 8 {
println!("Received TM[1,8] completion failure for request ID {req_id}");
}
} else {
println!(
"Received TM[{}, {}] with {} bytes",
pus_tm.service(),
pus_tm.subservice(),
pus_tm.service_type_id(),
pus_tm.message_subtype_id(),
size
);
}

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

@@ -3,7 +3,7 @@ use derive_new::new;
use satrs::hk::UniqueId;
use satrs::request::UniqueApidTargetId;
use satrs::spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use satrs::spacepackets::ecss::{hk, CreatorConfig};
use satrs::spacepackets::ecss::{hk, CreatorConfig, MessageTypeId};
use satrs::spacepackets::{ByteConversionError, SpHeader};
#[derive(Debug, new, Copy, Clone)]
@@ -54,8 +54,12 @@ impl PusHkHelper {
hk_data_writer: &mut HkWriter,
buf: &'b mut [u8],
) -> Result<PusTmCreator<'a, 'b>, ByteConversionError> {
let sec_header =
PusTmSecondaryHeader::new(3, hk::Subservice::TmHkPacket as u8, 0, 0, timestamp);
let sec_header = PusTmSecondaryHeader::new(
MessageTypeId::new(3, hk::Subservice::TmHkPacket as u8),
0,
0,
timestamp,
);
buf[0..4].copy_from_slice(&self.component_id.unique_id.as_u32().to_be_bytes());
buf[4..8].copy_from_slice(&set_id.to_be_bytes());
let (_, second_half) = buf.split_at_mut(8);

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

@@ -116,7 +116,7 @@ mod tests {
use arbitrary_int::traits::Integer as _;
use arbitrary_int::u14;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs::{
spacepackets::{
ecss::{tc::PusTcCreator, WritablePusPacket},
@@ -182,7 +182,12 @@ mod tests {
tm_handler,
};
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())
let ping_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
)
.to_vec()
.unwrap();
let client = UdpSocket::bind("127.0.0.1:0").expect("Connecting to UDP server failed");

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

@@ -161,7 +161,7 @@ impl PusTcToRequestConverter<ActivePusActionRequestStd, ActionRequest> for Actio
verif_reporter: &impl VerificationReportingProvider,
time_stamp: &[u8],
) -> Result<(ActivePusActionRequestStd, ActionRequest), Self::Error> {
let subservice = tc.subservice();
let subservice = tc.message_subtype_id();
let user_data = tc.user_data();
if user_data.len() < 8 {
verif_reporter
@@ -277,7 +277,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::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs::tmtc::PacketAsVec;
use satrs::ComponentId;
use satrs::{
@@ -450,7 +450,7 @@ mod tests {
);
// Create a basic action request and verify forwarding.
let sp_header = SpHeader::new_from_apid(TEST_APID);
let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
let action_id = 5_u32;
let mut app_data: [u8; 8] = [0; 8];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_1.as_u32().to_be_bytes());
@@ -492,7 +492,7 @@ mod tests {
TEST_COMPONENT_ID_1.id(),
);
// Create a basic action request and verify forwarding.
let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
let action_id = 5_u32;
let mut app_data: [u8; 8] = [0; 8];
// Invalid ID, routing should fail.
@@ -518,7 +518,7 @@ mod tests {
TEST_COMPONENT_ID_0.raw(),
ActionRequestConverter::default(),
);
let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
let action_id = 5_u32;
let mut app_data: [u8; 8] = [0; 8];
// Invalid ID, routing should fail.
@@ -554,7 +554,7 @@ mod tests {
fn converter_action_req_with_data() {
let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ActionRequestConverter::default());
let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(8, 128));
let action_id = 5_u32;
let mut app_data: [u8; 16] = [0; 16];
// Invalid ID, routing should fail.

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

@@ -164,7 +164,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
found: 4,
});
}
let subservice = tc.subservice();
let subservice = tc.message_subtype_id();
let target_id_and_apid = UniqueApidTargetId::from_pus_tc(tc).expect("invalid tc format");
let unique_id = u32::from_be_bytes(tc.user_data()[4..8].try_into().unwrap());
@@ -308,7 +308,7 @@ mod tests {
TEST_COMPONENT_ID_0, TEST_COMPONENT_ID_1, TEST_UNIQUE_ID_0, TEST_UNIQUE_ID_1,
};
use satrs::request::MessageMetadata;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs::{
hk::HkRequestVariant,
pus::test_util::TEST_APID,
@@ -340,8 +340,7 @@ mod tests {
let hk_req = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcGenerateOneShotHk as u8,
MessageTypeId::new(3, Subservice::TcGenerateOneShotHk as u8),
&app_data,
CreatorConfig::default(),
);
@@ -380,16 +379,14 @@ mod tests {
};
let tc0 = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcEnableHkGeneration as u8,
MessageTypeId::new(3, Subservice::TcEnableHkGeneration as u8),
&app_data,
CreatorConfig::default(),
);
generic_check(&tc0);
let tc1 = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcEnableDiagGeneration as u8,
MessageTypeId::new(3, Subservice::TcEnableDiagGeneration as u8),
&app_data,
CreatorConfig::default(),
);
@@ -419,16 +416,14 @@ mod tests {
};
let tc0 = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcDisableHkGeneration as u8,
MessageTypeId::new(3, Subservice::TcDisableHkGeneration as u8),
&app_data,
CreatorConfig::default(),
);
generic_check(&tc0);
let tc1 = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcDisableDiagGeneration as u8,
MessageTypeId::new(3, Subservice::TcDisableDiagGeneration as u8),
&app_data,
CreatorConfig::default(),
);
@@ -462,16 +457,14 @@ mod tests {
};
let tc0 = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcModifyHkCollectionInterval as u8,
MessageTypeId::new(3, Subservice::TcModifyHkCollectionInterval as u8),
&app_data,
CreatorConfig::default(),
);
generic_check(&tc0);
let tc1 = PusTcCreator::new_simple(
sp_header,
3,
Subservice::TcModifyDiagCollectionInterval as u8,
MessageTypeId::new(3, Subservice::TcModifyDiagCollectionInterval as u8),
&app_data,
CreatorConfig::default(),
);

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

@@ -113,7 +113,7 @@ impl PusTcDistributor {
.verif_reporter
.acceptance_success(&self.tm_sender, init_token, self.stamp_helper.stamp())
.expect("Acceptance success failure");
let service = PusServiceId::try_from(pus_tc.service());
let service = PusServiceId::try_from(pus_tc.service_type_id());
let tc_in_memory: TcInMemory = if let Some(store_addr) = addr_opt {
PacketInPool::new(sender_id, store_addr).into()
} else {
@@ -535,7 +535,7 @@ pub(crate) mod tests {
use satrs::pus::test_util::TEST_COMPONENT_ID_0;
use satrs::pus::{MpscTmAsVecSender, PusTmVariant};
use satrs::request::RequestId;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs::{
pus::{
verification::test_util::TestVerificationReporter, ActivePusRequestStd,
@@ -597,7 +597,7 @@ pub(crate) mod tests {
time_stamp: &[u8],
) -> (verification::RequestId, ActivePusRequestStd) {
let sp_header = SpHeader::new_from_apid(apid);
let sec_header_dummy = PusTcSecondaryHeader::new_simple(0, 0);
let sec_header_dummy = PusTcSecondaryHeader::new_simple(MessageTypeId::new(0, 0));
let init = self.verif_reporter.start_verification(&PusTcCreator::new(
sp_header,
sec_header_dummy,

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

@@ -2,7 +2,7 @@ use arbitrary_int::traits::Integer as _;
use arbitrary_int::u14;
use derive_new::new;
use satrs::mode_tree::{ModeNode, ModeParent};
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs_example::ids;
use std::sync::mpsc;
use std::time::Duration;
@@ -81,8 +81,12 @@ impl PusReplyHandler<ActivePusRequestStd, ModeReply> for ModeReplyHandler {
.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::ZERO, 0);
let sec_header =
PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp);
let sec_header = PusTmSecondaryHeader::new(
MessageTypeId::new(200, Subservice::TmModeReply as u8),
0,
0,
time_stamp,
);
let pus_tm = PusTmCreator::new(
sp_header,
sec_header,
@@ -154,7 +158,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, ModeRequest> for ModeRequestCo
verif_reporter: &impl VerificationReportingProvider,
time_stamp: &[u8],
) -> Result<(ActivePusRequestStd, ModeRequest), Self::Error> {
let subservice = tc.subservice();
let subservice = tc.message_subtype_id();
let user_data = tc.user_data();
let not_enough_app_data = |expected: usize| {
verif_reporter
@@ -302,7 +306,7 @@ mod tests {
use arbitrary_int::u14;
use satrs::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0, TEST_UNIQUE_ID_0};
use satrs::request::MessageMetadata;
use satrs::spacepackets::ecss::CreatorConfig;
use satrs::spacepackets::ecss::{CreatorConfig, MessageTypeId};
use satrs::{
mode::{ModeAndSubmode, ModeReply, ModeRequest},
pus::mode::Subservice,
@@ -326,7 +330,8 @@ mod tests {
let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcReadMode as u8);
let sec_header =
PusTcSecondaryHeader::new_simple(MessageTypeId::new(200, Subservice::TcReadMode as u8));
let mut app_data: [u8; 4] = [0; 4];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
@@ -342,7 +347,8 @@ mod tests {
let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcSetMode as u8);
let sec_header =
PusTcSecondaryHeader::new_simple(MessageTypeId::new(200, Subservice::TcSetMode as u8));
let mut app_data: [u8; 4 + ModeAndSubmode::RAW_LEN] = [0; 4 + ModeAndSubmode::RAW_LEN];
let mode_and_submode = ModeAndSubmode::new(2, 1);
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
@@ -368,7 +374,10 @@ mod tests {
let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceMode as u8);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
200,
Subservice::TcAnnounceMode as u8,
));
let mut app_data: [u8; 4] = [0; 4];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());
@@ -384,8 +393,10 @@ mod tests {
let mut testbench =
PusConverterTestbench::new(TEST_COMPONENT_ID_0.id(), ModeRequestConverter::default());
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header =
PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
200,
Subservice::TcAnnounceModeRecursive as u8,
));
let mut app_data: [u8; 4] = [0; 4];
app_data[0..4].copy_from_slice(&TEST_UNIQUE_ID_0.as_u32().to_be_bytes());
let tc = PusTcCreator::new(sp_header, sec_header, &app_data, CreatorConfig::default());

2
satrs-example/src/pus/test.rs
View File

@@ -122,7 +122,7 @@ impl DirectPusService for TestCustomServiceWrapper {
}
}
} else {
let fail_data = [tc.subservice()];
let fail_data = [tc.message_subtype_id()];
self.handler
.service_helper
.verif_reporter()

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

@@ -55,7 +55,7 @@ impl GenericRequestRouter {
) {
warn!(
"Routing request for service {} failed: {error:?}",
tc.service()
tc.service_type_id()
);
let accepted_token: VerificationToken<TcStateAccepted> = active_request
.token()

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

@@ -59,7 +59,7 @@ impl TmFunnelCommon {
);
let entry = self
.msg_counter_map
.entry(zero_copy_writer.service())
.entry(zero_copy_writer.service_type_id())
.or_insert(0);
zero_copy_writer.set_msg_count(*entry);
if *entry == u16::MAX {
@@ -76,8 +76,8 @@ impl TmFunnelCommon {
fn packet_printout(tm: &PusTmZeroCopyWriter) {
info!(
"Sending PUS TM[{},{}] with APID {}",
tm.service(),
tm.subservice(),
tm.service_type_id(),
tm.message_subtype_id(),
tm.apid()
);
}

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
[dependencies]
spacepackets = { version = ">=0.14, <=0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
serde = { version = "1", default-features = false, optional = true }
defmt = {version = "1", optional = true }

16
satrs-shared/src/res_code.rs
View File

@@ -14,6 +14,7 @@ pub struct ResultU16 {
}
impl ResultU16 {
#[inline]
pub const fn new(group_id: u8, unique_id: u8) -> Self {
Self {
group_id,
@@ -21,18 +22,22 @@ impl ResultU16 {
}
}
pub fn raw(&self) -> u16 {
#[inline]
pub const fn raw(&self) -> u16 {
((self.group_id as u16) << 8) | self.unique_id as u16
}
pub fn group_id(&self) -> u8 {
#[inline]
pub const fn group_id(&self) -> u8 {
self.group_id
}
pub fn unique_id(&self) -> u8 {
#[inline]
pub const fn unique_id(&self) -> u8 {
self.unique_id
}
#[inline]
pub fn from_be_bytes(bytes: [u8; 2]) -> Self {
Self::from(u16::from_be_bytes(bytes))
}
@@ -51,6 +56,7 @@ impl From<ResultU16> for EcssEnumU16 {
}
impl UnsignedEnum for ResultU16 {
#[inline]
fn size(&self) -> usize {
core::mem::size_of::<u16>()
}
@@ -67,12 +73,14 @@ impl UnsignedEnum for ResultU16 {
Ok(self.size())
}
fn value(&self) -> u64 {
#[inline]
fn value_raw(&self) -> u64 {
self.raw() as u64
}
}
impl EcssEnumeration for ResultU16 {
#[inline]
fn pfc(&self) -> u8 {
16
}

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

@@ -99,7 +99,7 @@ mod tests {
use arbitrary_int::{u11, u14};
use spacepackets::{
CcsdsPacket, PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader,
ecss::{CreatorConfig, tc::PusTcCreator},
ecss::{CreatorConfig, MessageTypeId, tc::PusTcCreator},
};
use crate::{ComponentId, encoding::tests::TcCacher};
@@ -139,7 +139,12 @@ mod tests {
#[test]
fn test_basic() {
let sph = SpHeader::new_from_apid(TEST_APID_0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let ping_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
let mut buffer: [u8; 32] = [0; 32];
let packet_len = ping_tc
.write_to_bytes(&mut buffer)
@@ -164,8 +169,14 @@ mod tests {
#[test]
fn test_multi_packet() {
let sph = SpHeader::new_from_apid(TEST_APID_0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
let ping_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
let action_tc =
PusTcCreator::new_simple(sph, MessageTypeId::new(8, 0), &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32];
let packet_len_ping = ping_tc
.write_to_bytes(&mut buffer)
@@ -199,9 +210,15 @@ mod tests {
#[test]
fn test_multi_apid() {
let sph = SpHeader::new_from_apid(TEST_APID_0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let ping_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
let sph = SpHeader::new_from_apid(TEST_APID_1);
let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
let action_tc =
PusTcCreator::new_simple(sph, MessageTypeId::new(8, 0), &[], CreatorConfig::default());
let mut buffer: [u8; 32] = [0; 32];
let packet_len_ping = ping_tc
.write_to_bytes(&mut buffer)
@@ -231,15 +248,13 @@ mod tests {
fn test_split_packet_multi() {
let ping_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_0),
17,
1,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
let action_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_1),
8,
0,
MessageTypeId::new(8, 0),
&[],
CreatorConfig::default(),
);
@@ -274,8 +289,7 @@ mod tests {
fn test_one_split_packet() {
let ping_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_0),
17,
1,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);

8
satrs/src/events_legacy.rs
View File

@@ -386,7 +386,7 @@ impl UnsignedEnum for EventU32 {
self.base.write_to_bytes(self.raw(), buf, self.size())
}
fn value(&self) -> u64 {
fn value_raw(&self) -> u64 {
self.raw().into()
}
}
@@ -445,7 +445,7 @@ impl<SEVERITY: HasSeverity> UnsignedEnum for EventU32TypedSev<SEVERITY> {
delegate!(to self.event {
fn size(&self) -> usize;
fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
fn value(&self) -> u64;
fn value_raw(&self) -> u64;
});
}
@@ -558,7 +558,7 @@ impl UnsignedEnum for EventU16 {
self.base.write_to_bytes(self.raw(), buf, self.size())
}
fn value(&self) -> u64 {
fn value_raw(&self) -> u64 {
self.raw().into()
}
}
@@ -611,7 +611,7 @@ impl<SEVERITY: HasSeverity> UnsignedEnum for EventU16TypedSev<SEVERITY> {
delegate!(to self.event {
fn size(&self) -> usize;
fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError>;
fn value(&self) -> u64;
fn value_raw(&self) -> u64;
});
}

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

@@ -241,7 +241,7 @@ mod tests {
use hashbrown::HashSet;
use spacepackets::{
CcsdsPacket, PacketId, SpHeader,
ecss::{CreatorConfig, WritablePusPacket, tc::PusTcCreator},
ecss::{CreatorConfig, MessageTypeId, WritablePusPacket, tc::PusTcCreator},
};
use crate::{
@@ -334,8 +334,7 @@ mod tests {
});
let ping_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_0),
17,
1,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
@@ -370,8 +369,7 @@ mod tests {
let mut total_tm_len = 0;
let verif_tm = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_0),
1,
1,
MessageTypeId::new(1, 1),
&[],
CreatorConfig::default(),
);
@@ -380,8 +378,7 @@ mod tests {
tm_source.add_tm(&tm_0);
let verif_tm = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_1),
1,
3,
MessageTypeId::new(1, 3),
&[],
CreatorConfig::default(),
);
@@ -431,8 +428,7 @@ mod tests {
// Send telecommands
let ping_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_0),
17,
1,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
@@ -442,8 +438,7 @@ mod tests {
.expect("writing to TCP server failed");
let action_tc = PusTcCreator::new_simple(
SpHeader::new_from_apid(TEST_APID_1),
8,
0,
MessageTypeId::new(8, 0),
&[],
CreatorConfig::default(),
);

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

@@ -26,7 +26,7 @@ use std::vec::Vec;
/// use satrs::ComponentId;
/// use satrs::tmtc::PacketHandler;
/// use spacepackets::SpHeader;
/// use spacepackets::ecss::tc::{PusTcCreator, CreatorConfig};
/// use spacepackets::ecss::tc::{MessageTypeId, PusTcCreator, CreatorConfig};
/// use arbitrary_int::u11;
///
/// const UDP_SERVER_ID: ComponentId = 0x05;
@@ -36,7 +36,7 @@ use std::vec::Vec;
/// let mut udp_tc_server = UdpTcServer::new(UDP_SERVER_ID, dest_addr, 2048, packet_sender)
/// .expect("Creating UDP TMTC server failed");
/// let sph = SpHeader::new_from_apid(u11::new(0x02));
/// let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
/// let pus_tc = PusTcCreator::new_simple(sph, MessageTypeId::new(17, 1), &[], CreatorConfig::default());
/// // Can not fail.
/// let ping_tc_raw = pus_tc.to_vec().unwrap();
///
@@ -131,8 +131,8 @@ mod tests {
use arbitrary_int::u11;
use core::cell::RefCell;
use spacepackets::SpHeader;
use spacepackets::ecss::CreatorConfig;
use spacepackets::ecss::tc::PusTcCreator;
use spacepackets::ecss::{CreatorConfig, MessageTypeId};
use std::collections::VecDeque;
use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
use std::vec::Vec;
@@ -169,7 +169,12 @@ mod tests {
.expect("Creating UDP TMTC server failed");
is_send(&udp_tc_server);
let sph = SpHeader::new_from_apid(u11::new(0x02));
let pus_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let pus_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
let len = pus_tc
.write_to_bytes(&mut buf)
.expect("Error writing PUS TC packet");

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

@@ -4,6 +4,7 @@ use spacepackets::ByteConversionError;
use spacepackets::SpHeader;
use spacepackets::ecss::CreatorConfig;
use spacepackets::ecss::EcssEnumeration;
use spacepackets::ecss::MessageTypeId;
use spacepackets::ecss::tm::PusTmCreator;
use spacepackets::ecss::tm::PusTmSecondaryHeader;
@@ -110,8 +111,12 @@ impl EventReportCreator {
src_data_len += aux_data.len();
}
source_buffer_large_enough(src_data_buf.len(), src_data_len)?;
let sec_header =
PusTmSecondaryHeader::new(5, subservice.into(), 0, self.dest_id, time_stamp);
let sec_header = PusTmSecondaryHeader::new(
MessageTypeId::new(5, subservice.into()),
0,
self.dest_id,
time_stamp,
);
let mut current_idx = 0;
event_id.write_to_be_bytes(&mut src_data_buf[0..event_id.size()])?;
current_idx += event_id.size();

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

@@ -409,8 +409,8 @@ mod tests {
assert!(res.params_were_propagated);
let event_tm = event_rx.try_recv().expect("no event received");
let tm = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
assert_eq!(tm.service(), 5);
assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
assert_eq!(tm.service_type_id(), 5);
assert_eq!(tm.message_subtype_id(), Subservice::TmInfoReport as u8);
assert_eq!(tm.user_data().len(), 4 + param_data.len());
let u32_event = u32::from_be_bytes(tm.user_data()[0..4].try_into().unwrap());
assert_eq!(u32_event, INFO_EVENT.raw());
@@ -437,8 +437,8 @@ mod tests {
assert!(res.params_were_propagated);
let event_tm = event_rx.try_recv().expect("no event received");
let tm = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
assert_eq!(tm.service(), 5);
assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
assert_eq!(tm.service_type_id(), 5);
assert_eq!(tm.message_subtype_id(), Subservice::TmInfoReport as u8);
assert_eq!(tm.user_data().len(), 4 + param_data.len());
let u32_event = u32::from_be_bytes(tm.user_data()[0..4].try_into().unwrap());
assert_eq!(u32_event, INFO_EVENT.raw());

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

@@ -60,11 +60,11 @@ impl<
.tc_in_mem_converter_mut()
.cache(&ecss_tc_and_token.tc_in_memory)?;
let tc = self.service_helper.tc_in_mem_converter().convert()?;
let subservice = tc.subservice();
let subservice = tc.message_subtype_id();
let srv = Subservice::try_from(subservice);
if srv.is_err() {
return Ok(DirectPusPacketHandlerResult::CustomSubservice(
tc.subservice(),
tc.message_subtype_id(),
ecss_tc_and_token.token,
));
}
@@ -121,7 +121,7 @@ impl<
| Subservice::TmMediumSeverityReport
| Subservice::TmHighSeverityReport => {
return Err(PusPacketHandlingError::RequestConversion(
GenericConversionError::WrongService(tc.subservice()),
GenericConversionError::WrongService(tc.message_subtype_id()),
));
}
Subservice::TcEnableEventGeneration => {
@@ -147,8 +147,8 @@ 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::ecss::{CreatorConfig, MessageTypeId};
use spacepackets::time::{TimeWriter, cds};
use spacepackets::util::UnsignedEnum;
use spacepackets::{
@@ -246,7 +246,7 @@ mod tests {
event_req_receiver: mpsc::Receiver<EventRequestWithToken>,
) {
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(5, subservice as u8);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(5, subservice as u8));
let mut app_data = [0; 4];
TEST_EVENT_0
.write_to_be_bytes(&mut app_data)
@@ -311,7 +311,7 @@ mod tests {
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, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(5, 200);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(5, 200));
let ping_tc =
PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc);
@@ -331,8 +331,10 @@ mod tests {
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, u14::ZERO, 0);
let sec_header =
PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
5,
Subservice::TcEnableEventGeneration as u8,
));
let ping_tc =
PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc);

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

@@ -1364,10 +1364,10 @@ pub mod tests {
let mut timestamp = [0; 7];
timestamp.clone_from_slice(&tm.timestamp()[0..7]);
Self {
subservice: PusPacket::subservice(tm),
subservice: PusPacket::message_subtype_id(tm),
apid: tm.apid(),
seq_count: tm.seq_count(),
msg_counter: tm.msg_counter(),
msg_counter: tm.msg_type_counter(),
dest_id: tm.dest_id(),
timestamp: timestamp.to_vec(),
}
@@ -1478,8 +1478,8 @@ pub mod tests {
let tm_pool = self.tm_pool.0.read().unwrap();
let tm_raw = tm_pool.read_as_vec(&tm_in_pool.store_addr).unwrap();
let tm = PusTmReader::new(&tm_raw, 7).unwrap();
assert_eq!(PusPacket::service(&tm), 1);
assert_eq!(PusPacket::subservice(&tm), subservice);
assert_eq!(PusPacket::service_type_id(&tm), 1);
assert_eq!(PusPacket::message_subtype_id(&tm), subservice);
assert_eq!(tm.apid(), TEST_APID);
let req_id =
RequestId::from_bytes(tm.user_data()).expect("generating request ID failed");
@@ -1597,8 +1597,8 @@ pub mod tests {
assert!(next_msg.is_ok());
let next_msg = next_msg.unwrap();
let tm = PusTmReader::new(next_msg.packet.as_slice(), 7).unwrap();
assert_eq!(PusPacket::service(&tm), 1);
assert_eq!(PusPacket::subservice(&tm), subservice);
assert_eq!(PusPacket::service_type_id(&tm), 1);
assert_eq!(PusPacket::message_subtype_id(&tm), subservice);
assert_eq!(tm.apid(), TEST_APID);
let req_id =
RequestId::from_bytes(tm.user_data()).expect("generating request ID failed");
@@ -1615,9 +1615,9 @@ pub mod tests {
impl<const SERVICE: u8> TestConverter<SERVICE> {
pub fn check_service(&self, tc: &PusTcReader) -> Result<(), PusPacketHandlingError> {
if tc.service() != SERVICE {
if tc.service_type_id() != SERVICE {
return Err(PusPacketHandlingError::RequestConversion(
GenericConversionError::WrongService(tc.service()),
GenericConversionError::WrongService(tc.service_type_id()),
));
}
Ok(())

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

@@ -272,14 +272,16 @@ pub trait PusSchedulerProvider {
pus_tc: &(impl IsPusTelecommand + PusPacket + GenericPusTcSecondaryHeader),
pool: &mut (impl PoolProvider + ?Sized),
) -> Result<TcInfo, ScheduleError> {
if PusPacket::service(pus_tc) != 11 {
return Err(ScheduleError::WrongService(PusPacket::service(pus_tc)));
}
if PusPacket::subservice(pus_tc) != 4 {
return Err(ScheduleError::WrongSubservice(PusPacket::subservice(
if PusPacket::service_type_id(pus_tc) != 11 {
return Err(ScheduleError::WrongService(PusPacket::service_type_id(
pus_tc,
)));
}
if PusPacket::message_subtype_id(pus_tc) != 4 {
return Err(ScheduleError::WrongSubservice(
PusPacket::message_subtype_id(pus_tc),
));
}
if pus_tc.user_data().is_empty() {
return Err(ScheduleError::TcDataEmpty);
}
@@ -299,7 +301,9 @@ pub trait PusSchedulerProvider {
pool: &mut (impl PoolProvider + ?Sized),
) -> Result<TcInfo, ScheduleError> {
let check_tc = PusTcReader::new(tc)?;
if PusPacket::service(&check_tc) == 11 && PusPacket::subservice(&check_tc) == 4 {
if PusPacket::service_type_id(&check_tc) == 11
&& PusPacket::message_subtype_id(&check_tc) == 4
{
return Err(ScheduleError::NestedScheduledTc);
}
let req_id = RequestId::from_tc(&check_tc);
@@ -487,7 +491,9 @@ pub mod alloc_mod {
pool: &mut (impl PoolProvider + ?Sized),
) -> Result<TcInfo, ScheduleError> {
let check_tc = PusTcReader::new(tc)?;
if PusPacket::service(&check_tc) == 11 && PusPacket::subservice(&check_tc) == 4 {
if PusPacket::service_type_id(&check_tc) == 11
&& PusPacket::message_subtype_id(&check_tc) == 4
{
return Err(ScheduleError::NestedScheduledTc);
}
let req_id = RequestId::from_tc(&check_tc);
@@ -865,7 +871,7 @@ mod tests {
use arbitrary_int::traits::Integer;
use arbitrary_int::{u11, u14};
use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
use spacepackets::ecss::{CreatorConfig, MessageTypeId, WritablePusPacket};
use spacepackets::time::{TimeWriter, UnixTime, cds};
use spacepackets::{PacketId, PacketSequenceControl, PacketType, SequenceFlags, SpHeader};
use std::time::Duration;
@@ -889,17 +895,32 @@ mod tests {
fn scheduled_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
let (sph, len_app_data) = pus_tc_base(timestamp, buf);
PusTcCreator::new_simple(sph, 11, 4, &buf[..len_app_data], CreatorConfig::default())
PusTcCreator::new_simple(
sph,
MessageTypeId::new(11, 4),
&buf[..len_app_data],
CreatorConfig::default(),
)
}
fn wrong_tc_service(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
let (sph, len_app_data) = pus_tc_base(timestamp, buf);
PusTcCreator::new_simple(sph, 12, 4, &buf[..len_app_data], CreatorConfig::default())
PusTcCreator::new_simple(
sph,
MessageTypeId::new(12, 4),
&buf[..len_app_data],
CreatorConfig::default(),
)
}
fn wrong_tc_subservice(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
let (sph, len_app_data) = pus_tc_base(timestamp, buf);
PusTcCreator::new_simple(sph, 11, 5, &buf[..len_app_data], CreatorConfig::default())
PusTcCreator::new_simple(
sph,
MessageTypeId::new(11, 5),
&buf[..len_app_data],
CreatorConfig::default(),
)
}
fn double_wrapped_time_tagged_tc(timestamp: UnixTime, buf: &mut [u8]) -> PusTcCreator<'_> {
@@ -910,15 +931,18 @@ mod tests {
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
// away
let inner_time_tagged_tc =
PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default());
let inner_time_tagged_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(11, 4),
&[],
CreatorConfig::default(),
);
let packet_len = inner_time_tagged_tc
.write_to_bytes(&mut buf[len_time_stamp..])
.expect("writing inner time tagged tc failed");
PusTcCreator::new_simple(
sph,
11,
4,
MessageTypeId::new(11, 4),
&buf[..len_time_stamp + packet_len],
CreatorConfig::default(),
)
@@ -926,12 +950,22 @@ mod tests {
fn invalid_time_tagged_cmd() -> PusTcCreator<'static> {
let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), u14::new(0x34), 1);
PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default())
PusTcCreator::new_simple(
sph,
MessageTypeId::new(11, 4),
&[],
CreatorConfig::default(),
)
}
fn base_ping_tc_simple_ctor(seq_count: u14, app_data: &'static [u8]) -> PusTcCreator<'static> {
let sph = SpHeader::new_for_unseg_tc(u11::new(0x02), seq_count, 0);
PusTcCreator::new_simple(sph, 17, 1, app_data, CreatorConfig::default())
PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
app_data,
CreatorConfig::default(),
)
}
fn ping_tc_to_store(
@@ -1096,7 +1130,7 @@ mod tests {
let apid_to_set = u11::new(0x22);
let seq_count = u14::new(105);
let sp_header = SpHeader::new_for_unseg_tc(apid_to_set, u14::new(105), 0);
let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let mut sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
sec_header.source_id = src_id_to_set;
let ping_tc =
PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
@@ -2047,7 +2081,7 @@ mod tests {
PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
0,
);
let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
let mut buf: [u8; 64] = [0; 64];
let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc);
@@ -2069,7 +2103,7 @@ mod tests {
PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
0,
);
let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
let mut buf: [u8; 16] = [0; 16];
let result = generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc);
@@ -2098,7 +2132,7 @@ mod tests {
PacketSequenceControl::new(SequenceFlags::Unsegmented, u14::new(5)),
0,
);
let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
let ping_tc = PusTcCreator::new_no_app_data(sph, sec_header, CreatorConfig::default());
let mut buf: [u8; 64] = [0; 64];
generate_insert_telecommand_app_data(&mut buf, &time_writer, &ping_tc).unwrap();

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

@@ -79,7 +79,7 @@ impl<
.tc_in_mem_converter_mut()
.cache(&ecss_tc_and_token.tc_in_memory)?;
let tc = self.service_helper.tc_in_mem_converter().convert()?;
let subservice = PusPacket::subservice(&tc);
let subservice = PusPacket::message_subtype_id(&tc);
let standard_subservice = scheduling::Subservice::try_from(subservice);
if standard_subservice.is_err() {
return Ok(DirectPusPacketHandlerResult::CustomSubservice(
@@ -266,7 +266,7 @@ mod tests {
use spacepackets::SpHeader;
use spacepackets::ecss::scheduling::Subservice;
use spacepackets::ecss::tc::PusTcSecondaryHeader;
use spacepackets::ecss::{CreatorConfig, WritablePusPacket};
use spacepackets::ecss::{CreatorConfig, MessageTypeId, WritablePusPacket};
use spacepackets::time::TimeWriter;
use spacepackets::{
ecss::{tc::PusTcCreator, tm::PusTmReader},
@@ -389,7 +389,7 @@ mod tests {
subservice: Subservice,
) {
let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, u14::ZERO, 0);
let tc_header = PusTcSecondaryHeader::new_simple(11, subservice as u8);
let tc_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(11, subservice as u8));
let enable_scheduling =
PusTcCreator::new(reply_header, tc_header, &[0; 7], CreatorConfig::default());
let token = test_harness.start_verification(&enable_scheduling);
@@ -437,7 +437,7 @@ mod tests {
fn test_insert_activity_tc() {
let mut test_harness = Pus11HandlerWithStoreTester::new();
let mut reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let mut sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let mut sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
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");
@@ -447,7 +447,10 @@ mod tests {
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, u14::ZERO, 0);
sec_header = PusTcSecondaryHeader::new_simple(11, Subservice::TcInsertActivity as u8);
sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
11,
Subservice::TcInsertActivity as u8,
));
let enable_scheduling = PusTcCreator::new(
reply_header,
sec_header,

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

@@ -6,7 +6,7 @@ use arbitrary_int::traits::Integer as _;
use arbitrary_int::u14;
use spacepackets::SpHeader;
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use spacepackets::ecss::{CreatorConfig, PusPacket};
use spacepackets::ecss::{CreatorConfig, MessageTypeId, PusPacket};
use std::sync::mpsc;
use super::verification::{VerificationReporter, VerificationReportingProvider};
@@ -59,10 +59,10 @@ impl<
.tc_in_mem_converter_mut()
.cache(&ecss_tc_and_token.tc_in_memory)?;
let tc = self.service_helper.tc_in_mem_converter().convert()?;
if tc.service() != 17 {
return Err(GenericConversionError::WrongService(tc.service()).into());
if tc.service_type_id() != 17 {
return Err(GenericConversionError::WrongService(tc.service_type_id()).into());
}
if tc.subservice() == 1 {
if tc.message_subtype_id() == 1 {
let opt_started_token = match self.service_helper.verif_reporter().start_success(
&self.service_helper.common.tm_sender,
ecss_tc_and_token.token,
@@ -82,7 +82,7 @@ impl<
u14::ZERO,
0,
);
let tc_header = PusTmSecondaryHeader::new_simple(17, 2, time_stamp);
let tc_header = PusTmSecondaryHeader::new_simple(MessageTypeId::new(17, 2), time_stamp);
let ping_reply =
PusTmCreator::new(reply_header, tc_header, &[], CreatorConfig::default());
if let Err(e) = self
@@ -104,7 +104,7 @@ impl<
}
} else {
return Ok(DirectPusPacketHandlerResult::CustomSubservice(
tc.subservice(),
tc.message_subtype_id(),
ecss_tc_and_token.token,
));
}
@@ -160,7 +160,7 @@ mod tests {
use spacepackets::SpHeader;
use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader};
use spacepackets::ecss::tm::PusTmReader;
use spacepackets::ecss::{CreatorConfig, PusPacket};
use spacepackets::ecss::{CreatorConfig, MessageTypeId, PusPacket};
use spacepackets::time::{TimeWriter, cds};
use super::PusService17TestHandler;
@@ -292,7 +292,7 @@ mod tests {
fn ping_test(test_harness: &mut (impl PusTestHarness + SimplePusPacketHandler)) {
// Create a ping TC, verify acceptance.
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
let ping_tc =
PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc);
@@ -311,8 +311,8 @@ mod tests {
// Ping reply
let tm = test_harness.read_next_tm();
assert_eq!(tm.service(), 17);
assert_eq!(tm.subservice(), 2);
assert_eq!(tm.service_type_id(), 17);
assert_eq!(tm.message_subtype_id(), 2);
assert!(tm.user_data().is_empty());
// TM completion
@@ -348,7 +348,7 @@ mod tests {
fn test_sending_unsupported_service() {
let mut test_harness = Pus17HandlerWithStoreTester::new(0);
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(3, 1);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(3, 1));
let ping_tc =
PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc);
@@ -370,7 +370,7 @@ mod tests {
fn test_sending_custom_subservice() {
let mut test_harness = Pus17HandlerWithStoreTester::new(0);
let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let sec_header = PusTcSecondaryHeader::new_simple(17, 200);
let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 200));
let ping_tc =
PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let token = test_harness.start_verification(&ping_tc);

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

@@ -23,7 +23,7 @@
//! use satrs::request::UniqueApidTargetId;
//! use spacepackets::ecss::PusPacket;
//! use spacepackets::SpHeader;
//! use spacepackets::ecss::tc::{PusTcCreator, PusTcSecondaryHeader, CreatorConfig};
//! use spacepackets::ecss::tc::{MessageTypeId, PusTcCreator, PusTcSecondaryHeader, CreatorConfig};
//! use spacepackets::ecss::tm::PusTmReader;
//! use arbitrary_int::{u11, u21};
//!
@@ -41,7 +41,7 @@
//! let cfg = VerificationReporterConfig::new(TEST_APID, 1, 2, 8);
//! let mut reporter = VerificationReporter::new(TEST_COMPONENT_ID.id(), &cfg);
//!
//! let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
//! let tc_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
//! let pus_tc_0 = PusTcCreator::new_no_app_data(
//! SpHeader::new_from_apid(TEST_APID),
//! tc_header,
@@ -67,11 +67,11 @@
//! }
//! let pus_tm = PusTmReader::new(&tm_buf[0..tm_len], 7).expect("Error reading verification TM");
//! if packet_idx == 0 {
//! assert_eq!(pus_tm.subservice(), 1);
//! assert_eq!(pus_tm.message_subtype_id(), 1);
//! } else if packet_idx == 1 {
//! assert_eq!(pus_tm.subservice(), 3);
//! assert_eq!(pus_tm.message_subtype_id(), 3);
//! } else if packet_idx == 2 {
//! assert_eq!(pus_tm.subservice(), 7);
//! assert_eq!(pus_tm.message_subtype_id(), 7);
//! }
//! packet_idx += 1;
//! }
@@ -94,7 +94,7 @@ use serde::{Deserialize, Serialize};
use spacepackets::SpHeader;
use spacepackets::ecss::tc::IsPusTelecommand;
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use spacepackets::ecss::{CreatorConfig, EcssEnumeration};
use spacepackets::ecss::{CreatorConfig, EcssEnumeration, MessageTypeId};
use spacepackets::{ByteConversionError, CcsdsPacket, PacketId, PacketSequenceControl};
pub use spacepackets::ecss::verification::*;
@@ -820,8 +820,12 @@ impl VerificationReportCreator {
time_stamp: &'time [u8],
source_data_len: usize,
) -> PusTmCreator<'time, 'src_data> {
let tm_sec_header =
PusTmSecondaryHeader::new(1, subservice, msg_counter, self.dest_id, time_stamp);
let tm_sec_header = PusTmSecondaryHeader::new(
MessageTypeId::new(1, subservice),
msg_counter,
self.dest_id,
time_stamp,
);
PusTmCreator::new(
sp_header,
tm_sec_header,
@@ -1423,7 +1427,7 @@ pub mod test_util {
token.request_id(),
VerificationReportInfo::AcceptanceFailure(FailureData {
sender: self.owner_id(),
error_enum: params.failure_code.value(),
error_enum: params.failure_code.value_raw(),
fail_data: params.failure_data.to_vec(),
time_stamp: params.time_stamp.to_vec(),
}),
@@ -1460,7 +1464,7 @@ pub mod test_util {
token.request_id(),
VerificationReportInfo::StartedFailure(FailureData {
sender: self.owner_id(),
error_enum: params.failure_code.value(),
error_enum: params.failure_code.value_raw(),
fail_data: params.failure_data.to_vec(),
time_stamp: params.time_stamp.to_vec(),
}),
@@ -1482,7 +1486,7 @@ pub mod test_util {
sender: self.owner_id(),
time_stamp: time_stamp.to_vec(),
},
step: step.value() as u16,
step: step.value_raw() as u16,
},
));
Ok(())
@@ -1498,7 +1502,7 @@ pub mod test_util {
token.request_id(),
VerificationReportInfo::StepFailure(FailureData {
sender: self.owner_id(),
error_enum: params.common.failure_code.value(),
error_enum: params.common.failure_code.value_raw(),
fail_data: params.common.failure_data.to_vec(),
time_stamp: params.common.time_stamp.to_vec(),
}),
@@ -1532,7 +1536,7 @@ pub mod test_util {
token.request_id(),
VerificationReportInfo::CompletionFailure(FailureData {
sender: self.owner_id(),
error_enum: params.failure_code.value(),
error_enum: params.failure_code.value_raw(),
fail_data: params.failure_data.to_vec(),
time_stamp: params.time_stamp.to_vec(),
}),
@@ -1727,8 +1731,8 @@ pub mod tests {
use arbitrary_int::{u11, u14};
use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
use spacepackets::ecss::{
CreatorConfig, EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, PusError, PusPacket,
WritablePusPacket,
CreatorConfig, EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, MessageTypeId,
PusError, PusPacket, WritablePusPacket,
};
use spacepackets::util::UnsignedEnum;
use spacepackets::{ByteConversionError, SpHeader};
@@ -1779,7 +1783,7 @@ pub mod tests {
panic!("TestSender: Can not deal with addresses");
}
PusTmVariant::Direct(tm) => {
assert_eq!(PusPacket::service(&tm), 1);
assert_eq!(PusPacket::service_type_id(&tm), 1);
assert!(!tm.source_data().is_empty());
let mut time_stamp = [0; 7];
time_stamp.clone_from_slice(&tm.timestamp()[0..7]);
@@ -2098,7 +2102,7 @@ pub mod tests {
fn create_generic_ping() -> PusTcCreator<'static> {
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(MessageTypeId::new(17, 1));
PusTcCreator::new(sph, tc_header, &[], CreatorConfig::default())
}

12
satrs/src/request.rs
View File

@@ -501,7 +501,7 @@ mod tests {
use spacepackets::{
ByteConversionError, SpHeader,
ecss::{
CreatorConfig,
CreatorConfig, MessageTypeId,
tc::{PusTcCreator, PusTcSecondaryHeader},
},
};
@@ -540,8 +540,12 @@ mod tests {
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 app_data = 1_u32.to_be_bytes();
let pus_tc =
PusTcCreator::new_simple(sp_header, 17, 1, &app_data, CreatorConfig::default());
let pus_tc = PusTcCreator::new_simple(
sp_header,
MessageTypeId::new(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.value(), 1);
@@ -550,7 +554,7 @@ mod tests {
#[test]
fn test_basic_target_id_with_apid_from_pus_tc_invalid_app_data() {
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(MessageTypeId::new(17, 1));
let pus_tc = PusTcCreator::new_no_app_data(sp_header, sec_header, CreatorConfig::default());
let error = UniqueApidTargetId::from_pus_tc(&pus_tc);
assert!(error.is_err());

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

@@ -1,7 +1,7 @@
use arbitrary_int::{u11, u14};
use spacepackets::SpHeader;
use spacepackets::ecss::CreatorConfig;
use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
use spacepackets::ecss::{CreatorConfig, MessageTypeId};
use spacepackets::time::cds::CdsTime;
pub struct PusTmWithCdsShortHelper {
@@ -50,7 +50,10 @@ impl PusTmWithCdsShortHelper {
seq_count: u14,
) -> 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);
let tc_header = PusTmSecondaryHeader::new_simple(
MessageTypeId::new(service, subservice),
&self.cds_short_buf,
);
PusTmCreator::new(
reply_header,
tc_header,
@@ -73,8 +76,8 @@ mod tests {
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));
assert_eq!(tm.service(), 17);
assert_eq!(tm.subservice(), 1);
assert_eq!(tm.service_type_id(), 17);
assert_eq!(tm.message_subtype_id(), 1);
assert_eq!(tm.user_data(), &[1, 2, 3, 4]);
assert_eq!(tm.seq_count().value(), 25);
assert_eq!(tm.timestamp(), [64, 0, 0, 0, 0, 0, 0])
@@ -84,8 +87,8 @@ mod tests {
fn test_helper_from_now() {
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], u14::new(25));
assert_eq!(tm.service(), 17);
assert_eq!(tm.subservice(), 1);
assert_eq!(tm.service_type_id(), 17);
assert_eq!(tm.message_subtype_id(), 1);
assert_eq!(tm.user_data(), &[1, 2, 3, 4]);
assert_eq!(tm.seq_count().value(), 25);
assert_eq!(tm.timestamp().len(), 7);

8
satrs/tests/pus_events.rs
View File

@@ -107,8 +107,8 @@ fn test_threaded_usage() {
Ok(event_tm) => {
let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
.expect("Deserializing TM failed");
assert_eq!(tm.service(), 5);
assert_eq!(tm.subservice(), 1);
assert_eq!(tm.service_type_id(), 5);
assert_eq!(tm.message_subtype_id(), 1);
let src_data = tm.source_data();
assert!(!src_data.is_empty());
assert_eq!(src_data.len(), 4);
@@ -137,8 +137,8 @@ fn test_threaded_usage() {
Ok(event_tm) => {
let tm = PusTmReader::new(event_tm.packet.as_slice(), 7)
.expect("Deserializing TM failed");
assert_eq!(tm.service(), 5);
assert_eq!(tm.subservice(), 2);
assert_eq!(tm.service_type_id(), 5);
assert_eq!(tm.message_subtype_id(), 2);
let src_data = tm.source_data();
assert!(!src_data.is_empty());
assert_eq!(src_data.len(), 12);

12
satrs/tests/pus_verification.rs
View File

@@ -13,7 +13,9 @@ pub mod crossbeam_test {
use spacepackets::SpHeader;
use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
use spacepackets::ecss::tm::PusTmReader;
use spacepackets::ecss::{CreatorConfig, EcssEnumU8, EcssEnumU16, WritablePusPacket};
use spacepackets::ecss::{
CreatorConfig, EcssEnumU8, EcssEnumU16, MessageTypeId, WritablePusPacket,
};
use std::sync::RwLock;
use std::thread;
use std::time::Duration;
@@ -60,7 +62,7 @@ pub mod crossbeam_test {
{
let mut tc_guard = shared_tc_pool.write().unwrap();
let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
let tc_header = PusTcSecondaryHeader::new_simple(17, 1);
let tc_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(17, 1));
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
@@ -70,7 +72,7 @@ pub mod crossbeam_test {
.unwrap();
tx_tc_0.send(addr).unwrap();
let sph = SpHeader::new_for_unseg_tc(TEST_APID, u14::new(1), 0);
let tc_header = PusTcSecondaryHeader::new_simple(5, 1);
let tc_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(5, 1));
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
@@ -164,11 +166,11 @@ pub mod crossbeam_test {
RequestId::from_bytes(&pus_tm.source_data()[0..RequestId::SIZE_AS_BYTES])
.expect("reading request ID from PUS TM source data failed");
if !verif_map.contains_key(&req_id) {
let content = vec![pus_tm.subservice()];
let content = vec![pus_tm.service_type_id()];
verif_map.insert(req_id, content);
} else {
let content = verif_map.get_mut(&req_id).unwrap();
content.push(pus_tm.subservice())
content.push(pus_tm.message_subtype_id())
}
packet_counter += 1;
}

12
satrs/tests/tcp_servers.rs
View File

@@ -40,7 +40,7 @@ use satrs::{
};
use spacepackets::{
CcsdsPacket, PacketId, SpHeader,
ecss::{CreatorConfig, WritablePusPacket, tc::PusTcCreator},
ecss::{CreatorConfig, MessageTypeId, WritablePusPacket, tc::PusTcCreator},
};
use std::{collections::VecDeque, sync::Arc, vec::Vec};
@@ -222,7 +222,8 @@ 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, u14::new(0), 0);
let verif_tm = PusTcCreator::new_simple(sph, 1, 1, &[], CreatorConfig::default());
let verif_tm =
PusTcCreator::new_simple(sph, MessageTypeId::new(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();
@@ -271,7 +272,12 @@ fn test_ccsds_server() {
// Send ping telecommand.
let sph = SpHeader::new_for_unseg_tc(TEST_APID_0, u14::new(0), 0);
let ping_tc = PusTcCreator::new_simple(sph, 17, 1, &[], CreatorConfig::default());
let ping_tc = PusTcCreator::new_simple(
sph,
MessageTypeId::new(17, 1),
&[],
CreatorConfig::default(),
);
let tc_0 = ping_tc.to_vec().expect("packet creation failed");
stream
.write_all(&tc_0)