using PeriodicTask::new(); Also some insight into temporary variables in instantiation

mission_rust/src/lib.rs

@@ -24,6 +24,7 @@ macro_rules! sif {
     );
 }
 
+use core::mem::size_of;
 use core::panic::PanicInfo;
 
 #[panic_handler]
@@ -49,7 +50,6 @@ fn panic(panic: &PanicInfo<'_>) -> ! {
 
 type TaskFunction = unsafe extern "C" fn(*mut cty::c_void);
 
-
 extern "C" {
     fn outbyte(c: cty::c_char);
     //void *create_task(TaskFunction_t taskFunction, void *parameter, size_t stack_size)
@@ -109,22 +109,21 @@ struct PeriodicTask<'a> {
     task_objects: &'a mut [&'a mut dyn ExecutableObjectIF],
 }
 
-// TODO Passing the slice does not work, find out why...
+impl<'a> PeriodicTask<'a> {
-// impl<'a> PeriodicTask<'a> {
+    fn new(
-//     fn new(
+        objects: &'a mut [&'a mut dyn ExecutableObjectIF],
-//         objects: &'a mut [&'a mut dyn ExecutableObjectIF],
+        stack_size: usize,
-//         stack_size: usize,
+        period: usize,
-//         period: usize,
+    ) -> PeriodicTask<'a> {
-//     ) -> Self {
+        let instance: PeriodicTask<'a> = Self {
-//         let instance = Self {
+            stack_size: stack_size,
-//             stack_size: stack_size,
+            task_handle: 0 as *const cty::c_void,
-//             task_handle: 0 as *const cty::c_void,
+            period: period,
-//             period: period,
+            task_objects: objects,
-//             task_objects: objects,
+        };
-//         };
+        instance
-//         instance
+    }
-//     }
+}
-// }
 
 impl<'a> TaskIF for PeriodicTask<'a> {
     fn run(&mut self) {
@@ -199,11 +198,16 @@ struct HandlerSender {
 impl Handler {
     fn handle_message(&self, message: Message) {
         match message {
-            Message::OK=> {sifln!("OK");},
+            Message::OK => {
-            Message::FAILED => {sifln!("FAILED");},
+                sifln!("OK");
-            Message::DATA(data) => {sifln!("p1: {}, p2 {}", data.p1, data.p2);}
+            }
+            Message::FAILED => {
+                sifln!("FAILED");
+            }
+            Message::DATA(data) => {
+                sifln!("p1: {}, p2 {}", data.p1, data.p2);
+            }
         }
-
     }
 }
 
@@ -213,7 +217,9 @@ impl ExecutableObjectIF for Handler {
         let result = self.command_queue.receive();
         match result {
             Ok(message) => self.handle_message(message),
-            Err(_) => {sifln!("Handler {} got nothing", self.id);}
+            Err(_) => {
+                sifln!("Handler {} got nothing", self.id);
+            }
         }
     }
 }
@@ -222,9 +228,17 @@ impl ExecutableObjectIF for HandlerSender {
     fn perform(&mut self) {
         sifln!("HandlerSender {} performs step {}", self.id, self.cycle);
         match self.cycle {
-            0 => {let _ = self.other_handler.send(Message::OK);},
+            0 => {
-            1 => {let _ = self.other_handler.send(Message::FAILED);},
+                let _ = self.other_handler.send(Message::OK);
-            2 => {let _ = self.other_handler.send(Message::DATA(GenericMessageData { p1: 13, p2: 2 }));},
+            }
+            1 => {
+                let _ = self.other_handler.send(Message::FAILED);
+            }
+            2 => {
+                let _ = self
+                    .other_handler
+                    .send(Message::DATA(GenericMessageData { p1: 13, p2: 2 }));
+            }
             _ => (),
         }
         self.cycle += 1;
@@ -247,7 +261,7 @@ impl<T: Default> MessageQueue<T> {
         unsafe {
             instance = Self {
                 queue_id: 0 as *const cty::c_void,
-                _unused: None
+                _unused: None,
             };
             //TODO check cast of depth
             instance.queue_id = create_queue(depth, core::mem::size_of::<T>());
@@ -349,12 +363,9 @@ fn mission() {
 
     h2.other_handler = h1.command_queue.get_sender();
 
-    let mut t1: PeriodicTask = PeriodicTask {
+    let array: &mut [&mut dyn ExecutableObjectIF] = &mut [&mut h1];
-        task_objects: &mut [&mut h1],
+
-        stack_size: 512,
+    let mut t1 = PeriodicTask::new(array, 512, 200);
-        period: 200,
-        task_handle: 0 as *const cty::c_void,
-    };
 
     let mut t2: PeriodicTask = PeriodicTask {
         task_objects: &mut [&mut h2],
@@ -363,6 +374,10 @@ fn mission() {
         task_handle: 0 as *const cty::c_void,
     };
 
+    let _i = 1;
+
+    sifln!("sizeof {}, pointer struct {:p}, pointer element {:p}, next element{:p}", size_of::<PeriodicTask>(), &t2, t2.task_objects, &_i);
+
     let mut task_executor = TaskExecutor {
         tasks: &mut [&mut t1, &mut t2],
     };