CMUX: Initial version of CMUX implementation

esp_modem/include/cxx_include/esp_modem_cmux.hpp

@@ -15,7 +15,11 @@
 #ifndef _ESP_MODEM_CMUX_HPP_
 #define _ESP_MODEM_CMUX_HPP_
 
+#include "esp_modem_terminal.hpp"
+
 namespace esp_modem {
+
+constexpr size_t max_terms = 2;
 /**
  * @defgroup ESP_MODEM_CMUX ESP_MODEM CMUX class
  * @brief Definition of CMUX terminal
@@ -43,19 +47,20 @@ enum class cmux_state {
  *
  * @note Implementation of CMUX protocol is experimental
  */
-class CMUXedTerminal: public Terminal {
+class CMuxInstance;
+
+class CMux {
 public:
-    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 set_data_cb(std::function<bool(size_t len)> f) override {}
-    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 {}
+    explicit CMux(std::unique_ptr<Terminal> t, std::unique_ptr<uint8_t[]> b, size_t buff_size):
+            term(std::move(t)), buffer_size(buff_size), buffer(std::move(b)) {}
+    ~CMux() = default;
+    void init();
+    void set_read_cb(int inst, std::function<bool(uint8_t *data, size_t len)> f);
+
+    int write(int i, uint8_t *data, size_t len);
 private:
-    static bool process_cmux_recv(size_t len);
+    std::function<bool(uint8_t *data, size_t len)> read_cb[max_terms];
+    void data_available(uint8_t *data, size_t len);
     void send_sabm(size_t i);
     std::unique_ptr<Terminal> term;
     cmux_state state;
@@ -65,9 +70,25 @@ private:
     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);
+    bool on_cmux(uint8_t *data, size_t len);
+    static uint8_t fcs_crc(const uint8_t frame[6]);
+    Lock lock;
+    int instance;
+};
+
+class CMuxInstance: public Terminal {
+public:
+    explicit CMuxInstance(std::shared_ptr<CMux> parent, int i): cmux(std::move(parent)), instance(i) {}
+
+    int write(uint8_t *data, size_t len) override { return cmux->write(instance, data, len); }
+    void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f) override { return cmux->set_read_cb(instance, std::move(f)); }
+    int read(uint8_t *data, size_t len) override { return  0; }
+    void start() override { }
+    void stop() override { }
+private:
+    std::shared_ptr<CMux> cmux;
+    int instance;
 };
 
 /**

esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -42,8 +42,17 @@ public:
         return actual_len;
     }
 
-    void set_data_cb(std::function<bool(size_t len)> f) {
-        term->set_data_cb(std::move(f));
+    void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f)
+    {
+        on_data = std::move(f);
+        term->set_read_cb([this](uint8_t *data, size_t len) {
+            if (!data) {
+                auto data_to_read = std::min(len, buffer_size - consumed);
+                data = buffer.get();
+                len = term->read(data, data_to_read);
+            }
+            return on_data(data, len);
+        });
     }
 
     void start() { term->start(); }
@@ -54,7 +63,10 @@ public:
         term->start();
         mode = m;
         if (m == modem_mode::DATA_MODE) {
-            term->set_data_cb(on_data);
+            term->set_read_cb(on_data);
+            if (other_term) { // if we have the other terminal, let's use it for commands
+                command_term = other_term.get();
+            }
         } else if (m == modem_mode::CMUX_MODE) {
             setup_cmux();
         }
@@ -62,23 +74,32 @@ public:
 
     command_result command(const std::string &command, got_line_cb got_line, uint32_t time_ms) override;
 
-    void send_cmux_command(uint8_t i, const std::string &command);
 
 private:
     Lock lock;
 
     void setup_cmux();
+//    command_result command(Terminal *t, const std::string &command, got_line_cb got_line, uint32_t time_ms);
 
     static const size_t GOT_LINE = signal_group::bit0;
     size_t buffer_size;
     size_t consumed;
     std::unique_ptr<uint8_t[]> buffer;
     std::unique_ptr<Terminal> term;
+    Terminal *command_term;
+    std::unique_ptr<Terminal> other_term;
     modem_mode mode;
     signal_group signal;
-    std::function<bool(size_t len)> on_data;
+    std::function<bool(uint8_t *data, size_t len)> on_data;
 };
 
+//class DTE_inst: public DTE {
+//public:
+//    DTE_inst(std::shared_ptr<DTE> parent) : DTE(t), dte(parent) {}
+//private:
+//    std::shared_ptr<DTE> dte;
+//};
+
 } // namespace esp_modem
 
 #endif // _ESP_MODEM_DTE_HPP_

esp_modem/include/cxx_include/esp_modem_terminal.hpp

@@ -36,9 +36,10 @@ class Terminal {
 public:
     virtual ~Terminal() = default;
 
-    virtual void set_data_cb(std::function<bool(size_t len)> f) { on_data = std::move(f); }
+//    virtual void set_data_cb(std::function<bool(size_t len)> f) { on_data = std::move(f); }
 
     void set_error_cb(std::function<void(terminal_error)> f) { on_error = std::move(f); }
+    virtual void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f) { on_data = std::move(f); }
 
     virtual int write(uint8_t *data, size_t len) = 0;
 
@@ -51,7 +52,8 @@ public:
     virtual size_t max_virtual_terms() { return 1; }
 
 protected:
-    std::function<bool(size_t len)> on_data;
+//    std::function<bool(size_t len)> on_data;
+    std::function<bool(uint8_t *data, size_t len)> on_data;
     std::function<void(terminal_error)> on_error;
 };