Merge pull request #786 from robbedptechnics/support-sqn-gm02s

feat(module): add support for sequans GM02S modem (DPTechnics) (IDFGH-14891)

Author: david-cermak

components/esp_modem/include/cxx17_include/esp_modem_command_library_17.hpp

@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <string>
+#include <list>
+#include "esp_log.h"
+#include "cxx_include/esp_modem_dte.hpp"
+#include "cxx_include/esp_modem_dce_module.hpp"
+
+namespace esp_modem::dce_commands {
+command_result generic_command(CommandableIf *t, const std::string &command,
+                               const std::list<std::string_view> &pass_phrase,
+                               const std::list<std::string_view> &fail_phrase,
+                               uint32_t timeout_ms);
+}

components/esp_modem/include/cxx_include/esp_modem_api.hpp

@@ -84,7 +84,6 @@ std::unique_ptr<DCE> create_SIM7070_dce(const dce_config *config, std::shared_pt
  */
 std::unique_ptr<DCE> create_SIM7000_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif);
 
-
 /**
  * @brief Create DCE based on SIM800 module
  */
@@ -95,6 +94,11 @@ std::unique_ptr<DCE> create_SIM800_dce(const dce_config *config, std::shared_ptr
  */
 std::unique_ptr<DCE> create_BG96_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif);
 
+/**
+ * @brief Create DCE based on Sequans GM02S module
+ */
+std::unique_ptr<DCE> create_SQNGM02S_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif);
+
 /**
  * @brief Create generic DCE
  */

components/esp_modem/include/cxx_include/esp_modem_dce_factory.hpp

@@ -118,6 +118,7 @@ enum class ModemType {
     SIM7000,            /*!< Derived from the GenericModule, specifics applied to SIM7000 model */
     BG96,               /*!< Derived from the GenericModule, specifics applied to BG69 model */
     SIM800,             /*!< Derived from the GenericModule with specifics applied to SIM800 model */
+    SQNGM02S,           /*!< Derived from the GenericModule, specifics applied to GM02S model */
 };
 
 /**
@@ -178,6 +179,8 @@ class Factory {
             return build_shared_module<SIM7000>(cfg, std::forward<Args>(args)...);
         case ModemType::BG96:
             return build_shared_module<BG96>(cfg, std::forward<Args>(args)...);
+        case ModemType::SQNGM02S:
+            return build_shared_module<SQNGM02S>(cfg, std::forward<Args>(args)...);
         case ModemType::GenericModule:
             return build_shared_module<GenericModule>(cfg, std::forward<Args>(args)...);
         default:
@@ -207,6 +210,8 @@ class Factory {
             return build_unique<SIM7000>(cfg, std::forward<Args>(args)...);
         case ModemType::BG96:
             return build_unique<BG96>(cfg, std::forward<Args>(args)...);
+        case ModemType::SQNGM02S:
+            return build_unique<SQNGM02S>(cfg, std::forward<Args>(args)...);
         case ModemType::GenericModule:
             return build_unique<GenericModule>(cfg, std::forward<Args>(args)...);
         default:
@@ -229,6 +234,8 @@ class Factory {
             return build<SIM7000>(cfg, std::forward<Args>(args)...);
         case ModemType::BG96:
             return build<BG96>(cfg, std::forward<Args>(args)...);
+        case ModemType::SQNGM02S:
+            return build<SQNGM02S>(cfg, std::forward<Args>(args)...);
         case ModemType::GenericModule:
             return build<GenericModule>(cfg, std::forward<Args>(args)...);
         default:

components/esp_modem/include/cxx_include/esp_modem_dce_module.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -115,7 +115,7 @@ class GenericModule: public ModuleIf {
 #define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, num, ...) \
     virtual return_type name(__VA_ARGS__);
 
-    DECLARE_ALL_COMMAND_APIS(virtual return_type name(...); )
+    DECLARE_ALL_COMMAND_APIS(virtual return_type name(...);)
 
 #undef ESP_MODEM_DECLARE_DCE_COMMAND
 
@@ -177,6 +177,14 @@ class BG96: public GenericModule {
     command_result set_pdp_context(PdpContext &pdp) override;
 };
 
+class SQNGM02S : public GenericModule {
+    using GenericModule::GenericModule;
+
+public:
+    command_result connect(PdpContext &pdp);
+    bool setup_data_mode() override;
+};
+
 /**
  * @}
  */

components/esp_modem/include/esp_modem_c_api_types.h

@@ -60,6 +60,7 @@ typedef enum esp_modem_dce_device {
     ESP_MODEM_DCE_BG96,
     ESP_MODEM_DCE_EC20,
     ESP_MODEM_DCE_SIM800,
+    ESP_MODEM_DCE_SQNGM02S,
     ESP_MODEM_DCE_CUSTOM
 } esp_modem_dce_device_t;
 
@@ -162,6 +163,8 @@ esp_err_t esp_modem_set_apn(esp_modem_dce_t *dce, const char *apn);
 esp_err_t esp_modem_set_urc(esp_modem_dce_t *dce, esp_err_t(*got_line_cb)(uint8_t *data, size_t len));
 #endif
 
+esp_err_t esp_modem_sqn_gm02s_connect(esp_modem_dce_t *dce, const esp_modem_PdpContext_t *pdp_context);
+
 /**
  * @brief This API provides support for temporarily pausing networking in order
  * to send/receive AT commands and resume networking afterwards.

components/esp_modem/include/esp_private/c_api_wrapper.hpp

@@ -43,6 +43,8 @@ inline dce_factory::ModemType convert_modem_enum(esp_modem_dce_device_t module)
         return esp_modem::dce_factory::ModemType::BG96;
     case ESP_MODEM_DCE_SIM800:
         return esp_modem::dce_factory::ModemType::SIM800;
+    case ESP_MODEM_DCE_SQNGM02S:
+        return esp_modem::dce_factory::ModemType::SQNGM02S;
     default:
     case ESP_MODEM_DCE_GENERIC:
         return esp_modem::dce_factory::ModemType::GenericModule;

components/esp_modem/include/generate/esp_modem_command_declare.inc

@@ -290,7 +290,69 @@ ESP_MODEM_DECLARE_DCE_COMMAND(set_gnss_power_mode, command_result, 1, INT_IN(p1,
  */ \
 ESP_MODEM_DECLARE_DCE_COMMAND(get_gnss_power_mode, command_result, 1, INT_OUT(p1, mode)) \
     \
-
+/**
+ * @brief Configure PSM
+ * @param[in] mode psm mode (0 - off, 1 - on, 2 - off & discard stored params)
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(config_psm, command_result, 3, INT_IN(p1, mode), STRING_IN(p2, tau), STRING_IN(p3, active_time)) \
+    \
+/**
+ * @brief Configure CEREG urc
+ * @param[in] value
+ * value = 0 - Disable network URC
+ * value = 1 - Enable network URC
+ * value = 2 - Enable network URC with location information
+ * value = 3 - Enable network URC with location information and EMM cause
+ * value = 4 - Enable network URC with location information and PSM value
+ * value = 5 - Enable network URC with location information and PSM value, EMM cause
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(config_network_registration_urc, command_result, 1, INT_IN(p1, value)) \
+    \
+/**
+ *  @brief Gets the current network registration state
+ *  @param[out] state The current network registration state
+ *  state = 0 - Not registered, MT is not currently searching an operator to register to
+ *  state = 1 - Registered, home network
+ *  state = 2 - Not registered, but MT is currently trying to attach or searching an operator to register to
+ *  state = 3 - Registration denied
+ *  state = 4 - Unknown
+ *  state = 5 - Registered, Roaming
+ *  state = 6 - Registered, for SMS only, home network (NB-IoT only)
+ *  state = 7 - Registered, for SMS only, roaming (NB-IoT only)
+ *  state = 8 - Attached for emergency bearer services only
+ *  state = 9 - Registered for CSFB not preferred, home network
+ *  state = 10 - Registered for CSFB not preferred, roaming
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(get_network_registration_state, command_result, 1, INT_OUT(p1,state)) \
+    \
+/**
+ *  @brief Configures the mobile termination error (+CME ERROR)
+ *  @param[in] mode The form of the final result code
+ *  mode = 0 - Disable, use and send ERROR instead
+ *  mode = 1 - Enable, use numeric error values
+ *  mode = 2 - Enable, result code and use verbose error values
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(config_mobile_termination_error, command_result, 1, INT_IN(p1, mode)) \
+    \
+/**
+ * @brief Configure eDRX
+ * @param[in] mode
+ * mode = 0 - Disable
+ * mode = 1 - Enable
+ * mode = 2 - Enable + URC
+ * mode = 3 - Disable + Reset parameter.
+ * @param[in] access_technology
+ * act = 0 - ACT is not using eDRX (used in URC)
+ * act = 1 - EC-GSM-IoT (A/Gb mode)
+ * act = 2 - GSM (A/Gb mode)
+ * act = 3 - UTRAN (Iu mode)
+ * act = 4 - E-UTRAN (WB-S1 mode)
+ * act = 5 - E-UTRAN (NB-S1 mode)
+ * @param[in] edrx_value nible string containing encoded eDRX time
+ * @param[in] ptw_value nible string containing encoded Paging Time Window
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(config_edrx, command_result, 3, INT_IN(p1, mode), INT_IN(p2, access_technology), STRING_IN(p3, edrx_value)) \
 
 #ifdef GENERATE_DOCS
 // cat ../include/generate/esp_modem_command_declare.inc | clang++ -E -P -CC  -xc++ -I../include -DGENERATE_DOCS  - | sed -n '1,/DCE command documentation/!p'

components/esp_modem/src/esp_modem_api.cpp

@@ -66,6 +66,11 @@ std::unique_ptr<DCE> create_BG96_dce(const dce_config *config, std::shared_ptr<D
     return create_modem_dce(dce_factory::ModemType::BG96, config, std::move(dte), netif);
 }
 
+std::unique_ptr<DCE> create_SQNGM02S_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif)
+{
+    return create_modem_dce(dce_factory::ModemType::SQNGM02S, config, std::move(dte), netif);
+}
+
 std::unique_ptr<DCE> create_generic_dce(const dce_config *config, std::shared_ptr<DTE> dte, esp_netif_t *netif)
 {
     return create_modem_dce(dce_factory::ModemType::GenericModule, config, std::move(dte), netif);

components/esp_modem/src/esp_modem_c_api.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -439,6 +439,77 @@ extern "C" esp_err_t esp_modem_get_gnss_power_mode(esp_modem_dce_t *dce_wrap, in
     return ret;
 }
 
+extern "C" esp_err_t esp_modem_config_psm(esp_modem_dce_t *dce_wrap, int mode, const char *tau, const char *active_time)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || mode > 3) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (mode == 1 && (strlen(tau) != 8 || strlen(active_time) != 8)) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->config_psm(mode, std::string(tau), std::string(active_time)));
+}
+
+extern "C" esp_err_t esp_modem_config_network_registration_urc(esp_modem_dce_t *dce_wrap, int value)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || value > 5) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->config_network_registration_urc(value));
+}
+
+extern "C" esp_err_t esp_modem_get_network_registration_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_state == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_registration_state(state));
+
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_config_mobile_termination_error(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || mode > 2) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->config_mobile_termination_error(mode));
+}
+
+extern "C" esp_err_t esp_modem_config_edrx(esp_modem_dce_t *dce_wrap, int mode, int access_technology, const char *edrx_value)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || mode > 3 || access_technology > 5) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if ((mode == 1 || mode == 2) && strlen(edrx_value) != 4) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->config_edrx(mode, access_technology, std::string(edrx_value)));
+}
+
+extern "C" esp_err_t esp_modem_sqn_gm02s_connect(esp_modem_dce_t *dce_wrap, const esp_modem_PdpContext_t *pdp_context)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    esp_modem::PdpContext pdp{pdp_context->apn};
+    pdp.context_id = pdp_context->context_id;
+    pdp.protocol_type = pdp_context->protocol_type;
+    return command_response_to_esp_err(static_cast<SQNGM02S *>(dce_wrap->dce->get_module())->connect(pdp));
+}
+
 extern "C" esp_err_t esp_modem_reset(esp_modem_dce_t *dce_wrap)
 {
     return command_response_to_esp_err(dce_wrap->dce->reset());