Adafruit Feather M0 Adalogger多传感器日志写入延迟问题求助

Alright, let's dig into those annoying periodic delays you're hitting with your Feather M0 Adalogger. 30-50ms hiccups at 30s and 37s are a killer for synchronized multi-sensor comparisons, so let's break down what's causing this and fix it step by step.

The Likely Culprits #

Your delay patterns align with two common SD card logging issues on microcontrollers:

1. Dynamic FAT Table Updates: When your log file grows past a certain size, the file system needs to update the FAT (File Allocation Table) to allocate new blocks. This is a blocking operation that causes sudden delays.
2. Frequent Small Writes: Using line-by-line println() for TXT files means you're writing tiny chunks of data (a few dozen bytes) every 10ms. The SD card has to erase and rewrite blocks repeatedly, and eventually, the cache fills up, forcing a full flush that takes longer than your sample interval.

Fixes to Eliminate Delays #

1. Switch to Binary Block-Based Logging (Biggest Impact)

Ditch human-readable TXT for binary data—this cuts down on string formatting overhead and lets you write data in chunks that match the SD card's 512-byte block size. Here's how to implement it:

First, define a struct to hold your sensor data (adjust types based on your sensors, e.g., uint16_t for 12-bit ADC readings):

struct SensorSample {
  uint32_t timestamp;       // 4 bytes (millis() value)
  uint16_t channelData[8];  // 16 bytes total for 8 channels
}; // 20 bytes per sample

Then, use a buffer to accumulate samples until you hit a full 512-byte block (25 samples × 20 bytes = 500 bytes; add padding if needed to hit 512):

SensorSample sampleBuffer[25];
int bufferPos = 0;
SdFile logFile;

void loop() {
  // Grab your sensor readings (replace with your actual read logic)
  sampleBuffer[bufferPos].timestamp = millis();
  for (int i = 0; i < 8; i++) {
    sampleBuffer[bufferPos].channelData[i] = analogRead(A0 + i); // Example ADC read
  }

  bufferPos++;

  // Write buffer to SD when full (aligns to SD block size)
  if (bufferPos >= 25) {
    fwrite(sampleBuffer, sizeof(SensorSample), 25, logFile);
    bufferPos = 0;
    // Skip fflush() unless you need instant persistence—it adds unnecessary delay
  }

  // Enforce 10ms sample interval (adjust if needed for sensor read time)
  static unsigned long lastSample = 0;
  while(millis() - lastSample < 10);
  lastSample = millis();
}

2. Pre-Allocate File Space (Fixes FAT Table Delays)

The delays at 30s/37s are almost certainly when the file size triggers a FAT table update. Pre-allocate all the space you need upfront so the file system doesn't have to modify the FAT mid-logging:

void setup() {
  // Initialize SD card (use full speed if your card supports it)
  if (!SD.begin(SD_CS)) {
    // Handle error
    while(1);
  }

  // Open or create your log file
  logFile = SD.open("sensor_data.bin", O_CREAT | O_WRITE);
  if (!logFile) {
    // Handle error
    while(1);
  }

  // Pre-allocate space: calculate total bytes needed (example: 1 hour of data)
  const uint32_t totalSamples = 100 * 60 * 60; // 100 samples/sec × 3600 sec
  const uint32_t totalFileSize = totalSamples * sizeof(SensorSample);

  // Move to the end of the pre-allocated space and write a dummy byte
  logFile.seek(totalFileSize - 1);
  logFile.write(0);
  // Jump back to the start to write actual data
  logFile.seek(0);
}

3. Optimize SD Library Settings

Tweak the SD library to use a 512-byte buffer (matching the SD card's block size) instead of the default smaller buffer. This reduces the number of SD card operations:

// Instead of using the simple SD.begin(), initialize with explicit buffer size
#include <SdFat.h>

SdFat sd;
SdFile logFile;
const int SD_CS = 4; // Adjust to your Feather's CS pin

void setup() {
  // Initialize with 512-byte buffer
  if (!sd.begin(SD_CS, SPI_FULL_SPEED, 512)) {
    // Fall back to half speed if full speed fails
    sd.begin(SD_CS, SPI_HALF_SPEED, 512);
  }

  // Rest of file setup...
}

4. Minimize Blocking Operations

• Avoid calling fflush(logFile) every sample—only flush when your buffer is full (or if you need to recover data after a power loss).
• Use non-blocking delay logic (as shown in the loop example) instead of delay(10) to ensure you don't waste extra time waiting for delays that aren't needed if sensor reads are faster.

Bonus: Verify Sensor Read Overhead #

Double-check that your sensor reading code isn't causing occasional delays. For ADC reads on the Feather M0, set the ADC to its fastest sampling rate:

void setupADC() {
  ADC->CTRLA.bit.ENABLE = 0; // Disable ADC to modify settings
  ADC->SAMPCTRL.reg = 0;     // Set minimum sample time (fastest)
  ADC->CTRLA.bit.ENABLE = 1; // Re-enable ADC
}

Final Notes #

The combination of binary block writing and file pre-allocation should eliminate those periodic delays entirely. If you still need human-readable data, you can post-process the binary file on a computer using a simple Python script to convert it to CSV/TXT.

内容的提问来源于stack exchange，提问作者João Mário Künzle