rusefi
/
atbetaflight
mirror of https://github.com/rusefi/atbetaflight.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed special case for SPRACINGF3OSD, fixed tests.

This commit is contained in:
mikeller 2018-06-16 17:17:41 +12:00
parent afb6068400
commit 8107ad254c
6 changed files with 62 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/main/fc/fc_core.c
View File

@ -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;
}

1
src/main/fc/fc_core.h
View File

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

26
src/main/fc/fc_tasks.c
View File

@ -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,

2
src/main/scheduler/scheduler.c
View File

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

2
src/main/scheduler/scheduler.h
View File

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

80
src/test/unit/scheduler_unittest.cc
View File

@ -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);
EXPECT_EQ(taskId + 1, taskQueueSize);
EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
if (cfTasks[taskId].taskFunc) {
setTaskEnabled(static_cast<cfTaskId_e>(taskId), true);
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[TASK_COUNT_UNITTEST - 2]);
const cfTask_t *lastTaskPrev = taskQueueArray[TASK_COUNT_UNITTEST - 2];
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
EXPECT_NE(static_cast<cfTask_t*>(0), taskQueueArray[enqueuedTasks - 1]);
const cfTask_t *lastTaskPrev = taskQueueArray[enqueuedTasks - 1];
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
setTaskEnabled(TASK_SYSTEM, false);
EXPECT_EQ(TASK_COUNT_UNITTEST - 2, taskQueueSize);
EXPECT_EQ(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 3]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 2]); // NULL at end of queue
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
EXPECT_EQ(enqueuedTasks - 1, taskQueueSize);
EXPECT_EQ(lastTaskPrev, taskQueueArray[enqueuedTasks - 2]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]); // NULL at end of queue
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
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(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 2]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
EXPECT_EQ(enqueuedTasks, taskQueueSize);
EXPECT_EQ(lastTaskPrev, taskQueueArray[enqueuedTasks - 1]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
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);
EXPECT_EQ(TASK_COUNT_UNITTEST, taskQueueSize);
EXPECT_EQ(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]); // check no buffer overrun
setTaskEnabled(static_cast<cfTaskId_e>(enqueuedTasks), true);
EXPECT_EQ(enqueuedTasks, taskQueueSize);
EXPECT_EQ(lastTaskPrev, taskQueueArray[enqueuedTasks - 1]);
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(lastTaskPrev, taskQueueArray[TASK_COUNT_UNITTEST - 3]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
EXPECT_EQ(enqueuedTasks - 1, taskQueueSize);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
setTaskEnabled(TASK_ACCEL, false);
EXPECT_EQ(TASK_COUNT_UNITTEST - 2, taskQueueSize);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 2]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
EXPECT_EQ(enqueuedTasks - 2, taskQueueSize);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
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(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 3]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 2]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST - 1]);
EXPECT_EQ(NULL, taskQueueArray[TASK_COUNT_UNITTEST]);
EXPECT_EQ(enqueuedTasks - 2, taskQueueSize);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 2]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks - 1]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks]);
EXPECT_EQ(NULL, taskQueueArray[enqueuedTasks + 1]);
EXPECT_EQ(deadBeefPtr, taskQueueArray[TASK_COUNT_UNITTEST + 1]);
}