Arduino Audio Tools on Daisy ?

[MathiasSchneider-fr]

Hello, I really like your work and was wondering if your libraries could be used on the daisy seed platform? I've tried different approaches but without success.

Thanks a lot!

[pschatzmann]

I don't see any reason why not. The main part is platform independent C++ and can be used with cmake or as part of Arduino.

However you would need to implement the platform specific input or output stream classes that you want to use yourself, since DaisyDuino does not provide any such audio classes. This should not be too difficult...

Where exactly are you struggling ?

[MathiasSchneider-fr]

Thank you for your answer !

I'm still fairly new to audio programming, so I first tried to adapt the faust noise example (i love Faust) to a daisyduino example before realizing that it wasn't, a priori, possible. Then I tried to use STM32CubeMX to configure the chip, but I quickly got lost... And I'm not even sure it's the right approach :)

[pschatzmann]

The easiest way forward would be to use DaisyDuino and install my library.

As a first step you could try to use my library as a data source (e.g. with the sine generator).
If you have a basic understanding how input and output are working in your environment, you can add a new DaisyStream class.

[MathiasSchneider-fr]

"The easiest way forward would be to use DaisyDuino and install my library."

Most probably yes, but the way you set up Faust on ESP32 is too good and I'd like to port it to Daisy (faust2daisy doesn't work very well) but I'm struggling :)

[pschatzmann]

My faust integration should work w/o any changes.

[MathiasSchneider-fr]

Really ? Because i spent hours and hours to try it and i can't figure out to do it, so if you have any hint...

[pschatzmann]

Do you have the simple sine output working ?

[MathiasSchneider-fr]

This one for Daisy ?

#include "DaisyDuino.h"

DaisyHardware hw;

size_t num_channels;

static Oscillator osc;

float pitchknob;

void MyCallback(float **in, float **out, size_t size) {
// Convert Pitchknob MIDI Note Number to frequency
osc.SetFreq(mtof(pitchknob));
for (size_t i = 0; i < size; i++) {
float sig = osc.Process();

for (size_t chn = 0; chn < num_channels; chn++) {
  out[chn][i] = sig;
}

}
}

void setup() {
float sample_rate;
// Initialize for Daisy pod at 48kHz
hw = DAISY.init(DAISY_SEED, AUDIO_SR_48K);
num_channels = hw.num_channels;
sample_rate = DAISY.get_samplerate();

osc.Init(sample_rate);
osc.SetFreq(440);
osc.SetAmp(0.5);
osc.SetWaveform(osc.WAVE_TRI);

DAISY.begin(MyCallback);
}

void loop() { pitchknob = 24.0 + ((analogRead(A0) / 1023.0) * 60.0); }

Yes if you're talking about that

[pschatzmann]

So, next you need to implement a Stream class in my framework. Something like the following.
I was just handling the output and did not do any testing.

You can extend the logic a bit to be more flexible with the number of channels and the bits_per_sample.
I am not sure how the number of channels are handled in Daisy. Can you flexibly change it ?

#pragma once;

#include "AudioToos/AudioStreams.h"
#include "DaisyDuino.h"

namespace audio_tools {
/**
 * @brief Custom Stream for Daisyduino
 * https://github.com/electro-smith/DaisyDuino
 */
class DaisyStream : public AudioStream {

public:
  DaisyStream() { self = this; };

  bool begin() {
    TRACEI();
    petal = DAISY.init(DAISY_SEED, daisy_rate);
    petal.ClearLeds();

    // start callback
    DAISY.begin(AudioCallback);
    return true;
  }

  /// Stops the processing and releases the memory
  void end() {
    TRACEI();
    DAISY.end();
  }

  void setAudioInfo(AudioInfo info) override {
    TRACED();

    AudioStream::setAudioInfo(info);

    switch (info.sample_rate) {
    case 8000:
      daisy_rate = AUDIO_SR_8K;
      break;
    case 16000:
      daisy_rate = AUDIO_SR_16K;
      break;
    case 32000:
      daisy_rate = AUDIO_SR_32K;
      break;
    case 48000:
      daisy_rate = AUDIO_SR_48K;
      break;
    case 96000:
      daisy_rate = AUDIO_SR_96K;
      break;
    default:
      LOGE("Unsupported sample rate: %d", info.sample_rate);
      break;
    }
  }

  /// Write audio data to buffer
  size_t write(const uint8_t *buffer, size_t size) override {
    // check channels
    if (info.channels != petal.num_channels) {
        LOGE("Invalid channels %d - expected %d", info.channels, petal.num_channels);
        return 0;
    }
    // write to buffer
    return write_buffer.writeArray(buffer, size);
  }

  /// Limit amout of data to be written
  int availableForWrite() { return 1024; }

protected:
  // daisy hardware
  static DaisyHardware petal;
  // provide access from static methods
  static DaisyStream *self;
  // output buffer
  NBuffer<uint8_t> *write_buffer(1024, 5);
  // actually selected sample rate
  DaisyDuinoSampleRate daisy_rate = AUDIO_SR_96K;

  static void AudioCallback(float *in, float *out, size_t size) {
    // process out
    switch (self->bits_per_sample) {
    case 16: {
      for (int j = 0; j < size; j++) {
        // get array of int16_t data from buffer
        int bytes = size * sizeof(int16_t);
        int16_t buffer[size];
        self->writeBuffer->readArray((uint8_t *)buffer, bytes);
        // output floats
        for (int j = 0; j < size; j++) {
          out[j] = static_cast<float>(buffer[j]) / 32768.0;
        }
      }
    } break;
    default:
      LOGE("Unsupported bits_per_sample: %d", self->bits_per_sample);
    }
  }
}
};

DaisyStream *DaisyStream::self = nullptr;

} // namespace audio_tools

[MathiasSchneider-fr]

Wow, this looks really promising, i tried to do a class without success. Unfortunately, i've no time to try it now but i will as soon as possible, i'm so excited. And if/when i manage to make it work, i will do a proper tutorial for daisy and faust because i know a lot of people are struggling with this.
A big thank to you, i'll let you know about my experiments with that.

[pschatzmann]

I added the following to the documentation: https://github.com/pschatzmann/arduino-audio-tools/wiki/Writing-your-Custom-Input&Output-Class

[MathiasSchneider-fr]

Hello, it's me again, after a few months...
I'm still struggling.

I tried to implement your solution, but all I get are errors.

In particular, I get this:

In file included from /Users/mv/Documents/Arduino/libraries/arduino-audio-tools/src/AudioI2S/I2SStream.h:16,
                 from /Users/mv/Documents/Arduino/libraries/arduino-audio-tools/src/AudioTools.h:74,
                 from /Users/mv/Documents/Arduino/libraries/arduino-audio-tools/examples/examples-perso/TestDaisy/TestDaisy.ino:113:
/Users/mv/Documents/Arduino/libraries/arduino-audio-tools/src/AudioI2S/I2SSTM32.h:5:10: fatal error: stm32-i2s.h: No such file or directory
    5 | #include "stm32-i2s.h"
      |          ^~~~~~~~~~~~~
compilation terminated.
exit status 1

Compilation error: exit status 1

This raises two questions for me: firstly, indeed, this file is missing from this location. But more importantly, why is it important for us here? Isn't it the purpose of DaisyDuino to handle all this? Isn't the implementation of the custom class meant for this? Thank you for your help.

(Here is my whole code if this can help : https://codeshare.io/obQ3bL

[pschatzmann]

In the AudioConfig.h there is some logic to determine the board. In your case the system thinks it's a STM32 board.
In this case you might need to adjust these rules!

• e.g. make sure that STM is not determined or
• comment out the I2S support

For the supported STM devices some additional libraries need to be installed.

[MathiasSchneider-fr]

Hi thank you for your answer, it seems that this issue is solved !

I worked all day on this for debugging it but i'm not sure of what i've done...
But i think there's some weird things in your code :

NBuffer<uint8_t> *write_buffer(1024, 3);
If there a pointers, how could we pass arguments like this ?

NBuffer<uint8_t>* write_buffer = new NBuffer<uint8_t>(1024, 5); should be better, no ?

In the same idea
return write_buffer.writeArray(buffer, size);
return write_buffer->writeArray(buffer, size); no ?

The end of my work is here :

#pragma once;

#include "AudioTools/AudioStreams.h"
#include "DaisyDuino.h"

namespace audio_tools {
/**
 * @brief Custom Stream for Daisyduino
 * https://github.com/electro-smith/DaisyDuino
 */
class CustomStream : public AudioStream {

public:
  CustomStream() { self = this; };
   // Destructeur
  ~CustomStream() {
    delete write_buffer;
    delete read_buffer;
  }
  void setAudioInfo(AudioInfo info) override {
    TRACED();

    AudioStream::setAudioInfo(info);

    switch (info.sample_rate) {
    case 8000:
      daisy_rate = AUDIO_SR_8K;
      break;
    case 16000:
      daisy_rate = AUDIO_SR_16K;
      break;
    case 32000:
      daisy_rate = AUDIO_SR_32K;
      break;
    case 48000:
      daisy_rate = AUDIO_SR_48K;
      break;
    case 96000:
      daisy_rate = AUDIO_SR_96K;
      break;
    default:
      LOGE("Unsupported sample rate: %d", info.sample_rate);
      break;
    }
  }

  bool begin(const AudioInfo& info) {
    TRACEI();
    setAudioInfo(info); // Configure les informations audio avant de démarrer

    petal = DAISY.init(DAISY_SEED, daisy_rate);
    petal.ClearLeds();

    // start callback
    DAISY.begin(AudioCallback);
    return true;
  }

  /// Stops the processing and releases the memory
  void end() {
    TRACEI();
    DAISY.end();
  }

  
  /// Limit amount of data to be written
  int availableForWrite() { return 1024; }

  /// Write audio data to buffer
  size_t write(const uint8_t *buffer, size_t size) override {
    // check channels
    if (info.channels != petal.num_channels) {
        LOGE("Invalid channels %d - expected %d", info.channels, petal.num_channels);
        return 0;
    }
    // write to buffer
    return write_buffer->writeArray(buffer, size);
  }

/// amount of data available
  int available() { return read_buffer->available(); }

  /// Read from audio data to buffer
  size_t readBytes(uint8_t *buffer, size_t size) override {
    // write to buffer or use your custom logic
    size_t result = read_buffer->readArray(buffer, size);
    return result;
  }

protected:
  // output buffer
  NBuffer<uint8_t>* write_buffer = new NBuffer<uint8_t>(1024, 5);
  NBuffer<uint8_t>* read_buffer = new NBuffer<uint8_t>(1024, 3);
  static inline DaisyHardware petal;
  static CustomStream* self;
  int bits_per_sample = 16; // Valeur par défaut, ajustez selon les besoins
 
  // actually selected sample rate
  DaisyDuinoSampleRate daisy_rate = AUDIO_SR_96K;

  static void AudioCallback(float *in, float *out, size_t size) {
    // process out
    switch (self->bits_per_sample) {
    case 16: {
      for (int j = 0; j < size; j++) {
        // get array of int16_t data from buffer
        int bytes = size * sizeof(int16_t);
        int16_t buffer[size];
        self->write_buffer->readArray((uint8_t *)buffer, bytes);
        // output floats
        for (int j = 0; j < size; j++) {
          out[j] = static_cast<float>(buffer[j]) / 32768.0;
        }
      }
    } break;
    default:
      LOGE("Unsupported bits_per_sample: %d", self->bits_per_sample);
    }
  }
};


CustomStream *CustomStream::self = nullptr;

} // namespace audio_tools

But i end up with a "region `FLASH' overflowed by 108112 bytes
collect2: error: ld returned 1 exit status"

So i'm not sure how to deal with it...

Thank you again

[pschatzmann]

It should be NBuffer<uint8_t> write_buffer(1024, 3); which is a valid initialization in some cases but it should be better NBuffer<uint8_t> write_buffer{1024, 3};

Not sure why you run out of flash: I have my framework working on a STM32F411 Blackpill which has only 512KB flash.
What is the sketch that you try to compile ? It tends to get that big, if the sketch loads audio data into progmem. In your environment this should better end up in RAM...

[pschatzmann]

In the Tools Menu I used

• Debug Symbols: none
• Optimize: smallest

[MathiasSchneider-fr]

Yes, this is already set like this too

[MathiasSchneider-fr]

OK my bad, there's just 128kb, 8MB is the external flash (i'm not sure what does it mean)
But i think i'm screwed 😄

[pschatzmann]

I would ask Daisy how to load the program or sections of it to the external flash

[MathiasSchneider-fr]

I did and... No :)
Thank for your help, i will continue my journey to Faust and a (pretty) fast CPU. (The ESP32 is a little bit slow for my needs)