Try to be more helpful with the executor (#4313)

Author: bugadani

esp-rtos/src/embassy/mod.rs

@@ -4,6 +4,8 @@ use core::{cell::UnsafeCell, mem::MaybeUninit, sync::atomic::Ordering};
 
 use embassy_executor::{SendSpawner, Spawner, raw};
 use esp_hal::interrupt::{InterruptHandler, Priority, software::SoftwareInterrupt};
+#[cfg(multi_core)]
+use esp_hal::system::Cpu;
 use macros::ram;
 use portable_atomic::AtomicPtr;
 
@@ -40,7 +42,16 @@ pub trait Callbacks {
 
 /// Thread-mode executor.
 ///
-/// This executor runs in an OS thread.
+/// This executor runs in an OS thread, meaning the scheduler needs to be started before using any
+/// async operations.
+#[cfg_attr(
+    multi_core,
+    doc = r"
+
+If you want to start the executor on the second core, you will need to start the second core using [`crate::start_second_core`].
+If you are looking for a way to run code on the second core without the scheduler, use the [`InterruptExecutor`].
+"
+)]
 pub struct Executor {
     executor: UnsafeCell<MaybeUninit<raw::Executor>>,
 }
@@ -129,6 +140,14 @@ impl Executor {
             ))
         };
 
+        #[cfg(multi_core)]
+        if Cpu::current() != Cpu::ProCpu
+            && crate::SCHEDULER
+                .with(|scheduler| !scheduler.per_cpu[Cpu::current() as usize].initialized)
+        {
+            panic!("Executor cannot be started: the scheduler is not running on the current CPU.");
+        }
+
         init(executor.spawner());
 
         loop {

esp-rtos/src/scheduler.rs

@@ -117,6 +117,13 @@ impl SchedulerState {
         }
     }
 
+    pub(crate) fn current_task(&self, cpu: Cpu) -> TaskPtr {
+        unwrap!(
+            self.per_cpu[cpu as usize].current_task,
+            "The scheduler is not running on the current CPU. Make sure you start the scheduler before calling OS functions."
+        )
+    }
+
     pub(crate) fn setup(&mut self, time_driver: TimeDriver, idle_hook: IdleFn) {
         assert!(
             self.time_driver.is_none(),
@@ -437,8 +444,7 @@ impl Scheduler {
 
     pub(crate) fn sleep_until(&self, wake_at: Instant) -> bool {
         self.with(|scheduler| {
-            let current_cpu = Cpu::current() as usize;
-            let current_task = unwrap!(scheduler.per_cpu[current_cpu].current_task);
+            let current_task = scheduler.current_task(Cpu::current());
             if scheduler.sleep_task_until(current_task, wake_at) {
                 task::yield_task();
                 true

esp-rtos/src/semaphore.rs

@@ -46,8 +46,7 @@ impl SemaphoreInner {
                 ..
             } => {
                 SCHEDULER.with(|scheduler| {
-                    let current_cpu = Cpu::current() as usize;
-                    let current = unwrap!(scheduler.per_cpu[current_cpu].current_task);
+                    let current = scheduler.current_task(Cpu::current());
                     if let Some(owner) = owner {
                         if *owner == current && *recursive {
                             *lock_counter += 1;

esp-rtos/src/wait_queue.rs

@@ -32,9 +32,7 @@ impl WaitQueue {
 
     pub(crate) fn wait_with_deadline(&mut self, deadline: Instant) {
         SCHEDULER.with(|scheduler| {
-            let current_cpu = Cpu::current() as usize;
-            let mut task = unwrap!(scheduler.per_cpu[current_cpu].current_task);
-
+            let mut task = scheduler.current_task(Cpu::current());
             if scheduler.sleep_task_until(task, deadline) {
                 self.waiting_tasks.push(task);
                 unsafe {