cmux moved to a separate class

esp_modem/examples/simple_cxx_client/main/simple_client.cpp

@@ -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?");

esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -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;
 };
 
 

esp_modem/src/esp_modem_cmux.cpp

@@ -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;
+static CMUXedTerminal * s_cmux;
-bool DTE::s_on_cmux(size_t len)
+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 CMUXedTerminal::setup_cmux()
-
-void DTE::setup_cmux()
 {
-//    if (type == (FT_UA | PF)) {
+    s_cmux = this;
-//        ESP_LOGI("CMUX", "SAMB ok");
-//    }
-
-    s_dte = 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;
+}

esp_modem/src/esp_modem_dte.cpp

@@ -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)
+        term(std::move(terminal)), mode(dte_mode::UNDEF) {}
-{
-//    buffer = new std::shared_ptr<uint8_t[]>(buffer_size, [](uint8_t p[]){ delete[] p;});
-
-}
 
 command_result DTE::command(const std::string& command, got_line_cb got_line, uint32_t time_ms)
 {