Merge pull request 'prepare alpha release' (#222) from prep-satrs-v0.3.0-alpha.0 into main

Reviewed-on: #222

satrs-example/pytmtc/pytmtc/common.py

@@ -39,7 +39,10 @@ class EventU32:
 
 
 class AcsId(enum.IntEnum):
-    MGM_0 = 0
+    SUBSYSTEM = 1
+    MGM_ASSEMBLY = 2
+    MGM_0 = 3
+    MGM_1 = 4
 
 
 class AcsHkIds(enum.IntEnum):

satrs-example/src/acs/assembly.rs

@@ -0,0 +1 @@
+// TODO: Write the assembly

satrs-example/src/acs/ctrl.rs

@@ -0,0 +1 @@
+// TODO: Write dummy controller

satrs-example/src/acs/mgm.rs

@@ -2,6 +2,7 @@ use derive_new::new;
 use satrs::hk::{HkRequest, HkRequestVariant};
 use satrs::mode_tree::{ModeChild, ModeNode};
 use satrs::power::{PowerSwitchInfo, PowerSwitcherCommandSender};
+use satrs_example::config::pus::PUS_MODE_SERVICE;
 use satrs_example::{DeviceMode, TimestampHelper};
 use satrs_minisim::acs::lis3mdl::{
     MgmLis3MdlReply, MgmLis3RawValues, FIELD_LSB_PER_GAUSS_4_SENS, GAUSS_TO_MICROTESLA_FACTOR,
@@ -20,7 +21,7 @@ use satrs::mode::{
 };
 use satrs::pus::{EcssTmSender, PusTmVariant};
 use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
-use satrs_example::config::components::{NO_SENDER, PUS_MODE_SERVICE};
+use satrs_example::config::components::NO_SENDER;
 
 use crate::hk::PusHkHelper;
 use crate::pus::hk::{HkReply, HkReplyVariant};
@@ -491,7 +492,7 @@ mod tests {
         tmtc::PacketAsVec,
         ComponentId,
     };
-    use satrs_example::config::components::{Apid, MGM_ASSEMBLY};
+    use satrs_example::config::{acs::MGM_ASSEMBLY, components::Apid};
     use satrs_minisim::acs::lis3mdl::MgmLis3RawValues;
 
     use crate::{eps::TestSwitchHelper, pus::hk::HkReply, requests::CompositeRequest};

satrs-example/src/acs/mod.rs

@@ -1 +1,4 @@
+pub mod assembly;
+pub mod ctrl;
 pub mod mgm;
+pub mod subsystem;

satrs-example/src/acs/subsystem.rs

@@ -0,0 +1 @@
+// TODO: Write subsystem

satrs-example/src/config.rs

@@ -135,23 +135,6 @@ pub mod components {
         Eps = 6,
     }
 
-    // Component IDs for components with the PUS APID.
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    pub enum PusId {
-        PusEventManagement = 0,
-        PusRouting = 1,
-        PusTest = 2,
-        PusAction = 3,
-        PusMode = 4,
-        PusHk = 5,
-    }
-
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    pub enum AcsId {
-        Mgm0 = 0,
-        Assembly = 1,
-    }
-
     #[derive(Copy, Clone, PartialEq, Eq)]
     pub enum EpsId {
         Pcdu = 0,
@@ -164,6 +147,31 @@ pub mod components {
         TcpServer = 1,
     }
 
+    pub const EPS_SUBSYSTEM: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Subsystem as u32);
+    pub const PCDU_HANDLER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Pcdu as u32);
+    pub const UDP_SERVER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::UdpServer as u32);
+    pub const TCP_SERVER: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::TcpServer as u32);
+    pub const NO_SENDER: ComponentId = ComponentId::MAX;
+}
+
+pub mod pus {
+    use super::components::Apid;
+    use satrs::request::UniqueApidTargetId;
+
+    // Component IDs for components with the PUS APID.
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum PusId {
+        PusEventManagement = 0,
+        PusRouting = 1,
+        PusTest = 2,
+        PusAction = 3,
+        PusMode = 4,
+        PusHk = 5,
+    }
     pub const PUS_ACTION_SERVICE: UniqueApidTargetId =
         UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusAction as u32);
     pub const PUS_EVENT_MANAGEMENT: UniqueApidTargetId =
@@ -178,19 +186,26 @@ pub mod components {
         UniqueApidTargetId::new(Apid::GenericPus as u16, PusId::PusHk as u32);
     pub const PUS_SCHED_SERVICE: UniqueApidTargetId =
         UniqueApidTargetId::new(Apid::Sched as u16, 0);
+}
+
+pub mod acs {
+    use super::components::Apid;
+    use satrs::request::UniqueApidTargetId;
+
+    #[derive(Copy, Clone, PartialEq, Eq)]
+    pub enum AcsId {
+        Subsystem = 1,
+        Assembly = 2,
+        Mgm0 = 3,
+        Mgm1 = 4,
+    }
+
     pub const MGM_ASSEMBLY: UniqueApidTargetId =
         UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Assembly as u32);
     pub const MGM_HANDLER_0: UniqueApidTargetId =
         UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
-    pub const EPS_SUBSYSTEM: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Subsystem as u32);
-    pub const PCDU_HANDLER: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Eps as u16, EpsId::Pcdu as u32);
-    pub const UDP_SERVER: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::UdpServer as u32);
-    pub const TCP_SERVER: UniqueApidTargetId =
-        UniqueApidTargetId::new(Apid::Tmtc as u16, TmtcId::TcpServer as u32);
-    pub const NO_SENDER: ComponentId = ComponentId::MAX;
+    pub const MGM_HANDLER_1: UniqueApidTargetId =
+        UniqueApidTargetId::new(Apid::Acs as u16, AcsId::Mgm0 as u32);
 }
 
 pub mod pool {

satrs-example/src/eps/pcdu.rs

@@ -20,7 +20,10 @@ use satrs::{
     spacepackets::ByteConversionError,
 };
 use satrs_example::{
-    config::components::{NO_SENDER, PCDU_HANDLER, PUS_MODE_SERVICE},
+    config::{
+        components::{NO_SENDER, PCDU_HANDLER},
+        pus::PUS_MODE_SERVICE,
+    },
     DeviceMode, TimestampHelper,
 };
 use satrs_minisim::{
@@ -35,6 +38,7 @@ use crate::{
     hk::PusHkHelper,
     pus::hk::{HkReply, HkReplyVariant},
     requests::CompositeRequest,
+    tmtc::sender::TmTcSender,
 };
 
 pub trait SerialInterface {
@@ -203,14 +207,14 @@ pub type SharedSwitchSet = Arc<Mutex<SwitchSet>>;
 /// Example PCDU device handler.
 #[derive(new)]
 #[allow(clippy::too_many_arguments)]
-pub struct PcduHandler<ComInterface: SerialInterface, TmSender: EcssTmSender> {
+pub struct PcduHandler<ComInterface: SerialInterface> {
     id: UniqueApidTargetId,
     dev_str: &'static str,
     mode_node: ModeRequestHandlerMpscBounded,
     composite_request_rx: mpsc::Receiver<GenericMessage<CompositeRequest>>,
     hk_reply_tx: mpsc::SyncSender<GenericMessage<HkReply>>,
     switch_request_rx: mpsc::Receiver<GenericMessage<SwitchRequest>>,
-    tm_sender: TmSender,
+    tm_sender: TmTcSender,
     pub com_interface: ComInterface,
     shared_switch_map: Arc<Mutex<SwitchSet>>,
     #[new(value = "PusHkHelper::new(id)")]
@@ -223,7 +227,7 @@ pub struct PcduHandler<ComInterface: SerialInterface, TmSender: EcssTmSender> {
     tm_buf: [u8; 256],
 }
 
-impl<ComInterface: SerialInterface, TmSender: EcssTmSender> PcduHandler<ComInterface, TmSender> {
+impl<ComInterface: SerialInterface> PcduHandler<ComInterface> {
     pub fn periodic_operation(&mut self, op_code: OpCode) {
         match op_code {
             OpCode::RegularOp => {
@@ -404,17 +408,13 @@ impl<ComInterface: SerialInterface, TmSender: EcssTmSender> PcduHandler<ComInter
     }
 }
 
-impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeProvider
-    for PcduHandler<ComInterface, TmSender>
-{
+impl<ComInterface: SerialInterface> ModeProvider for PcduHandler<ComInterface> {
     fn mode_and_submode(&self) -> ModeAndSubmode {
         self.mode_and_submode
     }
 }
 
-impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeRequestHandler
-    for PcduHandler<ComInterface, TmSender>
-{
+impl<ComInterface: SerialInterface> ModeRequestHandler for PcduHandler<ComInterface> {
     type Error = ModeError;
     fn start_transition(
         &mut self,
@@ -490,17 +490,13 @@ impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeRequestHandler
     }
 }
 
-impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeNode
-    for PcduHandler<ComInterface, TmSender>
-{
+impl<ComInterface: SerialInterface> ModeNode for PcduHandler<ComInterface> {
     fn id(&self) -> satrs::ComponentId {
         PCDU_HANDLER.into()
     }
 }
 
-impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeChild
-    for PcduHandler<ComInterface, TmSender>
-{
+impl<ComInterface: SerialInterface> ModeChild for PcduHandler<ComInterface> {
     type Sender = mpsc::SyncSender<GenericMessage<ModeReply>>;
 
     fn add_mode_parent(&mut self, id: satrs::ComponentId, reply_sender: Self::Sender) {
@@ -515,7 +511,10 @@ mod tests {
     use satrs::{
         mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
     };
-    use satrs_example::config::components::{Apid, EPS_SUBSYSTEM, MGM_HANDLER_0, PCDU_HANDLER};
+    use satrs_example::config::{
+        acs::MGM_HANDLER_0,
+        components::{Apid, EPS_SUBSYSTEM, PCDU_HANDLER},
+    };
     use satrs_minisim::eps::SwitchMapBinary;
 
     use super::*;
@@ -563,7 +562,7 @@ mod tests {
         pub hk_reply_rx: mpsc::Receiver<GenericMessage<HkReply>>,
         pub tm_rx: mpsc::Receiver<PacketAsVec>,
         pub switch_request_tx: mpsc::Sender<GenericMessage<SwitchRequest>>,
-        pub handler: PcduHandler<SerialInterfaceTest, mpsc::Sender<PacketAsVec>>,
+        pub handler: PcduHandler<SerialInterfaceTest>,
     }
 
     impl PcduTestbench {
@@ -575,7 +574,7 @@ mod tests {
                 ModeRequestHandlerMpscBounded::new(PCDU_HANDLER.into(), mode_request_rx);
             let (composite_request_tx, composite_request_rx) = mpsc::channel();
             let (hk_reply_tx, hk_reply_rx) = mpsc::sync_channel(10);
-            let (tm_tx, tm_rx) = mpsc::channel::<PacketAsVec>();
+            let (tm_tx, tm_rx) = mpsc::sync_channel::<PacketAsVec>(5);
             let (switch_request_tx, switch_reqest_rx) = mpsc::channel();
             let shared_switch_map = Arc::new(Mutex::new(SwitchSet::default()));
             let mut handler = PcduHandler::new(
@@ -585,7 +584,7 @@ mod tests {
                 composite_request_rx,
                 hk_reply_tx,
                 switch_reqest_rx,
-                tm_tx,
+                TmTcSender::Heap(tm_tx.clone()),
                 SerialInterfaceTest::default(),
                 shared_switch_map,
             );

satrs-example/src/events.rs

@@ -16,7 +16,7 @@ use satrs::{
     },
     spacepackets::time::cds::CdsTime,
 };
-use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
+use satrs_example::config::pus::PUS_EVENT_MANAGEMENT;
 
 use crate::update_time;
 

satrs-example/src/main.rs

@@ -39,7 +39,8 @@ use satrs::{
 };
 use satrs_example::{
     config::{
-        components::{MGM_HANDLER_0, NO_SENDER, PCDU_HANDLER, TCP_SERVER, UDP_SERVER},
+        acs::{MGM_HANDLER_0, MGM_HANDLER_1},
+        components::{NO_SENDER, PCDU_HANDLER, TCP_SERVER, UDP_SERVER},
         pool::create_sched_tc_pool,
         tasks::{FREQ_MS_AOCS, FREQ_MS_PUS_STACK, FREQ_MS_UDP_TMTC, SIM_CLIENT_IDLE_DELAY_MS},
         OBSW_SERVER_ADDR, PACKET_ID_VALIDATOR, SERVER_PORT,
@@ -107,20 +108,26 @@ fn main() {
     }
 
     let (sim_request_tx, sim_request_rx) = mpsc::channel();
-    let (mgm_sim_reply_tx, mgm_sim_reply_rx) = mpsc::channel();
+    let (mgm_0_sim_reply_tx, mgm_0_sim_reply_rx) = mpsc::channel();
+    let (mgm_1_sim_reply_tx, mgm_1_sim_reply_rx) = mpsc::channel();
     let (pcdu_sim_reply_tx, pcdu_sim_reply_rx) = mpsc::channel();
     let mut opt_sim_client = create_sim_client(sim_request_rx);
 
-    let (mgm_handler_composite_tx, mgm_handler_composite_rx) = mpsc::sync_channel(10);
+    let (mgm_0_handler_composite_tx, mgm_0_handler_composite_rx) = mpsc::sync_channel(10);
+    let (mgm_1_handler_composite_tx, mgm_1_handler_composite_rx) = mpsc::sync_channel(10);
     let (pcdu_handler_composite_tx, pcdu_handler_composite_rx) = mpsc::sync_channel(30);
-    let (mgm_handler_mode_tx, mgm_handler_mode_rx) = mpsc::sync_channel(5);
+    let (mgm_0_handler_mode_tx, mgm_0_handler_mode_rx) = mpsc::sync_channel(5);
+    let (mgm_1_handler_mode_tx, mgm_1_handler_mode_rx) = mpsc::sync_channel(5);
     let (pcdu_handler_mode_tx, pcdu_handler_mode_rx) = mpsc::sync_channel(5);
 
     // Some request are targetable. This map is used to retrieve sender handles based on a target ID.
     let mut request_map = GenericRequestRouter::default();
     request_map
         .composite_router_map
-        .insert(MGM_HANDLER_0.id(), mgm_handler_composite_tx);
+        .insert(MGM_HANDLER_0.id(), mgm_0_handler_composite_tx);
+    request_map
+        .composite_router_map
+        .insert(MGM_HANDLER_0.id(), mgm_1_handler_composite_tx);
     request_map
         .composite_router_map
         .insert(PCDU_HANDLER.id(), pcdu_handler_composite_tx);
@@ -292,34 +299,67 @@ fn main() {
     let (switch_request_tx, switch_request_rx) = mpsc::sync_channel(20);
     let switch_helper = PowerSwitchHelper::new(switch_request_tx, shared_switch_set.clone());
 
-    let shared_mgm_set = Arc::default();
-    let mgm_mode_node =
-        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_handler_mode_rx);
-    let mgm_spi_interface = if let Some(sim_client) = opt_sim_client.as_mut() {
-        sim_client.add_reply_recipient(satrs_minisim::SimComponent::MgmLis3Mdl, mgm_sim_reply_tx);
-        SpiSimInterfaceWrapper::Sim(SpiSimInterface {
-            sim_request_tx: sim_request_tx.clone(),
-            sim_reply_rx: mgm_sim_reply_rx,
-        })
-    } else {
-        SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default())
-    };
-    let mut mgm_handler = MgmHandlerLis3Mdl::new(
+    let shared_mgm_0_set = Arc::default();
+    let shared_mgm_1_set = Arc::default();
+    let mgm_0_mode_node =
+        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_0.into(), mgm_0_handler_mode_rx);
+    let mgm_1_mode_node =
+        ModeRequestHandlerMpscBounded::new(MGM_HANDLER_1.into(), mgm_1_handler_mode_rx);
+    let (mgm_0_spi_interface, mgm_1_spi_interface) =
+        if let Some(sim_client) = opt_sim_client.as_mut() {
+            sim_client
+                .add_reply_recipient(satrs_minisim::SimComponent::Mgm0Lis3Mdl, mgm_0_sim_reply_tx);
+            sim_client
+                .add_reply_recipient(satrs_minisim::SimComponent::Mgm1Lis3Mdl, mgm_1_sim_reply_tx);
+            (
+                SpiSimInterfaceWrapper::Sim(SpiSimInterface {
+                    sim_request_tx: sim_request_tx.clone(),
+                    sim_reply_rx: mgm_0_sim_reply_rx,
+                }),
+                SpiSimInterfaceWrapper::Sim(SpiSimInterface {
+                    sim_request_tx: sim_request_tx.clone(),
+                    sim_reply_rx: mgm_1_sim_reply_rx,
+                }),
+            )
+        } else {
+            (
+                SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default()),
+                SpiSimInterfaceWrapper::Dummy(SpiDummyInterface::default()),
+            )
+        };
+    let mut mgm_0_handler = MgmHandlerLis3Mdl::new(
         MGM_HANDLER_0,
         "MGM_0",
-        mgm_mode_node,
-        mgm_handler_composite_rx,
+        mgm_0_mode_node,
+        mgm_0_handler_composite_rx,
         pus_hk_reply_tx.clone(),
         switch_helper.clone(),
-        tm_sender,
-        mgm_spi_interface,
-        shared_mgm_set,
+        tm_sender.clone(),
+        mgm_0_spi_interface,
+        shared_mgm_0_set,
     );
-    // Connect PUS service to device handler.
+    let mut mgm_1_handler = MgmHandlerLis3Mdl::new(
+        MGM_HANDLER_1,
+        "MGM_1",
+        mgm_1_mode_node,
+        mgm_1_handler_composite_rx,
+        pus_hk_reply_tx.clone(),
+        switch_helper.clone(),
+        tm_sender.clone(),
+        mgm_1_spi_interface,
+        shared_mgm_1_set,
+    );
+    // Connect PUS service to device handlers.
     connect_mode_nodes(
         &mut pus_stack.mode_srv,
-        mgm_handler_mode_tx,
-        &mut mgm_handler,
+        mgm_0_handler_mode_tx,
+        &mut mgm_0_handler,
+        pus_mode_reply_tx.clone(),
+    );
+    connect_mode_nodes(
+        &mut pus_stack.mode_srv,
+        mgm_1_handler_mode_tx,
+        &mut mgm_1_handler,
         pus_mode_reply_tx.clone(),
     );
 
@@ -341,7 +381,7 @@ fn main() {
         pcdu_handler_composite_rx,
         pus_hk_reply_tx,
         switch_request_rx,
-        tm_sink_tx,
+        tm_sender.clone(),
         pcdu_serial_interface,
         shared_switch_set,
     );
@@ -414,7 +454,8 @@ fn main() {
     let jh_aocs = thread::Builder::new()
         .name("sat-rs aocs".to_string())
         .spawn(move || loop {
-            mgm_handler.periodic_operation();
+            mgm_0_handler.periodic_operation();
+            mgm_1_handler.periodic_operation();
             thread::sleep(Duration::from_millis(FREQ_MS_AOCS));
         })
         .unwrap();

satrs-example/src/pus/action.rs

@@ -16,7 +16,7 @@ use satrs::pus::{
 use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{EcssEnumU16, PusPacket, PusServiceId};
-use satrs_example::config::components::PUS_ACTION_SERVICE;
+use satrs_example::config::pus::PUS_ACTION_SERVICE;
 use satrs_example::config::tmtc_err;
 use std::sync::mpsc;
 use std::time::Duration;

satrs-example/src/pus/event.rs

@@ -10,7 +10,7 @@ use satrs::pus::{
     PartialPusHandlingError, PusServiceHelper,
 };
 use satrs::spacepackets::ecss::PusServiceId;
-use satrs_example::config::components::PUS_EVENT_MANAGEMENT;
+use satrs_example::config::pus::PUS_EVENT_MANAGEMENT;
 
 use super::{DirectPusService, HandlingStatus};
 

satrs-example/src/pus/hk.rs

@@ -13,7 +13,7 @@ use satrs::request::{GenericMessage, UniqueApidTargetId};
 use satrs::res_code::ResultU16;
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{hk, PusPacket, PusServiceId};
-use satrs_example::config::components::PUS_HK_SERVICE;
+use satrs_example::config::pus::PUS_HK_SERVICE;
 use satrs_example::config::{hk_err, tmtc_err};
 use std::sync::mpsc;
 use std::time::Duration;

satrs-example/src/pus/mod.rs

@@ -18,7 +18,7 @@ use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
 use satrs::tmtc::{PacketAsVec, PacketInPool};
 use satrs::ComponentId;
-use satrs_example::config::components::PUS_ROUTING_SERVICE;
+use satrs_example::config::pus::PUS_ROUTING_SERVICE;
 use satrs_example::config::{tmtc_err, CustomPusServiceId};
 use satrs_example::TimestampHelper;
 use std::fmt::Debug;

satrs-example/src/pus/mode.rs

@@ -1,5 +1,6 @@
 use derive_new::new;
 use satrs::mode_tree::{ModeNode, ModeParent};
+use satrs_example::config::pus::PUS_MODE_SERVICE;
 use std::sync::mpsc;
 use std::time::Duration;
 
@@ -33,7 +34,6 @@ use satrs::{
     },
     ComponentId,
 };
-use satrs_example::config::components::PUS_MODE_SERVICE;
 use satrs_example::config::{mode_err, tmtc_err, CustomPusServiceId};
 
 use super::{

satrs-example/src/pus/scheduler.rs

@@ -15,7 +15,7 @@ use satrs::pus::{
 use satrs::spacepackets::ecss::PusServiceId;
 use satrs::tmtc::{PacketAsVec, PacketInPool, PacketSenderWithSharedPool};
 use satrs::ComponentId;
-use satrs_example::config::components::PUS_SCHED_SERVICE;
+use satrs_example::config::pus::PUS_SCHED_SERVICE;
 
 use super::{DirectPusService, HandlingStatus};
 

satrs-example/src/pus/test.rs

@@ -11,7 +11,7 @@ use satrs::pus::{
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::{PusPacket, PusServiceId};
-use satrs_example::config::components::PUS_TEST_SERVICE;
+use satrs_example::config::pus::PUS_TEST_SERVICE;
 use satrs_example::config::{tmtc_err, TEST_EVENT};
 use std::sync::mpsc;
 

satrs-example/src/requests.rs

@@ -14,7 +14,7 @@ use satrs::request::{GenericMessage, MessageMetadata, UniqueApidTargetId};
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
 use satrs::ComponentId;
-use satrs_example::config::components::PUS_ROUTING_SERVICE;
+use satrs_example::config::pus::PUS_ROUTING_SERVICE;
 use satrs_example::config::tmtc_err;
 
 #[derive(Clone, Debug)]

satrs-minisim/src/acs.rs

@@ -203,7 +203,7 @@ pub mod tests {
         let sim_reply = sim_testbench.try_receive_next_reply();
         assert!(sim_reply.is_some());
         let sim_reply = sim_reply.unwrap();
-        assert_eq!(sim_reply.component(), SimComponent::MgmLis3Mdl);
+        assert_eq!(sim_reply.component(), SimComponent::Mgm0Lis3Mdl);
         let reply = MgmLis3MdlReply::from_sim_message(&sim_reply)
             .expect("failed to deserialize MGM sensor values");
         assert_eq!(reply.common.switch_state, SwitchStateBinary::Off);
@@ -226,7 +226,7 @@ pub mod tests {
         let mut sim_reply_res = sim_testbench.try_receive_next_reply();
         assert!(sim_reply_res.is_some());
         let mut sim_reply = sim_reply_res.unwrap();
-        assert_eq!(sim_reply.component(), SimComponent::MgmLis3Mdl);
+        assert_eq!(sim_reply.component(), SimComponent::Mgm0Lis3Mdl);
         let first_reply = MgmLis3MdlReply::from_sim_message(&sim_reply)
             .expect("failed to deserialize MGM sensor values");
         sim_testbench.step_until(Duration::from_millis(50)).unwrap();

satrs-minisim/src/controller.rs

@@ -24,7 +24,8 @@ const PCDU_REQ_WIRETAPPING: bool = false;
 const MGT_REQ_WIRETAPPING: bool = false;
 
 pub struct ModelAddrWrapper {
-    mgm_addr: Address<MagnetometerModel<MgmLis3MdlReply>>,
+    mgm_0_addr: Address<MagnetometerModel<MgmLis3MdlReply>>,
+    mgm_1_addr: Address<MagnetometerModel<MgmLis3MdlReply>>,
     pcdu_addr: Address<PcduModel>,
     mgt_addr: Address<MagnetorquerModel>,
 }
@@ -42,12 +43,14 @@ pub struct SimController {
 
 impl ModelAddrWrapper {
     pub fn new(
-        mgm_addr: Address<MagnetometerModel<MgmLis3MdlReply>>,
+        mgm_0_addr: Address<MagnetometerModel<MgmLis3MdlReply>>,
+        mgm_1_addr: Address<MagnetometerModel<MgmLis3MdlReply>>,
         pcdu_addr: Address<PcduModel>,
         mgt_addr: Address<MagnetorquerModel>,
     ) -> Self {
         Self {
-            mgm_addr,
+            mgm_0_addr,
+            mgm_1_addr,
             pcdu_addr,
             mgt_addr,
         }
@@ -96,7 +99,8 @@ impl SimController {
                     }
                     if let Err(e) = match request.component() {
                         SimComponent::SimCtrl => self.handle_ctrl_request(&request),
-                        SimComponent::MgmLis3Mdl => self.handle_mgm_request(&request),
+                        SimComponent::Mgm0Lis3Mdl => self.handle_mgm_request(0, &request),
+                        SimComponent::Mgm1Lis3Mdl => self.handle_mgm_request(1, &request),
                         SimComponent::Mgt => self.handle_mgt_request(&request),
                         SimComponent::Pcdu => self.handle_pcdu_request(&request),
                     } {
@@ -128,19 +132,25 @@ impl SimController {
         Ok(())
     }
 
-    fn handle_mgm_request(&mut self, request: &SimRequest) -> Result<(), SimRequestError> {
+    fn handle_mgm_request(
+        &mut self,
+        mgm_idx: usize,
+        request: &SimRequest,
+    ) -> Result<(), SimRequestError> {
         let mgm_request = MgmRequestLis3Mdl::from_sim_message(request)?;
         if MGM_REQ_WIRETAPPING {
             log::info!("received MGM request: {:?}", mgm_request);
         }
         match mgm_request {
             MgmRequestLis3Mdl::RequestSensorData => {
+                let addr = match mgm_idx {
+                    0 => &self.addr_wrapper.mgm_0_addr,
+                    1 => &self.addr_wrapper.mgm_1_addr,
+
+                    _ => panic!("invalid mgm index"),
+                };
                 self.simulation
-                    .process_event(
-                        MagnetometerModel::send_sensor_values,
-                        (),
-                        &self.addr_wrapper.mgm_addr,
-                    )
+                    .process_event(MagnetometerModel::send_sensor_values, (), addr)
                     .expect("event execution error for mgm");
             }
         }

satrs-minisim/src/eps.rs

@@ -14,7 +14,8 @@ pub const SWITCH_INFO_DELAY_MS: u64 = 10;
 
 pub struct PcduModel {
     pub switcher_map: SwitchMapBinaryWrapper,
-    pub mgm_switch: Output<SwitchStateBinary>,
+    pub mgm_0_switch: Output<SwitchStateBinary>,
+    pub mgm_1_switch: Output<SwitchStateBinary>,
     pub mgt_switch: Output<SwitchStateBinary>,
     pub reply_sender: mpsc::Sender<SimReply>,
 }
@@ -23,7 +24,8 @@ impl PcduModel {
     pub fn new(reply_sender: mpsc::Sender<SimReply>) -> Self {
         Self {
             switcher_map: Default::default(),
-            mgm_switch: Output::new(),
+            mgm_0_switch: Output::new(),
+            mgm_1_switch: Output::new(),
             mgt_switch: Output::new(),
             reply_sender,
         }
@@ -55,7 +57,7 @@ impl PcduModel {
         *val = switch_and_target_state.1;
         match switch_and_target_state.0 {
             PcduSwitch::Mgm => {
-                self.mgm_switch.send(switch_and_target_state.1).await;
+                self.mgm_0_switch.send(switch_and_target_state.1).await;
             }
             PcduSwitch::Mgt => {
                 self.mgt_switch.send(switch_and_target_state.1).await;

satrs-minisim/src/lib.rs

@@ -5,7 +5,8 @@ use serde::{de::DeserializeOwned, Deserialize, Serialize};
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
 pub enum SimComponent {
     SimCtrl,
-    MgmLis3Mdl,
+    Mgm0Lis3Mdl,
+    Mgm1Lis3Mdl,
     Mgt,
     Pcdu,
 }
@@ -277,7 +278,7 @@ pub mod acs {
     }
 
     impl SerializableSimMsgPayload<SimRequest> for MgmRequestLis3Mdl {
-        const TARGET: SimComponent = SimComponent::MgmLis3Mdl;
+        const TARGET: SimComponent = SimComponent::Mgm0Lis3Mdl;
     }
 
     // Normally, small magnetometers generate their output as a signed 16 bit raw format or something
@@ -368,7 +369,7 @@ pub mod acs {
         }
 
         impl SerializableSimMsgPayload<SimReply> for MgmLis3MdlReply {
-            const TARGET: SimComponent = SimComponent::MgmLis3Mdl;
+            const TARGET: SimComponent = SimComponent::Mgm0Lis3Mdl;
         }
 
         impl MgmReplyProvider for MgmLis3MdlReply {
@@ -418,7 +419,7 @@ pub mod acs {
     }
 
     impl SerializableSimMsgPayload<SimReply> for MgtReply {
-        const TARGET: SimComponent = SimComponent::MgmLis3Mdl;
+        const TARGET: SimComponent = SimComponent::Mgm0Lis3Mdl;
     }
 }
 

satrs-minisim/src/main.rs

@@ -31,11 +31,15 @@ fn create_sim_controller(
     request_receiver: mpsc::Receiver<SimRequest>,
 ) -> SimController {
     // Instantiate models and their mailboxes.
-    let mgm_model =
+    let mgm_0_model =
+        MagnetometerModel::new_for_lis3mdl(Duration::from_millis(50), reply_sender.clone());
+    let mgm_1_model =
         MagnetometerModel::new_for_lis3mdl(Duration::from_millis(50), reply_sender.clone());
 
-    let mgm_mailbox = Mailbox::new();
-    let mgm_addr = mgm_mailbox.address();
+    let mgm_0_mailbox = Mailbox::new();
+    let mgm_0_addr = mgm_0_mailbox.address();
+    let mgm_1_mailbox = Mailbox::new();
+    let mgm_1_addr = mgm_1_mailbox.address();
     let pcdu_mailbox = Mailbox::new();
     let pcdu_addr = pcdu_mailbox.address();
     let mgt_mailbox = Mailbox::new();
@@ -43,8 +47,11 @@ fn create_sim_controller(
 
     let mut pcdu_model = PcduModel::new(reply_sender.clone());
     pcdu_model
-        .mgm_switch
-        .connect(MagnetometerModel::switch_device, &mgm_addr);
+        .mgm_0_switch
+        .connect(MagnetometerModel::switch_device, &mgm_0_addr);
+    pcdu_model
+        .mgm_1_switch
+        .connect(MagnetometerModel::switch_device, &mgm_1_addr);
 
     let mut mgt_model = MagnetorquerModel::new(reply_sender.clone());
     // Input connections.
@@ -52,9 +59,14 @@ fn create_sim_controller(
         .mgt_switch
         .connect(MagnetorquerModel::switch_device, &mgt_addr);
     // Output connections.
-    mgt_model
-        .gen_magnetic_field
-        .connect(MagnetometerModel::apply_external_magnetic_field, &mgm_addr);
+    mgt_model.gen_magnetic_field.connect(
+        MagnetometerModel::apply_external_magnetic_field,
+        &mgm_0_addr,
+    );
+    mgt_model.gen_magnetic_field.connect(
+        MagnetometerModel::apply_external_magnetic_field,
+        &mgm_1_addr,
+    );
 
     // Instantiate the simulator
     let sys_clock = SystemClock::from_system_time(start_time, SystemTime::now());
@@ -63,9 +75,10 @@ fn create_sim_controller(
     } else {
         SimInit::new()
     };
-    let addrs = ModelAddrWrapper::new(mgm_addr, pcdu_addr, mgt_addr);
+    let addrs = ModelAddrWrapper::new(mgm_0_addr, mgm_1_addr, pcdu_addr, mgt_addr);
     let (simulation, scheduler) = sim_init
-        .add_model(mgm_model, mgm_mailbox, "MGM model")
+        .add_model(mgm_0_model, mgm_0_mailbox, "MGM 0 model")
+        .add_model(mgm_1_model, mgm_1_mailbox, "MGM 1 model")
         .add_model(pcdu_model, pcdu_mailbox, "PCDU model")
         .add_model(mgt_model, mgt_mailbox, "MGT model")
         .init(start_time)

satrs/CHANGELOG.md

@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 # [unreleased]
 
+# [v0.3.0-alpha.0] 2025-02-18
+
+`spacepackets` v0.13
+
 ## Changed
 
 - Renamed `StaticPoolConfig::new` to `StaticPoolConfig::new_from_subpool_cfg_tuples`. The new

satrs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs"
-version = "0.2.1"
+version = "0.3.0-alpha.0"
 edition = "2021"
 rust-version = "1.82.0"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]

satrs/src/subsystem.rs

@@ -121,10 +121,10 @@ impl SequenceExecutionHelper {
     ///   example by checking [mode replies][ModeReply] received by the children components, and
     ///   then calling [Self::confirm_sequence_done] to advance to the sequence or complete the
     ///   sequence.
-    /// * [ModeCommandingResult::CommandingDone] - The sequence is done. The user can load a new
+    /// * [ModeCommandingResult::Done] - The sequence is done. The user can load a new
     ///   sequence now without overwriting the last one. The sequence executor is in
     ///   [SequenceExecutionHelperState::Idle] again.
-    /// * [ModeCommandingResult::CommandingStepDone] - The sequence has advanced one step. The user
+    /// * [ModeCommandingResult::StepDone] - The sequence has advanced one step. The user
     ///   can now call [Self::run] again to immediately execute the next step in the sequence.
     ///
     /// Generally, periodic execution of the [Self::run] method should be performed while