Fixed special case for SPRACINGF3OSD, fixed tests.

src/main/fc/fc_core.c

@@ -67,7 +67,6 @@
 
 #include "interface/cli.h"
 
-#include "io/asyncfatfs/asyncfatfs.h"
 #include "io/beeper.h"
 #include "io/gps.h"
 #include "io/motors.h"
@@ -929,15 +928,6 @@ static FAST_CODE_NOINLINE void subTaskPidSubprocesses(timeUs_t currentTimeUs)
     DEBUG_SET(DEBUG_PIDLOOP, 3, micros() - startTime);
 }
 
-void taskMain(timeUs_t currentTimeUs)
-{
-    UNUSED(currentTimeUs);
-
-#ifdef USE_SDCARD
-    afatfs_poll();
-#endif
-}
-
 #ifdef USE_TELEMETRY
 void subTaskTelemetryPollSensors(timeUs_t currentTimeUs)
 {
@@ -1059,4 +1049,3 @@ void resetTryingToArm()
 {
     tryingToArm = false;
 }
-

src/main/fc/fc_core.h

@@ -57,5 +57,4 @@ timeUs_t getLastDisarmTimeUs(void);
 bool isTryingToArm();
 void resetTryingToArm();
 
-void taskMain(timeUs_t currentTimeUs);
 void subTaskTelemetryPollSensors(timeUs_t currentTimeUs);

src/main/fc/fc_tasks.c

@@ -58,6 +58,7 @@
 #include "interface/cli.h"
 #include "interface/msp.h"
 
+#include "io/asyncfatfs/asyncfatfs.h"
 #include "io/beeper.h"
 #include "io/dashboard.h"
 #include "io/gps.h"
@@ -93,16 +94,27 @@
 #include "telemetry/telemetry.h"
 
 #ifdef USE_BST
-void taskBstMasterProcess(timeUs_t currentTimeUs);
+static void taskBstMasterProcess(timeUs_t currentTimeUs);
 #endif
 
-bool taskSerialCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTimeUs)
+static void taskMain(timeUs_t currentTimeUs)
+{
+    UNUSED(currentTimeUs);
+
+#ifdef USE_SDCARD
+    afatfs_poll();
+#endif
+}
+
+#ifdef USE_OSD_SLAVE
+static bool taskSerialCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTimeUs)
 {
     UNUSED(currentTimeUs);
     UNUSED(currentDeltaTimeUs);
 
     return mspSerialWaiting();
 }
+#endif
 
 static void taskHandleSerial(timeUs_t currentTimeUs)
 {
@@ -122,7 +134,7 @@ static void taskHandleSerial(timeUs_t currentTimeUs)
     mspSerialProcess(evaluateMspData, mspFcProcessCommand, mspFcProcessReply);
 }
 
-void taskBatteryAlerts(timeUs_t currentTimeUs)
+static void taskBatteryAlerts(timeUs_t currentTimeUs)
 {
     if (!ARMING_FLAG(ARMED)) {
         // the battery *might* fall out in flight, but if that happens the FC will likely be off too unless the user has battery backup.
@@ -194,7 +206,7 @@ static void taskTelemetry(timeUs_t currentTimeUs)
 #endif
 
 #ifdef USE_CAMERA_CONTROL
-void taskCameraControl(uint32_t currentTime)
+static void taskCameraControl(uint32_t currentTime)
 {
     if (ARMING_FLAG(ARMED)) {
         return;
@@ -208,7 +220,7 @@ void fcTasksInit(void)
 {
     schedulerInit();
 
-    setTaskEnabled(TASK_SYSTEM, true);
+    setTaskEnabled(TASK_MAIN, true);
 
     setTaskEnabled(TASK_SERIAL, true);
     rescheduleTask(TASK_SERIAL, TASK_PERIOD_HZ(serialConfig()->serial_update_rate_hz));
@@ -323,7 +335,7 @@ void fcTasksInit(void)
 }
 
 cfTask_t cfTasks[TASK_COUNT] = {
-    [TASK_SYSTEM_LOAD] = {
+    [TASK_SYSTEM] = {
         .taskName = "SYSTEM",
         .subTaskName = "LOAD",
         .taskFunc = taskSystemLoad,
@@ -331,7 +343,7 @@ cfTask_t cfTasks[TASK_COUNT] = {
         .staticPriority = TASK_PRIORITY_MEDIUM_HIGH,
     },
 
-    [TASK_SYSTEM] = {
+    [TASK_MAIN] = {
         .taskName = "SYSTEM",
         .subTaskName = "UPDATE",
         .taskFunc = taskMain,

src/main/scheduler/scheduler.c

@@ -225,7 +225,7 @@ void schedulerInit(void)
 {
     calculateTaskStatistics = true;
     queueClear();
-    queueAdd(&cfTasks[TASK_SYSTEM_LOAD]);
+    queueAdd(&cfTasks[TASK_SYSTEM]);
 }
 
 FAST_CODE void scheduler(void)

src/main/scheduler/scheduler.h

@@ -58,7 +58,7 @@ typedef struct {
 typedef enum {
     /* Actual tasks */
     TASK_SYSTEM = 0,
-    TASK_SYSTEM_LOAD,
+    TASK_MAIN,
     TASK_GYROPID,
     TASK_ACCEL,
     TASK_ATTITUDE,

src/test/unit/scheduler_unittest.cc

@@ -69,7 +69,7 @@ extern "C" {
     cfTask_t cfTasks[TASK_COUNT] = {
         [TASK_SYSTEM] = {
             .taskName = "SYSTEM",
-            .taskFunc = taskSystem,
+            .taskFunc = taskSystemLoad,
             .desiredPeriod = TASK_PERIOD_HZ(10),
             .staticPriority = TASK_PRIORITY_MEDIUM_HIGH,
         },
@@ -122,8 +122,6 @@ extern "C" {
 
 TEST(SchedulerUnittest, TestPriorites)
 {
-    EXPECT_EQ(20, TASK_COUNT);
-
     EXPECT_EQ(TASK_PRIORITY_MEDIUM_HIGH, cfTasks[TASK_SYSTEM].staticPriority);
     EXPECT_EQ(TASK_PRIORITY_REALTIME, cfTasks[TASK_GYROPID].staticPriority);
     EXPECT_EQ(TASK_PRIORITY_MEDIUM, cfTasks[TASK_ACCEL].staticPriority);
@@ -238,64 +236,68 @@ TEST(SchedulerUnittest, TestQueueArray)
     queueClear();
     taskQueueArray[TASK_COUNT_UNITTEST + 1] = deadBeefPtr; // note, must set deadBeefPtr after queueClear
 
+    unsigned enqueuedTasks = 0;
+    EXPECT_EQ(enqueuedTasks, taskQueueSize);
+
     for (int taskId = 0; taskId < TASK_COUNT_UNITTEST - 1; ++taskId) {
-        setTaskEnabled(static_cast<cfTaskId_e>(taskId), true);
+        if (cfTasks[taskId].taskFunc) {
-        EXPECT_EQ(taskId + 1, taskQueueSize);
+            setTaskEnabled(static_cast<cfTaskId_e>(taskId), true);
-        EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
+            enqueuedTasks++;
+            EXPECT_EQ(enqueuedTasks, taskQueueSize);
+            EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
+        }
     }
 
-    EXPECT_EQ(TASK_COUNT_UNITTEST - 1, taskQueueSize);
+    EXPECT_NE(static_cast<cfTask_t*>(0), taskQueueArray[enqueuedTasks - 1]);
-    EXPECT_NE(static_cast<cfTask_t*>(0), taskQueueArray[TASK_COUNT_UNITTEST - 2]);
+    const cfTask_t *lastTaskPrev = taskQueueArray[enqueuedTasks - 1];
-    const cfTask_t *lastTaskPrev = taskQueueArray[TASK_COUNT_UNITTEST - 2];
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 
     setTaskEnabled(TASK_SYSTEM, false);
-    EXPECT_EQ(TASK_COUNT_UNITTEST - 2, taskQueueSize);
+    EXPECT_EQ(enqueuedTasks - 1, taskQueueSize);
-    EXPECT_EQ(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 3]);
+    EXPECT_EQ(lastTaskPrev, taskQueueArray[enqueuedTasks - 2]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 2]); // NULL at end of queue
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]); // NULL at end of queue
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]);
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 
-    taskQueueArray[TASK_COUNT_UNITTEST - 2] = 0;
+    taskQueueArray[enqueuedTasks - 1] = 0;
     setTaskEnabled(TASK_SYSTEM, true);
-    EXPECT_EQ(TASK_COUNT_UNITTEST - 1, taskQueueSize);
+    EXPECT_EQ(enqueuedTasks, taskQueueSize);
-    EXPECT_EQ(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 2]);
+    EXPECT_EQ(lastTaskPrev, taskQueueArray[enqueuedTasks - 1]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 
     cfTaskInfo_t taskInfo;
-    getTaskInfo(static_cast<cfTaskId_e>(TASK_COUNT_UNITTEST - 1), &taskInfo);
+    getTaskInfo(static_cast<cfTaskId_e>(enqueuedTasks + 1), &taskInfo);
     EXPECT_EQ(false, taskInfo.isEnabled);
-    setTaskEnabled(static_cast<cfTaskId_e>(TASK_COUNT_UNITTEST - 1), true);
+    setTaskEnabled(static_cast<cfTaskId_e>(enqueuedTasks), true);
-    EXPECT_EQ(TASK_COUNT_UNITTEST, taskQueueSize);
+    EXPECT_EQ(enqueuedTasks, taskQueueSize);
-    EXPECT_EQ(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(lastTaskPrev, taskQueueArray[enqueuedTasks - 1]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]); // check no buffer overrun
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]); // check no buffer overrun
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 
     setTaskEnabled(TASK_SYSTEM, false);
-    EXPECT_EQ(TASK_COUNT_UNITTEST - 1, taskQueueSize);
+    EXPECT_EQ(enqueuedTasks - 1, taskQueueSize);
-    //EXPECT_EQ(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 3]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 
     setTaskEnabled(TASK_ACCEL, false);
-    EXPECT_EQ(TASK_COUNT_UNITTEST - 2, taskQueueSize);
+    EXPECT_EQ(enqueuedTasks - 2, taskQueueSize);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 2]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 
     setTaskEnabled(TASK_BATTERY_VOLTAGE, false);
-    EXPECT_EQ(TASK_COUNT_UNITTEST - 3, taskQueueSize);
+    EXPECT_EQ(enqueuedTasks - 2, taskQueueSize);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 3]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 2]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 2]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
-    EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
+    EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
     EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
 }