Merge pull request #330 from gabsuren/websocket/release_1.0.1

bump(websocket): 1.0.0 -> 1.0.1

.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://github.com/espressif/esp-protocols#readme) 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 links
+    url: https://github.com/espressif/esp-protocols#readme
+    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://github.com/espressif/esp-protocols#readme) 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/examples_build-host-test.yml

@@ -0,0 +1,48 @@
+name: "examples: build/host-tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types: [opened, synchronize, reopened, labeled]
+
+jobs:
+  build_all_examples:
+    if: contains(github.event.pull_request.labels.*.name, 'examples') || github.event_name == 'push'
+    name: Build examples
+    strategy:
+      matrix:
+        idf_ver: ["latest", "release-v5.1"]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+      - name: Build with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          python -m pip install idf-build-apps
+          # Build default configs for all targets
+          python ./ci/build_apps.py examples -m examples/.build-test-rules.yml -d -c
+
+  build_and_run_on_host:
+    if: contains(github.event.pull_request.labels.*.name, 'examples') || github.event_name == 'push'
+    name: Build and run examples on linux
+    strategy:
+      matrix:
+        idf_ver: ["latest"]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+      - name: Build with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          python -m pip install idf-build-apps
+          python ./ci/build_apps.py examples/mqtt -l -t linux
+          timeout 5 ./examples/mqtt/build_linux_default/esp_mqtt_demo.elf | tee test.log  || true
+          grep 'MQTT_EVENT_DATA' test.log

.github/workflows/gcov_analyzer.yml

@@ -1,92 +0,0 @@
-name: Code Coverage Analyzer
-
-on: [push, pull_request]
-
-jobs:
-  gcovr_analyzer_esp_modem:
-    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/host-test.yml

@@ -1,63 +0,0 @@
-name: Host test
-
-on: [push, pull_request]
-
-jobs:
-  host_test_esp_modem:
-    name: esp-modem 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
-      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_mdns:
-    name: mdns Build and Test on Host
-    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

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

@@ -0,0 +1,84 @@
+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", "release-v5.0"]
+        test: [ { app: example, path: "examples" }, { app: unit_test, path: "tests/unit_test" }, { app: test_app, path: "tests/test_apps" } ]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    steps:
+      - name: Checkout esp-protocols
+        uses: actions/checkout@v3
+      - name: Build ${{ matrix.test.app }} with IDF-${{ matrix.idf_ver }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          python -m pip install idf-build-apps
+          # Build default configs for all targets
+          python ./ci/build_apps.py components/mdns/${{ matrix.test.path }} -r default -m components/mdns/.build-test-rules.yml -d
+          # Build specific configs for test targets
+          python ./ci/build_apps.py components/mdns/${{ matrix.test.path }}
+          cd components/mdns/${{ matrix.test.path }}
+          for dir in `ls -d build_esp32_*`; do
+          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
+          zip -qur artifacts.zip $dir
+          done
+      - uses: actions/upload-artifact@v3
+        with:
+          name: mdns_bin_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: components/mdns/${{ matrix.test.path }}/artifacts.zip
+          if-no-files-found: error
+
+  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: "examples" }, { app: unit_test, path: "tests/unit_test" }, { app: test_app, path: "tests/test_apps" } ]
+    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: components/mdns/${{ 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: components/mdns/${{ 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: components/mdns/${{ 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:release-v5.1
+
+    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,163 @@
+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 }} -m components/esp_modem/examples/.build-test-rules.yml
+
+  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
+    permissions:
+      contents: write
+    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
+          repository: ''
+          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
+          cp -rf docs_gcovr $GITHUB_WORKSPACE
+      - 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
+      - name: Deploy code coverage results
+        if: github.ref == 'refs/heads/master'
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./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
+      - modem
+    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

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

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

@@ -5,66 +5,89 @@ on:
     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_ORIG : ${{ secrets.DOCS_DEPLOY_PATH }}
+
 jobs:
-  docs_build:
-    name: Docs-Build-And-Upload
+  publish:
+    name: Publish Tag, Release, Docs, Component
     runs-on: ubuntu-latest
     # Skip running on forks since it won't have access to secrets
     if: github.repository == 'espressif/esp-protocols'
-
     steps:
       - name: Checkout esp-protocols
-        uses: actions/checkout@master
+        uses: actions/checkout@v3
         with:
           persist-credentials: false
           fetch-depth: 0
           submodules: recursive
-
+          token: "${{ secrets.GITHUB_TOKEN }}"
+      - name: Check for version update
+        shell: bash
+        run: ./ci/detect_component_bump
+      - name: Tag merge commit
+        if: env.BUMP_VERSION != ''
+        uses: anothrNick/github-tag-action@1.61.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CUSTOM_TAG: ${{ env.BUMP_TAG }}
+      - name: Create Release
+        if: env.BUMP_VERSION != ''
+        uses: softprops/action-gh-release@v1
+        with:
+          body_path: "release_notes.md"
+          tag_name: ${{ env.BUMP_TAG }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - 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
+            python -m pip install breathe recommonmark esp-docs==1.4.1
+            for comp in  `ls components`; do
+              cd $GITHUB_WORKSPACE/docs/${comp}
+              if [[ "${{ env.BUMP_COMPONENT }}" == "${comp}" ]]; then
+                echo "Building specific version of ${comp} (${{ env.BUMP_VERSION }})"
+                ./generate_docs ${{ env.BUMP_VERSION }}
+              else
+                echo "Building latest version of ${comp}"
                 ./generate_docs
-          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
-
-
+              fi
+            done
+      - name: Deploying generated docs
+        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=latest
+            for comp in  `ls components`; do
+              echo "Deploying latest of ${comp}"
+              export DOCS_BUILD_DIR=$GITHUB_WORKSPACE/docs/${comp}
+              export DOCS_DEPLOY_PATH=$DOCS_DEPLOY_PATH_ORIG/${comp}
+              cd $GITHUB_WORKSPACE/docs/${comp}
+              deploy-docs
+            done;
+            # Deploy docs with version path
+            if [[ "${{ env.BUMP_VERSION }}" != "" ]]; then
+                echo "Deploying specific version of ${comp} (${{ env.BUMP_VERSION }})"
+                cd $GITHUB_WORKSPACE/docs/${{ env.BUMP_COMPONENT }}
+                export GITHUB_REF_NAME=${{ env.BUMP_VERSION }}
+                deploy-docs
+            fi
       - name: Upload components to component service
-        uses: espressif/github-actions/upload_components@master
+        uses: espressif/upload-components-ci-action@v1
         with:
-          directories: "components/esp_modem;components/esp_websocket_client;components/mdns;components/asio"
+          directories: >
+            components/asio;
+            components/esp_modem;
+            components/esp_mqtt_cxx;
+            components/esp_websocket_client;
+            components/mdns;
           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

.github/workflows/target-test.yml

@@ -1,383 +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", "release-v5.0"]
-        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"]
-        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_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 }}
-    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
-
-
-  build_websocket:
-    strategy:
-      matrix:
-        idf_ver: ["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
-
-  build_esp_mqtt_cxx:
-      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
-
-  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
-    env:
-      TEST_DIR: components/esp_websocket_client/examples
-    # 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@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
-
-  run-target-mdns:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32"]
-        test: [ { app: example, path: "components/mdns/examples" }, { app: unit_test, path: "components/mdns/tests/unit_test" } ]
-    name: Run mDNS target tests
-    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@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
-
-  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
-    env:
-      TEST_DIR: components/asio/examples
-    # 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@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
-
-  build_esp_modem_tests:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800, 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
-
-  run_esp_modem_tests:
-    strategy:
-      matrix:
-        idf_ver: ["latest"]
-        idf_target: ["esp32c3"]
-        test: [ { app: pppd, path: test/target }, { app: sim800, path: examples/pppos_client } ]
-    name: Run esp_modem Test on target
-    needs: build_esp_modem_tests
-    runs-on:
-      - self-hosted
-      - BrnoRPI-GH006
-    env:
-      TEST_DIR: components/esp_modem/${{ matrix.test.path }}
-    # 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@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/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,86 @@
+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", "release-v5.1", "latest"]
+        test: [ { app: example, path: "examples" }, { app: unit_test, path: "test" } ]
+    runs-on: ubuntu-20.04
+    container: espressif/idf:${{ matrix.idf_ver }}
+    env:
+      TEST_DIR: components/esp_websocket_client/${{ matrix.test.path }}
+    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 }}
+        shell: bash
+        run: |
+          . ${IDF_PATH}/export.sh
+          python -m pip install idf-build-apps
+          python ./ci/build_apps.py ${TEST_DIR}
+          cd ${TEST_DIR}
+          for dir in `ls -d build_esp32_*`; do
+          $GITHUB_WORKSPACE/ci/clean_build_artifacts.sh `pwd`/$dir
+          zip -qur artifacts.zip $dir
+          done
+      - uses: actions/upload-artifact@v3
+        with:
+          name: websocket_bin_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ env.TEST_DIR }}/artifacts.zip
+          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", "release-v5.1", "latest"]
+        idf_target: ["esp32"]
+        test: [ { app: example, path: "examples" }, { app: unit_test, path: "test" } ]
+    runs-on:
+      - self-hosted
+      - ESP32-ETHERNET-KIT
+    env:
+      TEST_DIR: components/esp_websocket_client/${{ matrix.test.path }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/download-artifact@v3
+        with:
+          name: websocket_bin_esp32_${{ matrix.idf_ver }}_${{ matrix.test.app }}
+          path: ${{ env.TEST_DIR }}/ci/
+      - 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: Run Example Test on target
+        working-directory: ${{ env.TEST_DIR }}
+        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: components/esp_websocket_client/${{ matrix.test.path }}/*.xml

.pre-commit-config.yaml

@@ -16,6 +16,7 @@ repos:
     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, manual]
+  - 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|examples)\)\:)'
+        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 step needs to be performed manually by project maintainers running the `bump` command. Release procedure is as follows:
+* Run `ci/bump [component] [version]` (version number is optional, `cz` would automatically increment it if not present)
+* Check the updated `CHANGELOG.md` and the generated bump commit message
+* Create a PR
+Once the PR is merged, the CI job tags the merge commit, creates a new release, builds and deploys documentation and the new component to the component registry

README.md

@@ -1,26 +1,29 @@
 # 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/projects/esp-protocols/esp_modem/docs/latest/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/projects/esp-protocols/mdns/docs/latest/en/index.html)
+* Full html [documentation(Chinese)](https://docs.espressif.com/projects/esp-protocols/mdns/docs/latest/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/projects/esp-protocols/esp_websocket_client/docs/latest/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/projects/esp-protocols/asio/docs/latest/index.html)
+
+### esp_mqtt_cxx
+
+* Brief introduction [README](components/esp_mqtt_cxx/README.md)
+* Full html [documentation](https://docs.espressif.com/projects/esp-protocols/esp_mqtt_cxx/docs/latest/index.html)

ci/build_apps.py

@@ -0,0 +1,67 @@
+# 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 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',
+    )
+    parser.add_argument('-r', '--rules', nargs='*', default=['sdkconfig.ci=default', 'sdkconfig.ci.*=', '=default'], help='Rules how to treat configs')
+    parser.add_argument('-m', '--manifests', nargs='*', default=[], help='list of manifest files')
+    parser.add_argument('-d', '--delete', action='store_true', help='Delete build artifacts')
+    parser.add_argument('-c', '--recursive', action='store_true', help='Build recursively')
+    parser.add_argument('-l', '--linux', action='store_true', help='Include linux build (dont check warnings)')
+    args = parser.parse_args()
+
+    IDF_PATH = os.environ['IDF_PATH']
+
+    # Compose the ignore warning strings from the global list and from the environment
+    ignore_warning_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),'ignore_build_warnings.txt')
+    ignore_warning = open(ignore_warning_file).read().rstrip('\n').split('\n')
+    if 'EXPECTED_WARNING' in os.environ:
+        ignore_warning += os.environ['EXPECTED_WARNING'].split('\n')
+    if args.linux:
+        SUPPORTED_TARGETS.append('linux')
+        ignore_warning = 'warning: '  # Ignore all common warnings on linux builds
+    setup_logging(2)
+    apps = find_apps(
+        args.paths,
+        recursive=args.recursive,
+        target=args.target,
+        build_dir='build_@t_@w',
+        config_rules_str=args.rules,
+        build_log_path='build_log.txt',
+        size_json_path='size.json' if not args.linux else None,
+        check_warnings=True,
+        preserve=not args.delete,
+        manifest_files=args.manifests,
+        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=ignore_warning)
+    )

ci/bump

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+if [ -z "$1" ]; then
+    echo "Usage: bump component [version]"
+    exit 1;
+fi
+
+comp=$1; shift;
+
+cd components/${comp}
+if ! cz bump --dry-run; then
+    echo "Commitizen bump commad failed!"
+    exit 1;
+fi
+
+cz_bump_out=`cz bump --files-only "$@"`
+commit_title=`echo "${cz_bump_out}" | head -1`
+commit_body=`cat ../../release_notes.txt`
+
+git add -u .
+git commit -m $"${commit_title}
+
+${commit_body}"

ci/changelog.py

@@ -0,0 +1,105 @@
+# 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)
+
+    # write the current changelog entry to a local text file (removing links, captions and extra newlines)
+    changelog = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', changelog)
+    changelog = re.sub(r'\#\#[\#\s]*(.+)', r'\1', changelog)
+    changelog = re.sub(r'\n\n', '\n', changelog)
+    with open(os.path.join(root_path, 'release_notes.txt'), 'w') as release_notes:
+        release_notes.write(changelog)
+
+
+if __name__ == '__main__':
+    main()

ci/check_copyright_config.yaml

@@ -29,6 +29,7 @@ DEFAULT:
 # this section sets the default license for examples and unit tests of components
 examples_and_unit_tests:
   include:
+   - 'examples/**'
    - 'components/**/examples/**'
    - 'components/**/test/**'
    - 'components/**/tests/**'
@@ -57,7 +58,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/detect_component_bump

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+
+set -e
+
+if ! git show -s | grep -q '^Merge'; then
+    echo "Not a merge commit"
+    exit 0;
+fi
+
+for comp in  `ls components`; do
+if git log -1 -m --name-only --pretty="" | grep -q components/${comp}/idf_component.yml; then
+    echo "${comp}: Component version file has changed"
+    version=`grep version: components/${comp}/.cz.yaml`
+    version=${version#*version: }
+
+    tag_format=`grep tag_format: components/${comp}/.cz.yaml`
+    tag_format=${tag_format#*tag_format: }
+
+    eval tag=$tag_format
+    # check if the tag is already created
+    if [ $(git tag -l "$tag") ]; then
+        echo "${comp}: version (${tag}) already exits"
+    else
+        echo "${comp}: Component version has been updated to ${version}"
+        # creates release notes from the last entry (between first two "## sections")
+        awk '/^## \[/{a++};{if(a==1){print}}' components/${comp}/CHANGELOG.md > release_notes.md
+
+        echo "BUMP_VERSION=${version}"
+        echo "BUMP_COMPONENT=${comp}"
+        echo "BUMP_TAG=${tag}"
+
+        # export the findings to github env, so it could be used in other jobs
+        echo "BUMP_VERSION=${version}" >> "$GITHUB_ENV"
+        echo "BUMP_COMPONENT=${comp}" >> "$GITHUB_ENV"
+        echo "BUMP_TAG=${tag}" >> "$GITHUB_ENV"
+
+        exit 0;
+    fi
+fi
+done
+echo "No changes in component version file"

ci/ignore_build_warnings.txt

@@ -0,0 +1 @@
+DeprecationWarning: pkg_resources is deprecated as an API

common_components/linux_compat/esp_timer/CMakeLists.txt

@@ -1,6 +1,5 @@
 idf_component_register(SRCS esp_timer_linux.c timer_task.cpp
-                       INCLUDE_DIRS include
-                       REQUIRES esp_event)
+                       INCLUDE_DIRS include)
 
 set_target_properties(${COMPONENT_LIB} PROPERTIES
     CXX_STANDARD 17

common_components/linux_compat/esp_timer/esp_timer_linux.c

@@ -7,6 +7,7 @@
 #include "esp_timer.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#include <pthread.h>
 
 void *create_tt(esp_timer_cb_t cb);
 
@@ -37,3 +38,10 @@ esp_err_t esp_timer_delete(esp_timer_handle_t timer)
     destroy_tt(timer);
     return ESP_OK;
 }
+
+int64_t esp_timer_get_time(void)
+{
+    struct timespec spec;
+    clock_gettime(CLOCK_REALTIME, &spec);
+    return spec.tv_nsec / 1000 + spec.tv_sec * 1000000;
+}

common_components/linux_compat/esp_timer/include/esp_timer.h

@@ -7,6 +7,12 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bsd/string.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 
 typedef struct esp_timer *esp_timer_handle_t;
 
@@ -31,3 +37,9 @@ esp_err_t esp_timer_start_periodic(esp_timer_handle_t timer, uint64_t period);
 esp_err_t esp_timer_stop(esp_timer_handle_t timer);
 
 esp_err_t esp_timer_delete(esp_timer_handle_t timer);
+
+int64_t esp_timer_get_time(void);
+
+#ifdef __cplusplus
+}
+#endif

common_components/linux_compat/freertos/CMakeLists.txt

@@ -1,4 +1,5 @@
-idf_component_register(SRCS freertos_linux.c queue_unique_ptr.cpp
+idf_component_register(SRCS freertos_linux.c
+                            osal/queue.cpp osal/event_group.cpp osal/mutex.cpp
                        INCLUDE_DIRS include)
 
 set(THREADS_PREFER_PTHREAD_FLAG ON)

common_components/linux_compat/freertos/freertos_linux.c

@@ -0,0 +1,272 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <unistd.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <pthread.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include "osal/osal_api.h"
+
+static uint64_t s_semaphore_data = 0;
+
+typedef enum queue_type_tag {
+    MUTEX_REC,
+    MUTEX,
+    SEMA,
+    QUEUE,
+} queue_type_t;
+
+struct generic_queue_handle {
+    queue_type_t type;
+    size_t item_size;
+    void *q;
+};
+
+static struct generic_queue_handle *create_generic_queue(queue_type_t type, uint32_t len, uint32_t item_size)
+{
+    struct generic_queue_handle *h = calloc(1, sizeof(struct generic_queue_handle));
+    h->item_size = len;
+    h->type = type;
+    switch (type) {
+    default:
+    case QUEUE:
+    case SEMA:
+        h->q = osal_queue_create();
+        break;
+
+    case MUTEX:
+    case MUTEX_REC:
+        h->q = osal_mutex_create();
+        break;
+    }
+    return h;
+}
+
+QueueHandle_t xQueueCreate(uint32_t uxQueueLength, uint32_t uxItemSize )
+{
+    return (QueueHandle_t)create_generic_queue(QUEUE, uxQueueLength, uxItemSize);
+}
+
+uint32_t xQueueSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
+{
+    struct generic_queue_handle *h = xQueue;
+    return osal_queue_send(h->q, (uint8_t *)pvItemToQueue, h->item_size) ? pdTRUE : pdFAIL;
+}
+
+uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait )
+{
+    return xQueueSend(xQueue, pvItemToQueue, xTicksToWait);
+}
+
+uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
+{
+    struct generic_queue_handle *h = xQueue;
+    return osal_queue_recv(h->q, (uint8_t *)pvBuffer, h->item_size, xTicksToWait) ? pdTRUE : pdFAIL;
+}
+
+BaseType_t xSemaphoreGive( QueueHandle_t xQueue)
+{
+    struct generic_queue_handle *h = xQueue;
+    if (h->type == MUTEX) {
+        osal_mutex_give(h->q);
+        return pdTRUE;
+    }
+    return xQueueSend(xQueue, &s_semaphore_data, portMAX_DELAY);
+}
+
+BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue)
+{
+    struct generic_queue_handle *h = xQueue;
+    if (h->type == MUTEX_REC) {
+        osal_mutex_give(h->q);
+        return pdTRUE;
+    }
+    return pdFALSE;
+}
+BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask )
+{
+    struct generic_queue_handle *h = xQueue;
+    if (h->type == MUTEX) {
+        osal_mutex_take(h->q);
+        return pdTRUE;
+    }
+    return xQueueReceive(xQueue, &s_semaphore_data, portMAX_DELAY);
+}
+
+
+BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask )
+{
+    struct generic_queue_handle *h = xQueue;
+    if (h->type == MUTEX_REC) {
+        osal_mutex_take(h->q);
+        return pdTRUE;
+    }
+    return pdFALSE;
+}
+
+
+
+
+void vQueueDelete( QueueHandle_t xQueue )
+{
+    struct generic_queue_handle *h = xQueue;
+    if (h->q) {
+        if (h->type == MUTEX || h->type == MUTEX_REC) {
+            osal_mutex_delete(h->q);
+        } else {
+            osal_queue_delete(h->q);
+        }
+    }
+    free(xQueue);
+}
+
+QueueHandle_t xSemaphoreCreateBinary(void)
+{
+    QueueHandle_t sempaphore =  xQueueCreate(1, 1);
+    return sempaphore;
+}
+
+QueueHandle_t xSemaphoreCreateMutex(void)
+{
+    return (QueueHandle_t)create_generic_queue(MUTEX, 1, 1);
+}
+
+QueueHandle_t xSemaphoreCreateRecursiveMutex(void)
+{
+    return (QueueHandle_t)create_generic_queue(MUTEX_REC, 1, 1);
+}
+
+
+void vTaskDelete(TaskHandle_t *task)
+{
+    if (task == NULL) {
+        pthread_exit(0);
+    }
+    void *thread_rval = NULL;
+    pthread_join((pthread_t)task, &thread_rval);
+}
+
+void vTaskSuspend(void *task)
+{
+    vTaskDelete(task);
+}
+
+TickType_t xTaskGetTickCount( void )
+{
+    struct timespec spec;
+    clock_gettime(CLOCK_REALTIME, &spec);
+    return spec.tv_nsec / 1000000 + spec.tv_sec * 1000;
+}
+
+void vTaskDelay( const TickType_t xTicksToDelay )
+{
+    usleep(xTicksToDelay * 1000);
+}
+
+void *pthread_task(void *params)
+{
+    struct {
+        void *const param;
+        TaskFunction_t task;
+        bool started;
+    } *pthread_params = params;
+
+    void *const param = pthread_params->param;
+    TaskFunction_t task = pthread_params->task;
+    pthread_params->started = true;
+
+    task(param);
+
+    return NULL;
+}
+
+BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
+                                    const char *const pcName,
+                                    const uint32_t usStackDepth,
+                                    void *const pvParameters,
+                                    UBaseType_t uxPriority,
+                                    TaskHandle_t *const pvCreatedTask,
+                                    const BaseType_t xCoreID)
+{
+    xTaskCreate(pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask);
+    return pdTRUE;
+}
+
+
+BaseType_t xTaskCreate(TaskFunction_t pvTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pvCreatedTask)
+{
+    pthread_t new_thread = (pthread_t)NULL;
+    pthread_attr_t attr;
+    struct {
+        void *const param;
+        TaskFunction_t task;
+        bool started;
+    } pthread_params = { .param = pvParameters, .task = pvTaskCode};
+    int res = pthread_attr_init(&attr);
+    assert(res == 0);
+    res = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+    assert(res == 0);
+    res = pthread_create(&new_thread, &attr, pthread_task, &pthread_params);
+    assert(res == 0);
+
+    if (pvCreatedTask) {
+        *pvCreatedTask = (void *)new_thread;
+    }
+
+    // just wait till the task started so we can unwind params from the stack
+    while (pthread_params.started == false) {
+        usleep(1000);
+    }
+    return pdTRUE;
+}
+
+void xTaskNotifyGive(TaskHandle_t task)
+{
+
+}
+
+BaseType_t xTaskNotifyWait(uint32_t bits_entry_clear, uint32_t bits_exit_clear, uint32_t *value, TickType_t wait_time )
+{
+    return true;
+}
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void)
+{
+    return NULL;
+}
+
+EventGroupHandle_t xEventGroupCreate( void )
+{
+    return osal_signal_create();
+}
+
+void vEventGroupDelete( EventGroupHandle_t xEventGroup )
+{
+    osal_signal_delete(xEventGroup);
+}
+
+EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
+{
+    return osal_signal_clear(xEventGroup, uxBitsToClear);
+}
+
+EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup)
+{
+    return osal_signal_get(xEventGroup);
+}
+
+EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
+{
+    return osal_signal_set(xEventGroup, uxBitsToSet);
+}
+
+EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
+{
+    return osal_signal_wait(xEventGroup, uxBitsToWaitFor, xWaitForAllBits, xTicksToWait);
+}

common_components/linux_compat/freertos/include/esp_task.h

@@ -10,3 +10,4 @@
 
 #define ESP_TASK_PRIO_MAX 25
 #define ESP_TASKD_EVENT_PRIO 5
+#define ESP_TASKD_EVENT_STACK 1024

common_components/linux_compat/freertos/include/freertos/FreeRTOS.h

@@ -16,7 +16,9 @@
 typedef void *SemaphoreHandle_t;
 typedef void *QueueHandle_t;
 typedef void *TaskHandle_t;
+typedef void *EventGroupHandle_t;
 typedef uint32_t TickType_t;
+typedef TickType_t               EventBits_t;
 
 typedef void (*TaskFunction_t)( void * );
 typedef unsigned int    UBaseType_t;
@@ -30,6 +32,5 @@ typedef int             BaseType_t;
 
 #define pdMS_TO_TICKS(tick)    (tick)
 
-uint32_t esp_get_free_heap_size(void);
 uint32_t esp_random(void);
 void vTaskSuspendAll(void);

common_components/linux_compat/freertos/include/freertos/event_groups.h

@@ -0,0 +1,6 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once

common_components/linux_compat/freertos/include/freertos/queue.h

@@ -3,11 +3,4 @@
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
-//
-// Created by david on 1/13/23.
-//
-
-#ifndef _QUEUE_H_
-#define _QUEUE_H_
-
-#endif //_QUEUE_H_
+#pragma once

common_components/linux_compat/freertos/include/freertos/semphr.h

@@ -3,11 +3,4 @@
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
-//
-// Created by david on 1/13/23.
-//
-
-#ifndef _SEMAPHR_H_
-#define _SEMAPHR_H_
-
-#endif //_SEMAPHR_H_
+#pragma once

common_components/linux_compat/freertos/include/freertos/task.h

@@ -7,6 +7,10 @@
 
 #include "freertos/FreeRTOS.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define TaskHandle_t TaskHandle_t
 #define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
 
@@ -26,7 +30,7 @@ BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
                                     TaskHandle_t *const pvCreatedTask,
                                     const BaseType_t xCoreID);
 
-void xTaskCreate(TaskFunction_t pvTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pvCreatedTask);
+BaseType_t xTaskCreate(TaskFunction_t pvTaskCode, const char *const pcName, const uint32_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pvCreatedTask);
 
 TickType_t xTaskGetTickCount( void );
 
@@ -35,11 +39,16 @@ void vQueueDelete( QueueHandle_t xQueue );
 QueueHandle_t xSemaphoreCreateBinary(void);
 
 QueueHandle_t xSemaphoreCreateMutex(void);
+QueueHandle_t xSemaphoreCreateRecursiveMutex(void);
 
 BaseType_t xSemaphoreGive( QueueHandle_t xQueue);
 
 BaseType_t xSemaphoreTake( QueueHandle_t xQueue, TickType_t pvTask );
 
+BaseType_t xSemaphoreGiveRecursive( QueueHandle_t xQueue);
+
+BaseType_t xSemaphoreTakeRecursive( QueueHandle_t xQueue, TickType_t pvTask );
+
 void vTaskDelete(TaskHandle_t *task);
 
 QueueHandle_t xQueueCreate( uint32_t uxQueueLength,
@@ -48,3 +57,27 @@ QueueHandle_t xQueueCreate( uint32_t uxQueueLength,
 uint32_t xQueueSend(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait);
 
 uint32_t xQueueReceive(QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait);
+
+void vTaskSuspend(void *task);
+
+EventGroupHandle_t xEventGroupCreate( void );
+void vEventGroupDelete( EventGroupHandle_t xEventGroup );
+EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
+                                  const EventBits_t uxBitsToClear );
+
+EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
+                                 const EventBits_t uxBitsToWaitFor,
+                                 const BaseType_t xClearOnExit,
+                                 const BaseType_t xWaitForAllBits,
+                                 TickType_t xTicksToWait );
+
+EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup);
+
+EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
+                                const EventBits_t uxBitsToSet );
+
+uint32_t xQueueSendToBack(QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait );
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus

common_components/linux_compat/freertos/osal/event_group.cpp

@@ -0,0 +1,109 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <mutex>
+#include <condition_variable>
+#include "osal_api.h"
+
+
+class SignalGroup {
+
+    struct SignalGroupInternal {
+        std::condition_variable notify;
+        std::mutex m;
+        uint32_t flags{ 0 };
+    };
+
+    using SignalT = std::unique_ptr<SignalGroupInternal>;
+
+public:
+
+    void set(uint32_t bits)
+    {
+        std::unique_lock<std::mutex> lock(event_group->m);
+        event_group->flags |= bits;
+        event_group->notify.notify_all();
+    }
+
+    uint32_t get()
+    {
+        return event_group->flags;
+    }
+
+    void clear(uint32_t bits)
+    {
+        std::unique_lock<std::mutex> lock(event_group->m);
+        event_group->flags &= ~bits;
+        event_group->notify.notify_all();
+    }
+
+    // waiting for all and clearing if set
+    bool wait(uint32_t flags, uint32_t time_ms)
+    {
+        std::unique_lock<std::mutex> lock(event_group->m);
+        return event_group->notify.wait_for(lock, std::chrono::milliseconds(time_ms), [&] {
+            if ((flags & event_group->flags) == flags)
+            {
+                event_group->flags &= ~flags;
+                return true;
+            }
+            return false;
+        });
+    }
+
+
+    // waiting for any bit, not clearing them
+    bool wait_any(uint32_t flags, uint32_t time_ms)
+    {
+        std::unique_lock<std::mutex> lock(event_group->m);
+        return event_group->notify.wait_for(lock, std::chrono::milliseconds(time_ms), [&] { return flags & event_group->flags; });
+    }
+
+private:
+    SignalT event_group{std::make_unique<SignalGroupInternal>()};
+};
+
+
+void *osal_signal_create()
+{
+    auto signal = new SignalGroup;
+    return signal;
+}
+
+void osal_signal_delete(void *s)
+{
+    delete static_cast<SignalGroup *>(s);
+}
+
+uint32_t osal_signal_clear(void *s, uint32_t bits)
+{
+    auto signal = static_cast<SignalGroup *>(s);
+    signal->clear(bits);
+    return signal->get();
+}
+
+uint32_t osal_signal_set(void *s, uint32_t bits)
+{
+    auto signal = static_cast<SignalGroup *>(s);
+    signal->set(bits);
+    return signal->get();
+}
+
+uint32_t osal_signal_get(void *s)
+{
+    auto signal = static_cast<SignalGroup *>(s);
+    return signal->get();
+}
+
+uint32_t osal_signal_wait(void *s, uint32_t flags, bool all, uint32_t timeout)
+{
+    auto signal = static_cast<SignalGroup *>(s);
+    if (all) {
+        signal->wait(flags, timeout);
+    } else {
+        signal->wait_any(flags, timeout);
+    }
+    return signal->get();
+}

common_components/linux_compat/freertos/osal/mutex.cpp

@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#include <queue>
+#include <mutex>
+#include "osal_api.h"
+
+void *osal_mutex_create()
+{
+    auto mut = new std::recursive_mutex();
+    return mut;
+}
+
+void osal_mutex_delete(void *mut)
+{
+    delete static_cast<std::recursive_mutex *>(mut);
+}
+
+void osal_mutex_take(void *m)
+{
+    auto mut = static_cast<std::recursive_mutex *>(m);
+    mut->lock();
+}
+
+void osal_mutex_give(void *m)
+{
+    auto mut = static_cast<std::recursive_mutex *>(m);
+    mut->unlock();
+}

common_components/linux_compat/freertos/osal/osal_api.h

@@ -0,0 +1,34 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// queue api
+void *osal_queue_create(void);
+void osal_queue_delete(void *q);
+bool osal_queue_send(void *q, uint8_t *data, size_t len);
+bool osal_queue_recv(void *q, uint8_t *data, size_t len, uint32_t ms);
+
+// mutex api
+void *osal_mutex_create(void);
+void osal_mutex_delete(void *m);
+void osal_mutex_take(void *m);
+void osal_mutex_give(void *m);
+
+// event groups
+void *osal_signal_create(void);
+void osal_signal_delete(void *s);
+uint32_t osal_signal_clear(void *s, uint32_t bits);
+uint32_t osal_signal_set(void *s, uint32_t bits);
+uint32_t osal_signal_get(void *s);
+uint32_t osal_signal_wait(void *s, uint32_t flags, bool all, uint32_t timeout);
+
+#ifdef __cplusplus
+}
+#endif

common_components/linux_compat/freertos/osal/queue.cpp

@@ -0,0 +1,78 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <cstdint>
+#include <vector>
+#include <cstring>
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+#include <atomic>
+#include "osal_api.h"
+
+template <class T>
+class Queue {
+public:
+    void send(std::unique_ptr<T> t)
+    {
+        std::lock_guard<std::mutex> lock(m);
+        q.push(std::move(t));
+        c.notify_one();
+    }
+
+    std::unique_ptr<T> receive(std::chrono::milliseconds ms)
+    {
+        std::unique_lock<std::mutex> lock(m);
+        while (q.empty()) {
+            if (c.wait_for(lock, ms) == std::cv_status::timeout) {
+                return nullptr;
+            }
+        }
+        std::unique_ptr<T> val = std::move(q.front());
+        q.pop();
+        return val;
+    }
+
+private:
+    std::queue<std::unique_ptr<T>> q{};
+    mutable std::mutex m{};
+    std::condition_variable c{};
+};
+
+using item_t = std::vector<uint8_t>;
+
+void *osal_queue_create(void)
+{
+    auto *q = new Queue<item_t>();
+    return q;
+}
+
+void osal_queue_delete(void *q)
+{
+    auto *queue = static_cast<Queue<item_t> *>(q);
+    delete (queue);
+}
+
+bool osal_queue_send(void *q, uint8_t *data, size_t len)
+{
+    auto v = std::make_unique<item_t>(len);
+    v->assign(data, data + len);
+    auto queue = static_cast<Queue<item_t> *>(q);
+    queue->send(std::move(v));
+    return true;
+}
+
+
+bool osal_queue_recv(void *q, uint8_t *data, size_t len, uint32_t ms)
+{
+    auto queue = static_cast<Queue<item_t> *>(q);
+    auto v = queue->receive(std::chrono::milliseconds(ms));
+    if (v != nullptr) {
+        memcpy(data, (void *)v->data(), len);
+        return true;
+    }
+    return false;
+}

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

@@ -6,8 +6,8 @@ Asio is a cross-platform C++ library, see https://think-async.com/Asio/. It prov
 
 ## Examples
 
-Get started with example test :example:`examples <examples/..>`:
+Get started with examples [examples](https://github.com/espressif/esp-protocols/tree/master/components/asio/examples)
 
 ## Documentation
 
-* View the full [html documentation](https://espressif.github.io/esp-protocols/asio/index.html)
+* View the full [html documentation](https://docs.espressif.com/projects/esp-protocols/asio/docs/latest/index.html)

components/asio/docs/generate_docs

@@ -1,26 +0,0 @@
-build-docs --target esp32 --language en
-
-cp -rf _build/en/esp32/html .
-rm -rf _build __pycache__
-
-# Modifes some version and target fields of index.html
-echo "<script type="text/javascript">
-window.onload =(function() {
-    var myAnchor = document.getElementById('version-select');
-    var mySpan = document.createElement('input');
-    mySpan.setAttribute('type', 'text');
-    mySpan.setAttribute('maxLength', '10');
-    mySpan.value = 'latest';
-    mySpan.setAttribute('disabled', true);
-    myAnchor.parentNode.replaceChild(mySpan, myAnchor);
-
-    var myAnchor = document.getElementById('target-select');
-    var mySpan = document.createElement('input');
-    mySpan.setAttribute('type', 'text');
-    mySpan.setAttribute('maxLength', '10');
-    mySpan.value = 'all targets';
-    mySpan.setAttribute('disabled', true);
-    myAnchor.parentNode.replaceChild(mySpan, myAnchor);
-
-})();
-</script>" >> html/index.html

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.1
+  version_files:
+  - idf_component.yml

components/esp_modem/CHANGELOG.md

@@ -0,0 +1,352 @@
+# Changelog
+
+## [1.0.1](https://github.com/espressif/esp-protocols/commits/modem-v1.0.1)
+
+### Bug Fixes
+
+- Support UART clean build with IDF v5.2 ([e620eb5](https://github.com/espressif/esp-protocols/commit/e620eb5))
+- enable code coverage publishing to github pages ([4910e89](https://github.com/espressif/esp-protocols/commit/4910e89))
+- fix esp_modem build issue ([ab94566](https://github.com/espressif/esp-protocols/commit/ab94566))
+- Example to use 1.0.0 ([afb6930](https://github.com/espressif/esp-protocols/commit/afb6930))
+- Changelog to correctly pick references ([423e965](https://github.com/espressif/esp-protocols/commit/423e965))
+
+### Updated
+
+- docs(esp_modem): updated documents to show missed topics ([0534853](https://github.com/espressif/esp-protocols/commit/0534853))
+- docs(common): improving documentation ([ca3fce0](https://github.com/espressif/esp-protocols/commit/ca3fce0))
+
+## [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,15 +47,3 @@ 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

@@ -17,5 +17,5 @@ Get started with one of the examples:
 
 ## Documentation
 
-* Continue with esp-modem [brief overview](docs/README.md)
-* View the full [html documentation](https://espressif.github.io/esp-protocols/esp_modem/index.html)
+* Continue with esp-modem [brief overview](https://github.com/espressif/esp-protocols/tree/master/docs/esp_modem/en/README.rst)
+* View the full [html documentation](https://docs.espressif.com/projects/esp-protocols/esp_modem/docs/latest/index.html)

components/esp_modem/docs/README.md

@@ -1,92 +0,0 @@
-# ESP MODEM
-
-This component is used to communicate with modems in the command mode (using AT commands), as well as the data mode
-(over PPPoS protocol).
-The modem device is modeled with a DCE (Data Communication Equipment) object, which is composed of:
-* DTE (Data Terminal Equipment), which abstracts the terminal (currently only UART implemented).
-* PPP Netif representing a network interface communicating with the DTE using PPP protocol.
-* Module abstracting the specific device model and its commands.
-
-```
-   +-----+
-   | DTE |--+
-   +-----+  |   +-------+
-            +-->|   DCE |
-   +-------+    |       |o--- set_mode(command/data)
-   | Module|--->|       |
-   +-------+    |       |o--- send_commands
-             +->|       |
-   +------+  |  +-------+
-   | PPP  |--+
-   | netif|------------------> network events
-   +------+
-```
-
-## Modem components
-### DCE
-
-This is the basic operational unit of the esp_modem component, abstracting a specific module in software,
-which is basically configured by
-* the I/O communication media (UART), defined by the DTE configuration
-* the specific command library supported by the device model, defined with the module type
-* network interface configuration (PPPoS config in lwip)
-
-After the object is created, the application interaction with the DCE is in
-* issuing specific commands to the modem
-* switching between data and command mode
-
-### DTE
-Is an abstraction of the physical interface connected to the modem. Current implementation supports only UART
-
-### PPP netif
-
-Is used to attach the specific network interface to a network communication protocol used by the modem. Currently implementation supports only PPPoS protocol.
-
-### Module
-
-Abstraction of the specific modem device. Currently the component supports SIM800, BG96, SIM7600.
-
-## Use cases
-
-Users interact with the esp-modem using the DCE's interface, to basically
-* Switch between command and data mode to connect to the internet via cellular network.
-* Send various commands to the device (e.g. send SMS)
-
-The applications typically register handlers for network events to receive notification on the network availability and
-IP address changes.
-
-Common use cases of the esp-modem are also listed as the examples:
-* `examples/pppos_client` -- simple client which reads some module properties and switches to the data mode to connect to a public mqtt broker.
-* `examples/modem_console` -- is an example to exercise all possible module commands in a console application.
-* `examples/ap_to_pppos` -- this example focuses on the network connectivity of the esp-modem and provides a WiFi AP that forwards packets (and uses NAT) to and from the PPPoS connection.
-
-## Extensibility
-
-### CMUX
-
-Implementation of virtual terminals is an experimental feature, which allows users to also issue commands in the data mode,
-after creating multiple virtual terminals, designating some of them solely to data mode, others solely to command mode.
-
-### DTE's
-
-Currently, we support only UART (and USB as a preview feature), but modern modules support other communication interfaces, such as USB, SPI.
-
-### Other devices
-
-Adding a new device is a must-have requirement for the esp-modem component. Different modules support different commands,
-or some commands might have a different implementation. Adding a new device means to provide a new implementation
-as a class derived from `GenericModule`, where we could add new commands or modify the existing ones.
-
-## Configuration
-
-Modem abstraction is configurable both compile-time and run-time.
-
-### Component Kconfig
-
-Compile-time configuration is provided using menuconfig. Please check the description for the CMUX mode configuration options.
-
-### Runtime configuration
-
-Is defined using standard configuration structures for `DTE` and `DCE` objects separately. Please find documentation of
-* :cpp:class:`esp_modem_dte_config_t`
-* :cpp:class:`esp_modem_dce_config_t`

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/docs/internal_design.md

@@ -1,36 +0,0 @@
-# Internal design
-
-## Design decisions
-
-* Use C++ with additional C API
-
-* Use exceptions
-  - Use macro wrapper over `try-catch` blocks when exceptions off (use `abort()` if `THROW()`)
-
-* Initializes and allocates in the constructor (might throw)
-  - easier code with exceptions ON, with exceptions OFF alloc/init failures are not treated as runtime error (program aborts)
-  - break down long initialization in constructor into more private methods
-
-* Implements different devices using inheritance from `GenericModule`, which is the most general implementation of a common modem
-  - Internally uses templates with device specialization (modeled as `DCE<SpecificModule>`) which could be used as well for some special cases,
-  such as implantation of a minimal device (ModuleIf), add new AT commands (oOnly in compile time), or using the Module with DTE only (no DCE, no Netif) for sending AT commands without network
-
-## DCE collaboration model
-
-The diagram describes how the DCE class collaborates with DTE, PPP and the device abstraction
-
-![DCE_architecture](DCE_DTE_collaboration.png)
-
-## Terminal inheritance
-
-Terminal is a class which can read or write data, and can handle callbacks when data are available. UART specialization
-is provided implementing these method using the uart driver.
-
-## CMUX terminal
-
-The below diagram depicts the idea of using CMUX terminal mode using the CMuxInstance class which is a terminal
-(it implements the basic read/write methods) interfacing arbitrary number of virtual terminals,
-but at the same time it is also composed of CMux class, which consumes the original terminal and uses its read/write methods
-to multiplex the terminal.
-
-![CMUX Terminal](CMux_collaboration.png)

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.
@@ -286,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 {
@@ -339,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_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

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

@@ -208,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.

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

@@ -1,3 +1,4 @@
+CONFIG_IDF_TARGET="esp32c3"
 # Override some defaults to enable PPP
 CONFIG_LWIP_PPP_SUPPORT=y
 CONFIG_LWIP_PPP_NOTIFY_PHASE_SUPPORT=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,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)
 
 set(EXTRA_COMPONENT_DIRS "../..")
 

components/esp_modem/idf_component.yml

@@ -1,4 +1,4 @@
-version: "0.1.27"
+version: "1.0.1"
 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

components/esp_modem/include/cxx_include/esp_modem_types.hpp

@@ -29,6 +29,7 @@ enum class modem_mode {
     UNDEF,
     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 */
+    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 */
@@ -79,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_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
@@ -100,7 +105,7 @@ struct esp_modem_dte_config {
             .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 "generate/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_dce.cpp

@@ -88,6 +88,7 @@ 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 || mode >= modem_mode::CMUX_MANUAL_MODE) {

components/esp_modem/src/esp_modem_dte.cpp

@@ -24,6 +24,16 @@ DTE::DTE(std::unique_ptr<Terminal> terminal):
     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);
@@ -104,9 +114,9 @@ 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 == modem_mode::CMUX_MANUAL_MODE) {
+        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 {
@@ -114,7 +124,7 @@ bool DTE::set_mode(modem_mode m)
         }
         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()) {
@@ -123,7 +133,7 @@ bool DTE::set_mode(modem_mode m)
             }
             mode = modem_mode::UNDEF;
             return false;
-        } if (mode == modem_mode::CMUX_MANUAL_MODE) {
+        } if (mode == modem_mode::CMUX_MANUAL_MODE || mode == modem_mode::DUAL_MODE) {
             return true;
         } else {
             mode = m;
@@ -192,6 +202,34 @@ int DTE::write(uint8_t *data, size_t 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;
+    });
+}
+
 /**
  * Implemented here to keep all headers C++11 compliant
  */

components/esp_modem/src/esp_modem_term_uart.cpp

@@ -8,6 +8,11 @@
 #include "esp_modem_config.h"
 #include "uart_resource.hpp"
 
+#ifndef UART_HW_FIFO_LEN
+// to build with IDF <= v5.1
+#define UART_HW_FIFO_LEN(uart_nr) UART_FIFO_LEN
+#endif
+
 namespace esp_modem {
 
 uart_resource::~uart_resource()
@@ -18,7 +23,7 @@ uart_resource::~uart_resource()
 }
 
 uart_resource::uart_resource(const esp_modem_uart_term_config *config, QueueHandle_t *event_queue, int fd)
-    : port(-1)
+    : port(UART_NUM_MAX)
 {
     esp_err_t res;
 
@@ -44,9 +49,9 @@ uart_resource::uart_resource(const esp_modem_uart_term_config *config, QueueHand
     ESP_MODEM_THROW_IF_ERROR(res, "config uart gpio failed");
     /* Set flow control threshold */
     if (config->flow_control == ESP_MODEM_FLOW_CONTROL_HW) {
-        res = uart_set_hw_flow_ctrl(config->port_num, UART_HW_FLOWCTRL_CTS_RTS, UART_FIFO_LEN - 8);
+        res = uart_set_hw_flow_ctrl(config->port_num, UART_HW_FLOWCTRL_CTS_RTS, UART_HW_FIFO_LEN(config->port_num) - 8);
     } else if (config->flow_control == ESP_MODEM_FLOW_CONTROL_SW) {
-        res = uart_set_sw_flow_ctrl(config->port_num, true, 8, UART_FIFO_LEN - 8);
+        res = uart_set_sw_flow_ctrl(config->port_num, true, 8, UART_HW_FIFO_LEN(config->port_num) - 8);
     }
     ESP_MODEM_THROW_IF_ERROR(res, "config uart flow control failed");