KARadioProtocolServer provide abstract classes

Author: pschatzmann

examples/examples-communication/serial/mp3/receive-mp3/receive-mp3.ino

@@ -0,0 +1,42 @@
+
+/**
+ * @file receive-mp3.ino
+ * @brief Example of receiving an mp3 stream over serial and playing it over I2S
+ * using the AudioTools library.
+ * The processing must be synchronized with RTS/CTS flow control to prevent a
+ * buffer overflow and lost data.
+ */
+#include "AudioTools.h"
+#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
+#include "AudioTools/AudioLibs/AudioBoardStream.h"
+
+
+AudioBoardStream i2s(AudioKitEs8388V1);  // final output of decoded stream
+EncodedAudioStream dec(&i2s, new MP3DecoderHelix());  // Decoding stream
+HardwareSerial MP3Serial(1);             // define a Serial for UART1
+StreamCopy copier(dec, MP3Serial);       // copy url to decoder
+// pins
+const int MySerialTX = -1;
+const int MySerialRX = 18;
+const int MySerialRTS = -1;
+const int MySerialCTS = 20;
+
+void setup() {
+  Serial.begin(115200);
+  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
+
+  // setup serial data source with flow control
+  MP3Serial.begin(115200, SERIAL_8N1);
+  MP3Serial.setPins(MySerialRX, MySerialTX, MySerialCTS, MySerialRTS);
+  MP3Serial.setHwFlowCtrlMode(HW_FLOWCTRL_CTS_RTS);
+ 
+  // setup i2s
+  auto config = i2s.defaultConfig(TX_MODE);
+  i2s.begin(config);
+
+  // setup I2S based on sampling rate provided by decoder
+  dec.begin();
+
+}
+
+void loop() { copier.copy(); }

examples/examples-communication/serial/mp3/send-mp3/send-mp3.ino

@@ -0,0 +1,38 @@
+
+/**
+ * @file send-mp3.ino
+ * @brief Example of sending an mp3 stream over Serial the AudioTools library.
+ * The processing must be synchronized with RTS/CTS flow control to prevent a
+ * buffer overflow and lost data.
+ * We get the mp3 from an URLStream.
+ */
+#include <HardwareSerial.h>
+
+#include "AudioTools.h"
+#include "AudioTools/AudioCodecs/CodecMP3Helix.h"
+#include "AudioTools/AudioLibs/AudioBoardStream.h"
+
+URLStream url("ssid", "password");  // or replace with ICYStream to get metadata
+AudioBoardStream i2s(AudioKitEs8388V1);  // final output of decoded stream
+HardwareSerial MP3Serial(1);             // define a Serial for UART1
+StreamCopy copier(MP3Serial, url);       // copy url to decoder
+// pins
+const int MySerialTX = 17;
+const int MySerialRX = -1;
+const int MySerialRTS = 19;
+const int MySerialCTS = -1;
+
+void setup() {
+  Serial.begin(115200);
+  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Info);
+
+  // setup serial data sink with flow control
+  MP3Serial.begin(115200, SERIAL_8N1);
+  MP3Serial.setPins(MySerialRX, MySerialTX, MySerialCTS, MySerialRTS);
+  MP3Serial.setHwFlowCtrlMode(HW_FLOWCTRL_CTS_RTS);
+
+  // mp3 radio
+  url.begin("http://stream.srg-ssr.ch/m/rsj/mp3_128", "audio/mp3");
+}
+
+void loop() { copier.copy(); }

src/AudioTools/AudioLibs/AudioPlayerProtocol.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "AudioTools/CoreAudio/AudioPlayer.h"
+
+namespace audio_tools {
+
+/***
+ * @brief  Abstract class for protocol to control the audio player.
+ * @ingroup player
+ * @author Phil Schatzmann
+ */
+class AudioPlayerProtocol {
+ public:
+  /// processes the commands and returns the result output via the Print
+  /// object
+  virtual bool processCommand(const char* input, Print& result) = 0;
+
+  /// Proceess commands passed by Stream (e.g. Serial)
+  virtual bool processCommand(Stream& input, Print& result) {
+    char buffer[max_input_buffer_size];
+    int len = readLine(input, buffer, max_input_buffer_size);
+    if (len == 0) return false;
+    return processCommand(buffer, result);
+  }
+  /// Defines the player
+  virtual void setPlayer(AudioPlayer& player) { p_player = &player; }
+
+  /// Defines the input buffer size used by the readLine function (default 256)
+  void setMaxInputBufferSize(int size) { max_input_buffer_size = size; }
+
+ protected:
+  AudioPlayer* p_player = nullptr;
+  int max_input_buffer_size = 256;
+
+  /// Reads a line delimited by '\n' from the stream
+  int readLine(Stream& in, char* str, int max) {
+    int index = 0;
+    if (in.available() > 0) {
+      index = in.readBytesUntil('\n', str, max);
+      str[index] = '\0';  // null termination character
+    }
+    return index;
+  }
+};
+
+}  // namespace audio_tools

src/AudioTools/AudioLibs/AudioPlayerProtocolServer.h

@@ -0,0 +1,90 @@
+#pragma once
+#include "AudioPlayerProtocol.h"
+#include "AudioTools/CoreAudio/BaseStream.h"
+#include "AudioTools/CoreAudio/Buffers.h"
+#include "HttpServer.h"
+
+namespace audio_tools {
+
+/***
+ * @brief Audio Player Protocol Server: We can use the indicated protocol over
+ * http to control the audio player provided by the audiotools.
+ * @author Phil Schatzmann
+ */
+class AudioPlayerProtocolServer {
+ public:
+  /// Default constructor
+  AudioPlayerProtocolServer(AudioPlayerProtocol& protocol,
+                                          AudioPlayer& player, int port = 80,
+                                          const char* ssid = nullptr,
+                                          const char* pwd = nullptr) {
+    setProtocol(protocol);
+    setPlayer(player);
+    setPort(port);
+    setSSID(ssid);
+    setPassword(pwd);
+  }
+
+  /// Empty constructor: call setPlayer to define the player
+  AudioPlayerProtocolServer() = default;
+
+  /// Defines the player
+  void setPlayer(AudioPlayer& player) { p_protocol->setPlayer(player); }
+
+  void setPort(int port) { this->port = port; }
+  void setSSID(const char* ssid) { this->ssid = ssid; }
+  void setPassword(const char* password) { this->password = password; }
+  void setSSID(const char* ssid, const char* password) {
+    this->ssid = ssid;
+    this->password = password;
+  }
+
+  bool begin() {
+    context[0] = this;
+    server.on("/", T_GET, parse, context.data(), context.size());
+
+    // connect to WIFI
+    if (ssid != nullptr && password != nullptr) {
+      return server.begin(port, ssid, password);
+    }
+    return server.begin(port);
+  }
+
+  void loop() { server.copy(); }
+  void copy() { server.copy(); }
+
+  /// Defines the buffer size that is made available for the http reply
+  void setBufferSize(int size) { buffer_size = size; }
+
+  void setProtocol(AudioPlayerProtocol& protocol) {
+    this->p_protocol = &protocol;
+  }
+
+ protected:
+  WiFiServer wifi;
+  HttpServer server{wifi};
+  AudioPlayerProtocol* p_protocol;
+  RingBuffer<uint8_t> ringBuffer{0};
+  QueueStream<uint8_t> queueStream{ringBuffer};
+  Vector<void*> context{1};
+  int port = 80;
+  const char* ssid = nullptr;
+  const char* password = nullptr;
+  int buffer_size = 512;
+
+  static void parse(HttpServer* server, const char* requestPath,
+                    HttpRequestHandlerLine* hl) {
+    LOGI("parse: %s", requestPath);
+    AudioPlayerProtocolServer* self = (AudioPlayerProtocolServer*)hl->context[0];
+    self->ringBuffer.resize(self->buffer_size);
+    QueueStream<uint8_t>& queueStream = self->queueStream;
+    queueStream.begin();
+    bool ok = self->p_protocol->processCommand(requestPath, queueStream);
+    LOGI("available: %d", queueStream.available());
+    server->reply("text/plain", queueStream, queueStream.available(),
+                  ok ? 200 : 400, ok ? SUCCESS : "Error");
+    self->ringBuffer.resize(0);
+  }
+};
+
+}  // namespace audio_tools

src/AudioTools/AudioLibs/KARadioProtocol.h

@@ -5,24 +5,25 @@
 #include "AudioTools/CoreAudio/AudioBasic/Str.h"
 #include "AudioTools/CoreAudio/AudioPlayer.h"
 #include "AudioTools/Disk/AudioSource.h"
+#include "AudioPlayerProtocol.h"
 
 #define KA_VERSION "Release: 2.4, Revision: R0"
 
 namespace audio_tools {
 
 /***
  * @brief KA-Radio Protocol: We can use the KA-Radio protocol to control the
- * audio player provided by the audiotools.  
+ * audio player provided by the audiotools.
  * Supported commands: play, instant, volume, volume+, volume-, pause,
  * resume, stop, start, next, prev, mute, infos, version.
  * Example: volume=50&play=128&infos
  * See https://github.com/karawin/Ka-Radio32/blob/master/Interface.md
- * 
+ *
  * @ingroup player
  * @author Phil Schatzmann
  */
 
-class KARadioProtocol {
+class KARadioProtocol : public AudioPlayerProtocol {
  public:
   /// Empty constructor: call setPlayer to define the player
   KARadioProtocol() {
@@ -141,14 +142,18 @@ class KARadioProtocol {
   }
 
   /// Defines the player
-  void setPlayer(AudioPlayer& player) {
-    p_player = &player;
+  void setPlayer(AudioPlayer& player) override {
+    AudioPlayerProtocol::setPlayer(player);
     volume = player.volume() * 254.0f;
   }
 
+  bool processCommand(Stream& input, Print& result) override {
+    return AudioPlayerProtocol::processCommand(input, result);
+  }
+
   /// processes the commands and returns the result output via the Print
   /// object
-  bool processCommand(const char* input, Print& result) {
+  bool processCommand(const char* input, Print& result) override {
     if (p_player == nullptr) {
       LOGE("player not set");
       return false;
@@ -219,7 +224,6 @@ class KARadioProtocol {
   }
 
  protected:
-  AudioPlayer* p_player = nullptr;
   int volume = 0;
   Str title_str = "n/a";
   struct Action {

src/AudioTools/AudioLibs/KARadioProtocolServer.h

@@ -1,21 +1,22 @@
 #pragma once
-#include "AudioTools/CoreAudio/BaseStream.h"
-#include "AudioTools/CoreAudio/Buffers.h"
-#include "HttpServer.h"
+#include "AudioPlayerProtocolServer.h"
 #include "KARadioProtocol.h"
 
 namespace audio_tools {
 
 /***
- * @brief KA-Radio Protocol: We can use the KA-Radio protocol over http to
- * control the audio player provided by the audiotools.
+ * @brief KA-Radio Protocol Server which provides the KA-Radio protocol over
+ * http to control the audio player provided by the audiotools.
+ * @ingroup player
  * @author Phil Schatzmann
  */
-class KARadioProtocolServer {
+
+class KARadioProtocolServer : public AudioPlayerProtocolServer {
  public:
   /// Default constructor
   KARadioProtocolServer(AudioPlayer& player, int port = 80,
                         const char* ssid = nullptr, const char* pwd = nullptr) {
+    setProtocol(protocol);
     setPlayer(player);
     setPort(port);
     setSSID(ssid);
@@ -25,60 +26,7 @@ class KARadioProtocolServer {
   /// Empty constructor: call setPlayer to define the player
   KARadioProtocolServer() = default;
 
-  /// Defines the player
-  void setPlayer(AudioPlayer& player) { protocol.setPlayer(player); }
-
-  void setPort(int port) { this->port = port; }
-  void setSSID(const char* ssid) { this->ssid = ssid; }
-  void setPassword(const char* password) { this->password = password; }
-  void setSSID(const char* ssid, const char* password) {
-    this->ssid = ssid;
-    this->password = password;
-  }
-
-  bool begin() {
-    context[0] = this;
-    server.on("/", T_GET, parse, context.data(), context.size());
-
-    // connect to WIFI
-    if (ssid != nullptr && password != nullptr) {
-      return server.begin(port, ssid, password);
-    }
-    return server.begin(port);
-  }
-
-  void loop() { server.copy(); }
-  void copy() { server.copy(); }
-
-  /// Defines the buffer size that is made available for the http reply
-  void setBufferSize(int size){
-    buffer_size = size;
-  }
-
  protected:
-  WiFiServer wifi;
-  HttpServer server{wifi};
   KARadioProtocol protocol;
-  RingBuffer<uint8_t> ringBuffer{0};
-  QueueStream<uint8_t> queueStream{ringBuffer};
-  Vector<void*> context{1};
-  int port = 80;
-  const char* ssid = nullptr;
-  const char* password = nullptr;
-  int buffer_size = 512;
-
-  static void parse(HttpServer* server, const char* requestPath,
-                    HttpRequestHandlerLine* hl) {
-    LOGI("parse: %s", requestPath);
-    KARadioProtocolServer* self = (KARadioProtocolServer*)hl->context[0];
-    self->ringBuffer.resize(self->buffer_size);
-    QueueStream<uint8_t>& queueStream = self->queueStream;
-    queueStream.begin();
-    bool ok = self->protocol.processCommand(requestPath, queueStream);
-    LOGI("available: %d", queueStream.available());
-    server->reply("text/plain", queueStream, queueStream.available(),
-                  ok ? 200 : 400, ok ? SUCCESS : "Error");
-    self->ringBuffer.resize(0);
-  }
 };
 }  // namespace audio_tools