docs(common): improving documentation

- update esp_modem to use esp_docs
- migrated docs from github pages to docs.espressif.com

.flake8

@@ -137,4 +137,4 @@ show_source = True
 statistics = True
 
 exclude =
-        components/asio/docs/conf_common.py
+        docs/asio/conf_common.py

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,51 @@
+name: Installation or build bug report
+description: Report installation or build bugs
+labels: ['Type: Bug']
+body:
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Answers checklist.
+      description: Before submitting a new issue, please follow the checklist and try to find the answer.
+      options:
+        - label: I have read the documentation for [esp-protocols components](https://espressif.github.io/esp-protocols/) and the issue is not addressed there.
+          required: true
+        - label: I have updated my esp-protocols branch (master or release) to the latest version and checked that the issue is present there.
+          required: true
+        - label: I have searched the issue tracker for a similar issue and not found a similar issue.
+          required: true
+  - type: dropdown
+    id: component
+    attributes:
+      label: What component are you using? If you choose Other, provide details in More Information.
+      multiple: false
+      options:
+        - ASIO port
+        - esp_modem
+        - esp_websocket_client
+        - mDNS
+        - Other
+    validations:
+      required: true
+  - type: input
+    id: component_id
+    attributes:
+      label: component version
+      description: Which component version does this issue occur on? (see your `idf_component.yml`)
+      placeholder: ex. 1.0.0
+  - type: input
+    id: idf_version
+    attributes:
+      label: IDF version.
+      description: On which IDF version does this issue occur on? Run `git describe --tags` to find it.
+      placeholder: ex. v3.2-dev-1148-g96cd3b75c
+    validations:
+      required: true
+  - type: textarea
+    id: more-info
+    attributes:
+      label: More Information.
+      description: Do you have any other information from investigating this?
+      placeholder: ex. I tried on my friend's Windows 10 PC and the command works there.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+contact_links:
+  - name: esp-protocols documentation
+    url: https://espressif.github.io/esp-protocols/
+    about: Documenation for esp-protocols components.
+  - name: ESP-IDF Programming Guide
+    url: https://docs.espressif.com/projects/esp-idf/en/latest/
+    about: Documentation for configuring and using ESP-IDF.
+  - name: Espressif documentation page
+    url: https://www.espressif.com/en/support/download/documents
+    about: Hardware documentation (datasheets, Technical Reference Manual, etc).
+  - name: Forum
+    url: https://esp32.com
+    about: For questions about using ESP-IDF and/or ESP32 series chips. Please submit all questions starting "How do I..." here.

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,33 @@
+name: Feature request
+description: Suggest an idea or new component for this project.
+labels: ['Type: Feature Request']
+body:
+  - type: markdown
+    attributes:
+      value: |
+        * We welcome any ideas or feature requests! It’s helpful if you can explain exactly why the feature would be useful.
+        * There are usually some outstanding feature requests in the [existing issues list](https://github.com/espressif/esp-protocols/labels/Type%3A%20Feature%20Request), feel free to add comments to them.
+  - type: textarea
+    id: problem-related
+    attributes:
+      label: Is your feature request related to a problem?
+      description: Please provide a clear and concise description of what the problem is.
+      placeholder: ex. I'm always frustrated when ...
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe the solution you'd like.
+      description: Please provide a clear and concise description of what you want to happen.
+      placeholder: ex. When building my application ...
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered.
+      description: Please provide a clear and concise description of any alternative solutions or features you've considered.
+      placeholder: ex. Choosing other approach wouldn't work, because ...
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context.
+      description: Please add any other context or screenshots about the feature request here.
+      placeholder: ex. This would work only when ...

.github/ISSUE_TEMPLATE/other-issue.yml

@@ -0,0 +1,23 @@
+name: General issue report
+description: File an issue report
+body:
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Answers checklist.
+      description: Before submitting a new issue, please follow the checklist and try to find the answer.
+      options:
+        - label: I have read the documentation for [esp-protocols components](https://espressif.github.io/esp-protocols/) and the issue is not addressed there.
+          required: true
+        - label: I have updated my esp-protocols branch (master or release) to the latest version and checked that the issue is present there.
+          required: true
+        - label: I have searched the issue tracker for a similar issue and not found a similar issue.
+          required: true
+  - type: textarea
+    id: issue
+    attributes:
+      label: General issue report
+      description: Your issue report goes here.
+      placeholder: ex. How do I...
+    validations:
+      required: true

.github/workflows/asio__build-target-test.yml

@@ -0,0 +1,100 @@
+name: "asio: build/target-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_asio:
+    if: contains(github.event.pull_request.labels.*.name, 'asio') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.0"]
+        idf_target: ["esp32", "esp32s2"]
+        example: ["asio_chat", "async_request", "socks4", "ssl_client_server", "tcp_echo_server", "udp_echo_server"]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/asio/examples
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          test -f sdkconfig.ci && cat sdkconfig.ci >> sdkconfig.defaults || echo "No sdkconfig.ci"
+          idf.py set-target ${{ matrix.idf_target }}
+          idf.py build
+      - name: Merge binaries with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }} for ${{ matrix.example }}
+        working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}/build
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
+      - uses: actions/upload-artifact@v3
+        with:
+          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
+          path: |
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/bootloader/bootloader.bin
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build//partition_table/partition-table.bin
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/*.bin
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/*.elf
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/flasher_args.json
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/config/sdkconfig.h
+            ${{ env.TEST_DIR }}/${{ matrix.example }}/build/config/sdkconfig.json
+          if-no-files-found: error
+
+  target_tests_asio:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'asio') || github.event_name == 'push' )
+    name: Target tests
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.0"]
+        idf_target: ["esp32"]
+        example: ["asio_chat", "tcp_echo_server", "udp_echo_server", "ssl_client_server"]
+    needs: build_asio
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/asio/examples
+    steps:
+      - name: Clear repository
+        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
+          path: ${{ env.TEST_DIR }}/${{ matrix.example }}/build
+      - name: Install Python packages
+        env:
+          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
+        run: |
+            sudo apt-get install -y dnsutils
+      - name: Download Example Test to target ${{ matrix.config }}
+        run: |
+            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 ${{ env.TEST_DIR }}/${{ matrix.example }}/build/flash_image.bin
+      - name: Run Example Test ${{ matrix.example }} on target
+        working-directory: ${{ env.TEST_DIR }}/${{ matrix.example }}
+        run: |
+            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}.xml --target=${{ matrix.idf_target }}
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
+          path: ${{ env.TEST_DIR }}/${{ matrix.example }}/*.xml

.github/workflows/host-test.yml

@@ -1,44 +0,0 @@
-name: Host test
-
-on: [push, pull_request]
-
-jobs:
-  host_test:
-    name: Build and Test on Host
-    runs-on: ubuntu-20.04
-    container: espressif/idf:release-v4.3
-    env:
-      lwip: lwip-2.1.2
-      lwip_contrib: contrib-2.1.0
-      lwip_uri: http://download.savannah.nongnu.org/releases/lwip
-
-
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@master
-        with:
-          path: esp-protocols
-
-      - name: Build and Test
-        shell: bash
-        run: |
-          apt-get update && apt-get install -y gcc-8 g++-8
-          update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800 --slave /usr/bin/g++ g++ /usr/bin/g++-8
-          export LWIP_PATH=`pwd`/${{ env.lwip }}
-          export LWIP_CONTRIB_PATH=`pwd`/${{ env.lwip_contrib }}
-          wget --no-verbose ${lwip_uri}/${lwip}.zip
-          unzip -oq ${lwip}.zip
-          wget --no-verbose ${lwip_uri}/${lwip_contrib}.zip
-          unzip -oq ${lwip_contrib}.zip
-          . ${IDF_PATH}/export.sh
-          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/examples/linux_modem
-          idf.py build
-          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/test/host_test
-          idf.py build
-          ./build/host_modem_test.elf -r junit -o junit.xml
-
-      - name: Publish Results
-        uses: EnricoMi/publish-unit-test-result-action@v1
-        if: always()
-        with:
-          files: esp-protocols/components/esp_modem/test/host_test/junit.xml

.github/workflows/mdns__build-target-test.yml

@@ -0,0 +1,173 @@
+name: "mdns: build/target-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_mdns:
+    if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32", "esp32s2", "esp32c3"]
+        test: [ { app: example, path: "components/mdns/examples" }, { app: unit_test, path: "components/mdns/tests/unit_test" } ]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        shell: bash
+        working-directory: ${{ matrix.test.path }}
+        run: |
+          ${IDF_PATH}/install.sh --enable-pytest
+          . ${IDF_PATH}/export.sh
+          python $IDF_PATH/tools/ci/ci_build_apps.py . --target ${{ matrix.idf_target }} -vv --preserve-all --pytest-app
+          for dir in `ls -d build_*`; do
+          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
+          zip -qur artifacts.zip $dir
+          done
+      - uses: actions/upload-artifact@v3
+        if: ${{ matrix.idf_target }} == "esp32"
+        with:
+          name: mdns_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ matrix.test.path }}/artifacts.zip
+          if-no-files-found: error
+
+  build_mdns_app:
+    if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
+    name: Build Test Apps
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32", "esp32s2", "esp32c3"]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Setup Build Environment
+        working-directory: components/mdns/tests/test_apps
+        run: |
+          . ${IDF_PATH}/export.sh
+          pip install -r $GITHUB_WORKSPACE/ci/requirements.txt
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        working-directory: components/mdns/tests/test_apps
+        run: |
+          . ${IDF_PATH}/export.sh
+          python $IDF_PATH/tools/ci/ci_build_apps.py . --target ${{ matrix.idf_target }} -vv --pytest-apps
+      - name: Merge binaries with IDF-${{ matrix.idf_ver }}
+        working-directory: components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
+      - uses: actions/upload-artifact@v2
+        with:
+          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
+          path: |
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/bootloader/bootloader.bin
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/partition_table/partition-table.bin
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/*.bin
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/*.elf
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/flasher_args.json
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/config/sdkconfig.h
+            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/config/sdkconfig.json
+          if-no-files-found: error
+
+  target_test_apps_mdns:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push' )
+    name: Target Test Apps
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32"]
+    needs: build_mdns_app
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    steps:
+      - name: Clear repository
+        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v2
+        with:
+          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
+          path: components/mdns/tests/test_apps/build
+      - name: Install Python packages
+        env:
+          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
+        run: |
+            sudo apt-get install -y dnsutils
+      - name: Download Test apps to target
+        run: |
+            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/mdns/tests/test_apps/build/flash_image.bin
+      - name: Run Example Test on target
+        working-directory: components/mdns/tests/test_apps
+        run: |
+            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml --target=${{matrix.idf_target}}
+      - uses: actions/upload-artifact@v2
+        if: always()
+        with:
+          name: test_apps_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
+          path: components/mdns/tests/test_apps/*.xml
+
+  target_tests_mdns:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push' )
+    name: Target Example and Unit tests
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32"]
+        test: [ { app: example, path: "components/mdns/examples" }, { app: unit_test, path: "components/mdns/tests/unit_test" } ]
+    needs: build_mdns
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    steps:
+      - name: Clear repository
+        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: mdns_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ matrix.test.path }}/ci/
+      - name: Install Python packages
+        env:
+          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
+        run: |
+            sudo apt-get install -y dnsutils
+      - name: Run ${{ matrix.test.app }} application on ${{ matrix.idf_target }}
+        working-directory: ${{ matrix.test.path }}
+        run: |
+            unzip ci/artifacts.zip -d ci
+            for dir in `ls -d ci/build_*`; do
+            rm -rf build sdkconfig.defaults
+            mv $dir build
+            python -m pytest --log-cli-level DEBUG --junit-xml=./results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${dir#"ci/build_"}.xml --target=${{ matrix.idf_target }}
+            done
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: results_${{ matrix.test.app }}_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml
+          path: ${{ matrix.test.path }}/*.xml

.github/workflows/mdns__host-tests.yml

@@ -0,0 +1,61 @@
+name: "mdns: host-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  host_test_mdns:
+    if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
+    name: Host test
+    runs-on: ubuntu-20.04
+    container: espressif/idf:latest
+
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@master
+        with:
+          path: esp-protocols
+
+      - name: Build and Test
+        shell: bash
+        run: |
+          apt-get update && apt-get install -y dnsutils gcc g++
+          . ${IDF_PATH}/export.sh
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/host_test
+          idf.py build
+          ./build/mdns_host.elf &
+          dig +short -p 5353 @224.0.0.251 myesp.local > ip.txt
+          cat ip.txt | xargs dig +short -p 5353 @224.0.0.251 -x
+          cat ip.txt
+
+  build_afl_host_test_mdns:
+    if: contains(github.event.pull_request.labels.*.name, 'mdns') || github.event_name == 'push'
+    name: Build AFL host test
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32"]
+
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@master
+        with:
+          path: esp-protocols
+      - name: Install Necessary Libs
+        run: |
+          apt-get update -y
+          apt-get install -y libbsd-dev
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/test_afl_fuzz_host/
+          make INSTR=off

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

@@ -0,0 +1,177 @@
+name: "esp-modem: build/host-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_esp_modem:
+    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v4.2", "release-v4.3", "release-v4.4", "release-v5.0"]
+        example: ["pppos_client", "modem_console", "modem_tcp_client", "ap_to_pppos", "simple_cmux_client"]
+        exclude:
+          - idf_ver: "release-v4.2"
+            example: simple_cmux_client
+          - idf_ver: "release-v4.2"
+            example: modem_tcp_client
+          - idf_ver: "release-v4.3"
+            example: modem_tcp_client
+        include:
+          - idf_ver: "release-v4.2"
+            skip_config: usb
+          - idf_ver: "release-v4.3"
+            skip_config: usb
+          - idf_ver: "release-v5.0"
+            example: "simple_cmux_client"
+            warning: "Warning: The smallest app partition is nearly full"
+
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          path: protocols
+      - 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
+        run: |
+          . ${IDF_PATH}/export.sh
+          python -m pip install idf-build-apps
+          cd $GITHUB_WORKSPACE/protocols
+          python ./ci/build_apps.py components/esp_modem/examples/${{ matrix.example }}
+
+  host_test_esp_modem:
+    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
+    name: Host Tests
+    runs-on: ubuntu-20.04
+    container: espressif/idf:release-v4.3
+    env:
+      lwip: lwip-2.1.2
+      lwip_contrib: contrib-2.1.0
+      lwip_uri: http://download.savannah.nongnu.org/releases/lwip
+      COMP_DIR: esp-protocols/components/esp_modem
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@master
+        with:
+          path: esp-protocols
+
+      - name: Build and Test
+        shell: bash
+        run: |
+          apt-get update && apt-get install -y gcc-8 g++-8
+          update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800 --slave /usr/bin/g++ g++ /usr/bin/g++-8
+          export LWIP_PATH=`pwd`/${{ env.lwip }}
+          export LWIP_CONTRIB_PATH=`pwd`/${{ env.lwip_contrib }}
+          . ${IDF_PATH}/export.sh
+          $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/test/host_test/env.sh $lwip $lwip_uri $lwip_contrib
+          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/examples/linux_modem
+          idf.py build
+          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/test/host_test
+          idf.py build
+          ./build/host_modem_test.elf -r junit -o junit.xml
+
+      - name: Publish Results
+        uses: EnricoMi/publish-unit-test-result-action@v1
+        if: always()
+        with:
+          files: esp-protocols/components/esp_modem/test/host_test/junit.xml
+
+  host_test_gcov_esp_modem:
+    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
+    name: Run gcovr on esp modem host test
+    runs-on: ubuntu-22.04
+    container: espressif/idf:release-v4.3
+    env:
+      lwip: lwip-2.1.2
+      lwip_contrib: contrib-2.1.0
+      lwip_uri: http://download.savannah.nongnu.org/releases/lwip
+      COMP_DIR: esp-protocols/components/esp_modem
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          path: esp-protocols
+          persist-credentials: false
+      - name: Build and Test
+        shell: bash
+        run: |
+          apt-get update
+          apt-get update && apt-get install -y gcc-8 g++-8 python3-pip
+          apt-get install -y rsync
+          update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800 --slave /usr/bin/g++ g++ /usr/bin/g++-8
+          export DEBIAN_FRONTEND=noninteractive
+          export LWIP_PATH=`pwd`/${{ env.lwip }}
+          export LWIP_CONTRIB_PATH=`pwd`/${{ env.lwip_contrib }}
+          . ${IDF_PATH}/export.sh
+          ${{ env.COMP_DIR }}/test/host_test/env.sh $lwip $lwip_uri $lwip_contrib
+          cd $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/test/host_test
+          cat sdkconfig.ci.coverage >> sdkconfig.defaults
+          idf.py build
+          ./build/host_modem_test.elf
+      - name: Run gcovr
+        shell: bash
+        run: |
+          python -m pip install gcovr
+          cd $GITHUB_WORKSPACE/${{ env.COMP_DIR }}
+          gcov-8 `find . -name "esp_modem*gcda" -printf '%h\n' | head -n 1`/*
+          gcovr --gcov-ignore-parse-errors -g -k -r . --html index.html  -x esp_modem_coverage.xml
+          mkdir docs_gcovr
+          cp $GITHUB_WORKSPACE/${{ env.COMP_DIR }}/index.html docs_gcovr
+          touch docs_gcovr/.nojekyll
+
+      - name: Code Coverage Summary Report
+        uses: irongut/CodeCoverageSummary@v1.3.0
+        with:
+          filename: esp-protocols/**/esp_modem_coverage.xml
+          badge: true
+          fail_below_min: false
+          format: markdown
+          hide_branch_rate: false
+          hide_complexity: false
+          indicators: true
+          output: both
+          thresholds: '60 80'
+
+      - name: Write to Job Summary
+        run: cat code-coverage-results.md >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: docs_gcovr
+          path: |
+            ${{ env.COMP_DIR }}/docs_gcovr
+          if-no-files-found: error
+
+#  show_report_data:
+#    name: Publish-Results
+#    if: github.ref == 'refs/heads/master' || github.repository != 'espressif/esp-protocols'
+#    runs-on: ubuntu-22.04
+#    needs: gcovr_analyzer_esp_modem
+#    steps:
+#      - name: Checkout 🛎️
+#        uses: actions/checkout@v3
+#        with:
+#          persist-credentials: false
+#      - name: Download Artifacts
+#        uses: actions/download-artifact@v1
+#        with:
+#          name: docs_gcovr
+#
+#      - name: Deploy generated docs
+#        uses: JamesIves/github-pages-deploy-action@v4
+#        with:
+#          branch: gh-pages
+#          folder: 'docs_gcovr'

.github/workflows/modem__target-test.yml

@@ -0,0 +1,75 @@
+name: "esp-modem: target-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_esp_modem_tests:
+    if: contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push'
+    name: Build Target tests
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32c3"]
+        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client } ]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/esp_modem/${{ matrix.test.path }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build esp-modem target tests with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+          SDKCONFIG: sdkconfig.ci.${{ matrix.test.app }}
+        shell: bash
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          . ${IDF_PATH}/export.sh
+          rm -rf sdkconfig build
+          [ -f ${SDKCONFIG} ] && cp ${SDKCONFIG} sdkconfig.defaults
+          idf.py set-target ${{ matrix.idf_target }}
+          idf.py build
+          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh ${GITHUB_WORKSPACE}/${TEST_DIR}/build
+      - uses: actions/upload-artifact@v3
+        with:
+          name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ env.TEST_DIR }}/build
+          if-no-files-found: error
+
+  target_tests_esp_modem:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'modem') || github.event_name == 'push' )
+    name: Run Target tests
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+        idf_target: ["esp32c3"]
+        test: [ { app: pppd, path: test/target }, { app: sim800_c3, path: examples/pppos_client } ]
+    needs: build_esp_modem_tests
+    runs-on:
+      - self-hosted
+      - BrnoRPI-GH006
+    env:
+      TEST_DIR: components/esp_modem/${{ matrix.test.path }}
+    steps:
+      - name: Clear repository
+        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: modem_target_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ env.TEST_DIR }}/build
+      - name: Run Example Test on target
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+            python -m pytest --log-cli-level DEBUG --target=${{ matrix.idf_target }}

.github/workflows/mqtt_cxx__build.yml

@@ -0,0 +1,32 @@
+name: "mqtt-cxx: build-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_esp_mqtt_cxx:
+    if: contains(github.event.pull_request.labels.*.name, 'mqtt') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.0"]
+        idf_target: ["esp32"]
+        test: [ { app: example, path: "components/esp_mqtt_cxx/examples" }]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        shell: bash
+        working-directory: ${{matrix.test.path}}
+        run: |
+          ${IDF_PATH}/install.sh --enable-pytest
+          . ${IDF_PATH}/export.sh
+          python $IDF_PATH/tools/ci/ci_build_apps.py . --target ${{ matrix.idf_target }} -vv --preserve-all --pytest-app

.github/workflows/pre_commit_check.yml

@@ -26,6 +26,7 @@ jobs:
         run: |
           pip install pre-commit
           pre-commit install-hooks
+          pre-commit install --hook-type commit-msg --hook-type pre-push
       - name: Run pre-commit and check for any changes
         run: |
           echo "Commits being checked:"

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

@@ -1,17 +1,25 @@
 name: Docs and Publish
 
-on:
-  push:
-    branches:
-      - master
+on: [push, pull_request]
+#    branches:
+#      - master
+
+env:
+  DOCS_DEPLOY_URL_BASE: ${{ secrets.DOCS_DEPLOY_URL_BASE }}
+  DOCS_DEPLOY_SERVER: ${{ secrets.DOCS_DEPLOY_SERVER }}
+  DOCS_DEPLOY_SERVER_USER: ${{ secrets.DOCS_DEPLOY_SERVER_USER }}
+  DOCS_DEPLOY_KEY: ${{ secrets.DOCS_DEPLOY_PRIVATEKEY }}
+  DOCS_DEPLOY_PATH : ${{ secrets.DOCS_DEPLOY_PATH }}
 
 jobs:
   docs_build:
     name: Docs-Build-And-Upload
+    strategy:
+      matrix:
+        ver: ["latest"]
     runs-on: ubuntu-latest
     # Skip running on forks since it won't have access to secrets
-    if: github.repository == 'espressif/esp-protocols'
-
+    #if: github.repository == 'espressif/esp-protocols'
     steps:
       - name: Checkout esp-protocols
         uses: actions/checkout@master
@@ -19,52 +27,33 @@ jobs:
           persist-credentials: false
           fetch-depth: 0
           submodules: recursive
-
       - name: Generate docs
+        shell: bash
         run: |
-          sudo apt-get update
-          sudo apt-get -y install doxygen clang python3-pip
-          python -m pip install breathe recommonmark esp-docs
-          cd $GITHUB_WORKSPACE/components/esp_modem/docs
-          ./generate_docs
-          mkdir -p $GITHUB_WORKSPACE/docs/esp_modem
-          cp -r html/. $GITHUB_WORKSPACE/docs/esp_modem
-
-          cd $GITHUB_WORKSPACE/components/esp_websocket_client/docs
-          ./generate_docs
-          mkdir -p $GITHUB_WORKSPACE/docs/esp_websocket_client
-          cp -r html/. $GITHUB_WORKSPACE/docs/esp_websocket_client
-
-          cd $GITHUB_WORKSPACE/components/mdns/docs
-          ./generate_docs
-          mkdir -p $GITHUB_WORKSPACE/docs/mdns/en
-          mkdir -p $GITHUB_WORKSPACE/docs/mdns/zh_CN
-          cp -r html_en/. $GITHUB_WORKSPACE/docs/mdns/en
-          cp -r html_zh_CN/. $GITHUB_WORKSPACE/docs/mdns/zh_CN
-
-          cd $GITHUB_WORKSPACE/components/asio/docs
-          ./generate_docs
-          mkdir -p $GITHUB_WORKSPACE/docs/asio
-          cp -r html/. $GITHUB_WORKSPACE/docs/asio
-
-          cd $GITHUB_WORKSPACE/docs
-          touch .nojekyll
-          echo '<a href="esp_modem/index.html">esp-modem</a><br>' > index.html
-          echo '<a href="esp_websocket_client/index.html">esp-websocket-client</a><br>' >> index.html
-          echo '<a href="asio/index.html">ASIO</a><br>' >> index.html
-          echo '<a href="mdns/en/index.html">mDNS_en</a><br>' >> index.html
-          echo '<a href="mdns/zh_CN/index.html">mDNS_zh_CN</a><br>' >> index.html
-
-
-      - name: Upload components to component service
-        uses: espressif/github-actions/upload_components@master
-        with:
-          directories: "components/esp_modem;components/esp_websocket_client;components/mdns;components/asio"
-          namespace: "espressif"
-          api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}
-
-      - name: Deploy generated docs
-        uses: JamesIves/github-pages-deploy-action@4.1.5
-        with:
-          branch: gh-pages
-          folder: docs
+            sudo apt-get update
+            sudo apt-get -y install doxygen clang python3-pip
+            python -m pip install breathe recommonmark esp-docs==1.4.1
+            cd $GITHUB_WORKSPACE/docs
+            ./generate_docs
+            touch .nojekyll
+            echo '<a href="esp_modem/index.html">esp-modem</a><br>' > index.html
+            echo '<a href="esp_websocket_client/index.html">esp-websocket-client</a><br>' >> index.html
+            echo '<a href="asio/index.html">ASIO</a><br>' >> index.html
+            echo '<a href="mdns/en/html/index.html">mDNS_en</a><br>' >> index.html
+            echo '<a href="mdns/zh_CN/html/index.html">mDNS_zh_CN</a><br>' >> index.html
+      - name: Deploying generated docs
+        if: always()
+        shell: bash
+        run: |
+            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=${{ matrix.ver }}
+            export DOCS_BUILD_DIR=$GITHUB_WORKSPACE/docs
+            deploy-docs
+#      - name: Upload components to component service
+#        uses: espressif/github-actions/upload_components@master
+#        with:
+#          directories: "components/esp_modem;components/esp_websocket_client;components/mdns;components/asio"
+#          namespace: "espressif"
+#          api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}

.github/workflows/target-test.yml

@@ -1,312 +0,0 @@
-name: Build and Run Target tests
-
-on: [push, pull_request]
-
-jobs:
-  build_esp_modem:
-    strategy:
-      matrix:
-        idf_ver: ["latest", "release-v4.1", "release-v4.2", "release-v4.3", "release-v4.4"]
-        example: ["pppos_client", "modem_console", "ap_to_pppos", "simple_cmux_client"]
-        idf_target: ["esp32"]
-        exclude:
-          - idf_ver: "release-v4.1"
-            example: modem_console
-          - idf_ver: "release-v4.1"
-            example: ap_to_pppos
-          - idf_ver: "release-v4.1"
-            example: simple_cmux_client
-          - idf_ver: "release-v4.2"
-            example: simple_cmux_client
-
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@master
-        with:
-          path: esp-protocols
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          cd $GITHUB_WORKSPACE/esp-protocols/components/esp_modem/examples/${{ matrix.example }}
-          idf.py build
-
-  build_esp_modem_usb:
-    strategy:
-      matrix:
-        idf_ver: ["latest", "release-v4.4", "release-v5.0"]
-        example: ["modem_console", "pppos_client"]
-        idf_target: ["esp32s2", "esp32s3"]
-
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        working-directory: components/esp_modem/examples/${{ matrix.example }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          cat sdkconfig.ci.usb >> sdkconfig.defaults
-          idf.py build
-
-  build_mdns:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32", "esp32s2", "esp32c3"]
-        config: ["eth_custom_netif", "eth_def", "eth_no_ipv6", "eth_socket"]
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }} for ${{ matrix.config }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        working-directory: components/mdns/examples/
-        run: |
-          . ${IDF_PATH}/export.sh
-          rm -rf sdkconfig sdkconfig.defaults build build_${{ matrix.config }}
-          cat sdkconfig.ci.${{ matrix.config }} >> sdkconfig.defaults
-          idf.py set-target ${{ matrix.idf_target }}
-          idf.py build
-          mv build build_${{ matrix.config }}
-      - name: Merge binaries with IDF-${{ matrix.idf_ver }} for ${{ matrix.config }}
-        working-directory: components/mdns/examples
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          cd build_${{ matrix.config }}
-          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-          cd ../
-          cat build_${{ matrix.config }}/config/sdkconfig.json
-      - uses: actions/upload-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}
-          path: |
-            components/mdns/examples/build_${{ matrix.config }}/bootloader/bootloader.bin
-            components/mdns/examples/build_${{ matrix.config }}/partition_table/partition-table.bin
-            components/mdns/examples/build_${{ matrix.config }}/*.bin
-            components/mdns/examples/build_${{ matrix.config }}/*.elf
-            components/mdns/examples/build_${{ matrix.config }}/flasher_args.json
-            components/mdns/examples/build_${{ matrix.config }}/config/sdkconfig.h
-            components/mdns/examples/build_${{ matrix.config }}/config/sdkconfig.json
-          if-no-files-found: error
-
-  build_asio:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32", "esp32s2"]
-        example: ["asio_chat", "async_request", "socks4", "ssl_client_server", "tcp_echo_server", "udp_echo_server"]
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        working-directory: components/asio/examples/${{ matrix.example }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          test -f sdkconfig.ci && cat sdkconfig.ci >> sdkconfig.defaults || echo "No sdkconfig.ci"
-          idf.py set-target ${{ matrix.idf_target }}
-          idf.py build
-      - name: Merge binaries with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }} for ${{ matrix.example }}
-        working-directory: components/asio/examples/${{ matrix.example }}/build
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-      - uses: actions/upload-artifact@v3
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
-          path: |
-            components/asio/examples/${{ matrix.example }}/build/bootloader/bootloader.bin
-            components/asio/examples/${{ matrix.example }}/build//partition_table/partition-table.bin
-            components/asio/examples/${{ matrix.example }}/build/*.bin
-            components/asio/examples/${{ matrix.example }}/build/*.elf
-            components/asio/examples/${{ matrix.example }}/build/flasher_args.json
-            components/asio/examples/${{ matrix.example }}/build/config/sdkconfig.h
-            components/asio/examples/${{ matrix.example }}/build/config/sdkconfig.json
-          if-no-files-found: error
-
-
-  build_websocket:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        working-directory: components/esp_websocket_client/examples/
-        run: |
-          . ${IDF_PATH}/export.sh
-          cat sdkconfig.ci >> sdkconfig.defaults
-          idf.py build
-      - name: Merge binaries
-        working-directory: components/esp_websocket_client/examples/build
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-      - uses: actions/upload-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: |
-            components/esp_websocket_client/examples/build/bootloader/bootloader.bin
-            components/esp_websocket_client/examples/build/partition_table/partition-table.bin
-            components/esp_websocket_client/examples/build/*.bin
-            components/esp_websocket_client/examples/build/*.elf
-            components/esp_websocket_client/examples/build/flasher_args.json
-            components/esp_websocket_client/examples/build/config/sdkconfig.h
-            components/esp_websocket_client/examples/build/config/sdkconfig.json
-          if-no-files-found: error
-
-  run-target-websocket:
-    name: Run Websocket Example Test on target
-    needs: build_websocket
-    strategy:
-      fail-fast: false
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-    runs-on:
-      - self-hosted
-      - ESP32-ETHERNET-KIT
-    # Skip running on forks since it won't have access to secrets
-    if: github.repository == 'espressif/esp-protocols'
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: components/esp_websocket_client/examples/build/
-      - name: Install Python packages
-        env:
-          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
-        run: |
-          pip install --only-binary cryptography --extra-index-url https://dl.espressif.com/pypi/ -r $GITHUB_WORKSPACE/ci/requirements.txt
-      - name: Download Example Test to target
-        run: python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/esp_websocket_client/examples/build/flash_image.bin
-      - name: Run Example Test on target
-        working-directory: components/esp_websocket_client/examples
-        run: |
-          python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml --target=${{ matrix.idf_target }}
-      - uses: actions/upload-artifact@v2
-        if: always()
-        with:
-          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: components/esp_websocket_client/examples/*.xml
-
-  run-target-mdns:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-        config: ["eth_custom_netif", "eth_def", "eth_no_ipv6", "eth_socket"]
-    name: Run mDNS Example Test on target
-    needs: build_mdns
-    runs-on:
-      - self-hosted
-      - ESP32-ETHERNET-KIT
-    # Skip running on forks since it won't have access to secrets
-    if: github.repository == 'espressif/esp-protocols'
-    steps:
-      - name: Clear repository
-        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}
-          path: components/mdns/examples/build_${{ matrix.config }}
-      - name: Install Python packages
-        env:
-          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
-        run: |
-            sudo apt-get install -y dnsutils
-      - name: Download Example Test to target ${{ matrix.config }}
-        run: |
-            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/mdns/examples/build_${{ matrix.config }}/flash_image.bin
-      - name: Run Example Test on target ${{ matrix.config }}
-        working-directory: components/mdns/examples
-        run: |
-            rm -rf build
-            mv build_${{ matrix.config }} build
-            cat sdkconfig.ci.${{ matrix.config }} >> sdkconfig.defaults
-            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}.xml --target=${{ matrix.idf_target }}
-            rm -rf build sdkconfig.defaults
-      - uses: actions/upload-artifact@v2
-        if: always()
-        with:
-          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}
-          path: components/mdns/examples/*.xml
-
-  run-target-asio:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-        example: ["asio_chat", "tcp_echo_server", "udp_echo_server", "ssl_client_server"]
-    name: Run ASIO Example Test on target
-    needs: build_asio
-    runs-on:
-      - self-hosted
-      - ESP32-ETHERNET-KIT
-    # Skip running on forks since it won't have access to secrets
-    if: github.repository == 'espressif/esp-protocols'
-    steps:
-      - name: Clear repository
-        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
-          path: components/asio/examples/${{ matrix.example }}/build
-      - name: Install Python packages
-        env:
-          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
-        run: |
-            sudo apt-get install -y dnsutils
-      - name: Download Example Test to target ${{ matrix.config }}
-        run: |
-            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/asio/examples/${{ matrix.example }}/build/flash_image.bin
-      - name: Run Example Test ${{ matrix.example }} on target
-        working-directory: components/asio/examples/${{ matrix.example }}
-        run: |
-            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.config }}.xml --target=${{ matrix.idf_target }}
-      - uses: actions/upload-artifact@v2
-        if: always()
-        with:
-          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}_${{ matrix.example }}
-          path: components/asio/examples/${{ matrix.example }}/*.xml

.github/workflows/test_afl_fuzzer.yml

@@ -1,30 +0,0 @@
-name: AFL fuzzer compilation test
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@master
-        with:
-          path: esp-protocols
-      - name: Install Necessary Libs
-        run: |
-          apt-get update -y
-          apt-get install -y libbsd-dev
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          cd $GITHUB_WORKSPACE/esp-protocols/components/mdns/tests/test_afl_fuzz_host/
-          make INSTR=off

.github/workflows/test_apps.yml

@@ -1,94 +0,0 @@
-name: Build and Run Test apps
-
-on:
-   push:
-     paths:
-       - 'components/mdns/**'
-   pull_request:
-     paths:
-       - 'components/mdns/**'
-
-jobs:
-  build_mdns_app:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32", "esp32s2", "esp32c3"]
-    runs-on: ubuntu-20.04
-    container: espressif/idf:${{ matrix.idf_ver }}
-    steps:
-      - name: Checkout esp-protocols
-        uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - name: Setup Build Environment
-        working-directory: components/mdns/tests/test_apps
-        run: |
-          . ${IDF_PATH}/export.sh
-          pip install -r $GITHUB_WORKSPACE/ci/requirements.txt
-      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        working-directory: components/mdns/tests/test_apps
-        run: |
-          . ${IDF_PATH}/export.sh
-          python $IDF_PATH/tools/ci/ci_build_apps.py . --target ${{ matrix.idf_target }} -vv --pytest-apps
-      - name: Merge binaries with IDF-${{ matrix.idf_ver }}
-        working-directory: components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default
-        env:
-          IDF_TARGET: ${{ matrix.idf_target }}
-        shell: bash
-        run: |
-          . ${IDF_PATH}/export.sh
-          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
-      - uses: actions/upload-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: |
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/bootloader/bootloader.bin
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/partition_table/partition-table.bin
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/*.bin
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/*.elf
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/flasher_args.json
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/config/sdkconfig.h
-            components/mdns/tests/test_apps/build_${{ matrix.idf_target }}_default/config/sdkconfig.json
-          if-no-files-found: error
-
-  run-target-mdns-app:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-    name: Run mDNS Test apps on target
-    needs: build_mdns_app
-    runs-on:
-      - self-hosted
-      - ESP32-ETHERNET-KIT
-    # Skip running on forks since it won't have access to secrets
-    if: github.repository == 'espressif/esp-protocols'
-    steps:
-      - name: Clear repository
-        run: sudo rm -fr $GITHUB_WORKSPACE && mkdir $GITHUB_WORKSPACE
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v2
-        with:
-          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: components/mdns/tests/test_apps/build
-      - name: Install Python packages
-        env:
-          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
-        run: |
-            sudo apt-get install -y dnsutils
-      - name: Download Test apps to target
-        run: |
-            python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/mdns/tests/test_apps/build/flash_image.bin
-      - name: Run Example Test on target
-        working-directory: components/mdns/tests/test_apps
-        run: |
-            python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml --target=${{matrix.idf_target}}
-      - uses: actions/upload-artifact@v2
-        if: always()
-        with:
-          name: test_apps_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
-          path: components/mdns/tests/test_apps/*.xml

.github/workflows/websocket__build-target-test.yml

@@ -0,0 +1,95 @@
+name: "websocket: build/target-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_websocket:
+    if: contains(github.event.pull_request.labels.*.name, 'websocket') || github.event_name == 'push'
+    name: Build
+    strategy:
+      matrix:
+        idf_ver: ["release-v5.0", "latest"]
+        idf_target: ["esp32"]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/esp_websocket_client/examples
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Build ${{ matrix.example }} with IDF-${{ matrix.idf_ver }} for ${{ matrix.idf_target }}
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          . ${IDF_PATH}/export.sh
+          cat sdkconfig.ci >> sdkconfig.defaults
+          idf.py build
+      - name: Merge binaries
+        working-directory: ${{ env.TEST_DIR }}/build
+        env:
+          IDF_TARGET: ${{ matrix.idf_target }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          esptool.py --chip ${{ matrix.idf_target }} merge_bin --fill-flash-size 4MB -o flash_image.bin @flash_args
+      - uses: actions/upload-artifact@v3
+        with:
+          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
+          path: |
+            ${{ env.TEST_DIR }}/build/bootloader/bootloader.bin
+            ${{ env.TEST_DIR }}/build/partition_table/partition-table.bin
+            ${{ env.TEST_DIR }}/build/*.bin
+            ${{ env.TEST_DIR }}/build/*.elf
+            ${{ env.TEST_DIR }}/build/flasher_args.json
+            ${{ env.TEST_DIR }}/build/config/sdkconfig.h
+            ${{ env.TEST_DIR }}/build/config/sdkconfig.json
+          if-no-files-found: error
+
+  run-target-websocket:
+    # Skip running on forks since it won't have access to secrets
+    if: |
+      github.repository == 'espressif/esp-protocols' &&
+      ( contains(github.event.pull_request.labels.*.name, 'websocket') || github.event_name == 'push' )
+    name: Target test
+    needs: build_websocket
+    strategy:
+      fail-fast: false
+      matrix:
+        idf_ver: ["release-v5.0", "latest"]
+        idf_target: ["esp32"]
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/esp_websocket_client/examples
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: examples_app_bin_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/build/
+      - name: Install Python packages
+        env:
+          PIP_EXTRA_INDEX_URL: "https://www.piwheels.org/simple"
+        run: |
+          pip install --only-binary cryptography --extra-index-url https://dl.espressif.com/pypi/ -r $GITHUB_WORKSPACE/ci/requirements.txt
+      - name: Download Example Test to target
+        run: python -m esptool --chip ${{ matrix.idf_target }} write_flash 0x0 components/esp_websocket_client/examples/build/flash_image.bin
+      - name: Run Example Test on target
+        working-directory: ${{ env.TEST_DIR }}
+        run: |
+          python -m pytest --log-cli-level DEBUG --junit-xml=./examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}.xml --target=${{ matrix.idf_target }}
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: examples_results_${{ matrix.idf_target }}_${{ matrix.idf_ver }}
+          path: ${{ env.TEST_DIR }}/*.xml

.pre-commit-config.yaml

@@ -12,10 +12,11 @@ repos:
       - id: trailing-whitespace
       - id: mixed-line-ending
       - id: debug-statements
-  - repo: https://gitlab.com/pycqa/flake8
+  - repo: https://github.com/pycqa/flake8
     rev: 5.0.4
     hooks:
       - id: flake8
+        args: ['--config=.flake8', '--tee', '--benchmark']
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v0.981
     hooks:
@@ -32,6 +33,7 @@ repos:
     rev: "v0.32.0"
     hooks:
       - id: yapf
+        args: ['style={based_on_style: google, column_limit: 160, indent_width: 4}']
   - repo: https://github.com/pre-commit/mirrors-isort
     rev: v5.10.1
     hooks:
@@ -50,3 +52,17 @@ repos:
     hooks:
     -   id: astyle_py
         args: ['--style=otbs', '--attach-namespaces', '--attach-classes', '--indent=spaces=4', '--convert-tabs', '--align-pointer=name', '--align-reference=name', '--keep-one-line-statements', '--pad-header', '--pad-oper']
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: v2.42.1
+    hooks:
+      - id: commitizen
+      - id: commitizen-branch
+        stages: [push]
+  - repo: local
+    hooks:
+      - id: commit message scopes
+        name: "commit message must be scoped with: mdns, modem, websocket, asio, mqtt_cxx, common"
+        entry: '\A(?!(feat|fix|ci|bump|test|docs)\((mdns|modem|common|websocket|asio|mqtt_cxx)\)\:)'
+        language: pygrep
+        args: [--multiline]
+        stages: [commit-msg]

CONTRIBUTING.md

@@ -6,8 +6,26 @@ Contributions in the form of pull requests, issue reports, and feature requests
 
 - [ ] Fork the [esp-protocols repository on GitHub](https://github.com/espressif/esp-protocols) to start making your changes.
 
-- [ ] Install pre-commit hooks: `pip install pre-commit && pre-commit install`
+- [ ] Install pre-commit hooks: `pip install pre-commit && pre-commit install-hooks && pre-commit install --hook-type commit-msg --hook-type pre-push`
 
 - [ ] Send a pull request (PR) and work with us until it gets merged and published. Contributions may need some modifications, so a few rounds of review and fixing may be necessary.
 
 For quick merging, the contribution should be short, and concentrated on a single feature or topic. The larger the contribution is, the longer it would take to review it and merge it.
+
+Please follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) rule when writing commit messages.
+
+## Release process
+
+When releasing a new component version we have to:
+
+* Update the version number
+* Update the changelog
+* Create the version tag in this repository
+* Deploy the component to component registry
+* Update the documentation
+
+This process is not fully automated, the first three steps need to be performed manually by project maintainers running the `bump` command (from within this repository, rather than forks, to publish the release `tag`). Release procedure is as follows:
+* Create a branch in this repository (not from fork)
+* Run `cz bump [version]` (version number is optional, `cz` would automatically increment it if not present)
+* Check the updated `CHANGELOG.md`
+* Create and merge the branch to master

README.md

@@ -1,26 +1,24 @@
 # Collection of protocol components for ESP-IDF
 
-[Documentation of esp-protocol](https://espressif.github.io/esp-protocols)
-
 ## Components
 
 ### esp_modem
 
 * Brief introduction [README](components/esp_modem/README.md)
-* Full html [documentation](https://espressif.github.io/esp-protocols/esp_modem/index.html)
+* Full html [documentation](https://docs.espressif.com/esp-protocols/esp_modem/index.html)
 
 ### mDNS
 
 * Brief introduction [README](components/mdns/README.md)
-* Full html [documentation(English)](https://espressif.github.io/esp-protocols/mdns/en/index.html)
-* Full html [documentation(Chinese)](https://espressif.github.io/esp-protocols/mdns/zh_CN/index.html)
+* Full html [documentation(English)](https://docs.espressif.com/esp-protocols/mdns/en/index.html)
+* Full html [documentation(Chinese)](https://docs.espressif.com/esp-protocols/mdns/zh_CN/index.html)
 
 ### esp_websocket_client
 
 * Brief introduction [README](components/esp_websocket_client/README.md)
-* Full html [documentation](https://espressif.github.io/esp-protocols/esp_websocket_client/index.html)
+* Full html [documentation](https://docs.espressif.com/esp-protocols/esp_websocket_client/index.html)
 
 ### ASIO port
 
 * Brief introduction [README](components/asio/README.md)
-* Full html [documentation](https://espressif.github.io/esp-protocols/asio/index.html)
+* Full html [documentation](https://docs.espressif.com/esp-protocols/asio/index.html)

ci/build_apps.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Apache-2.0
+"""
+This file is used in CI for esp-protocols build tests
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from idf_build_apps import build_apps, find_apps, setup_logging
+from idf_build_apps.constants import SUPPORTED_TARGETS
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Build all projects',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument('paths', nargs='+', help='Paths to the apps to build.')
+    parser.add_argument(
+        '-t',
+        '--target',
+        default='all',
+        help='Build apps for given target',
+    )
+    args = parser.parse_args()
+
+    IDF_PATH = os.environ['IDF_PATH']
+
+    print(args.paths)
+    setup_logging(2)
+    apps = find_apps(
+        args.paths,
+        recursive=True,
+        target=args.target,
+        build_dir='build_@t_@w',
+        config_rules_str=[
+            'sdkconfig.ci=default', 'sdkconfig.ci.*=', '=default'
+        ],
+        build_log_path='build_log.txt',
+        size_json_path='size.json',
+        check_warnings=True,
+        preserve=True,
+        manifest_files=[
+            str(p) for p in Path('.').glob('**/.build-test-rules.yml')
+        ],
+        default_build_targets=SUPPORTED_TARGETS,
+        manifest_rootpath='.',
+    )
+
+    for app in apps:
+        print(app)
+
+    sys.exit(
+        build_apps(apps,
+                   dry_run=False,
+                   keep_going=False,
+                   ignore_warning_strs=os.environ['EXPECTED_WARNING']
+                   if 'EXPECTED_WARNING' in os.environ else None))

ci/changelog.py

@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Apache-2.0
+import argparse
+import os
+import re
+
+import sh
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generates a change log from cz commits')
+    parser.add_argument('component')
+    args = parser.parse_args()
+
+    old_ref = os.environ.get('CZ_PRE_CURRENT_TAG_VERSION')
+    new_tag = os.environ.get('CZ_PRE_NEW_TAG_VERSION')
+    new_ref = os.environ.get('CZ_PRE_NEW_VERSION')
+    component = args.component
+
+    root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+
+    git = sh.git.bake(_cwd=root_path)
+
+    keys = ['breaking', 'major', 'feat', 'fix', 'update']
+    items = {key: [] for key in keys}
+    sections = {
+        'feat': 'Features',
+        'fix': 'Bug Fixes',
+        'update': 'Updated',
+        'breaking': 'Breaking changes',
+        'major': 'Major changes'
+    }
+    brief_log = git.log('--oneline', '{}..HEAD'.format(old_ref), '--', 'components/' + component, _tty_out=False)
+    for oneline in brief_log.splitlines():
+        [commit, brief_msg] = oneline.split(' ', 1)
+        if 'Merge' in str(brief_msg) or brief_msg.startswith('bump('):  # skip Merge commits and bumps
+            continue
+        find_title = re.findall(r'^(fix|feat|esp_modem|esp-modem|mdns)(\([^\)]+\))?:\s*(.+)$', str(brief_msg))
+        item_type = ''             # default prefix
+        item_message = brief_msg   # default body
+        if find_title is not None and len(find_title) > 0:  # Use scopes & types
+            item_type = find_title[0][0]      # prefix (fix/feat/ci)
+            item_message = find_title[0][-1]  # title body
+
+        # Add details in parentheses (commit-id and references from the FOOTER section)
+        details = '[{}](https://github.com/espressif/esp-protocols/commit/{})'.format(commit, commit)
+        msg_details = git.show('-s', commit, _tty_out=False)
+        # check references
+        if any(s in str(msg_details) for s in ['esp-protocols/issues', 'BREAKING CHANGE', 'MAJOR CHANGE']):
+            # Closes <issue>
+            closes = re.findall(r'Closes ([^\d]+/(\d+))', str(msg_details), re.MULTILINE)
+            if closes and closes[0] is not None:
+                details += ', [#{}]({})'.format(closes[0][1], closes[0][0])
+            # Breaking changes
+            find_breaking = re.findall(r'BREAKING CHANGE:\s*([^\n]*)', str(msg_details), re.MULTILINE)
+            if find_breaking is not None and len(find_breaking) > 0:
+                if find_breaking[0] != '':
+                    items['breaking'].append('{} ([{}](https://github.com/espressif/esp-protocols/commit/{}))'.format(find_breaking[0], item_message, commit))
+                else:
+                    items['breaking'].append('{} ({})'.format(item_message, details))
+                details += ', !BREAKING'
+            # Major changes
+            find_major = re.findall(r'MAJOR CHANGE:\s*([^\n]*)',
+                                    str(msg_details), re.MULTILINE)
+            if find_major is not None and len(
+                    find_major) > 0 and find_major[0] != '':
+                items['major'].append('{} ([{}](https://github.com/espressif/esp-protocols/commit/{}))'.format(find_major[0], item_message, commit))
+        if item_type in ['fix', 'feat']:
+            items[item_type].append('{} ({})'.format(item_message, details))
+        else:
+            items['update'].append('{} ({})'.format(item_message, details))
+    # Generate changelog
+    changelog = '## [{}](https://github.com/espressif/esp-protocols/commits/{})\n'.format(
+        new_ref, new_tag)
+    for section, item in items.items():
+        if len(item) > 0:
+            changelog += '\n### {}\n\n'.format(sections[section])
+            for it in item:
+                changelog += '- {}\n'.format(it)
+    changelog += '\n'
+    filename = os.path.join(root_path, 'components', component, 'CHANGELOG.md')
+    # insert the actual changelog to the beginning of the file, just after the title (2nd line)
+    with open(filename, 'r') as orig_changelog:
+        changelog_title = orig_changelog.readline(
+        )  # expect # Changelog title on the first line
+        changelog_nl = orig_changelog.readline()
+        orig_items = orig_changelog.read()
+    with open(filename, 'w') as updated_changelog:
+        updated_changelog.write(changelog_title)
+        updated_changelog.write(changelog_nl)
+        updated_changelog.write(changelog)
+        updated_changelog.write(orig_items)
+    git.add(filename)
+
+
+if __name__ == '__main__':
+    main()

ci/check_copyright_config.yaml

@@ -57,7 +57,7 @@ slim_modem_examples:
 ignore:
   perform_check: no
   include:
-   - 'components/**/docs/**'
+   - '**/docs/**'
    - 'components/esp_modem/port/linux/**'
    - 'components/asio/examples/**'
    - 'components/mdns/**/esp_system_protocols_linux/**'

ci/clean_build_artifacts.sh

@@ -0,0 +1,7 @@
+# Remove everything, but
+# - elf/bin files in the build dir
+# - partition-table and bootloader binaries
+# - flasher args
+# - sdkconfigs (header and json)
+# (Ignoring the command failure as it refuses to delete nonempty dirs)
+find $1 ! -regex ".*/build[^/]*/[^/]+.\(bin\|elf\)" -a ! -regex ".*\(bootloader\|partition-table\).bin" -a ! -name "flasher_args.json" -a ! -regex ".*/build[^/]*/config/sdkconfig.\(h\|json\)" -delete || true

ci/requirements.txt

@@ -5,3 +5,4 @@ SimpleWebSocketServer
 dpkt
 pytest
 idf_build_apps
+netifaces

components/asio/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+## [1.14.1~3](https://github.com/espressif/esp-protocols/commits/f148c98)
+
+### Updated
+
+- ASIO: Updated package version to "1.14.1~3" ([f148c98](https://github.com/espressif/esp-protocols/commit/f148c98))
+- ASIO: Example tests integration ([5193ebc](https://github.com/espressif/esp-protocols/commit/5193ebc))
+
+
+## [1.0.2](https://github.com/espressif/esp-protocols/commits/57afa38)
+
+### Updated
+
+- Bump asio/mdns/esp_websocket_client versions ([57afa38](https://github.com/espressif/esp-protocols/commit/57afa38))
+- ignore format warnings ([d66f9dc](https://github.com/espressif/esp-protocols/commit/d66f9dc))
+- asio: Fix exampels build ([3662c14](https://github.com/espressif/esp-protocols/commit/3662c14))
+
+
+## [1.0.1](https://github.com/espressif/esp-protocols/commits/055f051)
+
+### Updated
+
+- ASIO: Initial version based on IDF 5.0 with history ([055f051](https://github.com/espressif/esp-protocols/commit/055f051))
+- asio: Disable concepts support       Fix example for compatibility with C++20 ([ac7bf46](https://github.com/espressif/esp-protocols/commit/ac7bf46), [IDF@9dba047](https://github.com/espressif/esp-idf/commit/9dba0476a01cd80d76e21706ad350009606b877e))
+- lwip: Update socket API to include port-version of sockets/netdb ([057a5d2](https://github.com/espressif/esp-protocols/commit/057a5d2), [IDF@53c009e](https://github.com/espressif/esp-idf/commit/53c009e62631bae569fa849c6b6c9e70a10b3afe))
+- esp_netif/lwip: Implement basic support for vanilla-lwip (2.1.3-REL) ([63bff63](https://github.com/espressif/esp-protocols/commit/63bff63), [IDF@5b471a1](https://github.com/espressif/esp-idf/commit/5b471a18489b056f65fe8dcbb2c992d27909ebc9))
+- mbedtls: Remove certs.c and certs.h from port directory ([e3c4391](https://github.com/espressif/esp-protocols/commit/e3c4391), [IDF@f31d8dd](https://github.com/espressif/esp-idf/commit/f31d8dd2955be0fe949340dcf3b043ec6daf4378))
+- mbedtls-3 update: 1) Fix build issue in mbedtls 2) skip the public headers check in IDF 3)Update Kconfig Macros 4)Remove deprecated config options 5) Update the sha API according to new nomenclature 6) Update mbedtls_rsa_init usage 7) Include mbedtls/build_info.h instead of mbedtls/config.h 8) Dont include check_config.h 9) Add additional error message in esp_blufi_api.h ([9813818](https://github.com/espressif/esp-protocols/commit/9813818), [IDF@4512253](https://github.com/espressif/esp-idf/commit/45122533e0bca5d538585e22308f14b74c33e474))
+- asio: Use internal ssl context and engine impl ([f605fdd](https://github.com/espressif/esp-protocols/commit/f605fdd), [IDF@d823106](https://github.com/espressif/esp-idf/commit/d823106aa6b24b8bdcc30373513c8688c61438c4))
+- Build & config: Remove leftover files from the unsupported "make" build system ([abbc8d9](https://github.com/espressif/esp-protocols/commit/abbc8d9), [IDF@766aa57](https://github.com/espressif/esp-idf/commit/766aa5708443099f3f033b739cda0e1de101cca6))
+- openssl: Add deprecation warning to ssl.h ([a029774](https://github.com/espressif/esp-protocols/commit/a029774), [IDF@cfc0018](https://github.com/espressif/esp-idf/commit/cfc001870c5e0afed7b42b6bf8c326eae053fe96))
+- asio coap: If LWIP IPV6 is disabled, automatically don't build asio & coap ([cc0f2b3](https://github.com/espressif/esp-protocols/commit/cc0f2b3), [IDF@e305f29](https://github.com/espressif/esp-idf/commit/e305f2938278c2a39e75c21a3ed59d8f4d4e62fa))
+- asio: update copyright notice ([47d57a5](https://github.com/espressif/esp-protocols/commit/47d57a5), [IDF@2d0895e](https://github.com/espressif/esp-idf/commit/2d0895e9a98bc7846d0ac7321f2b86b47346bf21))
+- Whitespace: Automated whitespace fixes (large commit) ([622a360](https://github.com/espressif/esp-protocols/commit/622a360), [IDF@66fb5a2](https://github.com/espressif/esp-idf/commit/66fb5a29bbdc2482d67c52e6f66b303378c9b789))
+- cmake: Apply cmakelint fixes ([4358c3c](https://github.com/espressif/esp-protocols/commit/4358c3c), [IDF@e82eac4](https://github.com/espressif/esp-idf/commit/e82eac4354b8b4111697656f3acce7450eeff366))
+- asio: option to use wolfSSL as TLS stack for ASIO ([c05558b](https://github.com/espressif/esp-protocols/commit/c05558b), [IDF@1c8171c](https://github.com/espressif/esp-idf/commit/1c8171c3e8d5a67e47dc8d6abac27ad2989470c3))
+- asio: Basic SSL/TLS support in asio port for ESP platform ([dab1230](https://github.com/espressif/esp-protocols/commit/dab1230), [IDF@9459c0d](https://github.com/espressif/esp-idf/commit/9459c0dd432fdd0fccb49ea65bb5c72d1849e1ba))
+- asio: updated ASIO port to use latest asio and esp-idf features ([9190917](https://github.com/espressif/esp-protocols/commit/9190917), [IDF@13d603e](https://github.com/espressif/esp-idf/commit/13d603e486624380d49f2e89614b10425c208d14))
+- components: use new component registration api ([9e83b1e](https://github.com/espressif/esp-protocols/commit/9e83b1e), [IDF@9eccd7c](https://github.com/espressif/esp-idf/commit/9eccd7c0826d6cc2e9de59304d1e5f76c0063ccf))
+- Rename Kconfig options (root) ([3b49d1f](https://github.com/espressif/esp-protocols/commit/3b49d1f), [IDF@c5000c8](https://github.com/espressif/esp-idf/commit/c5000c83d250896fffbddd7a3991384ea0fc286d))
+- cmake: make main a component again ([57672d5](https://github.com/espressif/esp-protocols/commit/57672d5), [IDF@d9939ce](https://github.com/espressif/esp-idf/commit/d9939cedd9b44d63dc148354c3a0a139b9c7113d))
+- asio: initial idf port of asio library without ssl ([5472d5c](https://github.com/espressif/esp-protocols/commit/5472d5c), [IDF@1ef13c5](https://github.com/espressif/esp-idf/commit/1ef13c524c484e9fb62e6c0b11482c30c5383728))

components/asio/LICENSE

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

components/asio/README.md

@@ -1,5 +1,7 @@
 # ASIO port
 
+[![Component Registry](https://components.espressif.com/components/espressif/asio/badge.svg)](https://components.espressif.com/components/espressif/asio)
+
 Asio is a cross-platform C++ library, see https://think-async.com/Asio/. It provides a consistent asynchronous model using a modern C++ approach.
 
 ## Examples

components/asio/examples/asio_chat/sdkconfig.defaults

@@ -1,2 +1,8 @@
 CONFIG_ESP_MAIN_TASK_STACK_SIZE=8192
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
+
+#
+# Partition Table
+#
+# Leave some room for larger apps without needing to reduce other features
+CONFIG_PARTITION_TABLE_SINGLE_APP_LARGE=y

components/asio/idf_component.yml

@@ -1,5 +1,6 @@
 version: "1.14.1~3"
 description: ASIO
+url: https://github.com/espressif/esp-protocols/tree/master/components/asio
 dependencies:
   idf:
     version: ">=5.0"

components/esp_modem/.cz.yaml

@@ -0,0 +1,8 @@
+---
+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.0.0
+  version_files:
+  - idf_component.yml

components/esp_modem/CHANGELOG.md

@@ -0,0 +1,337 @@
+# Changelog
+
+## [1.0.0](https://github.com/espressif/esp-protocols/commits/modem-v1.0.0)
+
+### Major changes
+
+- Enable DTE to redefine on_read() and write(cmd) directly ([DTE to support sending and receiving raw data](https://github.com/espressif/esp-protocols/commit/bf114d3))
+
+### Features
+
+- Add mqtt example in AT-only mode ([7547267](https://github.com/espressif/esp-protocols/commit/7547267))
+- DTE to support sending and receiving raw data ([bf114d3](https://github.com/espressif/esp-protocols/commit/bf114d3))
+
+### Bug Fixes
+
+- Changelog to correctly pick references ([c59e330](https://github.com/espressif/esp-protocols/commit/c59e330))
+- AT-only example: support MQTT over TLS on BG96 ([31d4323](https://github.com/espressif/esp-protocols/commit/31d4323))
+- AT-only example: initial adaptation to BG96 ([ceedcfc](https://github.com/espressif/esp-protocols/commit/ceedcfc))
+- warning in ap-2-pppos example when using lwip/napt ([bf32e45](https://github.com/espressif/esp-protocols/commit/bf32e45))
+- trigger PR jobs based on labels ([13eca12](https://github.com/espressif/esp-protocols/commit/13eca12))
+- Reintroduce missing CHANGELOGs ([200cbb3](https://github.com/espressif/esp-protocols/commit/200cbb3), [#235](https://github.com/espressif/esp-protocols/issues/235))
+- Use default UART CLK source ([d0814bf](https://github.com/espressif/esp-protocols/commit/d0814bf), [#241](https://github.com/espressif/esp-protocols/issues/241))
+- run CI build job for all targets ([a089e0d](https://github.com/espressif/esp-protocols/commit/a089e0d))
+
+### Updated
+
+- Update examples for USB v1.1 ([610372f](https://github.com/espressif/esp-protocols/commit/610372f))
+
+
+## [0.1.28](https://github.com/espressif/esp-protocols/commits/01c26c8)
+
+### Updated
+
+- Dual DTE support ([01c26c8](https://github.com/espressif/esp-protocols/commit/01c26c8))
+
+
+## [0.1.27](https://github.com/espressif/esp-protocols/commits/44bae24)
+
+### Updated
+
+- Return true from on_data callback in data mode ([44bae24](https://github.com/espressif/esp-protocols/commit/44bae24))
+
+
+## [0.1.26](https://github.com/espressif/esp-protocols/commits/05fff94)
+
+### Features
+
+- Added target test ([4314c78](https://github.com/espressif/esp-protocols/commit/4314c78))
+- Add support for manual CMUX operations ([ac5d438](https://github.com/espressif/esp-protocols/commit/ac5d438), [#168](https://github.com/espressif/esp-protocols/issues/168))
+
+### Bug Fixes
+
+- Example to use variable mqtt topic/data ([8958d5e](https://github.com/espressif/esp-protocols/commit/8958d5e))
+- Fix cmux client compilation issue ([f71192b](https://github.com/espressif/esp-protocols/commit/f71192b))
+- Exit data mode only after state change ([9a7bd90](https://github.com/espressif/esp-protocols/commit/9a7bd90))
+- Support AT with callback in C-API ([2180ab1](https://github.com/espressif/esp-protocols/commit/2180ab1), [#143](https://github.com/espressif/esp-protocols/issues/143))
+
+### Updated
+
+- update(esp_modem): Bump component version to 0.1.26 ([05fff94](https://github.com/espressif/esp-protocols/commit/05fff94), [#213](https://github.com/espressif/esp-protocols/issues/213))
+- Added the missing definition for the esp_modem_set_baud function (IDFGH-9181) (#209) ([0e215b1](https://github.com/espressif/esp-protocols/commit/0e215b1))
+- CI: Added coverage analyzer for esp_modem host tests ([6b684ce](https://github.com/espressif/esp-protocols/commit/6b684ce))
+- Update esp_modem_command_library.cpp ([5304a6e](https://github.com/espressif/esp-protocols/commit/5304a6e))
+- Added badges with version of components to the respective README files ([e4c8a59](https://github.com/espressif/esp-protocols/commit/e4c8a59))
+- esp_modem/examples: Add an example to synchronise PSM sleep in Sim70XX modem and esp32. ([1ca1391](https://github.com/espressif/esp-protocols/commit/1ca1391))
+
+
+## [0.1.25](https://github.com/espressif/esp-protocols/commits/f1ae14f)
+
+### Bug Fixes
+
+- Cleanup custom lib-commands and factory ([65c0e0e](https://github.com/espressif/esp-protocols/commit/65c0e0e))
+- Examples to configure MQTT Broker ([71a2388](https://github.com/espressif/esp-protocols/commit/71a2388))
+- Extend pppos example project config ([ebc36a3](https://github.com/espressif/esp-protocols/commit/ebc36a3))
+- Uart Terminal read_cb race ([a02bf05](https://github.com/espressif/esp-protocols/commit/a02bf05))
+
+### Updated
+
+- update(esp_modem): Bump component version ([f1ae14f](https://github.com/espressif/esp-protocols/commit/f1ae14f))
+- fix(esp_modem) Add example that reads GNSS info ([652314e](https://github.com/espressif/esp-protocols/commit/652314e))
+- CI: fixing the files to be complient with pre-commit hooks ([945bd17](https://github.com/espressif/esp-protocols/commit/945bd17))
+- Quick fix esp_modem: Added modem_console commands for deep-sleep and modem PSM. ([cf504ec](https://github.com/espressif/esp-protocols/commit/cf504ec))
+- fix(esp-modem) Make simple_cmux_client example configurable ([511ed54](https://github.com/espressif/esp-protocols/commit/511ed54))
+- Added modem_console commands for deep-sleep and modem PSM. ([85a2e25](https://github.com/espressif/esp-protocols/commit/85a2e25))
+- ci: Compile esp_modem examples with USB support ([988b3f9](https://github.com/espressif/esp-protocols/commit/988b3f9))
+- Expand PPPoS example with USB DTE ([53b5933](https://github.com/espressif/esp-protocols/commit/53b5933))
+- Allow USB DTE reconnection ([bf84ae9](https://github.com/espressif/esp-protocols/commit/bf84ae9))
+- Add ConsoleCommand destructor ([a89a0ab](https://github.com/espressif/esp-protocols/commit/a89a0ab))
+- esp_modem_get_gnss_power_mode (#136) ([fe536e4](https://github.com/espressif/esp-protocols/commit/fe536e4))
+- remove unused Config Parameters ! ([55b4775](https://github.com/espressif/esp-protocols/commit/55b4775))
+
+
+## [0.1.24](https://github.com/espressif/esp-protocols/commits/9b48b0a)
+
+### Features
+
+- Make some CMUX params compile-time configurable ([25ac2d9](https://github.com/espressif/esp-protocols/commit/25ac2d9))
+
+### Bug Fixes
+
+- CMUX to ignore MSC frames ([ce175df](https://github.com/espressif/esp-protocols/commit/ce175df), [#140](https://github.com/espressif/esp-protocols/issues/140))
+- Fix CRLF endlines in examples ([07a347f](https://github.com/espressif/esp-protocols/commit/07a347f))
+- Console example to use configurable flow-ctrl ([d9c9681](https://github.com/espressif/esp-protocols/commit/d9c9681))
+
+### Updated
+
+- update(esp_modem): Bump component version ([9b48b0a](https://github.com/espressif/esp-protocols/commit/9b48b0a))
+- Allow error handler register in C ([62cb235](https://github.com/espressif/esp-protocols/commit/62cb235))
+
+
+## [0.1.23](https://github.com/espressif/esp-protocols/commits/04c711f)
+
+### Features
+
+- Add exit PPP in example ([290197c](https://github.com/espressif/esp-protocols/commit/290197c))
+
+### Updated
+
+- Move common C definitions in to separate header ([04c711f](https://github.com/espressif/esp-protocols/commit/04c711f))
+- Minor formatting fix and spelling ([accf924](https://github.com/espressif/esp-protocols/commit/accf924))
+- extended the modem_console example.  (#120) ([ef0e48a](https://github.com/espressif/esp-protocols/commit/ef0e48a))
+
+
+## [0.1.22](https://github.com/espressif/esp-protocols/commits/187ef76)
+
+### Bug Fixes
+
+- DTE command race of timeout vs reply's signal ([a871473](https://github.com/espressif/esp-protocols/commit/a871473), [#110](https://github.com/espressif/esp-protocols/issues/110))
+- Correct timeouts for certain commands ([1029078](https://github.com/espressif/esp-protocols/commit/1029078), [#129](https://github.com/espressif/esp-protocols/issues/129))
+- Make get_operator_name() return also ACT value ([0015e54](https://github.com/espressif/esp-protocols/commit/0015e54), [#128](https://github.com/espressif/esp-protocols/issues/128))
+
+### Updated
+
+- update(esp_modem): Bump component version ([187ef76](https://github.com/espressif/esp-protocols/commit/187ef76))
+
+
+## [0.1.21](https://github.com/espressif/esp-protocols/commits/d07237b)
+
+### Updated
+
+- Fix IDF version resolution ([d07237b](https://github.com/espressif/esp-protocols/commit/d07237b))
+- Fix format warnings ([98bf3ef](https://github.com/espressif/esp-protocols/commit/98bf3ef), [#79](https://github.com/espressif/esp-protocols/issues/79))
+
+
+## [0.1.20](https://github.com/espressif/esp-protocols/commits/ae8479c)
+
+### Bug Fixes
+
+- Correct exit of CMUX mode ([2099434](https://github.com/espressif/esp-protocols/commit/2099434), [#103](https://github.com/espressif/esp-protocols/issues/103))
+- Add filename/line info to exception message ([89e1bd2](https://github.com/espressif/esp-protocols/commit/89e1bd2))
+
+### Updated
+
+- Expose set_error_cb method ([ae8479c](https://github.com/espressif/esp-protocols/commit/ae8479c))
+
+
+## [0.1.19](https://github.com/espressif/esp-protocols/commits/469f953)
+
+### Features
+
+- Add optional ACT to operator-name ([a286634](https://github.com/espressif/esp-protocols/commit/a286634), [#80](https://github.com/espressif/esp-protocols/issues/80))
+
+### Bug Fixes
+
+- Add missing set_pdp_context() to C-API ([4980ac8](https://github.com/espressif/esp-protocols/commit/4980ac8))
+
+### Updated
+
+- updated package version to 0.1.19 ([469f953](https://github.com/espressif/esp-protocols/commit/469f953))
+- CI: Fix build issues ([6e4e4fa](https://github.com/espressif/esp-protocols/commit/6e4e4fa))
+- esp_err_to_name (IDFGH-7793) (#78) ([d1129f3](https://github.com/espressif/esp-protocols/commit/d1129f3))
+
+
+## [0.1.18](https://github.com/espressif/esp-protocols/commits/e8145fc)
+
+### Features
+
+- Add CMUX mode to C-API ([3fd4391](https://github.com/espressif/esp-protocols/commit/3fd4391), [#41](https://github.com/espressif/esp-protocols/issues/41))
+- Add support to CMUX exit ([a16aab6](https://github.com/espressif/esp-protocols/commit/a16aab6), [#37](https://github.com/espressif/esp-protocols/issues/37))
+
+### Bug Fixes
+
+- Update ap2ppp example to recover network on disconnection ([a243d7e](https://github.com/espressif/esp-protocols/commit/a243d7e), [#44](https://github.com/espressif/esp-protocols/issues/44))
+- Implement movable unique_buffer to bundle data, size, ptr ([66e6d4c](https://github.com/espressif/esp-protocols/commit/66e6d4c))
+- DTE should own both command and data terminal ([f3ff98b](https://github.com/espressif/esp-protocols/commit/f3ff98b))
+- Update CMUX example to use CMUX mode automatically ([58a0b57](https://github.com/espressif/esp-protocols/commit/58a0b57))
+- Improve PPP exit sequence ([1e0aefd](https://github.com/espressif/esp-protocols/commit/1e0aefd), [#47](https://github.com/espressif/esp-protocols/issues/47))
+
+### Updated
+
+- Ignore format warnings ([e8145fc](https://github.com/espressif/esp-protocols/commit/e8145fc))
+- Allow to customize uart source_clk ([d723fb7](https://github.com/espressif/esp-protocols/commit/d723fb7))
+- Add "at" api for custom commands ([0cf08fb](https://github.com/espressif/esp-protocols/commit/0cf08fb))
+
+
+## [0.1.17](https://github.com/espressif/esp-protocols/commits/5addf9e)
+
+### Features
+
+- Bumped version number to 0.1.17 ([5addf9e](https://github.com/espressif/esp-protocols/commit/5addf9e))
+
+### Bug Fixes
+
+- Support 2 byte size packets ([128c0a2](https://github.com/espressif/esp-protocols/commit/128c0a2), [#46](https://github.com/espressif/esp-protocols/issues/46))
+- Correction of switching to CMUX ([503218b](https://github.com/espressif/esp-protocols/commit/503218b), [#33](https://github.com/espressif/esp-protocols/issues/33))
+
+### Updated
+
+- Fix param description for get_operator_name() ([a661e51](https://github.com/espressif/esp-protocols/commit/a661e51))
+- Update: Removed stringstream to decrease static sizes ([3ced2d9](https://github.com/espressif/esp-protocols/commit/3ced2d9))
+- Update: Renamed list_in to be type-specific Update: Removed modem-specific comment ([ba88d7f](https://github.com/espressif/esp-protocols/commit/ba88d7f))
+- Update: Changed tests to coincide with new initial esp_modem mode ([4f3c429](https://github.com/espressif/esp-protocols/commit/4f3c429))
+- typo ([52de8f1](https://github.com/espressif/esp-protocols/commit/52de8f1))
+- Update: Removed duplicate power down function Add: gnss power mode function ([e98cf16](https://github.com/espressif/esp-protocols/commit/e98cf16))
+- Update: Formatting ([be3d2ec](https://github.com/espressif/esp-protocols/commit/be3d2ec))
+- Add: Sim7600 extended support ([15ed885](https://github.com/espressif/esp-protocols/commit/15ed885))
+- Add: Support for SIM7000 modules ([0733ea8](https://github.com/espressif/esp-protocols/commit/0733ea8))
+- Update: modem_mode::UNDEF initially ([15cbc9b](https://github.com/espressif/esp-protocols/commit/15cbc9b))
+- Add: sim7070 support ([bb7f198](https://github.com/espressif/esp-protocols/commit/bb7f198))
+- Add: Expanded modem_command_library with more "standard" commands ([d3f7ea6](https://github.com/espressif/esp-protocols/commit/d3f7ea6))
+- Fix DCE selection in ‘pppos_client’ example ([d191a72](https://github.com/espressif/esp-protocols/commit/d191a72))
+- Fix AT command in ‘set_data_mode_sim8xx()’ for SIM800 modem device ([cc0d527](https://github.com/espressif/esp-protocols/commit/cc0d527))
+
+
+## [0.1.16](https://github.com/espressif/esp-protocols/commits/74040cf)
+
+### Updated
+
+- Extend modem_console example with USB DTE ([74040cf](https://github.com/espressif/esp-protocols/commit/74040cf))
+
+
+## [0.1.15](https://github.com/espressif/esp-protocols/commits/1f5eb39)
+
+### Updated
+
+- Fix IDFv5.0 include paths ([1f5eb39](https://github.com/espressif/esp-protocols/commit/1f5eb39))
+
+
+## [0.1.14](https://github.com/espressif/esp-protocols/commits/745201b)
+
+### Bug Fixes
+
+- missing default statement in a switch in the modem_console example ([325a193](https://github.com/espressif/esp-protocols/commit/325a193))
+- add virtual destructors to ModuleIf and CommandableIf ([face03e](https://github.com/espressif/esp-protocols/commit/face03e))
+
+### Updated
+
+- build: fix issue with passing cxx_std option, a common workaround ([745201b](https://github.com/espressif/esp-protocols/commit/745201b))
+- add(esp_modem): Add unit test to check polymorphic delete ([e54b240](https://github.com/espressif/esp-protocols/commit/e54b240))
+- Implement esp_modem_sync for the C API ([8b3d420](https://github.com/espressif/esp-protocols/commit/8b3d420))
+
+
+## [0.1.13](https://github.com/espressif/esp-protocols/commits/2cb74cf)
+
+### Bug Fixes
+
+- Update the test to exersise CBC parser ([d879e82](https://github.com/espressif/esp-protocols/commit/d879e82))
+- Fix battery status parse ([4f1d31f](https://github.com/espressif/esp-protocols/commit/4f1d31f))
+- Read module name with AT commands ([8417e23](https://github.com/espressif/esp-protocols/commit/8417e23))
+- linux port to work with lwip-2.1.2 ([8465b14](https://github.com/espressif/esp-protocols/commit/8465b14))
+
+### Updated
+
+- Update(esp_modem): Bump component version ([2cb74cf](https://github.com/espressif/esp-protocols/commit/2cb74cf))
+
+
+## [0.1.12](https://github.com/espressif/esp-protocols/commits/5d9ad9c)
+
+### Updated
+
+- Update FreeRTOS EventQueueHandle_t forward declaration ([5d9ad9c](https://github.com/espressif/esp-protocols/commit/5d9ad9c))
+
+
+## [0.1.11](https://github.com/espressif/esp-protocols/commits/9649876)
+
+### Updated
+
+- New version to publish to component registry ([9649876](https://github.com/espressif/esp-protocols/commit/9649876))
+- Docs: Add links to GitHub pages ([cf990d1](https://github.com/espressif/esp-protocols/commit/cf990d1))
+- Add missing AT commands to plain C-API ([5299b42](https://github.com/espressif/esp-protocols/commit/5299b42))
+- CI/Docs: Generate docs locally before uploading to registry ([2c21aa1](https://github.com/espressif/esp-protocols/commit/2c21aa1))
+- CI/Docs: Add jobs to deploy component docs ([b9ff1e4](https://github.com/espressif/esp-protocols/commit/b9ff1e4))
+- Update Task handle and Event Group handle to match freertos v10.4.3 ([5888717](https://github.com/espressif/esp-protocols/commit/5888717))
+- Examples: Fix print format for http_client() API ([01e2a9c](https://github.com/espressif/esp-protocols/commit/01e2a9c))
+- Examples: Fix build error when SIM needs no PIN ([c8c24ed](https://github.com/espressif/esp-protocols/commit/c8c24ed))
+- Examples: Use bigger 4M flash for OTA example ([b380ded](https://github.com/espressif/esp-protocols/commit/b380ded))
+
+
+## [0.1.9](https://github.com/espressif/esp-protocols/commits/2a2d270)
+
+### Updated
+
+- Fix CMake3.5 build with no cxx_std_17 feature ([2a2d270](https://github.com/espressif/esp-protocols/commit/2a2d270))
+
+
+## [0.1.8](https://github.com/espressif/esp-protocols/commits/9dd1bd5)
+
+### Updated
+
+- 0.1.8: Update comonent version ([9dd1bd5](https://github.com/espressif/esp-protocols/commit/9dd1bd5))
+- Add pre upload script to deploy the docs before component upload ([918db0d](https://github.com/espressif/esp-protocols/commit/918db0d))
+- Minor correction of the docs ([c1b1330](https://github.com/espressif/esp-protocols/commit/c1b1330))
+- Examples/console: Remove unnecessary event-base check on IP handler ([fb7295e](https://github.com/espressif/esp-protocols/commit/fb7295e))
+- Examples: Extend CMux client default stack size for the main task ([8236b3d](https://github.com/espressif/esp-protocols/commit/8236b3d))
+- CMUX: Refactor the protocol decoder to multiple methods per cmux state ([fb6029b](https://github.com/espressif/esp-protocols/commit/fb6029b))
+- Factory: Rename Builder class to Creator, since it's not 100% builder pattern ([6e34954](https://github.com/espressif/esp-protocols/commit/6e34954))
+- Formal  updates per code review ([148a930](https://github.com/espressif/esp-protocols/commit/148a930))
+- Docs: Update CMux collaboration diagram to resemble composite ([1fb9150](https://github.com/espressif/esp-protocols/commit/1fb9150))
+- Applied astyle code formatting ([a61e9e2](https://github.com/espressif/esp-protocols/commit/a61e9e2))
+- Minor corrections per code review ([dc64f86](https://github.com/espressif/esp-protocols/commit/dc64f86))
+- Bulk replace header guards to use ([3332c27](https://github.com/espressif/esp-protocols/commit/3332c27))
+- Host test fix: renamed Loopback inherited member ([84b0dcf](https://github.com/espressif/esp-protocols/commit/84b0dcf))
+- Update documentation and minor fixes ([e0e6585](https://github.com/espressif/esp-protocols/commit/e0e6585))
+
+
+## [0.1.7](https://github.com/espressif/esp-protocols/commits/28433de)
+
+### Updated
+
+- Update version to 0.1.7 -- support socket VFS ([28433de](https://github.com/espressif/esp-protocols/commit/28433de))
+- Reworked decouple resources from the file system ([8f17a90](https://github.com/espressif/esp-protocols/commit/8f17a90))
+- Make the component compatible with IDFv4.1, v4.2, v4.3 ([69ad3ea](https://github.com/espressif/esp-protocols/commit/69ad3ea))
+
+
+## [0.1.6](https://github.com/espressif/esp-protocols/commits/a67d749)
+
+### Updated
+
+- Bump the version and upload the component ([a67d749](https://github.com/espressif/esp-protocols/commit/a67d749))
+- Updated per review comments ([ab93c13](https://github.com/espressif/esp-protocols/commit/ab93c13))
+
+
+## [0.1.5](https://github.com/espressif/esp-protocols/commits/90641c8)
+
+### Updated
+
+- Moved to component folder ([90641c8](https://github.com/espressif/esp-protocols/commit/90641c8))

components/esp_modem/CMakeLists.txt

@@ -47,3 +47,15 @@ if(${target} STREQUAL "linux")
     # This is needed for ESP_LOGx() macros, as integer formats differ on ESP32(..) and x64
     set_target_properties(${COMPONENT_LIB} PROPERTIES COMPILE_FLAGS -Wno-format)
 endif()
+
+if(CONFIG_GCOV_ENABLED)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+
+
+    MARK_AS_ADVANCED(
+        CMAKE_CXX_FLAGS_COVERAGE
+        CMAKE_C_FLAGS_COVERAGE
+        CMAKE_EXE_LINKER_FLAGS_COVERAGE
+        CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+endif()

components/esp_modem/README.md

@@ -1,5 +1,7 @@
 # ESP MODEM
 
+[![Component Registry](https://components.espressif.com/components/espressif/esp_modem/badge.svg)](https://components.espressif.com/components/espressif/esp_modem)
+
 The `esp-modem` component is a managed component for `esp-idf` that is used for communication with GSM/LTE modems
 that support AT commands and PPP protocol as a network interface.
 

components/esp_modem/docs/generate_docs

@@ -1,23 +0,0 @@
-# Cleanup the generated html
-rm -rf html
-
-# Cleans example and test build dirs (to reduce the component size before upload)
-rm -rf ../examples/ap_to_pppos/build/ ../examples/simple_cmux_client/build/ ../examples/pppos_client/build/ ../examples/linux_modem/build/ ../examples/modem_console/build ../test/host_test/build/ ../test/target/build/
-
-# Generate C++ API header of the DCE
-cat ../include/generate/esp_modem_command_declare.inc | clang++ -E -P -CC  -xc++ -I../include -DGENERATE_DOCS  - | sed -n '1,/DCE command documentation/!p' > esp_modem_dce.hpp
-
-# Generate C API header of the modem_api.h
-cat ../include/generate/esp_modem_command_declare.inc | clang -E -P -CC  -xc -I../include -DGENERATE_DOCS  - | sed -n '1,/DCE command documentation/!p' > esp_modem_api_commands.h
-
-# RST with links to C++ API
-cat ../include/generate/esp_modem_command_declare.inc | clang -E -P  -xc -I../include -DGENERATE_DOCS -DGENERATE_RST_LINKS - | sed 's/NL/\n/g' > cxx_api_links.rst
-
-# Run doxygen
-doxygen
-
-# Generate the docs
-python -u -m sphinx.cmd.build -b html  . html
-
-# Cleanup the doxygen xml's and temporary headers
-rm -rf xml esp_modem_api_commands.h esp_modem_dce.hpp cxx_api_links.rst

components/esp_modem/examples/.build-test-rules.yml

@@ -0,0 +1,7 @@
+components/esp_modem/examples/ap_to_pppos:
+  disable:
+    - if: IDF_TARGET in ["esp32h2"]
+
+components/esp_modem/examples/modem_console:
+  disable:
+    - if: IDF_TARGET in ["esp32h2"]

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

@@ -7,4 +7,6 @@ endif()
 idf_component_register(SRCS "ap_to_pppos.c"
                             ${NETWORK_DCE}
                     INCLUDE_DIRS ".")
-target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")
+
+# Ignore strict prototypes, as the network_dce.h can used in both C and C++ compilation
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-strict-prototypes")

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

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -14,6 +14,7 @@
 #include "esp_log.h"
 #include "esp_idf_version.h"
 #include "nvs_flash.h"
+#include "lwip/netif.h"
 #include "lwip/lwip_napt.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/event_groups.h"
@@ -38,7 +39,7 @@ static const int DISCONNECT_BIT = BIT1;
 static void on_ip_event(void *arg, esp_event_base_t event_base,
                         int32_t event_id, void *event_data)
 {
-    ESP_LOGD(TAG, "IP event! %d", event_id);
+    ESP_LOGD(TAG, "IP event! %" PRId32, event_id);
     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;

components/esp_modem/examples/modem_console/CMakeLists.txt

@@ -1,6 +1,7 @@
 # The following lines of boilerplate have to be in your project's CMakeLists
 # in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.8)
+set(CMAKE_CXX_STANDARD 17)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(modem-console)

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

@@ -1,5 +1,6 @@
 idf_component_register(SRCS "modem_console_main.cpp"
                             "console_helper.cpp"
+                            "my_module_dce.cpp"
                             "httpget_handle.c"
                             "ping_handle.c"
                        REQUIRES console esp_http_client nvs_flash

components/esp_modem/examples/modem_console/main/Kconfig.projbuild

@@ -16,17 +16,18 @@ menu "Example Configuration"
     endchoice
 
     choice EXAMPLE_MODEM_DEVICE
-        depends on EXAMPLE_SERIAL_CONFIG_UART
         prompt "Choose supported modem device (DCE)"
-        default EXAMPLE_MODEM_DEVICE_BG96
+        default EXAMPLE_MODEM_DEVICE_SHINY
         help
             Select modem device connected to the ESP DTE.
         config EXAMPLE_MODEM_DEVICE_SHINY
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SHINY"
             help
                 SHINY is a GSM/GPRS module.
                 It supports SHINY.
         config EXAMPLE_MODEM_DEVICE_SIM800
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SIM800"
             help
                 SIMCom SIM800L is a GSM/GPRS module.
@@ -36,10 +37,12 @@ menu "Example Configuration"
             help
                 Quectel BG96 is a series of LTE Cat M1/Cat NB1/EGPRS module.
         config EXAMPLE_MODEM_DEVICE_SIM7000
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SIM7000"
             help
                 SIM7000 is a Multi-Band LTE-FDD and GSM/GPRS/EDGE module.
         config EXAMPLE_MODEM_DEVICE_SIM7070
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SIM7070"
             help
                 SIM7070 is Multi-Band CAT M and NB IoT module.
@@ -47,6 +50,11 @@ menu "Example Configuration"
             bool "SIM7600"
             help
                 SIM7600 is a Multi-Band LTE-TDD/LTE-FDD/HSPA+ and GSM/GPRS/EDGE module.
+        config EXAMPLE_MODEM_DEVICE_A7670
+            depends on EXAMPLE_SERIAL_CONFIG_USB
+            bool "A7670"
+            help
+                A7670X is Multi-Band LTE-FDD/LTE-TDD/GSM/GPRS/EDGE module.
     endchoice
 
     config EXAMPLE_MODEM_PPP_APN

components/esp_modem/examples/modem_console/main/idf_component.yml

@@ -3,10 +3,10 @@ dependencies:
   ## Required IDF version
   idf: ">=4.1.0"
   espressif/esp_modem:
-    version: "^0.1.20"
+    version: "^1.0.0"
     override_path: "../../../"
   espressif/esp_modem_usb_dte:
-    version: "^1.0.0"
+    version: "^1.1.0"
     rules:
       - if: "idf_version >=4.4"
       - if: "target in [esp32s2, esp32s3]"

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

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -48,9 +48,9 @@
         } } while (0)
 
 /**
- * Please update the default APN name here (this could be updated runtime)
+ * Default APN name is taken from Kconfig (this could be updated runtime)
  */
-#define DEFAULT_APN "my_apn"
+#define DEFAULT_APN CONFIG_EXAMPLE_MODEM_PPP_APN
 
 #define GPIO_OUTPUT_PWRKEY    (gpio_num_t)CONFIG_EXAMPLE_MODEM_PWRKEY_PIN
 #define GPIO_OUTPUT_PIN_SEL  (1ULL<<GPIO_OUTPUT_PWRKEY)
@@ -89,6 +89,14 @@ void wakeup_modem(void)
     vTaskDelay(pdMS_TO_TICKS(2000));
 }
 
+#ifdef CONFIG_EXAMPLE_MODEM_DEVICE_SHINY
+command_result handle_urc(uint8_t *data, size_t len)
+{
+    ESP_LOG_BUFFER_HEXDUMP("on_read", data, len, ESP_LOG_INFO);
+    return command_result::TIMEOUT;
+}
+#endif
+
 extern "C" void app_main(void)
 {
     static RTC_RODATA_ATTR char apn_rtc[20] = DEFAULT_APN;
@@ -122,19 +130,19 @@ extern "C" void app_main(void)
     dte_config.dte_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE / 2;
     auto uart_dte = create_uart_dte(&dte_config);
 
-#if CONFIG_EXAMPLE_MODEM_DEVICE_SHINY == 1
+#if defined(CONFIG_EXAMPLE_MODEM_DEVICE_SHINY)
     ESP_LOGI(TAG, "Initializing esp_modem for the SHINY module...");
     auto dce = create_shiny_dce(&dce_config, uart_dte, esp_netif);
-#elif CONFIG_EXAMPLE_MODEM_DEVICE_BG96 == 1
+#elif defined(CONFIG_EXAMPLE_MODEM_DEVICE_BG96)
     ESP_LOGI(TAG, "Initializing esp_modem for the BG96 module...");
     auto dce = create_BG96_dce(&dce_config, uart_dte, esp_netif);
-#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM800 == 1
+#elif defined(CONFIG_EXAMPLE_MODEM_DEVICE_SIM800)
     ESP_LOGI(TAG, "Initializing esp_modem for the SIM800 module...");
     auto dce = create_SIM800_dce(&dce_config, uart_dte, esp_netif);
-#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7000 == 1
+#elif defined(CONFIG_EXAMPLE_MODEM_DEVICE_SIM7000)
     ESP_LOGI(TAG, "Initializing esp_modem for the SIM7000 module...");
     auto dce = create_SIM7000_dce(&dce_config, uart_dte, esp_netif);
-#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070 == 1
+#elif defined(CONFIG_EXAMPLE_MODEM_DEVICE_SIM7070)
     ESP_LOGI(TAG, "Initializing esp_modem for the SIM7070 module...");
     auto dce = create_SIM7070_dce(&dce_config, uart_dte, esp_netif);
 #elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7600 == 1
@@ -149,7 +157,18 @@ extern "C" void app_main(void)
 #elif defined(CONFIG_EXAMPLE_SERIAL_CONFIG_USB)
     while (1) {
         exit_signal.clear(1);
-        struct esp_modem_usb_term_config usb_config = ESP_MODEM_DEFAULT_USB_CONFIG(0x2C7C, 0x0296, 2); // VID, PID and interface num of BG96 modem
+#if CONFIG_EXAMPLE_MODEM_DEVICE_BG96 == 1
+        ESP_LOGI(TAG, "Initializing esp_modem for the BG96 module...");
+        struct esp_modem_usb_term_config usb_config = ESP_MODEM_BG96_USB_CONFIG();
+#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7600 == 1
+        ESP_LOGI(TAG, "Initializing esp_modem for the SIM7600 module...");
+        struct esp_modem_usb_term_config usb_config = ESP_MODEM_SIM7600_USB_CONFIG();
+#elif CONFIG_EXAMPLE_MODEM_DEVICE_A7670 == 1
+        ESP_LOGI(TAG, "Initializing esp_modem for the A7670 module...");
+        struct esp_modem_usb_term_config usb_config = ESP_MODEM_A7670_USB_CONFIG();
+#else
+#error USB modem not selected
+#endif
         const esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_USB_CONFIG(usb_config);
         ESP_LOGI(TAG, "Waiting for USB device connection...");
         auto dte = create_usb_dte(&dte_config);
@@ -159,7 +178,13 @@ extern "C" void app_main(void)
                 exit_signal.set(1);
             }
         });
+#if CONFIG_EXAMPLE_MODEM_DEVICE_BG96 == 1
         std::unique_ptr<DCE> dce = create_BG96_dce(&dce_config, dte, esp_netif);
+#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7600 == 1 || CONFIG_EXAMPLE_MODEM_DEVICE_A7670 == 1
+        std::unique_ptr<DCE> dce = create_SIM7600_dce(&dce_config, dte, esp_netif);
+#else
+#error USB modem not selected
+#endif
 
 #else
 #error Invalid serial connection to modem.
@@ -210,7 +235,17 @@ extern "C" void app_main(void)
         if (c->get_count_of(&SetModeArgs::mode)) {
             auto mode = c->get_string_of(&SetModeArgs::mode);
             modem_mode dev_mode;
-            if (mode == "CMD") {
+            if (mode == "CMUX1") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_MODE;
+            } else if (mode == "CMUX2") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_EXIT;
+            } else if (mode == "CMUX3") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_SWAP;
+            } else if (mode == "CMUX4") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_DATA;
+            } else if (mode == "CMUX5") {
+                dev_mode = esp_modem::modem_mode::CMUX_MANUAL_COMMAND;
+            } else if (mode == "CMD") {
                 dev_mode = esp_modem::modem_mode::COMMAND_MODE;
             } else if (mode == "PPP") {
                 dev_mode = esp_modem::modem_mode::DATA_MODE;
@@ -276,8 +311,9 @@ extern "C" void app_main(void)
 
     const ConsoleCommand GetOperatorName("get_operator_name", "reads the operator name", no_args, [&](ConsoleCommand * c) {
         std::string operator_name;
+        int act;
         ESP_LOGI(TAG, "Reading operator name...");
-        CHECK_ERR(dce->get_operator_name(operator_name), ESP_LOGI(TAG, "OK. Operator name: %s", operator_name.c_str()));
+        CHECK_ERR(dce->get_operator_name(operator_name, act), ESP_LOGI(TAG, "OK. Operator name: %s", operator_name.c_str()));
     });
 
     const struct GenericCommandArgs {
@@ -329,6 +365,20 @@ extern "C" void app_main(void)
         ESP_LOGI(TAG, "Resetting the module...");
         CHECK_ERR(dce->reset(), ESP_LOGI(TAG, "OK"));
     });
+#ifdef CONFIG_EXAMPLE_MODEM_DEVICE_SHINY
+    const ConsoleCommand HandleURC("urc", "toggle urc handling", no_args, [&](ConsoleCommand * c) {
+        static int cnt = 0;
+        if (++cnt % 2) {
+            ESP_LOGI(TAG, "Adding URC handler");
+            dce->set_on_read(handle_urc);
+        } else {
+            ESP_LOGI(TAG, "URC removed");
+            dce->set_on_read(nullptr);
+        }
+        return 0;
+    });
+#endif
+
     const struct SetApn {
         SetApn(): apn(STR1, nullptr, nullptr, "<apn>", "APN (Access Point Name)") {}
         CommandArgs apn;

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

@@ -0,0 +1,114 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+/* Modem console example: Custom DCE
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+#include <cstring>
+#include "cxx_include/esp_modem_api.hpp"
+#include "cxx_include/esp_modem_dce_module.hpp"
+#include "generate/esp_modem_command_declare.inc"
+#include "my_module_dce.hpp"
+
+using namespace esp_modem;
+
+//
+// Define preprocessor's forwarding to dce_commands definitions
+//
+
+// Helper macros to handle multiple arguments of declared API
+#define ARGS0
+#define ARGS1 , p1
+#define ARGS2 , p1 , p2
+#define ARGS3 , p1 , p2 , p3
+#define ARGS4 , p1 , p2 , p3, p4
+#define ARGS5 , p1 , p2 , p3, p4, p5
+#define ARGS6 , p1 , p2 , p3, p4, p5, p6
+
+#define _ARGS(x)  ARGS ## x
+#define ARGS(x)  _ARGS(x)
+
+#define CMD_OK    (1)
+#define CMD_FAIL  (2)
+
+//
+// Repeat all declarations and forward to the AT commands defined in esp_modem::dce_commands:: namespace
+//
+#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, arg_nr, ...) \
+     return_type Shiny::DCE::name(__VA_ARGS__) { return esp_modem::dce_commands::name(this ARGS(arg_nr) ); }
+
+DECLARE_ALL_COMMAND_APIS(return_type name(...) )
+
+#undef ESP_MODEM_DECLARE_DCE_COMMAND
+
+std::unique_ptr<Shiny::DCE> create_shiny_dce(const esp_modem::dce_config *config,
+        std::shared_ptr<esp_modem::DTE> dte,
+        esp_netif_t *netif)
+{
+    return Shiny::Factory::create(config, std::move(dte), netif);
+}
+
+/**
+ * @brief Definition of the command API, which makes the Shiny::DCE "command-able class"
+ * @param cmd Command to send
+ * @param got_line Recv line callback
+ * @param time_ms timeout in ms
+ * @param separator line break separator
+ * @return OK, FAIL or TIMEOUT
+ */
+command_result Shiny::DCE::command(const std::string &cmd, got_line_cb got_line, uint32_t time_ms, const char separator)
+{
+    if (!handling_urc) {
+        return dte->command(cmd, got_line, time_ms, separator);
+    }
+    handle_cmd = got_line;
+    signal.clear(CMD_OK | CMD_FAIL);
+    esp_modem::DTE_Command command{cmd};
+    dte->write(command);
+    signal.wait_any(CMD_OK | CMD_FAIL, time_ms);
+    handle_cmd = nullptr;
+    if (signal.is_any(CMD_OK)) {
+        return esp_modem::command_result::OK;
+    }
+    if (signal.is_any(CMD_FAIL)) {
+        return esp_modem::command_result::FAIL;
+    }
+    return esp_modem::command_result::TIMEOUT;
+}
+
+/**
+ * @brief Handle received data
+ *
+ * @param data Data received from the device
+ * @param len Length of the data
+ * @return standard command return code (OK|FAIL|TIMEOUT)
+ */
+command_result Shiny::DCE::handle_data(uint8_t *data, size_t len)
+{
+    if (std::memchr(data, '\n', len)) {
+        if (handle_urc) {
+            handle_urc(data, len);
+        }
+        if (handle_cmd) {
+            auto ret = handle_cmd(data, len);
+            if (ret == esp_modem::command_result::TIMEOUT) {
+                return command_result::TIMEOUT;
+            }
+            if (ret == esp_modem::command_result::OK) {
+                signal.set(CMD_OK);
+            }
+            if (ret == esp_modem::command_result::FAIL) {
+                signal.set(CMD_FAIL);
+            }
+        }
+    }
+    return command_result::TIMEOUT;
+}

components/esp_modem/examples/modem_console/main/my_module_dce.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -11,6 +11,8 @@
 #pragma once
 
 
+#include <utility>
+
 #include "cxx_include/esp_modem_dce_factory.hpp"
 #include "cxx_include/esp_modem_dce_module.hpp"
 
@@ -28,13 +30,84 @@ public:
     }
 };
 
+namespace Shiny {
+
+using namespace esp_modem;
+
+class DCE : public esp_modem::DCE_T<MyShinyModem>, public CommandableIf {
+public:
+    using DCE_T<MyShinyModem>::DCE_T;
+
+    command_result
+    command(const std::string &cmd, got_line_cb got_line, uint32_t time_ms) override
+    {
+        return command(cmd, got_line, time_ms, '\n');
+    }
+
+    command_result
+    command(const std::string &cmd, got_line_cb got_line, uint32_t time_ms, const char separator) override;
+
+    int write(uint8_t *data, size_t len) override
+    {
+        return dte->write(data, len);
+    }
+
+    void on_read(got_line_cb on_data) override
+    {
+        return dte->on_read(on_data);
+    }
+
+#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, num, ...) \
+    esp_modem::return_type name(__VA_ARGS__);
+
+    DECLARE_ALL_COMMAND_APIS(forwards name(...))
+
+#undef ESP_MODEM_DECLARE_DCE_COMMAND
+
+    void set_on_read(esp_modem::got_line_cb on_read_cb)
+    {
+        if (on_read_cb == nullptr) {
+            handling_urc = false;
+            handle_urc = nullptr;
+            dte->on_read(nullptr);
+            return;
+        }
+        handle_urc = std::move(on_read_cb);
+        dte->on_read([this](uint8_t *data, size_t len) {
+            this->handle_data(data, len);
+            return command_result::TIMEOUT;
+        });
+        handling_urc = true;
+    }
+
+private:
+    got_line_cb handle_urc{nullptr};
+    got_line_cb handle_cmd{nullptr};
+    SignalGroup signal;
+    bool handling_urc {false};
+
+    command_result handle_data(uint8_t *data, size_t len);
+
+};
+
+class Factory: public ::esp_modem::dce_factory::Factory {
+public:
+
+    static std::unique_ptr<DCE> create(const esp_modem::dce_config *config,
+                                       std::shared_ptr<esp_modem::DTE> dte,
+                                       esp_netif_t *netif)
+    {
+        return build_generic_DCE<MyShinyModem, DCE, std::unique_ptr<DCE>>(config, std::move(dte), netif);
+    }
+
+};
+
+} // namespace Shiny
+
 /**
  * @brief Helper create method which employs the DCE factory for creating DCE objects templated by a custom module
  * @return unique pointer of the resultant DCE
  */
-std::unique_ptr<esp_modem::DCE> create_shiny_dce(const esp_modem::dce_config *config,
+std::unique_ptr<Shiny::DCE> create_shiny_dce(const esp_modem::dce_config *config,
         std::shared_ptr<esp_modem::DTE> dte,
-        esp_netif_t *netif)
-{
-    return esp_modem::dce_factory::Factory::build_unique<MyShinyModem>(config, std::move(dte), netif);
-}
+        esp_netif_t *netif);

components/esp_modem/examples/modem_console/sdkconfig.ci.usb_s2

@@ -1 +1,2 @@
+CONFIG_IDF_TARGET="esp32s2"
 CONFIG_EXAMPLE_SERIAL_CONFIG_USB=y

components/esp_modem/examples/modem_console/sdkconfig.ci.usb_s3

@@ -1 +1,2 @@
+CONFIG_IDF_TARGET="esp32s3"
 CONFIG_EXAMPLE_SERIAL_CONFIG_USB=y

components/esp_modem/examples/modem_psm/CMakeLists.txt

@@ -0,0 +1,10 @@
+# For more information about build system see
+# https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/build-system.html
+# The following five lines of boilerplate have to be in your project's
+# CMakeLists in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.16)
+
+set(EXTRA_COMPONENT_DIRS "../..")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(modem_psm)

components/esp_modem/examples/modem_psm/README.md

@@ -0,0 +1,32 @@
+# Modem Power Saving Mode, sleep modes example
+
+
+## Overview
+
+This example demonstrates Power Saving Mode(PSM) in Sim70XX modems along with Deep sleep and Light Sleep modes in esp32.
+This example enables Power saving mode in Sim70XX modem and tries to synchronise the sleep cycle of the modem with esp32.
+When the modem wakes up from PSM sleep it wakes up the esp32. While the modem is awake esp32 goes to light sleep.
+
+This example is tested on a SIM7080 modem.
+
+## Supported devices
+
+This example is supported only on ESP32, ESP32-S2 and ESP32-S3.
+
+## Configuration
+
+* EXAMPLE_MODEM_UART_TX_PIN: Connect this pin to the UART Tx pin of the modem.
+* EXAMPLE_MODEM_UART_RX_PIN: Connect this pin to the UART Rx pin of the modem.
+* EXAMPLE_MODEM_PWRKEY_PIN: Connect this pin to the PWRKEY pin of the modem.
+* EXAMPLE_MODEM_STATUS_PIN: Connect this pin to the Status pin of the modem.
+
+    The status pin might not be exposed on a modem. It needs to tapped out from the LED indicator marked as STS.
+
+* EXAMPLE_MODEM_LIGHT_SLEEP_DURATION: Duration for which the esp32 will go into light sleep, while the modem is awake.
+
+    If the esp32 goes into deep sleep while the modem is awake, esp32 will be awaken by the STATUS pin. So it's recommended to go to light sleep while the modem is awake.
+
+* EXAMPLE_MODEM_T3412_PERIODIC_TAU: T3412 timer is the duration of one awake and sleep cycle of the modem in PSM.
+* EXAMPLE_MODEM_T3324_ACTIVE_TIME: T3324 timer is the duration for which the modem stays PSM.
+
+    The timeout information is coded in bit format for T3412 and T3324 timer.

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

@@ -0,0 +1,3 @@
+
+idf_component_register(SRCS "modem_psm.c"
+                    INCLUDE_DIRS ".")

components/esp_modem/examples/modem_psm/main/Kconfig.projbuild

@@ -0,0 +1,109 @@
+
+menu "Example Configuration"
+
+    choice EXAMPLE_MODEM_DEVICE
+        prompt "Choose supported modem device (DCE)"
+        default EXAMPLE_MODEM_DEVICE_SIM7080
+        help
+            Select modem device connected to the ESP DTE.
+        config EXAMPLE_MODEM_DEVICE_SIM7070
+            bool "SIM7070"
+            help
+                SIM7070 is Multi-Band CAT M and NB IoT module.
+        config EXAMPLE_MODEM_DEVICE_SIM7080
+            bool "SIM7080"
+            help
+                SIM7080 is Multi-Band CAT M and NB IoT module.
+    endchoice
+
+    menu "UART Configuration"
+        config EXAMPLE_MODEM_UART_TX_PIN
+            int "TXD Pin Number"
+            default 4
+            range 0 31
+            help
+                Pin number of UART TX.
+
+        config EXAMPLE_MODEM_UART_RX_PIN
+            int "RXD Pin Number"
+            default 5
+            range 0 31
+            help
+                Pin number of UART RX.
+
+        config EXAMPLE_MODEM_UART_EVENT_TASK_STACK_SIZE
+            int "UART Event Task Stack Size"
+            range 2000 6000
+            default 4096
+            help
+                Stack size of UART event task.
+
+        config EXAMPLE_MODEM_UART_EVENT_TASK_PRIORITY
+            int "UART Event Task Priority"
+            range 3 22
+            default 5
+            help
+                Priority of UART event task.
+
+        config EXAMPLE_MODEM_UART_EVENT_QUEUE_SIZE
+            int "UART Event Queue Size"
+            range 10 40
+            default 30
+            help
+                Length of UART event queue.
+
+        config EXAMPLE_MODEM_UART_TX_BUFFER_SIZE
+            int "UART TX Buffer Size"
+            range 256 2048
+            default 512
+            help
+                Buffer size of UART TX buffer.
+
+        config EXAMPLE_MODEM_UART_RX_BUFFER_SIZE
+            int "UART RX Buffer Size"
+            range 256 2048
+            default 1024
+            help
+                Buffer size of UART RX buffer.
+    endmenu
+
+    config EXAMPLE_MODEM_PWRKEY_PIN
+        int "PWRKEY Pin Number"
+        default 18
+        range 0 31
+        help
+            Pin number connected to modem's power key pin.
+
+    config EXAMPLE_MODEM_STATUS_PIN
+        int "STATUS Pin Number"
+        default 19
+        range 0 31
+        help
+            Pin number connected to modem's status pin.
+
+    config EXAMPLE_MODEM_LIGHT_SLEEP_DURATION
+        int "Light Sleep Duration"
+        default 10
+        range 0 15000
+        help
+            Duration in seconds, of which the esp32 goes into light sleep while the modem is awake.
+
+    config EXAMPLE_MODEM_PPP_APN
+        string "Set MODEM APN"
+        default "internet"
+        help
+            Set APN (Access Point Name), a logical name to choose data network
+
+    config EXAMPLE_MODEM_T3412_PERIODIC_TAU
+        string "T3412 Requester Periodic TAU"
+        default "00000100"
+        help
+            T3412 timer, i.e the duration of one awake and sleep cycle of the modem in PSM.
+
+    config EXAMPLE_MODEM_T3324_ACTIVE_TIME
+        string "T3324 Requester Active Time"
+        default "00000001"
+        help
+            T3324 timer, i.e the duration for which the modem stays PSM.
+
+endmenu

components/esp_modem/examples/modem_psm/main/modem_psm.c

@@ -0,0 +1,202 @@
+/*
+ * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+
+/*
+ * Power Saving Mode(PSM) in Sim70XX modems along with
+ * Deep sleep and Light Sleep modes in esp32.
+*/
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include "driver/uart.h"
+#include "string.h"
+#include "driver/gpio.h"
+#include "esp_sleep.h"
+#include "driver/rtc_io.h"
+#include "esp_modem_api.h"
+#include "esp_event.h"
+#include "sdkconfig.h"
+
+
+#define BUF_SIZE 1024
+
+#define TXD_PIN             ((gpio_num_t)CONFIG_EXAMPLE_MODEM_UART_TX_PIN)
+#define RXD_PIN             ((gpio_num_t)CONFIG_EXAMPLE_MODEM_UART_RX_PIN)
+#define GPIO_INPUT_STATUS   ((gpio_num_t)CONFIG_EXAMPLE_MODEM_STATUS_PIN)
+#define GPIO_OUTPUT_PWRKEY  ((gpio_num_t)CONFIG_EXAMPLE_MODEM_PWRKEY_PIN)
+#define GPIO_OUTPUT_PIN_SEL (1ULL<<GPIO_OUTPUT_PWRKEY)
+
+#define CHECK_ERR(cmd, success_action)  do {    \
+        esp_err_t ret = cmd;                    \
+        if (ret == ESP_OK) {                    \
+            success_action;                     \
+        } else {                                \
+            ESP_LOGE(TAG, "Failed with %s", ret == ESP_ERR_TIMEOUT ? "TIMEOUT":"ERROR");  \
+        } } while (0)
+
+
+const char *TAG = "modem_psm";
+RTC_DATA_ATTR static int boot_count = 0;
+
+
+void dce_init(esp_modem_dce_t **dce, esp_netif_t **esp_netif)
+{
+    esp_modem_dce_config_t dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG(CONFIG_EXAMPLE_MODEM_PPP_APN);
+    esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+    esp_netif_config_t netif_ppp_config = ESP_NETIF_DEFAULT_PPP();
+    *esp_netif = esp_netif_new(&netif_ppp_config);
+    assert(*esp_netif);
+
+    /* setup UART specific configuration based on kconfig options */
+    dte_config.uart_config.tx_io_num = CONFIG_EXAMPLE_MODEM_UART_TX_PIN;
+    dte_config.uart_config.rx_io_num = CONFIG_EXAMPLE_MODEM_UART_RX_PIN;
+    dte_config.uart_config.rx_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE;
+    dte_config.uart_config.tx_buffer_size = CONFIG_EXAMPLE_MODEM_UART_TX_BUFFER_SIZE;
+    dte_config.uart_config.event_queue_size = CONFIG_EXAMPLE_MODEM_UART_EVENT_QUEUE_SIZE;
+    dte_config.task_stack_size = CONFIG_EXAMPLE_MODEM_UART_EVENT_TASK_STACK_SIZE;
+    dte_config.task_priority = CONFIG_EXAMPLE_MODEM_UART_EVENT_TASK_PRIORITY;
+    dte_config.dte_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE / 2;
+
+    ESP_LOGI(TAG, "Initializing esp_modem for a generic module...");
+    *dce = esp_modem_new(&dte_config, &dce_config, *esp_netif);
+    assert(*dce);
+}
+
+void config_pwrkey_gpio(void)
+{
+    gpio_config_t io_conf = {};                     //zero-initialize the config structure.
+
+    io_conf.intr_type = GPIO_INTR_DISABLE;          //disable interrupt
+    io_conf.mode = GPIO_MODE_OUTPUT;                //set as output mode
+    io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;     //bit mask of the pins that you want to set,e.g.GPIO18/19
+    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;   //disable pull-down mode
+    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;       //disable pull-up mode
+
+    gpio_config(&io_conf);                          //configure GPIO with the given settings
+}
+
+void power_on_modem(esp_modem_dce_t *dce)
+{
+    rtc_gpio_hold_dis(GPIO_OUTPUT_PWRKEY);
+
+    /* Power on the modem */
+    ESP_LOGI(TAG, "Power on the modem");
+    gpio_set_level(GPIO_OUTPUT_PWRKEY, 1);
+    vTaskDelay(pdMS_TO_TICKS(500));
+    gpio_set_level(GPIO_OUTPUT_PWRKEY, 0);
+
+    rtc_gpio_hold_en(GPIO_OUTPUT_PWRKEY);
+    vTaskDelay(pdMS_TO_TICKS(2000));
+
+    CHECK_ERR(esp_modem_sync(dce), ESP_LOGI(TAG, "OK"));
+}
+
+void power_down_modem(esp_modem_dce_t *dce)
+{
+    char data[BUF_SIZE];
+
+    ESP_LOGI(TAG, "Power down the modem");
+
+    /* Power down the modem by AT command */
+    CHECK_ERR(esp_modem_at(dce, "AT+CPOWD=1", data, 500), ESP_LOGI(TAG, "OK. %s", data));
+}
+
+void run_at(esp_modem_dce_t *dce, uint8_t count)
+{
+    for (int i = 0; i < count; i++) {
+        CHECK_ERR(esp_modem_sync(dce), ESP_LOGI(TAG, "OK"));
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
+
+void run_at_ping(esp_modem_dce_t *dce)
+{
+    char data[BUF_SIZE];
+    int rssi, ber;
+    CHECK_ERR(esp_modem_get_signal_quality(dce, &rssi, &ber), ESP_LOGI(TAG, "OK. rssi=%d, ber=%d", rssi, ber));
+    vTaskDelay(pdMS_TO_TICKS(1000));
+
+    CHECK_ERR(esp_modem_at(dce, "AT+CPSMS?", data, 500), ESP_LOGI(TAG, "OK. %s", data));
+    vTaskDelay(pdMS_TO_TICKS(1000));
+
+    CHECK_ERR(esp_modem_at(dce, "AT+CPSI?", data, 500), ESP_LOGI(TAG, "OK. %s", data));             // Inquiring UE system information
+    CHECK_ERR(esp_modem_at(dce, "AT+CNACT=0,1", data, 500), ESP_LOGI(TAG, "OK. %s", data));         // Activate the APP network
+    CHECK_ERR(esp_modem_at(dce, "AT+SNPDPID=0", data, 500), ESP_LOGI(TAG, "OK. %s", data));         // Select PDP index for PING
+    CHECK_ERR(esp_modem_at(dce, "AT+SNPING4=\"8.8.8.8\",3,16,1000", data, 500), ESP_LOGI(TAG, "OK. %s", data));     // Send IPv4 PING
+    CHECK_ERR(esp_modem_at(dce, "AT+CNACT=0,0", data, 500), ESP_LOGI(TAG, "OK. %s", data));         // Deactivate the APP network
+}
+
+
+void app_main(void)
+{
+    char *cmd;
+    char data[BUF_SIZE];
+    esp_modem_dce_t *dce = NULL;
+    esp_netif_t *esp_netif = NULL;
+    esp_sleep_wakeup_cause_t wakeup_cause = esp_sleep_get_wakeup_cause();
+    ESP_LOGI(TAG, "Deep sleep Wake Up Cause: %d\n", wakeup_cause);
+
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    dce_init(&dce, &esp_netif);
+
+    switch (wakeup_cause) {
+    case ESP_SLEEP_WAKEUP_UNDEFINED:
+        /* Power on the modem */
+        config_pwrkey_gpio();
+        power_on_modem(dce);
+
+        run_at(dce, 3);
+
+        /* Configure Power Saving Mode in the modem */
+        asprintf(&cmd, "AT+CPSMS=1,,,\"%s\",\"%s\"\r\n", CONFIG_EXAMPLE_MODEM_T3412_PERIODIC_TAU,
+                 CONFIG_EXAMPLE_MODEM_T3324_ACTIVE_TIME);
+        CHECK_ERR(esp_modem_at(dce, cmd, data, 500), ESP_LOGI(TAG, "OK. %s", data));
+        free(cmd);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+
+        /* Perform Communication tasks */
+        run_at_ping(dce);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        break;
+
+    case ESP_SLEEP_WAKEUP_EXT0:
+        run_at(dce, 3);
+
+        /* Perform Communication tasks */
+        run_at_ping(dce);
+        vTaskDelay(pdMS_TO_TICKS(1000));
+        break;
+
+    default:
+        ESP_LOGI(TAG, "Not a deep sleep reset: %d\n", wakeup_cause);
+    }
+
+    ESP_LOGI(TAG, "Light sleep before going to Deep sleep\n\n");
+
+    /* Enter light sleep mode as long as the modem is awake */
+    esp_sleep_enable_timer_wakeup(CONFIG_EXAMPLE_MODEM_LIGHT_SLEEP_DURATION * 1000000);
+    esp_light_sleep_start();
+    esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);    // Disabling timer before going to deep sleep.
+    wakeup_cause = esp_sleep_get_wakeup_cause();
+    ESP_LOGI(TAG, "Light sleep wakeup cause: %d\n", wakeup_cause);
+
+    /* DCE and netif clean-up */
+    /* In Deep-sleep mode, the CPUs, most of the RAM, and all digital peripherals are powered off.
+     * So dce and netif would be lost anyway if they are not explicitly destroyed.
+     * But since dce is also linked with UART communication with the modem it's better to exit gracefully before going to deep sleep.
+     */
+    esp_modem_destroy(dce);
+    esp_netif_destroy(esp_netif);
+
+    /* Enable wakeup if status pin is high */
+    esp_sleep_enable_ext0_wakeup(GPIO_INPUT_STATUS, 1);
+
+    ESP_LOGI(TAG, "Entering deep sleep: %d\n", boot_count++);
+    esp_deep_sleep_start();
+}

components/esp_modem/examples/modem_psm/sdkconfig.defaults

@@ -0,0 +1,4 @@
+# This file was generated using idf.py save-defconfig. It can be edited manually.
+# Espressif IoT Development Framework (ESP-IDF) Project Minimal Configuration
+#
+CONFIG_LWIP_PPP_SUPPORT=y

components/esp_modem/examples/modem_tcp_client/CMakeLists.txt

@@ -0,0 +1,9 @@
+# The following lines of boilerplate have to be in your project's CMakeLists
+# in this exact order for cmake to work correctly
+cmake_minimum_required(VERSION 3.8)
+set(CMAKE_CXX_STANDARD 17)
+
+set(EXTRA_COMPONENT_DIRS "../..")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(modem_tcp_client)

components/esp_modem/examples/modem_tcp_client/README.md

@@ -0,0 +1,10 @@
+# Modem TCP client
+
+(See the README.md file in the upper level 'examples' directory for more information about examples.)
+
+## Overview
+This example demonstrates how to act as a MQTT client using modem's TCP commands (provided, the device supports "socket" related commands)
+
+### Supported IDF versions
+
+This example is supported from IDF `v4.4`.

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

@@ -0,0 +1,11 @@
+if (CONFIG_EXAMPLE_MODEM_DEVICE_BG96)
+    set(device_srcs sock_commands_bg96.cpp)
+elseif(CONFIG_EXAMPLE_MODEM_DEVICE_SIM7600)
+    set(device_srcs sock_commands_sim7600.cpp)
+endif()
+
+idf_component_register(SRCS "modem_client.cpp"
+                            "sock_dce.cpp"
+                            "${device_srcs}"
+                       INCLUDE_DIRS ".")
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/esp_modem/examples/modem_tcp_client/main/Kconfig.projbuild

@@ -0,0 +1,96 @@
+menu "Example Configuration"
+
+    choice EXAMPLE_MODEM_DEVICE
+        prompt "Choose supported modem device (DCE)"
+        default EXAMPLE_MODEM_DEVICE_BG96
+        help
+            Select modem device connected to the ESP DTE.
+        config EXAMPLE_MODEM_DEVICE_BG96
+            bool "BG96"
+            help
+                Quectel BG96 is a series of LTE Cat M1/Cat NB1/EGPRS module.
+        config EXAMPLE_MODEM_DEVICE_SIM7600
+            bool "SIM7600"
+            help
+                SIM7600 is Multi-Band LTE-TDD/LTE-FDD/HSPA+ and GSM/GPRS/EDGE module
+    endchoice
+
+    config EXAMPLE_MODEM_APN
+        string "Set MODEM APN"
+        default "internet"
+        help
+            Set APN (Access Point Name), a logical name to choose data network
+
+    menu "UART Configuration"
+        config EXAMPLE_MODEM_UART_TX_PIN
+            int "TXD Pin Number"
+            default 25
+            range 0 31
+            help
+                Pin number of UART TX.
+
+        config EXAMPLE_MODEM_UART_RX_PIN
+            int "RXD Pin Number"
+            default 26
+            range 0 31
+            help
+                Pin number of UART RX.
+
+        config EXAMPLE_MODEM_UART_RTS_PIN
+            int "RTS Pin Number"
+            default 27
+            range 0 31
+            help
+                Pin number of UART RTS.
+
+        config EXAMPLE_MODEM_UART_CTS_PIN
+            int "CTS Pin Number"
+            default 23
+            range 0 31
+            help
+                Pin number of UART CTS.
+
+        config EXAMPLE_MODEM_UART_EVENT_TASK_STACK_SIZE
+            int "UART Event Task Stack Size"
+            range 2000 6000
+            default 2048
+            help
+                Stack size of UART event task.
+
+        config EXAMPLE_MODEM_UART_EVENT_TASK_PRIORITY
+            int "UART Event Task Priority"
+            range 3 22
+            default 5
+            help
+                Priority of UART event task.
+
+        config EXAMPLE_MODEM_UART_EVENT_QUEUE_SIZE
+            int "UART Event Queue Size"
+            range 10 40
+            default 30
+            help
+                Length of UART event queue.
+
+        config EXAMPLE_MODEM_UART_PATTERN_QUEUE_SIZE
+            int "UART Pattern Queue Size"
+            range 10 40
+            default 20
+            help
+                Length of UART pattern queue.
+
+        config EXAMPLE_MODEM_UART_TX_BUFFER_SIZE
+            int "UART TX Buffer Size"
+            range 256 2048
+            default 512
+            help
+                Buffer size of UART TX buffer.
+
+        config EXAMPLE_MODEM_UART_RX_BUFFER_SIZE
+            int "UART RX Buffer Size"
+            range 256 2048
+            default 1024
+            help
+                Buffer size of UART RX buffer.
+    endmenu
+
+endmenu

components/esp_modem/examples/modem_tcp_client/main/modem_client.cpp

@@ -0,0 +1,140 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Unlicense OR CC0-1.0
+ */
+/* PPPoS Client Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+#include <string>
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+#include "esp_netif.h"
+#include "esp_netif_ppp.h"
+#include "mqtt_client.h"
+#include "esp_modem_config.h"
+#include "cxx_include/esp_modem_api.hpp"
+#include "sock_dce.hpp"
+#include "esp_log.h"
+
+#define BROKER_URL "mqtt.eclipseprojects.io"
+
+static const char *TAG = "modem_client";
+static EventGroupHandle_t event_group = NULL;
+static const int CONNECT_BIT = BIT0;
+static const int GOT_DATA_BIT = BIT2;
+
+static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
+{
+    ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
+    esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;
+    esp_mqtt_client_handle_t client = event->client;
+    int msg_id;
+    switch ((esp_mqtt_event_id_t)event_id) {
+    case MQTT_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
+        msg_id = esp_mqtt_client_subscribe(client, "/topic/esp-pppos", 0);
+        ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
+        break;
+    case MQTT_EVENT_DISCONNECTED:
+        ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
+        break;
+    case MQTT_EVENT_SUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
+        msg_id = esp_mqtt_client_publish(client, "/topic/esp-pppos", "esp32-pppos", 0, 0, 0);
+        ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
+        break;
+    case MQTT_EVENT_UNSUBSCRIBED:
+        ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
+        break;
+    case MQTT_EVENT_PUBLISHED:
+        ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
+        break;
+    case MQTT_EVENT_DATA:
+        ESP_LOGI(TAG, "MQTT_EVENT_DATA");
+        printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
+        printf("DATA=%.*s\r\n", event->data_len, event->data);
+        xEventGroupSetBits(event_group, GOT_DATA_BIT);
+        break;
+    case MQTT_EVENT_ERROR:
+        ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
+        break;
+    default:
+        ESP_LOGI(TAG, "MQTT other event id: %d", event->event_id);
+        break;
+    }
+}
+
+extern "C" void app_main(void)
+{
+
+    /* Init and register system/core components */
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+
+    event_group = xEventGroupCreate();
+
+    /* Configure and create the UART DTE */
+    esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+    /* setup UART specific configuration based on kconfig options */
+    dte_config.uart_config.tx_io_num = CONFIG_EXAMPLE_MODEM_UART_TX_PIN;
+    dte_config.uart_config.rx_io_num = CONFIG_EXAMPLE_MODEM_UART_RX_PIN;
+    dte_config.uart_config.rts_io_num = CONFIG_EXAMPLE_MODEM_UART_RTS_PIN;
+    dte_config.uart_config.cts_io_num = CONFIG_EXAMPLE_MODEM_UART_CTS_PIN;
+    dte_config.uart_config.rx_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE;
+    dte_config.uart_config.tx_buffer_size = CONFIG_EXAMPLE_MODEM_UART_TX_BUFFER_SIZE;
+    dte_config.uart_config.event_queue_size = CONFIG_EXAMPLE_MODEM_UART_EVENT_QUEUE_SIZE;
+    dte_config.task_stack_size = CONFIG_EXAMPLE_MODEM_UART_EVENT_TASK_STACK_SIZE * 2;
+    dte_config.task_priority = CONFIG_EXAMPLE_MODEM_UART_EVENT_TASK_PRIORITY;
+    dte_config.dte_buffer_size = CONFIG_EXAMPLE_MODEM_UART_RX_BUFFER_SIZE / 2;
+
+    auto dte = esp_modem::create_uart_dte(&dte_config);
+    assert(dte);
+
+    /* Configure the DCE */
+    esp_modem_dce_config_t dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG(CONFIG_EXAMPLE_MODEM_APN);
+
+    /* create the DCE and initialize network manually (using AT commands) */
+    auto dce = sock_dce::create(&dce_config, std::move(dte));
+    if (!dce->init_network()) {
+        ESP_LOGE(TAG,  "Failed to setup network");
+        return;
+    }
+
+    dce->init_sock(8883);
+    esp_mqtt_client_config_t mqtt_config = {};
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
+    mqtt_config.broker.address.uri = "mqtts://127.0.0.1";
+    mqtt_config.session.message_retransmit_timeout = 10000;
+#else
+    mqtt_config.uri = "mqtt://127.0.0.1";
+    mqtt_config.message_retransmit_timeout = 10000;
+#endif
+    esp_mqtt_client_handle_t mqtt_client = esp_mqtt_client_init(&mqtt_config);
+    esp_mqtt_client_register_event(mqtt_client, static_cast<esp_mqtt_event_id_t>(ESP_EVENT_ANY_ID), mqtt_event_handler, NULL);
+    esp_mqtt_client_start(mqtt_client);
+    if (!dce->start(BROKER_URL, 8883)) {
+        ESP_LOGE(TAG, "Failed to start DCE");
+        return;
+    }
+    while (1) {
+        while (dce->perform_sock()) {
+            ESP_LOGV(TAG, "...performing");
+        }
+        ESP_LOGE(TAG, "Loop exit.. retrying");
+        // handle disconnections errors
+        if (!dce->init_network()) {
+            ESP_LOGE(TAG, "Failed to reinit network");
+            return;
+        }
+        if (!dce->start("test.mosquitto.org", 1883)) {
+            ESP_LOGI(TAG, "Network reinitialized, retrying");
+        }
+    }
+
+}

components/esp_modem/examples/modem_tcp_client/main/sock_commands.hpp

@@ -0,0 +1,25 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "cxx_include/esp_modem_dte.hpp"
+#include "cxx_include/esp_modem_dce_module.hpp"
+#include "cxx_include/esp_modem_types.hpp"
+#include "socket_commands.inc"
+
+namespace sock_commands {
+
+//using namespace esp_modem;
+
+#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, num, ...) \
+        esp_modem::return_type name(esp_modem::CommandableIf *t, ## __VA_ARGS__);
+
+DECLARE_SOCK_COMMANDS(declare name(Commandable *p, ...);)
+
+#undef ESP_MODEM_DECLARE_DCE_COMMAND
+
+}

components/esp_modem/examples/modem_tcp_client/main/sock_commands_bg96.cpp

@@ -0,0 +1,348 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <charconv>
+#include <cstring>
+#include <sys/socket.h>
+#include "sock_commands.hpp"
+#include "cxx_include/esp_modem_command_library_utils.hpp"
+#include "sock_dce.hpp"
+
+static const char *TAG = "sock_commands";
+
+namespace sock_commands {
+
+using namespace esp_modem;
+
+command_result net_open(CommandableIf *t)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string out;
+    auto ret = dce_commands::generic_get_string(t, "AT+QISTATE?\r", out, 1000);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    if (out.find("+QISTATE: 0") != std::string::npos) {
+        ESP_LOGV(TAG, "%s", out.data() );
+        ESP_LOGD(TAG, "Already there");
+        return command_result::FAIL;
+    } else if (out.empty()) {
+        return dce_commands::generic_command(t, "AT+QIACT=1\r", "OK", "ERROR", 150000);
+    }
+    return command_result::FAIL;
+}
+
+command_result net_close(CommandableIf *t)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    dce_commands::generic_command(t, "AT+QICLOSE=0\r", "OK", "ERROR", 10000);
+    esp_modem::Task::Delay(1000);
+    return dce_commands::generic_command(t, "AT+QIDEACT=1\r", "OK", "ERROR", 40000);
+}
+
+command_result tcp_open(CommandableIf *t, const std::string &host, int port, int timeout)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string ip_open = R"(AT+QIOPEN=1,0,"TCP",")" + host + "\"," + std::to_string(port) + "\r";
+    auto ret = dce_commands::generic_command(t, ip_open, "+QIOPEN: 0,0", "ERROR", timeout);
+    if (ret != command_result::OK) {
+        ESP_LOGE(TAG, "%s Failed", __func__ );
+        return ret;
+    }
+    return command_result::OK;
+}
+
+command_result tcp_close(CommandableIf *t)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return dce_commands::generic_command(t, "AT+QICLOSE=0\r", "OK", "ERROR", 10000);
+}
+
+command_result tcp_send(CommandableIf *t, uint8_t *data, size_t len)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    assert(0);      // Remove when fix done
+    return command_result::FAIL;
+}
+
+command_result tcp_recv(CommandableIf *t, uint8_t *data, size_t len, size_t &out_len)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    assert(0);      // Remove when fix done
+    return command_result::FAIL;
+}
+
+command_result get_ip(CommandableIf *t, std::string &ip)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string out;
+    auto ret = dce_commands::generic_get_string(t, "AT+QIACT?\r", out, 5000);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    auto pos = out.find("+QIACT: 1");
+    auto property = 0;
+    while (pos != std::string::npos) {
+        // Looking for: +QIACT: <contextID>,<context_state>,<context_type>,<IP_address>
+        if (property++ == 3) {  // ip is after 3rd comma (as a 4rd property of QIACT string)
+            ip = out.substr(++pos);
+            // strip quotes if present
+            auto quote1 = ip.find('"');
+            auto quote2 = ip.rfind('"');
+            if (quote1 != std::string::npos && quote2 != std::string::npos) {
+                ip = ip.substr(quote1 + 1, quote2 - 1);
+            }
+            return command_result::OK;
+        }
+        pos = out.find(',', ++pos);
+    }
+    return command_result::FAIL;
+}
+
+} // sock_commands
+
+namespace sock_dce {
+
+void Responder::start_sending(size_t len)
+{
+    data_to_send = len;
+    send_stat = 0;
+    send_cmd("AT+QISEND=0," + std::to_string(len) + "\r");
+}
+
+void Responder::start_receiving(size_t len)
+{
+    send_cmd("AT+QIRD=0," + std::to_string(len) + "\r");
+}
+
+bool Responder::start_connecting(std::string host, int port)
+{
+    send_cmd(R"(AT+QIOPEN=1,0,"TCP",")" + host + "\"," + std::to_string(port) + "\r");
+    return true;
+}
+
+Responder::ret Responder::recv(uint8_t *data, size_t len)
+{
+    const int MIN_MESSAGE = 6;
+    size_t actual_len = 0;
+    auto *recv_data = (char *)data;
+    if (data_to_recv == 0) {
+        const std::string_view head = "+QIRD: ";
+        auto head_pos = std::search(recv_data, recv_data + len, head.begin(), head.end());
+        if (head_pos == nullptr) {
+            return ret::FAIL;
+        }
+
+        auto next_nl = (char *)memchr(head_pos + head.size(), '\n', MIN_MESSAGE);
+        if (next_nl == nullptr) {
+            return ret::FAIL;
+        }
+
+        if (std::from_chars(head_pos + head.size(), next_nl, actual_len).ec == std::errc::invalid_argument) {
+            ESP_LOGE(TAG, "cannot convert");
+            return ret::FAIL;
+        }
+
+        ESP_LOGD(TAG, "Received: actual len=%d", actual_len);
+        if (actual_len == 0) {
+            ESP_LOGD(TAG, "no data received");
+            return ret::FAIL;
+        }
+
+        if (actual_len > buffer_size) {
+            ESP_LOGE(TAG, "TOO BIG");
+            return ret::FAIL;
+        }
+
+        recv_data = next_nl + 1;
+        auto first_data_len = len - (recv_data - (char *)data) /* minus size of the command marker */;
+        if (actual_len > first_data_len) {
+            ::send(sock, recv_data, first_data_len, 0);
+            data_to_recv = actual_len - first_data_len;
+            return ret::NEED_MORE_DATA;
+        }
+        ::send(sock, recv_data, actual_len, 0);
+    } else if (data_to_recv > len) {    // continue sending
+        ::send(sock, recv_data, len, 0);
+        data_to_recv -= len;
+        return ret::NEED_MORE_DATA;
+    } else if (data_to_recv <= len) {    // last read -> looking for "OK" marker
+        ::send(sock, recv_data, data_to_recv, 0);
+        actual_len = data_to_recv;
+    }
+
+    // "OK" after the data
+    char *last_pos = nullptr;
+    if (actual_len + 1 + 2 /* OK */  > len) {
+        last_pos = (char *)memchr(recv_data + 1 + actual_len, 'O', MIN_MESSAGE);
+        if (last_pos == nullptr || last_pos[1] != 'K') {
+            data_to_recv = 0;
+            return ret::FAIL;
+        }
+    }
+    if (last_pos != nullptr && (char *)data + len - last_pos - 2 > MIN_MESSAGE) {
+        // check for async replies after the Recv header
+        std::string_view response((char *)last_pos + 2 /* OK */, (char *)data + len - last_pos);
+        check_async_replies(status::RECEIVING, response);
+    }
+    // check if some other data?
+    start_receiving(0);
+    data_to_recv = 0;
+    return ret::OK;
+}
+
+
+Responder::ret Responder::send(uint8_t *data, size_t len)
+{
+    if (send_stat < 3) {
+        if (memchr(data, '>', len) == NULL) {
+            if (send_stat++ < 2) {
+                return Responder::ret::NEED_MORE_DATA;
+            }
+            ESP_LOGE(TAG, "Missed >");
+            return ret::FAIL;
+        }
+        auto written = dte->write(&buffer[0], data_to_send);
+        if (written != data_to_send) {
+            ESP_LOGE(TAG, "written %d (%d)...", written, len);
+            return ret::FAIL;
+        }
+        data_to_send = 0;
+        send_stat = 3;
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::send(std::string_view response)
+{
+    if (send_stat == 3) {
+        if (response.find("SEND OK") != std::string::npos) {
+            send_cmd("AT+QISEND=0,0\r");
+            send_stat++;
+            return ret::IN_PROGRESS;
+        } else if (response.find("SEND FAIL") != std::string::npos) {
+            ESP_LOGE(TAG, "Sending buffer full");
+            return ret::FAIL;
+        } else if (response.find("ERROR") != std::string::npos) {
+            ESP_LOGE(TAG, "Failed to sent");
+            return ret::FAIL;
+        }
+    } else if (send_stat == 4) {
+        constexpr std::string_view head = "+QISEND: ";
+        if (response.find(head) != std::string::npos) {
+            // Parsing +QISEND: <total_send_length>,<ackedbytes>,<unackedbytes>
+            size_t head_pos = response.find(head);
+            response = response.substr(head_pos + head.size());
+            int pos, property = 0;
+            int total = 0, ack = 0, unack = 0;
+            while ((pos = response.find(',')) != std::string::npos) {
+                auto next_comma = (char *)memchr(response.data(), ',', response.size());
+
+                // extract value
+                size_t value;
+                if (std::from_chars(response.data(), next_comma, value).ec == std::errc::invalid_argument) {
+                    ESP_LOGE(TAG, "cannot convert");
+                    return ret::FAIL;
+                }
+
+                switch (property++) {
+                case 0: total = value;
+                    break;
+                case 1: ack = value;
+                    break;
+                default:
+                    return ret::FAIL;
+                }
+                response = response.substr(pos + 1);
+            }
+            if (std::from_chars(response.data(), response.data() + pos, unack).ec == std::errc::invalid_argument) {
+                return ret::FAIL;
+            }
+
+            if (ack < total) {
+                ESP_LOGD(TAG, "all sending data are not ack (missing %d bytes acked)", (total - ack));
+                if (total - ack > 64) {
+                    ESP_LOGW(TAG, "Need a pause: missing %d bytes acked", (total - ack));
+                    return ret::NEED_MORE_TIME;
+                }
+            }
+            send_stat = 0;
+            return ret::OK;
+        } else if (response.find("ERROR") != std::string::npos) {
+            ESP_LOGE(TAG, "Failed to check sending");
+            return ret::FAIL;
+        }
+
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::connect(std::string_view response)
+{
+    if (response.find("+QIOPEN: 0,0") != std::string::npos) {
+        ESP_LOGI(TAG, "Connected!");
+        return ret::OK;
+    }
+    if (response.find("ERROR") != std::string::npos) {
+        ESP_LOGE(TAG, "Failed to open");
+        return ret::FAIL;
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::check_async_replies(status state, std::string_view &response)
+{
+    ESP_LOGD(TAG, "response %.*s", static_cast<int>(response.size()), response.data());
+    if (response.find("+QIURC: \"recv\",0") != std::string::npos) {
+        uint64_t data_ready = 1;
+        write(data_ready_fd, &data_ready, sizeof(data_ready));
+        ESP_LOGD(TAG, "Got data on modem!");
+    } else if (response.find("+QIRD: ") != std::string::npos) {
+        static constexpr std::string_view head = "+QIRD: ";
+        size_t head_pos = response.find(head);
+        // Parsing +QIURC: <total_receive_length>,<have_read_length>,<unread_length>
+        response = response.substr(head_pos + head.size());
+        int next_cr = response.find('\r');
+        if (next_cr != std::string::npos) {
+            response = response.substr(next_cr - 2, next_cr);
+            if (response.find(",0") != std::string::npos) {
+                ESP_LOGV(TAG, "Receiving done");
+            } else {
+                uint64_t data_ready = 1;
+                write(data_ready_fd, &data_ready, sizeof(data_ready));
+                ESP_LOGD(TAG, "Got data on modem!");
+            }
+        }
+    } else if (response.find("+QIURC: \"closed\",0") != std::string::npos) {
+        return ret::FAIL;
+    }
+    if (state == status::SENDING) {
+        return send(response);
+    } else if (state == status::CONNECTING) {
+        return connect(response);
+    }
+    return ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::process_data(status state, uint8_t *data, size_t len)
+{
+    if (state == status::SENDING) {
+        return send(data, len);
+    }
+    if (state == status::RECEIVING) {
+        return recv(data, len);
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+status Responder::pending()
+{
+    send_cmd("AT+QISEND=0,0\r");
+    return status::SENDING;
+}
+
+
+} // sock_dce

components/esp_modem/examples/modem_tcp_client/main/sock_commands_sim7600.cpp

@@ -0,0 +1,378 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <charconv>
+#include <cstring>
+#include <sys/socket.h>
+#include "sock_commands.hpp"
+#include "cxx_include/esp_modem_command_library_utils.hpp"
+#include "sock_dce.hpp"
+
+static const char *TAG = "sock_commands";
+
+namespace sock_commands {
+
+using namespace esp_modem;
+
+command_result net_open(CommandableIf *term)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string response;
+    auto ret = dce_commands::generic_get_string(term, "AT+NETOPEN?\r", response, 1000);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    ESP_LOGV(TAG, "%s", response.data() );
+    if (response.find("+NETOPEN: 1") != std::string::npos) {
+        ESP_LOGD(TAG, "Already there");
+        ret = command_result::OK;
+    } else if (response.find("+NETOPEN: 0") != std::string::npos) {
+        ESP_LOGD(TAG, "Need to setup");
+        ret = dce_commands::generic_command(term, "AT+NETOPEN\r", "+NETOPEN: 1", "+NETOPEN: 0", 10000);
+    } else {
+        return command_result::FAIL;
+    }
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    return dce_commands::generic_command(term, "AT+CIPRXGET=1\r", "OK", "ERROR", 5000);
+}
+
+command_result net_close(CommandableIf *term)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return dce_commands::generic_command(term, "AT+NETCLOSE\r", "+NETCLOSE:", "ERROR", 30000);
+}
+
+command_result tcp_open(CommandableIf *term, const std::string &host, int port, int timeout)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    auto ret = dce_commands::generic_command(term, "AT+CIPRXGET=1\r", "OK", "ERROR", 50000);
+    if (ret != command_result::OK) {
+        ESP_LOGE(TAG, "Setting Rx mode failed!");
+        return ret;
+    }
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string ip_open = R"(AT+CIPOPEN=0,"TCP",")" + host + "\"," + std::to_string(port) + "\r";
+    ret = dce_commands::generic_command(term, ip_open, "+CIPOPEN: 0,0", "ERROR", timeout);
+    if (ret != command_result::OK) {
+        ESP_LOGE(TAG, "%s Failed", __func__ );
+        return ret;
+    }
+    return command_result::OK;
+}
+
+command_result tcp_close(CommandableIf *term)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    return dce_commands::generic_command(term, "AT+CIPCLOSE=0\r", "+CIPCLOSE:", "ERROR", 10000);
+}
+
+command_result tcp_send(CommandableIf *term, uint8_t *data, size_t len)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string send = "AT+CIPSEND=0," + std::to_string(len) + "\r";
+    auto ret = term->command(send, [&](uint8_t *data, size_t len) {
+        std::string_view response((char *)data, len);
+        ESP_LOGI(TAG, "CIPSEND response %.*s", static_cast<int>(response.size()), response.data());
+        if (response.find('>') != std::string::npos) {
+            return command_result::OK;
+        }
+        return command_result::TIMEOUT;
+    }, 50000, '>');
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    ret = command_result::TIMEOUT;
+    ESP_LOGW(TAG, "Before setting...");
+    term->on_read([&ret](uint8_t *cmd_data, size_t cmd_len) {
+        std::string_view response((char *)cmd_data, cmd_len);
+        ESP_LOGW(TAG, "CIPSEND response %.*s", static_cast<int>(response.size()), response.data());
+
+        if (response.find("+CIPSEND:") != std::string::npos) {
+            ret = command_result::OK;
+        } else if (response.find("ERROR") != std::string::npos) {
+            ret = command_result::FAIL;
+        }
+        return ret;
+    });
+    ESP_LOGW(TAG, "Before writing...");
+    auto written = term->write(data, len);
+    if (written != len) {
+        ESP_LOGE(TAG, "written %d (%d)...", written, len);
+        return command_result::FAIL;
+    }
+    uint8_t ctrl_z = '\x1A';
+    term->write(&ctrl_z, 1);
+    int count = 0;
+    while (ret == command_result::TIMEOUT && count++ < 1000 ) {
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+    term->on_read(nullptr);
+    return ret;
+}
+
+command_result tcp_recv(CommandableIf *term, uint8_t *data, size_t len, size_t &out_len)
+{
+    ESP_LOGV(TAG, "%s", __func__ );
+    std::string out;
+    auto ret = dce_commands::generic_get_string(term, "AT+CIPRXGET=4,0\r", out);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    constexpr std::string_view pattern = "+CIPRXGET: 4,0,";
+    if (out.find(pattern) == std::string::npos) {
+
+        return command_result::FAIL;
+    }
+    size_t data_len;
+    if (std::from_chars(out.data() + pattern.size(), out.data() + out.size(), data_len).ec == std::errc::invalid_argument) {
+        return command_result::FAIL;
+    }
+    ESP_LOGD(TAG, "size=%d", data_len);
+    if (data_len == 0) {
+        out_len = data_len;
+        return command_result::OK;
+    }
+    return term->command("AT+CIPRXGET=2,0,100\r", [&](uint8_t *cmd_data, size_t cmd_len) {
+        char pattern[] = "+CIPRXGET: 2,0,";
+        ESP_LOG_BUFFER_HEXDUMP(TAG, cmd_data, cmd_len, ESP_LOG_DEBUG);
+        char *pos = strstr((char *)cmd_data, pattern);
+        if (pos == nullptr) {
+            return command_result::FAIL;
+        }
+        auto p1 = memchr(pos + sizeof(pattern) - 1, ',', 4);
+        if (p1 == nullptr)  {
+            return command_result::FAIL;
+        }
+        *(char *)p1 = '\0';
+        size_t actual_len = atoi(pos + sizeof(pattern) - 1);
+        ESP_LOGD(TAG, "actual len=%d", actual_len);
+
+        pos = strchr((char *)p1 + 1, '\n');
+        if (pos == nullptr) {
+            ESP_LOGE(TAG, "not found");
+            return command_result::FAIL;
+        }
+        if (actual_len > len) {
+            ESP_LOGE(TAG, "TOO BIG");
+            return command_result::FAIL;
+        }
+        out_len = actual_len;
+        memcpy(data, pos + 1, actual_len);
+        pos = strstr((char *)pos + 1 + actual_len, "OK");
+        if (pos == nullptr) {
+            ESP_LOGE(TAG, "ok NOT FOUND");
+            return command_result::FAIL;
+        }
+        return command_result::OK;
+    }, 50000);
+}
+
+command_result get_ip(CommandableIf *term, std::string &ip)
+{
+    std::string resp;
+    auto ret = dce_commands::generic_get_string(term, "AT+IPADDR\r", resp, 5000);
+    if (ret != command_result::OK) {
+        return ret;
+    }
+    ip = resp;
+    return command_result::OK;
+}
+
+command_result set_rx_mode(CommandableIf *term, int mode)
+{
+    return dce_commands::generic_command(term, "AT+CIPRXGET=" + std::to_string(mode) + "\r", "OK", "ERROR", 5000);
+}
+
+} // sock_commands
+
+namespace sock_dce {
+
+void Responder::start_sending(size_t len)
+{
+    data_to_send = len;
+    send_stat = 0;
+    send_cmd("AT+CIPSEND=0," + std::to_string(len) + "\r");
+}
+
+void Responder::start_receiving(size_t len)
+{
+    send_cmd("AT+CIPRXGET=2,0," + std::to_string(len) + "\r");
+}
+
+bool Responder::start_connecting(std::string host, int port)
+{
+    send_cmd(R"(AT+CIPOPEN=0,"TCP",")" + host + "\"," + std::to_string(port) + "\r");
+    return true;
+}
+
+Responder::ret Responder::recv(uint8_t *data, size_t len)
+{
+    const int MIN_MESSAGE = 6;
+    size_t actual_len = 0;
+    auto *recv_data = (char *)data;
+    if (data_to_recv == 0) {
+        static constexpr std::string_view head = "+CIPRXGET: 2,0,";
+        auto head_pos = std::search(recv_data, recv_data + len, head.begin(), head.end());
+        if (head_pos == nullptr) {
+            return ret::FAIL;
+        }
+
+        if (head_pos - (char *)data > MIN_MESSAGE) {
+            // check for async replies before the Recv header
+            std::string_view response((char *)data, head_pos - (char *)data);
+            check_async_replies(status::RECEIVING, response);
+        }
+
+        auto next_comma = (char *)memchr(head_pos + head.size(), ',', MIN_MESSAGE);
+        if (next_comma == nullptr)  {
+            return ret::FAIL;
+        }
+        if (std::from_chars(head_pos + head.size(), next_comma, actual_len).ec == std::errc::invalid_argument) {
+            ESP_LOGE(TAG, "cannot convert");
+            return ret::FAIL;
+        }
+
+        auto next_nl = (char *)memchr(next_comma, '\n', 8 /* total_len size (~4) + markers */);
+        if (next_nl == nullptr) {
+            ESP_LOGE(TAG, "not found");
+            return ret::FAIL;
+        }
+        if (actual_len > buffer_size) {
+            ESP_LOGE(TAG, "TOO BIG");
+            return ret::FAIL;
+        }
+        size_t total_len = 0;
+        if (std::from_chars(next_comma + 1, next_nl - 1, total_len).ec == std::errc::invalid_argument) {
+            ESP_LOGE(TAG, "cannot convert");
+            return ret::FAIL;
+        }
+        read_again = (total_len > 0);
+        recv_data = next_nl + 1;
+        auto first_data_len = len - (recv_data - (char *)data) /* minus size of the command marker */;
+        if (actual_len > first_data_len) {
+            ::send(sock, recv_data, first_data_len, 0);
+            data_to_recv = actual_len - first_data_len;
+            return ret::NEED_MORE_DATA;
+        }
+        ::send(sock, recv_data, actual_len, 0);
+    } else if (data_to_recv > len) {    // continue sending
+        ::send(sock, recv_data, len, 0);
+        data_to_recv -= len;
+        return ret::NEED_MORE_DATA;
+    } else if (data_to_recv <= len) {    // last read -> looking for "OK" marker
+        ::send(sock, recv_data, data_to_recv, 0);
+        actual_len = data_to_recv;
+    }
+
+    // "OK" after the data
+    char *last_pos = nullptr;
+    if (actual_len + 1 + 2 /* OK */  > len) {
+        last_pos = (char *)memchr(recv_data + 1 + actual_len, 'O', MIN_MESSAGE);
+        if (last_pos == nullptr || last_pos[1] != 'K') {
+            data_to_recv = 0;
+            return ret::FAIL;
+        }
+    }
+    if (last_pos != nullptr && (char *)data + len - last_pos - 2 > MIN_MESSAGE) {
+        // check for async replies after the Recv header
+        std::string_view response((char *)last_pos + 2 /* OK */, (char *)data + len - last_pos - 2);
+        check_async_replies(status::RECEIVING, response);
+    }
+    data_to_recv = 0;
+    if (read_again) {
+        uint64_t data_ready = 1;
+        write(data_ready_fd, &data_ready, sizeof(data_ready));
+    }
+    return ret::OK;
+}
+
+Responder::ret Responder::send(uint8_t *data, size_t len)
+{
+    if (send_stat == 0) {
+        if (memchr(data, '>', len) == NULL) {
+            ESP_LOGE(TAG, "Missed >");
+            return ret::FAIL;
+        }
+        auto written = dte->write(&buffer[0], data_to_send);
+        if (written != data_to_send) {
+            ESP_LOGE(TAG, "written %d (%d)...", written, len);
+            return ret::FAIL;
+        }
+        data_to_send = 0;
+        uint8_t ctrl_z = '\x1A';
+        dte->write(&ctrl_z, 1);
+        send_stat++;
+        return ret::IN_PROGRESS;
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::send(std::string_view response)
+{
+    if (send_stat == 1) {
+        if (response.find("+CIPSEND:") != std::string::npos) {
+            send_stat = 0;
+            return ret::OK;
+        }
+        if (response.find("ERROR") != std::string::npos) {
+            ESP_LOGE(TAG, "Failed to sent");
+            send_stat = 0;
+            return ret::FAIL;
+        }
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::connect(std::string_view response)
+{
+    if (response.find("+CIPOPEN: 0,0") != std::string::npos) {
+        ESP_LOGI(TAG, "Connected!");
+        return ret::OK;
+    }
+    if (response.find("ERROR") != std::string::npos) {
+        ESP_LOGE(TAG, "Failed to open");
+        return ret::FAIL;
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+Responder::ret Responder::check_async_replies(status state, std::string_view &response)
+{
+    ESP_LOGD(TAG, "response %.*s", static_cast<int>(response.size()), response.data());
+    if (response.find("+CIPRXGET: 1") != std::string::npos) {
+        uint64_t data_ready = 1;
+        write(data_ready_fd, &data_ready, sizeof(data_ready));
+        ESP_LOGD(TAG, "Got data on modem!");
+    }
+    if (state == status::SENDING) {
+        return send(response);
+    } else if (state == status::CONNECTING) {
+        return connect(response);
+    }
+    return ret::IN_PROGRESS;
+
+}
+
+Responder::ret Responder::process_data(status state, uint8_t *data, size_t len)
+{
+    if (state == status::SENDING) {
+        return send(data, len);
+    }
+    if (state == status::RECEIVING) {
+        return recv(data, len);
+    }
+    return Responder::ret::IN_PROGRESS;
+}
+
+status Responder::pending()
+{
+    return status::PENDING;
+}
+
+
+} // sock_dce

components/esp_modem/examples/modem_tcp_client/main/sock_dce.cpp

@@ -0,0 +1,326 @@
+/*
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <charconv>
+#include <sys/socket.h>
+#include "esp_vfs.h"
+#include "esp_vfs_eventfd.h"
+
+#include "sock_dce.hpp"
+
+namespace sock_dce {
+
+constexpr auto const *TAG = "sock_dce";
+
+
+bool DCE::perform_sock()
+{
+    if (listen_sock == -1) {
+        ESP_LOGE(TAG, "Listening socket not ready");
+        close_sock();
+        return false;
+    }
+    if (sock == -1) {   // no active socket, need to accept one first
+        return accept_sock();
+    }
+
+    // we have a socket, let's check the status
+    struct timeval tv = {
+        .tv_sec = 0,
+        .tv_usec = 500000,
+    };
+    if (state == status::PENDING) {
+        vTaskDelay(pdMS_TO_TICKS(500));
+        state = at.pending();
+        return true;
+    }
+    fd_set fdset;
+    FD_ZERO(&fdset);
+    FD_SET(sock, &fdset);
+    FD_SET(data_ready_fd, &fdset);
+    int s = select(std::max(sock, data_ready_fd) + 1, &fdset, nullptr, nullptr, &tv);
+    if (s == 0) {
+        ESP_LOGV(TAG, "perform select timeout...");
+        return true;
+    } else if (s < 0) {
+        ESP_LOGE(TAG,  "select error %d", errno);
+        close_sock();
+        return false;
+    }
+    if (FD_ISSET(sock, &fdset) && !sock_to_at()) {
+        return false;
+    }
+    if (FD_ISSET(data_ready_fd, &fdset) && !at_to_sock()) {
+        return false;
+    }
+    return true;
+}
+
+void DCE::perform_at(uint8_t *data, size_t len)
+{
+    ESP_LOG_BUFFER_HEXDUMP(TAG, data, len, ESP_LOG_VERBOSE);
+    switch (at.process_data(state, data, len)) {
+    case Responder::ret::OK:
+        state = status::IDLE;
+        signal.set(IDLE);
+        return;
+    case Responder::ret::FAIL:
+        state = status::FAILED;
+        signal.set(IDLE);
+        return;
+    case Responder::ret::NEED_MORE_DATA:
+        return;
+    case Responder::ret::IN_PROGRESS:
+        break;
+    case Responder::ret::NEED_MORE_TIME:
+        state = status::PENDING;
+        return;
+    }
+    std::string_view response((char *)data, len);
+    switch (at.check_async_replies(state, response)) {
+    case Responder::ret::OK:
+        state = status::IDLE;
+        signal.set(IDLE);
+        return;
+    case Responder::ret::FAIL:
+        state = status::FAILED;
+        signal.set(IDLE);
+        return;
+    case Responder::ret::NEED_MORE_TIME:
+        state = status::PENDING;
+        return;
+    case Responder::ret::NEED_MORE_DATA:
+    case Responder::ret::IN_PROGRESS:
+        break;
+    }
+}
+
+void DCE::close_sock()
+{
+    if (sock > 0) {
+        close(sock);
+        sock = -1;
+    }
+    dte->on_read(nullptr);
+    const int retries = 5;
+    int i = 0;
+    while (net_close() != esp_modem::command_result::OK) {
+        if (i++ > retries) {
+            ESP_LOGE(TAG, "Failed to close network");
+            return;
+        }
+        esp_modem::Task::Delay(1000);
+    }
+}
+
+bool DCE::at_to_sock()
+{
+    uint64_t data;
+    read(data_ready_fd, &data, sizeof(data));
+    ESP_LOGD(TAG, "select read: modem data available %x", data);
+    if (!signal.wait(IDLE, 1000)) {
+        ESP_LOGE(TAG, "Failed to get idle");
+        close_sock();
+        return false;
+    }
+    if (state != status::IDLE) {
+        ESP_LOGE(TAG, "Unexpected state %d", state);
+        close_sock();
+        return false;
+    }
+    state = status::RECEIVING;
+    at.start_receiving(at.get_buf_len());
+    return true;
+}
+
+bool DCE::sock_to_at()
+{
+    ESP_LOGD(TAG,  "socket read: data available");
+    if (!signal.wait(IDLE, 1000)) {
+        ESP_LOGE(TAG,  "Failed to get idle");
+        close_sock();
+        return false;
+    }
+    if (state != status::IDLE) {
+        ESP_LOGE(TAG,  "Unexpected state %d", state);
+        close_sock();
+        return false;
+    }
+    state = status::SENDING;
+    int len = ::recv(sock, at.get_buf(), at.get_buf_len(), 0);
+    if (len < 0) {
+        ESP_LOGE(TAG,  "read error %d", errno);
+        close_sock();
+        return false;
+    } else if (len == 0) {
+        ESP_LOGE(TAG,  "EOF %d", errno);
+        close_sock();
+        return false;
+    }
+    ESP_LOG_BUFFER_HEXDUMP(TAG, at.get_buf(), len, ESP_LOG_VERBOSE);
+    at.start_sending(len);
+    return true;
+}
+
+bool DCE::accept_sock()
+{
+    struct timeval tv = {
+        .tv_sec = 0,
+        .tv_usec = 500000,
+    };
+    fd_set fdset;
+    FD_ZERO(&fdset);
+    FD_SET(listen_sock, &fdset);
+    int s = select(listen_sock + 1, &fdset, nullptr, nullptr, &tv);
+    if (s > 0 && FD_ISSET(listen_sock, &fdset)) {
+        struct sockaddr_in source_addr = {};
+        socklen_t addr_len = sizeof(source_addr);
+        sock = accept(listen_sock, (struct sockaddr *)&source_addr, &addr_len);
+        if (sock < 0) {
+            ESP_LOGE(TAG, "Unable to accept connection: errno %d", errno);
+            return false;
+        }
+        ESP_LOGD(TAG, "Socket accepted!");
+        FD_ZERO(&fdset);
+        return true;
+    } else if (s == 0) {
+        return true;
+    }
+    return false;
+}
+
+void DCE::init_sock(int port)
+{
+    esp_vfs_eventfd_config_t config = ESP_VFS_EVENTD_CONFIG_DEFAULT();
+    esp_vfs_eventfd_register(&config);
+
+    data_ready_fd = eventfd(0, EFD_SUPPORT_ISR);
+    assert(data_ready_fd > 0);
+
+    listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+    if (listen_sock < 0) {
+        ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
+        return;
+    }
+    int opt = 1;
+    setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+    ESP_LOGI(TAG, "Socket created");
+    struct sockaddr_in addr = { };
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+//    inet_aton("127.0.0.1", &addr.sin_addr);
+
+    int err = bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr));
+    if (err != 0) {
+        ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno);
+        return;
+    }
+    ESP_LOGI(TAG, "Socket bound, port %d", 1883);
+    err = listen(listen_sock, 1);
+    if (err != 0) {
+        ESP_LOGE(TAG, "Error occurred during listen: errno %d", errno);
+        return;
+    }
+
+}
+
+bool DCE::start(std::string host, int port)
+{
+    dte->on_read(nullptr);
+    tcp_close();
+    dte->on_read([this](uint8_t *data, size_t len) {
+        this->perform_at(data, len);
+        return esp_modem::command_result::TIMEOUT;
+    });
+    if (!at.start_connecting(host, port)) {
+        ESP_LOGE(TAG, "Unable to start connecting");
+        dte->on_read(nullptr);
+        return false;
+    }
+    state = status::CONNECTING;
+    return true;
+}
+
+bool DCE::init_network()
+{
+    dte->on_read(nullptr);
+    const int retries = 5;
+    int i = 0;
+    while (sync() != esp_modem::command_result::OK) {
+        if (i++ > retries) {
+            ESP_LOGE(TAG, "Failed to sync up");
+            return false;
+        }
+        esp_modem::Task::Delay(1000);
+    }
+    ESP_LOGD(TAG, "Modem in sync");
+    i = 0;
+    while (setup_data_mode() != true) {
+        if (i++ > retries) {
+            ESP_LOGE(TAG, "Failed to setup pdp/data");
+            return false;
+        }
+        esp_modem::Task::Delay(1000);
+    }
+    ESP_LOGD(TAG, "PDP configured");
+    i = 0;
+    while (net_open() != esp_modem::command_result::OK) {
+        if (i++ > retries) {
+            ESP_LOGE(TAG, "Failed to open network");
+            return false;
+        }
+        net_close();
+        esp_modem::Task::Delay(1000);
+    }
+    ESP_LOGD(TAG, "Network opened");
+    i = 0;
+    std::string ip_addr;
+    while (get_ip(ip_addr) != esp_modem::command_result::OK) {
+        if (i++ > retries) {
+            ESP_LOGE(TAG, "Failed obtain an IP address");
+            return false;
+        }
+        esp_modem::Task::Delay(5000);
+    }
+    ESP_LOGI(TAG, "Got IP %s", ip_addr.c_str());
+    return true;
+}
+
+
+class Factory: public ::esp_modem::dce_factory::Factory {
+public:
+    static std::unique_ptr<DCE> create(const esp_modem::dce_config *config, std::shared_ptr<esp_modem::DTE> dte)
+    {
+        return esp_modem::dce_factory::Factory::build_module_T<DCE, std::unique_ptr<DCE>>(config, std::move(dte));
+    }
+};
+
+std::unique_ptr<DCE> create(const esp_modem::dce_config *config, std::shared_ptr<esp_modem::DTE> dte)
+{
+    return Factory::create(config, std::move(dte));
+}
+
+// Helper macros to handle multiple arguments of declared API
+#define ARGS0
+#define ARGS1 , p1
+#define ARGS2 , p1 , p2
+#define ARGS3 , p1 , p2 , p3
+
+#define EXPAND_ARGS(x)  ARGS ## x
+#define ARGS(x)  EXPAND_ARGS(x)
+
+//
+// Repeat all declarations and forward to the AT commands defined in ::sock_commands namespace
+//
+#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, arg_nr, ...) \
+     esp_modem::return_type DCE::name(__VA_ARGS__) { return sock_commands::name(dte.get() ARGS(arg_nr) ); }
+
+DECLARE_SOCK_COMMANDS(return_type name(...) )
+
+#undef ESP_MODEM_DECLARE_DCE_COMMAND
+
+} // namespace sock_dce

components/esp_modem/examples/modem_tcp_client/main/sock_dce.hpp

@@ -0,0 +1,108 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "esp_modem_config.h"
+#include "cxx_include/esp_modem_api.hpp"
+#include <cxx_include/esp_modem_dce_factory.hpp>
+#include "socket_commands.inc"
+#include "sock_commands.hpp"
+
+#pragma  once
+
+namespace sock_dce {
+
+
+enum class status {
+    IDLE,
+    CONNECTING,
+    SENDING,
+    RECEIVING,
+    FAILED,
+    PENDING
+};
+
+class Responder {
+public:
+    enum class ret {
+        OK, FAIL, IN_PROGRESS, NEED_MORE_DATA, NEED_MORE_TIME
+    };
+    Responder(int &s, int &ready_fd, std::shared_ptr<esp_modem::DTE> &dte_arg):
+        sock(s), data_ready_fd(ready_fd), dte(dte_arg) {}
+    ret process_data(status state, uint8_t *data, size_t len);
+    ret check_async_replies(status state, std::string_view &response);
+
+    void start_sending(size_t len);
+    void start_receiving(size_t len);
+    bool start_connecting(std::string host, int port);
+    status pending();
+    uint8_t *get_buf()
+    {
+        return &buffer[0];
+    }
+    size_t get_buf_len()
+    {
+        return buffer_size;
+    }
+private:
+    static constexpr size_t buffer_size = 512;
+
+    ret recv(uint8_t *data, size_t len);
+    ret send(uint8_t *data, size_t len);
+    ret send(std::string_view response);
+    ret connect(std::string_view response);
+    void send_cmd(std::string_view command)
+    {
+        dte->write((uint8_t *) command.begin(), command.size());
+    }
+    std::array<uint8_t, buffer_size> buffer;
+    size_t data_to_recv = 0;
+    bool read_again = false;
+    int &sock;
+    int &data_ready_fd;
+    int send_stat = 0;
+    size_t data_to_send = 0;
+    std::shared_ptr<esp_modem::DTE> &dte;
+};
+
+class DCE : public ::esp_modem::GenericModule {
+    using esp_modem::GenericModule::GenericModule;
+public:
+
+#define ESP_MODEM_DECLARE_DCE_COMMAND(name, return_type, num, ...) \
+esp_modem::return_type name(__VA_ARGS__);
+
+    DECLARE_SOCK_COMMANDS(declare name(Commandable *p, ...);)
+
+#undef ESP_MODEM_DECLARE_DCE_COMMAND
+
+    bool init_network();
+    bool start(std::string host, int port);
+
+    void init_sock(int port);
+
+    bool perform_sock();
+
+private:
+    esp_modem::SignalGroup signal;
+
+    void close_sock();
+    bool accept_sock();
+    bool sock_to_at();
+    bool at_to_sock();
+
+    void perform_at(uint8_t *data, size_t len);
+
+    status state{status::IDLE};
+    static constexpr uint8_t IDLE = 1;
+    Responder at{sock, data_ready_fd, dte};
+    int sock {-1};
+    int listen_sock {-1};
+    int data_ready_fd {-1};
+};
+
+std::unique_ptr<DCE> create(const esp_modem::dce_config *config, std::shared_ptr<esp_modem::DTE> dte);
+
+}

components/esp_modem/examples/modem_tcp_client/main/socket_commands.inc

@@ -0,0 +1,58 @@
+// Copyright 2021-2022 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#include "generate/esp_modem_command_declare_helper.inc"
+
+#define DECLARE_SOCK_COMMANDS(...) \
+/**
+ * @brief Opens network in AT command mode
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(net_open, command_result, 0) \
+    \
+/**
+ * @brief Closes network in AT command mode
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(net_close, command_result, 0) \
+    \
+/**
+ * @brief Opens a TCP connection
+ * @param[in] host Host name or IP address to connect to
+ * @param[in] port Port number
+ * @param[in] timeout Connection timeout
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(tcp_open, command_result, 3, STRING_IN(p1, host), INT_IN(p2, port), INT_IN(p3, timeout)) \
+    \
+/**
+ * @brief Closes opened TCP socket
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(tcp_close, command_result, 0) \
+    \
+/**
+ * @brief Gets modem IP address
+ * @param[out] addr String representation of modem's IP
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(get_ip, command_result, 1, STRING_OUT(p1, addr)) \
+    \
+/**
+ * @brief Sets Rx mode
+ * @param[in] mode 0=auto, 1=manual
+ * @return OK, FAIL or TIMEOUT
+ */ \
+ESP_MODEM_DECLARE_DCE_COMMAND(set_rx_mode, command_result, 1, INT_IN(p1, mode))

components/esp_modem/examples/pppos_client/main/Kconfig.projbuild

@@ -15,12 +15,12 @@ menu "Example Configuration"
     endchoice
 
     choice EXAMPLE_MODEM_DEVICE
-        depends on EXAMPLE_SERIAL_CONFIG_UART
         prompt "Choose supported modem device (DCE)"
         default EXAMPLE_MODEM_DEVICE_BG96
         help
             Select modem device connected to the ESP DTE.
         config EXAMPLE_MODEM_DEVICE_SIM800
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SIM800"
             help
                 SIMCom SIM800L is a GSM/GPRS module.
@@ -30,10 +30,12 @@ menu "Example Configuration"
             help
                 Quectel BG96 is a series of LTE Cat M1/Cat NB1/EGPRS module.
         config EXAMPLE_MODEM_DEVICE_SIM7000
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SIM7000"
             help
                 SIM7000 is a Multi-Band LTE-FDD and GSM/GPRS/EDGE module.
         config EXAMPLE_MODEM_DEVICE_SIM7070
+            depends on EXAMPLE_SERIAL_CONFIG_UART
             bool "SIM7070"
             help
                 SIM7070 is Multi-Band CAT M and NB IoT module.
@@ -41,6 +43,11 @@ menu "Example Configuration"
             bool "SIM7600"
             help
                 SIM7600 is a Multi-Band LTE-TDD/LTE-FDD/HSPA+ and GSM/GPRS/EDGE module.
+        config EXAMPLE_MODEM_DEVICE_A7670
+            depends on EXAMPLE_SERIAL_CONFIG_USB
+            bool "A7670"
+            help
+                A7670X is Multi-Band LTE-FDD/LTE-TDD/GSM/GPRS/EDGE module.
     endchoice
 
     config EXAMPLE_MODEM_PPP_APN
@@ -184,4 +191,22 @@ menu "Example Configuration"
 
     endmenu
 
+    config EXAMPLE_MQTT_BROKER_URI
+        string "MQTT Broker URL"
+        default "mqtt://mqtt.eclipseprojects.io"
+        help
+            URL of the mqtt broker which this example connects to.
+
+    config EXAMPLE_MQTT_TEST_TOPIC
+        string "MQTT topic to publish/subscribe"
+        default "/topic/esp-pppos"
+        help
+            MQTT topic, which we subscribe on and publish to.
+
+    config EXAMPLE_MQTT_TEST_DATA
+        string "MQTT data to publish/receive"
+        default "esp32-pppos"
+        help
+            MQTT data message, which we publish and expect to receive.
+
 endmenu

components/esp_modem/examples/pppos_client/main/idf_component.yml

@@ -3,10 +3,10 @@ dependencies:
   ## Required IDF version
   idf: ">=4.1.0"
   espressif/esp_modem:
-    version: "^0.1.23"
+    version: "^1.0.0"
     override_path: "../../../"
   espressif/esp_modem_usb_dte:
-    version: "^1.0.0"
+    version: "^1.1.0"
     rules:
       - if: "idf_version >=4.4"
       - if: "target in [esp32s2, esp32s3]"

components/esp_modem/examples/pppos_client/main/pppos_client_main.c

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -30,7 +30,6 @@
 #define EXAMPLE_FLOW_CONTROL ESP_MODEM_FLOW_CONTROL_HW
 #endif
 
-#define BROKER_URL "mqtt://mqtt.eclipseprojects.io"
 
 static const char *TAG = "pppos_example";
 static EventGroupHandle_t event_group = NULL;
@@ -68,7 +67,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
     switch ((esp_mqtt_event_id_t)event_id) {
     case MQTT_EVENT_CONNECTED:
         ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
-        msg_id = esp_mqtt_client_subscribe(client, "/topic/esp-pppos", 0);
+        msg_id = esp_mqtt_client_subscribe(client, CONFIG_EXAMPLE_MQTT_TEST_TOPIC, 0);
         ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
         break;
     case MQTT_EVENT_DISCONNECTED:
@@ -76,7 +75,7 @@ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_
         break;
     case MQTT_EVENT_SUBSCRIBED:
         ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
-        msg_id = esp_mqtt_client_publish(client, "/topic/esp-pppos", "esp32-pppos", 0, 0, 0);
+        msg_id = esp_mqtt_client_publish(client, CONFIG_EXAMPLE_MQTT_TEST_TOPIC, CONFIG_EXAMPLE_MQTT_TEST_DATA, 0, 0, 0);
         ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
         break;
     case MQTT_EVENT_UNSUBSCRIBED:
@@ -209,14 +208,28 @@ void app_main(void)
 
 #elif defined(CONFIG_EXAMPLE_SERIAL_CONFIG_USB)
     while (1) {
+#if CONFIG_EXAMPLE_MODEM_DEVICE_BG96 == 1
         ESP_LOGI(TAG, "Initializing esp_modem for the BG96 module...");
-        struct esp_modem_usb_term_config usb_config = ESP_MODEM_DEFAULT_USB_CONFIG(0x2C7C, 0x0296, 2); // VID, PID and interface num of BG96 modem
+        struct esp_modem_usb_term_config usb_config = ESP_MODEM_BG96_USB_CONFIG();
+        esp_modem_dce_device_t usb_dev_type = ESP_MODEM_DCE_BG96;
+#elif CONFIG_EXAMPLE_MODEM_DEVICE_SIM7600 == 1
+        ESP_LOGI(TAG, "Initializing esp_modem for the SIM7600 module...");
+        struct esp_modem_usb_term_config usb_config = ESP_MODEM_SIM7600_USB_CONFIG();
+        esp_modem_dce_device_t usb_dev_type = ESP_MODEM_DCE_SIM7600;
+#elif CONFIG_EXAMPLE_MODEM_DEVICE_A7670 == 1
+        ESP_LOGI(TAG, "Initializing esp_modem for the A7670 module...");
+        struct esp_modem_usb_term_config usb_config = ESP_MODEM_A7670_USB_CONFIG();
+        esp_modem_dce_device_t usb_dev_type = ESP_MODEM_DCE_SIM7600;
+#else
+#error USB modem not selected
+#endif
         const esp_modem_dte_config_t dte_usb_config = ESP_MODEM_DTE_DEFAULT_USB_CONFIG(usb_config);
         ESP_LOGI(TAG, "Waiting for USB device connection...");
-        esp_modem_dce_t *dce = esp_modem_new_dev_usb(ESP_MODEM_DCE_BG96, &dte_usb_config, &dce_config, esp_netif);
+        esp_modem_dce_t *dce = esp_modem_new_dev_usb(usb_dev_type, &dte_usb_config, &dce_config, esp_netif);
         assert(dce);
         esp_modem_set_error_cb(dce, usb_terminal_error_handler);
-        vTaskDelay(pdMS_TO_TICKS(1000)); // Although the DTE should be ready after USB enumeration, sometimes it fails to respond without this delay
+        ESP_LOGI(TAG, "Modem connected, waiting 10 seconds for boot...");
+        vTaskDelay(pdMS_TO_TICKS(10000)); // Give DTE some time to boot
 
 #else
 #error Invalid serial connection to modem.
@@ -271,11 +284,11 @@ void app_main(void)
     /* Config MQTT */
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
     esp_mqtt_client_config_t mqtt_config = {
-        .broker.address.uri = BROKER_URL,
+        .broker.address.uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
     };
 #else
     esp_mqtt_client_config_t mqtt_config = {
-        .uri = BROKER_URL,
+        .uri = CONFIG_EXAMPLE_MQTT_BROKER_URI,
     };
 #endif
     esp_mqtt_client_handle_t mqtt_client = esp_mqtt_client_init(&mqtt_config);

components/esp_modem/examples/pppos_client/pytest_pppos_client.py

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+from __future__ import print_function, unicode_literals
+
+
+def test_pppos_connect(dut):
+    """
+    steps:
+      1. initializes connection with SIM800
+      2. checks we get an IP
+      3. checks for the MQTT events
+      4. checks that the client cleanly disconnects
+    """
+    # Check the sequence of connecting, publishing, disconnecting
+    dut.expect('Modem Connect to PPP Server')
+    # Check for MQTT connection and the data event
+    dut.expect('MQTT_EVENT_CONNECTED')
+    dut.expect('MQTT_EVENT_DATA')
+    dut.expect('TOPIC=/ci/esp-modem/pppos-client')
+    dut.expect('DATA=esp32-pppos')
+    # Check that we have disconnected
+    dut.expect('User interrupted event')
+    # And can use commands again
+    dut.expect('IMSI=[0-9]+')

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

@@ -0,0 +1,15 @@
+CONFIG_IDF_TARGET="esp32c3"
+# Override some defaults to enable PPP
+CONFIG_LWIP_PPP_SUPPORT=y
+CONFIG_LWIP_PPP_NOTIFY_PHASE_SUPPORT=y
+CONFIG_LWIP_PPP_PAP_SUPPORT=y
+CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=4096
+CONFIG_LWIP_PPP_ENABLE_IPV6=n
+CONFIG_EXAMPLE_MODEM_UART_TX_PIN=4
+CONFIG_EXAMPLE_MODEM_UART_RX_PIN=5
+CONFIG_EXAMPLE_MODEM_DEVICE_SIM800=y
+CONFIG_EXAMPLE_MODEM_DEVICE_BG96=n
+CONFIG_EXAMPLE_MODEM_PPP_APN="lpwa.vodafone.com"
+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/examples/pppos_client/sdkconfig.ci.usb_s2

@@ -0,0 +1,2 @@
+CONFIG_IDF_TARGET="esp32s2"
+CONFIG_EXAMPLE_SERIAL_CONFIG_USB=y

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

@@ -0,0 +1,2 @@
+CONFIG_IDF_TARGET="esp32s3"
+CONFIG_EXAMPLE_SERIAL_CONFIG_USB=y

components/esp_modem/examples/simple_cmux_client/CMakeLists.txt

@@ -1,8 +1,9 @@
 # The following lines of boilerplate have to be in your project's CMakeLists
 # in this exact order for cmake to work correctly
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.8)
+set(CMAKE_CXX_STANDARD 17)
 
-set(EXTRA_COMPONENT_DIRS "../.." $ENV{IDF_PATH}/examples/cxx/experimental/experimental_cpp_component)
+set(EXTRA_COMPONENT_DIRS "../..")
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(simple_cmux_client)

components/esp_modem/examples/simple_cmux_client/main/simple_cmux_client_main.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -17,10 +17,10 @@
 #include "freertos/event_groups.h"
 #include "esp_netif.h"
 #include "esp_log.h"
+#include "esp_event.h"
 #include "cxx_include/esp_modem_dte.hpp"
 #include "esp_modem_config.h"
 #include "cxx_include/esp_modem_api.hpp"
-#include "esp_event_cxx.hpp"
 #include "simple_mqtt_client.hpp"
 #include "esp_vfs_dev.h"        // For optional VFS support
 #include "esp_https_ota.h"      // For potential OTA configuration
@@ -39,16 +39,87 @@
 
 
 using namespace esp_modem;
-using namespace idf::event;
-
 
 static const char *TAG = "cmux_example";
 
+class StatusHandler {
+public:
+    static constexpr auto IP_Event      = SignalGroup::bit0;
+    static constexpr auto MQTT_Connect  = SignalGroup::bit1;
+    static constexpr auto MQTT_Data     = SignalGroup::bit2;
+
+    StatusHandler()
+    {
+        ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_event, this));
+    }
+
+    ~StatusHandler()
+    {
+        esp_event_handler_unregister(IP_EVENT, ESP_EVENT_ANY_ID, on_event);
+    }
+
+    void handle_mqtt(MqttClient *client)
+    {
+        mqtt_client = client;
+        client->register_handler(ESP_EVENT_ANY_ID, on_event, this);
+    }
+
+    esp_err_t wait_for(decltype(IP_Event) event, int milliseconds)
+    {
+        return signal.wait_any(event, milliseconds);
+    }
+
+    ip_event_t get_ip_event_type()
+    {
+        return ip_event_type;
+    }
+
+private:
+    static void on_event(void *arg, esp_event_base_t base, int32_t event, void *data)
+    {
+        auto *handler = static_cast<StatusHandler *>(arg);
+        if (base == IP_EVENT) {
+            handler->ip_event(event, data);
+        } else {
+            handler->mqtt_event(event, data);
+        }
+    }
+
+    void ip_event(int32_t id, void *data)
+    {
+        if (id == IP_EVENT_PPP_GOT_IP) {
+            auto *event = (ip_event_got_ip_t *)data;
+            ESP_LOGI(TAG, "IP          : " IPSTR, IP2STR(&event->ip_info.ip));
+            ESP_LOGI(TAG, "Netmask     : " IPSTR, IP2STR(&event->ip_info.netmask));
+            ESP_LOGI(TAG, "Gateway     : " IPSTR, IP2STR(&event->ip_info.gw));
+            signal.set(IP_Event);
+        } else if (id == IP_EVENT_PPP_LOST_IP) {
+            signal.set(IP_Event);
+        }
+        ip_event_type = static_cast<ip_event_t>(id);
+    }
+
+    void mqtt_event(int32_t event, void *data)
+    {
+        if (mqtt_client && event == mqtt_client->get_event(MqttClient::Event::CONNECT)) {
+            signal.set(MQTT_Connect);
+        } else if (mqtt_client && event == mqtt_client->get_event(MqttClient::Event::DATA)) {
+            ESP_LOGI(TAG, " TOPIC: %s", mqtt_client->get_topic(data).c_str());
+            ESP_LOGI(TAG, " DATA: %s", mqtt_client->get_data(data).c_str());
+            signal.set(MQTT_Data);
+        }
+    }
+
+    esp_modem::SignalGroup signal{};
+    MqttClient *mqtt_client{nullptr};
+    ip_event_t ip_event_type;
+};
+
 
 extern "C" void app_main(void)
 {
     /* Init and register system/core components */
-    auto loop = std::make_shared<ESPEventLoop>();
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
     ESP_ERROR_CHECK(esp_netif_init());
 
     /* Configure and create the DTE */
@@ -145,45 +216,32 @@ extern "C" void app_main(void)
 #endif
 
     /* Try to connect to the network and publish an mqtt topic */
-    ESPEventHandlerSync event_handler(loop);
-    event_handler.listen_to(ESPEvent(IP_EVENT, ESPEventID(ESP_EVENT_ANY_ID)));
-    auto result = event_handler.wait_event_for(std::chrono::milliseconds(60000));
-    if (result.timeout) {
+    StatusHandler handler;
+    if (!handler.wait_for(StatusHandler::IP_Event, 60000)) {
         ESP_LOGE(TAG, "Cannot get IP within specified timeout... exiting");
         return;
-    } else if (result.event.id == ESPEventID(IP_EVENT_PPP_GOT_IP)) {
-        auto *event = (ip_event_got_ip_t *)result.ev_data;
-        ESP_LOGI(TAG, "IP          : " IPSTR, IP2STR(&event->ip_info.ip));
-        ESP_LOGI(TAG, "Netmask     : " IPSTR, IP2STR(&event->ip_info.netmask));
-        ESP_LOGI(TAG, "Gateway     : " IPSTR, IP2STR(&event->ip_info.gw));
+    } else if (handler.get_ip_event_type() == IP_EVENT_PPP_GOT_IP) {
         std::cout << "Got IP address" << std::endl;
 
         /* When connected to network, subscribe and publish some MQTT data */
         MqttClient mqtt(BROKER_URL);
-        event_handler.listen_to(MqttClient::get_event(MqttClient::Event::CONNECT));
-        event_handler.listen_to(MqttClient::get_event(MqttClient::Event::DATA));
-
-        auto reg = loop->register_event(MqttClient::get_event(MqttClient::Event::DATA),
-        [&mqtt](const ESPEvent & event, void *data) {
-            std::cout << " TOPIC:" << mqtt.get_topic(data) << std::endl;
-            std::cout << " DATA:" << mqtt.get_data(data) << std::endl;
-        });
+        handler.handle_mqtt(&mqtt);
         mqtt.connect();
-        while (true) {
-            result = event_handler.wait_event_for(std::chrono::milliseconds(60000));
-            if (result.event == MqttClient::get_event(MqttClient::Event::CONNECT)) {
-                mqtt.subscribe("/topic/esp-modem");
-                mqtt.publish("/topic/esp-modem", "Hello modem");
-                continue;
-            } else if (result.event == MqttClient::get_event(MqttClient::Event::DATA)) {
-                std::cout << "Data received" << std::endl;
-                break; /* Continue with CMUX example after getting data from MQTT */
-            } else {
-                break;
-            }
+        if (!handler.wait_for(StatusHandler::MQTT_Connect, 60000)) {
+            ESP_LOGE(TAG, "Cannot connect to %s within specified timeout... exiting", BROKER_URL);
+            return;
         }
+        std::cout << "Connected" << std::endl;
 
-    } else if (result.event.id == ESPEventID(IP_EVENT_PPP_LOST_IP)) {
+        mqtt.subscribe("/topic/esp-modem");
+        mqtt.publish("/topic/esp-modem", "Hello modem");
+        if (!handler.wait_for(StatusHandler::MQTT_Data, 60000)) {
+            ESP_LOGE(TAG, "Didn't receive published data within specified timeout... exiting");
+            return;
+        }
+        std::cout << "Received MQTT data" << std::endl;
+
+    } else if (handler.get_ip_event_type() == IP_EVENT_PPP_LOST_IP) {
         ESP_LOGE(TAG, "PPP client has lost connection... exiting");
         return;
     }

components/esp_modem/examples/simple_cmux_client/main/simple_mqtt_client.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -10,11 +10,8 @@
 
 #include <memory>
 #include "mqtt_client.h"
-#include "esp_event_cxx.hpp"
 #include "simple_mqtt_client.hpp"
 
-using namespace idf::event;
-
 /**
  * Reference to the MQTT event base
  */
@@ -33,7 +30,6 @@ struct MqttClientHandle {
         config.uri = uri.c_str();
 #endif
         client = esp_mqtt_client_init(&config);
-        esp_mqtt_client_register_event(client, MQTT_EVENT_ANY, mqtt_event_handler, this);
     }
 
     ~MqttClientHandle()
@@ -41,12 +37,6 @@ struct MqttClientHandle {
         esp_mqtt_client_destroy(client);
     }
 
-    static void mqtt_event_handler(void *args, esp_event_base_t base, int32_t id, void *data)
-    {
-        // forwards the internal event to the global ESPEvent
-        esp_event_post(base, id, data, sizeof(esp_mqtt_event_t), portMAX_DELAY);
-    }
-
     esp_mqtt_client_handle_t client;
 };
 
@@ -62,16 +52,16 @@ void MqttClient::connect()
     esp_mqtt_client_start(h->client);
 }
 
-idf::event::ESPEvent MqttClient::get_event(MqttClient::Event ev)
+int32_t MqttClient::get_event(MqttClient::Event ev)
 {
     switch (ev) {
     case Event::CONNECT: {
-        return { MQTT_EVENTS, ESPEventID(MQTT_EVENT_CONNECTED) };
+        return MQTT_EVENT_CONNECTED;
     }
     case Event::DATA:
-        return { MQTT_EVENTS, ESPEventID(MQTT_EVENT_DATA) };
+        return MQTT_EVENT_DATA;
     }
-    return { };
+    return -1;
 }
 
 int MqttClient::publish(const std::string &topic, const std::string &data, int qos)
@@ -102,4 +92,9 @@ std::string MqttClient::get_data(void *event_data)
     return std::string(event->data, event->data_len);
 }
 
+void MqttClient::register_handler(int32_t event_id, esp_event_handler_t event_handler, void *arg)
+{
+    ESP_ERROR_CHECK(esp_mqtt_client_register_event(h->client, MQTT_EVENT_ANY, event_handler, arg));
+}
+
 MqttClient::~MqttClient() = default;

components/esp_modem/examples/simple_cmux_client/main/simple_mqtt_client.hpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
@@ -11,7 +11,6 @@
 
 #include <string>
 #include <memory>
-#include "esp_event_cxx.hpp"
 
 struct MqttClientHandle;
 
@@ -62,12 +61,20 @@ public:
      */
     std::string get_data(void *);
 
+    /**
+     * @brief Register MQTT event
+     * @param id Event id
+     * @param event_handler Event handler
+     * @param event_handler_arg Event handler parameters
+     */
+    void register_handler(int32_t id, esp_event_handler_t event_handler, void *event_handler_arg);
+
     /**
      * @brief Convert internal MQTT event to standard ESPEvent
      * @param ev internal mqtt event
-     * @return corresponding ESPEvent
+     * @return corresponding esp_event id
      */
-    static idf::event::ESPEvent get_event(Event ev);
+    static int32_t get_event(Event ev);
 
 private:
     std::unique_ptr<MqttClientHandle> h;

components/esp_modem/idf_component.yml

@@ -1,4 +1,4 @@
-version: "0.1.25"
+version: "1.0.0"
 description: esp modem
 url: https://github.com/espressif/esp-protocols/tree/master/components/esp_modem
 dependencies:

components/esp_modem/include/cxx_include/esp_modem_command_library.hpp

@@ -22,6 +22,19 @@ namespace dce_commands {
  * @{
  */
 
+/**
+ * @brief Generic AT command to be send with pass and fail phrases
+ *
+ * @param t Commandable object (anything that can accept commands)
+ * @param command Command to be sent do the commandable object
+ * @param pass_phrase String to be present in the reply to pass this command
+ * @param fail_phrase String to be present in the reply to fail this command
+ * @param timeout_ms Timeout in ms
+ */
+command_result generic_command(CommandableIf *t, const std::string &command,
+                               const std::string &pass_phrase,
+                               const std::string &fail_phrase, uint32_t timeout_ms);
+
 /**
  * @brief Declaration of all commands is generated from esp_modem_command_declare.inc
  */

components/esp_modem/include/cxx_include/esp_modem_dce_factory.hpp

@@ -69,6 +69,10 @@ public:
         ESP_MODEM_THROW_IF_FALSE(netif != nullptr, "Null netif");
     }
 
+    explicit Creator(std::shared_ptr<DTE> dte): dte(std::move(dte)), device(nullptr), netif(nullptr)
+    {
+    }
+
     ~Creator()
     {
         if (device != nullptr) {

components/esp_modem/include/cxx_include/esp_modem_dte.hpp

@@ -29,6 +29,13 @@ class CMux;
 * @{
 */
 
+struct DTE_Command {
+    DTE_Command(const std::string &cmd): data((uint8_t *)cmd.c_str()), len(cmd.length()) {}
+
+    uint8_t *data;
+    size_t len;
+};
+
 /**
  * DTE (Data Terminal Equipment) class
  */
@@ -39,9 +46,12 @@ public:
      * @brief Creates a DTE instance from the terminal
      * @param config DTE config structure
      * @param t unique-ptr to Terminal
+     * @param s unique-ptr to secondary Terminal
      */
     explicit DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> t);
     explicit DTE(std::unique_ptr<Terminal> t);
+    explicit DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> t, std::unique_ptr<Terminal> s);
+    explicit DTE(std::unique_ptr<Terminal> t, std::unique_ptr<Terminal> s);
 
     ~DTE() = default;
 
@@ -51,7 +61,9 @@ public:
      * @param len Data len to write
      * @return number of bytes written
      */
-    int write(uint8_t *data, size_t len);
+    int write(uint8_t *data, size_t len) override;
+
+    int write(DTE_Command command);
 
     /**
      * @brief Reading from the underlying terminal
@@ -67,6 +79,8 @@ public:
      */
     void set_read_cb(std::function<bool(uint8_t *data, size_t len)> f);
 
+    void on_read(got_line_cb on_data) override;
+
     /**
      * @brief Sets DTE error callback
      * @param f Function to be called on DTE error
@@ -116,8 +130,8 @@ private:
     Lock internal_lock{};                                   /*!< Locks DTE operations */
     unique_buffer buffer;                                   /*!< DTE buffer */
     std::shared_ptr<CMux> cmux_term;                        /*!< Primary terminal for this DTE */
-    std::shared_ptr<Terminal> command_term;                 /*!< Reference to the terminal used for sending commands */
-    std::shared_ptr<Terminal> data_term;                    /*!< Secondary terminal for this DTE */
+    std::shared_ptr<Terminal> primary_term;                 /*!< Reference to the primary terminal (mostly for sending commands) */
+    std::shared_ptr<Terminal> secondary_term;               /*!< Secondary terminal for this DTE */
     modem_mode mode;                                        /*!< DTE operation mode */
     SignalGroup signal;                                     /*!< Event group used to signal request-response operations */
     command_result result;                                  /*!< Command result of the currently exectuted command */

components/esp_modem/include/cxx_include/esp_modem_types.hpp

@@ -27,10 +27,16 @@ namespace esp_modem {
  */
 enum class modem_mode {
     UNDEF,
-    COMMAND_MODE, /*!< Command mode -- the modem is supposed to send AT commands in this mode  */
+    COMMAND_MODE, /*!< Command mode -- the modem is supposed to send AT commands in this mode */
     DATA_MODE,    /*!< Data mode -- the modem communicates with network interface on PPP protocol */
-    CMUX_MODE     /*!< CMUX (Multiplex mode) -- Simplified CMUX mode, which creates two virtual terminals,
+    DUAL_MODE,    /*!< Dual mode -- the modem has two real terminals. Data and commands work at the same time */
+    CMUX_MODE,    /*!< CMUX (Multiplex mode) -- Simplified CMUX mode, which creates two virtual terminals,
                    *  assigning one solely to command interface and the other  to the data mode */
+    CMUX_MANUAL_MODE,    /*!< Enter CMUX mode manually -- just creates two virtual terminals */
+    CMUX_MANUAL_EXIT,    /*!< Exits CMUX mode manually -- just destroys two virtual terminals */
+    CMUX_MANUAL_DATA,    /*!< Sets the primary terminal to DATA mode in manual CMUX */
+    CMUX_MANUAL_COMMAND, /*!< Sets the primary terminal to COMMAND mode in manual CMUX */
+    CMUX_MANUAL_SWAP,    /*!< Swaps virtual terminals in manual CMUX mode (primary <-> secondary) */
 };
 
 /**
@@ -74,6 +80,9 @@ public:
      */
     virtual command_result command(const std::string &command, got_line_cb got_line, uint32_t time_ms, const char separator) = 0;
     virtual command_result command(const std::string &command, got_line_cb got_line, uint32_t time_ms) = 0;
+
+    virtual int write(uint8_t *data, size_t len) = 0;
+    virtual void on_read(got_line_cb on_data) = 0;
 };
 
 /**

components/esp_modem/include/esp_modem_c_api_types.h

@@ -36,6 +36,11 @@ typedef enum esp_modem_dce_mode {
     ESP_MODEM_MODE_COMMAND,  /**< Default mode after modem startup, used for sending AT commands */
     ESP_MODEM_MODE_DATA,     /**< Used for switching to PPP mode for the modem to connect to a network */
     ESP_MODEM_MODE_CMUX,     /**< Multiplexed terminal mode */
+    ESP_MODEM_MODE_CMUX_MANUAL,         /**< CMUX manual mode */
+    ESP_MODEM_MODE_CMUX_MANUAL_EXIT,    /**< Exit CMUX manual mode */
+    ESP_MODEM_MODE_CMUX_MANUAL_SWAP,    /**< Swap terminals in CMUX manual mode */
+    ESP_MODEM_MODE_CMUX_MANUAL_DATA,    /**< Set DATA mode in CMUX manual mode */
+    ESP_MODEM_MODE_CMUX_MANUAL_COMMAND, /**< Set COMMAND mode in CMUX manual mode */
 } esp_modem_dce_mode_t;
 
 /**
@@ -113,6 +118,8 @@ esp_err_t esp_modem_set_error_cb(esp_modem_dce_t *dce, esp_modem_terminal_error_
  */
 esp_err_t esp_modem_set_mode(esp_modem_dce_t *dce, esp_modem_dce_mode_t mode);
 
+esp_err_t esp_modem_command(esp_modem_dce_t *dce, const char *command, esp_err_t(*got_line_cb)(uint8_t *data, size_t len), uint32_t timeout_ms);
+
 /**
  * @}
  */

components/esp_modem/include/esp_modem_config.h

@@ -84,6 +84,11 @@ struct esp_modem_dte_config {
     };
 };
 
+#if ESP_IDF_VERSION_MAJOR >= 5
+#define ESP_MODEM_DEFAULT_UART_CLK      UART_SCLK_DEFAULT
+#else
+#define ESP_MODEM_DEFAULT_UART_CLK      UART_SCLK_APB
+#endif
 
 /**
  * @brief ESP Modem DTE Default Configuration
@@ -92,15 +97,15 @@ struct esp_modem_dte_config {
 #define ESP_MODEM_DTE_DEFAULT_CONFIG() \
     {                                  \
         .dte_buffer_size = 512,        \
-        .task_stack_size = 4096, \
-        .task_priority = 5,      \
+        .task_stack_size = 4096,       \
+        .task_priority = 5,            \
         .uart_config = {               \
             .port_num = UART_NUM_1,                 \
             .data_bits = UART_DATA_8_BITS,          \
             .stop_bits = UART_STOP_BITS_1,          \
             .parity = UART_PARITY_DISABLE,          \
             .flow_control = ESP_MODEM_FLOW_CONTROL_NONE,\
-            .source_clk = UART_SCLK_APB,            \
+            .source_clk = ESP_MODEM_DEFAULT_UART_CLK,   \
             .baud_rate = 115200,                    \
             .tx_io_num = 25,                        \
             .rx_io_num = 26,                        \

components/esp_modem/include/generate/esp_modem_command_declare.inc

@@ -1,4 +1,4 @@
-// Copyright 2021 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2021-2022 Espressif Systems (Shanghai) PTE LTD
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,36 +11,11 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+#pragma once
 
-#ifndef _ESP_MODEM_COMMAND_DECLARE_INC_
-#define _ESP_MODEM_COMMAND_DECLARE_INC_
+#include "esp_modem_command_declare_helper.inc"
 
 
-// Parameters
-// * handle different parameters for C++ and C API
-// * make parameter unique names, so they could be easily referenced and forwarded
-#define _ARG(param, name) param
-#define INT_IN(param, name) int  _ARG(param, name)
-#ifdef __cplusplus
-#include <string>
-#define STRING_IN(param, name) const std::string& _ARG(param, name)
-#define STRING_OUT(param, name) std::string& _ARG(param, name)
-#define BOOL_IN(param, name) const bool  _ARG(param, name)
-#define BOOL_OUT(param, name) bool&  _ARG(param, name)
-#define INT_OUT(param, name) int&  _ARG(param, name)
-#define INTEGER_LIST_IN(param, name) const int* _ARG(param, name)
-
-#define STRUCT_OUT(struct_name, p1)  struct_name& p1
-#else
-#define STRING_IN(param, name) const char* _ARG(param, name)
-#define STRING_OUT(param, name) char* _ARG(param, name)
-#define BOOL_IN(param, name) const bool _ARG(param, name)
-#define BOOL_OUT(param, name) bool* _ARG(param, name)
-#define INT_OUT(param, name) int* _ARG(param, name)
-#define INTEGER_LIST_IN(param, name) const int* _ARG(param, name)
-#define STRUCT_OUT(struct_name, p1)  esp_modem_ ## struct_name ## _t* p1
-#endif
-
 #define DECLARE_ALL_COMMAND_APIS(...) \
 /**
  * @brief Sends the initial AT sequence to sync up with the device
@@ -331,5 +306,3 @@ public:
 #endif
 
 #endif
-
-#endif // _ESP_MODEM_COMMAND_DECLARE_INC_

components/esp_modem/include/generate/esp_modem_command_declare_helper.inc

@@ -0,0 +1,26 @@
+
+
+// Parameters
+// * handle different parameters for C++ and C API
+// * make parameter unique names, so they could be easily referenced and forwarded
+#define _ARG(param, name) param
+#define INT_IN(param, name) int  _ARG(param, name)
+#ifdef __cplusplus
+#include <string>
+#define STRING_IN(param, name) const std::string& _ARG(param, name)
+#define STRING_OUT(param, name) std::string& _ARG(param, name)
+#define BOOL_IN(param, name) const bool  _ARG(param, name)
+#define BOOL_OUT(param, name) bool&  _ARG(param, name)
+#define INT_OUT(param, name) int&  _ARG(param, name)
+#define INTEGER_LIST_IN(param, name) const int* _ARG(param, name)
+
+#define STRUCT_OUT(struct_name, p1)  struct_name& p1
+#else
+#define STRING_IN(param, name) const char* _ARG(param, name)
+#define STRING_OUT(param, name) char* _ARG(param, name)
+#define BOOL_IN(param, name) const bool _ARG(param, name)
+#define BOOL_OUT(param, name) bool* _ARG(param, name)
+#define INT_OUT(param, name) int* _ARG(param, name)
+#define INTEGER_LIST_IN(param, name) const int* _ARG(param, name)
+#define STRUCT_OUT(struct_name, p1)  esp_modem_ ## struct_name ## _t* p1
+#endif

components/esp_modem/src/esp_modem_c_api.cpp

@@ -1,393 +1,425 @@
-/*
- * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include <cassert>
-#include "cxx_include/esp_modem_dte.hpp"
-#include "uart_terminal.hpp"
-#include "esp_log.h"
-#include "cxx_include/esp_modem_api.hpp"
-#include "cxx_include/esp_modem_dce_factory.hpp"
-#include "esp_modem_c_api_types.h"
-#include "esp_modem_config.h"
-#include "exception_stub.hpp"
-#include "esp_private/c_api_wrapper.hpp"
-#include "cstring"
-
-#ifndef ESP_MODEM_C_API_STR_MAX
-#define ESP_MODEM_C_API_STR_MAX 64
-#endif
-
-#ifndef HAVE_STRLCPY
-size_t strlcpy(char *dest, const char *src, size_t len);
-#endif
-
-//
-// C API definitions
-using namespace esp_modem;
-
-extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
-{
-    auto dce_wrap = new (std::nothrow) esp_modem_dce_wrap;
-    if (dce_wrap == nullptr) {
-        return nullptr;
-    }
-    auto dte = create_uart_dte(dte_config);
-    if (dte == nullptr) {
-        delete dce_wrap;
-        return nullptr;
-    }
-    dce_wrap->dte = dte;
-    dce_factory::Factory f(convert_modem_enum(module));
-    dce_wrap->dce = f.build(dce_config, std::move(dte), netif);
-    if (dce_wrap->dce == nullptr) {
-        delete dce_wrap;
-        return nullptr;
-    }
-    dce_wrap->modem_type = convert_modem_enum(module);
-    dce_wrap->dte_type = esp_modem_dce_wrap::modem_wrap_dte_type::UART;
-    return dce_wrap;
-}
-
-extern "C" esp_modem_dce_t *esp_modem_new(const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
-{
-    return esp_modem_new_dev(ESP_MODEM_DCE_GENETIC, dte_config, dce_config, netif);
-}
-
-extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
-{
-    if (dce_wrap) {
-        delete dce_wrap->dce;
-        delete dce_wrap;
-    }
-}
-
-extern "C" esp_err_t esp_modem_set_error_cb(esp_modem_dce_t *dce_wrap, esp_modem_terminal_error_cbt err_cb)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || dce_wrap->dte == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    if (err_cb) {
-        dce_wrap->dte->set_error_cb([err_cb](terminal_error err) {
-            err_cb(convert_terminal_error_enum(err));
-        });
-    } else {
-        dce_wrap->dte->set_error_cb(nullptr);
-    }
-    return ESP_OK;
-}
-
-extern "C" esp_err_t esp_modem_sync(esp_modem_dce_t *dce_wrap)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->sync());
-}
-
-extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t *dce_wrap, esp_modem_dce_mode_t mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    if (mode == ESP_MODEM_MODE_DATA) {
-        return dce_wrap->dce->set_mode(modem_mode::DATA_MODE) ? ESP_OK : ESP_FAIL;
-    }
-    if (mode == ESP_MODEM_MODE_COMMAND) {
-        return dce_wrap->dce->set_mode(modem_mode::COMMAND_MODE) ? ESP_OK : ESP_FAIL;
-    }
-    if (mode == ESP_MODEM_MODE_CMUX) {
-        return dce_wrap->dce->set_mode(modem_mode::CMUX_MODE) ? ESP_OK : ESP_FAIL;
-    }
-    return ESP_ERR_NOT_SUPPORTED;
-}
-
-extern "C" esp_err_t esp_modem_read_pin(esp_modem_dce_t *dce_wrap, bool *pin)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    return command_response_to_esp_err(dce_wrap->dce->read_pin(*pin));
-}
-
-extern "C" esp_err_t esp_modem_sms_txt_mode(esp_modem_dce_t *dce_wrap, bool txt)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    return command_response_to_esp_err(dce_wrap->dce->sms_txt_mode(txt));
-}
-
-extern "C" esp_err_t esp_modem_send_sms(esp_modem_dce_t *dce_wrap, const char *number, const char *message)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string number_str(number);
-    std::string message_str(message);
-    return command_response_to_esp_err(dce_wrap->dce->send_sms(number_str, message_str));
-}
-
-extern "C" esp_err_t esp_modem_sms_character_set(esp_modem_dce_t *dce_wrap)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    return command_response_to_esp_err(dce_wrap->dce->sms_character_set());
-}
-
-extern "C" esp_err_t esp_modem_set_pin(esp_modem_dce_t *dce_wrap, const char *pin)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string pin_str(pin);
-    return command_response_to_esp_err(dce_wrap->dce->set_pin(pin_str));
-}
-
-extern "C" esp_err_t esp_modem_at(esp_modem_dce_t *dce_wrap, const char *at, char *p_out, int timeout)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string out;
-    std::string at_str(at);
-    auto ret = command_response_to_esp_err(dce_wrap->dce->at(at_str, out, timeout));
-    if ((p_out != NULL) && (!out.empty())) {
-        strlcpy(p_out, out.c_str(), ESP_MODEM_C_API_STR_MAX);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_signal_quality(esp_modem_dce_t *dce_wrap, int *rssi, int *ber)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->get_signal_quality(*rssi, *ber));
-}
-
-extern "C" esp_err_t esp_modem_get_imsi(esp_modem_dce_t *dce_wrap, char *p_imsi)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string imsi;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_imsi(imsi));
-    if (ret == ESP_OK && !imsi.empty()) {
-        strlcpy(p_imsi, imsi.c_str(), ESP_MODEM_C_API_STR_MAX);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_flow_control(esp_modem_dce_t *dce_wrap, int dce_flow, int dte_flow)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_flow_control(dce_flow, dte_flow));
-}
-
-extern "C" esp_err_t esp_modem_store_profile(esp_modem_dce_t *dce_wrap)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->store_profile());
-}
-
-extern "C" esp_err_t esp_modem_get_imei(esp_modem_dce_t *dce_wrap, char *p_imei)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string imei;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_imei(imei));
-    if (ret == ESP_OK && !imei.empty()) {
-        strlcpy(p_imei, imei.c_str(), ESP_MODEM_C_API_STR_MAX);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_operator_name(esp_modem_dce_t *dce_wrap, char *p_name, int *p_act)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_name == nullptr || p_act == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string name;
-    int act;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_operator_name(name, act));
-    if (ret == ESP_OK && !name.empty()) {
-        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
-        *p_act = act;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_module_name(esp_modem_dce_t *dce_wrap, char *p_name)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string name;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_module_name(name));
-    if (ret == ESP_OK && !name.empty()) {
-        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_get_battery_status(esp_modem_dce_t *dce_wrap, int *p_volt, int *p_bcs, int *p_bcl)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_bcs == nullptr || p_bcl == nullptr || p_volt == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int bcs, bcl, volt;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_battery_status(volt, bcs, bcl));
-    if (ret == ESP_OK) {
-        *p_volt = volt;
-        *p_bcs = bcs;
-        *p_bcl = bcl;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_power_down(esp_modem_dce_t *dce_wrap)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->power_down());
-}
-
-extern "C" esp_err_t esp_modem_set_operator(esp_modem_dce_t *dce_wrap, int mode, int format, const char *oper)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string operator_str(oper);
-    return command_response_to_esp_err(dce_wrap->dce->set_operator(mode, format, operator_str));
-}
-
-extern "C" esp_err_t esp_modem_set_network_attachment_state(esp_modem_dce_t *dce_wrap, int state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_network_attachment_state(state));
-}
-
-extern "C" esp_err_t esp_modem_get_network_attachment_state(esp_modem_dce_t *dce_wrap, int *p_state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int state;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_attachment_state(state));
-    if (ret == ESP_OK) {
-        *p_state = state;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_radio_state(esp_modem_dce_t *dce_wrap, int state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_radio_state(state));
-}
-
-extern "C" esp_err_t esp_modem_get_radio_state(esp_modem_dce_t *dce_wrap, int *p_state)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int state;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_radio_state(state));
-    if (ret == ESP_OK) {
-        *p_state = state;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_network_mode(esp_modem_dce_t *dce_wrap, int mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_network_mode(mode));
-}
-
-extern "C" esp_err_t esp_modem_set_preferred_mode(esp_modem_dce_t *dce_wrap, int mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_preferred_mode(mode));
-}
-
-extern "C" esp_err_t esp_modem_set_network_bands(esp_modem_dce_t *dce_wrap, const char *mode, const int *bands, int size)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    std::string mode_str(mode);
-    return command_response_to_esp_err(dce_wrap->dce->set_network_bands(mode, bands, size));
-}
-
-extern "C" esp_err_t esp_modem_get_network_system_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int mode;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_system_mode(mode));
-    if (ret == ESP_OK) {
-        *p_mode = mode;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_set_gnss_power_mode(esp_modem_dce_t *dce_wrap, int mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    return command_response_to_esp_err(dce_wrap->dce->set_gnss_power_mode(mode));
-}
-
-extern "C" esp_err_t esp_modem_get_gnss_power_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    int mode;
-    auto ret = command_response_to_esp_err(dce_wrap->dce->get_gnss_power_mode(mode));
-    if (ret == ESP_OK) {
-        *p_mode = mode;
-    }
-    return ret;
-}
-
-extern "C" esp_err_t esp_modem_reset(esp_modem_dce_t *dce_wrap)
-{
-    return command_response_to_esp_err(dce_wrap->dce->reset());
-}
-
-extern "C" esp_err_t esp_modem_set_pdp_context(esp_modem_dce_t *dce_wrap, esp_modem_PdpContext_t *c_api_pdp)
-{
-    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
-        return ESP_ERR_INVALID_ARG;
-    }
-    esp_modem::PdpContext pdp{c_api_pdp->apn};
-    pdp.context_id = c_api_pdp->context_id;
-    pdp.protocol_type = c_api_pdp->protocol_type;
-    return command_response_to_esp_err(dce_wrap->dce->set_pdp_context(pdp));
-}
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <cassert>
+#include "cxx_include/esp_modem_dte.hpp"
+#include "uart_terminal.hpp"
+#include "esp_log.h"
+#include "cxx_include/esp_modem_api.hpp"
+#include "cxx_include/esp_modem_dce_factory.hpp"
+#include "esp_modem_c_api_types.h"
+#include "esp_modem_config.h"
+#include "exception_stub.hpp"
+#include "esp_private/c_api_wrapper.hpp"
+#include "cstring"
+
+#ifndef ESP_MODEM_C_API_STR_MAX
+#define ESP_MODEM_C_API_STR_MAX 64
+#endif
+
+#ifndef HAVE_STRLCPY
+size_t strlcpy(char *dest, const char *src, size_t len);
+#endif
+
+//
+// C API definitions
+using namespace esp_modem;
+
+extern "C" esp_modem_dce_t *esp_modem_new_dev(esp_modem_dce_device_t module, const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
+{
+    auto dce_wrap = new (std::nothrow) esp_modem_dce_wrap;
+    if (dce_wrap == nullptr) {
+        return nullptr;
+    }
+    auto dte = create_uart_dte(dte_config);
+    if (dte == nullptr) {
+        delete dce_wrap;
+        return nullptr;
+    }
+    dce_wrap->dte = dte;
+    dce_factory::Factory f(convert_modem_enum(module));
+    dce_wrap->dce = f.build(dce_config, std::move(dte), netif);
+    if (dce_wrap->dce == nullptr) {
+        delete dce_wrap;
+        return nullptr;
+    }
+    dce_wrap->modem_type = convert_modem_enum(module);
+    dce_wrap->dte_type = esp_modem_dce_wrap::modem_wrap_dte_type::UART;
+    return dce_wrap;
+}
+
+extern "C" esp_modem_dce_t *esp_modem_new(const esp_modem_dte_config_t *dte_config, const esp_modem_dce_config_t *dce_config, esp_netif_t *netif)
+{
+    return esp_modem_new_dev(ESP_MODEM_DCE_GENETIC, dte_config, dce_config, netif);
+}
+
+extern "C" void esp_modem_destroy(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap) {
+        delete dce_wrap->dce;
+        delete dce_wrap;
+    }
+}
+
+extern "C" esp_err_t esp_modem_set_error_cb(esp_modem_dce_t *dce_wrap, esp_modem_terminal_error_cbt err_cb)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || dce_wrap->dte == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (err_cb) {
+        dce_wrap->dte->set_error_cb([err_cb](terminal_error err) {
+            err_cb(convert_terminal_error_enum(err));
+        });
+    } else {
+        dce_wrap->dte->set_error_cb(nullptr);
+    }
+    return ESP_OK;
+}
+
+extern "C" esp_err_t esp_modem_sync(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->sync());
+}
+
+extern "C" esp_err_t esp_modem_set_mode(esp_modem_dce_t *dce_wrap, esp_modem_dce_mode_t mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    switch (mode) {
+    case ESP_MODEM_MODE_DATA:
+        return dce_wrap->dce->set_mode(modem_mode::DATA_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_COMMAND:
+        return dce_wrap->dce->set_mode(modem_mode::COMMAND_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_MODE) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_EXIT:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_EXIT) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_SWAP:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_SWAP) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_DATA:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_DATA) ? ESP_OK : ESP_FAIL;
+    case ESP_MODEM_MODE_CMUX_MANUAL_COMMAND:
+        return dce_wrap->dce->set_mode(modem_mode::CMUX_MANUAL_COMMAND) ? ESP_OK : ESP_FAIL;
+    }
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+extern "C" esp_err_t esp_modem_read_pin(esp_modem_dce_t *dce_wrap, bool *pin)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->read_pin(*pin));
+}
+
+extern "C" esp_err_t esp_modem_sms_txt_mode(esp_modem_dce_t *dce_wrap, bool txt)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->sms_txt_mode(txt));
+}
+
+extern "C" esp_err_t esp_modem_send_sms(esp_modem_dce_t *dce_wrap, const char *number, const char *message)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string number_str(number);
+    std::string message_str(message);
+    return command_response_to_esp_err(dce_wrap->dce->send_sms(number_str, message_str));
+}
+
+extern "C" esp_err_t esp_modem_sms_character_set(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    return command_response_to_esp_err(dce_wrap->dce->sms_character_set());
+}
+
+extern "C" esp_err_t esp_modem_set_pin(esp_modem_dce_t *dce_wrap, const char *pin)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string pin_str(pin);
+    return command_response_to_esp_err(dce_wrap->dce->set_pin(pin_str));
+}
+
+extern "C" esp_err_t esp_modem_at(esp_modem_dce_t *dce_wrap, const char *at, char *p_out, int timeout)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string out;
+    std::string at_str(at);
+    auto ret = command_response_to_esp_err(dce_wrap->dce->at(at_str, out, timeout));
+    if ((p_out != NULL) && (!out.empty())) {
+        strlcpy(p_out, out.c_str(), ESP_MODEM_C_API_STR_MAX);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_signal_quality(esp_modem_dce_t *dce_wrap, int *rssi, int *ber)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->get_signal_quality(*rssi, *ber));
+}
+
+extern "C" esp_err_t esp_modem_get_imsi(esp_modem_dce_t *dce_wrap, char *p_imsi)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string imsi;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_imsi(imsi));
+    if (ret == ESP_OK && !imsi.empty()) {
+        strlcpy(p_imsi, imsi.c_str(), ESP_MODEM_C_API_STR_MAX);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_flow_control(esp_modem_dce_t *dce_wrap, int dce_flow, int dte_flow)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_flow_control(dce_flow, dte_flow));
+}
+
+extern "C" esp_err_t esp_modem_store_profile(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->store_profile());
+}
+
+extern "C" esp_err_t esp_modem_get_imei(esp_modem_dce_t *dce_wrap, char *p_imei)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string imei;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_imei(imei));
+    if (ret == ESP_OK && !imei.empty()) {
+        strlcpy(p_imei, imei.c_str(), ESP_MODEM_C_API_STR_MAX);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_operator_name(esp_modem_dce_t *dce_wrap, char *p_name, int *p_act)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_name == nullptr || p_act == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string name;
+    int act;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_operator_name(name, act));
+    if (ret == ESP_OK && !name.empty()) {
+        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
+        *p_act = act;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_module_name(esp_modem_dce_t *dce_wrap, char *p_name)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string name;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_module_name(name));
+    if (ret == ESP_OK && !name.empty()) {
+        strlcpy(p_name, name.c_str(), ESP_MODEM_C_API_STR_MAX);
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_get_battery_status(esp_modem_dce_t *dce_wrap, int *p_volt, int *p_bcs, int *p_bcl)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || p_bcs == nullptr || p_bcl == nullptr || p_volt == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int bcs, bcl, volt;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_battery_status(volt, bcs, bcl));
+    if (ret == ESP_OK) {
+        *p_volt = volt;
+        *p_bcs = bcs;
+        *p_bcl = bcl;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_power_down(esp_modem_dce_t *dce_wrap)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->power_down());
+}
+
+extern "C" esp_err_t esp_modem_set_operator(esp_modem_dce_t *dce_wrap, int mode, int format, const char *oper)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string operator_str(oper);
+    return command_response_to_esp_err(dce_wrap->dce->set_operator(mode, format, operator_str));
+}
+
+extern "C" esp_err_t esp_modem_set_network_attachment_state(esp_modem_dce_t *dce_wrap, int state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_network_attachment_state(state));
+}
+
+extern "C" esp_err_t esp_modem_get_network_attachment_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_attachment_state(state));
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_radio_state(esp_modem_dce_t *dce_wrap, int state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_radio_state(state));
+}
+
+extern "C" esp_err_t esp_modem_get_radio_state(esp_modem_dce_t *dce_wrap, int *p_state)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int state;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_radio_state(state));
+    if (ret == ESP_OK) {
+        *p_state = state;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_network_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_network_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_set_preferred_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_preferred_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_set_network_bands(esp_modem_dce_t *dce_wrap, const char *mode, const int *bands, int size)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string mode_str(mode);
+    return command_response_to_esp_err(dce_wrap->dce->set_network_bands(mode, bands, size));
+}
+
+extern "C" esp_err_t esp_modem_get_network_system_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int mode;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_network_system_mode(mode));
+    if (ret == ESP_OK) {
+        *p_mode = mode;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_set_gnss_power_mode(esp_modem_dce_t *dce_wrap, int mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    return command_response_to_esp_err(dce_wrap->dce->set_gnss_power_mode(mode));
+}
+
+extern "C" esp_err_t esp_modem_get_gnss_power_mode(esp_modem_dce_t *dce_wrap, int *p_mode)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    int mode;
+    auto ret = command_response_to_esp_err(dce_wrap->dce->get_gnss_power_mode(mode));
+    if (ret == ESP_OK) {
+        *p_mode = mode;
+    }
+    return ret;
+}
+
+extern "C" esp_err_t esp_modem_reset(esp_modem_dce_t *dce_wrap)
+{
+    return command_response_to_esp_err(dce_wrap->dce->reset());
+}
+
+extern "C" esp_err_t esp_modem_set_pdp_context(esp_modem_dce_t *dce_wrap, esp_modem_PdpContext_t *c_api_pdp)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    esp_modem::PdpContext pdp{c_api_pdp->apn};
+    pdp.context_id = c_api_pdp->context_id;
+    pdp.protocol_type = c_api_pdp->protocol_type;
+    return command_response_to_esp_err(dce_wrap->dce->set_pdp_context(pdp));
+}
+
+extern "C" esp_err_t esp_modem_command(esp_modem_dce_t *dce_wrap, const char *command, esp_err_t(*got_line_fn)(uint8_t *data, size_t len), uint32_t timeout_ms)
+{
+    if (dce_wrap == nullptr || dce_wrap->dce == nullptr || command == nullptr || got_line_fn == nullptr) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    std::string cmd(command);
+    return command_response_to_esp_err(dce_wrap->dce->command(cmd, [got_line_fn](uint8_t *data, size_t len) {
+        switch (got_line_fn(data, len)) {
+        case ESP_OK:
+            return command_result::OK;
+        case ESP_FAIL:
+            return command_result::FAIL;
+        default:
+            return command_result::TIMEOUT;
+        }
+    }, timeout_ms));
+}
+
+extern "C" esp_err_t esp_modem_set_baud(esp_modem_dce_t *dce_wrap, int baud)
+{
+    return command_response_to_esp_err(dce_wrap->dce->set_baud(baud));
+}

components/esp_modem/src/esp_modem_command_library.cpp

@@ -218,7 +218,7 @@ 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__ );
-    return generic_command_common(t, "AT+IFC=" + std::to_string(dce_flow) + ", " + std::to_string(dte_flow) + "\r");
+    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)

components/esp_modem/src/esp_modem_dce.cpp

@@ -14,6 +14,59 @@
 
 namespace esp_modem {
 
+namespace transitions {
+
+static bool exit_data(DTE &dte, ModuleIf &device, Netif &netif)
+{
+    netif.stop();
+    auto signal = std::make_shared<SignalGroup>();
+    std::weak_ptr<SignalGroup> weak_signal = signal;
+    dte.set_read_cb([weak_signal](uint8_t *data, size_t len) -> bool {
+        if (memchr(data, '\n', len))
+        {
+            ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, len, ESP_LOG_DEBUG);
+            const auto pass = std::list<std::string_view>({"NO CARRIER", "DISCONNECTED"});
+            std::string_view response((char *) data, len);
+            for (auto &it : pass)
+                if (response.find(it) != std::string::npos) {
+                    if (auto signal = weak_signal.lock()) {
+                        signal->set(1);
+                    }
+                    return true;
+                }
+        }
+        return false;
+    });
+    netif.wait_until_ppp_exits();
+    if (!signal->wait(1, 2000)) {
+        if (!device.set_mode(modem_mode::COMMAND_MODE)) {
+            return false;
+        }
+    }
+    dte.set_read_cb(nullptr);
+    if (!dte.set_mode(modem_mode::COMMAND_MODE)) {
+        return false;
+    }
+    return true;
+}
+
+static bool enter_data(DTE &dte, ModuleIf &device, Netif &netif)
+{
+    if (!device.setup_data_mode()) {
+        return false;
+    }
+    if (!device.set_mode(modem_mode::DATA_MODE)) {
+        return false;
+    }
+    if (!dte.set_mode(modem_mode::DATA_MODE)) {
+        return false;
+    }
+    netif.start();
+    return true;
+}
+
+} // namespace transitions
+
 /**
  * Set mode while the entire DTE is locked
 */
@@ -35,9 +88,10 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
 {
     switch (m) {
     case modem_mode::UNDEF:
+    case modem_mode::DUAL_MODE: // Only DTE can be in Dual mode
         break;
-    case modem_mode::COMMAND_MODE: {
-        if (mode == modem_mode::COMMAND_MODE) {
+    case modem_mode::COMMAND_MODE:
+        if (mode == modem_mode::COMMAND_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
             return false;
         }
         if (mode == modem_mode::CMUX_MODE) {
@@ -49,59 +103,23 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
             mode = m;
             return true;
         }
-        netif.stop();
-        auto signal = std::make_shared<SignalGroup>();
-        std::weak_ptr<SignalGroup> weak_signal = signal;
-        dte->set_read_cb([weak_signal](uint8_t *data, size_t len) -> bool {
-            if (memchr(data, '\n', len))
-            {
-                ESP_LOG_BUFFER_HEXDUMP("esp-modem: debug_data", data, len, ESP_LOG_DEBUG);
-                const auto pass = std::list<std::string_view>({"NO CARRIER", "DISCONNECTED"});
-                std::string_view response((char *) data, len);
-                for (auto &it : pass)
-                    if (response.find(it) != std::string::npos) {
-                        if (auto signal = weak_signal.lock()) {
-                            signal->set(1);
-                        }
-                        return true;
-                    }
-            }
-            return false;
-        });
-        netif.wait_until_ppp_exits();
-        if (!signal->wait(1, 2000)) {
-            if (!device->set_mode(modem_mode::COMMAND_MODE)) {
-                mode = modem_mode::UNDEF;
-                return false;
-            }
-        }
-        dte->set_read_cb(nullptr);
-        if (!dte->set_mode(modem_mode::COMMAND_MODE)) {
+        if (!transitions::exit_data(*dte, *device, netif)) {
             mode = modem_mode::UNDEF;
             return false;
         }
         mode = m;
         return true;
-    }
-    break;
     case modem_mode::DATA_MODE:
-        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE) {
+        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
             return false;
         }
-        if (!device->setup_data_mode()) {
+        if (!transitions::enter_data(*dte, *device, netif)) {
             return false;
         }
-        if (!device->set_mode(modem_mode::DATA_MODE)) {
-            return false;
-        }
-        if (!dte->set_mode(modem_mode::DATA_MODE)) {
-            return false;
-        }
-        netif.start();
         mode = m;
         return true;
     case modem_mode::CMUX_MODE:
-        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE) {
+        if (mode == modem_mode::DATA_MODE || mode == modem_mode::CMUX_MODE || mode >= modem_mode::CMUX_MANUAL_MODE) {
             return false;
         }
         device->set_mode(modem_mode::CMUX_MODE);    // switch the device into CMUX mode
@@ -111,17 +129,46 @@ bool DCE_Mode::set_unsafe(DTE *dte, ModuleIf *device, Netif &netif, modem_mode m
             return false;
         }
         mode = modem_mode::CMUX_MODE;
-        if (!device->setup_data_mode()) {
+        return transitions::enter_data(*dte, *device, netif);
+    case modem_mode::CMUX_MANUAL_MODE:
+        if (mode != modem_mode::COMMAND_MODE && mode != modem_mode::UNDEF) {
             return false;
         }
-        if (!device->set_mode(modem_mode::DATA_MODE)) {
+        device->set_mode(modem_mode::CMUX_MODE);
+        usleep(100'000);
+
+        if (!dte->set_mode(m)) {
             return false;
         }
-        if (!dte->set_mode(modem_mode::DATA_MODE)) {
-            return false;
-        }
-        netif.start();
+        mode = modem_mode::CMUX_MANUAL_MODE;
         return true;
+    case modem_mode::CMUX_MANUAL_EXIT:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        if (!dte->set_mode(m)) {
+            return false;
+        }
+        mode = modem_mode::COMMAND_MODE;
+        return true;
+    case modem_mode::CMUX_MANUAL_SWAP:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        if (!dte->set_mode(m)) {
+            return false;
+        }
+        return true;
+    case modem_mode::CMUX_MANUAL_DATA:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        return transitions::enter_data(*dte, *device, netif);
+    case modem_mode::CMUX_MANUAL_COMMAND:
+        if (mode != modem_mode::CMUX_MANUAL_MODE) {
+            return false;
+        }
+        return transitions::exit_data(*dte, *device, netif);
     }
     return false;
 }

components/esp_modem/src/esp_modem_dte.cpp

@@ -16,23 +16,33 @@ static const size_t dte_default_buffer_size = 1000;
 
 DTE::DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> terminal):
     buffer(config->dte_buffer_size),
-    cmux_term(nullptr), command_term(std::move(terminal)), data_term(command_term),
+    cmux_term(nullptr), primary_term(std::move(terminal)), secondary_term(primary_term),
     mode(modem_mode::UNDEF) {}
 
 DTE::DTE(std::unique_ptr<Terminal> terminal):
     buffer(dte_default_buffer_size),
-    cmux_term(nullptr), command_term(std::move(terminal)), data_term(command_term),
+    cmux_term(nullptr), primary_term(std::move(terminal)), secondary_term(primary_term),
     mode(modem_mode::UNDEF) {}
 
+DTE::DTE(const esp_modem_dte_config *config, std::unique_ptr<Terminal> t, std::unique_ptr<Terminal> s):
+    buffer(config->dte_buffer_size),
+    cmux_term(nullptr), primary_term(std::move(t)), secondary_term(std::move(s)),
+    mode(modem_mode::DUAL_MODE) {}
+
+DTE::DTE(std::unique_ptr<Terminal> t, std::unique_ptr<Terminal> s):
+    buffer(dte_default_buffer_size),
+    cmux_term(nullptr), primary_term(std::move(t)), secondary_term(std::move(s)),
+    mode(modem_mode::DUAL_MODE) {}
+
 command_result DTE::command(const std::string &command, got_line_cb got_line, uint32_t time_ms, const char separator)
 {
     Scoped<Lock> l(internal_lock);
     result = command_result::TIMEOUT;
     signal.clear(GOT_LINE);
-    command_term->set_read_cb([this, got_line, separator](uint8_t *data, size_t len) {
+    primary_term->set_read_cb([this, got_line, separator](uint8_t *data, size_t len) {
         if (!data) {
             data = buffer.get();
-            len = command_term->read(data + buffer.consumed, buffer.size - buffer.consumed);
+            len = primary_term->read(data + buffer.consumed, buffer.size - buffer.consumed);
         } else {
             buffer.consumed = 0; // if the underlying terminal contains data, we cannot fragment
         }
@@ -46,13 +56,13 @@ command_result DTE::command(const std::string &command, got_line_cb got_line, ui
         buffer.consumed += len;
         return false;
     });
-    command_term->write((uint8_t *)command.c_str(), command.length());
+    primary_term->write((uint8_t *)command.c_str(), command.length());
     auto got_lf = signal.wait(GOT_LINE, time_ms);
     if (got_lf && result == command_result::TIMEOUT) {
         ESP_MODEM_THROW_IF_ERROR(ESP_ERR_INVALID_STATE);
     }
     buffer.consumed = 0;
-    command_term->set_read_cb(nullptr);
+    primary_term->set_read_cb(nullptr);
     return result;
 }
 
@@ -68,26 +78,26 @@ bool DTE::exit_cmux()
     }
     auto ejected = cmux_term->detach();
     // return the ejected terminal and buffer back to this DTE
-    command_term = std::move(ejected.first);
+    primary_term = std::move(ejected.first);
     buffer = std::move(ejected.second);
-    data_term = command_term;
+    secondary_term = primary_term;
     return true;
 }
 
 bool DTE::setup_cmux()
 {
-    cmux_term = std::make_shared<CMux>(command_term, std::move(buffer));
+    cmux_term = std::make_shared<CMux>(primary_term, std::move(buffer));
     if (cmux_term == nullptr) {
         return false;
     }
     if (!cmux_term->init()) {
         return false;
     }
-    command_term = std::make_unique<CMuxInstance>(cmux_term, 0);
-    if (command_term == nullptr) {
+    primary_term = std::make_unique<CMuxInstance>(cmux_term, 0);
+    if (primary_term == nullptr) {
         return false;
     }
-    data_term = std::make_unique<CMuxInstance>(cmux_term, 1);
+    secondary_term = std::make_unique<CMuxInstance>(cmux_term, 1);
     return true;
 }
 
@@ -104,19 +114,17 @@ bool DTE::set_mode(modem_mode m)
             return false;
         }
     }
-    // transitions (COMMAND|CMUX|UNDEF) -> DATA
+    // transitions (COMMAND|DUAL|CMUX|UNDEF) -> DATA
     if (m == modem_mode::DATA_MODE) {
-        if (mode == modem_mode::CMUX_MODE) {
-            // mode stays the same, but need to swap terminals (as command has been switch)
-            data_term.swap(command_term);
+        if (mode == modem_mode::CMUX_MODE || mode == modem_mode::CMUX_MANUAL_MODE || mode == modem_mode::DUAL_MODE) {
+            // mode stays the same, but need to swap terminals (as command has been switched)
+            secondary_term.swap(primary_term);
         } else {
             mode = m;
         }
-        // prepare the data terminal's callback to the configured std::function (used by netif)
-        data_term->set_read_cb(on_data);
         return true;
     }
-    // transitions (DATA|CMUX|UNDEF) -> COMMAND
+    // transitions (DATA|DUAL|CMUX|UNDEF) -> COMMAND
     if (m == modem_mode::COMMAND_MODE) {
         if (mode == modem_mode::CMUX_MODE) {
             if (exit_cmux()) {
@@ -125,21 +133,47 @@ bool DTE::set_mode(modem_mode m)
             }
             mode = modem_mode::UNDEF;
             return false;
+        } if (mode == modem_mode::CMUX_MANUAL_MODE || mode == modem_mode::DUAL_MODE) {
+            return true;
         } else {
             mode = m;
             return true;
         }
     }
-    return true;
+    // manual CMUX transitions: Enter CMUX
+    if (m == modem_mode::CMUX_MANUAL_MODE) {
+        if (setup_cmux()) {
+            mode = m;
+            return true;
+        }
+        mode = modem_mode::UNDEF;
+        return false;
+    }
+    // manual CMUX transitions: Exit CMUX
+    if (m == modem_mode::CMUX_MANUAL_EXIT && mode == modem_mode::CMUX_MANUAL_MODE) {
+        if (exit_cmux()) {
+            mode = modem_mode::COMMAND_MODE;
+            return true;
+        }
+        mode = modem_mode::UNDEF;
+        return false;
+    }
+    // manual CMUX transitions: Swap terminals
+    if (m == modem_mode::CMUX_MANUAL_SWAP && mode == modem_mode::CMUX_MANUAL_MODE) {
+        secondary_term.swap(primary_term);
+        return true;
+    }
+    mode = modem_mode::UNDEF;
+    return false;
 }
 
 void DTE::set_read_cb(std::function<bool(uint8_t *, size_t)> f)
 {
     on_data = std::move(f);
-    data_term->set_read_cb([this](uint8_t *data, size_t len) {
+    secondary_term->set_read_cb([this](uint8_t *data, size_t len) {
         if (!data) { // if no data available from terminal callback -> need to explicitly read some
             data = buffer.get();
-            len = data_term->read(buffer.get(), buffer.size);
+            len = secondary_term->read(buffer.get(), buffer.size);
         }
         if (on_data) {
             return on_data(data, len);
@@ -150,22 +184,50 @@ void DTE::set_read_cb(std::function<bool(uint8_t *, size_t)> f)
 
 void DTE::set_error_cb(std::function<void(terminal_error err)> f)
 {
-    data_term->set_error_cb(f);
-    command_term->set_error_cb(f);
+    secondary_term->set_error_cb(f);
+    primary_term->set_error_cb(f);
 }
 
 int DTE::read(uint8_t **d, size_t len)
 {
     auto data_to_read = std::min(len, buffer.size);
     auto data = buffer.get();
-    auto actual_len = data_term->read(data, data_to_read);
+    auto actual_len = secondary_term->read(data, data_to_read);
     *d = data;
     return actual_len;
 }
 
 int DTE::write(uint8_t *data, size_t len)
 {
-    return data_term->write(data, len);
+    return secondary_term->write(data, len);
+}
+
+int DTE::write(DTE_Command command)
+{
+    return primary_term->write(command.data, command.len);
+}
+
+void DTE::on_read(got_line_cb on_read_cb)
+{
+    if (on_read_cb == nullptr) {
+        primary_term->set_read_cb(nullptr);
+        internal_lock.unlock();
+        return;
+    }
+    internal_lock.lock();
+    primary_term->set_read_cb([this, on_read_cb](uint8_t *data, size_t len) {
+        if (!data) {
+            data = buffer.get();
+            len = primary_term->read(data, buffer.size);
+        }
+        auto res = on_read_cb(data, len);
+        if (res == command_result::OK || res == command_result::FAIL) {
+            primary_term->set_read_cb(nullptr);
+            internal_lock.unlock();
+            return true;
+        }
+        return false;
+    });
 }
 
 /**

components/esp_modem/src/esp_modem_netif.cpp

@@ -21,7 +21,7 @@ void Netif::on_ppp_changed(void *arg, esp_event_base_t event_base,
                            int32_t event_id, void *event_data)
 {
     auto *ppp = static_cast<Netif *>(arg);
-    if (event_id < NETIF_PP_PHASE_OFFSET) {
+    if (event_id > NETIF_PPP_ERRORNONE && event_id < NETIF_PP_PHASE_OFFSET) {
         ESP_LOGI("esp_modem_netif", "PPP state changed event %" PRId32, event_id);
         // only notify the modem on state/error events, ignoring phase transitions
         ppp->signal.set(PPP_EXIT);
@@ -87,7 +87,7 @@ void Netif::start()
 {
     ppp_dte->set_read_cb([this](uint8_t *data, size_t len) -> bool {
         receive(data, len);
-        return false;
+        return true;
     });
     esp_netif_action_start(driver.base.netif, nullptr, 0, nullptr);
     signal.set(PPP_STARTED);

components/esp_modem/src/esp_modem_netif_linux.cpp

@@ -39,7 +39,7 @@ void Netif::start()
 {
     ppp_dte->set_read_cb([this](uint8_t *data, size_t len) -> bool {
         receive(data, len);
-        return false;
+        return true;
     });
     netif->transmit = esp_modem_dte_transmit;
     netif->ctx = (void *)this;

components/esp_modem/src/esp_modem_uart.cpp

@@ -125,9 +125,7 @@ void UartTerminal::task()
             case UART_DATA:
                 uart_get_buffered_data_len(uart.port, &len);
                 if (len && on_read) {
-                    if (on_read(nullptr, len)) {
-                        on_read = nullptr;
-                    }
+                    on_read(nullptr, len);
                 }
                 break;
             case UART_FIFO_OVF:

components/esp_modem/test/host_test/CMakeLists.txt

@@ -13,3 +13,15 @@ idf_component_get_property(esp_modem esp_modem COMPONENT_LIB)
 target_compile_definitions(${esp_modem} PRIVATE "-DCONFIG_COMPILER_CXX_EXCEPTIONS")
 target_compile_definitions(${esp_modem} PRIVATE "-DCONFIG_IDF_TARGET_LINUX")
 target_link_options(${esp_modem} INTERFACE -fsanitize=address -fsanitize=undefined)
+
+if(CONFIG_GCOV_ENABLED)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+
+
+    MARK_AS_ADVANCED(
+        CMAKE_CXX_FLAGS_COVERAGE
+        CMAKE_C_FLAGS_COVERAGE
+        CMAKE_EXE_LINKER_FLAGS_COVERAGE
+        CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+endif()

components/esp_modem/test/host_test/env.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+lwip=$1
+lwip_uri=$2
+lwip_contrib=$3
+
+wget --no-verbose ${lwip_uri}/${lwip}.zip
+unzip -oq ${lwip}.zip
+wget --no-verbose ${lwip_uri}/${lwip_contrib}.zip
+unzip -oq ${lwip_contrib}.zip

components/esp_modem/test/host_test/main/Kconfig

@@ -0,0 +1,9 @@
+menu "Host-test config"
+
+    config GCOV_ENABLED
+        bool "Coverage analyzer"
+        default n
+        help
+	        Enables coverage analyzing for host tests.
+
+endmenu

components/esp_modem/test/host_test/sdkconfig.ci.coverage

@@ -0,0 +1 @@
+CONFIG_GCOV_ENABLED=y

components/esp_modem/test/target/main/CMakeLists.txt

@@ -8,3 +8,5 @@ set_target_properties(${COMPONENT_LIB} PROPERTIES
     CXX_STANDARD_REQUIRED ON
     CXX_EXTENSIONS ON
 )
+
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

components/esp_modem/test/target/main/Kconfig.projbuild

@@ -1,26 +1,38 @@
-menu "Example Configuration"
+menu "Test App Configuration"
 
-    config ESP_WIFI_SSID
-        string "WiFi SSID"
-        default "myssid"
+    config TEST_APP_PPP_SERVER_IP
+        string "IP address of PPP server"
+        default "10.0.0.1"
         help
-            SSID (network name) for the example to connect to.
+            IP address of PPP server. Note: this is also the address
+            where the TCP server is started to test the connection
 
-    config ESP_WIFI_PASSWORD
-        string "WiFi Password"
-        default "mypassword"
+    config TEST_APP_PPP_CLIENT_IP
+        string "IP address of PPP client"
+        default "10.0.0.2"
         help
-            WiFi password (WPA or WPA2) for the example to use.
-    config ESP_WIFI_CHANNEL
-        int "WiFi Channel"
-        range 1 13
-        default 1
-        help
-            WiFi channel (network channel) for the example to use.
+            IP address that PPP server assigns to PPP client.
 
-    config ESP_MAX_STA_CONN
-        int "Maximal STA connections"
-        default 4
+    config TEST_APP_UART_TX_PIN
+        int "TXD Pin Number"
+        default 6
+        range 0 31
         help
-            Max number of the STA connects to AP.
+            Pin number of UART TX.
+
+    config TEST_APP_UART_RX_PIN
+        int "RXD Pin Number"
+        default 7
+        range 0 31
+        help
+            Pin number of UART RX.
+
+    config TEST_APP_TCP_PORT
+        int "Port of test"
+        range 0 65535
+        default 2222
+        help
+            The remote port to which the client will connects to
+            once the PPP connection established
+
 endmenu

components/esp_modem/test/target/main/NetworkDCE.cpp

@@ -60,6 +60,8 @@ public:
     {
         // configure
         esp_modem_dte_config_t dte_config = ESP_MODEM_DTE_DEFAULT_CONFIG();
+        dte_config.uart_config.tx_io_num = CONFIG_TEST_APP_UART_TX_PIN;
+        dte_config.uart_config.rx_io_num = CONFIG_TEST_APP_UART_RX_PIN;
         esp_modem_dce_config dce_config = ESP_MODEM_DCE_DEFAULT_CONFIG("");
 
         // create DTE and minimal network DCE
@@ -96,6 +98,7 @@ esp_err_t modem_init_network(esp_netif_t *netif)
 esp_err_t modem_start_network()
 {
     NetModule::start();
+    return ESP_OK;
 }
 
 void modem_stop_network()

components/esp_modem/test/target/pytest_pppd.py

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
+# SPDX-License-Identifier: Unlicense OR CC0-1.0
+from __future__ import print_function, unicode_literals
+
+import subprocess
+import time
+from threading import Event, Thread
+
+import netifaces
+
+
+def run_server(server_stop, port, server_ip, client_ip):
+    print('Starting PPP server on port: {}'.format(port))
+    try:
+        arg_list = [
+            'sudo', 'pppd', port, '115200',
+            '{}:{}'.format(server_ip, client_ip), 'modem', 'local', 'noauth',
+            'debug', 'nocrtscts', 'nodetach', '+ipv6'
+        ]
+        p = subprocess.Popen(arg_list, stdout=subprocess.PIPE, bufsize=1)
+        while not server_stop.is_set():
+            if p.poll() is not None:
+                if p.poll() == 16:
+                    print('[PPPD:] Terminated: hang-up received')
+                    break
+                else:
+                    raise ValueError(
+                        'ENV_TEST_FAILURE: PPP terminated unexpectedly with {}'
+                        .format(p.poll()))
+            line = p.stdout.readline()
+            if line:
+                print('[PPPD:]{}'.format(line.rstrip()))
+            time.sleep(0.1)
+    except Exception as e:
+        print(e)
+        raise ValueError('ENV_TEST_FAILURE: Error running PPP server')
+    finally:
+        p.terminate()
+    print('PPP server stopped')
+
+
+def test_examples_protocol_pppos_connect(dut):
+    """
+    steps:
+      1. starts PPP server
+      2. get DUT as PPP client to connect to the server
+      3. run unit test FW
+    """
+
+    # Look for test case symbolic names
+    try:
+        server_ip = dut.app.sdkconfig.get('TEST_APP_PPP_SERVER_IP')
+        client_ip = dut.app.sdkconfig.get('TEST_APP_PPP_CLIENT_IP')
+    except Exception:
+        print(
+            'ENV_TEST_FAILURE: Some mandatory configuration not found in sdkconfig'
+        )
+        raise
+
+    # the PPP test env uses two ttyUSB's: one for ESP32 board, another one for ppp server
+    # use the other port for PPP server than the DUT/ESP
+    port = '/dev/ttyUSB0' if dut.serial.port == '/dev/ttyUSB1' else '/dev/ttyUSB1'
+    # Start the PPP server
+    server_stop = Event()
+    t = Thread(target=run_server,
+               args=(server_stop, port, server_ip, client_ip))
+    t.start()
+    try:
+        ppp_server_timeout = time.time() + 30
+        while 'ppp0' not in netifaces.interfaces():
+            print(
+                "PPP server haven't yet setup its netif, list of active netifs:{}"
+                .format(netifaces.interfaces()))
+            time.sleep(0.5)
+            if time.time() > ppp_server_timeout:
+                raise ValueError(
+                    'ENV_TEST_FAILURE: PPP server failed to setup ppp0 interface within timeout'
+                )
+
+        dut.expect('All tests passed')
+    finally:
+        server_stop.set()
+        t.join()