cxx modem data mode working

esp_modem/examples/simple_cxx_client/main/simple_client.cpp

@@ -277,17 +277,27 @@ static void modem_test_app(esp_modem_dte_config_t *dte_config, esp_modem_dce_con
 //        std::cout << response << std::endl;
 //        return true;
 //    }, 1000);
+
+//    return;
     esp_netif_t *esp_netif = esp_netif_new(ppp_config);
     assert(esp_netif);
 
     auto my_dce = create_dce(ddd, esp_netif);
 
-    ddd->send_command("AT+COPS=?\r", [&](uint8_t *data, size_t len) {
+    my_dce->command("AT+CPIN?\r", [&](uint8_t *data, size_t len) {
         std::string response((char*)data, len);
         ESP_LOGI("in the lambda", "len=%d data %s", len, (char*)data);
         std::cout << response << std::endl;
         return true;
-    }, 60000);
+    }, 1000);
+
+    my_dce->set_data();
+//    ddd->send_command("AT+COPS=?\r", [&](uint8_t *data, size_t len) {
+//        std::string response((char*)data, len);
+//        ESP_LOGI("in the lambda", "len=%d data %s", len, (char*)data);
+//        std::cout << response << std::endl;
+//        return true;
+//    }, 60000);
 
 //    auto uart = create_uart_terminal(dte_config);
 //    uart->set_data_cb([&](size_t len){

esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -66,11 +66,23 @@ public:
   ~dte() = default;
 //  void set_line_cb(got_line f) { on_line_cb = std::move(f); }
     int write(uint8_t *data, size_t len)  { return term->write(data, len); }
-    int read(uint8_t *data, size_t len)   { return term->read(data, len); }
+    int read(uint8_t **d, size_t len)   {
+        auto data_to_read = std::min(len, buffer_size);
+        auto data = buffer.get();
+        auto actual_len = term->read(data, data_to_read);
+        *d = data;
+        return actual_len;
+    }
+    void set_data_cb(std::function<void(size_t len)> f) { on_data = std::move(f); }
 
     void start() { term->start(); }
     void data_mode_closed() { term->stop(); }
-  void set_mode(dte_mode m) { term->start(); mode = m; }
+  void set_mode(dte_mode m) {
+        term->start(); mode = m;
+        if (m == dte_mode::DATA_MODE) {
+            term->set_data_cb(on_data);
+        }
+    }
   bool send_command(const std::string& command, got_line_cb got_line, uint32_t time_ms);
 
 private:
@@ -82,14 +94,29 @@ private:
     got_line_cb on_line;
     dte_mode mode;
     signal_group signal;
+    std::function<void(size_t len)> on_data;
 };
 
 
 class dce {
 public:
     explicit dce(std::shared_ptr<dte> d, esp_netif_t * netif);
+    void set_data() {
+        command("AT+CGDCONT=1,\"IP\",\"internet\"\r", [&](uint8_t *data, size_t len) {
+            return true;
+        }, 1000);
+        command("ATD*99***1#\r", [&](uint8_t *data, size_t len) {
+            return true;
+        }, 1000);
+
+        dce_dte->set_mode(dte_mode::DATA_MODE);
+        ppp_netif.start();
+    }
+    bool command(const std::string& command, got_line_cb got_line, uint32_t time_ms) {
+        return dce_dte->send_command(command, got_line, time_ms);
+    }
 private:
-    std::shared_ptr<dte> _dte;
+    std::shared_ptr<dte> dce_dte;
     ppp ppp_netif;
 };
 

esp_modem/include/cxx_include/ppp_netif.hpp

@@ -20,9 +20,11 @@ class ppp {
 public:
     explicit ppp(std::shared_ptr<dte> e, esp_netif_t *netif);
 
+    void start();
 private:
+    void receive(uint8_t *data, size_t len) const;
+    std::shared_ptr<dte> ppp_dte;
     esp_netif_t *netif;
-    std::shared_ptr<dte> _dte;
     struct ppp_netif_driver driver;
 };
 

esp_modem/src/esp_modem_dte.cpp

@@ -348,6 +348,6 @@ bool dte::send_command(const std::string& command, got_line_cb got_line, uint32_
 }
 
 dce::dce(std::shared_ptr<dte> e, esp_netif_t * netif):
-_dte(std::move(e)), ppp_netif(e, netif)
+dce_dte(e), ppp_netif(e, netif)
 { }
 

esp_modem/src/ppp_netif.cpp

@@ -18,6 +18,7 @@ static void on_ppp_changed(void *arg, esp_event_base_t event_base,
                            int32_t event_id, void *event_data)
 {
     dte *e = (dte*)arg;
+    ESP_LOGW("TAG", "PPP state changed event %d", event_id);
     if (event_id < NETIF_PP_PHASE_OFFSET) {
         ESP_LOGI("TAG", "PPP state changed event %d", event_id);
         // only notify the modem on state/error events, ignoring phase transitions
@@ -35,10 +36,9 @@ static esp_err_t esp_modem_dte_transmit(void *h, void *buffer, size_t len)
     return ESP_FAIL;
 }
 
-
 static esp_err_t esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
 {
-    ppp_netif_driver *d = (ppp_netif_driver*)args;
+    auto d = (ppp_netif_driver*)args;
     esp_netif_driver_ifconfig_t driver_ifconfig = { };
     driver_ifconfig.transmit = esp_modem_dte_transmit;
     driver_ifconfig.handle = (void*)d->e;
@@ -58,12 +58,26 @@ static esp_err_t esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
     return ESP_OK;
 }
 
+void ppp::receive(uint8_t *data, size_t len) const
+{
+    esp_netif_receive(driver.base.netif, data, len, nullptr);
+}
 
 ppp::ppp(std::shared_ptr<dte> e, esp_netif_t *ppp_netif):
-    netif(ppp_netif), _dte(std::move(e))
+    ppp_dte(std::move(e)), netif(ppp_netif)
 {
     driver.base.netif = ppp_netif;
-    driver.e = this->_dte.get();
+    driver.e = this->ppp_dte.get();
     driver.base.post_attach = esp_modem_post_attach;
+    ppp_dte->set_data_cb([&](size_t len){
+        uint8_t *data;
+        auto actual_len = ppp_dte->read(&data, len);
+        return receive(data, actual_len);
+    });
     throw_if_esp_fail(esp_netif_attach(ppp_netif, &driver));
 }
+
+void ppp::start()
+{
+    esp_netif_action_start(driver.base.netif, 0, 0, 0);
+}