RP3040 example

Author: pschatzmann

examples/SnapClientRP2040/SnapClientRP2040.ino

@@ -0,0 +1,69 @@
+/**
+ * @brief SnapClient with Opus decoder: Wifi processing is on core 0, decoding and
+ * i2s output is on core 1.
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+
+#include "AudioTools.h"
+#include "AudioTools/AudioCodecs/CodecOpus.h"
+#include "SnapClient.h"
+#include "api/SnapProcessorRP2040.h" 
+
+//#define ARDUINO_LOOP_STACK_SIZE (10 * 1024)
+
+I2SStream out;
+OpusAudioDecoder opus;
+WiFiClient wifi;
+//SnapTimeSyncDynamic synch(172, 10); // optional configuratioin
+SnapClient client(wifi, out, opus);
+SnapProcessorRP2040 processor_rp2040(1024*8); // define OPUS queue with 8 kbytes
+
+void setup() {
+  Serial.begin(115200);
+  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
+  while(!Serial);
+  Serial.println("starting...");
+
+  // login to wifi -> Define values in SnapConfig.h or replace them here
+  WiFi.begin("ssid", "password");
+  Serial.print("Connecting to WiFi ..");
+  while (WiFi.status() != WL_CONNECTED) {
+    Serial.print('.');
+    delay(1000);
+  }
+
+  // print ip address
+  Serial.println();
+  Serial.println(WiFi.localIP());
+
+  // Define CONFIG_SNAPCAST_SERVER_HOST in SnapConfig.h or here
+  client.setServerIP(IPAddress(192,168,1,44));
+  client.setSnapProcessor(processor_rp2040);
+
+  // start snap client
+  client.begin();
+  Serial.println("started");
+}
+
+void loop() {
+  // fill queue  
+  client.doLoop();
+}
+
+void setup1(){
+  // setup I2S to define custom pins
+  auto cfg = out.defaultConfig();
+  //cfg.pin_bck = 14;
+  //cfg.pin_ws = 15;
+  //cfg.pin_data = 22;
+  cfg.sample_rate = 48000;
+  cfg.buffer_size = 1024;
+  cfg.buffer_count = 4;
+  out.begin(cfg);
+}
+
+void loop1(){
+  // trigger output from queue  
+  processor_rp2040.doLoop1();
+}

src/api/SnapLogger.h

@@ -7,8 +7,8 @@
 #ifdef ESP32
 #  include "esp_log.h"
 #else
-static char msg[100] = {0};
-#  define DEFAULT_LOG(...) { Serial.println(__PRETTY_FUNCTION__); snprintf((char*)msg, 100, __VA_ARGS__); Serial.println(msg); }
+static char msg[100] = ": ";
+#  define DEFAULT_LOG(...) { Serial.print(__PRETTY_FUNCTION__); snprintf((char*)msg+2, 100, __VA_ARGS__); Serial.println(msg); }
 #  define ESP_LOGE(tag,  ...) DEFAULT_LOG(__VA_ARGS__)
 #  define ESP_LOGW(tag,  ...) DEFAULT_LOG(__VA_ARGS__)
 #  define ESP_LOGI(tag,  ...) //DEFAULT_LOG(__VA_ARGS__)

src/api/SnapProcessor.h

@@ -85,6 +85,11 @@ class SnapProcessor {
       return processLoopStep();
    }
 
+  /// Usually not used!
+  virtual bool doLoop1() { 
+    return false;
+   }
+
   /// Defines the output class
   void setOutput(AudioOutput &output) { p_snap_output->setOutput(output); }
 

src/api/SnapProcessorRP2040.h

@@ -0,0 +1,128 @@
+#pragma once
+#include "AudioTools/Concurrency/RP2040.h"
+#include "SnapOutput.h"
+
+namespace snap_arduino {
+
+/**
+ * @brief Processor for which the encoded output is buffered in a queue. The decoding and 
+ * audio output can be done on the second core by calling loop1();
+ * 
+ * @author Phil Schatzmann
+ * @version 0.1
+ * @date 2024-02-26
+ * @copyright Copyright (c) 2023
+ */
+class SnapProcessorRP2040 : public SnapProcessor {
+ public:
+  /// Default constructor
+  SnapProcessorRP2040(SnapOutput &output, int bufferSizeBytes, int activationAtPercent = 75)
+      : SnapProcessor(output) {
+    active_percent = activationAtPercent;
+    initQueues(bufferSizeBytes);
+  }
+  /// Default constructor
+  SnapProcessorRP2040(int bufferSizeBytes, int activationAtPercent = 75)
+      : SnapProcessor() {
+    active_percent = activationAtPercent;
+    initQueues(bufferSizeBytes);
+  }
+
+  bool begin() override {
+    ESP_LOGW(TAG, "begin: %d", buffer_count * 1024);
+    // regular begin logic
+    bool result = SnapProcessor::begin();
+    // allocate buffer, so that we could use psram
+    size_queue.resize(RTOS_MAX_QUEUE_ENTRY_COUNT);
+    buffer.resize(buffer_count * 1024);
+    is_active = false;
+    return result;
+  }
+
+  void end(void) override {
+    size_queue.clear();
+    buffer.reset();
+    SnapProcessor::end();
+  }
+
+  bool doLoop1() override {
+    ESP_LOGD(TAG, "doLoop1 %d / %d", size_queue.available(), buffer.available());
+    if (!isBufferActive()) return true;
+
+    size_t size = 0;
+    if (size_queue.readArray(&size, 1)) {
+      uint8_t data[size];
+      int read = buffer.readArray(data, size);
+      if (read != size){
+        ESP_LOGE(TAG, "readArray failed %d -> %d", size, read);
+      }
+      int written = p_snap_output->audioWrite(data, size);
+      if (written != size) {
+        ESP_LOGE(TAG, "write error: %d of %d", written, size);
+      }
+    }
+    return true;
+  }
+
+ protected:
+  const char *TAG = "SnapProcessorRP2040";
+  audio_tools::BufferRP2040T<size_t> size_queue{1, 0};
+  audio_tools::BufferRP2040T<uint8_t> buffer{1024, 0};  // size defined in begin
+  int buffer_count = 0;
+  bool is_active = false;
+  int active_percent = 0;
+
+  bool isBufferActive() {
+    if (!is_active && buffer.available()>0) {
+
+      int limit = buffer.size() * active_percent / 100;
+      if (buffer.available() >= limit) {
+        LOGI("Setting buffer active");
+        is_active = true;
+      }
+      delay(10);
+    }
+    return is_active;
+  }
+
+  /// store parameters provided by constructor
+  void initQueues(int bufferSizeBytes) {
+    buffer_count = bufferSizeBytes / 1024;
+    if (buffer_count <= 2){
+      buffer_count = 2;
+    }
+  }
+
+  /// Writes the encoded audio data to a queue
+  size_t writeAudio(const uint8_t *data, size_t size) override {
+
+    if (size > buffer.size()) {
+      ESP_LOGE(TAG, "The buffer is too small with %d. Use a multiple of %d", buffer.size(), size);
+      stop();
+    }
+
+    ESP_LOGI(TAG, "size: %zu / buffer %d", size, buffer.available());
+    if (!p_snap_output->isStarted() || size == 0) {
+      ESP_LOGW(TAG, "not started");
+      return 0;
+    }
+
+    // if (!p_snap_output->synchronizePlayback()) {
+    //   return size;
+    // }
+
+    if (!size_queue.writeArray(&size, 1)) {
+      ESP_LOGW(TAG, "size_queue full");
+      return 0;
+    }
+
+    size_t size_written = buffer.writeArray(data, size);
+    if (size_written != size) {
+      ESP_LOGE(TAG, "buffer-overflow");
+    }
+
+    return size;
+  }
+};
+
+}  // namespace snap_arduino