rust
/
eurosim-obsw
6
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

added intermediate changes to power and pld handler

This commit is contained in:
lkoester 2023-02-10 14:00:14 +01:00
parent a30caabacb
commit 1e27c34928
9 changed files with 281 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
pyclient/main copy.py
View File

@ -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(

1
src/aocs_handler.rs Normal file
View File

@ -0,0 +1 @@

2
src/can.rs
View File

@ -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,

46
src/can_ids.rs
View File

@ -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::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(()),
}
}

4
src/hk.rs
View File

@ -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 {}

56
src/main.rs
View File

@ -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 {

148
src/pld_handler.rs
View File

@ -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<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(
start_token,
Some(&time_stamp_buf),
)
.completion_success(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(_) => {}
}
}
}
}

137
src/pcdu.rs → src/power_handler.rs
View File

@ -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<Mutex<HashMap<DeviceId, SwitchState>>>) -> PowerSwitcher {
PowerSwitcher{switch_tx, device_state_map}
pub fn new(
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(())}
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<PackageModel>, device_state_map: Arc<Mutex<HashMap<DeviceId, SwitchState>>>) -> 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<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 => {
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<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 => {
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<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();
}
}
}

4
src/pus.rs
View File

@ -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;