tweaks for msp430

satrs-example/src/bin/simpleclient.rs

@@ -29,7 +29,7 @@ fn main() {
         let res = client.recv(&mut buf);
         match res {
             Ok(_len) => {
-                let (pus_tm, size) = PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
+                let pus_tm= PusTmReader::new(&buf, 7).expect("Parsing PUS TM failed");
                 if pus_tm.service() == 17 && pus_tm.subservice() == 2 {
                     println!("Received PUS Ping Reply TM[17,2]")
                 } else if pus_tm.service() == 1 {

satrs-example/src/pus/mod.rs

@@ -109,7 +109,7 @@ impl PusTcDistributor {
             // TODO: Shouldn't this be an error?
             return Ok(HandlingStatus::HandledOne);
         }
-        let pus_tc = pus_tc_result.unwrap().0;
+        let pus_tc = pus_tc_result.unwrap();
         let init_token = self.verif_reporter.add_tc(&pus_tc);
         self.stamp_helper.update_from_now();
         let accepted_token = self
@@ -734,7 +734,7 @@ pub(crate) mod tests {
             let tc_reader = PusTcReader::new(&current_packet).unwrap();
             let (active_info, request) = self.converter.convert(
                 token,
-                &tc_reader.0,
+                &tc_reader,
                 &self.dummy_sender,
                 &self.verif_reporter,
                 time_stamp,

satrs-example/src/pus/test.rs

@@ -90,7 +90,7 @@ impl DirectPusService for TestCustomServiceWrapper {
                 );
             }
             DirectPusPacketHandlerResult::CustomSubservice(subservice, token) => {
-                let (tc, _) = PusTcReader::new(
+                let tc = PusTcReader::new(
                     self.handler
                         .service_helper
                         .tc_in_mem_converter

satrs-mib/Cargo.toml

@@ -24,6 +24,7 @@ optional = true
 
 [dependencies.satrs-shared]
 version = ">=0.1.3, <=0.2"
+path = "../satrs-shared"
 features = ["serde"]
 
 [dependencies.satrs-mib-codegen]

satrs-shared/Cargo.toml

@@ -23,6 +23,7 @@ optional = true
 
 [dependencies.spacepackets]
 version = ">0.9, <=0.13"
+path = "../../spacepackets"
 default-features = false
 
 [features]

satrs/Cargo.toml

@@ -13,16 +13,13 @@ keywords = ["no-std", "space", "aerospace"]
 categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]
 
 [dependencies]
-satrs-shared = ">=0.1.3, <=0.2"
+satrs-shared = { version = ">=0.1.3, <=0.2", path = "../satrs-shared" }
 delegate = ">0.7, <=0.13"
 paste = "1"
 derive-new = ">=0.6, <=0.7"
-smallvec = "1"
-crc = "3"
 num_enum = { version = ">0.5, <=0.7", default-features = false }
-spacepackets = { version = "0.13", default-features = false }
+spacepackets = { version = "0.13", default-features = false, path = "../../spacepackets" }
-cobs = { version = "0.3", default-features = false }
+cobs = { version = "0.4", default-features = false, path = "../../cobs.rs" }
-num-traits = { version = "0.2", default-features = false }
 thiserror = { version = "2", default-features = false }
 
 hashbrown = { version = ">=0.14, <=0.15", optional = true }

satrs/src/pus/mod.rs

@@ -959,15 +959,11 @@ pub mod std_mod {
             possible_packet: &TcInMemory,
         ) -> Result<PusTcReader<'_>, PusTcFromMemError> {
             self.cache(possible_packet)?;
-            Ok(PusTcReader::new(self.tc_slice_raw())
+            Ok(PusTcReader::new(self.tc_slice_raw()).map_err(EcssTmtcError::Pus)?)
-                .map_err(EcssTmtcError::Pus)?
-                .0)
         }
 
         fn convert(&self) -> Result<PusTcReader<'_>, PusTcFromMemError> {
-            Ok(PusTcReader::new(self.tc_slice_raw())
+            Ok(PusTcReader::new(self.tc_slice_raw()).map_err(EcssTmtcError::Pus)?)
-                .map_err(EcssTmtcError::Pus)?
-                .0)
         }
     }
 
@@ -1459,7 +1455,7 @@ 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();
             self.tm_buf[0..tm_raw.len()].copy_from_slice(&tm_raw);
-            PusTmReader::new(&self.tm_buf, 7).unwrap().0
+            PusTmReader::new(&self.tm_buf, 7).unwrap()
         }
 
         pub fn check_no_tm_available(&self) -> bool {
@@ -1476,7 +1472,7 @@ pub mod tests {
             let tm_in_pool = next_msg.unwrap();
             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().0;
+            let tm = PusTmReader::new(&tm_raw, 7).unwrap();
             assert_eq!(PusPacket::service(&tm), 1);
             assert_eq!(PusPacket::subservice(&tm), subservice);
             assert_eq!(tm.apid(), TEST_APID);
@@ -1584,9 +1580,7 @@ pub mod tests {
             let next_msg = self.tm_receiver.try_recv();
             assert!(next_msg.is_ok());
             self.current_tm = Some(next_msg.unwrap().packet);
-            PusTmReader::new(self.current_tm.as_ref().unwrap(), 7)
+            PusTmReader::new(self.current_tm.as_ref().unwrap(), 7).unwrap()
-                .unwrap()
-                .0
         }
 
         pub fn check_no_tm_available(&self) -> bool {
@@ -1601,7 +1595,7 @@ pub mod tests {
             let next_msg = self.tm_receiver.try_recv();
             assert!(next_msg.is_ok());
             let next_msg = next_msg.unwrap();
-            let tm = PusTmReader::new(next_msg.packet.as_slice(), 7).unwrap().0;
+            let tm = PusTmReader::new(next_msg.packet.as_slice(), 7).unwrap();
             assert_eq!(PusPacket::service(&tm), 1);
             assert_eq!(PusPacket::subservice(&tm), subservice);
             assert_eq!(tm.apid(), TEST_APID);

satrs/src/pus/scheduler.rs

@@ -292,10 +292,10 @@ pub trait PusSchedulerProvider {
         pool: &mut (impl PoolProvider + ?Sized),
     ) -> Result<TcInfo, ScheduleError> {
         let check_tc = PusTcReader::new(tc)?;
-        if PusPacket::service(&check_tc.0) == 11 && PusPacket::subservice(&check_tc.0) == 4 {
+        if PusPacket::service(&check_tc) == 11 && PusPacket::subservice(&check_tc) == 4 {
             return Err(ScheduleError::NestedScheduledTc);
         }
-        let req_id = RequestId::from_tc(&check_tc.0);
+        let req_id = RequestId::from_tc(&check_tc);
 
         match pool.add(tc) {
             Ok(addr) => {
@@ -480,10 +480,10 @@ pub mod alloc_mod {
             pool: &mut (impl PoolProvider + ?Sized),
         ) -> Result<TcInfo, ScheduleError> {
             let check_tc = PusTcReader::new(tc)?;
-            if PusPacket::service(&check_tc.0) == 11 && PusPacket::subservice(&check_tc.0) == 4 {
+            if PusPacket::service(&check_tc) == 11 && PusPacket::subservice(&check_tc) == 4 {
                 return Err(ScheduleError::NestedScheduledTc);
             }
-            let req_id = RequestId::from_tc(&check_tc.0);
+            let req_id = RequestId::from_tc(&check_tc);
 
             match pool.add(tc) {
                 Ok(addr) => {
@@ -1313,7 +1313,7 @@ mod tests {
         let mut read_buf: [u8; 64] = [0; 64];
         pool.read(&tc_info_0.addr(), &mut read_buf).unwrap();
         let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data");
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
 
         assert_eq!(scheduler.num_scheduled_telecommands(), 1);
 
@@ -1335,8 +1335,8 @@ mod tests {
 
         let read_len = pool.read(&addr_vec[0], &mut read_buf).unwrap();
         let check_tc = PusTcReader::new(&read_buf).expect("incorrect Pus tc raw data");
-        assert_eq!(read_len, check_tc.1);
+        assert_eq!(read_len, check_tc.total_len());
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
     }
 
     #[test]
@@ -1362,8 +1362,8 @@ mod tests {
 
         let read_len = pool.read(&info.addr, &mut buf).unwrap();
         let check_tc = PusTcReader::new(&buf).expect("incorrect Pus tc raw data");
-        assert_eq!(read_len, check_tc.1);
+        assert_eq!(read_len, check_tc.total_len());
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
 
         assert_eq!(scheduler.num_scheduled_telecommands(), 1);
 
@@ -1387,8 +1387,8 @@ mod tests {
 
         let read_len = pool.read(&addr_vec[0], &mut buf).unwrap();
         let check_tc = PusTcReader::new(&buf).expect("incorrect PUS tc raw data");
-        assert_eq!(read_len, check_tc.1);
+        assert_eq!(read_len, check_tc.total_len());
-        assert_eq!(check_tc.0, base_ping_tc_simple_ctor(0, &[]));
+        assert_eq!(check_tc, base_ping_tc_simple_ctor(0, &[]));
     }
 
     #[test]
@@ -2031,7 +2031,7 @@ mod tests {
         assert_eq!(n, 1);
         let time_reader = cds::CdsTime::from_bytes_with_u16_days(&buf[2..2 + 7]).unwrap();
         assert_eq!(time_reader, time_writer);
-        let pus_tc_reader = PusTcReader::new(&buf[9..]).unwrap().0;
+        let pus_tc_reader = PusTcReader::new(&buf[9..]).unwrap();
         assert_eq!(pus_tc_reader, ping_tc);
     }
 

satrs/src/pus/verification.rs

@@ -482,7 +482,7 @@ pub trait VerificationReportingProvider {
 /// the buffer passed to the API exposes by this struct will be used to serialize the source data.
 /// This buffer may not be re-used to serialize the whole telemetry because that would overwrite
 /// the source data itself.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct VerificationReportCreator {
     pub dest_id: u16,
     apid: u16,