experimental factory/builder

esp_modem/examples/ap_to_pppos/main/CMakeLists.txt

@@ -1,3 +1,5 @@
 idf_component_register(SRCS "ap2pppos_example_main.c"
-                            "modem_board.c"
+                            "NetworkDCE.cpp"
-                    INCLUDE_DIRS ".")
+                    INCLUDE_DIRS ".")
+
+#target_compile_features(${COMPONENT_LIB} PRIVATE cxx_std_17)

esp_modem/examples/ap_to_pppos/main/NetworkDCE.cpp

@@ -0,0 +1,116 @@
+//
+// Created by david on 3/25/21.
+//
+#include "cxx_include/esp_modem_dte.hpp"
+#include "esp_modem_config.h"
+#include "cxx_include/esp_modem_api.hpp"
+#include "cxx_include/esp_modem_dce_factory.hpp"
+#include <memory>
+#include <utility>
+
+class NetModule;
+typedef DCE_T<MinimalModule> NetDCE;
+
+class NetModule: public ModuleIf {
+public:
+    explicit NetModule(std::shared_ptr<DTE> dte):
+            dte(std::move(dte)) {}
+
+    bool setup_data_mode() override
+    {
+        set_command_mode(); // send in case we were in PPP mode, ignore potential failure
+        bool is_pin_ok;
+        if (read_pin(is_pin_ok) != command_result::OK)
+            return false;
+        if (!is_pin_ok) {
+            if (set_pin(pin) != command_result::OK)
+                return ESP_FAIL;
+            vTaskDelay(pdMS_TO_TICKS(1000));
+            if (read_pin(is_pin_ok) != command_result::OK || !is_pin_ok)
+                return ESP_FAIL;
+        }
+
+        PdpContext pdp(apn);
+        if (set_pdp_context(pdp) != command_result::OK)
+            return false;
+        return true;
+    }
+
+    bool set_mode(modem_mode mode) override
+    {
+        if (mode == modem_mode::DATA_MODE) {
+            if (set_data_mode() != command_result::OK)
+                return resume_data_mode() == command_result::OK;
+            return true;
+        }
+        if (mode == modem_mode::COMMAND_MODE) {
+            return set_command_mode() == command_result::OK;
+        }
+        return false;
+    }
+
+    static esp_err_t init(esp_netif_t *netif, std::string apn_name, std::string pin_number)
+    {
+        apn = std::move(apn_name);
+        pin = std::move(pin_number);
+        esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+        dte_config.event_task_stack_size = 4096;
+        dte_config.rx_buffer_size = 16384;
+        dte_config.tx_buffer_size = 2048;
+
+        // create
+        auto uart_dte = create_uart_dte(&dte_config);
+        esp_modem::DCE::Factory f(esp_modem::DCE::Modem::MinModule);
+        MinimalModule* module;
+        if (!f.build_module_T<MinimalModule>(module, uart_dte, netif)) {
+            return ESP_OK;
+        }
+        esp_modem::DCE::Factory f2(esp_modem::DCE::Modem::SIM7600);
+//        std::shared_ptr<MinimalModule> dev;
+        auto dev = f2.build_shared_module(uart_dte, netif);
+
+        //        esp_modem::DCE::Builder<MinimalModule> factory(uart_dte, netif);
+//        dce = factory.create(apn_name);
+//        auto pdp = std::make_unique<PdpContext>(apn);
+//        auto dev = std::make_shared<MinimalModule>(uart_dte, std::move(pdp));
+//        auto dev = std::make_shared<MinimalModule>(uart_dte, nullptr);
+//        dce = new DCE_T<MinimalModule>(uart_dte, module, netif);
+        return ESP_OK;
+    }
+
+    static void deinit()    { delete dce; }
+    static void start()     { dce->set_data();  }
+    static void stop()      { dce->exit_data(); }
+
+private:
+    static NetDCE *dce;
+    std::shared_ptr<DTE> dte;
+    static std::string apn;
+    static std::string pin;
+
+    template <typename ...T> command_result set_pdp_context(T&&... args) { return esp_modem::dce_commands::set_pdp_context(dte.get(),std::forward<T>(args)...); }
+    template <typename ...T> command_result set_pin(T&&... args) { return esp_modem::dce_commands::set_pin(dte.get(),std::forward<T>(args)...); }
+    template <typename ...T> command_result read_pin(T&&... args) { return esp_modem::dce_commands::read_pin(dte.get(),std::forward<T>(args)...); }
+    command_result set_data_mode() { return esp_modem::dce_commands::set_data_mode(dte.get()); }
+    command_result resume_data_mode() { return esp_modem::dce_commands::resume_data_mode(dte.get()); }
+    command_result set_command_mode() { return esp_modem::dce_commands::set_command_mode(dte.get()); }
+};
+
+NetDCE *NetModule::dce = nullptr;
+std::string NetModule::apn;
+std::string NetModule::pin;
+
+extern "C" esp_err_t modem_init_network(esp_netif_t *netif)
+{
+    return NetModule::init(netif, "internet", "1234");
+}
+
+extern "C" void modem_start_network()
+{
+    NetModule::start();
+}
+
+extern "C" void modem_stop_network()
+{
+    NetModule::stop();
+}

esp_modem/examples/ap_to_pppos/main/ap2pppos_example_main.c

@@ -12,7 +12,6 @@
 #include "esp_event.h"
 #include "esp_log.h"
 #include "nvs_flash.h"
-#include "esp_modem.h"
 #include "lwip/lwip_napt.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/event_groups.h"
@@ -35,6 +34,7 @@ static void on_modem_event(void *arg, esp_event_base_t event_base,
         if (event_id == IP_EVENT_PPP_GOT_IP) {
             esp_netif_dns_info_t dns_info;
 
+
             ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
             esp_netif_t *netif = event->esp_netif;
 
@@ -59,9 +59,6 @@ static void on_modem_event(void *arg, esp_event_base_t event_base,
             ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
             ESP_LOGI(TAG, "Got IPv6 address " IPV6STR, IPV62STR(event->ip6_info.ip));
         }
-    } else if (event_base == ESP_MODEM_EVENT) {
-        ESP_LOGD(TAG, "Modem event! %d", event_id);
-
     }
 }
 
@@ -125,7 +122,9 @@ void wifi_init_softap(void)
              EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS, EXAMPLE_ESP_WIFI_CHANNEL);
 }
 
-esp_modem_dce_t *sim7600_board_create(esp_modem_dce_config_t *config);
+esp_err_t modem_init_network(esp_netif_t *netif);
+void modem_start_network();
+void modem_stop_network();
 
 void app_main(void)
 {
@@ -142,29 +141,32 @@ void app_main(void)
     event_group = xEventGroupCreate();
 
     // init the DTE
-    esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
-    dte_config.event_task_stack_size = 4096;
-    dte_config.rx_buffer_size = 16384;
-    dte_config.tx_buffer_size = 2048;
-    esp_modem_dce_config_t dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG("internet23");
-    dce_config.populate_command_list = true;
     esp_netif_config_t ppp_netif_config = ESP_NETIF_DEFAULT_PPP();
+    esp_netif_t *ppp_netif = esp_netif_new(&ppp_netif_config);
+    assert(ppp_netif);
+
+    ESP_ERROR_CHECK(modem_init_network(ppp_netif));
+//    vTaskDelay(pdMS_TO_TICKS(1000));
+//    esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+//    dte_config.event_task_stack_size = 4096;
+//    dte_config.rx_buffer_size = 16384;
+//    dte_config.tx_buffer_size = 2048;
+//    esp_modem_dce_config_t dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG("internet23");
+//    dce_config.populate_command_list = true;
 
 
     // Initialize esp-modem units, DTE, DCE, ppp-netif
-    esp_modem_dte_t *dte = esp_modem_dte_new(&dte_config);
+//    esp_modem_dte_t *dte = esp_modem_dte_new(&dte_config);
-    esp_modem_dce_t *dce = sim7600_board_create(&dce_config);
+//    esp_modem_dce_t *dce = sim7600_board_create(&dce_config);
-    esp_netif_t *ppp_netif = esp_netif_new(&ppp_netif_config);
+//
-
+//    ESP_ERROR_CHECK(esp_modem_set_event_handler(dte, on_modem_event, ESP_EVENT_ANY_ID, dte));
-    assert(ppp_netif);
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_modem_event, NULL));
-
+//
-    ESP_ERROR_CHECK(esp_modem_set_event_handler(dte, on_modem_event, ESP_EVENT_ANY_ID, dte));
+//    ESP_ERROR_CHECK(esp_modem_default_attach(dte, dce, ppp_netif));
-    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_modem_event, dte));
+//
-
+//    ESP_ERROR_CHECK(esp_modem_default_start(dte)); // use retry
-    ESP_ERROR_CHECK(esp_modem_default_attach(dte, dce, ppp_netif));
+//    ESP_ERROR_CHECK(esp_modem_start_ppp(dte));
-
+    modem_start_network();
-    ESP_ERROR_CHECK(esp_modem_default_start(dte)); // use retry
-    ESP_ERROR_CHECK(esp_modem_start_ppp(dte));
     /* Wait for the first connection */
     EventBits_t bits;
     do {
@@ -186,8 +188,8 @@ void app_main(void)
     /* Provide recovery if disconnection of some kind registered */
     while (DISCONNECT_BIT&xEventGroupWaitBits(event_group, DISCONNECT_BIT, pdTRUE, pdFALSE, portMAX_DELAY)) {
         // restart the modem PPP mode
-        ESP_ERROR_CHECK(esp_modem_stop_ppp(dte));
+        modem_stop_network();
-        ESP_ERROR_CHECK(esp_modem_start_ppp(dte));
+        modem_start_network();
     }
 
 }

esp_modem/include/cxx_include/esp_modem_dce_factory.hpp

@@ -0,0 +1,261 @@
+//
+// Created by david on 3/28/21.
+//
+
+#ifndef AP_TO_PPPOS_ESP_MODEM_DCE_FACTORY_HPP
+#define AP_TO_PPPOS_ESP_MODEM_DCE_FACTORY_HPP
+
+namespace esp_modem::DCE {
+
+
+    class FactoryHelper {
+    public:
+        static std::unique_ptr<PdpContext> create_pdp_context(std::string &apn);
+
+        template <typename T, typename ...Args>
+        static bool make(T* &t, Args&&... args)
+        {
+            t = new T(std::forward<Args>(args)...);
+            return true;
+        }
+
+        template <typename T, typename ...Args>
+        static bool make(std::shared_ptr<T> &t, Args&&... args)
+        {
+            t = std::make_shared<T>(std::forward<Args>(args)...);
+            return true;
+        }
+
+        template <typename T, typename ...Args>
+        static bool make(std::unique_ptr<T> &t, Args&&... args)
+        {
+            t = std::unique_ptr<T>(std::forward<Args>(args)...);
+            return true;
+        }
+
+//    template <typename T, typename ...Args>
+//    static T* make(Args&&... args)
+//    {
+//        return new T(std::forward<Args>(args)...);
+//    }
+//    template <typename T, typename ...Args>
+//    static std::shared_ptr<T> make(Args&&... args)
+//    {
+//        return std::make_shared<T>(std::forward<Args>(args)...);
+//    }
+//    template <typename T, typename ...Args>
+//    static std::unique_ptr<T> make(Args&&... args)
+//    {
+//        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+//    }
+
+
+    };
+
+    template<typename T>
+    class Builder {
+    public:
+        explicit Builder(std::shared_ptr<DTE> dte): dte(std::move(dte))
+        {
+            esp_netif_config_t netif_config = ESP_NETIF_DEFAULT_PPP();
+            netif = esp_netif_new(&netif_config);
+            throw_if_false(netif != nullptr, "Cannot create default PPP netif");
+        }
+
+        Builder(std::shared_ptr<DTE> dte, esp_netif_t* esp_netif): dte(std::move(dte)), module(nullptr), netif(esp_netif)
+        {
+            throw_if_false(netif != nullptr, "Null netif");
+        }
+
+        Builder(std::shared_ptr<DTE> dte, esp_netif_t* esp_netif, std::shared_ptr<T> dev): dte(std::move(dte)), module(std::move(dev)), netif(esp_netif)
+        {
+            throw_if_false(netif != nullptr, "Null netif");
+        }
+
+        ~Builder()
+        {
+            throw_if_false(netif == nullptr, "Netif created but never used");
+            throw_if_false(dte == nullptr, "dte was captured but never used");
+        }
+
+        DCE_T<T>* create(std::string &apn)
+        {
+            return create_dce(dte, netif, apn);
+        }
+
+        template<typename U>
+        bool create_module(U &t, std::string &apn)
+        {
+            auto pdp = FactoryHelper::create_pdp_context(apn);
+//        t = new T(std::move(dte), std::move(pdp));
+            return FactoryHelper::make<T>(t, std::move(dte), std::move(pdp));
+            return true;
+        }
+
+//    bool create_module(std::shared_ptr<T> &t, std::string &apn)
+//    {
+//        auto pdp = FactoryHelper::create_pdp_context(apn);
+//        t = std::make_shared<T>(std::move(dte), std::move(pdp));
+//        return true;
+//    }
+
+        template<typename U, typename V>
+        U create_device(std::string &apn)
+        {
+            auto pdp = FactoryHelper::create_pdp_context(apn);
+            return FactoryHelper::make<V>(std::move(dte), std::move(pdp));
+        }
+
+        T* create_dev(std::string &apn)
+        {
+            auto pdp = FactoryHelper::create_pdp_context(apn);
+            return new T(std::move(dte), std::move(pdp));
+        }
+
+        std::shared_ptr<T> create_shared_dev(std::string &apn)
+        {
+            auto pdp = FactoryHelper::create_pdp_context(apn);
+            return std::make_shared<T>(std::move(dte), std::move(pdp));
+        }
+
+        static DCE_T<T>* create_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<T>& dev, esp_netif_t *netif)
+        {
+            return new DCE_T<T>(dte, dev, netif);
+        }
+
+        static std::unique_ptr<DCE_T<T>> create_unique_dce_from_module(const std::shared_ptr<DTE>& dte, const std::shared_ptr<T>& dev, esp_netif_t *netif)
+        {
+            return std::unique_ptr<DCE_T<T>>(new DCE_T<T>(dte, dev, netif));
+        }
+
+        static std::shared_ptr<T> create_module(const std::shared_ptr<DTE>& dte, std::string &apn)
+        {
+            auto pdp = FactoryHelper::create_pdp_context(apn);
+            return std::make_shared<T>(dte, std::move(pdp));
+        }
+
+        static std::unique_ptr<DCE_T<T>> create_unique_dce(const std::shared_ptr<DTE>& dte, esp_netif_t *netif, std::string &apn)
+        {
+            auto module = create_module(dte, apn);
+            return create_unique_dce_from_module(dte, std::move(module), netif);
+        }
+
+        static DCE_T<T>* create_dce(const std::shared_ptr<DTE>& dte, esp_netif_t *netif, std::string &apn)
+        {
+            auto module = create_module(dte, apn);
+            return create_dce_from_module(dte, std::move(module), netif);
+        }
+
+    private:
+        std::shared_ptr<DTE> dte;
+        std::shared_ptr<T> module;
+        esp_netif_t *netif;
+    };
+
+    enum class Modem {
+        SIM800,
+        SIM7600,
+        BG96,
+        MinModule
+    };
+    class Factory {
+    public:
+        explicit Factory(Modem modem): m(modem) {}
+
+        template <typename T, typename ...Args>
+        T* create(Builder<T> b, std::string apn)
+        {
+            return b.create_dev(apn);
+        }
+
+        template <typename T, typename ...Args>
+        std::shared_ptr<T> create(Builder<T> b, std::string apn)
+        {
+            return b.create_shared_dev(apn);
+        }
+
+        template <typename T, typename U, typename ...Args>
+//    std::shared_ptr<T> build_module_T(Args&&... args)
+//    bool build_module_T(std::shared_ptr<T> &t, Args&&... args)
+        bool build_module_T(U &t, Args&&... args)
+        {
+            Builder<T> b(std::forward<Args>(args)...);
+            std::string apn = "internet";
+            return b.create_module(t, apn);
+//        return b.create_shared_dev(apn);
+        }
+//    template <typename T, typename ...Args>
+//    T* build_module_T(Args&&... args)
+//    {
+//        Builder<T> b(std::forward<Args>(args)...);
+//        std::string apn = "internet";
+//        return b.create_dev(apn);
+//    }
+
+        template <typename T, typename U, typename ...Args>
+        T build_module_T(Args&&... args)
+        {
+//        Builder<U> b(std::forward<Args>(args)...);
+//        std::string apn = "internet";
+//        return b.template create_device<T>(apn);
+
+
+            T module;
+            if (build_module_T<U>(module, std::forward<Args>(args)...))
+                return module;
+            return nullptr;
+        }
+
+        template <typename T, typename ...Args>
+        T build_module_xxT(Args&&... args)
+        {
+            T generic_module = nullptr;
+            switch (m) {
+                case Modem::MinModule:
+                    break;
+                case Modem::SIM7600: {
+                    SIM7600 *module;
+                    if (build_module_T<SIM7600>(module, std::forward<Args>(args)...))
+                        generic_module = module;
+                    break;
+                }
+                case Modem::SIM800: {
+                    SIM800 *module;
+                    if (build_module_T<SIM800>(module, std::forward<Args>(args)...))
+                        generic_module = module;
+                    break;
+                }
+                case Modem::BG96: {
+                    BG96 *module;
+                    if (build_module_T<BG96>(module, std::forward<Args>(args)...))
+                        generic_module = module;
+                    break;
+                }
+            }
+            return generic_module;
+        }
+
+        template <typename T, typename ...Args>
+        std::shared_ptr<T> build_shared_module_specific(Args&&... args)
+        {
+            return build_module_T<std::shared_ptr<T>, T>(std::forward<Args>(args)...);
+        }
+
+        template <typename ...Args>
+        std::shared_ptr<GenericModule> build_shared_module(Args&&... args)
+        {
+//        Builder<GenericModule> b(std::forward<Args>(args)...);
+//        std::string apn = "internet";
+//        return b.template create_device<GenericModule, std::shared_ptr<GenericModule>>(apn);
+
+            return build_shared_module_specific<SIM7600>(std::forward<Args>(args)...);
+        }
+
+
+    private:
+        Modem m;
+    };
+
+} // esp_modem
+
+#endif //AP_TO_PPPOS_ESP_MODEM_DCE_FACTORY_HPP

esp_modem/include/cxx_include/esp_modem_dce_module.hpp

@@ -8,9 +8,9 @@
 enum class command_result;
 class DTE;
 
-class GenericModule: public ModuleIf {
+class MinimalModule: public ModuleIf {
 public:
-    explicit GenericModule(std::shared_ptr<DTE> dte, std::unique_ptr<PdpContext> pdp):
+    explicit MinimalModule(std::shared_ptr<DTE> dte, std::unique_ptr<PdpContext> pdp):
             dte(std::move(dte)), pdp(std::move(pdp)) {}
 
     bool setup_data_mode() override
@@ -36,20 +36,31 @@ public:
         return true;
     }
 
-
+    template <typename ...T> command_result set_echo(T&&... args) { return esp_modem::dce_commands::set_echo(dte.get(),std::forward<T>(args)...); }
-#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, TEMPLATE_ARG, MUX_ARG, ...) \
+    template <typename ...T> command_result set_pdp_context(T&&... args) { return esp_modem::dce_commands::set_pdp_context(dte.get(),std::forward<T>(args)...); }
-    virtual return_type name(__VA_ARGS__);
+    template <typename ...T> command_result set_data_mode(T&&... args) { return esp_modem::dce_commands::set_data_mode(dte.get(),std::forward<T>(args)...); }
-
+    template <typename ...T> command_result resume_data_mode(T&&... args) { return esp_modem::dce_commands::resume_data_mode(dte.get(),std::forward<T>(args)...); }
-    DECLARE_ALL_COMMAND_APIS(virtual return_type name(...); )
+    template <typename ...T> command_result set_command_mode(T&&... args) { return esp_modem::dce_commands::set_command_mode(dte.get(),std::forward<T>(args)...); }
-
+    template <typename ...T> command_result set_cmux(T&&... args) { return esp_modem::dce_commands::set_cmux(dte.get(),std::forward<T>(args)...); }
-#undef ESP_MODEM_DECLARE_DCE_COMMAND
-
 
 protected:
     std::shared_ptr<DTE> dte;
     std::unique_ptr<PdpContext> pdp;
 };
 
+class GenericModule: public MinimalModule {
+    using MinimalModule::MinimalModule;
+public:
+
+#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, TEMPLATE_ARG, MUX_ARG, ...) \
+    virtual return_type name(__VA_ARGS__);
+
+    DECLARE_ALL_COMMAND_APIS(virtual return_type name(...);)
+
+#undef ESP_MODEM_DECLARE_DCE_COMMAND
+};
+
+
 // Definitions of other modules
 class SIM7600: public GenericModule {
     using GenericModule::GenericModule;
@@ -64,6 +75,7 @@ public:
 };
 
 class BG96: public GenericModule {
+    using GenericModule::GenericModule;
 public:
     command_result get_module_name(std::string& name) override;
 };

esp_modem/src/esp_modem_netif.cpp

@@ -33,7 +33,7 @@ esp_err_t Netif::esp_modem_dte_transmit(void *h, void *buffer, size_t len)
 {
     Netif *ppp = (Netif*)h;
     if (ppp->signal.is_any(PPP_STARTED)) {
-        std::cout << "sending data " << len << std::endl;
+//        std::cout << "sending data " << len << std::endl;
         if (ppp->ppp_dte->write((uint8_t*)buffer, len) > 0) {
             return ESP_OK;
         }
@@ -66,7 +66,7 @@ esp_err_t Netif::esp_modem_post_attach(esp_netif_t * esp_netif, void * args)
 void Netif::receive(uint8_t *data, size_t len)
 {
     if (signal.is_any(PPP_STARTED)) {
-        std::cout << "received data " << len << std::endl;
+//        std::cout << "received data " << len << std::endl;
         esp_netif_receive(driver.base.netif, data, len, nullptr);
     }
 }

esp_modem/src/esp_modem_uart.cpp

@@ -191,10 +191,10 @@ void uart_terminal::task()
             }
             switch (event.type) {
                 case UART_DATA:
-                    ESP_LOGI(TAG, "UART_DATA");
+//                    ESP_LOGI(TAG, "UART_DATA");
 //                    ESP_LOG_BUFFER_HEXDUMP("esp-modem-pattern: debug_data", esp_dte->buffer, length, ESP_LOG_DEBUG);
                     uart_get_buffered_data_len(uart.port, &len);
-                    ESP_LOGI(TAG, "UART_DATA len=%d, on_data=%d", len, (bool)on_data);
+//                    ESP_LOGI(TAG, "UART_DATA len=%d, on_data=%d", len, (bool)on_data);
                     if (len && on_data_priv) {
                         if (on_data_priv(len)) {
                             on_data_priv = nullptr;