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

added pus service 8 to obsw and pyclient

Browse Source
This commit is contained in:
lkoester
2023-01-20 14:27:44 +01:00
parent 1e3aa40a87
commit 47e36cb0b5
7 changed files with 208 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/action.rs Normal file
View File

@ -0,0 +1,21 @@
use satrs_core::tmtc::AddressableId;
use eurosim_obsw::RequestTargetId;
pub type CollectionIntervalFactor = u32;
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ActionIds {
ImageRequest = 1,
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum ActionRequest {
ImageRequest(RequestTargetId),
OrientationRequest(RequestTargetId),
}
pub enum Subservice {
ImageRequest = 1,
OrientationRequest = 2,
PointingRequest = 3,
}

5
src/device_handler.rs
View File

@ -1,6 +1,7 @@
use std::collections::HashMap;
use std::hash::Hash;
use log::info;
use crate::can_ids::DeviceId;
use crate::can_ids::{DeviceId, PackageId};
use socketcan::{errors, frame, socket, CanFrame, Socket};
pub use num_derive::{FromPrimitive, ToPrimitive};
@ -16,10 +17,10 @@ pub enum DeviceState {
Unknown,
}
#[derive(Clone, Debug)]
pub struct DeviceHandler {
device_state_map: HashMap<DeviceId, DeviceState>,
}
impl DeviceHandler {

87
src/main.rs
View File

@ -10,6 +10,7 @@ mod requests;
mod tmtc;
mod aocs;
mod cam;
mod action;
use crate::hk::{AcsHkIds, HkRequest};
use crate::requests::{Request, RequestWithToken};
@ -47,10 +48,12 @@ use log::{info, warn};
use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::sync::mpsc::{channel, TryRecvError};
use std::sync::mpsc::{channel, RecvError, TryRecvError};
use std::sync::{mpsc, Arc, RwLock};
use std::thread;
use std::time::Duration;
//use libc::time64_t;
use crate::action::ActionRequest;
use crate::cam::CameraRequest;
#[derive(Clone)]
@ -140,6 +143,7 @@ fn main() {
let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
let mut reporter_event_handler = verif_reporter.clone();
let mut reporter_aocs = verif_reporter.clone();
let mut reporter_pld = verif_reporter.clone();
event_man.subscribe_all(pus_event_man_send_provider.id());
let mut request_map = HashMap::new();
@ -147,6 +151,7 @@ fn main() {
let (pld_thread_tx, pld_thread_rx) = channel::<RequestWithToken>();
request_map.insert(RequestTargetId::AcsSubsystem as u32, acs_thread_tx);
request_map.insert(RequestTargetId::PldSubsystem as u32, pld_thread_tx);
//add here receivers for tmtc task to send requests to
//request_map.insert(RequestTargetId::CanTask as u32, can_thread_tx);
let tc_source = PusTcSource {
@ -226,7 +231,7 @@ fn main() {
let aocs_tm_funnel_tx = tm_funnel_tx.clone();
let mut aocs_tm_store = tm_store.clone();
/*
// AOCS Thread
let socket1 =
can::CanTxHandler::new_socket("can0", ThreadId::AOCSThread, package_map_aocs_tx).unwrap();
@ -316,6 +321,8 @@ fn main() {
}
});
*/
let package_map_pld_tx = load_package_ids();
let pld_tm_funnel_tx = tm_funnel_tx.clone();
let mut pld_tm_store = tm_store.clone();
@ -325,16 +332,82 @@ fn main() {
println!("Starting Payload Handling task");
let builder3 = thread::Builder::new().name("PLDThread".into());
let jh3 = builder3.spawn(move || {
let mut time_stamp_buf: [u8; 7] = [0; 7];
loop {
match pld_thread_rx.try_recv() {
Ok(request_with_token) => {
match request_with_token.0 {
Request::CameraRequest(cam_req) => {
match cam_req {
CameraRequest::OneShot(id) => {
Request::ActionRequest(action_id) => {
match action_id {
ActionRequest::ImageRequest(target_id) => {
assert_eq!(target_id, RequestTargetId::PldSubsystem);
// get current time stamp
let cds_stamp =
TimeProvider::from_now_with_u16_days().unwrap();
cds_stamp.write_to_bytes(&mut time_stamp_buf);
// send start verification and get token
let start_token = reporter_pld
.start_success(request_with_token.1, &time_stamp_buf)
.expect("Error sending start success.");
// make can bus package to camera
let data = [1];
PLDCanSocket.tx_socket(PackageId::CameraImageRequest, &data);
//let timeout = Duration::from_millis(400);
// loop to allow early exit incase verif never arrives
// wait for request verification
loop {
match pld_can_rx.recv() {
Ok(msg) => {
if msg.package_id() == PackageId::CameraImageRequestConfirmation && msg.data()[0] == 1 {
break;
}
}
Err(_) => {
warn!("Error receiving Can Bus Message.");
}
}
}
// wait for start of execution
loop {
match pld_can_rx.recv() {
Ok(msg) => {
if msg.package_id() == PackageId::CameraImageExecutionStart && msg.data()[0] == 1 {
break;
}
}
Err(_) => {
warn!("Error receiving Can Bus Message.");
}
}
}
// wait for end of execution
loop {
match pld_can_rx.recv() {
Ok(msg) => {
if msg.package_id() == PackageId::CameraImageExectutionEnd && msg.data()[0] == 1 {
let cds_stamp =
TimeProvider::from_now_with_u16_days().unwrap();
cds_stamp.write_to_bytes(&mut time_stamp_buf);
// send end verification with token
reporter_pld
.completion_success(start_token, &time_stamp_buf)
.expect("Error sending start success.");
break;
}
}
Err(_) => {
warn!("Error receiving Can Bus Message.");
}
}
}
}
CameraRequest::OneShotWithTimeStamp(id) => {}
ActionRequest::OrientationRequest(_) => {}
}
}
_ => {}
@ -369,7 +442,7 @@ fn main() {
jh1.unwrap()
.join()
.expect("Joining CAN Bus Listening thread failed");
jh2.unwrap().join().expect("Joing AOCS 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");

47
src/pus.rs
View File

@ -1,7 +1,7 @@
use crate::hk::{CollectionIntervalFactor, HkRequest};
use crate::requests::{Request, RequestWithToken};
use crate::tmtc::{PusTcSource, TmStore};
use eurosim_obsw::{hk_err, tmtc_err};
use eurosim_obsw::{hk_err, RequestTargetId, tmtc_err};
use satrs_core::events::EventU32;
use satrs_core::pool::StoreAddr;
use satrs_core::pus::event::Subservices;
@ -20,6 +20,10 @@ use satrs_core::{
use std::collections::HashMap;
use std::sync::mpsc::Sender;
use satrs_core::spacepackets::ecss::PusServiceId::Action;
use eurosim_obsw::RequestTargetId::{AcsSubsystem, PldSubsystem};
use crate::action;
use crate::action::ActionRequest;
pub struct PusReceiver {
pub tm_helper: PusTmWithCdsShortHelper,
@ -273,7 +277,46 @@ impl PusReceiver {
}
}
fn handle_function_request(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
fn handle_function_request(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
if pus_tc.user_data().is_none() {
self.update_time_stamp();
/*self.verif_reporter
.start_failure(
token,
FailParams::new(&self.time_stamp, &tmtc_err::NOT_ENOUGH_APP_DATA, None),
)
.expect("Sending start failure TM failed");
*/
return;
}
let send_request = |request: ActionRequest| {
match request {
ActionRequest::ImageRequest(target_id) => {
let id = target_id as u32;
let sender = self.request_map.get(&id).unwrap();
sender
.send(RequestWithToken(Request::ActionRequest(request), token))
.unwrap_or_else(|_| panic!("Sending Action request {:?} failed", request));
}
ActionRequest::OrientationRequest(target_id) => {
let id = target_id as u32;
let sender = self.request_map.get(&id).unwrap();
sender
.send(RequestWithToken(Request::ActionRequest(request), token))
.unwrap_or_else(|_| panic!("Sending Action request {:?} failed", request));
}
}
};
if PusPacket::subservice(pus_tc) == action::Subservice::ImageRequest as u8 {
send_request(ActionRequest::ImageRequest(PldSubsystem));
} else if PusPacket::subservice(pus_tc) == action::Subservice::OrientationRequest as u8 {
send_request(ActionRequest::OrientationRequest(AcsSubsystem));
}
}
}

3
src/requests.rs
View File

@ -1,11 +1,12 @@
use crate::hk::HkRequest;
use satrs_core::pus::verification::{TcStateAccepted, VerificationToken};
use crate::action::ActionRequest;
use crate::cam::CameraRequest;
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum Request {
HkRequest(HkRequest),
CameraRequest(CameraRequest),
ActionRequest(ActionRequest),
}
#[derive(Copy, Clone, Eq, PartialEq, Debug)]