From 1e27c34928da553fbe6ce26aa9a9c1fcbb44e50a Mon Sep 17 00:00:00 2001 From: lkoester Date: Fri, 10 Feb 2023 14:00:14 +0100 Subject: [PATCH] added intermediate changes to power and pld handler --- pyclient/main copy.py | 34 +++++-- src/aocs_handler.rs | 1 + src/can.rs | 2 +- src/can_ids.rs | 46 +++++----- src/hk.rs | 4 +- src/main.rs | 56 ++++++----- src/pld_handler.rs | 148 ++++++++++++++++++++++++------ src/{pcdu.rs => power_handler.rs} | 137 ++++++++++++++------------- src/pus.rs | 4 +- 9 files changed, 281 insertions(+), 151 deletions(-) create mode 100644 src/aocs_handler.rs rename src/{pcdu.rs => power_handler.rs} (67%) diff --git a/pyclient/main copy.py b/pyclient/main copy.py index 9973513..99655ee 100644 --- a/pyclient/main copy.py +++ b/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") - 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=17, subservice=1), - apid=EXAMPLE_PUS_APID, + if op_code == "0": + 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=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( diff --git a/src/aocs_handler.rs b/src/aocs_handler.rs new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/aocs_handler.rs @@ -0,0 +1 @@ + diff --git a/src/can.rs b/src/can.rs index bae4f5c..679ad08 100644 --- a/src/can.rs +++ b/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, diff --git a/src/can_ids.rs b/src/can_ids.rs index c3913b6..892c87e 100644 --- a/src/can_ids.rs +++ b/src/can_ids.rs @@ -95,29 +95,29 @@ impl TryFrom for DeviceId { fn try_from(v: u16) -> Result { match v { - x if x==DeviceId::OBC as u16 => Ok(DeviceId::OBC), - x if x==DeviceId::PCDU as u16 => Ok(DeviceId::PCDU), - x if x==DeviceId::MGM1 as u16 => Ok(DeviceId::MGM1), - x if x==DeviceId::MGM2 as u16 => Ok(DeviceId::MGM2), - x if x==DeviceId::MGM3 as u16 => Ok(DeviceId::MGM3), - x if x==DeviceId::MGM4 as u16 => Ok(DeviceId::MGM4), - x if x==DeviceId::SunSensor1 as u16 => Ok(DeviceId::SunSensor1), - x if x==DeviceId::SunSensor2 as u16 => Ok(DeviceId::SunSensor2), - x if x==DeviceId::SunSensor3 as u16 => Ok(DeviceId::SunSensor3), - x if x==DeviceId::SunSensor4 as u16 => Ok(DeviceId::SunSensor4), - x if x==DeviceId::SunSensor5 as u16 => Ok(DeviceId::SunSensor5), - x if x==DeviceId::SunSensor6 as u16 => Ok(DeviceId::SunSensor6), - x if x==DeviceId::StarTracker as u16 => Ok(DeviceId::StarTracker), - x if x==DeviceId::MGT1 as u16 => Ok(DeviceId::MGT1), - x if x==DeviceId::MGT2 as u16 => Ok(DeviceId::MGT2), - x if x==DeviceId::MGT3 as u16 => Ok(DeviceId::MGT3), - x if x==DeviceId::MGT4 as u16 => Ok(DeviceId::MGT4), - x if x==DeviceId::RWL1 as u16 => Ok(DeviceId::RWL1), - x if x==DeviceId::RWL2 as u16 => Ok(DeviceId::RWL2), - x if x==DeviceId::RWL3 as u16 => Ok(DeviceId::RWL3), - x if x==DeviceId::RWL4 as u16 => Ok(DeviceId::RWL4), - x if x==DeviceId::Camera as u16 => Ok(DeviceId::Camera), - x if x==DeviceId::All as u16 => Ok(DeviceId::All), + x if x == DeviceId::OBC as u16 => Ok(DeviceId::OBC), + x if x == DeviceId::PCDU as u16 => Ok(DeviceId::PCDU), + x if x == DeviceId::MGM1 as u16 => Ok(DeviceId::MGM1), + x if x == DeviceId::MGM2 as u16 => Ok(DeviceId::MGM2), + x if x == DeviceId::MGM3 as u16 => Ok(DeviceId::MGM3), + x if x == DeviceId::MGM4 as u16 => Ok(DeviceId::MGM4), + x if x == DeviceId::SunSensor1 as u16 => Ok(DeviceId::SunSensor1), + x if x == DeviceId::SunSensor2 as u16 => Ok(DeviceId::SunSensor2), + x if x == DeviceId::SunSensor3 as u16 => Ok(DeviceId::SunSensor3), + x if x == DeviceId::SunSensor4 as u16 => Ok(DeviceId::SunSensor4), + x if x == DeviceId::SunSensor5 as u16 => Ok(DeviceId::SunSensor5), + x if x == DeviceId::SunSensor6 as u16 => Ok(DeviceId::SunSensor6), + x if x == DeviceId::StarTracker as u16 => Ok(DeviceId::StarTracker), + x if x == DeviceId::MGT1 as u16 => Ok(DeviceId::MGT1), + x if x == DeviceId::MGT2 as u16 => Ok(DeviceId::MGT2), + x if x == DeviceId::MGT3 as u16 => Ok(DeviceId::MGT3), + x if x == DeviceId::MGT4 as u16 => Ok(DeviceId::MGT4), + x if x == DeviceId::RWL1 as u16 => Ok(DeviceId::RWL1), + x if x == DeviceId::RWL2 as u16 => Ok(DeviceId::RWL2), + x if x == DeviceId::RWL3 as u16 => Ok(DeviceId::RWL3), + x if x == DeviceId::RWL4 as u16 => Ok(DeviceId::RWL4), + x if x == DeviceId::Camera as u16 => Ok(DeviceId::Camera), + x if x == DeviceId::All as u16 => Ok(DeviceId::All), _ => Err(()), } } diff --git a/src/hk.rs b/src/hk.rs index d27c0f0..fd38fa9 100644 --- a/src/hk.rs +++ b/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 {} diff --git a/src/main.rs b/src/main.rs index f17a66e..1f5aa78 100644 --- a/src/main.rs +++ b/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, - PusEventDispatcher, + DefaultPusMgmtBackendProvider, EventReporter, EventRequestWithToken, PusEventDispatcher, }; use satrs_core::pus::verification::{ MpscVerifSender, VerificationReporterCfg, VerificationReporterWithSender, }; use satrs_core::pus::{EcssTmErrorWithSend, EcssTmSenderCore}; -use satrs_core::seq_count::{ - SeqCountProviderSyncClonable, -}; +use satrs_core::seq_count::SeqCountProviderSyncClonable; use satrs_core::{ - spacepackets::time::cds::TimeProvider, - spacepackets::time::TimeWriter, - spacepackets::tm::{PusTm}, + spacepackets::time::cds::TimeProvider, 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, Arc, RwLock, Mutex}; +use std::sync::mpsc::channel; +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::pcdu::{core_power_task, PowerSwitcher}; +use crate::pld_handler::{core_pld_task, CameraHandler}; +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() { - device_state_map.insert(id, SwitchState::Off); - } + for id in DeviceId::iter() { + 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 { diff --git a/src/pld_handler.rs b/src/pld_handler.rs index add4e49..3e13aa5 100644 --- a/src/pld_handler.rs +++ b/src/pld_handler.rs @@ -1,17 +1,16 @@ -use std::sync::mpsc; -use std::sync::mpsc::{Receiver, Sender, TryRecvError}; +use crate::action::ActionRequest; +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 crate::action::ActionRequest; -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}; +use std::sync::mpsc; +use std::sync::mpsc::{Receiver, Sender, TryRecvError}; #[derive(Debug, PartialEq, Copy, Clone)] pub enum CameraMode { @@ -31,18 +30,36 @@ pub struct CameraHandler { can_rx: Receiver, mode: CameraMode, mode_rx: Receiver, + action_rx: Receiver, } impl CameraHandler { - pub fn new(power_switcher: PowerSwitcher, camera_device_id: DeviceId, can_tx: CanTxHandler, can_rx: Receiver, mode_rx: Receiver) -> CameraHandler { + pub fn new( + power_switcher: PowerSwitcher, + camera_device_id: DeviceId, + can_tx: CanTxHandler, + can_rx: Receiver, + mode_rx: Receiver, + action_rx: Receiver, + ) -> 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, pld_can_rx: Receiver, reporter_pld: &mut VerificationReporterWithSender) { +pub fn core_pld_task( + power_switcher: PowerSwitcher, + pld_thread_rx: Receiver, + pld_can_rx: Receiver, + reporter_pld: &mut VerificationReporterWithSender, +) { 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 {} @@ -167,5 +264,4 @@ pub fn core_pld_task(power_switcher: PowerSwitcher, pld_thread_rx: Receiver {} } } - -} \ No newline at end of file +} diff --git a/src/pcdu.rs b/src/power_handler.rs similarity index 67% rename from src/pcdu.rs rename to src/power_handler.rs index 9e251a8..35d31c2 100644 --- a/src/pcdu.rs +++ b/src/power_handler.rs @@ -1,17 +1,19 @@ -use std::collections::HashMap; -use std::sync::mpsc::{Receiver, Sender}; -use satrs_core::power::{PowerSwitcherCommandSender, PowerSwitchInfo, PowerSwitchProvider, SwitchId, SwitchState}; -use crate::can::{CanTxHandler}; +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>>) -> PowerSwitcher { - PowerSwitcher{switch_tx, device_state_map} + pub fn new( + switch_tx: Sender<(SwitchId, SwitchState)>, + device_state_map: Arc>>, + ) -> 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(())} - Err(_) => {Err(())} - } + Ok(_) => Ok(()), + 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(())} - Err(_) => {Err(())} - } + Ok(_) => Ok(()), + 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, device_state_map: Arc>>) -> PCDU{ - PCDU{switch_rx, can_tx, can_rx, device_state_map} + pub fn new( + switch_rx: Receiver<(SwitchId, SwitchState)>, + can_tx: CanTxHandler, + can_rx: Receiver, + device_state_map: Arc>>, + ) -> 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 => { - state = SwitchState::Off - }, - 1 => { - state = SwitchState::On - }, - 2 => { - state = SwitchState::Faulty - }, + 0 => state = SwitchState::Off, + 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 => { - self.update_all_states_helper() - } - _ => { - self.update_states_helper(&dev_id) - } + DeviceId::All => self.update_all_states_helper(), + _ => self.update_states_helper(&dev_id), } } else { Err(()) - } + }; } - pub fn handle_power_requests(&mut self) -> Result{ + pub fn handle_power_requests(&mut self) -> Result { let mut i = 0; while let Ok((switch_id, switch_state)) = self.switch_rx.recv() { match switch_state { - SwitchState::Off => { - match self.send_power_off(switch_id) { - Ok(_) => { - i = i + 1; - } - Err(_) => { - return Err(()); - } + SwitchState::Off => match self.send_power_off(switch_id) { + Ok(_) => { + i = i + 1; } - } - SwitchState::On => { - match self.send_power_on(switch_id) { - Ok(_) => { - i = i + 1; - } - Err(_) => { - return Err(()); - } + 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, device_state_map: Arc>>) { +pub fn core_power_task( + switch_rx: Receiver<(SwitchId, SwitchState)>, + can_tx: CanTxHandler, + can_rx: Receiver, + device_state_map: Arc>>, +) { let mut pcdu = PCDU::new(switch_rx, can_tx, can_rx, device_state_map); - loop{ + loop { pcdu.handle_power_requests().unwrap(); } -} \ No newline at end of file +} diff --git a/src/pus.rs b/src/pus.rs index dee889c..beaa952 100644 --- a/src/pus.rs +++ b/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::time::cds::TimeProvider, spacepackets::time::TimeWriter, spacepackets::SpHeader, + spacepackets::ecss::PusPacket, spacepackets::tc::PusTc, spacepackets::time::cds::TimeProvider, + spacepackets::time::TimeWriter, spacepackets::SpHeader, }; use std::cell::RefCell;