andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Refactor, fix ESP32 WebSocketSerial (#13689)

pull/1/head
Kajetan Rzepecki 6 years ago
committed by Scott Lahteine
parent
db373f130c
commit
20dc45bca7
2 changed files with 124 additions and 220 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 251
      Marlin/src/HAL/HAL_ESP32/WebSocketSerial.cpp
  2. 89
      Marlin/src/HAL/HAL_ESP32/WebSocketSerial.h

251
Marlin/src/HAL/HAL_ESP32/WebSocketSerial.cpp
View File

@ -21,213 +21,132 @@
*/ */
#ifdef ARDUINO_ARCH_ESP32 #ifdef ARDUINO_ARCH_ESP32
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfigPre.h"
#if ENABLED(WIFISUPPORT) #if ENABLED(WIFISUPPORT)
#include "WebSocketSerial.h" #include "WebSocketSerial.h"
extern WebSocketSerial webSocketSerial;
#include "wifi.h" #include "wifi.h"
#include <AsyncTCP.h>
#include <ESPAsyncWebServer.h> #include <ESPAsyncWebServer.h>
struct ring_buffer_r { WebSocketSerial webSocketSerial;
unsigned char buffer[RX_BUFFER_SIZE]; AsyncWebSocket ws("/ws"); // TODO Move inside the class.
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; // RingBuffer impl
#if ENABLED(EMERGENCY_PARSER) #define NEXT_INDEX(I, SIZE) ((I + 1) & (ring_buffer_pos_t)(SIZE - 1))
static EmergencyParser::State emergency_state; // = EP_RESET
#endif
AsyncWebSocket ws("/ws"); // access at ws://[esp ip]/ws RingBuffer::RingBuffer(ring_buffer_pos_t size)
: data(new uint8_t[size]),
read_index(0),
write_index(0),
size(size)
{}
FORCE_INLINE int next_rx_index(const int i) { return (ring_buffer_pos_t)(i + 1) & (ring_buffer_pos_t)(RX_BUFFER_SIZE - 1); } RingBuffer::~RingBuffer() { delete[] data; }
FORCE_INLINE int next_tx_index(const int i) { return (ring_buffer_pos_t)(i + 1) & (ring_buffer_pos_t)(TX_BUFFER_SIZE - 1); }
static void addToBuffer(uint8_t * const data, const size_t len) { ring_buffer_pos_t RingBuffer::write(const uint8_t c) {
for (size_t i = 0; i < len; i++) { const ring_buffer_pos_t n = NEXT_INDEX(write_index, size);
ring_buffer_pos_t h = rx_buffer.head;
const ring_buffer_pos_t t = rx_buffer.tail, n = next_rx_index(h);
if (n != t) { rx_buffer.buffer[h] = data[i]; h = n; } if (n != read_index) {
this->data[write_index] = c;
write_index = n;
return 1;
}
// TODO: buffer is full, handle? // TODO: buffer is full, handle?
return 0;
rx_buffer.head = h;
}
} }
// Handle WebSocket event ring_buffer_pos_t RingBuffer::write(const uint8_t *buffer, ring_buffer_pos_t size) {
static void onEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len) { ring_buffer_pos_t written = 0;
switch (type) { for (ring_buffer_pos_t i = 0; i < size; i++) {
case WS_EVT_CONNECT: client->ping(); break; // client connected written += write(buffer[i]);
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);
}
} }
return written;
} }
// Public Methods int RingBuffer::available(void) {
void WebSocketSerial::begin(const long baud_setting) { return (size - read_index + write_index) & (size - 1);
ws.onEvent(onEvent);
server.addHandler(&ws); // attach AsyncWebSocket
} }
void WebSocketSerial::end() { } int RingBuffer::peek(void) {
return available() ? data[read_index] : -1;
int WebSocketSerial::peek(void) {
const int v = rx_buffer.head == rx_buffer.tail ? -1 : rx_buffer.buffer[rx_buffer.tail];
return v;
} }
int WebSocketSerial::read(void) { int RingBuffer::read(void) {
const ring_buffer_pos_t h = rx_buffer.head, t = rx_buffer.tail; if (available()) {
if (h == t) return -1; // Nothing to read? Return now const int ret = data[read_index];
read_index = NEXT_INDEX(read_index, size);
const int v = rx_buffer.buffer[t]; return ret;
}
rx_buffer.tail = (ring_buffer_pos_t)(t + 1) & (RX_BUFFER_SIZE - 1); // Advance tail return -1;
return v;
}
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);
} }
void WebSocketSerial::flush(void) { ring_buffer_pos_t RingBuffer::read(uint8_t *buffer) {
ws.textAll("flush"); ring_buffer_pos_t len = available();
rx_buffer.tail = rx_buffer.head;
}
#if TX_BUFFER_SIZE 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::write(const uint8_t c) { return len;
_written = true; }
const uint8_t i = (tx_buffer.head + 1) & (TX_BUFFER_SIZE - 1); void RingBuffer::flush(void) { read_index = write_index; }
// Store new char. head is always safe to move // WebSocketSerial impl
tx_buffer.buffer[tx_buffer.head] = c; WebSocketSerial::WebSocketSerial()
tx_buffer.head = i; : rx_buffer(RingBuffer(RX_BUFFER_SIZE)),
tx_buffer(RingBuffer(TX_BUFFER_SIZE))
{}
if (c == '\n') { void WebSocketSerial::begin(const long baud_setting) {
ws.textAll(tx_buffer.buffer, tx_buffer.head); ws.onEvent([this](AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type, void *arg, uint8_t *data, size_t len) {
tx_buffer.head = 0; 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);
} }
void WebSocketSerial::flushTx(void) {
ws.textAll("flushTx");
if (!_written) return;
} }
});
server.addHandler(&ws);
}
#else void WebSocketSerial::end() { }
int WebSocketSerial::peek(void) { return rx_buffer.peek(); }
//void WebSocketSerial::write(const uint8_t c) { _written = true; } int WebSocketSerial::read(void) { return rx_buffer.read(); }
//void WebSocketSerial::flushTx(void) { if (!_written) return; } int WebSocketSerial::available(void) { return rx_buffer.available(); }
void WebSocketSerial::flush(void) { rx_buffer.flush(); }
#endif
size_t WebSocketSerial::write(const uint8_t c) {
/** size_t ret = tx_buffer.write(c);
* Imports from print.h
*/ if (ret && c == '\n') {
uint8_t tmp[TX_BUFFER_SIZE];
void WebSocketSerial::print(char c, int base) { print((long)c, base); } ring_buffer_pos_t size = tx_buffer.read(tmp);
void WebSocketSerial::print(unsigned char b, int base) { print((unsigned long)b, base); } ws.textAll(tmp, size);
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);
} }
else
printNumber(n, base);
}
void WebSocketSerial::print(unsigned long n, int base) { return ret;
if (base == 0) write(n); else printNumber(n, base);
} }
void WebSocketSerial::print(double n, int digits) { printFloat(n, digits); } size_t WebSocketSerial::write(const uint8_t* buffer, size_t size) {
size_t written = 0;
void WebSocketSerial::println(void) { print('\r'); print('\n'); } for(size_t i = 0; i < size; i++) {
void WebSocketSerial::println(const String& s) { print(s); println(); } written += write(buffer[i]);
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--) return written;
print((char)(buf[i] + (buf[i] < 10 ? '0' : 'A' - 10)));
}
else
print('0');
} }
void WebSocketSerial::printFloat(double number, uint8_t digits) { void WebSocketSerial::flushTX(void) {
// Handle negative numbers // No need to do anything as there's no benefit to sending partial lines over the websocket connection.
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;
}
}
} }
#endif // WIFISUPPORT #endif // WIFISUPPORT

89
Marlin/src/HAL/HAL_ESP32/WebSocketSerial.h
View File

@ -23,12 +23,7 @@
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfig.h"
#include <WString.h> #include "Stream.h"
#define DEC 10
#define HEX 16
#define OCT 8
#define BIN 2
#ifndef RX_BUFFER_SIZE #ifndef RX_BUFFER_SIZE
#define RX_BUFFER_SIZE 128 #define RX_BUFFER_SIZE 128
@ -40,60 +35,50 @@
#error "TX_BUFFER_SIZE is required for the WebSocket." #error "TX_BUFFER_SIZE is required for the WebSocket."
#endif #endif
#if RX_BUFFER_SIZE > 256 typedef uint16_t ring_buffer_pos_t;
typedef uint16_t ring_buffer_pos_t;
#else
typedef uint8_t ring_buffer_pos_t;
#endif
class WebSocketSerial { class RingBuffer {
public: uint8_t *data;
WebSocketSerial() {}; ring_buffer_pos_t size, read_index, write_index;
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);
#if ENABLED(SERIAL_STATS_DROPPED_RX) public:
FORCE_INLINE static uint32_t dropped() { return 0; } RingBuffer(ring_buffer_pos_t size);
#endif ~RingBuffer();
#if ENABLED(SERIAL_STATS_MAX_RX_QUEUED) int available(void);
FORCE_INLINE static int rxMaxEnqueued() { return 0; } int peek(void);
#endif 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++); } class WebSocketSerial: public Stream {
FORCE_INLINE static void write(const uint8_t* buffer, size_t size) { while (size--) write(*buffer++); } RingBuffer rx_buffer;
FORCE_INLINE static void print(const String& s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); } RingBuffer tx_buffer;
FORCE_INLINE static void print(const char* str) { write(str); }
static void print(char, int = 0); public:
static void print(unsigned char, int = 0); WebSocketSerial();
static void print(int, int = DEC); void begin(const long);
static void print(unsigned int, int = DEC); void end();
static void print(long, int = DEC); int available(void);
static void print(unsigned long, int = DEC); int peek(void);
static void print(double, int = 2); 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; } operator bool() { return true; }
private: #if ENABLED(SERIAL_STATS_DROPPED_RX)
static void printNumber(unsigned long, const uint8_t); FORCE_INLINE uint32_t dropped() { return 0; }
static void printFloat(double, uint8_t); #endif
#if ENABLED(SERIAL_STATS_MAX_RX_QUEUED)
FORCE_INLINE int rxMaxEnqueued() { return 0; }
#endif
}; };
extern WebSocketSerial webSocketSerial; extern WebSocketSerial webSocketSerial;

Write Preview
Loading…
Cancel
Save