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

This commit is contained in:
Ulrich Mohr 2023-11-22 16:17:39 +01:00
parent 02d78e3c8b
commit 10c38b4ac9

View File

@ -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> {
// fn new(
// objects: &'a mut [&'a mut dyn ExecutableObjectIF],
// stack_size: usize,
// period: usize,
// ) -> Self {
// let instance = Self {
// stack_size: stack_size,
// task_handle: 0 as *const cty::c_void,
// period: period,
// task_objects: objects,
// };
// instance
// }
// }
impl<'a> PeriodicTask<'a> {
fn new(
objects: &'a mut [&'a mut dyn ExecutableObjectIF],
stack_size: usize,
period: usize,
) -> PeriodicTask<'a> {
let instance: PeriodicTask<'a> = Self {
stack_size: stack_size,
task_handle: 0 as *const cty::c_void,
period: period,
task_objects: objects,
};
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::FAILED => {sifln!("FAILED");},
Message::DATA(data) => {sifln!("p1: {}, p2 {}", data.p1, data.p2);}
Message::OK => {
sifln!("OK");
}
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);},
1 => {let _ = self.other_handler.send(Message::FAILED);},
2 => {let _ = self.other_handler.send(Message::DATA(GenericMessageData { p1: 13, p2: 2 }));},
0 => {
let _ = self.other_handler.send(Message::OK);
}
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>());
@ -343,18 +357,15 @@ fn mission() {
};
let mut h2 = HandlerSender {
id: 2,
cycle: 0,
other_handler: MessageQueueSender::<Message>::new(),
cycle: 0,
other_handler: MessageQueueSender::<Message>::new(),
};
h2.other_handler = h1.command_queue.get_sender();
let mut t1: PeriodicTask = PeriodicTask {
task_objects: &mut [&mut h1],
stack_size: 512,
period: 200,
task_handle: 0 as *const cty::c_void,
};
let array: &mut [&mut dyn ExecutableObjectIF] = &mut [&mut h1];
let mut t1 = PeriodicTask::new(array, 512, 200);
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],
};