idk
This commit is contained in:
parent
71a8a249e8
commit
e67835733f
248
src/aocs.rs
248
src/aocs.rs
@ -1,21 +1,24 @@
|
|||||||
use std::sync::{Arc, Mutex};
|
use crate::action::ActionRequest;
|
||||||
use crate::can_ids::{DeviceId, PackageId, PackageModel};
|
use crate::can_ids::{DeviceId, PackageId, PackageModel};
|
||||||
|
use crate::hk::{AOCSSensorData, AocsHousekeeper};
|
||||||
use crate::power_handler::{DeviceState, PowerSwitcher};
|
use crate::power_handler::{DeviceState, PowerSwitcher};
|
||||||
use crate::requests::{Request, RequestWithToken};
|
use crate::requests::{Request, RequestWithToken};
|
||||||
use satrs_core::power::SwitchId;
|
use crate::tmtc::TmStore;
|
||||||
use std::sync::mpsc::{channel, Receiver, Sender};
|
use byteorder::{ByteOrder, LittleEndian};
|
||||||
use std::u32;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use byteorder::{LittleEndian, ByteOrder};
|
|
||||||
use num_derive::ToPrimitive;
|
use num_derive::ToPrimitive;
|
||||||
use satrs_core::hk::HkRequest;
|
use satrs_core::hk::HkRequest;
|
||||||
use satrs_core::mode::ModeRequest;
|
use satrs_core::mode::ModeRequest;
|
||||||
use satrs_core::pool::StoreAddr;
|
use satrs_core::pool::StoreAddr;
|
||||||
use satrs_core::pus::verification::{StdVerifSenderError, TcStateAccepted, TcStateNone, VerificationReporterWithSender, VerificationToken};
|
use satrs_core::power::SwitchId;
|
||||||
|
use satrs_core::pus::verification::{
|
||||||
|
TcStateAccepted, TcStateNone, VerificationReporterWithSender, VerificationToken,
|
||||||
|
};
|
||||||
|
use satrs_core::pus::MpscPusInStoreSendError;
|
||||||
use satrs_core::seq_count::SeqCountProviderSyncClonable;
|
use satrs_core::seq_count::SeqCountProviderSyncClonable;
|
||||||
use crate::action::ActionRequest;
|
use serde::{Deserialize, Serialize};
|
||||||
use crate::hk::{AOCSHousekeeper, AOCSSensorData};
|
use std::sync::mpsc::{channel, Receiver, Sender};
|
||||||
use crate::tmtc::{TmStore};
|
use std::sync::{Arc, Mutex};
|
||||||
|
use std::u32;
|
||||||
|
|
||||||
#[derive(ToPrimitive)]
|
#[derive(ToPrimitive)]
|
||||||
pub enum AOCSSensorMode {
|
pub enum AOCSSensorMode {
|
||||||
@ -53,20 +56,23 @@ pub struct MGMData {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl MGMData {
|
impl MGMData {
|
||||||
pub fn from_floats(axis_1: f64,
|
pub fn from_floats(axis_1: f64, axis_2: f64, axis_3: f64) -> MGMData {
|
||||||
axis_2: f64,
|
MGMData {
|
||||||
axis_3: f64,
|
axis_1,
|
||||||
) -> MGMData {
|
axis_2,
|
||||||
MGMData{axis_1, axis_2, axis_3}
|
axis_3,
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn new() -> MGMData { MGMData{axis_1: 0.0, axis_2: 0.0, axis_3: 0.0} }
|
pub fn new() -> MGMData {
|
||||||
|
MGMData {
|
||||||
|
axis_1: 0.0,
|
||||||
|
axis_2: 0.0,
|
||||||
|
axis_3: 0.0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn update(&mut self,
|
pub fn update(&mut self, axis_1: f64, axis_2: f64, axis_3: f64) {
|
||||||
axis_1: f64,
|
|
||||||
axis_2: f64,
|
|
||||||
axis_3: f64
|
|
||||||
) {
|
|
||||||
self.axis_1 = axis_1;
|
self.axis_1 = axis_1;
|
||||||
self.axis_2 = axis_2;
|
self.axis_2 = axis_2;
|
||||||
self.axis_3 = axis_3;
|
self.axis_3 = axis_3;
|
||||||
@ -92,19 +98,37 @@ pub struct CSSData {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl CSSData {
|
impl CSSData {
|
||||||
pub fn from_floats(voltage_1: f64,
|
pub fn from_floats(
|
||||||
|
voltage_1: f64,
|
||||||
voltage_2: f64,
|
voltage_2: f64,
|
||||||
voltage_3: f64,
|
voltage_3: f64,
|
||||||
voltage_4: f64,
|
voltage_4: f64,
|
||||||
voltage_5: f64,
|
voltage_5: f64,
|
||||||
voltage_6: f64,
|
voltage_6: f64,
|
||||||
) -> CSSData {
|
) -> CSSData {
|
||||||
CSSData{voltage_1, voltage_2, voltage_3, voltage_4, voltage_5, voltage_6}
|
CSSData {
|
||||||
|
voltage_1,
|
||||||
|
voltage_2,
|
||||||
|
voltage_3,
|
||||||
|
voltage_4,
|
||||||
|
voltage_5,
|
||||||
|
voltage_6,
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn new() -> CSSData { CSSData{voltage_1: 0.0, voltage_2: 0.0, voltage_3: 0.0, voltage_4: 0.0, voltage_5: 0.0, voltage_6: 0.0} }
|
pub fn new() -> CSSData {
|
||||||
|
CSSData {
|
||||||
|
voltage_1: 0.0,
|
||||||
|
voltage_2: 0.0,
|
||||||
|
voltage_3: 0.0,
|
||||||
|
voltage_4: 0.0,
|
||||||
|
voltage_5: 0.0,
|
||||||
|
voltage_6: 0.0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn update(&mut self,
|
pub fn update(
|
||||||
|
&mut self,
|
||||||
voltage_1: f64,
|
voltage_1: f64,
|
||||||
voltage_2: f64,
|
voltage_2: f64,
|
||||||
voltage_3: f64,
|
voltage_3: f64,
|
||||||
@ -121,11 +145,25 @@ impl CSSData {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_array(&self) -> [f64; 6] {
|
pub fn to_array(&self) -> [f64; 6] {
|
||||||
[self.voltage_1, self.voltage_2, self.voltage_3, self.voltage_4, self.voltage_5, self.voltage_6]
|
[
|
||||||
|
self.voltage_1,
|
||||||
|
self.voltage_2,
|
||||||
|
self.voltage_3,
|
||||||
|
self.voltage_4,
|
||||||
|
self.voltage_5,
|
||||||
|
self.voltage_6,
|
||||||
|
]
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_tuple(&self) -> (f64, f64, f64, f64, f64, f64) {
|
pub fn to_tuple(&self) -> (f64, f64, f64, f64, f64, f64) {
|
||||||
(self.voltage_1, self.voltage_2, self.voltage_3, self.voltage_4, self.voltage_5, self.voltage_6)
|
(
|
||||||
|
self.voltage_1,
|
||||||
|
self.voltage_2,
|
||||||
|
self.voltage_3,
|
||||||
|
self.voltage_4,
|
||||||
|
self.voltage_5,
|
||||||
|
self.voltage_6,
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -149,7 +187,9 @@ impl AOCSSensorHandler for CSSHandler {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn send_message(&mut self, id: PackageId, buf: &[u8]) -> Result<(), Self::Error> {
|
fn send_message(&mut self, id: PackageId, buf: &[u8]) -> Result<(), Self::Error> {
|
||||||
self.can_tx.send(PackageModel::new(id, buf).unwrap()).unwrap();
|
self.can_tx
|
||||||
|
.send(PackageModel::new(id, buf).unwrap())
|
||||||
|
.unwrap();
|
||||||
return Ok(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -166,7 +206,17 @@ impl CSSHandler {
|
|||||||
can_rx: Receiver<PackageModel>,
|
can_rx: Receiver<PackageModel>,
|
||||||
request_rx: Receiver<RequestWithToken>,
|
request_rx: Receiver<RequestWithToken>,
|
||||||
) -> CSSHandler {
|
) -> CSSHandler {
|
||||||
CSSHandler{power_switcher, device_id, switch_id, device_state, device_mode, css_data: Arc::new(Mutex::new(CSSData::default())), can_tx, can_rx, request_rx}
|
CSSHandler {
|
||||||
|
power_switcher,
|
||||||
|
device_id,
|
||||||
|
switch_id,
|
||||||
|
device_state,
|
||||||
|
device_mode,
|
||||||
|
css_data: Arc::new(Mutex::new(CSSData::default())),
|
||||||
|
can_tx,
|
||||||
|
can_rx,
|
||||||
|
request_rx,
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn get_data_ref(&mut self) -> Arc<Mutex<CSSData>> {
|
pub fn get_data_ref(&mut self) -> Arc<Mutex<CSSData>> {
|
||||||
@ -179,37 +229,39 @@ impl CSSHandler {
|
|||||||
|
|
||||||
fn handle_request_messages(&mut self) {
|
fn handle_request_messages(&mut self) {
|
||||||
let request = self.request_rx.try_recv().unwrap();
|
let request = self.request_rx.try_recv().unwrap();
|
||||||
let token = request.1;
|
let token = request.1.unwrap();
|
||||||
match request.0 {
|
match request.0 {
|
||||||
Request::HkRequest(_) => {}
|
Request::HkRequest(_) => {}
|
||||||
Request::ModeRequest(request) => {
|
Request::ModeRequest(request) => {
|
||||||
self.handle_mode_request(request, token);
|
self.handle_mode_request(request, token);
|
||||||
}
|
}
|
||||||
Request::ActionRequest(request) => {
|
Request::ActionRequest(request) => self.handle_action_request(request, token),
|
||||||
self.handle_action_request(request, token)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_mode_request(&mut self, request: ModeRequest, token: VerificationToken<TcStateAccepted>) {
|
fn handle_mode_request(
|
||||||
|
&mut self,
|
||||||
|
request: ModeRequest,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) {
|
||||||
match request {
|
match request {
|
||||||
ModeRequest::SetMode(mode) => {
|
ModeRequest::SetMode(mode) => match mode.mode() {
|
||||||
match mode.mode() {
|
|
||||||
0 => {}
|
0 => {}
|
||||||
_ => {}
|
_ => {}
|
||||||
}
|
},
|
||||||
}
|
ModeRequest::ReadMode => {}
|
||||||
ModeRequest::ReadMode(_) => {}
|
ModeRequest::AnnounceMode => {}
|
||||||
ModeRequest::AnnounceMode(_) => {}
|
ModeRequest::AnnounceModeRecursive => {}
|
||||||
ModeRequest::AnnounceModeRecursive(_) => {}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_action_request(&mut self, request: ActionRequest, token: VerificationToken<TcStateAccepted>) {
|
fn handle_action_request(
|
||||||
|
&mut self,
|
||||||
|
request: ActionRequest,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) {
|
||||||
match request {
|
match request {
|
||||||
ActionRequest::ImageRequest(target_id) => {
|
ActionRequest::ImageRequest(target_id) => {}
|
||||||
|
|
||||||
}
|
|
||||||
ActionRequest::OrientationRequest(_) => {}
|
ActionRequest::OrientationRequest(_) => {}
|
||||||
ActionRequest::PointingRequest(_) => {}
|
ActionRequest::PointingRequest(_) => {}
|
||||||
}
|
}
|
||||||
@ -236,7 +288,9 @@ impl AOCSSensorHandler for MGMHandler {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn send_message(&mut self, id: PackageId, buf: &[u8]) -> Result<(), Self::Error> {
|
fn send_message(&mut self, id: PackageId, buf: &[u8]) -> Result<(), Self::Error> {
|
||||||
self.can_tx.send(PackageModel::new(id, buf).unwrap()).unwrap();
|
self.can_tx
|
||||||
|
.send(PackageModel::new(id, buf).unwrap())
|
||||||
|
.unwrap();
|
||||||
return Ok(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -273,8 +327,7 @@ impl MGMHandler {
|
|||||||
self.read_sensor_data();
|
self.read_sensor_data();
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn update_mode(&mut self) {
|
pub fn update_mode(&mut self) {}
|
||||||
}
|
|
||||||
|
|
||||||
pub fn handle_requests(&mut self) {
|
pub fn handle_requests(&mut self) {
|
||||||
if self.device_state == DeviceState::On {
|
if self.device_state == DeviceState::On {
|
||||||
@ -297,9 +350,9 @@ impl MGMHandler {
|
|||||||
pub fn handle_mode_request(&mut self, mode_request: ModeRequest) {
|
pub fn handle_mode_request(&mut self, mode_request: ModeRequest) {
|
||||||
match mode_request {
|
match mode_request {
|
||||||
ModeRequest::SetMode(_) => {}
|
ModeRequest::SetMode(_) => {}
|
||||||
ModeRequest::ReadMode(_) => {}
|
ModeRequest::ReadMode => {}
|
||||||
ModeRequest::AnnounceMode(_) => {}
|
ModeRequest::AnnounceMode => {}
|
||||||
ModeRequest::AnnounceModeRecursive(_) => {}
|
ModeRequest::AnnounceModeRecursive => {}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -332,13 +385,12 @@ impl MGMHandler {
|
|||||||
let float_data = self.decode_sensor_data(package.data());
|
let float_data = self.decode_sensor_data(package.data());
|
||||||
if let Ok(mut mgm_data) = self.mgm_data.lock() {
|
if let Ok(mut mgm_data) = self.mgm_data.lock() {
|
||||||
match package.package_id() {
|
match package.package_id() {
|
||||||
PackageId::AOCSDataMGM1 => { mgm_data.axis_1 = float_data }
|
PackageId::AOCSDataMGM1 => mgm_data.axis_1 = float_data,
|
||||||
PackageId::AOCSDataMGM2 => { mgm_data.axis_2 = float_data }
|
PackageId::AOCSDataMGM2 => mgm_data.axis_2 = float_data,
|
||||||
PackageId::AOCSDataMGM3 => { mgm_data.axis_3 = float_data }
|
PackageId::AOCSDataMGM3 => mgm_data.axis_3 = float_data,
|
||||||
_ => {}
|
_ => {}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -349,93 +401,11 @@ impl MGMHandler {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub struct AOCSController {
|
pub struct AOCSController {
|
||||||
aocs_housekeeper: AOCSHousekeeper,
|
aocs_housekeeper: AocsHousekeeper,
|
||||||
mgm_handler: MGMHandler,
|
mgm_handler: MGMHandler,
|
||||||
request_rx: Receiver<RequestWithToken>,
|
request_rx: Receiver<RequestWithToken>,
|
||||||
hk_request_tx: Sender<RequestWithToken>,
|
hk_request_tx: Sender<RequestWithToken>,
|
||||||
mgm_request_tx: Sender<RequestWithToken>,
|
mgm_request_tx: Sender<RequestWithToken>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl AOCSController {
|
pub fn core_aocs_loop() {}
|
||||||
pub fn new(
|
|
||||||
sensor_data_pool: Arc<Mutex<AOCSSensorData>>,
|
|
||||||
seq_count_provider: SeqCountProviderSyncClonable,
|
|
||||||
aocs_can_receiver_rx: Receiver<PackageModel>,
|
|
||||||
aocs_can_sender_tx: Sender<PackageModel>,
|
|
||||||
mgm_can_receiver_rx: Receiver<PackageModel>,
|
|
||||||
aocs_tm_store: TmStore,
|
|
||||||
aocs_tm_funnel_tx: Sender<StoreAddr>,
|
|
||||||
verif_reporter: VerificationReporterWithSender<StdVerifSenderError>,
|
|
||||||
power_switcher: PowerSwitcher,
|
|
||||||
aocs_request_rx: Receiver<RequestWithToken>,
|
|
||||||
) -> AOCSController {
|
|
||||||
let mgm_can_sender_tx = aocs_can_sender_tx.clone();
|
|
||||||
|
|
||||||
let (mgm_request_tx, mgm_request_rx) = channel();
|
|
||||||
let (hk_request_tx, hk_request_rx) = channel();
|
|
||||||
|
|
||||||
let aocs_housekeeper = AOCSHousekeeper::new(sensor_data_pool, hk_request_rx, seq_count_provider, aocs_tm_store, aocs_tm_funnel_tx, verif_reporter);
|
|
||||||
|
|
||||||
let mgm_handler = MGMHandler::new(power_switcher, DeviceId::MGM1, mgm_can_sender_tx, mgm_can_receiver_rx, mgm_request_rx);
|
|
||||||
|
|
||||||
AOCSController{aocs_housekeeper, mgm_handler, request_rx: aocs_request_rx, hk_request_tx, mgm_request_tx}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn periodic_op(&mut self) {
|
|
||||||
self.update_sensors();
|
|
||||||
self.process_requests();
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn process_requests(&mut self) {
|
|
||||||
if let Ok(request) = self.request_rx.try_recv() {
|
|
||||||
match request.0 {
|
|
||||||
Request::HkRequest(hk_request) => {
|
|
||||||
self.handle_hk_request(hk_request);
|
|
||||||
}
|
|
||||||
Request::ModeRequest(mode_request) => {
|
|
||||||
self.handle_mode_request(mode_request);
|
|
||||||
}
|
|
||||||
Request::ActionRequest(_) => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn handle_hk_request(&mut self, request: HkRequest) {
|
|
||||||
match request {
|
|
||||||
HkRequest::OneShot(id) => {
|
|
||||||
self.aocs_housekeeper.one_shot_hk(id);
|
|
||||||
}
|
|
||||||
HkRequest::Enable(id) => {
|
|
||||||
self.aocs_housekeeper.enable_hk(id);
|
|
||||||
}
|
|
||||||
HkRequest::Disable(id) => {
|
|
||||||
self.aocs_housekeeper.disable_hk(id);
|
|
||||||
}
|
|
||||||
HkRequest::ModifyCollectionInterval(_, _) => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn handle_mode_request(&mut self, mode_request: ModeRequest) {
|
|
||||||
match mode_request {
|
|
||||||
ModeRequest::SetMode(mode_command) => {
|
|
||||||
// if let mode_command.target_id
|
|
||||||
match mode_command.mode() {
|
|
||||||
0 => self.set_mode_off(),
|
|
||||||
1 => self.set_mode_on(),
|
|
||||||
_ => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
ModeRequest::ReadMode(_) => {}
|
|
||||||
ModeRequest::AnnounceMode(_) => {}
|
|
||||||
ModeRequest::AnnounceModeRecursive(_) => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn set_mode_off(&mut self) {}
|
|
||||||
|
|
||||||
pub fn set_mode_on(&mut self) {}
|
|
||||||
|
|
||||||
pub fn update_sensors(&mut self) {
|
|
||||||
self.mgm_handler.periodic_op();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
20
src/can.rs
20
src/can.rs
@ -1,6 +1,6 @@
|
|||||||
use crate::can_ids::{
|
use crate::can_ids::{
|
||||||
can_id_to_package_id, package_id_to_can_id, DeviceId, PackageId,
|
can_id_to_package_id, package_id_to_can_id, DeviceId, PackageId, PackageModel,
|
||||||
PackageModel, SenderReceiverThread, ThreadId,
|
SenderReceiverApid, SenderReceiverThread, ThreadId,
|
||||||
};
|
};
|
||||||
use embedded_can::{self, Frame};
|
use embedded_can::{self, Frame};
|
||||||
use log::{debug, warn};
|
use log::{debug, warn};
|
||||||
@ -13,9 +13,9 @@ pub struct CanRxHandler {
|
|||||||
interface: &'static str,
|
interface: &'static str,
|
||||||
socket: socket::CanSocket,
|
socket: socket::CanSocket,
|
||||||
//frame_id_to_sender_id: HashMap<embedded_can::Id, u32>, // double hash map: frame id -> receiver id -> sender handle
|
//frame_id_to_sender_id: HashMap<embedded_can::Id, u32>, // double hash map: frame id -> receiver id -> sender handle
|
||||||
can_senders: HashMap<ThreadId, Sender<PackageModel>>,
|
can_senders: HashMap<u16, Sender<PackageModel>>,
|
||||||
//dismissed_ids: Vec<embedded_can::Id>,
|
//dismissed_ids: Vec<embedded_can::Id>,
|
||||||
package_map: HashMap<PackageId, SenderReceiverThread>,
|
package_map: HashMap<PackageId, SenderReceiverApid>,
|
||||||
//packet_id_to_sender_id: HashMap<PackageId, ThreadId>,
|
//packet_id_to_sender_id: HashMap<PackageId, ThreadId>,
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -23,8 +23,8 @@ impl CanRxHandler {
|
|||||||
pub fn new_socket(
|
pub fn new_socket(
|
||||||
interface: &'static str,
|
interface: &'static str,
|
||||||
//frame_id_to_sender_id: HashMap<embedded_can::Id, u32>,
|
//frame_id_to_sender_id: HashMap<embedded_can::Id, u32>,
|
||||||
can_senders: HashMap<ThreadId, Sender<PackageModel>>,
|
can_senders: HashMap<u16, Sender<PackageModel>>,
|
||||||
package_map: HashMap<PackageId, SenderReceiverThread>,
|
package_map: HashMap<PackageId, SenderReceiverApid>,
|
||||||
) -> Result<CanRxHandler, ()> {
|
) -> Result<CanRxHandler, ()> {
|
||||||
let socket = socket::CanSocket::open(&interface);
|
let socket = socket::CanSocket::open(&interface);
|
||||||
if let Ok(socket) = socket {
|
if let Ok(socket) = socket {
|
||||||
@ -66,13 +66,13 @@ impl CanRxHandler {
|
|||||||
if self.package_map.contains_key(&frame_id) {
|
if self.package_map.contains_key(&frame_id) {
|
||||||
let value = self.package_map.get(&frame_id).unwrap();
|
let value = self.package_map.get(&frame_id).unwrap();
|
||||||
if value.get_sender() != DeviceId::OBC {
|
if value.get_sender() != DeviceId::OBC {
|
||||||
let message_sender = self.can_senders.get(&value.get_thread()).unwrap();
|
let message_sender = self.can_senders.get(&value.get_apid()).unwrap();
|
||||||
let data = frame.data();
|
let data = frame.data();
|
||||||
let message =
|
let message =
|
||||||
PackageModel::new(frame_id, data).expect("Error generating message.");
|
PackageModel::new(frame_id, data).expect("Error generating message.");
|
||||||
message_sender.send(message).expect(&*format!(
|
message_sender.send(message).expect(&*format!(
|
||||||
"Failure sending can bus frame to thread{:?}, frame id {:?}",
|
"Failure sending can bus frame to thread{:?}, frame id {:?}",
|
||||||
value.get_thread(),
|
value.get_apid(),
|
||||||
frame_id
|
frame_id
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
@ -84,14 +84,14 @@ impl CanRxHandler {
|
|||||||
pub struct CanTxHandler {
|
pub struct CanTxHandler {
|
||||||
interface: &'static str,
|
interface: &'static str,
|
||||||
socket: socket::CanSocket,
|
socket: socket::CanSocket,
|
||||||
package_map: HashMap<PackageId, SenderReceiverThread>,
|
package_map: HashMap<PackageId, SenderReceiverApid>,
|
||||||
message_receiver: Receiver<PackageModel>,
|
message_receiver: Receiver<PackageModel>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl CanTxHandler {
|
impl CanTxHandler {
|
||||||
pub fn new_socket(
|
pub fn new_socket(
|
||||||
interface: &'static str,
|
interface: &'static str,
|
||||||
package_map: HashMap<PackageId, SenderReceiverThread>,
|
package_map: HashMap<PackageId, SenderReceiverApid>,
|
||||||
message_receiver: Receiver<PackageModel>,
|
message_receiver: Receiver<PackageModel>,
|
||||||
) -> Result<CanTxHandler, ()> {
|
) -> Result<CanTxHandler, ()> {
|
||||||
let socket = socket::CanSocket::open(&interface);
|
let socket = socket::CanSocket::open(&interface);
|
||||||
|
@ -2,6 +2,7 @@ use embedded_can::{Id, StandardId};
|
|||||||
use log::warn;
|
use log::warn;
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
|
|
||||||
|
use crate::tmtc::{CSS_APID, MGM_APID, MGT_APID, PLD_APID, PWR_APID, RWL_APID, STR_APID};
|
||||||
pub use num_derive::{FromPrimitive, ToPrimitive};
|
pub use num_derive::{FromPrimitive, ToPrimitive};
|
||||||
pub use num_traits::{FromPrimitive, ToPrimitive};
|
pub use num_traits::{FromPrimitive, ToPrimitive};
|
||||||
pub use strum::IntoEnumIterator; // 0.17.1
|
pub use strum::IntoEnumIterator; // 0.17.1
|
||||||
@ -154,6 +155,7 @@ impl PackageModel {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// TODO delete!!
|
||||||
#[derive(Debug, Copy, Clone)]
|
#[derive(Debug, Copy, Clone)]
|
||||||
pub struct SenderReceiverThread {
|
pub struct SenderReceiverThread {
|
||||||
sender: DeviceId,
|
sender: DeviceId,
|
||||||
@ -181,7 +183,7 @@ impl SenderReceiverThread {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn load_package_ids() -> HashMap<PackageId, SenderReceiverThread> {
|
pub fn load_package_id_to_threads() -> HashMap<PackageId, SenderReceiverThread> {
|
||||||
let mut package_map: HashMap<PackageId, SenderReceiverThread> = HashMap::new();
|
let mut package_map: HashMap<PackageId, SenderReceiverThread> = HashMap::new();
|
||||||
|
|
||||||
let properties = vec![
|
let properties = vec![
|
||||||
@ -244,6 +246,96 @@ pub fn load_package_ids() -> HashMap<PackageId, SenderReceiverThread> {
|
|||||||
return package_map;
|
return package_map;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Copy, Clone)]
|
||||||
|
pub struct SenderReceiverApid {
|
||||||
|
sender: DeviceId,
|
||||||
|
receiver: DeviceId,
|
||||||
|
apid: u16,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SenderReceiverApid {
|
||||||
|
pub fn new(sender: DeviceId, receiver: DeviceId, apid: u16) -> Self {
|
||||||
|
Self {
|
||||||
|
sender,
|
||||||
|
receiver,
|
||||||
|
apid,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_sender(&self) -> DeviceId {
|
||||||
|
self.sender
|
||||||
|
}
|
||||||
|
pub fn get_receiver(&self) -> DeviceId {
|
||||||
|
self.receiver
|
||||||
|
}
|
||||||
|
pub fn get_apid(&self) -> u16 {
|
||||||
|
self.apid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn load_package_id_to_apids() -> HashMap<PackageId, SenderReceiverApid> {
|
||||||
|
let mut package_map: HashMap<PackageId, SenderReceiverApid> = HashMap::new();
|
||||||
|
|
||||||
|
let properties = vec![
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::PCDU, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::PCDU, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::PCDU, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::PCDU, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::PCDU, DeviceId::OBC, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::PCDU, DeviceId::OBC, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::PCDU, DeviceId::OBC, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::PCDU, DeviceId::OBC, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::PCDU, DeviceId::OBC, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::PCDU, DeviceId::OBC, PWR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGT1, MGT_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGT2, MGT_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGT3, MGT_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGT4, MGT_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::RWL1, RWL_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::RWL2, RWL_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::RWL3, RWL_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::RWL4, RWL_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGM1, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGM2, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGM3, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::MGM4, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::SunSensor1, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::SunSensor2, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::SunSensor3, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::SunSensor4, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::SunSensor5, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::SunSensor6, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::StarTracker, STR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::MGM1, DeviceId::OBC, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::MGM2, DeviceId::OBC, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::MGM3, DeviceId::OBC, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::MGM4, DeviceId::OBC, MGM_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::SunSensor1, DeviceId::OBC, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::SunSensor2, DeviceId::OBC, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::SunSensor3, DeviceId::OBC, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::SunSensor4, DeviceId::OBC, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::SunSensor5, DeviceId::OBC, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::SunSensor6, DeviceId::OBC, CSS_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::StarTracker, DeviceId::OBC, STR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::StarTracker, DeviceId::OBC, STR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::StarTracker, DeviceId::OBC, STR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::StarTracker, DeviceId::OBC, STR_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::OBC, DeviceId::Camera, PLD_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::Camera, DeviceId::OBC, PLD_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::Camera, DeviceId::OBC, PLD_APID),
|
||||||
|
SenderReceiverApid::new(DeviceId::Camera, DeviceId::OBC, PLD_APID),
|
||||||
|
];
|
||||||
|
|
||||||
|
let mut i = 0;
|
||||||
|
for id in PackageId::iter() {
|
||||||
|
let value = properties.get(i).unwrap();
|
||||||
|
package_map.insert(id, *value);
|
||||||
|
i += 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
return package_map;
|
||||||
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
pub fn load_device_ids() {
|
pub fn load_device_ids() {
|
||||||
let mut package_map: HashMap<DeviceId, DeviceProperties> = HashMap::new();
|
let mut package_map: HashMap<DeviceId, DeviceProperties> = HashMap::new();
|
||||||
|
20
src/ccsds.rs
20
src/ccsds.rs
@ -1,5 +1,8 @@
|
|||||||
|
use crate::tmtc::{
|
||||||
|
MpscStoreAndSendError, PusTcSource, AOCS_APID, AOCS_HK_APID, CSS_APID, MGM_APID, MGT_APID,
|
||||||
|
PLD_APID, PUS_APID, PWR_APID, RWL_APID, STR_APID,
|
||||||
|
};
|
||||||
use log::warn;
|
use log::warn;
|
||||||
use crate::tmtc::{MpscStoreAndSendError, PusTcSource, PUS_APID};
|
|
||||||
use satrs_core::spacepackets::{CcsdsPacket, SpHeader};
|
use satrs_core::spacepackets::{CcsdsPacket, SpHeader};
|
||||||
use satrs_core::tmtc::{CcsdsPacketHandler, ReceivesCcsdsTc};
|
use satrs_core::tmtc::{CcsdsPacketHandler, ReceivesCcsdsTc};
|
||||||
|
|
||||||
@ -11,7 +14,18 @@ impl CcsdsPacketHandler for CcsdsReceiver {
|
|||||||
type Error = MpscStoreAndSendError;
|
type Error = MpscStoreAndSendError;
|
||||||
|
|
||||||
fn valid_apids(&self) -> &'static [u16] {
|
fn valid_apids(&self) -> &'static [u16] {
|
||||||
&[PUS_APID]
|
&[
|
||||||
|
PUS_APID,
|
||||||
|
PLD_APID,
|
||||||
|
PWR_APID,
|
||||||
|
AOCS_APID,
|
||||||
|
AOCS_HK_APID,
|
||||||
|
MGM_APID,
|
||||||
|
CSS_APID,
|
||||||
|
STR_APID,
|
||||||
|
MGT_APID,
|
||||||
|
RWL_APID,
|
||||||
|
]
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_known_apid(
|
fn handle_known_apid(
|
||||||
@ -21,6 +35,8 @@ impl CcsdsPacketHandler for CcsdsReceiver {
|
|||||||
) -> Result<(), Self::Error> {
|
) -> Result<(), Self::Error> {
|
||||||
if sp_header.apid() == PUS_APID {
|
if sp_header.apid() == PUS_APID {
|
||||||
return self.tc_source.pass_ccsds(sp_header, tc_raw);
|
return self.tc_source.pass_ccsds(sp_header, tc_raw);
|
||||||
|
} else {
|
||||||
|
return self.tc_source.pass_ccsds(sp_header, tc_raw);
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
225
src/hk.rs
225
src/hk.rs
@ -1,13 +1,19 @@
|
|||||||
|
use std::collections::HashMap;
|
||||||
|
use strum::IntoEnumIterator;
|
||||||
|
|
||||||
use crate::aocs::{CSSData, MGMData};
|
use crate::aocs::{CSSData, MGMData};
|
||||||
|
use crate::hk::AocsDataType::float_value;
|
||||||
use crate::requests::Request;
|
use crate::requests::Request;
|
||||||
use crate::requests::RequestWithToken;
|
use crate::requests::RequestWithToken;
|
||||||
use crate::tmtc::TmStore;
|
use crate::tmtc::{TmStore, AOCS_HK_APID};
|
||||||
use eurosim_obsw::{hk_err};
|
use byteorder::{ByteOrder, LittleEndian};
|
||||||
|
use eurosim_obsw::hk_err;
|
||||||
|
use num_enum::FromPrimitive;
|
||||||
|
use satrs_core::hk::{HkRequest, UniqueId};
|
||||||
use satrs_core::pool::StoreAddr;
|
use satrs_core::pool::StoreAddr;
|
||||||
use satrs_core::pus::hk::Subservice;
|
use satrs_core::pus::hk::Subservice;
|
||||||
use satrs_core::pus::verification::{
|
use satrs_core::pus::verification::{FailParams, VerificationReporterWithSender};
|
||||||
FailParams, StdVerifSenderError, VerificationReporterWithSender,
|
use satrs_core::pus::MpscPusInStoreSendError;
|
||||||
};
|
|
||||||
use satrs_core::seq_count::{SeqCountProviderSyncClonable, SequenceCountProviderCore};
|
use satrs_core::seq_count::{SeqCountProviderSyncClonable, SequenceCountProviderCore};
|
||||||
use satrs_core::spacepackets::time::cds::TimeProvider;
|
use satrs_core::spacepackets::time::cds::TimeProvider;
|
||||||
use satrs_core::spacepackets::time::TimeWriter;
|
use satrs_core::spacepackets::time::TimeWriter;
|
||||||
@ -15,19 +21,77 @@ use satrs_core::spacepackets::tm::{PusTm, PusTmSecondaryHeader};
|
|||||||
use satrs_core::spacepackets::SpHeader;
|
use satrs_core::spacepackets::SpHeader;
|
||||||
use satrs_core::tmtc::AddressableId;
|
use satrs_core::tmtc::AddressableId;
|
||||||
use serde::{Deserialize, Serialize};
|
use serde::{Deserialize, Serialize};
|
||||||
use std::ops::{Deref};
|
use std::ops::Deref;
|
||||||
use std::sync::mpsc::{Receiver, Sender};
|
use std::sync::mpsc::{Receiver, Sender};
|
||||||
use std::sync::{Arc, Mutex};
|
use std::sync::{Arc, Mutex};
|
||||||
use satrs_core::hk::HkRequest;
|
use strum_macros::EnumIter;
|
||||||
|
|
||||||
pub type CollectionIntervalFactor = u32;
|
pub type CollectionIntervalFactor = u32;
|
||||||
|
|
||||||
|
pub const MGM_VOLTAGE_1: UniqueId = 1;
|
||||||
|
pub const MGM_VOLTAGE_2: UniqueId = 2;
|
||||||
|
pub const MGM_VOLTAGE_3: UniqueId = 3;
|
||||||
|
pub const CSS_VOLTAGE_1: UniqueId = 4;
|
||||||
|
pub const CSS_VOLTAGE_2: UniqueId = 5;
|
||||||
|
pub const CSS_VOLTAGE_3: UniqueId = 6;
|
||||||
|
pub const CSS_VOLTAGE_4: UniqueId = 7;
|
||||||
|
pub const CSS_VOLTAGE_5: UniqueId = 8;
|
||||||
|
pub const CSS_VOLTAGE_6: UniqueId = 9;
|
||||||
|
pub const STR_QUATERNION_1: UniqueId = 10;
|
||||||
|
pub const STR_QUATERNION_2: UniqueId = 11;
|
||||||
|
pub const STR_QUATERNION_3: UniqueId = 12;
|
||||||
|
pub const STR_QUATERNION_4: UniqueId = 13;
|
||||||
|
|
||||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||||
pub enum AocsHkIds {
|
pub enum AocsHkIds {
|
||||||
TestAocsSet = 1,
|
TestAocsSet = 1,
|
||||||
TestMgmSet = 2,
|
TestMgmSet = 2,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
pub struct AocsDataMap {
|
||||||
|
map: HashMap<UniqueId, AocsDataType>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AocsDataMap {
|
||||||
|
pub fn new() -> Self {
|
||||||
|
let mut data_map = HashMap::new();
|
||||||
|
|
||||||
|
data_map.insert(MGM_VOLTAGE_1, float_value(0.0));
|
||||||
|
data_map.insert(MGM_VOLTAGE_2, float_value(0.0));
|
||||||
|
data_map.insert(MGM_VOLTAGE_3, float_value(0.0));
|
||||||
|
data_map.insert(CSS_VOLTAGE_1, float_value(0.0));
|
||||||
|
data_map.insert(CSS_VOLTAGE_2, float_value(0.0));
|
||||||
|
data_map.insert(CSS_VOLTAGE_3, float_value(0.0));
|
||||||
|
data_map.insert(CSS_VOLTAGE_4, float_value(0.0));
|
||||||
|
data_map.insert(CSS_VOLTAGE_5, float_value(0.0));
|
||||||
|
data_map.insert(CSS_VOLTAGE_6, float_value(0.0));
|
||||||
|
data_map.insert(STR_QUATERNION_1, float_value(0.0));
|
||||||
|
data_map.insert(STR_QUATERNION_2, float_value(0.0));
|
||||||
|
data_map.insert(STR_QUATERNION_3, float_value(0.0));
|
||||||
|
data_map.insert(STR_QUATERNION_4, float_value(0.0));
|
||||||
|
|
||||||
|
Self { map: data_map }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn update_value(&mut self, id: UniqueId, val: AocsDataType) -> Result<(), ()> {
|
||||||
|
if self.map.contains_key(&id) {
|
||||||
|
self.map.insert(id, val);
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_value(&self, id: UniqueId) -> Option<&AocsDataType> {
|
||||||
|
self.map.get(&id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, EnumIter, PartialEq, Copy, Clone)]
|
||||||
|
pub enum AocsDataType {
|
||||||
|
float_value(f64),
|
||||||
|
}
|
||||||
|
|
||||||
#[derive(Serialize, Deserialize)]
|
#[derive(Serialize, Deserialize)]
|
||||||
pub struct AOCSSensorData {
|
pub struct AOCSSensorData {
|
||||||
mgm_data: MGMData, // Voltage for 3 axis
|
mgm_data: MGMData, // Voltage for 3 axis
|
||||||
@ -74,35 +138,51 @@ impl AOCSSensorData {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct AOCSHousekeeper {
|
pub struct AocsHousekeeper {
|
||||||
sensor_data_pool: Arc<Mutex<AOCSSensorData>>,
|
data_map: Arc<Mutex<AocsDataMap>>,
|
||||||
|
id_list: Vec<UniqueId>,
|
||||||
request_rx: Receiver<RequestWithToken>,
|
request_rx: Receiver<RequestWithToken>,
|
||||||
seq_count_provider: SeqCountProviderSyncClonable,
|
seq_count_provider: SeqCountProviderSyncClonable,
|
||||||
aocs_tm_store: TmStore,
|
aocs_tm_store: TmStore,
|
||||||
aocs_tm_funnel_tx: Sender<StoreAddr>,
|
aocs_tm_funnel_tx: Sender<StoreAddr>,
|
||||||
verif_reporter: VerificationReporterWithSender<StdVerifSenderError>,
|
verif_reporter: VerificationReporterWithSender<MpscPusInStoreSendError>,
|
||||||
periodic_hk_enabled: bool,
|
periodic_hk_ids: Option<Vec<UniqueId>>,
|
||||||
periodic_hk_id: Option<AddressableId>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl AOCSHousekeeper {
|
impl AocsHousekeeper {
|
||||||
pub fn new(
|
pub fn new(
|
||||||
sensor_data_pool: Arc<Mutex<AOCSSensorData>>,
|
sensor_data_pool: Arc<Mutex<AocsDataMap>>,
|
||||||
request_rx: Receiver<RequestWithToken>,
|
request_rx: Receiver<RequestWithToken>,
|
||||||
seq_count_provider: SeqCountProviderSyncClonable,
|
seq_count_provider: SeqCountProviderSyncClonable,
|
||||||
aocs_tm_store: TmStore,
|
aocs_tm_store: TmStore,
|
||||||
aocs_tm_funnel_tx: Sender<StoreAddr>,
|
aocs_tm_funnel_tx: Sender<StoreAddr>,
|
||||||
verif_reporter: VerificationReporterWithSender<StdVerifSenderError>,
|
verif_reporter: VerificationReporterWithSender<MpscPusInStoreSendError>,
|
||||||
) -> AOCSHousekeeper {
|
) -> AocsHousekeeper {
|
||||||
AOCSHousekeeper {
|
let id_list = vec![
|
||||||
sensor_data_pool,
|
MGM_VOLTAGE_1,
|
||||||
|
MGM_VOLTAGE_2,
|
||||||
|
MGM_VOLTAGE_3,
|
||||||
|
CSS_VOLTAGE_1,
|
||||||
|
CSS_VOLTAGE_2,
|
||||||
|
CSS_VOLTAGE_3,
|
||||||
|
CSS_VOLTAGE_4,
|
||||||
|
CSS_VOLTAGE_5,
|
||||||
|
CSS_VOLTAGE_6,
|
||||||
|
STR_QUATERNION_1,
|
||||||
|
STR_QUATERNION_2,
|
||||||
|
STR_QUATERNION_3,
|
||||||
|
STR_QUATERNION_4,
|
||||||
|
];
|
||||||
|
|
||||||
|
AocsHousekeeper {
|
||||||
|
data_map: sensor_data_pool,
|
||||||
|
id_list,
|
||||||
request_rx,
|
request_rx,
|
||||||
seq_count_provider,
|
seq_count_provider,
|
||||||
aocs_tm_store,
|
aocs_tm_store,
|
||||||
aocs_tm_funnel_tx,
|
aocs_tm_funnel_tx,
|
||||||
verif_reporter,
|
verif_reporter,
|
||||||
periodic_hk_enabled: false,
|
periodic_hk_ids: None,
|
||||||
periodic_hk_id: None,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -115,7 +195,7 @@ impl AOCSHousekeeper {
|
|||||||
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
||||||
let start_token = self //implement this for verification
|
let start_token = self //implement this for verification
|
||||||
.verif_reporter
|
.verif_reporter
|
||||||
.start_success(request_with_token.1, Some(&time_stamp_buf))
|
.start_success(request_with_token.1.unwrap(), Some(&time_stamp_buf))
|
||||||
.expect("Error sending start success");
|
.expect("Error sending start success");
|
||||||
if let Ok(()) = match hk_req {
|
if let Ok(()) = match hk_req {
|
||||||
HkRequest::OneShot(id) => self.one_shot_hk(id),
|
HkRequest::OneShot(id) => self.one_shot_hk(id),
|
||||||
@ -147,38 +227,84 @@ impl AOCSHousekeeper {
|
|||||||
}
|
}
|
||||||
|
|
||||||
pub fn periodic_hk(&mut self) {
|
pub fn periodic_hk(&mut self) {
|
||||||
if self.periodic_hk_enabled {
|
//let json_string = self.aocs_data_to_str();
|
||||||
let json_string = self.aocs_data_to_str();
|
let data = self.data_map.lock().unwrap();
|
||||||
if let Some(id) = self.periodic_hk_id {
|
let data_copy = data.clone();
|
||||||
self.send_hk_packet(id, &json_string);
|
drop(data);
|
||||||
|
let mut buf: [u8; 8] = [0; 8];
|
||||||
|
if let Some(ids) = &self.periodic_hk_ids {
|
||||||
|
for id in ids.clone() {
|
||||||
|
if let Some(float_value(field)) = data_copy.get_value(id) {
|
||||||
|
let data_str = LittleEndian::write_f64(&mut buf, *field);
|
||||||
|
&self.send_hk_packet(id, &buf);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn one_shot_hk(&mut self, id: AddressableId) -> Result<(), ()> {
|
pub fn one_shot_hk(&mut self, id: UniqueId) -> Result<(), ()> {
|
||||||
let json_string = self.aocs_data_to_str();
|
let data = self.data_map.lock().unwrap();
|
||||||
self.send_hk_packet(id, &json_string);
|
let data_copy = data.clone();
|
||||||
|
drop(data);
|
||||||
|
let mut buf: [u8; 8] = [0; 8];
|
||||||
|
if let Some(float_value(field)) = data_copy.get_value(id) {
|
||||||
|
let data_str = LittleEndian::write_f64(&mut buf, *field);
|
||||||
|
self.send_hk_packet(id, &buf);
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn enable_hk(&mut self, id: UniqueId) -> Result<(), ()> {
|
||||||
|
if !self.id_list.contains(&id) {
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
|
||||||
|
let periodic_hk_ids = self.periodic_hk_ids.clone();
|
||||||
|
match periodic_hk_ids {
|
||||||
|
None => self.periodic_hk_ids = Some(vec![id]),
|
||||||
|
Some(mut ids) => {
|
||||||
|
ids.push(id);
|
||||||
|
self.periodic_hk_ids = Some(ids);
|
||||||
|
}
|
||||||
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn enable_hk(&mut self, id: AddressableId) -> Result<(), ()> {
|
pub fn disable_hk(&mut self, id: UniqueId) -> Result<(), ()> {
|
||||||
self.periodic_hk_enabled = true;
|
if !self.id_list.contains(&id) {
|
||||||
self.periodic_hk_id = Some(id);
|
return Err(());
|
||||||
return Ok(())
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn disable_hk(&mut self, _id: AddressableId) -> Result<(), ()> {
|
let periodic_hk_ids = self.periodic_hk_ids.clone();
|
||||||
self.periodic_hk_enabled = false;
|
match periodic_hk_ids {
|
||||||
self.periodic_hk_id = None;
|
None => return Err(()),
|
||||||
return Ok(())
|
Some(mut ids) => {
|
||||||
|
if !ids.contains(&id) {
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
// .unwrap is allowed, since existence check is performed
|
||||||
|
let index = ids.iter().position(|x| *x == id).unwrap();
|
||||||
|
ids.remove(index);
|
||||||
|
if ids.len() < 1 {
|
||||||
|
self.periodic_hk_ids = None;
|
||||||
|
} else {
|
||||||
|
self.periodic_hk_ids = Some(ids);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
pub fn aocs_data_to_str(&mut self) -> String {
|
pub fn aocs_data_to_str(&mut self) -> String {
|
||||||
let pool = self.sensor_data_pool.lock().unwrap();
|
let pool = self.data_map.lock().unwrap();
|
||||||
serde_json::to_string(pool.deref()).unwrap()
|
serde_json::to_string(pool.deref()).unwrap()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn send_hk_packet(&mut self, id: AddressableId, data: &str) {
|
*/
|
||||||
|
|
||||||
|
pub fn send_hk_packet_from_str(&mut self, id: UniqueId, data: &str) {
|
||||||
let mut time_stamp_buf: [u8; 7] = [0; 7];
|
let mut time_stamp_buf: [u8; 7] = [0; 7];
|
||||||
let mut huge_buf: [u8; 8192] = [0; 8192];
|
let mut huge_buf: [u8; 8192] = [0; 8192];
|
||||||
|
|
||||||
@ -186,7 +312,8 @@ impl AOCSHousekeeper {
|
|||||||
SpHeader::tm_unseg(0x02, self.seq_count_provider.get_and_increment(), 0).unwrap();
|
SpHeader::tm_unseg(0x02, self.seq_count_provider.get_and_increment(), 0).unwrap();
|
||||||
let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
|
let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
|
||||||
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
||||||
let mut len = id.write_to_be_bytes(&mut huge_buf).unwrap();
|
huge_buf[0..4].copy_from_slice(&id.to_be_bytes());
|
||||||
|
let mut len = 4;
|
||||||
huge_buf[8..data.len() + 8].copy_from_slice(data.as_bytes());
|
huge_buf[8..data.len() + 8].copy_from_slice(data.as_bytes());
|
||||||
len += data.len();
|
len += data.len();
|
||||||
let tm_sec_header =
|
let tm_sec_header =
|
||||||
@ -195,4 +322,24 @@ impl AOCSHousekeeper {
|
|||||||
let addr = self.aocs_tm_store.add_pus_tm(&hk_tm);
|
let addr = self.aocs_tm_store.add_pus_tm(&hk_tm);
|
||||||
self.aocs_tm_funnel_tx.send(addr).expect("sending failed");
|
self.aocs_tm_funnel_tx.send(addr).expect("sending failed");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn send_hk_packet(&mut self, id: UniqueId, data: &[u8]) {
|
||||||
|
let mut time_stamp_buf: [u8; 7] = [0; 7];
|
||||||
|
let mut huge_buf: [u8; 8192] = [0; 8192];
|
||||||
|
|
||||||
|
let mut sp_header =
|
||||||
|
SpHeader::tm_unseg(AOCS_HK_APID, self.seq_count_provider.get_and_increment(), 0)
|
||||||
|
.unwrap();
|
||||||
|
let cds_stamp = TimeProvider::from_now_with_u16_days().unwrap();
|
||||||
|
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
||||||
|
huge_buf[0..4].copy_from_slice(&id.to_be_bytes());
|
||||||
|
let mut len = 4;
|
||||||
|
huge_buf[8..data.len() + 8].copy_from_slice(data);
|
||||||
|
len += data.len();
|
||||||
|
let tm_sec_header =
|
||||||
|
PusTmSecondaryHeader::new_simple(3, Subservice::TmHkPacket as u8, &time_stamp_buf);
|
||||||
|
let hk_tm = PusTm::new(&mut sp_header, tm_sec_header, Some(&huge_buf[0..len]), true);
|
||||||
|
let addr = self.aocs_tm_store.add_pus_tm(&hk_tm);
|
||||||
|
self.aocs_tm_funnel_tx.send(addr).expect("sending failed");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
@ -1,6 +1,6 @@
|
|||||||
use std::net::Ipv4Addr;
|
|
||||||
use num_enum::{IntoPrimitive, TryFromPrimitive};
|
use num_enum::{IntoPrimitive, TryFromPrimitive};
|
||||||
use satrs_core::events::{EventU32TypedSev, SeverityInfo};
|
use satrs_core::events::{EventU32TypedSev, SeverityInfo};
|
||||||
|
use std::net::Ipv4Addr;
|
||||||
|
|
||||||
use satrs_mib::res_code::{ResultU16, ResultU16Info};
|
use satrs_mib::res_code::{ResultU16, ResultU16Info};
|
||||||
use satrs_mib::resultcode;
|
use satrs_mib::resultcode;
|
||||||
|
153
src/main.rs
153
src/main.rs
@ -11,16 +11,17 @@ mod can_ids;
|
|||||||
mod ccsds;
|
mod ccsds;
|
||||||
mod hk;
|
mod hk;
|
||||||
mod logger;
|
mod logger;
|
||||||
|
mod messages;
|
||||||
mod pld_handler;
|
mod pld_handler;
|
||||||
mod power_handler;
|
mod power_handler;
|
||||||
mod pus;
|
mod pus;
|
||||||
mod requests;
|
mod requests;
|
||||||
mod tmtc;
|
mod tmtc;
|
||||||
mod messages;
|
|
||||||
|
|
||||||
use crate::requests::{RequestWithToken};
|
use crate::requests::RequestWithToken;
|
||||||
use crate::tmtc::{
|
use crate::tmtc::{
|
||||||
core_tmtc_task, OtherArgs, PusTcSource, TcArgs, TcStore, TmArgs, TmFunnel, TmStore, PUS_APID,
|
core_tmtc_task, OtherArgs, PusTcSource, TcArgs, TcStore, TmArgs, TmFunnel, TmStore, AOCS_APID,
|
||||||
|
AOCS_HK_APID, CSS_APID, MGM_APID, MGT_APID, PLD_APID, PUS_APID, PWR_APID, RWL_APID, STR_APID,
|
||||||
};
|
};
|
||||||
use eurosim_obsw::{RequestTargetId, OBSW_SERVER_ADDR, SERVER_PORT};
|
use eurosim_obsw::{RequestTargetId, OBSW_SERVER_ADDR, SERVER_PORT};
|
||||||
use satrs_core::event_man::{
|
use satrs_core::event_man::{
|
||||||
@ -36,13 +37,13 @@ use satrs_core::pus::verification::{
|
|||||||
};
|
};
|
||||||
use satrs_core::pus::{EcssTmErrorWithSend, EcssTmSenderCore};
|
use satrs_core::pus::{EcssTmErrorWithSend, EcssTmSenderCore};
|
||||||
use satrs_core::seq_count::SeqCountProviderSyncClonable;
|
use satrs_core::seq_count::SeqCountProviderSyncClonable;
|
||||||
use satrs_core::{spacepackets::tm::PusTm};
|
use satrs_core::spacepackets::tm::PusTm;
|
||||||
use strum::IntoEnumIterator;
|
use strum::IntoEnumIterator;
|
||||||
|
|
||||||
use crate::can_ids::{
|
use crate::can_ids::{
|
||||||
load_package_ids, DeviceId, PackageModel, ThreadId,
|
load_package_id_to_apids, load_package_id_to_threads, DeviceId, PackageModel, ThreadId,
|
||||||
};
|
};
|
||||||
use log::{info};
|
use log::info;
|
||||||
use satrs_core::power::{SwitchId, SwitchState};
|
use satrs_core::power::{SwitchId, SwitchState};
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
use std::net::{IpAddr, SocketAddr};
|
use std::net::{IpAddr, SocketAddr};
|
||||||
@ -50,39 +51,13 @@ use std::sync::mpsc::channel;
|
|||||||
use std::sync::{mpsc, Arc, Mutex, RwLock};
|
use std::sync::{mpsc, Arc, Mutex, RwLock};
|
||||||
use std::thread;
|
use std::thread;
|
||||||
//use libc::time64_t;
|
//use libc::time64_t;
|
||||||
use crate::aocs::{MGMData, MGMHandler};
|
use crate::aocs::{core_aocs_loop, MGMData, MGMHandler};
|
||||||
#[cfg(feature = "can")]
|
#[cfg(feature = "can")]
|
||||||
use crate::can::CanTxHandler;
|
use crate::can::CanTxHandler;
|
||||||
use crate::hk::{AOCSHousekeeper, AOCSSensorData};
|
use crate::hk::{AOCSSensorData, AocsDataMap, AocsHousekeeper};
|
||||||
use crate::pld_handler::{core_pld_task};
|
use crate::pld_handler::core_pld_task;
|
||||||
use crate::power_handler::{core_power_task, PowerSwitcher};
|
use crate::power_handler::{core_power_task, PowerSwitcher};
|
||||||
|
|
||||||
#[derive(Clone)]
|
|
||||||
struct EventTmSender {
|
|
||||||
store_helper: TmStore,
|
|
||||||
sender: mpsc::Sender<StoreAddr>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl EventTmSender {
|
|
||||||
fn new(store_helper: TmStore, sender: mpsc::Sender<StoreAddr>) -> Self {
|
|
||||||
Self {
|
|
||||||
store_helper,
|
|
||||||
sender,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl EcssTmSenderCore for EventTmSender {
|
|
||||||
type Error = mpsc::SendError<StoreAddr>;
|
|
||||||
|
|
||||||
fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmErrorWithSend<Self::Error>> {
|
|
||||||
let addr = self.store_helper.add_pus_tm(&tm);
|
|
||||||
self.sender
|
|
||||||
.send(addr)
|
|
||||||
.map_err(EcssTmErrorWithSend::SendError)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
logger::setup_logger().unwrap();
|
logger::setup_logger().unwrap();
|
||||||
info!("Running DemoSat OBSW!");
|
info!("Running DemoSat OBSW!");
|
||||||
@ -111,17 +86,20 @@ fn main() {
|
|||||||
};
|
};
|
||||||
|
|
||||||
let seq_count_provider = SeqCountProviderSyncClonable::default();
|
let seq_count_provider = SeqCountProviderSyncClonable::default();
|
||||||
|
let msg_count_provider = SeqCountProviderSyncClonable::default();
|
||||||
let aocs_seq_count_provider = seq_count_provider.clone();
|
let aocs_seq_count_provider = seq_count_provider.clone();
|
||||||
|
let verif_seq_count_provider = seq_count_provider.clone();
|
||||||
|
let tmtc_seq_count_provider = seq_count_provider.clone();
|
||||||
|
|
||||||
let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
|
let sock_addr = SocketAddr::new(IpAddr::V4(OBSW_SERVER_ADDR), SERVER_PORT);
|
||||||
let (tc_source_tx, tc_source_rx) = channel();
|
let (tc_source_tx, tc_source_rx) = channel();
|
||||||
let (tm_funnel_tx, tm_funnel_rx) = channel();
|
let (tm_funnel_tx, tm_funnel_rx) = channel();
|
||||||
let (tm_server_tx, tm_server_rx) = channel();
|
let (tm_server_tx, tm_server_rx) = channel();
|
||||||
let verif_sender = MpscVerifSender::new(tm_store.pool.clone(), tm_funnel_tx.clone());
|
let verif_sender = MpscVerifSender::new(1, "name", tm_store.pool.clone(), tm_funnel_tx.clone());
|
||||||
let verif_cfg = VerificationReporterCfg::new(
|
let verif_cfg = VerificationReporterCfg::new(
|
||||||
PUS_APID,
|
PUS_APID,
|
||||||
#[allow(clippy::box_default)]
|
Box::new(verif_seq_count_provider.clone()),
|
||||||
Box::new(seq_count_provider.clone()),
|
Box::new(msg_count_provider),
|
||||||
1,
|
1,
|
||||||
2,
|
2,
|
||||||
8,
|
8,
|
||||||
@ -137,8 +115,7 @@ fn main() {
|
|||||||
let mut event_man = EventManagerWithMpscQueue::new(Box::new(event_recv));
|
let mut event_man = EventManagerWithMpscQueue::new(Box::new(event_recv));
|
||||||
let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
|
let event_reporter = EventReporter::new(PUS_APID, 128).unwrap();
|
||||||
let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
|
let pus_tm_backend = DefaultPusMgmtBackendProvider::<EventU32>::default();
|
||||||
let pus_event_dispatcher =
|
let pus_event_dispatcher = PusEventDispatcher::new(event_reporter, Box::new(pus_tm_backend));
|
||||||
PusEventDispatcher::new(event_reporter, Box::new(pus_tm_backend));
|
|
||||||
let (pus_event_man_tx, pus_event_man_rx) = channel();
|
let (pus_event_man_tx, pus_event_man_rx) = channel();
|
||||||
let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
|
let pus_event_man_send_provider = MpscEventU32SendProvider::new(1, pus_event_man_tx);
|
||||||
let reporter_event_handler = verif_reporter.clone();
|
let reporter_event_handler = verif_reporter.clone();
|
||||||
@ -146,11 +123,19 @@ fn main() {
|
|||||||
let mut reporter_pld = verif_reporter.clone();
|
let mut reporter_pld = verif_reporter.clone();
|
||||||
event_man.subscribe_all(pus_event_man_send_provider.id());
|
event_man.subscribe_all(pus_event_man_send_provider.id());
|
||||||
|
|
||||||
|
// possibly deprecated, as the apid should replace the target id
|
||||||
let mut request_map = HashMap::new();
|
let mut request_map = HashMap::new();
|
||||||
let (aocs_thread_tx, aocs_thread_rx) = channel::<RequestWithToken>();
|
let (aocs_thread_tx, aocs_thread_rx) = channel::<RequestWithToken>();
|
||||||
let (pld_thread_tx, pld_thread_rx) = channel::<RequestWithToken>();
|
let (pld_thread_tx, pld_thread_rx) = channel::<RequestWithToken>();
|
||||||
request_map.insert(RequestTargetId::AcsSubsystem as u32, aocs_thread_tx);
|
let (pwr_thread_tx, pwr_thread_rx) = channel::<RequestWithToken>();
|
||||||
request_map.insert(RequestTargetId::PldSubsystem as u32, pld_thread_tx);
|
let (aocs_hk_tx, aocs_hk_rx) = channel::<RequestWithToken>();
|
||||||
|
let (mgm_tx, mgm_rx) = channel::<RequestWithToken>();
|
||||||
|
let (css_tx, css_rx) = channel::<RequestWithToken>();
|
||||||
|
let (str_tx, str_rx) = channel::<RequestWithToken>();
|
||||||
|
let (mgt_tx, mgt_rx) = channel::<RequestWithToken>();
|
||||||
|
let (rwl_tx, rwl_rx) = channel::<RequestWithToken>();
|
||||||
|
request_map.insert(RequestTargetId::AcsSubsystem as u32, aocs_thread_tx.clone());
|
||||||
|
request_map.insert(RequestTargetId::PldSubsystem as u32, pld_thread_tx.clone());
|
||||||
//add here receivers for tmtc task to send requests to
|
//add here receivers for tmtc task to send requests to
|
||||||
//request_map.insert(RequestTargetId::CanTask as u32, can_thread_tx);
|
//request_map.insert(RequestTargetId::CanTask as u32, can_thread_tx);
|
||||||
|
|
||||||
@ -159,6 +144,18 @@ fn main() {
|
|||||||
tc_source: tc_source_tx,
|
tc_source: tc_source_tx,
|
||||||
};
|
};
|
||||||
|
|
||||||
|
let mut apid_map = HashMap::new();
|
||||||
|
|
||||||
|
apid_map.insert(PLD_APID, pld_thread_tx.clone());
|
||||||
|
apid_map.insert(PWR_APID, pwr_thread_tx.clone());
|
||||||
|
apid_map.insert(AOCS_APID, aocs_thread_tx.clone());
|
||||||
|
apid_map.insert(AOCS_HK_APID, aocs_hk_tx.clone());
|
||||||
|
apid_map.insert(MGM_APID, mgm_tx.clone());
|
||||||
|
apid_map.insert(CSS_APID, css_tx.clone());
|
||||||
|
apid_map.insert(STR_APID, str_tx.clone());
|
||||||
|
apid_map.insert(MGT_APID, mgt_tx.clone());
|
||||||
|
apid_map.insert(RWL_APID, rwl_tx.clone());
|
||||||
|
|
||||||
// Create clones here to allow moving the values
|
// Create clones here to allow moving the values
|
||||||
let core_args = OtherArgs {
|
let core_args = OtherArgs {
|
||||||
sock_addr,
|
sock_addr,
|
||||||
@ -166,6 +163,8 @@ fn main() {
|
|||||||
event_sender,
|
event_sender,
|
||||||
event_request_tx,
|
event_request_tx,
|
||||||
request_map,
|
request_map,
|
||||||
|
apid_map,
|
||||||
|
seq_count_provider: verif_seq_count_provider,
|
||||||
};
|
};
|
||||||
let tc_args = TcArgs {
|
let tc_args = TcArgs {
|
||||||
tc_source,
|
tc_source,
|
||||||
@ -177,18 +176,26 @@ fn main() {
|
|||||||
tm_server_rx,
|
tm_server_rx,
|
||||||
};
|
};
|
||||||
|
|
||||||
let (aocs_can_tx, aocs_can_rx) = mpsc::channel::<PackageModel>();
|
let (mgm_can_tx, mgm_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
|
let (mgt_can_tx, mgt_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
|
let (css_can_tx, css_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
|
let (rwl_can_tx, rwl_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
|
let (str_can_tx, str_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
let (power_can_tx, power_can_rx) = mpsc::channel::<PackageModel>();
|
let (power_can_tx, power_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
let (pld_can_tx, pld_can_rx) = mpsc::channel::<PackageModel>();
|
let (pld_can_tx, pld_can_rx) = mpsc::channel::<PackageModel>();
|
||||||
|
|
||||||
// make tx thread id hashmap
|
// make tx thread id hashmap
|
||||||
let mut can_senders = HashMap::new();
|
let mut can_senders = HashMap::new();
|
||||||
can_senders.insert(ThreadId::AOCSThread, aocs_can_tx);
|
can_senders.insert(PWR_APID, power_can_tx);
|
||||||
can_senders.insert(ThreadId::PowerThread, power_can_tx);
|
can_senders.insert(PLD_APID, pld_can_tx);
|
||||||
can_senders.insert(ThreadId::PLDThread, pld_can_tx);
|
can_senders.insert(MGM_APID, mgm_can_tx);
|
||||||
|
can_senders.insert(MGT_APID, mgt_can_tx);
|
||||||
|
can_senders.insert(RWL_APID, rwl_can_tx);
|
||||||
|
can_senders.insert(CSS_APID, css_can_tx);
|
||||||
|
can_senders.insert(STR_APID, str_can_tx);
|
||||||
|
|
||||||
// get package id hashmap
|
// get package id hashmap
|
||||||
let package_ids_rx = load_package_ids();
|
let package_ids_rx = load_package_id_to_apids();
|
||||||
|
|
||||||
info!("Starting TMTC task");
|
info!("Starting TMTC task");
|
||||||
let builder0 = thread::Builder::new().name("TMTCThread".into());
|
let builder0 = thread::Builder::new().name("TMTCThread".into());
|
||||||
@ -199,7 +206,8 @@ fn main() {
|
|||||||
let (can_tx_sender, can_tx_receiver) = channel();
|
let (can_tx_sender, can_tx_receiver) = channel();
|
||||||
|
|
||||||
#[cfg(feature = "can")]
|
#[cfg(feature = "can")]
|
||||||
let mut can_rx_socket = can::CanRxHandler::new_socket("can0", can_senders.clone(), package_ids_rx.clone()).unwrap();
|
let mut can_rx_socket =
|
||||||
|
can::CanRxHandler::new_socket("can0", can_senders.clone(), package_ids_rx.clone()).unwrap();
|
||||||
|
|
||||||
#[cfg(feature = "can")]
|
#[cfg(feature = "can")]
|
||||||
info!("Starting CAN Socket listening task");
|
info!("Starting CAN Socket listening task");
|
||||||
@ -210,7 +218,8 @@ fn main() {
|
|||||||
});
|
});
|
||||||
|
|
||||||
#[cfg(feature = "can")]
|
#[cfg(feature = "can")]
|
||||||
let mut can_tx_socket = CanTxHandler::new_socket("can0", package_ids_rx.clone(), can_tx_receiver).unwrap();
|
let mut can_tx_socket =
|
||||||
|
CanTxHandler::new_socket("can0", package_ids_rx.clone(), can_tx_receiver).unwrap();
|
||||||
|
|
||||||
#[cfg(feature = "can")]
|
#[cfg(feature = "can")]
|
||||||
info!("Starting CAN Socket writing task");
|
info!("Starting CAN Socket writing task");
|
||||||
@ -221,8 +230,7 @@ fn main() {
|
|||||||
});
|
});
|
||||||
|
|
||||||
let (pcdu_tx, pcdu_rx) = mpsc::channel::<(SwitchId, SwitchState)>();
|
let (pcdu_tx, pcdu_rx) = mpsc::channel::<(SwitchId, SwitchState)>();
|
||||||
let pcdu_can_tx_sender =
|
let pcdu_can_tx_sender = can_tx_sender.clone();
|
||||||
can_tx_sender.clone();
|
|
||||||
|
|
||||||
let mut device_state_map = HashMap::new();
|
let mut device_state_map = HashMap::new();
|
||||||
for id in DeviceId::iter() {
|
for id in DeviceId::iter() {
|
||||||
@ -243,12 +251,11 @@ fn main() {
|
|||||||
);
|
);
|
||||||
});
|
});
|
||||||
|
|
||||||
let package_map_pld_tx = load_package_ids();
|
let package_map_pld_tx = load_package_id_to_threads();
|
||||||
let pld_tm_funnel_tx = tm_funnel_tx.clone();
|
let pld_tm_funnel_tx = tm_funnel_tx.clone();
|
||||||
let pld_tm_store = tm_store.clone();
|
let pld_tm_store = tm_store.clone();
|
||||||
|
|
||||||
let pld_can_tx_sender =
|
let pld_can_tx_sender = can_tx_sender.clone();
|
||||||
can_tx_sender.clone();
|
|
||||||
|
|
||||||
let power_switcher_pld = power_switcher.clone();
|
let power_switcher_pld = power_switcher.clone();
|
||||||
|
|
||||||
@ -282,24 +289,42 @@ fn main() {
|
|||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
let package_map_aocs_tx = load_package_ids();
|
let package_map_aocs_tx = load_package_id_to_threads();
|
||||||
let aocs_tm_funnel_tx = tm_funnel_tx.clone();
|
let aocs_tm_funnel_tx = tm_funnel_tx.clone();
|
||||||
let aocs_tm_store = tm_store.clone();
|
let aocs_tm_store = tm_store.clone();
|
||||||
|
|
||||||
let mgm_shared_data: Arc<Mutex<MGMData>> = Arc::default();
|
let mgm_shared_data: Arc<Mutex<MGMData>> = Arc::default();
|
||||||
|
|
||||||
let aocs_sensor_data = Arc::new(Mutex::new(AOCSSensorData::new()));
|
let aocs_data = Arc::new(Mutex::new(AocsDataMap::new()));
|
||||||
let (mgm_action_tx, mgm_action_rx) = channel();
|
let (mgm_action_tx, mgm_action_rx) = channel::<RequestWithToken>();
|
||||||
|
|
||||||
let power_switcher_aocs = power_switcher.clone();
|
let power_switcher_aocs = power_switcher.clone();
|
||||||
|
|
||||||
info!("Starting AOCS task");
|
info!("Starting AOCS task");
|
||||||
let builder5 = thread::Builder::new().name("AOCSThread".into());
|
let builder5 = thread::Builder::new().name("AOCSThread".into());
|
||||||
let jh5 = builder5.spawn(move || {
|
let jh5 = builder5.spawn(move || {
|
||||||
let mut mgm_handler = MGMHandler::new(power_switcher_aocs.clone(), DeviceId::MGM1, can_tx_sender.clone(), aocs_can_rx, mgm_action_rx);
|
let mut aocs_housekeeper = AocsHousekeeper::new(
|
||||||
|
aocs_data,
|
||||||
|
aocs_hk_rx,
|
||||||
|
aocs_seq_count_provider,
|
||||||
|
aocs_tm_store,
|
||||||
|
aocs_tm_funnel_tx,
|
||||||
|
reporter_aocs,
|
||||||
|
);
|
||||||
|
|
||||||
let aocs_sensor_data = Arc::new(Mutex::new(AOCSSensorData::new()));
|
loop {
|
||||||
let mut aocs_housekeeper = AOCSHousekeeper::new(
|
aocs_housekeeper.handle_hk_request();
|
||||||
|
}
|
||||||
|
/*let mut mgm_handler = MGMHandler::new(
|
||||||
|
power_switcher_aocs.clone(),
|
||||||
|
DeviceId::MGM1,
|
||||||
|
can_tx_sender.clone(),
|
||||||
|
mgm_can_rx,
|
||||||
|
mgm_action_rx,
|
||||||
|
);
|
||||||
|
|
||||||
|
let aocs_sensor_data = Arc::new(Mutex::new(AocsDataMap::new()));
|
||||||
|
let mut aocs_housekeeper = AocsHousekeeper::new(
|
||||||
aocs_sensor_data.clone(),
|
aocs_sensor_data.clone(),
|
||||||
aocs_thread_rx,
|
aocs_thread_rx,
|
||||||
aocs_seq_count_provider,
|
aocs_seq_count_provider,
|
||||||
@ -314,17 +339,21 @@ fn main() {
|
|||||||
drop(locked_sensor_data);
|
drop(locked_sensor_data);
|
||||||
aocs_housekeeper.handle_hk_request();
|
aocs_housekeeper.handle_hk_request();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
core_aocs_loop();
|
||||||
});
|
});
|
||||||
|
|
||||||
jh0.unwrap()
|
jh0.unwrap()
|
||||||
.join()
|
.join()
|
||||||
.expect("Joining UDP TMTC server thread failed");
|
.expect("Joining UDP TMTC server thread failed");
|
||||||
|
|
||||||
|
|
||||||
jh1.unwrap()
|
jh1.unwrap()
|
||||||
.join()
|
.join()
|
||||||
.expect("Joining CAN Bus Listening thread failed");
|
.expect("Joining CAN Bus Listening thread failed");
|
||||||
jh_can_tx.unwrap()
|
jh_can_tx
|
||||||
|
.unwrap()
|
||||||
.join()
|
.join()
|
||||||
.expect("Joining CAN Bus Writing thread failed");
|
.expect("Joining CAN Bus Writing thread failed");
|
||||||
jh2.unwrap().join().expect("Joining power thread failed");
|
jh2.unwrap().join().expect("Joining power thread failed");
|
||||||
|
@ -1,5 +1,5 @@
|
|||||||
use std::sync::mpsc::Sender;
|
|
||||||
use crate::requests::RequestWithToken;
|
use crate::requests::RequestWithToken;
|
||||||
|
use std::sync::mpsc::Sender;
|
||||||
|
|
||||||
pub struct InternalMessage {
|
pub struct InternalMessage {
|
||||||
response_sender: Option<Sender<ResponseDataTypes>>,
|
response_sender: Option<Sender<ResponseDataTypes>>,
|
||||||
@ -10,6 +10,4 @@ pub enum MessageDataTypes {
|
|||||||
RequestWithToken(RequestWithToken),
|
RequestWithToken(RequestWithToken),
|
||||||
}
|
}
|
||||||
|
|
||||||
pub enum ResponseDataTypes {
|
pub enum ResponseDataTypes {}
|
||||||
|
|
||||||
}
|
|
||||||
|
@ -2,14 +2,17 @@ use crate::action::ActionRequest;
|
|||||||
use crate::can_ids::{DeviceId, PackageId, PackageModel};
|
use crate::can_ids::{DeviceId, PackageId, PackageModel};
|
||||||
use crate::power_handler::{DeviceState, PowerSwitcher};
|
use crate::power_handler::{DeviceState, PowerSwitcher};
|
||||||
use crate::requests::{Request, RequestWithToken};
|
use crate::requests::{Request, RequestWithToken};
|
||||||
use eurosim_obsw::RequestTargetId;
|
use eurosim_obsw::{tmtc_err, RequestTargetId};
|
||||||
use log::{debug};
|
use log::debug;
|
||||||
use satrs_core::power::{PowerSwitchInfo, PowerSwitcherCommandSender, SwitchId};
|
use satrs_core::power::{PowerSwitchInfo, PowerSwitcherCommandSender, SwitchId};
|
||||||
use satrs_core::pus::verification::{StdVerifSenderError, VerificationReporterWithSender};
|
use satrs_core::pus::verification::{FailParams, VerificationReporterWithSender};
|
||||||
|
use satrs_core::pus::MpscPusInStoreSendError;
|
||||||
use satrs_core::spacepackets::time::cds::TimeProvider;
|
use satrs_core::spacepackets::time::cds::TimeProvider;
|
||||||
use satrs_core::spacepackets::time::TimeWriter;
|
use satrs_core::spacepackets::time::TimeWriter;
|
||||||
use std::sync::mpsc;
|
use std::sync::mpsc;
|
||||||
use std::sync::mpsc::{Receiver, Sender};
|
use std::sync::mpsc::{Receiver, Sender};
|
||||||
|
use std::thread::sleep;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
#[derive(Debug, PartialEq, Copy, Clone)]
|
#[derive(Debug, PartialEq, Copy, Clone)]
|
||||||
pub enum CameraMode {
|
pub enum CameraMode {
|
||||||
@ -18,6 +21,7 @@ pub enum CameraMode {
|
|||||||
Verification,
|
Verification,
|
||||||
Start,
|
Start,
|
||||||
End,
|
End,
|
||||||
|
Broken,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct CameraHandler {
|
pub struct CameraHandler {
|
||||||
@ -127,6 +131,7 @@ impl CameraHandler {
|
|||||||
// Camera Device Handler State Machine
|
// Camera Device Handler State Machine
|
||||||
|
|
||||||
match self.mode {
|
match self.mode {
|
||||||
|
CameraMode::Broken => {}
|
||||||
CameraMode::Idle => {}
|
CameraMode::Idle => {}
|
||||||
CameraMode::PictureRequest => {
|
CameraMode::PictureRequest => {
|
||||||
if self.device_state == DeviceState::Off {
|
if self.device_state == DeviceState::Off {
|
||||||
@ -137,6 +142,8 @@ impl CameraHandler {
|
|||||||
debug!("switching power");
|
debug!("switching power");
|
||||||
}
|
}
|
||||||
if self.device_state == DeviceState::SwitchingPower {
|
if self.device_state == DeviceState::SwitchingPower {
|
||||||
|
let allowed_cycles = 10;
|
||||||
|
for i in 0..allowed_cycles {
|
||||||
if self
|
if self
|
||||||
.power_switcher
|
.power_switcher
|
||||||
.get_is_switch_on(self.camera_switch_id)
|
.get_is_switch_on(self.camera_switch_id)
|
||||||
@ -146,8 +153,12 @@ impl CameraHandler {
|
|||||||
debug!("device on");
|
debug!("device on");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
self.mode = CameraMode::Broken;
|
||||||
|
}
|
||||||
if self.device_state == DeviceState::On {
|
if self.device_state == DeviceState::On {
|
||||||
self.can_tx.send(PackageModel::new(PackageId::CameraImageRequest, &[1]).unwrap()).unwrap();
|
self.can_tx
|
||||||
|
.send(PackageModel::new(PackageId::CameraImageRequest, &[1]).unwrap())
|
||||||
|
.unwrap();
|
||||||
debug!("sent camera request");
|
debug!("sent camera request");
|
||||||
self.mode = CameraMode::Verification;
|
self.mode = CameraMode::Verification;
|
||||||
}
|
}
|
||||||
@ -208,7 +219,7 @@ pub fn core_pld_task(
|
|||||||
pld_thread_rx: Receiver<RequestWithToken>,
|
pld_thread_rx: Receiver<RequestWithToken>,
|
||||||
pld_can_rx: Receiver<PackageModel>,
|
pld_can_rx: Receiver<PackageModel>,
|
||||||
pld_can_tx: Sender<PackageModel>,
|
pld_can_tx: Sender<PackageModel>,
|
||||||
reporter_pld: &mut VerificationReporterWithSender<StdVerifSenderError>,
|
reporter_pld: &mut VerificationReporterWithSender<MpscPusInStoreSendError>,
|
||||||
) {
|
) {
|
||||||
let (_camera_mode_tx, camera_mode_rx) = mpsc::channel();
|
let (_camera_mode_tx, camera_mode_rx) = mpsc::channel();
|
||||||
let (_action_tx, action_rx) = mpsc::channel();
|
let (_action_tx, action_rx) = mpsc::channel();
|
||||||
@ -223,7 +234,7 @@ pub fn core_pld_task(
|
|||||||
);
|
);
|
||||||
|
|
||||||
let mut time_stamp_buf: [u8; 7] = [0; 7];
|
let mut time_stamp_buf: [u8; 7] = [0; 7];
|
||||||
loop {
|
'outer: loop {
|
||||||
match pld_thread_rx.try_recv() {
|
match pld_thread_rx.try_recv() {
|
||||||
Ok(request_with_token) => {
|
Ok(request_with_token) => {
|
||||||
match request_with_token.0 {
|
match request_with_token.0 {
|
||||||
@ -237,7 +248,10 @@ pub fn core_pld_task(
|
|||||||
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
cds_stamp.write_to_bytes(&mut time_stamp_buf).unwrap();
|
||||||
// send start verification and get token
|
// send start verification and get token
|
||||||
let start_token = reporter_pld
|
let start_token = reporter_pld
|
||||||
.start_success(request_with_token.1, Some(&time_stamp_buf))
|
.start_success(
|
||||||
|
request_with_token.1.unwrap(),
|
||||||
|
Some(&time_stamp_buf),
|
||||||
|
)
|
||||||
.expect("Error sending start success.");
|
.expect("Error sending start success.");
|
||||||
|
|
||||||
debug!("{:?}", camera_handler.get_mode());
|
debug!("{:?}", camera_handler.get_mode());
|
||||||
|
@ -1,8 +1,6 @@
|
|||||||
use crate::can_ids::{DeviceId, PackageId, PackageModel};
|
use crate::can_ids::{DeviceId, PackageId, PackageModel};
|
||||||
use log::{debug};
|
use log::debug;
|
||||||
use satrs_core::power::{
|
use satrs_core::power::{PowerSwitchInfo, PowerSwitcherCommandSender, SwitchId, SwitchState};
|
||||||
PowerSwitchInfo, PowerSwitchProvider, PowerSwitcherCommandSender, SwitchId, SwitchState,
|
|
||||||
};
|
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
use std::sync::mpsc::{Receiver, Sender};
|
use std::sync::mpsc::{Receiver, Sender};
|
||||||
@ -85,10 +83,6 @@ impl PowerSwitchInfo for PowerSwitcher {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl PowerSwitchProvider for PowerSwitcher {
|
|
||||||
type Error = ();
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PCDU {
|
impl PCDU {
|
||||||
pub fn new(
|
pub fn new(
|
||||||
switch_rx: Receiver<(SwitchId, SwitchState)>,
|
switch_rx: Receiver<(SwitchId, SwitchState)>,
|
||||||
@ -108,7 +102,9 @@ impl PCDU {
|
|||||||
return if let Ok(dev_id) = DeviceId::try_from(switch_id) {
|
return if let Ok(dev_id) = DeviceId::try_from(switch_id) {
|
||||||
let dev_id_bytes = dev_id as u8;
|
let dev_id_bytes = dev_id as u8;
|
||||||
let buf: &[u8] = &dev_id_bytes.to_be_bytes();
|
let buf: &[u8] = &dev_id_bytes.to_be_bytes();
|
||||||
self.can_tx.send(PackageModel::new(PackageId::DevicePowerOnRequest, buf).unwrap()).unwrap();
|
self.can_tx
|
||||||
|
.send(PackageModel::new(PackageId::DevicePowerOnRequest, buf).unwrap())
|
||||||
|
.unwrap();
|
||||||
let mut map_lock = self.device_state_map.lock().unwrap();
|
let mut map_lock = self.device_state_map.lock().unwrap();
|
||||||
*map_lock.get_mut(&dev_id).unwrap() = SwitchState::Unknown;
|
*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
|
// TODO: potentially change bus logic -> remove acceptance and verification of power off/on, since status is simply called in next step anyway
|
||||||
@ -124,7 +120,9 @@ impl PCDU {
|
|||||||
return if let Ok(dev_id) = DeviceId::try_from(switch_id) {
|
return if let Ok(dev_id) = DeviceId::try_from(switch_id) {
|
||||||
let dev_id_bytes = dev_id as u8;
|
let dev_id_bytes = dev_id as u8;
|
||||||
let buf: &[u8] = &dev_id_bytes.to_be_bytes();
|
let buf: &[u8] = &dev_id_bytes.to_be_bytes();
|
||||||
self.can_tx.send(PackageModel::new(PackageId::DevicePowerOffRequest, buf).unwrap()).unwrap();
|
self.can_tx
|
||||||
|
.send(PackageModel::new(PackageId::DevicePowerOffRequest, buf).unwrap())
|
||||||
|
.unwrap();
|
||||||
let mut map_lock = self.device_state_map.lock().unwrap();
|
let mut map_lock = self.device_state_map.lock().unwrap();
|
||||||
*map_lock.get_mut(&dev_id).unwrap() = SwitchState::Unknown;
|
*map_lock.get_mut(&dev_id).unwrap() = SwitchState::Unknown;
|
||||||
self.can_rx.recv().unwrap();
|
self.can_rx.recv().unwrap();
|
||||||
@ -139,7 +137,9 @@ impl PCDU {
|
|||||||
let _switch_id: SwitchId = *dev_id as u16;
|
let _switch_id: SwitchId = *dev_id as u16;
|
||||||
let dev_id_bytes = *dev_id as u8;
|
let dev_id_bytes = *dev_id as u8;
|
||||||
let buf: &[u8] = &dev_id_bytes.to_be_bytes();
|
let buf: &[u8] = &dev_id_bytes.to_be_bytes();
|
||||||
self.can_tx.send(PackageModel::new(PackageId::DevicePowerStatusRequest, buf).unwrap()).unwrap();
|
self.can_tx
|
||||||
|
.send(PackageModel::new(PackageId::DevicePowerStatusRequest, buf).unwrap())
|
||||||
|
.unwrap();
|
||||||
match self.can_rx.recv_timeout(Duration::from_secs(10)) {
|
match self.can_rx.recv_timeout(Duration::from_secs(10)) {
|
||||||
Ok(msg) => {
|
Ok(msg) => {
|
||||||
if msg.package_id() == PackageId::DevicePowerStatusResponse
|
if msg.package_id() == PackageId::DevicePowerStatusResponse
|
||||||
|
204
src/pus.rs
204
src/pus.rs
@ -1,8 +1,12 @@
|
|||||||
|
use crate::action;
|
||||||
|
use crate::action::ActionRequest;
|
||||||
use crate::requests::{Request, RequestWithToken};
|
use crate::requests::{Request, RequestWithToken};
|
||||||
use crate::tmtc::{PusTcSource, TmStore};
|
use crate::tmtc::{PusTcSource, TmStore};
|
||||||
|
use eurosim_obsw::RequestTargetId::{AcsSubsystem, PldSubsystem};
|
||||||
|
use eurosim_obsw::{hk_err, tmtc_err, CustomPusServiceId, TEST_EVENT};
|
||||||
use log::{info, warn};
|
use log::{info, warn};
|
||||||
use satrs_core::events::EventU32;
|
use satrs_core::events::EventU32;
|
||||||
use satrs_core::hk::{CollectionIntervalFactor, HkRequest};
|
use satrs_core::hk::{CollectionIntervalFactor, HkRequest, UniqueId};
|
||||||
use satrs_core::mode::{ModeAndSubmode, ModeCommand, ModeRequest};
|
use satrs_core::mode::{ModeAndSubmode, ModeCommand, ModeRequest};
|
||||||
use satrs_core::params::Params;
|
use satrs_core::params::Params;
|
||||||
use satrs_core::pool::StoreAddr;
|
use satrs_core::pool::StoreAddr;
|
||||||
@ -18,21 +22,20 @@ use satrs_core::pus::verification::{
|
|||||||
use satrs_core::pus::{event, GenericTcCheckError};
|
use satrs_core::pus::{event, GenericTcCheckError};
|
||||||
use satrs_core::res_code::ResultU16;
|
use satrs_core::res_code::ResultU16;
|
||||||
use satrs_core::spacepackets::ecss::{scheduling, PusServiceId};
|
use satrs_core::spacepackets::ecss::{scheduling, PusServiceId};
|
||||||
|
use satrs_core::spacepackets::CcsdsPacket;
|
||||||
use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
|
use satrs_core::tmtc::tm_helper::PusTmWithCdsShortHelper;
|
||||||
use satrs_core::tmtc::{AddressableId, PusServiceProvider, TargetId};
|
use satrs_core::tmtc::{AddressableId, PusServiceProvider, TargetId};
|
||||||
use satrs_core::{
|
use satrs_core::{
|
||||||
spacepackets::ecss::PusPacket, spacepackets::tc::PusTc, spacepackets::time::cds::TimeProvider,
|
spacepackets::ecss::PusPacket, spacepackets::tc::PusTc, spacepackets::time::cds::TimeProvider,
|
||||||
spacepackets::time::TimeWriter, spacepackets::SpHeader,
|
spacepackets::time::TimeWriter, spacepackets::SpHeader,
|
||||||
};
|
};
|
||||||
use eurosim_obsw::{hk_err, tmtc_err, CustomPusServiceId, TEST_EVENT};
|
|
||||||
use std::cell::RefCell;
|
use std::cell::RefCell;
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
use std::convert::TryFrom;
|
use std::convert::TryFrom;
|
||||||
|
use std::hash::Hash;
|
||||||
use std::rc::Rc;
|
use std::rc::Rc;
|
||||||
use std::sync::mpsc::Sender;
|
use std::sync::mpsc::Sender;
|
||||||
use eurosim_obsw::RequestTargetId::{AcsSubsystem, PldSubsystem};
|
use satrs_core::seq_count::{SeqCountProviderSyncClonable, SequenceCountProviderCore};
|
||||||
use crate::action;
|
|
||||||
use crate::action::ActionRequest;
|
|
||||||
|
|
||||||
pub struct PusReceiver {
|
pub struct PusReceiver {
|
||||||
pub tm_helper: PusTmWithCdsShortHelper,
|
pub tm_helper: PusTmWithCdsShortHelper,
|
||||||
@ -48,6 +51,8 @@ pub struct PusTmArgs {
|
|||||||
pub tm_store: TmStore,
|
pub tm_store: TmStore,
|
||||||
/// All verification reporting is done with this reporter.
|
/// All verification reporting is done with this reporter.
|
||||||
pub verif_reporter: StdVerifReporterWithSender,
|
pub verif_reporter: StdVerifReporterWithSender,
|
||||||
|
/// Sequence count provider for TMs sent from within pus demultiplexer
|
||||||
|
pub seq_count_provider: SeqCountProviderSyncClonable,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl PusTmArgs {
|
impl PusTmArgs {
|
||||||
@ -64,6 +69,7 @@ pub struct PusTcArgs {
|
|||||||
pub tc_source: PusTcSource,
|
pub tc_source: PusTcSource,
|
||||||
pub event_sender: Sender<(EventU32, Option<Params>)>,
|
pub event_sender: Sender<(EventU32, Option<Params>)>,
|
||||||
pub scheduler: Rc<RefCell<PusScheduler>>,
|
pub scheduler: Rc<RefCell<PusScheduler>>,
|
||||||
|
pub apid_map: HashMap<u16, Sender<RequestWithToken>>,
|
||||||
}
|
}
|
||||||
|
|
||||||
struct TimeStampHelper {
|
struct TimeStampHelper {
|
||||||
@ -113,6 +119,8 @@ impl PusServiceProvider for PusReceiver {
|
|||||||
_header: &SpHeader,
|
_header: &SpHeader,
|
||||||
pus_tc: &PusTc,
|
pus_tc: &PusTc,
|
||||||
) -> Result<(), Self::Error> {
|
) -> Result<(), Self::Error> {
|
||||||
|
let apid = pus_tc.apid();
|
||||||
|
println!("{:?}", apid);
|
||||||
let init_token = self.tm_args.verif_reporter.add_tc(pus_tc);
|
let init_token = self.tm_args.verif_reporter.add_tc(pus_tc);
|
||||||
self.stamp_helper.update_from_now();
|
self.stamp_helper.update_from_now();
|
||||||
let accepted_token = self
|
let accepted_token = self
|
||||||
@ -121,15 +129,17 @@ impl PusServiceProvider for PusReceiver {
|
|||||||
.acceptance_success(init_token, Some(self.stamp_helper.stamp()))
|
.acceptance_success(init_token, Some(self.stamp_helper.stamp()))
|
||||||
.expect("Acceptance success failure");
|
.expect("Acceptance success failure");
|
||||||
let service = PusServiceId::try_from(service);
|
let service = PusServiceId::try_from(service);
|
||||||
match service {
|
|
||||||
|
// services handled by pus handler return none, otherwise request is returned to be forwarded via apid
|
||||||
|
if let Some(request) = match service {
|
||||||
Ok(standard_service) => match standard_service {
|
Ok(standard_service) => match standard_service {
|
||||||
PusServiceId::Test => self.handle_test_service(pus_tc, accepted_token),
|
PusServiceId::Test => self.handle_test_service(pus_tc, accepted_token),
|
||||||
PusServiceId::Housekeeping => self.handle_hk_request(pus_tc, accepted_token),
|
PusServiceId::Housekeeping => self.handle_hk_request(pus_tc, accepted_token),
|
||||||
PusServiceId::Event => self.handle_event_request(pus_tc, accepted_token),
|
PusServiceId::Event => self.handle_event_request(pus_tc, accepted_token),
|
||||||
PusServiceId::Scheduling => self.handle_scheduled_tc(pus_tc, accepted_token),
|
PusServiceId::Scheduling => self.handle_scheduled_tc(pus_tc, accepted_token),
|
||||||
PusServiceId::Action => self.handle_action_request(pus_tc, accepted_token),
|
PusServiceId::Action => self.handle_function_request(pus_tc, accepted_token),
|
||||||
_ => self
|
_ => {
|
||||||
.tm_args
|
self.tm_args
|
||||||
.verif_reporter
|
.verif_reporter
|
||||||
.start_failure(
|
.start_failure(
|
||||||
accepted_token,
|
accepted_token,
|
||||||
@ -139,7 +149,9 @@ impl PusServiceProvider for PusReceiver {
|
|||||||
Some(&[standard_service as u8]),
|
Some(&[standard_service as u8]),
|
||||||
),
|
),
|
||||||
)
|
)
|
||||||
.expect("Start failure verification failed"),
|
.expect("Start failure verification failed");
|
||||||
|
None
|
||||||
|
}
|
||||||
},
|
},
|
||||||
Err(e) => {
|
Err(e) => {
|
||||||
if let Ok(custom_service) = CustomPusServiceId::try_from(e.number) {
|
if let Ok(custom_service) = CustomPusServiceId::try_from(e.number) {
|
||||||
@ -147,7 +159,7 @@ impl PusServiceProvider for PusReceiver {
|
|||||||
CustomPusServiceId::Mode => {
|
CustomPusServiceId::Mode => {
|
||||||
self.handle_mode_service(pus_tc, accepted_token)
|
self.handle_mode_service(pus_tc, accepted_token)
|
||||||
}
|
}
|
||||||
CustomPusServiceId::Health => {}
|
CustomPusServiceId::Health => None,
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
self.tm_args
|
self.tm_args
|
||||||
@ -160,16 +172,25 @@ impl PusServiceProvider for PusReceiver {
|
|||||||
Some(&[e.number]),
|
Some(&[e.number]),
|
||||||
),
|
),
|
||||||
)
|
)
|
||||||
.expect("Start failure verification failed")
|
.expect("Start failure verification failed");
|
||||||
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
} {
|
||||||
|
if let Some(sender) = self.tc_args.apid_map.clone().get(&apid) {
|
||||||
|
sender.send(request).expect("error sending request");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl PusReceiver {
|
impl PusReceiver {
|
||||||
fn handle_test_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
|
fn handle_test_service(
|
||||||
|
&mut self,
|
||||||
|
pus_tc: &PusTc,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) -> Option<RequestWithToken> {
|
||||||
match PusPacket::subservice(pus_tc) {
|
match PusPacket::subservice(pus_tc) {
|
||||||
1 => {
|
1 => {
|
||||||
info!("Received PUS ping command TC[17,1]");
|
info!("Received PUS ping command TC[17,1]");
|
||||||
@ -179,12 +200,13 @@ impl PusReceiver {
|
|||||||
.verif_reporter
|
.verif_reporter
|
||||||
.start_success(token, Some(self.stamp_helper.stamp()))
|
.start_success(token, Some(self.stamp_helper.stamp()))
|
||||||
.expect("Error sending start success");
|
.expect("Error sending start success");
|
||||||
let ping_reply = self.tm_helper.create_pus_tm_timestamp_now(17, 2, None);
|
let ping_reply = self.tm_helper.create_pus_tm_timestamp_now(17, 2, None, self.tm_args.seq_count_provider.get());
|
||||||
let addr = self.tm_args.tm_store.add_pus_tm(&ping_reply);
|
let addr = self.tm_args.tm_store.add_pus_tm(&ping_reply);
|
||||||
self.tm_args
|
self.tm_args
|
||||||
.tm_tx
|
.tm_tx
|
||||||
.send(addr)
|
.send(addr)
|
||||||
.expect("Sending TM to TM funnel failed");
|
.expect("Sending TM to TM funnel failed");
|
||||||
|
self.tm_args.seq_count_provider.increment();
|
||||||
self.tm_args
|
self.tm_args
|
||||||
.verif_reporter
|
.verif_reporter
|
||||||
.completion_success(start_token, Some(self.stamp_helper.stamp()))
|
.completion_success(start_token, Some(self.stamp_helper.stamp()))
|
||||||
@ -220,9 +242,14 @@ impl PusReceiver {
|
|||||||
.expect("Sending start failure TM failed");
|
.expect("Sending start failure TM failed");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_hk_request(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
|
fn handle_hk_request(
|
||||||
|
&mut self,
|
||||||
|
pus_tc: &PusTc,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) -> Option<RequestWithToken> {
|
||||||
if pus_tc.user_data().is_none() {
|
if pus_tc.user_data().is_none() {
|
||||||
self.tm_args
|
self.tm_args
|
||||||
.verif_reporter
|
.verif_reporter
|
||||||
@ -235,15 +262,11 @@ impl PusReceiver {
|
|||||||
),
|
),
|
||||||
)
|
)
|
||||||
.expect("Sending start failure TM failed");
|
.expect("Sending start failure TM failed");
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
let user_data = pus_tc.user_data().unwrap();
|
let user_data = pus_tc.user_data().unwrap();
|
||||||
if user_data.len() < 8 {
|
if user_data.len() < 4 {
|
||||||
let err = if user_data.len() < 4 {
|
let err = &hk_err::UNIQUE_ID_MISSING;
|
||||||
&hk_err::TARGET_ID_MISSING
|
|
||||||
} else {
|
|
||||||
&hk_err::UNIQUE_ID_MISSING
|
|
||||||
};
|
|
||||||
self.tm_args
|
self.tm_args
|
||||||
.verif_reporter
|
.verif_reporter
|
||||||
.start_failure(
|
.start_failure(
|
||||||
@ -251,27 +274,19 @@ impl PusReceiver {
|
|||||||
FailParams::new(Some(self.stamp_helper.stamp()), err, None),
|
FailParams::new(Some(self.stamp_helper.stamp()), err, None),
|
||||||
)
|
)
|
||||||
.expect("Sending start failure TM failed");
|
.expect("Sending start failure TM failed");
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
let addressable_id = AddressableId::from_raw_be(user_data).unwrap();
|
|
||||||
if !self
|
let apid = pus_tc.sp_header().apid();
|
||||||
.tc_args
|
|
||||||
.request_map
|
match apid {
|
||||||
.contains_key(&addressable_id.target_id)
|
_ => {}
|
||||||
{
|
|
||||||
self.tm_args
|
|
||||||
.verif_reporter
|
|
||||||
.start_failure(
|
|
||||||
token,
|
|
||||||
FailParams::new(
|
|
||||||
Some(self.stamp_helper.stamp()),
|
|
||||||
&hk_err::UNKNOWN_TARGET_ID,
|
|
||||||
None,
|
|
||||||
),
|
|
||||||
)
|
|
||||||
.expect("Sending start failure TM failed");
|
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
let unique_id: UniqueId =
|
||||||
|
u32::from_be_bytes(user_data[0..4].try_into().unwrap()) as UniqueId;
|
||||||
|
|
||||||
|
/*
|
||||||
let send_request = |request: HkRequest| {
|
let send_request = |request: HkRequest| {
|
||||||
let sender = self
|
let sender = self
|
||||||
.tc_args
|
.tc_args
|
||||||
@ -279,15 +294,22 @@ impl PusReceiver {
|
|||||||
.get(&addressable_id.target_id)
|
.get(&addressable_id.target_id)
|
||||||
.unwrap();
|
.unwrap();
|
||||||
sender
|
sender
|
||||||
.send(RequestWithToken(Request::HkRequest(request), token))
|
.send(RequestWithToken(Request::HkRequest(request), Some(token)))
|
||||||
.unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
|
.unwrap_or_else(|_| panic!("Sending HK request {request:?} failed"));
|
||||||
};
|
};
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
if let Some(request) =
|
||||||
if PusPacket::subservice(pus_tc) == hk::Subservice::TcEnableHkGeneration as u8 {
|
if PusPacket::subservice(pus_tc) == hk::Subservice::TcEnableHkGeneration as u8 {
|
||||||
send_request(HkRequest::Enable(addressable_id));
|
//send_request(HkRequest::Enable(addressable_id));
|
||||||
|
Some(HkRequest::Enable(unique_id))
|
||||||
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcDisableHkGeneration as u8 {
|
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcDisableHkGeneration as u8 {
|
||||||
send_request(HkRequest::Disable(addressable_id));
|
//send_request(HkRequest::Disable(addressable_id));
|
||||||
|
Some(HkRequest::Enable(unique_id))
|
||||||
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcGenerateOneShotHk as u8 {
|
} else if PusPacket::subservice(pus_tc) == hk::Subservice::TcGenerateOneShotHk as u8 {
|
||||||
send_request(HkRequest::OneShot(addressable_id));
|
//send_request(HkRequest::OneShot(addressable_id));
|
||||||
|
Some(HkRequest::OneShot(unique_id))
|
||||||
} else if PusPacket::subservice(pus_tc)
|
} else if PusPacket::subservice(pus_tc)
|
||||||
== hk::Subservice::TcModifyHkCollectionInterval as u8
|
== hk::Subservice::TcModifyHkCollectionInterval as u8
|
||||||
{
|
{
|
||||||
@ -303,16 +325,27 @@ impl PusReceiver {
|
|||||||
),
|
),
|
||||||
)
|
)
|
||||||
.expect("Sending start failure TM failed");
|
.expect("Sending start failure TM failed");
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
send_request(HkRequest::ModifyCollectionInterval(
|
//send_request(HkRequest::ModifyCollectionInterval(addressable_id,CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap())));
|
||||||
addressable_id,
|
Some(HkRequest::ModifyCollectionInterval(
|
||||||
|
unique_id,
|
||||||
CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap()),
|
CollectionIntervalFactor::from_be_bytes(user_data[8..12].try_into().unwrap()),
|
||||||
));
|
))
|
||||||
|
} else {
|
||||||
|
return None;
|
||||||
}
|
}
|
||||||
|
{
|
||||||
|
return Some(RequestWithToken(Request::HkRequest(request), Some(token)));
|
||||||
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_event_request(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
|
fn handle_event_request(
|
||||||
|
&mut self,
|
||||||
|
pus_tc: &PusTc,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) -> Option<RequestWithToken> {
|
||||||
let send_start_failure = |vr: &mut StdVerifReporterWithSender,
|
let send_start_failure = |vr: &mut StdVerifReporterWithSender,
|
||||||
timestamp: &[u8],
|
timestamp: &[u8],
|
||||||
failure_code: &ResultU16,
|
failure_code: &ResultU16,
|
||||||
@ -334,7 +367,7 @@ impl PusReceiver {
|
|||||||
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
||||||
None,
|
None,
|
||||||
);
|
);
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
let app_data = pus_tc.user_data().unwrap();
|
let app_data = pus_tc.user_data().unwrap();
|
||||||
if app_data.len() < 4 {
|
if app_data.len() < 4 {
|
||||||
@ -344,7 +377,7 @@ impl PusReceiver {
|
|||||||
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
||||||
None,
|
None,
|
||||||
);
|
);
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap()));
|
let event_id = EventU32::from(u32::from_be_bytes(app_data.try_into().unwrap()));
|
||||||
match PusPacket::subservice(pus_tc).try_into() {
|
match PusPacket::subservice(pus_tc).try_into() {
|
||||||
@ -383,9 +416,14 @@ impl PusReceiver {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_scheduled_tc(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
|
fn handle_scheduled_tc(
|
||||||
|
&mut self,
|
||||||
|
pus_tc: &PusTc,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) -> Option<RequestWithToken> {
|
||||||
let subservice = match pus_11_generic_tc_check(pus_tc) {
|
let subservice = match pus_11_generic_tc_check(pus_tc) {
|
||||||
Ok(subservice) => subservice,
|
Ok(subservice) => subservice,
|
||||||
Err(e) => match e {
|
Err(e) => match e {
|
||||||
@ -401,7 +439,7 @@ impl PusReceiver {
|
|||||||
),
|
),
|
||||||
)
|
)
|
||||||
.expect("could not sent verification error");
|
.expect("could not sent verification error");
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
GenericTcCheckError::InvalidSubservice => {
|
GenericTcCheckError::InvalidSubservice => {
|
||||||
self.tm_args
|
self.tm_args
|
||||||
@ -415,7 +453,7 @@ impl PusReceiver {
|
|||||||
),
|
),
|
||||||
)
|
)
|
||||||
.expect("could not sent verification error");
|
.expect("could not sent verification error");
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
@ -509,9 +547,14 @@ impl PusReceiver {
|
|||||||
}
|
}
|
||||||
_ => {}
|
_ => {}
|
||||||
}
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_mode_service(&mut self, pus_tc: &PusTc, token: VerificationToken<TcStateAccepted>) {
|
fn handle_mode_service(
|
||||||
|
&mut self,
|
||||||
|
pus_tc: &PusTc,
|
||||||
|
token: VerificationToken<TcStateAccepted>,
|
||||||
|
) -> Option<RequestWithToken> {
|
||||||
let mut app_data_len = 0;
|
let mut app_data_len = 0;
|
||||||
let app_data = pus_tc.user_data();
|
let app_data = pus_tc.user_data();
|
||||||
if app_data.is_some() {
|
if app_data.is_some() {
|
||||||
@ -554,7 +597,10 @@ impl PusReceiver {
|
|||||||
None => warn!("not mode request recipient for target ID {target_id} found"),
|
None => warn!("not mode request recipient for target ID {target_id} found"),
|
||||||
Some(sender_to_recipient) => {
|
Some(sender_to_recipient) => {
|
||||||
sender_to_recipient
|
sender_to_recipient
|
||||||
.send(RequestWithToken(Request::ModeRequest(mode_request), token))
|
.send(RequestWithToken(
|
||||||
|
Request::ModeRequest(mode_request),
|
||||||
|
Some(token),
|
||||||
|
))
|
||||||
.expect("sending mode request failed");
|
.expect("sending mode request failed");
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
@ -586,22 +632,19 @@ impl PusReceiver {
|
|||||||
.unwrap(),
|
.unwrap(),
|
||||||
)
|
)
|
||||||
.unwrap();
|
.unwrap();
|
||||||
forward_mode_request(
|
forward_mode_request(target_id, ModeRequest::SetMode(mode_submode));
|
||||||
target_id,
|
|
||||||
ModeRequest::SetMode(ModeCommand::new(target_id, mode_submode)),
|
|
||||||
);
|
|
||||||
}
|
}
|
||||||
Subservice::TcReadMode => {
|
Subservice::TcReadMode => {
|
||||||
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
|
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
|
||||||
forward_mode_request(target_id, ModeRequest::ReadMode(target_id));
|
forward_mode_request(target_id, ModeRequest::ReadMode);
|
||||||
}
|
}
|
||||||
Subservice::TcAnnounceMode => {
|
Subservice::TcAnnounceMode => {
|
||||||
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
|
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
|
||||||
forward_mode_request(target_id, ModeRequest::AnnounceMode(target_id));
|
forward_mode_request(target_id, ModeRequest::AnnounceMode);
|
||||||
}
|
}
|
||||||
Subservice::TcAnnounceModeRecursive => {
|
Subservice::TcAnnounceModeRecursive => {
|
||||||
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
|
let target_id = u32::from_be_bytes(app_data[0..4].try_into().unwrap());
|
||||||
forward_mode_request(target_id, ModeRequest::AnnounceModeRecursive(target_id));
|
forward_mode_request(target_id, ModeRequest::AnnounceModeRecursive);
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
warn!("Can not process mode request with subservice {subservice:?}");
|
warn!("Can not process mode request with subservice {subservice:?}");
|
||||||
@ -618,22 +661,28 @@ impl PusReceiver {
|
|||||||
} else {
|
} else {
|
||||||
invalid_subservice_handler();
|
invalid_subservice_handler();
|
||||||
}
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
|
|
||||||
fn handle_action_request(
|
fn handle_function_request(
|
||||||
&mut self,
|
&mut self,
|
||||||
pus_tc: &PusTc,
|
pus_tc: &PusTc,
|
||||||
token: VerificationToken<TcStateAccepted>,
|
token: VerificationToken<TcStateAccepted>,
|
||||||
) {
|
) -> Option<RequestWithToken> {
|
||||||
if pus_tc.user_data().is_none() {
|
if pus_tc.user_data().is_none() {
|
||||||
self.stamp_helper.stamper.update_from_now().unwrap();
|
self.stamp_helper.stamper.update_from_now().unwrap();
|
||||||
self.tm_args.verif_reporter
|
self.tm_args
|
||||||
|
.verif_reporter
|
||||||
.start_failure(
|
.start_failure(
|
||||||
token,
|
token,
|
||||||
FailParams::new(Some(&self.stamp_helper.stamp()), &tmtc_err::NOT_ENOUGH_APP_DATA, None),
|
FailParams::new(
|
||||||
|
Some(&self.stamp_helper.stamp()),
|
||||||
|
&tmtc_err::NOT_ENOUGH_APP_DATA,
|
||||||
|
None,
|
||||||
|
),
|
||||||
)
|
)
|
||||||
.expect("Sending start failure TM failed");
|
.expect("Sending start failure TM failed");
|
||||||
return;
|
return None;
|
||||||
}
|
}
|
||||||
|
|
||||||
let send_request = |request: ActionRequest| match request {
|
let send_request = |request: ActionRequest| match request {
|
||||||
@ -641,23 +690,34 @@ impl PusReceiver {
|
|||||||
let id = target_id as u32;
|
let id = target_id as u32;
|
||||||
let sender = self.tc_args.request_map.get(&id).unwrap();
|
let sender = self.tc_args.request_map.get(&id).unwrap();
|
||||||
sender
|
sender
|
||||||
.send(RequestWithToken(Request::ActionRequest(request), token))
|
.send(RequestWithToken(
|
||||||
|
Request::ActionRequest(request),
|
||||||
|
Some(token),
|
||||||
|
))
|
||||||
.unwrap_or_else(|_| panic!("Sending Action request {:?} failed", request));
|
.unwrap_or_else(|_| panic!("Sending Action request {:?} failed", request));
|
||||||
}
|
}
|
||||||
ActionRequest::OrientationRequest(target_id) => {
|
ActionRequest::OrientationRequest(target_id) => {
|
||||||
let id = target_id as u32;
|
let id = target_id as u32;
|
||||||
let sender = self.tc_args.request_map.get(&id).unwrap();
|
let sender = self.tc_args.request_map.get(&id).unwrap();
|
||||||
sender
|
sender
|
||||||
.send(RequestWithToken(Request::ActionRequest(request), token))
|
.send(RequestWithToken(
|
||||||
|
Request::ActionRequest(request),
|
||||||
|
Some(token),
|
||||||
|
))
|
||||||
.unwrap_or_else(|_| panic!("Sending Action request {:?} failed", request));
|
.unwrap_or_else(|_| panic!("Sending Action request {:?} failed", request));
|
||||||
}
|
}
|
||||||
_ => {}
|
_ => {}
|
||||||
};
|
};
|
||||||
|
|
||||||
if PusPacket::subservice(pus_tc) == action::Subservice::ImageRequest as u8 {
|
if PusPacket::subservice(pus_tc) == action::Subservice::ImageRequest as u8 {
|
||||||
send_request(ActionRequest::ImageRequest(PldSubsystem));
|
//send_request(ActionRequest::ImageRequest(PldSubsystem));
|
||||||
|
return Some(RequestWithToken(
|
||||||
|
Request::ActionRequest(ActionRequest::ImageRequest(PldSubsystem)),
|
||||||
|
Some(token),
|
||||||
|
));
|
||||||
} else if PusPacket::subservice(pus_tc) == action::Subservice::OrientationRequest as u8 {
|
} else if PusPacket::subservice(pus_tc) == action::Subservice::OrientationRequest as u8 {
|
||||||
send_request(ActionRequest::OrientationRequest(AcsSubsystem));
|
send_request(ActionRequest::OrientationRequest(AcsSubsystem));
|
||||||
}
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1,19 +1,15 @@
|
|||||||
|
use crate::action::ActionRequest;
|
||||||
use satrs_core::hk::HkRequest;
|
use satrs_core::hk::HkRequest;
|
||||||
use satrs_core::mode::ModeRequest;
|
use satrs_core::mode::ModeRequest;
|
||||||
use satrs_core::pus::verification::{TcStateAccepted, VerificationToken};
|
use satrs_core::pus::verification::{TcStateAccepted, VerificationToken};
|
||||||
use crate::action::ActionRequest;
|
|
||||||
|
|
||||||
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
||||||
#[non_exhaustive]
|
#[non_exhaustive]
|
||||||
pub enum Request {
|
pub enum Request {
|
||||||
HkRequest(HkRequest),
|
HkRequest(HkRequest),
|
||||||
ModeRequest(ModeRequest),
|
ModeRequest(ModeRequest),
|
||||||
ActionRequest(ActionRequest)
|
ActionRequest(ActionRequest),
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
||||||
pub struct RequestWithToken(pub Request, pub VerificationToken<TcStateAccepted>);
|
pub struct RequestWithToken(pub Request, pub Option<VerificationToken<TcStateAccepted>>);
|
||||||
|
|
||||||
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
|
|
||||||
pub struct RequestWithOptionalToken(pub Request, pub Option<VerificationToken<TcStateAccepted>>);
|
|
||||||
|
|
||||||
|
15
src/tmtc.rs
15
src/tmtc.rs
@ -19,12 +19,23 @@ use satrs_core::pool::{SharedPool, StoreAddr, StoreError};
|
|||||||
use satrs_core::pus::event_man::EventRequestWithToken;
|
use satrs_core::pus::event_man::EventRequestWithToken;
|
||||||
use satrs_core::pus::scheduling::{PusScheduler, TcInfo};
|
use satrs_core::pus::scheduling::{PusScheduler, TcInfo};
|
||||||
use satrs_core::pus::verification::StdVerifReporterWithSender;
|
use satrs_core::pus::verification::StdVerifReporterWithSender;
|
||||||
|
use satrs_core::seq_count::SeqCountProviderSyncClonable;
|
||||||
|
use satrs_core::spacepackets::tc::PUS_TC_MIN_LEN_WITHOUT_APP_DATA;
|
||||||
use satrs_core::spacepackets::{ecss::PusPacket, tc::PusTc, tm::PusTm, SpHeader};
|
use satrs_core::spacepackets::{ecss::PusPacket, tc::PusTc, tm::PusTm, SpHeader};
|
||||||
use satrs_core::tmtc::{
|
use satrs_core::tmtc::{
|
||||||
CcsdsDistributor, CcsdsError, PusServiceProvider, ReceivesCcsdsTc, ReceivesEcssPusTc,
|
CcsdsDistributor, CcsdsError, PusServiceProvider, ReceivesCcsdsTc, ReceivesEcssPusTc,
|
||||||
};
|
};
|
||||||
|
|
||||||
pub const PUS_APID: u16 = 0x02;
|
pub const PUS_APID: u16 = 0x02;
|
||||||
|
pub const PLD_APID: u16 = 0x30;
|
||||||
|
pub const PWR_APID: u16 = 0x40;
|
||||||
|
pub const AOCS_APID: u16 = 0x50;
|
||||||
|
pub const AOCS_HK_APID: u16 = 0x51;
|
||||||
|
pub const MGM_APID: u16 = 0x52;
|
||||||
|
pub const CSS_APID: u16 = 0x53;
|
||||||
|
pub const STR_APID: u16 = 0x54;
|
||||||
|
pub const MGT_APID: u16 = 0x55;
|
||||||
|
pub const RWL_APID: u16 = 0x56;
|
||||||
|
|
||||||
pub struct OtherArgs {
|
pub struct OtherArgs {
|
||||||
pub sock_addr: SocketAddr,
|
pub sock_addr: SocketAddr,
|
||||||
@ -32,6 +43,8 @@ pub struct OtherArgs {
|
|||||||
pub event_sender: Sender<(EventU32, Option<Params>)>,
|
pub event_sender: Sender<(EventU32, Option<Params>)>,
|
||||||
pub event_request_tx: Sender<EventRequestWithToken>,
|
pub event_request_tx: Sender<EventRequestWithToken>,
|
||||||
pub request_map: HashMap<u32, Sender<RequestWithToken>>,
|
pub request_map: HashMap<u32, Sender<RequestWithToken>>,
|
||||||
|
pub apid_map: HashMap<u16, Sender<RequestWithToken>>,
|
||||||
|
pub seq_count_provider: SeqCountProviderSyncClonable,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct TmArgs {
|
pub struct TmArgs {
|
||||||
@ -173,6 +186,7 @@ pub fn core_tmtc_task(args: OtherArgs, mut tc_args: TcArgs, tm_args: TmArgs) {
|
|||||||
tm_tx: tm_args.tm_sink_sender,
|
tm_tx: tm_args.tm_sink_sender,
|
||||||
tm_store: tm_args.tm_store.clone(),
|
tm_store: tm_args.tm_store.clone(),
|
||||||
verif_reporter: args.verif_reporter,
|
verif_reporter: args.verif_reporter,
|
||||||
|
seq_count_provider: args.seq_count_provider.clone(),
|
||||||
};
|
};
|
||||||
let pus_tc_args = PusTcArgs {
|
let pus_tc_args = PusTcArgs {
|
||||||
event_request_tx: args.event_request_tx,
|
event_request_tx: args.event_request_tx,
|
||||||
@ -180,6 +194,7 @@ pub fn core_tmtc_task(args: OtherArgs, mut tc_args: TcArgs, tm_args: TmArgs) {
|
|||||||
tc_source: tc_args.tc_source.clone(),
|
tc_source: tc_args.tc_source.clone(),
|
||||||
event_sender: args.event_sender,
|
event_sender: args.event_sender,
|
||||||
scheduler: sched_clone,
|
scheduler: sched_clone,
|
||||||
|
apid_map: args.apid_map,
|
||||||
};
|
};
|
||||||
let mut pus_receiver = PusReceiver::new(PUS_APID, pus_tm_args, pus_tc_args);
|
let mut pus_receiver = PusReceiver::new(PUS_APID, pus_tm_args, pus_tc_args);
|
||||||
|
|
||||||
|
Loading…
Reference in New Issue
Block a user