update spacepackets

embedded-examples/embedded-client/Cargo.toml

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

embedded-examples/embedded-client/src/main.rs

@@ -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);
+        let tc = create_stm32f3_tc(&request);
-        log::info!("Sending ping request");
+        log::info!(
-        serial.write_all(&tc_encoded_raw).unwrap();
+            "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);
+        let tc = create_stm32f3_tc(&request);
-        log::info!("Sending change blink frequency request: {:?}", request);
+        log::info!(
-        serial.write_all(&tc_encoded_raw).unwrap();
+            "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];
+        transport
-        let received_bytes = serial.read(&mut reception_buffer);
+            .receive(|packet: &[u8]| {
-        match received_bytes {
+                let reader = CcsdsPacketReader::new_with_checksum(packet);
-            Ok(0) => {
+                log::info!("Received packet: {:?}", reader);
-                std::thread::sleep(std::time::Duration::from_millis(100));
+            })
-            }
+            .unwrap();
-            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));
-            }
-        }
     }
 }
 
-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();
+    CcsdsPacketCreatorOwned::new_tc_with_checksum(sp_header, &req_raw).unwrap()
-    let tc_raw = ccsds_tc_packet.to_vec();
-    cobs::encode_vec_including_sentinels(&tc_raw)
 }

embedded-examples/stm32f3-disco-rtic/Cargo.lock

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

embedded-examples/stm32f3-disco-rtic/src/lib.rs

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

satrs-example/src/bin/simpleclient.rs

@@ -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,
+        MessageTypeId::new(17, 1),
-        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.service_type_id(),
-                        pus_tm.subservice(),
+                        pus_tm.message_subtype_id(),
                         size
                     );
                 }

satrs-example/src/hk.rs

@@ -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 =
+        let sec_header = PusTmSecondaryHeader::new(
-            PusTmSecondaryHeader::new(3, hk::Subservice::TmHkPacket as u8, 0, 0, timestamp);
+            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);

satrs-example/src/interface/udp.rs

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

satrs-example/src/pus/action.rs

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

satrs-example/src/pus/hk.rs

@@ -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,
+            MessageTypeId::new(3, Subservice::TcGenerateOneShotHk as u8),
-            Subservice::TcGenerateOneShotHk as u8,
             &app_data,
             CreatorConfig::default(),
         );
@@ -380,16 +379,14 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            3,
+            MessageTypeId::new(3, Subservice::TcEnableHkGeneration as u8),
-            Subservice::TcEnableHkGeneration as u8,
             &app_data,
             CreatorConfig::default(),
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            3,
+            MessageTypeId::new(3, Subservice::TcEnableDiagGeneration as u8),
-            Subservice::TcEnableDiagGeneration as u8,
             &app_data,
             CreatorConfig::default(),
         );
@@ -419,16 +416,14 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            3,
+            MessageTypeId::new(3, Subservice::TcDisableHkGeneration as u8),
-            Subservice::TcDisableHkGeneration as u8,
             &app_data,
             CreatorConfig::default(),
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            3,
+            MessageTypeId::new(3, Subservice::TcDisableDiagGeneration as u8),
-            Subservice::TcDisableDiagGeneration as u8,
             &app_data,
             CreatorConfig::default(),
         );
@@ -462,16 +457,14 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            3,
+            MessageTypeId::new(3, Subservice::TcModifyHkCollectionInterval as u8),
-            Subservice::TcModifyHkCollectionInterval as u8,
             &app_data,
             CreatorConfig::default(),
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            3,
+            MessageTypeId::new(3, Subservice::TcModifyDiagCollectionInterval as u8),
-            Subservice::TcModifyDiagCollectionInterval as u8,
             &app_data,
             CreatorConfig::default(),
         );

satrs-example/src/pus/mod.rs

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

satrs-example/src/pus/mode.rs

@@ -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 =
+                let sec_header = PusTmSecondaryHeader::new(
-                    PusTmSecondaryHeader::new(200, Subservice::TmModeReply as u8, 0, 0, time_stamp);
+                    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 =
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
-            PusTcSecondaryHeader::new_simple(200, Subservice::TcAnnounceModeRecursive as u8);
+            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());

satrs-example/src/pus/test.rs

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

satrs-example/src/requests.rs

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

satrs-example/src/tmtc/tm_sink.rs

@@ -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.service_type_id(),
-            tm.subservice(),
+            tm.message_subtype_id(),
             tm.apid()
         );
     }

satrs-shared/Cargo.toml

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

satrs-shared/src/res_code.rs

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

satrs/src/encoding/ccsds.rs

@@ -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 ping_tc = PusTcCreator::new_simple(
-        let action_tc = PusTcCreator::new_simple(sph, 8, 0, &[], CreatorConfig::default());
+            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,
+            MessageTypeId::new(17, 1),
-            1,
             &[],
             CreatorConfig::default(),
         );
         let action_tc = PusTcCreator::new_simple(
             SpHeader::new_from_apid(TEST_APID_1),
-            8,
+            MessageTypeId::new(8, 0),
-            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,
+            MessageTypeId::new(17, 1),
-            1,
             &[],
             CreatorConfig::default(),
         );

satrs/src/events_legacy.rs

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

satrs/src/hal/std/tcp_spacepackets_server.rs

@@ -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,
+            MessageTypeId::new(17, 1),
-            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,
+            MessageTypeId::new(1, 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,
+            MessageTypeId::new(1, 3),
-            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,
+            MessageTypeId::new(17, 1),
-            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,
+            MessageTypeId::new(8, 0),
-            0,
             &[],
             CreatorConfig::default(),
         );

satrs/src/hal/std/udp_server.rs

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

satrs/src/pus/event.rs

@@ -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 =
+        let sec_header = PusTmSecondaryHeader::new(
-            PusTmSecondaryHeader::new(5, subservice.into(), 0, self.dest_id, time_stamp);
+            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();

satrs/src/pus/event_man.rs

@@ -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.service_type_id(), 5);
-        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
+        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.service_type_id(), 5);
-        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
+        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());

satrs/src/pus/event_srv.rs

@@ -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 =
+        let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
-            PusTcSecondaryHeader::new_simple(5, Subservice::TcEnableEventGeneration as u8);
+            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);

satrs/src/pus/mod.rs

@@ -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::service_type_id(&tm), 1);
-            assert_eq!(PusPacket::subservice(&tm), subservice);
+            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::service_type_id(&tm), 1);
-            assert_eq!(PusPacket::subservice(&tm), subservice);
+            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(())

satrs/src/pus/scheduler.rs

@@ -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 {
+        if PusPacket::service_type_id(pus_tc) != 11 {
-            return Err(ScheduleError::WrongService(PusPacket::service(pus_tc)));
+            return Err(ScheduleError::WrongService(PusPacket::service_type_id(
-        }
-        if PusPacket::subservice(pus_tc) != 4 {
-            return Err(ScheduleError::WrongSubservice(PusPacket::subservice(
                 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 =
+        let inner_time_tagged_tc = PusTcCreator::new_simple(
-            PusTcCreator::new_simple(sph, 11, 4, &[], CreatorConfig::default());
+            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,
+            MessageTypeId::new(11, 4),
-            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();

satrs/src/pus/scheduler_srv.rs

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

satrs/src/pus/test.rs

@@ -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 {
+        if tc.service_type_id() != 17 {
-            return Err(GenericConversionError::WrongService(tc.service()).into());
+            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.service_type_id(), 17);
-        assert_eq!(tm.subservice(), 2);
+        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);

satrs/src/pus/verification.rs

@@ -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 =
+        let tm_sec_header = PusTmSecondaryHeader::new(
-            PusTmSecondaryHeader::new(1, subservice, msg_counter, self.dest_id, time_stamp);
+            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,
+        CreatorConfig, EcssEnumU8, EcssEnumU16, EcssEnumU32, EcssEnumeration, MessageTypeId,
-        WritablePusPacket,
+        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())
     }
 

satrs/src/request.rs

@@ -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 =
+        let pus_tc = PusTcCreator::new_simple(
-            PusTcCreator::new_simple(sp_header, 17, 1, &app_data, CreatorConfig::default());
+            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());

satrs/src/tmtc/tm_helper.rs

@@ -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.service_type_id(), 17);
-        assert_eq!(tm.subservice(), 1);
+        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.service_type_id(), 17);
-        assert_eq!(tm.subservice(), 1);
+        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);

satrs/tests/pus_events.rs

@@ -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.service_type_id(), 5);
-                    assert_eq!(tm.subservice(), 1);
+                    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.service_type_id(), 5);
-                    assert_eq!(tm.subservice(), 2);
+                    assert_eq!(tm.message_subtype_id(), 2);
                     let src_data = tm.source_data();
                     assert!(!src_data.is_empty());
                     assert_eq!(src_data.len(), 12);

satrs/tests/pus_verification.rs

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

satrs/tests/tcp_servers.rs

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