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

added pcdu struct

Browse Source
This commit is contained in:
lkoester 2023-02-07 16:45:00 +01:00
parent cc1a0e09e4
commit 251757ff7f
9 changed files with 233 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/action.rs
View File

@ -1,5 +1,4 @@
use eurosim_obsw::RequestTargetId;
use satrs_core::tmtc::AddressableId;
pub type CollectionIntervalFactor = u32;

2
src/can.rs
View File

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

36
src/can_ids.rs
View File

@ -1,9 +1,6 @@
use embedded_can::{Id, StandardId};
use log::warn;
use std::collections::HashMap;
use std::fs;
use std::sync::mpsc::Sender;
use std::thread::Thread;
pub use num_derive::{FromPrimitive, ToPrimitive};
pub use num_traits::{FromPrimitive, ToPrimitive};
@ -93,6 +90,39 @@ pub enum DeviceId {
All = 23,
}
impl TryFrom<u16> for DeviceId {
type Error = ();
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),
_ => Err(()),
}
}
}
#[derive(Debug)]
pub struct PackageModel {
package_id: PackageId,

222
src/device_handler.rs
View File

@ -1,222 +0,0 @@
use crate::can_ids::{DeviceId, PackageId, PackageModel, ThreadId};
use log::{info, warn};
use socketcan::{errors, frame, socket, CanFrame, Socket};
use std::collections::HashMap;
use std::hash::Hash;
use std::sync::mpsc::{Receiver, RecvError, Sender};
use crate::can::{CanRxHandler, CanTxHandler};
pub use num_derive::{FromPrimitive, ToPrimitive};
pub use num_traits::{FromPrimitive, ToPrimitive};
pub use strum::IntoEnumIterator; // 0.17.1
pub use strum_macros::EnumIter; // 0.17.1
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum DeviceState {
On,
Off,
Broken,
Unknown,
}
pub struct CanDeviceHandler {
device_state_map: HashMap<DeviceId, DeviceState>,
can_tx_handler: CanTxHandler,
can_rx_receiver: Receiver<PackageModel>,
}
impl CanDeviceHandler {
pub fn new(
can_tx_handler: CanTxHandler,
can_rx_receiver: Receiver<PackageModel>,
) -> CanDeviceHandler {
let mut device_state_map: HashMap<DeviceId, DeviceState> = HashMap::new();
for id in DeviceId::iter() {
device_state_map.insert(id, DeviceState::Unknown);
}
CanDeviceHandler {
device_state_map,
can_tx_handler,
can_rx_receiver,
}
}
pub fn power_on(&mut self, id: DeviceId) -> Result<(), ()> {
if !self.device_state_map.contains_key(&id) {
return Err(());
}
info!("Powering on device {:?}", id);
let msg_data: [u8; 1] = [id as u8];
self.can_tx_handler
.tx_socket(PackageId::DevicePowerOnRequest, &msg_data);
let request_confirmation = self.can_rx_receiver.recv();
match request_confirmation {
Ok(confirmation) => {
if confirmation.package_id() != PackageId::DevicePowerOnRequestConfirmation {
warn!("Wrong package ID.");
return Err(());
}
if confirmation.data()[0] != id as u8 {
warn!("Wrong device ID.");
return Err(());
}
if confirmation.data()[1] != 1 {
warn!("Request unsuccessful.");
return Err(());
}
info!("Power on request confirmation received.");
}
Err(_) => {
warn!("Error receiving package.");
return Err(());
}
}
let request_success = self.can_rx_receiver.recv();
match request_success {
Ok(success) => {
if success.package_id() != PackageId::DevicePowerOnConfirmation {
warn!("Wrong package ID.");
return Err(());
}
if success.data()[0] != id as u8 {
warn!("Wrong device ID.");
return Err(());
}
if success.data()[1] != 1 {
warn!("Power on unsuccessful.");
return Err(());
}
info!("Power on confirmation received.");
}
Err(_) => {
warn!("Error receiving package.");
return Err(());
}
}
Ok(())
}
pub fn power_off(&mut self, id: DeviceId) -> Result<(), ()> {
if !self.device_state_map.contains_key(&id) {
return Err(());
}
info!("Powering on device {:?}", id);
let msg_data: [u8; 1] = [id as u8];
self.can_tx_handler
.tx_socket(PackageId::DevicePowerOffRequest, &msg_data);
let request_confirmation = self.can_rx_receiver.recv();
match request_confirmation {
Ok(confirmation) => {
if confirmation.package_id() != PackageId::DevicePowerOffRequestConfirmation {
warn!("Wrong package ID.");
return Err(());
}
if confirmation.data()[0] != id as u8 {
warn!("Wrong device ID.");
return Err(());
}
if confirmation.data()[1] != 1 {
warn!("Request unsuccessful.");
return Err(());
}
info!("Power off request confirmation received.");
}
Err(_) => {
warn!("Error receiving package.");
return Err(());
}
}
let request_success = self.can_rx_receiver.recv();
match request_success {
Ok(success) => {
if success.package_id() != PackageId::DevicePowerOffConfirmation {
warn!("Wrong package ID.");
return Err(());
}
if success.data()[0] != id as u8 {
warn!("Wrong device ID.");
return Err(());
}
if success.data()[1] != 1 {
warn!("Power off unsuccessful.");
return Err(());
}
info!("Power off confirmation received.");
}
Err(_) => {
warn!("Error receiving package.");
return Err(());
}
}
Ok(())
}
pub fn get_power_states(&mut self) -> HashMap<DeviceId, DeviceState> {
for id in DeviceId::iter() {
self.update_power_state(id)
.expect("Error updating power state.");
}
self.device_state_map.clone()
}
pub fn get_power_state(&mut self, id: DeviceId) -> Option<&DeviceState> {
self.update_power_state(id)
.expect("Error updating power state.");
self.device_state_map.get(&id)
}
pub fn update_power_state(&mut self, id: DeviceId) -> Result<(), ()> {
if !self.device_state_map.contains_key(&id) {
return Err(());
}
let msg_data: [u8; 1] = [id as u8];
self.can_tx_handler
.tx_socket(PackageId::DevicePowerStatusRequest, &msg_data);
let response = self.can_rx_receiver.recv();
if let Ok(response) = response {
let data = response.data();
if data[0] == id as u8 {
if data[1] == 1 {
*self.device_state_map.get_mut(&id).unwrap() = DeviceState::On;
} else if data[1] == 0 {
*self.device_state_map.get_mut(&id).unwrap() = DeviceState::Off;
} else {
return Err(());
}
}
} else {
return Err(());
}
Ok(())
}
}
pub fn power_up_sequence(mut device_handler: CanDeviceHandler) -> HashMap<DeviceId, DeviceState> {
for id in DeviceId::iter() {
device_handler
.power_on(id)
.expect("Error powering on device.");
}
device_handler.get_power_states()
}
pub fn power_down_sequence(mut device_handler: CanDeviceHandler) -> HashMap<DeviceId, DeviceState> {
for id in DeviceId::iter() {
device_handler
.power_off(id)
.expect("Error powering on device.");
}
device_handler.get_power_states()
}

30
src/main.rs
View File

@ -10,6 +10,7 @@ mod logger;
mod pus;
mod requests;
mod tmtc;
mod pcdu;
use crate::hk::{AcsHkIds, HkRequest};
use crate::requests::{Request, RequestWithToken};
@ -41,7 +42,7 @@ use satrs_core::{
spacepackets::{SequenceFlags, SpHeader},
};
use crate::can_ids::{can_id_to_package_id, load_package_ids, PackageId, PackageModel, ThreadId};
use crate::can_ids::{can_id_to_package_id, DeviceId, load_package_ids, PackageId, PackageModel, ThreadId};
use embedded_can::{Id, StandardId};
use log::{info, warn};
use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
@ -51,9 +52,11 @@ use std::sync::mpsc::{channel, RecvError, TryRecvError};
use std::sync::{mpsc, Arc, RwLock};
use std::thread;
use std::time::Duration;
use satrs_core::power::{SwitchId, SwitchState};
//use libc::time64_t;
use crate::action::ActionRequest;
use crate::cam::CameraRequest;
use crate::pcdu::core_power_task;
#[derive(Clone)]
struct EventTmSender {
@ -217,6 +220,16 @@ fn main() {
}
});
let (pcdu_tx, pcdu_rx) = mpsc::channel::<(SwitchId, SwitchState)>();
let pcdu_can_tx =
can::CanTxHandler::new_socket("can0", ThreadId::PowerThread, load_package_ids()).unwrap();
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);
});
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();
@ -319,6 +332,7 @@ fn main() {
let PLDCanSocket =
can::CanTxHandler::new_socket("can0", ThreadId::PLDThread, package_map_pld_tx).unwrap();
let mut pcdu_tx_pld_clone = pcdu_tx.clone();
println!("Starting Payload Handling task");
let builder3 = thread::Builder::new().name("PLDThread".into());
let jh3 = builder3.spawn(move || {
@ -328,6 +342,7 @@ fn main() {
Ok(request_with_token) => {
match request_with_token.0 {
Request::ActionRequest(action_id) => {
pcdu_tx_pld_clone.send((DeviceId::Camera as SwitchId, SwitchState::On)).unwrap();
match action_id {
ActionRequest::ImageRequest(target_id) => {
assert_eq!(target_id, RequestTargetId::PldSubsystem);
@ -408,6 +423,7 @@ fn main() {
}
}
}
pcdu_tx_pld_clone.send((DeviceId::Camera as SwitchId, SwitchState::Off)).unwrap();
}
ActionRequest::OrientationRequest(_) => {}
_ => {}
@ -444,15 +460,9 @@ fn main() {
jh1.unwrap()
.join()
.expect("Joining CAN Bus Listening thread failed");
//jh2.unwrap().join().expect("Joing AOCS thread failed");
jh3.unwrap().join().expect("Joing AOCS thread failed");
jh4.unwrap().join().expect("Joing AOCS thread failed");
/*
jh1.join().expect("Joining TM Funnel thread failed");
jh2.join().expect("Joining Event Manager thread failed");
jh3.join().expect("Joining AOCS 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");
}
#[derive(Default)]
struct MgmData {

170
src/pcdu.rs
View File

@ -0,0 +1,170 @@
use std::collections::HashMap;
use std::sync::mpsc::Receiver;
use satrs_core::power::{PowerSwitch, PowerSwitcher, SwitchId, SwitchState};
use crate::can::{CanRxHandler, CanTxHandler};
use crate::can_ids::{DeviceId, PackageId, PackageModel};
use std::convert::TryFrom;
use std::ops::Deref;
use std::time::Duration;
use log::warn;
pub use strum::IntoEnumIterator; // 0.17.1
pub use strum_macros::EnumIter; // 0.17.1
#[derive(Copy, Clone, Debug, PartialEq, EnumIter)]
pub enum DeviceState {
On,
Off,
SwitchingPower,
Setup,
Idle,
}
pub struct PCDU {
switch_rx: Receiver<(SwitchId, SwitchState)>,
can_tx: CanTxHandler,
can_rx: Receiver<PackageModel>,
device_state_map: HashMap<DeviceId, SwitchState>,
}
impl PCDU {
pub fn new(switch_rx: Receiver<(SwitchId, SwitchState)>, can_tx: CanTxHandler, can_rx: Receiver<PackageModel>) -> PCDU{
let mut device_state_map: HashMap<DeviceId, SwitchState> = HashMap::new();
for id in DeviceId::iter() {
device_state_map.insert(id, SwitchState::Off);
}
PCDU{switch_rx, can_tx, can_rx, device_state_map}
}
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_switch_off_cmd(switch_id) {
Ok(_) => {
i = i + 1;
}
Err(_) => {
return Err(());
}
}
}
SwitchState::On => {
match self.send_switch_on_cmd(switch_id) {
Ok(_) => {
i = i + 1;
}
Err(_) => {
return Err(());
}
}
}
_ => {}
}
}
return Ok(i);
}
}
impl PowerSwitcher for PCDU {
type Error = ();
fn send_switch_on_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error> {
return match DeviceId::try_from(switch_id) {
Ok(device_id) => {
let buf: &[u8] = &switch_id.to_be_bytes();
if buf.len() == 1 {
self.can_tx.tx_socket(PackageId::DevicePowerOnRequest, buf);
let mut i = 0;
while i < 10 {
match self.can_rx.recv() {
Ok(msg) => {
if msg.package_id()
== PackageId::DevicePowerOnConfirmation {
return if msg.data()[0] == device_id as u8
&& msg.data()[1] == 1 {
*self.device_state_map.get_mut(&(device_id)).unwrap() = SwitchState::On;
Ok(())
} else {
Err(())
}
}
}
Err(_) => {
warn!("Error receiving Can Bus Message.");
}
}
i = i + 1;
}
Err(())
} else {
Err(())
}
}
Err(_) => { Err(()) }
}
}
fn send_switch_off_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error> {
return match DeviceId::try_from(switch_id) {
Ok(device_id) => {
let buf: &[u8] = &switch_id.to_be_bytes();
if buf.len() == 1 {
self.can_tx.tx_socket(PackageId::DevicePowerOffRequest, buf);
let mut i = 0;
while i < 10 {
match self.can_rx.recv() {
Ok(msg) => {
if msg.package_id()
== PackageId::DevicePowerOffConfirmation {
return if msg.data()[0] == device_id as u8
&& msg.data()[1] == 1 {
*self.device_state_map.get_mut(&(device_id)).unwrap() = SwitchState::Off;
Ok(())
} else {
Err(())
}
}
}
Err(_) => {
warn!("Error receiving Can Bus Message.");
}
}
i = i + 1;
}
Err(())
} else {
Err(())
}
}
Err(_) => { Err(()) }
}
}
fn get_switch_state(&mut self, switch_id: SwitchId) -> Result<SwitchState, Self::Error> {
if let Ok(device_id) = DeviceId::try_from(switch_id) {
return match self.device_state_map.get_mut(&device_id) {
None => { Err(()) }
Some(state) => {
let return_state = state.clone();
Ok(return_state)
}
}
} else {
Err(())
}
}
fn switch_delay_ms(&self) -> u32 {
return 0;
}
}
pub fn core_power_task(switch_rx: Receiver<(SwitchId, SwitchState)>, can_tx: CanTxHandler, can_rx: Receiver<PackageModel>) {
let mut pcdu = PCDU::new(switch_rx, can_tx, can_rx);
loop{
pcdu.handle_power_requests().unwrap();
}
}

18
src/pus.rs
View File

@ -1,10 +1,10 @@
use crate::hk::{CollectionIntervalFactor, HkRequest};
use crate::requests::{Request, RequestWithToken};
use crate::tmtc::{PusTcSource, TmStore};
use eurosim_obsw::{hk_err, tmtc_err, RequestTargetId};
use eurosim_obsw::{hk_err, tmtc_err};
use satrs_core::events::EventU32;
use satrs_core::pool::StoreAddr;
use satrs_core::pus::event::Subservices;
use satrs_core::pus::event::Subservice;
use satrs_core::pus::event_man::{EventRequest, EventRequestWithToken};
use satrs_core::pus::hk;
use satrs_core::pus::verification::{
@ -14,7 +14,7 @@ use satrs_core::res_code::ResultU16;
use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
use satrs_core::tmtc::{AddressableId, PusServiceProvider};
use satrs_core::{
spacepackets, spacepackets::ecss::PusPacket, spacepackets::tc::PusTc,
spacepackets::ecss::PusPacket, spacepackets::tc::PusTc,
spacepackets::time::cds::TimeProvider, spacepackets::time::TimeWriter, spacepackets::SpHeader,
};
use std::cell::RefCell;
@ -23,7 +23,6 @@ use crate::action;
use crate::action::ActionRequest;
use eurosim_obsw::RequestTargetId::{AcsSubsystem, PldSubsystem};
use satrs_core::pus::scheduling::PusScheduler;
use satrs_core::spacepackets::ecss::PusServiceId::Action;
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::mpsc::Sender;
@ -188,13 +187,14 @@ impl PusReceiver {
.send(RequestWithToken(Request::HkRequest(request), token))
.unwrap_or_else(|_| panic!("Sending HK request {:?} failed", request));
};
if PusPacket::subservice(pus_tc) == hk::Subservice::TcEnableGeneration as u8 {
if PusPacket::subservice(pus_tc) == hk::Subservice::TcEnableHkGeneration as u8 {
send_request(HkRequest::Enable(addressable_id));
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcDisableGeneration as u8 {
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcDisableHkGeneration as u8 {
send_request(HkRequest::Disable(addressable_id));
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcGenerateOneShotHk as u8 {
send_request(HkRequest::OneShot(addressable_id));
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcModifyCollectionInterval as u8
} else if PusPacket::subservice(pus_tc)
== hk::Subservice::TcModifyHkCollectionInterval as u8
{
if user_data.len() < 12 {
self.update_time_stamp();
@ -257,7 +257,7 @@ impl PusReceiver {
}
let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap()));
match PusPacket::subservice(pus_tc).try_into() {
Ok(Subservices::TcEnableEventGeneration) => {
Ok(Subservice::TcEnableEventGeneration) => {
self.update_time_stamp();
let start_token = send_start_acceptance(&mut self.verif_reporter, &self.time_stamp);
self.event_request_tx
@ -267,7 +267,7 @@ impl PusReceiver {
})
.expect("Sending event request failed");
}
Ok(Subservices::TcDisableEventGeneration) => {
Ok(Subservice::TcDisableEventGeneration) => {
self.update_time_stamp();
let start_token = send_start_acceptance(&mut self.verif_reporter, &self.time_stamp);
self.event_request_tx

1
src/requests.rs
View File

@ -1,5 +1,4 @@
use crate::action::ActionRequest;
use crate::cam::CameraRequest;
use crate::hk::HkRequest;
use satrs_core::pus::verification::{TcStateAccepted, VerificationToken};

1
src/tmtc.rs
View File

@ -8,7 +8,6 @@ use std::fmt::{Display, Formatter};
use std::net::SocketAddr;
use std::rc::Rc;
use std::sync::mpsc::{Receiver, SendError, Sender, TryRecvError};
use std::sync::{Arc, LockResult, Mutex};
use std::thread;
use std::time::Duration;