numerous compile errors for TeensyDmaAdcLogger.ino SdFat version 2.3.1

[rjsdotorg]

For Teensy 4.0 with Arduino IDE 2.3.7 and Teensduino 1.59

Ln 43 RingBuf<FsFile, RING_BUF_SIZE> rb;
Ln 57 rb.beginISR();

etc

What version of RingBuf is expected?

I do run this version just fine lib/SdFat-2.2.0/examples/TeensyDmaAdcLogger/TeensyDmaAdcLogger.ino

which is what is delivered with the IDE.

[greiman]

If there is a problem with Teensy DMA ADC, please post on the Teensy forum. I didn't write the DMA code.

I will probably be removing this example.

[rjsdotorg]

The problem was lib versions, I had a version before 57900b2 (no beginISR) which was packaged with Arduino IDE I assume. I don't know of a way to differentiate libs on Arduino at compile time...

Try this mod of your example before deleting, which runs on my Teensy 4.0 boards:

#/***************************************************************
 * @file main.cpp
 * @brief Teensy exFAT DMA ADC logger example with RingBuf.
 *
 * This sketch demonstrates using ADC + DMA to capture samples into
 * a ping-pong buffer and persist 512-byte sectors to an exFAT file
 * via SdFs using a `RingBuf` as the bridge between ISR and main loop.
 *
 * Key behaviours:
 * - Minimal ISR: cache maintenance, safe calls to `rb.write()` within
 *   `rb.beginISR()`/`rb.endISR()`.
 * - Ping-pong DMA buffer in DMAMEM, 32-byte aligned.
 * - Pre-allocated file space to avoid runtime fragmentation.
 *
 * Hardware: Teensy 3.6 / 4.0 / 4.1 (handles __IMXRT1062__ differences).
 *
 * Usage: open Serial at 9600 baud to step through tests and start/stop
 * captures interactively.
 *
 * Copilot docstrings: function-level Doxygen blocks below assist with
 * code-navigation and automated documentation tools.
 ***************************************************************/
#ifndef DISABLE_FS_H_WARNING
  #define DISABLE_FS_H_WARNING  // Disable warning for type File not defined.
#endif
#include "ADC.h"
#include "DMAChannel.h"
#include "SdFat.h"
#include "FreeStack.h"
#include "RingBuf.h"

//******************************************************************************
// global definitions
//******************************************************************************
// Pin must be on first ADC.
#define ADC_PIN A0
// Use FIFO SDIO.
#define SD_CONFIG SdioConfig(FIFO_SDIO)
//------------------------------------------------------------------------------
#if defined(__IMXRT1062__)  // Teensy 4.x
  #define SOURCE_SADDR ADC1_R0
  #define SOURCE_EVENT DMAMUX_SOURCE_ADC1
#else
  #define SOURCE_SADDR ADC0_RA
  #define SOURCE_EVENT DMAMUX_SOURCE_ADC0
#endif

#define AVERAGING 1
#define RESOLUTION 12 
//LOW_SPEED = VERY_LOW_SPEED, MED_SPEED,  HIGH_SPEED,  VERY_HIGH_SPEED = HIGH_SPEED
#define CONVERSION_SPEED ADC_CONVERSION_SPEED::HIGH_SPEED


//******************************************************************************
// global variables
//******************************************************************************
// 400 sector RingBuf - could be larger on Teensy 4.1.
const size_t RING_BUF_SIZE = 400 * 512;
// Count of DMA interrupts.
volatile size_t dmaCount;
// Overrun error for write to RingBuf.
volatile bool overrun;
//******************************************************************************
// create globally available objects
//******************************************************************************
// Preallocate nGiB file.
const uint64_t PRE_ALLOCATE_SIZE = 8ULL << 26; 
ADC adc;
DMAChannel dma(true);

SdFs sd;
FsFile file;

// Ping-pong DMA buffer.
DMAMEM static uint16_t __attribute__((aligned(32))) dmaBuf[2][512];  //[256];


// RingBuf for 512 byte sectors.
RingBuf<FsFile, RING_BUF_SIZE> rb;

// Shared between ISR and background.
volatile size_t maxBytesUsed;

//******************************************************************************
/**
 * @brief DMA interrupt service routine.
 *
 * Called by the DMA channel when a transfer completes (half/full). This ISR
 * performs the minimal required work: invalidate D-cache for the DMA buffer,
 * write a 512-byte sector into the RingBuf in an ISR-safe manner, and update
 * counters. If the RingBuf write fails the `overrun` flag is set.
 *
 * @note Must be kept short and safe for ISR context. Uses `rb.beginISR()` and
 * `rb.endISR()` to enable RingBuf operations inside the ISR.
 */
static void isr() {
  if (!overrun) {
    // Clear cache for buffer filled by DMA to insure read from DMA memory.
    arm_dcache_delete((void*)dmaBuf[dmaCount & 1], 512);
    // Enable RingBuf functions to be called in ISR.
    rb.beginISR();
    if (rb.write(dmaBuf[dmaCount & 1], 512) == 512) {
      dmaCount++;
      if (rb.bytesUsed() > maxBytesUsed) {
        maxBytesUsed = rb.bytesUsed();
      }
    } else {
      overrun = true;
    }
    // End use of RingBuf functions in ISR.
    rb.endISR();
  }
  dma.clearComplete();
  dma.clearInterrupt();
#if defined(__IMXRT1062__)
  // Handle clear interrupt glitch in Teensy 4.x!
  asm("DSB");
#endif  // defined(__IMXRT1062__)
}

//------------------------------------------------------------------------------
/**
 * @brief Initialize DMA and start ADC continuous conversion on `pin`.
 *
 * Configures the DMA channel for ping-pong transfers into `dmaBuf`, attaches
 * the ISR and arms the ADC to start continuous DMA-driven sampling.
 *
 * @param pin ADC input pin (e.g., `ADC_PIN`).
 */
static void init_dma_adc(uint8_t pin) {
  dma.begin();
  dma.attachInterrupt(isr);
  dma.source((volatile const signed short&)SOURCE_SADDR);
  dma.destinationBuffer((volatile uint16_t*)dmaBuf, sizeof(dmaBuf));
  dma.interruptAtHalf();
  dma.interruptAtCompletion();
  dma.triggerAtHardwareEvent(SOURCE_EVENT);
  dma.enable();
  adc.adc0->enableDMA();
  adc.adc0->startContinuous(pin);
}

//------------------------------------------------------------------------------
/**
 * @brief Stop ADC DMA and disable the DMA channel.
 *
 * Safe to call from the main thread to halt sampling before file sync/close.
 */
void stopDma() {
  adc.adc0->disableDMA();
  dma.disable();
}
//------------------------------------------------------------------------------
/**
 * @brief Print a small verification readback of the captured data.
 *
 * Reads a portion of the captured data from `file` via the RingBuf and prints
 * values to the provided `Print` instance. Intended for quick verification
 * that samples were captured and written.
 *
 * @param pr Pointer to a `Print`-derived object (for example `&Serial`).
 */
void printTest(Print* pr) {
  if (file.fileSize() < 1024 * 2) {
    return;
  }
  file.rewind();
  rb.begin(&file);
  // Could readIn RING_BUF_SIZE bytes and write to a csv file in a loop.
  if (rb.readIn(2048) != 2048) {
    sd.errorHalt("rb.readIn failed");
  }
  uint16_t data;
  for (size_t i = 0; i < 1024; i += 8) {
    //pr->printf("%d\t", i);
    for (size_t j = 0; j < 8; j++) {
      // Test read with: template <typename Type>bool read(Type* data).
      rb.read(&data);
      pr->printf(" %d", data);
      if (j != 7) {
        pr->print(",");
      }
    }
    pr->println();
  }
}

//------------------------------------------------------------------------------
/**
 * @brief Run the main capture test loop.
 *
 * Prepares the file (pre-allocation), begins the ADC+DMA capture, and
 * continuously drains `rb` to disk in 512-byte sectors until stopped by
 * the user or an overrun condition. Prints statistics and runs
 * `printTest()` after capture completes.
 *
 * @param pin ADC input pin to sample (e.g., `ADC_PIN`).
 */
void runTest(uint8_t pin) {
  dmaCount = 0;
  maxBytesUsed = 0;
  overrun = false;
  // wait for Serial to start/connect
  do {
    delay(10);
  } while (Serial.read() >= 0);

  if (!file.open("IsrLoggerTest.bin", O_CREAT | O_TRUNC | O_RDWR)) {
    sd.errorHalt("file.open failed");
  }
  if (!file.preAllocate(PRE_ALLOCATE_SIZE)) {
    sd.errorHalt("file.preAllocate failed");
  }
  rb.begin(&file);
  Serial.println("Enter to stop\n");

  // start the ADC in freerun
  init_dma_adc(pin);
  uint32_t samplingTime = micros();
  //while (!overrun && !Serial.available()) {
  while (!overrun && !Serial.available()) {
    size_t n = rb.bytesUsed();
    if ((n + file.curPosition()) >= (PRE_ALLOCATE_SIZE - 512)) {
      Serial.println("File full - stopping");
      break;
    }
    if (n >= 512) {
      if (rb.writeOut(512) != 512) {
        Serial.println("writeOut() failed");
        file.close();
        return;
      }
    }
  }
  stopDma();
  samplingTime = micros() - samplingTime;
  if (!rb.sync()) {
    Serial.println("sync() failed");
    file.close();
    return;
  }
  if (!file.truncate()) {
    sd.errorHalt("truncate failed");
  }
  if (overrun) {
    Serial.println("Overrun ERROR!!");
  }
  Serial.printf("FreeStack: %d\n", FreeStack());
  Serial.printf("dmaCount %d\n", dmaCount);
  Serial.printf("RingBufSize %d\n", RING_BUF_SIZE);
  Serial.printf("maxBytesUsed %d\n", maxBytesUsed);
  Serial.printf("fileSize %d\n", file.fileSize());
  Serial.printf("%.4f seconds\n", 0.000001 * samplingTime);
  Serial.printf("%.3fMB/sec\n", 1.0 * file.fileSize() / samplingTime);
  //dmaCount is multiples of 512 bytes, ie 256 samples
  Serial.printf("%.3fsmp/s\n\n", 256 * dmaCount / (0.000001 * samplingTime));

  printTest(&Serial);
  file.close();
}

//------------------------------------------------------------------------------
/**
 * @brief Wait for a serial keypress with a prompt message.
 *
 * Blocks until a character is available on `Serial`. Prints `msg` before
 * waiting so the user knows what to do.
 *
 * @param msg Null-terminated prompt string to print.
 */
void waitSerial(const char* msg) {
  do {
    delay(10);
  } while (Serial.read() >= 0);
  Serial.println(msg);
  while (!Serial.available()) {
  }
  Serial.println();
}

/**
 * @brief Initialize ADC configuration used by the tests.
 *
 * Sets averaging, resolution, conversion speed and sampling speed. This
 * helper is called from `setup()` to ensure the Arduino core/hardware
 * is initialized prior to touching ADC registers.
 */
static void initADCSettings() {
  adc.adc0->setAveraging(AVERAGING);
  adc.adc0->setResolution(RESOLUTION);
  adc.adc0->setConversionSpeed(CONVERSION_SPEED);
  //adc.adc0->setSamplingSpeed(ADC_SAMPLING_SPEED::HIGH_SPEED);
}

//------------------------------------------------------------------------------
/**
 * @brief Arduino `setup()` entry point.
 *
 * Initializes `Serial`, the SD card, and configures ADC parameters such as
 * averaging, resolution and conversion/sampling speeds used by the test.
 */
void setup() {
  Serial.begin(9600);
  while (!Serial) {
    yield();
  }
  if (!sd.begin(SD_CONFIG)) {
    sd.initErrorHalt(&Serial);
  }
  waitSerial("Enter to begin");

  // set adc speed etc
  // Configure ADC settings (centralized helper)
  initADCSettings();
}
//------------------------------------------------------------------------------
/**
 * @brief Arduino `loop()` entry point.
 *
 * Runs `runTest()` and then waits for user input to repeat the test.
 */
void loop() {
  runTest(ADC_PIN);
  waitSerial("Enter to run test again");
}