Update version

Add some Doxygen documentation to core and libraries (#2780 )
Add Olimex Pico2XL and Pico2XXL (#2868 )
2025-03-18 17:03:18 -07:00 · 2025-03-18 17:00:44 -07:00 · 2025-03-18 16:40:51 -07:00 · 2025-03-18 16:29:54 -07:00 · 2025-03-18 15:26:34 -07:00 · 2025-03-18 15:11:25 -07:00
102 changed files with 6259 additions and 1817 deletions
@@ -25,6 +25,7 @@ Read the [Contributing Guide](https://github.com/earlephilhower/arduino-pico/blo
 * Adafruit KB2040
 * Adafruit Macropad RP2040
 * Adafruit Metro RP2040
+* Adafruit Metro RP2350
 * Adafruit QTPy RP2040
 * Adafruit STEMMA Friend RP2040
 * Adafruit Trinkey RP2040 QT
@@ -68,16 +69,21 @@ Read the [Contributing Guide](https://github.com/earlephilhower/arduino-pico/blo
 * Melopero Cookie RP2040
 * Melopero Shake RP2040
 * METE HOCA Akana R1
+* Makerbase MKSTHR36
+* Makerbase MKSTHR42
 * MyMakers RP2040
 * Neko Systems BL2040 Mini
 * Newsan Archi
 * nullbits Bit-C PRO
+* Olimex Pico2XL
+* Olimex Pico2XXL
 * Olimex RP2040-Pico30
 * Pimoroni PGA2040
 * Pimoroni Pico Plus 2
 * Pimoroni Pico Plus 2W
 * Pimoroni Plasma2040
 * Pimoroni Plasma2350
+* Pimoroni Servo2040
 * Pimoroni Tiny2040
 * Pimoroni Tiny2350
 * Pintronix PinMax
@@ -92,11 +98,13 @@ Read the [Contributing Guide](https://github.com/earlephilhower/arduino-pico/blo
 * Solder Party RP2040 Stamp
 * Solder Party RP2350 Stamp
 * Solder Party RP2350 Stamp XL
+* SparkFun IoT RedBoard RP2350
 * SparkFun MicroMod RP2040
 * SparkFun ProMicro RP2040
 * SparkFun ProMicro RP2350
 * SparkFun Thing Plus RP2040
 * SparkFun Thing Plus RP2350
+* SparkFun XRP Controller
 * uPesy RP2040 DevKit
 * VCC-GND YD-RP2040
 * Viyalab Mizu RP2040
@@ -110,7 +110,7 @@ extern bool __isFreeRTOS;
 #endif

 #ifndef PGM_VOID_P
-#define PGM_VOID_P void *
+#define PGM_VOID_P const void *
 #endif

 #ifdef __cplusplus
@@ -159,3 +159,7 @@ constexpr uint64_t __bitset(const int (&a)[N], size_t i = 0U) {
 #define __GPIOCNT 30
 #define __FIRSTANALOGGPIO 26
 #endif
+
+#ifdef __cplusplus
+using namespace arduino;
+#endif
@@ -20,10 +20,21 @@

 #pragma once

+/**
+    @brief Wrapper class for polling the BOOTSEL button
+*/
 class __Bootsel {
 public:
    __Bootsel() { }
+    /**
+        @brief Get state of the BOOTSEL pin
+
+        @returns True if BOOTSEL pushed
+    */
    operator bool();
 };

+/**
+    @brief BOOTSEL accessor instance
+*/
 extern __Bootsel BOOTSEL;
@@ -182,6 +182,9 @@ extern "C" void loop1() __attribute__((weak));
 extern "C" bool core1_separate_stack;
 extern "C" uint32_t* core1_separate_stack_address;

+/**
+    @brief RP2040/RP2350 helper function for HW-specific features
+*/
 class RP2040 {
 public:
    RP2040()  { /* noop */ }
@@ -207,26 +210,50 @@ public:
 #endif
    }

-    // Convert from microseconds to PIO clock cycles
+    /**
+        @brief Convert from microseconds to PIO clock cycles
+
+        @returns the PIO cycles for a given microsecond delay
+    */
    static int usToPIOCycles(int us) {
        // Parenthesis needed to guarantee order of operations to avoid 32bit overflow
        return (us * (clock_get_hz(clk_sys) / 1'000'000));
    }

-    // Get current clock frequency
+    /**
+        @brief Gets the active CPU speed (may differ from F_CPU
+
+        @returns CPU frequency in Hz
+    */
    static int f_cpu() {
        return clock_get_hz(clk_sys);
    }

-    // Get current CPU core number
+    /**
+        @brief Get the core ID that is currently executing this code
+
+        @returns 0 for Core 0, 1 for Core 1
+    */
    static int cpuid() {
        return sio_hw->cpuid;
    }

-    // Get CPU cycle count.  Needs to do magic to extens 24b HW to something longer
+    /**
+        @brief CPU cycle counter epoch (24-bit cycle).  For internal use
+    */
    volatile uint64_t _epoch = 0;
+    /**
+        @brief Get the count of CPU clock cycles since power on.
+
+        @details
+        The 32-bit count will overflow every 4 billion cycles, so consider using ``getCycleCount64`` for
+        longer measurements
+
+        @returns CPU clock cycles since power up
+    */
    inline uint32_t getCycleCount() {
 #if !defined(__riscv) && !defined(__PROFILE)
+        // Get CPU cycle count.  Needs to do magic to extend 24b HW to something longer
        if (!__isFreeRTOS) {
            uint32_t epoch;
            uint32_t ctr;
@@ -242,7 +269,11 @@ public:
        }
 #endif
    }
+    /**
+        @brief Get the count of CPU clock cycles since power on as a 64-bit quantrity

+        @returns CPU clock cycles since power up
+    */
    inline uint64_t getCycleCount64() {
 #if !defined(__riscv) && !defined(__PROFILE)
        if (!__isFreeRTOS) {
@@ -261,23 +292,53 @@ public:
 #endif
    }

+    /**
+        @brief Gets total unused heap (dynamic memory)
+
+        @details
+        Note that the allocations of the size of the total free heap may fail due to fragmentation.
+        For example, ``getFreeHeap`` can report 100KB available, but an allocation of 90KB may fail
+        because there may not be a contiguous 90KB space available
+
+        @returns Free heap in bytes
+    */
    inline int getFreeHeap() {
        return getTotalHeap() - getUsedHeap();
    }

+    /**
+        @brief Gets total used heap (dynamic memory)
+
+        @returns Used heap in bytes
+    */
    inline int getUsedHeap() {
        struct mallinfo m = mallinfo();
        return m.uordblks;
    }

+    /**
+        @brief Gets total heap (dynamic memory) compiled into the program
+
+        @returns Total heap size in bytes
+    */
    inline int getTotalHeap() {
        return &__StackLimit  - &__bss_end__;
    }

+    /**
+        @brief On the RP2350, returns the amount of heap (dynamic memory) available in PSRAM
+
+        @returns Total free heap in PSRAM, or 0 if no PSRAM present
+    */
    inline int getFreePSRAMHeap() {
        return getTotalPSRAMHeap() - getUsedPSRAMHeap();
    }

+    /**
+        @brief On the RP2350, returns the total amount of PSRAM heap (dynamic memory) used
+
+        @returns Bytes used in PSRAM, or 0 if no PSRAM present
+    */
    inline int getUsedPSRAMHeap() {
 #if defined(RP2350_PSRAM_CS)
        extern size_t __psram_total_used();
@@ -287,6 +348,11 @@ public:
 #endif
    }

+    /**
+        @brief On the RP2350, gets total heap (dynamic memory) compiled into the program
+
+        @returns Total PSRAM heap size in bytes, or 0 if no PSRAM present
+    */
    inline int getTotalPSRAMHeap() {
 #if defined(RP2350_PSRAM_CS)
        extern size_t __psram_total_space();
@@ -296,6 +362,11 @@ public:
 #endif
    }

+    /**
+        @brief Gets the current stack pointer in a ARM/RISC-V safe manner
+
+        @returns Current SP
+    */
    inline uint32_t getStackPointer() {
        uint32_t *sp;
 #if defined(__riscv)
@@ -306,6 +377,14 @@ public:
        return (uint32_t)sp;
    }

+    /**
+        @brief Calculates approximately how much stack space is still available for the running core.  Handles multiprocessing and separate stacks.
+
+        @details
+        Not valid in FreeRTOS.  Use the FreeRTOS internal functions to access this information.
+
+        @returns Approximation of the amount of stack available for use on the specific core
+    */
    inline int getFreeStack() {
        const unsigned int sp = getStackPointer();
        uint32_t ref = 0x20040000;
@@ -319,6 +398,11 @@ public:
        return sp - ref;
    }

+    /**
+        @brief On the RP2350, gets the size of attached PSRAM
+
+        @returns PSRAM size in bytes, or 0 if no PSRAM present
+    */
    inline size_t getPSRAMSize() {
 #if defined(RP2350_PSRAM_CS)
        extern size_t __psram_size;
@@ -328,20 +412,48 @@ public:
 #endif
    }

+    /**
+        @brief Freezes the other core in a flash-write-safe state.  Not generally needed by applications
+
+        @details
+        When the external flash chip is erasing or writing, the Pico cannot fetch instructions from it.
+        In this case both the core doing the writing and the other core (if active) need to run from a
+        routine that's contained in RAM.  This call forces the other core into a tight, RAM-based loop
+        safe for this operation.  When flash erase/write is completed, ``resumeOtherCore`` to return
+        it to operation.
+
+        Be sure to disable any interrupts or task switches before calling to avoid deadlocks.
+
+        If the second core is not started, this is a no-op.
+    */
    void idleOtherCore() {
        fifo.idleOtherCore();
    }

+    /**
+        @brief Resumes normal operation of the other core
+    */
    void resumeOtherCore() {
        fifo.resumeOtherCore();
    }

+    /**
+        @brief Hard resets the 2nd core (CORE1).
+
+        @details
+        Because core1 will restart with the heap and global variables not in the same state as
+        power-on, this call may not work as desired and a full CPU reset may be necessary in
+        certain cases.
+    */
    void restartCore1() {
        multicore_reset_core1();
        fifo.clear();
        multicore_launch_core1(main1);
    }

+    /**
+        @brief Warm-reboots the chip in normal mode
+    */
    void reboot() {
        watchdog_reboot(0, 0, 10);
        while (1) {
@@ -349,10 +461,16 @@ public:
        }
    }

+    /**
+        @brief Warm-reboots the chip in normal mode
+    */
    inline void restart() {
        reboot();
    }

+    /**
+        @brief Warm-reboots the chip into the USB bootloader mode
+    */
    inline void rebootToBootloader() {
        reset_usb_boot(0, 0);
        while (1) {
@@ -364,16 +482,32 @@ public:
    static void enableDoubleResetBootloader();
 #endif

+    /**
+        @brief Starts the hardware watchdog timer.  The CPU will reset if the watchdog is not fed every delay_ms
+
+        @param [in] delay_ms Milliseconds without a wdt_reset before rebooting
+    */
    void wdt_begin(uint32_t delay_ms) {
        watchdog_enable(delay_ms, 1);
    }

+    /**
+        @brief Feeds the watchdog timer, resetting it for another delay_ms countdown
+    */
    void wdt_reset() {
        watchdog_update();
    }

+    /**
+        @brief Best-effort reasons for chip reset
+    */
    enum resetReason_t {UNKNOWN_RESET, PWRON_RESET, RUN_PIN_RESET, SOFT_RESET, WDT_RESET, DEBUG_RESET, GLITCH_RESET, BROWNOUT_RESET};

+    /**
+        @brief Attempts to determine the reason for the last chip reset.  May not always be able to determine accurately
+
+        @returns Reason for reset
+    */
    resetReason_t getResetReason(void) {
        io_rw_32 *WD_reason_reg = (io_rw_32 *)(WATCHDOG_BASE + WATCHDOG_REASON_OFFSET);

@@ -427,6 +561,10 @@ public:
        return UNKNOWN_RESET;
    }

+    /**
+        @brief Get unique ID string for the running board
+        @returns String with the unique board ID as determined by the SDK
+    */
    const char *getChipID() {
        static char id[2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES + 1] = { 0 };
        if (!id[0]) {
@@ -437,6 +575,17 @@ public:

 #pragma GCC push_options
 #pragma GCC optimize ("Os")
+    /**
+        @brief Perform a memcpy using a DMA engine for speed
+
+        @details
+        Uses the DMA to copy to and from RAM.  Only works on 4-byte aligned, 4-byte multiple length
+        sources and destination (i.e. word-aligned, word-length).  Falls back to normal memcpy otherwise.
+
+        @param [out] dest Memcpy destination, 4-byte aligned
+        @param [in] src Memcpy source, 4-byte aligned
+        @param [in] n Count in bytes to transfer (should be a multiple of 4 bytes)
+    */
    void *memcpyDMA(void *dest, const void *src, size_t n) {
        // Allocate a DMA channel on 1st call, reuse it every call after
        if (memcpyDMAChannel < 1) {
@@ -465,14 +614,32 @@ public:
    }
 #pragma GCC pop_options

-    // Multicore comms FIFO
+    /**
+        @brief Multicore communications FIFO
+    */
    _MFIFO fifo;


+    /**
+        @brief Return a 32-bit from the hardware random number generator
+
+        @returns Random value using appropriate hardware (RP2350 has true RNG, RP2040 has a less true RNG method)
+    */
    uint32_t hwrand32() {
        return get_rand_32();
    }

+    /**
+        @brief Determines if code is running on a Pico or a PicoW
+
+        @details
+        Code compiled for the RP2040 PicoW can run on the RP2040 Pico.  This call lets an application
+        identify if the current device is really a Pico or PicoW and handle appropriately.  For
+        the RP2350, this runtime detection is not available and the call returns whether it was
+        compiled for the CYW43 WiFi driver
+
+        @returns True if running on a PicoW board with CYW43 WiFi chip.
+    */
    bool isPicoW() {
 #if !defined(PICO_CYW43_SUPPORTED)
        return false;
@@ -1,5 +1,5 @@
 #pragma once
 #define ARDUINO_PICO_MAJOR 4
-#define ARDUINO_PICO_MINOR 4
-#define ARDUINO_PICO_REVISION 3
-#define ARDUINO_PICO_VERSION_STR "4.4.3"
+#define ARDUINO_PICO_MINOR 5
+#define ARDUINO_PICO_REVISION 1
+#define ARDUINO_PICO_VERSION_STR "4.5.1"
@@ -24,7 +24,9 @@

 // Input/output will be handled by OpenOCD

-// From https://developer.arm.com/documentation/dui0471/g/Semihosting/Semihosting-operations?lang=en
+/**
+    @brief Semihosting host API opcodes, from https://developer.arm.com/documentation/dui0471/g/Semihosting/Semihosting-operations?lang=en
+*/
 typedef enum {
    SEMIHOST_SYS_CLOSE = 0x02,
    SEMIHOST_SYS_CLOCK = 0x10,
@@ -52,7 +54,13 @@ typedef enum {

 #ifdef __arm__

-// From https://github.com/ErichStyger/mcuoneclipse/blob/master/Examples/MCUXpresso/FRDM-K22F/FRDM-K22F_Semihosting/source/McuSemihost.c
+/**
+    @brief Execute a semihosted request, from https://github.com/ErichStyger/mcuoneclipse/blob/master/Examples/MCUXpresso/FRDM-K22F/FRDM-K22F_Semihosting/source/McuSemihost.c
+
+    @param [in] reason Opcode to execute
+    @param [in] arg Any arguments for the opcode
+    @returns Result of operation
+*/
 static inline int __attribute__((always_inline)) Semihost(int reason, void *arg) {
    int value;
    __asm volatile(
@@ -69,7 +77,13 @@ static inline int __attribute__((always_inline)) Semihost(int reason, void *arg)
 }
 #else

-// https://groups.google.com/a/groups.riscv.org/g/sw-dev/c/n-5VQ9PHZ4w/m/KbzH5t9MBgAJ
+/**
+    @brief Execute a semihosted request, from https://groups.google.com/a/groups.riscv.org/g/sw-dev/c/n-5VQ9PHZ4w/m/KbzH5t9MBgAJ
+
+    @param [in] reason Opcode to execute
+    @param [in] argPack Any arguments for the opcode
+    @returns Result of operation
+*/
 static inline int __attribute__((always_inline)) Semihost(int reason, void *argPack) {
    register int value asm("a0") = reason;
    register void *ptr asm("a1") = argPack;
@@ -29,7 +29,7 @@

 extern "C" typedef struct uart_inst uart_inst_t;

-class SerialPIO : public HardwareSerial {
+class SerialPIO : public arduino::HardwareSerial {
 public:
    static const pin_size_t NOPIN = 0xff; // Use in constructor to disable RX or TX unit
    SerialPIO(pin_size_t tx, pin_size_t rx, size_t fifoSize = 32);
@@ -24,7 +24,7 @@
 #include "Arduino.h"
 #include "api/HardwareSerial.h"

-class SerialSemiClass : public HardwareSerial {
+class SerialSemiClass : public arduino::HardwareSerial {
 public:
    SerialSemiClass() {
        /* noop */
@@ -32,15 +32,20 @@ extern void serialEvent1() __attribute__((weak));
 extern void serialEvent2() __attribute__((weak));

 bool SerialUART::setRX(pin_size_t pin) {
-#ifdef PICO_RP2350B
-    constexpr uint64_t valid[2] = { __bitset({1, 13, 17, 29, 33, 45}) /* UART0 */,
-                                    __bitset({5, 9, 21, 25, 37, 41})  /* UART1 */
+#if defined(PICO_RP2350B)
+    constexpr uint64_t valid[2] = { __bitset({1, 3, 13, 15, 17, 19, 29, 31, 33, 35, 45, 47}) /* UART0 */,
+                                    __bitset({5, 7, 9, 11, 21, 23, 25, 27, 37, 39, 41, 43})  /* UART1 */
+                                  };
+#elif defined(PICO_RP2350)
+    constexpr uint64_t valid[2] = { __bitset({1, 3, 13, 15, 17, 19, 29})     /* UART0 */,
+                                    __bitset({5, 7, 9, 11, 21, 23, 25, 27})  /* UART1 */
                                  };
 #else
    constexpr uint64_t valid[2] = { __bitset({1, 13, 17, 29}) /* UART0 */,
                                    __bitset({5, 9, 21, 25})  /* UART1 */
                                  };
 #endif
+
    if ((!_running) && ((1LL << pin) & valid[uart_get_index(_uart)])) {
        _rx = pin;
        return true;
@@ -59,9 +64,13 @@ bool SerialUART::setRX(pin_size_t pin) {
 }

 bool SerialUART::setTX(pin_size_t pin) {
-#ifdef PICO_RP2350B
-    constexpr uint64_t valid[2] = { __bitset({0, 12, 16, 28, 32, 44}) /* UART0 */,
-                                    __bitset({4, 8, 20, 24, 36, 40})  /* UART1 */
+#if defined(PICO_RP2350B)
+    constexpr uint64_t valid[2] = { __bitset({0, 2, 12, 14, 16, 18, 28, 30, 32, 34, 44, 46}) /* UART0 */,
+                                    __bitset({4, 6, 8, 10, 20, 22, 24, 26, 36, 38, 40, 42})  /* UART1 */
+                                  };
+#elif defined(PICO_RP2350)
+    constexpr uint64_t valid[2] = { __bitset({0, 2, 12, 14, 16, 18, 28})     /* UART0 */,
+                                    __bitset({4, 6, 8, 10, 20, 22, 24, 26})  /* UART1 */
                                  };
 #else
    constexpr uint64_t valid[2] = { __bitset({0, 12, 16, 28}) /* UART0 */,
@@ -170,6 +179,41 @@ SerialUART::SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx, pin_size
 static void _uart0IRQ();
 static void _uart1IRQ();

+// Does the selected TX/RX need UART_AUX function (rp2350)
+static gpio_function_t __gpioFunction(int pin) {
+    switch (pin) {
+#if defined(PICO_RP2350) || defined(PICO_RP2350B)
+    case 2:
+    case 3:
+    case 6:
+    case 7:
+    case 10:
+    case 11:
+    case 14:
+    case 15:
+    case 18:
+    case 19:
+    case 22:
+    case 23:
+    case 26:
+    case 27:
+    case 30:
+    case 31:
+    case 34:
+    case 35:
+    case 38:
+    case 39:
+    case 42:
+    case 43:
+    case 46:
+    case 47:
+        return GPIO_FUNC_UART_AUX;
+#endif
+    default:
+        return GPIO_FUNC_UART;
+    }
+}
+
 void SerialUART::begin(unsigned long baud, uint16_t config) {
    if (_running) {
        end();
@@ -180,9 +224,9 @@ void SerialUART::begin(unsigned long baud, uint16_t config) {

    _fcnTx = gpio_get_function(_tx);
    _fcnRx = gpio_get_function(_rx);
-    gpio_set_function(_tx, GPIO_FUNC_UART);
+    gpio_set_function(_tx, __gpioFunction(_tx));
    gpio_set_outover(_tx, _invertTX ? 1 : 0);
-    gpio_set_function(_rx, GPIO_FUNC_UART);
+    gpio_set_function(_rx, __gpioFunction(_rx));
    gpio_set_inover(_rx, _invertRX ? 1 : 0);
    if (_rts != UART_PIN_NOT_DEFINED) {
        _fcnRts = gpio_get_function(_rts);
@@ -29,7 +29,7 @@
 extern "C" typedef struct uart_inst uart_inst_t;

 #define UART_PIN_NOT_DEFINED      (255u)
-class SerialUART : public HardwareSerial {
+class SerialUART : public arduino::HardwareSerial {
 public:
    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);

@@ -24,7 +24,7 @@
 #include "api/HardwareSerial.h"
 #include <stdarg.h>

-class SerialUSB : public HardwareSerial {
+class SerialUSB : public arduino::HardwareSerial {
 public:
    SerialUSB() { }
    void begin(unsigned long baud = 115200) override;
@@ -22,9 +22,18 @@

 #include "SerialPIO.h"

+/**
+    @brief Implements a UART port using PIO for input and output
+*/
 class SoftwareSerial : public SerialPIO {
 public:
-    // Note the rx/tx pins are swapped in PIO vs SWSerial
+    /**
+        @brief Constructs a PIO-based UART
+
+        @param [in] rx GPIO for RX pin or -1 for transmit-only
+        @param [in] tx GPIO for TX pin or -1 for receive-only
+        @param [in] invert True to invert the receive and transmit lines
+    */
    SoftwareSerial(pin_size_t rx, pin_size_t tx, bool invert = false) : SerialPIO(tx, rx) {
        _invert = invert;
    }
@@ -32,18 +41,37 @@ public:
    ~SoftwareSerial() {
    }

+    /**
+        @brief Starts the PIO UART
+
+        @param [in] baud Serial bit rate
+    */
    virtual void begin(unsigned long baud = 115200) override {
        begin(baud, SERIAL_8N1);
    };

+    /**
+        @brief Starts the PIO UART
+
+        @param [in] baud Serial bit rate
+        @param [in] config Start/Stop/Len configuration (i.e. SERIAL_8N1 or SERIAL_7E2)
+    */
    void begin(unsigned long baud, uint16_t config) override {
        setInvertTX(_invert);
        setInvertRX(_invert);
        SerialPIO::begin(baud, config);
    }

+    /**
+        @brief No-op on this core
+    */
    void listen() { /* noop */ }

+    /**
+        @brief No-op on this core
+
+        @returns True always
+    */
    bool isListening() {
        return true;
    }
@@ -22,7 +22,11 @@
 #include "RP2040USB.h"
 #include <pico/stdlib.h>
 #include <pico/multicore.h>
+#include <hardware/vreg.h>
 #include <reent.h>
+#ifdef RP2350_PSRAM_CS
+#include "psram.h"
+#endif

 RP2040 rp2040;
 extern "C" {
@@ -80,9 +84,41 @@ static struct _reent *_impure_ptr1 = nullptr;

 extern "C" int main() {
 #if (defined(PICO_RP2040) && (F_CPU != 125000000)) || (defined(PICO_RP2350) && (F_CPU != 150000000))
-    set_sys_clock_khz(F_CPU / 1000, true);
+
+#if defined(PICO_RP2040)
+    // From runtime_init_clocks() to bump up RP2040 V for 200Mhz+ operation
+    if ((F_CPU > 133000000) && (vreg_get_voltage() < VREG_VOLTAGE_1_15)) {
+        vreg_set_voltage(VREG_VOLTAGE_1_15);
+        // wait for voltage to settle; must use CPU cycles as TIMER is not yet clocked correctly
+        busy_wait_at_least_cycles((uint32_t)((SYS_CLK_VREG_VOLTAGE_AUTO_ADJUST_DELAY_US * (uint64_t)XOSC_HZ) / 1000000));
+    }
 #endif

+#if defined(RP2350_PSRAM_CS) && (F_CPU > 150000000)
+    // Need to increase the qmi divider before upping sysclk to ensure we keep the output sck w/in legal bounds
+    psram_reinit_timing(F_CPU);
+    // Per datasheet, need to do a dummy access and memory barrier before it takes effect
+    extern uint8_t __psram_start__;
+    volatile uint8_t *x = &__psram_start__;
+    *x ^= 0xff;
+    *x ^= 0xff;
+    asm volatile("" ::: "memory");
+#endif
+
+    set_sys_clock_khz(F_CPU / 1000, true);
+
+#if defined(RP2350_PSRAM_CS) && (F_CPU < 150000000)
+    psram_reinit_timing();
+    // Per datasheet, need to do a dummy access and memory barrier before it takes effect
+    extern uint8_t __psram_start__;
+    volatile uint8_t *x = &__psram_start__;
+    *x ^= 0xff;
+    *x ^= 0xff;
+    asm volatile("" ::: "memory");
+#endif
+
+#endif // over/underclock
+
    // Let rest of core know if we're using FreeRTOS
    __isFreeRTOS = initFreeRTOS ? true : false;

@@ -23,6 +23,7 @@
 #include <errno.h>
 #include <_syslist.h>
 #include <sys/times.h>
+#include <sys/unistd.h>
 #include <pico/stdlib.h>
 #include <pico/multicore.h>

@@ -195,10 +195,7 @@ static size_t __no_inline_not_in_flash_func(get_psram_size)(void) {
 ///
 /// @note This function expects interrupts to be enabled on entry

-static void __no_inline_not_in_flash_func(set_psram_timing)(void) {
-    // Get secs / cycle for the system clock - get before disabling interrupts.
-    uint32_t sysHz = (uint32_t)clock_get_hz(clk_sys);
-
+static void __no_inline_not_in_flash_func(set_psram_timing)(uint32_t sysHz) {
    // Calculate the clock divider - goal to get clock used for PSRAM <= what
    // the PSRAM IC can handle - which is defined in SFE_PSRAM_MAX_SCK_HZ
    volatile uint8_t clockDivider = (sysHz + SFE_PSRAM_MAX_SCK_HZ - 1) / SFE_PSRAM_MAX_SCK_HZ;
@@ -283,7 +280,7 @@ static void __no_inline_not_in_flash_func(runtime_init_setup_psram)(/*uint32_t p

    // check our interrupts and setup the timing
    restore_interrupts(intr_stash);
-    set_psram_timing();
+    set_psram_timing((uint32_t)clock_get_hz(clk_sys));

    // and now stash interrupts again
    intr_stash = save_and_disable_interrupts();
@@ -323,8 +320,11 @@ static void __no_inline_not_in_flash_func(runtime_init_setup_psram)(/*uint32_t p
 PICO_RUNTIME_INIT_FUNC_RUNTIME(runtime_init_setup_psram, PICO_RUNTIME_INIT_PSRAM);

 // update timing -- used if the system clock/timing was changed.
-void psram_reinit_timing() {
-    set_psram_timing();
+void psram_reinit_timing(uint32_t hz) {
+    if (!hz) {
+        hz = (uint32_t)clock_get_hz(clk_sys);
+    }
+    set_psram_timing(hz);
 }

 static bool __psram_heap_init() {
@@ -31,7 +31,7 @@

 #include <Arduino.h>

-void psram_reinit_timing();
+void psram_reinit_timing(uint32_t hz = 0);
 void *__psram_malloc(size_t size);
 void __psram_free(void *ptr);
 void *__psram_realloc(void *ptr, size_t size);
@@ -56,9 +56,9 @@ extern "C" void shiftOut(pin_size_t dataPin, pin_size_t clockPin, BitOrder bitOr
    }
    for (i = 0; i < 8; i++)  {
        if (bitOrder == LSBFIRST) {
-            digitalWrite(dataPin, !!(val & (1 << i)));
+            digitalWrite(dataPin, !!(val & (1 << i)) ? HIGH : LOW);
        } else {
-            digitalWrite(dataPin, !!(val & (1 << (7 - i))));
+            digitalWrite(dataPin, !!(val & (1 << (7 - i))) ? HIGH : LOW);
        }

        digitalWrite(clockPin, HIGH);
@@ -54,9 +54,9 @@ author = u'Earle F. Philhower, III'
 # built documents.
 #
 # The short X.Y version.
-version = u'4.4.3'
+version = u'4.5.1'
 # The full version, including alpha/beta/rc tags.
-release = u'4.4.3'
+release = u'4.5.1'

 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -13,7 +13,7 @@

 #define PICO_SDK_VERSION_MAJOR    2
 #define PICO_SDK_VERSION_MINOR    1
-#define PICO_SDK_VERSION_REVISION 0
-#define PICO_SDK_VERSION_STRING   "2.1.0"
+#define PICO_SDK_VERSION_REVISION 2
+#define PICO_SDK_VERSION_STRING   "2.1.2-develop"

 #endif
@@ -13,7 +13,7 @@

 #define PICO_SDK_VERSION_MAJOR    2
 #define PICO_SDK_VERSION_MINOR    1
-#define PICO_SDK_VERSION_REVISION 0
-#define PICO_SDK_VERSION_STRING   "2.1.0"
+#define PICO_SDK_VERSION_REVISION 2
+#define PICO_SDK_VERSION_STRING   "2.1.2-develop"

 #endif
@@ -10,5 +10,6 @@
 -iwithprefixbefore/pico-sdk/lib/btstack/src
 -iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/bluedroid/decoder/include
 -iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/bluedroid/encoder/include
+-iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/yxml
 -iwithprefixbefore/pico-sdk/lib/btstack/platform/embedded
 -iwithprefixbefore/pico-sdk/src/rp2_common/cmsis/stub/CMSIS/Device/RP2040/Include
@@ -15,4 +15,5 @@
 -iwithprefixbefore/pico-sdk/lib/btstack/src
 -iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/bluedroid/decoder/include
 -iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/bluedroid/encoder/include
+-iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/yxml
 -iwithprefixbefore/pico-sdk/lib/btstack/platform/embedded
@@ -13,4 +13,5 @@
 -iwithprefixbefore/pico-sdk/lib/btstack/src
 -iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/bluedroid/decoder/include
 -iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/bluedroid/encoder/include
+-iwithprefixbefore/pico-sdk/lib/btstack/3rd-party/yxml
 -iwithprefixbefore/pico-sdk/lib/btstack/platform/embedded
@@ -223,7 +223,7 @@ size_t A2DPSource::write(const uint8_t *buffer, size_t size) {
    size = std::min((size_t)availableForWrite(), size);

    size_t count = 0;
-    size /= 2;
+    size /= sizeof(int16_t); // Convert size to samples

    // First copy from writer to either end of
    uint32_t start = _pcmWriter;
@@ -262,7 +262,7 @@ int A2DPSource::availableForWrite() {
    } else {
        avail = _pcmBufferSize - _pcmWriter + _pcmReader - 1;
    }
-    avail /= sizeof(uint32_t); // availableForWrite always 32b sample pairs in this core...
+    avail *= sizeof(int16_t); // Convert samples to bytes
    return avail;
 }

@@ -125,6 +125,14 @@ public:
        return _hci.scan(mask, scanTimeSec, async);
    }

+    bool scanAsyncDone() {
+        return _hci.scanAsyncDone();
+    }
+
+    std::vector<BTDeviceInfo> scanAsyncResult() {
+        return _hci.scanAsyncResult();
+    }
+
    bool connect(const uint8_t *addr = nullptr);

    bool connected() {
@@ -151,6 +159,7 @@ public:
    }

    // from Print (see notes on write() methods below)
+    // Writes only full samples (size must be divisible by sample size in bytes)
    virtual size_t write(const uint8_t *buffer, size_t size) override;
    virtual int availableForWrite() override;

@@ -178,7 +178,7 @@ bool I2S::setLSBJFormat() {
 }

 bool I2S::setTDMFormat() {
-    if (_running || !_isOutput || _isInput) {
+    if (_running || !_isOutput) {
        return false;
    }
    _isTDM = true;
@@ -186,7 +186,7 @@ bool I2S::setTDMFormat() {
 }

 bool I2S::setTDMChannels(int channels) {
-    if (_running || !_isOutput || _isInput) {
+    if (_running || !_isOutput) {
        return false;
    }
    _tdmChannels = channels;
@@ -255,9 +255,9 @@ bool I2S::begin() {
    _isHolding = 0;
    int off = 0;
    if (!_swapClocks) {
-        _i2s = new PIOProgram(_isOutput ? (_isInput ? &pio_i2s_inout_program : (_isTDM ? &pio_tdm_out_program : (_isLSBJ ? &pio_lsbj_out_program : &pio_i2s_out_program))) : &pio_i2s_in_program);
+        _i2s = new PIOProgram(_isOutput ? (_isInput ? (_isTDM ? &pio_tdm_inout_program : &pio_i2s_inout_program) : (_isTDM ? &pio_tdm_out_program : (_isLSBJ ? &pio_lsbj_out_program : &pio_i2s_out_program))) : &pio_i2s_in_program);
    } else {
-        _i2s = new PIOProgram(_isOutput ? (_isInput ? &pio_i2s_inout_swap_program : (_isTDM ? &pio_tdm_out_swap_program : (_isLSBJ ? &pio_lsbj_out_swap_program : &pio_i2s_out_swap_program))) : &pio_i2s_in_swap_program);
+        _i2s = new PIOProgram(_isOutput ? (_isInput ? (_isTDM ? &pio_tdm_inout_swap_program : &pio_i2s_inout_swap_program) : (_isTDM ? &pio_tdm_out_swap_program : (_isLSBJ ? &pio_lsbj_out_swap_program : &pio_i2s_out_swap_program))) : &pio_i2s_in_swap_program);
    }
    int minpin, maxpin;
    if (_isOutput && _isInput) {
@@ -278,7 +278,11 @@ bool I2S::begin() {
    }
    if (_isOutput) {
        if (_isInput) {
-            pio_i2s_inout_program_init(_pio, _sm, off, _pinDIN, _pinDOUT, _pinBCLK, _bps, _swapClocks);
+            if (_isTDM) {
+                pio_tdm_inout_program_init(_pio, _sm, off, _pinDIN, _pinDOUT, _pinBCLK, _bps, _swapClocks, _tdmChannels);
+            } else {
+                pio_i2s_inout_program_init(_pio, _sm, off, _pinDIN, _pinDOUT, _pinBCLK, _bps, _swapClocks);
+            }
        } else if (_isTDM) {
            pio_tdm_out_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps, _swapClocks, _tdmChannels);
        } else if (_isLSBJ) {
@@ -104,6 +104,41 @@ lastbit:
    ; Loop back to the beginning


+.program pio_tdm_inout
+.side_set 2   ; 0 = bclk, 1 = wclk
+; The C code should place (number of bits * channels - 1) in Y and update SHIFTCTRL
+; to be 32 (as per the TDM specs)
+;                           +----- WCLK
+;                           |+---- BCLK
+    mov x, y         side 0b01 [1]
+bitloop:
+    out pins, 1      side 0b00      ; Output changes on falling edge
+    in pins, 1       side 0b00      ; Sample input on falling edge
+    jmp x-- bitloop  side 0b11 [1]  ; Last bit toggles WCLK to mark frame boundary
+
+lastbit:
+    in pins, 1       side 0b10
+    out pins, 1      side 0b10
+    ; Loop back to the beginning
+
+
+.program pio_tdm_inout_swap
+.side_set 2   ; 0 = bclk, 1 = wclk
+; The C code should place (number of bits * channels - 1) in Y and update SHIFTCTRL
+; to be 32 (as per the TDM specs)
+;                           +----- WCLK
+;                           |+---- BCLK
+    mov x, y         side 0b10 [1]
+bitloop:
+    out pins, 1      side 0b00      ; Output changes on falling edge
+    in pins, 1       side 0b00      ; Sample input on falling edge
+    jmp x-- bitloop  side 0b11 [1]  ; Last bit toggles WCLK to mark frame boundary
+
+lastbit:
+    in pins, 1       side 0b01
+    out pins, 1      side 0b01
+    ; Loop back to the beginning
+

 .program pio_lsbj_out
 .side_set 2   ; 0 = bclk, 1=wclk
@@ -313,6 +348,42 @@ static inline void pio_tdm_out_program_init(PIO pio, uint sm, uint offset, uint
    pio_sm_exec(pio, sm, pio_encode_out(pio_osr, 32));
 }

+static inline void pio_tdm_inout_program_init(PIO pio, uint sm, uint offset, uint data_in_pin, uint data_out_pin, uint clock_pin_base, uint bits, bool swap, uint channels) {
+    pio_gpio_init(pio, data_in_pin);
+    pio_gpio_init(pio, data_out_pin);
+    pio_gpio_init(pio, clock_pin_base);
+    pio_gpio_init(pio, clock_pin_base + 1);
+
+    pio_sm_config c = swap ? pio_tdm_inout_swap_program_get_default_config(offset) : pio_tdm_inout_program_get_default_config(offset);
+
+    sm_config_set_in_pins(&c, data_in_pin);
+    sm_config_set_out_pins(&c, data_out_pin, 1);
+    sm_config_set_sideset_pins(&c, clock_pin_base);
+    sm_config_set_in_shift(&c, false, true, 32);
+    sm_config_set_out_shift(&c, false, true, 32);
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_NONE);
+
+    pio_sm_init(pio, sm, offset, &c);
+
+    pio_sm_set_consecutive_pindirs(pio, sm, data_in_pin, 1, false);
+    pio_sm_set_consecutive_pindirs(pio, sm, data_out_pin, 1, true);
+    pio_sm_set_consecutive_pindirs(pio, sm, clock_pin_base, 2, true);
+    pio_sm_set_set_pins(pio, sm, data_out_pin, 1);
+    pio_sm_set_set_pins(pio, sm, clock_pin_base, 2);
+
+    // Initialize PIO state for TDM
+    // Can't set constant > 31, so push and pop/mov if needed
+    if (bits * channels - 1 > 31) {
+        pio_sm_put_blocking(pio, sm, bits * channels - 2);
+        pio_sm_exec(pio, sm, pio_encode_pull(false, false));
+        pio_sm_exec(pio, sm, pio_encode_mov(pio_y, pio_osr));
+    } else {
+        pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits * channels - 2));
+    }
+
+    // Need to make OSR believe there's nothing left to shift out
+    pio_sm_exec(pio, sm, pio_encode_out(pio_osr, 32));
+}

 static inline void pio_lsbj_out_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits, bool swap) {
    pio_gpio_init(pio, data_pin);
@@ -193,6 +193,80 @@ static inline pio_sm_config pio_tdm_out_swap_program_get_default_config(uint off
 }
 #endif

+// ------------- //
+// pio_tdm_inout //
+// ------------- //
+
+#define pio_tdm_inout_wrap_target 0
+#define pio_tdm_inout_wrap 5
+
+static const uint16_t pio_tdm_inout_program_instructions[] = {
+    //     .wrap_target
+    0xa922, //  0: mov    x, y            side 1 [1]
+    0x6001, //  1: out    pins, 1         side 0
+    0x4001, //  2: in     pins, 1         side 0
+    0x1941, //  3: jmp    x--, 1          side 3 [1]
+    0x5001, //  4: in     pins, 1         side 2
+    0x7001, //  5: out    pins, 1         side 2
+    //     .wrap
+};
+
+#if !PICO_NO_HARDWARE
+static const struct pio_program pio_tdm_inout_program = {
+    .instructions = pio_tdm_inout_program_instructions,
+    .length = 6,
+    .origin = -1,
+    .pio_version = 0,
+#if PICO_PIO_VERSION > 0
+    .used_gpio_ranges = 0x0
+#endif
+};
+
+static inline pio_sm_config pio_tdm_inout_program_get_default_config(uint offset) {
+    pio_sm_config c = pio_get_default_sm_config();
+    sm_config_set_wrap(&c, offset + pio_tdm_inout_wrap_target, offset + pio_tdm_inout_wrap);
+    sm_config_set_sideset(&c, 2, false, false);
+    return c;
+}
+#endif
+
+// ------------------ //
+// pio_tdm_inout_swap //
+// ------------------ //
+
+#define pio_tdm_inout_swap_wrap_target 0
+#define pio_tdm_inout_swap_wrap 5
+
+static const uint16_t pio_tdm_inout_swap_program_instructions[] = {
+    //     .wrap_target
+    0xb122, //  0: mov    x, y            side 2 [1]
+    0x6001, //  1: out    pins, 1         side 0
+    0x4001, //  2: in     pins, 1         side 0
+    0x1941, //  3: jmp    x--, 1          side 3 [1]
+    0x4801, //  4: in     pins, 1         side 1
+    0x6801, //  5: out    pins, 1         side 1
+    //     .wrap
+};
+
+#if !PICO_NO_HARDWARE
+static const struct pio_program pio_tdm_inout_swap_program = {
+    .instructions = pio_tdm_inout_swap_program_instructions,
+    .length = 6,
+    .origin = -1,
+    .pio_version = 0,
+#if PICO_PIO_VERSION > 0
+    .used_gpio_ranges = 0x0
+#endif
+};
+
+static inline pio_sm_config pio_tdm_inout_swap_program_get_default_config(uint offset) {
+    pio_sm_config c = pio_get_default_sm_config();
+    sm_config_set_wrap(&c, offset + pio_tdm_inout_swap_wrap_target, offset + pio_tdm_inout_swap_wrap);
+    sm_config_set_sideset(&c, 2, false, false);
+    return c;
+}
+#endif
+
 // ------------ //
 // pio_lsbj_out //
 // ------------ //
@@ -490,6 +564,36 @@ static inline void pio_tdm_out_program_init(PIO pio, uint sm, uint offset, uint
    // Need to make OSR believe there's nothing left to shift out, or the 1st word will be the count we just passed in, not a sample
    pio_sm_exec(pio, sm, pio_encode_out(pio_osr, 32));
 }
+static inline void pio_tdm_inout_program_init(PIO pio, uint sm, uint offset, uint data_in_pin, uint data_out_pin, uint clock_pin_base, uint bits, bool swap, uint channels) {
+    pio_gpio_init(pio, data_in_pin);
+    pio_gpio_init(pio, data_out_pin);
+    pio_gpio_init(pio, clock_pin_base);
+    pio_gpio_init(pio, clock_pin_base + 1);
+    pio_sm_config c = swap ? pio_tdm_inout_swap_program_get_default_config(offset) : pio_tdm_inout_program_get_default_config(offset);
+    sm_config_set_in_pins(&c, data_in_pin);
+    sm_config_set_out_pins(&c, data_out_pin, 1);
+    sm_config_set_sideset_pins(&c, clock_pin_base);
+    sm_config_set_in_shift(&c, false, true, 32);
+    sm_config_set_out_shift(&c, false, true, 32);
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_NONE);
+    pio_sm_init(pio, sm, offset, &c);
+    pio_sm_set_consecutive_pindirs(pio, sm, data_in_pin, 1, false);
+    pio_sm_set_consecutive_pindirs(pio, sm, data_out_pin, 1, true);
+    pio_sm_set_consecutive_pindirs(pio, sm, clock_pin_base, 2, true);
+    pio_sm_set_set_pins(pio, sm, data_out_pin, 1);
+    pio_sm_set_set_pins(pio, sm, clock_pin_base, 2);
+    // Initialize PIO state for TDM
+    // Can't set constant > 31, so push and pop/mov if needed
+    if (bits * channels - 1 > 31) {
+        pio_sm_put_blocking(pio, sm, bits * channels - 2);
+        pio_sm_exec(pio, sm, pio_encode_pull(false, false));
+        pio_sm_exec(pio, sm, pio_encode_mov(pio_y, pio_osr));
+    } else {
+        pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits * channels - 2));
+    }
+    // Need to make OSR believe there's nothing left to shift out
+    pio_sm_exec(pio, sm, pio_encode_out(pio_osr, 32));
+}
 static inline void pio_lsbj_out_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits, bool swap) {
    pio_gpio_init(pio, data_pin);
    pio_gpio_init(pio, clock_pin_base);
@@ -25,65 +25,219 @@
 #include <hardware/spi.h>
 #include "SPIHelper.h"

+/**
+    @brief Implements a hardware-based SPI interface using the Pico's SPI blocks
+*/
 class SPIClassRP2040 : public arduino::HardwareSPI {
 public:
+    /**
+            @brief Create a PIO-based SPI instance, pins can be changed before begin() call
+
+            @param [in] spi SPI hardware instance (spi0/spi1)
+            @param [in] rx MISO GPIO
+            @param [in] cs CS GPIO
+            @param [in] sck SCK GPIO
+            @param [in] tx MOSI GPIO
+    */
    SPIClassRP2040(spi_inst_t *spi, pin_size_t rx, pin_size_t cs, pin_size_t sck, pin_size_t tx);

-    // Send or receive 8- or 16-bit data.  Returns read back value
+    /**
+           @brief Send an 8-bit byte of data and return read-back 8-bit value
+
+           @param [in] data Data to send
+           @returns Read back byte from SPI interface
+    */
    byte transfer(uint8_t data) override;
+
+    /**
+        @brief Send a 16-bit quantity over SPI and return read-back 16-bit value under a single CS assertion
+
+        @param [in] data Data to send
+        @returns Read back 16-bit quantity
+    */
    uint16_t transfer16(uint16_t data) override;

-    // Sends buffer in 8 bit chunks.  Overwrites buffer with read data
+
+    /**
+        @brief Sends buffer in 8 bit chunks under a single CS. Overwrites buffer with read data
+
+        @param [in, out] buf Buffer to read and write back into
+        @param [in] count Number of bytes to transmit/read
+    */
    void transfer(void *buf, size_t count) override;

-    // Sends one buffer and receives into another, much faster! can set rx or txbuf to nullptr
+    /**
+            @brief Sends one buffer and receives into another under a single CS. Can set rx or txbuf to nullptr
+
+            @param [in] txbuf Buffer to transmit or nullptr to send 0s
+            @param [out] rxbuf Buffer to read back into or nullptr to ignore returned data
+            @param [in] count Numbner of bytes to transmit/receive
+    */
    void transfer(const void *txbuf, void *rxbuf, size_t count) override;

    // DMA/asynchronous transfers.  Do not combime with synchronous runs or bad stuff will happen
    // All buffers must be valid for entire DMA and not touched until `finished()` returns true.
+    /**
+        @brief Perform a transfer() using DMA in the background. Returns immediately, need to check for completion
+
+        @details
+        Do not combine asynchronous and synchronous transfers.  All buffers must be valid until
+        the transfer reports that it is completed (``finished`` returns true).
+
+        @param [in] send Buffer to transmit, must remain valid through entire operation
+        @param [out] recv Buffer to receive, must remain valid through entire operation
+        @param [in] bytes Number of bytes to transfer under single CS
+    */
    bool transferAsync(const void *send, void *recv, size_t bytes);
-    bool finishedAsync(); // Call to check if the async operations is completed and the buffer can be reused/read
-    void abortAsync(); // Cancel an outstanding async operation
+    /**
+        @brief Call to check if the async operations is completed and the buffer can be reused/read
+
+        @returns True if the asynchronous SPI operation has completed and ``recv`` buffer is valid
+    */
+    bool finishedAsync();
+
+    /**
+        @brief Aborts an ongoing asynchronous SPI operation, if one is still operating
+
+        @details
+        Not normally needed, but in the case where a large, long SPI operation needs to be aborted
+        this call allows an application to safely stop the SPI and dispose of the ``recv`` and
+        ``send`` buffers
+    */
+    void abortAsync();


-    // Call before/after every complete transaction
+    /**
+           @brief Begin an SPI transaction, sets SPI speed and masks necessary interrupts
+
+           @param [in] SPISettings SPI configuration parameters, including the clock speed
+    */
    void beginTransaction(SPISettings settings) override;
+
+    /**
+            @brief Ends an SPI transaction, unmasks and masked GPIO interrupts
+    */
    void endTransaction(void) override;

-    // Assign pins, call before begin()
+    /**
+           @brief Sets the MISO(RX) pin. Call before begin()
+
+           @param [in] pin The GPIO number to assign to
+           @returns True on success
+    */
    bool setRX(pin_size_t pin);
+
+    /**
+            @brief Sets the MISO(RX) pin. Call before begin()
+
+            @param [in] pin The GPIO number to assign to
+            @returns True on success
+    */
    inline bool setMISO(pin_size_t pin) {
        return setRX(pin);
    }
+
+    /**
+            @brief Sets the CS pin. Call before begin()
+
+            @param [in] pin The GPIO number to assign to
+            @returns True on success
+    */
    bool setCS(pin_size_t pin);
+
+    /**
+            @brief Sets the SCK pin. Call before begin()
+
+            @param [in] pin The GPIO number to assign to
+            @returns True on success
+    */
    bool setSCK(pin_size_t pin);
+
+    /**
+          @brief Sets the MOSI(TX) pin. Call before begin()
+
+          @param [in] pin The GPIO number to assign to
+          @returns True on success
+    */
    bool setTX(pin_size_t pin);
+
+    /**
+          @brief Sets the MOSI(TX) pin. Call before begin()
+
+          @param [in] pin The GPIO number to assign to
+          @returns True on success
+    */
    inline bool setMOSI(pin_size_t pin) {
        return setTX(pin);
    }

-    // Call once to init/deinit SPI class, select pins, etc.
+    /**
+            @brief Call once to init/deinit SPI class, select pins, etc.
+    */
    virtual void begin() override {
        begin(false);
    }
+
+    /**
+           @brief Call once to init/deinit SPI class, select pins, etc.
+
+           @param [in] hwCS Pass in true to enable HW-controlled CS.  Otherwise application needs to assert/deassert CS.
+    */
    void begin(bool hwCS);
+
+    /**
+           @brief Call to deinit and disable the SPI interface.
+    */
    void end() override;

-    // Deprecated - do not use!
+    /**
+            @brief Deprecated, do not use
+
+            @param [in] order Deprecated
+    */
    void setBitOrder(BitOrder order) __attribute__((deprecated));
+
+    /**
+            @brief Deprecated, do not use
+
+            @param [in] order Deprecated
+    */
    void setDataMode(uint8_t uc_mode) __attribute__((deprecated));
+
+    /**
+            @brief Deprecated, do not use
+
+            @param [in] order Deprecated
+    */
    void setClockDivider(uint8_t uc_div) __attribute__((deprecated));

-    // List of GPIO IRQs to disable during a transaction
+    /**
+            @brief Ensure specific GPIO interrupt is disabled during and SPI transaction to protect against re-entrancy.  Multiple GPIOs supported by multiple calls.
+
+            @param [in] interruptNumber GPIO pin to mask
+    */
    virtual void usingInterrupt(int interruptNumber) override {
        _helper.usingInterrupt(interruptNumber);
    }

+    /**
+            @brief Remove a GPIO from the masked-during-transaction list.
+
+            @param [in] interruptNumber GPIO pin to unmask
+    */
    virtual void notUsingInterrupt(int interruptNumber) override {
        _helper.notUsingInterrupt(interruptNumber);
    }
-    virtual void attachInterrupt() override { /* noop */ }
-    virtual void detachInterrupt() override { /* noop */ }
+
+    /**
+           @brief Deprecated, do not use
+    */
+    virtual void attachInterrupt() override  __attribute__((deprecated)) { /* noop */ }
+
+    /**
+           @brief Deprecated, do not use
+    */
+    virtual void detachInterrupt() override  __attribute__((deprecated)) { /* noop */ }

 private:
    void adjustBuffer(const void *s, void *d, size_t cnt, bool by16);
@@ -108,6 +108,9 @@ public:
        @brief Disables any GPIO interrupts registered before an SPI transaction begins
    */
    void maskInterrupts() {
+        if (_usingIRQs.empty()) {
+            return;
+        }
        noInterrupts(); // Avoid possible race conditions if IRQ comes in while main app is in middle of this
        // Disable any IRQs that are being used for SPI
        io_bank0_irq_ctrl_hw_t *irq_ctrl_base = get_core_num() ? &iobank0_hw->proc1_irq_ctrl : &iobank0_hw->proc0_irq_ctrl;
@@ -134,6 +137,9 @@ public:
        @brief Restores GPIO interrupts masks after an SPI transaction completes
    */
    void unmaskInterrupts() {
+        if (_usingIRQs.empty()) {
+            return;
+        }
        noInterrupts(); // Avoid race condition so the GPIO IRQs won't come back until all state is restored
        DEBUGSPI("SPI::endTransaction()\n");
        // Re-enable IRQs
@@ -25,6 +25,9 @@
 #include <api/HardwareSPI.h>
 #include <hardware/spi.h>

+/**
+    @brief Implements a PIO-based SPI interface without pin restrictions
+*/
 class SoftwareSPI : public arduino::HardwareSPI {
 public:
    /**
@@ -37,53 +40,170 @@ public:
    */
    SoftwareSPI(pin_size_t sck, pin_size_t miso, pin_size_t mosi, pin_size_t cs = -1);

-    // Send or receive 8- or 16-bit data.  Returns read back value
+    /**
+        @brief Send an 8-bit byte of data and return read-back 8-bit value
+
+        @param [in] data Data to send
+        @returns Read back byte from SPI interface
+    */
    byte transfer(uint8_t data) override;
+
+    /**
+        @brief Send a 16-bit quantity over SPI and return read-back 16-bit value under a single CS assertion
+
+        @param [in] data Data to send
+        @returns Read back 16-bit quantity
+    */
    uint16_t transfer16(uint16_t data) override;

-    // Sends buffer in 8 bit chunks.  Overwrites buffer with read data
+    /**
+        @brief Sends buffer in 8 bit chunks under a single CS. Overwrites buffer with read data
+
+        @param [in, out] buf Buffer to read and write back into
+        @param [in] count Number of bytes to transmit/read
+    */
    void transfer(void *buf, size_t count) override;

-    // Sends one buffer and receives into another, much faster! can set rx or txbuf to nullptr
+    /**
+        @brief Sends one buffer and receives into another under a single CS. Can set rx or txbuf to nullptr
+
+        @param [in] txbuf Buffer to transmit or nullptr to send 0s
+        @param [out] rxbuf Buffer to read back into or nullptr to ignore returned data
+        @param [in] count Numbner of bytes to transmit/receive
+    */
    void transfer(const void *txbuf, void *rxbuf, size_t count) override;

-    // Call before/after every complete transaction
+    /**
+        @brief Begin an SPI transaction, sets SPI speed and masks necessary interrupts
+
+        @param [in] SPISettings SPI configuration parameters, including the clock speed
+    */
    void beginTransaction(SPISettings settings) override;
+
+    /**
+        @brief Ends an SPI transaction, unmasks and masked GPIO interrupts
+    */
    void endTransaction(void) override;

-    // Assign pins, call before begin()
+    /**
+        @brief Sets the MISO(RX) pin. Call before begin()
+
+        @param [in] pin The GPIO number to assign to
+        @returns True on success
+    */
    bool setMISO(pin_size_t pin);
+
+    /**
+        @brief Sets the MISO(RX) pin. Call before begin()
+
+        @param [in] pin The GPIO number to assign to
+        @returns True on success
+    */
    inline bool setRX(pin_size_t pin) {
        return setMISO(pin);
    }
+
+    /**
+        @brief Sets the CS pin. Call before begin()
+
+        @param [in] pin The GPIO number to assign to
+        @returns True on success
+    */
    bool setCS(pin_size_t pin);
+
+    /**
+        @brief Sets the SCK pin. Call before begin()
+
+        @param [in] pin The GPIO number to assign to
+        @returns True on success
+    */
    bool setSCK(pin_size_t pin);
+
+    /**
+        @brief Sets the MOSI(TX) pin. Call before begin()
+
+        @param [in] pin The GPIO number to assign to
+        @returns True on success
+    */
    bool setMOSI(pin_size_t pin);
+
+    /**
+        @brief Sets the MOSI(TX) pin. Call before begin()
+
+        @param [in] pin The GPIO number to assign to
+        @returns True on success
+    */
    inline bool setTX(pin_size_t pin) {
        return setMOSI(pin);
    }

-    // Call once to init/deinit SPI class, select pins, etc.
+    /**
+        @brief Call once to init/deinit SPI class, select pins, etc.
+    */
    virtual void begin() override {
        begin(false);
    }
+
+    /**
+        @brief Call once to init/deinit SPI class, select pins, etc.
+
+        @param [in] hwCS Pass in true to enable HW-controlled CS.  Otherwise application needs to assert/deassert CS.
+    */
    void begin(bool hwCS);
+
+    /**
+        @brief Call to deinit and disable the SPI interface.
+    */
    void end() override;

-    // Deprecated - do not use!
+    /**
+        @brief Deprecated, do not use
+
+        @param [in] order Deprecated
+    */
    void setBitOrder(BitOrder order) __attribute__((deprecated));
+
+    /**
+        @brief Deprecated, do not use
+
+        @param [in] uc_mode Deprecated
+    */
    void setDataMode(uint8_t uc_mode) __attribute__((deprecated));
+
+    /**
+        @brief Deprecated, do not use
+
+        @param [in] uc_div Deprecated
+    */
    void setClockDivider(uint8_t uc_div) __attribute__((deprecated));

-    // List of GPIO IRQs to disable during a transaction
+    /**
+        @brief Ensure specific GPIO interrupt is disabled during and SPI transaction to protect against re-entrancy.  Multiple GPIOs supported by multiple calls.
+
+        @param [in] interruptNumber GPIO pin to mask
+    */
    virtual void usingInterrupt(int interruptNumber) override {
        _helper.usingInterrupt(interruptNumber);
    }
+
+    /**
+        @brief Remove a GPIO from the masked-during-transaction list.
+
+        @param [in] interruptNumber GPIO pin to unmask
+    */
    virtual void notUsingInterrupt(int interruptNumber) override {
        _helper.notUsingInterrupt(interruptNumber);
    }
-    virtual void attachInterrupt() override { /* noop */ }
-    virtual void detachInterrupt() override { /* noop */ }
+
+    /**
+        @brief Deprecated, do not use
+    */
+    virtual void attachInterrupt() override __attribute__((deprecated)) { /* noop */ }
+
+    /**
+        @brief Deprecated, do not use
+    */
+    virtual void detachInterrupt() override __attribute__((deprecated)) { /* noop */ }

 private:
    void _adjustPIO(int bits);
@@ -35,8 +35,8 @@
 #if USE_WIFI
 #include <WiFi.h>
 #elif USE_WIRED
-#include <W5500lwIP.h> // Or W5100lwIP.h or ENC28J60lwIP.h
-Wiznet5500lwIP eth(1 /* chip select */); // or Wiznet5100lwIP or ENC28J60lwIP
+#include <W5500lwIP.h> // or W6100lwIP.h or W5100lwIP.h or ENC28J60lwIP.h
+Wiznet5500lwIP eth(1 /* SPI chip select */); // or Wiznet6100lwIP or Wiznet5100lwIP or ENC28J60lwIP
 #endif

 #include <WiFiClient.h>
@@ -216,9 +216,9 @@ void handleFileList() {
      // as an HTTP chunk
      Serial.println(output);
      server.sendContent(output);
-      output = ',';
+      output = ",";
    } else {
-      output = '[';
+      output = "[";
    }

    output += "{\"type\":\"";
@@ -21,6 +21,7 @@

 #pragma once

+#include <Arduino.h>
 #include <Udp.h>
 #include <include/slist.h>

@@ -489,6 +489,14 @@ void TwoWire::flush(void) {
    // data transfer.
 }

+bool TwoWire::busIdle() {
+    // Check hardware status
+    uint32_t status = _i2c->hw->status;
+    bool tfe = (status & I2C_IC_STATUS_TFE_BITS);
+    bool mast = (status & I2C_IC_STATUS_MST_ACTIVITY_BITS);
+    return (tfe && !mast);
+}
+
 // DMA/asynchronous transfers.  Do not combime with synchronous runs or bad stuff will happen
 // All buffers must be valid for entire DMA and not touched until `finishedAsync()` returns true.
 bool TwoWire::writeReadAsync(uint8_t address, const void *wbuffer, size_t wbytes, const void *rbuffer, size_t rbytes, bool sendStop) {
@@ -496,6 +504,10 @@ bool TwoWire::writeReadAsync(uint8_t address, const void *wbuffer, size_t wbytes
        return false;
    }

+    if (!busIdle()) {
+        return false;
+    }
+
    if (!_dmaRunning) {
        beginAsync();
        if (!_dmaRunning) {
@@ -507,7 +519,7 @@ bool TwoWire::writeReadAsync(uint8_t address, const void *wbuffer, size_t wbytes
    abortAsync();

    // Create or enlarge dma command buffer, we need one entry for every i2c byte we want to write/read
-    const size_t bufLen = (wbytes + rbytes) * 2;
+    const size_t bufLen = (wbytes + rbytes) * sizeof(uint16_t);
    if (_dmaSendBufferLen < bufLen) {
        if (_dmaSendBuffer) {
            free(_dmaSendBuffer);
@@ -518,6 +530,7 @@ bool TwoWire::writeReadAsync(uint8_t address, const void *wbuffer, size_t wbytes
        if (!_dmaSendBuffer) {
            return false;
        }
+        _dmaSendBufferLen = bufLen;
    }

    // Fill the dma command buffer
@@ -87,6 +87,7 @@ public:
    bool writeReadAsync(uint8_t address, const void *wbuffer, size_t wbytes, const void *rbuffer, size_t rbytes, bool sendStop = true);
    bool writeAsync(uint8_t address, const void *buffer, size_t bytes, bool sendStop = true);
    bool readAsync(uint8_t address, void *buffer, size_t bytes, bool sendStop = true);
+    bool busIdle();
    bool finishedAsync(); // Call to check if the async operations is completed and the buffer can be reused/read
    void abortAsync(); // Cancel an outstanding async I2C operation
    void onFinishedAsync(void(*function)(void)); // Set callback for async operation
@@ -1,6 +1,6 @@
 {
  "name": "framework-arduinopico",
-  "version": "1.40403.0",
+  "version": "1.40501.0",
  "description": "Arduino Wiring-based Framework (RPi Pico RP2040, RP2350)",
  "keywords": [
    "framework",
@@ -86,6 +86,9 @@
                  {
                     "name": "Adafruit Floppsy"
                  },
+                  {
+                     "name": "Adafruit Metro RP2350"
+                  },
                  {
                     "name": "Amken BunnyBoard"
                  },
@@ -206,6 +209,12 @@
                  {
                     "name": "iLabs Challenger 2350 BConnect"
                  },
+                  {
+                     "name": "Makerbase MKS THR36"
+                  },
+                  {
+                     "name": "Makerbase MKS THR42"
+                  },
                  {
                     "name": "Melopero Cookie RP2040"
                  },
@@ -228,10 +237,13 @@
                     "name": "nullbits Bit-C PRO"
                  },
                  {
-                     "name": "Olimex RP2040-Pico30 2MB"
+                     "name": "Olimex Pico2XL"
                  },
                  {
-                     "name": "Olimex RP2040-Pico30 16MB"
+                     "name": "Olimex Pico2XXL"
+                  },
+                  {
+                     "name": "Olimex RP2040-Pico30"
                  },
                  {
                     "name": "Pimoroni PGA2040"
@@ -251,6 +263,9 @@
                  {
                     "name": "Pimoroni Plasma2350"
                  },
+                  {
+                     "name": "Pimoroni Servo2040"
+                  },
                  {
                     "name": "Pimoroni Tiny2040"
                  },
@@ -284,6 +299,9 @@
                  {
                     "name": "Solder Party RP2350 Stamp XL"
                  },
+                  {
+                     "name": "SparkFun IoT RedBoard RP2350"
+                  },
                  {
                     "name": "SparkFun MicroMod RP2040"
                  },
@@ -302,6 +320,12 @@
                  {
                     "name": "SparkFun IoT Node LoRaWAN"
                  },
+                  {
+                     "name": "SparkFun XRP Controller (Beta)"
+                  },
+                  {
+                     "name": "SparkFun XRP Controller"
+                  },
                  {
                     "name": "Seeed INDICATOR RP2040"
                  },
@@ -20,7 +20,7 @@
 # https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5---3rd-party-Hardware-specification

 name=Raspberry Pi RP2040/RP2350 Boards
-version=4.4.3
+version=4.5.1

 # Required discoveries and monitors
 # ---------------------------------
@@ -0,0 +1,55 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "none.S",
+                "usb_vid": "0x239A",
+                "usb_pid": "0x814D"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m33",
+        "extra_flags": "-DARDUINO_ADAFRUIT_METRO_RP2350 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
+        "f_cpu": "150000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x239A",
+                "0x814D"
+            ]
+        ],
+        "mcu": "rp2350",
+        "variant": "adafruit_metro_rp2350"
+    },
+    "debug": {
+        "jlink_device": "RP2350_0",
+        "openocd_target": "rp2350.cfg",
+        "svd_path": "rp2350.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "Metro RP2350",
+    "upload": {
+        "maximum_ram_size": 524288,
+        "maximum_size": 16777216,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ]
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "Adafruit"
+}
@@ -3,13 +3,13 @@
        "arduino": {
            "earlephilhower": {
                "boot2_source": "boot2_w25q080_2_padded_checksum.S",
-                "usb_vid": "0x15BA",
-                "usb_pid": "0x0026"
+                "usb_vid": "0x2E8A",
+                "usb_pid": "0x000A"
            }
        },
        "core": "earlephilhower",
        "cpu": "cortex-m0plus",
-        "extra_flags": "-DARDUINO_OLIMEX_RP2040_PICO30_16MB -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
+        "extra_flags": "-DARDUINO_MAKERBASE_MKSTHR36 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
        "f_cpu": "133000000L",
        "hwids": [
            [
@@ -17,12 +17,12 @@
                "0x00C0"
            ],
            [
-                "0x15BA",
-                "0x0026"
+                "0x2E8A",
+                "0x000A"
            ]
        ],
        "mcu": "rp2040",
-        "variant": "olimex_rp2040pico30_16mb"
+        "variant": "mksthr36"
    },
    "debug": {
        "jlink_device": "RP2040_M0_0",
@@ -32,10 +32,10 @@
    "frameworks": [
        "arduino"
    ],
-    "name": "RP2040-Pico30 16MB",
+    "name": "MKS THR36",
    "upload": {
        "maximum_ram_size": 262144,
-        "maximum_size": 16777216,
+        "maximum_size": 1048576,
        "require_upload_port": true,
        "native_usb": true,
        "use_1200bps_touch": true,
@@ -51,5 +51,5 @@
        ]
    },
    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
-    "vendor": "Olimex"
+    "vendor": "Makerbase"
 }
@@ -0,0 +1,55 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+                "usb_vid": "0x2E8A",
+                "usb_pid": "0x000A"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m0plus",
+        "extra_flags": "-DARDUINO_MAKERBASE_MKSTHR42 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
+        "f_cpu": "133000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x2E8A",
+                "0x000A"
+            ]
+        ],
+        "mcu": "rp2040",
+        "variant": "mksthr42"
+    },
+    "debug": {
+        "jlink_device": "RP2040_M0_0",
+        "openocd_target": "rp2040.cfg",
+        "svd_path": "rp2040.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "MKS THR42",
+    "upload": {
+        "maximum_ram_size": 262144,
+        "maximum_size": 1048576,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ]
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "Makerbase"
+}
@@ -0,0 +1,55 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "none.S",
+                "usb_vid": "0x15BA",
+                "usb_pid": "0x0026"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m33",
+        "extra_flags": "-DARDUINO_OLIMEX_PICO2XL -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
+        "f_cpu": "150000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x15BA",
+                "0x0026"
+            ]
+        ],
+        "mcu": "rp2350",
+        "variant": "olimex_pico2xl"
+    },
+    "debug": {
+        "jlink_device": "RP2350_0",
+        "openocd_target": "rp2350.cfg",
+        "svd_path": "rp2350.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "Pico2XL",
+    "upload": {
+        "maximum_ram_size": 524288,
+        "maximum_size": 2097152,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ]
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "Olimex"
+}
@@ -0,0 +1,56 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "none.S",
+                "usb_vid": "0x15BA",
+                "usb_pid": "0x0026"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m33",
+        "extra_flags": "-DARDUINO_OLIMEX_PICO2XXL -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500 ",
+        "f_cpu": "150000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x15BA",
+                "0x0026"
+            ]
+        ],
+        "mcu": "rp2350",
+        "variant": "olimex_pico2xxl"
+    },
+    "debug": {
+        "jlink_device": "RP2350_0",
+        "openocd_target": "rp2350.cfg",
+        "svd_path": "rp2350.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "Pico2XXL",
+    "upload": {
+        "maximum_ram_size": 524288,
+        "maximum_size": 16777216,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ],
+        "psram_length": 8388608
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "Olimex"
+}
@@ -9,7 +9,7 @@
        },
        "core": "earlephilhower",
        "cpu": "cortex-m0plus",
-        "extra_flags": "-DARDUINO_OLIMEX_RP2040_PICO30_2MB -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
+        "extra_flags": "-DARDUINO_OLIMEX_RP2040_PICO30 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250 ",
        "f_cpu": "133000000L",
        "hwids": [
            [
@@ -22,7 +22,7 @@
            ]
        ],
        "mcu": "rp2040",
-        "variant": "olimex_rp2040pico30_2mb"
+        "variant": "olimex_rp2040pico30"
    },
    "debug": {
        "jlink_device": "RP2040_M0_0",
@@ -32,7 +32,7 @@
    "frameworks": [
        "arduino"
    ],
-    "name": "RP2040-Pico30 2MB",
+    "name": "RP2040-Pico30",
    "upload": {
        "maximum_ram_size": 262144,
        "maximum_size": 2097152,
@@ -9,7 +9,7 @@
        },
        "core": "earlephilhower",
        "cpu": "cortex-m33",
-        "extra_flags": "-DARDUINO_PIMORONI_PLASMA2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500 ",
+        "extra_flags": "-DARDUINO_PIMORONI_PLASMA2350 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500 ",
        "f_cpu": "150000000L",
        "hwids": [
            [
@@ -0,0 +1,55 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+                "usb_vid": "0x2E8A",
+                "usb_pid": "0x10A5"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m0plus",
+        "extra_flags": "-DARDUINO_PIMORONI_SERVO2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500 ",
+        "f_cpu": "133000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x2E8A",
+                "0x10A5"
+            ]
+        ],
+        "mcu": "rp2040",
+        "variant": "pimoroni_servo2040"
+    },
+    "debug": {
+        "jlink_device": "RP2040_M0_0",
+        "openocd_target": "rp2040.cfg",
+        "svd_path": "rp2040.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "Servo2040",
+    "upload": {
+        "maximum_ram_size": 262144,
+        "maximum_size": 2097152,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ]
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "Pimoroni"
+}
@@ -35,7 +35,7 @@
    "name": "XIAO RP2350",
    "upload": {
        "maximum_ram_size": 524288,
-        "maximum_size": 16777216,
+        "maximum_size": 2097152,
        "require_upload_port": true,
        "native_usb": true,
        "use_1200bps_touch": true,
@@ -48,8 +48,7 @@
            "raspberrypi-swd",
            "picotool",
            "picoprobe"
-        ],
-        "psram_length": 8388608
+        ]
    },
    "url": "https://www.seeedstudio.com/Seeed-XIAO-RP2350-p-5944.html",
    "vendor": "Seeed"
@@ -0,0 +1,56 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "none.S",
+                "usb_vid": "0x1B4F",
+                "usb_pid": "0x0047"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m33",
+        "extra_flags": "-DARDUINO_SPARKFUN_IOTREDBOARD_RP2350 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250  -DPICO_CYW43_SUPPORTED=1 -DCYW43_PIN_WL_DYNAMIC=1",
+        "f_cpu": "150000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x1B4F",
+                "0x0047"
+            ]
+        ],
+        "mcu": "rp2350",
+        "variant": "sparkfun_iotredboard_rp2350"
+    },
+    "debug": {
+        "jlink_device": "RP2350_0",
+        "openocd_target": "rp2350.cfg",
+        "svd_path": "rp2350.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "IoT RedBoard RP2350",
+    "upload": {
+        "maximum_ram_size": 524288,
+        "maximum_size": 16777216,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ],
+        "psram_length": 8388608
+    },
+    "url": "https://www.sparkfun.com/sparkfun-iot-redboard-rp2350.html",
+    "vendor": "SparkFun"
+}
@@ -0,0 +1,56 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "none.S",
+                "usb_vid": "0x1B4F",
+                "usb_pid": "0x0046"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m33",
+        "extra_flags": "-DARDUINO_SPARKFUN_XRP_CONTROLLER -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250  -DPICO_CYW43_SUPPORTED=1 -DCYW43_PIN_WL_DYNAMIC=1",
+        "f_cpu": "150000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x1B4F",
+                "0x0046"
+            ]
+        ],
+        "mcu": "rp2350",
+        "variant": "sparkfun_xrp_controller"
+    },
+    "debug": {
+        "jlink_device": "RP2350_0",
+        "openocd_target": "rp2350.cfg",
+        "svd_path": "rp2350.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "XRP Controller",
+    "upload": {
+        "maximum_ram_size": 524288,
+        "maximum_size": 16777216,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ],
+        "psram_length": 8388608
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "SparkFun"
+}
@@ -0,0 +1,55 @@
+{
+    "build": {
+        "arduino": {
+            "earlephilhower": {
+                "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+                "usb_vid": "0x1B4F",
+                "usb_pid": "0x0045"
+            }
+        },
+        "core": "earlephilhower",
+        "cpu": "cortex-m0plus",
+        "extra_flags": "-DARDUINO_SPARKFUN_XRP_CONTROLLER_BETA -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250  -DPICO_CYW43_SUPPORTED=1 -DCYW43_PIN_WL_DYNAMIC=1",
+        "f_cpu": "133000000L",
+        "hwids": [
+            [
+                "0x2E8A",
+                "0x00C0"
+            ],
+            [
+                "0x1B4F",
+                "0x0045"
+            ]
+        ],
+        "mcu": "rp2040",
+        "variant": "sparkfun_xrp_controller_beta"
+    },
+    "debug": {
+        "jlink_device": "RP2040_M0_0",
+        "openocd_target": "rp2040.cfg",
+        "svd_path": "rp2040.svd"
+    },
+    "frameworks": [
+        "arduino"
+    ],
+    "name": "XRP Controller (Beta)",
+    "upload": {
+        "maximum_ram_size": 262144,
+        "maximum_size": 2097152,
+        "require_upload_port": true,
+        "native_usb": true,
+        "use_1200bps_touch": true,
+        "wait_for_upload_port": false,
+        "protocol": "picotool",
+        "protocols": [
+            "blackmagic",
+            "cmsis-dap",
+            "jlink",
+            "raspberrypi-swd",
+            "picotool",
+            "picoprobe"
+        ]
+    },
+    "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+    "vendor": "SparkFun"
+}
@@ -39,7 +39,7 @@ def BuildDebugLevel(name):

 def BuildFreq(name, defmhz):
    out = 0
-    for f in [ defmhz, 50, 100, 120, 125, 128, 133, 150, 175, 200, 225, 240, 250, 275, 300]:
+    for f in [ defmhz, 50, 100, 120, 125, 128, 133, 150, 176, 200, 225, 240, 250, 276, 300]:
        warn = ""
        if f > defmhz: warn = " (Overclock)"
        if (out == 1) and (f == defmhz):
@@ -313,7 +313,8 @@ def BuildWifiType(name):
    print("%s.menu.espwifitype.esp_hosted.build.espwifitype=-DESPHOSTSPI=SPI1" % (name))

 def MakeBoard(name, chip, vendor_name, product_name, vid, pid, pwr, boarddefine, flashsizemb, psramsize, boot2, extra = None, board_url = None):
-    fssizelist = [ 0, 64 * 1024, 128 * 1024, 256 * 1024, 512 * 1024 ]
+    smallfs = [ 0, 64 * 1024, 128 * 1024, 256 * 1024, 512 * 1024 ]
+    fssizelist = list(smallfs)
    for i in range(1, flashsizemb):
        fssizelist.append(i * 1024 * 1024)
    if chip == "rp2040":
@@ -329,17 +330,21 @@ def MakeBoard(name, chip, vendor_name, product_name, vid, pid, pwr, boarddefine,
        raise Exception("Unknown board type " + str(chip));
    BuildHeader(name, chip, tup, opts, vendor_name, product_name, vid, pid, pwr, boarddefine, name, flashsizemb * 1024 * 1024, psramsize, boot2, extra)
    if (name == "generic") or (name == "generic_rp2350") or (name == "vccgnd_yd_rp2040"):
-        BuildFlashMenu(name, chip, 2*1024*1024, [0, 1*1024*1024])
+        smfs =  [ 0, 64 * 1024, 128 * 1024, 256 * 1024, 512 * 1024 ]
+        BuildFlashMenu(name, chip, 2*1024*1024, [*smallfs, 1024 * 1024])
        BuildFlashMenu(name, chip, 4*1024*1024, [0, 3*1024*1024, 2*1024*1024])
        BuildFlashMenu(name, chip, 8*1024*1024, [0, 7*1024*1024, 4*1024*1024, 2*1024*1024])
        BuildFlashMenu(name, chip, 16*1024*1024, [0, 15*1024*1024, 14*1024*1024, 12*1024*1024, 8*1024*1024, 4*1024*1024, 2*1024*1024])
    elif name == "pimoroni_tiny2040":
-        BuildFlashMenu(name, chip, 2*1024*1024, fssizelist)
+        BuildFlashMenu(name, chip, 2*1024*1024, [*smallfs, 1024 * 1024])
        BuildFlashMenu(name, chip, 8*1024*1024, [0, 7*1024*1024, 4*1024*1024, 2*1024*1024])
    elif name == "akana_r1":
-        BuildFlashMenu(name, chip, 2*1024*1024, [0, 1*1024*1024])
+        BuildFlashMenu(name, chip, 2*1024*1024, [*smallfs, 1024 * 1024])
        BuildFlashMenu(name, chip, 8*1024*1024, [0, 7*1024*1024, 4*1024*1024, 2*1024*1024])
        BuildFlashMenu(name, chip, 16*1024*1024, [0, 15*1024*1024, 14*1024*1024, 12*1024*1024, 8*1024*1024, 4*1024*1024, 2*1024*1024])
+    elif name == "olimex_rp2040pico30":
+        BuildFlashMenu(name, chip, 2*1024*1024, [*smallfs, 1024 * 1024])
+        BuildFlashMenu(name, chip, 16*1024*1024, [0, 15*1024*1024, 14*1024*1024, 12*1024*1024, 8*1024*1024, 4*1024*1024, 2*1024*1024])
    elif (name == "challenger_2350_wifi6_ble5") or (name == "challenger_2040_wifi_ble"):        
        BuildWifiType(name)
        BuildCountry(name)
@@ -363,7 +368,7 @@ def MakeBoard(name, chip, vendor_name, product_name, vid, pid, pwr, boarddefine,
            # Optional, user needs to solder themselves
            BuildPSRAM(name)
    else:
-        BuildFreq(name, 133)
+        BuildFreq(name, 200)
    BuildOptimize(name)
    BuildProfile(name)
    BuildRTTI(name)
@@ -516,7 +521,7 @@ MakeBoard("adafruit_macropad2040", "rp2040", "Adafruit", "MacroPad RP2040", "0x2
 MakeBoard("adafruit_kb2040", "rp2040", "Adafruit", "KB2040", "0x239a", "0x8105", 250, "ADAFRUIT_KB2040_RP2040", 8, 0, "boot2_w25q080_2_padded_checksum")
 MakeBoard("adafruit_feather_rp2350_hstx", "rp2350", "Adafruit", "Feather RP2350 HSTX", "0x239a", "0x814f", 250, "ADAFRUIT_FEATHER_RP2350_HSTX", 8, 0, "none")
 MakeBoard("adafruit_floppsy", "rp2040", "Adafruit", "Floppsy", "0x239a", "0x8151", 250, "ADAFRUIT_FLOPPSY_RP2040", 16, 0, "boot2_w25q080_2_padded_checksum")
-
+MakeBoard("adafruit_metro_rp2350", "rp2350", "Adafruit", "Metro RP2350", "0x239a", "0x814d", 250, "ADAFRUIT_METRO_RP2350", 16, 0, "none")
 # Amken
 MakeBoard("amken_bunny", "rp2040","Amken","BunnyBoard","0x2770",["0x7303"],250,"AMKEN_BB",128,0,"boot2_w25q128jvxq_4_padded_checksum","","https://www.amken3d.com")
 MakeBoard("amken_revelop", "rp2040","Amken","Revelop","0x2770",["0x7304"],250,"AMKEN_REVELOP",32,0,"boot2_W25Q32JVxQ_4_padded_checksum","","https://www.amken3d.com")
@@ -591,6 +596,10 @@ MakeBoard("ilabs_rpico32", "rp2040", "iLabs", "RPICO32", "0x2e8a", "0x1010", 250
 MakeBoard("challenger_2350_wifi6_ble5", "rp2350", "iLabs", "Challenger 2350 WiFi/BLE", "0x2e8a", "0x109a", 500, "CHALLENGER_2350_WIFI_BLE_RP2350", 8, 8, "none")
 MakeBoard("challenger_2350_bconnect", "rp2350", "iLabs", "Challenger 2350 BConnect", "0x2e8a", "0x109b", 500, "CHALLENGER_2350_BCONNECT_RP2350", 8, 8, "none")

+# Makerbase
+MakeBoard("mksthr36", "rp2040", "Makerbase", "MKS THR36", "0x2e8a", "0x000a", 250, "MAKERBASE_MKSTHR36", 1, 0, "boot2_w25q080_2_padded_checksum")
+MakeBoard("mksthr42", "rp2040", "Makerbase", "MKS THR42", "0x2e8a", "0x000a", 250, "MAKERBASE_MKSTHR42", 1, 0, "boot2_w25q080_2_padded_checksum")
+
 # Melopero
 MakeBoard("melopero_cookie_rp2040", "rp2040", "Melopero", "Cookie RP2040", "0x2e8a", "0x1011", 250, "MELOPERO_COOKIE_RP2040", 8, 0, "boot2_w25q080_2_padded_checksum")
 MakeBoard("melopero_shake_rp2040", "rp2040", "Melopero", "Shake RP2040", "0x2e8a", "0x1005", 250, "MELOPERO_SHAKE_RP2040", 16, 0, "boot2_w25q080_2_padded_checksum")
@@ -611,8 +620,9 @@ MakeBoard("newsan_archi", "rp2040", "Newsan", "Archi", "0x2E8A", "0x1043", 250,
 MakeBoard("nullbits_bit_c_pro", "rp2040", "nullbits", "Bit-C PRO", "0x2e8a", "0x6e61", 500, "NULLBITS_BIT_C_PRO", 4, 0, "boot2_w25x10cl_4_padded_checksum")

 # Olimex
-MakeBoard("olimex_rp2040pico30_2mb", "rp2040", "Olimex", "RP2040-Pico30 2MB", "0x15ba", "0x0026", 250, "OLIMEX_RP2040_PICO30_2MB", 2, 0, "boot2_w25q080_2_padded_checksum")
-MakeBoard("olimex_rp2040pico30_16mb", "rp2040", "Olimex", "RP2040-Pico30 16MB", "0x15ba", "0x0026", 250, "OLIMEX_RP2040_PICO30_16MB", 16, 0, "boot2_w25q080_2_padded_checksum")
+MakeBoard("olimex_pico2xl", "rp2350", "Olimex", "Pico2XL", "0x15ba", "0x0026", 250, "OLIMEX_PICO2XL", 2, 0, "none")
+MakeBoard("olimex_pico2xxl", "rp2350", "Olimex", "Pico2XXL", "0x15ba", "0x0026", 500, "OLIMEX_PICO2XXL", 16, 8, "none")
+MakeBoard("olimex_rp2040pico30", "rp2040", "Olimex", "RP2040-Pico30", "0x15ba", "0x0026", 250, "OLIMEX_RP2040_PICO30", 2, 0, "boot2_w25q080_2_padded_checksum")

 # Pimoroni
 MakeBoard("pimoroni_pga2040", "rp2040", "Pimoroni", "PGA2040", "0x2e8a", "0x1008", 250, "PIMORONI_PGA2040", 8, 0, "boot2_w25q64jv_4_padded_checksum")
@@ -620,7 +630,8 @@ MakeBoard("pimoroni_pga2350", "rp2350", "Pimoroni", "PGA2350", "0x2e8a", "0x1018
 MakeBoard("pimoroni_pico_plus_2", "rp2350", "Pimoroni", "PicoPlus2", "0x2e8a", "0x100a", 500, "PIMORONI_PICO_PLUS_2", 16, 8, "none")
 MakeBoard("pimoroni_pico_plus_2w", "rp2350", "Pimoroni", "PicoPlus2W", "0x2e8a", "0x100a", 500, "PIMORONI_PICO_PLUS_2W", 16, 8, "none", ["PICO_CYW43_SUPPORTED=1", "CYW43_PIN_WL_DYNAMIC=1"])
 MakeBoard("pimoroni_plasma2040", "rp2040", "Pimoroni", "Plasma2040", "0x2e8a", "0x100a", 500, "PIMORONI_PLASMA2040", 2, 0, "boot2_w25q080_2_padded_checksum")
-MakeBoard("pimoroni_plasma2350", "rp2350", "Pimoroni", "Plasma2350", "0x2e8a", "0x10a5", 500, "PIMORONI_PLASMA2040", 2, 0, "none")
+MakeBoard("pimoroni_plasma2350", "rp2350", "Pimoroni", "Plasma2350", "0x2e8a", "0x10a5", 500, "PIMORONI_PLASMA2350", 2, 0, "none")
+MakeBoard("pimoroni_servo2040", "rp2040", "Pimoroni", "Servo2040", "0x2e8a", "0x10a5", 500, "PIMORONI_SERVO2040", 2, 0, "boot2_w25q080_2_padded_checksum")
 MakeBoard("pimoroni_tiny2040", "rp2040", "Pimoroni", "Tiny2040", "0x2e8a", "0x100a", 500, "PIMORONI_TINY2040", 2, 0, "boot2_w25q64jv_4_padded_checksum")
 MakeBoard("pimoroni_tiny2350", "rp2350", "Pimoroni", "Tiny2350", "0x2e8a", "0x100b", 500, "PIMORONI_TINY2350", 4, 0, "none")

@@ -646,17 +657,20 @@ MakeBoard("solderparty_rp2350_stamp", "rp2350", "Solder Party", "RP2350 Stamp",
 MakeBoard("solderparty_rp2350_stamp_xl", "rp2350", "Solder Party", "RP2350 Stamp XL", "0x1209", "0xa184", 500, "SOLDERPARTY_RP2350_STAMP_XL", 16, 0, "none", None, "https://www.solder.party/docs/rp2350-stamp-xl/")

 # SparkFun
+MakeBoard("sparkfun_iotredboard_rp2350", "rp2350", "SparkFun", "IoT RedBoard RP2350", "0x1b4f", "0x0047", 250, "SPARKFUN_IOTREDBOARD_RP2350", 16, 8, "none", ["PICO_CYW43_SUPPORTED=1", "CYW43_PIN_WL_DYNAMIC=1"], "https://www.sparkfun.com/sparkfun-iot-redboard-rp2350.html")
 MakeBoard("sparkfun_micromodrp2040", "rp2040", "SparkFun", "MicroMod RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_MICROMOD_RP2040", 16, 0, "boot2_w25q080_2_padded_checksum")
 MakeBoard("sparkfun_promicrorp2040", "rp2040", "SparkFun", "ProMicro RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_PROMICRO_RP2040", 16, 0, "boot2_generic_03h_4_padded_checksum")
 MakeBoard("sparkfun_promicrorp2350", "rp2350", "SparkFun", "ProMicro RP2350", "0x1b4f", "0x0026", 250, "SPARKFUN_PROMICRO_RP2350", 16, 8, "none")
 MakeBoard("sparkfun_thingplusrp2040", "rp2040", "SparkFun", "Thing Plus RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_THINGPLUS_RP2040", 16, 0, "boot2_w25q080_2_padded_checksum")
 MakeBoard("sparkfun_thingplusrp2350", "rp2350", "SparkFun", "Thing Plus RP2350", "0x1b4f", "0x0038", 250, "SPARKFUN_THINGPLUS_RP2350", 16, 8, "none", ["PICO_CYW43_SUPPORTED=1", "CYW43_PIN_WL_DYNAMIC=1"])
 MakeBoard("sparkfun_iotnode_lorawanrp2350", "rp2350", "SparkFun", "IoT Node LoRaWAN", "0x1b4f", "0x0044", 250, "SPARKFUN_IOTNODE_LORAWAN_RP2350", 16, 8, "none")
+MakeBoard("sparkfun_xrp_controller_beta", "rp2040", "SparkFun", "XRP Controller (Beta)", "0x1b4f", "0x0045", 250, "SPARKFUN_XRP_CONTROLLER_BETA", 2, 0, "boot2_w25q080_2_padded_checksum", ["PICO_CYW43_SUPPORTED=1", "CYW43_PIN_WL_DYNAMIC=1"])
+MakeBoard("sparkfun_xrp_controller", "rp2350", "SparkFun", "XRP Controller", "0x1b4f", "0x0046", 250, "SPARKFUN_XRP_CONTROLLER", 16, 8, "none", ["PICO_CYW43_SUPPORTED=1", "CYW43_PIN_WL_DYNAMIC=1"])

 # Seeed
 MakeBoard("seeed_indicator_rp2040", "rp2040", "Seeed", "INDICATOR RP2040", "0x2886", "0x0050", 250, "SEEED_INDICATOR_RP2040", 2, 0, "boot2_w25q080_2_padded_checksum")
 MakeBoard("seeed_xiao_rp2040", "rp2040", "Seeed", "XIAO RP2040", "0x2e8a", "0x000a", 250, "SEEED_XIAO_RP2040", 2, 0, "boot2_w25q080_2_padded_checksum")
-MakeBoard("seeed_xiao_rp2350", "rp2350", "Seeed", "XIAO RP2350", "0x2886", "0x0058", 250, "SEEED_XIAO_RP2350", 16, 8, "none", None, "https://www.seeedstudio.com/Seeed-XIAO-RP2350-p-5944.html")
+MakeBoard("seeed_xiao_rp2350", "rp2350", "Seeed", "XIAO RP2350", "0x2886", "0x0058", 250, "SEEED_XIAO_RP2350", 2, 0, "none", None, "https://www.seeedstudio.com/Seeed-XIAO-RP2350-p-5944.html")

 # Upesy
 MakeBoard("upesy_rp2040_devkit", "rp2040", "uPesy", "RP2040 DevKit", "0x2e8a", "0x1007", 250, "UPESY_RP2040_DEVKIT", 2, 0, "boot2_w25q080_2_padded_checksum")
@@ -5,89 +5,96 @@ import sys
 import time
 import threading

-
 toolspath = os.path.dirname(os.path.realpath(__file__))
 try:
-    sys.path.insert(0, os.path.join(toolspath, ".")) # Add pyserial dir to search path
+    sys.path.insert(0, os.path.join(toolspath, ".")) # Add uf2conv dir to search path
    import uf2conv # If this fails, we can't continue and will bomb below
 except ImportError:
    sys.stderr.write("uf2conv not found next to this tool.\n")
    sys.exit(1)

+scannerStop = threading.Event()
+dropDead = False

-scannerGo = False
+class ScannerDarkly(threading.Thread):
+
+    loopTime = 0.0 # Set to 0 for 1st pass to get immediate response for arduino-cli, then bumped to 2.0 for ongoing checks
+
+    # https://stackoverflow.com/questions/12435211/threading-timer-repeat-function-every-n-seconds
+    def __init__(self, event):
+        threading.Thread.__init__(self)
+        self.stopped = event
+
+    def run(self):
+        global dropDead
+        boards = False;
+        while not self.stopped.wait(self.loopTime):
+            if self.stopped.is_set() or dropDead:
+                return
+            self.loopTime = 2.0
+            l = uf2conv.get_drives()
+            if (len(l) > 0) and not boards:
+                boards = True
+                print ("""{
+          "eventType": "add",
+          "port": {
+            "address": "UF2_Board",
+            "label": "UF2 Board",
+            "protocol": "uf2conv",
+            "protocolLabel": "UF2 Devices",
+            "properties": {
+                "mac": "ffffffffffff",
+                "pid" : "0x2e8a",
+                "vid" : "0x000a"
+            }
+          }
+        }""", flush=True)
+            elif (len(l) == 0) and boards:
+                boards = False
+                print("""{
+          "eventType": "remove",
+          "port": {
+            "address": "UF2_Board",
+            "protocol": "uf2conv"
+          }
+        }""", flush = True)

-def scanner():
-    global scannerGo
-    scannerGo = True
-    boards = False
-    while scannerGo:
-        l = uf2conv.get_drives()
-        if (len(l) > 0) and scannerGo and not boards:
-            boards = True
-            print ("""{
-  "eventType": "add",
-  "port": {
-    "address": "UF2_Board",
-    "label": "UF2 Board",
-    "protocol": "uf2conv",
-    "protocolLabel": "UF2 Devices",
-    "properties": {
-        "mac": "ffffffffffff",
-        "pid" : "0x2e8a",
-        "vid" : "0x000a"
-    }
-  }
-}""", flush=True)
-        elif (len(l) == 0) and scannerGo and boards:
-            boards = False
-            print("""{
-  "eventType": "remove",
-  "port": {
-    "address": "UF2_Board",
-    "protocol": "uf2conv"
-  }
-}""", flush = True)
-        n = time.time() + 2
-        while scannerGo and (time.time() < n):
-            time.sleep(.1)
-    scannerGo = True

 def main():
-    global scannerGo
-    while True:
-        cmdline = input()
-        cmd = cmdline.split()[0]
-        if cmd == "HELLO":
-            print(""" {
+    global scannerStop
+    global dropDead
+    try:
+        while True:
+            cmdline = input()
+            cmd = cmdline.split()[0]
+            if cmd == "HELLO":
+                print(""" {
  "eventType": "hello",
  "message": "OK",
  "protocolVersion": 1
 }""", flush = True)
-        elif cmd == "START":
-            print("""{
+            elif cmd == "START":
+                print("""{
  "eventType": "start",
  "message": "OK"
 }""", flush = True);
-        elif cmd == "STOP":
-            scannerGo = False
-            while not scannerGo:
-                time.sleep(.1)
-            print("""{
+            elif cmd == "STOP":
+                scannerStop.set()
+                print("""{
  "eventType": "stop",
  "message": "OK"
 }""", flush = True)
-        elif cmd == "QUIT":
-            scannerGo = False
-            print("""{
+            elif cmd == "QUIT":
+                scannerStop.set()
+                print("""{
  "eventType": "quit",
  "message": "OK"
 }""", flush = True)
-            return
-        elif cmd == "LIST":
-            l = uf2conv.get_drives()
-            if len(l) > 0:
-                        print ("""{
+                return
+            elif cmd == "LIST":
+                l = uf2conv.get_drives()
+                if len(l) > 0:
+                    print ("""{
  "eventType": "list",
  "ports": [
   {
@@ -103,18 +110,19 @@ def main():
   }
 ]
 }""", flush=True)
-            else:
-                print ("""{
+                else:
+                    print ("""{
  "eventType": "list",
  "ports": [ ]
 }""", flush=True)
-        elif cmd == "START_SYNC":
-            print("""{
+            elif cmd == "START_SYNC":
+                print("""{
  "eventType": "start_sync",
  "message": "OK"
 }""", flush = True)
-            scannerGo = True
-            threading.Thread(target = scanner).start()
-    time.sleep(.5)
+                thread = ScannerDarkly(scannerStop)
+                thread.start()
+    except:
+          dropDead = True

 main()
@@ -39,4 +39,14 @@
 #define RP2350_PSRAM_CS         (8u)
 #define RP2350_PSRAM_MAX_SCK_HZ (109*1000*1000)

+// DVI connector
+#define PIN_CKN (15u)
+#define PIN_CKP (14u)
+#define PIN_D0N (19u)
+#define PIN_D0P (18u)
+#define PIN_D1N (17u)
+#define PIN_D1P (16u)
+#define PIN_D2N (13u)
+#define PIN_D2P (12u)
+
 #include "../generic/common.h"
@@ -0,0 +1,82 @@
+#pragma once
+#define PICO_RP2350B 1
+
+// LEDs
+#define PIN_LED        (23u)
+
+#define PIN_NEOPIXEL   (25)
+#define NUM_NEOPIXEL   (1)
+
+// 'Boot0' button also on GPIO #24
+#define PIN_BUTTON      (24u)
+
+// USB host connector
+#define PIN_USB_HOST_DP (32u)
+#define PIN_USB_HOST_DM (33u)
+#define PIN_5V_EN       (29u)
+#define PIN_5V_EN_STATE (1u)
+
+// SDIO
+#define PIN_SD_CLK       (34u)
+#define PIN_SD_CMD_MOSI  (35u)
+#define PIN_SD_DAT0_MISO (36u)
+#define PIN_SD_DAT1      (37u)
+#define PIN_SD_DAT2      (38u)
+#define PIN_SD_DAT3_CS   (39u)
+#define PIN_SD_DETECT    (40u)
+
+#define __PIN_A0        (41u)
+#define __PIN_A1        (42u)
+#define __PIN_A2        (43u)
+#define __PIN_A3        (44u)
+#define __PIN_A4        (45u)
+#define __PIN_A5        (46u)
+
+// UARTs
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+#define PIN_SERIAL2_TX (99u) // not pinned out
+#define PIN_SERIAL2_RX (99u)
+
+// SPI
+#define __SPI0_DEVICE   spi1
+#define PIN_SPI1_MISO  (36u)
+#define PIN_SPI1_MOSI  (35u)
+#define PIN_SPI1_SCK   (34u)
+#define PIN_SPI1_SS    (39u)
+
+#define __SPI1_DEVICE   spi0
+#define PIN_SPI0_MISO  (28u)
+#define PIN_SPI0_MOSI  (31u)
+#define PIN_SPI0_SCK   (30u)
+#define PIN_SPI0_SS    (29u)
+
+// Wire
+#define __WIRE0_DEVICE i2c0
+#define PIN_WIRE0_SDA  (20u)
+#define PIN_WIRE0_SCL  (21u)
+
+#define __WIRE1_DEVICE i2c1
+#define PIN_WIRE1_SDA  (99u) // not pinned out
+#define PIN_WIRE1_SCL  (99u)
+
+#define SERIAL_HOWMANY (1u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (1u)
+
+// PSRAM
+#define RP2350_PSRAM_CS         (47u)
+#define RP2350_PSRAM_MAX_SCK_HZ (109*1000*1000)
+
+// DVI connector
+#define PIN_CKN (15u)
+#define PIN_CKP (14u)
+#define PIN_D0N (19u)
+#define PIN_D0P (18u)
+#define PIN_D1N (17u)
+#define PIN_D1P (16u)
+#define PIN_D2N (13u)
+#define PIN_D2P (12u)
+
+
+#include "../generic/common.h"
@@ -0,0 +1,58 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://datasheets.raspberrypi.org/pico/pico-datasheet.pdf
+
+#define PIN_HE0 (0u)
+
+#define PIN_FAN0 (1u)
+#define PIN_FAN1 (2u)
+#define PIN_FAN2 (3u)
+
+#define PIN_E0_DIR (4u)
+#define PIN_E0_STEP (5u)
+
+#define PIN_SERIAL1_TX (6u)
+#define PIN_E0_UART (6u)
+#define PIN_SERIAL1_RX (31u)
+#define PIN_E0_DIAG (7u)
+#define PIN_E0_EN (10u)
+
+#define PIN_CAN_RX (8u)
+#define PIN_CAN_TX (9u)
+#define PIN_SERIAL2_TX (8u)
+#define PIN_SERIAL2_RX (9u)
+
+#define PIN_3D_TOUCH (11u)
+
+//SPI
+#define PIN_SPI1_MISO  (12u)
+#define PIN_SPI1_MOSI  (15u)
+#define PIN_SPI1_SCK   (14u)
+#define PIN_SPI1_SS    (13u)
+
+#define PIN_SPI0_MISO  (16u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (17u)
+
+#define PIN_NEOPIXEL   (20u)
+#define PIN_ZPLUS      (21u)
+
+// Wire
+#define PIN_WIRE0_SDA  (22u)
+#define PIN_WIRE0_SCL  (23u)
+#define PIN_I2C_SDA  (22u)
+#define PIN_I2C_SCL  (23u)
+
+#define PIN_IO24     (24u)
+#define PIN_IO25     (25u)
+
+#define PIN_TH0      (26u)
+#define PIN_IPO29    (29u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (1u)
+
+#include "../generic/common.h"
@@ -0,0 +1,58 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://datasheets.raspberrypi.org/pico/pico-datasheet.pdf
+
+#define PIN_HE0 (0u)
+
+#define PIN_FAN0 (1u)
+#define PIN_FAN1 (2u)
+#define PIN_FAN2 (3u)
+
+#define PIN_E0_DIR (4u)
+#define PIN_E0_STEP (5u)
+
+#define PIN_SERIAL1_TX (6u)
+#define PIN_E0_UART (6u)
+#define PIN_SERIAL1_RX (31u)
+#define PIN_E0_DIAG (7u)
+#define PIN_E0_EN (10u)
+
+#define PIN_CAN_RX (8u)
+#define PIN_CAN_TX (9u)
+#define PIN_SERIAL2_TX (8u)
+#define PIN_SERIAL2_RX (9u)
+
+#define PIN_3D_TOUCH (11u)
+
+//SPI
+#define PIN_SPI1_MISO  (12u)
+#define PIN_SPI1_MOSI  (15u)
+#define PIN_SPI1_SCK   (14u)
+#define PIN_SPI1_SS    (13u)
+
+#define PIN_SPI0_MISO  (16u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (17u)
+
+#define PIN_NEOPIXEL   (20u)
+#define PIN_ZPLUS      (21u)
+
+// Wire
+#define PIN_WIRE0_SDA  (22u)
+#define PIN_WIRE0_SCL  (23u)
+#define PIN_I2C_SDA  (22u)
+#define PIN_I2C_SCL  (23u)
+
+#define PIN_IO24     (24u)
+#define PIN_IO25     (25u)
+
+#define PIN_TH0      (26u)
+#define PIN_IPO29    (29u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (1u)
+
+#include "../generic/common.h"
@@ -0,0 +1,3 @@
+#pragma once
+#define PICO_RP2350B 1
+#include "../rpipico2/pins_arduino.h"
@@ -0,0 +1,4 @@
+#pragma once
+#define PICO_RP2350B 1
+#define RP2350_PSRAM_CS 8
+#include "../rpipico2/pins_arduino.h"
@@ -1,2 +0,0 @@
-#pragma once
-#include "../rpipico/pins_arduino.h"
@@ -0,0 +1,89 @@
+#pragma once
+
+// Pin definitions taken from:
+// https://github.com/rp-rs/rp-hal-boards/blob/main/boards/pimoroni-servo2040/src/lib.rs
+
+// LEDs
+#define PIN_LED        (18u)
+#define LED_BUILTIN    PIN_LED
+
+// Digital pins
+#define SERVO1  (0u)
+#define SERVO2  (1u)
+#define SERVO3  (2u)
+#define SERVO4  (3u)
+#define SERVO5  (4u)
+#define SERVO6  (5u)
+#define SERVO7  (6u)
+#define SERVO8  (7u)
+#define SERVO9  (8u)
+#define SERVO10 (9u)
+#define SERVO11 (10u)
+#define SERVO12 (11u)
+#define SERVO13 (12u)
+#define SERVO14 (13u)
+#define SERVO15 (14u)
+#define SERVO16 (15u)
+#define SERVO17 (16u)
+#define SERVO18 (17u)
+#define USER_SW (22u)
+
+// Analog pins
+#define ADC_ADDR_0 (22u)
+#define ADC_ADDR_1 (24u)
+#define ADC_ADDR_2 (25u)
+static const uint8_t A0  = (26u);
+static const uint8_t A1  = (27u);
+static const uint8_t A2  = (28u);
+static const uint8_t A3  = (31u);
+#define ADC_SHARED A3
+#define ADC_RESOLUTION 12
+
+// NeoPixel
+#define PIN_NEOPIXEL   (15u)
+//#define NEOPIXEL_POWER (11u)
+
+// Serial1
+#define PIN_SERIAL1_TX (31u)
+#define PIN_SERIAL1_RX (31u)
+
+// Serial2 not pinned out
+#define PIN_SERIAL2_TX (31u)
+#define PIN_SERIAL2_RX (31u)
+
+// SPI
+#define PIN_SPI0_MISO  (31u)
+#define PIN_SPI0_MOSI  (31u)
+#define PIN_SPI0_SCK   (31u)
+#define PIN_SPI0_SS    (31u) // not pinned out
+//static const uint8_t SS   = PIN_SPI0_SS;   // SPI Slave SS not used. Set here only for reference.
+//static const uint8_t MOSI = PIN_SPI0_MOSI;
+//static const uint8_t MISO = PIN_SPI0_MISO;
+//static const uint8_t SCK  = PIN_SPI0_SCK;
+
+// Not pinned out
+#define PIN_SPI1_MISO  (31u)
+#define PIN_SPI1_MOSI  (31u)
+#define PIN_SPI1_SCK   (31u)
+#define PIN_SPI1_SS    (31u)
+//#define SPI_MISO       (PIN_SPI1_MISO)
+//#define SPI_MOSI       (PIN_SPI1_MOSI)
+//#define SPI_SCK        (PIN_SPI1_SCK)
+
+// Wire
+#define __WIRE0_DEVICE (i2c0)
+#define PIN_WIRE0_SDA  (20u)
+#define PIN_WIRE0_SCL  (21u)
+#define SDA            PIN_WIRE0_SDA
+#define SCL            PIN_WIRE0_SCL
+#define I2C_SDA        (SDA)
+#define I2C_SCL        (SCL)
+
+// Wire1 not pinned out
+#define __WIRE1_DEVICE (i2c1)
+#define PIN_WIRE1_SDA  (31u)
+#define PIN_WIRE1_SCL  (31u)
+
+#define SERIAL_HOWMANY (0u)
+#define SPI_HOWMANY    (0u)
+#define WIRE_HOWMANY   (1u)
@@ -53,8 +53,17 @@ static const uint8_t D18 = (9u);


 // Wire
-#define PIN_WIRE1_SDA  (16u)
-#define PIN_WIRE1_SCL  (17u)
+#define __WIRE0_DEVICE (i2c0)
+#define PIN_WIRE0_SDA  (16u)
+#define PIN_WIRE0_SCL  (17u)
+#define SDA            PIN_WIRE0_SDA
+#define SCL            PIN_WIRE0_SCL
+#define I2C_SDA        (SDA)
+#define I2C_SCL        (SCL)
+
+#define __WIRE1_DEVICE (i2c1)
+#define PIN_WIRE1_SDA  (6u)
+#define PIN_WIRE1_SCL  (7u)

 #define SERIAL_HOWMANY (3u)
 #define SPI_HOWMANY    (2u)
@@ -66,10 +75,3 @@ static const uint8_t MISO = PIN_SPI0_MISO;
 static const uint8_t SCK  = PIN_SPI0_SCK;
 static const uint8_t SS   = PIN_SPI0_SS;

-#define __WIRE0_DEVICE (i2c1)
-#define PIN_WIRE0_SDA  (6u)
-#define PIN_WIRE0_SCL  (7u)
-#define SDA            PIN_WIRE0_SDA
-#define SCL            PIN_WIRE0_SCL
-#define I2C_SDA        (SDA)
-#define I2C_SCL        (SCL)
@@ -0,0 +1,33 @@
+/*
+    pinMode and digitalRead/Write for the Raspberry Pi Pico W 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
+*/
+
+#include "Arduino.h"
+#include <cyw43_wrappers.h>
+
+extern "C" void pinMode(pin_size_t pin, PinMode mode) {
+    cyw43_pinMode(pin, mode);
+}
+
+extern "C" void digitalWrite(pin_size_t pin, PinStatus val) {
+    cyw43_digitalWrite(pin, val);
+}
+
+extern "C" PinStatus digitalRead(pin_size_t pin) {
+    return cyw43_digitalRead(pin);
+}
@@ -0,0 +1,28 @@
+/*
+    Initialize the Pico W WiFi driver
+
+    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 <cyw43_wrappers.h>
+#include "pico/cyw43_driver.h"
+
+extern "C" void initVariant() {
+    static uint cyw43_pin_array[CYW43_PIN_INDEX_WL_COUNT] = {24, 38, 38, 38, 37, 36};
+    cyw43_set_pins_wl(cyw43_pin_array);
+    init_cyw43_wifi();
+}
@@ -0,0 +1,169 @@
+#pragma once
+
+#include <stdint.h>
+#include <cyw43_wrappers.h>
+
+#define PICO_RP2350B 1
+#define PICO_RP2350A 0
+
+#define PINS_COUNT          (48u)
+#define NUM_DIGITAL_PINS    (48u)
+#define NUM_ANALOG_INPUTS   (7u)
+#define NUM_ANALOG_OUTPUTS  (0u)
+#define ADC_RESOLUTION      (12u)
+
+// LEDs
+#define PIN_LED        (25u)
+#define LED_BUILTIN    PIN_LED
+
+#define PIN_WL_LED     (64u)
+
+#define PIN_NEOPIXEL   (3u)
+#define NUM_NEOPIXEL   (1u)
+
+// Serial
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+#define PIN_SERIAL2_TX (40u)
+#define PIN_SERIAL2_RX (41u)
+
+// External SPI
+#define PIN_SPI0_MISO  (20u)
+#define PIN_SPI0_MOSI  (23u)
+#define PIN_SPI0_SCK   (22u)
+#define PIN_SPI0_SS    (21u) // CS pin for External SPI.
+
+#define PIN_SPI0_POCI  PIN_SPI0_MISO
+#define PIN_SPI0_PICO  PIN_SPI0_MOSI
+#define PIN_SPI0_CS    PIN_SPI0_SS
+
+// SD Card SPI
+#define PIN_SPI1_MISO  (8u)
+#define PIN_SPI1_MOSI  (11u)
+#define PIN_SPI1_SCK   (10u)
+#define PIN_SPI1_SS    (9u) // CS pin for SD card.
+
+#define PIN_SPI1_POCI  PIN_SPI1_MISO
+#define PIN_SPI1_PICO  PIN_SPI1_MOSI
+#define PIN_SPI1_CS    PIN_SPI1_SS
+
+// Wire
+#define PIN_WIRE0_SDA  (4u)
+#define PIN_WIRE0_SCL  (5u)
+
+#define PIN_WIRE1_SDA  (30u)
+#define PIN_WIRE1_SCL  (31u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (2u)
+#define WIRE_INTERFACES_COUNT (WIRE_HOWMANY)
+
+// PSRAM
+#define RP2350_PSRAM_CS         (47u)
+#define RP2350_PSRAM_MAX_SCK_HZ (109*1000*1000)
+
+/* Pin mappings for marked pins on the board */
+// UART0
+static const uint8_t D0 = (0u);
+static const uint8_t D1 = (1u);
+
+// I2C0
+static const uint8_t D4 = (4u);
+static const uint8_t D5 = (5u);
+
+// SD Card/SPI1
+static const uint8_t D8 = (8u);
+static const uint8_t D9 = (9u);
+static const uint8_t D10 = (10u);
+static const uint8_t D11 = (11u);
+
+// HSTX GPIO
+static const uint8_t D12 = (12u);
+static const uint8_t D13 = (13u);
+static const uint8_t D14 = (14u);
+static const uint8_t D15 = (15u);
+static const uint8_t D16 = (16u);
+static const uint8_t D17 = (17u);
+static const uint8_t D18 = (18u);
+static const uint8_t D19 = (19u);
+
+// SPI0
+static const uint8_t D20 = (20u);
+static const uint8_t D21 = (21u);
+static const uint8_t D22 = (22u);
+static const uint8_t D23 = (23u);
+
+// External GPIO
+static const uint8_t D28 = (28u);
+static const uint8_t D29 = (29u);
+static const uint8_t D30 = (30u);
+static const uint8_t D31 = (31u);
+static const uint8_t D32 = (32u);
+static const uint8_t D33 = (33u);
+static const uint8_t D34 = (34u);
+static const uint8_t D35 = (35u);
+
+// Analog Inputs are also digital capable.
+static const uint8_t D40 = (40u);
+static const uint8_t D41 = (41u);
+static const uint8_t D42 = (42u);
+static const uint8_t D43 = (43u);
+static const uint8_t D44 = (44u);
+static const uint8_t D45 = (45u);
+
+static const uint8_t A0 = (40u);
+static const uint8_t A1 = (41u);
+static const uint8_t A2 = (42u);
+static const uint8_t A3 = (43u);
+static const uint8_t A4 = (44u);
+static const uint8_t A5 = (45u);
+
+// SD Card detect - Active Low
+static const uint8_t SD_DET_N = (2u);
+
+// RGB LED data pin
+static const uint8_t RGB_LED = (3u);
+
+// Low battery alert - Active Low
+static const uint8_t BATT_ALRT_N = (6u);
+
+// Power enable for peripherals - qwiic, sd, rgb. Default HIGH via HW jumper.
+static const uint8_t PERIPHERAL_POWER_ENABLE = (7u);
+
+// WiFi power GPIO
+static const uint8_t WRL_ON = (24u);
+
+// aka STAT LED
+static const uint8_t D25 = (25u);
+
+// Power status inputs
+static const uint8_t POWER_SRC_5V = (26u);
+static const uint8_t BATT_POWER = (27u);
+
+// User button
+static const uint8_t USER_SW = (39u);
+
+// Input voltage measurement
+static const uint8_t VIN_MEAS = (46u);
+
+static const uint8_t SS = PIN_SPI0_SS;
+static const uint8_t CS = PIN_SPI0_CS;
+
+static const uint8_t MOSI = PIN_SPI0_MOSI;
+static const uint8_t PICO = PIN_SPI0_PICO;
+
+static const uint8_t MISO = PIN_SPI0_MISO;
+static const uint8_t POCI = PIN_SPI0_POCI;
+
+static const uint8_t SCK = PIN_SPI0_SCK;
+
+static const uint8_t SDA = PIN_WIRE0_SDA;
+static const uint8_t SCL = PIN_WIRE0_SCL;
+
+static const uint8_t SDA1 = PIN_WIRE1_SDA;
+static const uint8_t SCL1 = PIN_WIRE1_SCL;
+
+static const uint8_t RX = PIN_SERIAL1_RX;
+static const uint8_t TX = PIN_SERIAL1_TX;
@@ -0,0 +1,33 @@
+/*
+    pinMode and digitalRead/Write for the Raspberry Pi Pico W 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
+*/
+
+#include "Arduino.h"
+#include <cyw43_wrappers.h>
+
+extern "C" void pinMode(pin_size_t pin, PinMode mode) {
+    cyw43_pinMode(pin, mode);
+}
+
+extern "C" void digitalWrite(pin_size_t pin, PinStatus val) {
+    cyw43_digitalWrite(pin, val);
+}
+
+extern "C" PinStatus digitalRead(pin_size_t pin) {
+    return cyw43_digitalRead(pin);
+}
@@ -0,0 +1,34 @@
+/*
+    Initialize the Pico W WiFi driver
+
+    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 <cyw43_wrappers.h>
+
+extern "C" void initVariant() {
+    static uint cyw43_pin_array[CYW43_PIN_INDEX_WL_COUNT] = {
+        26, // CYW43_PIN_INDEX_WL_REG_ON
+        29, // CYW43_PIN_INDEX_WL_DATA_OUT
+        29, // CYW43_PIN_INDEX_WL_DATA_IN
+        29, // CYW43_PIN_INDEX_WL_HOST_WAKE
+        28, // CYW43_PIN_INDEX_WL_CLOCK
+        27  // CYW43_PIN_INDEX_WL_CS
+    };
+    cyw43_set_pins_wl(cyw43_pin_array);
+    init_cyw43_wifi();
+}
@@ -0,0 +1,122 @@
+#pragma once
+
+#define PICO_RP2350A 0
+
+#include <cyw43_wrappers.h>
+
+// XRP default pin names
+#define MOTOR_L_IN_1 (34u)
+#define MOTOR_L_IN_2 (35u)
+#define MOTOR_R_IN_1 (32u)
+#define MOTOR_R_IN_2 (33u)
+#define MOTOR_3_IN_1 (20u)
+#define MOTOR_3_IN_2 (21u)
+#define MOTOR_4_IN_1 (10u)
+#define MOTOR_4_IN_2 (11u)
+#define MOTOR_L_ENCODER_A (30u)
+#define MOTOR_L_ENCODER_B (31u)
+#define MOTOR_R_ENCODER_A (24u)
+#define MOTOR_R_ENCODER_B (25u)
+#define MOTOR_3_ENCODER_A (22u)
+#define MOTOR_3_ENCODER_B (23u)
+#define MOTOR_4_ENCODER_A (2u)
+#define MOTOR_4_ENCODER_B (3u)
+#define MOTOR_L_CURRENT (40u)
+#define MOTOR_R_CURRENT (43u)
+#define MOTOR_3_CURRENT (41u)
+#define MOTOR_4_CURRENT (42u)
+#define SERVO_1 (6u)
+#define SERVO_2 (9u)
+#define SERVO_3 (7u)
+#define SERVO_4 (8u)
+#define I2C_SDA_0 (4u)
+#define I2C_SCL_0 (5u)
+#define I2C_SDA_1 (38u)
+#define I2C_SCL_1 (39u)
+#define DISTANCE_TRIGGER (0u)
+#define DISTANCE_ECHO (1u)
+#define LINE_L (44u)
+#define LINE_R (45u)
+#define BOARD_VIN_MEASURE (46u)
+#define BOARD_USER_BUTTON (36u)
+#define BOARD_NEOPIXEL (37u)
+#define BOARD_LED (PIN_LED)
+
+// XRP alternate pin names
+#define ML_IN_1 (34u)
+#define ML_IN_2 (35u)
+#define MR_IN_1 (32u)
+#define MR_IN_2 (33u)
+#define M3_IN_1 (20u)
+#define M3_IN_2 (21u)
+#define M4_IN_1 (10u)
+#define M4_IN_2 (11u)
+#define ML_ENC_A (30u)
+#define ML_ENC_B (31u)
+#define MR_ENC_A (24u)
+#define MR_ENC_B (25u)
+#define M3_ENC_A (22u)
+#define M3_ENC_B (23u)
+#define M4_ENC_A (2u)
+#define M4_ENC_B (3u)
+#define ML_CUR (40u)
+#define MR_CUR (43u)
+#define M3_CUR (41u)
+#define M4_CUR (42u)
+#define S1 (6u)
+#define S2 (9u)
+#define S3 (7u)
+#define S4 (8u)
+#define SDA_0 (4u)
+#define SCL_0 (5u)
+#define SDA_1 (38u)
+#define SCL_1 (39u)
+#define RANGE_TRIGGER (0u)
+#define RANGE_ECHO (1u)
+#define REFLECTANCE_L (44u)
+#define REFLECTANCE_R (45u)
+#define BRD_VIN (46u)
+#define BRD_USR_BTN (36u)
+#define BRD_RGB_LED (37u)
+#define BRD_LED (PIN_LED)
+
+// LEDs
+#define PIN_LED        (64u)
+
+#define PIN_NEOPIXEL   (37)
+#define NUM_NEOPIXEL   (1)
+
+// Serial
+#define PIN_SERIAL1_TX (12u)
+#define PIN_SERIAL1_RX (13u)
+
+#define PIN_SERIAL2_TX (8u)
+#define PIN_SERIAL2_RX (9u)
+
+// SPI
+#define PIN_SPI0_MISO  (16u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (17u)
+
+#define PIN_SPI1_MISO  (12u)
+#define PIN_SPI1_MOSI  (15u)
+#define PIN_SPI1_SCK   (14u)
+#define PIN_SPI1_SS    (13u)
+
+// Wire
+#define PIN_WIRE0_SDA  (4u)
+#define PIN_WIRE0_SCL  (5u)
+
+#define PIN_WIRE1_SDA  (38u)
+#define PIN_WIRE1_SCL  (39u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (2u)
+
+// PSRAM
+#define RP2350_PSRAM_CS         (47u)
+#define RP2350_PSRAM_MAX_SCK_HZ (109*1000*1000)
+
+#include "../generic/common.h"
@@ -0,0 +1,33 @@
+/*
+    pinMode and digitalRead/Write for the Raspberry Pi Pico W 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
+*/
+
+#include "Arduino.h"
+#include <cyw43_wrappers.h>
+
+extern "C" void pinMode(pin_size_t pin, PinMode mode) {
+    cyw43_pinMode(pin, mode);
+}
+
+extern "C" void digitalWrite(pin_size_t pin, PinStatus val) {
+    cyw43_digitalWrite(pin, val);
+}
+
+extern "C" PinStatus digitalRead(pin_size_t pin) {
+    return cyw43_digitalRead(pin);
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Earle F. Philhower, III	49397a7f3d	Update version	2025-03-18 17:03:18 -07:00
Earle F. Philhower, III	aabbba67ce	Add some Doxygen documentation to core and libraries (#2780 )	2025-03-18 17:00:44 -07:00
Earle F. Philhower, III	50b9ea99bd	Add Olimex Pico2XL and Pico2XXL (#2868 ) Fixes #2820	2025-03-18 16:40:51 -07:00
Earle F. Philhower, III	beece2ec9d	Add <1MB FS options for multi-size boards (#2867 ) Boards with selectable flash sizes only had a 1MB FS as the smallest option on 2MB boards. For the normal Pico @ 2MB, though, we supported filesystems down to 64KB. Add those same options to the 2MB SKUs of configurable boards.	2025-03-18 16:29:54 -07:00
Earle F. Philhower, III	1a8735700f	Use flash size menu for Olimex boards (#2866 ) Remove duplicated boards with just different flash sizes. Use the flash size menu to select 2 or 16 MB units.	2025-03-18 15:26:34 -07:00
Earle F. Philhower, III	cc1af990b4	Add Pimoroni Servo2040 (#2865 ) Fixes #2730 . Untested, based off of schematics	2025-03-18 15:11:25 -07:00
Eris Fairbanks	0ec1dc6724	Bidirectional TDM Support (#2843 ) * Initial commit. * Works with AK4619 in TDM128 I2S compatibility mode set to rising BCLK. * Works with I2S compat mode with BCLK mode set to 0 on AK4619.	2025-03-14 11:35:37 -07:00
Earle F. Philhower, III	15d1c6813a	Redo UF2 discovery for Windows compatibility (#2853 ) Windows Python doesn't seem to kill the worker Thread properly when the IDE is exited, leading to a) multiple Python3 instances on a PC after many uses and b) errors updating the core when it tries to re-install Python3 while still having the older version's EXE loaded and in use. When an exception happens on the input() call under Windows, it seems like it can still leave a thread running. Add one more flag, caught in a global exception handler. Works around https://github.com/arduino/arduino-cli/issues/2867	2025-03-14 10:08:37 -07:00
Earle F. Philhower, III	cdf0a65d0f	Fix invalid overclock speeds 175 and 275 MHz (#2855 ) Fixes #2854 Change 175->176 and 275->276 in CPU speed menu to avoid panic when attempting to set a clock that wasn't exactly possible.	2025-03-13 20:18:50 -07:00
Earle F. Philhower, III	e60858c327	Update version	2025-03-11 13:35:52 -07:00
Earle F. Philhower, III	bebd1dff50	Update README.md (#2848 )	2025-03-11 13:34:08 -07:00
Earle F. Philhower, III	14145e4469	Update to SDK 2.1.2-develop (#2844 ) Supercedes #2815 Move to pico-sdk official develop branch which includes a necessary IRQ header fix. 200MHz is now default for the Pico, but 133 is still available from the menus.	2025-03-11 13:30:17 -07:00
Dryw Wade	d9d556bcd0	Add SparkFun XRP Controller (#2847 )	2025-03-11 13:00:55 -07:00
InfiniteCoder	5bd1a3a0f6	A2DP: scanAsyncDone & scanAsyncResults; fix write and availableForWrite (#2839 )	2025-03-06 10:55:56 -08:00
Earle F. Philhower, III	5bfc35caf5	Enable add'l UART_AUX pinouts for RP2350 (#2837 ) Fixes #2835. Thanks @deltaford!	2025-03-05 07:02:32 -08:00
Alex Brudner	8e1e709ab1	Add SparkFun IoT RedBoard RP2350 (#2836 )	2025-03-03 16:30:42 -08:00
Jeff Epler	46a58fb4b5	Early out of (un)maskInterrupts() if no GPIO interrupts need to be masked (#2831 ) My application is designed to generate HSTX data on core0 in interrupts, but also uses hardware SPI for SD card access. It turns out that the amount of time spent in maskInterrupts/ unmaskInterrupts, even with an empty _usingIRQs, is too long. Add a quick check and avoid touching the interrupt disable flag if there's not actually any GPIO interrupt to (un)mask.	2025-02-28 12:44:47 -08:00
Earle F. Philhower, III	8deb6b9724	Adjust the PSRAM clock when over/underclock F_SYS (#2824 ) * Adjust the PSRAM clock when over/underclock F_SYS Fixes #2818 * Need to increase PSRAM divider before sysclk increase Per datasheet, when increasing sysclk speed we need to set the qmi clocks first and do a dummy transfer to ensure no invalid speed operations happen on the bus. Handle the logic for this while setting up the overclock.	2025-02-26 16:38:52 -08:00
Jeff Epler	6236d1f7c5	Define HSTX pins on Adafruit boards with HSTX or DVI connectors (#2825 )	2025-02-25 08:36:58 -08:00
Dryw Wade	91ce323a68	Add SparkFun XRP Controller (Beta) (#2823 )	2025-02-24 12:03:55 -08:00
Earle F. Philhower, III	2f82bfd22a	Update README.md	2025-02-23 11:36:36 -08:00
Michael Ring	1689c75ef1	Support Makerbase MKSTHR36 and MKSTHR42 Boards (#2819 ) * Support Makerbase MKSTHR36 and MKSTHR42 Boards * Added missing define for PIN_SERIAL1_* for MKSTHR42 Board	2025-02-23 11:35:53 -08:00
brabl2	935eb64a8e	Added WizNet W6100 to the AdvancedWebServer example (#2812 )	2025-02-19 07:25:09 -08:00
Earle F. Philhower, III	31786cdc24	Update version	2025-02-18 12:55:03 -08:00
Earle F. Philhower, III	3d17a56ecf	Fix Wire/Wire1 definitions for Xaio RP2350 (#2811 ) Fixes #2808	2025-02-18 10:28:12 -08:00
Earle F. Philhower, III	3cb5c315f3	Correct Seeed XAIO RP2350 config (#2803 ) Fixes #2801	2025-02-15 16:15:29 -08:00
Earle F. Philhower, III	0148b1469c	Update README.md	2025-02-09 09:53:46 -08:00
Stefan NürnbergerandStefan Nuernberger	96a4059f09	added I2C TwoWire::busIdle to be checked by writeReadAsync (#2798 ) --------- Co-authored-by: Stefan Nuernberger <stefan@elexir.eu>	2025-02-09 09:52:45 -08:00
Limor "Ladyada" Fried	c3d15931a4	Add new RP2350 Metro! (#2795 )	2025-02-09 09:16:45 -08:00
Earle F. Philhower, III	c79e543c41	Move to Arduino API 10501 (#2797 ) * Move to Arduino API 10501 Track upstream Arduino API headers * IPAddress V4/V6 compatiblity restored * Fix WiFiUDP includes * String differences in example * HardwareSerial using exported	2025-02-08 22:45:10 -08:00
Stefan NürnbergerandStefan Nuernberger	3c556e6729	fixed: Wire::writeReadAsync not setting _dmaSendBufferLen, therefore allocating the DMA buffer anew on every call (#2796 ) Co-authored-by: Stefan Nuernberger <stefan@elexir.eu>	2025-02-08 14:15:18 -08:00