Mirror/betaflight
1
0
Fork 0
mirror of https://github.com/betaflight/betaflight.git synced 2025-07-24 00:35:39 +03:00
Code Issues Wiki Activity

Merge pull request #2932 from martinbudden/bf_blackbox_switch

Browse source 
Tidied blackbox switch statements
This commit is contained in:
Martin Budden 2017-04-24 09:04:45 +01:00 • committed by GitHub
commit 01777439de
1 changed files with 220 additions and 220 deletions
Download patch file Download diff file Expand all files Collapse all files

440
src/main/blackbox/blackbox.c
View file

@ -388,64 +388,64 @@ static bool blackboxIsOnlyLoggingIntraframes() {
static bool testBlackboxConditionUncached(FlightLogFieldCondition condition) static bool testBlackboxConditionUncached(FlightLogFieldCondition condition)
{ {
switch (condition) { switch (condition) {
case FLIGHT_LOG_FIELD_CONDITION_ALWAYS: case FLIGHT_LOG_FIELD_CONDITION_ALWAYS:
return true; return true;
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_1: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_1:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_2: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_2:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_3: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_3:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_4: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_4:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_5: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_5:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_6: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_6:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_7: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_7:
case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_8: case FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_8:
return getMotorCount() >= condition - FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_1 + 1; return getMotorCount() >= condition - FLIGHT_LOG_FIELD_CONDITION_AT_LEAST_MOTORS_1 + 1;
case FLIGHT_LOG_FIELD_CONDITION_TRICOPTER: case FLIGHT_LOG_FIELD_CONDITION_TRICOPTER:
return mixerConfig()->mixerMode == MIXER_TRI || mixerConfig()->mixerMode == MIXER_CUSTOM_TRI; return mixerConfig()->mixerMode == MIXER_TRI || mixerConfig()->mixerMode == MIXER_CUSTOM_TRI;
case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_0: case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_0:
case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_1: case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_1:
case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_2: case FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_2:
return currentPidProfile->D8[condition - FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_0] != 0; return currentPidProfile->D8[condition - FLIGHT_LOG_FIELD_CONDITION_NONZERO_PID_D_0] != 0;
case FLIGHT_LOG_FIELD_CONDITION_MAG: case FLIGHT_LOG_FIELD_CONDITION_MAG:
#ifdef MAG #ifdef MAG
return sensors(SENSOR_MAG); return sensors(SENSOR_MAG);
#else #else
return false; return false;
#endif #endif
case FLIGHT_LOG_FIELD_CONDITION_BARO: case FLIGHT_LOG_FIELD_CONDITION_BARO:
#ifdef BARO #ifdef BARO
return sensors(SENSOR_BARO); return sensors(SENSOR_BARO);
#else #else
return false; return false;
#endif #endif
case FLIGHT_LOG_FIELD_CONDITION_VBAT: case FLIGHT_LOG_FIELD_CONDITION_VBAT:
return batteryConfig()->voltageMeterSource != VOLTAGE_METER_NONE; return batteryConfig()->voltageMeterSource != VOLTAGE_METER_NONE;
case FLIGHT_LOG_FIELD_CONDITION_AMPERAGE_ADC: case FLIGHT_LOG_FIELD_CONDITION_AMPERAGE_ADC:
return batteryConfig()->currentMeterSource == CURRENT_METER_ADC; return batteryConfig()->currentMeterSource == CURRENT_METER_ADC;
case FLIGHT_LOG_FIELD_CONDITION_SONAR: case FLIGHT_LOG_FIELD_CONDITION_SONAR:
#ifdef SONAR #ifdef SONAR
return feature(FEATURE_SONAR); return feature(FEATURE_SONAR);
#else #else
return false; return false;
#endif #endif
case FLIGHT_LOG_FIELD_CONDITION_RSSI: case FLIGHT_LOG_FIELD_CONDITION_RSSI:
return rxConfig()->rssi_channel > 0 || feature(FEATURE_RSSI_ADC); return rxConfig()->rssi_channel > 0 || feature(FEATURE_RSSI_ADC);
case FLIGHT_LOG_FIELD_CONDITION_NOT_LOGGING_EVERY_FRAME: case FLIGHT_LOG_FIELD_CONDITION_NOT_LOGGING_EVERY_FRAME:
return blackboxConfig()->rate_num < blackboxConfig()->rate_denom; return blackboxConfig()->rate_num < blackboxConfig()->rate_denom;
case FLIGHT_LOG_FIELD_CONDITION_NEVER: case FLIGHT_LOG_FIELD_CONDITION_NEVER:
return false; return false;
default: default:
return false; return false;
} }
} }
@ -471,32 +471,32 @@ static void blackboxSetState(BlackboxState newState)
{ {
//Perform initial setup required for the new state //Perform initial setup required for the new state
switch (newState) { switch (newState) {
case BLACKBOX_STATE_PREPARE_LOG_FILE: case BLACKBOX_STATE_PREPARE_LOG_FILE:
blackboxLoggedAnyFrames = false; blackboxLoggedAnyFrames = false;
break; break;
case BLACKBOX_STATE_SEND_HEADER: case BLACKBOX_STATE_SEND_HEADER:
blackboxHeaderBudget = 0; blackboxHeaderBudget = 0;
xmitState.headerIndex = 0; xmitState.headerIndex = 0;
xmitState.u.startTime = millis(); xmitState.u.startTime = millis();
break; break;
case BLACKBOX_STATE_SEND_MAIN_FIELD_HEADER: case BLACKBOX_STATE_SEND_MAIN_FIELD_HEADER:
case BLACKBOX_STATE_SEND_GPS_G_HEADER: case BLACKBOX_STATE_SEND_GPS_G_HEADER:
case BLACKBOX_STATE_SEND_GPS_H_HEADER: case BLACKBOX_STATE_SEND_GPS_H_HEADER:
case BLACKBOX_STATE_SEND_SLOW_HEADER: case BLACKBOX_STATE_SEND_SLOW_HEADER:
xmitState.headerIndex = 0; xmitState.headerIndex = 0;
xmitState.u.fieldIndex = -1; xmitState.u.fieldIndex = -1;
break; break;
case BLACKBOX_STATE_SEND_SYSINFO: case BLACKBOX_STATE_SEND_SYSINFO:
xmitState.headerIndex = 0; xmitState.headerIndex = 0;
break; break;
case BLACKBOX_STATE_RUNNING: case BLACKBOX_STATE_RUNNING:
blackboxSlowFrameIterationTimer = SLOW_FRAME_INTERVAL; //Force a slow frame to be written on the first iteration blackboxSlowFrameIterationTimer = SLOW_FRAME_INTERVAL; //Force a slow frame to be written on the first iteration
break; break;
case BLACKBOX_STATE_SHUTTING_DOWN: case BLACKBOX_STATE_SHUTTING_DOWN:
xmitState.u.startTime = millis(); xmitState.u.startTime = millis();
break; break;
default: default:
; ;
} }
blackboxState = newState; blackboxState = newState;
} }
@ -808,16 +808,16 @@ void validateBlackboxConfig()
// If we've chosen an unsupported device, change the device to serial // If we've chosen an unsupported device, change the device to serial
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
#endif #endif
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
// Device supported, leave the setting alone // Device supported, leave the setting alone
break; break;
default: default:
blackboxConfigMutable()->device = BLACKBOX_DEVICE_SERIAL; blackboxConfigMutable()->device = BLACKBOX_DEVICE_SERIAL;
} }
} }
@ -873,19 +873,19 @@ void startBlackbox(void)
void finishBlackbox(void) void finishBlackbox(void)
{ {
switch (blackboxState) { switch (blackboxState) {
case BLACKBOX_STATE_DISABLED: case BLACKBOX_STATE_DISABLED:
case BLACKBOX_STATE_STOPPED: case BLACKBOX_STATE_STOPPED:
case BLACKBOX_STATE_SHUTTING_DOWN: case BLACKBOX_STATE_SHUTTING_DOWN:
// We're already stopped/shutting down // We're already stopped/shutting down
break; break;
case BLACKBOX_STATE_RUNNING: case BLACKBOX_STATE_RUNNING:
case BLACKBOX_STATE_PAUSED: case BLACKBOX_STATE_PAUSED:
blackboxLogEvent(FLIGHT_LOG_EVENT_LOG_END, NULL); blackboxLogEvent(FLIGHT_LOG_EVENT_LOG_END, NULL);
// Fall through // Fall through
default: default:
blackboxSetState(BLACKBOX_STATE_SHUTTING_DOWN); blackboxSetState(BLACKBOX_STATE_SHUTTING_DOWN);
} }
} }
@ -1341,29 +1341,29 @@ void blackboxLogEvent(FlightLogEvent event, flightLogEventData_t *data)
//Now serialize the data for this specific frame type //Now serialize the data for this specific frame type
switch (event) { switch (event) {
case FLIGHT_LOG_EVENT_SYNC_BEEP: case FLIGHT_LOG_EVENT_SYNC_BEEP:
blackboxWriteUnsignedVB(data->syncBeep.time); blackboxWriteUnsignedVB(data->syncBeep.time);
break; break;
case FLIGHT_LOG_EVENT_FLIGHTMODE: // New flightmode flags write case FLIGHT_LOG_EVENT_FLIGHTMODE: // New flightmode flags write
blackboxWriteUnsignedVB(data->flightMode.flags); blackboxWriteUnsignedVB(data->flightMode.flags);
blackboxWriteUnsignedVB(data->flightMode.lastFlags); blackboxWriteUnsignedVB(data->flightMode.lastFlags);
break; break;
case FLIGHT_LOG_EVENT_INFLIGHT_ADJUSTMENT: case FLIGHT_LOG_EVENT_INFLIGHT_ADJUSTMENT:
if (data->inflightAdjustment.floatFlag) { if (data->inflightAdjustment.floatFlag) {
blackboxWrite(data->inflightAdjustment.adjustmentFunction + FLIGHT_LOG_EVENT_INFLIGHT_ADJUSTMENT_FUNCTION_FLOAT_VALUE_FLAG); blackboxWrite(data->inflightAdjustment.adjustmentFunction + FLIGHT_LOG_EVENT_INFLIGHT_ADJUSTMENT_FUNCTION_FLOAT_VALUE_FLAG);
blackboxWriteFloat(data->inflightAdjustment.newFloatValue); blackboxWriteFloat(data->inflightAdjustment.newFloatValue);
} else { } else {
blackboxWrite(data->inflightAdjustment.adjustmentFunction); blackboxWrite(data->inflightAdjustment.adjustmentFunction);
blackboxWriteSignedVB(data->inflightAdjustment.newValue); blackboxWriteSignedVB(data->inflightAdjustment.newValue);
} }
break; break;
case FLIGHT_LOG_EVENT_LOGGING_RESUME: case FLIGHT_LOG_EVENT_LOGGING_RESUME:
blackboxWriteUnsignedVB(data->loggingResume.logIteration); blackboxWriteUnsignedVB(data->loggingResume.logIteration);
blackboxWriteUnsignedVB(data->loggingResume.currentTime); blackboxWriteUnsignedVB(data->loggingResume.currentTime);
break; break;
case FLIGHT_LOG_EVENT_LOG_END: case FLIGHT_LOG_EVENT_LOG_END:
blackboxPrint("End of log"); blackboxPrint("End of log");
blackboxWrite(0); blackboxWrite(0);
break; break;
} }
} }
@ -1489,160 +1489,160 @@ void handleBlackbox(timeUs_t currentTimeUs)
int i; int i;
switch (blackboxState) { switch (blackboxState) {
case BLACKBOX_STATE_STOPPED: case BLACKBOX_STATE_STOPPED:
if (ARMING_FLAG(ARMED)) { if (ARMING_FLAG(ARMED)) {
blackboxOpen(); blackboxOpen();
startBlackbox(); startBlackbox();
} }
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
if (IS_RC_MODE_ACTIVE(BOXBLACKBOXERASE)) { if (IS_RC_MODE_ACTIVE(BOXBLACKBOXERASE)) {
blackboxSetState(BLACKBOX_STATE_START_ERASE); blackboxSetState(BLACKBOX_STATE_START_ERASE);
} }
#endif #endif
break; break;
case BLACKBOX_STATE_PREPARE_LOG_FILE: case BLACKBOX_STATE_PREPARE_LOG_FILE:
if (blackboxDeviceBeginLog()) { if (blackboxDeviceBeginLog()) {
blackboxSetState(BLACKBOX_STATE_SEND_HEADER); blackboxSetState(BLACKBOX_STATE_SEND_HEADER);
} }
break; break;
case BLACKBOX_STATE_SEND_HEADER: case BLACKBOX_STATE_SEND_HEADER:
blackboxReplenishHeaderBudget(); blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and startTime is intialised //On entry of this state, xmitState.headerIndex is 0 and startTime is intialised
/* /*
* Once the UART has had time to init, transmit the header in chunks so we don't overflow its transmit * Once the UART has had time to init, transmit the header in chunks so we don't overflow its transmit
* buffer, overflow the OpenLog's buffer, or keep the main loop busy for too long. * buffer, overflow the OpenLog's buffer, or keep the main loop busy for too long.
*/ */
if (millis() > xmitState.u.startTime + 100) { if (millis() > xmitState.u.startTime + 100) {
if (blackboxDeviceReserveBufferSpace(BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION) == BLACKBOX_RESERVE_SUCCESS) { if (blackboxDeviceReserveBufferSpace(BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION) == BLACKBOX_RESERVE_SUCCESS) {
for (i = 0; i < BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION && blackboxHeader[xmitState.headerIndex] != '\0'; i++, xmitState.headerIndex++) { for (i = 0; i < BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION && blackboxHeader[xmitState.headerIndex] != '\0'; i++, xmitState.headerIndex++) {
blackboxWrite(blackboxHeader[xmitState.headerIndex]); blackboxWrite(blackboxHeader[xmitState.headerIndex]);
blackboxHeaderBudget--; blackboxHeaderBudget--;
} }
if (blackboxHeader[xmitState.headerIndex] == '\0') { if (blackboxHeader[xmitState.headerIndex] == '\0') {
blackboxSetState(BLACKBOX_STATE_SEND_MAIN_FIELD_HEADER); blackboxSetState(BLACKBOX_STATE_SEND_MAIN_FIELD_HEADER);
}
} }
} }
}
break; break;
case BLACKBOX_STATE_SEND_MAIN_FIELD_HEADER: case BLACKBOX_STATE_SEND_MAIN_FIELD_HEADER:
blackboxReplenishHeaderBudget(); blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1 //On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1
if (!sendFieldDefinition('I', 'P', blackboxMainFields, blackboxMainFields + 1, ARRAY_LENGTH(blackboxMainFields), if (!sendFieldDefinition('I', 'P', blackboxMainFields, blackboxMainFields + 1, ARRAY_LENGTH(blackboxMainFields),
&blackboxMainFields[0].condition, &blackboxMainFields[1].condition)) { &blackboxMainFields[0].condition, &blackboxMainFields[1].condition)) {
#ifdef GPS #ifdef GPS
if (feature(FEATURE_GPS)) { if (feature(FEATURE_GPS)) {
blackboxSetState(BLACKBOX_STATE_SEND_GPS_H_HEADER); blackboxSetState(BLACKBOX_STATE_SEND_GPS_H_HEADER);
} else } else
#endif #endif
blackboxSetState(BLACKBOX_STATE_SEND_SLOW_HEADER);
}
break;
#ifdef GPS
case BLACKBOX_STATE_SEND_GPS_H_HEADER:
blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1
if (!sendFieldDefinition('H', 0, blackboxGpsHFields, blackboxGpsHFields + 1, ARRAY_LENGTH(blackboxGpsHFields),
NULL, NULL)) {
blackboxSetState(BLACKBOX_STATE_SEND_GPS_G_HEADER);
}
break;
case BLACKBOX_STATE_SEND_GPS_G_HEADER:
blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1
if (!sendFieldDefinition('G', 0, blackboxGpsGFields, blackboxGpsGFields + 1, ARRAY_LENGTH(blackboxGpsGFields),
&blackboxGpsGFields[0].condition, &blackboxGpsGFields[1].condition)) {
blackboxSetState(BLACKBOX_STATE_SEND_SLOW_HEADER); blackboxSetState(BLACKBOX_STATE_SEND_SLOW_HEADER);
} }
break;
#ifdef GPS
case BLACKBOX_STATE_SEND_GPS_H_HEADER:
blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1
if (!sendFieldDefinition('H', 0, blackboxGpsHFields, blackboxGpsHFields + 1, ARRAY_LENGTH(blackboxGpsHFields),
NULL, NULL)) {
blackboxSetState(BLACKBOX_STATE_SEND_GPS_G_HEADER);
}
break;
case BLACKBOX_STATE_SEND_GPS_G_HEADER:
blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1
if (!sendFieldDefinition('G', 0, blackboxGpsGFields, blackboxGpsGFields + 1, ARRAY_LENGTH(blackboxGpsGFields),
&blackboxGpsGFields[0].condition, &blackboxGpsGFields[1].condition)) {
blackboxSetState(BLACKBOX_STATE_SEND_SLOW_HEADER);
}
break; break;
#endif #endif
case BLACKBOX_STATE_SEND_SLOW_HEADER: case BLACKBOX_STATE_SEND_SLOW_HEADER:
blackboxReplenishHeaderBudget(); blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1 //On entry of this state, xmitState.headerIndex is 0 and xmitState.u.fieldIndex is -1
if (!sendFieldDefinition('S', 0, blackboxSlowFields, blackboxSlowFields + 1, ARRAY_LENGTH(blackboxSlowFields), if (!sendFieldDefinition('S', 0, blackboxSlowFields, blackboxSlowFields + 1, ARRAY_LENGTH(blackboxSlowFields),
NULL, NULL)) { NULL, NULL)) {
blackboxSetState(BLACKBOX_STATE_SEND_SYSINFO); blackboxSetState(BLACKBOX_STATE_SEND_SYSINFO);
} }
break; break;
case BLACKBOX_STATE_SEND_SYSINFO: case BLACKBOX_STATE_SEND_SYSINFO:
blackboxReplenishHeaderBudget(); blackboxReplenishHeaderBudget();
//On entry of this state, xmitState.headerIndex is 0 //On entry of this state, xmitState.headerIndex is 0
//Keep writing chunks of the system info headers until it returns true to signal completion //Keep writing chunks of the system info headers until it returns true to signal completion
if (blackboxWriteSysinfo()) { if (blackboxWriteSysinfo()) {
/*
* Wait for header buffers to drain completely before data logging begins to ensure reliable header delivery
* (overflowing circular buffers causes all data to be discarded, so the first few logged iterations
* could wipe out the end of the header if we weren't careful)
*/
if (blackboxDeviceFlushForce()) {
blackboxSetState(BLACKBOX_STATE_RUNNING);
}
}
break;
case BLACKBOX_STATE_PAUSED:
// Only allow resume to occur during an I-frame iteration, so that we have an "I" base to work from
if (IS_RC_MODE_ACTIVE(BOXBLACKBOX) && blackboxShouldLogIFrame()) {
// Write a log entry so the decoder is aware that our large time/iteration skip is intended
flightLogEvent_loggingResume_t resume;
resume.logIteration = blackboxIteration;
resume.currentTime = currentTimeUs;
blackboxLogEvent(FLIGHT_LOG_EVENT_LOGGING_RESUME, (flightLogEventData_t *) &resume);
blackboxSetState(BLACKBOX_STATE_RUNNING);
blackboxLogIteration(currentTimeUs);
}
// Keep the logging timers ticking so our log iteration continues to advance
blackboxAdvanceIterationTimers();
break;
case BLACKBOX_STATE_RUNNING:
// On entry to this state, blackboxIteration, blackboxPFrameIndex and blackboxIFrameIndex are reset to 0
// Prevent the Pausing of the log on the mode switch if in Motor Test Mode
if (blackboxModeActivationConditionPresent && !IS_RC_MODE_ACTIVE(BOXBLACKBOX) && !startedLoggingInTestMode) {
blackboxSetState(BLACKBOX_STATE_PAUSED);
} else {
blackboxLogIteration(currentTimeUs);
}
blackboxAdvanceIterationTimers();
break;
case BLACKBOX_STATE_SHUTTING_DOWN:
//On entry of this state, startTime is set
/* /*
* Wait for the log we've transmitted to make its way to the logger before we release the serial port, * Wait for header buffers to drain completely before data logging begins to ensure reliable header delivery
* since releasing the port clears the Tx buffer. * (overflowing circular buffers causes all data to be discarded, so the first few logged iterations
* * could wipe out the end of the header if we weren't careful)
* Don't wait longer than it could possibly take if something funky happens.
*/ */
if (blackboxDeviceEndLog(blackboxLoggedAnyFrames) && (millis() > xmitState.u.startTime + BLACKBOX_SHUTDOWN_TIMEOUT_MILLIS || blackboxDeviceFlushForce())) { if (blackboxDeviceFlushForce()) {
blackboxDeviceClose(); blackboxSetState(BLACKBOX_STATE_RUNNING);
blackboxSetState(BLACKBOX_STATE_STOPPED);
} }
}
break;
case BLACKBOX_STATE_PAUSED:
// Only allow resume to occur during an I-frame iteration, so that we have an "I" base to work from
if (IS_RC_MODE_ACTIVE(BOXBLACKBOX) && blackboxShouldLogIFrame()) {
// Write a log entry so the decoder is aware that our large time/iteration skip is intended
flightLogEvent_loggingResume_t resume;
resume.logIteration = blackboxIteration;
resume.currentTime = currentTimeUs;
blackboxLogEvent(FLIGHT_LOG_EVENT_LOGGING_RESUME, (flightLogEventData_t *) &resume);
blackboxSetState(BLACKBOX_STATE_RUNNING);
blackboxLogIteration(currentTimeUs);
}
// Keep the logging timers ticking so our log iteration continues to advance
blackboxAdvanceIterationTimers();
break;
case BLACKBOX_STATE_RUNNING:
// On entry to this state, blackboxIteration, blackboxPFrameIndex and blackboxIFrameIndex are reset to 0
// Prevent the Pausing of the log on the mode switch if in Motor Test Mode
if (blackboxModeActivationConditionPresent && !IS_RC_MODE_ACTIVE(BOXBLACKBOX) && !startedLoggingInTestMode) {
blackboxSetState(BLACKBOX_STATE_PAUSED);
} else {
blackboxLogIteration(currentTimeUs);
}
blackboxAdvanceIterationTimers();
break;
case BLACKBOX_STATE_SHUTTING_DOWN:
//On entry of this state, startTime is set
/*
* Wait for the log we've transmitted to make its way to the logger before we release the serial port,
* since releasing the port clears the Tx buffer.
*
* Don't wait longer than it could possibly take if something funky happens.
*/
if (blackboxDeviceEndLog(blackboxLoggedAnyFrames) && (millis() > xmitState.u.startTime + BLACKBOX_SHUTDOWN_TIMEOUT_MILLIS || blackboxDeviceFlushForce())) {
blackboxDeviceClose();
blackboxSetState(BLACKBOX_STATE_STOPPED);
}
break; break;
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_STATE_START_ERASE: case BLACKBOX_STATE_START_ERASE:
blackboxEraseAll(); blackboxEraseAll();
blackboxSetState(BLACKBOX_STATE_ERASING); blackboxSetState(BLACKBOX_STATE_ERASING);
beeper(BEEPER_BLACKBOX_ERASE);
break;
case BLACKBOX_STATE_ERASING:
if (isBlackboxErased()) {
//Done erasing
blackboxSetState(BLACKBOX_STATE_ERASED);
beeper(BEEPER_BLACKBOX_ERASE); beeper(BEEPER_BLACKBOX_ERASE);
}
break; break;
case BLACKBOX_STATE_ERASING: case BLACKBOX_STATE_ERASED:
if (isBlackboxErased()) { if (!IS_RC_MODE_ACTIVE(BOXBLACKBOXERASE)) {
//Done erasing blackboxSetState(BLACKBOX_STATE_STOPPED);
blackboxSetState(BLACKBOX_STATE_ERASED); }
beeper(BEEPER_BLACKBOX_ERASE); break;
}
break;
case BLACKBOX_STATE_ERASED:
if (!IS_RC_MODE_ACTIVE(BOXBLACKBOXERASE)) {
blackboxSetState(BLACKBOX_STATE_STOPPED);
}
break;
#endif #endif
default: default:
break; break;
} }