blackbox: continue an SD log in a new file when it can't grow

docs/Blackbox.md

@@ -228,6 +228,11 @@ After downloading the log, be sure to erase the chip to make it ready for reuse
 
 If you try to start recording a new flight when the dataflash is already full, Blackbox logging will be disabled and nothing will be recorded.
 
+### Usage - Onboard SD card
+Logs are `LOGxxxxx.TXT` files on the card. The card's free space is kept in a file named `FREESPAC.E`; at every boot it grows again over the space freed since, so logs deleted on a PC make room again after the next power cycle.
+
+On targets with more than 512 KB of flash, a log that can't grow any further, because it reached 4 GB (the largest FAT32 file) or `FREESPAC.E` ran out while the card still has room, continues in a new file with its own header.
+
 ### Usage - Logging switch
 If you're recording to an onboard flash chip, you probably want to disable Blackbox recording when not required in order to save storage space. To do this, you can add a Blackbox flight mode to one of your AUX channels on the Configurator's modes tab. Once you've added a mode, Blackbox will only log flight data when the mode is active.
 

src/main/blackbox/blackbox.c

@@ -906,6 +906,13 @@ static bool testBlackboxCondition(FlightLogFieldCondition condition)
     return (blackboxConditionCache & position) != 0;
 }
 
+#if defined(USE_SDCARD) && defined(USE_BLACKBOX_SDCARD_SPLIT)
+// A new file after a split has no serial port to wait for
+static bool blackboxSplitting;
+#else
+#define blackboxSplitting false
+#endif
+
 static void blackboxSetState(BlackboxState newState)
 {
     //Perform initial setup required for the new state
@@ -930,6 +937,9 @@ static void blackboxSetState(BlackboxState newState)
         break;
     case BLACKBOX_STATE_RUNNING:
         blackboxSlowFrameIterationTimer = blackboxSInterval; //Force a slow frame to be written on the first iteration
+#if defined(USE_SDCARD) && defined(USE_BLACKBOX_SDCARD_SPLIT)
+        blackboxSplitting = false;
+#endif
         break;
     case BLACKBOX_STATE_SHUTTING_DOWN:
         xmitState.u.startTime = millis();
@@ -2329,10 +2339,34 @@ static void blackboxLogIteration(timeUs_t currentTimeUs)
     blackboxDeviceFlush();
 }
 
+#if defined(USE_SDCARD) && defined(USE_BLACKBOX_SDCARD_SPLIT)
+static void blackboxUpdateState(timeUs_t currentTimeUs);
+
+// Time per iteration a new file's header may take on top of the usual step
+#define BLACKBOX_SPLIT_HEADER_US 50
+
 /**
  * Call each flight loop iteration to perform blackbox logging.
  */
 void blackboxUpdate(timeUs_t currentTimeUs)
+{
+    blackboxUpdateState(currentTimeUs);
+
+    // Every iteration spent on the new file's header is a gap in the log, so send it several steps at a time
+    const timeUs_t startUs = micros();
+    while (blackboxSplitting && blackboxState >= BLACKBOX_FIRST_HEADER_SENDING_STATE && blackboxState <= BLACKBOX_LAST_HEADER_SENDING_STATE
+        && cmpTimeUs(micros(), startUs) < BLACKBOX_SPLIT_HEADER_US && blackboxDeviceHasRoomToSpare()) {
+        blackboxUpdateState(currentTimeUs);
+    }
+}
+
+static void blackboxUpdateState(timeUs_t currentTimeUs)
+#else
+/**
+ * Call each flight loop iteration to perform blackbox logging.
+ */
+void blackboxUpdate(timeUs_t currentTimeUs)
+#endif
 {
 #ifdef USE_TERRAIN
     if(blackboxConfig()->device == BLACKBOX_DEVICE_SDCARD){
@@ -2370,7 +2404,7 @@ void blackboxUpdate(timeUs_t currentTimeUs)
          * 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.
          */
-        if (millis() > xmitState.u.startTime + 100) {
+        if (blackboxSplitting || millis() > xmitState.u.startTime + 100) {
             if (blackboxDeviceReserveBufferSpace(BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION) == BLACKBOX_RESERVE_SUCCESS) {
                 for (int i = 0; i < BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION && blackboxHeader[xmitState.headerIndex] != '\0'; i++, xmitState.headerIndex++) {
                     blackboxWrite(blackboxHeader[xmitState.headerIndex]);
@@ -2477,6 +2511,14 @@ void blackboxUpdate(timeUs_t currentTimeUs)
         break;
     }
 
+#if defined(USE_SDCARD) && defined(USE_BLACKBOX_SDCARD_SPLIT)
+    // Can't grow but the card has room: close the log, it goes on in a new file
+    if ((blackboxState == BLACKBOX_STATE_RUNNING || blackboxState == BLACKBOX_STATE_PAUSED) && blackboxDeviceNeedsNewLog()) {
+        blackboxSplitting = true;
+        blackboxSetState(BLACKBOX_STATE_SHUTTING_DOWN);
+    }
+#endif
+
     // Did we run out of room on the device? Stop!
     if (isBlackboxDeviceFull()) {
         blackboxSetState(BLACKBOX_STATE_STOPPED);

src/main/blackbox/blackbox_io.c

@@ -291,7 +291,7 @@ bool blackboxDeviceOpen(void)
 #endif
 #ifdef USE_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 || isBlackboxDeviceFull()) {
             return false;
         }
 
@@ -432,7 +432,13 @@ static bool blackboxSDCardBeginLog(void)
     doMore:
     switch (blackboxSDCard.state) {
     case BLACKBOX_SDCARD_INITIAL:
+#ifdef USE_BLACKBOX_SDCARD_SPLIT
+        // A new file waits until the freefile has room for its first supercluster, unless no room can
+        // come: then it opens as without the option and the full card stops the log
+        if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY && (afatfs_freeFileHasRoom() || !afatfs_freeFileCanContinue())) {
+#else
         if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY) {
+#endif
             blackboxSDCard.state = BLACKBOX_SDCARD_WAITING;
 
             if(afatfs_isCurrentDirRoot()){
@@ -579,8 +585,13 @@ bool isBlackboxDeviceFull(void)
 
 #ifdef USE_SDCARD
     case BLACKBOX_DEVICE_SDCARD:
+#ifdef USE_BLACKBOX_SDCARD_SPLIT
+        // Only full once no new file can get room either
+        return afatfs_isFull() && !afatfs_freeFileCanContinue();
+#else
         return afatfs_isFull();
 #endif
+#endif
 
 #if defined (SITL_BUILD)
     case BLACKBOX_DEVICE_FILE:
@@ -592,6 +603,23 @@ bool isBlackboxDeviceFull(void)
     }
 }
 
+#if defined(USE_SDCARD) && defined(USE_BLACKBOX_SDCARD_SPLIT)
+// The log file can't grow but the card has room for a new one
+bool blackboxDeviceNeedsNewLog(void)
+{
+    return blackboxConfig()->device == BLACKBOX_DEVICE_SDCARD && afatfs_isFull() && afatfs_freeFileCanContinue();
+}
+
+// Below this free cache space a new file's header goes back to one step per iteration: afatfs
+// counts the sectors it keeps for open files as free
+#define BLACKBOX_SDCARD_SPARE_BYTES 2048
+
+bool blackboxDeviceHasRoomToSpare(void)
+{
+    return afatfs_getFreeBufferSpace() >= BLACKBOX_SDCARD_SPARE_BYTES;
+}
+#endif
+
 bool isBlackboxDeviceWorking(void)
 {
     switch (blackboxConfig()->device) {

src/main/blackbox/blackbox_io.h

@@ -70,6 +70,10 @@ bool blackboxDeviceBeginLog(void);
 bool blackboxDeviceEndLog(bool retainLog);
 
 bool isBlackboxDeviceFull(void);
+#if defined(USE_SDCARD) && defined(USE_BLACKBOX_SDCARD_SPLIT)
+bool blackboxDeviceNeedsNewLog(void);
+bool blackboxDeviceHasRoomToSpare(void);
+#endif
 bool isBlackboxDeviceWorking(void);
 int32_t blackboxGetLogNumber(void);