src/main/blackbox/blackbox_io.c

   1 /*
   2  * This file is part of Cleanflight.
   3  *
   4  * Cleanflight is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * Cleanflight is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with Cleanflight.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <stdlib.h>
  19 #include <stdarg.h>
  20 #include <string.h>
  21
  22 #if defined(SITL_BUILD)
  23 #include <stdio.h>
  24 #include <time.h>
  25 #endif
  26
  27 #include "platform.h"
  28
  29 #ifdef USE_BLACKBOX
  30
  31 #include "blackbox.h"
  32 #include "blackbox_io.h"
  33
  34 #include "common/axis.h"
  35 #include "common/encoding.h"
  36 #include "common/maths.h"
  37 #include "common/printf.h"
  38 #include "common/typeconversion.h"
  39
  40 #include "config/parameter_group.h"
  41 #include "config/parameter_group_ids.h"
  42
  43 #ifdef USE_SDCARD
  44 #include "drivers/sdcard/sdcard.h"
  45 #endif
  46
  47 #include "io/asyncfatfs/asyncfatfs.h"
  48 #include "io/flashfs.h"
  49 #include "io/serial.h"
  50
  51 #include "msp/msp_serial.h"
  52
  53 #include "sensors/gyro.h"
  54 #include "fc/config.h"
  55
  56 #define BLACKBOX_SERIAL_PORT_MODE MODE_TX
  57
  58 // How many bytes can we transmit per loop iteration when writing headers?
  59 static uint8_t blackboxMaxHeaderBytesPerIteration;
  60
  61 // How many bytes can we write *this* iteration without overflowing transmit buffers or overstressing the OpenLog?
  62 int32_t blackboxHeaderBudget;
  63
  64 STATIC_UNIT_TESTED serialPort_t *blackboxPort = NULL;
  65 #ifndef UNIT_TEST
  66 static portSharing_e blackboxPortSharing;
  67 #endif // UNIT_TEST
  68
  69 #ifdef USE_SDCARD
  70
  71 static struct {
  72     afatfsFilePtr_t logFile;
  73     afatfsFilePtr_t logDirectory;
  74     afatfsFinder_t logDirectoryFinder;
  75     uint32_t largestLogFileNumber;
  76
  77     enum {
  78         BLACKBOX_SDCARD_INITIAL,
  79         BLACKBOX_SDCARD_WAITING,
  80         BLACKBOX_SDCARD_ENUMERATE_FILES,
  81         BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY,
  82         BLACKBOX_SDCARD_READY_TO_CREATE_LOG,
  83         BLACKBOX_SDCARD_READY_TO_LOG
  84     } state;
  85 } blackboxSDCard;
  86
  87 #endif
  88
  89 #if defined(SITL_BUILD)
  90 static struct {
  91     FILE *file_handler;
  92 } blackboxFile;
  93 #endif
  94
  95 #ifndef UNIT_TEST
  96 void blackboxOpen(void)
  97 {
  98     serialPort_t *sharedBlackboxAndMspPort = findSharedSerialPort(FUNCTION_BLACKBOX, FUNCTION_MSP);
  99     if (sharedBlackboxAndMspPort) {
 100         mspSerialReleasePortIfAllocated(sharedBlackboxAndMspPort);
 101     }
 102 }
 103 #endif // UNIT_TEST
 104
 105 void blackboxWrite(uint8_t value)
 106 {
 107     switch (blackboxConfig()->device) {
 108 #ifdef USE_FLASHFS
 109     case BLACKBOX_DEVICE_FLASH:
 110         flashfsWriteByte(value); // Write byte asynchronously
 111         break;
 112 #endif
 113 #ifdef USE_SDCARD
 114     case BLACKBOX_DEVICE_SDCARD:
 115         afatfs_fputc(blackboxSDCard.logFile, value);
 116         break;
 117 #endif
 118 #if defined(SITL_BUILD)
 119     case BLACKBOX_DEVICE_FILE:
 120         fputc(value, blackboxFile.file_handler);
 121         break;
 122 #endif
 123     case BLACKBOX_DEVICE_SERIAL:
 124     default:
 125         serialWrite(blackboxPort, value);
 126         break;
 127     }
 128 }
 129
 130 // Print the null-terminated string 's' to the blackbox device and return the number of bytes written
 131 int blackboxPrint(const char *s)
 132 {
 133     int length;
 134     const uint8_t *pos;
 135
 136     switch (blackboxConfig()->device) {
 137
 138 #ifdef USE_FLASHFS
 139     case BLACKBOX_DEVICE_FLASH:
 140         length = strlen(s);
 141         flashfsWrite((const uint8_t*) s, length, false); // Write asynchronously
 142         break;
 143 #endif
 144
 145 #ifdef USE_SDCARD
 146     case BLACKBOX_DEVICE_SDCARD:
 147         length = strlen(s);
 148         afatfs_fwrite(blackboxSDCard.logFile, (const uint8_t*) s, length); // Ignore failures due to buffers filling up
 149         break;
 150 #endif
 151
 152 #if defined(SITL_BUILD)
 153     case BLACKBOX_DEVICE_FILE:
 154         length = strlen(s);
 155         fputs(s, blackboxFile.file_handler);
 156         break;
 157 #endif
 158
 159     case BLACKBOX_DEVICE_SERIAL:
 160     default:
 161         pos = (uint8_t*) s;
 162         while (*pos) {
 163             serialWrite(blackboxPort, *pos);
 164             pos++;
 165         }
 166
 167         length = pos - (uint8_t*) s;
 168         break;
 169     }
 170
 171     return length;
 172 }
 173
 174 /**
 175  * If there is data waiting to be written to the blackbox device, attempt to write (a portion of) that now.
 176  *
 177  * Intended to be called regularly for the blackbox device to perform housekeeping.
 178  */
 179 void blackboxDeviceFlush(void)
 180 {
 181     switch (blackboxConfig()->device) {
 182 #ifdef USE_FLASHFS
 183         /*
 184          * This is our only output device which requires us to call flush() in order for it to write anything. The other
 185          * devices will progressively write in the background without Blackbox calling anything.
 186          */
 187     case BLACKBOX_DEVICE_FLASH:
 188         flashfsFlushAsync();
 189         break;
 190 #endif
 191
 192     default:
 193         ;
 194     }
 195 }
 196
 197 /**
 198  * If there is data waiting to be written to the blackbox device, attempt to write (a portion of) that now.
 199  *
 200  * Returns true if all data has been written to the device.
 201  */
 202 bool blackboxDeviceFlushForce(void)
 203 {
 204     switch (blackboxConfig()->device) {
 205     case BLACKBOX_DEVICE_SERIAL:
 206         // Nothing to speed up flushing on serial, as serial is continuously being drained out of its buffer
 207         return isSerialTransmitBufferEmpty(blackboxPort);
 208
 209 #ifdef USE_FLASHFS
 210     case BLACKBOX_DEVICE_FLASH:
 211         return flashfsFlushAsync();
 212 #endif
 213
 214 #ifdef USE_SDCARD
 215     case BLACKBOX_DEVICE_SDCARD:
 216         /* SD card will flush itself without us calling it, but we need to call flush manually in order to check
 217          * if it's done yet or not!
 218          */
 219         return afatfs_flush();
 220 #endif
 221
 222 #if defined(SITL_BUILD)
 223     case BLACKBOX_DEVICE_FILE:
 224         fflush(blackboxFile.file_handler);
 225         return true;
 226 #endif
 227
 228     default:
 229         return false;
 230     }
 231 }
 232
 233 /**
 234  * Attempt to open the logging device. Returns true if successful.
 235  */
 236 #ifndef UNIT_TEST
 237 bool blackboxDeviceOpen(void)
 238 {
 239     switch (blackboxConfig()->device) {
 240     case BLACKBOX_DEVICE_SERIAL:
 241         {
 242             serialPortConfig_t *portConfig = findSerialPortConfig(FUNCTION_BLACKBOX);
 243             baudRate_e baudRateIndex;
 244             portOptions_t portOptions = SERIAL_PARITY_NO | SERIAL_NOT_INVERTED;
 245
 246             if (!portConfig) {
 247                 return false;
 248             }
 249
 250             blackboxPortSharing = determinePortSharing(portConfig, FUNCTION_BLACKBOX);
 251             baudRateIndex = portConfig->peripheral_baudrateIndex;
 252
 253             if (baudRates[baudRateIndex] == 230400) {
 254                 /*
 255                  * OpenLog's 230400 baud rate is very inaccurate, so it requires a larger inter-character gap in
 256                  * order to maintain synchronization.
 257                  */
 258                 portOptions |= SERIAL_STOPBITS_2;
 259             } else {
 260                 portOptions |= SERIAL_STOPBITS_1;
 261             }
 262
 263             blackboxPort = openSerialPort(portConfig->identifier, FUNCTION_BLACKBOX, NULL, NULL, baudRates[baudRateIndex],
 264                 BLACKBOX_SERIAL_PORT_MODE, portOptions);
 265
 266             /*
 267              * The slowest MicroSD cards have a write latency approaching 150ms. The OpenLog's buffer is about 900
 268              * bytes. In order for its buffer to be able to absorb this latency we must write slower than 6000 B/s.
 269              *
 270              * So:
 271              *     Bytes per loop iteration = floor((looptime_ns / 1000000.0) * 6000)
 272              *                              = floor((looptime_ns * 6000) / 1000000.0)
 273              *                              = floor((looptime_ns * 3) / 500.0)
 274              *                              = (looptime_ns * 3) / 500
 275              */
 276             blackboxMaxHeaderBytesPerIteration = constrain((getLooptime() * 3) / 500, 1, BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION);
 277
 278             return blackboxPort != NULL;
 279         }
 280         break;
 281 #ifdef USE_FLASHFS
 282     case BLACKBOX_DEVICE_FLASH:
 283         if (flashfsGetSize() == 0 || isBlackboxDeviceFull()) {
 284             return false;
 285         }
 286
 287         blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
 288
 289         return true;
 290         break;
 291 #endif
 292 #ifdef USE_SDCARD
 293     case BLACKBOX_DEVICE_SDCARD:
 294         if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_FATAL || afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_UNKNOWN || afatfs_isFull()) {
 295             return false;
 296         }
 297
 298         blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
 299
 300         return true;
 301         break;
 302 #endif
 303 #if defined(SITL_BUILD)
 304     case BLACKBOX_DEVICE_FILE:
 305         {
 306             const time_t now = time(NULL);
 307             const struct tm *t = localtime(&now);
 308             char filename[32];
 309             strftime(filename, sizeof(filename), "%Y_%m_%d_%H%M%S.TXT", t);
 310
 311             blackboxFile.file_handler = fopen(filename, "wb");
 312             if (blackboxFile.file_handler == NULL) {
 313                 fprintf(stderr, "[BlackBox] Failed to create log file\n");
 314                 return false;
 315             }
 316             fprintf(stderr, "[BlackBox] Created %s\n", filename);
 317         }
 318
 319         blackboxMaxHeaderBytesPerIteration = BLACKBOX_TARGET_HEADER_BUDGET_PER_ITERATION;
 320         return true;
 321         break;
 322 #endif
 323     default:
 324         return false;
 325     }
 326 }
 327 #endif // UNIT_TEST
 328
 329 /**
 330  * Close the Blackbox logging device immediately without attempting to flush any remaining data.
 331  */
 332 #ifndef UNIT_TEST
 333 void blackboxDeviceClose(void)
 334 {
 335     switch (blackboxConfig()->device) {
 336     case BLACKBOX_DEVICE_SERIAL:
 337         // Since the serial port could be shared with other processes, we have to give it back here
 338         closeSerialPort(blackboxPort);
 339         blackboxPort = NULL;
 340
 341         /*
 342          * Normally this would be handled by mw.c, but since we take an unknown amount
 343          * of time to shut down asynchronously, we're the only ones that know when to call it.
 344          */
 345         if (blackboxPortSharing == PORTSHARING_SHARED) {
 346             mspSerialAllocatePorts();
 347         }
 348         break;
 349 #ifdef USE_FLASHFS
 350     case BLACKBOX_DEVICE_FLASH:
 351         // Some flash device, e.g., NAND devices, require explicit close to flush internally buffered data.
 352         flashfsClose();
 353         break;
 354 #endif
 355 #if defined(SITL_BUILD)
 356     case BLACKBOX_DEVICE_FILE:
 357         fclose(blackboxFile.file_handler);
 358         break;
 359 #endif
 360     default:
 361         ;
 362     }
 363 }
 364 #endif // UNIT_TEST
 365
 366 #ifdef USE_SDCARD
 367
 368 static void blackboxLogDirCreated(afatfsFilePtr_t directory)
 369 {
 370     if (directory) {
 371         blackboxSDCard.logDirectory = directory;
 372
 373         afatfs_findFirst(blackboxSDCard.logDirectory, &blackboxSDCard.logDirectoryFinder);
 374
 375         blackboxSDCard.state = BLACKBOX_SDCARD_ENUMERATE_FILES;
 376     } else {
 377         // Retry
 378         blackboxSDCard.state = BLACKBOX_SDCARD_INITIAL;
 379     }
 380 }
 381
 382 static void blackboxLogFileCreated(afatfsFilePtr_t file)
 383 {
 384     if (file) {
 385         blackboxSDCard.logFile = file;
 386
 387         blackboxSDCard.largestLogFileNumber++;
 388
 389         blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_LOG;
 390     } else {
 391         // Retry
 392         blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
 393     }
 394 }
 395
 396 static void blackboxCreateLogFile(void)
 397 {
 398     uint32_t remainder = blackboxSDCard.largestLogFileNumber + 1;
 399
 400     char filename[13];
 401
 402     filename[0] = 'L';
 403     filename[1] = 'O';
 404     filename[2] = 'G';
 405
 406     for (int i = 7; i >= 3; i--) {
 407         filename[i] = (remainder % 10) + '0';
 408         remainder /= 10;
 409     }
 410
 411     filename[8] = '.';
 412     filename[9] = 'T';
 413     filename[10] = 'X';
 414     filename[11] = 'T';
 415     filename[12] = 0;
 416
 417     blackboxSDCard.state = BLACKBOX_SDCARD_WAITING;
 418
 419     afatfs_fopen(filename, "as", blackboxLogFileCreated);
 420 }
 421
 422 /**
 423  * Begin a new log on the SDCard.
 424  *
 425  * Keep calling until the function returns true (open is complete).
 426  */
 427 static bool blackboxSDCardBeginLog(void)
 428 {
 429     fatDirectoryEntry_t *directoryEntry;
 430
 431     doMore:
 432     switch (blackboxSDCard.state) {
 433     case BLACKBOX_SDCARD_INITIAL:
 434         if (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY) {
 435             blackboxSDCard.state = BLACKBOX_SDCARD_WAITING;
 436
 437             afatfs_mkdir("logs", blackboxLogDirCreated);
 438         }
 439         break;
 440
 441     case BLACKBOX_SDCARD_WAITING:
 442         // Waiting for directory entry to be created
 443         break;
 444
 445     case BLACKBOX_SDCARD_ENUMERATE_FILES:
 446         while (afatfs_findNext(blackboxSDCard.logDirectory, &blackboxSDCard.logDirectoryFinder, &directoryEntry) == AFATFS_OPERATION_SUCCESS) {
 447             if (directoryEntry && !fat_isDirectoryEntryTerminator(directoryEntry)) {
 448                 // If this is a log file, parse the log number from the filename
 449                 if (
 450                     directoryEntry->filename[0] == 'L' && directoryEntry->filename[1] == 'O' && directoryEntry->filename[2] == 'G'
 451                     && directoryEntry->filename[8] == 'T' && directoryEntry->filename[9] == 'X' && directoryEntry->filename[10] == 'T'
 452                 ) {
 453                     char logSequenceNumberString[6];
 454
 455                     memcpy(logSequenceNumberString, directoryEntry->filename + 3, 5);
 456                     logSequenceNumberString[5] = '\0';
 457
 458                     blackboxSDCard.largestLogFileNumber = MAX((uint32_t) fastA2I(logSequenceNumberString), blackboxSDCard.largestLogFileNumber);
 459                 }
 460             } else {
 461                 // We're done checking all the files on the card, now we can create a new log file
 462                 afatfs_findLast(blackboxSDCard.logDirectory);
 463
 464                 blackboxSDCard.state = BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY;
 465                 goto doMore;
 466             }
 467         }
 468         break;
 469
 470     case BLACKBOX_SDCARD_CHANGE_INTO_LOG_DIRECTORY:
 471         // Change into the log directory:
 472         if (afatfs_chdir(blackboxSDCard.logDirectory)) {
 473             // We no longer need our open handle on the log directory
 474             afatfs_fclose(blackboxSDCard.logDirectory, NULL);
 475             blackboxSDCard.logDirectory = NULL;
 476
 477             blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
 478             goto doMore;
 479         }
 480         break;
 481
 482     case BLACKBOX_SDCARD_READY_TO_CREATE_LOG:
 483         blackboxCreateLogFile();
 484         break;
 485
 486     case BLACKBOX_SDCARD_READY_TO_LOG:
 487         return true; // Log has been created!
 488     }
 489
 490     // Not finished init yet
 491     return false;
 492 }
 493
 494 #endif
 495
 496 /**
 497  * Begin a new log (for devices which support separations between the logs of multiple flights).
 498  *
 499  * Keep calling until the function returns true (open is complete).
 500  */
 501 bool blackboxDeviceBeginLog(void)
 502 {
 503     switch (blackboxConfig()->device) {
 504 #ifdef USE_SDCARD
 505     case BLACKBOX_DEVICE_SDCARD:
 506         return blackboxSDCardBeginLog();
 507 #endif
 508     default:
 509         return true;
 510     }
 511
 512 }
 513
 514 /**
 515  * Terminate the current log (for devices which support separations between the logs of multiple flights).
 516  *
 517  * retainLog - Pass true if the log should be kept, or false if the log should be discarded (if supported).
 518  *
 519  * Keep calling until this returns true
 520  */
 521 bool blackboxDeviceEndLog(bool retainLog)
 522 {
 523 #ifndef USE_SDCARD
 524     (void) retainLog;
 525 #endif
 526
 527     switch (blackboxConfig()->device) {
 528 #ifdef USE_SDCARD
 529     case BLACKBOX_DEVICE_SDCARD:
 530         // Keep retrying until the close operation queues
 531         if (
 532             (retainLog && afatfs_fclose(blackboxSDCard.logFile, NULL))
 533             || (!retainLog && afatfs_funlink(blackboxSDCard.logFile, NULL))
 534         ) {
 535             // Don't bother waiting the for the close to complete, it's queued now and will complete eventually
 536             blackboxSDCard.logFile = NULL;
 537             blackboxSDCard.state = BLACKBOX_SDCARD_READY_TO_CREATE_LOG;
 538             return true;
 539         }
 540         return false;
 541 #endif
 542     default:
 543         return true;
 544     }
 545 }
 546
 547 bool isBlackboxDeviceFull(void)
 548 {
 549     switch (blackboxConfig()->device) {
 550     case BLACKBOX_DEVICE_SERIAL:
 551         return false;
 552
 553 #ifdef USE_FLASHFS
 554     case BLACKBOX_DEVICE_FLASH:
 555         return flashfsIsEOF();
 556 #endif
 557
 558 #ifdef USE_SDCARD
 559     case BLACKBOX_DEVICE_SDCARD:
 560         return afatfs_isFull();
 561 #endif
 562
 563 #if defined (SITL_BUILD)
 564     case BLACKBOX_DEVICE_FILE:
 565         return false;
 566 #endif
 567
 568     default:
 569         return false;
 570     }
 571 }
 572
 573 bool isBlackboxDeviceWorking(void)
 574 {
 575     switch (blackboxConfig()->device) {
 576         case BLACKBOX_DEVICE_SERIAL:
 577             return blackboxPort != NULL;
 578 #ifdef USE_SDCARD
 579         case BLACKBOX_DEVICE_SDCARD:
 580             return sdcard_isInserted() && sdcard_isFunctional() && (afatfs_getFilesystemState() == AFATFS_FILESYSTEM_STATE_READY);
 581 #endif
 582 #ifdef USE_FLASHFS
 583         case BLACKBOX_DEVICE_FLASH:
 584             return flashfsIsReady();
 585 #endif
 586     default:
 587         return false;
 588     }
 589 }
 590
 591 int32_t blackboxGetLogNumber(void)
 592 {
 593     switch (blackboxConfig()->device) {
 594 #ifdef USE_SDCARD
 595         case BLACKBOX_DEVICE_SDCARD:
 596             return blackboxSDCard.largestLogFileNumber;
 597 #endif
 598         default:
 599             return -1;
 600     }
 601 }
 602
 603 /**
 604  * Call once every loop iteration in order to maintain the global blackboxHeaderBudget with the number of bytes we can
 605  * transmit this iteration.
 606  */
 607 void blackboxReplenishHeaderBudget(void)
 608 {
 609     int32_t freeSpace;
 610
 611     switch (blackboxConfig()->device) {
 612     case BLACKBOX_DEVICE_SERIAL:
 613         freeSpace = serialTxBytesFree(blackboxPort);
 614         break;
 615 #ifdef USE_FLASHFS
 616     case BLACKBOX_DEVICE_FLASH:
 617         freeSpace = flashfsGetWriteBufferFreeSpace();
 618         break;
 619 #endif
 620 #ifdef USE_SDCARD
 621     case BLACKBOX_DEVICE_SDCARD:
 622         freeSpace = afatfs_getFreeBufferSpace();
 623         break;
 624 #endif
 625 #if defined(SITL_BUILD)
 626     case BLACKBOX_DEVICE_FILE:
 627         freeSpace = BLACKBOX_MAX_ACCUMULATED_HEADER_BUDGET;
 628         break;
 629 #endif
 630     default:
 631         freeSpace = 0;
 632     }
 633
 634     blackboxHeaderBudget = MIN(MIN(freeSpace, blackboxHeaderBudget + blackboxMaxHeaderBytesPerIteration), BLACKBOX_MAX_ACCUMULATED_HEADER_BUDGET);
 635 }
 636
 637 /**
 638  * You must call this function before attempting to write Blackbox header bytes to ensure that the write will not
 639  * cause buffers to overflow. The number of bytes you can write is capped by the blackboxHeaderBudget. Calling this
 640  * reservation function doesn't decrease blackboxHeaderBudget, so you must manually decrement that variable by the
 641  * number of bytes you actually wrote.
 642  *
 643  * When the Blackbox device is FlashFS, a successful return code guarantees that no data will be lost if you write that
 644  * many bytes to the device (i.e. FlashFS's buffers won't overflow).
 645  *
 646  * When the device is a serial port, a successful return code guarantees that Cleanflight's serial Tx buffer will not
 647  * overflow, and the outgoing bandwidth is likely to be small enough to give the OpenLog time to absorb MicroSD card
 648  * latency. However the OpenLog could still end up silently dropping data.
 649  *
 650  * Returns:
 651  *  BLACKBOX_RESERVE_SUCCESS - Upon success
 652  *  BLACKBOX_RESERVE_TEMPORARY_FAILURE - The buffer is currently too full to service the request, try again later
 653  *  BLACKBOX_RESERVE_PERMANENT_FAILURE - The buffer is too small to ever service this request
 654  */
 655 blackboxBufferReserveStatus_e blackboxDeviceReserveBufferSpace(int32_t bytes)
 656 {
 657     if (bytes <= blackboxHeaderBudget) {
 658         return BLACKBOX_RESERVE_SUCCESS;
 659     }
 660
 661     // Handle failure:
 662     switch (blackboxConfig()->device) {
 663     case BLACKBOX_DEVICE_SERIAL:
 664         /*
 665          * One byte of the tx buffer isn't available for user data (due to its circular list implementation),
 666          * hence the -1. Note that the USB VCP implementation doesn't use a buffer and has txBufferSize set to zero.
 667          */
 668         if (blackboxPort->txBufferSize && bytes > (int32_t) blackboxPort->txBufferSize - 1) {
 669             return BLACKBOX_RESERVE_PERMANENT_FAILURE;
 670         }
 671
 672         return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
 673
 674 #ifdef USE_FLASHFS
 675     case BLACKBOX_DEVICE_FLASH:
 676         if (bytes > (int32_t) flashfsGetWriteBufferSize()) {
 677             return BLACKBOX_RESERVE_PERMANENT_FAILURE;
 678         }
 679
 680         if (bytes > (int32_t) flashfsGetWriteBufferFreeSpace()) {
 681             /*
 682              * The write doesn't currently fit in the buffer, so try to make room for it. Our flushing here means
 683              * that the Blackbox header writing code doesn't have to guess about the best time to ask flashfs to
 684              * flush, and doesn't stall waiting for a flush that would otherwise not automatically be called.
 685              */
 686             flashfsFlushAsync();
 687         }
 688
 689         return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
 690 #endif
 691
 692 #ifdef USE_SDCARD
 693     case BLACKBOX_DEVICE_SDCARD:
 694         // Assume that all writes will fit in the SDCard's buffers
 695         return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
 696 #endif
 697
 698 #if defined(SITL_BUILD)
 699     case BLACKBOX_DEVICE_FILE:
 700         // Assume that all writes will fit in the file's buffers
 701         return BLACKBOX_RESERVE_TEMPORARY_FAILURE;
 702 #endif
 703
 704     default:
 705         return BLACKBOX_RESERVE_PERMANENT_FAILURE;
 706     }
 707 }
 708
 709 #endif