added intermediate changes to power and pld handler

pyclient/main copy.py

@@ -110,6 +110,7 @@ class SatRsConfigHook(HookBase):
 
         srv_11 = OpCodeEntry()
         srv_11.add("0", "Scheduled TC Test")
+        srv_11.add("1", "Scheduled Camera Request TC")
         defs.add_service(
             name=CoreServiceList.SERVICE_11,
             info="PUS Service 11 TC Scheduling",
@@ -287,17 +288,30 @@ class TcHandler(TcHandlerBase):
                 q.add_log_cmd("Sending PUS ping telecommand")
                 return q.add_pus_tc(PusTelecommand(service=17, subservice=1))
             if service == CoreServiceList.SERVICE_11:
-                q.add_log_cmd("Sending PUS scheduled TC telecommand")
+                if op_code == "0":
-                crt_time = CdsShortTimestamp.from_now()
+                    q.add_log_cmd("Sending PUS scheduled TC telecommand")
-                time_stamp = crt_time + datetime.timedelta(seconds=10)
+                    crt_time = CdsShortTimestamp.from_now()
-                time_stamp = time_stamp.pack()
+                    time_stamp = crt_time + datetime.timedelta(seconds=10)
-                return q.add_pus_tc(
+                    time_stamp = time_stamp.pack()
-                    create_time_tagged_cmd(
+                    return q.add_pus_tc(
-                        time_stamp,
+                        create_time_tagged_cmd(
-                        PusTelecommand(service=17, subservice=1),
+                            time_stamp,
-                        apid=EXAMPLE_PUS_APID,
+                            PusTelecommand(service=17, subservice=1),
+                            apid=EXAMPLE_PUS_APID,
+                        )
+                    )
+                if op_code == "1":
+                    q.add_log_cmd("Sending PUS scheduled TC telecommand")
+                    crt_time = CdsShortTimestamp.from_now()
+                    time_stamp = crt_time + datetime.timedelta(seconds=10)
+                    time_stamp = time_stamp.pack()
+                    return q.add_pus_tc(
+                        create_time_tagged_cmd(
+                            time_stamp,
+                            PusTelecommand(service=8, subservice=1, app_data=make_target_id(RequestTargetId.PLD)),
+                            apid=EXAMPLE_PUS_APID,
+                        )
                     )
-                )
             if service == CoreServiceList.SERVICE_8:
                 q.add_log_cmd("Sending PUS action request telecommand")
                 return q.add_pus_tc(

src/aocs_handler.rs

@@ -0,0 +1 @@
+

src/can.rs

@@ -2,7 +2,7 @@
 #![allow(unused_variables)]
 #![allow(unused_imports)]
 
-use crate::pcdu::DeviceState;
+use crate::power_handler::DeviceState;
 
 use crate::can_ids::{
     can_id_to_package_id, package_id_to_can_id, value_to_package_id, DeviceId, PackageId,

src/can_ids.rs

@@ -95,29 +95,29 @@ impl TryFrom<u16> for DeviceId {
 
     fn try_from(v: u16) -> Result<Self, Self::Error> {
         match v {
-            x if x==DeviceId::OBC as u16 => Ok(DeviceId::OBC),
+            x if x == DeviceId::OBC as u16 => Ok(DeviceId::OBC),
-            x if x==DeviceId::PCDU as u16 => Ok(DeviceId::PCDU),
+            x if x == DeviceId::PCDU as u16 => Ok(DeviceId::PCDU),
-            x if x==DeviceId::MGM1 as u16 => Ok(DeviceId::MGM1),
+            x if x == DeviceId::MGM1 as u16 => Ok(DeviceId::MGM1),
-            x if x==DeviceId::MGM2 as u16 => Ok(DeviceId::MGM2),
+            x if x == DeviceId::MGM2 as u16 => Ok(DeviceId::MGM2),
-            x if x==DeviceId::MGM3 as u16 => Ok(DeviceId::MGM3),
+            x if x == DeviceId::MGM3 as u16 => Ok(DeviceId::MGM3),
-            x if x==DeviceId::MGM4 as u16 => Ok(DeviceId::MGM4),
+            x if x == DeviceId::MGM4 as u16 => Ok(DeviceId::MGM4),
-            x if x==DeviceId::SunSensor1 as u16 => Ok(DeviceId::SunSensor1),
+            x if x == DeviceId::SunSensor1 as u16 => Ok(DeviceId::SunSensor1),
-            x if x==DeviceId::SunSensor2 as u16 => Ok(DeviceId::SunSensor2),
+            x if x == DeviceId::SunSensor2 as u16 => Ok(DeviceId::SunSensor2),
-            x if x==DeviceId::SunSensor3 as u16 => Ok(DeviceId::SunSensor3),
+            x if x == DeviceId::SunSensor3 as u16 => Ok(DeviceId::SunSensor3),
-            x if x==DeviceId::SunSensor4 as u16 => Ok(DeviceId::SunSensor4),
+            x if x == DeviceId::SunSensor4 as u16 => Ok(DeviceId::SunSensor4),
-            x if x==DeviceId::SunSensor5 as u16 => Ok(DeviceId::SunSensor5),
+            x if x == DeviceId::SunSensor5 as u16 => Ok(DeviceId::SunSensor5),
-            x if x==DeviceId::SunSensor6 as u16 => Ok(DeviceId::SunSensor6),
+            x if x == DeviceId::SunSensor6 as u16 => Ok(DeviceId::SunSensor6),
-            x if x==DeviceId::StarTracker as u16 => Ok(DeviceId::StarTracker),
+            x if x == DeviceId::StarTracker as u16 => Ok(DeviceId::StarTracker),
-            x if x==DeviceId::MGT1 as u16 => Ok(DeviceId::MGT1),
+            x if x == DeviceId::MGT1 as u16 => Ok(DeviceId::MGT1),
-            x if x==DeviceId::MGT2 as u16 => Ok(DeviceId::MGT2),
+            x if x == DeviceId::MGT2 as u16 => Ok(DeviceId::MGT2),
-            x if x==DeviceId::MGT3 as u16 => Ok(DeviceId::MGT3),
+            x if x == DeviceId::MGT3 as u16 => Ok(DeviceId::MGT3),
-            x if x==DeviceId::MGT4 as u16 => Ok(DeviceId::MGT4),
+            x if x == DeviceId::MGT4 as u16 => Ok(DeviceId::MGT4),
-            x if x==DeviceId::RWL1 as u16 => Ok(DeviceId::RWL1),
+            x if x == DeviceId::RWL1 as u16 => Ok(DeviceId::RWL1),
-            x if x==DeviceId::RWL2 as u16 => Ok(DeviceId::RWL2),
+            x if x == DeviceId::RWL2 as u16 => Ok(DeviceId::RWL2),
-            x if x==DeviceId::RWL3 as u16 => Ok(DeviceId::RWL3),
+            x if x == DeviceId::RWL3 as u16 => Ok(DeviceId::RWL3),
-            x if x==DeviceId::RWL4 as u16 => Ok(DeviceId::RWL4),
+            x if x == DeviceId::RWL4 as u16 => Ok(DeviceId::RWL4),
-            x if x==DeviceId::Camera as u16 => Ok(DeviceId::Camera),
+            x if x == DeviceId::Camera as u16 => Ok(DeviceId::Camera),
-            x if x==DeviceId::All as u16 => Ok(DeviceId::All),
+            x if x == DeviceId::All as u16 => Ok(DeviceId::All),
             _ => Err(()),
         }
     }

src/hk.rs

@@ -3,7 +3,7 @@ use satrs_core::tmtc::AddressableId;
 pub type CollectionIntervalFactor = u32;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum AcsHkIds {
+pub enum AocsHkIds {
     TestMgmSet = 1,
 }
 
@@ -14,3 +14,5 @@ pub enum HkRequest {
     Disable(AddressableId),
     ModifyCollectionInterval(AddressableId, CollectionIntervalFactor),
 }
+
+pub struct AocsHkHandler {}

src/main.rs

@@ -1,16 +1,17 @@
 mod action;
 mod aocs;
+mod aocs_handler;
 mod cam;
 mod can;
 mod can_ids;
 mod ccsds;
-mod pld_handler;
 mod hk;
 mod logger;
+mod pld_handler;
+mod power_handler;
 mod pus;
 mod requests;
 mod tmtc;
-mod pcdu;
 
 use crate::requests::{Request, RequestWithToken};
 use crate::tmtc::{
@@ -23,37 +24,34 @@ use satrs_core::event_man::{
 use satrs_core::events::EventU32;
 use satrs_core::pool::{LocalPool, PoolCfg, StoreAddr};
 use satrs_core::pus::event_man::{
-    DefaultPusMgmtBackendProvider, EventReporter, EventRequestWithToken,
+    DefaultPusMgmtBackendProvider, EventReporter, EventRequestWithToken, PusEventDispatcher,
-    PusEventDispatcher,
 };
 use satrs_core::pus::verification::{
     MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender,
 };
 use satrs_core::pus::{EcssTmErrorWithSend, EcssTmSenderCore};
-use satrs_core::seq_count::{
+use satrs_core::seq_count::SeqCountProviderSyncClonable;
-    SeqCountProviderSyncClonable,
-};
 use satrs_core::{
-    spacepackets::time::cds::TimeProvider,
+    spacepackets::time::cds::TimeProvider, spacepackets::time::TimeWriter, spacepackets::tm::PusTm,
-    spacepackets::time::TimeWriter,
-    spacepackets::tm::{PusTm},
 };
 use strum::IntoEnumIterator;
 
-use crate::can_ids::{can_id_to_package_id, DeviceId, load_package_ids, PackageId, PackageModel, ThreadId};
+use crate::can_ids::{
+    can_id_to_package_id, load_package_ids, DeviceId, PackageId, PackageModel, ThreadId,
+};
 use embedded_can::{Id, StandardId};
 use log::{info, warn};
+use satrs_core::power::{SwitchId, SwitchState};
 use std::collections::HashMap;
 use std::net::{IpAddr, SocketAddr};
-use std::sync::mpsc::{channel};
+use std::sync::mpsc::channel;
-use std::sync::{mpsc, Arc, RwLock, Mutex};
+use std::sync::{mpsc, Arc, Mutex, RwLock};
 use std::thread;
-use satrs_core::power::{SwitchId, SwitchState};
 //use libc::time64_t;
 use crate::action::ActionRequest;
 use crate::cam::CameraRequest;
-use crate::pld_handler::{CameraHandler, core_pld_task};
+use crate::pld_handler::{core_pld_task, CameraHandler};
-use crate::pcdu::{core_power_task, PowerSwitcher};
+use crate::power_handler::{core_power_task, PowerSwitcher};
 
 #[derive(Clone)]
 struct EventTmSender {
@@ -210,11 +208,10 @@ fn main() {
     let pcdu_can_tx =
         can::CanTxHandler::new_socket("can0", ThreadId::PowerThread, load_package_ids()).unwrap();
 
-
     let mut device_state_map = HashMap::new();
-        for id in DeviceId::iter() {
+    for id in DeviceId::iter() {
-            device_state_map.insert(id, SwitchState::Off);
+        device_state_map.insert(id, SwitchState::Off);
-        }
+    }
     let clonable_device_state_map = Arc::new(Mutex::new(device_state_map));
 
     let mut power_switcher = PowerSwitcher::new(pcdu_tx, clonable_device_state_map.clone());
@@ -222,10 +219,14 @@ fn main() {
     info!("Starting power task");
     let builder2 = thread::Builder::new().name("PowerThread".into());
     let jh2 = builder2.spawn(move || {
-        core_power_task(pcdu_rx, pcdu_can_tx, power_can_rx, clonable_device_state_map.clone());
+        core_power_task(
+            pcdu_rx,
+            pcdu_can_tx,
+            power_can_rx,
+            clonable_device_state_map.clone(),
+        );
     });
 
-
     let package_map_aocs_tx = load_package_ids();
     let aocs_tm_funnel_tx = tm_funnel_tx.clone();
     let mut aocs_tm_store = tm_store.clone();
@@ -333,7 +334,12 @@ fn main() {
     println!("Starting Payload Handling task");
     let builder3 = thread::Builder::new().name("PLDThread".into());
     let jh3 = builder3.spawn(move || {
-        core_pld_task(power_switcher.clone(), pld_thread_rx, pld_can_rx, &mut reporter_pld);
+        core_pld_task(
+            power_switcher.clone(),
+            pld_thread_rx,
+            pld_can_rx,
+            &mut reporter_pld,
+        );
     });
 
     println!("Starting TM funnel task");
@@ -361,7 +367,9 @@ fn main() {
         .expect("Joining CAN Bus Listening thread failed");
     jh2.unwrap().join().expect("Joining power thread failed");
     jh3.unwrap().join().expect("Joining PLD thread failed");
-    jh4.unwrap().join().expect("Joining TM funnel thread failed");
+    jh4.unwrap()
+        .join()
+        .expect("Joining TM funnel thread failed");
 }
 #[derive(Default)]
 struct MgmData {

src/pld_handler.rs

@@ -1,17 +1,16 @@
-use std::sync::mpsc;
+use crate::action::ActionRequest;
-use std::sync::mpsc::{Receiver, Sender, TryRecvError};
+use crate::can::CanTxHandler;
+use crate::can_ids::{load_package_ids, DeviceId, PackageId, PackageModel, ThreadId};
+use crate::power_handler::{DeviceState, PowerSwitcher};
+use crate::requests::{Request, RequestWithToken};
+use eurosim_obsw::RequestTargetId;
 use log::info;
-use satrs_core::power::{PowerSwitcherCommandSender, PowerSwitchInfo, SwitchId, SwitchState};
+use satrs_core::power::{PowerSwitchInfo, PowerSwitcherCommandSender, SwitchId, SwitchState};
 use satrs_core::pus::verification::{StdVerifSenderError, VerificationReporterWithSender};
 use satrs_core::spacepackets::time::cds::TimeProvider;
 use satrs_core::spacepackets::time::TimeWriter;
-use eurosim_obsw::RequestTargetId;
+use std::sync::mpsc;
-use crate::action::ActionRequest;
+use std::sync::mpsc::{Receiver, Sender, TryRecvError};
-use crate::can::CanTxHandler;
-use crate::can_ids::{DeviceId, load_package_ids, PackageId, PackageModel, ThreadId};
-use crate::pld_handler::CameraMode::PictureRequest;
-use crate::pcdu::{DeviceState, PowerSwitcher};
-use crate::requests::{Request, RequestWithToken};
 
 #[derive(Debug, PartialEq, Copy, Clone)]
 pub enum CameraMode {
@@ -31,18 +30,36 @@ pub struct CameraHandler {
     can_rx: Receiver<PackageModel>,
     mode: CameraMode,
     mode_rx: Receiver<CameraMode>,
+    action_rx: Receiver<RequestWithToken>,
 }
 
 impl CameraHandler {
-    pub fn new(power_switcher: PowerSwitcher, camera_device_id: DeviceId, can_tx: CanTxHandler, can_rx: Receiver<PackageModel>, mode_rx: Receiver<CameraMode>) -> CameraHandler {
+    pub fn new(
+        power_switcher: PowerSwitcher,
+        camera_device_id: DeviceId,
+        can_tx: CanTxHandler,
+        can_rx: Receiver<PackageModel>,
+        mode_rx: Receiver<CameraMode>,
+        action_rx: Receiver<RequestWithToken>,
+    ) -> CameraHandler {
         let camera_switch_id = camera_device_id as u16;
-        CameraHandler{power_switcher, camera_device_id, camera_switch_id, device_state: DeviceState::Off, can_tx, can_rx, mode: CameraMode::Idle, mode_rx}
+        CameraHandler {
+            power_switcher,
+            camera_device_id,
+            camera_switch_id,
+            device_state: DeviceState::Off,
+            can_tx,
+            can_rx,
+            mode: CameraMode::Idle,
+            mode_rx,
+            action_rx,
+        }
     }
 
     pub fn set_mode(&mut self, mode: CameraMode) {
-        if self.mode == CameraMode::Idle{
+        if self.mode == CameraMode::Idle {
             if mode == CameraMode::PictureRequest {
-                self.mode = PictureRequest;
+                self.mode = CameraMode::PictureRequest;
             }
         }
     }
@@ -51,6 +68,62 @@ impl CameraHandler {
         self.mode
     }
 
+    pub fn handle_mode_requests(&mut self) {
+        match self.mode_rx.try_recv() {
+            Ok(mode) => {
+                self.set_mode(mode);
+            }
+            Err(_) => {}
+        }
+    }
+
+    /*pub fn handle_action_requests(&mut self) {
+        match self.action_rx.try_recv() {
+            Ok(request_with_token) => {
+                match request_with_token.0 {
+                    Request::ActionRequest(action_id) => {
+                        match action_id {
+                            ActionRequest::ImageRequest(target_id) => {
+                                assert_eq!(target_id, RequestTargetId::PldSubsystem);
+                                camera_handler.set_mode(CameraMode::PictureRequest);
+
+                                let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
+                                cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
+                                // send start verification and get token
+                                let start_token = reporter_pld
+                                    .start_success(request_with_token.1, Some(&time_stamp_buf))
+                                    .expect("Error sending start success.");
+
+                                info!("{:?}", camera_handler.get_mode());
+                                while camera_handler.get_mode() != CameraMode::Idle {
+                                    camera_handler.periodic_op();
+                                }
+
+                                let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
+                                cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
+                                // send end verification with token
+                                reporter_pld
+                                    .completion_success(
+                                        start_token,
+                                        Some(&time_stamp_buf),
+                                    )
+                                    .expect("Error sending start success.");
+                            }
+                            ActionRequest::OrientationRequest(_) => {}
+                            ActionRequest::PointingRequest(_) => {}
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            Err(_) => {}
+        }
+    }
+
+     */
+
+    pub fn take_picture(&mut self) {}
+
     pub fn periodic_op(&mut self) {
         // Camera Device Handler State Machine
 
@@ -58,12 +131,18 @@ impl CameraHandler {
             CameraMode::Idle => {}
             CameraMode::PictureRequest => {
                 if self.device_state == DeviceState::Off {
-                    self.power_switcher.send_switch_on_cmd(self.camera_switch_id).expect("sending switch cmd failed");
+                    self.power_switcher
+                        .send_switch_on_cmd(self.camera_switch_id)
+                        .expect("sending switch cmd failed");
                     self.device_state = DeviceState::SwitchingPower;
                     info!("switching power");
                 }
                 if self.device_state == DeviceState::SwitchingPower {
-                    if self.power_switcher.get_is_switch_on(self.camera_switch_id).expect("reading switch state failed") {
+                    if self
+                        .power_switcher
+                        .get_is_switch_on(self.camera_switch_id)
+                        .expect("reading switch state failed")
+                    {
                         self.device_state = DeviceState::On;
                         info!("device on");
                     }
@@ -99,14 +178,20 @@ impl CameraHandler {
                     info!("waiting for image end confirmation");
                     if let Ok(msg) = self.can_rx.recv() {
                         if msg.package_id() == PackageId::CameraImageExectutionEnd {
-                            self.power_switcher.send_switch_off_cmd(self.camera_switch_id).expect("sending switch command failed");
+                            self.power_switcher
+                                .send_switch_off_cmd(self.camera_switch_id)
+                                .expect("sending switch command failed");
                             self.device_state = DeviceState::SwitchingPower;
                             info!("switching power");
                         }
                     }
                 }
                 if self.device_state == DeviceState::SwitchingPower {
-                    if !self.power_switcher.get_is_switch_on(self.camera_switch_id).expect("reading switch state failed") {
+                    if !self
+                        .power_switcher
+                        .get_is_switch_on(self.camera_switch_id)
+                        .expect("reading switch state failed")
+                    {
                         self.device_state = DeviceState::Off;
                         info!("device off");
                     }
@@ -119,12 +204,25 @@ impl CameraHandler {
     }
 }
 
-pub fn core_pld_task(power_switcher: PowerSwitcher, pld_thread_rx: Receiver<RequestWithToken>, pld_can_rx: Receiver<PackageModel>, reporter_pld: &mut VerificationReporterWithSender<StdVerifSenderError>) {
+pub fn core_pld_task(
+    power_switcher: PowerSwitcher,
+    pld_thread_rx: Receiver<RequestWithToken>,
+    pld_can_rx: Receiver<PackageModel>,
+    reporter_pld: &mut VerificationReporterWithSender<StdVerifSenderError>,
+) {
     let (camera_mode_tx, camera_mode_rx) = mpsc::channel();
+    let (action_tx, action_rx) = mpsc::channel();
     let camera_can_tx =
         CanTxHandler::new_socket("can0", ThreadId::PLDThread, load_package_ids()).unwrap();
 
-    let mut camera_handler = CameraHandler::new(power_switcher, DeviceId::Camera, camera_can_tx, pld_can_rx, camera_mode_rx);
+    let mut camera_handler = CameraHandler::new(
+        power_switcher,
+        DeviceId::Camera,
+        camera_can_tx,
+        pld_can_rx,
+        camera_mode_rx,
+        action_rx,
+    );
 
     let mut time_stamp_buf: [u8; 7] = [0; 7];
     loop {
@@ -149,12 +247,11 @@ pub fn core_pld_task(power_switcher: PowerSwitcher, pld_thread_rx: Receiver<Requ
                                     camera_handler.periodic_op();
                                 }
 
+                                let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
+                                cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
                                 // send end verification with token
                                 reporter_pld
-                                    .completion_success(
+                                    .completion_success(start_token, Some(&time_stamp_buf))
-                                        start_token,
-                                        Some(&time_stamp_buf),
-                                    )
                                     .expect("Error sending start success.");
                             }
                             ActionRequest::OrientationRequest(_) => {}
@@ -167,5 +264,4 @@ pub fn core_pld_task(power_switcher: PowerSwitcher, pld_thread_rx: Receiver<Requ
             Err(_) => {}
         }
     }
-
+}
-}

src/power_handler.rs

@@ -1,17 +1,19 @@
-use std::collections::HashMap;
+use crate::can::CanTxHandler;
-use std::sync::mpsc::{Receiver, Sender};
-use satrs_core::power::{PowerSwitcherCommandSender, PowerSwitchInfo, PowerSwitchProvider, SwitchId, SwitchState};
-use crate::can::{CanTxHandler};
 use crate::can_ids::{DeviceId, PackageId, PackageModel};
+use log::info;
+use satrs_core::power::{
+    PowerSwitchInfo, PowerSwitchProvider, PowerSwitcherCommandSender, SwitchId, SwitchState,
+};
+use std::collections::HashMap;
 use std::convert::TryFrom;
+use std::sync::mpsc::{Receiver, Sender};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use std::vec;
-use log::info;
 pub use strum::IntoEnumIterator; // 0.17.1
 pub use strum_macros::EnumIter; // 0.17.1
 
-#[derive(Copy, Clone, Debug, PartialEq,  EnumIter)]
+#[derive(Copy, Clone, Debug, PartialEq, EnumIter)]
 pub enum DeviceState {
     On,
     Off,
@@ -34,8 +36,14 @@ pub struct PCDU {
 }
 
 impl PowerSwitcher {
-    pub fn new(switch_tx: Sender<(SwitchId, SwitchState)>, device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>) -> PowerSwitcher {
+    pub fn new(
-        PowerSwitcher{switch_tx, device_state_map}
+        switch_tx: Sender<(SwitchId, SwitchState)>,
+        device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>,
+    ) -> PowerSwitcher {
+        PowerSwitcher {
+            switch_tx,
+            device_state_map,
+        }
     }
 }
 
@@ -44,16 +52,16 @@ impl PowerSwitcherCommandSender for PowerSwitcher {
 
     fn send_switch_on_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error> {
         return match self.switch_tx.send((switch_id, SwitchState::On)) {
-            Ok(_) => {Ok(())}
+            Ok(_) => Ok(()),
-            Err(_) => {Err(())}
+            Err(_) => Err(()),
-        }
+        };
     }
 
     fn send_switch_off_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error> {
         return match self.switch_tx.send((switch_id, SwitchState::Off)) {
-            Ok(_) => {Ok(())}
+            Ok(_) => Ok(()),
-            Err(_) => {Err(())}
+            Err(_) => Err(()),
-        }
+        };
     }
 }
 
@@ -67,11 +75,10 @@ impl PowerSwitchInfo for PowerSwitcher {
                 Ok(*state)
             } else {
                 Err(())
-            }
+            };
         } else {
             Err(())
         }
-
     }
 
     fn switch_delay_ms(&self) -> u32 {
@@ -84,8 +91,18 @@ impl PowerSwitchProvider for PowerSwitcher {
 }
 
 impl PCDU {
-    pub fn new(switch_rx: Receiver<(SwitchId, SwitchState)>, can_tx: CanTxHandler, can_rx: Receiver<PackageModel>, device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>) -> PCDU{
+    pub fn new(
-        PCDU{switch_rx, can_tx, can_rx, device_state_map}
+        switch_rx: Receiver<(SwitchId, SwitchState)>,
+        can_tx: CanTxHandler,
+        can_rx: Receiver<PackageModel>,
+        device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>,
+    ) -> PCDU {
+        PCDU {
+            switch_rx,
+            can_tx,
+            can_rx,
+            device_state_map,
+        }
     }
 
     pub fn send_power_on(&mut self, switch_id: SwitchId) -> Result<(), ()> {
@@ -95,12 +112,13 @@ impl PCDU {
             self.can_tx.tx_socket(PackageId::DevicePowerOnRequest, buf);
             let mut map_lock = self.device_state_map.lock().unwrap();
             *map_lock.get_mut(&dev_id).unwrap() = SwitchState::Unknown;
+            // TODO: potentially change bus logic -> remove acceptance and verification of power off/on, since status is simply called in next step anyway
             self.can_rx.recv();
             self.can_rx.recv();
             Ok(())
         } else {
             Err(())
-        }
+        };
     }
 
     pub fn send_power_off(&mut self, switch_id: SwitchId) -> Result<(), ()> {
@@ -115,30 +133,27 @@ impl PCDU {
             Ok(())
         } else {
             Err(())
-        }
+        };
     }
 
     pub fn update_states_helper(&mut self, dev_id: &DeviceId) -> Result<(), ()> {
         let switch_id: SwitchId = *dev_id as u16;
         let dev_id_bytes = *dev_id as u8;
         let buf: &[u8] = &dev_id_bytes.to_be_bytes();
-        self.can_tx.tx_socket(PackageId::DevicePowerStatusRequest, buf);
+        self.can_tx
+            .tx_socket(PackageId::DevicePowerStatusRequest, buf);
         match self.can_rx.recv_timeout(Duration::from_secs(10)) {
             Ok(msg) => {
-                if msg.package_id() == PackageId::DevicePowerStatusResponse && msg.data()[0] == dev_id_bytes{
+                if msg.package_id() == PackageId::DevicePowerStatusResponse
+                    && msg.data()[0] == dev_id_bytes
+                {
                     info!("received power status response");
                     let mut map_lock = self.device_state_map.lock().unwrap();
                     let mut state: SwitchState;
                     match msg.data()[1] {
-                        0 => {
+                        0 => state = SwitchState::Off,
-                            state = SwitchState::Off
+                        1 => state = SwitchState::On,
-                        },
+                        2 => state = SwitchState::Faulty,
-                        1 => {
-                            state = SwitchState::On
-                        },
-                        2 => {
-                            state = SwitchState::Faulty
-                        },
                         _ => {
                             return Err(());
                         }
@@ -150,11 +165,8 @@ impl PCDU {
                     Err(())
                 }
             }
-            Err(_) => {
+            Err(_) => Err(()),
-                Err(())
-            }
         }
-
     }
 
     pub fn update_all_states_helper(&mut self) -> Result<(), ()> {
@@ -173,42 +185,34 @@ impl PCDU {
     pub fn update_switch_states(&mut self, switch_id: SwitchId) -> Result<(), ()> {
         return if let Ok(dev_id) = DeviceId::try_from(switch_id) {
             match dev_id {
-                DeviceId::All => {
+                DeviceId::All => self.update_all_states_helper(),
-                    self.update_all_states_helper()
+                _ => self.update_states_helper(&dev_id),
-                }
-                _ => {
-                    self.update_states_helper(&dev_id)
-                }
             }
         } else {
             Err(())
-        }
+        };
     }
 
-    pub fn handle_power_requests(&mut self) -> Result<u16, ()>{
+    pub fn handle_power_requests(&mut self) -> Result<u16, ()> {
         let mut i = 0;
         while let Ok((switch_id, switch_state)) = self.switch_rx.recv() {
             match switch_state {
-                SwitchState::Off => {
+                SwitchState::Off => match self.send_power_off(switch_id) {
-                    match self.send_power_off(switch_id) {
+                    Ok(_) => {
-                        Ok(_) => {
+                        i = i + 1;
-                            i = i + 1;
-                        }
-                        Err(_) => {
-                            return Err(());
-                        }
                     }
-                }
+                    Err(_) => {
-                SwitchState::On => {
+                        return Err(());
-                    match self.send_power_on(switch_id) {
-                        Ok(_) => {
-                            i = i + 1;
-                        }
-                        Err(_) => {
-                            return Err(());
-                        }
                     }
-                }
+                },
+                SwitchState::On => match self.send_power_on(switch_id) {
+                    Ok(_) => {
+                        i = i + 1;
+                    }
+                    Err(_) => {
+                        return Err(());
+                    }
+                },
                 _ => {}
             }
             self.update_switch_states(switch_id);
@@ -217,9 +221,14 @@ impl PCDU {
     }
 }
 
-pub fn core_power_task(switch_rx: Receiver<(SwitchId, SwitchState)>, can_tx: CanTxHandler, can_rx: Receiver<PackageModel>, device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>) {
+pub fn core_power_task(
+    switch_rx: Receiver<(SwitchId, SwitchState)>,
+    can_tx: CanTxHandler,
+    can_rx: Receiver<PackageModel>,
+    device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>,
+) {
     let mut pcdu = PCDU::new(switch_rx, can_tx, can_rx, device_state_map);
-    loop{
+    loop {
         pcdu.handle_power_requests().unwrap();
     }
-}
+}

src/pus.rs

@@ -14,8 +14,8 @@ use satrs_core::res_code::ResultU16;
 use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
 use satrs_core::tmtc::{AddressableId, PusServiceProvider};
 use satrs_core::{
-    spacepackets::ecss::PusPacket, spacepackets::tc::PusTc,
+    spacepackets::ecss::PusPacket, spacepackets::tc::PusTc, spacepackets::time::cds::TimeProvider,
-    spacepackets::time::cds::TimeProvider, spacepackets::time::TimeWriter, spacepackets::SpHeader,
+    spacepackets::time::TimeWriter, spacepackets::SpHeader,
 };
 use std::cell::RefCell;