Play Audio to a BT Device on a button press

[subbamaggus]

my current setup looks like:
download a file from an internal webserver (home net)

init everything

play the sound on a button press.

basically i got everything up and running.

But: the usage of the callback does not really work the way i expect it to.

in the setup i use:

a2dp_source.set_data_callback(get_sound_data);
a2dp_source.start(btDeviceName);

and in the isr i just set a variable (pressed) to true.

the loop looks like:

    if(pressed) {
        Serial.println("button pressed");
        playbackDone = false;
        a2dp_source.start(btDeviceName);
        pressed = false;
    }

my callback looks like:

int32_t get_sound_data(uint8_t *data, int32_t len) {
    if (playbackDone) return 0;
    if (!audioFile) {
        Serial.println("loading file");
        audioFile = SPIFFS.open(filePath, "r");
        if (!audioFile) { Serial.println("Error opening audio file"); playbackDone = true; return 0; }
        audioFile.seek(44, SeekSet);
        Serial.println("file loaded");
    }
    int bytesRead = audioFile.read(data, len);
    Serial.printf("len %d\n", len);
    if (bytesRead <= 0) { Serial.println("Playback finished!"); playbackDone = true; audioFile.close(); return 0; }
    return bytesRead;
}

i guess there is more going on. since i dont see a reason in the documentation how the callback should be used.

i will change the loading of the file to a buffer... but first i would like to understand the callback.

do you have a hint for that?

[pschatzmann]

Your code is impossible to read: please use the proper code formatting provided by Markdown!

In any case, you need to feed the requested number of bytes as described in the Readme Chapter Sending Data from a A2DS Data Source with a Callback: if you have nothing just initialize the array with zeros.
If you have a file, you need to sequentially provide the requested data from the file and at the end, fill the remainder with zeroes.

Here is an example that processes an mp3 file!

[subbamaggus]

sorry, it was my first discussion. i was not familiar with the formatting.

i guess i am pretty close.
just the reocurring "button press" to replay the same file again and again might be the issue.

which is not in your example

[subbamaggus]

I narrowed it further down.

the
a2dp_source.start(btDeviceName); is not needed in the loop() everytime the button is pressed.

the callback is called the whole time.
So i guess i would load the file in setup, copy the data to a buffer.

just the callback needs to set its pointer back to start everytime the button is pressed.

for the moment, i will have to read into the handling of this behavoir.

[subbamaggus]

i guess the buffer example does not help me. the way the callback works might be the confusing part.

i attached a button to pin 18, and this is my souce.
using the buffer as in https://github.com/pschatzmann/arduino-audio-tools/blob/main/examples/examples-communication/a2dp/basic-player-a2dp/basic-player-a2dp.ino

but i guess the way the data should be treated is different.
the buffer is basically fixed. the example is about a stream.

i will try further.

just for completeness, here my try.

#include <BluetoothA2DPSinkQueued.h>
#include <BluetoothA2DPCommon.h>
#include <BluetoothA2DPSource.h>
#include <A2DPVolumeControl.h>
#include <config.h>
#include <BluetoothA2DPSink.h>
#include <BluetoothA2DPOutput.h>
#include <BluetoothA2DP.h>

#include <WiFi.h>
#include <HTTPClient.h>
#include <SPIFFS.h>
#include "BluetoothA2DPSource.h"
#include "esp_task_wdt.h"

#include <Arduino.h>

const char* ssid = "MYSSID";
const char* password = "MYPASSWORD";
const char* fileURL  = "http://www.sasemdusem.de/response.wav"; //use your local server ip and the open port
const char* filePath = "/response.wav";
const char* btDeviceName = "MYBTDEVICE"; //use the name of your bt device


BluetoothA2DPSource a2dp_source;
File audioFile;
bool playbackDone = false;
int counter = 0;

const uint8_t buttonPin = 18;
volatile bool pressed = false;

void ARDUINO_ISR_ATTR buttonISR() {
    pressed = true;
}

bool downloadFile(const char* url, const char* path) {
    Serial.println("downloading file");
    HTTPClient http;
    http.setTimeout(10000);
    http.begin(url);
    int httpCode = http.GET();
    if (httpCode == HTTP_CODE_OK) {
        WiFiClient* stream = http.getStreamPtr();
        File file = SPIFFS.open(path, FILE_WRITE);
        if (!file) {
            http.end();
            return false;
        }
        
        uint8_t buff[1024];
        int len = http.getSize(), total = 0;
        while (http.connected() && (len > 0 || len == -1)) {
            size_t avail = stream->available();
            if (avail) {
                int c = stream->readBytes(buff, min(avail, sizeof(buff)));
                file.write(buff, c);
                total += c;
                if (len > 0) len -= c;
                Serial.print(".");
            }
            delay(1);
        }
        Serial.printf("\nBytes received: %d\n", total);
        file.close();
        http.end();
        return true;
    } else {
        Serial.printf("HTTP error: %d\n", httpCode);
        http.end();
        return false;
    }
}

int32_t get_sound_data(uint8_t *data, int32_t len) {
    Serial.print("#");
    if (playbackDone) return 0;
    
    if (!audioFile) {
        Serial.println("\nloading file");
        audioFile = SPIFFS.open(filePath, "r");
        if (!audioFile) {
            Serial.println("\nError opening audio file"); 
            playbackDone = true; return 0;
        }
        audioFile.seek(44, SeekSet);
        Serial.println("file loaded");
    }
    int bytesRead = audioFile.read(data, len);
    Serial.printf("len %d", len);
    if (bytesRead <= 0) {
        Serial.println("\nPlayback finished!");
        playbackDone = true; 
        audioFile.close(); 
        return 0;
    }
    return bytesRead;
}

void setup() {
  
    Serial.begin(115200);
    delay(1000);
    esp_task_wdt_deinit();

    pinMode(buttonPin, INPUT_PULLUP);
    attachInterrupt(buttonPin, buttonISR, RISING);
    
    WiFi.begin(ssid, password);
    Serial.print("Connecting to WiFi");
    while (WiFi.status() != WL_CONNECTED) {
        delay(500); 
        Serial.print(".");
    }
    Serial.println(" Connected!");

    if (!SPIFFS.begin(true)) {
        Serial.println("SPIFFS mount failed, formatting...");
        if (!SPIFFS.format() || !SPIFFS.begin(true)) { 
            Serial.println("SPIFFS not available");
            return;
        }
    }

    if (downloadFile(fileURL, filePath)) {
        Serial.println("Download completed successfully");
    }
    else { 
        Serial.println("Download failed");
        return;
    }
    
    Serial.println("Initializing Bluetooth...");
    a2dp_source.set_data_callback(get_sound_data);
    
    Serial.println("waiting...");
    delay(2000);
    
    a2dp_source.start(btDeviceName);
}

void loop() {
    counter++;
    
    Serial.printf("-");

    if(pressed) {
        pressed = false;
        Serial.println("\nbutton pressed");
        playbackDone = false;
        //a2dp_source.start(btDeviceName);
    }

    delay(500);
}

[pschatzmann]

You are thinking way too complicated!
Just do something like the following:

File file;

// this will play as soon as you open the file
int32_t get_sound_data(uint8_t *data, int32_t len) {
   // when no data: return silence
   if (!file) {
        memset(data,len, 0);
        return len;
   }
  // return data from file
   size_t read = file.readBytes(data, len);
   return read;
}

If you have a wav file at 44200 samples/second, 2 channels, 16 bits, just open it and set the start position to 44 to ignore the wav header. Otherwise you would need the wav decoder provided by the AudioTools.

void loop() {
    if(pressed) {
        file = SPIFFS.open(filePath, "r");
        if (!file) {
            Serial.println("\nError opening audio file"); 
        }
        file.seek(44, SeekSet);
   }
}

Please note that you want use WiFi and A2DP together!

[subbamaggus]

thank you for your answer!
that looks a lot easier. i guess i need to get vscode running. arduino code completion is not great, and to look up every possible call is kind of time consuming ;-)

I gave it a short shot. and even turned off wifi after getting the file.
but i guess the sync of the playback and the button press are not as i expect it to be.

i will have to look into that later... i am headed out for vacation.