Tidied blackbox switch statements
This commit is contained in:
Martin Budden
parent
1ad0546af3
commit
68154a223b
|
|
@ -78,18 +78,18 @@ void blackboxWrite(uint8_t value)
|
|||
{
|
||||
switch (blackboxConfig()->device) {
|
||||
#ifdef USE_FLASHFS
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
flashfsWriteByte(value); // Write byte asynchronously
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
flashfsWriteByte(value); // Write byte asynchronously
|
||||
break;
|
||||
#endif
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
afatfs_fputc(blackboxSDCard.logFile, value);
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
afatfs_fputc(blackboxSDCard.logFile, value);
|
||||
break;
|
||||
#endif
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
default:
|
||||
serialWrite(blackboxPort, value);
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
default:
|
||||
serialWrite(blackboxPort, value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -153,28 +153,28 @@ int blackboxPrint(const char *s)
|
|||
switch (blackboxConfig()->device) {
|
||||
|
||||
#ifdef USE_FLASHFS
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
length = strlen(s);
|
||||
flashfsWrite((const uint8_t*) s, length, false); // Write asynchronously
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
length = strlen(s);
|
||||
flashfsWrite((const uint8_t*) s, length, false); // Write asynchronously
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
length = strlen(s);
|
||||
afatfs_fwrite(blackboxSDCard.logFile, (const uint8_t*) s, length); // Ignore failures due to buffers filling up
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
length = strlen(s);
|
||||
afatfs_fwrite(blackboxSDCard.logFile, (const uint8_t*) s, length); // Ignore failures due to buffers filling up
|
||||
break;
|
||||
#endif
|
||||
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
default:
|
||||
pos = (uint8_t*) s;
|
||||
while (*pos) {
|
||||
serialWrite(blackboxPort, *pos);
|
||||
pos++;
|
||||
}
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
default:
|
||||
pos = (uint8_t*) s;
|
||||
while (*pos) {
|
||||
serialWrite(blackboxPort, *pos);
|
||||
pos++;
|
||||
}
|
||||
|
||||
length = pos - (uint8_t*) s;
|
||||
length = pos - (uint8_t*) s;
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -278,72 +278,72 @@ void blackboxWriteTag2_3S32(int32_t *values) {
|
|||
}
|
||||
|
||||
switch (selector) {
|
||||
case BITS_2:
|
||||
blackboxWrite((selector << 6) | ((values[0] & 0x03) << 4) | ((values[1] & 0x03) << 2) | (values[2] & 0x03));
|
||||
case BITS_2:
|
||||
blackboxWrite((selector << 6) | ((values[0] & 0x03) << 4) | ((values[1] & 0x03) << 2) | (values[2] & 0x03));
|
||||
break;
|
||||
case BITS_4:
|
||||
blackboxWrite((selector << 6) | (values[0] & 0x0F));
|
||||
blackboxWrite((values[1] << 4) | (values[2] & 0x0F));
|
||||
case BITS_4:
|
||||
blackboxWrite((selector << 6) | (values[0] & 0x0F));
|
||||
blackboxWrite((values[1] << 4) | (values[2] & 0x0F));
|
||||
break;
|
||||
case BITS_6:
|
||||
blackboxWrite((selector << 6) | (values[0] & 0x3F));
|
||||
blackboxWrite((uint8_t)values[1]);
|
||||
blackboxWrite((uint8_t)values[2]);
|
||||
case BITS_6:
|
||||
blackboxWrite((selector << 6) | (values[0] & 0x3F));
|
||||
blackboxWrite((uint8_t)values[1]);
|
||||
blackboxWrite((uint8_t)values[2]);
|
||||
break;
|
||||
case BITS_32:
|
||||
/*
|
||||
* Do another round to compute a selector for each field, assuming that they are at least 8 bits each
|
||||
*
|
||||
* Selector2 field possibilities
|
||||
* 0 - 8 bits
|
||||
* 1 - 16 bits
|
||||
* 2 - 24 bits
|
||||
* 3 - 32 bits
|
||||
*/
|
||||
selector2 = 0;
|
||||
case BITS_32:
|
||||
/*
|
||||
* Do another round to compute a selector for each field, assuming that they are at least 8 bits each
|
||||
*
|
||||
* Selector2 field possibilities
|
||||
* 0 - 8 bits
|
||||
* 1 - 16 bits
|
||||
* 2 - 24 bits
|
||||
* 3 - 32 bits
|
||||
*/
|
||||
selector2 = 0;
|
||||
|
||||
//Encode in reverse order so the first field is in the low bits:
|
||||
for (x = NUM_FIELDS - 1; x >= 0; x--) {
|
||||
selector2 <<= 2;
|
||||
//Encode in reverse order so the first field is in the low bits:
|
||||
for (x = NUM_FIELDS - 1; x >= 0; x--) {
|
||||
selector2 <<= 2;
|
||||
|
||||
if (values[x] < 128 && values[x] >= -128) {
|
||||
selector2 |= BYTES_1;
|
||||
} else if (values[x] < 32768 && values[x] >= -32768) {
|
||||
selector2 |= BYTES_2;
|
||||
} else if (values[x] < 8388608 && values[x] >= -8388608) {
|
||||
selector2 |= BYTES_3;
|
||||
} else {
|
||||
selector2 |= BYTES_4;
|
||||
}
|
||||
if (values[x] < 128 && values[x] >= -128) {
|
||||
selector2 |= BYTES_1;
|
||||
} else if (values[x] < 32768 && values[x] >= -32768) {
|
||||
selector2 |= BYTES_2;
|
||||
} else if (values[x] < 8388608 && values[x] >= -8388608) {
|
||||
selector2 |= BYTES_3;
|
||||
} else {
|
||||
selector2 |= BYTES_4;
|
||||
}
|
||||
}
|
||||
|
||||
//Write the selectors
|
||||
blackboxWrite((selector << 6) | selector2);
|
||||
//Write the selectors
|
||||
blackboxWrite((selector << 6) | selector2);
|
||||
|
||||
//And now the values according to the selectors we picked for them
|
||||
for (x = 0; x < NUM_FIELDS; x++, selector2 >>= 2) {
|
||||
switch (selector2 & 0x03) {
|
||||
case BYTES_1:
|
||||
blackboxWrite(values[x]);
|
||||
break;
|
||||
case BYTES_2:
|
||||
blackboxWrite(values[x]);
|
||||
blackboxWrite(values[x] >> 8);
|
||||
break;
|
||||
case BYTES_3:
|
||||
blackboxWrite(values[x]);
|
||||
blackboxWrite(values[x] >> 8);
|
||||
blackboxWrite(values[x] >> 16);
|
||||
break;
|
||||
case BYTES_4:
|
||||
blackboxWrite(values[x]);
|
||||
blackboxWrite(values[x] >> 8);
|
||||
blackboxWrite(values[x] >> 16);
|
||||
blackboxWrite(values[x] >> 24);
|
||||
break;
|
||||
}
|
||||
//And now the values according to the selectors we picked for them
|
||||
for (x = 0; x < NUM_FIELDS; x++, selector2 >>= 2) {
|
||||
switch (selector2 & 0x03) {
|
||||
case BYTES_1:
|
||||
blackboxWrite(values[x]);
|
||||
break;
|
||||
case BYTES_2:
|
||||
blackboxWrite(values[x]);
|
||||
blackboxWrite(values[x] >> 8);
|
||||
break;
|
||||
case BYTES_3:
|
||||
blackboxWrite(values[x]);
|
||||
blackboxWrite(values[x] >> 8);
|
||||
blackboxWrite(values[x] >> 16);
|
||||
break;
|
||||
case BYTES_4:
|
||||
blackboxWrite(values[x]);
|
||||
blackboxWrite(values[x] >> 8);
|
||||
blackboxWrite(values[x] >> 16);
|
||||
blackboxWrite(values[x] >> 24);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -386,42 +386,42 @@ void blackboxWriteTag8_4S16(int32_t *values) {
|
|||
buffer = 0;
|
||||
for (x = 0; x < 4; x++, selector >>= 2) {
|
||||
switch (selector & 0x03) {
|
||||
case FIELD_ZERO:
|
||||
//No-op
|
||||
case FIELD_ZERO:
|
||||
//No-op
|
||||
break;
|
||||
case FIELD_4BIT:
|
||||
if (nibbleIndex == 0) {
|
||||
//We fill high-bits first
|
||||
buffer = values[x] << 4;
|
||||
nibbleIndex = 1;
|
||||
} else {
|
||||
blackboxWrite(buffer | (values[x] & 0x0F));
|
||||
nibbleIndex = 0;
|
||||
}
|
||||
case FIELD_4BIT:
|
||||
if (nibbleIndex == 0) {
|
||||
//We fill high-bits first
|
||||
buffer = values[x] << 4;
|
||||
nibbleIndex = 1;
|
||||
} else {
|
||||
blackboxWrite(buffer | (values[x] & 0x0F));
|
||||
nibbleIndex = 0;
|
||||
}
|
||||
break;
|
||||
case FIELD_8BIT:
|
||||
if (nibbleIndex == 0) {
|
||||
blackboxWrite(values[x]);
|
||||
} else {
|
||||
//Write the high bits of the value first (mask to avoid sign extension)
|
||||
blackboxWrite(buffer | ((values[x] >> 4) & 0x0F));
|
||||
//Now put the leftover low bits into the top of the next buffer entry
|
||||
buffer = values[x] << 4;
|
||||
}
|
||||
case FIELD_8BIT:
|
||||
if (nibbleIndex == 0) {
|
||||
blackboxWrite(values[x]);
|
||||
} else {
|
||||
//Write the high bits of the value first (mask to avoid sign extension)
|
||||
blackboxWrite(buffer | ((values[x] >> 4) & 0x0F));
|
||||
//Now put the leftover low bits into the top of the next buffer entry
|
||||
buffer = values[x] << 4;
|
||||
}
|
||||
break;
|
||||
case FIELD_16BIT:
|
||||
if (nibbleIndex == 0) {
|
||||
//Write high byte first
|
||||
blackboxWrite(values[x] >> 8);
|
||||
blackboxWrite(values[x]);
|
||||
} else {
|
||||
//First write the highest 4 bits
|
||||
blackboxWrite(buffer | ((values[x] >> 12) & 0x0F));
|
||||
// Then the middle 8
|
||||
blackboxWrite(values[x] >> 4);
|
||||
//Only the smallest 4 bits are still left to write
|
||||
buffer = values[x] << 4;
|
||||
}
|
||||
case FIELD_16BIT:
|
||||
if (nibbleIndex == 0) {
|
||||
//Write high byte first
|
||||
blackboxWrite(values[x] >> 8);
|
||||
blackboxWrite(values[x]);
|
||||
} else {
|
||||
//First write the highest 4 bits
|
||||
blackboxWrite(buffer | ((values[x] >> 12) & 0x0F));
|
||||
// Then the middle 8
|
||||
blackboxWrite(values[x] >> 4);
|
||||
//Only the smallest 4 bits are still left to write
|
||||
buffer = values[x] << 4;
|
||||
}
|
||||
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
|
||||
* devices will progressively write in the background without Blackbox calling anything.
|
||||
*/
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
flashfsFlushAsync();
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
flashfsFlushAsync();
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
;
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -516,25 +516,25 @@ void blackboxDeviceFlush(void)
|
|||
bool blackboxDeviceFlushForce(void)
|
||||
{
|
||||
switch (blackboxConfig()->device) {
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
// Nothing to speed up flushing on serial, as serial is continuously being drained out of its buffer
|
||||
return isSerialTransmitBufferEmpty(blackboxPort);
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
// Nothing to speed up flushing on serial, as serial is continuously being drained out of its buffer
|
||||
return isSerialTransmitBufferEmpty(blackboxPort);
|
||||
|
||||
#ifdef USE_FLASHFS
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
return flashfsFlushAsync();
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
return flashfsFlushAsync();
|
||||
#endif
|
||||
|
||||
#ifdef USE_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
|
||||
* if it's done yet or not!
|
||||
*/
|
||||
return afatfs_flush();
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
/* 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!
|
||||
*/
|
||||
return afatfs_flush();
|
||||
#endif
|
||||
|
||||
default:
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -544,71 +544,71 @@ bool blackboxDeviceFlushForce(void)
|
|||
bool blackboxDeviceOpen(void)
|
||||
{
|
||||
switch (blackboxConfig()->device) {
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
{
|
||||
serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX);
|
||||
baudRate_e baudRateIndex;
|
||||
portOptions_t portOptions = SERIAL_PARITY_NO | SERIAL_NOT_INVERTED;
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
{
|
||||
serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX);
|
||||
baudRate_e baudRateIndex;
|
||||
portOptions_t portOptions = SERIAL_PARITY_NO | SERIAL_NOT_INVERTED;
|
||||
|
||||
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()) {
|
||||
if (!portConfig) {
|
||||
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;
|
||||
#endif
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_FATAL || afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_UNKNOWN || afatfs_isFull()) {
|
||||
return false;
|
||||
}
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_FATAL || afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_UNKNOWN || afatfs_isFull()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
|
||||
blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
|
||||
|
||||
return true;
|
||||
return true;
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -653,21 +653,21 @@ bool isBlackboxErased(void)
|
|||
void blackboxDeviceClose(void)
|
||||
{
|
||||
switch (blackboxConfig()->device) {
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
// Since the serial port could be shared with other processes, we have to give it back here
|
||||
closeSerialPort(blackboxPort);
|
||||
blackboxPort = NULL;
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
// Since the serial port could be shared with other processes, we have to give it back here
|
||||
closeSerialPort(blackboxPort);
|
||||
blackboxPort = NULL;
|
||||
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
if (blackboxPortSharing == PORTSHARING_SHARED) {
|
||||
mspSerialAllocatePorts();
|
||||
}
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
if (blackboxPortSharing == PORTSHARING_SHARED) {
|
||||
mspSerialAllocatePorts();
|
||||
}
|
||||
break;
|
||||
default:
|
||||
;
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -728,59 +728,59 @@ static bool blackboxSDCardBeginLog()
|
|||
|
||||
doMore:
|
||||
switch (blackboxSDCard.state) {
|
||||
case BLACKBOX_SDCARD_INITIAL:
|
||||
if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY) {
|
||||
blackboxSDCard.state = BLACKBOX_SDCARD_WAITING;
|
||||
case BLACKBOX_SDCARD_INITIAL:
|
||||
if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY) {
|
||||
blackboxSDCard.state = BLACKBOX_SDCARD_WAITING;
|
||||
|
||||
afatfs_mkdir("logs", blackboxLogDirCreated);
|
||||
}
|
||||
break;
|
||||
afatfs_mkdir("logs", blackboxLogDirCreated);
|
||||
}
|
||||
break;
|
||||
|
||||
case BLACKBOX_SDCARD_WAITING:
|
||||
// Waiting for directory entry to be created
|
||||
break;
|
||||
case BLACKBOX_SDCARD_WAITING:
|
||||
// Waiting for directory entry to be created
|
||||
break;
|
||||
|
||||
case BLACKBOX_SDCARD_ENUMERATE_FILES:
|
||||
while (afatfs_findNext(blackboxSDCard.logDirectory, &blackboxSDCard.logDirectoryFinder, &directoryEntry) == AFATFS_OPERATION_SUCCESS) {
|
||||
if (directoryEntry && !fat_isDirectoryEntryTerminator(directoryEntry)) {
|
||||
// If this is a log file, parse the log number from the filename
|
||||
if (strncmp(directoryEntry->filename, LOGFILE_PREFIX, strlen(LOGFILE_PREFIX)) == 0
|
||||
&& strncmp(directoryEntry->filename + 8, LOGFILE_SUFFIX, strlen(LOGFILE_SUFFIX)) == 0) {
|
||||
char logSequenceNumberString[6];
|
||||
case BLACKBOX_SDCARD_ENUMERATE_FILES:
|
||||
while (afatfs_findNext(blackboxSDCard.logDirectory, &blackboxSDCard.logDirectoryFinder, &directoryEntry) == AFATFS_OPERATION_SUCCESS) {
|
||||
if (directoryEntry && !fat_isDirectoryEntryTerminator(directoryEntry)) {
|
||||
// If this is a log file, parse the log number from the filename
|
||||
if (strncmp(directoryEntry->filename, LOGFILE_PREFIX, strlen(LOGFILE_PREFIX)) == 0
|
||||
&& strncmp(directoryEntry->filename + 8, LOGFILE_SUFFIX, strlen(LOGFILE_SUFFIX)) == 0) {
|
||||
char logSequenceNumberString[6];
|
||||
|
||||
memcpy(logSequenceNumberString, directoryEntry->filename + 3, 5);
|
||||
logSequenceNumberString[5] = '\0';
|
||||
memcpy(logSequenceNumberString, directoryEntry->filename + 3, 5);
|
||||
logSequenceNumberString[5] = '\0';
|
||||
|
||||
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;
|
||||
blackboxSDCard.largestLogFileNumber = MAX((uint32_t) atoi(logSequenceNumberString), blackboxSDCard.largestLogFileNumber);
|
||||
}
|
||||
}
|
||||
break;
|
||||
} else {
|
||||
// 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:
|
||||
// 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;
|
||||
blackboxSDCard.state = BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY;
|
||||
goto doMore;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case BLACKBOX_SDCARD_READY_TO_CREATE_LOG:
|
||||
blackboxCreateLogFile();
|
||||
break;
|
||||
case 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;
|
||||
|
||||
case BLACKBOX_SDCARD_READY_TO_LOG:
|
||||
return true; // Log has been created!
|
||||
blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
|
||||
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
|
||||
|
|
@ -798,11 +798,11 @@ bool blackboxDeviceBeginLog(void)
|
|||
{
|
||||
switch (blackboxConfig()->device) {
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
return blackboxSDCardBeginLog();
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
return blackboxSDCardBeginLog();
|
||||
#endif
|
||||
default:
|
||||
return true;
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -822,42 +822,42 @@ bool blackboxDeviceEndLog(bool retainLog)
|
|||
|
||||
switch (blackboxConfig()->device) {
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
// Keep retrying until the close operation queues
|
||||
if (
|
||||
(retainLog && afatfs_fclose(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
|
||||
blackboxSDCard.logFile = NULL;
|
||||
blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
#endif
|
||||
default:
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
// Keep retrying until the close operation queues
|
||||
if (
|
||||
(retainLog && afatfs_fclose(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
|
||||
blackboxSDCard.logFile = NULL;
|
||||
blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
#endif
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool isBlackboxDeviceFull(void)
|
||||
{
|
||||
switch (blackboxConfig()->device) {
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
return false;
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
return false;
|
||||
|
||||
#ifdef USE_FLASHFS
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
return flashfsIsEOF();
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
return flashfsIsEOF();
|
||||
#endif
|
||||
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
return afatfs_isFull();
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
return afatfs_isFull();
|
||||
#endif
|
||||
|
||||
default:
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -870,21 +870,21 @@ void blackboxReplenishHeaderBudget()
|
|||
int32_t freeSpace;
|
||||
|
||||
switch (blackboxConfig()->device) {
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
freeSpace = serialTxBytesFree(blackboxPort);
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
freeSpace = serialTxBytesFree(blackboxPort);
|
||||
break;
|
||||
#ifdef USE_FLASHFS
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
freeSpace = flashfsGetWriteBufferFreeSpace();
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
freeSpace = flashfsGetWriteBufferFreeSpace();
|
||||
break;
|
||||
#endif
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
freeSpace = afatfs_getFreeBufferSpace();
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
freeSpace = afatfs_getFreeBufferSpace();
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
freeSpace = 0;
|
||||
default:
|
||||
freeSpace = 0;
|
||||
}
|
||||
|
||||
blackboxHeaderBudget = MIN(MIN(freeSpace, blackboxHeaderBudget + blackboxMaxHeaderBytesPerIteration), BLACKBOX_MAX_ACCUMULATED_HEADER_BUDGET);
|
||||
|
|
@ -916,43 +916,43 @@ blackboxBufferReserveStatus_e blackboxDeviceReserveBufferSpace(int32_t bytes)
|
|||
|
||||
// Handle failure:
|
||||
switch (blackboxConfig()->device) {
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
if (blackboxPort->txBufferSize && bytes > (int32_t) blackboxPort->txBufferSize - 1) {
|
||||
return BLACKBOX_RESERVE_PERMANENT_FAILURE;
|
||||
}
|
||||
case BLACKBOX_DEVICE_SERIAL:
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
if (blackboxPort->txBufferSize && bytes > (int32_t) blackboxPort->txBufferSize - 1) {
|
||||
return BLACKBOX_RESERVE_PERMANENT_FAILURE;
|
||||
}
|
||||
|
||||
return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
|
||||
return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
|
||||
|
||||
#ifdef USE_FLASHFS
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
if (bytes > (int32_t) flashfsGetWriteBufferSize()) {
|
||||
return BLACKBOX_RESERVE_PERMANENT_FAILURE;
|
||||
}
|
||||
case BLACKBOX_DEVICE_FLASH:
|
||||
if (bytes > (int32_t) flashfsGetWriteBufferSize()) {
|
||||
return BLACKBOX_RESERVE_PERMANENT_FAILURE;
|
||||
}
|
||||
|
||||
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
|
||||
* 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.
|
||||
*/
|
||||
flashfsFlushAsync();
|
||||
}
|
||||
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
|
||||
* 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.
|
||||
*/
|
||||
flashfsFlushAsync();
|
||||
}
|
||||
|
||||
return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
|
||||
return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
|
||||
#endif
|
||||
|
||||
#ifdef USE_SDCARD
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
// Assume that all writes will fit in the SDCard's buffers
|
||||
return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
|
||||
case BLACKBOX_DEVICE_SDCARD:
|
||||
// Assume that all writes will fit in the SDCard's buffers
|
||||
return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
|
||||
#endif
|
||||
|
||||
default:
|
||||
return BLACKBOX_RESERVE_PERMANENT_FAILURE;
|
||||
default:
|
||||
return BLACKBOX_RESERVE_PERMANENT_FAILURE;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue