re-work ACS

satrs-example/models/src/lib.rs

@@ -1,4 +1,6 @@
 extern crate alloc;
+use core::str::FromStr;
+
 use spacepackets::{
     CcsdsPacketIdAndPsc,
     time::cds::{CdsTime, MIN_CDS_FIELD_LEN},
@@ -7,6 +9,7 @@ use spacepackets::{
 pub mod ccsds;
 pub mod control;
 pub mod mgm;
+pub mod mgm_assembly;
 pub mod pcdu;
 
 #[derive(
@@ -152,13 +155,32 @@ pub trait Message {
     fn message_type(&self) -> MessageType;
 }
 
+/// Generic device mode which covers the requirements of most devices.
+///
+/// The states are related both to the physical and the logical state of the device. Some
+/// device handlers control the power supply of their own device and an off state might also
+/// mean that the device is physically off.
 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Copy, Clone)]
 pub enum DeviceMode {
     Off = 0,
     On = 1,
+    /// Normal operation mode where periodic polling might be done as well.
     Normal = 2,
 }
 
+impl FromStr for DeviceMode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "off" => Ok(DeviceMode::Off),
+            "on" => Ok(DeviceMode::On),
+            "normal" => Ok(DeviceMode::Normal),
+            _ => Err(()),
+        }
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 #[non_exhaustive]
 pub enum HkRequestType {

satrs-example/models/src/mgm.rs

@@ -1,5 +1,11 @@
 pub mod request {
-    use crate::{HkRequestType, Message};
+    use crate::{DeviceMode, HkRequestType, Message};
+
+    #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+    pub enum ModeRequest {
+        SetMode(DeviceMode),
+        ReadMode,
+    }
 
     #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
     pub enum HkId {
@@ -16,7 +22,7 @@ pub mod request {
     pub enum Request {
         Ping,
         Hk(HkRequest),
-        Mode(crate::DeviceMode),
+        Mode(ModeRequest),
     }
 
     impl Request {
@@ -44,17 +50,26 @@ pub struct MgmData {
 }
 
 pub mod response {
-    use crate::{Message, mgm::MgmData};
+    use crate::{DeviceMode, Message, mgm::MgmData};
 
     #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
     pub enum HkResponse {
         MgmData(MgmData),
     }
 
+    #[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy)]
+    pub enum ModeResponse {
+        /// New mode has been set.
+        Mode(DeviceMode),
+        /// Setting a mode timed out.
+        SetModeTimeout,
+    }
+
     #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
     pub enum Response {
         Ok,
         Hk(HkResponse),
+        Mode(ModeResponse),
     }
 
     impl Response {
@@ -62,6 +77,7 @@ pub mod response {
             match self {
                 Response::Ok => crate::MessageType::Verification,
                 Response::Hk(_hk_response) => crate::MessageType::Hk,
+                Response::Mode(_mode_failure) => crate::MessageType::Mode,
             }
         }
     }

satrs-example/models/src/mgm_assembly.rs

@@ -0,0 +1,109 @@
+use core::str::FromStr;
+
+use crate::DeviceMode;
+
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AssemblyMode {
+    /// The assembly mode ressembles the modes of the devices it controls. It also tries to keep
+    /// the children in the correct mode by re-commanding them into the correct mode.
+    Device(DeviceMode),
+    /// Mode keeping disabled.
+    NoModeKeeping,
+}
+
+impl FromStr for AssemblyMode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "off" => Ok(AssemblyMode::Device(DeviceMode::Off)),
+            "on" => Ok(AssemblyMode::Device(DeviceMode::On)),
+            "normal" => Ok(AssemblyMode::Device(DeviceMode::Normal)),
+            "no_mode_keeping" => Ok(AssemblyMode::NoModeKeeping),
+            _ => Err(()),
+        }
+    }
+}
+
+pub mod request {
+    use crate::{HkRequestType, Message, mgm_assembly::AssemblyMode};
+
+    #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
+    pub enum HkId {
+        Sensor,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    pub enum ModeRequest {
+        SetMode(AssemblyMode),
+        ReadMode,
+    }
+
+    #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Serialize, serde::Deserialize)]
+    pub struct HkRequest {
+        pub id: HkId,
+        pub req_type: HkRequestType,
+    }
+
+    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug)]
+    pub enum Request {
+        Ping,
+        Mode(ModeRequest),
+    }
+
+    impl Request {
+        fn message_type(&self) -> crate::MessageType {
+            match self {
+                Request::Ping => crate::MessageType::Verification,
+                Request::Mode(_mode) => crate::MessageType::Mode,
+            }
+        }
+    }
+    impl Message for Request {
+        fn message_type(&self) -> crate::MessageType {
+            self.message_type()
+        }
+    }
+}
+
+pub mod response {
+    use crate::{DeviceMode, Message};
+
+    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
+    pub enum ModeCommandFailure {
+        Timeout,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+    pub enum ModeReport {
+        /// Mode of the assembly.
+        Mode(super::AssemblyMode),
+        /// Timeout failure setting the children modes.
+        SetModeTimeout([Option<DeviceMode>; 2]),
+        /// Children are in wrong mode after commanding.
+        WrongMode([Option<DeviceMode>; 2]),
+        /// An assembly tried modekeeping but can not keep its mode.
+        CanNotKeepMode([Option<DeviceMode>; 2]),
+    }
+
+    #[derive(serde::Serialize, serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
+    pub enum Response {
+        Ok,
+        Mode(ModeReport),
+    }
+
+    impl Response {
+        fn message_type(&self) -> crate::MessageType {
+            match self {
+                Response::Ok => crate::MessageType::Verification,
+                Response::Mode(_mode_report) => crate::MessageType::Mode,
+            }
+        }
+    }
+
+    impl Message for Response {
+        fn message_type(&self) -> crate::MessageType {
+            self.message_type()
+        }
+    }
+}