Mirror/betaflight
1
0
Fork 0
mirror of https://github.com/betaflight/betaflight.git synced 2025-07-25 01:05:27 +03:00
Code Issues Wiki Activity

Naming changes suggested by Hydra

Browse source
This commit is contained in:
Steve Evans 2022-01-28 20:31:47 +00:00
parent 2e8d026b4e
commit cc67b2e87c
3 changed files with 46 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/main/fc/tasks.c
View file

@ -182,7 +182,7 @@ bool taskUpdateRxMainInProgress()
static void taskUpdateRxMain(timeUs_t currentTimeUs) static void taskUpdateRxMain(timeUs_t currentTimeUs)
{ {
static timeDelta_t rxStateDurationFracUs[RX_STATE_COUNT]; static timeDelta_t rxStateDurationFractionUs[RX_STATE_COUNT];
timeDelta_t executeTimeUs; timeDelta_t executeTimeUs;
rxState_e oldRxState = rxState; rxState_e oldRxState = rxState;
timeDelta_t anticipatedExecutionTime; timeDelta_t anticipatedExecutionTime;
@ -230,23 +230,23 @@ static void taskUpdateRxMain(timeUs_t currentTimeUs)
// If the scheduler has reduced the anticipatedExecutionTime due to task aging, pick that up // If the scheduler has reduced the anticipatedExecutionTime due to task aging, pick that up
anticipatedExecutionTime = schedulerGetNextStateTime(); anticipatedExecutionTime = schedulerGetNextStateTime();
if (anticipatedExecutionTime != (rxStateDurationFracUs[oldRxState] >> RX_TASK_DECAY_SHIFT)) { if (anticipatedExecutionTime != (rxStateDurationFractionUs[oldRxState] >> RX_TASK_DECAY_SHIFT)) {
rxStateDurationFracUs[oldRxState] = anticipatedExecutionTime << RX_TASK_DECAY_SHIFT; rxStateDurationFractionUs[oldRxState] = anticipatedExecutionTime << RX_TASK_DECAY_SHIFT;
} }
if (executeTimeUs > (rxStateDurationFracUs[oldRxState] >> RX_TASK_DECAY_SHIFT)) { if (executeTimeUs > (rxStateDurationFractionUs[oldRxState] >> RX_TASK_DECAY_SHIFT)) {
rxStateDurationFracUs[oldRxState] = executeTimeUs << RX_TASK_DECAY_SHIFT; rxStateDurationFractionUs[oldRxState] = executeTimeUs << RX_TASK_DECAY_SHIFT;
} else { } else {
// Slowly decay the max time // Slowly decay the max time
rxStateDurationFracUs[oldRxState]--; rxStateDurationFractionUs[oldRxState]--;
} }
} }
if (debugMode == DEBUG_RX_STATE_TIME) { if (debugMode == DEBUG_RX_STATE_TIME) {
debug[oldRxState] = rxStateDurationFracUs[oldRxState] >> RX_TASK_DECAY_SHIFT; debug[oldRxState] = rxStateDurationFractionUs[oldRxState] >> RX_TASK_DECAY_SHIFT;
} }
schedulerSetNextStateTime(rxStateDurationFracUs[rxState] >> RX_TASK_DECAY_SHIFT); schedulerSetNextStateTime(rxStateDurationFractionUs[rxState] >> RX_TASK_DECAY_SHIFT);
} }

6
src/main/io/gps.c
View file

@ -766,7 +766,7 @@ void gpsUpdate(timeUs_t currentTimeUs)
{ {
static gpsState_e gpsStateDurationUs[GPS_STATE_COUNT]; static gpsState_e gpsStateDurationUs[GPS_STATE_COUNT];
timeUs_t executeTimeUs; timeUs_t executeTimeUs;
gpsState_e gpsCurState = gpsData.state; gpsState_e gpsCurrentState = gpsData.state;
// read out available GPS bytes // read out available GPS bytes
if (gpsPort) { if (gpsPort) {
@ -861,8 +861,8 @@ void gpsUpdate(timeUs_t currentTimeUs)
executeTimeUs = micros() - currentTimeUs; executeTimeUs = micros() - currentTimeUs;
if (executeTimeUs > gpsStateDurationUs[gpsCurState]) { if (executeTimeUs > gpsStateDurationUs[gpsCurrentState]) {
gpsStateDurationUs[gpsCurState] = executeTimeUs; gpsStateDurationUs[gpsCurrentState] = executeTimeUs;
} }
schedulerSetNextStateTime(gpsStateDurationUs[gpsData.state]); schedulerSetNextStateTime(gpsStateDurationUs[gpsData.state]);

71
src/main/osd/osd.c
View file

@ -1169,17 +1169,16 @@ bool osdUpdateCheck(timeUs_t currentTimeUs, timeDelta_t currentDeltaTimeUs)
// Called when there is OSD update work to be done // Called when there is OSD update work to be done
void osdUpdate(timeUs_t currentTimeUs) void osdUpdate(timeUs_t currentTimeUs)
{ {
// Times are known to be short so use uint16_t rather than timeUs_t static uint16_t osdStateDurationFractionUs[OSD_STATE_COUNT] = { 0 };
static uint16_t osdStateDurationFracUs[OSD_STATE_COUNT] = { 0 };
static uint32_t osdElementDurationUs[OSD_ITEM_COUNT] = { 0 }; static uint32_t osdElementDurationUs[OSD_ITEM_COUNT] = { 0 };
static uint8_t osdElementGroupMembership[OSD_ITEM_COUNT]; static uint8_t osdElementGroupMemberships[OSD_ITEM_COUNT];
static uint16_t osdElementGroupTargetFracUs[OSD_GROUP_COUNT] = { 0 }; static uint16_t osdElementGroupTargetFractionUs[OSD_GROUP_COUNT] = { 0 };
static uint16_t osdElementGroupDurationFracUs[OSD_GROUP_COUNT] = { 0 }; static uint16_t osdElementGroupDurationFractionUs[OSD_GROUP_COUNT] = { 0 };
static uint8_t osdElementGroup; static uint8_t osdElementGroup;
static bool firstPass = true; static bool firstPass = true;
uint8_t osdCurElementGroup = 0; uint8_t osdCurrentElementGroup = 0;
timeUs_t executeTimeUs; timeUs_t executeTimeUs;
osdState_e osdCurState = osdState; osdState_e osdCurrentState = osdState;
if (osdState != OSD_STATE_UPDATE_CANVAS) { if (osdState != OSD_STATE_UPDATE_CANVAS) {
schedulerIgnoreTaskExecRate(); schedulerIgnoreTaskExecRate();
@ -1218,7 +1217,7 @@ void osdUpdate(timeUs_t currentTimeUs)
case OSD_STATE_UPDATE_HEARTBEAT: case OSD_STATE_UPDATE_HEARTBEAT:
if (displayHeartbeat(osdDisplayPort)) { if (displayHeartbeat(osdDisplayPort)) {
// Extraordinary action was taken, so return without allowing osdStateDurationFracUs table to be updated // Extraordinary action was taken, so return without allowing osdStateDurationFractionUs table to be updated
return; return;
} }
@ -1316,25 +1315,25 @@ void osdUpdate(timeUs_t currentTimeUs)
// Reset groupings // Reset groupings
for (elementGroup = 0; elementGroup < OSD_GROUP_COUNT; elementGroup++) { for (elementGroup = 0; elementGroup < OSD_GROUP_COUNT; elementGroup++) {
if (osdElementGroupDurationFracUs[elementGroup] > (OSD_ELEMENT_RENDER_TARGET << OSD_EXEC_TIME_SHIFT)) { if (osdElementGroupDurationFractionUs[elementGroup] > (OSD_ELEMENT_RENDER_TARGET << OSD_EXEC_TIME_SHIFT)) {
osdElementGroupDurationFracUs[elementGroup] = 0; osdElementGroupDurationFractionUs[elementGroup] = 0;
} }
osdElementGroupTargetFracUs[elementGroup] = 0; osdElementGroupTargetFractionUs[elementGroup] = 0;
} }
elementGroup = 0; elementGroup = 0;
// Based on the current element rendering, group to execute in approx 40us // Based on the current element rendering, group to execute in approx 40us
for (uint8_t curElement = 0; curElement < activeElements; curElement++) { for (uint8_t curElement = 0; curElement < activeElements; curElement++) {
if ((osdElementGroupTargetFracUs[elementGroup] == 0) || if ((osdElementGroupTargetFractionUs[elementGroup] == 0) ||
(osdElementGroupTargetFracUs[elementGroup] + (osdElementDurationUs[curElement]) <= (OSD_ELEMENT_RENDER_TARGET << OSD_EXEC_TIME_SHIFT)) || (osdElementGroupTargetFractionUs[elementGroup] + (osdElementDurationUs[curElement]) <= (OSD_ELEMENT_RENDER_TARGET << OSD_EXEC_TIME_SHIFT)) ||
(elementGroup == (OSD_GROUP_COUNT - 1))) { (elementGroup == (OSD_GROUP_COUNT - 1))) {
osdElementGroupTargetFracUs[elementGroup] += osdElementDurationUs[curElement]; osdElementGroupTargetFractionUs[elementGroup] += osdElementDurationUs[curElement];
// If group membership changes, reset the stats for the group // If group membership changes, reset the stats for the group
if (osdElementGroupMembership[curElement] != elementGroup) { if (osdElementGroupMemberships[curElement] != elementGroup) {
osdElementGroupDurationFracUs[elementGroup] = osdElementGroupTargetFracUs[elementGroup] + (OSD_ELEMENT_RENDER_GROUP_MARGIN << OSD_EXEC_TIME_SHIFT); osdElementGroupDurationFractionUs[elementGroup] = osdElementGroupTargetFractionUs[elementGroup] + (OSD_ELEMENT_RENDER_GROUP_MARGIN << OSD_EXEC_TIME_SHIFT);
} }
osdElementGroupMembership[curElement] = elementGroup; osdElementGroupMemberships[curElement] = elementGroup;
} else { } else {
elementGroup++; elementGroup++;
// Try again for this element // Try again for this element
@ -1355,15 +1354,15 @@ void osdUpdate(timeUs_t currentTimeUs)
case OSD_STATE_UPDATE_ELEMENTS: case OSD_STATE_UPDATE_ELEMENTS:
{ {
osdCurElementGroup = osdElementGroup; osdCurrentElementGroup = osdElementGroup;
bool moreElements = true; bool moreElements = true;
do { do {
timeUs_t startElementTime = micros(); timeUs_t startElementTime = micros();
uint8_t osdCurElement = osdGetActiveElement(); uint8_t osdCurrentElement = osdGetActiveElement();
// This element should be rendered in the next group // This element should be rendered in the next group
if (osdElementGroupMembership[osdCurElement] != osdElementGroup) { if (osdElementGroupMemberships[osdCurrentElement] != osdElementGroup) {
osdElementGroup++; osdElementGroup++;
break; break;
} }
@ -1372,11 +1371,11 @@ void osdUpdate(timeUs_t currentTimeUs)
executeTimeUs = micros() - startElementTime; executeTimeUs = micros() - startElementTime;
if (executeTimeUs > (osdElementDurationUs[osdCurElement] >> OSD_EXEC_TIME_SHIFT)) { if (executeTimeUs > (osdElementDurationUs[osdCurrentElement] >> OSD_EXEC_TIME_SHIFT)) {
osdElementDurationUs[osdCurElement] = executeTimeUs << OSD_EXEC_TIME_SHIFT; osdElementDurationUs[osdCurrentElement] = executeTimeUs << OSD_EXEC_TIME_SHIFT;
} else if (osdElementDurationUs[osdCurElement] > 0) { } else if (osdElementDurationUs[osdCurrentElement] > 0) {
// Slowly decay the max time // Slowly decay the max time
osdElementDurationUs[osdCurElement]--; osdElementDurationUs[osdCurrentElement]--;
} }
} while (moreElements); } while (moreElements);
@ -1430,31 +1429,31 @@ void osdUpdate(timeUs_t currentTimeUs)
// On the first pass no element groups will have been formed, so all elements will have been // On the first pass no element groups will have been formed, so all elements will have been
// rendered which is unrepresentative, so ignore // rendered which is unrepresentative, so ignore
if (!firstPass) { if (!firstPass) {
if (osdCurState == OSD_STATE_UPDATE_ELEMENTS) { if (osdCurrentState == OSD_STATE_UPDATE_ELEMENTS) {
if (executeTimeUs > (osdElementGroupDurationFracUs[osdCurElementGroup] >> OSD_EXEC_TIME_SHIFT)) { if (executeTimeUs > (osdElementGroupDurationFractionUs[osdCurrentElementGroup] >> OSD_EXEC_TIME_SHIFT)) {
osdElementGroupDurationFracUs[osdCurElementGroup] = executeTimeUs << OSD_EXEC_TIME_SHIFT; osdElementGroupDurationFractionUs[osdCurrentElementGroup] = executeTimeUs << OSD_EXEC_TIME_SHIFT;
} else if (osdElementGroupDurationFracUs[osdCurElementGroup] > 0) { } else if (osdElementGroupDurationFractionUs[osdCurrentElementGroup] > 0) {
// Slowly decay the max time // Slowly decay the max time
osdElementGroupDurationFracUs[osdCurElementGroup]--; osdElementGroupDurationFractionUs[osdCurrentElementGroup]--;
} }
} }
if (executeTimeUs > (osdStateDurationFracUs[osdCurState] >> OSD_EXEC_TIME_SHIFT)) { if (executeTimeUs > (osdStateDurationFractionUs[osdCurrentState] >> OSD_EXEC_TIME_SHIFT)) {
osdStateDurationFracUs[osdCurState] = executeTimeUs << OSD_EXEC_TIME_SHIFT; osdStateDurationFractionUs[osdCurrentState] = executeTimeUs << OSD_EXEC_TIME_SHIFT;
} else if (osdStateDurationFracUs[osdCurState] > 0) { } else if (osdStateDurationFractionUs[osdCurrentState] > 0) {
// Slowly decay the max time // Slowly decay the max time
osdStateDurationFracUs[osdCurState]--; osdStateDurationFractionUs[osdCurrentState]--;
} }
} }
} }
if (osdState == OSD_STATE_UPDATE_ELEMENTS) { if (osdState == OSD_STATE_UPDATE_ELEMENTS) {
schedulerSetNextStateTime((osdElementGroupDurationFracUs[osdElementGroup] >> OSD_EXEC_TIME_SHIFT) + OSD_ELEMENT_RENDER_GROUP_MARGIN); schedulerSetNextStateTime((osdElementGroupDurationFractionUs[osdElementGroup] >> OSD_EXEC_TIME_SHIFT) + OSD_ELEMENT_RENDER_GROUP_MARGIN);
} else { } else {
if (osdState == OSD_STATE_IDLE) { if (osdState == OSD_STATE_IDLE) {
schedulerSetNextStateTime((osdStateDurationFracUs[OSD_STATE_CHECK] >> OSD_EXEC_TIME_SHIFT) + OSD_TASK_MARGIN); schedulerSetNextStateTime((osdStateDurationFractionUs[OSD_STATE_CHECK] >> OSD_EXEC_TIME_SHIFT) + OSD_TASK_MARGIN);
} else { } else {
schedulerSetNextStateTime((osdStateDurationFracUs[osdState] >> OSD_EXEC_TIME_SHIFT) + OSD_TASK_MARGIN); schedulerSetNextStateTime((osdStateDurationFractionUs[osdState] >> OSD_EXEC_TIME_SHIFT) + OSD_TASK_MARGIN);
} }
} }
} }