Merge remote-tracking branch 'origin/main' into cfdp-state-machines

satrs-core/Cargo.toml

@@ -5,15 +5,15 @@ edition = "2021"
 rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 description = "Core components of the sat-rs framework to build software for remote systems"
-homepage = "https://egit.irs.uni-stuttgart.de/rust/satrs-core"
+homepage = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
-repository = "https://egit.irs.uni-stuttgart.de/rust/satrs-core"
+repository = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
 license = "Apache-2.0"
 keywords = ["no-std", "space", "aerospace"]
 categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-support", "embedded"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-delegate = ">=0.8, <0.11"
+delegate = ">0.7, <=0.10"
 paste = "1"
 embed-doc-image = "0.1"
 
@@ -21,7 +21,7 @@ embed-doc-image = "0.1"
 version = "1"
 
 [dependencies.num_enum]
-version = "0.6"
+version = ">0.5, <=0.7"
 default-features = false
 
 [dependencies.crc]
@@ -67,16 +67,16 @@ default-features = false
 optional = true
 
 [dependencies.spacepackets]
-version = "0.7.0-beta.0"
+version = "0.7.0-beta.1"
 # path = "../../spacepackets"
-git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git"
+# git = "https://egit.irs.uni-stuttgart.de/rust/spacepackets.git"
 # rev = ""
-branch = "pdu-additions"
+# branch = ""
 default-features = false
 
 [dev-dependencies]
 serde = "1"
-zerocopy = "0.6"
+zerocopy = "0.7"
 once_cell = "1.13"
 serde_json = "1"
 

satrs-core/README.md

@@ -1,5 +1,9 @@
+[![Crates.io](https://img.shields.io/crates/v/satrs-core)](https://crates.io/crates/satrs-core)
+[![docs.rs](https://img.shields.io/docsrs/satrs-core)](https://docs.rs/satrs-core)
+
 satrs-core
 ======
 
 This crate contains the core components of the sat-rs framework.
-You can find more information on [homepage](https://egit.irs.uni-stuttgart.de/rust/sat-rs)
+You can find more information on [homepage](https://egit.irs.uni-stuttgart.de/rust/sat-rs).
+

satrs-core/release-checklist.md

@@ -0,0 +1,25 @@
+Checklist for new releases
+=======
+
+# Pre-Release
+
+1. Make sure any new modules are documented sufficiently enough and check docs with
+   `cargo doc --all-features --open`.
+2. Bump version specifier in `Cargo.toml`.
+3. Update `CHANGELOG.md`: Convert `unreleased` section into version section with date and add new
+   `unreleased` section.
+4. Run `cargo test --all-features`.
+5. Run `cargo fmt` and `cargo clippy`. Check `cargo msrv` against MSRV in `Cargo.toml`.
+6. Wait for CI/CD results for EGit and Github. These also check cross-compilation for bare-metal
+   targets.
+
+# Release
+
+1. `cargo publish`
+
+# Post-Release
+
+1. Create a new annotaged tag and push it with `git tag -a satrs-core-<version>` and
+   `git push -u origin satrs-core-<version>`
+2. Create a new release on `EGit` based on the tag.
+

satrs-core/src/events.rs

@@ -33,7 +33,7 @@ use core::marker::PhantomData;
 use delegate::delegate;
 use spacepackets::ecss::EcssEnumeration;
 use spacepackets::util::{ToBeBytes, UnsignedEnum};
-use spacepackets::{ByteConversionError, SizeMissmatch};
+use spacepackets::ByteConversionError;
 
 /// Using a type definition allows to change this to u64 in the future more easily
 pub type LargestEventRaw = u32;
@@ -124,10 +124,10 @@ impl<RAW: ToBeBytes, GID, UID> EventBase<RAW, GID, UID> {
         width: usize,
     ) -> Result<usize, ByteConversionError> {
         if buf.len() < width {
-            return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+            return Err(ByteConversionError::ToSliceTooSmall {
                 found: buf.len(),
                 expected: width,
-            }));
+            });
         }
         buf.copy_from_slice(raw.to_be_bytes().as_ref());
         Ok(raw.written_len())
@@ -783,9 +783,9 @@ mod tests {
         let err = HIGH_SEV_EVENT.write_to_be_bytes(&mut buf);
         assert!(err.is_err());
         let err = err.unwrap_err();
-        if let ByteConversionError::ToSliceTooSmall(missmatch) = err {
+        if let ByteConversionError::ToSliceTooSmall { found, expected } = err {
-            assert_eq!(missmatch.expected, 4);
+            assert_eq!(expected, 4);
-            assert_eq!(missmatch.found, 3);
+            assert_eq!(found, 3);
         }
     }
 
@@ -795,9 +795,9 @@ mod tests {
         let err = HIGH_SEV_EVENT_SMALL.write_to_be_bytes(&mut buf);
         assert!(err.is_err());
         let err = err.unwrap_err();
-        if let ByteConversionError::ToSliceTooSmall(missmatch) = err {
+        if let ByteConversionError::ToSliceTooSmall { found, expected } = err {
-            assert_eq!(missmatch.expected, 2);
+            assert_eq!(expected, 2);
-            assert_eq!(missmatch.found, 1);
+            assert_eq!(found, 1);
         }
     }
 

satrs-core/src/mode.rs

@@ -2,7 +2,7 @@ use crate::tmtc::TargetId;
 use core::mem::size_of;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use spacepackets::{ByteConversionError, SizeMissmatch};
+use spacepackets::ByteConversionError;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -26,10 +26,10 @@ impl ModeAndSubmode {
 
     pub fn from_be_bytes(buf: &[u8]) -> Result<Self, ByteConversionError> {
         if buf.len() < 6 {
-            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+            return Err(ByteConversionError::FromSliceTooSmall {
                 expected: 6,
                 found: buf.len(),
-            }));
+            });
         }
         Ok(Self {
             mode: u32::from_be_bytes(buf[0..4].try_into().unwrap()),

satrs-core/src/params.rs

@@ -55,7 +55,6 @@ use paste::paste;
 use spacepackets::ecss::{EcssEnumU16, EcssEnumU32, EcssEnumU64, EcssEnumU8};
 use spacepackets::util::UnsignedEnum;
 use spacepackets::ByteConversionError;
-use spacepackets::SizeMissmatch;
 
 #[cfg(feature = "alloc")]
 pub use alloc_mod::*;
@@ -80,10 +79,10 @@ macro_rules! param_to_be_bytes_impl {
             fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
                 let raw_len = self.raw_len();
                 if buf.len() < raw_len {
-                    return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+                    return Err(ByteConversionError::ToSliceTooSmall {
                         found: buf.len(),
                         expected: raw_len,
-                    }));
+                    });
                 }
                 buf[0..raw_len].copy_from_slice(&self.to_be_bytes());
                 Ok(raw_len)
@@ -186,10 +185,10 @@ macro_rules! scalar_byte_conversions_impl {
 
                     fn try_from(v: &[u8]) -> Result<Self, Self::Error>  {
                         if v.len() < size_of::<$ty>() {
-                            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                            return Err(ByteConversionError::FromSliceTooSmall{
                                 expected: size_of::<$ty>(),
                                 found: v.len()
-                            }));
+                            });
                         }
                         Ok([<$ty:upper>]($ty::from_be_bytes(v[0..size_of::<$ty>()].try_into().unwrap())))
                     }
@@ -225,10 +224,10 @@ macro_rules! pair_byte_conversions_impl {
 
                     fn try_from(v: &[u8]) -> Result<Self, Self::Error>  {
                         if v.len() < 2 * size_of::<$ty>() {
-                            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                            return Err(ByteConversionError::FromSliceTooSmall{
                                 expected: 2 * size_of::<$ty>(),
                                 found: v.len()
-                            }));
+                            });
                         }
                         Ok([<$ty:upper Pair>](
                             $ty::from_be_bytes(v[0..size_of::<$ty>()].try_into().unwrap()),
@@ -269,10 +268,10 @@ macro_rules! triplet_to_be_bytes_impl {
 
                     fn try_from(v: &[u8]) -> Result<Self, Self::Error>  {
                         if v.len() < 3 * size_of::<$ty>() {
-                            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                            return Err(ByteConversionError::FromSliceTooSmall{
                                 expected: 3 * size_of::<$ty>(),
                                 found: v.len()
-                            }));
+                            });
                         }
                         Ok([<$ty:upper Triplet>](
                             $ty::from_be_bytes(v[0..size_of::<$ty>()].try_into().unwrap()),

satrs-core/src/pool.rs

@@ -344,7 +344,7 @@ mod alloc_mod {
     }
 
     /// Pool implementation providing sub-pools with fixed size memory blocks. More details in
-    /// the [module documentation][super::pool]
+    /// the [module documentation][crate::pool]
     pub struct LocalPool {
         pool_cfg: PoolCfg,
         pool: Vec<Vec<u8>>,

satrs-core/src/pus/event.rs

@@ -425,12 +425,12 @@ mod tests {
         let err = reporter.event_info(sender, &time_stamp_empty, event, None);
         assert!(err.is_err());
         let err = err.unwrap_err();
-        if let EcssTmtcError::Pus(PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(
+        if let EcssTmtcError::Pus(PusError::ByteConversion(
-            missmatch,
+            ByteConversionError::ToSliceTooSmall { found, expected },
-        ))) = err
+        )) = err
         {
-            assert_eq!(missmatch.expected, 4);
+            assert_eq!(expected, 4);
-            assert_eq!(missmatch.found, expected_found_len);
+            assert_eq!(found, expected_found_len);
         } else {
             panic!("Unexpected error {:?}", err);
         }

satrs-core/src/pus/mod.rs

@@ -14,7 +14,7 @@ use std::error::Error;
 use spacepackets::ecss::tc::{PusTcCreator, PusTcReader};
 use spacepackets::ecss::tm::PusTmCreator;
 use spacepackets::ecss::PusError;
-use spacepackets::{ByteConversionError, SizeMissmatch, SpHeader};
+use spacepackets::{ByteConversionError, SpHeader};
 
 pub mod event;
 pub mod event_man;
@@ -735,10 +735,10 @@ pub mod std_mod {
 pub(crate) fn source_buffer_large_enough(cap: usize, len: usize) -> Result<(), EcssTmtcError> {
     if len > cap {
         return Err(
-            PusError::ByteConversion(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+            PusError::ByteConversion(ByteConversionError::ToSliceTooSmall {
                 found: cap,
                 expected: len,
-            }))
+            })
             .into(),
         );
     }

satrs-core/src/pus/verification.rs

@@ -1584,12 +1584,12 @@ mod tests {
         assert_eq!(err_with_token.1, tok);
         match err_with_token.0 {
             EcssTmtcError::Pus(PusError::ByteConversion(e)) => match e {
-                ByteConversionError::ToSliceTooSmall(missmatch) => {
+                ByteConversionError::ToSliceTooSmall { found, expected } => {
                     assert_eq!(
-                        missmatch.expected,
+                        expected,
                         fail_data.len() + RequestId::SIZE_AS_BYTES + fail_code.size()
                     );
-                    assert_eq!(missmatch.found, b.rep().allowed_source_data_len());
+                    assert_eq!(found, b.rep().allowed_source_data_len());
                 }
                 _ => {
                     panic!("{}", format!("Unexpected error {:?}", e))

satrs-core/src/res_code.rs

@@ -2,7 +2,7 @@
 use serde::{Deserialize, Serialize};
 use spacepackets::ecss::{EcssEnumU16, EcssEnumeration};
 use spacepackets::util::UnsignedEnum;
-use spacepackets::{ByteConversionError, SizeMissmatch};
+use spacepackets::ByteConversionError;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -42,10 +42,10 @@ impl UnsignedEnum for ResultU16 {
 
     fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         if buf.len() < 2 {
-            return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+            return Err(ByteConversionError::ToSliceTooSmall {
                 found: buf.len(),
                 expected: 2,
-            }));
+            });
         }
         buf[0] = self.group_id;
         buf[1] = self.unique_id;

satrs-core/src/tmtc/ccsds_distrib.rs

@@ -89,7 +89,7 @@ use crate::tmtc::{ReceivesCcsdsTc, ReceivesTcCore};
 use alloc::boxed::Box;
 use core::fmt::{Display, Formatter};
 use downcast_rs::Downcast;
-use spacepackets::{ByteConversionError, CcsdsPacket, SizeMissmatch, SpHeader};
+use spacepackets::{ByteConversionError, CcsdsPacket, SpHeader};
 #[cfg(feature = "std")]
 use std::error::Error;
 
@@ -174,10 +174,10 @@ impl<E: 'static> ReceivesTcCore for CcsdsDistributor<E> {
     fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
         if tc_raw.len() < 7 {
             return Err(CcsdsError::ByteConversionError(
-                ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+                ByteConversionError::FromSliceTooSmall {
                     found: tc_raw.len(),
                     expected: 7,
-                }),
+                },
             ));
         }
         let (sp_header, _) =

satrs-core/src/tmtc/mod.rs

@@ -9,7 +9,7 @@
 use downcast_rs::{impl_downcast, Downcast};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use spacepackets::{ByteConversionError, SizeMissmatch, SpHeader};
+use spacepackets::{ByteConversionError, SpHeader};
 
 #[cfg(feature = "alloc")]
 pub mod ccsds_distrib;
@@ -34,10 +34,10 @@ pub struct AddressableId {
 impl AddressableId {
     pub fn from_raw_be(buf: &[u8]) -> Result<Self, ByteConversionError> {
         if buf.len() < 8 {
-            return Err(ByteConversionError::FromSliceTooSmall(SizeMissmatch {
+            return Err(ByteConversionError::FromSliceTooSmall {
                 found: buf.len(),
                 expected: 8,
-            }));
+            });
         }
         Ok(Self {
             target_id: u32::from_be_bytes(buf[0..4].try_into().unwrap()),
@@ -47,10 +47,10 @@ impl AddressableId {
 
     pub fn write_to_be_bytes(&self, buf: &mut [u8]) -> Result<usize, ByteConversionError> {
         if buf.len() < 8 {
-            return Err(ByteConversionError::ToSliceTooSmall(SizeMissmatch {
+            return Err(ByteConversionError::ToSliceTooSmall {
                 found: buf.len(),
                 expected: 8,
-            }));
+            });
         }
         buf[0..4].copy_from_slice(&self.target_id.to_be_bytes());
         buf[4..8].copy_from_slice(&self.unique_id.to_be_bytes());

satrs-core/src/tmtc/pus_distrib.rs

@@ -9,8 +9,9 @@
 //! [ReceivesTcCore] trait which allows to pass raw packets, CCSDS packets and PUS TC packets into
 //! it. Upon receiving a packet, it performs the following steps:
 //!
-//! 1. It tries to extract the [SpHeader] and [PusTc] objects from the raw bytestream. If this
+//! 1. It tries to extract the [SpHeader] and [spacepackets::ecss::tc::PusTcReader] objects from
-//!    process fails, a [PusDistribError::PusError] is returned to the user.
+//!    the raw bytestream. If this process fails, a [PusDistribError::PusError] is returned to the
+//!    user.
 //! 2. If it was possible to extract both components, the packet will be passed to the
 //!    [PusServiceProvider::handle_pus_tc_packet] method provided by the user.
 //!

satrs-example/Cargo.toml

@@ -4,6 +4,8 @@ version = "0.1.0"
 edition = "2021"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
 default-run = "satrs-example"
+homepage = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
+repository = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
 
 [dependencies]
 fern = "0.6"
@@ -13,11 +15,13 @@ crossbeam-channel = "0.5"
 delegate = "0.10"
 zerocopy = "0.6"
 csv = "1"
-num_enum = "0.6"
+num_enum = "0.7"
 thiserror = "1"
 
 [dependencies.satrs-core]
+# version = "0.1.0-alpha.0"
 path = "../satrs-core"
 
+
 [dependencies.satrs-mib]
 path = "../satrs-mib"