cosmetics

mission_rust/src/fsrc/objectmanager.rs

@@ -1,12 +1,12 @@
-use super::tasks::ExecutableObjectIF;
+use super::*;
 
 pub type ObjectId = usize;
 pub trait ObjectManager<'a> {
-    fn get_object(&self, id: ObjectId) -> Option<&'a dyn SystemObject>;
+    fn get_object(&self, id: ObjectId) -> Result<&'a dyn SystemObjectIF, ()>;
 }
 
-pub trait SystemObject: ExecutableObjectIF {
+pub trait SystemObjectIF: tasks::ExecutableObjectIF {
     fn get_id(&self) -> ObjectId;
-    fn initialize(&mut self, object_manager: &dyn ObjectManager) -> Result<(),()>;
+    fn initialize(&mut self, object_manager: &dyn ObjectManager) -> Result<(), ()>;
-    fn get_command_queue(&self) -> crate::fsrc::queues::MessageQueueSender;
+    fn get_command_queue(&self) -> queues::MessageQueueSender;
-}
+}

mission_rust/src/fsrc/osal/mod.rs

@@ -9,7 +9,7 @@ extern "C" {
         stack_size: cty::size_t,
     ) -> *const cty::c_void;
 
-    pub fn get_task_name() -> *const core::ffi::c_uchar;
+    pub fn get_task_name() -> *const core::ffi::c_char;
 
     pub fn stop_it();
 

mission_rust/src/fsrc/tasks/mod.rs

@@ -21,7 +21,7 @@ pub trait TaskIF<'a> {
     fn get_stack_size(&self) -> cty::size_t;
     fn set_handle(&mut self, task_handle: *const cty::c_void);
     fn get_handle(&self) -> *const cty::c_void;
-    fn get_objects(&'a self) -> &'a [&'a mut dyn crate::objectmanager::SystemObject];
+    fn get_objects(&'a self) -> &'a [&'a mut dyn crate::objectmanager::SystemObjectIF];
     fn initialize(&mut self, object_manager: &dyn ObjectManager) -> Result<(), ()>;
 }
 
@@ -29,12 +29,12 @@ pub struct PeriodicTask<'a> {
     pub stack_size: cty::size_t, //TODO generic type and safety
     pub task_handle: *const cty::c_void,
     pub period: usize,
-    pub task_objects: &'a mut [&'a mut dyn crate::objectmanager::SystemObject],
+    pub task_objects: &'a mut [&'a mut dyn crate::objectmanager::SystemObjectIF],
 }
 
 impl<'a> PeriodicTask<'a> {
     pub fn new(
-        objects: &'a mut [&'a mut dyn crate::objectmanager::SystemObject],
+        objects: &'a mut [&'a mut dyn crate::objectmanager::SystemObjectIF],
         stack_size: usize,
         period: usize,
     ) -> PeriodicTask<'a> {
@@ -69,7 +69,7 @@ impl<'a> TaskIF<'a> for PeriodicTask<'a> {
     fn get_handle(&self) -> *const cty::c_void {
         self.task_handle
     }
-    fn get_objects(&'a self) -> &'a [&'a mut dyn crate::objectmanager::SystemObject] {
+    fn get_objects(&'a self) -> &'a [&'a mut dyn crate::objectmanager::SystemObjectIF] {
         self.task_objects
     }
     fn initialize(&mut self, object_manager: &dyn ObjectManager) -> Result<(), ()> {
@@ -89,12 +89,12 @@ pub struct TaskExecutor<'a> {
 }
 
 impl<'a> TaskExecutor<'a> {
-    pub fn run_tasks(&mut self) {
+    pub fn init_and_run(&mut self) {
         let object_manager = TaskObjectManager {
             tasks: unsafe { slice::from_raw_parts(self.tasks.as_ptr(), self.tasks.len()) },
         };
         for task in self.tasks.iter_mut() {
-            let _ = task.initialize(&object_manager);
+            let _ = task.initialize(&object_manager).unwrap();
         }
         drop(object_manager);
         for task in self.tasks.iter_mut() {
@@ -126,15 +126,15 @@ impl<'a> crate::objectmanager::ObjectManager<'a> for TaskObjectManager<'a> {
     fn get_object(
         &self,
         id: crate::objectmanager::ObjectId,
-    ) -> Option<&'a dyn crate::objectmanager::SystemObject> {
+    ) -> Result<&'a dyn crate::objectmanager::SystemObjectIF, ()> {
         for task in self.tasks.iter() {
             for object in task.get_objects().iter() {
                 if object.get_id() == id {
-                    return Some(*object);
+                    return Ok(*object);
                 }
             }
         }
-        None
+        Err(())
     }
 }
 

mission_rust/src/lib.rs

@@ -9,9 +9,13 @@ mod fsrc;
 use core::fmt::Write;
 use core::panic::PanicInfo;
 
-use fsrc::objectmanager::SystemObject;
+use fsrc::objectmanager::SystemObjectIF;
 use fsrc::*;
 
+extern "C" {
+    fn done();
+}
+
 #[panic_handler]
 fn panic(panic: &PanicInfo<'_>) -> ! {
     unsafe {
@@ -20,16 +24,21 @@ fn panic(panic: &PanicInfo<'_>) -> ! {
     // TODO: Make this unicode-safe
     sif!("In Task \"");
     unsafe {
-        let task_name = osal::get_task_name();
+        let task_name = core::ffi::CStr::from_ptr(osal::get_task_name());
-        let mut offset = 0;
+        let task_name_utf8 = core::str::from_utf8(task_name.to_bytes());
-        while *task_name.offset(offset) != 0 {
+        match task_name_utf8 {
-            sif!("{}", *task_name.offset(offset) as char);
+            Ok(string) => {
-            offset = offset + 1;
+                sif!("{}", string);
+            }
+            Err(_) => {
+                sif!("Schei<EFBFBD> Encoding");
+            }
         }
     }
     sifln!("\":");
     sifln!("{}", panic);
     //TODO: stop RTOS, exit if hosted
+    unsafe { done() };
     loop {}
 }
 
@@ -102,7 +111,7 @@ impl tasks::ExecutableObjectIF for HandlerSender {
     }
 }
 
-impl SystemObject for Handler {
+impl SystemObjectIF for Handler {
     fn get_command_queue(&self) -> crate::fsrc::queues::MessageQueueSender {
         self.command_queue.get_sender()
     }
@@ -114,7 +123,7 @@ impl SystemObject for Handler {
     }
 }
 
-impl SystemObject for HandlerSender {
+impl SystemObjectIF for HandlerSender {
     fn get_command_queue(&self) -> crate::fsrc::queues::MessageQueueSender {
         queues::MessageQueueSender::new()
     }
@@ -124,8 +133,8 @@ impl SystemObject for HandlerSender {
     fn initialize(&mut self, object_manager: &dyn objectmanager::ObjectManager) -> Result<(), ()> {
         let other_handler = object_manager.get_object(self.other_handler);
         match other_handler {
-            Some(other) => self.other_handler_queue = other.get_command_queue(),
+            Ok(other) => self.other_handler_queue = other.get_command_queue(),
-            None => return Err(()),
+            Err(_) => return Err(()),
         }
         Ok(())
     }
@@ -140,12 +149,12 @@ fn mission() {
     };
     let mut h2 = HandlerSender {
         id: 2,
-        other_handler: 1,
+        other_handler: 3,
         cycle: 0,
         other_handler_queue: queues::MessageQueueSender::new(),
     };
 
-    let array: &mut [&mut dyn objectmanager::SystemObject] = &mut [&mut h1];
+    let array: &mut [&mut dyn objectmanager::SystemObjectIF] = &mut [&mut h1];
 
     let mut t1 = tasks::PeriodicTask::new(array, 512, 200);
 
@@ -160,7 +169,7 @@ fn mission() {
         tasks: &mut [&mut t1, &mut t2],
     };
 
-    task_executor.run_tasks();
+    task_executor.init_and_run();
 
     sifln!("Mission delay");
     unsafe {