Merge pull request #934 from david-cermak/bump/modem_1.4.2

[modem]: Release `v1.4.2`

.github/workflows/modem__build-host-tests.yml

@@ -15,11 +15,6 @@ jobs:
       matrix:
         idf_ver: ["latest", "release-v5.0", "release-v5.1", "release-v5.2", "release-v5.3", "release-v5.4"]
         example: ["pppos_client", "modem_console", "modem_tcp_client", "ap_to_pppos", "simple_cmux_client"]
-        include:
-          - idf_ver: "release-v5.0"
-            example: "simple_cmux_client"
-            warning: "Warning: The smallest app partition is nearly full"
-
     runs-on: ubuntu-22.04
     container: espressif/idf:${{ matrix.idf_ver }}
     steps:
@@ -30,9 +25,9 @@ jobs:
       - if: ${{ matrix.skip_config }}
         run: rm -f $GITHUB_WORKSPACE/protocols/components/esp_modem/examples/${{ matrix.example }}/sdkconfig.ci.${{ matrix.skip_config }}*
       - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }}
-        env:
-          EXPECTED_WARNING: ${{ matrix.warning }}
         shell: bash
+        env:
+          EXPECTED_WARNING: "Warning: The smallest app partition is nearly full\nwarning: unknown kconfig symbol 'ESP32_PANIC_PRINT_HALT'"
         run: |
           . ${IDF_PATH}/export.sh
           python -m pip install idf-build-apps

.github/workflows/mosq__build.yml

@@ -169,7 +169,7 @@ jobs:
       - name: Run Test
         working-directory: ${{ env.TEST_DIR }}
         run: |
-          python -m pip install pytest-embedded-serial-esp pytest-embedded-idf pytest-rerunfailures pytest-timeout pytest-ignore-test-results "paho-mqtt<2"
+          python -m pip install pytest-embedded-serial-esp pytest-embedded-idf pytest-rerunfailures pytest-timeout pytest-ignore-test-results "paho-mqtt<2"  --upgrade
           unzip ci/artifacts.zip -d ci
           for dir in `ls -d ci/build_*`; do
           rm -rf build sdkconfig.defaults

.github/workflows/pre_commit_check.yml

@@ -1,45 +0,0 @@
-name: Check pre-commit rules
-
-on:
-  pull_request:
-    types: [opened, reopened, synchronize]
-
-permissions:
-  contents: read
-
-jobs:
-  pre_commit_check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.base_ref }}
-          fetch-depth: 20
-      - name: Fetch head and base refs
-        # This is necessary for pre-commit to check the changes in the PR branch (and to set origin/HEAD and HEAD refs)
-        run: |
-          git fetch origin ${{ github.event.pull_request.head.sha }}:pr_ref
-          git checkout pr_ref
-          git remote set-head origin --auto
-          git merge-base origin/HEAD HEAD || ( echo "Your PR is far behind origin/HEAD, please rebase" && exit 1 )
-      - name: Set up Python environment
-        uses: actions/setup-python@master
-        with:
-          python-version: v3.8
-      - name: Install python packages
-        run: |
-          pip install pre-commit
-          pre-commit install-hooks
-      - name: Run pre-commit and check for any changes
-        run: |
-          echo "Commits being checked:"
-          git log --oneline --no-decorate origin/HEAD..HEAD
-          echo ""
-          if ! pre-commit run --from-ref origin/HEAD --to-ref HEAD --hook-stage manual --show-diff-on-failure ; then
-            echo ""
-            echo "::notice::It looks like the commits in this PR have been made without having pre-commit hooks installed."
-            echo "::notice::Please see https://github.com/espressif/esp-protocols/CONTRIBUTING.md for instructions."
-            echo ""
-            exit 1
-          fi

.github/workflows/publish-docs-component.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - master
+      - release-modem-v1.4
 
 env:
   DOCS_DEPLOY_URL_BASE: ${{ secrets.DOCS_DEPLOY_URL_BASE }}
@@ -55,9 +56,6 @@ jobs:
                 if [[ "${{ env.BUMP_COMPONENT }}" == "${comp}" ]]; then
                   echo "Building specific version of ${comp} (${{ env.BUMP_VERSION }})"
                   ./generate_docs ${{ env.BUMP_VERSION }}
-                else
-                  echo "Building latest version of ${comp}"
-                  ./generate_docs
                 fi
               fi
             done
@@ -67,16 +65,6 @@ jobs:
             source $GITHUB_WORKSPACE/docs/utils.sh
             add_doc_server_ssh_keys $DOCS_DEPLOY_KEY $DOCS_DEPLOY_SERVER $DOCS_DEPLOY_SERVER_USER
             export GIT_VER=$(git describe --always)
-            export GITHUB_REF_NAME=latest
-            for comp in  `ls components`; do
-              if [[ -d $GITHUB_WORKSPACE/docs/${comp} ]]; then
-                echo "Deploying latest of ${comp}"
-                export DOCS_BUILD_DIR=$GITHUB_WORKSPACE/docs/${comp}
-                export DOCS_DEPLOY_PATH=$DOCS_DEPLOY_PATH_ORIG/${comp}
-                cd $GITHUB_WORKSPACE/docs/${comp}
-                deploy-docs
-              fi
-            done;
             # Deploy docs with version path
             if [[ "${{ env.BUMP_VERSION }}" != "" ]] && [[ -d $GITHUB_WORKSPACE/docs/${{ env.BUMP_COMPONENT }} ]]; then
                 echo "Deploying specific version of ${{ env.BUMP_COMPONENT }} (${{ env.BUMP_VERSION }})"

ci/build_apps.py

@@ -56,7 +56,7 @@ if __name__ == '__main__':
         build_dir='build_@t_@w',
         config_rules_str=args.rules,
         build_log_filename='build_log.txt',
-        size_json_filename='size.json' if not args.linux else None,
+        size_json_filename=None,
         check_warnings=True,
         manifest_files=args.manifests,
         default_build_targets=SUPPORTED_TARGETS,
@@ -65,6 +65,7 @@ if __name__ == '__main__':
 
     sys.exit(
         build_apps(apps,
+                   verbose=2,
                    dry_run=False,
                    keep_going=False,
                    no_preserve=args.delete,

components/esp_modem/.cz.yaml

@@ -3,6 +3,6 @@ commitizen:
   bump_message: 'bump(modem): $current_version -> $new_version'
   pre_bump_hooks: python ../../ci/changelog.py esp_modem
   tag_format: modem-v$version
-  version: 1.3.0
+  version: 1.4.2
   version_files:
   - idf_component.yml

components/esp_modem/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [1.4.2](https://github.com/espressif/esp-protocols/commits/modem-v1.4.2)
+
+### Bug Fixes
+
+- CEREG parsing fails due to incorrect state index ([a80a3cbb](https://github.com/espressif/esp-protocols/commit/a80a3cbb))
+
+## [1.4.1](https://github.com/espressif/esp-protocols/commits/modem-v1.4.1)
+
+### Bug Fixes
+
+- Remove unused kconfig ([97194507](https://github.com/espressif/esp-protocols/commit/97194507))
+- Fix modem console dependencies ([0d17f19f](https://github.com/espressif/esp-protocols/commit/0d17f19f))
+- Fix CI build issues with IDFv6.0 ([d65f8f69](https://github.com/espressif/esp-protocols/commit/d65f8f69))
+- Address build issues ([b4520660](https://github.com/espressif/esp-protocols/commit/b4520660))
+- Fix driver dependency issue on v6.0 ([26b3859c](https://github.com/espressif/esp-protocols/commit/26b3859c))
+
+## [1.4.0](https://github.com/espressif/esp-protocols/commits/modem-v1.4.0)
+
+### Features
+
+- added config_edrx api function ([74b7d85d](https://github.com/espressif/esp-protocols/commit/74b7d85d))
+- added sqn_gm02s connect function ([b97dfc08](https://github.com/espressif/esp-protocols/commit/b97dfc08))
+- add support for sequans GM02S modem ([8560f021](https://github.com/espressif/esp-protocols/commit/8560f021))
+
+### Bug Fixes
+
+- Fix cmux log message ([6ed672da](https://github.com/espressif/esp-protocols/commit/6ed672da))
+- fixed minor code mistakes. ([317faf89](https://github.com/espressif/esp-protocols/commit/317faf89))
+- handle nullptr in DTE constructors to prevent invalid access ([95b56600](https://github.com/espressif/esp-protocols/commit/95b56600))
+
 ## [1.3.0](https://github.com/espressif/esp-protocols/commits/modem-v1.3.0)
 
 ### Features

components/esp_modem/CMakeLists.txt

@@ -11,7 +11,12 @@ else()
                       src/esp_modem_uart.cpp
                       src/esp_modem_term_uart.cpp
                       src/esp_modem_netif.cpp)
-    set(dependencies driver esp_event esp_netif)
+    set(dependencies esp_event esp_netif)
+    if("${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}" VERSION_GREATER "5.3")
+        list(APPEND dependencies esp_driver_uart)
+    else()
+        list(APPEND dependencies driver)
+    endif()
 endif()
 
 

components/esp_modem/examples/ap_to_pppos/main/ap_to_pppos.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -100,10 +100,10 @@ void wifi_init_softap(void)
     ESP_ERROR_CHECK(esp_wifi_init(&cfg));
 
     ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
-                    ESP_EVENT_ANY_ID,
-                    &wifi_event_handler,
-                    NULL,
-                    NULL));
+                                                        ESP_EVENT_ANY_ID,
+                                                        &wifi_event_handler,
+                                                        NULL,
+                                                        NULL));
 
     wifi_config_t wifi_config = {
         .ap = {
@@ -120,7 +120,7 @@ void wifi_init_softap(void)
     }
 
     ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
-    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));
+    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
     ESP_ERROR_CHECK(esp_wifi_start());
 
     ESP_LOGI(TAG, "wifi_init_softap finished. SSID:%s password:%s channel:%d",

components/esp_modem/examples/modem_console/main/CMakeLists.txt

@@ -3,5 +3,4 @@ idf_component_register(SRCS "modem_console_main.cpp"
                             "my_module_dce.cpp"
                             "httpget_handle.c"
                             "ping_handle.c"
-                       REQUIRES console esp_http_client nvs_flash
                        INCLUDE_DIRS ".")

components/esp_modem/examples/modem_console/main/console_helper.cpp

@@ -63,13 +63,12 @@ void ConsoleCommand::RegisterCommand(const char *command, const char *help, cons
 
     arg_type end = { .end = arg_end(1) };
     arg_table.emplace_back(end);
-    const esp_console_cmd_t command_def = {
-        .command = command,
-        .help = help,
-        .hint = nullptr,
-        .func = command_func_pts[last_command],
-        .argtable = &arg_table[0]
-    };
+    esp_console_cmd_t command_def = { };
+    command_def.command = command;
+    command_def.help = help;
+    command_def.hint = nullptr;
+    command_def.func = command_func_pts[last_command];
+    command_def.argtable = &arg_table[0];
     ESP_ERROR_CHECK(esp_console_cmd_register(&command_def));
     last_command++;
     console_commands.emplace_back(this);

components/esp_modem/examples/modem_console/main/modem_console_main.cpp

@@ -21,6 +21,7 @@
 #include "cxx_include/esp_modem_dte.hpp"
 #include "esp_modem_config.h"
 #include "cxx_include/esp_modem_api.hpp"
+#include "esp_idf_version.h"
 #if defined(CONFIG_EXAMPLE_SERIAL_CONFIG_USB)
 #include "esp_modem_usb_config.h"
 #include "cxx_include/esp_modem_usb_api.hpp"
@@ -29,6 +30,12 @@
 #include "console_helper.hpp"
 #include "my_module_dce.hpp"
 
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(6, 0, 0)
+#define GET_WAKEUP_CAUSE() esp_sleep_get_wakeup_causes()
+#else
+#define GET_WAKEUP_CAUSE() esp_sleep_get_wakeup_cause()
+#endif
+
 #if defined(CONFIG_EXAMPLE_FLOW_CONTROL_NONE)
 #define EXAMPLE_FLOW_CONTROL ESP_MODEM_FLOW_CONTROL_NONE
 #elif defined(CONFIG_EXAMPLE_FLOW_CONTROL_SW)
@@ -208,7 +215,7 @@ extern "C" void app_main(void)
     esp_console_dev_uart_config_t uart_config = ESP_CONSOLE_DEV_UART_CONFIG_DEFAULT();
     ESP_ERROR_CHECK(esp_console_new_repl_uart(&uart_config, &repl_config, &s_repl));
 
-    switch (esp_sleep_get_wakeup_cause()) {
+    switch (GET_WAKEUP_CAUSE()) {
     case ESP_SLEEP_WAKEUP_TIMER:
         if (esp_modem::modem_mode::CMUX_MODE == mode_rtc) {
             ESP_LOGI(TAG, "Deep sleep reset\n");
@@ -427,7 +434,7 @@ extern "C" void app_main(void)
     const ConsoleCommand SetDeepSleep("set_deep_sleep", "Put esp32 to deep sleep", &deep_sleep_args, sizeof(deep_sleep_args), [&](ConsoleCommand * c) {
         int tout = c->get_int_of(&DeepSleepArgs::timeout);
         ESP_LOGI(TAG, "Entering deep sleep for %d sec", tout);
-        ESP_LOGI(TAG, "Wakeup Cause: %d ", esp_sleep_get_wakeup_cause());
+        ESP_LOGI(TAG, "Wakeup Cause: %d ", GET_WAKEUP_CAUSE());
         esp_deep_sleep(tout * 1000000);
         return 0;
     });

components/esp_modem/examples/pppos_client/sdkconfig.ci.usb_a7670_s2

@@ -8,7 +8,6 @@ CONFIG_LWIP_PPP_ENABLE_IPV6=n
 CONFIG_EXAMPLE_SERIAL_CONFIG_USB=y
 CONFIG_EXAMPLE_MODEM_DEVICE_A7670=y
 CONFIG_EXAMPLE_MODEM_PPP_APN="lpwa.vodafone.com"
-CONFIG_EXAMPLE_MODEM_PPP_AUTH_NONE=y
 CONFIG_EXAMPLE_MQTT_TEST_TOPIC="/ci/esp-modem/pppos-client"
 CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y
 CONFIG_ESP32_PANIC_PRINT_HALT=y

components/esp_modem/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.3.0"
+version: "1.4.2"
 description: Library for communicating with cellular modems in command and data modes
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_modem
 issues: https://github.com/espressif/esp-protocols/issues

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 @@ public:
             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 @@ public:
             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 @@ public:
             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 @@ public:
 #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 @@ public:
     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/port/linux/esp_netif_linux/lwipopts.h

@@ -89,7 +89,7 @@
 
 #define MPPE_SUPPORT                    0
 
-#define PPP_MAXIDLEFLAG                 0
+#define PPP_MAXIDLEFLAG                 100
 
 #define PRINTPKT_SUPPORT                1
 #define PPP_PROTOCOLNAME                1

components/esp_modem/port/linux/esp_netif_linux/tun_io.c

@@ -104,7 +104,7 @@ static void ppp_link_status_cb(ppp_pcb *pcb, int err_code, void *ctx)
     }
 }
 
-static u32_t ppp_output_cb(struct ppp_pcb_s *pcb, const void *data, u32_t len, void *ctx)
+static u32_t ppp_output_cb(struct ppp_pcb_s *pcb, u8_t *data, u32_t len, void *ctx)
 {
     esp_netif_t *netif = (esp_netif_t *)ctx;
     if (netif->transmit) {

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());

components/esp_modem/src/esp_modem_cmux.cpp

@@ -248,7 +248,7 @@ bool CMux::on_header(CMuxFrame &frame)
     // Sanity check for expected values of DLCI and type,
     // since CRC could be evaluated after the frame payload gets received
     if (dlci > MAX_TERMINALS_NUM || (frame_header[1] & 0x01) == 0 ||
-            (((type & FT_UIH) != FT_UIH) &&  type != (FT_UA | PF) ) ) {
+            (((type & FT_UIH) != FT_UIH) &&  type != (FT_UA | PF))) {
         recover_protocol(protocol_mismatch_reason::UNEXPECTED_HEADER);
         return true;
     }
@@ -327,7 +327,7 @@ bool CMux::on_cmux_data(uint8_t *data, size_t actual_len)
             auto data_end = buffer.get() + buffer.size;
             data_to_read = payload_len + 2; // 2 -- CMUX protocol footer
             if (data + data_to_read >= data_end) {
-                ESP_LOGW("CUMX", "Failed to defragment longer payload (payload=%" PRIsize_t ")", payload_len);
+                ESP_LOGW("CMUX", "Failed to defragment longer payload (payload=%" PRIsize_t ")", payload_len);
                 // If you experience this error, your device uses longer payloads while
                 // the configured buffer is too small to defragment the payload properly.
                 // To resolve this issue you can:

components/esp_modem/src/esp_modem_command_library.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
  */
@@ -12,14 +12,16 @@
 #include "cxx_include/esp_modem_command_library.hpp"
 #include "cxx_include/esp_modem_command_library_utils.hpp"
 
+#include "cxx17_include/esp_modem_command_library_17.hpp"
+
 namespace esp_modem::dce_commands {
 
 static const char *TAG = "command_lib";
 
-static 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)
+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)
 {
     ESP_LOGD(TAG, "%s command %s\n", __func__, command.c_str());
     return t->command(command, [&](uint8_t *data, size_t len) {
@@ -45,7 +47,7 @@ command_result generic_command(CommandableIf *t, const std::string &command,
                                const std::string &pass_phrase,
                                const std::string &fail_phrase, uint32_t timeout_ms)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     const auto pass = std::list<std::string_view>({pass_phrase});
     const auto fail = std::list<std::string_view>({fail_phrase});
     return generic_command(t, command, pass, fail, timeout_ms);
@@ -81,7 +83,7 @@ bool set(std::span<char> &dest, std::string_view &src)
 
 template <typename T> command_result generic_get_string(CommandableIf *t, const std::string &command, T &output, uint32_t timeout_ms)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return t->command(command, [&](uint8_t *data, size_t len) {
         size_t pos = 0;
         std::string_view response((char *)data, len);
@@ -110,67 +112,67 @@ template <typename T> command_result generic_get_string(CommandableIf *t, const
 
 command_result generic_command_common(CommandableIf *t, const std::string &command, uint32_t timeout_ms)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, command, "OK", "ERROR", timeout_ms);
 }
 
 command_result sync(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT\r");
 }
 
 command_result store_profile(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT&W\r");
 }
 
 command_result power_down(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, "AT+QPOWD=1\r", "POWERED DOWN", "ERROR", 1000);
 }
 
 command_result power_down_sim76xx(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CPOF\r", 1000);
 }
 
 command_result power_down_sim70xx(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, "AT+CPOWD=1\r", "POWER DOWN", "ERROR", 1000);
 }
 
 command_result power_down_sim8xx(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, "AT+CPOWD=1\r", "POWER DOWN", "ERROR", 1000);
 }
 
 command_result reset(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t,  "AT+CRESET\r", "PB DONE", "ERROR", 60000);
 }
 
 command_result set_baud(CommandableIf *t, int baud)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t,  "AT+IPR=" + std::to_string(baud) + "\r");
 }
 
 command_result hang_up(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "ATH\r", 90000);
 }
 
 command_result get_battery_status(CommandableIf *t, int &voltage, int &bcs, int &bcl)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CBC\r", out);
     if (ret != command_result::OK) {
@@ -206,7 +208,7 @@ command_result get_battery_status(CommandableIf *t, int &voltage, int &bcs, int
 
 command_result get_battery_status_sim7xxx(CommandableIf *t, int &voltage, int &bcs, int &bcl)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CBC\r", out);
     if (ret != command_result::OK) {
@@ -235,13 +237,13 @@ command_result get_battery_status_sim7xxx(CommandableIf *t, int &voltage, int &b
 
 command_result set_flow_control(CommandableIf *t, int dce_flow, int dte_flow)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+IFC=" + std::to_string(dce_flow) + "," + std::to_string(dte_flow) + "\r");
 }
 
 command_result get_operator_name(CommandableIf *t, std::string &operator_name, int &act)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+COPS?\r", out, 75000);
     if (ret != command_result::OK) {
@@ -272,7 +274,7 @@ command_result get_operator_name(CommandableIf *t, std::string &operator_name, i
 
 command_result set_echo(CommandableIf *t, bool on)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     if (on) {
         return generic_command_common(t, "ATE1\r");
     }
@@ -281,7 +283,7 @@ command_result set_echo(CommandableIf *t, bool on)
 
 command_result set_pdp_context(CommandableIf *t, PdpContext &pdp, uint32_t timeout_ms)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string pdp_command = "AT+CGDCONT=" + std::to_string(pdp.context_id) +
                               ",\"" + pdp.protocol_type + "\",\"" + pdp.apn + "\"\r";
     return generic_command_common(t, pdp_command, timeout_ms);
@@ -294,25 +296,25 @@ command_result set_pdp_context(CommandableIf *t, PdpContext &pdp)
 
 command_result set_data_mode(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, "ATD*99#\r", "CONNECT", "ERROR", 5000);
 }
 
 command_result set_data_mode_alt(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, "ATD*99##\r", "CONNECT", "ERROR", 5000);
 }
 
 command_result resume_data_mode(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command(t, "ATO\r", "CONNECT", "ERROR", 5000);
 }
 
 command_result set_command_mode(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     const auto pass = std::list<std::string_view>({"NO CARRIER", "OK"});
     const auto fail = std::list<std::string_view>({"ERROR"});
     return generic_command(t, "+++", pass, fail, 5000);
@@ -320,25 +322,25 @@ command_result set_command_mode(CommandableIf *t)
 
 command_result get_imsi(CommandableIf *t, std::string &imsi_number)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_get_string(t, "AT+CIMI\r", imsi_number, 5000);
 }
 
 command_result get_imei(CommandableIf *t, std::string &out)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_get_string(t, "AT+CGSN\r", out, 5000);
 }
 
 command_result get_module_name(CommandableIf *t, std::string &out)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_get_string(t, "AT+CGMM\r", out, 5000);
 }
 
 command_result sms_txt_mode(CommandableIf *t, bool txt = true)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     if (txt) {
         return generic_command_common(t, "AT+CMGF=1\r");    // Text mode (default)
     }
@@ -348,13 +350,13 @@ command_result sms_txt_mode(CommandableIf *t, bool txt = true)
 command_result sms_character_set(CommandableIf *t)
 {
     // Sets the default GSM character set
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CSCS=\"GSM\"\r");
 }
 
 command_result send_sms(CommandableIf *t, const std::string &number, const std::string &message)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     auto ret = t->command("AT+CMGS=\"" + number + "\"\r", [&](uint8_t *data, size_t len) {
         std::string_view response((char *)data, len);
         ESP_LOGD(TAG, "Send SMS response %.*s", static_cast<int>(response.size()), response.data());
@@ -372,13 +374,13 @@ command_result send_sms(CommandableIf *t, const std::string &number, const std::
 
 command_result set_cmux(CommandableIf *t)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CMUX=0\r");
 }
 
 command_result read_pin(CommandableIf *t, bool &pin_ok)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CPIN?\r", out);
     if (ret != command_result::OK) {
@@ -400,21 +402,21 @@ command_result read_pin(CommandableIf *t, bool &pin_ok)
 
 command_result set_pin(CommandableIf *t, const std::string &pin)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string set_pin_command = "AT+CPIN=" + pin + "\r";
     return generic_command_common(t, set_pin_command);
 }
 
 command_result at(CommandableIf *t, const std::string &cmd, std::string &out, int timeout = 500)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string at_command = cmd + "\r";
     return generic_get_string(t, at_command, out, timeout);
 }
 
 command_result at_raw(CommandableIf *t, const std::string &cmd, std::string &out, const std::string &pass, const std::string &fail, int timeout = 500)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return t->command(cmd, [&](uint8_t *data, size_t len) {
         out.assign(reinterpret_cast<char *>(data), len);
 
@@ -430,7 +432,7 @@ command_result at_raw(CommandableIf *t, const std::string &cmd, std::string &out
 
 command_result get_signal_quality(CommandableIf *t, int &rssi, int &ber)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CSQ\r", out);
     if (ret != command_result::OK) {
@@ -456,19 +458,19 @@ command_result get_signal_quality(CommandableIf *t, int &rssi, int &ber)
 
 command_result set_operator(CommandableIf *t, int mode, int format, const std::string &oper)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+COPS=" + std::to_string(mode) + "," + std::to_string(format) + ",\"" + oper + "\"\r", 90000);
 }
 
 command_result set_network_attachment_state(CommandableIf *t, int state)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CGATT=" + std::to_string(state) + "\r");
 }
 
 command_result get_network_attachment_state(CommandableIf *t, int &state)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CGATT?\r", out);
     if (ret != command_result::OK) {
@@ -489,13 +491,13 @@ command_result get_network_attachment_state(CommandableIf *t, int &state)
 
 command_result set_radio_state(CommandableIf *t, int state)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CFUN=" + std::to_string(state) + "\r", 15000);
 }
 
 command_result get_radio_state(CommandableIf *t, int &state)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CFUN?\r", out);
     if (ret != command_result::OK) {
@@ -516,19 +518,19 @@ command_result get_radio_state(CommandableIf *t, int &state)
 
 command_result set_network_mode(CommandableIf *t, int mode)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CNMP=" + std::to_string(mode) + "\r");
 }
 
 command_result set_preferred_mode(CommandableIf *t, int mode)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CMNB=" + std::to_string(mode) + "\r");
 }
 
 command_result set_network_bands(CommandableIf *t, const std::string &mode, const int *bands, int size)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string band_string = "";
     for (int i = 0; i < size - 1; ++i) {
         band_string += std::to_string(bands[i]) + ",";
@@ -542,7 +544,7 @@ command_result set_network_bands(CommandableIf *t, const std::string &mode, cons
 // any_mode = "0xFFFFFFFF7FFFFFFF";
 command_result set_network_bands_sim76xx(CommandableIf *t, const std::string &mode, const int *bands, int size)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     static const char *hexDigits = "0123456789ABCDEF";
     uint64_t band_bits = 0;
     int hex_len = 16;
@@ -560,7 +562,7 @@ command_result set_network_bands_sim76xx(CommandableIf *t, const std::string &mo
 
 command_result get_network_system_mode(CommandableIf *t, int &mode)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CNSMOD?\r", out);
     if (ret != command_result::OK) {
@@ -582,13 +584,13 @@ command_result get_network_system_mode(CommandableIf *t, int &mode)
 
 command_result set_gnss_power_mode(CommandableIf *t, int mode)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CGNSPWR=" + std::to_string(mode) + "\r");
 }
 
 command_result get_gnss_power_mode(CommandableIf *t, int &mode)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     std::string out;
     auto ret = generic_get_string(t, "AT+CGNSPWR?\r", out);
     if (ret != command_result::OK) {
@@ -607,9 +609,72 @@ 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", 5000);
+    }
+    return generic_command_common(t, "AT+CPSMS=" + std::to_string(enabled) + "\r", 5000);
+}
+
+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(value) + "\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;
+    }
+
+    state_pos_start += 1; // move past the comma
+
+    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(CommandableIf *t, int mode, int access_technology, const std::string &edrx_value)
+{
+    if (mode == 1 || mode == 2) {
+        return dce_commands::generic_command_common(t,
+                                                    "AT+CEDRXS=" +
+                                                    std::to_string(mode) +
+                                                    "," +
+                                                    std::to_string(access_technology) +
+                                                    ",\"" +
+                                                    edrx_value + "\"\r");
+    }
+    return dce_commands::generic_command_common(t, "AT+SQNEDRX=" + std::to_string(mode), 500);
+}
 command_result set_gnss_power_mode_sim76xx(CommandableIf *t, int mode)
 {
-    ESP_LOGV(TAG, "%s", __func__ );
+    ESP_LOGV(TAG, "%s", __func__);
     return generic_command_common(t, "AT+CGPS=" + std::to_string(mode) + "\r");
 }
 

components/esp_modem/src/esp_modem_modules.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
  */
@@ -7,6 +7,7 @@
 #include "cxx_include/esp_modem_api.hpp"
 #include "cxx_include/esp_modem_dce_module.hpp"
 #include "generate/esp_modem_command_declare.inc"
+#include "cxx17_include/esp_modem_command_library_17.hpp"
 
 namespace esp_modem {
 
@@ -35,7 +36,7 @@ GenericModule::GenericModule(std::shared_ptr<DTE> dte, const dce_config *config)
 #define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, arg_nr, ...) \
      return_type GenericModule::name(__VA_ARGS__) { return esp_modem::dce_commands::name(dte.get() ARGS(arg_nr) ); }
 
-DECLARE_ALL_COMMAND_APIS(return_type name(...) )
+DECLARE_ALL_COMMAND_APIS(return_type name(...))
 
 #undef ESP_MODEM_DECLARE_DCE_COMMAND
 
@@ -87,4 +88,41 @@ command_result BG96::set_pdp_context(esp_modem::PdpContext &pdp)
     return dce_commands::set_pdp_context(dte.get(), pdp, 300);
 }
 
+bool SQNGM02S::setup_data_mode()
+{
+    return true;
+}
+
+command_result SQNGM02S::connect(PdpContext &pdp)
+{
+    command_result res;
+    configure_pdp_context(std::make_unique<PdpContext>(pdp));
+    set_pdp_context(*this->pdp);
+    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.
+    const auto pass = std::list<std::string_view>({"+CEREG: 1", "+CEREG: 5"});
+    const auto fail = std::list<std::string_view>({"ERROR"});
+    res = esp_modem::dce_commands::generic_command(dte.get(), "", pass, fail, 1200000);
+
+    if (res != command_result::OK) {
+        config_network_registration_urc(0);
+        return res;
+    }
+
+    res = config_network_registration_urc(0);
+    if (res != command_result::OK) {
+        return res;
+    }
+
+    return command_result::OK;
+}
 }

components/esp_modem/test/target_ota/main/ota_test.cpp

@@ -14,11 +14,17 @@
 #include "cxx_include/esp_modem_dte.hpp"
 #include "esp_modem_config.h"
 #include "cxx_include/esp_modem_api.hpp"
-#include "esp_vfs_dev.h"        // For optional VFS support
-#include "vfs_resource/vfs_create.hpp"
+#include "esp_idf_version.h"
 #include "network_dce.hpp"
 #include "manual_ota.hpp"
 #include "mqtt_client.h"
+// For optional VFS support
+#include "vfs_resource/vfs_create.hpp"
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+#include "driver/uart_vfs.h"
+#else
+#include "esp_vfs_dev.h"
+#endif
 
 using namespace esp_modem;
 
@@ -189,7 +195,12 @@ extern "C" void app_main(void)
     assert(vfs_create_uart(&uart_config, &dte_config.vfs_config) == true);
 
     auto dte = create_vfs_dte(&dte_config);
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
+    uart_vfs_dev_use_driver(uart_config.uart.port_num);
+#else
     esp_vfs_dev_uart_use_driver(uart_config.uart.port_num);
+#endif
+
 #else
     auto dte = create_uart_dte(&dte_config);
 #endif // CONFIG_TEST_USE_VFS_TERM

components/mdns/.cz.yaml

@@ -3,6 +3,6 @@ commitizen:
   bump_message: 'bump(mdns): $current_version -> $new_version'
   pre_bump_hooks: python ../../ci/changelog.py mdns
   tag_format: mdns-v$version
-  version: 1.8.1
+  version: 1.8.2
   version_files:
   - idf_component.yml

components/mdns/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.8.2](https://github.com/espressif/esp-protocols/commits/mdns-v1.8.2)
+
+### Bug Fixes
+
+- Fix parsing incorrect txt records ([8fd2c99f](https://github.com/espressif/esp-protocols/commit/8fd2c99f))
+
 ## [1.8.1](https://github.com/espressif/esp-protocols/commits/mdns-v1.8.1)
 
 ### Bug Fixes

components/mdns/idf_component.yml

@@ -1,4 +1,4 @@
-version: "1.8.1"
+version: "1.8.2"
 description: "Multicast UDP service used to provide local network service and host discovery."
 url: "https://github.com/espressif/esp-protocols/tree/master/components/mdns"
 issues: "https://github.com/espressif/esp-protocols/issues"

components/mdns/mdns.c

@@ -3593,7 +3593,7 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it
         }
 
         int name_len = _mdns_txt_item_name_get_len(data + i, partLen);
-        if (name_len < 0) {//invalid item (no name)
+        if (name_len < 0 || txt_num >= num_items) {//invalid item (no name or more items than expected)
             i += partLen;
             continue;
         }
@@ -3602,7 +3602,6 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it
             HOOK_MALLOC_FAILED;
             goto handle_error;//error
         }
-
         mdns_txt_item_t *t = &txt[txt_num];
         uint8_t *value_len = &txt_value_len[txt_num];
         txt_num++;
@@ -3624,6 +3623,8 @@ static void _mdns_result_txt_create(const uint8_t *data, size_t len, mdns_txt_it
             *value_len = new_value_len;
             i += new_value_len;
             t->value = value;
+        } else {
+            t->value = NULL;
         }
     }