Update version

* Add support for the WiFi chip on the Pico W board.
* USB interrupt now no longer hard coded (conflicted with the WiFi IRQ).
* Add in Pico W board to makeboards.py
* Add in GPIO and variant support
* Initialize WiFi in the Variant
* Use manual LWIP, fix size accounting
* Remove the SDK WiFi overrides
* Pulling in work done in the ESP8266 core.
* Make IPAddress support IPv6
* Build LWIP with IPv4 and IPv6 support
* Use proper MAC
* Avoid cyw_warn crash.  Make macro to a comment while building
* Add WiFiServer
* Add WiFiUdp
* Move LWIP-specific support files to LWIP_Ethernet
* Add WiFi::ping (ICMP ping)
* Move ICMP echo (ping) to LWIPIntfDev
* Move hostByName to LwipIntfDev
* Add AP mode with simple DHCP server
* Add some examples and basic ESP8266 compat hacks
* Update Adafruit TinyUSB to fix crash
* Set DHCP hostname
* Make Wifi.begin() return CONNECTED with link + IP
* Return connected() on WiFi::begin
* Fix spurious TCP retransmission
* Protect LWIP from reentrancy

The Pico SDK calls "sys_check_timeouts() from inside a periodic interrupt.
This appears unsafe, as the interrupt could happen while already in the
(non-reentrant) LWIP code.

Block the interrupt from calling sys_check_timeouts by using a global flag
manually set via an RAII recursive lock.

Add interrupt protection macros around critical sections inside LWIP via
the standard defines.

These two changes should make LWIP significantly more stable and long
running.

* Support disconnecting and reconnecting WiFi
* Add WiFiServer simple example
* Update documentation

Fixes #666
Fixed #665

.github/workflows/pull-request.yml

@@ -14,21 +14,21 @@ jobs:
     name: Check spelling
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: true
     - name: Run codespell
       uses: codespell-project/actions-codespell@master
       with:
-        skip: ./pico-extras,./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api
-        ignore_words_list: ser,DOUT
+        skip: ./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api,./libraries/FreeRTOS
+        ignore_words_list: ser,dout
 
 # Consistent style
   astyle:
     name: Style, Boards, Package
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: false
     - name: Check package references
@@ -46,10 +46,10 @@ jobs:
         ./tests/restyle.sh
         # If anything changed, GIT should return an error and fail the test
         git diff --exit-code
-    - name: Check Arduino API copy is clean
-      run: |
-        git submodule update --init ./ArduinoCore-API
-        diff -r ./cores/rp2040/api ./ArduinoCore-API/api
+#    - name: Check Arduino API copy is clean
+#      run: |
+#        git submodule update --init ./ArduinoCore-API
+#        diff -r ./cores/rp2040/api ./ArduinoCore-API/api
 
 # Build all examples on linux (core and Arduino IDE)
   build-linux:
@@ -59,7 +59,7 @@ jobs:
       matrix:
         chunk: [0, 1, 2, 3]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: true
     - uses: actions/setup-python@v2
@@ -81,8 +81,6 @@ jobs:
       run: |
         cd pico-sdk
         git submodule update --init
-        cd ../pico-extras
-        git submodule update --init
         cd ..
         bash ./tests/build.sh
 
@@ -91,7 +89,7 @@ jobs:
     name: Build TinyUSB Examples
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: true
     - uses: actions/setup-python@v2
@@ -111,8 +109,6 @@ jobs:
       run: |
         cd pico-sdk
         git submodule update --init
-        cd ../pico-extras
-        git submodule update --init
         cd ..
         bash ./tests/build-tinyusb.sh
 
@@ -121,7 +117,7 @@ jobs:
     name: Windows
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: true
     - uses: actions/setup-python@v2
@@ -147,8 +143,6 @@ jobs:
         try { Get-Command python3 } catch { copy (get-command python).source (get-command python).source.Replace("python.exe", "python3.exe") }
         cd pico-sdk
         git submodule update --init
-        cd ../pico-extras
-        git submodule update --init
         cd ..
         bash ./tests/build.sh
 
@@ -158,7 +152,7 @@ jobs:
     name: Mac
     runs-on: macOS-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         submodules: true
     - uses: actions/setup-python@v2
@@ -181,8 +175,40 @@ jobs:
       run: |
         cd pico-sdk
         git submodule update --init
-        cd ../pico-extras
-        git submodule update --init
         cd ..
         bash ./tests/build.sh
 
+# Build a few examples with PlatformIO to test if integration works
+  build-platformio:
+    name: Build PlatformIO Examples
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: 'recursive'
+    - name: Cache pip
+      uses: actions/cache@v2
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+    - name: Cache PlatformIO
+      uses: actions/cache@v2
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+    - name: Set up Python
+      uses: actions/setup-python@v2
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
+        pio pkg install --global --platform https://github.com/maxgerhardt/platform-raspberrypi.git
+        pio pkg install --global --tool symlink://.
+    - name: Build Multicore Example
+      run: pio ci --board=rpipico --board=adafruit_feather -O "platform_packages=framework-arduinopico@symlink:///home/runner/work/arduino-pico/arduino-pico" libraries/rp2040/examples/Multicore/Multicore.ino
+    - name: Build Fade Example
+      run: pio ci --board=rpipico --board=adafruit_feather -O "platform_packages=framework-arduinopico@symlink:///home/runner/work/arduino-pico/arduino-pico" libraries/rp2040/examples/Fade/Fade.ino
+    - name: Build TinyUSB Example
+      run: pio ci --board=rpipico --board=adafruit_feather -O "platform_packages=framework-arduinopico@symlink:///home/runner/work/arduino-pico/arduino-pico" -O "build_flags=-DUSE_TINYUSB" libraries/Adafruit_TinyUSB_Arduino/examples/CDC/cdc_multi/cdc_multi.ino

.github/workflows/release-to-publish.yml

@@ -12,16 +12,36 @@ jobs:
     - uses: actions/checkout@v2
       with:
         submodules: true
+    - name: Cache pip
+      uses: actions/cache@v2
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+    - name: Cache PlatformIO
+      uses: actions/cache@v2
+      with:
+        path: ~/.platformio
+        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
     - uses: actions/setup-python@v2
       with:
         python-version: '3.x'
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
     - name: Deploy updated JSON
       env:
         TRAVIS_BUILD_DIR: ${{ github.workspace }}
         BUILD_TYPE: package
         CI_GITHUB_API_KEY: ${{ secrets.GITHUB_TOKEN }}
+        PLATFORMIO_AUTH_TOKEN: ${{ secrets.PLATFORMIO_AUTH_TOKEN }}
       run: |
            pip3 install PyGithub
            TAG=$(git describe --exact-match --tags)
            curl -L -o package_rp2040_index.json "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/releases/download/$TAG/package_rp2040_index.json"
            ./package/update_release.py --token ${CI_GITHUB_API_KEY} --repo "$GITHUB_REPOSITORY" --tag global package_rp2040_index.json
+           # Upload to Platform.IO
+           curl -LO $GITHUB_SERVER_URL/$GITHUB_REPOSITORY/releases/download/$TAG/rp2040-$TAG.zip
+           pio package publish rp2040-$TAG.zip --non-interactive

.github/workflows/tag-to-draft-release.yml

@@ -29,7 +29,6 @@ jobs:
         CI_GITHUB_API_KEY: ${{ secrets.GITHUB_TOKEN }}
       run: |
            (cd pico-sdk && git submodule update --init)
-           (cd pico-extras && git submodule update --init)
            (cd ./package && bash ./build_boards_manager_package.sh)
            pip3 install PyGithub
            # Create a draft release and upload the ZIP and JSON files.

.gitmodules

@@ -13,9 +13,6 @@
 [submodule "libraries/SdFat"]
 	path = libraries/ESP8266SdFat
 	url = https://github.com/earlephilhower/ESP8266SdFat.git
-[submodule "pico-extras"]
-	path = pico-extras
-	url = https://github.com/raspberrypi/pico-extras.git
 [submodule "libraries/Keyboard"]
 	path = libraries/Keyboard
 	url = https://github.com/earlephilhower/Keyboard
@@ -25,3 +22,6 @@
 [submodule "libraries/Adafruit_TinyUSB_Arduino"]
 	path = libraries/Adafruit_TinyUSB_Arduino
 	url = https://github.com/adafruit/Adafruit_TinyUSB_Arduino.git
+[submodule "libraries/FreeRTOS/lib/FreeRTOS-Kernel"]
+	path = libraries/FreeRTOS/lib/FreeRTOS-Kernel
+	url = https://github.com/earlephilhower/FreeRTOS-Kernel.git

README.md

@@ -11,6 +11,7 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 
 # Supported Boards
 * Raspberry Pi Pico
+* Raspberry Pi Pico W
 * Adafruit Feather RP2040
 * Adafruit ItsyBitsy RP2040
 * Adafruit KB2040
@@ -18,19 +19,28 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 * Adafruit QTPy RP2040
 * Adafruit STEMMA Friend RP2040
 * Adafruit Trinkey RP2040 QT
-* Arduino Nano RP2040 Connect (preliminary)
+* Arduino Nano RP2040 Connect
 * Cytron Maker Pi RP2040
 * Cytron Maker Nano RP2040
 * DeRuiLab FlyBoard2040 Core
+* DFRobot Beetle RP2040
 * Invector Labs Challenger RP2040 WiFi
+* Invector Labs Challenger RP2040 WiFi/BLE
 * Invector Labs Challenger NB RP2040 WiFi
 * Invector Labs Challenger RP2040 LTE
+* Invector Labs Challenger RP2040 LoRa
+* Invector Labs Challenger RP2040 SubGHz
+* Invector Labs Challenger RP2040 SD/RTC
 * Invector Labs RPICO32
 * Melopero Shake RP2040
+* Seeed XIAO RP2040
 * Solder Party RP2040 Stamp
 * SparkFun ProMicro RP2040
+* SparkFun Thing Plus RP2040
 * uPesy RP2040 DevKit
 * WIZnet W5100S-EVB-Pico
+* WIZnet W5500-EVB-Pico
+* WIZnet WizFi360-EVB-Pico
 * Generic (configurable flash, I/O pins)
 
 # Installing via Arduino Boards Manager
@@ -66,8 +76,6 @@ cd ~/Arduino/hardware/pico/rp2040
 git submodule update --init
 cd pico-sdk
 git submodule update --init
-cd ../pico-extras
-git submodule update --init
 cd ../tools
 python3 ./get.py
 `````
@@ -81,7 +89,7 @@ If you follow Les' step-by-step you will also have a fully functional `CMake`-ba
 To upload your first sketch, you will need to hold the BOOTSEL button down while plugging in the Pico to your computer.
 Then hit the upload button and the sketch should be transferred and start to run.
 
-After the first upload, this should not be necessary as the `arduino-pico` core has auto-reset support. 
+After the first upload, this should not be necessary as the `arduino-pico` core has auto-reset support.
 Select the appropriate serial port shown in the Arduino Tools->Port->Serial Port menu once (this setting will stick and does not need to be
 touched for multiple uploads).   This selection allows the auto-reset tool to identify the proper device to reset.
 Them hit the upload button and your sketch should upload and run.
@@ -93,8 +101,8 @@ follow the initial procedure of holding the BOOTSEL button down while plugging i
 The onboard flash filesystem for the Pico, LittleFS, lets you upload a filesystem image from the sketch directory for your sketch to use.  Download the needed plugin from
 * https://github.com/earlephilhower/arduino-pico-littlefs-plugin/releases
 
-To install, follow the directions in 
-* https://github.com/earlephilhower/arduino-pico-littlefs-plugin/blob/master/README.md 
+To install, follow the directions in
+* https://github.com/earlephilhower/arduino-pico-littlefs-plugin/blob/master/README.md
 
 For detailed usage information, please check the ESP8266 repo documentation (ignore SPIFFS related notes) available at
 * https://arduino-esp8266.readthedocs.io/en/latest/filesystem.html
@@ -139,14 +147,16 @@ The installed tools include a version of OpenOCD (in the pqt-openocd directory)
 * Generic Arduino USB Serial, Keyboard, and Mouse emulation
 * Filesystems (LittleFS and SD/SDFS)
 * Multicore support (setup1() and loop1())
+* FreeRTOS SMP support
 * Overclocking and underclocking from the menus
 * digitalWrite/Read, shiftIn/Out, tone, analogWrite(PWM)/Read, temperature
-* Peripherals:  SPI master, Wire(I2C) master/slave, dual UART, emulated EEPROM, I2S audio output, Servo
-* printf (i.e. debug) output over USB serial 
+* Peripherals:  SPI master, Wire(I2C) master/slave, dual UART, emulated EEPROM, I2S audio input, I2S audio output, Servo
+* printf (i.e. debug) output over USB serial
 
 The RP2040 PIO state machines (SMs) are used to generate jitter-free:
 * Servos
 * Tones
+* I2S Input
 * I2S Output
 * Software UARTs (Serial ports)
 
@@ -164,11 +174,14 @@ If you want to contribute or have bugfixes, drop me a note at <earlephilhower@ya
 # Licensing and Credits
 * The [Arduino IDE and ArduinoCore-API](https://arduino.cc) are developed and maintained by the Arduino team. The IDE is licensed under GPL.
 * The [RP2040 GCC-based toolchain](https://github.com/earlephilhower/pico-quick-toolchain) is licensed under under the GPL.
-* The [Pico-SDK](https://github.com/raspberrypi/pico-sdk) and [Pico-Extras](https://github.com/raspberrypi/pico-extras) are by Raspberry Pi (Trading) Ltd and licensed under the BSD 3-Clause license.
+* The [Pico-SDK](https://github.com/raspberrypi/pico-sdk) is by Raspberry Pi (Trading) Ltd and licensed under the BSD 3-Clause license.
 * [Arduino-Pico](https://github.com/earlephilhower/arduino-pico) core files are licensed under the LGPL.
 * [LittleFS](https://github.com/ARMmbed/littlefs) library written by ARM Limited and released under the [BSD 3-clause license](https://github.com/ARMmbed/littlefs/blob/master/LICENSE.md).
 * [UF2CONV.PY](https://github.com/microsoft/uf2) is by Microsoft Corporation and licensed under the MIT license.
-* Some filesystem code taken from the [ESP8266 Arduino Core](https://github.com/esp8266/Arduino) and licensed under the LGPL.
+* Networking and filesystem code taken from the [ESP8266 Arduino Core](https://github.com/esp8266/Arduino) and licensed under the LGPL.
+* DHCP server for AP host mode from the [Micropython Project](https://micropython.org), distributed under the MIT License.
+* [FreeRTOS](https://freertos.org) is Copyright Amazon.com, Inc. or its affiliates, and distributed under the MIT license.
+* [lwIP](https://savannah.nongnu.org/projects/lwip/) is (c) the Swedish Institute of Computer Science and licenced under the BSD license.
 
 -Earle F. Philhower, III
  earlephilhower@yahoo.com

cores/rp2040/Arduino.h

@@ -18,13 +18,13 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef Arduino_h
-#define Arduino_h
+#pragma once
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include "stdlib_noniso.h" // Wacky deprecated AVR compatibility functions
+#include "RP2040Version.h"
 #include "api/ArduinoAPI.h"
 #include "api/itoa.h" // ARM toolchain doesn't provide itoa etc, provide them
 #include <pins_arduino.h>
@@ -78,6 +78,9 @@ void analogWriteFreq(uint32_t freq);
 void analogWriteRange(uint32_t range);
 void analogWriteResolution(int res);
 
+// FreeRTOS potential calls
+extern bool __isFreeRTOS;
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
@@ -108,5 +111,3 @@ constexpr uint32_t __bitset(const int (&a)[N], size_t i = 0U) {
     return i < N ? (1L << a[i]) | __bitset(a, i + 1) : 0;
 }
 #endif
-
-#endif // Arduino_h

cores/rp2040/Bootsel.cpp

@@ -47,8 +47,8 @@ static bool __no_inline_not_in_flash_func(get_bootsel_button)() {
                     GPIO_OVERRIDE_NORMAL << IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_LSB,
                     IO_QSPI_GPIO_QSPI_SS_CTRL_OEOVER_BITS);
 
-    interrupts();
     rp2040.resumeOtherCore();
+    interrupts();
 
     return button_state;
 }

cores/rp2040/FS.h

@@ -18,8 +18,7 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef FS_H
-#define FS_H
+#pragma once
 
 #include <memory>
 #include <Arduino.h>
@@ -188,15 +187,6 @@ public:
     bool     _autoFormat;
 };
 
-class SPIFFSConfig : public FSConfig {
-public:
-    static constexpr uint32_t FSId = 0x53504946;
-    SPIFFSConfig(bool autoFormat = true) : FSConfig(FSId, autoFormat) { }
-
-    // Inherit _type and _autoFormat
-    // nothing yet, enableTime TBD when SPIFFS has metadate
-};
-
 class FS {
 public:
     FS(FSImplPtr impl) : _impl(impl) {
@@ -272,11 +262,4 @@ using fs::SeekCur;
 using fs::SeekEnd;
 using fs::FSInfo;
 using fs::FSConfig;
-using fs::SPIFFSConfig;
 #endif //FS_NO_GLOBALS
-
-#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SPIFFS)
-extern fs::FS SPIFFS __attribute__((deprecated("SPIFFS has been deprecated. Please consider moving to LittleFS or other filesystems.")));
-#endif
-
-#endif //FS_H

cores/rp2040/FSImpl.h

@@ -17,8 +17,8 @@
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
-#ifndef FSIMPL_H
-#define FSIMPL_H
+
+#pragma once
 
 #include <stddef.h>
 #include <stdint.h>
@@ -149,5 +149,3 @@ protected:
 };
 
 } // namespace fs
-
-#endif //FSIMPL_H

cores/rp2040/LWIPMutex.h

@@ -0,0 +1,41 @@
+/*
+    WiFiMutex.h - Ensure the timer-driven sys_check_timeouts doesn't
+                  get executed while we're in the user-level TCP stack.
+    Copyright (c) 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Implements the API defined by the Arduino WiFiNINA library,
+    copyright (c) 2018 Arduino SA. All rights reserved.
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+extern "C" volatile bool __inLWIP;
+
+class LWIPMutex {
+public:
+    LWIPMutex() {
+        __inLWIP = true;
+        _ref++;
+    }
+    ~LWIPMutex() {
+        if (0 == --_ref) {
+            __inLWIP = false;
+        }
+    }
+private:
+    static int _ref;
+};

cores/rp2040/RP2040Support.h

@@ -25,7 +25,11 @@
 #include <hardware/structs/systick.h>
 #include <pico/multicore.h>
 #include <pico/util/queue.h>
-#include <CoreMutex.h>
+#include "CoreMutex.h"
+#include "ccount.pio.h"
+
+
+extern "C" volatile bool __otherCoreIdled;
 
 class _MFIFO {
 public:
@@ -45,9 +49,12 @@ public:
     }
 
     void registerCore() {
-        multicore_fifo_clear_irq();
-        irq_set_exclusive_handler(SIO_IRQ_PROC0 + get_core_num(), _irq);
-        irq_set_enabled(SIO_IRQ_PROC0 + get_core_num(), true);
+        if (!__isFreeRTOS) {
+            multicore_fifo_clear_irq();
+            irq_set_exclusive_handler(SIO_IRQ_PROC0 + get_core_num(), _irq);
+            irq_set_enabled(SIO_IRQ_PROC0 + get_core_num(), true);
+        }
+        // FreeRTOS port.c will handle the IRQ hooking
     }
 
     void push(uint32_t val) {
@@ -79,9 +86,9 @@ public:
             return;
         }
         mutex_enter_blocking(&_idleMutex);
-        _otherIdled = false;
+        __otherCoreIdled = false;
         multicore_fifo_push_blocking(_GOTOSLEEP);
-        while (!_otherIdled) { /* noop */ }
+        while (!__otherCoreIdled) { /* noop */ }
     }
 
     void resumeOtherCore() {
@@ -89,97 +96,50 @@ public:
             return;
         }
         mutex_exit(&_idleMutex);
-        _otherIdled = false;
+        __otherCoreIdled = false;
         // Other core will exit busy-loop and return to operation
-        // once otherIdled == false.
+        // once __otherCoreIdled == false.
+    }
+
+    void clear() {
+        uint32_t val;
+
+        while (queue_try_remove(&_queue[0], &val)) {
+            tight_loop_contents();
+        }
+
+        while (queue_try_remove(&_queue[1], &val)) {
+            tight_loop_contents();
+        }
     }
 
 private:
     static void __no_inline_not_in_flash_func(_irq)() {
-        multicore_fifo_clear_irq();
-        noInterrupts(); // We need total control, can't run anything
-        while (multicore_fifo_rvalid()) {
-            if (_GOTOSLEEP == multicore_fifo_pop_blocking()) {
-                _otherIdled = true;
-                while (_otherIdled) { /* noop */ }
-                break;
+        if (!__isFreeRTOS) {
+            multicore_fifo_clear_irq();
+            noInterrupts(); // We need total control, can't run anything
+            while (multicore_fifo_rvalid()) {
+                if (_GOTOSLEEP == multicore_fifo_pop_blocking()) {
+                    __otherCoreIdled = true;
+                    while (__otherCoreIdled) { /* noop */ }
+                    break;
+                }
             }
+            interrupts();
         }
-        interrupts();
     }
+
     bool _multicore = false;
-
     mutex_t _idleMutex;
-    static volatile bool _otherIdled;
     queue_t _queue[2];
-
-    static constexpr int _GOTOSLEEP = 0x66666666;
+    static constexpr uint32_t _GOTOSLEEP = 0xC0DED02E;
 };
 
+
 class RP2040;
 extern RP2040 rp2040;
-class RP2040 {
-public:
-    RP2040() {
-        _epoch = 0;
-        // Enable SYSTICK exception
-        exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
-        systick_hw->csr = 0x7;
-        systick_hw->rvr = 0x00FFFFFF;
-    }
-
-    ~RP2040() { /* noop */ }
-
-
-    // Convert from microseconds to PIO clock cycles
-    static int usToPIOCycles(int us) {
-        // Parenthesis needed to guarantee order of operations to avoid 32bit overflow
-        return (us * (clock_get_hz(clk_sys) / 1000000));
-    }
-
-    // Get current clock frequency
-    static int f_cpu() {
-        return clock_get_hz(clk_sys);
-    }
-
-    // Get CPU cycle count.  Needs to do magic to extens 24b HW to something longer
-    volatile uint64_t _epoch = 0;
-    inline uint32_t getCycleCount() {
-        uint32_t epoch;
-        uint32_t ctr;
-        do {
-            epoch = (uint32_t)_epoch;
-            ctr = systick_hw->cvr;
-        } while (epoch != (uint32_t)_epoch);
-        return epoch + (1 << 24) - ctr; /* CTR counts down from 1<<24-1 */
-    }
-
-    inline uint64_t getCycleCount64() {
-        uint64_t epoch;
-        uint64_t ctr;
-        do {
-            epoch = _epoch;
-            ctr = systick_hw->cvr;
-        } while (epoch != _epoch);
-        return epoch + (1LL << 24) - ctr;
-    }
-
-    void idleOtherCore() {
-        fifo.idleOtherCore();
-    }
-
-    void resumeOtherCore() {
-        fifo.resumeOtherCore();
-    }
-
-    // Multicore comms FIFO
-    _MFIFO fifo;
-
-private:
-    static void _SystickHandler() {
-        rp2040._epoch += 1LL << 24;
-    }
-};
+extern "C" void main1();
+class PIOProgram;
 
 // Wrapper class for PIO programs, abstracting common operations out
 // TODO - Add unload/destructor
@@ -235,3 +195,90 @@ private:
     const pio_program_t *_pgm;
 };
 
+class RP2040 {
+public:
+    RP2040()  { /* noop */ }
+    ~RP2040() { /* noop */ }
+
+    void begin() {
+        _epoch = 0;
+        if (!__isFreeRTOS) {
+            // Enable SYSTICK exception
+            exception_set_exclusive_handler(SYSTICK_EXCEPTION, _SystickHandler);
+            systick_hw->csr = 0x7;
+            systick_hw->rvr = 0x00FFFFFF;
+        } else {
+            int off = 0;
+            _ccountPgm = new PIOProgram(&ccount_program);
+            _ccountPgm->prepare(&_pio, &_sm, &off);
+            ccount_program_init(_pio, _sm, off);
+            pio_sm_set_enabled(_pio, _sm, true);
+        }
+    }
+
+    // Convert from microseconds to PIO clock cycles
+    static int usToPIOCycles(int us) {
+        // Parenthesis needed to guarantee order of operations to avoid 32bit overflow
+        return (us * (clock_get_hz(clk_sys) / 1000000));
+    }
+
+    // Get current clock frequency
+    static int f_cpu() {
+        return clock_get_hz(clk_sys);
+    }
+
+    // Get CPU cycle count.  Needs to do magic to extens 24b HW to something longer
+    volatile uint64_t _epoch = 0;
+    inline uint32_t getCycleCount() {
+        if (!__isFreeRTOS) {
+            uint32_t epoch;
+            uint32_t ctr;
+            do {
+                epoch = (uint32_t)_epoch;
+                ctr = systick_hw->cvr;
+            } while (epoch != (uint32_t)_epoch);
+            return epoch + (1 << 24) - ctr; /* CTR counts down from 1<<24-1 */
+        } else {
+            return ccount_read(_pio, _sm);
+        }
+    }
+
+    inline uint64_t getCycleCount64() {
+        if (!__isFreeRTOS) {
+            uint64_t epoch;
+            uint64_t ctr;
+            do {
+                epoch = _epoch;
+                ctr = systick_hw->cvr;
+            } while (epoch != _epoch);
+            return epoch + (1LL << 24) - ctr;
+        } else {
+            return ccount_read(_pio, _sm);
+        }
+    }
+
+    void idleOtherCore() {
+        fifo.idleOtherCore();
+    }
+
+    void resumeOtherCore() {
+        fifo.resumeOtherCore();
+    }
+
+    void restartCore1() {
+        multicore_reset_core1();
+        fifo.clear();
+        multicore_launch_core1(main1);
+    }
+
+    // Multicore comms FIFO
+    _MFIFO fifo;
+
+private:
+    static void _SystickHandler() {
+        rp2040._epoch += 1LL << 24;
+    }
+    PIO _pio;
+    int _sm;
+    PIOProgram *_ccountPgm;
+};

cores/rp2040/RP2040USB.cpp

@@ -40,7 +40,7 @@ mutex_t __usb_mutex;
 
 // USB processing will be a periodic timer task
 #define USB_TASK_INTERVAL 1000
-#define USB_TASK_IRQ 31
+static int __usb_task_irq;
 
 // USB VID/PID (note that PID can change depending on the add'l interfaces)
 #define USBD_VID (0x2E8A) // Raspberry Pi
@@ -120,49 +120,49 @@ int __USBGetMouseReportID() {
     return __USBInstallKeyboard ? 2 : 1;
 }
 
+static int      __hid_report_len = 0;
+static uint8_t *__hid_report     = nullptr;
+
 static uint8_t *GetDescHIDReport(int *len) {
-    static uint8_t *report = nullptr;
-    int report_len = 0;
-
-    if (report) {
-        free(report);
-        report = nullptr;
+    if (len) {
+        *len = __hid_report_len;
     }
+    return __hid_report;
+}
 
+void __SetupDescHIDReport() {
     if (__USBInstallKeyboard && __USBInstallMouse) {
         uint8_t desc_hid_report[] = {
             TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(1)),
             TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(2))
         };
-        report_len = sizeof(desc_hid_report);
-        report = (uint8_t *)malloc(report_len);
-        if (report) {
-            memcpy(report, desc_hid_report, report_len);
+        __hid_report = (uint8_t *)malloc(sizeof(desc_hid_report));
+        if (__hid_report) {
+            __hid_report_len = sizeof(desc_hid_report);
+            memcpy(__hid_report, desc_hid_report, __hid_report_len);
         }
     } else if (__USBInstallKeyboard && ! __USBInstallMouse) {
         uint8_t desc_hid_report[] = {
             TUD_HID_REPORT_DESC_KEYBOARD(HID_REPORT_ID(1))
         };
-        report_len = sizeof(desc_hid_report);
-        report = (uint8_t *)malloc(report_len);
-        if (report) {
-            memcpy(report, desc_hid_report, report_len);
+        __hid_report = (uint8_t *)malloc(sizeof(desc_hid_report));
+        if (__hid_report) {
+            __hid_report_len = sizeof(desc_hid_report);
+            memcpy(__hid_report, desc_hid_report, __hid_report_len);
         }
-    } else { // if (!__USBInstallKeyboard && __USBInstallMouse) {
+    } else if (! __USBInstallKeyboard &&  __USBInstallMouse) {
         uint8_t desc_hid_report[] = {
             TUD_HID_REPORT_DESC_MOUSE(HID_REPORT_ID(1))
         };
-        report_len = sizeof(desc_hid_report);
-        report = (uint8_t *)malloc(report_len);
-        if (report) {
-            memcpy(report, desc_hid_report, report_len);
+        __hid_report = (uint8_t *)malloc(sizeof(desc_hid_report));
+        if (__hid_report) {
+            __hid_report_len = sizeof(desc_hid_report);
+            memcpy(__hid_report, desc_hid_report, __hid_report_len);
         }
+    } else {
+        __hid_report = nullptr;
+        __hid_report_len = 0;
     }
-
-    if (len) {
-        *len = report_len;
-    }
-    return report;
 }
 
 // Invoked when received GET HID REPORT DESCRIPTOR
@@ -173,11 +173,13 @@ uint8_t const * tud_hid_descriptor_report_cb(uint8_t instance) {
     return GetDescHIDReport(nullptr);
 }
 
-
+static uint8_t *usbd_desc_cfg = nullptr;
 const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
     (void)index;
-    static uint8_t *usbd_desc_cfg = nullptr;
+    return usbd_desc_cfg;
+}
 
+void __SetupUSBDescriptor() {
     if (!usbd_desc_cfg) {
         bool hasHID = __USBInstallKeyboard || __USBInstallMouse;
 
@@ -229,7 +231,6 @@ const uint8_t *tud_descriptor_configuration_cb(uint8_t index) {
             }
         }
     }
-    return usbd_desc_cfg;
 }
 
 const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
@@ -283,22 +284,28 @@ static void usb_irq() {
 }
 
 static int64_t timer_task(__unused alarm_id_t id, __unused void *user_data) {
-    irq_set_pending(USB_TASK_IRQ);
+    irq_set_pending(__usb_task_irq);
     return USB_TASK_INTERVAL;
 }
 
+void __USBStart() __attribute__((weak));
+
 void __USBStart() {
     if (tusb_inited()) {
         // Already called
         return;
     }
 
+    __SetupDescHIDReport();
+    __SetupUSBDescriptor();
+
     mutex_init(&__usb_mutex);
 
     tusb_init();
 
-    irq_set_exclusive_handler(USB_TASK_IRQ, usb_irq);
-    irq_set_enabled(USB_TASK_IRQ, true);
+    __usb_task_irq = user_irq_claim_unused(true);
+    irq_set_exclusive_handler(__usb_task_irq, usb_irq);
+    irq_set_enabled(__usb_task_irq, true);
 
     add_alarm_in_us(USB_TASK_INTERVAL, timer_task, NULL, true);
 }

cores/rp2040/RP2040Version.h

@@ -0,0 +1,5 @@
+#pragma once
+#define ARDUINO_PICO_MAJOR 2
+#define ARDUINO_PICO_MINOR 3
+#define ARDUINO_PICO_REVISION 0
+#define ARDUINO_PICO_VERSION_STR "2.3.0"

cores/rp2040/SerialPIO.cpp

@@ -36,6 +36,10 @@ static pio_program_t *pio_make_uart_prog(int repl, const pio_program_t *pg) {
     p->length = pg->length;
     p->origin = pg->origin;
     uint16_t *insn = (uint16_t *)malloc(p->length * 2);
+    if (!insn) {
+        delete p;
+        return nullptr;
+    }
     memcpy(insn, pg->instructions, p->length * 2);
     insn[0] = pio_encode_set(pio_x, repl);
     p->instructions = insn;
@@ -93,7 +97,7 @@ void __not_in_flash_func(SerialPIO::_handleIRQ)() {
     }
     while (!pio_sm_is_rx_fifo_empty(_rxPIO, _rxSM)) {
         uint32_t decode = _rxPIO->rxf[_rxSM];
-        decode >>= 32 - _rxBits;
+        decode >>= 33 - _rxBits;
         uint32_t val = 0;
         for (int b = 0; b < _bits + 1; b++) {
             val |= (decode & (1 << (b * 2))) ? 1 << b : 0;
@@ -123,7 +127,7 @@ void __not_in_flash_func(SerialPIO::_handleIRQ)() {
             asm volatile("" ::: "memory"); // Ensure the queue is written before the written count advances
             _writer = next_writer;
         } else {
-            // TODO: Overflow
+            _overflow = true;
         }
     }
 }
@@ -142,6 +146,7 @@ SerialPIO::~SerialPIO() {
 }
 
 void SerialPIO::begin(unsigned long baud, uint16_t config) {
+    _overflow = false;
     _baud = baud;
     switch (config & SERIAL_PARITY_MASK) {
     case SERIAL_PARITY_EVEN:
@@ -225,7 +230,7 @@ void SerialPIO::begin(unsigned long baud, uint16_t config) {
         pio_sm_clear_fifos(_rxPIO, _rxSM); // Remove any existing data
 
         // Put phase divider into OSR w/o using add'l program memory
-        pio_sm_put_blocking(_rxPIO, _rxSM, clock_get_hz(clk_sys) / (_baud * 2) - 2);
+        pio_sm_put_blocking(_rxPIO, _rxSM, clock_get_hz(clk_sys) / (_baud * 2) - 5 /* insns in PIO halfbit loop */);
         pio_sm_exec(_rxPIO, _rxSM, pio_encode_pull(false, false));
 
         // Join the TX FIFO to the RX one now that we don't need it
@@ -238,8 +243,9 @@ void SerialPIO::begin(unsigned long baud, uint16_t config) {
         case 2: pio_set_irq0_source_enabled(_rxPIO, pis_sm2_rx_fifo_not_empty, true); break;
         case 3: pio_set_irq0_source_enabled(_rxPIO, pis_sm3_rx_fifo_not_empty, true); break;
         }
-        irq_set_exclusive_handler(PIO0_IRQ_0, _fifoIRQ);
-        irq_set_enabled(PIO0_IRQ_0, true);
+        auto irqno = pio_get_index(_rxPIO) == 0 ? PIO0_IRQ_0 : PIO1_IRQ_0;
+        irq_set_exclusive_handler(irqno, _fifoIRQ);
+        irq_set_enabled(irqno, true);
 
         pio_sm_set_enabled(_rxPIO, _rxSM, true);
     }
@@ -251,8 +257,23 @@ void SerialPIO::end() {
     if (!_running) {
         return;
     }
-    // TODO: Deallocate PIO resources, stop them
-    _pioSP[pio_get_index(_rxPIO)][_rxSM] = nullptr;
+    if (_tx != NOPIN) {
+        pio_sm_set_enabled(_txPIO, _txSM, false);
+    }
+    if (_rx != NOPIN) {
+        pio_sm_set_enabled(_rxPIO, _rxSM, false);
+        _pioSP[pio_get_index(_rxPIO)][_rxSM] = nullptr;
+        // If no more active, disable the IRQ
+        auto pioNum = pio_get_index(_rxPIO);
+        bool used = false;
+        for (int i = 0; i < 4; i++) {
+            used = used || !!_pioSP[pioNum][i];
+        }
+        if (!used) {
+            auto irqno = pioNum == 0 ? PIO0_IRQ_0 : PIO1_IRQ_0;
+            irq_set_enabled(irqno, false);
+        }
+    }
     _running = false;
 }
 
@@ -284,6 +305,17 @@ int SerialPIO::read() {
     return -1;
 }
 
+bool SerialPIO::overflow() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_rx == NOPIN)) {
+        return false;
+    }
+
+    bool hold = _overflow;
+    _overflow = false;
+    return hold;
+}
+
 int SerialPIO::available() {
     CoreMutex m(&_mutex);
     if (!_running || !m || (_rx == NOPIN)) {

cores/rp2040/SerialPIO.h

@@ -47,19 +47,21 @@ public:
     virtual int availableForWrite() override;
     virtual void flush() override;
     virtual size_t write(uint8_t c) override;
+    bool overflow();
     using Print::write;
     operator bool() override;
 
     // Not to be called by users, only from the IRQ handler.  In public so that the C-language IQR callback can access it
     void _handleIRQ();
 
-private:
+protected:
     bool _running = false;
     pin_size_t _tx, _rx;
     int _baud;
     int _bits;
     uart_parity_t _parity;
     int _stop;
+    bool _overflow;
     mutex_t _mutex;
 
     PIOProgram *_txPgm;

cores/rp2040/SerialUART.cpp

@@ -65,6 +65,39 @@ bool SerialUART::setTX(pin_size_t pin) {
     return false;
 }
 
+bool SerialUART::setRTS(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({3, 15, 19}) /* UART0 */,
+                                    __bitset({7, 11, 23, 27})  /* UART1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[uart_get_index(_uart)])) {
+        _rts = pin;
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set Serial%d.RTS while running", uart_get_index(_uart) + 1);
+    } else {
+        panic("FATAL: Attempting to set Serial%d.RTS to illegal pin %d", uart_get_index(_uart) + 1, pin);
+    }
+    return false;
+}
+
+bool SerialUART::setCTS(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({2, 14, 18}) /* UART0 */,
+                                    __bitset({6, 10, 22, 26})  /* UART1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[uart_get_index(_uart)])) {
+        _cts = pin;
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set Serial%d.CTS while running", uart_get_index(_uart) + 1);
+    } else {
+        panic("FATAL: Attempting to set Serial%d.CTS to illegal pin %d", uart_get_index(_uart) + 1, pin);
+    }
+    return false;
+}
 bool SerialUART::setPollingMode(bool mode) {
     if (_running) {
         return false;
@@ -81,17 +114,24 @@ bool SerialUART::setFIFOSize(size_t size) {
     return true;
 }
 
-SerialUART::SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx) {
+SerialUART::SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx, pin_size_t rts, pin_size_t cts) {
     _uart = uart;
     _tx = tx;
     _rx = rx;
+    _rts = rts;
+    _cts = cts;
     mutex_init(&_mutex);
+    mutex_init(&_fifoMutex);
 }
 
 static void _uart0IRQ();
 static void _uart1IRQ();
 
 void SerialUART::begin(unsigned long baud, uint16_t config) {
+    if (_running) {
+        end();
+    }
+    _overflow = false;
     _queue = new uint8_t[_fifoSize];
     _baud = baud;
     uart_init(_uart, baud);
@@ -133,6 +173,13 @@ void SerialUART::begin(unsigned long baud, uint16_t config) {
     uart_set_format(_uart, bits, stop, parity);
     gpio_set_function(_tx, GPIO_FUNC_UART);
     gpio_set_function(_rx, GPIO_FUNC_UART);
+    if (_rts != UART_PIN_NOT_DEFINED) {
+        gpio_set_function(_rts, GPIO_FUNC_UART);
+    }
+    if (_cts != UART_PIN_NOT_DEFINED) {
+        gpio_set_function(_cts, GPIO_FUNC_UART);
+    }
+    uart_set_hw_flow(_uart, _rts != UART_PIN_NOT_DEFINED, _cts != UART_PIN_NOT_DEFINED);
     _writer = 0;
     _reader = 0;
 
@@ -156,6 +203,7 @@ void SerialUART::end() {
     if (!_running) {
         return;
     }
+    _running = false;
     if (!_polling) {
         if (_uart == uart0) {
             irq_set_enabled(UART0_IRQ, false);
@@ -163,9 +211,28 @@ void SerialUART::end() {
             irq_set_enabled(UART1_IRQ, false);
         }
     }
+    // Paranoia - ensure nobody else is using anything here at the same time
+    mutex_enter_blocking(&_mutex);
+    mutex_enter_blocking(&_fifoMutex);
     uart_deinit(_uart);
     delete[] _queue;
-    _running = false;
+    // Reset the mutexes once all is off/cleaned up
+    mutex_exit(&_fifoMutex);
+    mutex_exit(&_mutex);
+}
+
+void SerialUART::_pumpFIFO() {
+    // Use the _fifoMutex to guard against the other core potentially
+    // running the IRQ (since we can't disable their IRQ handler).
+    // We guard against this core by disabling the IRQ handler and
+    // re-enabling if it was previously enabled at the end.
+    auto irqno = (_uart == uart0) ? UART0_IRQ : UART1_IRQ;
+    bool enabled = irq_is_enabled(irqno);
+    irq_set_enabled(irqno, false);
+    mutex_enter_blocking(&_fifoMutex);
+    _handleIRQ(false);
+    mutex_exit(&_fifoMutex);
+    irq_set_enabled(irqno, enabled);
 }
 
 int SerialUART::peek() {
@@ -174,7 +241,9 @@ int SerialUART::peek() {
         return -1;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
+    } else {
+        _pumpFIFO();
     }
     if (_writer != _reader) {
         return _queue[_reader];
@@ -188,7 +257,9 @@ int SerialUART::read() {
         return -1;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
+    } else {
+        _pumpFIFO();
     }
     if (_writer != _reader) {
         auto ret = _queue[_reader];
@@ -201,13 +272,25 @@ int SerialUART::read() {
     return -1;
 }
 
+bool SerialUART::overflow() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m) {
+        return false;
+    }
+    bool hold = _overflow;
+    _overflow = false;
+    return hold;
+}
+
 int SerialUART::available() {
     CoreMutex m(&_mutex);
     if (!_running || !m) {
         return 0;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
+    } else {
+        _pumpFIFO();
     }
     return (_writer - _reader) % _fifoSize;
 }
@@ -218,7 +301,7 @@ int SerialUART::availableForWrite() {
         return 0;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
     }
     return (uart_is_writable(_uart)) ? 1 : 0;
 }
@@ -229,7 +312,7 @@ void SerialUART::flush() {
         return;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
     }
     uart_tx_wait_blocking(_uart);
 }
@@ -240,7 +323,7 @@ size_t SerialUART::write(uint8_t c) {
         return 0;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
     }
     uart_putc_raw(_uart, c);
     return 1;
@@ -252,7 +335,7 @@ size_t SerialUART::write(const uint8_t *p, size_t len) {
         return 0;
     }
     if (_polling) {
-        _handleIRQ();
+        _handleIRQ(false);
     }
     size_t cnt = len;
     while (cnt) {
@@ -267,9 +350,6 @@ SerialUART::operator bool() {
     return _running;
 }
 
-SerialUART Serial1(uart0, PIN_SERIAL1_TX, PIN_SERIAL1_RX);
-SerialUART Serial2(uart1, PIN_SERIAL2_TX, PIN_SERIAL2_RX);
-
 void arduino::serialEvent1Run(void) {
     if (serialEvent1 && Serial1.available()) {
         serialEvent1();
@@ -283,7 +363,15 @@ void arduino::serialEvent2Run(void) {
 }
 
 // IRQ handler, called when FIFO > 1/8 full or when it had held unread data for >32 bit times
-void __not_in_flash_func(SerialUART::_handleIRQ)() {
+void __not_in_flash_func(SerialUART::_handleIRQ)(bool inIRQ) {
+    if (inIRQ) {
+        uint32_t owner;
+        if (!mutex_try_enter(&_fifoMutex, &owner)) {
+            // Main app on the other core has the mutex so it is
+            // in the process of pulling data out of the HW FIFO
+            return;
+        }
+    }
     // ICR is write-to-clear
     uart_get_hw(_uart)->icr = UART_UARTICR_RTIC_BITS | UART_UARTICR_RXIC_BITS;
     while (uart_is_readable(_uart)) {
@@ -298,15 +386,46 @@ void __not_in_flash_func(SerialUART::_handleIRQ)() {
             // Avoid using division or mod because the HW divider could be in use
             _writer = next_writer;
         } else {
-            // TODO: Overflow
+            _overflow = true;
         }
     }
+    if (inIRQ) {
+        mutex_exit(&_fifoMutex);
+    }
 }
 
+#ifndef __SERIAL1_DEVICE
+#define __SERIAL1_DEVICE uart0
+#endif
+#ifndef __SERIAL2_DEVICE
+#define __SERIAL2_DEVICE uart1
+#endif
+
+#if defined(PIN_SERIAL1_RTS)
+SerialUART Serial1(__SERIAL1_DEVICE, PIN_SERIAL1_TX, PIN_SERIAL1_RX, PIN_SERIAL1_RTS, PIN_SERIAL1_CTS);
+#else
+SerialUART Serial1(__SERIAL1_DEVICE, PIN_SERIAL1_TX, PIN_SERIAL1_RX);
+#endif
+
+#if defined(PIN_SERIAL2_RTS)
+SerialUART Serial2(__SERIAL2_DEVICE, PIN_SERIAL2_TX, PIN_SERIAL2_RX, PIN_SERIAL2_RTS, PIN_SERIAL2_CTS);
+#else
+SerialUART Serial2(__SERIAL2_DEVICE, PIN_SERIAL2_TX, PIN_SERIAL2_RX);
+#endif
+
+
 static void __not_in_flash_func(_uart0IRQ)() {
-    Serial1._handleIRQ();
+    if (__SERIAL1_DEVICE == uart0) {
+        Serial1._handleIRQ();
+    } else {
+        Serial2._handleIRQ();
+    }
 }
 
 static void __not_in_flash_func(_uart1IRQ)() {
-    Serial2._handleIRQ();
+    if (__SERIAL2_DEVICE == uart1) {
+        Serial2._handleIRQ();
+    } else {
+        Serial1._handleIRQ();
+    }
 }

cores/rp2040/SerialUART.h

@@ -28,13 +28,16 @@
 
 extern "C" typedef struct uart_inst uart_inst_t;
 
+#define UART_PIN_NOT_DEFINED      (255u)
 class SerialUART : public HardwareSerial {
 public:
-    SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx);
+    SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx, pin_size_t rts = UART_PIN_NOT_DEFINED, pin_size_t cts = UART_PIN_NOT_DEFINED);
 
     // Select the pinout.  Call before .begin()
     bool setRX(pin_size_t pin);
     bool setTX(pin_size_t pin);
+    bool setRTS(pin_size_t pin);
+    bool setCTS(pin_size_t pin);
     bool setPinout(pin_size_t tx, pin_size_t rx) {
         bool ret = setRX(rx);
         ret &= setTX(tx);
@@ -57,24 +60,29 @@ public:
     virtual size_t write(uint8_t c) override;
     virtual size_t write(const uint8_t *p, size_t len) override;
     using Print::write;
+    bool overflow();
     operator bool() override;
 
     // Not to be called by users, only from the IRQ handler.  In public so that the C-language IQR callback can access it
-    void _handleIRQ();
+    void _handleIRQ(bool inIRQ = true);
 
 private:
     bool _running = false;
     uart_inst_t *_uart;
     pin_size_t _tx, _rx;
+    pin_size_t _rts, _cts;
     int _baud;
     mutex_t _mutex;
     bool _polling = false;
+    bool _overflow;
 
     // Lockless, IRQ-handled circular queue
     uint32_t _writer;
     uint32_t _reader;
     size_t   _fifoSize = 32;
-    uint8_t  *_queue;
+    uint8_t *_queue;
+    mutex_t  _fifoMutex; // Only needed when non-IRQ updates _writer
+    void _pumpFIFO(); // User space FIFO transfer
 };
 
 extern SerialUART Serial1; // HW UART 0

cores/rp2040/SerialUSB.cpp

@@ -123,7 +123,7 @@ size_t SerialUSB::write(const uint8_t *buf, size_t length) {
     }
 
     static uint64_t last_avail_time;
-    int i = 0;
+    int written = 0;
     if (tud_cdc_connected()) {
         for (size_t i = 0; i < length;) {
             int n = length - i;
@@ -136,6 +136,7 @@ size_t SerialUSB::write(const uint8_t *buf, size_t length) {
                 tud_task();
                 tud_cdc_write_flush();
                 i += n2;
+                written += n2;
                 last_avail_time = time_us_64();
             } else {
                 tud_task();
@@ -150,7 +151,7 @@ size_t SerialUSB::write(const uint8_t *buf, size_t length) {
         // reset our timeout
         last_avail_time = 0;
     }
-    return i;
+    return written;
 }
 
 SerialUSB::operator bool() {

cores/rp2040/SerialUSB.h

@@ -18,8 +18,7 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef __SERIALUSB_H__
-#define __SERIALUSB_H__
+#pragma once
 
 #include <Arduino.h>
 #include "api/HardwareSerial.h"
@@ -54,5 +53,3 @@ extern SerialUSB Serial;
 namespace arduino {
 extern void serialEventRun(void) __attribute__((weak));
 };
-
-#endif

cores/rp2040/SoftwareSerial.h

@@ -0,0 +1,59 @@
+/*
+    SoftwareSerial wrapper for SerialPIO
+
+    Copyright (c) 2022 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+#include "SerialPIO.h"
+
+class SoftwareSerial : public SerialPIO {
+public:
+    // Note the rx/tx pins are swapped in PIO vs SWSerial
+    SoftwareSerial(pin_size_t rx, pin_size_t tx, bool invert = false) : SerialPIO(tx, rx) {
+        _invert = invert;
+    }
+
+    ~SoftwareSerial() {
+        if (_invert) {
+            gpio_set_outover(_tx, 0);
+            gpio_set_outover(_rx, 0);
+        }
+    }
+
+    virtual void begin(unsigned long baud = 115200) override {
+        begin(baud, SERIAL_8N1);
+    };
+
+    void begin(unsigned long baud, uint16_t config) override {
+        SerialPIO::begin(baud, config);
+        if (_invert) {
+            gpio_set_outover(_tx, GPIO_OVERRIDE_INVERT);
+            gpio_set_inover(_rx, GPIO_OVERRIDE_INVERT);
+        }
+    }
+
+    void listen() { /* noop */ }
+
+    bool isListening() {
+        return true;
+    }
+
+private:
+    bool _invert;
+};

cores/rp2040/api/Common.h

@@ -20,6 +20,10 @@ typedef enum {
   OUTPUT          = 0x1,
   INPUT_PULLUP    = 0x2,
   INPUT_PULLDOWN  = 0x3,
+  OUTPUT_2MA      = 0x4,
+  OUTPUT_4MA      = 0x5,
+  OUTPUT_8MA      = 0x6,
+  OUTPUT_12MA     = 0x7,
 } PinMode;
 
 typedef enum {

cores/rp2040/api/IPAddress.cpp

@@ -1,55 +1,75 @@
 /*
-  IPAddress.cpp - Base class that provides IPAddress
-  Copyright (c) 2011 Adrian McEwen.  All right reserved.
+ IPAddress.cpp - Base class that provides IPAddress
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
 
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
 
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
 
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
 
-#include "IPAddress.h"
-#include "Print.h"
+#include <Arduino.h>
+#include <IPAddress.h>
+#include <Print.h>
 
-using namespace arduino;
-
-IPAddress::IPAddress()
+IPAddress::IPAddress(const IPAddress& from)
 {
-    _address.dword = 0;
+    ip_addr_copy(_ip, from._ip);
 }
 
-IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
-{
-    _address.bytes[0] = first_octet;
-    _address.bytes[1] = second_octet;
-    _address.bytes[2] = third_octet;
-    _address.bytes[3] = fourth_octet;
+IPAddress::IPAddress() {
+    _ip = *IP_ANY_TYPE; // lwIP's v4-or-v6 generic address
 }
 
-IPAddress::IPAddress(uint32_t address)
-{
-    _address.dword = address;
+bool IPAddress::isSet () const {
+    return !ip_addr_isany(&_ip) && ((*this) != IPADDR_NONE);
 }
 
-IPAddress::IPAddress(const uint8_t *address)
-{
-    memcpy(_address.bytes, address, sizeof(_address.bytes));
+IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet) {
+    setV4();
+    (*this)[0] = first_octet;
+    (*this)[1] = second_octet;
+    (*this)[2] = third_octet;
+    (*this)[3] = fourth_octet;
 }
 
-bool IPAddress::fromString(const char *address)
-{
-    // TODO: add support for "a", "a.b", "a.b.c" formats
+void IPAddress::ctor32(uint32_t address) {
+    setV4();
+    v4() = address;
+}
 
-    int16_t acc = -1; // Accumulator
+IPAddress::IPAddress(const uint8_t *address) {
+    setV4();
+    (*this)[0] = address[0];
+    (*this)[1] = address[1];
+    (*this)[2] = address[2];
+    (*this)[3] = address[3];
+}
+
+bool IPAddress::fromString(const char *address) {
+    if (!fromString4(address)) {
+#if LWIP_IPV6
+        return fromString6(address);
+#else
+        return false;
+#endif
+    }
+    return true;
+}
+
+bool IPAddress::fromString4(const char *address) {
+    // TODO: (IPv4) add support for "a", "a.b", "a.b.c" formats
+
+    uint16_t acc = 0; // Accumulator
     uint8_t dots = 0;
 
     while (*address)
@@ -57,7 +77,7 @@ bool IPAddress::fromString(const char *address)
         char c = *address++;
         if (c >= '0' && c <= '9')
         {
-            acc = (acc < 0) ? (c - '0') : acc * 10 + (c - '0');
+            acc = acc * 10 + (c - '0');
             if (acc > 255) {
                 // Value out of [0..255] range
                 return false;
@@ -69,12 +89,8 @@ bool IPAddress::fromString(const char *address)
                 // Too much dots (there must be 3 dots)
                 return false;
             }
-            if (acc < 0) {
-                /* No value between dots, e.g. '1..' */
-                return false;
-            }
-            _address.bytes[dots++] = acc;
-            acc = -1;
+            (*this)[dots++] = acc;
+            acc = 0;
         }
         else
         {
@@ -87,41 +103,144 @@ bool IPAddress::fromString(const char *address)
         // Too few dots (there must be 3 dots)
         return false;
     }
-    if (acc < 0) {
-        /* No value between dots, e.g. '1..' */
-        return false;
-    }
-    _address.bytes[3] = acc;
+    (*this)[3] = acc;
+
+    setV4();
     return true;
 }
 
-IPAddress& IPAddress::operator=(const uint8_t *address)
-{
-    memcpy(_address.bytes, address, sizeof(_address.bytes));
+IPAddress& IPAddress::operator=(const uint8_t *address) {
+    setV4();
+    v4() = *reinterpret_cast<const uint32_t*>(address);
     return *this;
 }
 
-IPAddress& IPAddress::operator=(uint32_t address)
-{
-    _address.dword = address;
+IPAddress& IPAddress::operator=(uint32_t address) {
+    setV4();
+    v4() = address;
     return *this;
 }
 
-bool IPAddress::operator==(const uint8_t* addr) const
-{
-    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
+bool IPAddress::operator==(const uint8_t* addr) const {
+    return isV4() && v4() == *reinterpret_cast<const uint32_t*>(addr);
 }
 
-size_t IPAddress::printTo(Print& p) const
+size_t IPAddress::printTo(Print& p) const {
+    String s = toString();
+    return p.print(s);
+}
+
+String IPAddress::toString() const
 {
-    size_t n = 0;
-    for (int i =0; i < 3; i++)
-    {
-        n += p.print(_address.bytes[i], DEC);
-        n += p.print('.');
+    String s;
+
+    if (!isSet())
+        return "(IP unset)";
+
+#if LWIP_IPV6
+    if (isV6()) {
+        int count0 = 0;
+        for (int i = 0; i < 8; i++) {
+            uint16_t bit = PP_NTOHS(raw6()[i]);
+            if (bit || count0 < 0) {
+                char buff[64];
+                snprintf(buff, 64, "%x", bit);
+                buff[63] = 0;
+                s += buff;
+                if (count0 > 0)
+                    // no more hiding 0
+                    count0 = -8;
+            } else
+                count0++;
+            if ((i != 7 && count0 < 2) || count0 == 7)
+                s += ':';
+        }
+        return s;
     }
-    n += p.print(_address.bytes[3], DEC);
-    return n;
+#endif
+
+    for(int i = 0; i < 4; i++) {
+        char buff[16];
+        snprintf(buff, 16, "%d", (*this)[i]);
+        buff[15] = 0;
+        s += buff;
+        if (i != 3)
+            s += '.';
+    }
+    return s;
+
 }
 
-const IPAddress arduino::INADDR_NONE(0,0,0,0);
+bool IPAddress::isValid(const String& arg) {
+	return IPAddress().fromString(arg);
+}
+
+bool IPAddress::isValid(const char* arg) {
+	return IPAddress().fromString(arg);
+}
+
+const IPAddress INADDR_ANY; // generic "0.0.0.0" for IPv4 & IPv6
+const IPAddress INADDR_NONE(255,255,255,255);
+
+void IPAddress::clear() {
+    (*this) = INADDR_ANY;
+}
+
+/**************************************/
+
+#if LWIP_IPV6
+
+bool IPAddress::fromString6(const char *address) {
+    // TODO: test test test
+
+    uint32_t acc = 0; // Accumulator
+    int dots = 0, doubledots = -1;
+
+    while (*address)
+    {
+        char c = tolower(*address++);
+        if (isalnum(c)) {
+            if (c >= 'a')
+                c -= 'a' - '0' - 10;
+            acc = acc * 16 + (c - '0');
+            if (acc > 0xffff)
+                // Value out of range
+                return false;
+        }
+        else if (c == ':') {
+            if (*address == ':') {
+                if (doubledots >= 0)
+                    // :: allowed once
+                    return false;
+                // remember location
+                doubledots = dots + !!acc;
+                address++;
+            }
+            if (dots == 7)
+                // too many separators
+                return false;
+            raw6()[dots++] = PP_HTONS(acc);
+            acc = 0;
+        }
+        else
+            // Invalid char
+            return false;
+    }
+
+    if (doubledots == -1 && dots != 7)
+        // Too few separators
+        return false;
+    raw6()[dots++] = PP_HTONS(acc);
+
+    if (doubledots != -1) {
+        for (int i = dots - doubledots - 1; i >= 0; i--)
+            raw6()[8 - dots + doubledots + i] = raw6()[doubledots + i];
+        for (int i = doubledots; i < 8 - dots + doubledots; i++)
+            raw6()[i] = 0;
+    }
+
+    setV6();
+    return true;
+}
+
+#endif

cores/rp2040/api/IPAddress.h

@@ -1,85 +1,218 @@
 /*
-  IPAddress.h - Base class that provides IPAddress
-  Copyright (c) 2011 Adrian McEwen.  All right reserved.
+ IPAddress.h - Base class that provides IPAddress
+ Copyright (c) 2011 Adrian McEwen.  All right reserved.
 
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
 
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
 
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
 
 #pragma once
 
 #include <stdint.h>
-#include "Printable.h"
-#include "String.h"
+#include <api/String.h>
+#include <Printable.h>
 
-// forward declartions of global name space friend classes
-class EthernetClass;
-class DhcpClass;
-class DNSClient;
+#include <lwip/init.h>
+#include <lwip/ip_addr.h>
+#include <lwip/ip4_addr.h>
 
 namespace arduino {
 
+#if !LWIP_IPV6
+struct ip_addr: ipv4_addr { };
+#endif // !LWIP_IPV6
+
+// to display a netif id with printf:
+#define NETIFID_STR        "%c%c%u"
+#define NETIFID_VAL(netif) \
+        ((netif)? (netif)->name[0]: '-'),     \
+        ((netif)? (netif)->name[1]: '-'),     \
+        ((netif)? netif_get_index(netif): 42)
+
 // A class to make it easier to handle and pass around IP addresses
+// IPv6 update:
+// IPAddress is now a decorator class for lwIP's ip_addr_t
+// fully backward compatible with legacy IPv4-only Arduino's
+// with unchanged footprint when IPv6 is disabled
 
-class IPAddress : public Printable {
-private:
-    union {
-	uint8_t bytes[4];  // IPv4 address
-	uint32_t dword;
-    } _address;
+class IPAddress: public Printable {
+    private:
 
-    // Access the raw byte array containing the address.  Because this returns a pointer
-    // to the internal structure rather than a copy of the address this function should only
-    // be used when you know that the usage of the returned uint8_t* will be transient and not
-    // stored.
-    uint8_t* raw_address() { return _address.bytes; };
+        ip_addr_t _ip;
 
-public:
-    // Constructors
-    IPAddress();
-    IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
-    IPAddress(uint32_t address);
-    IPAddress(const uint8_t *address);
+        // Access the raw byte array containing the address.  Because this returns a pointer
+        // to the internal structure rather than a copy of the address this function should only
+        // be used when you know that the usage of the returned uint8_t* will be transient and not
+        // stored.
+        uint8_t* raw_address() {
+            return reinterpret_cast<uint8_t*>(&v4());
+        }
+        const uint8_t* raw_address() const {
+            return reinterpret_cast<const uint8_t*>(&v4());
+        }
 
-    bool fromString(const char *address);
-    bool fromString(const String &address) { return fromString(address.c_str()); }
+        void ctor32 (uint32_t);
 
-    // Overloaded cast operator to allow IPAddress objects to be used where a pointer
-    // to a four-byte uint8_t array is expected
-    operator uint32_t() const { return _address.dword; };
-    bool operator==(const IPAddress& addr) const { return _address.dword == addr._address.dword; };
-    bool operator!=(const IPAddress& addr) const { return _address.dword != addr._address.dword; };
-    bool operator==(const uint8_t* addr) const;
+    public:
+        // Constructors
+        IPAddress();
+        IPAddress(const IPAddress& from);
+        IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
+        IPAddress(uint32_t address) { ctor32(address); }
+//        IPAddress(unsigned long address) { ctor32(address); }
+        IPAddress(int address) { ctor32(address); }
+        IPAddress(const uint8_t *address);
 
-    // Overloaded index operator to allow getting and setting individual octets of the address
-    uint8_t operator[](int index) const { return _address.bytes[index]; };
-    uint8_t& operator[](int index) { return _address.bytes[index]; };
+        bool fromString(const char *address);
+        bool fromString(const String &address) { return fromString(address.c_str()); }
 
-    // Overloaded copy operators to allow initialisation of IPAddress objects from other types
-    IPAddress& operator=(const uint8_t *address);
-    IPAddress& operator=(uint32_t address);
+        // Overloaded cast operator to allow IPAddress objects to be used where a pointer
+        // to a four-byte uint8_t array is expected
+        operator uint32_t() const { return isV4()? v4(): (uint32_t)0; }
+        operator uint32_t()       { return isV4()? v4(): (uint32_t)0; }
 
-    virtual size_t printTo(Print& p) const;
+        bool isSet () const;
+        operator bool () const { return isSet(); } // <-
+        operator bool ()       { return isSet(); } // <- both are needed
+
+        // generic IPv4 wrapper to uint32-view like arduino loves to see it
+        const uint32_t& v4() const { return ip_2_ip4(&_ip)->addr; } // for raw_address(const)
+              uint32_t& v4()       { return ip_2_ip4(&_ip)->addr; }
+
+        bool operator==(const IPAddress& addr) const {
+            return ip_addr_cmp(&_ip, &addr._ip);
+        }
+        bool operator!=(const IPAddress& addr) const {
+            return !ip_addr_cmp(&_ip, &addr._ip);
+        }
+        bool operator==(uint32_t addr) const {
+            return isV4() && v4() == addr;
+        }
+//        bool operator==(unsigned long addr) const {
+//            return isV4() && v4() == (uint32_t)addr;
+//        }
+        bool operator!=(uint32_t addr) const {
+            return !(isV4() && v4() == addr);
+        }
+//        bool operator!=(unsigned long addr) const {
+//            return isV4() && v4() != (uint32_t)addr;
+//        }
+        bool operator==(const uint8_t* addr) const;
+
+        int operator>>(int n) const {
+            return isV4()? v4() >> n: 0;
+        }
+
+        // Overloaded index operator to allow getting and setting individual octets of the address
+        uint8_t operator[](int index) const {
+            return isV4()? *(raw_address() + index): 0;
+        }
+        uint8_t& operator[](int index) {
+            setV4();
+            return *(raw_address() + index);
+        }
+
+        // Overloaded copy operators to allow initialisation of IPAddress objects from other types
+        IPAddress& operator=(const uint8_t *address);
+        IPAddress& operator=(uint32_t address);
+        IPAddress& operator=(const IPAddress&) = default;
+
+        virtual size_t printTo(Print& p) const;
+        String toString() const;
+
+        void clear();
+
+        /*
+                check if input string(arg) is a valid IPV4 address or not.
+                return true on valid.
+                return false on invalid.
+        */
+        static bool isValid(const String& arg);
+        static bool isValid(const char* arg);
+
+        friend class WiFiClass;
+        friend class EthernetClass;
+        friend class UDP;
+        friend class Client;
+        friend class Server;
+        friend class DhcpClass;
+        friend class DNSClient;
+
+        /*
+               lwIP address compatibility
+        */
+        //IPAddress(const ipv4_addr& fw_addr)   { setV4(); v4() = fw_addr.addr; }
+        //IPAddress(const ipv4_addr* fw_addr)   { setV4(); v4() = fw_addr->addr; }
+
+        //IPAddress& operator=(const ipv4_addr& fw_addr)   { setV4(); v4() = fw_addr.addr;  return *this; }
+        //IPAddress& operator=(const ipv4_addr* fw_addr)   { setV4(); v4() = fw_addr->addr; return *this; }
+
+        operator       ip_addr_t () const { return  _ip; }
+        operator const ip_addr_t*() const { return &_ip; }
+        operator       ip_addr_t*()       { return &_ip; }
+
+        bool isV4() const { return IP_IS_V4_VAL(_ip); }
+        void setV4() { IP_SET_TYPE_VAL(_ip, IPADDR_TYPE_V4); }
+
+        bool isLocal () const { return ip_addr_islinklocal(&_ip); }
+
+#if LWIP_IPV6
+
+        IPAddress(const ip_addr_t& lwip_addr) { ip_addr_copy(_ip, lwip_addr); }
+        IPAddress(const ip_addr_t* lwip_addr) { ip_addr_copy(_ip, *lwip_addr); }
+
+        IPAddress& operator=(const ip_addr_t& lwip_addr) { ip_addr_copy(_ip, lwip_addr); return *this; }
+        IPAddress& operator=(const ip_addr_t* lwip_addr) { ip_addr_copy(_ip, *lwip_addr); return *this; }
+
+        uint16_t* raw6()
+        {
+            setV6();
+            return reinterpret_cast<uint16_t*>(ip_2_ip6(&_ip));
+        }
+
+        const uint16_t* raw6() const
+        {
+            return isV6()? reinterpret_cast<const uint16_t*>(ip_2_ip6(&_ip)): nullptr;
+        }
+
+        // when not IPv6, ip_addr_t == ip4_addr_t so this one would be ambiguous
+        // required otherwise
+        operator const ip4_addr_t*() const { return isV4()? ip_2_ip4(&_ip): nullptr; }
+
+        bool isV6() const { return IP_IS_V6_VAL(_ip); }
+        void setV6() { IP_SET_TYPE_VAL(_ip, IPADDR_TYPE_V6); }
+
+    protected:
+        bool fromString6(const char *address);
+
+#else
+
+        // allow portable code when IPv6 is not enabled
+
+        uint16_t* raw6() { return nullptr; }
+        const uint16_t* raw6() const { return nullptr; }
+        bool isV6() const { return false; }
+        void setV6() { }
+
+#endif
+
+    protected:
+        bool fromString4(const char *address);
 
-    friend class UDP;
-    friend class Client;
-    friend class Server;
-    
-    friend ::EthernetClass;
-    friend ::DhcpClass;
-    friend ::DNSClient;
 };
 
+extern const IPAddress INADDR_ANY;
 extern const IPAddress INADDR_NONE;
+
 }

cores/rp2040/ccount.pio

@@ -0,0 +1,62 @@
+; Cycle Count for the Raspberry Pi Pico RP2040
+;
+; Copyright (c) 2022 Earle F. Philhower, III <earlephilhower@yahoo.com>
+;
+; This library is free software; you can redistribute it and/or
+; modify it under the terms of the GNU Lesser General Public
+; License as published by the Free Software Foundation; either
+; version 2.1 of the License, or (at your option) any later version.
+;
+; This library is distributed in the hope that it will be useful,
+; but WITHOUT ANY WARRANTY; without even the implied warranty of
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+; Lesser General Public License for more details.
+;
+; You should have received a copy of the GNU Lesser General Public
+; License along with this library; if not, write to the Free Software
+; Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+; Cycle count is stored in {-y, -x}
+
+.program ccount
+cnt:
+    jmp x-- cnt
+epoch:
+    jmp y-- cnt
+
+% c-sdk {
+static inline void ccount_program_init(PIO pio, uint sm, uint offset) {
+    pio_sm_config c = ccount_program_get_default_config(offset);
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_exec(pio, sm, pio_encode_set(pio_x, 0));
+    pio_sm_exec(pio, sm, pio_encode_set(pio_y, 0));
+}
+
+static inline uint64_t ccount_read(PIO pio, uint sm) {
+    static uint64_t extra = 0;
+    // Guard against having the epoch rollover while we're reading the time.
+    // If epoch2 != epoch1, we looped in middle and get new LSW
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_y));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_x));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_y));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_x));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    extra += 8;
+    uint32_t y1 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t x1 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t y2 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t x2 = -((int)pio_sm_get_blocking(pio, sm));
+    uint64_t val;
+    if (y2 != y1) {
+        val = ((((uint64_t)y2) << 32LL) | x2) + y2 /* adjust for missed cycle every epoch increment */;
+    } else {
+        val = ((((uint64_t)y1) << 32LL) | x1) + y1 /* adjust for missed cycle every epoch increment */;
+    }
+    return val + extra;
+}
+
+%}
+

cores/rp2040/ccount.pio.h

@@ -0,0 +1,71 @@
+// -------------------------------------------------- //
+// This file is autogenerated by pioasm; do not edit! //
+// -------------------------------------------------- //
+
+#pragma once
+
+#if !PICO_NO_HARDWARE
+#include "hardware/pio.h"
+#endif
+
+// ------ //
+// ccount //
+// ------ //
+
+#define ccount_wrap_target 0
+#define ccount_wrap 1
+
+static const uint16_t ccount_program_instructions[] = {
+    //     .wrap_target
+    0x0040, //  0: jmp    x--, 0
+    0x0080, //  1: jmp    y--, 0
+    //     .wrap
+};
+
+#if !PICO_NO_HARDWARE
+static const struct pio_program ccount_program = {
+    .instructions = ccount_program_instructions,
+    .length = 2,
+    .origin = -1,
+};
+
+static inline pio_sm_config ccount_program_get_default_config(uint offset) {
+    pio_sm_config c = pio_get_default_sm_config();
+    sm_config_set_wrap(&c, offset + ccount_wrap_target, offset + ccount_wrap);
+    return c;
+}
+
+static inline void ccount_program_init(PIO pio, uint sm, uint offset) {
+    pio_sm_config c = ccount_program_get_default_config(offset);
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_exec(pio, sm, pio_encode_set(pio_x, 0));
+    pio_sm_exec(pio, sm, pio_encode_set(pio_y, 0));
+}
+static inline uint64_t ccount_read(PIO pio, uint sm) {
+    static uint64_t extra = 0;
+    // Guard against having the epoch rollover while we're reading the time.
+    // If epoch2 != epoch1, we looped in middle and get new LSW
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_y));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_x));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_y));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    pio_sm_exec(pio, sm, pio_encode_mov(pio_isr, pio_x));
+    pio_sm_exec(pio, sm, pio_encode_push(false, false));
+    extra += 8;
+    uint32_t y1 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t x1 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t y2 = -((int)pio_sm_get_blocking(pio, sm));
+    uint32_t x2 = -((int)pio_sm_get_blocking(pio, sm));
+    uint64_t val;
+    if (y2 != y1) {
+        val = ((((uint64_t)y2) << 32LL) | x2) + y2 /* adjust for missed cycle every epoch increment */;
+    } else {
+        val = ((((uint64_t)y1) << 32LL) | x1) + y1 /* adjust for missed cycle every epoch increment */;
+    }
+    return val + extra;
+}
+
+#endif
+

cores/rp2040/delay.cpp

@@ -25,6 +25,9 @@
 #include "Adafruit_TinyUSB_API.h"
 #endif
 
+extern "C" void delay(unsigned long ms) __attribute__((weak));
+extern "C" void yield() __attribute__((weak));
+
 extern "C"
 {
 

cores/rp2040/lock.cpp

@@ -0,0 +1,83 @@
+/*
+    Newlib retargetable lock class using RP2040 SDK
+
+    Overrides weak functions in Newlib for locking to safely support
+    multi-core operation.  Does not need any --wrap for memory allocators.
+
+    Copyright (c) 2022 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+
+#include <pico/mutex.h>
+#include <sys/lock.h>
+
+// HACK ALERT
+// Pico-SDK defines mutex which can be at global scope, but when the auto_init_
+// macros are used they are defined as static.  Newlib needs global access to
+// these mutextes, so instead of hacking pico-sdk just make "static" a no-op.
+
+#define static
+auto_init_recursive_mutex(__lock___sinit_recursive_mutex);
+auto_init_recursive_mutex(__lock___sfp_recursive_mutex);
+auto_init_recursive_mutex(__lock___atexit_recursive_mutex);
+auto_init_mutex(__lock___at_quick_exit_mutex);
+auto_init_recursive_mutex(__lock___malloc_recursive_mutex);
+auto_init_recursive_mutex(__lock___env_recursive_mutex);
+auto_init_mutex(__lock___tz_mutex);
+auto_init_mutex(__lock___dd_hash_mutex);
+auto_init_mutex(__lock___arc4random_mutex);
+#undef static
+
+void __retarget_lock_init(_LOCK_T *lock) {
+    mutex_init((mutex_t*) lock);
+}
+
+void __retarget_lock_init_recursive(_LOCK_T *lock) {
+    recursive_mutex_init((recursive_mutex_t*) lock);
+}
+
+void __retarget_lock_close(_LOCK_T lock) {
+    (void) lock;
+}
+
+void __retarget_lock_close_recursive(_LOCK_T lock) {
+    (void) lock;
+}
+
+void __retarget_lock_acquire(_LOCK_T lock) {
+    mutex_enter_blocking((mutex_t*)lock);
+}
+
+void __retarget_lock_acquire_recursive(_LOCK_T lock) {
+    recursive_mutex_enter_blocking((recursive_mutex_t*)lock);
+}
+
+int __retarget_lock_try_acquire(_LOCK_T lock) {
+    return mutex_try_enter((mutex_t *)lock, NULL);
+}
+
+int __retarget_lock_try_acquire_recursive(_LOCK_T lock) {
+    return recursive_mutex_try_enter((recursive_mutex_t*)lock, NULL);
+}
+
+void __retarget_lock_release(_LOCK_T lock) {
+    mutex_exit((mutex_t*)lock);
+}
+
+void __retarget_lock_release_recursive(_LOCK_T lock) {
+    recursive_mutex_exit((recursive_mutex_t*)lock);
+}

cores/rp2040/main.cpp

@@ -22,26 +22,34 @@
 #include "RP2040USB.h"
 #include <pico/stdlib.h>
 #include <pico/multicore.h>
+#include "LWIPMutex.h"
+#include <reent.h>
 
 RP2040 rp2040;
+extern "C" {
+    volatile bool __otherCoreIdled = false;
+};
 
-volatile bool _MFIFO::_otherIdled = false;
 mutex_t _pioMutex;
 
+int LWIPMutex::_ref = 0;
 
 extern void setup();
 extern void loop();
 
+// FreeRTOS potential includes
+extern void initFreeRTOS() __attribute__((weak));
+extern void startFreeRTOS() __attribute__((weak));
+bool __isFreeRTOS;
 
 // Weak empty variant initialization. May be redefined by variant files.
 void initVariant() __attribute__((weak));
 void initVariant() { }
 
-
 // Optional 2nd core setup and loop
 extern void setup1() __attribute__((weak));
 extern void loop1() __attribute__((weak));
-static void main1() {
+extern "C" void main1() {
     rp2040.fifo.registerCore();
     if (setup1) {
         setup1();
@@ -53,14 +61,47 @@ static void main1() {
     }
 }
 
+extern void __loop() {
+#ifdef USE_TINYUSB
+    yield();
+#endif
+
+    if (arduino::serialEventRun) {
+        arduino::serialEventRun();
+    }
+    if (arduino::serialEvent1Run) {
+        arduino::serialEvent1Run();
+    }
+    if (arduino::serialEvent2Run) {
+        arduino::serialEvent2Run();
+    }
+}
+static struct _reent *_impure_ptr1 = nullptr;
+
 extern "C" int main() {
 #if F_CPU != 125000000
     set_sys_clock_khz(F_CPU / 1000, true);
 #endif
 
+    // Let rest of core know if we're using FreeRTOS
+    __isFreeRTOS = initFreeRTOS ? true : false;
+
+    // Allocate impure_ptr (newlib temps) if there is a 2nd core running
+    if (!__isFreeRTOS && (setup1 || loop1)) {
+        _impure_ptr1 = (struct _reent*)calloc(sizeof(struct _reent), 1);
+        _REENT_INIT_PTR(_impure_ptr1);
+    }
+
     mutex_init(&_pioMutex);
+
+    rp2040.begin();
+
     initVariant();
 
+    if (__isFreeRTOS) {
+        initFreeRTOS();
+    }
+
 #ifndef NO_USB
 #ifdef USE_TINYUSB
     TinyUSB_Device_Init(0);
@@ -69,43 +110,67 @@ extern "C" int main() {
     __USBStart();
 
 #ifndef DISABLE_USB_SERIAL
-    // Enable serial port for reset/upload always
-    Serial.begin(115200);
+
+    if (!__isFreeRTOS) {
+        // Enable serial port for reset/upload always
+        Serial.begin(115200);
+    }
 #endif
 #endif
 #endif
 
 #if defined DEBUG_RP2040_PORT
-    DEBUG_RP2040_PORT.begin(115200);
+    if (!__isFreeRTOS) {
+        DEBUG_RP2040_PORT.begin(115200);
+    }
 #endif
 
 #ifndef NO_USB
-    if (setup1 || loop1) {
-        rp2040.fifo.begin(2);
-        multicore_launch_core1(main1);
-    } else {
-        rp2040.fifo.begin(1);
+    if (!__isFreeRTOS) {
+        if (setup1 || loop1) {
+            rp2040.fifo.begin(2);
+        } else {
+            rp2040.fifo.begin(1);
+        }
+        rp2040.fifo.registerCore();
     }
-    rp2040.fifo.registerCore();
 #endif
 
-    setup();
-    while (true) {
-        loop();
-
-#ifdef USE_TINYUSB
-        yield();
-#endif
-
-        if (arduino::serialEventRun) {
-            arduino::serialEventRun();
+    if (!__isFreeRTOS) {
+        if (setup1 || loop1) {
+            delay(1); // Needed to make Picoprobe upload start 2nd core
+            multicore_launch_core1(main1);
         }
-        if (arduino::serialEvent1Run) {
-            arduino::serialEvent1Run();
-        }
-        if (arduino::serialEvent2Run) {
-            arduino::serialEvent2Run();
+        setup();
+        while (true) {
+            loop();
+            __loop();
         }
+    } else {
+        rp2040.fifo.begin(2);
+        startFreeRTOS();
     }
     return 0;
 }
+
+extern "C" unsigned long ulMainGetRunTimeCounterValue() {
+    return rp2040.getCycleCount64();
+}
+
+extern "C" void __register_impure_ptr(struct _reent *p) {
+    if (get_core_num() == 0) {
+        _impure_ptr = p;
+    } else {
+        _impure_ptr1 = p;
+    }
+}
+
+
+// TODO:  FreeRTOS should implement this based on thread ID (and each thread should have its own struct _reent
+extern "C" struct _reent *__wrap___getreent() {
+    if (get_core_num() == 0) {
+        return _impure_ptr;
+    } else {
+        return _impure_ptr1;
+    }
+}

cores/rp2040/sdkoverride/cyw43_arch_threadsafe_background.c

@@ -0,0 +1,319 @@
+/*
+    Copyright (c) 2022 Raspberry Pi (Trading) Ltd.
+
+    SPDX-License-Identifier: BSD-3-Clause
+*/
+
+// Taken from the Pico-SDK v1.4.0 and hacked by EFP3 to allow overriding the LWIP setup
+
+#include <stdio.h>
+
+#include "pico/cyw43_arch.h"
+#include "pico/mutex.h"
+#include "pico/sem.h"
+
+#include "hardware/gpio.h"
+#include "hardware/irq.h"
+
+#include "cyw43_stats.h"
+
+#include <lwip/init.h>
+#include "lwip/timeouts.h"
+
+#ifndef CYW43_PIN_WL_HOST_WAKE
+#define CYW43_PIN_WL_HOST_WAKE 24
+#endif
+
+#ifndef CYW43_PIN_WL_REG_ON
+#define CYW43_PIN_WL_REG_ON 23
+#endif
+
+#ifndef CYW43_WL_GPIO_COUNT
+#define CYW43_WL_GPIO_COUNT 3
+#endif
+
+#ifndef CYW43_WL_GPIO_LED_PIN
+#define CYW43_WL_GPIO_LED_PIN 0
+#endif
+
+
+volatile bool __inLWIP = false;
+
+// note same code
+#if PICO_CYW43_ARCH_THREADSAFE_BACKGROUND
+
+#if PICO_CYW43_ARCH_THREADSAFE_BACKGROUND && CYW43_LWIP && !NO_SYS
+#error PICO_CYW43_ARCH_THREADSAFE_BACKGROUND requires lwIP NO_SYS=1
+#endif
+#if PICO_CYW43_ARCH_THREADSAFE_BACKGROUND && CYW43_LWIP && MEM_LIBC_MALLOC
+#error MEM_LIBC_MALLOC is incompatible with PICO_CYW43_ARCH_THREADSAFE_BACKGROUND
+#endif
+// todo right now we are now always doing a cyw43_dispatch along with a lwip one when hopping cores in low_prio_irq_schedule_dispatch
+
+#ifndef CYW43_SLEEP_CHECK_MS
+#define CYW43_SLEEP_CHECK_MS 50 // How often to run lwip callback
+#endif
+static alarm_id_t periodic_alarm = -1;
+
+static inline uint recursive_mutex_enter_count(recursive_mutex_t *mutex) {
+    return mutex->enter_count;
+}
+
+static inline lock_owner_id_t recursive_mutex_owner(recursive_mutex_t *mutex) {
+    return mutex->owner;
+}
+
+#define CYW43_GPIO_IRQ_HANDLER_PRIORITY 0x40
+
+enum {
+    CYW43_DISPATCH_SLOT_CYW43 = 0,
+    CYW43_DISPATCH_SLOT_ADAPTER,
+    CYW43_DISPATCH_SLOT_ENUM_COUNT
+};
+#ifndef CYW43_DISPATCH_SLOT_COUNT
+#define CYW43_DISPATCH_SLOT_COUNT CYW43_DISPATCH_SLOT_ENUM_COUNT
+#endif
+
+typedef void (*low_prio_irq_dispatch_t)(void);
+static void low_prio_irq_schedule_dispatch(size_t slot, low_prio_irq_dispatch_t f);
+
+static uint8_t cyw43_core_num;
+#ifndef NDEBUG
+static bool in_low_priority_irq;
+#endif
+static uint8_t low_priority_irq_num;
+static bool low_priority_irq_missed;
+static low_prio_irq_dispatch_t low_priority_irq_dispatch_slots[CYW43_DISPATCH_SLOT_COUNT];
+static recursive_mutex_t cyw43_mutex;
+semaphore_t cyw43_irq_sem;
+
+// Called in low priority pendsv interrupt only to do lwip processing and check cyw43 sleep
+static void periodic_worker(void) {
+#if CYW43_USE_STATS
+    static uint32_t counter;
+    if (counter++ % (30000 / LWIP_SYS_CHECK_MS) == 0) {
+        cyw43_dump_stats();
+    }
+#endif
+
+    CYW43_STAT_INC(LWIP_RUN_COUNT);
+    //#if CYW43_LWIP
+    if (!__inLWIP) {
+        sys_check_timeouts();
+    }
+    //#endif
+    if (cyw43_poll) {
+        if (cyw43_sleep > 0) {
+            if (--cyw43_sleep == 0) {
+                low_prio_irq_schedule_dispatch(CYW43_DISPATCH_SLOT_CYW43, cyw43_poll);
+            }
+        }
+    }
+}
+
+// Regular callback to get lwip to check for timeouts
+static int64_t periodic_alarm_handler(__unused alarm_id_t id, __unused void *user_data) {
+    // Do lwip processing in low priority pendsv interrupt
+    low_prio_irq_schedule_dispatch(CYW43_DISPATCH_SLOT_ADAPTER, periodic_worker);
+    return CYW43_SLEEP_CHECK_MS * 1000;
+}
+
+void cyw43_await_background_or_timeout_us(uint32_t timeout_us) {
+    // if we are called from within an IRQ, then don't wait (we are only ever called in a polling loop)
+    if (!__get_current_exception()) {
+        sem_acquire_timeout_us(&cyw43_irq_sem, timeout_us);
+    }
+}
+
+// GPIO interrupt handler to tell us there's cyw43 has work to do
+static void gpio_irq_handler(void) {
+    uint32_t events = gpio_get_irq_event_mask(CYW43_PIN_WL_HOST_WAKE);
+    if (events & GPIO_IRQ_LEVEL_HIGH) {
+        // As we use a high level interrupt, it will go off forever until it's serviced
+        // So disable the interrupt until this is done. It's re-enabled again by CYW43_POST_POLL_HOOK
+        // which is called at the end of cyw43_poll_func
+        gpio_set_irq_enabled(CYW43_PIN_WL_HOST_WAKE, GPIO_IRQ_LEVEL_HIGH, false);
+        // also clear the force bit which we use to progratically cause this handler to fire (on the right core)
+        io_irq_ctrl_hw_t *irq_ctrl_base = get_core_num() ?
+                                          &iobank0_hw->proc1_irq_ctrl : &iobank0_hw->proc0_irq_ctrl;
+        hw_clear_bits(&irq_ctrl_base->intf[CYW43_PIN_WL_HOST_WAKE / 8], GPIO_IRQ_LEVEL_HIGH << (4 * (CYW43_PIN_WL_HOST_WAKE & 7)));
+        low_prio_irq_schedule_dispatch(CYW43_DISPATCH_SLOT_CYW43, cyw43_poll);
+        CYW43_STAT_INC(IRQ_COUNT);
+    }
+}
+
+// Low priority interrupt handler to perform background processing
+static void low_priority_irq_handler(void) {
+    assert(cyw43_core_num == get_core_num());
+    if (recursive_mutex_try_enter(&cyw43_mutex, NULL)) {
+        if (recursive_mutex_enter_count(&cyw43_mutex) != 1) {
+            low_priority_irq_missed = true;
+            CYW43_STAT_INC(PENDSV_DISABLED_COUNT);
+        } else {
+            CYW43_STAT_INC(PENDSV_RUN_COUNT);
+#ifndef NDEBUG
+            in_low_priority_irq = true;
+#endif
+            for (size_t i = 0; i < count_of(low_priority_irq_dispatch_slots); i++) {
+                if (low_priority_irq_dispatch_slots[i] != NULL) {
+                    low_prio_irq_dispatch_t f = low_priority_irq_dispatch_slots[i];
+                    low_priority_irq_dispatch_slots[i] = NULL;
+                    f();
+                }
+            }
+#ifndef NDEBUG
+            in_low_priority_irq = false;
+#endif
+        }
+        recursive_mutex_exit(&cyw43_mutex);
+    } else {
+        CYW43_STAT_INC(PENDSV_DISABLED_COUNT);
+        low_priority_irq_missed = true;
+    }
+    sem_release(&cyw43_irq_sem);
+}
+
+static bool low_prio_irq_init(uint8_t priority) {
+    assert(get_core_num() == cyw43_core_num);
+    int irq = user_irq_claim_unused(false);
+    if (irq < 0) {
+        return false;
+    }
+    low_priority_irq_num = (uint8_t) irq;
+    irq_set_exclusive_handler(low_priority_irq_num, low_priority_irq_handler);
+    irq_set_enabled(low_priority_irq_num, true);
+    irq_set_priority(low_priority_irq_num, priority);
+    return true;
+}
+
+static void low_prio_irq_deinit(void) {
+    if (low_priority_irq_num > 0) {
+        irq_set_enabled(low_priority_irq_num, false);
+        irq_remove_handler(low_priority_irq_num, low_priority_irq_handler);
+        user_irq_unclaim(low_priority_irq_num);
+        low_priority_irq_num = 0;
+    }
+}
+
+int cyw43_arch_init(void) {
+    cyw43_core_num = get_core_num();
+    recursive_mutex_init(&cyw43_mutex);
+    cyw43_init(&cyw43_state);
+    sem_init(&cyw43_irq_sem, 0, 1);
+
+    // Start regular lwip callback to handle timeouts
+    periodic_alarm = add_alarm_in_us(CYW43_SLEEP_CHECK_MS * 1000, periodic_alarm_handler, NULL, true);
+    if (periodic_alarm < 0) {
+        return PICO_ERROR_GENERIC;
+    }
+
+    gpio_add_raw_irq_handler_with_order_priority(IO_IRQ_BANK0, gpio_irq_handler, CYW43_GPIO_IRQ_HANDLER_PRIORITY);
+    gpio_set_irq_enabled(CYW43_PIN_WL_HOST_WAKE, GPIO_IRQ_LEVEL_HIGH, true);
+    irq_set_enabled(IO_IRQ_BANK0, true);
+
+    lwip_init();
+
+    // start low priority handler (no background work is done before this)
+    bool ok = low_prio_irq_init(PICO_LOWEST_IRQ_PRIORITY);
+    if (!ok) {
+        cyw43_arch_deinit();
+        return PICO_ERROR_GENERIC;
+    }
+    return PICO_OK;
+}
+
+void cyw43_arch_deinit(void) {
+    if (periodic_alarm >= 0) {
+        cancel_alarm(periodic_alarm);
+        periodic_alarm = -1;
+    }
+    gpio_set_irq_enabled(CYW43_PIN_WL_HOST_WAKE, GPIO_IRQ_LEVEL_HIGH, false);
+    gpio_remove_raw_irq_handler(IO_IRQ_BANK0, gpio_irq_handler);
+    low_prio_irq_deinit();
+}
+
+void cyw43_post_poll_hook(void) {
+    gpio_set_irq_enabled(CYW43_PIN_WL_HOST_WAKE, GPIO_IRQ_LEVEL_HIGH, true);
+}
+
+// This is called in the gpio and low_prio_irq interrupts and on either core
+static void low_prio_irq_schedule_dispatch(size_t slot, low_prio_irq_dispatch_t f) {
+    assert(slot < count_of(low_priority_irq_dispatch_slots));
+    low_priority_irq_dispatch_slots[slot] = f;
+    if (cyw43_core_num == get_core_num()) {
+        //on same core, can dispatch directly
+        irq_set_pending(low_priority_irq_num);
+    } else {
+        // on wrong core, so force via GPIO IRQ which itself calls this method for the CYW43 slot.
+        // since the CYW43 slot always uses the same function, this is fine with the addition of an
+        // extra (but harmless) CYW43 slot call when another SLOT is invoked.
+        // We could do better, but would have to track why the IRQ was called.
+        io_irq_ctrl_hw_t *irq_ctrl_base = cyw43_core_num ?
+                                          &iobank0_hw->proc1_irq_ctrl : &iobank0_hw->proc0_irq_ctrl;
+        hw_set_bits(&irq_ctrl_base->intf[CYW43_PIN_WL_HOST_WAKE / 8], GPIO_IRQ_LEVEL_HIGH << (4 * (CYW43_PIN_WL_HOST_WAKE & 7)));
+    }
+}
+
+void cyw43_schedule_internal_poll_dispatch(void (*func)(void)) {
+    low_prio_irq_schedule_dispatch(CYW43_DISPATCH_SLOT_CYW43, func);
+}
+
+// Prevent background processing in pensv and access by the other core
+// These methods are called in pensv context and on either core
+// They can be called recursively
+void cyw43_thread_enter(void) {
+    // Lock the other core and stop low_prio_irq running
+    recursive_mutex_enter_blocking(&cyw43_mutex);
+}
+
+#ifndef NDEBUG
+void cyw43_thread_lock_check(void) {
+    // Lock the other core and stop low_prio_irq running
+    if (recursive_mutex_enter_count(&cyw43_mutex) < 1 || recursive_mutex_owner(&cyw43_mutex) != lock_get_caller_owner_id()) {
+        panic("cyw43_thread_lock_check failed");
+    }
+}
+#endif
+
+// Re-enable background processing
+void cyw43_thread_exit(void) {
+    // Run low_prio_irq if needed
+    if (1 == recursive_mutex_enter_count(&cyw43_mutex)) {
+        // note the outer release of the mutex is not via cyw43_exit in the low_priority_irq case (it is a direct mutex exit)
+        assert(!in_low_priority_irq);
+        //        if (low_priority_irq_missed) {
+        //            low_priority_irq_missed = false;
+        if (low_priority_irq_dispatch_slots[CYW43_DISPATCH_SLOT_CYW43]) {
+            low_prio_irq_schedule_dispatch(CYW43_DISPATCH_SLOT_CYW43, cyw43_poll);
+        }
+        //        }
+    }
+    recursive_mutex_exit(&cyw43_mutex);
+}
+
+
+static void cyw43_delay_until(absolute_time_t until) {
+    // sleep can be called in IRQs, so there's not much we can do there
+    if (__get_current_exception()) {
+        busy_wait_until(until);
+    } else {
+        sleep_until(until);
+    }
+}
+
+void cyw43_delay_ms(uint32_t ms) {
+    cyw43_delay_until(make_timeout_time_ms(ms));
+}
+
+void cyw43_delay_us(uint32_t us) {
+    cyw43_delay_until(make_timeout_time_us(us));
+}
+
+void cyw43_arch_poll() {
+    // should not be necessary
+    //    if (cyw43_poll) {
+    //        low_prio_irq_schedule_dispatch(CYW43_DISPATCH_SLOT_CYW43, cyw43_poll);
+    //    }
+}
+
+#endif

cores/rp2040/stdlib_noniso.h

@@ -19,8 +19,7 @@
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef STDLIB_NONISO_H
-#define STDLIB_NONISO_H
+#pragma once
 
 #ifdef __cplusplus
 extern "C" {
@@ -54,6 +53,3 @@ const char* strrstr(const char*__restrict p_pcString,
 #ifdef __cplusplus
 } // extern "C"
 #endif
-
-
-#endif

cores/rp2040/wiring_analog.cpp

@@ -27,7 +27,7 @@
 #include <hardware/adc.h>
 
 static uint32_t analogScale = 255;
-static uint16_t analogFreq = 1000;
+static uint32_t analogFreq = 1000;
 static bool pwmInitted = false;
 static bool adcInitted = false;
 static uint16_t analogWritePseudoScale = 1;
@@ -42,9 +42,9 @@ extern "C" void analogWriteFreq(uint32_t freq) {
     if (freq < 100) {
         DEBUGCORE("ERROR: analogWriteFreq too low (%d)\n", freq);
         analogFreq = 100;
-    } else if (freq > 60000) {
+    } else if (freq > 1000000) {
         DEBUGCORE("ERROR: analogWriteFreq too high (%d)\n", freq);
-        analogFreq = 60000;
+        analogFreq = 1000000;
     } else {
         analogFreq = freq;
     }

cores/rp2040/wiring_digital.cpp

@@ -23,7 +23,8 @@
 
 static PinMode _pm[30];
 
-extern "C" void pinMode(pin_size_t ulPin, PinMode ulMode) {
+extern "C" void pinMode(pin_size_t ulPin, PinMode ulMode) __attribute__((weak, alias("__pinMode")));
+extern "C" void __pinMode(pin_size_t ulPin, PinMode ulMode) {
     switch (ulMode) {
     case INPUT:
         gpio_init(ulPin);
@@ -43,7 +44,24 @@ extern "C" void pinMode(pin_size_t ulPin, PinMode ulMode) {
         gpio_put(ulPin, 1);
         break;
     case OUTPUT:
+    case OUTPUT_4MA:
         gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_4MA);
+        gpio_set_dir(ulPin, true);
+        break;
+    case OUTPUT_2MA:
+        gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_2MA);
+        gpio_set_dir(ulPin, true);
+        break;
+    case OUTPUT_8MA:
+        gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_8MA);
+        gpio_set_dir(ulPin, true);
+        break;
+    case OUTPUT_12MA:
+        gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_12MA);
         gpio_set_dir(ulPin, true);
         break;
     default:
@@ -59,7 +77,8 @@ extern "C" void pinMode(pin_size_t ulPin, PinMode ulMode) {
     _pm[ulPin] = ulMode;
 }
 
-extern "C" void digitalWrite(pin_size_t ulPin, PinStatus ulVal) {
+extern "C" void digitalWrite(pin_size_t ulPin, PinStatus ulVal) __attribute__((weak, alias("__digitalWrite")));
+extern "C" void __digitalWrite(pin_size_t ulPin, PinStatus ulVal) {
     if (ulPin > 29) {
         DEBUGCORE("ERROR: Illegal pin in pinMode (%d)\n", ulPin);
         return;
@@ -82,7 +101,8 @@ extern "C" void digitalWrite(pin_size_t ulPin, PinStatus ulVal) {
     }
 }
 
-extern "C" PinStatus digitalRead(pin_size_t ulPin) {
+extern "C" PinStatus digitalRead(pin_size_t ulPin) __attribute__((weak, alias("__digitalRead")));
+extern "C" PinStatus __digitalRead(pin_size_t ulPin) {
     if (ulPin > 29) {
         DEBUGCORE("ERROR: Illegal pin in digitalRead (%d)\n", ulPin);
         return LOW;

cores/rp2040/wiring_private.cpp

@@ -45,26 +45,40 @@ extern "C" void noInterrupts() {
 // Only 1 GPIO IRQ callback for all pins, so we need to look at the pin it's for and
 // dispatch to the real callback manually
 auto_init_mutex(_irqMutex);
-static std::map<pin_size_t, voidFuncPtr> _map;
+class CBInfo {
+public:
+    CBInfo(voidFuncPtr cb) : _cb(cb), _useParam(false), _param(nullptr) { };
+    CBInfo(voidFuncPtrParam cbParam, void *param) : _cbParam(cbParam), _useParam(true), _param(param) { };
+    void callback() {
+        if (_useParam && _cbParam) {
+            _cbParam(_param);
+        } else if (_cb) {
+            _cb();
+        }
+    }
+private:
+    union {
+        voidFuncPtr _cb;
+        voidFuncPtrParam _cbParam;
+    };
+    bool _useParam;
+    void *_param;
+};
+
+
+static std::map<pin_size_t, CBInfo> _map;
 
 void _gpioInterruptDispatcher(uint gpio, uint32_t events) {
     (void) events;
     // Only need to lock around the std::map check, not the whole IRQ callback
-    voidFuncPtr cb = nullptr;
-    {
-        CoreMutex m(&_irqMutex);
-        if (m) {
-            auto irq = _map.find(gpio);
-            if (irq != _map.end()) {
-                cb = irq->second;
-            }
+    CoreMutex m(&_irqMutex);
+    if (m) {
+        auto irq = _map.find(gpio);
+        if (irq != _map.end()) {
+            auto cb = irq->second;
+            cb.callback();
         }
     }
-    if (cb) {
-        cb(); // Do the callback
-    } else {
-        // ERROR, but we're in an IRQ so do nothing
-    }
 }
 
 extern "C" void attachInterrupt(pin_size_t pin, voidFuncPtr callback, PinStatus mode) {
@@ -84,7 +98,31 @@ extern "C" void attachInterrupt(pin_size_t pin, voidFuncPtr callback, PinStatus
     }
     noInterrupts();
     detachInterrupt(pin);
-    _map.insert({pin, callback});
+    CBInfo cb(callback);
+    _map.insert({pin, cb});
+    gpio_set_irq_enabled_with_callback(pin, events, true, _gpioInterruptDispatcher);
+    interrupts();
+}
+
+void attachInterruptParam(pin_size_t pin, voidFuncPtrParam callback, PinStatus mode, void *param) {
+    CoreMutex m(&_irqMutex);
+    if (!m) {
+        return;
+    }
+
+    uint32_t events;
+    switch (mode) {
+    case LOW:     events = 1; break;
+    case HIGH:    events = 2; break;
+    case FALLING: events = 4; break;
+    case RISING:  events = 8; break;
+    case CHANGE:  events = 4 | 8; break;
+    default:      return;  // ERROR
+    }
+    noInterrupts();
+    detachInterrupt(pin);
+    CBInfo cb(callback, param);
+    _map.insert({pin, cb});
     gpio_set_irq_enabled_with_callback(pin, events, true, _gpioInterruptDispatcher);
     interrupts();
 }

docs/analog.rst

@@ -13,6 +13,11 @@ int analogRead(pin_size_t pin = A0..A3)
 Returns a value from 0...4095 correspionding to the ADC reading
 of the specific pin.
 
+void analogReadResolution(int bits)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Determines the resolution (in bits) of the value returned by the analogRead() function.
+Default resolution is 10bit.
+
 float analogReadTemp()
 ~~~~~~~~~~~~~~~~~~~~~~
 Returns the temperature, in Celsius, of the onboard thermal sensor.
@@ -30,10 +35,21 @@ While up to 16 PWM channels can be generated, they are not independent
 and there are significant restrictions as to allowed pins in parallel.
 See the `RP2040 datasheet <https://datasheets.raspberrypi.org/rp2040/rp2040-datasheet.pdf>`_ for full details.
 
+Analog Output Restrictions
+--------------------------
+
+The PWM generator source clock restricts the legal combinations of
+frequency and ranges.  For example, at 1MHz only about 6 bits of range
+are possible.  When you define an ``analogWriteFreq`` and ``analogWriteRange``
+that can't be fulfilled by the hardware, the frequency will be preserved
+but the accuracy (range) will be reduced automatically.  Your code will
+still send in the range you specify, but the core itself will transparently
+map it into the allowable PWN range.
+
 void analogWriteFreq(uint32_t freq)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Sets the master PWM frequency used (i.e. how often the PWM output cycles).
-From 100Hz to 60KHz are supported.
+From 100Hz to 1MHz are supported.
 
 void analogWriteRange(uint32_t range) and analogWriteResolution(int res)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/conf.py

@@ -19,7 +19,7 @@
 # import os
 # import sys
 # sys.path.insert(0, os.path.abspath('.'))
-
+import sphinx_rtd_theme
 
 # -- General configuration ------------------------------------------------
 
@@ -30,7 +30,7 @@
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = []
+extensions = ['sphinx_rtd_theme']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -46,7 +46,7 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Arduino-Pico'
-copyright = u'2021, Earle F. Philhower, III'
+copyright = u'2022, Earle F. Philhower, III'
 author = u'Earle F. Philhower, III'
 
 # The version info for the project you're documenting, acts as replacement for
@@ -82,7 +82,7 @@ todo_include_todos = False
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+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/digital.rst

@@ -6,6 +6,14 @@ Board-Specific Pins
 The Raspberry Pi Pico RP2040 chip supports up to 30 digital I/O pins,
 however not all boards provide access to all pins.
 
+Input Modes
+-----------
+The Raspberry Pi Pico has 3 Input modes settings for use with `pinMode`: `INPUT`, `INPUT_PULLUP` and `INPUT_PULLDOWN`
+
+Output Modes (Pad Strength)
+---------------------------
+The Raspberry Pi Pico has the ability to set the current that a pin (actually the pad associated with it) is capable of supplying. The current can be set to values of 2mA, 4mA, 8mA and 12mA. By default, on a reset, the setting is 4mA. A `pinMode(x, OUTPUT)`, where `x` is the pin number, is also the default setting. 4 settings have been added for use with `pinMode`: `OUTPUT_2MA`, `OUTPUT_4MA`, which has the same behavior as `OUTPUT`, `OUTPUT_8MA` and `OUTPUT_12MA`.
+
 Tone/noTone
 -----------
 Simple square wave tone generation is possible for up to 8 channels using

docs/freertos.rst

@@ -0,0 +1,49 @@
+FreeRTOS SMP
+============
+
+The SMP (multicore) port of FreeRTOS is included with the core.  This allows complex
+task operations and real preemptive multithreading in your sketches.  While the
+``setup1`` and ``loop1`` way of multitasking is simplest for most folks, FreeRTOS
+is much more powerful.
+
+Enabling FreeRTOS
+-----------------
+
+To enable FreeRTOS, simply add
+
+.. code:: c++
+
+    #include <FreeRTOS.h>
+
+to your sketch and it will be included and enabled automatically.
+
+Configuration and Predefined Tasks
+----------------------------------
+
+FreeRTOS is configured with 8 priority levels (0 through 7) and a process for
+``setup()/loop()``, ``setup1()/loop1()``, and the USB port will be created.  The task
+quantum is 1 millisecond (i.e. 1,000 switches per second).
+
+``setup()`` and ``loop()`` are assigned to only run on core 0, while ``setup1()`` and ``loop1()``
+only run in core 1 in this mode, the same as the default multithreading mode.
+
+You can launch and manage additional processes using the standard FreeRTOS routines.
+
+``delay()`` and ``yield()`` free the CPU for other tasks, while ``delayMicroseconds()`` does not.
+
+Caveats
+-------
+
+While the core now supports FreeRTOS, most (probably all) Arduino libraries were not written
+to support preemptive multithreading.  This means that all calls to a particular library should
+be made from a single task.
+
+In particular, the ``LittleFS`` and ``SDFS`` libraries can not be called from different
+threads.  Do all ``File`` operations from a single thread or else undefined behavior
+(aka strange crashes or data corruption) can occur.
+
+More Information
+----------------
+
+For full FreeRTOS documentation look at `FreeRTOS.org <https://freertos.org/index.html>`__
+and `FreeRTOS SMP support <https://freertos.org/symmetric-multiprocessing-introduction.html>`__.

docs/i2s.rst

@@ -1,89 +1,181 @@
-I2S (Digital Audio) Output Library
-==================================
+I2S (Digital Audio) Audio Library
+=================================
 
 While the RP2040 chip on the Raspberry Pi Pico does not include a hardware
 I2S device, it is possible to use the PIO (Programmable I/O) state machines
 to implement one dynamically.
 
-This I2S library uses the ``pico-extras`` I2S audio library and wraps it in
-an Arduino I2S library.  It supports 16 bits/sample and frequencies of up
-to 48kHZ, with configurable BCLK, LRCLK(always pin "BCLK + 1"), and DOUT pins.
+Digital audio input and output are supported at 8, 16, 24, and 32 bits per
+sample.
+
+Theoretically up to 6 I2S ports may be created, but in practice there
+may not be enough resources (DMA, PIO SM) to actually create and use so
+many.
+
+Create an I2S port by instantiating a variable of the I2S class
+specifying the direction.  Configure it using API calls below before
+using it.
 
-**Note:** This I2S device takes over the entire PIO1 (second) unit and adjusts
-its clock frequency to meet the I2S needs.  That means when only 4 Tones
-or only 4 Servos may be used when the I2S device is used.
 
 I2S Class API
 -------------
 
+I2S(OUTPUT)
+~~~~~~~~~~~
+Creates an I2S output port.  Needs to be connected up to the
+desired pins (see below) and started before any output can happen.
+
+I2S(INPUT)
+~~~~~~~~~~
+Creates an I2S input port.  Needs to be connected up to the
+desired pins (see below) and started before any input can happen.
+
 bool setBCLK(pin_size_t pin)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Sets the BCLK pin of the I2S device.  The LRCLK/word clock will be ``pin + 1``
-due to limitations of the PIO state machines.  Call this before ``I2S.begin()``
-Default BCLK = 26, LRCLK = 27
+due to limitations of the PIO state machines.  Call this before ``I2S::begin()``
 
-bool setDOUT(pin_size_t pin)
+bool setDATA(pin_size_t pin)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Sets the DOUT pin of the I2S device.  Any pin may be used.  Default DOUT = 28
-Call before ``I2S.begin()``
+Sets the DOUT or DIN pin of the I2S device.  Any pin may be used.
+Call before ``I2S::begin()``
 
-bool begin(long sampleRate)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Start the I2S device up with the given sample rate.  The pins selected above
-will be turned to output and the I2S will begin to drive silence frames (all
-zero) out.
+bool setBitsPerSample(int bits)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Specify how many bits per audio sample to read or write.  Note that
+for 24-bit samples, audio samples must be left-aligned (i.e. bits 31...8).
+Call before ``I2S::begin()``
+
+bool setBuffers(size_t buffers, size_t bufferWords, int32_t silenceSample = 0)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Set the number of DMA buffers and their size in 32-bit words as well as
+the word to fill when no data is available to send to the I2S hardware.
+Call before ``I2S::begin()``.
+
+bool setFrequency(long sampleRate)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets the word clock frequency, but does not start the I2S device if not
+already running.  May be called after ``I2S::begin()`` to change the
+sample rate on-the-fly.
+
+bool begin()/begin(long sampleRate)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Start the I2S device up with the given sample rate, or with the value set
+using the prior ``setFrequency`` call.
 
 void end()
 ~~~~~~~~~~
-Stops the I2S device.  **Note, at present the memory allocated for I2S buffers
-is not freed leading to a memory leak when ``end()`` is called.  This is due
-to the state of the ``pico-extras`` release which this code uses.**
+Stops the I2S device.
 
 void flush()
 ~~~~~~~~~~~~
-Sends any partial frames in memory to the I2S output device.  They may NOT play
-immediately.  Potential use case for this call would be when the frequency of
-the output will be changing.
+Waits until all the I2S buffers have been output.
 
-size_t write(uint8_t)
-~~~~~~~~~~~~~~~~~~~~~
-Provided for compatibility, but not very useful.  Writes a sample from 0...255
-to the I2S buffer.  See ``write(int16_t)`` for a better one
+size_t write(uint8_t/int8_t/int16_t/int32_t)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes a single sample of ``bitsPerSample`` to the buffer.  It is up to the
+user to keep track of left/right channels.   Note this writes data equivalent
+to one channel's data, not the size of the passed in variable (i.e. if you have
+a 16-bit sample size and ``write((int8_t)-5); write((int8_t)5);`` you will have
+written **2 samples** to the I2S buffer of whatever the I2S size, not a single
+16-bit sample.
+
+This call will block (wait) until space is available to actually write
+the data.
+
+size_t write(int32_t val, bool sync)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes 32 bits of data to the I2S buffer (regardless of the configured I2S
+bit size).  When ``sync`` is true, it will not return until the data has
+been writte.  When ``sync`` is false, it will return ``0`` immediately if
+there is no space present in the I2S buffer.
 
 size_t write(const uint8_t \*buffer, size_t size)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Transfers number of bytes from an application buffer to the I2S output buffer.
 Be aware that ``size`` is in *bytes** and not samples.  Size must be a multiple
-of **4 bytes** (i.e. one left/right sample).  Will not block, so check
-the return value to find out how many bytes were actually written.
+of **4 bytes**.  Will not block, so check the return value to find out how
+many bytes were actually written.
 
 int availableForWrite()
 ~~~~~~~~~~~~~~~~~~~~~~~
-Returns the number of **32-bit L/R samples** that can be written without
+Returns the number of L/R samples that can be written without
 potentially blocking.
 
-bool setFrequency(int newFreq)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Adjusts the I2S output frequency.  When changing frequency while I2S output
-is underway, be sure to use ``I2S.flush()`` before changing the frequency to
-ensure the older data is played at the right frequency.
+int read()
+~~~~~~~~~~
+Reads a single sample of I2S data, whatever the I2S sample size is configured.
+Will not return until data is available.
 
-size_t write(int16_t)
-~~~~~~~~~~~~~~~~~~~~~
-Writes a single 16-bit left or right sample to the I2S output buffer.  The
-user is required to ensure that an even number of samples is written (i.e.
-left and right) over the application lifetime.  The application also needs
-to track which sample is next to be written (right/left).  For this reason,
-the ``write(void *b, size_t lrsamples)`` call may be easier and faster to use.
+int peek()
+~~~~~~~~~~
+Returns the next sample to be read from the I2S buffer (without actually
+removing it).
 
-size_t write(const void \*buffer, size_t lrsamples)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Writes up to size left+right packed samples to the I2S device.  Non-blocking,
-will writefrom 0...size samples and return that count.  Be sure your app
-handles partial writes (i.e. by ``yield()`` ing and then retrying to write the
-remaining data.)
+void onTransmit(void (\*fn)(void))
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets a callback to be called when an I2S DMA buffer is fully transmitted.
+Will be in an interrupt context so the specified function must operate
+quickly and not use blocking calls like delay() or write to the I2S.
 
-The ``onTransmit`` callback is not supported.
+void onReceive(void (\*fn)(void))
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets a callback to be called when an I2S DMA buffer is fully read in.
+Will be in an interrupt context so the specified function must operate
+quickly and not use blocking calls like delay() or read from the I2S.
 
-See the `ESP8266Audio <https://github.com/earlephilhower/ESP8266Audio>`_ library
-for a working example, or look at the included sample tone generator.
+Sample Writing/Reading API
+--------------------------
+Because I2S streams consist of a natural left and right sample, it is often
+convenient to write or read both with a single call.  The following calls
+allow applications to read or write both samples at the same time, and
+explicitly indicate the bit widths required (to avoid potential issues with
+type conversion on calls).
+
+size_t write8(int8_t l, int8_t r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes a left and right 8-bit sample to the I2S buffers.  Blocks until space
+is available.
+
+size_t write16(int16_t l, int16_t r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes a left and right 16-bit sample to the I2S buffers.  Blocks until space
+is available.
+
+size_t write24(int32_t l, int32_t r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes a left and right 24-bit sample to the I2S buffers.  See note below
+about 24-bit mode.  Blocks until space is available.
+
+size_t write32(int32_t l, int32_t r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes a left and right 32-bit sample to the I2S buffers.  Blocks until space
+is available.
+
+bool read8(int8_t \*l, int8_t \*r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Reads a left and right 8-bit sample and returns ``true`` on success.  Will block
+until data is available.
+
+bool read16(int16_t \*l, int16_t \*r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Reads a left and right 16-bit sample and returns ``true`` on success.  Will block
+until data is available.
+
+bool read24(int32_t \*l, int32_t \*r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Reads a left and right 24-bit sample and returns ``true`` on success.  See note below
+about 24-bit mode.  Will block until data is available.
+
+bool read32(int32_t \*l, int32_t \*r)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Reads a left and right 32-bit sample and returns ``true`` on success.  Will block
+until data is available.
+
+
+Note About 24-bit Samples
+-------------------------
+24-bit samples are stored as left-aligned 32-bit values with bits 7..0
+ignored.  Only the upper 24 bits 31...8 will be transmitted or
+received.  The actual I2S protocol will only transmit or receive 24 bits
+in this mode, even though the data is 32-bit packed.

docs/ide.rst

@@ -34,3 +34,40 @@ Debug messages from `printf` and the Core can be printed to a Serial port
 to allow for easier debugging.  Select the desired port and verbosity.
 Selecting a port for debug output does not stop a sketch from using it
 for normal operations.
+
+Generic RP2040 Support
+----------------------
+If your RP2040 board isn't in the menus you can still use it with the
+IDE bu using the `Board->Generic RP2040` menu option.  You will need to
+then set the flash size (see above) and tell the IDE how to communicate
+with the flash chip using the `Tools->Boot Stage 2` menu.
+
+Boot Stage 2 Options for Generic RP2040
+---------------------------------------
+The Arduino Pico needs to set up its internal flash interface to talk to
+whatever flash chip is in the system.  While all flash chips support a
+basic (and slow) 1-bit operation using common timings, each different
+brand (and sometimes model) of flash chip require custom timings to work
+in QSPI (4-bit) mode.  The `Boot Stage 2` menu lets you select from
+the supported timings.
+
+The options with `/2` in them divide the system clock by 2 to drive the
+bus.  Options with `/4` divide the clock by 4 and so are slower but more
+compatible.
+
+If you can't match a chip name in the menu to your flash chip, a simple
+test can be run to determine which is correct.  Simpily load the `Blink`
+example, select the first option in the `Boot Stage 2` menu, and upload.
+If that works, note it and continue.  Iterate through the options and
+note which ones work.  If an option doesn't work, unplug the chip and
+hold the BOOTSEL button down while re-inserting it to enter the ROM
+uploader mode.  (The CPU and flash will not be harmed if the test fails.)
+
+If one of the custom bootloaders (not `Generic SPI /2 or /4`) worked, use
+that option to get best performance.  If none worked other than the
+`Generic SPI /2 or /4` then use that.  The `/2` options of all models
+is preferred as it is faster, but some boards do require `/4` on the
+custom chip interfaces.
+
+When in doubt, `Generic SPI /4` should work with any flash chip but is
+slow.  

docs/index.rst

@@ -7,7 +7,7 @@ Arduino-Pico.  Arduino-Pico is a community port of the RP2040
 to make it easier and more fun to use and program the Raspberry Pi
 Pico / RP2040 based boards.
 
-This Arduino core uses a custom toolset with GCC 10.2 and Newlib 4.0.0
+This Arduino core uses a custom toolset with GCC 10.3 and Newlib 4.0.0
 and doesn't require any system-installed prerequisites.
 
 For the latest version, always check https://github.com/earlephilhower/arduino-pico
@@ -37,6 +37,10 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
    USB (Arduino and Adafruit_TinyUSB) <usb>
    Multicore Processing <multicore>
 
+   FreeRTOS SMP (multicore) <freertos>
+
+   WiFi (Raspberry Pi Pico-W Support) <wifi>
+
    Ported/Optimized Libraries <libraries>
    Using Pico-SDK <sdk>
 

docs/install.rst

@@ -40,8 +40,6 @@ To install via GIT (for latest and greatest versions):
         git submodule update --init
         cd pico-sdk
         git submodule update --init
-        cd pico-extras
-        git submodule update --init
         cd ../tools
         python3 ./get.py
 

docs/multicore.rst

@@ -41,6 +41,12 @@ void rp2040.resumeOtherCore()
 
 Resumes processing in the other core, where it left off.
 
+
+void rp2040.restartCore1()
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Hard resets Core1 from Core 0 and restarts its operation from ``setup1()``.
+
 Communicating Between Cores
 ---------------------------
 
@@ -50,23 +56,23 @@ use the following functions to access a software-managed, multicore safe
 FIFO.
 
 void rp2040.fifo.push(uint32_t)
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Pushes a value to the other core.  Will block if the FIFO is full.
 
 bool rp2040.fifo.push_nb(uint32_t)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Pushes a value to the other core.  If the FIFO is full, returns ``false``
 immediately and doesn't block.  If the push is successful, returns ``true``.
 
 uint32_t rp2040.fifo.pop()
-~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Reads a value from this core's FIFO.  Blocks until one is available.
 
 bool rp2040.fifo.pop_nb(uint32_t *dest)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Reads a value from this core's FIFO and places it in dest.  Will return
 ``true`` if successful, or ``false`` if the pop would block.

docs/pins.rst

@@ -26,6 +26,8 @@ Serial1 (UART0), Serial2 (UART1)
 
         ::setRX(pin)
         ::setTX(pin)
+        ::setRTS(pin)
+        ::setCTS(pin)
 
 SPI (SPI0), SPI1 (SPI1)
 -----------------------
@@ -58,4 +60,3 @@ it use a non-default pinout with a simple call
         SPI.setCS(5);
         SD.begin(5);
     }
-

docs/piouart.rst

@@ -3,8 +3,8 @@
 
 Equivalent to the Arduino SoftwareSerial library, an emulated UART using
 one or two PIO state machines is included in the Arduino-Pico core.  This
-allows for up to 8 additional serial ports to be run from the RP2040 without
-requiring additional CPU resources.
+allows for up to 4 bidirectional or up to 8 unidirectional serial ports to
+be run from the RP2040 without requiring additional CPU resources.
 
 Instantiate a ``SerialPIO(txpin, rxpin, fifosize)`` object in your sketch and then
 use it the same as any other serial port.  Even, odd, and no parity modes
@@ -21,3 +21,16 @@ For example, to make a transmit-only port on GP16
 
 For detailed information about the Serial ports, see the
 Arduino `Serial Reference <https://www.arduino.cc/reference/en/language/functions/communication/serial/>`_ .
+
+
+SoftwareSerial Emulation
+========================
+A ``SoftwareSerial`` wrapper is included to provide plug-and-play compatibility
+with the Arduino `Software Serial <https://docs.arduino.cc/learn/built-in-libraries/software-serial>`_
+library.  Use the normal ``#include <SoftwareSerial.h>`` to include it.   The following
+differences from the Arduino standard are present:
+
+* Inverted mode is not supported
+* All ports are always listening
+* ``listen`` call is a no-op
+* ``isListening()`` always returns ``true``

docs/platformio.rst

@@ -19,14 +19,14 @@ The PlatformIO experience:
 
 Refer to the general documentation at https://docs.platformio.org/.
 
-Especially useful is the `Getting started with VSCode + PlatformIO <https://docs.platformio.org/en/latest/integration/ide/vscode.html#installation), [CLI reference](https://docs.platformio.org/en/latest/core/index.html) and [platformio.ini options](https://docs.platformio.org/en/latest/projectconf/index.html)>`__ page.
+Especially useful is the `Getting started with VSCode + PlatformIO <https://docs.platformio.org/en/latest/integration/ide/vscode.html#installation>`_, `CLI reference <https://docs.platformio.org/en/latest/core/index.html>`_ and the `platformio.ini options <https://docs.platformio.org/en/latest/projectconf/index.html>`_ page.
 
 Hereafter it is assumed that you have a basic understanding of PlatformIO in regards to project creation, project file structure and building and uploading PlatformIO projects, through reading the above pages.
 
 Current state of development
 ----------------------------
 
-At the time of writing, PlatformIO integration for this core is a work-in-progress and not yet merged into mainline PlatformIO. This is subject to change soon.
+At the time of writing, PlatformIO integration for this core is a work-in-progress and not yet merged into mainline PlatformIO. This is subject to change once `this pull request <https://github.com/platformio/platform-raspberrypi/pull/36>`_ is merged.
 
 If you want to use the PlatformIO integration right now, make sure you first create a standard Raspberry Pi Pico + Arduino project within PlatformIO. 
 This will give you a project with the ``platformio.ini`` 
@@ -38,8 +38,7 @@ This will give you a project with the ``platformio.ini``
     board = pico
     framework = arduino
 
-Here, you need to change the `platform` to take advantage of the features described hereunder. 
-You *also* need to inject two PlatformIO packages, one for the compiler toolchain and one for the Arduino core package.
+Here, you need to change the `platform` to take advantage of the features described hereunder and switch to the new core.
 
 .. code:: ini
 
@@ -47,12 +46,32 @@ You *also* need to inject two PlatformIO packages, one for the compiler toolchai
     platform = https://github.com/maxgerhardt/platform-raspberrypi.git
     board = pico
     framework = arduino
+    board_build.core = earlephilhower
+    
+When the support for this core has been merged into mainline PlatformIO, this notice will be removed and a standard `platformio.ini` as shown above will work as a base.
+
+Deprecation warnings
+---------------------
+
+Previous versions of this documentation told users to inject the framework and toolchain package into the project by using
+
+.. code:: ini
+
     ; note that download link for toolchain is specific for OS. see https://github.com/earlephilhower/pico-quick-toolchain/releases.
     platform_packages = 
         maxgerhardt/framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git
         maxgerhardt/toolchain-pico@https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.arm-none-eabi-7855b0c.210706.zip
-    
-When the support for this core has been merged into mainline PlatformIO, this notice will be removed and a standard `platformio.ini` as shown above will work as a base.
+
+This is now **deprecated** and should not be done anymore. Users should delete these ``platform_packages`` lines and update the platform integration by issuing the command
+
+.. code:: bash
+
+    pio pkg update -g -p https://github.com/maxgerhardt/platform-raspberrypi.git
+
+in the `PlatformIO CLI <https://docs.platformio.org/en/latest/integration/ide/vscode.html#platformio-core-cli>`_. The same can be achieved by using the VSCode PIO Home -> Platforms -> Updates GUI.
+
+The toolchain, which was also renamed to ``toolchain-rp2040-earlephilhower`` is downloaded automatically from the registry. The same goes for the ``framework-arduinopico`` toolchain package, which points directly to the Arduino-Pico Github repository.
+However, users can still select a custom fork or branch of the core if desired so, as detailed in a chapter below.
 
 Selecting the new core
 ----------------------
@@ -61,8 +80,8 @@ Prerequisite for using this core is to tell PlatformIO to switch to it.
 There will be board definition files where the Earle-Philhower core will
 be the default since it's a board that only exists in this core (and not
 the other https://github.com/arduino/ArduinoCore-mbed). To switch boards
-for which this is not the default core (e.g. the standard
-``board = pico``), the directive
+for which this is not the default core (which are only
+``board = pico`` and ``board = nanorp2040connect``), the directive
 
 .. code:: ini
 
@@ -72,6 +91,8 @@ must be added to the ``platformio.ini``. This controls the `core
 switching
 logic <https://github.com/maxgerhardt/platform-raspberrypi/blob/77e0d3a29d1dbf00fd3ec3271104e3bf4820869c/builder/frameworks/arduino/arduino.py#L27-L32>`__.
 
+When using Arduino-Pico-only boards like ``board = rpipico`` or ``board = adafruit_feather``, this is not needed.
+
 Flash size
 ----------
 
@@ -154,6 +175,37 @@ either a sing line or a newline-separated expression.
        -DDEBUG_RP2040_CORE
        -DDEBUG_RP2040_PORT=Serial2
 
+C++ Exceptions
+--------------
+
+Exceptions are disabled by default. To enable them, use
+
+.. code:: ini
+
+    ; Enable Exceptions
+    build_flags = -DPIO_FRAMEWORK_ARDUINO_ENABLE_EXCEPTIONS
+
+Stack Protector
+---------------
+
+To enable GCC's stack protection feature, use
+
+.. code:: ini
+
+    ; Enable Stack Protector
+    build_flags = -fstack-protector
+
+
+RTTI
+----
+
+RTTI (run-time type information) is disabled by default. To enable it, use
+
+.. code:: ini
+
+    ; Enable RTTI
+    build_flags = -DPIO_FRAMEWORK_ARDUINO_ENABLE_RTTI
+
 USB Stack
 ---------
 
@@ -188,8 +240,8 @@ directive to do so. Simply specify that the framework package
 Whereas the ``#master`` can also be replaced by a ``#branchname`` or a
 ``#commithash``. If left out, it will pull the default branch, which is ``master``.
 
-The ``file://`` pseudo-protocol can also be used instead of ``https://`` to point to a
-local copy of the core (with e.g. some modifications) on disk.
+The ``file://`` and ``symlink://`` pseudo-protocols can also be used instead of ``https://`` to point to a
+local copy of the core (with e.g. some modifications) on disk (`see documentation <https://docs.platformio.org/en/latest/core/userguide/pkg/cmd_install.html?#local-folder>`_).
 
 Note that this can only be done for versions that have the PlatformIO
 builder script it in, so versions before 1.9.2 are not supported.
@@ -206,14 +258,48 @@ and 0.5MByte filesystem.
     platform = https://github.com/maxgerhardt/platform-raspberrypi.git
     board = pico
     framework = arduino
+    ; board can use both Arduino cores -- we select Arduino-Pico here
     board_build.core = earlephilhower
     board_build.filesystem_size = 0.5m
-    ; note that download link for toolchain is specific for OS. see https://github.com/earlephilhower/pico-quick-toolchain/releases.
-    platform_packages = 
-        maxgerhardt/framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git
-        maxgerhardt/toolchain-pico@https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.arm-none-eabi-7855b0c.210706.zip
 
 
 The initial project structure should be generated just creating a new
 project for the Pico and the Arduino framework, after which the
 auto-generated ``platformio.ini`` can be adapted per above.
+
+Debugging
+---------
+
+With recent updates to the toolchain and OpenOCD, debugging firmwares is also possible.
+
+To specify the debugging adapter, use ``debug_tool`` (`documentation <https://docs.platformio.org/en/latest/projectconf/section_env_debug.html#debug-tool>`_). Supported values are:
+
+* ``picoprobe``
+* ``cmsis-dap``
+* ``jlink``
+* ``raspberrypi-swd``
+
+These values can also be used in ``upload_protocol`` if you want PlatformIO to upload the regular firmware through this method, which you likely want.
+
+Especially the PicoProbe method is convenient when you have two Raspberry Pi Pico boards. One of them can be flashed with the PicoProbe firmware (`documentation <https://www.raspberrypi.com/documentation/microcontrollers/raspberry-pi-pico.html#debugging-using-another-raspberry-pi-pico>`_) and is then connected to the target Raspberry Pi Pico board (see `documentation <https://datasheets.raspberrypi.com/pico/getting-started-with-pico.pdf>`_ chapter "Picoprobe Wiring"). Remember that on Windows, you have to use `Zadig <https://zadig.akeo.ie/>`_ to also load "WinUSB" drivers for the "Picoprobe (Interface 2)" device so that OpenOCD can speak to it.
+
+With that set up, debugging can be started via the left debugging sidebar and works nicely: Setup breakpoints, inspect the value of variables in the code, step through the code line by line. When a breakpoint is hit or execution is halted, you can even see the execution state both Cortex-M0+ cores of the RP2040.
+
+.. image:: images/pio_debugging.png
+
+For further information on customizing debug options, like the initial breakpoint or debugging / SWD speed, consult `the documentation <https://docs.platformio.org/en/latest/projectconf/section_env_debug.html>`_.
+
+Filesystem Uploading
+--------------------
+
+For the Arduino IDE, `a plugin <https://github.com/earlephilhower/arduino-pico#uploading-filesystem-images>`_ is available that enables a data folder to be packed as a LittleFS filesystem binary and uploaded to the Pico.
+
+This functionality is also built-in in the PlatformIO integration. Open the `project tasks <https://docs.platformio.org/en/latest/integration/ide/vscode.html#project-tasks>`_ and expand the "Platform" tasks: 
+
+.. image:: images/pio_fs_upload.png
+
+The files you want to upload should be placed in a folder called ``data`` inside the project. This can be customized `if needed <https://docs.platformio.org/en/latest/projectconf/section_platformio.html#data-dir>`_.
+
+The task "Build Filesystem Image" will take all files in the data directory and create a ``littlefs.bin`` file from it using the ``mklittlefs`` tool.
+
+The task "Upload Filesystem Image" will upload the filesystem image to the Pico via the specified ``upload_protocol``. 

docs/serial.rst

@@ -32,15 +32,14 @@ using the ``setFIFOSize`` call prior to calling ``begin()``
         Serial1.begin(baud);
 
 The FIFO is normally handled via an interrupt, which reduced CPU load and
-makes it less likely to lose characters.  However, the FIFO introduces up
-to 32 bit-times of delay before serial data is available to the application.
+makes it less likely to lose characters.
 
-For applications where this is an issue (i.e. very low baud), use
+For applications where an IRQ driven serial port is not appropriate, use
 ``setPollingMode(true)`` before calling ``begin()``
 
 .. code:: cpp
         Serial1.setPollingMode(true);
-        Serial1.begin(110)
+        Serial1.begin(300)
 
 For detailed information about the Serial ports, see the
 Arduino `Serial Reference <https://www.arduino.cc/reference/en/language/functions/communication/serial/>`_ .

docs/usb.rst

@@ -46,3 +46,61 @@ Also, this stack requires sketches to manually call
 sketch upload from the IDE.  If a sketch is run without this command
 in ``setup()``, the user will need to use the standard "hold BOOTSEL
 and plug in USB" method to enter program upload mode.
+
+Adafruit TinyUSB Configuration and Quirks
+-----------------------------------------
+
+The Adafruit TinyUSB's configuration header for RP2040 devices is stored
+in ``libraries/Adafruit_TinyUSB_Arduino/src/arduino/ports/rp2040/tusb_config_rp2040.h`` (`here <https://github.com/adafruit/Adafruit_TinyUSB_Arduino/blob/master/src/arduino/ports/rp2040/tusb_config_rp2040.h>`__).
+
+In some cases it is important to know what TinyUSB is configured with. For example, by having set 
+
+.. code:: cpp
+
+    #define CFG_TUD_CDC 1
+    #define CFG_TUD_MSC 1
+    #define CFG_TUD_HID 1
+    #define CFG_TUD_MIDI 1
+    #define CFG_TUD_VENDOR 1
+
+this configuration file defines the maximum number of USB CDC (serial)
+devices as 1. Hence, the example sketch `cdc_multi.ino <https://github.com/adafruit/Adafruit_TinyUSB_Arduino/blob/master/examples/CDC/cdc_multi/cdc_multi.ino>`__
+that is delivered with the library will not work, it will only create one
+USB CDC device instead of two. It will however work when the above
+``CFG_TUD_CDC`` macro is defined to 2 instead of 1.
+
+To do such a modification when using the Arduino IDE, the file can be
+locally modified in the Arduino core's package files. The base path can
+be found per `this article <https://support.arduino.cc/hc/en-us/articles/360018448279-Open-the-Arduino15-folder>`__,
+then navigate further to the ``packages/rp2040/hardware/rp2040/<core version>/libraries/Adafruit_TinyUSB_Arduino``
+folder to find the Adafruit TinyUSB library.
+
+When using PlatformIO, one can also make use of the feature that TinyUSB
+allows redirecting the configuration file to another one if a certain
+macro is set.
+
+.. code:: cpp
+
+    #ifdef CFG_TUSB_CONFIG_FILE
+        #include CFG_TUSB_CONFIG_FILE
+    #else
+        #include "tusb_config.h"
+    #endif
+
+And as such, in the ``platformio.ini`` of the project, one can add
+
+.. code:: ini
+
+    build_flags =
+      -DUSE_TINYUSB 
+      -DCFG_TUSB_CONFIG_FILE=\"custom_tusb_config.h\"
+      -Iinclude/ 
+
+and further add create the file ``include/custom_tusb_config.h`` as a copy
+of the original ``tusb_config_rp2040.h`` but with the needed modifications.
+
+*Note:* Some configuration file changes have no effect because upper levels
+of the library don't properly support them. In particular, even though the
+maximum number of HID devices can be set to 2, and two ``Adafruit_USBD_HID``
+can be created, it will not cause two HID devices to actually show up, because
+of `code limitations <https://github.com/adafruit/Adafruit_TinyUSB_Arduino/blob/7264c1492a73d9a285512752b03f2550841c06bc/src/arduino/hid/Adafruit_USBD_HID.cpp#L36-L37>`__.

docs/wifi.rst

@@ -0,0 +1,47 @@
+WiFi (Raspberry Pi Pico W) Support
+==================================
+
+WiFi is supported on the Raspberry Pi Pico W by selecting the "Raspbery Pi Pico W" board in the Boards Manager.  It is generally compatible with the `Arduino WiFi library <https://www.arduino.cc/en/Reference/WiFi>`__ and the `ESP8266 Arduino WiFi library <https://github.com/esp8266/Arduino>`__.
+
+Enable WiFi support by selecting the `Raspberry Pi Pico W` board in the IDE and adding ``#include <WiFi.h>`` in your sketch.
+
+Supported Features
+------------------
+* WiFi connection (Open, WPA/WPA2) 
+  * Static IP or dynamic DHCP supported
+  * Station Mode (STA, connects to an existing network)
+  * Access Point Mode (AP, creates its own wireless network) with 4 clients
+* WiFi Scanning and Reporting
+  * See the ``ScanNetworks.ino`` example to better understand the process.
+* `WiFiClient (TCP/IP client) <wificlient.rst>`__
+  * See the ``WiFiClient.ino`` example which connects the Pico W to a remote internet service and retrieves some data
+* `WiFiServer (TCP/IP server) <wifiserver.rst>`__
+  * See the ``WiFiServer.ino`` example which implements a frientdy TCP/IP server 
+* `WiFiUDP (UDP packet input/output) <wifiudp.rst>`__
+  * See the ``UDP.ino`` example for a simple send/receive UDP application
+
+In the near future TLS (SSL/https) encryption is planned, but is not yet implemented.
+
+Important Information
+---------------------
+Please note that WiFi on the Pico W is a work-in-progress and there are some important caveats:
+* Adding WiFi increases flash usage by > 220KB.
+  * There is a binary firmware blob for the WiFi chip (CYW43-series) which the Pico W uses.  It's 220KB of code that needs to be included in any Pico W sketch, even one that simply flashes the onboard LED.  There are hopes to reduce this via compression (see `this issue <https://github.com/raspberrypi/pico-sdk/issues/909>`__ )
+* Adding WiFi increases RAM usage by ~40KB.
+  * LWIP, the TCP/IP driver, requires preallocated buffers to allow it to run in non-polling mode (i.e. packets can be sent and received in the background without the application needing to explicitly do anything).
+* The WiFi driver is a little limited as of now, but fully functional for sending and receiving data
+  * Extensible Authentication Protocol (EAP) is not supported
+  * Combined STA/AP mode is not supported
+  * Certain WiFi status values (RSSI, BSSID, etc.) are not available.
+* Multicore is supported, but only one core may run ``WiFi`` code.
+  * FreeRTOS is not yet supported due to the requirement for a very different LWIP implementation.  PRs always appreciated!
+
+The WiFi library borrows much work from the `ESP8266 Arduino Core <https://github.com/esp8266/Arduino>`__ , especially the ``WiFiClient`` and ``WiFiServer`` classes.
+
+Special Thanks
+--------------
+
+Special thanks to:
+* @todbot for donating one of his Pico W boards to the effort
+* @d-a-v for much patient explanation about LWIP internals
+* The whole ESP8266 Arduino team for their network classes

docs/wificlient.rst

@@ -0,0 +1,110 @@
+:orphan:
+
+Client Class
+------------
+
+Methods documented for `Client <https://www.arduino.cc/en/Reference/WiFiClientConstructor>`__ in `Arduino <https://github.com/arduino/Arduino>`__
+
+1.  `WiFiClient() <https://www.arduino.cc/en/Reference/WiFiClient>`__
+2.  `connected() <https://www.arduino.cc/en/Reference/WiFiClientConnected>`__
+3.  `connect() <https://www.arduino.cc/en/Reference/WiFiClientConnect>`__
+4.  `write() <https://www.arduino.cc/en/Reference/WiFiClientWrite>`__
+5.  `print() <https://www.arduino.cc/en/Reference/WiFiClientPrint>`__
+6.  `println() <https://www.arduino.cc/en/Reference/WiFiClientPrintln>`__
+7.  `available() <https://www.arduino.cc/en/Reference/WiFiClientAvailable>`__
+8.  `read() <https://www.arduino.cc/en/Reference/WiFiClientRead>`__
+9.  `flush() <https://www.arduino.cc/en/Reference/WiFiClientFlush>`__
+10. `stop() <https://www.arduino.cc/en/Reference/WiFIClientStop>`__
+
+Methods and properties described further down are specific to ESP8266. They are not covered in `Arduino WiFi library <https://www.arduino.cc/en/Reference/WiFi>`__ documentation. Before they are fully documented please refer to information below.
+
+flush and stop
+~~~~~~~~~~~~~~
+
+``flush(timeoutMs)`` and ``stop(timeoutMs)`` both have now an optional argument: ``timeout`` in millisecond, and both return a boolean.
+
+Default input value 0 means that effective value is left at the discretion of the implementer.
+
+``flush()`` returning ``true`` indicates that output data have effectively been sent, and ``false`` that a timeout has occurred.
+
+``stop()`` returns ``false`` in case of an issue when closing the client (for instance a timed-out ``flush``). Depending on implementation, its parameter can be passed to ``flush()``.
+
+setNoDelay
+~~~~~~~~~~
+
+.. code:: cpp
+
+    setNoDelay(nodelay)
+
+With ``nodelay`` set to ``true``, this function will to disable `Nagle algorithm <https://en.wikipedia.org/wiki/Nagle%27s_algorithm>`__.
+
+This algorithm is intended to reduce TCP/IP traffic of small packets sent over the network by combining a number of small outgoing messages, and sending them all at once. The downside of such approach is effectively delaying individual messages until a big enough packet is assembled.
+
+*Example:*
+
+.. code:: cpp
+
+    client.setNoDelay(true);
+
+getNoDelay
+~~~~~~~~~~
+
+Returns whether NoDelay is enabled or not for the current connection.
+
+setSync
+~~~~~~~
+
+This is an experimental API that will set the client in synchronized mode.
+In this mode, every ``write()`` is flushed.  It means that after a call to
+``write()``, data are ensured to be received where they went sent to (that is
+``flush`` semantic).
+
+When set to ``true`` in ``WiFiClient`` implementation,
+
+- It slows down transfers, and implicitly disable the Nagle algorithm.
+
+- It also allows to avoid a temporary copy of data that otherwise consumes
+  at most ``TCP_SND_BUF`` = (2 * ``MSS``) bytes per connection,
+
+getSync
+~~~~~~~
+
+Returns whether Sync is enabled or not for the current connection.
+
+setDefaultNoDelay and setDefaultSync
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+These set the default value for both ``setSync`` and ``setNoDelay`` for
+every future instance of ``WiFiClient`` (including those coming from
+``WiFiServer.available()`` by default).
+
+Default values are false for both ``NoDelay`` and ``Sync``.
+
+This means that Nagle is enabled by default *for all new connections*.
+
+getDefaultNoDelay and getDefaultSync
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Return the values to be used as default for NoDelay and Sync for all future connections.
+
+Other Function Calls
+~~~~~~~~~~~~~~~~~~~~
+
+.. code:: cpp
+
+    uint8_t  status () 
+    virtual size_t  write (const uint8_t *buf, size_t size) 
+    size_t  write_P (PGM_P buf, size_t size) 
+    size_t  write (Stream &stream) 
+    size_t  write (Stream &stream, size_t unitSize) __attribute__((deprecated)) 
+    virtual int  read (uint8_t *buf, size_t size) 
+    virtual int  peek () 
+    virtual size_t  peekBytes (uint8_t *buffer, size_t length) 
+    size_t  peekBytes (char *buffer, size_t length) 
+    virtual  operator bool () 
+    IPAddress  remoteIP () 
+    uint16_t  remotePort () 
+    IPAddress  localIP () 
+    uint16_t  localPort () 
+
+Documentation for the above functions is not yet available.

docs/wifiserver.rst

@@ -0,0 +1,75 @@
+:orphan:
+
+Server Class
+------------
+
+Methods documented for the `Server Class <https://www.arduino.cc/en/Reference/WiFiServerConstructor>`__ in `Arduino <https://github.com/arduino/Arduino>`__
+
+1. `WiFiServer() <https://www.arduino.cc/en/Reference/WiFiServer>`__
+2. `begin() <https://www.arduino.cc/en/Reference/WiFiServerBegin>`__
+3. `available() <https://www.arduino.cc/en/Reference/WiFiServerAvailable>`__
+4. `write() <https://www.arduino.cc/en/Reference/WiFiServerWrite>`__
+5. `print() <https://www.arduino.cc/en/Reference/WiFiServerPrint>`__
+6. `println() <https://www.arduino.cc/en/Reference/WiFiServerPrintln>`__
+
+In ESP8266WiFi library the ``ArduinoWiFiServer`` class implements ``available`` and the write-to-all-clients functionality as described in the Arduino WiFi library reference. The PageServer example shows how ``available`` and the write-to-all-clients works. 
+
+For most use cases the basic WiFiServer class of the ESP8266WiFi library is suitable.
+
+Methods and properties described further down are specific to ESP8266. They are not covered in `Arduino WiFi library <https://www.arduino.cc/en/Reference/WiFi>`__ documentation. Before they are fully documented please refer to information below.
+
+accept
+~~~~~~
+
+Method ``accept()`` returns a waiting client connection. `accept() is documented <https://www.arduino.cc/en/Reference/EthernetServerAccept>`__ for the Arduino Ethernet library.
+
+available
+~~~~~~~~~
+  see ``accept``
+
+``available`` in the ESP8266WiFi library's WiFiServer class doesn't work as documented for the Arduino WiFi library. It works the same way as ``accept``.
+
+write (write to all clients) not supported
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Please note that the ``write`` method on the ``WiFiServer`` object is not implemented and returns failure always.  Use the returned
+``WiFiClient`` object from the ``WiFiServer::accept()`` method to communicate with individual clients.  If you need to send
+the exact same packets to a series of clients, your application must maintain a list of connected clients and iterate over them manually.
+
+setNoDelay
+~~~~~~~~~~
+
+.. code:: cpp
+
+    setNoDelay(nodelay)
+
+With ``nodelay`` set to ``true``, this function will to disable `Nagle algorithm <https://en.wikipedia.org/wiki/Nagle%27s_algorithm>`__.
+
+This algorithm is intended to reduce TCP/IP traffic of small packets sent over the network by combining a number of small outgoing messages, and sending them all at once. The downside of such approach is effectively delaying individual messages until a big enough packet is assembled.
+
+*Example:*
+
+.. code:: cpp
+
+    server.begin();
+    server.setNoDelay(true);
+
+By default, ``nodelay`` value will depends on global ``WiFiClient::getDefaultNoDelay()`` (currently false by default).
+
+However, a call to ``wiFiServer.setNoDelay()`` will override ``NoDelay`` for all new ``WiFiClient`` provided by the calling instance (``wiFiServer``).
+
+Other Function Calls
+~~~~~~~~~~~~~~~~~~~~
+
+.. code:: cpp
+
+    bool  hasClient () 
+    size_t  hasClientData () 
+    bool  hasMaxPendingClients ()
+    bool  getNoDelay () 
+    virtual size_t  write (const uint8_t *buf, size_t size) 
+    uint8_t  status () 
+    void  close () 
+    void  stop ()
+
+Documentation for the above functions is not yet prepared.

docs/wifiudp.rst

@@ -0,0 +1,19 @@
+:orphan:
+
+UDP Class
+---------
+
+Methods documented for `WiFiUDP Class <https://www.arduino.cc/en/Reference/WiFiUDPConstructor>`__ in `Arduino <https://github.com/arduino/Arduino>`__
+
+1.  `begin() <https://www.arduino.cc/en/Reference/WiFiUDPBegin>`__
+2.  `available() <https://www.arduino.cc/en/Reference/WiFiUDPAvailable>`__
+3.  `beginPacket() <https://www.arduino.cc/en/Reference/WiFiUDPBeginPacket>`__
+4.  `endPacket() <https://www.arduino.cc/en/Reference/WiFiUDPEndPacket>`__
+5.  `write() <https://www.arduino.cc/en/Reference/WiFiUDPWrite>`__
+6.  `parsePacket() <https://www.arduino.cc/en/Reference/WiFiUDPParsePacket>`__
+7.  `peek() <https://www.arduino.cc/en/Reference/WiFiUDPPeek>`__
+8.  `read() <https://www.arduino.cc/en/Reference/WiFiUDPRead>`__
+9.  `flush() <https://www.arduino.cc/en/Reference/WiFiUDPFlush>`__
+10. `stop() <https://www.arduino.cc/en/Reference/WiFIUDPStop>`__
+11. `remoteIP() <https://www.arduino.cc/en/Reference/WiFiUDPRemoteIP>`__
+12. `remotePort() <https://www.arduino.cc/en/Reference/WiFiUDPRemotePort>`__

keywords.txt

@@ -11,7 +11,7 @@
 #######################################
 
 setup1	KEYWORD2
-loop2	KEYWORD2
+loop1	KEYWORD2
 
 analogWriteFreq	KEYWORD2
 analogWriteRange	KEYWORD2
@@ -36,3 +36,8 @@ prepare	KEYWORD2
 SerialPIO	KEYWORD2
 setFIFOSize	KEYWORD2
 setPollingMode	KEYWORD2
+
+OUTPUT_2MA	LITERAL1
+OUTPUT_4MA	LITERAL1
+OUTPUT_8MA	LITERAL1
+OUTPUT_12MA	LITERAL1

lib/memmap_default.ld

@@ -92,7 +92,7 @@ SECTIONS
     } > FLASH
 
     .rodata : {
-        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .rodata*)
+        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .rodata* .big_const*)
         . = ALIGN(4);
         *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.flashdata*)))
         . = ALIGN(4);

lib/pico_base/pico/version.h

@@ -12,8 +12,8 @@
 #define _PICO_VERSION_H
 
 #define PICO_SDK_VERSION_MAJOR    1
-#define PICO_SDK_VERSION_MINOR    3
+#define PICO_SDK_VERSION_MINOR    4
 #define PICO_SDK_VERSION_REVISION 0
-#define PICO_SDK_VERSION_STRING   "1.3.0"
+#define PICO_SDK_VERSION_STRING   "1.4.0"
 
 #endif

lib/platform_inc.txt

@@ -1,8 +1,5 @@
 -iwithprefixbefore/cores/rp2040/api/deprecated-avr-comp/
 -iwithprefixbefore/lib/pico_base/
--iwithprefixbefore/pico-extras/src/common/pico_audio/include
--iwithprefixbefore/pico-extras/src/common/pico_util_buffer/include
--iwithprefixbefore/pico-extras/src/rp2_common/pico_audio_i2s/include
 -iwithprefixbefore/pico-sdk/lib/tinyusb/src/
 -iwithprefixbefore/pico-sdk/src/boards/include
 -iwithprefixbefore/pico-sdk/src/common/pico_base/include
@@ -43,9 +40,11 @@
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_watchdog/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_xosc/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_bootrom/include
+-iwithprefixbefore/pico-sdk/src/rp2_common/pico_cyw43_arch/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_double/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_float/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_int64_ops/include
+-iwithprefixbefore/pico-sdk/src/rp2_common/pico_lwip/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_multicore/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_platform/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_printf/include
@@ -53,3 +52,5 @@
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_stdio/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_stdio_uart/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/pico_unique_id/include
+-iwithprefixbefore/pico-sdk/lib/cyw43-driver/src
+-iwithprefixbefore/pico-sdk/lib/lwip/src/include

lib/platform_wrap.txt

@@ -71,7 +71,6 @@
 -Wl,--wrap=atanf
 -Wl,--wrap=atanh
 -Wl,--wrap=atanhf
--Wl,--wrap=calloc
 -Wl,--wrap=cbrt
 -Wl,--wrap=cbrtf
 -Wl,--wrap=ceil
@@ -105,7 +104,6 @@
 -Wl,--wrap=fmaf
 -Wl,--wrap=fmod
 -Wl,--wrap=fmodf
--Wl,--wrap=free
 -Wl,--wrap=hypot
 -Wl,--wrap=hypotf
 -Wl,--wrap=ldexp
@@ -118,7 +116,6 @@
 -Wl,--wrap=log2
 -Wl,--wrap=log2f
 -Wl,--wrap=logf
--Wl,--wrap=malloc
 -Wl,--wrap=memcpy
 -Wl,--wrap=memset
 -Wl,--wrap=__popcountdi2
@@ -147,3 +144,4 @@
 -Wl,--wrap=tanhf
 -Wl,--wrap=trunc
 -Wl,--wrap=truncf
+-Wl,--wrap=__getreent

libraries/FreeRTOS/examples/Multicore-FreeRTOS/Multicore-FreeRTOS.ino

@@ -0,0 +1,81 @@
+// Demonstrates a simple use of the setup1()/loop1() functions
+// for a multiprocessor run.
+
+// Will output something like, where C0 is running on core 0 and
+// C1 is on core 1, in parallel.
+
+// 11:23:07.507 -> C0: Blue leader standing by...
+// 11:23:07.507 -> C1: Red leader standing by...
+// 11:23:07.507 -> C1: Stay on target...
+// 11:23:08.008 -> C1: Stay on target...
+// 11:23:08.505 -> C0: Blue leader standing by...
+// 11:23:08.505 -> C1: Stay on target...
+// 11:23:09.007 -> C1: Stay on target...
+// 11:23:09.511 -> C0: Blue leader standing by...
+// 11:23:09.511 -> C1: Stay on target...
+// 11:23:10.015 -> C1: Stay on target...
+
+// Released to the public domain
+#include <FreeRTOS.h>
+#include <task.h>
+#include <map>
+#include <EEPROM.h>
+
+std::map<eTaskState, const char *> eTaskStateName { {eReady, "Ready"}, { eRunning, "Running" }, {eBlocked, "Blocked"}, {eSuspended, "Suspended"}, {eDeleted, "Deleted"} };
+void ps() {
+  int tasks = uxTaskGetNumberOfTasks();
+  TaskStatus_t *pxTaskStatusArray = new TaskStatus_t[tasks];
+  unsigned long runtime;
+  tasks = uxTaskGetSystemState( pxTaskStatusArray, tasks, &runtime );
+  Serial.printf("# Tasks: %d\n", tasks);
+  Serial.println("ID, NAME, STATE, PRIO, CYCLES");
+  for (int i=0; i < tasks; i++) {
+    Serial.printf("%d: %-16s %-10s %d %lu\n", i, pxTaskStatusArray[i].pcTaskName, eTaskStateName[pxTaskStatusArray[i].eCurrentState], pxTaskStatusArray[i].uxCurrentPriority, pxTaskStatusArray[i].ulRunTimeCounter);
+  }
+  delete[] pxTaskStatusArray;
+}
+
+
+void blink(void *param) {
+  (void) param;
+  pinMode(LED_BUILTIN, OUTPUT);
+  while (true) {
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(750);
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(250);
+  }
+}
+
+
+void setup() {
+  Serial.begin(115200);
+  xTaskCreate(blink, "BLINK", 128, nullptr, 1, nullptr);
+  delay(5000);
+}
+
+volatile int val= 0;
+void loop() {
+  Serial.printf("C0: Blue leader standing by...\n");
+  ps();
+  Serial.printf("val: %d\n", val);
+  delay(1000);
+}
+
+// Running on core1
+void setup1() {
+  delay(5000);
+  Serial.printf("C1: Red leader standing by...\n");
+}
+
+void loop1() {
+  static int x = 0;
+  Serial.printf("C1: Stay on target...\n");
+  val++;
+  if (++x < 10) {
+    EEPROM.begin(512);
+    EEPROM.write(0,x);
+    EEPROM.commit();
+  }
+  delay(1000);
+}

libraries/FreeRTOS/keywords.txt

@@ -0,0 +1,60 @@
+# Syntax Coloring Map For FreeRTOS
+# https://arduino.github.io/arduino-cli/library-specification/#keywords
+# Formatted by a single true tab (not spaces)
+
+# Datatypes (KEYWORD1)
+StackType_t	KEYWORD1
+BaseType_t	KEYWORD1
+UBaseType_t	KEYWORD1
+TickType_t	KEYWORD1
+
+TaskHandle_t	KEYWORD1
+QueueHandle_t	KEYWORD1
+TimerHandle_t	KEYWORD1
+SemaphoreHandle_t	KEYWORD1
+StreamBufferHandle_t	KEYWORD1
+MessageBufferHandle_t	KEYWORD1
+EventGroupHandle_t	KEYWORD1
+
+# Methods and Functions (KEYWORD2)
+xSemaphoreCreateMutex	KEYWORD2
+xSemaphoreCreateBinary	KEYWORD2
+xSemaphoreTake	KEYWORD2
+xSemaphoreTakeFromISR	KEYWORD2
+xSemaphoreGive	KEYWORD2
+xSemaphoreGiveFromISR	KEYWORD2
+xTaskCreate	KEYWORD2
+vTaskDelete	KEYWORD2
+vTaskDelay	KEYWORD2
+xTaskDelayUntil	KEYWORD2
+xQueueCreate	KEYWORD2
+xQueueSend	KEYWORD2
+xQueueReceive	KEYWORD2
+pcTaskGetName KEYWORD2
+ulTaskNotifyTake	KEYWORD2
+vTaskNotifyGiveFromISR	KEYWORD2
+taskYIELD	KEYWORD2
+vTaskSuspend	KEYWORD2
+vTaskResume	KEYWORD2
+xTaskResumeFromISR	KEYWORD2
+xTaskGetTickCount	KEYWORD2
+xTaskGetTickCountFromISR	KEYWORD2
+uxTaskGetNumberOfTasks	KEYWORD2
+uxTaskGetStackHighWaterMark	KEYWORD2
+
+# Instances (KEYWORD2)
+
+# Structures (KEYWORD3)
+TaskParameters_t	KEYWORD3
+TaskStatus_t	KEYWORD3
+ListItem_t	KEYWORD3
+MiniListItem_t	KEYWORD3
+HeapStats_t	KEYWORD3
+
+# Constants (LITERAL1)
+portUSE_WDTO	LITERAL1
+portTICK_PERIOD_MS	LITERAL1
+configTICK_RATE_HZ	LITERAL1
+configCPU_CLOCK_HZ	LITERAL1
+configMAX_PRIORITIES	LITERAL1
+configMINIMAL_STACK_SIZE	LITERAL1

libraries/FreeRTOS/library.properties

@@ -0,0 +1,11 @@
+name=FreeRTOS
+version=1.0.0
+author=Graham Sanderson <info@freertos.org>
+maintainer=Graham Sanderson <info@freertos.org>
+sentence=<h3>FreeRTOS Real Time Operating System implemented for RP2040.</h3>
+paragraph=Taken from the official FreeRTOS SMP branch.
+category=Timing
+url=https://github.com/FreeRTOS/FreeRTOS-Kernel
+architectures=rp2040
+license=MIT
+dot_a_linkage=true

libraries/FreeRTOS/readme.md

@@ -0,0 +1,39 @@
+**ATTENTION**  
+Please be aware that this library was copied from the original Arduino AVR FreeRTOS library and may still contain files from that library that have no meaning in the context of this package, i.e. the licensing and code of conduct file! Each file retains the license and copyright from where it was taken (FreeRTOS repository or AVR FreeRTOS library, respectively.)
+
+______
+
+This is a copy of the RP2040 port of the FreeRTOS SMP branch, packaged as an Arduino library.
+
+It has been created to provide access to FreeRTOS capabilities, with full compatibility to the Arduino environment.
+It does this by keeping hands off almost everything, and only touching the minimum of hardware to be successful.
+
+## General
+
+FreeRTOS has a multitude of configuration options, which can be specified from within the FreeRTOSConfig.h file.
+To keep commonality with all of the Arduino hardware options, some sensible defaults have been selected.
+
+System ticks are 1ms, which means that Tasks can only be scheduled to run up to 1000 times per second.
+
+Stack for the `loop()` function has been set at 256 bytes. This can be configured by adjusting the `configMINIMAL_STACK_SIZE` parameter. If you have stack overflow issues, just increase it.
+Users should prefer to allocate larger structures, arrays, or buffers using `pvPortMalloc()`, rather than defining them locally on the stack.
+
+Memory for the heap is allocated by the normal `malloc()` function, wrapped by `pvPortMalloc()`.
+This option has been selected because it is automatically adjusted to use the capabilities of each device.
+Other heap allocation schemes are supported by FreeRTOS, and they can used with additional configuration.
+
+## Errors
+
+* Stack Overflow: If any stack (for the `loop()` or) for any Task overflows, there will be a slow LED blink, with 4 second cycle.
+* Heap Overflow: If any Task tries to allocate memory and that allocation fails, there will be a fast LED blink, with 100 millisecond cycle.
+
+## Files & Configuration
+
+* `RP2040_FreeRTOS.h` : Must always be `#include` first. It references other configuration files, and sets defaults where necessary.
+* `FreeRTOSConfig.h` : Contains a multitude of API and environment configurations.
+* `variantHooks.cpp` : Contains the RP2040 specific configurations for this port of FreeRTOS.
+* `heap_3.c` : Contains the heap allocation scheme based on `malloc()`. Other schemes are available, but depend on user configuration for specific MCU choice.
+
+## Sources / Credits ✨
+
+This library is built on the efforts of the authors of the FreeRTOS SMP port for the RP2040, using the original Arduino FreeRTOS library as a template for the library package and the Arduino specific behavior.

libraries/FreeRTOS/src/FreeRTOS.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/FreeRTOS.h"

libraries/FreeRTOS/src/FreeRTOSConfig.h

@@ -0,0 +1,129 @@
+/* Cores */
+#define configNUM_CORES                 2
+#define configUSE_CORE_AFFINITY         1
+#define configRUN_MULTIPLE_PRIORITIES   1
+
+#define configUSE_PREEMPTION			1
+#define configUSE_IDLE_HOOK				1
+#define configUSE_MINIMAL_IDLE_HOOK     1
+#define configUSE_TICK_HOOK				1
+#define configCPU_CLOCK_HZ				( ( unsigned long ) F_CPU  )
+#define configTICK_RATE_HZ				( ( TickType_t ) 1000 )
+#define configMAX_PRIORITIES			( 8 )
+#define configMINIMAL_STACK_SIZE		( ( unsigned short ) 256 )
+#define configTOTAL_HEAP_SIZE			( ( size_t ) ( 164 * 1024 ) )
+#define configMAX_TASK_NAME_LEN			( 10 )
+#define configUSE_TRACE_FACILITY		1
+#define configUSE_16_BIT_TICKS			0
+#define configIDLE_SHOULD_YIELD			1
+#define configUSE_MUTEXES				1
+#define configQUEUE_REGISTRY_SIZE		8
+#define configUSE_RECURSIVE_MUTEXES		1
+#define configUSE_MALLOC_FAILED_HOOK	1
+#define configUSE_APPLICATION_TASK_TAG	0
+#define configUSE_COUNTING_SEMAPHORES	1
+#define configUSE_QUEUE_SETS			1
+#define configSUPPORT_DYNAMIC_ALLOCATION 1
+#define configSUPPORT_STATIC_ALLOCATION 0
+#define configSTACK_DEPTH_TYPE			uint32_t
+
+#define configUSE_NEWLIB_REENTRANT 1
+#define configNEWLIB_REENTRANT_IS_DYNAMIC 0 /* Note that we have a different config option, portSET_IMPURE_PTR */
+#include <reent.h>
+extern void __register_impure_ptr(struct _reent *p);
+#define portSET_IMPURE_PTR(x) __register_impure_ptr(x)
+
+/* Run time stats related definitions. */
+void vMainConfigureTimerForRunTimeStats( void );
+unsigned long ulMainGetRunTimeCounterValue( void );
+#define configGENERATE_RUN_TIME_STATS	1
+#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() //vMainConfigureTimerForRunTimeStats()
+#define portGET_RUN_TIME_COUNTER_VALUE() ulMainGetRunTimeCounterValue()
+
+/* Co-routine definitions. */
+#define configUSE_CO_ROUTINES 			1
+#define configMAX_CO_ROUTINE_PRIORITIES ( 2 )
+
+/* Software timer definitions. */
+#define configUSE_TIMERS				1
+#define configTIMER_TASK_PRIORITY		( 2 )
+#define configTIMER_QUEUE_LENGTH		5
+#define configTIMER_TASK_STACK_DEPTH	( 80 )
+
+/* Set the following definitions to 1 to include the API function, or zero
+to exclude the API function. */
+#define INCLUDE_xTaskGetCurrentTaskHandle   1
+#define INCLUDE_vTaskPrioritySet		1
+#define INCLUDE_uxTaskPriorityGet		1
+#define INCLUDE_vTaskDelete				1
+#define INCLUDE_vTaskCleanUpResources	1
+#define INCLUDE_vTaskSuspend			1
+#define INCLUDE_vTaskDelayUntil			1
+#define INCLUDE_vTaskDelay				1
+#define INCLUDE_eTaskGetState			1
+
+/* This demo makes use of one or more example stats formatting functions.  These
+format the raw data provided by the uxTaskGetSystemState() function in to human
+readable ASCII form.  See the notes in the implementation of vTaskList() within
+FreeRTOS/Source/tasks.c for limitations. */
+#define configUSE_STATS_FORMATTING_FUNCTIONS	1
+
+#define configUSE_MUTEXES        				1
+#define INCLUDE_uxTaskGetStackHighWaterMark 	1
+#define INCLUDE_xTaskGetIdleTaskHandle 			1
+#define configUSE_MALLOC_FAILED_HOOK			1
+#define configCHECK_FOR_STACK_OVERFLOW 			2
+/* Normal assert() semantics without relying on the provision of an assert.h
+header file. */
+
+/* Cortex-M specific definitions. */
+#undef __NVIC_PRIO_BITS
+#ifdef __NVIC_PRIO_BITS
+	/* __BVIC_PRIO_BITS will be specified when CMSIS is being used. */
+	#define configPRIO_BITS       		__NVIC_PRIO_BITS
+#else
+	#define configPRIO_BITS       		3        /* 8 priority levels */
+#endif
+
+/* The lowest interrupt priority that can be used in a call to a "set priority"
+function. */
+#define configLIBRARY_LOWEST_INTERRUPT_PRIORITY			0x7
+
+/* The highest interrupt priority that can be used by any interrupt service
+routine that makes calls to interrupt safe FreeRTOS API functions.  DO NOT CALL
+INTERRUPT SAFE FREERTOS API FUNCTIONS FROM ANY INTERRUPT THAT HAS A HIGHER
+PRIORITY THAN THIS! (higher priorities are lower numeric values. */
+#define configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY	5
+
+/* Interrupt priorities used by the kernel port layer itself.  These are generic
+to all Cortex-M ports, and do not rely on any particular library functions. */
+#define configKERNEL_INTERRUPT_PRIORITY 		( configLIBRARY_LOWEST_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
+/* !!!! configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to zero !!!!
+See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */
+#define configMAX_SYSCALL_INTERRUPT_PRIORITY 	( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
+
+extern void rtosFatalError(void);
+#define configASSERT( x ) \
+	if( ( x ) == 0 ) { portDISABLE_INTERRUPTS(); rtosFatalError(); }
+
+/* Definitions that map the FreeRTOS port interrupt handlers to their CMSIS
+standard names - or at least those used in the unmodified vector table. */
+//#define xPortPendSVHandler PendSV_Handler
+//#define xPortSysTickHandler SysTick_Handler
+//#define vPortSVCHandler    SVC_Handler
+
+/* The size of the global output buffer that is available for use when there
+are multiple command interpreters running at once (for example, one on a UART
+and one on TCP/IP).  This is done to prevent an output buffer being defined by
+each implementation - which would waste RAM.  In this case, there is only one
+command interpreter running. */
+#define configCOMMAND_INT_MAX_OUTPUT_SIZE 2048
+
+
+#define configUSE_DYNAMIC_EXCEPTION_HANDLERS 0
+#define configSUPPORT_PICO_SYNC_INTEROP 1
+#define configSUPPORT_PICO_TIME_INTEROP 1
+
+
+#include "rp2040_config.h"
+//#include "task.h"

libraries/FreeRTOS/src/StackMacros.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/StackMacros.h"

libraries/FreeRTOS/src/atomic.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/atomic.h"

libraries/FreeRTOS/src/croutine.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/croutine.c"

libraries/FreeRTOS/src/croutine.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/croutine.h"

libraries/FreeRTOS/src/deprecated_definitions.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/deprecated_definitions.h"

libraries/FreeRTOS/src/event_groups.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/event_groups.c"

libraries/FreeRTOS/src/event_groups.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/event_groups.h"

libraries/FreeRTOS/src/freertos_sdk_config.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/portable/ThirdParty/GCC/RP2040/include/freertos_sdk_config.h"

libraries/FreeRTOS/src/heap_3.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/portable/MemMang/heap_3.c"

libraries/FreeRTOS/src/idle_task_static_memory.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/portable/ThirdParty/GCC/RP2040/idle_task_static_memory.c"

libraries/FreeRTOS/src/list.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/list.c"

libraries/FreeRTOS/src/list.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/list.h"

libraries/FreeRTOS/src/message_buffer.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/message_buffer.h"

libraries/FreeRTOS/src/mpu_prototypes.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/mpu_prototypes.h"

libraries/FreeRTOS/src/mpu_wrappers.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/mpu_wrappers.h"

libraries/FreeRTOS/src/port.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/portable/ThirdParty/GCC/RP2040/port.c"

libraries/FreeRTOS/src/portable.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/portable.h"

libraries/FreeRTOS/src/portmacro.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/portable/ThirdParty/GCC/RP2040/include/portmacro.h"

libraries/FreeRTOS/src/projdefs.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/projdefs.h"

libraries/FreeRTOS/src/queue.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/queue.c"

libraries/FreeRTOS/src/queue.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/queue.h"

libraries/FreeRTOS/src/rp2040_config.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/portable/ThirdParty/GCC/RP2040/include/rp2040_config.h"

libraries/FreeRTOS/src/semphr.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/semphr.h"

libraries/FreeRTOS/src/stack_macros.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/stack_macros.h"

libraries/FreeRTOS/src/stream_buffer.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/stream_buffer.c"

libraries/FreeRTOS/src/stream_buffer.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/stream_buffer.h"

libraries/FreeRTOS/src/task.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/task.h"

libraries/FreeRTOS/src/tasks.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/tasks.c"

libraries/FreeRTOS/src/timers.c

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/timers.c"

libraries/FreeRTOS/src/timers.h

@@ -0,0 +1 @@
+#include "../lib/FreeRTOS-Kernel/include/timers.h"

libraries/FreeRTOS/src/variantHooks.cpp

@@ -0,0 +1,425 @@
+/*
+ * Copyright (C) 2021 Phillip Stevens  All Rights Reserved.
+ * Modifications by Earle F. Philhower, III, for Arduino-Pico
+ *
+ * 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.
+ *
+ *
+ * This file is NOT part of the FreeRTOS distribution.
+ *
+ */
+#include <stdlib.h>
+
+/* Arduino Core includes */
+#include <Arduino.h>
+#include <RP2040USB.h>
+#include "tusb.h"
+#define USB_TASK_IRQ 31
+
+
+/* Raspberry PI Pico includes */
+#include <pico.h>
+#include <pico/time.h>
+
+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+
+/*-----------------------------------------------------------*/
+
+void initFreeRTOS(void)
+{
+}
+
+extern void setup() __attribute__((weak));
+extern void loop() __attribute__((weak));
+extern void setup1() __attribute__((weak));
+extern void loop1() __attribute__((weak));
+// Idle functions (USB, events, ...) from the core
+extern void __loop();
+volatile bool __usbInitted = false;
+
+static void __core0(void *params)
+{
+    (void) params;
+#ifndef NO_USB
+    while (!__usbInitted) {
+        delay(1);
+    }
+#endif
+    if (setup) {
+        setup();
+    }
+    if (loop) {
+        while (1) {
+            loop();
+            __loop();
+        }
+    } else {
+        while (1) {
+            __loop();
+        }
+    }
+}
+
+static void __core1(void *params)
+{
+    (void) params;
+#ifndef NO_USB
+    while (!__usbInitted) {
+        delay(1);
+    }
+#endif
+    if (setup1) {
+        setup1();
+    }
+    if (loop1) {
+        while (1) {
+            loop1();
+        }
+    } else {
+        while (1) {
+            vTaskDelay(1000);
+        }
+    }
+}   
+
+extern "C" void delay(unsigned long ms) {
+    vTaskDelay(ms / portTICK_PERIOD_MS);
+}
+
+extern "C" void yield() {
+    taskYIELD();
+}
+
+extern mutex_t __usb_mutex;
+static TaskHandle_t __usbTask;
+static void __usb(void *param);
+
+void startFreeRTOS(void)
+{
+
+    TaskHandle_t c0;
+    xTaskCreate(__core0, "CORE0", 1024, 0, configMAX_PRIORITIES / 2, &c0);
+    vTaskCoreAffinitySet( c0, 1 << 0 ); 
+
+    if (setup1 || loop1) {
+        TaskHandle_t c1;
+        xTaskCreate(__core1, "CORE1", 1024, 0, configMAX_PRIORITIES / 2, &c1);
+        vTaskCoreAffinitySet( c1, 1 << 1 );
+    }
+
+    // Initialise and run the freeRTOS scheduler. Execution should never return here.
+    vTaskStartScheduler();
+
+    while (true) {
+        /* noop */
+    }
+}
+
+
+/*-----------------------------------------------------------*/
+
+void prvDisableInterrupts()
+{
+    portDISABLE_INTERRUPTS();
+}
+
+void prvEnableInterrupts()
+{
+    portENABLE_INTERRUPTS();
+}
+
+/*-----------------------------------------------------------*/
+#if ( configUSE_IDLE_HOOK == 1 )
+/*
+ * Call the user defined loop() function from within the idle task.
+ * This allows the application designer to add background functionality
+ * without the overhead of a separate task.
+ *
+ * NOTE: vApplicationIdleHook() MUST NOT, UNDER ANY CIRCUMSTANCES, CALL A FUNCTION THAT MIGHT BLOCK.
+ *
+ */
+
+extern "C"
+void vApplicationIdleHook( void ) __attribute__((weak));
+
+
+void vApplicationIdleHook( void )
+{
+    __wfe(); // Low power idle if nothing to do...
+}
+
+#endif /* configUSE_IDLE_HOOK == 1 */
+/*-----------------------------------------------------------*/
+
+#if ( configUSE_MINIMAL_IDLE_HOOK == 1 )
+/*
+ * Call the user defined minimalIdle() function from within the idle task.
+ * This allows the application designer to add background functionality
+ * without the overhead of a separate task.
+ *
+ * NOTE: vApplicationMinimalIdleHook() MUST NOT, UNDER ANY CIRCUMSTANCES, CALL A FUNCTION THAT MIGHT BLOCK.
+ *
+ */
+void minimalIdle( void ) __attribute__((weak));
+void minimalIdle() {} //Empty minimalIdle function
+
+extern "C"
+void vApplicationMinimalIdleHook( void ) __attribute__((weak));
+
+void vApplicationMinimalIdleHook( void )
+{
+	minimalIdle();
+}
+
+#endif /* configUSE_MINIMAL_IDLE_HOOK == 1 */
+/*-----------------------------------------------------------*/
+
+#if ( configUSE_TICK_HOOK == 1 )
+/*
+ * Call the user defined minimalIdle() function from within the idle task.
+ * This allows the application designer to add background functionality
+ * without the overhead of a separate task.
+ *
+ * NOTE: vApplicationMinimalIdleHook() MUST NOT, UNDER ANY CIRCUMSTANCES, CALL A FUNCTION THAT MIGHT BLOCK.
+ *
+ */
+void tick( void ) __attribute__((weak));
+void tick() {} //Empty minimalIdle function
+
+extern "C"
+void vApplicationTickHook( void ) __attribute__((weak));
+
+void vApplicationTickHook( void )
+{
+	tick();
+}
+
+#endif /* configUSE_TICK_HOOK == 1 */
+/*-----------------------------------------------------------*/
+
+#if ( configUSE_MALLOC_FAILED_HOOK == 1 || configCHECK_FOR_STACK_OVERFLOW >= 1 || configDEFAULT_ASSERT == 1 )
+
+/**
+ * Private function to enable board led to use it in application hooks
+ */
+void prvSetMainLedOn( void ) 
+{
+	gpio_init(LED_BUILTIN);
+	gpio_set_dir(LED_BUILTIN, true);
+	gpio_put(LED_BUILTIN, true);
+}
+
+/**
+ * Private function to blink board led to use it in application hooks
+ */
+void prvBlinkMainLed( void ) 
+{
+	gpio_put(LED_BUILTIN, !gpio_get(LED_BUILTIN));
+}
+
+#endif
+
+/*---------------------------------------------------------------------------*\
+Usage:
+	called on fatal error (interrupts disabled already)
+\*---------------------------------------------------------------------------*/
+extern "C"
+void rtosFatalError(void)
+{
+    prvSetMainLedOn(); // Main LED on.
+    
+    for(;;)
+    {
+    	// Main LED slow flash
+        sleep_ms(100);
+        prvBlinkMainLed();
+        sleep_ms(2000);
+        prvBlinkMainLed();
+    }
+}
+
+#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
+/*---------------------------------------------------------------------------*\
+Usage:
+    called by task system when a malloc failure is noticed
+Description:
+    Malloc failure handler -- Shut down all interrupts, send serious complaint
+    to command port. FAST Blink on main LED.
+Arguments:
+    pxTask - pointer to task handle
+    pcTaskName - pointer to task name
+Results:
+    <none>
+Notes:
+    This routine will never return.
+    This routine is referenced in the task.c file of FreeRTOS as an extern.
+\*---------------------------------------------------------------------------*/
+extern "C"
+void vApplicationMallocFailedHook( void ) __attribute__((weak));
+
+void vApplicationMallocFailedHook( void )
+{
+    prvSetMainLedOn(); // Main LED on.
+    
+    for(;;)
+    {
+        sleep_ms(50);
+        prvBlinkMainLed(); // Main LED fast blink.
+    }
+}
+
+#endif /* configUSE_MALLOC_FAILED_HOOK == 1 */
+/*-----------------------------------------------------------*/
+
+
+#if ( configCHECK_FOR_STACK_OVERFLOW >= 1 )
+
+extern "C"
+void vApplicationStackOverflowHook( TaskHandle_t xTask,
+                                    char * pcTaskName ) __attribute__((weak));
+
+void vApplicationStackOverflowHook( TaskHandle_t xTask __attribute__((unused)),
+                                    char * pcTaskName __attribute__((unused)) )
+{
+    prvSetMainLedOn(); // Main LED on.
+
+    for(;;)
+    {
+        sleep_ms(2000);
+        prvBlinkMainLed();  // Main LED slow blink.
+    }
+}
+
+#endif /* configCHECK_FOR_STACK_OVERFLOW >= 1 */
+/*-----------------------------------------------------------*/
+
+#if ( configSUPPORT_STATIC_ALLOCATION >= 1 )
+
+extern "C"
+void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
+                                    StackType_t ** ppxIdleTaskStackBuffer,
+                                    configSTACK_DEPTH_TYPE * pulIdleTaskStackSize ) __attribute__((weak));
+
+void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
+                                    StackType_t ** ppxIdleTaskStackBuffer,
+                                    configSTACK_DEPTH_TYPE * pulIdleTaskStackSize )
+{
+    static StaticTask_t xIdleTaskTCB;
+    static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];
+
+    *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
+    *ppxIdleTaskStackBuffer = uxIdleTaskStack;
+    *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
+}
+
+#if ( configUSE_TIMERS >= 1 )
+
+extern "C"
+void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
+                                     StackType_t ** ppxTimerTaskStackBuffer,
+                                     configSTACK_DEPTH_TYPE * pulTimerTaskStackSize ) __attribute__((weak));
+
+void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
+                                     StackType_t ** ppxTimerTaskStackBuffer,
+                                     configSTACK_DEPTH_TYPE * pulTimerTaskStackSize )
+{
+    static StaticTask_t xTimerTaskTCB;
+    static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];
+
+    *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;
+    *ppxTimerTaskStackBuffer = uxTimerTaskStack;
+    *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
+}
+
+#endif /* configUSE_TIMERS >= 1 */
+
+#endif /* configSUPPORT_STATIC_ALLOCATION >= 1 */
+
+/**
+ * configASSERT default implementation
+ */
+#if configDEFAULT_ASSERT == 1
+
+extern "C"
+void vApplicationAssertHook() {
+
+    taskDISABLE_INTERRUPTS(); // Disable task interrupts
+
+    prvSetMainLedOn(); // Main LED on.
+    for(;;)
+    {
+        sleep_ms(100);
+        prvBlinkMainLed(); // Led off.
+
+        sleep_ms(2000);
+        prvBlinkMainLed(); // Led on.
+
+        sleep_ms(100);
+        prvBlinkMainLed(); // Led off
+
+        sleep_ms(100);
+        prvBlinkMainLed(); // Led on.
+    }
+}
+#endif
+
+
+static void __usb_irq() {
+    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
+    vTaskNotifyGiveFromISR( __usbTask, &xHigherPriorityTaskWoken );
+    portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+}
+
+static void __usb(void *param)
+{
+    (void) param;
+
+    tusb_init();
+    irq_set_exclusive_handler(USB_TASK_IRQ, __usb_irq);
+    irq_set_enabled(USB_TASK_IRQ, true);
+
+    Serial.begin(115200);
+
+    __usbInitted = true;
+
+    while (true) {
+        if (mutex_try_enter(&__usb_mutex, NULL)) {
+            tud_task();
+            mutex_exit(&__usb_mutex);
+        }
+        vTaskDelay(1 / portTICK_PERIOD_MS);
+    }
+}
+
+extern void __SetupDescHIDReport();
+extern void __SetupUSBDescriptor();
+
+void __USBStart()
+{
+    mutex_init(&__usb_mutex);
+
+    __SetupDescHIDReport();
+    __SetupUSBDescriptor();
+
+    // Make highest prio and locked to core 0
+    xTaskCreate(__usb, "USB", 256, 0, configMAX_PRIORITIES - 1, &__usbTask);
+    vTaskCoreAffinitySet( __usbTask, 1 << 0 );
+}

libraries/I2S/examples/I2SInput/I2SInput.ino

@@ -0,0 +1,37 @@
+/*
+   I2S stereo microphone (input) example
+   Run using the Arduino Serial Plotter to see waveform.
+   Released to the Public Domain by Earle F. Philhower, III
+
+   For the Google AIY Voice Hat Microphone daughterboard, part
+   of the Raspberry Pi AIY cardboard box, the I2S stereo pinout
+   looking at the board top with the RPI logo on the left hand
+   side:
+            +--   ------------------------------------  --+
+   left RPI | (1) GND (2) DIN (3) BCLK (4) LRCLK (5) 3.3V | AIY right
+       logo +---------------------------------------------+ logo
+*/
+
+#include <I2S.h>
+
+I2S i2s(INPUT);
+
+void setup() {
+  Serial.begin(115200);
+
+  i2s.setDATA(0);
+  i2s.setBCLK(1); // LRCLK = GP2
+  i2s.setBitsPerSample(16);
+  i2s.setFrequency(22050);
+  i2s.begin();
+
+  while (1) {
+    int16_t l, r;
+    i2s.read16(&l, &r);
+    Serial.printf("%d %d\n", l, r);
+  }
+}
+
+void loop() {
+  /* Nothing here */
+}