task demo (unsane)

mission_rust/src/lib.rs

@@ -10,13 +10,104 @@ fn panic(panic: &PanicInfo<'_>) -> ! {
     loop {}
 }
 
+type TaskFunction = unsafe extern "C" fn(*mut cty::c_void);
+
 extern "C" {
-    pub fn outbyte(c: cty::c_char);
+    fn outbyte(c: cty::c_char);
+
+    //void * createTask(void (* taskFunction)( void * ), void * parameter, void *buffer, size_t buffersize){
+
+    fn createTask(
+        taskFunction: TaskFunction,
+        parameter: *mut cty::c_void,
+        buffer: *mut cty::c_void,
+        buffersize: cty::size_t,
+    ) -> *const cty::c_void;
+
+    fn vTaskDelete(handle: *const cty::c_void);
+
+    fn task_delay(milliseconds: cty::uint32_t);
 }
 
 #[no_mangle]
-pub extern "C" fn rust_main() {
+extern "C" fn rust_main() {
+    let mut stdout = Outbytes {};
+
+    let _ok = writeln!(&mut stdout, "Rust startup");
     mission();
+
+    let _ok = writeln!(&mut stdout, "Mission done");
+}
+
+#[no_mangle]
+extern "C" fn task_entry(task_object: *mut cty::c_void) {
+    let task: &mut PeriodicTaskRunner;
+    unsafe {
+        let pointer = task_object as *mut PeriodicTaskRunner;
+        task = &mut *pointer;
+    }
+    task.execute();
+}
+
+trait ExecutableObjectIF {
+    fn perform(&self);
+}
+
+struct PeriodicTaskRunner<'a> {
+    period: u32,
+    task_object: &'a mut dyn ExecutableObjectIF,
+}
+struct PeriodicTask<'a, const STACKSIZE: usize> {
+    stack: [u8; STACKSIZE],
+    task: *const cty::c_void,
+    runner: PeriodicTaskRunner<'a>,
+}
+
+impl<'a> PeriodicTaskRunner<'a> {
+    fn execute(&mut self) {
+        loop {
+            self.task_object.perform();
+            unsafe {
+                task_delay(self.period);
+            }
+        }
+    }
+}
+
+impl<'a, const STACKSIZE: usize> PeriodicTask<'a, STACKSIZE> {
+    fn new(object: &'a mut dyn ExecutableObjectIF) -> Self {
+        let mut instance = Self {
+            stack: [0; STACKSIZE],
+            task: 0 as *const cty::c_void,
+            runner: PeriodicTaskRunner {
+                period: 500,
+                task_object: object,
+            },
+        };
+        let runner_pointer: *mut cty::c_void = &mut instance.runner as *mut _ as *mut cty::c_void;
+        let stack_pointer: *mut cty::c_void = &mut instance.stack as *mut _ as *mut cty::c_void;
+        unsafe {
+            instance.task = createTask(task_entry, runner_pointer, stack_pointer, STACKSIZE);
+        }
+        instance
+    }
+}
+
+impl<'a, const STACKSIZE: usize> Drop for PeriodicTask<'a, STACKSIZE> {
+    fn drop(&mut self) {
+        unsafe {vTaskDelete(self.task);}
+    }
+}
+
+struct Handler {
+    id: u32
+}
+
+impl ExecutableObjectIF for Handler {
+    fn perform(&self) {
+        let mut stdout = Outbytes {};
+        let _ok = writeln!(&mut stdout, "Handler {} performs", self.id);
+    }
 }
 
 struct Outbytes {}
@@ -41,8 +132,13 @@ fn panics(a: &mut [i32]) {
 fn mission() {
     let mut stdout = Outbytes {};
 
-    let _ok = writeln!(&mut stdout, "Rust startup");
+    let _ok = writeln!(&mut stdout, "Mission enter");
 
-    let mut array = [1, 2, 3];
-    panics(&mut array);
+    let mut h1 = Handler {id: 1};
+
+    let _t1: PeriodicTask<'_, 512> = PeriodicTask::new(&mut h1);
+
+    let _ok = writeln!(&mut stdout, "Mission done delay");
+    unsafe {task_delay(3000);}
+    
 }