andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-07 00:09:51 +03:00
Code Issues Packages Projects Releases Wiki Activity

comments

Browse Source
This commit is contained in:
proddy
2020-10-07 19:16:55 +02:00
parent 8bf55e74c5
commit 07992c391b
3 changed files with 218 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/ArduinoJson/src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp
View File

@@ -23,7 +23,6 @@ class MsgPackDeserializer {
_stringStorage(stringStorage),
_error(DeserializationError::Ok) {}
// TODO: add support for filter
DeserializationError parse(VariantData &variant, AllowAllFilter,
NestingLimit nestingLimit) {
parseVariant(variant, nestingLimit);

338
lib/ESPAsyncTCP/src/ESPAsyncTCPbuffer.cpp
View File

@@ -29,49 +29,49 @@
#include "ESPAsyncTCPbuffer.h"
AsyncTCPbuffer::AsyncTCPbuffer(AsyncClient* client) {
if(client == NULL) {
AsyncTCPbuffer::AsyncTCPbuffer(AsyncClient * client) {
if (client == NULL) {
DEBUG_ASYNC_TCP("[A-TCP] client is null!!!\n");
panic();
}
_client = client;
_TXbufferWrite = new (std::nothrow) cbuf(TCP_MSS);
_TXbufferRead = _TXbufferWrite;
_RXbuffer = new (std::nothrow) cbuf(100);
_RXmode = ATB_RX_MODE_FREE;
_rxSize = 0;
_rxTerminator = 0x00;
_rxReadBytesPtr = NULL;
_client = client;
_TXbufferWrite = new (std::nothrow) cbuf(TCP_MSS);
_TXbufferRead = _TXbufferWrite;
_RXbuffer = new (std::nothrow) cbuf(100);
_RXmode = ATB_RX_MODE_FREE;
_rxSize = 0;
_rxTerminator = 0x00;
_rxReadBytesPtr = NULL;
_rxReadStringPtr = NULL;
_cbDisconnect = NULL;
_cbDisconnect = NULL;
_cbRX = NULL;
_cbRX = NULL;
_cbDone = NULL;
_attachCallbacks();
}
AsyncTCPbuffer::~AsyncTCPbuffer() {
if(_client) {
if (_client) {
_client->close();
}
if(_RXbuffer) {
if (_RXbuffer) {
delete _RXbuffer;
_RXbuffer = NULL;
}
if(_TXbufferWrite) {
if (_TXbufferWrite) {
// will be deleted in _TXbufferRead chain
_TXbufferWrite = NULL;
}
if(_TXbufferRead) {
if (_TXbufferRead) {
cbuf * next = _TXbufferRead->next;
delete _TXbufferRead;
while(next != NULL) {
while (next != NULL) {
_TXbufferRead = next;
next = _TXbufferRead->next;
next = _TXbufferRead->next;
delete _TXbufferRead;
}
_TXbufferRead = NULL;
@@ -86,12 +86,12 @@ size_t AsyncTCPbuffer::write(uint8_t data) {
return write(&data, 1);
}
size_t AsyncTCPbuffer::write(const char* data) {
return write((const uint8_t *) data, strlen(data));
size_t AsyncTCPbuffer::write(const char * data) {
return write((const uint8_t *)data, strlen(data));
}
size_t AsyncTCPbuffer::write(const char *data, size_t len) {
return write((const uint8_t *) data, len);
size_t AsyncTCPbuffer::write(const char * data, size_t len) {
return write((const uint8_t *)data, len);
}
/**
@@ -100,29 +100,28 @@ size_t AsyncTCPbuffer::write(const char *data, size_t len) {
* @param len
* @return
*/
size_t AsyncTCPbuffer::write(const uint8_t *data, size_t len) {
if(_TXbufferWrite == NULL || _client == NULL || !_client->connected() || data == NULL || len == 0) {
size_t AsyncTCPbuffer::write(const uint8_t * data, size_t len) {
if (_TXbufferWrite == NULL || _client == NULL || !_client->connected() || data == NULL || len == 0) {
return 0;
}
size_t bytesLeft = len;
while(bytesLeft) {
size_t w = _TXbufferWrite->write((const char*) data, bytesLeft);
while (bytesLeft) {
size_t w = _TXbufferWrite->write((const char *)data, bytesLeft);
bytesLeft -= w;
data += w;
_sendBuffer();
// add new buffer since we have more data
if(_TXbufferWrite->full() && bytesLeft > 0) {
if (_TXbufferWrite->full() && bytesLeft > 0) {
// to less ram!!!
if(ESP.getFreeHeap() < 4096) {
if (ESP.getFreeHeap() < 4096) {
DEBUG_ASYNC_TCP("[A-TCP] run out of Heap can not send all Data!\n");
return (len - bytesLeft);
}
cbuf * next = new (std::nothrow) cbuf(TCP_MSS);
if(next == NULL) {
if (next == NULL) {
DEBUG_ASYNC_TCP("[A-TCP] run out of Heap!\n");
panic();
} else {
@@ -138,19 +137,18 @@ size_t AsyncTCPbuffer::write(const uint8_t *data, size_t len) {
}
return len;
}
/**
* wait until all data has send out
*/
void AsyncTCPbuffer::flush() {
while(!_TXbufferWrite->empty()) {
while(connected() && !_client->canSend()) {
delay(0);
while (!_TXbufferWrite->empty()) {
while (connected() && !_client->canSend()) {
delay(0);
}
if(!connected())
return;
if (!connected())
return;
_sendBuffer();
}
}
@@ -160,16 +158,16 @@ void AsyncTCPbuffer::noCallback() {
}
void AsyncTCPbuffer::readStringUntil(char terminator, String * str, AsyncTCPbufferDoneCb done) {
if(_client == NULL) {
if (_client == NULL) {
return;
}
DEBUG_ASYNC_TCP("[A-TCP] readStringUntil terminator: %02X\n", terminator);
_RXmode = ATB_RX_MODE_NONE;
_cbDone = done;
_RXmode = ATB_RX_MODE_NONE;
_cbDone = done;
_rxReadStringPtr = str;
_rxTerminator = terminator;
_rxSize = 0;
_RXmode = ATB_RX_MODE_TERMINATOR_STRING;
_rxTerminator = terminator;
_rxSize = 0;
_RXmode = ATB_RX_MODE_TERMINATOR_STRING;
}
/*
@@ -188,30 +186,30 @@ void AsyncTCPbuffer::readStringUntil(char terminator, String * str, AsyncTCPbuff
}
*/
void AsyncTCPbuffer::readBytes(char *buffer, size_t length, AsyncTCPbufferDoneCb done) {
if(_client == NULL) {
void AsyncTCPbuffer::readBytes(char * buffer, size_t length, AsyncTCPbufferDoneCb done) {
if (_client == NULL) {
return;
}
DEBUG_ASYNC_TCP("[A-TCP] readBytes length: %d\n", length);
_RXmode = ATB_RX_MODE_NONE;
_cbDone = done;
_rxReadBytesPtr = (uint8_t *) buffer;
_rxSize = length;
_RXmode = ATB_RX_MODE_READ_BYTES;
_RXmode = ATB_RX_MODE_NONE;
_cbDone = done;
_rxReadBytesPtr = (uint8_t *)buffer;
_rxSize = length;
_RXmode = ATB_RX_MODE_READ_BYTES;
}
void AsyncTCPbuffer::readBytes(uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done) {
readBytes((char *) buffer, length, done);
void AsyncTCPbuffer::readBytes(uint8_t * buffer, size_t length, AsyncTCPbufferDoneCb done) {
readBytes((char *)buffer, length, done);
}
void AsyncTCPbuffer::onData(AsyncTCPbufferDataCb cb) {
if(_client == NULL) {
if (_client == NULL) {
return;
}
DEBUG_ASYNC_TCP("[A-TCP] onData\n");
_RXmode = ATB_RX_MODE_NONE;
_cbDone = NULL;
_cbRX = cb;
_cbRX = cb;
_RXmode = ATB_RX_MODE_FREE;
}
@@ -220,44 +218,43 @@ void AsyncTCPbuffer::onDisconnect(AsyncTCPbufferDisconnectCb cb) {
}
IPAddress AsyncTCPbuffer::remoteIP() {
if(!_client) {
if (!_client) {
return IPAddress(0U);
}
return _client->remoteIP();
}
uint16_t AsyncTCPbuffer::remotePort() {
if(!_client) {
if (!_client) {
return 0;
}
return _client->remotePort();
}
bool AsyncTCPbuffer::connected() {
if(!_client) {
if (!_client) {
return false;
}
return _client->connected();
}
void AsyncTCPbuffer::stop() {
if(!_client) {
if (!_client) {
return;
}
_client->stop();
_client = NULL;
if(_cbDone) {
switch(_RXmode) {
case ATB_RX_MODE_READ_BYTES:
case ATB_RX_MODE_TERMINATOR:
case ATB_RX_MODE_TERMINATOR_STRING:
_RXmode = ATB_RX_MODE_NONE;
_cbDone(false, NULL);
break;
default:
break;
if (_cbDone) {
switch (_RXmode) {
case ATB_RX_MODE_READ_BYTES:
case ATB_RX_MODE_TERMINATOR:
case ATB_RX_MODE_TERMINATOR_STRING:
_RXmode = ATB_RX_MODE_NONE;
_cbDone(false, NULL);
break;
default:
break;
}
}
_RXmode = ATB_RX_MODE_NONE;
@@ -274,56 +271,66 @@ void AsyncTCPbuffer::close() {
* attachCallbacks to AsyncClient class
*/
void AsyncTCPbuffer::_attachCallbacks() {
if(!_client) {
if (!_client) {
return;
}
DEBUG_ASYNC_TCP("[A-TCP] attachCallbacks\n");
_client->onPoll([](void *obj, AsyncClient* c) {
(void)c;
AsyncTCPbuffer* b = ((AsyncTCPbuffer*)(obj));
if((b->_TXbufferRead != NULL) && !b->_TXbufferRead->empty()) {
b->_sendBuffer();
}
// if(!b->_RXbuffer->empty()) {
// b->_handleRxBuffer(NULL, 0);
// }
}, this);
_client->onPoll(
[](void * obj, AsyncClient * c) {
(void)c;
AsyncTCPbuffer * b = ((AsyncTCPbuffer *)(obj));
if ((b->_TXbufferRead != NULL) && !b->_TXbufferRead->empty()) {
b->_sendBuffer();
}
// if(!b->_RXbuffer->empty()) {
// b->_handleRxBuffer(NULL, 0);
// }
},
this);
_client->onAck([](void *obj, AsyncClient* c, size_t len, uint32_t time) {
(void)c;
(void)len;
(void)time;
DEBUG_ASYNC_TCP("[A-TCP] onAck\n");
((AsyncTCPbuffer*)(obj))->_sendBuffer();
}, this);
_client->onAck(
[](void * obj, AsyncClient * c, size_t len, uint32_t time) {
(void)c;
(void)len;
(void)time;
DEBUG_ASYNC_TCP("[A-TCP] onAck\n");
((AsyncTCPbuffer *)(obj))->_sendBuffer();
},
this);
_client->onDisconnect([](void *obj, AsyncClient* c) {
DEBUG_ASYNC_TCP("[A-TCP] onDisconnect\n");
AsyncTCPbuffer* b = ((AsyncTCPbuffer*)(obj));
b->_client = NULL;
bool del = true;
if(b->_cbDisconnect) {
del = b->_cbDisconnect(b);
}
delete c;
if(del) {
delete b;
}
}, this);
_client->onDisconnect(
[](void * obj, AsyncClient * c) {
DEBUG_ASYNC_TCP("[A-TCP] onDisconnect\n");
AsyncTCPbuffer * b = ((AsyncTCPbuffer *)(obj));
b->_client = NULL;
bool del = true;
if (b->_cbDisconnect) {
del = b->_cbDisconnect(b);
}
delete c;
if (del) {
delete b;
}
},
this);
_client->onData([](void *obj, AsyncClient* c, void *buf, size_t len) {
(void)c;
AsyncTCPbuffer* b = ((AsyncTCPbuffer*)(obj));
b->_rxData((uint8_t *)buf, len);
}, this);
_client->onData(
[](void * obj, AsyncClient * c, void * buf, size_t len) {
(void)c;
AsyncTCPbuffer * b = ((AsyncTCPbuffer *)(obj));
b->_rxData((uint8_t *)buf, len);
},
this);
_client->onTimeout([](void *obj, AsyncClient* c, uint32_t time){
(void)obj;
(void)time;
DEBUG_ASYNC_TCP("[A-TCP] onTimeout\n");
c->close();
}, this);
_client->onTimeout(
[](void * obj, AsyncClient * c, uint32_t time) {
(void)obj;
(void)time;
DEBUG_ASYNC_TCP("[A-TCP] onTimeout\n");
c->close();
},
this);
DEBUG_ASYNC_TCP("[A-TCP] attachCallbacks Done.\n");
}
@@ -334,20 +341,19 @@ void AsyncTCPbuffer::_attachCallbacks() {
void AsyncTCPbuffer::_sendBuffer() {
//DEBUG_ASYNC_TCP("[A-TCP] _sendBuffer...\n");
size_t available = _TXbufferRead->available();
if(available == 0 || _client == NULL || !_client->connected() || !_client->canSend()) {
if (available == 0 || _client == NULL || !_client->connected() || !_client->canSend()) {
return;
}
while(connected() && (_client->space() > 0) && (_TXbufferRead->available() > 0) && _client->canSend()) {
while (connected() && (_client->space() > 0) && (_TXbufferRead->available() > 0) && _client->canSend()) {
available = _TXbufferRead->available();
if(available > _client->space()) {
if (available > _client->space()) {
available = _client->space();
}
char *out = new (std::nothrow) char[available];
if(out == NULL) {
char * out = new (std::nothrow) char[available];
if (out == NULL) {
DEBUG_ASYNC_TCP("[A-TCP] to less heap, try later.\n");
return;
}
@@ -356,10 +362,10 @@ void AsyncTCPbuffer::_sendBuffer() {
_TXbufferRead->peek(out, available);
// send data
size_t send = _client->write((const char*) out, available);
if(send != available) {
size_t send = _client->write((const char *)out, available);
if (send != available) {
DEBUG_ASYNC_TCP("[A-TCP] write failed send: %d available: %d \n", send, available);
if(!connected()) {
if (!connected()) {
DEBUG_ASYNC_TCP("[A-TCP] incomplete transfer, connection lost.\n");
}
}
@@ -368,8 +374,8 @@ void AsyncTCPbuffer::_sendBuffer() {
_TXbufferRead->remove(send);
// if buffer is empty and there is a other buffer in chain delete the empty one
if(_TXbufferRead->available() == 0 && _TXbufferRead->next != NULL) {
cbuf * old = _TXbufferRead;
if (_TXbufferRead->available() == 0 && _TXbufferRead->next != NULL) {
cbuf * old = _TXbufferRead;
_TXbufferRead = _TXbufferRead->next;
delete old;
DEBUG_ASYNC_TCP("[A-TCP] delete cbuf\n");
@@ -377,7 +383,6 @@ void AsyncTCPbuffer::_sendBuffer() {
delete out;
}
}
/**
@@ -385,12 +390,12 @@ void AsyncTCPbuffer::_sendBuffer() {
* @param buf
* @param len
*/
void AsyncTCPbuffer::_rxData(uint8_t *buf, size_t len) {
if(!_client || !_client->connected()) {
void AsyncTCPbuffer::_rxData(uint8_t * buf, size_t len) {
if (!_client || !_client->connected()) {
DEBUG_ASYNC_TCP("[A-TCP] not connected!\n");
return;
}
if(!_RXbuffer) {
if (!_RXbuffer) {
DEBUG_ASYNC_TCP("[A-TCP] _rxData no _RXbuffer!\n");
return;
}
@@ -398,14 +403,14 @@ void AsyncTCPbuffer::_rxData(uint8_t *buf, size_t len) {
size_t handled = 0;
if(_RXmode != ATB_RX_MODE_NONE) {
handled = _handleRxBuffer((uint8_t *) buf, len);
if (_RXmode != ATB_RX_MODE_NONE) {
handled = _handleRxBuffer((uint8_t *)buf, len);
buf += handled;
len -= handled;
// handle as much as possible before using the buffer
if(_RXbuffer->empty()) {
while(_RXmode != ATB_RX_MODE_NONE && handled != 0 && len > 0) {
if (_RXbuffer->empty()) {
while (_RXmode != ATB_RX_MODE_NONE && handled != 0 && len > 0) {
handled = _handleRxBuffer(buf, len);
buf += handled;
len -= handled;
@@ -413,88 +418,86 @@ void AsyncTCPbuffer::_rxData(uint8_t *buf, size_t len) {
}
}
if(len > 0) {
if(_RXbuffer->room() < len) {
if (len > 0) {
if (_RXbuffer->room() < len) {
// to less space
DEBUG_ASYNC_TCP("[A-TCP] _rxData buffer full try resize\n");
_RXbuffer->resizeAdd((len + _RXbuffer->room()));
if(_RXbuffer->room() < len) {
if (_RXbuffer->room() < len) {
DEBUG_ASYNC_TCP("[A-TCP] _rxData buffer to full can only handle %d!!!\n", _RXbuffer->room());
}
}
_RXbuffer->write((const char *) (buf), len);
_RXbuffer->write((const char *)(buf), len);
}
if(!_RXbuffer->empty() && _RXmode != ATB_RX_MODE_NONE) {
if (!_RXbuffer->empty() && _RXmode != ATB_RX_MODE_NONE) {
// handle as much as possible data in buffer
handled = _handleRxBuffer(NULL, 0);
while(_RXmode != ATB_RX_MODE_NONE && handled != 0) {
while (_RXmode != ATB_RX_MODE_NONE && handled != 0) {
handled = _handleRxBuffer(NULL, 0);
}
}
// clean up ram
if(_RXbuffer->empty() && _RXbuffer->room() != 100) {
if (_RXbuffer->empty() && _RXbuffer->room() != 100) {
_RXbuffer->resize(100);
}
}
/**
*
*/
size_t AsyncTCPbuffer::_handleRxBuffer(uint8_t *buf, size_t len) {
if(!_client || !_client->connected() || _RXbuffer == NULL) {
size_t AsyncTCPbuffer::_handleRxBuffer(uint8_t * buf, size_t len) {
if (!_client || !_client->connected() || _RXbuffer == NULL) {
return 0;
}
DEBUG_ASYNC_TCP("[A-TCP] _handleRxBuffer len: %d RXmode: %d\n", len, _RXmode);
size_t BufferAvailable = _RXbuffer->available();
size_t r = 0;
size_t r = 0;
if(_RXmode == ATB_RX_MODE_NONE) {
if (_RXmode == ATB_RX_MODE_NONE) {
return 0;
} else if(_RXmode == ATB_RX_MODE_FREE) {
if(_cbRX == NULL) {
} else if (_RXmode == ATB_RX_MODE_FREE) {
if (_cbRX == NULL) {
return 0;
}
if(BufferAvailable > 0) {
if (BufferAvailable > 0) {
uint8_t * b = new (std::nothrow) uint8_t[BufferAvailable];
if(b == NULL){
panic(); //TODO: What action should this be ?
if (b == NULL) {
panic();
}
_RXbuffer->peek((char *) b, BufferAvailable);
_RXbuffer->peek((char *)b, BufferAvailable);
r = _cbRX(b, BufferAvailable);
_RXbuffer->remove(r);
}
if(r == BufferAvailable && buf && (len > 0)) {
if (r == BufferAvailable && buf && (len > 0)) {
return _cbRX(buf, len);
} else {
return 0;
}
} else if(_RXmode == ATB_RX_MODE_READ_BYTES) {
if(_rxReadBytesPtr == NULL || _cbDone == NULL) {
} else if (_RXmode == ATB_RX_MODE_READ_BYTES) {
if (_rxReadBytesPtr == NULL || _cbDone == NULL) {
return 0;
}
size_t newReadCount = 0;
if(BufferAvailable) {
r = _RXbuffer->read((char *) _rxReadBytesPtr, _rxSize);
if (BufferAvailable) {
r = _RXbuffer->read((char *)_rxReadBytesPtr, _rxSize);
_rxSize -= r;
_rxReadBytesPtr += r;
}
if(_RXbuffer->empty() && (len > 0) && buf) {
if (_RXbuffer->empty() && (len > 0) && buf) {
r = len;
if(r > _rxSize) {
if (r > _rxSize) {
r = _rxSize;
}
memcpy(_rxReadBytesPtr, buf, r);
@@ -503,7 +506,7 @@ size_t AsyncTCPbuffer::_handleRxBuffer(uint8_t *buf, size_t len) {
newReadCount += r;
}
if(_rxSize == 0) {
if (_rxSize == 0) {
_RXmode = ATB_RX_MODE_NONE;
_cbDone(true, NULL);
}
@@ -511,19 +514,18 @@ size_t AsyncTCPbuffer::_handleRxBuffer(uint8_t *buf, size_t len) {
// add left over bytes to Buffer
return newReadCount;
} else if(_RXmode == ATB_RX_MODE_TERMINATOR) {
// TODO implement read terminator non string
} else if(_RXmode == ATB_RX_MODE_TERMINATOR_STRING) {
if(_rxReadStringPtr == NULL || _cbDone == NULL) {
} else if (_RXmode == ATB_RX_MODE_TERMINATOR) {
//
} else if (_RXmode == ATB_RX_MODE_TERMINATOR_STRING) {
if (_rxReadStringPtr == NULL || _cbDone == NULL) {
return 0;
}
// handle Buffer
if(BufferAvailable > 0) {
while(!_RXbuffer->empty()) {
if (BufferAvailable > 0) {
while (!_RXbuffer->empty()) {
char c = _RXbuffer->read();
if(c == _rxTerminator || c == 0x00) {
if (c == _rxTerminator || c == 0x00) {
_RXmode = ATB_RX_MODE_NONE;
_cbDone(true, _rxReadStringPtr);
return 0;
@@ -533,13 +535,13 @@ size_t AsyncTCPbuffer::_handleRxBuffer(uint8_t *buf, size_t len) {
}
}
if(_RXbuffer->empty() && (len > 0) && buf) {
if (_RXbuffer->empty() && (len > 0) && buf) {
size_t newReadCount = 0;
while(newReadCount < len) {
char c = (char) *buf;
while (newReadCount < len) {
char c = (char)*buf;
buf++;
newReadCount++;
if(c == _rxTerminator || c == 0x00) {
if (c == _rxTerminator || c == 0x00) {
_RXmode = ATB_RX_MODE_NONE;
_cbDone(true, _rxReadStringPtr);
return newReadCount;

107
lib/ESPAsyncTCP/src/ESPAsyncTCPbuffer.h
View File

@@ -38,81 +38,70 @@
typedef enum {
ATB_RX_MODE_NONE,
ATB_RX_MODE_FREE,
ATB_RX_MODE_READ_BYTES,
ATB_RX_MODE_TERMINATOR,
ATB_RX_MODE_TERMINATOR_STRING
} atbRxMode_t;
typedef enum { ATB_RX_MODE_NONE, ATB_RX_MODE_FREE, ATB_RX_MODE_READ_BYTES, ATB_RX_MODE_TERMINATOR, ATB_RX_MODE_TERMINATOR_STRING } atbRxMode_t;
class AsyncTCPbuffer: public Print {
class AsyncTCPbuffer : public Print {
public:
typedef std::function<size_t(uint8_t * payload, size_t length)> AsyncTCPbufferDataCb;
typedef std::function<void(bool ok, void * ret)> AsyncTCPbufferDoneCb;
typedef std::function<bool(AsyncTCPbuffer * obj)> AsyncTCPbufferDisconnectCb;
public:
AsyncTCPbuffer(AsyncClient * c);
virtual ~AsyncTCPbuffer();
typedef std::function<size_t(uint8_t * payload, size_t length)> AsyncTCPbufferDataCb;
typedef std::function<void(bool ok, void * ret)> AsyncTCPbufferDoneCb;
typedef std::function<bool(AsyncTCPbuffer * obj)> AsyncTCPbufferDisconnectCb;
size_t write(String & data);
size_t write(uint8_t data);
size_t write(const char * data);
size_t write(const char * data, size_t len);
size_t write(const uint8_t * data, size_t len);
AsyncTCPbuffer(AsyncClient* c);
virtual ~AsyncTCPbuffer();
void flush();
size_t write(String & data);
size_t write(uint8_t data);
size_t write(const char* data);
size_t write(const char *data, size_t len);
size_t write(const uint8_t *data, size_t len);
void noCallback();
void flush();
void readStringUntil(char terminator, String * str, AsyncTCPbufferDoneCb done);
void noCallback();
//void readBytesUntil(char terminator, char *buffer, size_t length, AsyncTCPbufferDoneCb done);
//void readBytesUntil(char terminator, uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done);
void readStringUntil(char terminator, String * str, AsyncTCPbufferDoneCb done);
void readBytes(char * buffer, size_t length, AsyncTCPbufferDoneCb done);
void readBytes(uint8_t * buffer, size_t length, AsyncTCPbufferDoneCb done);
// TODO implement read terminator non string
//void readBytesUntil(char terminator, char *buffer, size_t length, AsyncTCPbufferDoneCb done);
//void readBytesUntil(char terminator, uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done);
// void setTimeout(size_t timeout);
void readBytes(char *buffer, size_t length, AsyncTCPbufferDoneCb done);
void readBytes(uint8_t *buffer, size_t length, AsyncTCPbufferDoneCb done);
void onData(AsyncTCPbufferDataCb cb);
void onDisconnect(AsyncTCPbufferDisconnectCb cb);
// TODO implement
// void setTimeout(size_t timeout);
IPAddress remoteIP();
uint16_t remotePort();
IPAddress localIP();
uint16_t localPort();
void onData(AsyncTCPbufferDataCb cb);
void onDisconnect(AsyncTCPbufferDisconnectCb cb);
bool connected();
IPAddress remoteIP();
uint16_t remotePort();
IPAddress localIP();
uint16_t localPort();
void stop();
void close();
bool connected();
protected:
AsyncClient * _client;
cbuf * _TXbufferRead;
cbuf * _TXbufferWrite;
cbuf * _RXbuffer;
atbRxMode_t _RXmode;
size_t _rxSize;
char _rxTerminator;
uint8_t * _rxReadBytesPtr;
String * _rxReadStringPtr;
void stop();
void close();
protected:
AsyncClient* _client;
cbuf * _TXbufferRead;
cbuf * _TXbufferWrite;
cbuf * _RXbuffer;
atbRxMode_t _RXmode;
size_t _rxSize;
char _rxTerminator;
uint8_t * _rxReadBytesPtr;
String * _rxReadStringPtr;
AsyncTCPbufferDataCb _cbRX;
AsyncTCPbufferDoneCb _cbDone;
AsyncTCPbufferDisconnectCb _cbDisconnect;
void _attachCallbacks();
void _sendBuffer();
void _on_close();
void _rxData(uint8_t *buf, size_t len);
size_t _handleRxBuffer(uint8_t *buf, size_t len);
AsyncTCPbufferDataCb _cbRX;
AsyncTCPbufferDoneCb _cbDone;
AsyncTCPbufferDisconnectCb _cbDisconnect;
void _attachCallbacks();
void _sendBuffer();
void _on_close();
void _rxData(uint8_t * buf, size_t len);
size_t _handleRxBuffer(uint8_t * buf, size_t len);
};
#endif /* ESPASYNCTCPBUFFER_H_ */