scheduler hotovo

scheduler/src/main.rs

@@ -23,12 +23,24 @@ fn busy_delay(ms: u32) {
     while millis() - start < ms {}
 }
 
-fn task1() { busy_delay(10_000); }
-fn task2() { busy_delay(10_000); }
-fn task3() { busy_delay(10_000); }
-fn task4() { busy_delay(10_000); }
-fn opt1() { busy_delay(3_000); }
-fn opt2() { busy_delay(4_000); }
+const TASK_CHUNK_MS: u32 = 1_000;
+const MAIN_TASK_TOTAL: u32 = 20_000;
+const OPT_TASK_TOTAL: u32 = 10_000;
+
+// aby úlohy vedeli, koľko im ešte zostáva
+static mut REMAIN_T1: u32 = MAIN_TASK_TOTAL;
+static mut REMAIN_T2: u32 = MAIN_TASK_TOTAL;
+static mut REMAIN_T3: u32 = MAIN_TASK_TOTAL;
+static mut REMAIN_T4: u32 = MAIN_TASK_TOTAL;
+static mut REMAIN_OPT1: u32 = OPT_TASK_TOTAL;
+static mut REMAIN_OPT2: u32 = OPT_TASK_TOTAL;
+
+fn task1() { unsafe { if REMAIN_T1 >= TASK_CHUNK_MS { busy_delay(TASK_CHUNK_MS); REMAIN_T1 -= TASK_CHUNK_MS; } } }
+fn task2() { unsafe { if REMAIN_T2 >= TASK_CHUNK_MS { busy_delay(TASK_CHUNK_MS); REMAIN_T2 -= TASK_CHUNK_MS; } } }
+fn task3() { unsafe { if REMAIN_T3 >= TASK_CHUNK_MS { busy_delay(TASK_CHUNK_MS); REMAIN_T3 -= TASK_CHUNK_MS; } } }
+fn task4() { unsafe { if REMAIN_T4 >= TASK_CHUNK_MS { busy_delay(TASK_CHUNK_MS); REMAIN_T4 -= TASK_CHUNK_MS; } } }
+fn opt1()  { unsafe { if REMAIN_OPT1 >= TASK_CHUNK_MS { busy_delay(TASK_CHUNK_MS); REMAIN_OPT1 -= TASK_CHUNK_MS; } } }
+fn opt2()  { unsafe { if REMAIN_OPT2 >= TASK_CHUNK_MS { busy_delay(TASK_CHUNK_MS); REMAIN_OPT2 -= TASK_CHUNK_MS; } } }
 
 struct Task {
     name: &'static str,
@@ -38,45 +50,52 @@ struct Task {
 }
 
 static TASKS_MAIN: [Task; 4] = [
-    Task { name: "T1", duration_ms: 10_000, active: true, func: task1 },
-    Task { name: "T2", duration_ms: 10_000, active: true, func: task2 },
-    Task { name: "T3", duration_ms: 10_000, active: true, func: task3 },
-    Task { name: "T4", duration_ms: 10_000, active: true, func: task4 },
+    Task { name: "T1", duration_ms: MAIN_TASK_TOTAL, active: true, func: task1 },
+    Task { name: "T2", duration_ms: MAIN_TASK_TOTAL, active: true, func: task2 },
+    Task { name: "T3", duration_ms: MAIN_TASK_TOTAL, active: true, func: task3 },
+    Task { name: "T4", duration_ms: MAIN_TASK_TOTAL, active: true, func: task4 },
 ];
 
 static TASKS_OPT: [Task; 2] = [
-    Task { name: "Opt1", duration_ms: 3_000, active: true, func: opt1 },
-    Task { name: "Opt2", duration_ms: 4_000, active: true, func: opt2 },
+    Task { name: "Opt1", duration_ms: OPT_TASK_TOTAL, active: true, func: opt1 },
+    Task { name: "Opt2", duration_ms: OPT_TASK_TOTAL, active: true, func: opt2 },
 ];
 
 const MAJOR_FRAME_MS: u32 = 120_000;
 
-fn run_optionals(tasks: &[Task], mut remaining: u32) {
-    for t in tasks {
-        if t.duration_ms <= remaining {
-            (t.func)();
-            remaining -= t.duration_ms;
-        } else {
-            break;
-        }
-    }
-}
 
 fn scheduler(tasks_main: &[Task], tasks_optional: &[Task]) {
-    let start_time = millis();
+    let frame_start = millis();
 
-    for t in tasks_main {
-        (t.func)();
+    // reset zostávajúce časy na začiatku rámca
+    unsafe {
+        REMAIN_T1 = MAIN_TASK_TOTAL;
+        REMAIN_T2 = MAIN_TASK_TOTAL;
+        REMAIN_T3 = MAIN_TASK_TOTAL;
+        REMAIN_T4 = MAIN_TASK_TOTAL;
+        REMAIN_OPT1 = OPT_TASK_TOTAL;
+        REMAIN_OPT2 = OPT_TASK_TOTAL;
     }
 
-    let elapsed = millis() - start_time;
+    while millis() - frame_start < MAJOR_FRAME_MS {
+        // iterovať cez všetky hlavné aj voliteľné úlohy po malých krokoch
+        for t in tasks_main {
+            (t.func)();
+        }
+        for t in tasks_optional {
+            (t.func)();
+        }
 
-    if elapsed < MAJOR_FRAME_MS {
-        run_optionals(tasks_optional, MAJOR_FRAME_MS - elapsed);
+        // ak všetky úlohy v rámci stihli bežať raz — koniec cyklu
+        unsafe {
+            if REMAIN_T1 == 0 && REMAIN_T2 == 0 && REMAIN_T3 == 0 && REMAIN_T4 == 0 &&
+               REMAIN_OPT1 == 0 && REMAIN_OPT2 == 0 {
+                break;
+            }
+        }
     }
 
-    // Wait out the frame so each cycle lasts exactly 120 s
-    while millis() - start_time < MAJOR_FRAME_MS {}
+    while millis() - frame_start < MAJOR_FRAME_MS {}
 }
 
 #[entry]