build(deps): bump actions/cache from 4 to 5

Bumps [actions/cache](https://github.com/actions/cache) from 4 to 5.
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/cache
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.gitattributes

@@ -18,6 +18,7 @@
 # These should also not be modified by git.
 tests/basics/string_cr_conversion.py -text
 tests/basics/string_crlf_conversion.py -text
+tests/micropython/test_normalize_newlines.py.exp -text
 ports/stm32/pybcdc.inf_template -text
 ports/stm32/usbhost/** -text
 ports/cc3200/hal/aes.c -text

.github/workflows/biome.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
     - name: Setup Biome
       uses: biomejs/setup-biome@v2
       with:

.github/workflows/code_formatting.yml

@@ -10,11 +10,11 @@ jobs:
   code-formatting:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_c_code_formatting_setup
+      run: tools/ci.sh c_code_formatting_setup
     - name: Run code formatting
-      run: source tools/ci.sh && ci_c_code_formatting_run
+      run: tools/ci.sh c_code_formatting_run
     - name: Check code formatting
       run: git diff --exit-code

.github/workflows/code_size.yml

@@ -25,15 +25,15 @@ jobs:
   build:
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         fetch-depth: 100
     - name: Install packages
-      run: source tools/ci.sh && ci_code_size_setup
+      run: tools/ci.sh code_size_setup
     - name: Build
-      run: source tools/ci.sh && ci_code_size_build
+      run: tools/ci.sh code_size_build
     - name: Compute code size difference
-      run: tools/metrics.py diff ~/size0 ~/size1 | tee diff
+      run: source tools/ci.sh && ci_code_size_report
     - name: Save PR number
       if: github.event_name == 'pull_request'
       env:

.github/workflows/code_size_comment.yml

@@ -15,7 +15,7 @@ jobs:
     steps:
       - name: 'Download artifact'
         id: download-artifact
-        uses: actions/github-script@v7
+        uses: actions/github-script@v8
         with:
           result-encoding: string
           script: |
@@ -56,7 +56,7 @@ jobs:
         run: unzip code-size-report.zip
       - name: Post comment to pull request
         if: steps.download-artifact.outputs.result == 'ok'
-        uses: actions/github-script@v7
+        uses: actions/github-script@v8
         with:
           github-token: ${{secrets.GITHUB_TOKEN}}
           script: |

.github/workflows/codespell.yml

@@ -6,7 +6,7 @@ jobs:
   codespell:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     # codespell version should be kept in sync with .pre-commit-config.yml
     - run: pip install --user codespell==2.4.1 tomli
     - run: codespell

.github/workflows/commit_formatting.yml

@@ -10,9 +10,9 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         fetch-depth: 100
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
     - name: Check commit message formatting
-      run: source tools/ci.sh && ci_commit_formatting_run
+      run: tools/ci.sh commit_formatting_run

.github/workflows/docs.yml

@@ -5,6 +5,8 @@ on:
   pull_request:
     paths:
       - docs/**
+      - py/**
+      - tests/cpydiff/**
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -15,9 +17,11 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
     - name: Install Python packages
       run: pip install -r docs/requirements.txt
+    - name: Build unix port
+      run: tools/ci.sh unix_build_helper
     - name: Build docs
       run: make -C docs/ html

.github/workflows/examples.yml

@@ -18,7 +18,7 @@ jobs:
   embedding:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
       run: make -C examples/embedding -f micropython_embed.mk && make -C examples/embedding
     - name: Run

.github/workflows/mpremote.yml

@@ -11,12 +11,12 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         # Setting this to zero means fetch all history and tags,
         # which hatch-vcs can use to discover the version tag.
         fetch-depth: 0
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
     - name: Install build tools
       run: pip install build
     - name: Build mpremote wheel

.github/workflows/mpy_format.yml

@@ -6,6 +6,8 @@ on:
     paths:
       - '.github/workflows/*.yml'
       - 'examples/**'
+      - 'mpy-cross/**'
+      - 'py/**'
       - 'tests/**'
       - 'tools/**'
 
@@ -15,10 +17,12 @@ concurrency:
 
 jobs:
   test:
-    runs-on: ubuntu-22.04 # use 22.04 to get python2
+    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_mpy_format_setup
+      run: tools/ci.sh mpy_format_setup
     - name: Test mpy-tool.py
-      run: source tools/ci.sh && ci_mpy_format_test
+      run: tools/ci.sh mpy_format_test
+    - name: Test mpy-cross debug emitter
+      run: tools/ci.sh mpy_cross_debug_emitter

.github/workflows/ports.yml

@@ -17,6 +17,6 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build ports download metadata
       run: mkdir boards && ./tools/autobuild/build-downloads.py . ./boards

.github/workflows/ports_alif.yml

@@ -26,8 +26,8 @@ jobs:
           - alif_ae3_build
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_alif_setup
+      run: tools/ci.sh alif_setup
     - name: Build ci_${{matrix.ci_func }}
-      run: source tools/ci.sh && ci_${{ matrix.ci_func }}
+      run: tools/ci.sh ${{ matrix.ci_func }}

.github/workflows/ports_cc3200.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_cc3200_setup
+      run: tools/ci.sh cc3200_setup
     - name: Build
-      run: source tools/ci.sh && ci_cc3200_build
+      run: tools/ci.sh cc3200_build

.github/workflows/ports_esp32.yml

@@ -12,6 +12,10 @@ on:
       - 'lib/**'
       - 'drivers/**'
       - 'ports/esp32/**'
+  schedule:
+     # Scheduled run exists to keep master branch ESP-IDF cache entry hot
+     # and prevent creating many redundant per-branch cache entries instead.
+     - cron: "20 0 * * *"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -25,9 +29,11 @@ jobs:
         ci_func:  # names are functions in ci.sh
           - esp32_build_cmod_spiram_s2
           - esp32_build_s3_c3
+          - esp32_build_c2_c5_c6
+          - esp32_build_p4
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
     - id: idf_ver
       name: Read the ESP-IDF version (including Python version)
@@ -35,7 +41,7 @@ jobs:
 
     - name: Cached ESP-IDF install
       id: cache_esp_idf
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         path: |
           ./esp-idf/
@@ -46,7 +52,7 @@ jobs:
 
     - name: Install ESP-IDF packages
       if: steps.cache_esp_idf.outputs.cache-hit != 'true'
-      run: source tools/ci.sh && ci_esp32_idf_setup
+      run: tools/ci.sh esp32_idf_setup
 
     - name: ccache
       uses: hendrikmuhs/ccache-action@v1.2
@@ -54,4 +60,4 @@ jobs:
         key: esp32-${{ matrix.ci_func }}
 
     - name: Build ci_${{matrix.ci_func }}
-      run: source tools/ci.sh && ci_${{ matrix.ci_func }}
+      run: tools/ci.sh ${{ matrix.ci_func }}

.github/workflows/ports_esp8266.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_esp8266_setup && ci_esp8266_path >> $GITHUB_PATH
+      run: tools/ci.sh esp8266_setup && tools/ci.sh esp8266_path >> $GITHUB_PATH
     - name: Build
-      run: source tools/ci.sh && ci_esp8266_build
+      run: tools/ci.sh esp8266_build

.github/workflows/ports_mimxrt.yml

@@ -24,10 +24,10 @@ jobs:
       run:
         working-directory: 'micropython repo'  # test build with space in path
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         path: 'micropython repo'
     - name: Install packages
-      run: source tools/ci.sh && ci_mimxrt_setup
+      run: tools/ci.sh mimxrt_setup
     - name: Build
-      run: source tools/ci.sh && ci_mimxrt_build
+      run: tools/ci.sh mimxrt_build

.github/workflows/ports_nrf.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_nrf_setup
+      run: tools/ci.sh nrf_setup
     - name: Build
-      run: source tools/ci.sh && ci_nrf_build
+      run: tools/ci.sh nrf_build

.github/workflows/ports_powerpc.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_powerpc_setup
+      run: tools/ci.sh powerpc_setup
     - name: Build
-      run: source tools/ci.sh && ci_powerpc_build
+      run: tools/ci.sh powerpc_build

.github/workflows/ports_qemu.yml

@@ -20,13 +20,21 @@ concurrency:
 
 jobs:
   build_and_test_arm:
+    strategy:
+      fail-fast: false
+      matrix:
+        ci_func:  # names are functions in ci.sh
+          - bigendian
+          - sabrelite
+          - thumb_softfp
+          - thumb_hardfp
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_qemu_setup_arm
-    - name: Build and run test suite
-      run: source tools/ci.sh && ci_qemu_build_arm
+      run: tools/ci.sh qemu_setup_arm
+    - name: Build and run test suite ci_qemu_build_arm_${{ matrix.ci_func }}
+      run: tools/ci.sh qemu_build_arm_${{ matrix.ci_func }}
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -34,11 +42,23 @@ jobs:
   build_and_test_rv32:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_qemu_setup_rv32
+      run: tools/ci.sh qemu_setup_rv32
     - name: Build and run test suite
-      run: source tools/ci.sh && ci_qemu_build_rv32
+      run: tools/ci.sh qemu_build_rv32
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  build_and_test_rv64:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install packages
+      run: tools/ci.sh qemu_setup_rv64
+    - name: Build and run test suite
+      run: tools/ci.sh qemu_build_rv64
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ports_renesas-ra.yml

@@ -21,9 +21,9 @@ jobs:
   build_renesas_ra_board:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_renesas_ra_setup
+      run: tools/ci.sh renesas_ra_setup
     - name: Build
-      run: source tools/ci.sh && ci_renesas_ra_board_build
+      run: tools/ci.sh renesas_ra_board_build
 

.github/workflows/ports_rp2.yml

@@ -24,10 +24,10 @@ jobs:
       run:
         working-directory: 'micropython repo'  # test build with space in path
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         path: 'micropython repo'
     - name: Install packages
-      run: source tools/ci.sh && ci_rp2_setup
+      run: tools/ci.sh rp2_setup
     - name: Build
-      run: source tools/ci.sh && ci_rp2_build
+      run: tools/ci.sh rp2_build

.github/workflows/ports_samd.yml

@@ -21,8 +21,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_samd_setup
+      run: tools/ci.sh samd_setup
     - name: Build
-      run: source tools/ci.sh && ci_samd_build
+      run: tools/ci.sh samd_build

.github/workflows/ports_stm32.yml

@@ -28,9 +28,9 @@ jobs:
           - stm32_misc_build
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_stm32_setup
+      run: tools/ci.sh stm32_setup && tools/ci.sh stm32_path >> $GITHUB_PATH
     - name: Build ci_${{matrix.ci_func }}
-      run: source tools/ci.sh && ci_${{ matrix.ci_func }}
+      run: tools/ci.sh ${{ matrix.ci_func }}
 

.github/workflows/ports_unix.yml

@@ -23,11 +23,11 @@ jobs:
   minimal:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_minimal_build
+      run: tools/ci.sh unix_minimal_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_minimal_run_tests
+      run: tools/ci.sh unix_minimal_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -35,9 +35,9 @@ jobs:
   reproducible:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build with reproducible date
-      run: source tools/ci.sh && ci_unix_minimal_build
+      run: tools/ci.sh unix_minimal_build
       env:
         SOURCE_DATE_EPOCH: 1234567890
     - name: Check reproducible build date
@@ -46,11 +46,11 @@ jobs:
   standard:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_standard_build
+      run: tools/ci.sh unix_standard_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_standard_run_tests
+      run: tools/ci.sh unix_standard_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -58,11 +58,11 @@ jobs:
   standard_v2:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_standard_v2_build
+      run: tools/ci.sh unix_standard_v2_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_standard_v2_run_tests
+      run: tools/ci.sh unix_standard_v2_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -70,19 +70,24 @@ jobs:
   coverage:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
+      # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
+      # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
+      with:
+        python-version: '3.11'
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_coverage_setup
+      run: tools/ci.sh unix_coverage_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_coverage_build
+      run: tools/ci.sh unix_coverage_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_coverage_run_tests
+      run: tools/ci.sh unix_coverage_run_tests
     - name: Test merging .mpy files
-      run: source tools/ci.sh && ci_unix_coverage_run_mpy_merge_tests
+      run: tools/ci.sh unix_coverage_run_mpy_merge_tests
     - name: Build native mpy modules
-      run: source tools/ci.sh && ci_native_mpy_modules_build
+      run: tools/ci.sh native_mpy_modules_build
     - name: Test importing .mpy generated by mpy_ld.py
-      run: source tools/ci.sh && ci_unix_coverage_run_native_mpy_tests
+      run: tools/ci.sh unix_coverage_run_native_mpy_tests
     - name: Run gcov coverage analysis
       run: |
         (cd ports/unix && gcov -o build-coverage/py ../../py/*.c || true)
@@ -100,31 +105,45 @@ jobs:
   coverage_32bit:
     runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_32bit_setup
+      run: tools/ci.sh unix_32bit_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_coverage_32bit_build
+      run: tools/ci.sh unix_coverage_32bit_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_coverage_32bit_run_tests
+      run: tools/ci.sh unix_coverage_32bit_run_tests
     - name: Build native mpy modules
-      run: source tools/ci.sh && ci_native_mpy_modules_32bit_build
+      run: tools/ci.sh native_mpy_modules_32bit_build
     - name: Test importing .mpy generated by mpy_ld.py
-      run: source tools/ci.sh && ci_unix_coverage_32bit_run_native_mpy_tests
+      run: tools/ci.sh unix_coverage_32bit_run_native_mpy_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
 
   nanbox:
-    runs-on: ubuntu-22.04 # use 22.04 to get python2, and libffi-dev:i386
+    runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_32bit_setup
+      run: tools/ci.sh unix_32bit_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_nanbox_build
+      run: tools/ci.sh unix_nanbox_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_nanbox_run_tests
+      run: tools/ci.sh unix_nanbox_run_tests
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  longlong:
+    runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install packages
+      run: tools/ci.sh unix_32bit_setup
+    - name: Build
+      run: tools/ci.sh unix_longlong_build
+    - name: Run main test suite
+      run: tools/ci.sh unix_longlong_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -132,11 +151,23 @@ jobs:
   float:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build
-      run: source tools/ci.sh && ci_unix_float_build
+      run: tools/ci.sh unix_float_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_float_run_tests
+      run: tools/ci.sh unix_float_run_tests
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  gil_enabled:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - name: Build
+      run: tools/ci.sh unix_gil_enabled_build
+    - name: Run main test suite
+      run: tools/ci.sh unix_gil_enabled_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -144,13 +175,13 @@ jobs:
   stackless_clang:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_clang_setup
+      run: tools/ci.sh unix_clang_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_stackless_clang_build
+      run: tools/ci.sh unix_stackless_clang_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_stackless_clang_run_tests
+      run: tools/ci.sh unix_stackless_clang_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -158,30 +189,13 @@ jobs:
   float_clang:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_clang_setup
+      run: tools/ci.sh unix_clang_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_float_clang_build
+      run: tools/ci.sh unix_float_clang_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_float_clang_run_tests
-    - name: Print failures
-      if: failure()
-      run: tests/run-tests.py --print-failures
-
-  settrace:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
-      # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
-      with:
-        python-version: '3.11'
-    - name: Build
-      run: source tools/ci.sh && ci_unix_settrace_build
-    - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_settrace_run_tests
+      run: tools/ci.sh unix_float_clang_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -189,31 +203,45 @@ jobs:
   settrace_stackless:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
       # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
       with:
         python-version: '3.11'
     - name: Build
-      run: source tools/ci.sh && ci_unix_settrace_stackless_build
+      run: tools/ci.sh unix_settrace_stackless_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_settrace_stackless_run_tests
+      run: tools/ci.sh unix_settrace_stackless_run_tests
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  repr_b:
+    runs-on: ubuntu-22.04 # use 22.04 to get libffi-dev:i386
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install packages
+      run: tools/ci.sh unix_32bit_setup
+    - name: Build
+      run: tools/ci.sh unix_repr_b_build
+    - name: Run main test suite
+      run: tools/ci.sh unix_repr_b_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
 
   macos:
-    runs-on: macos-latest
+    runs-on: macos-26
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
       with:
         python-version: '3.8'
     - name: Build
-      run: source tools/ci.sh && ci_unix_macos_build
+      run: tools/ci.sh unix_macos_build
     - name: Run tests
-      run: source tools/ci.sh && ci_unix_macos_run_tests
+      run: tools/ci.sh unix_macos_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -222,13 +250,13 @@ jobs:
     # ubuntu-22.04 is needed for older libffi.
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_qemu_mips_setup
+      run: tools/ci.sh unix_qemu_mips_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_qemu_mips_build
+      run: tools/ci.sh unix_qemu_mips_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_qemu_mips_run_tests
+      run: tools/ci.sh unix_qemu_mips_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -237,13 +265,13 @@ jobs:
     # ubuntu-22.04 is needed for older libffi.
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_qemu_arm_setup
+      run: tools/ci.sh unix_qemu_arm_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_qemu_arm_build
+      run: tools/ci.sh unix_qemu_arm_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_qemu_arm_run_tests
+      run: tools/ci.sh unix_qemu_arm_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures
@@ -252,13 +280,63 @@ jobs:
     # ubuntu-22.04 is needed for older libffi.
     runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_unix_qemu_riscv64_setup
+      run: tools/ci.sh unix_qemu_riscv64_setup
     - name: Build
-      run: source tools/ci.sh && ci_unix_qemu_riscv64_build
+      run: tools/ci.sh unix_qemu_riscv64_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_unix_qemu_riscv64_run_tests
+      run: tools/ci.sh unix_qemu_riscv64_run_tests
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  sanitize_address:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
+      # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
+      # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
+      with:
+        python-version: '3.11'
+    - name: Install packages
+      run: tools/ci.sh unix_coverage_setup
+    - name: Build
+      run: tools/ci.sh unix_sanitize_address_build
+    - name: Run main test suite
+      run: tools/ci.sh unix_sanitize_address_run_tests
+    - name: Test merging .mpy files
+      run: tools/ci.sh unix_coverage_run_mpy_merge_tests
+    - name: Build native mpy modules
+      run: tools/ci.sh native_mpy_modules_build
+    - name: Test importing .mpy generated by mpy_ld.py
+      run: tools/ci.sh unix_coverage_run_native_mpy_tests
+    - name: Print failures
+      if: failure()
+      run: tests/run-tests.py --print-failures
+
+  sanitize_undefined:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: actions/setup-python@v6
+      # Python 3.12 is the default for ubuntu-24.04, but that has compatibility issues with settrace tests.
+      # Can remove this step when ubuntu-latest uses a more recent Python 3.x as the default.
+      with:
+        python-version: '3.11'
+    - name: Install packages
+      run: tools/ci.sh unix_coverage_setup
+    - name: Build
+      run: tools/ci.sh unix_sanitize_undefined_build
+    - name: Run main test suite
+      run: tools/ci.sh unix_sanitize_undefined_run_tests
+    - name: Test merging .mpy files
+      run: tools/ci.sh unix_coverage_run_mpy_merge_tests
+    - name: Build native mpy modules
+      run: tools/ci.sh native_mpy_modules_build
+    - name: Test importing .mpy generated by mpy_ld.py
+      run: tools/ci.sh unix_coverage_run_native_mpy_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ports_webassembly.yml

@@ -11,6 +11,7 @@ on:
       - 'shared/**'
       - 'lib/**'
       - 'ports/webassembly/**'
+      - 'tests/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -20,13 +21,13 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_webassembly_setup
+      run: tools/ci.sh webassembly_setup
     - name: Build
-      run: source tools/ci.sh && ci_webassembly_build
+      run: tools/ci.sh webassembly_build
     - name: Run tests
-      run: source tools/ci.sh && ci_webassembly_run_tests
+      run: tools/ci.sh webassembly_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ports_windows.yml

@@ -28,13 +28,12 @@ jobs:
         visualstudio: ['2017', '2019', '2022']
         include:
         - visualstudio: '2017'
-          runner: windows-latest
           vs_version: '[15, 16)'
+          custom_vs_install: true
         - visualstudio: '2019'
-          runner: windows-2019
           vs_version: '[16, 17)'
+          custom_vs_install: true
         - visualstudio: '2022'
-          runner: windows-2022
           vs_version: '[17, 18)'
         # trim down the number of jobs in the matrix
         exclude:
@@ -42,24 +41,25 @@ jobs:
           configuration: Debug
         - visualstudio: '2019'
           configuration: Debug
+    runs-on: windows-latest
     env:
       CI_BUILD_CONFIGURATION: ${{ matrix.configuration }}
-    runs-on: ${{ matrix.runner }}
     steps:
-    - name: Install Visual Studio 2017
-      if: matrix.visualstudio == '2017'
+    - name: Install Visual Studio ${{ matrix.visualstudio }}
+      if: matrix.custom_vs_install
+      shell: bash
+      # Shell functions in this block are to retry intermittent corrupt
+      # downloads (with a clean download dir) before failing the job outright
       run: |
-        choco install visualstudio2017buildtools
-        choco install visualstudio2017-workload-vctools
-        choco install windows-sdk-8.1
+        try () { ($@) || ($@) || ($@) || ($@) }
+        clean_install () ( rm -rf $TEMP/chocolatey; choco install $1 )
+        try clean_install visualstudio${{ matrix.visualstudio }}buildtools
+        try clean_install visualstudio${{ matrix.visualstudio }}-workload-vctools
+        try clean_install windows-sdk-8.1
     - uses: microsoft/setup-msbuild@v2
       with:
         vs-version: ${{ matrix.vs_version }}
-    - uses: actions/setup-python@v5
-      if: matrix.runner == 'windows-2019'
-      with:
-        python-version: '3.9'
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build mpy-cross.exe
       run: msbuild mpy-cross\mpy-cross.vcxproj -maxcpucount -property:Configuration=${{ matrix.configuration }} -property:Platform=${{ matrix.platform }}
     - name: Update submodules
@@ -103,14 +103,14 @@ jobs:
             env: i686
           - sys: mingw64
             env: x86_64
-    runs-on: windows-2022
+    runs-on: windows-latest
     env:
       CHERE_INVOKING: enabled_from_arguments
     defaults:
       run:
         shell: msys2 {0}
     steps:
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
       # note: can go back to installing mingw-w64-${{ matrix.env }}-python after
       # MSYS2 updates to Python >3.12 (due to settrace compatibility issue)
       with:
@@ -126,7 +126,7 @@ jobs:
           git
           diffutils
         path-type: inherit  # Remove when setup-python is removed
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Build mpy-cross.exe
       run: make -C mpy-cross -j2
     - name: Update submodules
@@ -144,8 +144,8 @@ jobs:
   cross-build-on-linux:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install packages
-      run: source tools/ci.sh && ci_windows_setup
+      run: tools/ci.sh windows_setup
     - name: Build
-      run: source tools/ci.sh && ci_windows_build
+      run: tools/ci.sh windows_build

.github/workflows/ports_zephyr.yml

@@ -11,6 +11,11 @@ on:
       - 'shared/**'
       - 'lib/**'
       - 'ports/zephyr/**'
+      - 'tests/**'
+  schedule:
+     # Scheduled run exists to keep master branch Zephyr cache entry hot
+     # and prevent creating many redundant per-branch cache entries instead.
+     - cron: "40 4 * * *"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -23,19 +28,22 @@ jobs:
     - uses: jlumbroso/free-disk-space@main
       with:
         # Only free up a few things so this step runs quickly.
+        # (android would save 9.6GiB, but takes about 13m)
+        # (large-packages would save 4.6GiB, but takes about 3m)
         android: false
         dotnet: true
         haskell: true
         large-packages: false
         docker-images: false
+        tool-cache: true
         swap-storage: false
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - id: versions
       name: Read Zephyr version
       run: source tools/ci.sh && echo "ZEPHYR=$ZEPHYR_VERSION" | tee "$GITHUB_OUTPUT"
     - name: Cached Zephyr Workspace
       id: cache_workspace
-      uses: actions/cache@v4
+      uses: actions/cache@v5
       with:
         # note that the Zephyr CI docker image is 15GB. At time of writing
         # GitHub caches are limited to 10GB total for a project. So we only
@@ -47,14 +55,14 @@ jobs:
       with:
         key: zephyr
     - name: Install packages
-      run: source tools/ci.sh && ci_zephyr_setup
+      run: tools/ci.sh zephyr_setup
     - name: Install Zephyr
       if: steps.cache_workspace.outputs.cache-hit != 'true'
-      run: source tools/ci.sh && ci_zephyr_install
+      run: tools/ci.sh zephyr_install
     - name: Build
-      run: source tools/ci.sh && ci_zephyr_build
+      run: tools/ci.sh zephyr_build
     - name: Run main test suite
-      run: source tools/ci.sh && ci_zephyr_run_tests
+      run: tools/ci.sh zephyr_run_tests
     - name: Print failures
       if: failure()
       run: tests/run-tests.py --print-failures

.github/workflows/ruff.yml

@@ -6,8 +6,8 @@ jobs:
   ruff:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    # ruff version should be kept in sync with .pre-commit-config.yaml
-    - run: pipx install ruff==0.9.6
+    - uses: actions/checkout@v6
+    # ruff version should be kept in sync with .pre-commit-config.yaml & also micropython-lib
+    - run: pipx install ruff==0.11.6
     - run: ruff check --output-format=github .
     - run: ruff format --diff .

.gitignore

@@ -24,3 +24,11 @@ user.props
 
 # MacOS desktop metadata files
 .DS_Store
+
+# Created by ci.sh zephyr targets
+/.ccache
+/zephyrproject
+
+# Created by ci.sh esp8266 targets
+/xtensa-lx106-elf-standalone.tar.gz
+/xtensa-lx106-elf/

.gitmodules

@@ -35,7 +35,7 @@
 	url = https://github.com/bluekitchen/btstack.git
 [submodule "lib/nxp_driver"]
 	path = lib/nxp_driver
-	url = https://github.com/hathach/nxp_driver.git
+	url = https://github.com/micropython/nxp_driver.git
 [submodule "lib/libhydrogen"]
 	path = lib/libhydrogen
 	url = https://github.com/jedisct1/libhydrogen.git

.pre-commit-config.yaml

@@ -12,8 +12,8 @@ repos:
         verbose: true
         stages: [commit-msg]
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    # Version should be kept in sync with .github/workflows/ruff.yml
-    rev: v0.9.6
+    # Version should be kept in sync with .github/workflows/ruff.yml & also micropython-lib
+    rev: v0.11.6
     hooks:
       - id: ruff
       - id: ruff-format

CODECONVENTIONS.md

@@ -206,14 +206,21 @@ adhere to the existing style and use `tools/codeformat.py` to check any changes.
 The main conventions, and things not enforceable via the auto-formatter, are
 described below.
 
-White space:
+As the MicroPython code base is over ten years old, not every source file
+conforms fully to these conventions. If making small changes to existing code,
+then it's usually acceptable to follow the existing code's style. New code or
+major changes should follow the conventions described here.
+
+## White space
+
 - Expand tabs to 4 spaces.
 - Don't leave trailing whitespace at the end of a line.
 - For control blocks (if, for, while), put 1 space between the
   keyword and the opening parenthesis.
 - Put 1 space after a comma, and 1 space around operators.
 
-Braces:
+## Braces
+
 - Use braces for all blocks, even no-line and single-line pieces of
   code.
 - Put opening braces on the end of the line it belongs to, not on
@@ -221,18 +228,43 @@ Braces:
 - For else-statements, put the else on the same line as the previous
   closing brace.
 
-Header files:
+## Header files
+
 - Header files should be protected from multiple inclusion with #if
   directives. See an existing header for naming convention.
 
-Names:
+## Names
+
 - Use underscore_case, not camelCase for all names.
 - Use CAPS_WITH_UNDERSCORE for enums and macros.
 - When defining a type use underscore_case and put '_t' after it.
 
-Integer types: MicroPython runs on 16, 32, and 64 bit machines, so it's
-important to use the correctly-sized (and signed) integer types.  The
-general guidelines are:
+### Public names (declared in headers)
+
+- MicroPython-specific names (especially any declared in `py/` and `extmod/`
+  directories) should generally start with `mp_` or `MP_`.
+- Functions and variables declared in a header should generally share a longer
+  common prefix. Usually the prefix matches the file name (i.e. items defined in
+  `py/obj.c` are declared in `py/obj.h` and should be prefixed `mp_obj_`). There
+  are exceptions, for example where one header file contains declarations
+  implemented in multiple source files for expediency.
+
+### Private names (specific to a single .c file)
+
+- For static functions and variables exposed to Python (i.e. a static C function
+  that is wrapped in `MP_DEFINE_CONST_FUN_...` and attached to a module), use
+  the file-level shared common prefix, i.e. name them as if the function or
+  variable was not static.
+- Other static definitions in source files (i.e. functions or variables defined
+  in a .c file that are only used within that .c file) don't need any prefix
+  (specifically: no `s_` or `_` prefix, and generally avoid adding the
+  file-level common prefix).
+
+## Integer types
+
+MicroPython runs on 16, 32, and 64 bit machines, so it's important to use the
+correctly-sized (and signed) integer types. The general guidelines are:
+
 - For most cases use mp_int_t for signed and mp_uint_t for unsigned
   integer values.  These are guaranteed to be machine-word sized and
   therefore big enough to hold the value from a MicroPython small-int
@@ -241,11 +273,13 @@ general guidelines are:
 - You can use int/uint, but remember that they may be 16-bits wide.
 - If in doubt, use mp_int_t/mp_uint_t.
 
-Comments:
+## Comments
+
 - Be concise and only write comments for things that are not obvious.
 - Use `// ` prefix, NOT `/* ... */`. No extra fluff.
 
-Memory allocation:
+## Memory allocation
+
 - Use m_new, m_renew, m_del (and friends) to allocate and free heap memory.
   These macros are defined in py/misc.h.
 

README.md

@@ -80,9 +80,8 @@ This repository contains the following components:
 - [examples/](examples/) -- a few example Python scripts.
 
 "make" is used to build the components, or "gmake" on BSD-based systems.
-You will also need bash, gcc, and Python 3.3+ available as the command `python3`
-(if your system only has Python 2.7 then invoke make with the additional option
-`PYTHON=python2`). Some ports (rp2 and esp32) additionally use CMake.
+You will also need bash, gcc, and Python 3.3+ available as the command `python3`.
+Some ports (rp2 and esp32) additionally use CMake.
 
 Supported platforms & architectures
 -----------------------------------
@@ -99,28 +98,74 @@ development and testing of MicroPython itself, as well as providing
 lightweight alternative to CPython on these platforms (in particular on
 embedded Linux systems).
 
-The ["minimal"](ports/minimal) port provides an example of a very basic
-MicroPython port and can be compiled as both a standalone Linux binary as
-well as for ARM Cortex M4. Start with this if you want to port MicroPython to
-another microcontroller. Additionally the ["bare-arm"](ports/bare-arm) port
-is an example of the absolute minimum configuration, and is used to keep
-track of the code size of the core runtime and VM.
+Over twenty different MicroPython ports are provided in this repository,
+split across three
+[MicroPython Support Tiers](https://docs.micropython.org/en/latest/develop/support_tiers.html).
 
-In addition, the following ports are provided in this repository:
- - [cc3200](ports/cc3200) -- Texas Instruments CC3200 (including PyCom WiPy).
- - [esp32](ports/esp32) -- Espressif ESP32 SoC (including ESP32S2, ESP32S3, ESP32C3, ESP32C6).
- - [esp8266](ports/esp8266) -- Espressif ESP8266 SoC.
- - [mimxrt](ports/mimxrt) -- NXP m.iMX RT (including Teensy 4.x).
- - [nrf](ports/nrf) -- Nordic Semiconductor nRF51 and nRF52.
- - [pic16bit](ports/pic16bit) -- Microchip PIC 16-bit.
- - [powerpc](ports/powerpc) -- IBM PowerPC (including Microwatt)
- - [qemu](ports/qemu) -- QEMU-based emulated target (for testing)
- - [renesas-ra](ports/renesas-ra) -- Renesas RA family.
- - [rp2](ports/rp2) -- Raspberry Pi RP2040 (including Pico and Pico W).
- - [samd](ports/samd) -- Microchip (formerly Atmel) SAMD21 and SAMD51.
- - [stm32](ports/stm32) -- STMicroelectronics STM32 family (including F0, F4, F7, G0, G4, H7, L0, L4, WB)
- - [webassembly](ports/webassembly) -- Emscripten port targeting browsers and NodeJS.
- - [zephyr](ports/zephyr) -- Zephyr RTOS.
+Tier 1 Ports
+============
+
+👑 Ports in [Tier 1](https://docs.micropython.org/en/latest/develop/support_tiers.html)
+are mature and have the most active development, support and testing:
+
+| Port                     | Target                                                                                 | Quick Reference                                                      |
+|--------------------------|----------------------------------------------------------------------------------------|----------------------------------------------------------------------|
+| [esp32](ports/esp32)*    | Espressif ESP32 SoCs (ESP32, ESP32S2, ESP32S3, ESP32C3, ESP32C6)                       | [here](https://docs.micropython.org/en/latest/esp32/quickref.html)   |
+| [mimxrt](ports/mimxrt)   | NXP m.iMX RT                                                                           | [here](https://docs.micropython.org/en/latest/mimxrt/quickref.html)  |
+| [rp2](ports/rp2)         | Raspberry Pi RP2040 and RP2350                                                         | [here](https://docs.micropython.org/en/latest/rp2/quickref.html)     |
+| [samd](ports/samd)       | Microchip (formerly Atmel) SAMD21 and SAMD51                                           | [here](https://docs.micropython.org/en/latest/samd/quickref.html)    |
+| [stm32](ports/stm32)     | STMicroelectronics STM32 MCUs (F0, F4, F7, G0, G4, H5, H7, L0, L1, L4, N6, WB, WL)     | [here](https://docs.micropython.org/en/latest/pyboard/quickref.html) |
+| [unix](ports/unix)       | Linux, BSD, macOS, WSL                                                                 | [here](https://docs.micropython.org/en/latest/unix/quickref.html)    |
+| [windows](ports/windows) | Microsoft Windows                                                                      | [here](https://docs.micropython.org/en/latest/unix/quickref.html)    |
+
+An asterisk indicates that the port has ongoing financial support from the vendor.
+
+Tier 2 Ports
+============
+
+✔ Ports in [Tier 2](https://docs.micropython.org/en/latest/develop/support_tiers.html)
+are less mature and less actively developed and tested than Tier 1, but
+still fully supported:
+
+| Port                             | Target                                                      | Quick Reference                                                         |
+|----------------------------------|-------------------------------------------------------------|-------------------------------------------------------------------------|
+| [alif](ports/alif)               | Alif Semiconductor Ensemble MCUs (E3, E7)                   |                                                                         |
+| [embed](ports/embed)             | Generates a set of .c/.h files for embedding into a project |                                                                         |
+| [nrf](ports/nrf)                 | Nordic Semiconductor nRF51 and nRF52                        |                                                                         |
+| [renesas-ra](ports/renesas-ra)   | Renesas RA family                                           | [here](https://docs.micropython.org/en/latest/renesas-ra/quickref.html) |
+| [webassembly](ports/webassembly) | Emscripten port targeting browsers and NodeJS               |                                                                         |
+| [zephyr](ports/zephyr)           | Zephyr RTOS                                                 | [here](https://docs.micropython.org/en/latest/zephyr/quickref.html)     |
+
+Tier 3 Ports
+============
+
+Ports in [Tier 3](https://docs.micropython.org/en/latest/develop/support_tiers.html)
+are built in CI but not regularly tested by the MicroPython maintainers:
+
+| Port                       | Target                                                            | Quick Reference                                                         |
+|----------------------------|-------------------------------------------------------------------|-------------------------------------------------------------------------|
+| [cc3200](ports/cc3200)     | Texas Instruments CC3200                                          | [For WiPy](https://docs.micropython.org/en/latest/wipy/quickref.html)   |
+| [esp8266](ports/esp8266)   | Espressif ESP8266 SoC                                             | [here](https://docs.micropython.org/en/latest/esp8266/quickref.html)    |
+| [pic16bit](ports/pic16bit) | Microchip PIC 16-bit                                              |                                                                         |
+| [powerpc](ports/powerpc)   | IBM PowerPC (including Microwatt)                                 |                                                                         |
+
+Additional Ports
+================
+
+In addition to the above there is a Tier M containing ports that are used
+primarily for maintenance, development and testing:
+
+- The ["bare-arm"](ports/bare-arm) port is an example of the absolute minimum
+  configuration that still includes the compiler, and is used to keep track
+  of the code size of the core runtime and VM.
+
+- The ["minimal"](ports/minimal) port provides an example of a very basic
+  MicroPython port and can be compiled as both a standalone Linux binary as
+  well as for ARM Cortex-M4. Start with this if you want to port MicroPython
+  to another microcontroller.
+
+- The [qemu](ports/qemu) port is a QEMU-based emulated target for Cortex-A,
+  Cortex-M, RISC-V 32-bit and RISC-V 64-bit architectures.
 
 The MicroPython cross-compiler, mpy-cross
 -----------------------------------------

docs/README.md

@@ -13,8 +13,7 @@ Building the documentation locally
 If you're making changes to the documentation, you may want to build the
 documentation locally so that you can preview your changes.
 
-Install Sphinx, and optionally (for the RTD-styling), sphinx_rtd_theme,
-preferably in a virtualenv:
+Install Sphinx and sphinx_rtd_theme, preferably in a virtualenv:
 
      pip install sphinx
      pip install sphinx_rtd_theme
@@ -25,6 +24,21 @@ In `micropython/docs`, build the docs:
 
 You'll find the index page at `micropython/docs/build/html/index.html`.
 
+Documentation autobuild
+-----------------------
+
+For a more convenient development experience, you can use `sphinx-autobuild`
+to automatically rebuild and serve the documentation when you make changes:
+
+    pip install sphinx-autobuild
+
+Then run from the `micropython/docs` directory:
+
+    sphinx-autobuild . build/html
+
+This will start a local web server (typically at `http://127.0.0.1:8000`)
+and automatically rebuild the documentation whenever you save changes to the source files.
+
 Having readthedocs.org build the documentation
 ----------------------------------------------
 

docs/conf.py

@@ -55,6 +55,7 @@ extensions = [
     "sphinx.ext.todo",
     "sphinx.ext.coverage",
     "sphinxcontrib.jquery",
+    "sphinx_rtd_theme",
 ]
 
 # Add any paths that contain templates here, relative to this directory.
@@ -128,20 +129,9 @@ rst_epilog = """
 
 # -- Options for HTML output ----------------------------------------------
 
-# on_rtd is whether we are on readthedocs.org
-on_rtd = os.environ.get("READTHEDOCS", None) == "True"
+import sphinx_rtd_theme
 
-if not on_rtd:  # only import and set the theme if we're building docs locally
-    try:
-        import sphinx_rtd_theme
-
-        html_theme = "sphinx_rtd_theme"
-        html_theme_path = [sphinx_rtd_theme.get_html_theme_path(), "."]
-    except:
-        html_theme = "default"
-        html_theme_path = ["."]
-else:
-    html_theme_path = ["."]
+html_theme = "sphinx_rtd_theme"
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the

docs/develop/gettingstarted.rst

@@ -106,7 +106,7 @@ See the `ARM GCC
 toolchain <https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads>`_
 for the latest details.
 
-Python is also required. Python 2 is supported for now, but we recommend using Python 3.
+Python 3 is also required.
 Check that you have Python available on your system:
 
 .. code-block:: bash
@@ -282,6 +282,82 @@ To run a selection of tests on a board/device connected over USB use:
 
 See also :ref:`writingtests`.
 
+Additional make targets for developers
+--------------------------------------
+
+In all ``make``-based ports, there is a target to print the size of a specific object file.
+When a change is confined to a single file, this is useful when testing variations to find smaller alternatives.
+
+For instance, to print the size of ``objstr.o`` in the ``py/`` directory when making a unix standard build:
+
+.. code-block:: bash
+
+   $ make build-standard/py/objstr.sz
+
+Similarly, there is a target to save the preprocessed version of a file:
+
+.. code-block:: bash
+
+   $ make build-standard/py/objstr.pp
+
+In ``ports/unix`` there are additional targets related to running tests:
+
+.. code-block:: bash
+
+   $ make test//int       # Run all tests matching the pattern "int"
+   $ make test/ports/unix # Run all tests in ports/unix
+   $ make test-failures   # Re-run only the failed tests
+   $ make print-failures  # print the differences for failed tests
+   $ make clean-failures  # delete the .exp and .out files from failed tests
+
+Using ci.sh locally
+-------------------
+
+MicroPython uses GitHub Actions for continuous integration.
+To reduce dependence on any specific CI system, the actual build steps for Unix-based builds are in the file ``tools/ci.sh``.
+This can also be used as a script on developer desktops, with caveats:
+
+* For most steps, An Ubuntu/Debian system similar to the one used during CI is assumed.
+* Some specific steps assume specific Ubuntu versions.
+* The setup steps may invoke the system package manager to install packages,
+  download and install software from the internet, etc.
+
+To get a usage message including the list of commands, run:
+
+.. code-block:: bash
+
+   $ tools/ci.sh --help
+
+As an example, you can build and test the unix minimal port with:
+
+.. code-block:: bash
+
+   $ tools/ci.sh unix_minimal_build unix_minimal_run_tests
+
+If you use the bash shell, you can add a ``ci`` command with tab completion:
+
+.. code-block:: bash
+
+   $ eval $(tools/ci.sh --bash-completion)
+
+For the zsh shell, replace ``--bash-completion`` with ``--zsh-completion``.
+For the fish shell, replace ``--bash-completion`` with ``--fish-completion``.
+
+Then, typing:
+
+.. code-block:: bash
+
+   $ ci unix_cov<tab>
+
+This will complete the ci step name to ``unix_coverage_``.
+Pressing tab a second time will show the list of matching steps:
+
+.. code-block:: bash
+
+   $ ci unix_coverage_<tab>
+   unix_coverage_32bit_build
+   unix_coverage_32bit_run_native_mpy_tests…
+
 Folder structure
 ----------------
 

docs/develop/index.rst

@@ -24,3 +24,4 @@ MicroPython to a new platform and implementing a core MicroPython library.
    publiccapi.rst
    extendingmicropython.rst
    porting.rst
+   support_tiers.rst

docs/develop/natmod.rst

@@ -67,6 +67,9 @@ The known limitations are:
 
 * static BSS variables are not supported; workaround: use global BSS variables
 
+* thread-local storage variables are not supported on rv32imc; workaround: use
+  global BSS variables or allocate some space on the heap to store them
+
 So, if your C code has writable data, make sure the data is defined globally,
 without an initialiser, and only written to within functions.
 
@@ -81,7 +84,14 @@ Linker limitation: the native module is not linked against the symbol table of t
 full MicroPython firmware.  Rather, it is linked against an explicit table of exported
 symbols found in ``mp_fun_table`` (in ``py/nativeglue.h``), that is fixed at firmware
 build time.  It is thus not possible to simply call some arbitrary HAL/OS/RTOS/system
-function, for example.
+function, for example, unless that resides at a fixed address. In that case, the path
+of a linkerscript containing a series of symbol names and their fixed address can be
+passed to ``mpy_ld.py`` via the ``--externs`` command line argument. That way symbols
+appearing in the linkerscript will take precedence over what is provided from object
+files, but at the moment the object files' implementation will still reside in the
+final MPY file. The linkerscript parser is limited in its capabilities, and is
+currently used only for parsing the ESP8266 port ROM symbols list (see
+``ports/esp8266/boards/eagle.rom.addr.v6.ld``).
 
 New symbols can be added to the end of the table and the firmware rebuilt.
 The symbols also need to be added to ``tools/mpy_ld.py``'s ``fun_table`` dict in the
@@ -218,6 +228,26 @@ other module, for example::
     print(factorial.factorial(10))
     # should display 3628800
 
+Using Picolibc when building modules
+------------------------------------
+
+Using `Picolibc <https://github.com/picolibc/picolibc>`_ as your C standard
+library is not only supported, but in fact it is the default for the rv32imc
+platform.  However, there are a couple of things worth mentioning to make sure
+you don't run into problems later when building code.
+
+Some pre-built Picolibc versions (for example, those provided by Ubuntu Linux
+as the ``picolibc-arm-none-eabi``, ``picolibc-riscv64-unknown-elf``, and
+``picolibc-xtensa-lx106-elf`` packages) assume thread-local storage (TLS) is
+available at runtime, but unfortunately MicroPython modules do not support that
+on some architectures (namely ``rv32imc``).  This means that some
+functionalities provided by Picolibc will default to use TLS, returning an
+error either during compilation or during linking.
+
+For an example on how this may affect you, the ``examples/natmod/btree``
+example module contains a workaround to make sure ``errno`` works (look for
+``__PICOLIBC_ERRNO_FUNCTION`` in the Makefile and follow the trail from there).
+
 Further examples
 ----------------
 

docs/develop/porting.rst

@@ -42,7 +42,6 @@ The basic MicroPython firmware is implemented in the main port file, e.g ``main.
    #include "py/compile.h"
    #include "py/gc.h"
    #include "py/mperrno.h"
-   #include "py/stackctrl.h"
    #include "shared/runtime/gchelper.h"
    #include "shared/runtime/pyexec.h"
 
@@ -51,7 +50,7 @@ The basic MicroPython firmware is implemented in the main port file, e.g ``main.
 
    int main(int argc, char **argv) {
        // Initialise the MicroPython runtime.
-       mp_stack_ctrl_init();
+       mp_cstack_init_with_sp_here(2048);
        gc_init(heap, heap + sizeof(heap));
        mp_init();
 
@@ -162,8 +161,6 @@ The following is an example of an ``mpconfigport.h`` file:
 
    // Type definitions for the specific machine.
 
-   typedef intptr_t mp_int_t; // must be pointer size
-   typedef uintptr_t mp_uint_t; // must be pointer size
    typedef long mp_off_t;
 
    // We need to provide a declaration/definition of alloca().

docs/develop/support_tiers.rst

@@ -0,0 +1,68 @@
+MicroPython Support Tiers
+=========================
+
+MicroPython operates with a set of Support Tier levels for the various ports.
+Tiers 1, 2 and 3 are the main Tier levels with Tier 1 being the most mature and
+actively maintained.  There is also Tier M for additional ports used primarily
+for maintenance, development and testing. These Tier levels are defined in the
+table below.
+
+.. table::
+  :widths: 40 9 9 9 9
+
+  +-----------------------------------------------+--------+--------+--------+--------+
+  |                                               | Tier 1 | Tier 2 | Tier 3 | Tier M |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | builds pass under CI                          | ✔      | ✔      | ✔      | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | tests run under CI (where possible)           | ✔      | ✔      | ✔      | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | actively maintained                           | ✔      | ✔      |        | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | stable Python API                             | ✔      | ✔      |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | new features actively developed               | ✔      | ✔      |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | tested on hardware for releases               | ✔      | ✔      |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | prioritized bug reports                       | ✔      |        |        | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | regressions warrant a patch release           | ✔      |        |        | ✔      |
+  +-----------------------------------------------+--------+--------+--------+--------+
+  | has port-specific documentation               | ✔      |        |        |        |
+  +-----------------------------------------------+--------+--------+--------+--------+
+
+Lower Tiers may tick more boxes, but the above table defines the minimum requirements
+for a port to belong to a Tier.
+
+Tier 1 ports:
+
+  - esp32
+  - mimxrt
+  - rp2
+  - samd
+  - stm32
+  - unix
+  - windows
+
+Tier 2 ports:
+
+  - alif
+  - embed
+  - nrf
+  - renesas-ra
+  - webassembly
+  - zephyr
+
+Tier 3 ports:
+
+  - cc3200
+  - esp8266
+  - pic16bit
+  - powerpc
+
+Tier M ports:
+
+  - bare-arm
+  - minimal
+  - qemu

docs/differences/python_36.rst

@@ -25,7 +25,8 @@ Python 3.6 beta 1 was released on 12 Sep 2016, and a summary of the new features
   +--------------------------------------------------------+--------------------------------------------------+-----------------+
   | `PEP 468 <https://www.python.org/dev/peps/pep-0468/>`_ | Preserving the order of *kwargs* in a function   |                 |
   +--------------------------------------------------------+--------------------------------------------------+-----------------+
-  | `PEP 487 <https://www.python.org/dev/peps/pep-0487/>`_ | Simpler customization of class creation          |                 |
+  | `PEP 487 <https://www.python.org/dev/peps/pep-0487/>`_ | Simpler customization of class creation          | Partial         |
+  |                                                        |                                                  | [#setname]_     |
   +--------------------------------------------------------+--------------------------------------------------+-----------------+
   | `PEP 520 <https://www.python.org/dev/peps/pep-0520/>`_ | Preserving Class Attribute Definition Order      |                 |
   +--------------------------------------------------------+--------------------------------------------------+-----------------+
@@ -198,3 +199,7 @@ Changes to built-in modules:
   +--------------------------------------------------------------------------------------------------------------+----------------+
   | The *compress()* and *decompress()* functions now accept keyword arguments                                   |                |
   +--------------------------------------------------------------------------------------------------------------+----------------+
+
+.. rubric:: Notes
+
+.. [#setname] Currently, only :func:`__set_name__` is implemented.

docs/esp32/quickref.rst

@@ -148,6 +148,7 @@ Required keyword arguments for the constructor:
 - ``mdc`` and ``mdio`` - :class:`machine.Pin` objects (or integers) specifying
   the MDC and MDIO pins.
 - ``phy_type`` - Select the PHY device type. Supported devices are
+  ``PHY_GENERIC``,
   ``PHY_LAN8710``, ``PHY_LAN8720``, ``PHY_IP101``, ``PHY_RTL8201``,
   ``PHY_DP83848``, ``PHY_KSZ8041`` and ``PHY_KSZ8081``. These values are all
   constants defined in the ``network`` module.
@@ -270,8 +271,10 @@ Use the :mod:`time <time>` module::
 Timers
 ------
 
-The ESP32 port has four hardware timers. Use the :ref:`machine.Timer <machine.Timer>` class
-with a timer ID from 0 to 3 (inclusive)::
+The ESP32 port has one, two or four hardware timers, depending on the ESP32 device type.
+There is 1 timer for ESP32C2, 2 timers for ESP32C4, ESP32C6 and ESP32H4, and
+4 timers otherwise. Use the :ref:`machine.Timer <machine.Timer>` class
+with a timer ID of 0, 0 and 1, or from 0 to 3 (inclusive)::
 
     from machine import Timer
 
@@ -281,7 +284,12 @@ with a timer ID from 0 to 3 (inclusive)::
     tim1 = Timer(1)
     tim1.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(1))
 
-The period is in milliseconds.
+The period is in milliseconds. When using UART.IRQ_RXIDLE, timer 0 is needed for
+the IRQ_RXIDLE mechanism and must not be used otherwise.
+
+Timer callbacks are scheduled as soft interrupts on this port; hard
+callbacks are not implemented. Specifying ``hard=True`` will raise
+a ValueError.
 
 Virtual timers are not currently supported on this port.
 
@@ -383,7 +391,7 @@ for more details.
 
 Use the :ref:`machine.PWM <machine.PWM>` class::
 
-    from machine import Pin, PWM
+    from machine import Pin, PWM, lightsleep
 
     pwm0 = PWM(Pin(0), freq=5000, duty_u16=32768) # create PWM object from a pin
     freq = pwm0.freq()         # get current frequency
@@ -393,7 +401,7 @@ Use the :ref:`machine.PWM <machine.PWM>` class::
     pwm0.duty(256)             # set duty cycle from 0 to 1023 as a ratio duty/1023, (now 25%)
 
     duty_u16 = pwm0.duty_u16() # get current duty cycle, range 0-65535
-    pwm0.duty_u16(2**16*3//4)  # set duty cycle from 0 to 65535 as a ratio duty_u16/65535, (now 75%)
+    pwm0.duty_u16(65536*3//4)  # set duty cycle from 0 to 65535 as a ratio duty_u16/65535, (now 75%)
 
     duty_ns = pwm0.duty_ns()   # get current pulse width in ns
     pwm0.duty_ns(250_000)      # set pulse width in nanoseconds from 0 to 1_000_000_000/freq, (now 25%)
@@ -402,19 +410,35 @@ Use the :ref:`machine.PWM <machine.PWM>` class::
 
     pwm2 = PWM(Pin(2), freq=20000, duty=512)  # create and configure in one go
     print(pwm2)                               # view PWM settings
+    pwm2.deinit()                             # turn off PWM on the pin
+
+    pwm0 = PWM(Pin(0), duty_u16=16384)            # The output is at a high level 25% of the time.
+    pwm2 = PWM(Pin(2), duty_u16=16384, invert=1)  # The output is at a low level 25% of the time.
+
+    pwm4 = PWM(Pin(4), lightsleep=True)           # Allow PWM during light sleep mode
+
+    lightsleep(10*1000) # pwm0, pwm2 goes off, pwm4 stays on during 10s light sleep
+                        # pwm0, pwm2, pwm4 on after 10s light sleep
 
 ESP chips have different hardware peripherals:
 
-=====================================================  ========  ========  ========
-Hardware specification                                    ESP32  ESP32-S2  ESP32-C3
------------------------------------------------------  --------  --------  --------
-Number of groups (speed modes)                                2         1         1
-Number of timers per group                                    4         4         4
-Number of channels per group                                  8         8         6
------------------------------------------------------  --------  --------  --------
-Different PWM frequencies (groups * timers)                   8         4         4
-Total PWM channels (Pins, duties) (groups * channels)        16         8         6
-=====================================================  ========  ========  ========
+=======================================================  ========  =========  ==========
+Hardware specification                                      ESP32  ESP32-S2,  ESP32-C2,
+                                                                   ESP32-S3,  ESP32-C3,
+                                                                   ESP32-P4   ESP32-C5,
+                                                                              ESP32-C6,
+                                                                              ESP32-H2
+-------------------------------------------------------  --------  ---------  ----------
+Number of groups (speed modes)                                  2          1         1
+Number of timers per group                                      4          4         4
+Number of channels per group                                    8          8         6
+-------------------------------------------------------  --------  ---------  ----------
+Different PWM frequencies = (groups * timers)                   8          4         4
+Total PWM channels (Pins, duties) = (groups * channels)        16          8         6
+=======================================================  ========  =========  ==========
+
+In light sleep, the ESP32 PWM can only operate in low speed mode, so only 4 timers and
+8 channels are available.
 
 A maximum number of PWM channels (Pins) are available on the ESP32 - 16 channels,
 but only 8 different PWM frequencies are available, the remaining 8 channels must
@@ -524,14 +548,63 @@ Legacy methods:
 
     Equivalent to ``ADC.block().init(bits=bits)``.
 
-For compatibility, the ``ADC`` object also provides constants matching the
-supported ADC resolutions:
+The only chip that can switch resolution to a lower one is the normal esp32.
+The C2 & S3 are stuck at 12 bits, while the S2 is at 13 bits.
 
+For compatibility, the ``ADC`` object also provides constants matching the
+supported ADC resolutions, per chip:
+
+ESP32:
   - ``ADC.WIDTH_9BIT`` = 9
   - ``ADC.WIDTH_10BIT`` = 10
   - ``ADC.WIDTH_11BIT`` = 11
   - ``ADC.WIDTH_12BIT`` = 12
 
+ESP32 C3 & S3:
+  - ``ADC.WIDTH_12BIT`` = 12
+
+ESP32 S2:
+  - ``ADC.WIDTH_13BIT`` = 13
+
+.. method:: ADC.deinit()
+
+    Provided to deinit the adc driver.
+
+Pulse Counter (pin pulse/edge counting)
+---------------------------------------
+
+The ESP32 provides up to 8 pulse counter peripherals depending on the hardware,
+with id 0..7. These can be configured to count rising and/or falling edges on
+any input pin.
+
+Use the :ref:`esp32.PCNT <esp32.PCNT>` class::
+
+    from machine import Pin
+    from esp32 import PCNT
+
+    counter = PCNT(0, pin=Pin(2), rising=PCNT.INCREMENT)        # create counter
+    counter.start()                                             # start counter
+    count = counter.value()                                     # read count, -32768..32767
+    counter.value(0)                                            # reset counter
+    count = counter.value(0)                                    # read and reset
+
+The PCNT hardware supports monitoring multiple pins in a single unit to
+implement quadrature decoding or up/down signal counters.
+
+See the :ref:`machine.Counter <machine.Counter>` and
+:ref:`machine.Encoder <machine.Encoder>` classes for simpler abstractions of
+common pulse counting applications::
+
+    from machine import Pin, Counter
+
+    counter = Counter(0, Pin(2))    # create a counter as above and start it
+    count = counter.value()         # read the count as an arbitrary precision signed integer
+
+    encoder = Encoder(0, Pin(12), Pin(14))    # create an encoder and begin counting
+    count = encoder.value()                   # read the count as an arbitrary precision signed integer
+
+Note that the id passed to these ``Counter()`` and ``Encoder()`` objects must be
+a PCNT id.
 
 Software SPI bus
 ----------------
@@ -764,11 +837,14 @@ The RMT is ESP32-specific and allows generation of accurate digital pulses with
     import esp32
     from machine import Pin
 
-    r = esp32.RMT(0, pin=Pin(18), clock_div=8)
-    r   # RMT(channel=0, pin=18, source_freq=80000000, clock_div=8)
-    # The channel resolution is 100ns (1/(source_freq/clock_div)).
+    r = esp32.RMT(pin=Pin(18), resolution_hz=10000000)
+    r   # RMT(pin=18, source_freq=80000000, resolution_hz=10000000)
+    # The channel resolution is based on resolution_hz, i.e. 100ns for 10000000
     r.write_pulses((1, 20, 2, 40), 0) # Send 0 for 100ns, 1 for 2000ns, 0 for 200ns, 1 for 4000ns
 
+The ESP32-C2 family does not include any RMT peripheral, so this class is
+unavailable on those SoCs.
+
 OneWire driver
 --------------
 
@@ -827,8 +903,7 @@ The APA106 driver extends NeoPixel, but internally uses a different colour order
    ``NeoPixel`` object.
 
 For low-level driving of a NeoPixel see `machine.bitstream`.
-This low-level driver uses an RMT channel by default.  To configure this see
-`RMT.bitstream_channel`.
+This low-level driver uses an RMT channel by default.
 
 APA102 (DotStar) uses a different driver as it has an additional clock pin.
 

docs/esp32/tutorial/pwm.rst

@@ -11,16 +11,20 @@ compared with the length of a single period (low plus high time).  Maximum
 duty cycle is when the pin is high all of the time, and minimum is when it is
 low all of the time.
 
-* More comprehensive example with all 16 PWM channels and 8 timers::
+* More comprehensive example with all **16 PWM channels and 8 timers**::
 
+    from time import sleep
     from machine import Pin, PWM
     try:
-        f = 100  # Hz
-        d = 1024 // 16  # 6.25%
-        pins = (15, 2, 4, 16, 18, 19, 22, 23, 25, 26, 27, 14 , 12, 13, 32, 33)
+        F = 10000  # Hz
+        D = 65536 // 16  # 6.25%
+        pins = (2, 4, 12, 13, 14, 15, 16, 18, 19, 22, 23, 25, 26, 27, 32, 33)
         pwms = []
         for i, pin in enumerate(pins):
-            pwms.append(PWM(Pin(pin), freq=f * (i // 2 + 1), duty= 1023 if i==15 else d * (i + 1)))
+            f = F * (i // 2 + 1)
+            d = min(65535, D * (i + 1))
+            pwms.append(PWM(pin, freq=f, duty_u16=d))
+            sleep(2 / f)
             print(pwms[i])
     finally:
         for pwm in pwms:
@@ -31,65 +35,100 @@ low all of the time.
 
   Output is::
 
-    PWM(Pin(15), freq=100, duty=64, resolution=10, mode=0, channel=0, timer=0)
-    PWM(Pin(2), freq=100, duty=128, resolution=10, mode=0, channel=1, timer=0)
-    PWM(Pin(4), freq=200, duty=192, resolution=10, mode=0, channel=2, timer=1)
-    PWM(Pin(16), freq=200, duty=256, resolution=10, mode=0, channel=3, timer=1)
-    PWM(Pin(18), freq=300, duty=320, resolution=10, mode=0, channel=4, timer=2)
-    PWM(Pin(19), freq=300, duty=384, resolution=10, mode=0, channel=5, timer=2)
-    PWM(Pin(22), freq=400, duty=448, resolution=10, mode=0, channel=6, timer=3)
-    PWM(Pin(23), freq=400, duty=512, resolution=10, mode=0, channel=7, timer=3)
-    PWM(Pin(25), freq=500, duty=576, resolution=10, mode=1, channel=0, timer=0)
-    PWM(Pin(26), freq=500, duty=640, resolution=10, mode=1, channel=1, timer=0)
-    PWM(Pin(27), freq=600, duty=704, resolution=10, mode=1, channel=2, timer=1)
-    PWM(Pin(14), freq=600, duty=768, resolution=10, mode=1, channel=3, timer=1)
-    PWM(Pin(12), freq=700, duty=832, resolution=10, mode=1, channel=4, timer=2)
-    PWM(Pin(13), freq=700, duty=896, resolution=10, mode=1, channel=5, timer=2)
-    PWM(Pin(32), freq=800, duty=960, resolution=10, mode=1, channel=6, timer=3)
-    PWM(Pin(33), freq=800, duty=1023, resolution=10, mode=1, channel=7, timer=3)
+    PWM(Pin(2), freq=10000, duty_u16=4096)
+    PWM(Pin(4), freq=10000, duty_u16=8192)
+    PWM(Pin(12), freq=20000, duty_u16=12288)
+    PWM(Pin(13), freq=20000, duty_u16=16384)
+    PWM(Pin(14), freq=30030, duty_u16=20480)
+    PWM(Pin(15), freq=30030, duty_u16=24576)
+    PWM(Pin(16), freq=40000, duty_u16=28672)
+    PWM(Pin(18), freq=40000, duty_u16=32768)
+    PWM(Pin(19), freq=50000, duty_u16=36864)
+    PWM(Pin(22), freq=50000, duty_u16=40960)
+    PWM(Pin(23), freq=60060, duty_u16=45056)
+    PWM(Pin(25), freq=60060, duty_u16=49152)
+    PWM(Pin(26), freq=69930, duty_u16=53248)
+    PWM(Pin(27), freq=69930, duty_u16=57344)
+    PWM(Pin(32), freq=80000, duty_u16=61440)
+    PWM(Pin(33), freq=80000, duty_u16=65535)
 
-* Example of a smooth frequency change::
+
+* Example of a **smooth frequency change**::
 
     from time import sleep
     from machine import Pin, PWM
 
-    F_MIN = 500
-    F_MAX = 1000
+    F_MIN = 1000
+    F_MAX = 10000
 
     f = F_MIN
-    delta_f = 1
+    delta_f = F_MAX // 50
 
-    p = PWM(Pin(5), f)
-    print(p)
+    pwm = PWM(Pin(27), f)
 
     while True:
-        p.freq(f)
-
-        sleep(10 / F_MIN)
+        pwm.freq(f)
+        sleep(1 / f)
+        sleep(0.1)
+        print(pwm)
 
         f += delta_f
-        if f >= F_MAX or f <= F_MIN:
+        if f > F_MAX or f < F_MIN:
             delta_f = -delta_f
+            print()
+            if f > F_MAX:
+                f = F_MAX
+            elif f < F_MIN:
+                f = F_MIN
 
-  See PWM wave at Pin(5) with an oscilloscope.
+  See PWM wave on Pin(27) with an oscilloscope.
 
-* Example of a smooth duty change::
+  Output is::
+
+    PWM(Pin(27), freq=998, duty_u16=32768)
+    PWM(Pin(27), freq=1202, duty_u16=32768)
+    PWM(Pin(27), freq=1401, duty_u16=32768)
+    PWM(Pin(27), freq=1598, duty_u16=32768)
+    ...
+    PWM(Pin(27), freq=9398, duty_u16=32768)
+    PWM(Pin(27), freq=9615, duty_u16=32768)
+    PWM(Pin(27), freq=9804, duty_u16=32768)
+    PWM(Pin(27), freq=10000, duty_u16=32768)
+
+    PWM(Pin(27), freq=10000, duty_u16=32768)
+    PWM(Pin(27), freq=9804, duty_u16=32768)
+    PWM(Pin(27), freq=9615, duty_u16=32768)
+    PWM(Pin(27), freq=9398, duty_u16=32768)
+    ...
+    PWM(Pin(27), freq=1598, duty_u16=32768)
+    PWM(Pin(27), freq=1401, duty_u16=32768)
+    PWM(Pin(27), freq=1202, duty_u16=32768)
+    PWM(Pin(27), freq=998, duty_u16=32768)
+
+
+* Example of a **smooth duty change**::
 
     from time import sleep
     from machine import Pin, PWM
 
-    DUTY_MAX = 2**16 - 1
+    DUTY_MAX = 65535
 
     duty_u16 = 0
-    delta_d = 16
+    delta_d = 256
 
-    p = PWM(Pin(5), 1000, duty_u16=duty_u16)
-    print(p)
+    pwm = PWM(Pin(27), freq=1000, duty_u16=duty_u16)
 
     while True:
-        p.duty_u16(duty_u16)
+        pwm.duty_u16(duty_u16)
+        sleep(2 / pwm.freq())
+        print(pwm)
 
-        sleep(1 / 1000)
+        if duty_u16 >= DUTY_MAX:
+            print()
+            sleep(2)
+        elif duty_u16 <= 0:
+            print()
+            sleep(2)
 
         duty_u16 += delta_d
         if duty_u16 >= DUTY_MAX:
@@ -99,9 +138,106 @@ low all of the time.
             duty_u16 = 0
             delta_d = -delta_d
 
-  See PWM wave at Pin(5) with an oscilloscope.
+  PWM wave on Pin(27) with an oscilloscope.
 
-Note: the Pin.OUT mode does not need to be specified.  The channel is initialized
+  Output is::
+
+    PWM(Pin(27), freq=998, duty_u16=0)
+    PWM(Pin(27), freq=998, duty_u16=256)
+    PWM(Pin(27), freq=998, duty_u16=512)
+    PWM(Pin(27), freq=998, duty_u16=768)
+    PWM(Pin(27), freq=998, duty_u16=1024)
+    ...
+    PWM(Pin(27), freq=998, duty_u16=64512)
+    PWM(Pin(27), freq=998, duty_u16=64768)
+    PWM(Pin(27), freq=998, duty_u16=65024)
+    PWM(Pin(27), freq=998, duty_u16=65280)
+    PWM(Pin(27), freq=998, duty_u16=65535)
+
+    PWM(Pin(27), freq=998, duty_u16=65279)
+    PWM(Pin(27), freq=998, duty_u16=65023)
+    PWM(Pin(27), freq=998, duty_u16=64767)
+    PWM(Pin(27), freq=998, duty_u16=64511)
+    ...
+    PWM(Pin(27), freq=998, duty_u16=1023)
+    PWM(Pin(27), freq=998, duty_u16=767)
+    PWM(Pin(27), freq=998, duty_u16=511)
+    PWM(Pin(27), freq=998, duty_u16=255)
+    PWM(Pin(27), freq=998, duty_u16=0)
+
+
+* Example of a **smooth duty change and PWM output inversion**::
+
+    from utime import sleep
+    from machine import Pin, PWM
+
+    try:
+        DUTY_MAX = 65535
+
+        duty_u16 = 0
+        delta_d = 65536 // 32
+
+        pwm = PWM(Pin(27))
+        pwmi = PWM(Pin(32), invert=1)
+
+        while True:
+            pwm.duty_u16(duty_u16)
+            pwmi.duty_u16(duty_u16)
+
+            duty_u16 += delta_d
+            if duty_u16 >= DUTY_MAX:
+                duty_u16 = DUTY_MAX
+                delta_d = -delta_d
+            elif duty_u16 <= 0:
+                duty_u16 = 0
+                delta_d = -delta_d
+
+            sleep(.01)
+            print(pwm)
+            print(pwmi)
+
+    finally:
+        try:
+            pwm.deinit()
+        except:
+            pass
+        try:
+            pwmi.deinit()
+        except:
+            pass
+
+  Output is::
+
+    PWM(Pin(27), freq=5000, duty_u16=0)
+    PWM(Pin(32), freq=5000, duty_u16=32768, invert=1)
+    PWM(Pin(27), freq=5000, duty_u16=2048)
+    PWM(Pin(32), freq=5000, duty_u16=2048, invert=1)
+    PWM(Pin(27), freq=5000, duty_u16=4096)
+    PWM(Pin(32), freq=5000, duty_u16=4096, invert=1)
+    PWM(Pin(27), freq=5000, duty_u16=6144)
+    PWM(Pin(32), freq=5000, duty_u16=6144, invert=1)
+    PWM(Pin(27), freq=5000, duty_u16=8192)
+    PWM(Pin(32), freq=5000, duty_u16=8192, invert=1)
+    ...
+
+
+  See PWM waves on Pin(27) and Pin(32) with an oscilloscope.
+
+Note: New PWM parameters take effect in the next PWM cycle.
+
+    pwm = PWM(2, duty=512)
+    print(pwm)
+    >>> PWM(Pin(2), freq=5000, duty=1023)  # the duty is not relevant
+    pwm.init(freq=2, duty=64)
+    print(pwm)
+    >>> PWM(Pin(2), freq=2, duty=16)  # the duty is not relevant
+    time.sleep(1 / 2)                # wait one PWM period
+    print(pwm)
+    >>> PWM(Pin(2), freq=2, duty=64)  # the duty is actual
+
+Note: machine.freq(20_000_000) reduces the highest PWM frequency to 10 MHz.
+
+Note: the Pin.OUT mode does not need to be specified. The channel is initialized
 to PWM mode internally once for each Pin that is passed to the PWM constructor.
 
 The following code is wrong::

docs/esp8266/quickref.rst

@@ -108,6 +108,9 @@ with timer ID of -1::
 
 The period is in milliseconds.
 
+By default, timer callbacks are scheduled as soft interrupts on this port.
+Specify ``hard=True`` to run them in hard interrupt context instead.
+
 Pins and GPIO
 -------------
 

docs/library/bluetooth.rst

@@ -764,4 +764,5 @@ Constructor
     The **value** can be either:
 
     - A 16-bit integer. e.g. ``0x2908``.
+    - An object with the buffer protocol and that is 2, 4 or 16 bytes long, e.g. ``b'\x08\x29'``.
     - A 128-bit UUID string. e.g. ``'6E400001-B5A3-F393-E0A9-E50E24DCCA9E'``.

docs/library/btree.rst

@@ -151,10 +151,10 @@ Constants
 
 .. data:: INCL
 
-   A flag for `keys()`, `values()`, `items()` methods to specify that
+   A flag for :meth:`btree.keys`, :meth:`btree.values`, :meth:`btree.items` methods to specify that
    scanning should be inclusive of the end key.
 
 .. data:: DESC
 
-   A flag for `keys()`, `values()`, `items()` methods to specify that
+   A flag for :meth:`btree.keys`, :meth:`btree.values`, :meth:`btree.items` methods to specify that
    scanning should be in descending direction of keys.

docs/library/collections.rst

@@ -101,3 +101,19 @@ Classes
         a 2
         w 5
         b 3
+
+    .. method:: OrderedDict.popitem()
+
+        Remove and return a (key, value) pair from the dictionary.
+        Pairs are returned in LIFO order.
+
+        .. admonition:: Difference to CPython
+            :class: attention
+
+            ``OrderedDict.popitem()`` does not support the ``last=False`` argument and
+            will always remove and return the last item if present.
+
+            A workaround for this is to use ``pop(<first_key>)`` to remove the first item::
+
+                first_key = next(iter(d))
+                d.pop(first_key)

docs/library/esp32.rst

@@ -18,23 +18,40 @@ Functions
     Configure whether or not a touch will wake the device from sleep.
     *wake* should be a boolean value.
 
+    .. note:: This is only available for boards that have touch sensor support.
+
 .. function:: wake_on_ulp(wake)
 
     Configure whether or not the Ultra-Low-Power co-processor can wake the
     device from sleep. *wake* should be a boolean value.
 
+    .. note:: This is only available for boards that have ULP coprocessor support.
+
 .. function:: wake_on_ext0(pin, level)
 
     Configure how EXT0 wakes the device from sleep.  *pin* can be ``None``
     or a valid Pin object.  *level* should be ``esp32.WAKEUP_ALL_LOW`` or
     ``esp32.WAKEUP_ANY_HIGH``.
 
+    .. note:: This is only available for boards that have ext0 support.
+
 .. function:: wake_on_ext1(pins, level)
 
     Configure how EXT1 wakes the device from sleep.  *pins* can be ``None``
     or a tuple/list of valid Pin objects.  *level* should be ``esp32.WAKEUP_ALL_LOW``
     or ``esp32.WAKEUP_ANY_HIGH``.
 
+    .. note:: This is only available for boards that have ext1 support.
+
+.. function:: wake_on_gpio(pins, level)
+
+    Configure how GPIO wakes the device from sleep.  *pins* can be ``None``
+    or a tuple/list of valid Pin objects.  *level* should be ``esp32.WAKEUP_ALL_LOW``
+    or ``esp32.WAKEUP_ANY_HIGH``.
+
+    .. note:: Some boards don't support waking on GPIO from deep sleep,
+       on those boards, the pins set here can only be used to wake from light sleep.
+
 .. function:: gpio_deep_sleep_hold(enable)
 
     Configure whether non-RTC GPIO pin configuration is retained during
@@ -80,6 +97,29 @@ Functions
        The result of :func:`gc.mem_free()` is the total of the current "free"
        and "max new split" values printed by :func:`micropython.mem_info()`.
 
+.. function:: idf_task_info()
+
+    Returns information about running ESP-IDF/FreeRTOS tasks, which include
+    MicroPython threads. This data is useful to gain insight into how much time
+    tasks spend running or if they are blocked for significant parts of time,
+    and to determine if allocated stacks are fully utilized or might be reduced.
+
+    ``CONFIG_FREERTOS_USE_TRACE_FACILITY=y`` must be set in the board
+    configuration to make this method available. Additionally configuring
+    ``CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=y`` and
+    ``CONFIG_FREERTOS_VTASKLIST_INCLUDE_COREID=y`` is recommended to be able to
+    retrieve the total and per-task runtime and the core ID respectively.
+
+    The return value is a 2-tuple where the first value is the total runtime,
+    and the second a list of tasks. Each task is a 7-tuple containing: the task
+    ID, name, current state, priority, runtime, stack high water mark, and the
+    ID of the core it is running on. Runtime and core ID will be None when the
+    respective FreeRTOS configuration option is not enabled.
+
+    .. note:: For an easier to use output based on this function you can use the
+       `utop library <https://github.com/micropython/micropython-lib/tree/master/micropython/utop>`_,
+       which implements a live overview similar to the Unix ``top`` command.
+
 
 Flash partitions
 ----------------
@@ -164,6 +204,151 @@ Constants
 
     Used in `idf_heap_info`.
 
+
+.. _esp32.PCNT:
+
+PCNT
+----
+
+This class provides access to the ESP32 hardware support for pulse counting.
+There are 8 pulse counter units, with id 0..7.
+
+See the :ref:`machine.Counter <machine.Counter>` and
+:ref:`machine.Encoder <machine.Encoder>` classes for simpler and portable
+abstractions of common pulse counting applications. These classes are
+implemented as thin Python shims around :class:`PCNT`.
+
+.. class:: PCNT(id, *, ...)
+
+    Returns the singleton PCNT instance for the given unit ``id``.
+
+    Keyword arguments are passed to the ``init()`` method as described
+    below.
+
+.. method:: PCNT.init(*, ...)
+
+    (Re-)initialise a pulse counter unit. Supported keyword arguments are:
+
+      - ``channel``: see description below
+      - ``pin``: the input Pin to monitor for pulses
+      - ``rising``: an action to take on a rising edge - one of
+        ``PCNT.INCREMENT``, ``PCNT.DECREMENT`` or ``PCNT.IGNORE`` (the default)
+      - ``falling``: an action to take on a falling edge (takes the save values
+        as the ``rising`` argument).
+      - ``mode_pin``: ESP32 pulse counters support monitoring a second pin and
+        altering the behaviour of the counter based on its level - set this
+        keyword to any input Pin
+      - ``mode_low``: set to either ``PCNT.HOLD`` or ``PCNT.REVERSE`` to
+        either suspend counting or reverse the direction of the counter (i.e.,
+        ``PCNT.INCREMENT`` behaves as ``PCNT.DECREMENT`` and vice versa)
+        when ``mode_pin`` is low
+      - ``mode_high``: as ``mode_low`` but for the behaviour when ``mode_pin``
+        is high
+      - ``filter``: set to a value 1..1023, in ticks of the 80MHz clock, to
+        enable the pulse width filter
+      - ``min``: set to the minimum level of the counter value when
+        decrementing (-32768..-1) or 0 to disable
+      - ``max``: set to the maximum level of the counter value when
+        incrementing (1..32767) or 0 to disable
+      - ``threshold0``: sets the counter value for the
+        ``PCNT.IRQ_THRESHOLD0`` event (see ``irq`` method)
+      - ``threshold1``: sets the counter value for the
+        ``PCNT.IRQ_THRESHOLD1`` event (see ``irq`` method)
+      - ``value``: can be set to ``0`` to reset the counter value
+
+    The hardware initialisation is done in stages and so some of the keyword
+    arguments can be used in groups or in isolation to partially reconfigure a
+    unit:
+
+      - the ``pin`` keyword (optionally combined with ``mode_pin``) can be used
+        to change just the bound pin(s)
+      - ``rising``, ``falling``, ``mode_low`` and ``mode_high`` can be used
+        (singly or together) to change the counting logic - omitted keywords
+        use their default (``PCNT.IGNORE`` or ``PCNT.NORMAL``)
+      - ``filter`` can be used to change only the pulse width filter (with 0
+        disabling it)
+      - each of ``min``, ``max``, ``threshold0`` and ``threshold1`` can
+        be used to change these limit/event values individually; however,
+        setting any will reset the counter to zero (i.e., they imply
+        ``value=0``)
+
+    Each pulse counter unit supports two channels, 0 and 1, each able to
+    monitor different pins with different counting logic but updating the same
+    counter value. Use ``channel=1`` with the ``pin``, ``rising``, ``falling``,
+    ``mode_pin``, ``mode_low`` and ``mode_high`` keywords to configure the
+    second channel.
+
+    The second channel can be used to configure 4X quadrature decoding with a
+    single counter unit::
+
+        pin_a = Pin(2, Pin.INPUT, pull=Pin.PULL_UP)
+        pin_b = Pin(3, Pin.INPUT, pull=Pin.PULL_UP)
+        rotary = PCNT(0, min=-32000, max=32000)
+        rotary.init(channel=0, pin=pin_a, falling=PCNT.INCREMENT, rising=PCNT.DECREMENT, mode_pin=pin_b, mode_low=PCNT.REVERSE)
+        rotary.init(channel=1, pin=pin_b, falling=PCNT.DECREMENT, rising=PCNT.INCREMENT, mode_pin=pin_a, mode_low=PCNT.REVERSE)
+        rotary.start()
+
+.. method:: PCNT.value([value])
+
+    Call this method with no arguments to return the current counter value.
+
+    If the optional *value* argument is set to ``0`` then the counter is
+    reset (but the previous value is returned). Read and reset is not atomic and
+    so it is possible for a pulse to be missed. Any value other than ``0`` will
+    raise an error.
+
+.. method:: PCNT.irq(handler=None, trigger=PCNT.IRQ_ZERO)
+
+    ESP32 pulse counters support interrupts on these counter events:
+
+      - ``PCNT.IRQ_ZERO``: the counter has reset to zero
+      - ``PCNT.IRQ_MIN``: the counter has hit the ``min`` value
+      - ``PCNT.IRQ_MAX``: the counter has hit the ``max`` value
+      - ``PCNT.IRQ_THRESHOLD0``: the counter has hit the ``threshold0`` value
+      - ``PCNT.IRQ_THRESHOLD1``: the counter has hit the ``threshold1`` value
+
+    ``trigger`` should be a bit-mask of the desired events OR'ed together. The
+    ``handler`` function should take a single argument which is the
+    :class:`PCNT` instance that raised the event.
+
+    This method returns a callback object. The callback object can be used to
+    access the bit-mask of events that are outstanding on the PCNT unit.::
+
+        def pcnt_irq(pcnt):
+            flags = pcnt.irq().flags()
+            if flags & PCNT.IRQ_ZERO:
+               # reset
+            if flags & PCNT.IRQ_MAX:
+               # overflow...
+            ... etc
+
+        pcnt.irq(handler=pcnt_irq, trigger=PCNT.IRQ_ZERO | PCNT.IRQ_MAX | ...)
+
+    **Note:** Accessing ``irq.flags()`` will clear the flags, so only call it
+    once per invocation of the handler.
+
+    The handler is called with the MicroPython scheduler and so will run at a
+    point after the interrupt. If another interrupt occurs before the handler
+    has been called then the events will be coalesced together into a single
+    call and the bit mask will indicate all events that have occurred.
+
+    To avoid race conditions between a handler being called and retrieving the
+    current counter value, the ``value()`` method will force execution of any
+    pending events before returning the current counter value (and potentially
+    resetting the value).
+
+    Only one handler can be in place per-unit. Set ``handler`` to ``None`` to
+    disable the event interrupt.
+
+.. Note::
+    ESP32 pulse counters reset to *zero* when reaching the minimum or maximum
+    value. Thus the ``IRQ_ZERO`` event will also trigger when either of these
+    events occurs.
+
+See the :ref:`machine.Counter <machine.Counter>` and
+:ref:`machine.Encoder <machine.Encoder>` classes for simpler abstractions of
+common pulse counting applications.
+
 .. _esp32.RMT:
 
 RMT
@@ -177,29 +362,24 @@ used to transmit or receive many other types of digital signals::
     import esp32
     from machine import Pin
 
-    r = esp32.RMT(0, pin=Pin(18), clock_div=8)
-    r  # RMT(channel=0, pin=18, source_freq=80000000, clock_div=8, idle_level=0)
+    r = esp32.RMT(pin=Pin(18), resolution_hz=10000000)
+    r  # RMT(pin=18, source_freq=80000000, resolution_hz=10000000, idle_level=0)
 
     # To apply a carrier frequency to the high output
-    r = esp32.RMT(0, pin=Pin(18), clock_div=8, tx_carrier=(38000, 50, 1))
+    r = esp32.RMT(pin=Pin(18), resolution_hz=10000000, tx_carrier=(38000, 50, 1))
 
-    # The channel resolution is 100ns (1/(source_freq/clock_div)).
+    # The channel resolution is 100ns (1/resolution_hz)
     r.write_pulses((1, 20, 2, 40), 0)  # Send 0 for 100ns, 1 for 2000ns, 0 for 200ns, 1 for 4000ns
 
 The input to the RMT module is an 80MHz clock (in the future it may be able to
-configure the input clock but, for now, it's fixed). ``clock_div`` *divides*
-the clock input which determines the resolution of the RMT channel. The
-numbers specified in ``write_pulses`` are multiplied by the resolution to
+configure the input clock but, for now, it's fixed). ``resolution_hz`` determines
+the resolution of the RMT channel. The numbers specified in ``write_pulses`` are
+multiplied by the resolution to
 define the pulses.
 
-``clock_div`` is an 8-bit divider (0-255) and each pulse can be defined by
-multiplying the resolution by a 15-bit (1-``PULSE_MAX``) number. There are eight
-channels (0-7) and each can have a different clock divider.
-
-So, in the example above, the 80MHz clock is divided by 8. Thus the
-resolution is (1/(80Mhz/8)) 100ns. Since the ``start`` level is 0 and toggles
-with each number, the bitstream is ``0101`` with durations of [100ns, 2000ns,
-100ns, 4000ns].
+So, in the example above, the resolution is resolution is (1/10Mhz) = 100ns.
+Since the ``start`` level is 0 and toggles with each number, the bitstream is
+``0101`` with durations of [100ns, 2000ns, 100ns, 4000ns].
 
 For more details see Espressif's `ESP-IDF RMT documentation.
 <https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/peripherals/rmt.html>`_.
@@ -210,13 +390,24 @@ For more details see Espressif's `ESP-IDF RMT documentation.
    *beta feature* and the interface may change in the future.
 
 
-.. class:: RMT(channel, *, pin=None, clock_div=8, idle_level=False, tx_carrier=None)
+.. class:: RMT(channel, *, pin=None, resolution_hz=10000000, clock_div=None, idle_level=False, num_symbols=48|64, tx_carrier=None)
 
     This class provides access to one of the eight RMT channels. *channel* is
-    required and identifies which RMT channel (0-7) will be configured. *pin*,
-    also required, configures which Pin is bound to the RMT channel. *clock_div*
-    is an 8-bit clock divider that divides the source clock (80MHz) to the RMT
-    channel allowing the resolution to be specified. *idle_level* specifies
+    optional and a dummy parameter for backward compatibility. *pin* is required
+    and configures which Pin is bound to the RMT channel.
+    *resolution_hz* defines the resolution/unit of the samples.
+    For example, 1,000,000 means the unit is microsecond. The pulse widths can
+    assume values up to *RMT.PULSE_MAX*, so the resolution should be selected
+    accordingly to the signal to be transmitted.
+    *clock_div* (deprecated) is equivalent to *resolution_hz*, but expressed as
+    a clock divider that divides the source clock (80MHz) to the RMT
+    channel allowing the resolution to be specified. Either *clock_div* and
+    *resolution_hz* may be supplied, but not both.
+    *num_symbols* specifies the
+    RMT buffer allocated for this channel (minimum 48 or 64, depending on chip), from a small pool of
+    symbols (192 to 512, depending on chip) that are shared by all channels. This buffer does not limit the
+    size of the pulse train that you can send, but bigger buffers reduce the
+    CPU load and the potential of glitches/imprecise pulse lengths. *idle_level* specifies
     what level the output will be when no transmission is in progress and can
     be any value that converts to a boolean, with ``True`` representing high
     voltage and ``False`` representing low.
@@ -234,21 +425,52 @@ For more details see Espressif's `ESP-IDF RMT documentation.
 .. method:: RMT.clock_div()
 
     Return the clock divider. Note that the channel resolution is
-    ``1 / (source_freq / clock_div)``.
+    ``1 / (source_freq / clock_div)``. (Method deprecated. The value may
+    not be faithful if resolution was supplied as *resolution_hz*.)
 
 .. method:: RMT.wait_done(*, timeout=0)
 
     Returns ``True`` if the channel is idle or ``False`` if a sequence of
     pulses started with `RMT.write_pulses` is being transmitted. If the
     *timeout* keyword argument is given then block for up to this many
-    milliseconds for transmission to complete.
+    milliseconds for transmission to complete. Timeout of -1 blocks until
+    transmission is complete (and blocks forever if loop is enabled).
 
 .. method:: RMT.loop(enable_loop)
 
     Configure looping on the channel. *enable_loop* is bool, set to ``True`` to
     enable looping on the *next* call to `RMT.write_pulses`. If called with
     ``False`` while a looping sequence is currently being transmitted then the
-    current loop iteration will be completed and then transmission will stop.
+    transmission will stop. (Method deprecated by `RMT.loop_count`.)
+
+.. method:: RMT.loop_count(n)
+
+    Configure looping on the channel. *n* is int. Affects the *next* call to
+    `RMT.write_pulses`. Set to ``0`` to disable looping, ``-1`` to enable
+    infinite looping, or a positive number to loop for a given number of times.
+    If *n* is changed, the current transmission is stopped.
+
+    Note: looping for a finite number of times is not supported by all flavors
+    of ESP32.
+
+.. method:: RMT.active([boolean])
+
+    If called without parameters, returns *True* if there is an ongoing transmission.
+
+    If called with parameter *False*, stops the ongoing transmission.
+    This is useful to stop an infinite transmission loop.
+    The current loop is finished and transmission stops.
+    The object is not invalidated, and the RMT channel is again enabled when a new
+    transmission is started.
+
+    Calling with parameter *True* does not restart transmission. A new transmission
+    should always be initiated by *write_pulses()*.
+
+.. method:: RMT.deinit()
+
+    Release all RMT resources and invalidate the object. All subsequent method
+    calls will raise OSError. Useful to free RMT resources without having to wait
+    for the object to be garbage-collected.
 
 .. method:: RMT.write_pulses(duration, data=True)
 
@@ -278,17 +500,28 @@ For more details see Espressif's `ESP-IDF RMT documentation.
     new sequence of pulses. Looping sequences longer than 126 pulses is not
     supported by the hardware.
 
+.. staticmethod:: RMT.bitstream_rmt([value])
+
+    Configure RMT usage in the `machine.bitstream` implementation.
+
+    If *value* is ``True``, bitstream tries to use RMT if possible. If *value*
+    is ``False``, bitstream sticks to the bit-banging implementation.
+
+    If no parameter is supplied, it returns the current state. The default state
+    is ``True``.
+
 .. staticmethod:: RMT.bitstream_channel([value])
 
-    Select which RMT channel is used by the `machine.bitstream` implementation.
-    *value* can be ``None`` or a valid RMT channel number.  The default RMT
-    channel is the highest numbered one.
+    *This function is deprecated and will be replaced by `RMT.bitstream_rmt()`.*
 
-    Passing in ``None`` disables the use of RMT and instead selects a bit-banging
-    implementation for `machine.bitstream`.
+    Passing in no argument will return ``1`` if RMT was enabled for the `machine.bitstream`
+    feature, and ``None`` otherwise.
 
-    Passing in no argument will not change the channel.  This function returns
-    the current channel number.
+    Passing any non-negative integer argument is equivalent to calling ``RMT.bitstream_rmt(True)``.
+
+    .. note:: In previous versions of MicroPython it was necessary to use this function to assign
+              a specific RMT channel number for the bitstream, but the channel number is now assigned
+              dynamically.
 
 Constants
 ---------

docs/library/espnow.rst

@@ -164,13 +164,15 @@ Configuration
         wait forever. The timeout can also be provided as arg to
         `recv()`/`irecv()`/`recvinto()`.
 
-        *rate*: (ESP32 only) Set the transmission speed for
-        ESPNow packets. Must be set to a number from the allowed numeric values
-        in `enum wifi_phy_rate_t
-        <https://docs.espressif.com/projects/esp-idf/en/v5.2.3/esp32/
+        *rate*: (ESP32 only) Set the transmission data rate for ESPNow packets.
+        The default setting is `espnow.RATE_1M`. It's recommended to use one of
+        the other ``espnow.RATE_nnn`` constants to set this, but it's also
+        possible to pass an integer corresponding to the `enum wifi_phy_rate_t
+        <https://docs.espressif.com/projects/esp-idf/en/v5.5.1/esp32/
         api-reference/network/esp_wifi.html#_CPPv415wifi_phy_rate_t>`_. This
         parameter is actually *write-only* due to ESP-IDF not providing any
         means for querying the radio interface's rate parameter.
+        See also `espnow-long-range`. This API currently doesn't work on ESP32-C6.
 
     .. data:: Returns:
 
@@ -574,6 +576,45 @@ Constants
           espnow.MAX_TOTAL_PEER_NUM(=20)
           espnow.MAX_ENCRYPT_PEER_NUM(=6)
 
+The following constants correspond to different transmit data rates on ESP32
+only. Lower data rates are generally more reliable over long distances:
+
+.. data:: espnow.RATE_LORA_250K
+          espnow.RATE_LORA_500K
+
+             See  `espnow-long-range`.
+
+.. data:: espnow.RATE_1M
+          espnow.RATE_2M
+          espnow.RATE_5M
+          espnow.RATE_6M
+          espnow.RATE_11M
+          espnow.RATE_12M
+          espnow.RATE_24M
+          espnow.RATE_54M
+
+Unless using the two proprietary long range data rates, only the sender must
+configure the data rate.
+
+.. _espnow-long-range:
+
+Long Range Mode
+---------------
+
+(ESP32 Only, except ESP32-C2)
+
+To use the `espnow.RATE_LORA_250K` and `espnow.RATE_LORA_500K` data rates,
+first set the `WLAN` interface object to long-range mode, i.e.::
+
+  import network, espnow
+  sta = network.WLAN(network.WLAN.IF_STA)
+  sta.active(True)
+  sta.config(channel=6, protocol=WLAN.PROTOCOL_LR)  # Set on sender & receiver
+  e = espnow.ESPNow()
+  e.config(rate=espnow.RATE_LORA_250K)  # Needed on sender only
+
+For more information about the limitations of long-range mode, see `WLAN.PROTOCOL_LR`.
+
 Exceptions
 ----------
 

docs/library/framebuf.rst

@@ -137,6 +137,18 @@ Other methods
     is compared to the value from *palette*, not to the value directly from
     *fbuf*.)
 
+    *fbuf* can be another FrameBuffer instance, or a tuple or list of the form::
+
+        (buffer, width, height, format)
+
+    or::
+
+        (buffer, width, height, format, stride)
+
+    This matches the signature of the FrameBuffer constructor, and the elements
+    of the tuple/list are the same as the arguments to the constructor except that
+    the *buffer* here can be read-only.
+
     The *palette* argument enables blitting between FrameBuffers with differing
     formats. Typical usage is to render a monochrome or grayscale glyph/icon to
     a color display. The *palette* is a FrameBuffer instance whose format is

docs/library/machine.Counter.rst

@@ -0,0 +1,93 @@
+.. currentmodule:: machine
+.. _machine.Counter:
+
+class Counter -- pulse counter
+==============================
+
+Counter implements pulse counting by monitoring an input signal and counting
+rising or falling edges.
+
+Minimal example usage::
+
+    from machine import Pin, Counter
+
+    counter = Counter(0, Pin(0, Pin.IN))  # create Counter for pin 0 and begin counting
+    value = counter.value()               # retrieve current pulse count
+
+Availability: **ESP32**
+
+Constructors
+------------
+
+.. class:: Counter(id, ...)
+
+   Returns the singleton Counter object for the the given *id*. Values of *id*
+   depend on a particular port and its hardware. Values 0, 1, etc. are commonly
+   used to select hardware block #0, #1, etc.
+
+   Additional arguments are passed to the :meth:`init` method described below,
+   and will cause the Counter instance to be re-initialised and reset.
+
+   On ESP32, the *id* corresponds to a :ref:`PCNT unit <esp32.PCNT>`.
+
+Methods
+-------
+
+.. method:: Counter.init(src, *, ...)
+
+   Initialise and reset the Counter with the given parameters:
+
+   - *src* specifies the input pin as a :ref:`machine.Pin <machine.Pin>` object.
+     May be omitted on ports that have a predefined pin for a given hardware
+     block.
+
+   Additional keyword-only parameters that may be supported by a port are:
+
+   - *edge* specifies the edge to count. Either ``Counter.RISING`` (the default)
+     or ``Counter.FALLING``. *(Supported on ESP32)*
+
+   - *direction* specifies the direction to count. Either ``Counter.UP`` (the
+     default) or ``Counter.DOWN``. *(Supported on ESP32)*
+
+   - *filter_ns* specifies a minimum period of time in nanoseconds that the
+     source signal needs to be stable for a pulse to be counted. Implementations
+     should use the longest filter supported by the hardware that is less than
+     or equal to this value. The default is 0 (no filter). *(Supported on ESP32)*
+
+.. method:: Counter.deinit()
+
+   Stops the Counter, disabling any interrupts and releasing hardware resources.
+   A Soft Reset should deinitialize all Counter objects.
+
+.. method:: Counter.value([value])
+
+   Get, and optionally set, the counter value as a signed integer.
+   Implementations must aim to do the get and set atomically (i.e. without
+   leading to skipped counts).
+
+   This counter value could exceed the range of a :term:`small integer`, which
+   means that calling :meth:`Counter.value` could cause a heap allocation, but
+   implementations should aim to ensure that internal state only uses small
+   integers and therefore will not allocate until the user calls
+   :meth:`Counter.value`.
+
+   For example, on ESP32, the internal state counts overflows of the hardware
+   counter (every 32000 counts), which means that it will not exceed the small
+   integer range until ``2**30 * 32000`` counts (slightly over 1 year at 1MHz).
+
+   In general, it is recommended that you should use ``Counter.value(0)`` to reset
+   the counter (i.e. to measure the counts since the last call), and this will
+   avoid this problem.
+
+Constants
+---------
+
+.. data:: Counter.RISING
+          Counter.FALLING
+
+   Select the pulse edge.
+
+.. data:: Counter.UP
+          Counter.DOWN
+
+   Select the counting direction.

docs/library/machine.DAC.rst

@@ -0,0 +1,68 @@
+.. currentmodule:: machine
+.. _machine.DAC:
+
+class DAC -- digital to analog conversion
+=========================================
+
+The DAC is used to output an analog voltage based on a digital value.
+
+The output voltage will be between 0 and 3.3V.
+
+DAC is currently supported on ESP32 [#esp32_dac]_, SAMD and Renesas RA.
+
+.. note::
+  The STM32 port has similar functionality to ``machine.DAC``. See
+  :ref:`pyb.DAC <pyb.DAC>` for details.
+
+Example usage (ESP32)::
+
+    from machine import DAC
+
+    dac = DAC(pin)    # create a DAC object acting on a pin
+    dac.write(128)    # write a value to the DAC
+    dac.write(255)    # output maximum value, 3.3V
+
+Constructors
+------------
+
+.. class:: DAC(id)
+
+  Construct a new DAC object.
+
+  ``id`` is a pin object (ESP32 and Renesas RA) or an index to a DAC resource (SAMD).
+
+.. note::
+  On the ESP32, DAC functionality is available on pins 25 and 26. On the
+  ESP32-S2, pins 17 and 18. See :ref:`ESP32 Quickref <esp32_quickref>`
+  for more details.
+
+.. note::
+  SAMD21 has one DAC resource, SAMD51 has two. See :ref:`SAMD Quickref <samd_quickref>`
+  for more details.
+
+Methods
+-------
+
+.. method:: DAC.write(value)
+
+  Output an analog voltage to the pin connected to the DAC.
+
+  ``value`` is a representation of the desired output; a linear interpolation of
+  0-3.3V, though the range differs depending on the port and micro, see below:
+
+  +--------------+------+--------+
+  | *Port/micro* | Bits | Range  |
+  +==============+======+========+
+  | ESP32        | 8    | 0-255  |
+  +--------------+------+--------+
+  | SAMD21       | 10   | 0-1023 |
+  +--------------+------+--------+
+  | SAMD51       | 12   | 0-4095 |
+  +--------------+------+--------+
+  | Renesas RA   | 12   | 0-4095 |
+  +--------------+------+--------+
+
+.. rubric:: Footnotes
+
+.. [#esp32_dac] The original ESP32 and ESP32-S2 *only*, since DAC hardware is
+    not present on other microcontrollers in the family.

docs/library/machine.Encoder.rst

@@ -0,0 +1,72 @@
+.. currentmodule:: machine
+.. _machine.Encoder:
+
+class Encoder -- quadrature decoding
+====================================
+
+Encoder implements decoding of quadrature signals as commonly output from
+rotary encoders, by counting either up or down depending on the order of two
+input pulses.
+
+Minimal example usage::
+
+    from machine import Pin, Encoder
+
+    counter = Counter(0, Pin(0, Pin.IN), Pin(1, Pin.IN))   # create Encoder for pins 0, 1 and begin counting
+    value = counter.value()                                # retrieve current count
+
+Availability: **ESP32**
+
+Constructors
+------------
+
+.. class:: Encoder(id, ...)
+
+   Returns the singleton Encoder object for the the given *id*. Values of *id*
+   depend on a particular port and its hardware. Values 0, 1, etc. are commonly
+   used to select hardware block #0, #1, etc.
+
+   Additional arguments are passed to the :meth:`init` method described below,
+   and will cause the Encoder instance to be re-initialised and reset.
+
+   On ESP32, the *id* corresponds to a :ref:`PCNT unit <esp32.PCNT>`.
+
+Methods
+-------
+
+.. method:: Encoder.init(phase_a, phase_b, *, ...)
+
+   Initialise and reset the Encoder with the given parameters:
+
+   - *phase_a* specifies the first input pin as a
+     :ref:`machine.Pin <machine.Pin>` object.
+
+   - *phase_b* specifies the second input pin as a
+     :ref:`machine.Pin <machine.Pin>` object.
+
+   These pins may be omitted on ports that have predefined pins for a given
+   hardware block.
+
+   Additional keyword-only parameters that may be supported by a port are:
+
+   - *filter_ns* specifies a minimum period of time in nanoseconds that the
+     source signal needs to be stable for a pulse to be counted. Implementations
+     should use the longest filter supported by the hardware that is less than
+     or equal to this value. The default is 0 (no filter). *(Supported on ESP32)*
+
+   - *phases* specifies the number of signal edges to count and thus the
+     granularity of the decoding. e.g. 4 phases corresponds to "4x quadrature
+     decoding", and will result in four counts per pulse. Ports may support
+     either 1, 2, or 4 phases and the default is 1 phase. *(Supported on ESP32)*
+
+.. method:: Encoder.deinit()
+
+   Stops the Encoder, disabling any interrupts and releasing hardware resources.
+   A Soft Reset should deinitialize all Encoder objects.
+
+.. method:: Encoder.value([value])
+
+   Get, and optionally set, the encoder value as a signed integer.
+   Implementations should aim to do the get and set atomically.
+
+   See :meth:`machine.Counter.value` for details about overflow of this value.

docs/library/machine.I2CTarget.rst

@@ -0,0 +1,174 @@
+.. currentmodule:: machine
+.. _machine.I2CTarget:
+
+class I2CTarget -- an I2C target device
+=======================================
+
+An I2C target is a device which connects to an I2C bus and is controlled by an
+I2C controller.  I2C targets can take many forms.  The :class:`machine.I2CTarget`
+class implements an I2C target that can be configured as a memory/register device,
+or as an arbitrary I2C device by using callbacks (if supported by the port).
+
+Example usage for the case of a memory device::
+
+    from machine import I2CTarget
+
+    # Create the backing memory for the I2C target.
+    mem = bytearray(8)
+
+    # Create an I2C target.  Depending on the port, extra parameters
+    # may be required to select the peripheral and/or pins to use.
+    i2c = I2CTarget(addr=67, mem=mem)
+
+    # At this point an I2C controller can read and write `mem`.
+    ...
+
+    # Deinitialise the I2C target.
+    i2c.deinit()
+
+Note that some ports require an ``id``, and maybe ``scl`` and ``sda`` pins, to be
+passed to the `I2CTarget` constructor, to select the hardware I2C instance and
+pins that it connects to.
+
+When configured as a memory device, it's also possible to register to receive events.
+For example to be notified when the memory is read/written::
+
+    from machine import I2CTarget
+
+    # Define an IRQ handler, for I2C events.
+    def irq_handler(i2c_target):
+        flags = i2c_target.irq().flags()
+        if flags & I2CTarget.IRQ_END_READ:
+            print("controller read target at addr", i2c_target.memaddr)
+        if flags & I2CTarget.IRQ_END_WRITE:
+            print("controller wrote target at addr", i2c_target.memaddr)
+
+    # Create the I2C target and register to receive default events.
+    mem = bytearray(8)
+    i2c = I2CTarget(addr=67, mem=mem)
+    i2c.irq(irq_handler)
+
+More complicated I2C devices can be implemented using the full set of events.  For
+example, to see the raw events as they are triggered::
+
+    from machine import I2CTarget
+
+    # Define an IRQ handler that prints the event id and responds to reads/writes.
+    def irq_handler(i2c_target, buf=bytearray(1)):
+        flags = i2c_target.irq().flags()
+        print(flags)
+        if flags & I2CTarget.IRQ_READ_REQ:
+            i2c_target.write(buf)
+        if flags & I2CTarget.IRQ_WRITE_REQ:
+            i2c_target.readinto(buf)
+
+    # Create the I2C target and register to receive all events.
+    i2c = I2CTarget(addr=67)
+    all_triggers = (
+        I2CTarget.IRQ_ADDR_MATCH_READ
+        | I2CTarget.IRQ_ADDR_MATCH_WRITE
+        | I2CTarget.IRQ_READ_REQ
+        | I2CTarget.IRQ_WRITE_REQ
+        | I2CTarget.IRQ_END_READ
+        | I2CTarget.IRQ_END_WRITE
+    )
+    i2c.irq(irq_handler, trigger=all_triggers, hard=True)
+
+Constructors
+------------
+
+.. class:: I2CTarget(id, addr, *, addrsize=7, mem=None, mem_addrsize=8, scl=None, sda=None)
+
+   Construct and return a new I2CTarget object using the following parameters:
+
+      - *id* identifies a particular I2C peripheral.  Allowed values depend on the
+        particular port/board.  Some ports have a default in which case this parameter
+        can be omitted.
+      - *addr* is the I2C address of the target.
+      - *addrsize* is the number of bits in the I2C target address.  Valid values
+        are 7 and 10.
+      - *mem* is an object with the buffer protocol that is writable.  If not
+        specified then there is no backing memory and data must be read/written
+        using the :meth:`I2CTarget.readinto` and :meth:`I2CTarget.write` methods.
+      - *mem_addrsize* is the number of bits in the memory address.  Valid values
+        are 0, 8, 16, 24 and 32.
+      - *scl* is a pin object specifying the pin to use for SCL.
+      - *sda* is a pin object specifying the pin to use for SDA.
+
+   Note that some ports/boards will have default values of *scl* and *sda*
+   that can be changed in this constructor.  Others will have fixed values
+   of *scl* and *sda* that cannot be changed.
+
+General Methods
+---------------
+
+.. method:: I2CTarget.deinit()
+
+   Deinitialise the I2C target.  After this method is called the hardware will no
+   longer respond to requests on the I2C bus, and no other methods can be called.
+
+.. method:: I2CTarget.readinto(buf)
+
+   Read into the given buffer any pending bytes written by the I2C controller.
+   Returns the number of bytes read.
+
+.. method:: I2CTarget.write(buf)
+
+   Write out the bytes from the given buffer, to be passed to the I2C controller
+   after it sends a read request.  Returns the number of bytes written.  Most ports
+   only accept one byte at a time to this method.
+
+.. method:: I2CTarget.irq(handler=None, trigger=IRQ_END_READ|IRQ_END_WRITE, hard=False)
+
+   Configure an IRQ *handler* to be called when an event occurs.  The possible events are
+   given by the following constants, which can be or'd together and passed to the *trigger*
+   argument:
+
+      - ``IRQ_ADDR_MATCH_READ`` indicates that the target was addressed by a
+        controller for a read transaction.
+      - ``IRQ_ADDR_MATCH_WRITE`` indicates that the target was addressed by a
+        controller for a write transaction.
+      - ``IRQ_READ_REQ`` indicates that the controller is requesting data, and this
+        request must be satisfied by calling `I2CTarget.write` with the data to be
+        passed back to the controller.
+      - ``IRQ_WRITE_REQ`` indicates that the controller has written data, and the
+        data must be read by calling `I2CTarget.readinto`.
+      - ``IRQ_END_READ`` indicates that the controller has finished a read transaction.
+      - ``IRQ_END_WRITE`` indicates that the controller has finished a write transaction.
+
+   Not all triggers are available on all ports.  If a port has the constant then that
+   event is available.
+
+   Note the following restrictions:
+
+      - ``IRQ_ADDR_MATCH_READ``, ``IRQ_ADDR_MATCH_WRITE``, ``IRQ_READ_REQ`` and
+        ``IRQ_WRITE_REQ`` must be handled by a hard IRQ callback (with the *hard* argument
+        set to ``True``).  This is because these events have very strict timing requirements
+        and must usually be satisfied synchronously with the hardware event.
+
+      - ``IRQ_END_READ`` and ``IRQ_END_WRITE`` may be handled by either a soft or hard
+        IRQ callback (although note that all events must be registered with the same handler,
+        so if any events need a hard callback then all events must be hard).
+
+      - If a memory buffer has been supplied in the constructor then ``IRQ_END_WRITE``
+        is not emitted for the transaction that writes the memory address.  This is to
+        allow ``IRQ_END_READ`` and ``IRQ_END_WRITE`` to function correctly as soft IRQ
+        callbacks, where the IRQ handler may be called quite some time after the actual
+        hardware event.
+
+.. attribute:: I2CTarget.memaddr
+
+   The integer value of the most recent memory address that was selected by the I2C
+   controller (only valid if ``mem`` was specified in the constructor).
+
+Constants
+---------
+
+.. data:: I2CTarget.IRQ_ADDR_MATCH_READ
+          I2CTarget.IRQ_ADDR_MATCH_WRITE
+          I2CTarget.IRQ_READ_REQ
+          I2CTarget.IRQ_WRITE_REQ
+          I2CTarget.IRQ_END_READ
+          I2CTarget.IRQ_END_WRITE
+
+    IRQ trigger sources.

docs/library/machine.PWM.rst

@@ -11,20 +11,20 @@ Example usage::
     from machine import PWM
 
     pwm = PWM(pin, freq=50, duty_u16=8192)  # create a PWM object on a pin
-                                            # and set freq and duty
-    pwm.duty_u16(32768)     # set duty to 50%
+                                            # and set freq 50 Hz and duty 12.5%
+    pwm.duty_u16(32768)                     # set duty to 50%
 
     # reinitialise with a period of 200us, duty of 5us
     pwm.init(freq=5000, duty_ns=5000)
 
-    pwm.duty_ns(3000)       # set pulse width to 3us
+    pwm.duty_ns(3000)                       # set pulse width to 3us
 
     pwm.deinit()
 
 Constructors
 ------------
 
-.. class:: PWM(dest, *, freq, duty_u16, duty_ns, invert)
+.. class:: PWM(dest, *, freq, duty_u16, duty_ns, invert=False)
 
    Construct and return a new PWM object using the following parameters:
 
@@ -40,7 +40,7 @@ Constructors
    Setting *freq* may affect other PWM objects if the objects share the same
    underlying PWM generator (this is hardware specific).
    Only one of *duty_u16* and *duty_ns* should be specified at a time.
-   *invert* is not available at all ports.
+   *invert* is available only on the esp32, mimxrt, nrf, rp2, samd and zephyr ports.
 
 Methods
 -------
@@ -116,10 +116,10 @@ Limitations of PWM
   resolution of 8 bit, not 16-bit as may be expected.  In this case, the lowest
   8 bits of *duty_u16* are insignificant. So::
 
-    pwm=PWM(Pin(13), freq=300_000, duty_u16=2**16//2)
+    pwm=PWM(Pin(13), freq=300_000, duty_u16=65536//2)
 
   and::
 
-    pwm=PWM(Pin(13), freq=300_000, duty_u16=2**16//2 + 255)
+    pwm=PWM(Pin(13), freq=300_000, duty_u16=65536//2 + 255)
 
   will generate PWM with the same 50% duty cycle.

docs/library/machine.Timer.rst

@@ -4,41 +4,52 @@
 class Timer -- control hardware timers
 ======================================
 
-Hardware timers deal with timing of periods and events. Timers are perhaps
-the most flexible and heterogeneous kind of hardware in MCUs and SoCs,
-differently greatly from a model to a model. MicroPython's Timer class
-defines a baseline operation of executing a callback with a given period
-(or once after some delay), and allow specific boards to define more
-non-standard behaviour (which thus won't be portable to other boards).
+Timer class provides the ability to trigger a Python callback function after an
+expiry time, or periodically at a regular interval.
 
-See discussion of :ref:`important constraints <machine_callbacks>` on
-Timer callbacks.
-
-.. note::
-
-    Memory can't be allocated inside irq handlers (an interrupt) and so
-    exceptions raised within a handler don't give much information.  See
-    :func:`micropython.alloc_emergency_exception_buf` for how to get around this
-    limitation.
+The available features and restrictions of Timer objects vary depending on the
+MicroPython board and port.
 
 If you are using a WiPy board please refer to :ref:`machine.TimerWiPy <machine.TimerWiPy>`
 instead of this class.
 
+Timer Types
+-----------
+
+There are two types of Timer in MicroPython, but not all ports support both:
+
+- Virtual timers. These are managed in software, and are generally more
+  flexible. Multiple virtual timers can be constructed and active at once. The
+  ``id`` of a virtual timer is ``-1``. Not all ports support virtual timers, but
+  it's recommended to use them when available.
+- Hardware timers. Hardware timers have integer ``id`` values starting at ``0``.
+  The number of available ``id`` values is determined by the hardware. Hardware
+  timers may be more accurate for very fine sub-millisecond timing (especially
+  when ``hard=True`` is supported and set, see :ref:`isr_rules`.) Most
+  microcontroller ports support hardware timers, except Zephyr and RP2 which
+  only support virtual timers.
+
 Constructors
 ------------
 
 .. class:: Timer(id, /, ...)
 
-   Construct a new timer object of the given ``id``. ``id`` of -1 constructs a
-   virtual timer (if supported by a board).
+   Construct a new Timer object with the given ``id``.
+
+   On ports which support virtual timers the ``id`` parameter is optional - the
+   default value is ``-1`` which constructs a virtual timer.
+
+   On ports which support hardware timers, setting the ``id`` parameter to a
+   non-negative integer determines which timer to use.
+
    ``id`` shall not be passed as a keyword argument.
 
-   See ``init`` for parameters of initialisation.
+   Any additional parameters are handled the same as :func:`Timer.init()`.
 
 Methods
 -------
 
-.. method:: Timer.init(*, mode=Timer.PERIODIC, freq=-1, period=-1, callback=None)
+.. method:: Timer.init(*, mode=Timer.PERIODIC, freq=-1, period=-1, callback=None, hard=True)
 
    Initialise the timer. Example::
 
@@ -72,10 +83,23 @@ Methods
 
      - ``callback`` - The callable to call upon expiration of the timer period.
        The callback must take one argument, which is passed the Timer object.
+
        The ``callback`` argument shall be specified. Otherwise an exception
        will occur upon timer expiration:
        ``TypeError: 'NoneType' object isn't callable``
 
+     - ``hard`` can be one of:
+
+       - ``True`` - The callback will be executed in hard interrupt context,
+         which minimises delay and jitter but is subject to the limitations
+         described in :ref:`isr_rules`. Not all ports support hard interrupts,
+         see the port documentation for more information.
+       - ``False`` - The callback will be scheduled as a soft interrupt,
+         allowing it to allocate but possibly also introducing
+         garbage-collection delays and jitter.
+
+       The default value of this parameter is port-specific for historical reasons.
+
 .. method:: Timer.deinit()
 
    Deinitialises the timer. Stops the timer, and disables the timer peripheral.

docs/library/machine.TimerWiPy.rst

@@ -18,16 +18,6 @@ defines a baseline operation of executing a callback with a given period
 (or once after some delay), and allow specific boards to define more
 non-standard behaviour (which thus won't be portable to other boards).
 
-See discussion of :ref:`important constraints <machine_callbacks>` on
-Timer callbacks.
-
-.. note::
-
-    Memory can't be allocated inside irq handlers (an interrupt) and so
-    exceptions raised within a handler don't give much information.  See
-    :func:`micropython.alloc_emergency_exception_buf` for how to get around this
-    limitation.
-
 Constructors
 ------------
 
@@ -134,6 +124,9 @@ Methods
           ``TimerWiPy.ONE_SHOT``. In the case that mode is ``TimerWiPy.PWM`` then trigger must be equal to
           ``TimerWiPy.MATCH``.
 
+    Note that callback handlers are hard interrupts, and the constraints described in :ref:`isr_rules`
+    apply when they are executed.
+
     Returns a callback object.
 
 .. method:: timerchannel.freq([value])

docs/library/machine.UART.rst

@@ -224,7 +224,8 @@ Methods
 
 
    .. note::
-     - The ESP32 port does not support the option hard=True.
+     - The ESP32 port does not support the option hard=True. It uses Timer(0)
+       for UART.IRQ_RXIDLE, so this timer cannot be used for other means.
 
      - The rp2 port's UART.IRQ_TXIDLE is only triggered when the message
        is longer than 5 characters and the trigger happens when still 5 characters

docs/library/machine.rst

@@ -11,14 +11,6 @@ and unrestricted access to and control of hardware blocks on a system
 malfunction, lockups, crashes of your board, and in extreme cases, hardware
 damage.
 
-.. _machine_callbacks:
-
-A note of callbacks used by functions and class methods of :mod:`machine` module:
-all these callbacks should be considered as executing in an interrupt context.
-This is true for both physical devices with IDs >= 0 and "virtual" devices
-with negative IDs like -1 (these "virtual" devices are still thin shims on
-top of real hardware and real hardware interrupts). See :ref:`isr_rules`.
-
 Memory access
 -------------
 
@@ -260,13 +252,17 @@ Classes
    machine.Signal.rst
    machine.ADC.rst
    machine.ADCBlock.rst
+   machine.DAC.rst
    machine.PWM.rst
    machine.UART.rst
    machine.SPI.rst
    machine.I2C.rst
+   machine.I2CTarget.rst
    machine.I2S.rst
    machine.RTC.rst
    machine.Timer.rst
+   machine.Counter.rst
+   machine.Encoder.rst
    machine.WDT.rst
    machine.SD.rst
    machine.SDCard.rst

docs/library/network.WLAN.rst

@@ -145,6 +145,7 @@ Methods
    reconnects     Number of reconnect attempts to make (integer, 0=none, -1=unlimited)
    txpower        Maximum transmit power in dBm (integer or float)
    pm             WiFi Power Management setting (see below for allowed values)
+   protocol       (ESP32 Only.) WiFi Low level 802.11 protocol. See `WLAN.PROTOCOL_DEFAULTS`.
    =============  ===========
 
 Constants
@@ -161,3 +162,34 @@ Constants
         * ``PM_POWERSAVE``: enable WiFi power management with additional power
           savings and reduced WiFi performance
         * ``PM_NONE``: disable wifi power management
+
+
+ESP32 Protocol Constants
+------------------------
+
+The following ESP32-only constants relate to the ``WLAN.config(protocol=...)``
+network interface parameter:
+
+.. data:: WLAN.PROTOCOL_DEFAULTS
+
+      A bitmap representing all of the default 802.11 Wi-Fi modes supported by
+      the chip. Consult `ESP-IDF Wi-Fi Protocols`_ documentation for details.
+
+.. data:: WLAN.PROTOCOL_LR
+
+      This value corresponds to the `Espressif proprietary "long-range" mode`_,
+      which is not compatible with standard Wi-Fi devices. By setting this
+      protocol it's possible for an ESP32 STA in long-range mode to connect to
+      an ESP32 AP in long-range mode, or to use `ESP-NOW long range modes
+      <espnow-long-range>`.
+
+      This mode can be bitwise ORed with some standard 802.11 protocol bits
+      (including `WLAN.PROTOCOL_DEFAULTS`) in order to support a mix of standard
+      Wi-Fi modes as well as LR mode, consult the `Espressif long-range
+      documentation`_ for more details.
+
+      Long range mode is not supported on ESP32-C2.
+
+.. _ESP-IDF Wi-Fi Protocols: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/wifi.html#wi-fi-protocol-mode
+.. _Espressif proprietary "long-range" mode:
+.. _Espressif long-range documentation: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/wifi.html#long-range-lr

docs/library/os.rst

@@ -55,10 +55,9 @@ Filesystem access
       directories and 0x8000 for regular files;
     - *inode* is an integer corresponding to the inode of the file, and may be 0
       for filesystems that don't have such a notion.
-    - Some platforms may return a 4-tuple that includes the entry's *size*.  For
-      file entries, *size* is an integer representing the size of the file
-      or -1 if unknown.  Its meaning is currently undefined for directory
-      entries.
+    - *size* is an integer that may be included depending on the filesystem type.
+      For file entries, *size* represents the size of the file or -1 if unknown.
+      Its meaning is currently undefined for directory entries.
 
 .. function:: listdir([dir])
 
@@ -133,6 +132,37 @@ Terminal redirection and duplication
 
    The function returns the previous stream-like object in the given slot.
 
+.. function:: dupterm_notify(obj_in, /)
+
+    Notify the MicroPython REPL that input is available on a stream-like object
+    previously registered via `os.dupterm()`.
+
+    This function should be called by custom stream implementations (e.g., UART,
+    Bluetooth, or other non-USB REPL streams) to inform the REPL that input is
+    ready to be read. Proper use ensures that special characters such as
+    Ctrl+C (used to trigger KeyboardInterrupt) are processed promptly by the
+    REPL, enabling expected interruption behavior for user code.
+
+    The *obj_in* parameter is ignored by `os.dupterm_notify()`, but is required to allow calling
+    dupterm_notify from an interrupt handler such as `UART.irq()`.
+
+    Example:
+
+    .. code-block:: python
+
+        from machine import UART
+        import os
+        uart = UART(0)
+        os.dupterm(uart, 0)
+        uart.irq(os.dupterm_notify, machine.UART.IRQ_RX)
+
+    .. note::
+        If the ``dupterm_notify()`` function is not called, input from the custom stream
+        may not be detected or processed until the next REPL poll, potentially delaying
+        KeyboardInterrupts or other control signals.
+        This is especially important for UART, Bluetooth and other
+        non-standard REPL connections, where automatic notification is not guaranteed.
+
 Filesystem mounting
 -------------------
 

docs/library/platform.rst

@@ -36,3 +36,11 @@ Functions
    Returns a tuple of strings *(lib, version)*, where *lib* is the name of the
    libc that MicroPython is linked to, and *version* the corresponding version
    of this libc.
+
+.. function:: processor()
+
+   Returns a string with a detailed name of the processor, if one is available.
+   If no name for the processor is known, it will return an empty string
+   instead.
+
+   This is currently available only on RISC-V targets (both 32 and 64 bits).

docs/library/pyb.Timer.rst

@@ -62,7 +62,7 @@ Constructors
 Methods
 -------
 
-.. method:: Timer.init(*, freq, prescaler, period, mode=Timer.UP, div=1, callback=None, deadtime=0, brk=Timer.BRK_OFF)
+.. method:: Timer.init(*, freq, prescaler, period, mode=Timer.UP, div=1, callback=None, deadtime=0, brk=Timer.BRK_OFF, hard=True)
 
    Initialise the timer.  Initialisation must be either by frequency (in Hz)
    or by prescaler and period::
@@ -115,6 +115,18 @@ Methods
        ``mode=Pin.ALT, alt=Pin.AFn_TIMx``. The pin's GPIO input features are
        available in alt mode - ``pull=`` , ``value()`` and ``irq()``.
 
+     - ``hard`` can be one of:
+
+       - ``True`` - The callback will be executed in hard interrupt
+         context, which minimises delay and jitter but is subject to the
+         limitations described in :ref:`isr_rules` including being unable
+         to allocate on the heap.
+       - ``False`` - The callback will be scheduled as a soft interrupt,
+         allowing it to allocate but possibly also introducing
+         garbage-collection delays and jitter.
+
+       The default value of this option is True.
+
     You must either specify freq or both of period and prescaler.
 
 .. method:: Timer.deinit()

docs/library/re.rst

@@ -154,8 +154,8 @@ Regex objects
 Compiled regular expression. Instances of this class are created using
 `re.compile()`.
 
-.. method:: regex.match(string)
-            regex.search(string)
+.. method:: regex.match(string, [pos, [endpos]])
+            regex.search(string, [pos, [endpos]])
             regex.sub(replace, string, count=0, flags=0, /)
 
    Similar to the module-level functions :meth:`match`, :meth:`search`
@@ -163,6 +163,16 @@ Compiled regular expression. Instances of this class are created using
    Using methods is (much) more efficient if the same regex is applied to
    multiple strings.
 
+   The optional second parameter *pos* gives an index in the string where the
+   search is to start; it defaults to ``0``. This is not completely equivalent
+   to slicing the string; the ``'^'`` pattern character matches at the real
+   beginning of the string and at positions just after a newline, but not
+   necessarily at the index where the search is to start.
+
+   The optional parameter *endpos* limits how far the string will be searched;
+   it will be as if the string is *endpos* characters long, so only the
+   characters from *pos* to ``endpos - 1`` will be searched for a match.
+
 .. method:: regex.split(string, max_split=-1, /)
 
    Split a *string* using regex. If *max_split* is given, it specifies

docs/library/rp2.StateMachine.rst

@@ -58,6 +58,11 @@ Methods
     - *pull_thresh* is the threshold in bits before auto-pull or conditional
       re-pulling is triggered.
 
+    Note: pins used for *in_base* need to be configured manually for input (or
+    otherwise) so that the PIO can see the desired signal (they could be input
+    pins, output pins, or connected to a different peripheral).  The *jmp_pin*
+    can also be configured manually, but by default will be an input pin.
+
 .. method:: StateMachine.active([value])
 
     Gets or sets whether the state machine is currently running.

docs/library/socket.rst

@@ -227,22 +227,28 @@ Methods
    has the same "no short writes" policy for blocking sockets, and will return
    number of bytes sent on non-blocking sockets.
 
-.. method:: socket.recv(bufsize)
+.. method:: socket.recv(bufsize, [flags])
 
    Receive data from the socket. The return value is a bytes object representing the data
    received. The maximum amount of data to be received at once is specified by bufsize.
 
+   Most ports support the optional *flags* argument. Available *flags* are defined as constants
+   in the socket module and have the same meaning as in CPython. ``MSG_PEEK`` and ``MSG_DONTWAIT``
+   are supported on all ports which accept the *flags* argument.
+
 .. method:: socket.sendto(bytes, address)
 
    Send data to the socket. The socket should not be connected to a remote socket, since the
    destination socket is specified by *address*.
 
-.. method:: socket.recvfrom(bufsize)
+.. method:: socket.recvfrom(bufsize, [flags])
 
   Receive data from the socket. The return value is a pair *(bytes, address)* where *bytes* is a
   bytes object representing the data received and *address* is the address of the socket sending
   the data.
 
+  See the `recv` function for an explanation of the optional *flags* argument.
+
 .. method:: socket.setsockopt(level, optname, value)
 
    Set the value of the given socket option. The needed symbolic constants are defined in the

docs/library/ssl.rst

@@ -66,7 +66,7 @@ class SSLContext
    Set the available ciphers for sockets created with this context.  *ciphers* should be
    a list of strings in the `IANA cipher suite format <https://wiki.mozilla.org/Security/Cipher_Suites>`_ .
 
-.. method:: SSLContext.wrap_socket(sock, *, server_side=False, do_handshake_on_connect=True, server_hostname=None)
+.. method:: SSLContext.wrap_socket(sock, *, server_side=False, do_handshake_on_connect=True, server_hostname=None, client_id=None)
 
    Takes a `stream` *sock* (usually socket.socket instance of ``SOCK_STREAM`` type),
    and returns an instance of ssl.SSLSocket, wrapping the underlying stream.
@@ -89,6 +89,9 @@ class SSLContext
      server certificate.  It also sets the name for Server Name Indication (SNI), allowing the server
      to present the proper certificate.
 
+   - *client_id* is a MicroPython-specific extension argument used only when implementing a DTLS
+     Server. See :ref:`dtls` for details.
+
 .. warning::
 
    Some implementations of ``ssl`` module do NOT validate server certificates,
@@ -117,6 +120,8 @@ Exceptions
 
    This exception does NOT exist. Instead its base class, OSError, is used.
 
+.. _dtls:
+
 DTLS support
 ------------
 
@@ -125,16 +130,47 @@ DTLS support
 
    This is a MicroPython extension.
 
-This module supports DTLS in client and server mode via the `PROTOCOL_DTLS_CLIENT`
-and `PROTOCOL_DTLS_SERVER` constants that can be used as the ``protocol`` argument
-of `SSLContext`.
+On most ports, this module supports DTLS in client and server mode via the
+`PROTOCOL_DTLS_CLIENT` and `PROTOCOL_DTLS_SERVER` constants that can be used as
+the ``protocol`` argument of `SSLContext`.
 
 In this case the underlying socket is expected to behave as a datagram socket (i.e.
 like the socket opened with ``socket.socket`` with ``socket.AF_INET`` as ``af`` and
 ``socket.SOCK_DGRAM`` as ``type``).
 
-DTLS is only supported on ports that use mbed TLS, and it is not enabled by default:
-it requires enabling ``MBEDTLS_SSL_PROTO_DTLS`` in the specific port configuration.
+DTLS is only supported on ports that use mbedTLS, and it is enabled by default
+in most configurations but can be manually disabled by defining
+``MICROPY_PY_SSL_DTLS`` to 0.
+
+DTLS server support
+^^^^^^^^^^^^^^^^^^^
+
+MicroPython's DTLS server support is configured with "Hello Verify" as required
+for DTLS 1.2. This is transparent for DTLS clients, but there are relevant
+considerations when implementing a DTLS server in MicroPython:
+
+- The server should pass an additional argument *client_id* when calling
+  `SSLContext.wrap_socket()`. This ID must be a `bytes` object (or similar) with
+  a transport-specific identifier representing the client.
+
+  The simplest approach is to convert the tuple of ``(client_ip, client_port)``
+  returned from ``socket.recv_from()`` into a byte string, i.e.::
+
+        _, client_addr = sock.recvfrom(1, socket.MSG_PEEK)
+        sock.connect(client_addr)  # Connect back to the client
+        sock = ssl_ctx.wrap_socket(sock, server_side=True,
+                                   client_id=repr(client_addr).encode())
+
+- The first time a client connects, the server call to ``wrap_socket`` will fail
+  with a `OSError` error "Hello Verify Required". This is because the DTLS
+  "Hello Verify" cookie is not yet known by the client. If the same client
+  connects a second time then ``wrap_socket`` will succeed.
+
+- DTLS cookies for "Hello Verify" are associated with the `SSLContext` object,
+  so the same `SSLContext` object should be used to wrap a subsequent connection
+  from the same client. The cookie implementation includes a timeout and has
+  constant memory use regardless of how many clients connect, so it's OK to
+  reuse the same `SSLContext` object for the lifetime of the server.
 
 Constants
 ---------

docs/library/sys.rst

@@ -77,6 +77,8 @@ Constants
    * *_mpy* - supported mpy file-format version (optional attribute)
    * *_build* - string that can help identify the configuration that
      MicroPython was built with
+   * *_thread* - optional string attribute, exists if the target has threading
+     and is either "GIL" or "unsafe"
 
    This object is the recommended way to distinguish MicroPython from other
    Python implementations (note that it still may not exist in the very
@@ -95,6 +97,14 @@ Constants
    * On microcontroller targets, the first element is the board name and the second
      element (if present) is the board variant, for example ``'RPI_PICO2-RISCV'``
 
+   The *_thread* entry was added in version 1.26.0 and if it exists then the
+   target has the ``_thread`` module.  If the target enables the GIL (global
+   interpreter lock) then this attribute is ``"GIL"``.  Otherwise the attribute
+   is ``"unsafe"`` and the target has threading but does not enable the GIL,
+   and mutable Python objects (such as `bytearray`, `list` and `dict`) that are
+   shared amongst threads must be protected explicitly by locks such as
+   ``_thread.allocate_lock``.
+
    .. admonition:: Difference to CPython
       :class: attention
 

docs/library/time.rst

@@ -9,9 +9,10 @@
 The ``time`` module provides functions for getting the current time and date,
 measuring time intervals, and for delays.
 
-**Time Epoch**: Unix port uses standard for POSIX systems epoch of
-1970-01-01 00:00:00 UTC. However, some embedded ports use epoch of
-2000-01-01 00:00:00 UTC. Epoch year may be determined with ``gmtime(0)[0]``.
+**Time Epoch**: The unix, windows, webassembly, alif, mimxrt and rp2 ports
+use the standard for POSIX systems epoch of 1970-01-01 00:00:00 UTC.
+The other embedded ports use an epoch of 2000-01-01 00:00:00 UTC.
+Epoch year may be determined with ``gmtime(0)[0]``.
 
 **Maintaining actual calendar date/time**: This requires a
 Real Time Clock (RTC). On systems with underlying OS (including some
@@ -57,11 +58,11 @@ Functions
    * weekday is 0-6 for Mon-Sun
    * yearday is 1-366
 
-.. function:: mktime()
+.. function:: mktime(date_time_tuple)
 
    This is inverse function of localtime. It's argument is a full 8-tuple
    which expresses a time as per localtime. It returns an integer which is
-   the number of seconds since Jan 1, 2000.
+   the number of seconds since the time epoch.
 
 .. function:: sleep(seconds)
 

docs/library/wm8960.rst

@@ -358,13 +358,13 @@ Run WM8960 on a MIMXRT10xx_DEV board in secondary mode (default)::
         sysclk_source=wm8960.SYSCLK_MCLK)
 
 
-Record with a Sparkfun WM8960 breakout board with Teensy in secondary mode (default)::
+Record with a SparkFun WM8960 breakout board with Teensy in secondary mode (default)::
 
     # Micro_python WM8960 Codec driver
     #
     # The breakout board uses a fixed 24MHz MCLK. Therefore the internal
     # PLL must be used as sysclk, which is the master audio clock.
-    # The Sparkfun board has the WS pins for RX and TX connected on the
+    # The SparkFun board has the WS pins for RX and TX connected on the
     # board. Therefore adc_sync must be set to sync_adc, to configure
     # it's ADCLRC pin as input.
     #
@@ -379,11 +379,11 @@ Record with a Sparkfun WM8960 breakout board with Teensy in secondary mode (defa
         right_input=wm8960.INPUT_CLOSED)
 
 
-Play with a Sparkfun WM8960 breakout board with Teensy in secondary mode (default)::
+Play with a SparkFun WM8960 breakout board with Teensy in secondary mode (default)::
 
     # The breakout board uses a fixed 24MHz MCLK. Therefore the internal
     # PLL must be used as sysclk, which is the master audio clock.
-    # The Sparkfun board has the WS pins for RX and TX connected on the
+    # The SparkFun board has the WS pins for RX and TX connected on the
     # board. Therefore adc_sync must be set to sync_adc, to configure
     # it's ADCLRC pin as input.
 

docs/library/zephyr.rst

@@ -22,9 +22,10 @@ Functions
 
    Returns the thread id of the current thread, which is used to reference the thread.
 
-.. function:: thread_analyze()
+.. function:: thread_analyze(cpu)
 
-   Runs the Zephyr debug thread analyzer on the current thread and prints stack size statistics in the format:
+   Runs the Zephyr debug thread analyzer on the current thread on the given cpu
+   and prints stack size statistics in the format:
 
     "``thread_name``-20s: STACK: unused ``available_stack_space`` usage ``stack_space_used``
     / ``stack_size`` (``percent_stack_space_used`` %); CPU: ``cpu_utilization`` %"
@@ -35,6 +36,9 @@ Functions
    For more information, see documentation for Zephyr `thread analyzer
    <https://docs.zephyrproject.org/latest/guides/debug_tools/thread-analyzer.html#thread-analyzer>`_.
 
+   Note that the ``cpu`` argument is only used in Zephyr v4.0.0 and
+   newer and ignored otherwise.
+
 .. function:: shell_exec(cmd_in)
 
    Executes the given command on an UART backend. This function can only be accessed if ``CONFIG_SHELL_BACKEND_SERIAL``

docs/library/zephyr.zsensor.rst

@@ -20,7 +20,8 @@ See Zephyr documentation for sensor usage here: `Sensors
 Sensors are defined in the Zephyr devicetree for each board. The quantities that a given sensor can
 measure are called a sensor channels. Sensors can have multiple channels to represent different axes
 of one property or different properties a sensor can measure. See `Channels`_ below for defined sensor
-channels.
+channels. Each channel may have multiple attributes that can be changed and/or queried.
+See `Channel Attributes`_ below for defined sensor channel attributes.
 
 Constructor
 ~~~~~~~~~~~
@@ -59,6 +60,36 @@ Methods
     Returns only the integer value of the measurement sample.
     (Ex. value of ``(1, 500000)`` returns as ``1``)
 
+.. method:: Sensor.attr_set(sensor_channel, channel_attribute, val1, [val2])
+
+    Set the given channel's attribute to the given value.
+    ``val1`` may be a float, in which case ``val2`` is not given, or
+    ``val1`` can be used for the value's
+    integer part and ``val2`` for the value's fractional part in millionths.
+
+    Returns ``None`` if successful, or raises ``OSError``.
+
+.. method:: Sensor.attr_get_float(sensor_channel, channel_attribute)
+
+   Returns the value of the sensor channel's attribute as a float.
+
+   Many sensors do not support this or any other of the ``attr_get`` methods.
+
+.. method:: Sensor.attr_get_micros(sensor_channel, channel_attribute)
+
+    Returns the value of the sensor channel's attribute in millionths.
+    (Ex. value of ``(1, 500000)`` returns as ``1500000``)
+
+.. method:: Sensor.attr_get_millis(sensor_channel, channel_attribute)
+
+    Returns the value of the sensor channel's attribute in thousandths.
+    (Ex. value of ``(1, 500000)`` returns as ``1500``)
+
+.. method:: Sensor.attr_get_int(sensor_channel, channel_attribute)
+
+    Returns only the integer value of the channel's attribute.
+    (Ex. value of ``(1, 500000)`` returns as ``1``)
+
 Channels
 ~~~~~~~~
 
@@ -74,6 +105,11 @@ Channels
 
     Acceleration on the Z axis, in m/s^2.
 
+.. data:: ACCEL_XYZ
+
+    Pseudo-channel representing all three accelerometer axes.
+    Used for :meth:`Sensor.attr_set` and the ``Sensor.attr_get_xxx()`` methods.
+
 .. data:: GYRO_X
 
     Angular velocity around the X axis, in radians/s.
@@ -86,6 +122,11 @@ Channels
 
     Angular velocity around the Z axis, in radians/s.
 
+.. data:: GYRO_XYZ
+
+    Pseudo-channel representing all three gyroscope axes.
+    Used for :meth:`Sensor.attr_set` and the ``Sensor.attr_get_xxx()`` methods.
+
 .. data:: MAGN_X
 
     Magnetic field on the X axis, in Gauss.
@@ -121,3 +162,73 @@ Channels
 .. data:: ALTITUDE
 
     Altitude, in meters.
+
+Channel Attributes
+~~~~~~~~~~~~~~~~~~~
+
+.. data:: ATTR_SAMPLING_FREQUENCY
+
+    Sensor sampling frequency, i.e. how many times a second the sensor takes a measurement.
+
+.. data:: ATTR_LOWER_THRESH
+
+    Lower threshold for trigger.
+
+.. data:: ATTR_UPPER_THRESH
+
+    Upper threshold for trigger.
+
+.. data:: ATTR_SLOPE_TH
+
+    Threshold for any-motion (slope) trigger.
+
+.. data:: ATTR_SLOPE_DUR
+
+    Duration for which the slope values needs to be outside the threshold for the trigger to fire.
+
+.. data:: ATTR_HYSTERESIS
+
+.. data:: ATTR_OVERSAMPLING
+
+    Oversampling factor.
+
+.. data:: ATTR_FULL_SCALE
+
+    Sensor range, in SI units.
+
+.. data:: ATTR_OFFSET
+
+    The sensor value returned will be altered by the amount indicated by offset: final_value = sensor_value + offset.
+
+.. data:: ATTR_CALIB_TARGET
+
+    Calibration target. This will be used by the internal chip's algorithms to calibrate itself on a certain axis, or all of them.
+
+.. data:: ATTR_CONFIGURATION
+
+    Configure the operating modes of a sensor.
+
+.. data:: ATTR_CALIBRATION
+
+    Set a calibration value needed by a sensor.
+
+.. data:: ATTR_FEATURE_MASK
+
+    Enable/disable sensor features.
+
+.. data:: ATTR_ALERT
+
+    Alert threshold or alert enable/disable.
+
+.. data:: ATTR_FF_DUR
+
+    Free-fall duration represented in milliseconds.
+    If the sampling frequency is changed during runtime, this attribute should be set to adjust freefall duration to the new sampling frequency.
+
+.. data:: ATTR_BATCH_DURATION
+
+    Hardware batch duration in ticks.
+
+.. data:: ATTR_GAIN
+
+.. data:: ATTR_RESOLUTION

docs/mimxrt/pinout.rst

@@ -5,7 +5,10 @@ Pinout for the i.MXRT machine modules
 
 .. _mimxrt_uart_pinout:
 
-|
+The Teensy 4.0 and 4.1 board show pin numbers **nn** at the board's silkscreen.
+These are denoted in the tables below as **Dnn**. E.g. a silkscreen number **1** is
+shown as **D1**. Whenever a Pin has to be specified in a script, **Dnn** must
+be used, not **nn**.
 
 UART pin assignment
 -------------------
@@ -17,8 +20,8 @@ tables below:
 =================  ===========  ===========  ===========  ===========
 Board / Pin           UART0        UART1        UART2        UART3
 =================  ===========  ===========  ===========  ===========
-Teensy 4.0             -            0/1          7/8         14/15
-Teensy 4.1             -            0/1          7/8         14/15
+Teensy 4.0             -          D0/D1        D7/D8       D14/D15
+Teensy 4.1             -          D0/D1        D7/D8       D14/D15
 MIMXRT1010-EVK     Debug USB      D0/D1        D7/D6           -
 MIMXRT1015-EVK     Debug USB      D0/D1        D7/A1           -
 MIMXRT1020-EVK     Debug USB      D0/D1        D9/D6       D10/D13
@@ -35,11 +38,11 @@ Makerdiary RT1011     -           D9/D10      D13/A0       D11/D12
 
 |
 
-=================  ===========  ===========  =======  =======  =====
-Board / Pin            UART4        UART5      UART6   UART7   UART8
-=================  ===========  ===========  =======  =======  =====
-Teensy 4.0             16/17        21/20     25/24    28/29      -
-Teensy 4.1             16/17        21/20     25/24    28/29   34/35
+=================  ===========  ===========  =======  =======  =======
+Board / Pin            UART4        UART5      UART6   UART7    UART8
+=================  ===========  ===========  =======  =======  =======
+Teensy 4.0           D16/D17      D21/D20    D25/D24  D28/D29      -
+Teensy 4.1           D16/D17      D21/D20    D25/D24  D28/D29  D34/D35
 MIMXRT1010-EVK          -            -         -        -        -
 MIMXRT1015-EVK          -            -         -        -        -
 MIMXRT1020-EVK       D15/D14       A1/A0       -        -        -
@@ -51,7 +54,7 @@ MIMXRT1170-EVK       D15/D14      D25/D26    D33/D34  D35/D36    -
 Olimex RT1010Py         -            -         -        -        -
 Seeed ARCH MIX     J4_10/J4_11  J5_08/J5_12    -        -        -
 Makerdiary RT1011     A1/A2          -         -        -        -
-=================  ===========  ===========  =======  =======  =====
+=================  ===========  ===========  =======  =======  =======
 
 .. _mimxrt_pwm_pinout:
 
@@ -102,46 +105,46 @@ Pins denoted with (*) are by default not wired at the board.
 ====   ==========  ====   ==========
 Pin    Teensy 4.0  Pin    Teensy 4.1
 ====   ==========  ====   ==========
-0      F1/1/X      0      F1/1/X
-1      F1/0/X      1      F1/0/X
-2      F4/2/A      2      F4/2/A
-3      F4/2/B      3      F4/2/B
-4      F2/0/A      4      F2/0/A
-5      F2/1/A      5      F2/1/A
-6      F2/2/A      6      F2/2/A
-7      F1/3/B      7      F1/3/B
-8      F1/3/A      8      F1/3/A
-9      F2/2/B      9      F2/2/B
-10     Q1/0        10     Q1/0
-11     Q1/2        11     Q1/2
-12     Q1/1        12     Q1/1
-13     Q2/0        13     Q2/0
-14     Q3/2        14     Q3/2
-15     Q3/3        15     Q3/3
-18     Q3/1        18     Q3/1
-19     Q3/0        19     Q3/0
-22     F4/0/A      22     F4/0/A
-23     F4/1/A      23     F4/1/A
-24     F1/2/X      24     F1/2/X
-25     F1/3/X      25     F1/3/X
-28     F3/1/B      28     F3/1/B
-29     F3/1/A      29     F3/1/A
-33     F2/0/B      33     F2/0/B
--      -           36     F2/3/A
--      -           37     F2/3/B
-DAT1   F1/1/B      42     F1/1/B
-DAT0   F1/1/A      43     F1/1/A
-CLK    F1/0/B      44     F1/0/B
-CMD    F1/0/A      45     F1/0/A
-DAT2   F1/2/A      46     F1/2/A
-DAT3   F1/2/B      47     F1/2/B
--      -           48     F1/0/B
--      -           49     F1/2/A
--      -           50     F1/2/B
--      -           51     F3/3/B
--      -           52     F1/1/B
--      -           53     F1/1/A
--      -           54     F3/0/A
+D0     F1/1/X      D0     F1/1/X
+D1     F1/0/X      D1     F1/0/X
+D2     F4/2/A      D2     F4/2/A
+D3     F4/2/B      D3     F4/2/B
+D4     F2/0/A      D4     F2/0/A
+D5     F2/1/A      D5     F2/1/A
+D6     F2/2/A      D6     F2/2/A
+D7     F1/3/B      D7     F1/3/B
+D8     F1/3/A      D8     F1/3/A
+D9     F2/2/B      D9     F2/2/B
+D10    Q1/0        D10    Q1/0
+D11    Q1/2        D11    Q1/2
+D12    Q1/1        D12    Q1/1
+D13    Q2/0        D13    Q2/0
+D14    Q3/2        D14    Q3/2
+D15    Q3/3        D15    Q3/3
+D18    Q3/1        D18    Q3/1
+D19    Q3/0        D19    Q3/0
+D22    F4/0/A      D22    F4/0/A
+D23    F4/1/A      D23    F4/1/A
+D24    F1/2/X      D24    F1/2/X
+D25    F1/3/X      D25    F1/3/X
+D28    F3/1/B      D28    F3/1/B
+D29    F3/1/A      D29    F3/1/A
+D33    F2/0/B      D33    F2/0/B
+-      -           D36    F2/3/A
+-      -           D37    F2/3/B
+DAT1   F1/1/B      D42    F1/1/B
+DAT0   F1/1/A      D43    F1/1/A
+CLK    F1/0/B      D44    F1/0/B
+CMD    F1/0/A      D45    F1/0/A
+DAT2   F1/2/A      D46    F1/2/A
+DAT3   F1/2/B      D47    F1/2/B
+-      -           D48    F1/0/B
+-      -           D49    F1/2/A
+-      -           D50    F1/2/B
+-      -           D51    F3/3/B
+-      -           D52    F1/1/B
+-      -           D53    F1/1/A
+-      -           D54    F3/0/A
 ====   ==========  ====   ==========
 
 |
@@ -330,11 +333,11 @@ The SPI signals have fixed assignments to GPIO pins.
 It depends on the board design, which SPI's signals are exposed to the user, as
 detailed in the table below.  The signal order in the table is: CS0, CS1, MOSI, MISO, CLK.
 
-=================  =========================  =======================  ===============
+=================  =========================  =======================  =================
 Board / Pin        SPI0                       SPI1                     SPI2
-=================  =========================  =======================  ===============
-Teensy 4.0         10/-/11/12/13              0/-/26/1/27                    -
-Teensy 4.1         10/37/11/12/13             0/-/26/1/27              -/29/50/54/49
+=================  =========================  =======================  =================
+Teensy 4.0         D10/-/D11/D12/D13          D0/-/D26/D1/D27                -
+Teensy 4.1         D10/D37/D11/D12/D13        D0/-/D26/D1/D27          -/D29/D50/D54/D49
 MIXMXRT1010-EVK    D10/D7/D11/D12/D13                -                       -
 MIXMXRT1015-EVK    D10/-/D11/D12/D13                 -                       -
 MIXMXRT1020-EVK    D10/-/D11/D12/D13          A3/D0/A5/A4/A0                 -
@@ -347,7 +350,7 @@ Adafruit Metro M7  -/-/MOSI/MISO/SCK                -                        -
 Olimex RT1010Py             -                 CS0/-/SDO/SDI/SCK        SDCARD with CS1
 Seeed ARCH MIX     J4_12/-/J4_14/J4_13/J4_15  J3_09/J3_05/J3_08_J3_11
 Makerdiary RT1011  A5/A2/A4/A3/A6             A11/A1/A10/A9/CLK
-=================  =========================  =======================  ===============
+=================  =========================  =======================  =================
 
 Pins denoted with (*) are by default not wired at the board. The CS0 and CS1 signals
 are enabled with the keyword option cs=0 or cs=1 of the SPI object constructor.
@@ -367,8 +370,8 @@ detailed in the table below.  The signal order in the table is: SDA, SCL.
 =================  ===========  ===========  ===========  =======  =======
 Board / Pin        I2C 0        I2C 1        I2C 2        I2C 3    I2C 4
 =================  ===========  ===========  ===========  =======  =======
-Teensy 4.0         18/19        17/16        25/24         -        -
-Teensy 4.1         18/19        17/16        25/24         -        -
+Teensy 4.0         D18/D19      D17/D16      D25/D24       -        -
+Teensy 4.1         D18/D19      D17/D16      D25/D24       -        -
 MIXMXRT1010-EVK    D14/D15      D0/D1         -            -        -
 MIXMXRT1015-EVK    D14/D15       -            -            -        -
 MIXMXRT1020-EVK    D14/D15      A4/A5        D0/D1         -        -
@@ -396,10 +399,10 @@ Pin assignments for a few MIMXRT boards:
 =================  ==  =====  ======== ======= ======= ======== ======= =======
 Board              ID  MCK    SCK_TX   WS_TX   SD_TX   SCK_RX   WS_RX   SD_RX
 =================  ==  =====  ======== ======= ======= ======== ======= =======
-Teensy 4.0         1   23     26       27      7       21       20      8
-Teensy 4.0         2   33     4        3       2       -        -       5
-Teensy 4.1         1   23     26       27      7       21       20      8
-Teensy 4.1         2   33     4        3       2       -        -       5
+Teensy 4.0         1   D23    D26      D27     D7      D21      D20     D8
+Teensy 4.0         2   D33    D4       D3      D2      -        -       D5
+Teensy 4.1         1   D23    D26      D27     D7      D21      D20     D8
+Teensy 4.1         2   D33    D4       D3      D2      -        -       D5
 Seeed Arch MIX     1   J4_09  J4_14    J4_15   J14_13  J4_11    J4_10   J4_10
 Adafruit Metro M7  1   D8     D10      D9      D12     D14      D15     D13
 Olimex RT1010Py    1   D8     D6       D7      D4      D1       D2      D3

docs/pyboard/tutorial/lcd_skin.rst

@@ -29,7 +29,7 @@ Make sure the LCD skin is attached to the pyboard as pictured at the top of this
     >>> import pyb
     >>> lcd = pyb.LCD('X')
     >>> lcd.light(True)
-    >>> lcd.write('Hello uPy!\n')
+    >>> lcd.write('Hello MPy!\n')
 
 You can make a simple animation using the code::
 
@@ -38,7 +38,7 @@ You can make a simple animation using the code::
     lcd.light(True)
     for x in range(-80, 128):
         lcd.fill(0)
-        lcd.text('Hello uPy!', x, 10, 1)
+        lcd.text('Hello MPy!', x, 10, 1)
         lcd.show()
         pyb.delay(25)
 

docs/reference/asm_thumb2_index.rst

@@ -63,7 +63,7 @@ References
 -  :ref:`Assembler Tutorial <pyboard_tutorial_assembler>`
 -  `Wiki hints and tips
    <http://wiki.micropython.org/platforms/boards/pyboard/assembler>`__
--  `uPy Inline Assembler source-code,
+-  `MicroPython Inline Assembler source-code,
    emitinlinethumb.c <https://github.com/micropython/micropython/blob/master/py/emitinlinethumb.c>`__
 -  `ARM Thumb2 Instruction Set Quick Reference
    Card <http://infocenter.arm.com/help/topic/com.arm.doc.qrc0001l/QRC0001_UAL.pdf>`__

docs/reference/glossary.rst

@@ -188,6 +188,13 @@ Glossary
         Most MicroPython boards make a REPL available over a UART, and this is
         typically accessible on a host PC via USB.
 
+    small integer
+        MicroPython optimises the internal representation of integers such that
+        "small" values do not take up space on the heap, and calculations with
+        them do not require heap allocation. On most 32-bit ports, this
+        corresponds to values in the interval ``-2**30 <= x < 2**30``, but this
+        should be considered an implementation detail and not relied upon.
+
     stream
         Also known as a "file-like object". A Python object which provides
         sequential read-write access to the underlying data. A stream object

docs/reference/mpremote.rst

@@ -108,7 +108,7 @@ The full list of supported commands are:
   **Note:** Instead of using the ``connect`` command, there are several
   :ref:`pre-defined shortcuts <mpremote_shortcuts>` for common device paths. For
   example the ``a0`` shortcut command is equivalent to
-  ``connect /dev/ttyACM0`` (Linux), or ``c0`` for ``COM0`` (Windows).
+  ``connect /dev/ttyACM0`` (Linux), or ``c1`` for ``COM1`` (Windows).
 
   **Note:** The ``auto`` option will only detect USB serial ports, i.e. a serial
   port that has an associated USB VID/PID (i.e. CDC/ACM or FTDI-style
@@ -234,6 +234,7 @@ The full list of supported commands are:
   - ``rmdir <dirs...>`` to remove directories on the device
   - ``touch <file..>`` to create the files (if they don't already exist)
   - ``sha256sum <file..>`` to calculate the SHA256 sum of files
+  - ``tree [-vsh] <dirs...>`` to print a tree of the given directories
 
   The ``cp`` command uses a convention where a leading ``:`` represents a remote
   path. Without a leading ``:`` means a local path. This is based on the
@@ -264,6 +265,13 @@ The full list of supported commands are:
     There is no supported way to undelete files removed by ``mpremote rm -r :``.
     Please use with caution.
 
+  The ``tree`` command will print a tree of the given directories.
+  Using the ``--size/-s`` option will print the size of each file, or use
+  ``--human/-h`` to use a more human readable format.
+  Note: Directory size is only printed when a non-zero size is reported by the device's filesystem.
+  The ``-v`` option  can be used to include the name of the serial device in
+  the output.
+
   All other commands implicitly assume the path is a remote path, but the ``:``
   can be optionally used for clarity.
 
@@ -479,9 +487,16 @@ Shortcuts can be defined using the macro system.  Built-in shortcuts are:
 
 - ``cat``, ``edit``, ``ls``, ``cp``, ``rm``, ``mkdir``, ``rmdir``, ``touch``: Aliases for ``fs <sub-command>``
 
-Additional shortcuts can be defined by in user-configuration files, which is
-located at ``.config/mpremote/config.py``. This file should define a
-dictionary named ``commands``. The keys of this dictionary are the shortcuts
+Additional shortcuts can be defined in the user configuration file ``mpremote/config.py``,
+located in the User Configuration Directory.
+The correct location for each OS is determined using the ``platformdirs`` module.
+
+This is typically:
+- ``$XDG_CONFIG_HOME/mpremote/config.py``
+- ``$HOME/.config/mpremote/config.py``
+- ``$env:LOCALAPPDATA/mpremote/config.py``
+
+The ``config.py``` file should define a dictionary named ``commands``. The keys of this dictionary are the shortcuts
 and the values are either a string or a list-of-strings:
 
 .. code-block:: python3

docs/reference/mpyfiles.rst

@@ -58,12 +58,14 @@ If importing an .mpy file fails then try the following:
     sys_mpy = sys.implementation._mpy
     arch = [None, 'x86', 'x64',
         'armv6', 'armv6m', 'armv7m', 'armv7em', 'armv7emsp', 'armv7emdp',
-        'xtensa', 'xtensawin', 'rv32imc'][sys_mpy >> 10]
+        'xtensa', 'xtensawin', 'rv32imc', 'rv64imc'][(sys_mpy >> 10) & 0x0F]
     print('mpy version:', sys_mpy & 0xff)
     print('mpy sub-version:', sys_mpy >> 8 & 3)
     print('mpy flags:', end='')
     if arch:
         print(' -march=' + arch, end='')
+    if (sys_mpy >> 16) != 0:
+        print(' -march-flags=' + (sys_mpy >> 16), end='')
     print()
 
 * Check the validity of the .mpy file by inspecting the first two bytes of
@@ -80,6 +82,10 @@ If importing an .mpy file fails then try the following:
   above, or by inspecting the ``MPY_CROSS_FLAGS`` Makefile variable for the
   port that you are using.
 
+* If the third byte of the .mpy file has bit #6 set, then check whether the
+  encoded architecture-specific flag bits vuint is compatible with the
+  target you're importing the file on.
+
 The following table shows the correspondence between MicroPython release
 and .mpy version.
 
@@ -153,10 +159,42 @@ size    field
 ======  ================================
 byte    value 0x4d (ASCII 'M')
 byte    .mpy major version number
-byte    native arch and minor version number (was feature flags in older versions)
+byte    feature flags, native arch, minor version number (was feature flags in older versions)
 byte    number of bits in a small int
 ======  ================================
 
+The third byte is split as follows (MSB first):
+
+======  ================================
+bit     meaning
+======  ================================
+7       reserved, must be 0
+6       an architecture-specific flags vuint follows the header
+5..2    native arch number
+1..0    minor version number
+======  ================================
+
+Architecture-specific flags
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If bit #6 of the header's feature flags byte is set, then a vuint containing
+optional architecture-specific information will follow the header. The contents
+of this integer depends on which native architecture the file is meant for.
+
+This is currently used to store which RISC-V processor extensions the MPY file
+needs to operate correctly besides I, M, C, and Zicsr.  Different flavours of
+ArmV7 are identified by their native architecture number, but reusing that
+mechanism would complicate things for RV32 and RV64.
+
+MPY files targeting RV32 or RV64 that do not need any particular processor
+extensions do not need to provide a flags integer (along with setting the
+appropriate bit in the header).  The lack of a flags value for RV32 and RV64
+MPY files is used to indicate that no specific extensions are needed, and saves
+one byte in the final output binary.
+
+See also the ``-march-flags`` command-line option in both ``mpy-tool.py`` and
+``mpy-cross`` to set this value when creating MPY files.
+
 The global qstr and constant tables
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

docs/reference/speed_python.rst

@@ -246,6 +246,13 @@ There are certain limitations in the current implementation of the native code e
 * Context managers are not supported (the ``with`` statement).
 * Generators are not supported.
 * If ``raise`` is used an argument must be supplied.
+* The background scheduler (see `micropython.schedule`) is not run during
+  execution of native code.
+* On targets with thrteading and the GIL, the GIL is not released during
+  execution of native code.
+
+To mitigate the last two points, long running native functions should call
+``time.sleep(0)`` periodically, which will run the scheduler and bounce the GIL.
 
 The trade-off for the improved performance (roughly twice as fast as bytecode) is an
 increase in compiled code size.

docs/requirements.txt

@@ -1,2 +1,3 @@
 sphinx~=7.2.6
 sphinxcontrib.jquery==4.1
+sphinx-rtd-theme==3.0.2

docs/rp2/quickref.rst

@@ -135,6 +135,12 @@ Use the :mod:`machine.Timer` class::
     tim = Timer(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:print(1))
     tim.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(2))
 
+By default, timer callbacks run as soft IRQs so they can allocate but
+are prone to GC jitter and delays. Pass ``hard=True`` to the ``Timer()``
+constructor or ``init()`` method to run the callback in hard-IRQ context
+instead. This reduces delay and jitter, but see :ref:`isr_rules` for the
+restrictions that apply to hard-IRQ handlers.
+
 
 .. _rp2_Pins_and_GPIO:
 

docs/samd/pinout.rst

@@ -650,6 +650,124 @@ Adafruit ItsyBitsy M0 Express :ref:`samd21_pinout_table`.
 
 The board does not provide access to UART, I2C, SPI or DAC.
 
+SparkFun Redboard Turbo assignment table
+----------------------------------------
+
+=== ==== ============ ==== ==== ====== ====== ====== ======
+Pin GPIO Pin name     IRQ  ADC  Serial Serial TCC/TC TCC/TC
+=== ==== ============ ==== ==== ====== ====== ====== ======
+  2 PA02           A0   2    0     -      -      -      -
+ 40 PB08           A1   8    2     -     4/0    4/0     -
+ 41 PB09           A2   9    3     -     4/1    4/1     -
+  4 PA04           A3   4    4     -     0/0    0/0     -
+  5 PA05           A4   5    5     -     0/1    0/1     -
+ 34 PB02           A5   2   10     -     5/0    6/0     -
+ 11 PA11           D0  11   19    0/3    2/3    1/1    0/3
+ 10 PA10           D1  10   18    0/2    2/2    1/0    0/2
+ 14 PA14           D2  14    -    2/2    4/2    3/0    0/4
+  9 PA09           D3   9   17    0/1    2/1    0/1    1/3
+  8 PA08           D4   -   16    0/0    2/0    0/0    1/2
+ 15 PA15           D5  15    -    2/3    4/3    3/1    0/5
+ 20 PA20           D6   4    -    5/2    3/2    7/0    0/4
+ 21 PA21           D7   5    -    5/3    3/3    7/1    0/7
+  6 PA06           D8   6    6     -     0/2    1/0     -
+  7 PA07           D9   7    7     -     0/3    1/1     -
+ 11 PA11           RX  11   19    0/3    2/3    1/1    0/3
+ 10 PA10           TX  10   18    0/2    2/2    1/0    0/2
+  3 PA03         AREF   3    1     -      -      -      -
+ 18 PA18          D10   2    -    1/2    3/2    3/0    0/2
+ 16 PA16          D11   0    -    1/0    3/0    2/0    0/6
+ 19 PA19          D12   3    -    1/3    3/3    3/1    0/3
+ 17 PA17          D13   1    -    1/1    3/1    2/1    0/7
+ 13 PA13     FLASH_CS  13    -    2/1    4/1    2/0    0/7
+ 35 PB03   FLASH_MISO   3   11     -     5/1    6/1     -
+ 54 PB22   FLASH_MOSI   6    -     -     5/2    7/0     -
+ 55 PB23    FLASH_SCK   7    -     -     5/3    7/1     -
+ 31 PA31       LED_RX  11    -     -     1/3    1/1     -
+ 27 PA27       LED_TX  15    -     -      -      -      -
+ 12 PA12         MISO  12    -    2/0    4/0    2/0    0/6
+ 42 PB10         MOSI  10    -     -     4/2    5/0    0/4
+ 30 PA30     NEOPIXEL  10    -     -     1/2    1/0     -
+ 43 PB11          SCK  11    -     -     4/3    5/1    0/5
+ 23 PA23          SCL   7    -    3/1    5/1    4/1    0/5
+ 22 PA22          SDA   6    -    3/0    5/0    4/0    0/4
+ 30 PA30        SWCLK  10    -     -     1/2    1/0     -
+ 31 PA31        SWDIO  11    -     -     1/3    1/1     -
+ 24 PA24       USB_DM  12    -    3/2    5/2    5/0    1/2
+ 25 PA25       USB_DP  13    -    3/3    5/3    5/1    1/3
+  0 PA00                0    -     -     1/0    2/0     -
+  1 PA01                1    -     -     1/1    2/1     -
+ 28 PA28                8    -     -      -      -      -
+=== ==== ============ ==== ==== ====== ====== ====== ======
+
+For the definition of the table columns see the explanation at the table for
+Adafruit ItsyBitsy M0 Express :ref:`samd21_pinout_table`.
+
+The default devices at the board are:
+
+- UART 0 at pins PA11/PA10, labelled RX/TX
+- I2C 3 at pins PA22/PA23, labelled SDA/SCL
+- SPI 4 at pins PB10/PA12/PB11, labelled MISO, MOSI and SCK
+- DAC output on pin PA02, labelled A0
+
+
+SparkFun SAMD21 Dev Breakout assignment table
+---------------------------------------------
+
+=== ==== ============ ==== ==== ====== ====== ====== ======
+Pin GPIO Pin name     IRQ  ADC  Serial Serial TCC/TC TCC/TC
+=== ==== ============ ==== ==== ====== ====== ====== ======
+  2 PA02           A0   2    0      -     -      -      -
+ 40 PB08           A1   8    2      -    4/0    4/0     -
+ 41 PB09           A2   9    3      -    4/1    4/1     -
+  4 PA04           A3   4    4      -    0/0    0/0     -
+  5 PA05           A4   5    5      -    0/1    0/1     -
+ 34 PB02           A5   2   10      -    5/0    6/0     -
+ 11 PA11           D0  11   19     0/3   2/3    1/1    0/3
+ 10 PA10           D1  10   18     0/2   2/2    1/0    0/2
+ 14 PA14           D2  14    -     2/2   4/2    3/0    0/4
+  9 PA09           D3   9   17     0/1   2/1    0/1    1/3
+  8 PA08           D4   -   16     0/0   2/0    0/0    1/2
+ 15 PA15           D5  15    -     2/3   4/3    3/1    0/5
+ 20 PA20           D6   4    -     5/2   3/2    7/0    0/4
+ 21 PA21           D7   5    -     5/3   3/3    7/1    0/7
+  6 PA06           D8   6    6      -    0/2    1/0     -
+  7 PA07           D9   7    7      -    0/3    1/1     -
+ 11 PA11           RX  11   19     0/3   2/3    1/1    0/3
+ 10 PA10           TX  10   18     0/2   2/2    1/0    0/2
+  3 PA03         AREF   3    1      -     -      -      -
+ 18 PA18          D10   2    -     1/2   3/2    3/0    0/2
+ 16 PA16          D11   0    -     1/0   3/0    2/0    0/6
+ 19 PA19          D12   3    -     1/3   3/3    3/1    0/3
+ 17 PA17          D13   1    -     1/1   3/1    2/1    0/7
+ 54 PB22          D30   6    -      -    5/2    7/0     -
+ 55 PB23          D31   7    -      -    5/3    7/1     -
+ 13 PA13          D38  13    -     2/1   4/1    2/0    0/7
+ 35 PB03       LED_RX   3   11      -    5/1    6/1     -
+ 27 PA27       LED_TX  15    -      -     -      -      -
+ 12 PA12         MISO  12    -     2/0   4/0    2/0    0/6
+ 42 PB10         MOSI  10    -      -    4/2    5/0    0/4
+ 43 PB11          SCK  11    -      -    4/3    5/1    0/5
+ 23 PA23          SCL   7    -     3/1   5/1    4/1    0/5
+ 22 PA22          SDA   6    -     3/0   5/0    4/0    0/4
+ 30 PA30        SWCLK  10    -      -    1/2    1/0     -
+ 31 PA31        SWDIO  11    -      -    1/3    1/1     -
+ 24 PA24       USB_DM  12    -     3/2   5/2    5/0    1/2
+ 25 PA25       USB_DP  13    -     3/3   5/3    5/1    1/3
+  0 PA00                0    -      -    1/0    2/0     -
+  1 PA01                1    -      -    1/1    2/1     -
+ 28 PA28                8    -      -     -      -      -
+=== ==== ============ ==== ==== ====== ====== ====== ======
+
+For the definition of the table columns see the explanation at the table for
+Adafruit ItsyBitsy M0 Express :ref:`samd21_pinout_table`.
+
+The default devices at the board are:
+
+- UART 0 at pins PA11/PA10, labelled RX/TX
+- I2C 3 at pins PA22/PA23, labelled SDA/SCL
+- SPI 4 at pins PB10/PA12/PB11, labelled MISO, MOSI and SCK
+- DAC output on pin PA02, labelled A0
 
 SAMD21 Xplained PRO pin assignment table
 ----------------------------------------
@@ -892,7 +1010,7 @@ Default pin assignments:
 
 There seems to be no default pin assignment for this board.
 
-Sparkfun SAMD51 Thing Plus pin assignment table
+SparkFun SAMD51 Thing Plus pin assignment table
 ------------------------------------------------
 
 === ==== ============ ==== ==== ==== ====== ====== ===== ===== =====

docs/zephyr/quickref.rst

@@ -56,6 +56,21 @@ Use the :ref:`machine.Pin <machine.Pin>` class::
     switch = Pin(("gpioc", 6), Pin.IN)            # create input pin for a switch
     switch.irq(lambda t: print("SW2 changed"))    # enable an interrupt when switch state is changed
 
+PWM
+---
+
+Use the :ref:`machine.PWM <machine.PWM>` class::
+
+    from machine import PWM
+
+    pwm = PWM(("pwm0", 0), freq=3921568, duty_ns=200, invert=True)    # create pwm on PWM0
+    print(pwm)                                                        # print pwm
+
+    print(pwm.duty_ns())                                              # print pwm duty cycle in nanoseconds
+    pwm.duty_ns(255)                                                  # set new pwm duty cycle in nanoseconds
+
+    pwm.deinit()
+
 Hardware I2C bus
 ----------------
 
@@ -84,10 +99,10 @@ Hardware SPI is accessed via the :ref:`machine.SPI <machine.SPI>` class::
 
     from machine import SPI
 
-    spi = SPI("spi0")           # construct a spi bus with default configuration
+    spi = SPI("spi0")           # construct a SPI bus with default configuration
     spi.init(baudrate=100000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB) # set configuration
 
-    # equivalently, construct spi bus and set configuration at the same time
+    # equivalently, construct the SPI bus and set configuration at the same time
     spi = SPI("spi0", baudrate=100000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB)
     print(spi)                  # print device name and bus configuration
 
@@ -104,14 +119,30 @@ Hardware SPI is accessed via the :ref:`machine.SPI <machine.SPI>` class::
     spi.write_readinto(b'abcd', buf)    # write to MOSI and read from MISO into the buffer
     spi.write_readinto(buf, buf)        # write buf to MOSI and read back into the buf
 
+Analog to Digital Converter (ADC)
+----------------------------------
+
+Use the :ref:`machine.ADC <machine.ADC>` class.
+
+Example of using ADC to read a pin's analog value (the ``zephyr,user`` node must contain
+the ``io-channels`` property containing all the ADC channels)::
+
+    from machine import ADC
+
+    adc = ADC(("adc", 0))
+    adc.read_uv()
+
 Disk Access
 -----------
 
-Use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class to support filesystem::
+Storage devices such as SD cards are automatically mounted at startup (e.g., at ``/sd``).
+For manual mounting, use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class::
 
     import vfs
     from zephyr import DiskAccess
 
+    print(DiskAccess.disks)             # list available disk names, e.g., ('SDHC',)
+
     block_dev = DiskAccess('SDHC')      # create a block device object for an SD card
     vfs.VfsFat.mkfs(block_dev)          # create FAT filesystem object using the disk storage block
     vfs.mount(block_dev, '/sd')         # mount the filesystem at the SD card subdirectory
@@ -124,12 +155,15 @@ Use the :ref:`zephyr.DiskAccess <zephyr.DiskAccess>` class to support filesystem
 Flash Area
 ----------
 
-Use the :ref:`zephyr.FlashArea <zephyr.FlashArea>` class to support filesystem::
+Flash storage is automatically mounted at ``/flash`` at startup with automatic filesystem creation.
+For manual mounting, use the :ref:`zephyr.FlashArea <zephyr.FlashArea>` class::
 
     import vfs
     from zephyr import FlashArea
 
-    block_dev = FlashArea(4, 4096)      # creates a block device object in the frdm-k64f flash scratch partition
+    print(FlashArea.areas)              # list available areas, e.g., {'storage': 1, 'scratch': 4}
+
+    block_dev = FlashArea(FlashArea.areas['scratch'], 4096)  # creates a block device object using the scratch partition
     vfs.VfsLfs2.mkfs(block_dev)         # create filesystem in lfs2 format using the flash block device
     vfs.mount(block_dev, '/flash')      # mount the filesystem at the flash subdirectory
 
@@ -155,3 +189,34 @@ Use the :ref:`zsensor.Sensor <zsensor.Sensor>` class to access sensor data::
     accel.get_millis(zsensor.ACCEL_Y) # print measurement value for accelerometer Y-axis sensor channel in millionths
     accel.get_micro(zsensor.ACCEL_Z)  # print measurement value for accelerometer Z-axis sensor channel in thousandths
     accel.get_int(zsensor.ACCEL_X)    # print measurement integer value only for accelerometer X-axis sensor channel
+
+The channel IDs that are used as arguments to the :meth:`zsensor.Sensor.get_int`,
+:meth:`zsensor.Sensor.get_float()`, :meth:`zsensor.Sensor.get_millis()`, and
+:meth:`zsensor.Sensor.get_micros()` methods are constants in the :mod:`zsensor` module.
+
+You can use the :meth:`zsensor.Sensor.attr_set` method to set sensor attributes
+like full-scale range and update rate::
+
+    # Example for XIAO BLE NRF52840 SENSE
+    from zsensor import *
+    accel = Sensor('lsm6ds3tr_c')  # name from Devicetree
+    # Set full-scale to 2g (19.613300 m/sec^2)
+    # units are micro-m/s^2 (given as a float)
+    accel.attr_set(ACCEL_XYZ, ATTR_FULL_SCALE, 19.613300)
+    # Set sampling frequency to 104 Hz (as a pair of integers)
+    accel.attr_set(ACCEL_XYZ, ATTR_SAMPLING_FREQUENCY, 104, 0)
+    accel.measure()
+    accel.get_float(ACCEL_X) # -0.508 (m/s^2)
+    accel.get_float(ACCEL_Y) # -3.62 (m/s^2)
+    accel.get_float(ACCEL_Z) # 9.504889 (m/s^2)
+
+There are also the :meth:`zsensor.Sensor.attr_get_float`, :meth:`zsensor.Sensor.attr_get_int`,
+:meth:`zsensor.Sensor.attr_get_millis`, and :meth:`zsensor.Sensor.attr_get_micros` methods,
+but many sensors do not support these::
+
+    full_scale = accel.attr_get_float(ATTR_FULL_SCALE)
+
+The attribute IDs that are used as arguments to the :meth:`zsensor.Sensor.attr_set`,
+:meth:`zsensor.Sensor.attr_get_float`, :meth:`zsensor.Sensor.attr_get_int`,
+:meth:`zsensor.Sensor.attr_get_millis`, and :meth:`zsensor.Sensor.attr_get_micros`
+methods are constants in the :mod:`zsensor` module named ``ATTR_*``.

docs/zephyr/tutorial/repl.rst

@@ -31,8 +31,8 @@ With your serial program open (PuTTY, screen, picocom, etc) you may see a
 blank screen with a flashing cursor. Press Enter (or reset the board) and
 you should be presented with the following text::
 
-        *** Booting Zephyr OS build v3.7.0 ***
-        MicroPython v1.24.0-preview.179.g5b85b24bd on 2024-08-05; zephyr-frdm_k64f with mk64f12
+        *** Booting Zephyr OS build v4.2.0 ***
+        MicroPython v1.26.0-preview.451.gebc9525c9 on 2025-07-25; zephyr-frdm_k64f with mk64f12
         Type "help()" for more information.
         >>>
 

docs/zephyr/tutorial/storage.rst

@@ -8,6 +8,27 @@ Zephyr DiskAccess or FlashArea (flash map) APIs depending on which the board sup
 
 See `vfs Filesystem Mounting <https://docs.micropython.org/en/latest/library/vfs.html?highlight=vfs#filesystem-mounting>`_.
 
+Automatic Filesystem Mounting
+------------------------------
+
+MicroPython on Zephyr automatically attempts to mount available storage at startup:
+
+1. **Flash storage** (if available): Automatically mounted at ``/flash`` using the
+   littlefs2 filesystem. If the filesystem doesn't exist, it will be created
+   automatically.
+
+2. **Disk storage** (such as SD cards): Automatically detected and mounted at
+   ``/<disk_name>`` (e.g., ``/sd`` for SD cards).
+
+3. **Working directory**: The working directory is set to the mounted disk if
+   available, otherwise to ``/flash`` if flash storage is available.
+
+4. **Module search path**: The ``sys.path`` is automatically updated to include
+   ``/<disk>/lib`` for each mounted disk and ``/flash/lib`` for flash storage.
+
+This automatic mounting is performed by the ``_boot.py`` module at startup. For most
+use cases, you don't need to manually mount filesystems.
+
 Disk Access
 -----------
 
@@ -19,17 +40,26 @@ For use with SD card controllers, SD cards must be present at boot & not removed
 be auto detected and initialized by filesystem at boot. Use the disk driver interface and a
 file system to access SD cards via disk access (see below).
 
+The available disk names can be accessed via the ``DiskAccess.disks`` attribute, which contains
+a tuple of available disk names (e.g., ``('SDHC',)`` or ``('SD',)``).
+
 Example usage of FatFS with an SD card on the mimxrt1050_evk board::
 
     import vfs
     from zephyr import DiskAccess
-    bdev = zephyr.DiskAccess('SDHC')        # create block device object using DiskAccess
+
+    # List available disks
+    print(DiskAccess.disks)                 # prints available disk names, e.g., ('SDHC',)
+
+    bdev = DiskAccess('SDHC')               # create block device object using DiskAccess
     vfs.VfsFat.mkfs(bdev)                   # create FAT filesystem object using the disk storage block
     vfs.mount(bdev, '/sd')                  # mount the filesystem at the SD card subdirectory
     with open('/sd/hello.txt','w') as f:    # open a new file in the directory
         f.write('Hello world')              # write to the file
     print(open('/sd/hello.txt').read())     # print contents of the file
 
+Note: In most cases, disks are automatically mounted at startup and manual mounting is not necessary.
+
 
 Flash Area
 ----------
@@ -41,16 +71,26 @@ API is recommended (see below).
 This class uses `Zephyr Flash map API <https://docs.zephyrproject.org/latest/reference/storage/flash_map/flash_map.html#>`_ and
 implements the `vfs.AbstractBlockDev` protocol.
 
+The available flash area names can be accessed via the ``FlashArea.areas`` dictionary, which maps partition
+labels to their IDs (e.g., ``{'storage': 1, 'scratch': 4}``).
+
 Example usage with the internal flash on the reel_board or the rv32m1_vega_ri5cy board::
 
     import vfs
     from zephyr import FlashArea
-    bdev = FlashArea(FlashArea.STORAGE, 4096)   # create block device object using FlashArea
-    vfs.VfsLfs2.mkfs(bdev)                      # create Little filesystem object using the flash area block
-    vfs.mount(bdev, '/flash')                   # mount the filesystem at the flash storage subdirectory
-    with open('/flash/hello.txt','w') as f:     # open a new file in the directory
-        f.write('Hello world')                  # write to the file
-    print(open('/flash/hello.txt').read())      # print contents of the file
+
+    # List available flash areas
+    print(FlashArea.areas)                          # prints available areas, e.g., {'storage': 1, 'scratch': 4}
+
+    bdev = FlashArea(FlashArea.areas['storage'], 4096)   # create block device object using FlashArea
+    vfs.VfsLfs2.mkfs(bdev)                               # create Little filesystem object using the flash area block
+    vfs.mount(bdev, '/flash')                            # mount the filesystem at the flash storage subdirectory
+    with open('/flash/hello.txt','w') as f:              # open a new file in the directory
+        f.write('Hello world')                           # write to the file
+    print(open('/flash/hello.txt').read())               # print contents of the file
+
+Note: In most cases, the flash storage partition is automatically mounted at ``/flash`` at startup with
+automatic filesystem creation if needed, so manual mounting is not necessary.
 
 For boards such as the frdm_k64f in which the MicroPython application spills into the default flash storage
-partition, use the scratch partition by replacing ``FlashArea.STORAGE`` with the integer value 4.
+partition, use the scratch partition by replacing ``'storage'`` with ``'scratch'``.

drivers/bus/qspi.h

@@ -46,6 +46,7 @@ typedef struct _mp_qspi_proto_t {
     int (*write_cmd_addr_data)(void *self, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src);
     int (*read_cmd)(void *self, uint8_t cmd, size_t len, uint32_t *dest);
     int (*read_cmd_qaddr_qdata)(void *self, uint8_t cmd, uint32_t addr, uint8_t num_dummy, size_t len, uint8_t *dest);
+    int (*direct_read)(void *self, uint32_t addr, size_t len, uint8_t *dest); // can be NULL if direct read not supported
 } mp_qspi_proto_t;
 
 typedef struct _mp_soft_qspi_obj_t {

drivers/cyw43/README.md

@@ -1,17 +0,0 @@
-CYW43xx WiFi SoC driver
-=======================
-
-This is a driver for the CYW43xx WiFi SoC.
-
-There are four layers to the driver:
-
-1. SDIO bus interface, provided by the host device/system.
-
-2. Low-level CYW43xx interface, managing the bus, control messages, Ethernet
-   frames and asynchronous events.  Includes download of SoC firmware.  The
-   header file `cyw43_ll.h` defines the interface to this layer.
-
-3. Mid-level CYW43xx control, to control and set WiFi parameters and manage
-   events.  See `cyw43_ctrl.c`.
-
-4. TCP/IP bindings to lwIP.  See `cyw43_lwip.c`.

drivers/cyw43/cywbt.c

@@ -1,304 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2019-2020 Damien P. George
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * 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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include <stdio.h>
-#include <string.h>
-
-#include "py/runtime.h"
-#include "py/mphal.h"
-#include "extmod/mpbthci.h"
-
-#if MICROPY_PY_NETWORK_CYW43
-
-#include "lib/cyw43-driver/src/cyw43_config.h"
-#include "lib/cyw43-driver/firmware/cyw43_btfw_4343A1.h"
-
-// Provided by the port, and also possibly shared with the stack.
-extern uint8_t mp_bluetooth_hci_cmd_buf[4 + 256];
-
-/******************************************************************************/
-// CYW BT HCI low-level driver
-
-#ifdef CYW43_PIN_BT_CTS
-// This code is not portable and currently only builds on stm32 port.
-
-#include "pin_static_af.h"
-#include "uart.h"
-
-// Provided by the port.
-extern machine_uart_obj_t mp_bluetooth_hci_uart_obj;
-
-static void cywbt_wait_cts_low(void) {
-    mp_hal_pin_config(CYW43_PIN_BT_CTS, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
-    for (int i = 0; i < 200; ++i) {
-        if (mp_hal_pin_read(CYW43_PIN_BT_CTS) == 0) {
-            break;
-        }
-        mp_hal_delay_ms(1);
-    }
-    mp_hal_pin_config_alt(CYW43_PIN_BT_CTS, MP_HAL_PIN_MODE_ALT,
-        MP_HAL_PIN_PULL_UP, AF_FN_UART, mp_bluetooth_hci_uart_obj.uart_id);
-}
-#endif
-
-static int cywbt_hci_cmd_raw(size_t len, uint8_t *buf) {
-    mp_bluetooth_hci_uart_write((void *)buf, len);
-    for (int c, i = 0; i < 6; ++i) {
-        while ((c = mp_bluetooth_hci_uart_readchar()) == -1) {
-            mp_event_wait_indefinite();
-        }
-        buf[i] = c;
-    }
-
-    // expect a command complete event (event 0x0e)
-    if (buf[0] != 0x04 || buf[1] != 0x0e) {
-        printf("unknown response: %02x %02x %02x %02x\n", buf[0], buf[1], buf[2], buf[3]);
-        return -1;
-    }
-
-    /*
-    if buf[3:6] != cmd[:3]:
-        print('response doesn\'t match cmd:', cmd, ev)
-        return b''
-        */
-
-    int sz = buf[2] - 3;
-    for (int c, i = 0; i < sz; ++i) {
-        while ((c = mp_bluetooth_hci_uart_readchar()) == -1) {
-            mp_event_wait_indefinite();
-        }
-        buf[i] = c;
-    }
-
-    return 0;
-}
-
-static int cywbt_hci_cmd(int ogf, int ocf, size_t param_len, const uint8_t *param_buf) {
-    uint8_t *buf = mp_bluetooth_hci_cmd_buf;
-    buf[0] = 0x01;
-    buf[1] = ocf;
-    buf[2] = ogf << 2 | ocf >> 8;
-    buf[3] = param_len;
-    if (param_len) {
-        memcpy(buf + 4, param_buf, param_len);
-    }
-    return cywbt_hci_cmd_raw(4 + param_len, buf);
-}
-
-static void put_le16(uint8_t *buf, uint16_t val) {
-    buf[0] = val;
-    buf[1] = val >> 8;
-}
-
-static void put_le32(uint8_t *buf, uint32_t val) {
-    buf[0] = val;
-    buf[1] = val >> 8;
-    buf[2] = val >> 16;
-    buf[3] = val >> 24;
-}
-
-static int cywbt_set_baudrate(uint32_t baudrate) {
-    uint8_t buf[6];
-    put_le16(buf, 0);
-    put_le32(buf + 2, baudrate);
-    return cywbt_hci_cmd(0x3f, 0x18, 6, buf);
-}
-
-// download firmware
-static int cywbt_download_firmware(const uint8_t *firmware) {
-    cywbt_hci_cmd(0x3f, 0x2e, 0, NULL);
-
-    bool last_packet = false;
-    while (!last_packet) {
-        uint8_t *buf = mp_bluetooth_hci_cmd_buf;
-        memcpy(buf + 1, firmware, 3);
-        firmware += 3;
-        last_packet = buf[1] == 0x4e;
-        if (buf[2] != 0xfc) {
-            printf("fail1 %02x\n", buf[2]);
-            break;
-        }
-        uint8_t len = buf[3];
-
-        memcpy(buf + 4, firmware, len);
-        firmware += len;
-
-        buf[0] = 1;
-        cywbt_hci_cmd_raw(4 + len, buf);
-        if (buf[0] != 0) {
-            printf("fail3 %02x\n", buf[0]);
-            break;
-        }
-    }
-
-    // RF switch must select high path during BT patch boot
-    #if MICROPY_HW_ENABLE_RF_SWITCH
-    mp_hal_pin_config(CYW43_PIN_WL_GPIO_1, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
-    #endif
-    mp_hal_delay_ms(10); // give some time for CTS to go high
-    #ifdef CYW43_PIN_BT_CTS
-    cywbt_wait_cts_low();
-    #endif
-    #if MICROPY_HW_ENABLE_RF_SWITCH
-    // Select chip antenna (could also select external)
-    mp_hal_pin_config(CYW43_PIN_WL_GPIO_1, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_DOWN, 0);
-    #endif
-
-    mp_bluetooth_hci_uart_set_baudrate(115200);
-    cywbt_set_baudrate(MICROPY_HW_BLE_UART_BAUDRATE_SECONDARY);
-    mp_bluetooth_hci_uart_set_baudrate(MICROPY_HW_BLE_UART_BAUDRATE_SECONDARY);
-
-    return 0;
-}
-
-int mp_bluetooth_hci_controller_init(void) {
-    // This is called immediately after the UART is initialised during stack initialisation.
-
-    mp_hal_pin_output(CYW43_PIN_BT_REG_ON);
-    mp_hal_pin_low(CYW43_PIN_BT_REG_ON);
-    #ifdef CYW43_PIN_BT_HOST_WAKE
-    mp_hal_pin_input(CYW43_PIN_BT_HOST_WAKE);
-    #endif
-    #ifdef CYW43_PIN_BT_DEV_WAKE
-    mp_hal_pin_output(CYW43_PIN_BT_DEV_WAKE);
-    mp_hal_pin_low(CYW43_PIN_BT_DEV_WAKE);
-    #endif
-
-    #if MICROPY_HW_ENABLE_RF_SWITCH
-    // TODO don't select antenna if wifi is enabled
-    mp_hal_pin_config(CYW43_PIN_WL_GPIO_4, MP_HAL_PIN_MODE_OUTPUT, MP_HAL_PIN_PULL_NONE, 0); // RF-switch power
-    mp_hal_pin_high(CYW43_PIN_WL_GPIO_4); // Turn the RF-switch on
-    #endif
-
-    uint8_t buf[256];
-
-    mp_hal_pin_low(CYW43_PIN_BT_REG_ON);
-    mp_bluetooth_hci_uart_set_baudrate(115200);
-    mp_hal_delay_ms(100);
-    mp_hal_pin_high(CYW43_PIN_BT_REG_ON);
-    #ifdef CYW43_PIN_BT_CTS
-    cywbt_wait_cts_low();
-    #else
-    mp_hal_delay_ms(100);
-    #endif
-
-    // Reset
-    cywbt_hci_cmd(0x03, 0x0003, 0, NULL);
-
-    #ifdef MICROPY_HW_BLE_UART_BAUDRATE_DOWNLOAD_FIRMWARE
-    // Change baudrate
-    cywbt_set_baudrate(MICROPY_HW_BLE_UART_BAUDRATE_DOWNLOAD_FIRMWARE);
-    mp_bluetooth_hci_uart_set_baudrate(MICROPY_HW_BLE_UART_BAUDRATE_DOWNLOAD_FIRMWARE);
-    #endif
-
-    cywbt_download_firmware((const uint8_t *)&cyw43_btfw_4343A1[0]);
-
-    // Reset
-    cywbt_hci_cmd(0x03, 0x0003, 0, NULL);
-
-    // Set BD_ADDR (sent as little endian)
-    uint8_t bdaddr[6];
-    mp_hal_get_mac(MP_HAL_MAC_BDADDR, bdaddr);
-    buf[0] = bdaddr[5];
-    buf[1] = bdaddr[4];
-    buf[2] = bdaddr[3];
-    buf[3] = bdaddr[2];
-    buf[4] = bdaddr[1];
-    buf[5] = bdaddr[0];
-    cywbt_hci_cmd(0x3f, 0x0001, 6, buf);
-
-    // Set local name
-    // memset(buf, 0, 248);
-    // memcpy(buf, "PYBD-BLE", 8);
-    // cywbt_hci_cmd(0x03, 0x0013, 248, buf);
-
-    // Configure sleep mode
-    cywbt_hci_cmd(0x3f, 0x27, 12, (const uint8_t *)"\x01\x02\x02\x00\x00\x00\x01\x00\x00\x00\x00\x00");
-
-    // HCI_Write_LE_Host_Support
-    cywbt_hci_cmd(3, 109, 2, (const uint8_t *)"\x01\x00");
-
-    #ifdef CYW43_PIN_BT_DEV_WAKE
-    mp_hal_pin_high(CYW43_PIN_BT_DEV_WAKE); // let sleep
-    #endif
-
-    return 0;
-}
-
-int mp_bluetooth_hci_controller_deinit(void) {
-    mp_hal_pin_low(CYW43_PIN_BT_REG_ON);
-
-    return 0;
-}
-
-#ifdef CYW43_PIN_BT_DEV_WAKE
-static uint32_t bt_sleep_ticks;
-#endif
-
-int mp_bluetooth_hci_controller_sleep_maybe(void) {
-    #ifdef CYW43_PIN_BT_DEV_WAKE
-    if (mp_hal_pin_read(CYW43_PIN_BT_DEV_WAKE) == 0) {
-        if (mp_hal_ticks_ms() - bt_sleep_ticks > 500) {
-            mp_hal_pin_high(CYW43_PIN_BT_DEV_WAKE); // let sleep
-        }
-    }
-    #endif
-    return 0;
-}
-
-bool mp_bluetooth_hci_controller_woken(void) {
-    #ifdef CYW43_PIN_BT_HOST_WAKE
-    bool host_wake = mp_hal_pin_read(CYW43_PIN_BT_HOST_WAKE);
-    /*
-    // this is just for info/tracing purposes
-    static bool last_host_wake = false;
-    if (host_wake != last_host_wake) {
-        printf("HOST_WAKE change %d -> %d\n", last_host_wake, host_wake);
-        last_host_wake = host_wake;
-    }
-    */
-    return host_wake;
-    #else
-    return true;
-    #endif
-}
-
-int mp_bluetooth_hci_controller_wakeup(void) {
-    #ifdef CYW43_PIN_BT_DEV_WAKE
-    bt_sleep_ticks = mp_hal_ticks_ms();
-
-    if (mp_hal_pin_read(CYW43_PIN_BT_DEV_WAKE) == 1) {
-        mp_hal_pin_low(CYW43_PIN_BT_DEV_WAKE); // wake up
-        // Use delay_us rather than delay_ms to prevent running the scheduler (which
-        // might result in more BLE operations).
-        mp_hal_delay_us(5000); // can't go lower than this
-    }
-    #endif
-
-    return 0;
-}
-
-#endif

drivers/esp-hosted/esp_hosted_bthci_uart.c

@@ -72,7 +72,7 @@ int esp_hosted_hci_cmd(int ogf, int ocf, size_t param_len, const uint8_t *param_
     // Receive HCI event packet, initially reading 3 bytes (HCI Event, Event code, Plen).
     for (mp_uint_t start = mp_hal_ticks_ms(), size = 3, i = 0; i < size;) {
         while (!mp_bluetooth_hci_uart_any()) {
-            MICROPY_EVENT_POLL_HOOK
+            mp_event_wait_ms(1);
             // Timeout.
             if ((mp_hal_ticks_ms() - start) > HCI_COMMAND_TIMEOUT) {
                 error_printf("timeout waiting for HCI packet\n");
@@ -126,7 +126,7 @@ int mp_bluetooth_hci_controller_init(void) {
         if (mp_bluetooth_hci_uart_any()) {
             mp_bluetooth_hci_uart_readchar();
         }
-        MICROPY_EVENT_POLL_HOOK
+        mp_event_wait_ms(1);
     }
 
     #ifdef MICROPY_HW_BLE_UART_BAUDRATE_SECONDARY

drivers/esp-hosted/esp_hosted_wifi.c

@@ -243,7 +243,7 @@ static int esp_hosted_request(CtrlMsgId msg_id, void *ctrl_payload) {
 
 static CtrlMsg *esp_hosted_response(CtrlMsgId msg_id, uint32_t timeout) {
     CtrlMsg *ctrl_msg = NULL;
-    for (mp_uint_t start = mp_hal_ticks_ms(); ; mp_hal_delay_ms(10)) {
+    for (mp_uint_t start = mp_hal_ticks_ms(); ; mp_event_wait_ms(10)) {
         if (!esp_hosted_stack_empty(&esp_state.stack)) {
             ctrl_msg = esp_hosted_stack_pop(&esp_state.stack, true);
             if (ctrl_msg->msg_id == msg_id) {
@@ -264,8 +264,6 @@ static CtrlMsg *esp_hosted_response(CtrlMsgId msg_id, uint32_t timeout) {
         if ((mp_hal_ticks_ms() - start) >= timeout) {
             return NULL;
         }
-
-        MICROPY_EVENT_POLL_HOOK
     }
 
     // If message type is a response, check the response struct's return value.

drivers/memory/spiflash.c

@@ -197,6 +197,10 @@ void mp_spiflash_init(mp_spiflash_t *self) {
     } else {
         uint8_t num_dummy = MICROPY_HW_SPIFLASH_QREAD_NUM_DUMMY(self);
         self->config->bus.u_qspi.proto->ioctl(self->config->bus.u_qspi.data, MP_QSPI_IOCTL_INIT, num_dummy);
+        if (self->config->bus.u_qspi.proto->direct_read != NULL) {
+            // A bus with a custom read function should not have any further initialisation done.
+            return;
+        }
     }
 
     mp_spiflash_acquire_bus(self);
@@ -318,6 +322,10 @@ int mp_spiflash_read(mp_spiflash_t *self, uint32_t addr, size_t len, uint8_t *de
     if (len == 0) {
         return 0;
     }
+    const mp_spiflash_config_t *c = self->config;
+    if (c->bus_kind == MP_SPIFLASH_BUS_QSPI && c->bus.u_qspi.proto->direct_read != NULL) {
+        return c->bus.u_qspi.proto->direct_read(c->bus.u_qspi.data, addr, len, dest);
+    }
     mp_spiflash_acquire_bus(self);
     int ret = mp_spiflash_read_data(self, addr, len, dest);
     mp_spiflash_release_bus(self);

drivers/ninaw10/machine_pin_nina.c

@@ -114,13 +114,13 @@ void machine_pin_ext_config(machine_pin_obj_t *self, int mode, int value) {
         mode = NINA_GPIO_OUTPUT;
         self->is_output = true;
     } else {
-        mp_raise_ValueError("only Pin.OUT and Pin.IN are supported for this pin");
+        mp_raise_ValueError(MP_ERROR_TEXT("only Pin.OUT and Pin.IN are supported for this pin"));
     }
     if (self->id >= 0 && self->id < MICROPY_HW_PIN_EXT_COUNT) {
         uint8_t buf[] = {pin_map[self->id], mode};
         if (mode == NINA_GPIO_OUTPUT) {
             if (NINA_GPIO_IS_INPUT_ONLY(self->id)) {
-                mp_raise_ValueError("only Pin.IN is supported for this pin");
+                mp_raise_ValueError(MP_ERROR_TEXT("only Pin.IN is supported for this pin"));
             }
             machine_pin_ext_set(self, value);
         }

drivers/ninaw10/nina_bthci_uart.c

@@ -50,8 +50,8 @@
 #define OCF_SET_EVENT_MASK      (0x0001)
 #define OCF_RESET               (0x0003)
 
-#define error_printf(...)   // mp_printf(&mp_plat_print, "nina_bt_hci.c: " __VA_ARGS__)
-#define debug_printf(...)   // mp_printf(&mp_plat_print, "nina_bt_hci.c: " __VA_ARGS__)
+#define error_printf(...)   // mp_printf(&mp_plat_print, "nina_bthci_uart.c: " __VA_ARGS__)
+#define debug_printf(...)   // mp_printf(&mp_plat_print, "nina_bthci_uart.c: " __VA_ARGS__)
 
 // Provided by the port, and also possibly shared with the stack.
 extern uint8_t mp_bluetooth_hci_cmd_buf[4 + 256];

examples/bluetooth/ble_advertising.py

@@ -79,12 +79,9 @@ def decode_name(payload):
 
 def decode_services(payload):
     services = []
-    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
-        services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))
-    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
-        services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))
-    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
-        services.append(bluetooth.UUID(u))
+    for code in (_ADV_TYPE_UUID16_COMPLETE, _ADV_TYPE_UUID32_COMPLETE, _ADV_TYPE_UUID128_COMPLETE):
+        for u in decode_field(payload, code):
+            services.append(bluetooth.UUID(u))
     return services
 
 

examples/embedding/mpconfigport.h

@@ -13,3 +13,4 @@
 #define MICROPY_ENABLE_COMPILER                 (1)
 #define MICROPY_ENABLE_GC                       (1)
 #define MICROPY_PY_GC                           (1)
+#define MICROPY_PY_SYS                          (0)

examples/natmod/btree/Makefile

@@ -8,7 +8,7 @@ MOD = btree_$(ARCH)
 SRC = btree_c.c
 
 # Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
-ARCH = x64
+ARCH ?= x64
 
 BTREE_DIR = $(MPY_DIR)/lib/berkeley-db-1.xx
 BERKELEY_DB_CONFIG_FILE ?= \"extmod/berkeley-db/berkeley_db_config_port.h\"
@@ -32,6 +32,18 @@ SRC += $(addprefix $(realpath $(BTREE_DIR))/,\
 	mpool/mpool.c \
 	)
 
+ifeq ($(ARCH),xtensa)
+MPY_EXTERN_SYM_FILE=$(MPY_DIR)/ports/esp8266/boards/eagle.rom.addr.v6.ld
+endif
+
+# Use our own errno implementation if Picolibc is used
+CFLAGS += -D__PICOLIBC_ERRNO_FUNCTION=__errno
+
+ifeq ($(ARCH),armv6m)
+# Link with libgcc.a for division helper functions
+LINK_RUNTIME = 1
+endif
+
 include $(MPY_DIR)/py/dynruntime.mk
 
 # btree needs gnu99 defined

examples/natmod/deflate/Makefile

@@ -8,6 +8,17 @@ MOD = deflate_$(ARCH)
 SRC = deflate.c
 
 # Architecture to build for (x86, x64, armv7m, xtensa, xtensawin, rv32imc)
-ARCH = x64
+ARCH ?= x64
+
+ifeq ($(ARCH),armv6m)
+# Link with libgcc.a for division helper functions
+LINK_RUNTIME = 1
+endif
+
+ifeq ($(ARCH),xtensa)
+# Link with libm.a and libgcc.a from the toolchain
+LINK_RUNTIME = 1
+MPY_EXTERN_SYM_FILE=$(MPY_DIR)/ports/esp8266/boards/eagle.rom.addr.v6.ld
+endif
 
 include $(MPY_DIR)/py/dynruntime.mk

examples/natmod/framebuf/Makefile

@@ -8,6 +8,15 @@ MOD = framebuf_$(ARCH)
 SRC = framebuf.c
 
 # Architecture to build for (x86, x64, armv7m, xtensa, xtensawin)
-ARCH = x64
+ARCH ?= x64
+
+ifeq ($(ARCH),armv6m)
+# Link with libgcc.a for division helper functions
+LINK_RUNTIME = 1
+endif
+
+ifeq ($(ARCH),xtensa)
+MPY_EXTERN_SYM_FILE=$(MPY_DIR)/ports/esp8266/boards/eagle.rom.addr.v6.ld
+endif
 
 include $(MPY_DIR)/py/dynruntime.mk

examples/natmod/framebuf/framebuf.c

@@ -4,6 +4,9 @@
 #include "py/dynruntime.h"
 
 #if !defined(__linux__)
+void *memcpy(void *dst, const void *src, size_t n) {
+    return mp_fun_table.memmove_(dst, src, n);
+}
 void *memset(void *s, int c, size_t n) {
     return mp_fun_table.memset_(s, c, n);
 }