bumped spacepackets version

embedded-examples/embedded-client/Cargo.toml

@@ -9,7 +9,7 @@ serialport = "4"
 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" }
+spacepackets = { 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"

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

@@ -9,7 +9,7 @@ use clap::Parser;
 use cobs::CobsDecoderOwned;
 use satrs_stm32f3_disco_rtic::Request;
 use spacepackets::{CcsdsPacketCreatorOwned, CcsdsPacketReader, SpHeader};
-use tmtc_utils::transport::{PacketTransport, serial::PacketTransportSerialCobs};
+use tmtc_utils::transport::serial::PacketTransportSerialCobs;
 
 #[derive(Parser, Debug)]
 struct Cli {

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

@@ -17,7 +17,7 @@ cortex-m-semihosting = "0.5.0"
 embassy-stm32 = { version = "0.4", features = ["defmt", "stm32f303vc", "unstable-pac"] }
 enumset = "1"
 heapless = "0.9"
-spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false, features = ["defmt", "serde"] }
+spacepackets = { version = "0.17", default-features = false, features = ["defmt", "serde"] }
 static_cell = "2"
 cobs = { version = "0.5", default-features = false, features = ["defmt"] }
 postcard = { version = "1" }

justfile

@@ -1,4 +1,4 @@
-all: check build embedded test fmt clippy docs
+all: check build embedded test check-fmt clippy docs
 
 check:
   cargo check
@@ -15,6 +15,9 @@ embedded:
   cargo check -p satrs --target=thumbv7em-none-eabihf --no-default-features
 
 fmt:
+  cargo fmt --all
+
+check-fmt:
   cargo fmt --all -- --check
 
 clippy:

satrs-example/src/hk.rs

@@ -55,7 +55,7 @@ impl PusHkHelper {
         buf: &'b mut [u8],
     ) -> Result<PusTmCreator<'a, 'b>, ByteConversionError> {
         let sec_header = PusTmSecondaryHeader::new(
-            MessageTypeId::new(3, hk::Subservice::TmHkPacket as u8),
+            MessageTypeId::new(3, hk::MessageSubtypeId::TmHkPacket as u8),
             0,
             0,
             timestamp,

satrs-example/src/pus/hk.rs

@@ -168,7 +168,7 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
         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());
 
-        let standard_subservice = hk::Subservice::try_from(subservice);
+        let standard_subservice = hk::MessageSubtypeId::try_from(subservice);
         if standard_subservice.is_err() {
             verif_reporter
                 .start_failure(
@@ -180,19 +180,22 @@ impl PusTcToRequestConverter<ActivePusRequestStd, HkRequest> for HkRequestConver
             return Err(GenericConversionError::InvalidSubservice(subservice));
         }
         let request = match standard_subservice.unwrap() {
-            hk::Subservice::TcEnableHkGeneration | hk::Subservice::TcEnableDiagGeneration => {
+            hk::MessageSubtypeId::TcEnableHkGeneration
+            | hk::MessageSubtypeId::TcEnableDiagGeneration => {
                 HkRequest::new(unique_id, HkRequestVariant::EnablePeriodic)
             }
-            hk::Subservice::TcDisableHkGeneration | hk::Subservice::TcDisableDiagGeneration => {
+            hk::MessageSubtypeId::TcDisableHkGeneration
+            | hk::MessageSubtypeId::TcDisableDiagGeneration => {
                 HkRequest::new(unique_id, HkRequestVariant::DisablePeriodic)
             }
-            hk::Subservice::TcReportHkReportStructures => todo!(),
+            hk::MessageSubtypeId::TcReportHkReportStructures => todo!(),
-            hk::Subservice::TmHkPacket => todo!(),
+            hk::MessageSubtypeId::TmHkPacket => todo!(),
-            hk::Subservice::TcGenerateOneShotHk | hk::Subservice::TcGenerateOneShotDiag => {
+            hk::MessageSubtypeId::TcGenerateOneShotHk
+            | hk::MessageSubtypeId::TcGenerateOneShotDiag => {
                 HkRequest::new(unique_id, HkRequestVariant::OneShot)
             }
-            hk::Subservice::TcModifyDiagCollectionInterval
+            hk::MessageSubtypeId::TcModifyDiagCollectionInterval
-            | hk::Subservice::TcModifyHkCollectionInterval => {
+            | hk::MessageSubtypeId::TcModifyHkCollectionInterval => {
                 if user_data.len() < 12 {
                     verif_reporter
                         .start_failure(
@@ -314,7 +317,7 @@ mod tests {
         pus::test_util::TEST_APID,
         request::GenericMessage,
         spacepackets::{
-            ecss::{hk::Subservice, tc::PusTcCreator},
+            ecss::{hk::MessageSubtypeId, tc::PusTcCreator},
             SpHeader,
         },
     };
@@ -340,7 +343,7 @@ mod tests {
 
         let hk_req = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcGenerateOneShotHk as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcGenerateOneShotHk as u8),
             &app_data,
             CreatorConfig::default(),
         );
@@ -379,14 +382,14 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcEnableHkGeneration as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcEnableHkGeneration as u8),
             &app_data,
             CreatorConfig::default(),
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcEnableDiagGeneration as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcEnableDiagGeneration as u8),
             &app_data,
             CreatorConfig::default(),
         );
@@ -416,14 +419,14 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcDisableHkGeneration as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcDisableHkGeneration as u8),
             &app_data,
             CreatorConfig::default(),
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcDisableDiagGeneration as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcDisableDiagGeneration as u8),
             &app_data,
             CreatorConfig::default(),
         );
@@ -457,14 +460,14 @@ mod tests {
         };
         let tc0 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcModifyHkCollectionInterval as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcModifyHkCollectionInterval as u8),
             &app_data,
             CreatorConfig::default(),
         );
         generic_check(&tc0);
         let tc1 = PusTcCreator::new_simple(
             sp_header,
-            MessageTypeId::new(3, Subservice::TcModifyDiagCollectionInterval as u8),
+            MessageTypeId::new(3, MessageSubtypeId::TcModifyDiagCollectionInterval as u8),
             &app_data,
             CreatorConfig::default(),
         );

satrs-shared/CHANGELOG.md

@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v0.2.4] 2025-11-06
+
+`spacepackets` v0.17.0
+
 # [v0.2.3] 2025-07-22
 
 `spacepackets` range v0.14 to v0.15

satrs-shared/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "satrs-shared"
 description = "Components shared by multiple sat-rs crates"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 homepage = "https://absatsw.irs.uni-stuttgart.de/projects/sat-rs/"
@@ -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.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
+spacepackets = { version = "0.17", default-features = false }
 serde = { version = "1", default-features = false, optional = true }
 defmt = {version = "1", optional = true }
 

satrs/CHANGELOG.md

@@ -8,10 +8,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
-# [v0.3.0-alpha.3] 2025-09-??
+# [v0.3.0-alpha.3] 2025-11-06
 
 - Bump `sat-rs` edition to 2024.
-- Bumped `spacepackets` to v0.16
+- Bumped `spacepackets` to v0.17
 - `ComponentId` is u32 now
 - Simplified TCP servers
 

satrs/Cargo.toml

@@ -14,7 +14,7 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup
 
 [dependencies]
 satrs-shared = { version = "0.2", path = "../satrs-shared" }
-spacepackets = { version = "0.17", git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git", default-features = false }
+spacepackets = { version = "0.17", default-features = false }
 
 delegate = "0.13"
 paste = "1"

satrs/src/pus/event.rs

@@ -31,7 +31,7 @@ impl EventReportCreator {
         src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            Subservice::TmInfoReport,
+            MessageSubtypeId::TmInfoReport,
             time_stamp,
             event_id,
             params,
@@ -47,7 +47,7 @@ impl EventReportCreator {
         src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            Subservice::TmLowSeverityReport,
+            MessageSubtypeId::TmLowSeverityReport,
             time_stamp,
             event_id,
             params,
@@ -63,7 +63,7 @@ impl EventReportCreator {
         buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            Subservice::TmMediumSeverityReport,
+            MessageSubtypeId::TmMediumSeverityReport,
             time_stamp,
             event_id,
             params,
@@ -79,7 +79,7 @@ impl EventReportCreator {
         src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            Subservice::TmHighSeverityReport,
+            MessageSubtypeId::TmHighSeverityReport,
             time_stamp,
             event_id,
             params,
@@ -89,7 +89,7 @@ impl EventReportCreator {
 
     fn generate_and_send_generic_tm<'time, 'src_data>(
         &self,
-        subservice: Subservice,
+        subservice: MessageSubtypeId,
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
         params: Option<&'src_data [u8]>,
@@ -100,7 +100,7 @@ impl EventReportCreator {
 
     fn generate_generic_event_tm<'time, 'src_data>(
         &self,
-        subservice: Subservice,
+        subservice: MessageSubtypeId,
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
         params: Option<&'src_data [u8]>,
@@ -333,12 +333,12 @@ mod tests {
         }
     }
 
-    fn severity_to_subservice(severity: Severity) -> Subservice {
+    fn severity_to_subservice(severity: Severity) -> MessageSubtypeId {
         match severity {
-            Severity::Info => Subservice::TmInfoReport,
+            Severity::Info => MessageSubtypeId::TmInfoReport,
-            Severity::Low => Subservice::TmLowSeverityReport,
+            Severity::Low => MessageSubtypeId::TmLowSeverityReport,
-            Severity::Medium => Subservice::TmMediumSeverityReport,
+            Severity::Medium => MessageSubtypeId::TmMediumSeverityReport,
-            Severity::High => Subservice::TmHighSeverityReport,
+            Severity::High => MessageSubtypeId::TmHighSeverityReport,
         }
     }
 

satrs/src/pus/event_man.rs

@@ -313,7 +313,7 @@ mod tests {
     use alloc::vec;
     use arbitrary_int::{u11, u21};
     use spacepackets::ecss::PusPacket;
-    use spacepackets::ecss::event::Subservice;
+    use spacepackets::ecss::event::MessageSubtypeId;
     use spacepackets::ecss::tm::PusTmReader;
 
     use super::*;
@@ -410,7 +410,10 @@ mod tests {
         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_type_id(), 5);
-        assert_eq!(tm.message_subtype_id(), Subservice::TmInfoReport as u8);
+        assert_eq!(
+            tm.message_subtype_id(),
+            MessageSubtypeId::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());
@@ -438,7 +441,10 @@ mod tests {
         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_type_id(), 5);
-        assert_eq!(tm.message_subtype_id(), Subservice::TmInfoReport as u8);
+        assert_eq!(
+            tm.message_subtype_id(),
+            MessageSubtypeId::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

@@ -4,7 +4,7 @@ use crate::pus::verification::TcStateToken;
 use crate::pus::{DirectPusPacketHandlerResult, PartialPusHandlingError, PusPacketHandlingError};
 use crate::queue::GenericSendError;
 use spacepackets::ecss::PusPacket;
-use spacepackets::ecss::event::Subservice;
+use spacepackets::ecss::event::MessageSubtypeId;
 use std::sync::mpsc::Sender;
 
 use super::verification::VerificationReportingProvider;
@@ -61,7 +61,7 @@ impl<
             .cache(&ecss_tc_and_token.tc_in_memory)?;
         let tc = self.service_helper.tc_in_mem_converter().convert()?;
         let subservice = tc.message_subtype_id();
-        let srv = Subservice::try_from(subservice);
+        let srv = MessageSubtypeId::try_from(subservice);
         if srv.is_err() {
             return Ok(DirectPusPacketHandlerResult::CustomSubservice(
                 tc.message_subtype_id(),
@@ -116,21 +116,21 @@ impl<
             };
 
         match srv.unwrap() {
-            Subservice::TmInfoReport
+            MessageSubtypeId::TmInfoReport
-            | Subservice::TmLowSeverityReport
+            | MessageSubtypeId::TmLowSeverityReport
-            | Subservice::TmMediumSeverityReport
+            | MessageSubtypeId::TmMediumSeverityReport
-            | Subservice::TmHighSeverityReport => {
+            | MessageSubtypeId::TmHighSeverityReport => {
                 return Err(PusPacketHandlingError::RequestConversion(
                     GenericConversionError::WrongService(tc.message_subtype_id()),
                 ));
             }
-            Subservice::TcEnableEventGeneration => {
+            MessageSubtypeId::TcEnableEventGeneration => {
                 handle_enable_disable_request(true)?;
             }
-            Subservice::TcDisableEventGeneration => {
+            MessageSubtypeId::TcDisableEventGeneration => {
                 handle_enable_disable_request(false)?;
             }
-            Subservice::TcReportDisabledList | Subservice::TmDisabledEventsReport => {
+            MessageSubtypeId::TcReportDisabledList | MessageSubtypeId::TmDisabledEventsReport => {
                 return Ok(DirectPusPacketHandlerResult::SubserviceNotImplemented(
                     subservice,
                     ecss_tc_and_token.token,
@@ -147,7 +147,7 @@ mod tests {
     use arbitrary_int::traits::Integer as _;
     use arbitrary_int::u14;
     use delegate::delegate;
-    use spacepackets::ecss::event::Subservice;
+    use spacepackets::ecss::event::MessageSubtypeId;
     use spacepackets::ecss::{CreatorConfig, MessageTypeId};
     use spacepackets::time::{TimeWriter, cds};
     use spacepackets::util::UnsignedEnum;
@@ -241,7 +241,7 @@ mod tests {
 
     fn event_test(
         test_harness: &mut (impl PusTestHarness + SimplePusPacketHandler),
-        subservice: Subservice,
+        subservice: MessageSubtypeId,
         expected_event_req: EventRequest,
         event_req_receiver: mpsc::Receiver<EventRequestWithToken>,
     ) {
@@ -272,7 +272,7 @@ mod tests {
         let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx);
         event_test(
             &mut test_harness,
-            Subservice::TcEnableEventGeneration,
+            MessageSubtypeId::TcEnableEventGeneration,
             EventRequest::Enable(TEST_EVENT_0),
             event_request_rx,
         );
@@ -284,7 +284,7 @@ mod tests {
         let mut test_harness = Pus5HandlerWithStoreTester::new(event_request_tx);
         event_test(
             &mut test_harness,
-            Subservice::TcDisableEventGeneration,
+            MessageSubtypeId::TcDisableEventGeneration,
             EventRequest::Disable(TEST_EVENT_0),
             event_request_rx,
         );
@@ -333,7 +333,7 @@ mod tests {
         let sp_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
         let sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
             5,
-            Subservice::TcEnableEventGeneration as u8,
+            MessageSubtypeId::TcEnableEventGeneration as u8,
         ));
         let ping_tc =
             PusTcCreator::new(sp_header, sec_header, &[0, 1, 2], CreatorConfig::default());

satrs/src/pus/scheduler_srv.rs

@@ -80,7 +80,7 @@ impl<
             .cache(&ecss_tc_and_token.tc_in_memory)?;
         let tc = self.service_helper.tc_in_mem_converter().convert()?;
         let subservice = PusPacket::message_subtype_id(&tc);
-        let standard_subservice = scheduling::Subservice::try_from(subservice);
+        let standard_subservice = scheduling::MessageSubtypeId::try_from(subservice);
         if standard_subservice.is_err() {
             return Ok(DirectPusPacketHandlerResult::CustomSubservice(
                 subservice,
@@ -88,7 +88,7 @@ impl<
             ));
         }
         match standard_subservice.unwrap() {
-            scheduling::Subservice::TcEnableScheduling => {
+            scheduling::MessageSubtypeId::TcEnableScheduling => {
                 let opt_started_token = match self.service_helper.verif_reporter().start_success(
                     &self.service_helper.common.tm_sender,
                     ecss_tc_and_token.token,
@@ -117,7 +117,7 @@ impl<
                     ));
                 }
             }
-            scheduling::Subservice::TcDisableScheduling => {
+            scheduling::MessageSubtypeId::TcDisableScheduling => {
                 let opt_started_token = match self.service_helper.verif_reporter().start_success(
                     &self.service_helper.common.tm_sender,
                     ecss_tc_and_token.token,
@@ -147,7 +147,7 @@ impl<
                     ));
                 }
             }
-            scheduling::Subservice::TcResetScheduling => {
+            scheduling::MessageSubtypeId::TcResetScheduling => {
                 let start_token = self
                     .service_helper
                     .verif_reporter()
@@ -171,7 +171,7 @@ impl<
                     )
                     .expect("Error sending completion success");
             }
-            scheduling::Subservice::TcInsertActivity => {
+            scheduling::MessageSubtypeId::TcInsertActivity => {
                 let start_token = self
                     .service_helper
                     .common
@@ -264,7 +264,7 @@ mod tests {
     use arbitrary_int::u14;
     use delegate::delegate;
     use spacepackets::SpHeader;
-    use spacepackets::ecss::scheduling::Subservice;
+    use spacepackets::ecss::scheduling::MessageSubtypeId;
     use spacepackets::ecss::tc::PusTcSecondaryHeader;
     use spacepackets::ecss::{CreatorConfig, MessageTypeId, WritablePusPacket};
     use spacepackets::time::TimeWriter;
@@ -386,7 +386,7 @@ mod tests {
 
     fn generic_subservice_send(
         test_harness: &mut Pus11HandlerWithStoreTester,
-        subservice: Subservice,
+        subservice: MessageSubtypeId,
     ) {
         let reply_header = SpHeader::new_for_unseg_tm(TEST_APID, u14::ZERO, 0);
         let tc_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(11, subservice as u8));
@@ -411,7 +411,7 @@ mod tests {
         let mut test_harness = Pus11HandlerWithStoreTester::new();
         test_harness.handler.scheduler_mut().disable();
         assert!(!test_harness.handler.scheduler().is_enabled());
-        generic_subservice_send(&mut test_harness, Subservice::TcEnableScheduling);
+        generic_subservice_send(&mut test_harness, MessageSubtypeId::TcEnableScheduling);
         assert!(test_harness.handler.scheduler().is_enabled());
         assert_eq!(test_harness.handler.scheduler().enabled_count, 1);
     }
@@ -421,7 +421,7 @@ mod tests {
         let mut test_harness = Pus11HandlerWithStoreTester::new();
         test_harness.handler.scheduler_mut().enable();
         assert!(test_harness.handler.scheduler().is_enabled());
-        generic_subservice_send(&mut test_harness, Subservice::TcDisableScheduling);
+        generic_subservice_send(&mut test_harness, MessageSubtypeId::TcDisableScheduling);
         assert!(!test_harness.handler.scheduler().is_enabled());
         assert_eq!(test_harness.handler.scheduler().disabled_count, 1);
     }
@@ -429,7 +429,7 @@ mod tests {
     #[test]
     fn test_reset_scheduler_tc() {
         let mut test_harness = Pus11HandlerWithStoreTester::new();
-        generic_subservice_send(&mut test_harness, Subservice::TcResetScheduling);
+        generic_subservice_send(&mut test_harness, MessageSubtypeId::TcResetScheduling);
         assert_eq!(test_harness.handler.scheduler().reset_count, 1);
     }
 
@@ -449,7 +449,7 @@ mod tests {
         reply_header = SpHeader::new_for_unseg_tc(TEST_APID, u14::ZERO, 0);
         sec_header = PusTcSecondaryHeader::new_simple(MessageTypeId::new(
             11,
-            Subservice::TcInsertActivity as u8,
+            MessageSubtypeId::TcInsertActivity as u8,
         ));
         let enable_scheduling = PusTcCreator::new(
             reply_header,

satrs/src/pus/verification.rs

@@ -567,7 +567,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         let tm_creator = self.success_verification_no_step(
             src_data_buf,
-            Subservice::TmAcceptanceSuccess.into(),
+            MessageSubtypeId::TmAcceptanceSuccess.into(),
             request_id,
             seq_count,
             msg_count,
@@ -587,7 +587,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.failure_verification_no_step(
             src_data_buf,
-            Subservice::TmAcceptanceFailure.into(),
+            MessageSubtypeId::TmAcceptanceFailure.into(),
             request_id,
             seq_count,
             msg_count,
@@ -609,7 +609,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         let tm_creator = self.success_verification_no_step(
             src_data_buf,
-            Subservice::TmStartSuccess.into(),
+            MessageSubtypeId::TmStartSuccess.into(),
             request_id,
             seq_count,
             msg_count,
@@ -632,7 +632,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.failure_verification_no_step(
             src_data_buf,
-            Subservice::TmStartFailure.into(),
+            MessageSubtypeId::TmStartFailure.into(),
             request_id,
             seq_count,
             msg_count,
@@ -655,7 +655,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.create_pus_verif_success_tm(
             src_data_buf,
-            Subservice::TmStepSuccess.into(),
+            MessageSubtypeId::TmStepSuccess.into(),
             seq_count,
             msg_count,
             request_id,
@@ -678,7 +678,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.create_pus_verif_fail_tm(
             src_data_buf,
-            Subservice::TmStepFailure.into(),
+            MessageSubtypeId::TmStepFailure.into(),
             seq_count,
             msg_count,
             &token.request_id(),
@@ -701,7 +701,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.success_verification_no_step(
             src_data_buf,
-            Subservice::TmCompletionSuccess.into(),
+            MessageSubtypeId::TmCompletionSuccess.into(),
             request_id,
             seq_counter,
             msg_counter,
@@ -723,7 +723,7 @@ impl VerificationReportCreator {
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.failure_verification_no_step(
             src_data_buf,
-            Subservice::TmCompletionFailure.into(),
+            MessageSubtypeId::TmCompletionFailure.into(),
             request_id,
             seq_count,
             msg_count,