espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-18 04:52:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

cmux moved to a separate class

Browse Source
This commit is contained in:
David Cermak
2021-03-05 21:18:38 +01:00
parent fbb4791af1
commit fdfca36919
4 changed files with 87 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
esp_modem/examples/simple_cxx_client/main/simple_client.cpp
View File

@ -320,7 +320,8 @@ static void modem_test_app(esp_modem_dte_config_t *dte_config, esp_modem_dce_con
while (1) {
vTaskDelay(pdMS_TO_TICKS(1000));
uart_dte->send_cmux_command(1, "AT+CPIN?\r");
// uart_dte->send_cmux_command(1, "AT+CPIN?\r");
uart_dte->write((uint8_t*)"AT+CPIN?\r", 9);
}
// uart_dte->send_cmux_command(2, "AT+CPIN?");

71
esp_modem/include/cxx_include/esp_modem_dte.hpp
View File

@ -33,16 +33,23 @@ protected:
std::function<void(terminal_error)> on_error;
};
enum class cmux_state {
INIT,
HEADER,
PAYLOAD,
FOOTER,
};
class CMUXedTerminal: public Terminal {
public:
explicit CMUXedTerminal(std::unique_ptr<Terminal> t, std::shared_ptr<uint8_t[]> b):
explicit CMUXedTerminal(std::unique_ptr<Terminal> t, std::unique_ptr<uint8_t[]> b, size_t buff_size):
term(std::move(t)), buffer(std::move(b)) {}
~CMUXedTerminal() override = default;
void setup_cmux() {
}
void setup_cmux();
void set_data_cb(std::function<bool(size_t len)> f) override {}
int write(uint8_t *data, size_t len) override { return term->write(data, len); }
int write(uint8_t *data, size_t len) override;
int read(uint8_t *data, size_t len) override { return term->read(data, len); }
void start() override;
void stop() override {}
@ -50,7 +57,18 @@ private:
static bool process_cmux_recv(size_t len);
void send_sabm(size_t i);
std::unique_ptr<Terminal> term;
std::shared_ptr<uint8_t[]> buffer;
cmux_state state;
uint8_t dlci;
uint8_t type;
size_t payload_len;
uint8_t frame_header[6];
size_t frame_header_offset;
size_t buffer_size;
size_t consumed;
std::unique_ptr<uint8_t[]> buffer;
bool on_cmux(size_t len);
static bool s_on_cmux(size_t len);
};
@ -74,16 +92,30 @@ struct CMUXHelper {
void send_sabm(size_t dlci);
};
enum class cmux_state {
INIT,
HEADER,
PAYLOAD,
FOOTER,
};
typedef std::function<command_result(uint8_t *data, size_t len)> got_line_cb;
//class CMUX {
//public:
// void setup_cmux();
// void send_sabm(size_t dlci);
//
// bool on_cmux(size_t len);
// static bool s_on_cmux(size_t len);
// cmux_state state;
// uint8_t dlci;
// uint8_t type;
// size_t payload_len;
// uint8_t frame_header[6];
// size_t frame_header_offset;
// size_t buffer_size;
// size_t consumed;
//// std::shared_ptr<std::vector<uint8_t>> buffer;
// std::unique_ptr<uint8_t[]> buffer;
//
//};
class DTE {
public:
explicit DTE(std::unique_ptr<Terminal> t);
@ -122,9 +154,9 @@ public:
void send_cmux_command(uint8_t i, const std::string& command);
private:
// std::unique_ptr<CMUXedTerminal> cmux;
void setup_cmux();
void send_sabm(size_t dlci);
// void send_sabm(size_t dlci);
// CMUXHelper cmux;
static const size_t GOT_LINE = BIT0;
size_t buffer_size;
@ -132,19 +164,12 @@ private:
// std::shared_ptr<std::vector<uint8_t>> buffer;
std::unique_ptr<uint8_t[]> buffer;
std::unique_ptr<Terminal> term;
got_line_cb on_line;
// got_line_cb on_line;
dte_mode mode;
signal_group signal;
std::function<bool(size_t len)> on_data;
bool on_cmux(size_t len);
static bool s_on_cmux(size_t len);
cmux_state state;
uint8_t dlci;
uint8_t type;
size_t payload_len;
uint8_t frame_header[6];
size_t frame_header_offset;
};

80
esp_modem/src/esp_modem_cmux.cpp
View File

@ -77,7 +77,7 @@ void CMUXedTerminal::start()
}
}
void DTE::send_sabm(size_t dlci)
void CMUXedTerminal::send_sabm(size_t dlci)
{
uint8_t frame[6];
frame[0] = SOF_MARKER;
@ -86,37 +86,6 @@ void DTE::send_sabm(size_t dlci)
frame[3] = 1;
frame[4] = 0xFF - crc8(&frame[1], 3, FCS_POLYNOMIAL, FCS_INIT_VALUE, true);
frame[5] = SOF_MARKER;
// term->set_data_cb([&](size_t len) {
//// consumed = 0;
// auto data_to_read = std::min(len, DTE_BUFFER_SIZE - consumed);
// auto data = buffer.get() + consumed;
// auto actual_len = term->read(data, data_to_read);
// ESP_LOG_BUFFER_HEXDUMP("TEST", data, actual_len, ESP_LOG_INFO);
// auto available_len = consumed + actual_len;
// if (available_len > 4) {
// if (data[0] != SOF_MARKER) {
// ESP_LOGE("CMUX", "TODO: Recover!");
// return true;
// }
// auto frame = buffer.get();
// uint8_t dlci = frame[1] >> 2;
// uint8_t type = frame[2];
// uint8_t length = frame[3] >> 1;
// ESP_LOGW("CMUX", "CMUX FR: A:%02x T:%02x L:%d consumed:%d", dlci, type, length, consumed);
// size_t frame_len = length + 6;
// if (available_len >= frame_len) { // we have entire frame
// if (frame[frame_len-1] != SOF_MARKER) {
// ESP_LOGE("CMUX", "TODO: Recover!");
// return true;
// }
// if (type == (FT_UA | PF)) {
// ESP_LOGI("CMUX", "SAMB ok");
// }
//
// }
// }
// return false;
// });
term->write(frame, 6);
}
@ -125,10 +94,10 @@ bool CMUXedTerminal::process_cmux_recv(size_t len)
return false;
}
static DTE * s_dte;
bool DTE::s_on_cmux(size_t len)
static CMUXedTerminal * s_cmux;
bool CMUXedTerminal::s_on_cmux(size_t len)
{
s_dte->on_cmux(len);
s_cmux->on_cmux(len);
return false;
}
@ -144,7 +113,7 @@ bool output(uint8_t *data, size_t len, std::string message)
return true;
}
bool DTE::on_cmux(size_t len)
bool CMUXedTerminal::on_cmux(size_t len)
{
auto data_to_read = std::min(len, buffer_size);
auto data = buffer.get();
@ -228,15 +197,9 @@ bool DTE::on_cmux(size_t len)
}
return true;
}
void DTE::setup_cmux()
void CMUXedTerminal::setup_cmux()
{
// if (type == (FT_UA | PF)) {
// ESP_LOGI("CMUX", "SAMB ok");
// }
s_dte = this;
s_cmux = this;
frame_header_offset = 0;
state = cmux_state::INIT;
term->set_data_cb(s_on_cmux);
@ -248,6 +211,15 @@ void DTE::setup_cmux()
}
}
void DTE::setup_cmux()
{
auto original_term = std::move(term);
auto cmux_term = std::make_unique<CMUXedTerminal>(std::move(original_term), std::move(buffer), buffer_size);
buffer_size = 0;
cmux_term->setup_cmux();
term = std::move(cmux_term);
}
void DTE::send_cmux_command(uint8_t i, const std::string& command)
{
@ -269,3 +241,23 @@ void DTE::send_cmux_command(uint8_t i, const std::string& command)
ESP_LOG_BUFFER_HEXDUMP("Send", (uint8_t *)command.c_str(), command.length(), ESP_LOG_INFO);
ESP_LOG_BUFFER_HEXDUMP("Send", frame+4, 2, ESP_LOG_INFO);
}
int CMUXedTerminal::write(uint8_t *data, size_t len) {
size_t i = 1;
uint8_t frame[6];
frame[0] = SOF_MARKER;
frame[1] = (i << 2) + 1;
frame[2] = FT_UIH;
frame[3] = (len << 1) + 1;
frame[4] = 0xFF - crc8(&frame[1], 3, FCS_POLYNOMIAL, FCS_INIT_VALUE, true);
frame[5] = SOF_MARKER;
term->write(frame, 4);
term->write(data, len);
term->write(frame + 4, 2);
ESP_LOG_BUFFER_HEXDUMP("Send", frame, 4, ESP_LOG_INFO);
ESP_LOG_BUFFER_HEXDUMP("Send", data, len, ESP_LOG_INFO);
ESP_LOG_BUFFER_HEXDUMP("Send", frame+4, 2, ESP_LOG_INFO);
return 0;
}

10
esp_modem/src/esp_modem_dte.cpp
View File

@ -4,16 +4,8 @@
DTE::DTE(std::unique_ptr<Terminal> terminal):
buffer_size(DTE_BUFFER_SIZE), consumed(0),
// buffer(std::make_shared<std::vector<uint8_t>>(buffer_size)),
// buffer(new uint8_t[buffer_size], std::default_delete<uint8_t[]>()),
// buffer(new uint8_t[buffer_size], std::default_delete<uint8_t[]>()),
// buffer(nullptr),
buffer(std::make_unique<uint8_t[]>(buffer_size)),
term(std::move(terminal)), mode(dte_mode::UNDEF)
{
// buffer = new std::shared_ptr<uint8_t[]>(buffer_size, [](uint8_t p[]){ delete[] p;});
}
term(std::move(terminal)), mode(dte_mode::UNDEF) {}
command_result DTE::command(const std::string& command, got_line_cb got_line, uint32_t time_ms)
{