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

Tidied blackbox switch statements

This commit is contained in:
Martin Budden 2017-04-25 12:00:13 +01:00
parent 1ad0546af3
commit 68154a223b
1 changed files with 296 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

592
src/main/blackbox/blackbox_io.c
View File

@ -78,18 +78,18 @@ void blackboxWrite(uint8_t value)
{ {
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
flashfsWriteByte(value); // Write byte asynchronously flashfsWriteByte(value); // Write byte asynchronously
break; break;
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
afatfs_fputc(blackboxSDCard.logFile, value); afatfs_fputc(blackboxSDCard.logFile, value);
break; break;
#endif #endif
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
default: default:
serialWrite(blackboxPort, value); serialWrite(blackboxPort, value);
break; break;
} }
} }
@ -153,28 +153,28 @@ int blackboxPrint(const char *s)
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
length = strlen(s); length = strlen(s);
flashfsWrite((const uint8_t*) s, length, false); // Write asynchronously flashfsWrite((const uint8_t*) s, length, false); // Write asynchronously
break; break;
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
length = strlen(s); length = strlen(s);
afatfs_fwrite(blackboxSDCard.logFile, (const uint8_t*) s, length); // Ignore failures due to buffers filling up afatfs_fwrite(blackboxSDCard.logFile, (const uint8_t*) s, length); // Ignore failures due to buffers filling up
break; break;
#endif #endif
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
default: default:
pos = (uint8_t*) s; pos = (uint8_t*) s;
while (*pos) { while (*pos) {
serialWrite(blackboxPort, *pos); serialWrite(blackboxPort, *pos);
pos++; pos++;
} }
length = pos - (uint8_t*) s; length = pos - (uint8_t*) s;
break; break;
} }
@ -278,72 +278,72 @@ void blackboxWriteTag2_3S32(int32_t *values) {
} }
switch (selector) { switch (selector) {
case BITS_2: case BITS_2:
blackboxWrite((selector << 6) | ((values[0] & 0x03) << 4) | ((values[1] & 0x03) << 2) | (values[2] & 0x03)); blackboxWrite((selector << 6) | ((values[0] & 0x03) << 4) | ((values[1] & 0x03) << 2) | (values[2] & 0x03));
break; break;
case BITS_4: case BITS_4:
blackboxWrite((selector << 6) | (values[0] & 0x0F)); blackboxWrite((selector << 6) | (values[0] & 0x0F));
blackboxWrite((values[1] << 4) | (values[2] & 0x0F)); blackboxWrite((values[1] << 4) | (values[2] & 0x0F));
break; break;
case BITS_6: case BITS_6:
blackboxWrite((selector << 6) | (values[0] & 0x3F)); blackboxWrite((selector << 6) | (values[0] & 0x3F));
blackboxWrite((uint8_t)values[1]); blackboxWrite((uint8_t)values[1]);
blackboxWrite((uint8_t)values[2]); blackboxWrite((uint8_t)values[2]);
break; break;
case BITS_32: case BITS_32:
/* /*
* Do another round to compute a selector for each field, assuming that they are at least 8 bits each * Do another round to compute a selector for each field, assuming that they are at least 8 bits each
* *
* Selector2 field possibilities * Selector2 field possibilities
* 0 - 8 bits * 0 - 8 bits
* 1 - 16 bits * 1 - 16 bits
* 2 - 24 bits * 2 - 24 bits
* 3 - 32 bits * 3 - 32 bits
*/ */
selector2 = 0; selector2 = 0;
//Encode in reverse order so the first field is in the low bits: //Encode in reverse order so the first field is in the low bits:
for (x = NUM_FIELDS - 1; x >= 0; x--) { for (x = NUM_FIELDS - 1; x >= 0; x--) {
selector2 <<= 2; selector2 <<= 2;
if (values[x] < 128 && values[x] >= -128) { if (values[x] < 128 && values[x] >= -128) {
selector2 |= BYTES_1; selector2 |= BYTES_1;
} else if (values[x] < 32768 && values[x] >= -32768) { } else if (values[x] < 32768 && values[x] >= -32768) {
selector2 |= BYTES_2; selector2 |= BYTES_2;
} else if (values[x] < 8388608 && values[x] >= -8388608) { } else if (values[x] < 8388608 && values[x] >= -8388608) {
selector2 |= BYTES_3; selector2 |= BYTES_3;
} else { } else {
selector2 |= BYTES_4; selector2 |= BYTES_4;
}
} }
}
//Write the selectors //Write the selectors
blackboxWrite((selector << 6) | selector2); blackboxWrite((selector << 6) | selector2);
//And now the values according to the selectors we picked for them //And now the values according to the selectors we picked for them
for (x = 0; x < NUM_FIELDS; x++, selector2 >>= 2) { for (x = 0; x < NUM_FIELDS; x++, selector2 >>= 2) {
switch (selector2 & 0x03) { switch (selector2 & 0x03) {
case BYTES_1: case BYTES_1:
blackboxWrite(values[x]); blackboxWrite(values[x]);
break; break;
case BYTES_2: case BYTES_2:
blackboxWrite(values[x]); blackboxWrite(values[x]);
blackboxWrite(values[x] >> 8); blackboxWrite(values[x] >> 8);
break; break;
case BYTES_3: case BYTES_3:
blackboxWrite(values[x]); blackboxWrite(values[x]);
blackboxWrite(values[x] >> 8); blackboxWrite(values[x] >> 8);
blackboxWrite(values[x] >> 16); blackboxWrite(values[x] >> 16);
break; break;
case BYTES_4: case BYTES_4:
blackboxWrite(values[x]); blackboxWrite(values[x]);
blackboxWrite(values[x] >> 8); blackboxWrite(values[x] >> 8);
blackboxWrite(values[x] >> 16); blackboxWrite(values[x] >> 16);
blackboxWrite(values[x] >> 24); blackboxWrite(values[x] >> 24);
break; break;
}
} }
break; }
break;
} }
} }
@ -386,42 +386,42 @@ void blackboxWriteTag8_4S16(int32_t *values) {
buffer = 0; buffer = 0;
for (x = 0; x < 4; x++, selector >>= 2) { for (x = 0; x < 4; x++, selector >>= 2) {
switch (selector & 0x03) { switch (selector & 0x03) {
case FIELD_ZERO: case FIELD_ZERO:
//No-op //No-op
break; break;
case FIELD_4BIT: case FIELD_4BIT:
if (nibbleIndex == 0) { if (nibbleIndex == 0) {
//We fill high-bits first //We fill high-bits first
buffer = values[x] << 4; buffer = values[x] << 4;
nibbleIndex = 1; nibbleIndex = 1;
} else { } else {
blackboxWrite(buffer | (values[x] & 0x0F)); blackboxWrite(buffer | (values[x] & 0x0F));
nibbleIndex = 0; nibbleIndex = 0;
} }
break; break;
case FIELD_8BIT: case FIELD_8BIT:
if (nibbleIndex == 0) { if (nibbleIndex == 0) {
blackboxWrite(values[x]); blackboxWrite(values[x]);
} else { } else {
//Write the high bits of the value first (mask to avoid sign extension) //Write the high bits of the value first (mask to avoid sign extension)
blackboxWrite(buffer | ((values[x] >> 4) & 0x0F)); blackboxWrite(buffer | ((values[x] >> 4) & 0x0F));
//Now put the leftover low bits into the top of the next buffer entry //Now put the leftover low bits into the top of the next buffer entry
buffer = values[x] << 4; buffer = values[x] << 4;
} }
break; break;
case FIELD_16BIT: case FIELD_16BIT:
if (nibbleIndex == 0) { if (nibbleIndex == 0) {
//Write high byte first //Write high byte first
blackboxWrite(values[x] >> 8); blackboxWrite(values[x] >> 8);
blackboxWrite(values[x]); blackboxWrite(values[x]);
} else { } else {
//First write the highest 4 bits //First write the highest 4 bits
blackboxWrite(buffer | ((values[x] >> 12) & 0x0F)); blackboxWrite(buffer | ((values[x] >> 12) & 0x0F));
// Then the middle 8 // Then the middle 8
blackboxWrite(values[x] >> 4); blackboxWrite(values[x] >> 4);
//Only the smallest 4 bits are still left to write //Only the smallest 4 bits are still left to write
buffer = values[x] << 4; buffer = values[x] << 4;
} }
break; break;
} }
} }
@ -498,13 +498,13 @@ void blackboxDeviceFlush(void)
* This is our only output device which requires us to call flush() in order for it to write anything. The other * This is our only output device which requires us to call flush() in order for it to write anything. The other
* devices will progressively write in the background without Blackbox calling anything. * devices will progressively write in the background without Blackbox calling anything.
*/ */
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
flashfsFlushAsync(); flashfsFlushAsync();
break; break;
#endif #endif
default: default:
; ;
} }
} }
@ -516,25 +516,25 @@ void blackboxDeviceFlush(void)
bool blackboxDeviceFlushForce(void) bool blackboxDeviceFlushForce(void)
{ {
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
// Nothing to speed up flushing on serial, as serial is continuously being drained out of its buffer // Nothing to speed up flushing on serial, as serial is continuously being drained out of its buffer
return isSerialTransmitBufferEmpty(blackboxPort); return isSerialTransmitBufferEmpty(blackboxPort);
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
return flashfsFlushAsync(); return flashfsFlushAsync();
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
/* SD card will flush itself without us calling it, but we need to call flush manually in order to check /* SD card will flush itself without us calling it, but we need to call flush manually in order to check
* if it's done yet or not! * if it's done yet or not!
*/ */
return afatfs_flush(); return afatfs_flush();
#endif #endif
default: default:
return false; return false;
} }
} }
@ -544,71 +544,71 @@ bool blackboxDeviceFlushForce(void)
bool blackboxDeviceOpen(void) bool blackboxDeviceOpen(void)
{ {
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
{ {
serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX); serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX);
baudRate_e baudRateIndex; baudRate_e baudRateIndex;
portOptions_t portOptions = SERIAL_PARITY_NO | SERIAL_NOT_INVERTED; portOptions_t portOptions = SERIAL_PARITY_NO | SERIAL_NOT_INVERTED;
if (!portConfig) { if (!portConfig) {
return false;
}
blackboxPortSharing = determinePortSharing(portConfig, FUNCTION_BLACKBOX);
baudRateIndex = portConfig->blackbox_baudrateIndex;
if (baudRates[baudRateIndex] == 230400) {
/*
* OpenLog's 230400 baud rate is very inaccurate, so it requires a larger inter-character gap in
* order to maintain synchronization.
*/
portOptions |= SERIAL_STOPBITS_2;
} else {
portOptions |= SERIAL_STOPBITS_1;
}
blackboxPort = openSerialPort(portConfig->identifier, FUNCTION_BLACKBOX, NULL, baudRates[baudRateIndex],
BLACKBOX_SERIAL_PORT_MODE, portOptions);
/*
* The slowest MicroSD cards have a write latency approaching 150ms. The OpenLog's buffer is about 900
* bytes. In order for its buffer to be able to absorb this latency we must write slower than 6000 B/s.
*
* So:
* Bytes per loop iteration = floor((looptime_ns / 1000000.0) * 6000)
* = floor((looptime_ns * 6000) / 1000000.0)
* = floor((looptime_ns * 3) / 500.0)
* = (looptime_ns * 3) / 500
*/
blackboxMaxHeaderBytesPerIteration = constrain((targetPidLooptime * 3) / 500, 1, BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION);
return blackboxPort != NULL;
}
break;
#ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH:
if (flashfsGetSize() == 0 || isBlackboxDeviceFull()) {
return false; return false;
} }
blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION; blackboxPortSharing = determinePortSharing(portConfig, FUNCTION_BLACKBOX);
baudRateIndex = portConfig->blackbox_baudrateIndex;
return true; if (baudRates[baudRateIndex] == 230400) {
/*
* OpenLog's 230400 baud rate is very inaccurate, so it requires a larger inter-character gap in
* order to maintain synchronization.
*/
portOptions |= SERIAL_STOPBITS_2;
} else {
portOptions |= SERIAL_STOPBITS_1;
}
blackboxPort = openSerialPort(portConfig->identifier, FUNCTION_BLACKBOX, NULL, baudRates[baudRateIndex],
BLACKBOX_SERIAL_PORT_MODE, portOptions);
/*
* The slowest MicroSD cards have a write latency approaching 150ms. The OpenLog's buffer is about 900
* bytes. In order for its buffer to be able to absorb this latency we must write slower than 6000 B/s.
*
* So:
* Bytes per loop iteration = floor((looptime_ns / 1000000.0) * 6000)
* = floor((looptime_ns * 6000) / 1000000.0)
* = floor((looptime_ns * 3) / 500.0)
* = (looptime_ns * 3) / 500
*/
blackboxMaxHeaderBytesPerIteration = constrain((targetPidLooptime * 3) / 500, 1, BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION);
return blackboxPort != NULL;
}
break;
#ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH:
if (flashfsGetSize() == 0 || isBlackboxDeviceFull()) {
return false;
}
blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
return true;
break; break;
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_FATAL || afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_UNKNOWN || afatfs_isFull()) { if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_FATAL || afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_UNKNOWN || afatfs_isFull()) {
return false; return false;
} }
blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION; blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
return true; return true;
break; break;
#endif #endif
default: default:
return false; return false;
} }
} }
@ -653,21 +653,21 @@ bool isBlackboxErased(void)
void blackboxDeviceClose(void) void blackboxDeviceClose(void)
{ {
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
// Since the serial port could be shared with other processes, we have to give it back here // Since the serial port could be shared with other processes, we have to give it back here
closeSerialPort(blackboxPort); closeSerialPort(blackboxPort);
blackboxPort = NULL; blackboxPort = NULL;
/* /*
* Normally this would be handled by mw.c, but since we take an unknown amount * Normally this would be handled by mw.c, but since we take an unknown amount
* of time to shut down asynchronously, we're the only ones that know when to call it. * of time to shut down asynchronously, we're the only ones that know when to call it.
*/ */
if (blackboxPortSharing == PORTSHARING_SHARED) { if (blackboxPortSharing == PORTSHARING_SHARED) {
mspSerialAllocatePorts(); mspSerialAllocatePorts();
} }
break; break;
default: default:
; ;
} }
} }
@ -728,59 +728,59 @@ static bool blackboxSDCardBeginLog()
doMore: doMore:
switch (blackboxSDCard.state) { switch (blackboxSDCard.state) {
case BLACKBOX_SDCARD_INITIAL: case BLACKBOX_SDCARD_INITIAL:
if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY) { if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY) {
blackboxSDCard.state = BLACKBOX_SDCARD_WAITING; blackboxSDCard.state = BLACKBOX_SDCARD_WAITING;
afatfs_mkdir("logs", blackboxLogDirCreated); afatfs_mkdir("logs", blackboxLogDirCreated);
} }
break; break;
case BLACKBOX_SDCARD_WAITING: case BLACKBOX_SDCARD_WAITING:
// Waiting for directory entry to be created // Waiting for directory entry to be created
break; break;
case BLACKBOX_SDCARD_ENUMERATE_FILES: case BLACKBOX_SDCARD_ENUMERATE_FILES:
while (afatfs_findNext(blackboxSDCard.logDirectory, &blackboxSDCard.logDirectoryFinder, &directoryEntry) == AFATFS_OPERATION_SUCCESS) { while (afatfs_findNext(blackboxSDCard.logDirectory, &blackboxSDCard.logDirectoryFinder, &directoryEntry) == AFATFS_OPERATION_SUCCESS) {
if (directoryEntry && !fat_isDirectoryEntryTerminator(directoryEntry)) { if (directoryEntry && !fat_isDirectoryEntryTerminator(directoryEntry)) {
// If this is a log file, parse the log number from the filename // If this is a log file, parse the log number from the filename
if (strncmp(directoryEntry->filename, LOGFILE_PREFIX, strlen(LOGFILE_PREFIX)) == 0 if (strncmp(directoryEntry->filename, LOGFILE_PREFIX, strlen(LOGFILE_PREFIX)) == 0
&& strncmp(directoryEntry->filename + 8, LOGFILE_SUFFIX, strlen(LOGFILE_SUFFIX)) == 0) { && strncmp(directoryEntry->filename + 8, LOGFILE_SUFFIX, strlen(LOGFILE_SUFFIX)) == 0) {
char logSequenceNumberString[6]; char logSequenceNumberString[6];
memcpy(logSequenceNumberString, directoryEntry->filename + 3, 5); memcpy(logSequenceNumberString, directoryEntry->filename + 3, 5);
logSequenceNumberString[5] = '\0'; logSequenceNumberString[5] = '\0';
blackboxSDCard.largestLogFileNumber = MAX((uint32_t) atoi(logSequenceNumberString), blackboxSDCard.largestLogFileNumber); blackboxSDCard.largestLogFileNumber = MAX((uint32_t) atoi(logSequenceNumberString), blackboxSDCard.largestLogFileNumber);
}
} else {
// We're done checking all the files on the card, now we can create a new log file
afatfs_findLast(blackboxSDCard.logDirectory);
blackboxSDCard.state = BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY;
goto doMore;
} }
} } else {
break; // We're done checking all the files on the card, now we can create a new log file
afatfs_findLast(blackboxSDCard.logDirectory);
case BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY: blackboxSDCard.state = BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY;
// Change into the log directory:
if (afatfs_chdir(blackboxSDCard.logDirectory)) {
// We no longer need our open handle on the log directory
afatfs_fclose(blackboxSDCard.logDirectory, NULL);
blackboxSDCard.logDirectory = NULL;
blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
goto doMore; goto doMore;
} }
break; }
break;
case BLACKBOX_SDCARD_READY_TO_CREATE_LOG: case BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY:
blackboxCreateLogFile(); // Change into the log directory:
break; if (afatfs_chdir(blackboxSDCard.logDirectory)) {
// We no longer need our open handle on the log directory
afatfs_fclose(blackboxSDCard.logDirectory, NULL);
blackboxSDCard.logDirectory = NULL;
case BLACKBOX_SDCARD_READY_TO_LOG: blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
return true; // Log has been created! goto doMore;
}
break;
case BLACKBOX_SDCARD_READY_TO_CREATE_LOG:
blackboxCreateLogFile();
break;
case BLACKBOX_SDCARD_READY_TO_LOG:
return true; // Log has been created!
} }
// Not finished init yet // Not finished init yet
@ -798,11 +798,11 @@ bool blackboxDeviceBeginLog(void)
{ {
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
return blackboxSDCardBeginLog(); return blackboxSDCardBeginLog();
#endif #endif
default: default:
return true; return true;
} }
} }
@ -822,42 +822,42 @@ bool blackboxDeviceEndLog(bool retainLog)
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
// Keep retrying until the close operation queues // Keep retrying until the close operation queues
if ( if (
(retainLog && afatfs_fclose(blackboxSDCard.logFile, NULL)) (retainLog && afatfs_fclose(blackboxSDCard.logFile, NULL))
|| (!retainLog && afatfs_funlink(blackboxSDCard.logFile, NULL)) || (!retainLog && afatfs_funlink(blackboxSDCard.logFile, NULL))
) { ) {
// Don't bother waiting the for the close to complete, it's queued now and will complete eventually // Don't bother waiting the for the close to complete, it's queued now and will complete eventually
blackboxSDCard.logFile = NULL; blackboxSDCard.logFile = NULL;
blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG; blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
return true;
}
return false;
#endif
default:
return true; return true;
}
return false;
#endif
default:
return true;
} }
} }
bool isBlackboxDeviceFull(void) bool isBlackboxDeviceFull(void)
{ {
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
return false; return false;
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
return flashfsIsEOF(); return flashfsIsEOF();
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
return afatfs_isFull(); return afatfs_isFull();
#endif #endif
default: default:
return false; return false;
} }
} }
@ -870,21 +870,21 @@ void blackboxReplenishHeaderBudget()
int32_t freeSpace; int32_t freeSpace;
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
freeSpace = serialTxBytesFree(blackboxPort); freeSpace = serialTxBytesFree(blackboxPort);
break; break;
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
freeSpace = flashfsGetWriteBufferFreeSpace(); freeSpace = flashfsGetWriteBufferFreeSpace();
break; break;
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
freeSpace = afatfs_getFreeBufferSpace(); freeSpace = afatfs_getFreeBufferSpace();
break; break;
#endif #endif
default: default:
freeSpace = 0; freeSpace = 0;
} }
blackboxHeaderBudget = MIN(MIN(freeSpace, blackboxHeaderBudget + blackboxMaxHeaderBytesPerIteration), BLACKBOX_MAX_ACCUMULATED_HEADER_BUDGET); blackboxHeaderBudget = MIN(MIN(freeSpace, blackboxHeaderBudget + blackboxMaxHeaderBytesPerIteration), BLACKBOX_MAX_ACCUMULATED_HEADER_BUDGET);
@ -916,43 +916,43 @@ blackboxBufferReserveStatus_e blackboxDeviceReserveBufferSpace(int32_t bytes)
// Handle failure: // Handle failure:
switch (blackboxConfig()->device) { switch (blackboxConfig()->device) {
case BLACKBOX_DEVICE_SERIAL: case BLACKBOX_DEVICE_SERIAL:
/* /*
* One byte of the tx buffer isn't available for user data (due to its circular list implementation), * One byte of the tx buffer isn't available for user data (due to its circular list implementation),
* hence the -1. Note that the USB VCP implementation doesn't use a buffer and has txBufferSize set to zero. * hence the -1. Note that the USB VCP implementation doesn't use a buffer and has txBufferSize set to zero.
*/ */
if (blackboxPort->txBufferSize && bytes > (int32_t) blackboxPort->txBufferSize - 1) { if (blackboxPort->txBufferSize && bytes > (int32_t) blackboxPort->txBufferSize - 1) {
return BLACKBOX_RESERVE_PERMANENT_FAILURE; return BLACKBOX_RESERVE_PERMANENT_FAILURE;
} }
return BLACKBOX_RESERVE_TEMPORARY_FAILURE; return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
case BLACKBOX_DEVICE_FLASH: case BLACKBOX_DEVICE_FLASH:
if (bytes > (int32_t) flashfsGetWriteBufferSize()) { if (bytes > (int32_t) flashfsGetWriteBufferSize()) {
return BLACKBOX_RESERVE_PERMANENT_FAILURE; return BLACKBOX_RESERVE_PERMANENT_FAILURE;
} }
if (bytes > (int32_t) flashfsGetWriteBufferFreeSpace()) { if (bytes > (int32_t) flashfsGetWriteBufferFreeSpace()) {
/* /*
* The write doesn't currently fit in the buffer, so try to make room for it. Our flushing here means * The write doesn't currently fit in the buffer, so try to make room for it. Our flushing here means
* that the Blackbox header writing code doesn't have to guess about the best time to ask flashfs to * that the Blackbox header writing code doesn't have to guess about the best time to ask flashfs to
* flush, and doesn't stall waiting for a flush that would otherwise not automatically be called. * flush, and doesn't stall waiting for a flush that would otherwise not automatically be called.
*/ */
flashfsFlushAsync(); flashfsFlushAsync();
} }
return BLACKBOX_RESERVE_TEMPORARY_FAILURE; return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
#endif #endif
#ifdef USE_SDCARD #ifdef USE_SDCARD
case BLACKBOX_DEVICE_SDCARD: case BLACKBOX_DEVICE_SDCARD:
// Assume that all writes will fit in the SDCard's buffers // Assume that all writes will fit in the SDCard's buffers
return BLACKBOX_RESERVE_TEMPORARY_FAILURE; return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
#endif #endif
default: default:
return BLACKBOX_RESERVE_PERMANENT_FAILURE; return BLACKBOX_RESERVE_PERMANENT_FAILURE;
} }
} }