feat(module): add support for sequans GM02S modem

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

@@ -439,6 +439,74 @@ 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->configure_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, int value, const char *access_technology)
+{
+
+}
+
+extern "C" esp_err_t esp_modem_sqns_gm02s_connect(esp_modem_dce_t *dce, const esp_modem_PdpContext_t *pdp_context)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || dce_wrap->modem_type != ESP_MODEM_DCE_SQNGM02S)
+    {
+        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());

components/esp_modem/src/esp_modem_command_library.cpp

@@ -607,6 +607,71 @@ command_result get_gnss_power_mode(CommandableIf *t, int &mode)
     return command_result::OK;
 }
 
+command_result config_psm(CommandableIf *t, int enabled, const std::string &TAU, const std::string &activeTime)
+{
+    ESP_LOGV(TAG, "%s", __func__);
+    if (enabled == true)
+    {
+        return generic_command_common(t, "AT+CPSMS=1,,,\"" + TAU + "\"" + ",\"" + activeTime + "\"\r", 500);
+    }
+    return generic_command_common(t, "AT+CPSMS=" + std::to_string(enabled), 500);
+}
+
+command_result config_network_registration_urc(CommandableIf *t, int value)
+{
+    ESP_LOGV(TAG, "%s", __func__);
+    return generic_command_common(t,"AT+CEREG=" + std::to_string(state) + "\r", 500);
+}
+
+command_result get_network_registration_state(CommandableIf *t, int& state) 
+{
+    ESP_LOGV(TAG, "%s", __func__);
+    std::string out;
+
+    auto ret = generic_get_string(t, "AT+CEREG?\r", out, 500);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+
+    constexpr std::string_view pattern = "+CEREG: ";
+    int state_pos_start;
+    int state_pos_end;
+    if (out.find(pattern) == std::string::npos || (state_pos_start = out.find(',')) == std::string::npos) {
+        return command_result::FAIL;
+    }
+
+    if (out.find(pattern) == std::string::npos || (state_pos_end = out.find(',',state_pos_start)) == std::string::npos){
+        if (std::from_chars(out.data() + state_pos_start, out.data() + out.size(), state).ec == std::errc::invalid_argument) {
+            return command_result::FAIL;
+        }
+    } else if (std::from_chars(out.data() + state_pos_start, out.data() + state_pos_end, state).ec == std::errc::invalid_argument) {
+        return command_result::FAIL;
+    }
+
+    return command_result::OK;
+}
+
+command_result config_mobile_termination_error(CommandableIf *t, int value)
+{
+    ESP_LOGV(TAG, "%s", __func__);
+    return generic_command_common(t, "AT+CMEE=" + std::to_string(value) + "\r");
+}
+command_result config_edrx(int mode, int access_technology, const std::string &edrx_value, const std::string &ptw_value)
+{
+    if (mode == 1 || enabled == 2)
+    {
+        return dce_commands::generic_command_common(dte.get(),
+            "AT+SQNEDRX=" +
+            std::to_string(mode) +
+            "," +
+            std::to_string(access_technology) +
+            ",\"" +
+            edrx_value +
+            "\",\"" +
+            ptw_value + "\"\r");
+    }
+    return dce_commands::generic_command_common(dte.get(), "AT+SQNEDRX=" + std::to_string(mode), 500);
+}
 command_result set_gnss_power_mode_sim76xx(CommandableIf *t, int mode)
 {
     ESP_LOGV(TAG, "%s", __func__ );

components/esp_modem/src/esp_modem_modules.cpp

@@ -87,4 +87,59 @@ command_result BG96::set_pdp_context(esp_modem::PdpContext &pdp)
     return dce_commands::set_pdp_context(dte.get(), pdp, 300);
 }
 
+command_result urc_callback(uint8_t *line, size_t len)
+{
+    ESP_LOGI("WalterModem", "Received: %s", line);
+    if (strstr((const char *)line, "+CEREG: 1"))
+    {
+        return command_result::OK; // Succesfully registered
+    }
+    else if (strstr((const char *)line, "+CEREG: 5"))
+    {
+        return command_result::OK; // Succesfully registered
+    }
+    else if (strstr((const char *)line, "+CEREG: 3"))
+    {
+        return command_result::FAIL; // Permission denied
+    }
+    return command_result::TIMEOUT;
+}
+
+command_result SQNGM02S::connect(PdpContext &pdp)
+{
+    command_result res;
+    res = set_pdp_context(pdp);
+    if (res != command_result::OK)
+        return res;
+    res = config_network_registration_urc(1);
+    if (res != command_result::OK)
+        return res;
+
+    res = set_radio_state(1);
+    if (res != command_result::OK)
+        return res;
+
+    //wait for +CEREG: 5 or +CEREG: 1.
+
+    do
+    {
+        res = dte->command("", urc_callback, 20000, '\r');
+    } while (res == command_result::TIMEOUT);
+
+    if (res != command_result::OK)
+        return res;
+
+    res = config_network_registration_urc(0);
+    if (res != command_result::OK)
+        return res;
+
+    return command_result::OK;
+}
+
+bool SQNGM02S::setup_data_mode()
+{
+    ESP_LOGI("SQNGM02S", "setyp data mode");
+    return set_echo(false) == command_result::OK;
+    // PDP context has already been set before hand because SEQUANS modem must have already been connected/registered before setting up cmux
+}
 }