Refactor, fix ESP32 WebSocketSerial (#13689)

6 years ago · 20dc45bca7
2 changed files with 124 additions and 220 deletions
--- a/Marlin/src/HAL/HAL_ESP32/WebSocketSerial.cpp
+++ b/Marlin/src/HAL/HAL_ESP32/WebSocketSerial.cpp
@ -21,213 +21,132 @@
 */
 #ifdef ARDUINO_ARCH_ESP32

-#include "../../inc/MarlinConfig.h"
+#include "../../inc/MarlinConfigPre.h"

 #if ENABLED(WIFISUPPORT)

 #include "WebSocketSerial.h"
-
-extern WebSocketSerial webSocketSerial;
-
 #include "wifi.h"
-#include <AsyncTCP.h>
 #include <ESPAsyncWebServer.h>

-struct ring_buffer_r {
-  unsigned char buffer[RX_BUFFER_SIZE];
-  volatile ring_buffer_pos_t head, tail;
-};
-
-struct ring_buffer_t {
-  unsigned char buffer[256];
-  volatile uint8_t head, tail;
-};
-
-ring_buffer_r rx_buffer = { { 0 }, 0, 0 };
-ring_buffer_t tx_buffer = { { 0 }, 0, 0 };
-
-static bool _written;
+WebSocketSerial webSocketSerial;
+AsyncWebSocket ws("/ws"); // TODO Move inside the class.

-#if ENABLED(EMERGENCY_PARSER)
-  static EmergencyParser::State emergency_state; // = EP_RESET
-#endif
+// RingBuffer impl

-AsyncWebSocket ws("/ws"); // access at ws://[esp ip]/ws
+#define NEXT_INDEX(I, SIZE) ((I + 1) & (ring_buffer_pos_t)(SIZE - 1))

-FORCE_INLINE int next_rx_index(const int i) { return (ring_buffer_pos_t)(i + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1); }
-FORCE_INLINE int next_tx_index(const int i) { return (ring_buffer_pos_t)(i + 1) & (ring_buffer_pos_t)(TX_BUFFER_SIZE - 1); }
+RingBuffer::RingBuffer(ring_buffer_pos_t size)
+  : data(new uint8_t[size]),
+    read_index(0),
+    write_index(0),
+    size(size)
+{}

-static void addToBuffer(uint8_t * const data, const size_t len) {
-  for (size_t i = 0; i < len; i++) {
-    ring_buffer_pos_t h = rx_buffer.head;
-    const ring_buffer_pos_t t = rx_buffer.tail, n = next_rx_index(h);
+RingBuffer::~RingBuffer() { delete[] data; }

-    if (n != t) { rx_buffer.buffer[h] = data[i]; h = n; }
-
-    // TODO: buffer is full, handle?
-
-    rx_buffer.head = h;
-  }
-}
+ring_buffer_pos_t RingBuffer::write(const uint8_t c) {
+  const ring_buffer_pos_t n = NEXT_INDEX(write_index, size);

-// Handle WebSocket event
-static void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len) {
-  switch (type) {
-    case WS_EVT_CONNECT: client->ping(); break; // client connected
-    case WS_EVT_DISCONNECT:                     // client disconnected
-    case WS_EVT_ERROR:                          // error was received from the other end
-    case WS_EVT_PONG: break;                    // pong message was received (in response to a ping request maybe)
-    case WS_EVT_DATA: {                         // data packet
-      AwsFrameInfo * info = (AwsFrameInfo*)arg;
-      if (info->opcode == WS_TEXT || info->message_opcode == WS_TEXT)
-        addToBuffer(data, len);
-    }
+  if (n != read_index) {
+    this->data[write_index] = c;
+    write_index = n;
+    return 1;
  }
-}

-// Public Methods
-void WebSocketSerial::begin(const long baud_setting) {
-  ws.onEvent(onEvent);
-  server.addHandler(&ws); // attach AsyncWebSocket
+  // TODO: buffer is full, handle?
+  return 0;
 }

-void WebSocketSerial::end() { }
-
-int WebSocketSerial::peek(void) {
-  const int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
-  return v;
+ring_buffer_pos_t RingBuffer::write(const uint8_t *buffer, ring_buffer_pos_t size) {
+  ring_buffer_pos_t written = 0;
+  for (ring_buffer_pos_t i = 0; i < size; i++) {
+    written += write(buffer[i]);
+  }
+  return written;
 }

-int WebSocketSerial::read(void) {
-  const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail;
-  if (h == t) return -1;  // Nothing to read? Return now
-
-  const int v = rx_buffer.buffer[t];
-
-  rx_buffer.tail = (ring_buffer_pos_t)(t + 1) & (RX_BUFFER_SIZE - 1); // Advance tail
-
-  return v;
+int RingBuffer::available(void) {
+  return (size - read_index + write_index) & (size - 1);
 }

-bool WebSocketSerial::available(void) {
-  const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail;
-  return (ring_buffer_pos_t)(RX_BUFFER_SIZE + h - t) & (RX_BUFFER_SIZE - 1);
+int RingBuffer::peek(void) {
+  return available() ? data[read_index] : -1;
 }

-void WebSocketSerial::flush(void) {
-  ws.textAll("flush");
-  rx_buffer.tail = rx_buffer.head;
+int RingBuffer::read(void) {
+  if (available()) {
+    const int ret = data[read_index];
+    read_index = NEXT_INDEX(read_index, size);
+    return ret;
+  }
+  return -1;
 }

-#if TX_BUFFER_SIZE
-
-  void WebSocketSerial::write(const uint8_t c) {
-    _written = true;
-
-    const uint8_t i = (tx_buffer.head + 1) & (TX_BUFFER_SIZE - 1);
+ring_buffer_pos_t RingBuffer::read(uint8_t *buffer) {
+   ring_buffer_pos_t len = available();

-    // Store new char. head is always safe to move
-    tx_buffer.buffer[tx_buffer.head] = c;
-    tx_buffer.head = i;
-
-    if (c == '\n') {
-      ws.textAll(tx_buffer.buffer, tx_buffer.head);
-      tx_buffer.head = 0;
-    }
+  for(ring_buffer_pos_t i = 0; read_index != write_index; i++) {
+    buffer[i] = data[read_index];
+    read_index = NEXT_INDEX(read_index, size);
  }

-  void WebSocketSerial::flushTx(void) {
-    ws.textAll("flushTx");
-    if (!_written) return;
-  }
-
-#else
+  return len;
+}

- //void WebSocketSerial::write(const uint8_t c) { _written = true; }
- //void WebSocketSerial::flushTx(void) { if (!_written) return; }
+void RingBuffer::flush(void) { read_index = write_index; }

-#endif
+// WebSocketSerial impl
+WebSocketSerial::WebSocketSerial()
+    : rx_buffer(RingBuffer(RX_BUFFER_SIZE)),
+      tx_buffer(RingBuffer(TX_BUFFER_SIZE))
+{}

-/**
- * Imports from print.h
- */
+void WebSocketSerial::begin(const long baud_setting) {
+  ws.onEvent([this](AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
+    switch (type) {
+      case WS_EVT_CONNECT: client->ping(); break; // client connected
+      case WS_EVT_DISCONNECT:                     // client disconnected
+      case WS_EVT_ERROR:                          // error was received from the other end
+      case WS_EVT_PONG: break;                    // pong message was received (in response to a ping request maybe)
+      case WS_EVT_DATA: {                         // data packet
+        AwsFrameInfo * info = (AwsFrameInfo*)arg;
+        if (info->opcode == WS_TEXT || info->message_opcode == WS_TEXT)
+          this->rx_buffer.write(data, len);
+      }
+    }
+  });
+  server.addHandler(&ws);
+}

-void WebSocketSerial::print(char c, int base) { print((long)c, base); }
-void WebSocketSerial::print(unsigned char b, int base) { print((unsigned long)b, base); }
-void WebSocketSerial::print(int n, int base) { print((long)n, base); }
-void WebSocketSerial::print(unsigned int n, int base) { print((unsigned long)n, base); }
-void WebSocketSerial::print(long n, int base) {
-  if (base == 0)
-    write(n);
-  else if (base == 10) {
-    if (n < 0) { print('-'); n = -n; }
-    printNumber(n, 10);
+void WebSocketSerial::end() { }
+int WebSocketSerial::peek(void) { return rx_buffer.peek(); }
+int WebSocketSerial::read(void) { return rx_buffer.read(); }
+int WebSocketSerial::available(void) { return rx_buffer.available(); }
+void WebSocketSerial::flush(void) { rx_buffer.flush(); }
+
+size_t WebSocketSerial::write(const uint8_t c) {
+  size_t ret = tx_buffer.write(c);
+
+  if (ret && c == '\n') {
+    uint8_t tmp[TX_BUFFER_SIZE];
+    ring_buffer_pos_t size = tx_buffer.read(tmp);
+    ws.textAll(tmp, size);
  }
-  else
-    printNumber(n, base);
-}

-void WebSocketSerial::print(unsigned long n, int base) {
-  if (base == 0) write(n); else printNumber(n, base);
+  return ret;
 }

-void WebSocketSerial::print(double n, int digits)         { printFloat(n, digits); }
-
-void WebSocketSerial::println(void)                       { print('\r'); print('\n'); }
-void WebSocketSerial::println(const String& s)            { print(s); println(); }
-void WebSocketSerial::println(const char c[])             { print(c); println(); }
-void WebSocketSerial::println(char c, int base)           { print(c, base); println(); }
-void WebSocketSerial::println(unsigned char b, int base)  { print(b, base); println(); }
-void WebSocketSerial::println(int n, int base)            { print(n, base); println(); }
-void WebSocketSerial::println(unsigned int n, int base)   { print(n, base); println(); }
-void WebSocketSerial::println(long n, int base)           { print(n, base); println(); }
-void WebSocketSerial::println(unsigned long n, int base)  { print(n, base); println(); }
-void WebSocketSerial::println(double n, int digits)       { print(n, digits); println(); }
-
-// Private Methods
-
-void WebSocketSerial::printNumber(unsigned long n, uint8_t base) {
-  if (n) {
-    unsigned char buf[8 * sizeof(long)]; // Enough space for base 2
-    int8_t i = 0;
-    while (n) {
-      buf[i++] = n % base;
-      n /= base;
-    }
-    while (i--)
-      print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
+size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
+  size_t written = 0;
+  for(size_t i = 0; i < size; i++) {
+    written += write(buffer[i]);
  }
-  else
-    print('0');
+  return written;
 }

-void WebSocketSerial::printFloat(double number, uint8_t digits) {
-  // Handle negative numbers
-  if (number < 0.0) { print('-'); number = -number; }
-
-  // Round correctly so that print(1.999, 2) prints as "2.00"
-  // Use a lookup table for performance
-  constexpr double rounds[] = { 0.5, 0.05, 0.005, 0.0005, 0.00005, 0.000005, 0.0000005, 0.00000005 };
-  number += rounds[digits];
-
-  //number += pow(10, -(digits + 1)); // slower single-line equivalent
-
-  // Extract the integer part of the number and print it
-  unsigned long int_part = (unsigned long)number;
-  print(int_part);
-
-  // Print the decimal point, but only if there are digits beyond
-  double remainder = number - (double)int_part;
-  if (digits) {
-    print('.');
-    // Extract digits from the remainder one at a time
-    while (digits--) {
-      remainder *= 10.0;
-      const int toPrint = int(remainder);
-      print(toPrint);
-      remainder -= toPrint;
-    }
-  }
+void WebSocketSerial::flushTX(void) {
+  // No need to do anything as there's no benefit to sending partial lines over the websocket connection.
 }

 #endif // WIFISUPPORT
--- a/Marlin/src/HAL/HAL_ESP32/WebSocketSerial.h
+++ b/Marlin/src/HAL/HAL_ESP32/WebSocketSerial.h
@ -23,12 +23,7 @@

 #include "../../inc/MarlinConfig.h"

-#include <WString.h>
-
-#define DEC 10
-#define HEX 16
-#define OCT 8
-#define BIN 2
+#include "Stream.h"

 #ifndef RX_BUFFER_SIZE
  #define RX_BUFFER_SIZE 128
@ -40,60 +35,50 @@
  #error "TX_BUFFER_SIZE is required for the WebSocket."
 #endif

-#if RX_BUFFER_SIZE > 256
-  typedef uint16_t ring_buffer_pos_t;
-#else
-  typedef uint8_t ring_buffer_pos_t;
-#endif
+typedef uint16_t ring_buffer_pos_t;

-class WebSocketSerial {
-public:
-  WebSocketSerial() {};
-  static void begin(const long);
-  static void end();
-  static int peek(void);
-  static int read(void);
-  static void flush(void);
-  static void flushTx(void);
-  static bool available(void);
-  static void write(const uint8_t c);
+class RingBuffer {
+  uint8_t *data;
+  ring_buffer_pos_t size, read_index, write_index;

-  #if ENABLED(SERIAL_STATS_DROPPED_RX)
-    FORCE_INLINE static uint32_t dropped() { return 0; }
-  #endif
+public:
+  RingBuffer(ring_buffer_pos_t size);
+  ~RingBuffer();

-  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
-    FORCE_INLINE static int rxMaxEnqueued() { return 0; }
-  #endif
+  int available(void);
+  int peek(void);
+  int read(void);
+  ring_buffer_pos_t read(uint8_t *buffer);
+  void flush(void);
+  ring_buffer_pos_t write(const uint8_t c);
+  ring_buffer_pos_t write(const uint8_t* buffer, ring_buffer_pos_t size);
+};

-  FORCE_INLINE static void write(const char* str) { while (*str) write(*str++); }
-  FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); }
-  FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
-  FORCE_INLINE static void print(const char* str) { write(str); }
+class WebSocketSerial: public Stream {
+  RingBuffer rx_buffer;
+  RingBuffer tx_buffer;

-  static void print(char, int = 0);
-  static void print(unsigned char, int = 0);
-  static void print(int, int = DEC);
-  static void print(unsigned int, int = DEC);
-  static void print(long, int = DEC);
-  static void print(unsigned long, int = DEC);
-  static void print(double, int = 2);
+public:
+  WebSocketSerial();
+  void begin(const long);
+  void end();
+  int available(void);
+  int peek(void);
+  int read(void);
+  void flush(void);
+  void flushTX(void);
+  size_t write(const uint8_t c);
+  size_t write(const uint8_t* buffer, size_t size);

-  static void println(const String& s);
-  static void println(const char[]);
-  static void println(char, int = 0);
-  static void println(unsigned char, int = 0);
-  static void println(int, int = DEC);
-  static void println(unsigned int, int = DEC);
-  static void println(long, int = DEC);
-  static void println(unsigned long, int = DEC);
-  static void println(double, int = 2);
-  static void println(void);
  operator bool() { return true; }

-private:
-  static void printNumber(unsigned long, const uint8_t);
-  static void printFloat(double, uint8_t);
+  #if ENABLED(SERIAL_STATS_DROPPED_RX)
+    FORCE_INLINE uint32_t dropped() { return 0; }
+  #endif
+
+  #if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
+    FORCE_INLINE int rxMaxEnqueued() { return 0; }
+  #endif
 };

 extern WebSocketSerial webSocketSerial;