Update version

Fixes #537

.github/workflows/pull-request.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Run codespell
       uses: codespell-project/actions-codespell@master
       with:
-        skip: ./pico-extras,./ArduinoCore-API,./libraries/SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api
+        skip: ./pico-extras,./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api
         ignore_words_list: ser,DOUT
 
 # Consistent style
@@ -36,7 +36,7 @@ jobs:
         ./tests/ci/pkgrefs_test.sh
     - name: Check boards.txt was not edited after makeboards.py
       run: |
-        ./tools/makeboards.py > boards.txt
+        ./tools/makeboards.py
         # If anything changed, GIT should return an error and fail the test
         git diff --exit-code
     - name: Run astyle on all code/examples
@@ -46,10 +46,10 @@ jobs:
         ./tests/restyle.sh
         # If anything changed, GIT should return an error and fail the test
         git diff --exit-code
-    - name: Check Arduino API copy is clean
-      run: |
-        git submodule update --init ./ArduinoCore-API
-        diff -r ./cores/rp2040/api ./ArduinoCore-API/api
+#    - name: Check Arduino API copy is clean
+#      run: |
+#        git submodule update --init ./ArduinoCore-API
+#        diff -r ./cores/rp2040/api ./ArduinoCore-API/api
 
 # Build all examples on linux (core and Arduino IDE)
   build-linux:

.gitmodules

@@ -11,7 +11,7 @@
 	path = libraries/LittleFS/lib/littlefs
 	url = https://github.com/littlefs-project/littlefs.git
 [submodule "libraries/SdFat"]
-	path = libraries/SdFat
+	path = libraries/ESP8266SdFat
 	url = https://github.com/earlephilhower/ESP8266SdFat.git
 [submodule "pico-extras"]
 	path = pico-extras

README.md

@@ -13,15 +13,28 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 * Raspberry Pi Pico
 * Adafruit Feather RP2040
 * Adafruit ItsyBitsy RP2040
+* Adafruit KB2040
 * Adafruit Macropad RP2040
 * Adafruit QTPy RP2040
 * Adafruit STEMMA Friend RP2040
 * Adafruit Trinkey RP2040 QT
-* Arduino Nano RP2040 Connect (preliminary)
+* Arduino Nano RP2040 Connect
+* Cytron Maker Pi RP2040
+* Cytron Maker Nano RP2040
+* DeRuiLab FlyBoard2040 Core
+* DFRobot Beetle RP2040
 * Invector Labs Challenger RP2040 WiFi
+* Invector Labs Challenger NB RP2040 WiFi
 * Invector Labs Challenger RP2040 LTE
+* Invector Labs Challenger RP2040 LoRa
+* Invector Labs RPICO32
 * Melopero Shake RP2040
+* Seeed XIAO RP2040
+* Solder Party RP2040 Stamp
 * SparkFun ProMicro RP2040
+* SparkFun Thing Plus RP2040
+* uPesy RP2040 DevKit
+* WIZnet W5100S-EVB-Pico
 * Generic (configurable flash, I/O pins)
 
 # Installing via Arduino Boards Manager
@@ -72,7 +85,7 @@ If you follow Les' step-by-step you will also have a fully functional `CMake`-ba
 To upload your first sketch, you will need to hold the BOOTSEL button down while plugging in the Pico to your computer.
 Then hit the upload button and the sketch should be transferred and start to run.
 
-After the first upload, this should not be necessary as the `arduino-pico` core has auto-reset support. 
+After the first upload, this should not be necessary as the `arduino-pico` core has auto-reset support.
 Select the appropriate serial port shown in the Arduino Tools->Port->Serial Port menu once (this setting will stick and does not need to be
 touched for multiple uploads).   This selection allows the auto-reset tool to identify the proper device to reset.
 Them hit the upload button and your sketch should upload and run.
@@ -84,8 +97,8 @@ follow the initial procedure of holding the BOOTSEL button down while plugging i
 The onboard flash filesystem for the Pico, LittleFS, lets you upload a filesystem image from the sketch directory for your sketch to use.  Download the needed plugin from
 * https://github.com/earlephilhower/arduino-pico-littlefs-plugin/releases
 
-To install, follow the directions in 
-* https://github.com/earlephilhower/arduino-pico-littlefs-plugin/blob/master/README.md 
+To install, follow the directions in
+* https://github.com/earlephilhower/arduino-pico-littlefs-plugin/blob/master/README.md
 
 For detailed usage information, please check the ESP8266 repo documentation (ignore SPIFFS related notes) available at
 * https://arduino-esp8266.readthedocs.io/en/latest/filesystem.html
@@ -133,12 +146,13 @@ The installed tools include a version of OpenOCD (in the pqt-openocd directory)
 * Overclocking and underclocking from the menus
 * digitalWrite/Read, shiftIn/Out, tone, analogWrite(PWM)/Read, temperature
 * Peripherals:  SPI master, Wire(I2C) master/slave, dual UART, emulated EEPROM, I2S audio output, Servo
-* printf (i.e. debug) output over USB serial 
+* printf (i.e. debug) output over USB serial
 
 The RP2040 PIO state machines (SMs) are used to generate jitter-free:
 * Servos
 * Tones
 * I2S Output
+* Software UARTs (Serial ports)
 
 # Tutorials from Across the Web
 Here are some links to coverage and additional tutorials for using `arduino-pico`

cores/rp2040/Arduino.h

@@ -25,11 +25,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include "stdlib_noniso.h" // Wacky deprecated AVR compatibility functions
+#include "RP2040Version.h"
 #include "api/ArduinoAPI.h"
 #include "api/itoa.h" // ARM toolchain doesn't provide itoa etc, provide them
 #include <pins_arduino.h>
 #include "hardware/gpio.h" // Required for the port*Register macros
 #include "debug_internal.h"
+#include <RP2040.h> // CMSIS
 
 // Try and make the best of the old Arduino abs() macro.  When in C++, use
 // the sane std::abs() call, but for C code use their macro since stdlib abs()
@@ -69,6 +71,7 @@ void noInterrupts();
 #define portModeRegister(port)      ((volatile uint32_t*) sio_hw->gpio_oe)
 
 // ADC RP2040-specific calls
+void analogReadResolution(int bits);
 float analogReadTemp();  // Returns core temp in Centigrade
 
 // PWM RP2040-specific calls
@@ -95,7 +98,8 @@ void analogWriteResolution(int res);
 #endif
 
 #include "SerialUART.h"
-#include "RP2040.h"
+#include "RP2040Support.h"
+#include "SerialPIO.h"
 #include "Bootsel.h"
 
 // Template which will evaluate at *compile time* to a single 32b number

cores/rp2040/RP2040Support.h

@@ -94,6 +94,18 @@ public:
         // once otherIdled == false.
     }
 
+    void clear() {
+        uint32_t val;
+
+        while (queue_try_remove(&_queue[0], &val)) {
+            tight_loop_contents();
+        }
+
+        while (queue_try_remove(&_queue[1], &val)) {
+            tight_loop_contents();
+        }
+    }
+
 private:
     static void __no_inline_not_in_flash_func(_irq)() {
         multicore_fifo_clear_irq();
@@ -118,6 +130,8 @@ private:
 
 class RP2040;
 extern RP2040 rp2040;
+extern "C" void main1();
+
 class RP2040 {
 public:
     RP2040() {
@@ -172,6 +186,12 @@ public:
         fifo.resumeOtherCore();
     }
 
+    void restartCore1() {
+        multicore_reset_core1();
+        fifo.clear();
+        multicore_launch_core1(main1);
+    }
+
     // Multicore comms FIFO
     _MFIFO fifo;
 

cores/rp2040/RP2040USB.cpp

@@ -52,7 +52,6 @@ mutex_t __usb_mutex;
 #endif
 
 #define USBD_DESC_LEN (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN)
-#define USBD_MAX_POWER_MA (250)
 
 #define USBD_ITF_CDC (0) // needs 2 interfaces
 #define USBD_ITF_MAX (2)

cores/rp2040/RP2040Version.h

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

cores/rp2040/SerialPIO.cpp

@@ -0,0 +1,345 @@
+/*
+    Serial-over-PIO for the Raspberry Pi Pico RP2040
+
+    Copyright (c) 2021 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 "SerialPIO.h"
+#include "CoreMutex.h"
+#include <hardware/gpio.h>
+#include <map>
+#include "pio_uart.pio.h"
+
+
+// ------------------------------------------------------------------------
+// -- Generates a unique program for differing bit lengths
+static std::map<int, PIOProgram*> _txMap;
+static std::map<int, PIOProgram*> _rxMap;
+
+// Duplicate a program and replace the first insn with a "set x, repl"
+static pio_program_t *pio_make_uart_prog(int repl, const pio_program_t *pg) {
+    pio_program_t *p = new pio_program_t;
+    p->length = pg->length;
+    p->origin = pg->origin;
+    uint16_t *insn = (uint16_t *)malloc(p->length * 2);
+    if (!insn) {
+        delete p;
+        return nullptr;
+    }
+    memcpy(insn, pg->instructions, p->length * 2);
+    insn[0] = pio_encode_set(pio_x, repl);
+    p->instructions = insn;
+    return p;
+}
+
+static PIOProgram *_getTxProgram(int bits) {
+    auto f = _txMap.find(bits);
+    if (f == _txMap.end()) {
+        pio_program_t * p = pio_make_uart_prog(bits, &pio_tx_program);
+        _txMap.insert({bits, new PIOProgram(p)});
+        f = _txMap.find(bits);
+    }
+    return f->second;
+}
+
+static PIOProgram *_getRxProgram(int bits) {
+    auto f = _rxMap.find(bits);
+    if (f == _rxMap.end()) {
+        pio_program_t * p = pio_make_uart_prog(bits, &pio_rx_program);
+        _rxMap.insert({bits, new PIOProgram(p)});
+        f = _rxMap.find(bits);
+    }
+    return f->second;
+}
+// ------------------------------------------------------------------------
+
+// TODO - this works, but there must be a faster/better way...
+static int _parity(int bits, int data) {
+    int p = 0;
+    for (int b = 0; b < bits; b++) {
+        p ^= (data & (1 << b)) ? 1 : 0;
+    }
+    return p;
+}
+
+// We need to cache generated SerialPIOs so we can add data to them from
+// the shared handler
+static SerialPIO *_pioSP[2][4];
+static void __not_in_flash_func(_fifoIRQ)() {
+    for (int p = 0; p < 2; p++) {
+        for (int sm = 0; sm < 4; sm++) {
+            SerialPIO *s = _pioSP[p][sm];
+            if (s) {
+                s->_handleIRQ();
+                pio_interrupt_clear((p == 0) ? pio0 : pio1, sm);
+            }
+        }
+    }
+}
+
+void __not_in_flash_func(SerialPIO::_handleIRQ)() {
+    if (_rx == NOPIN) {
+        return;
+    }
+    while (!pio_sm_is_rx_fifo_empty(_rxPIO, _rxSM)) {
+        uint32_t decode = _rxPIO->rxf[_rxSM];
+        decode >>= 32 - _rxBits;
+        uint32_t val = 0;
+        for (int b = 0; b < _bits + 1; b++) {
+            val |= (decode & (1 << (b * 2))) ? 1 << b : 0;
+        }
+        if (_parity == UART_PARITY_EVEN) {
+            int p = ::_parity(_bits, val);
+            int r = (val & (1 << _bits)) ? 1 : 0;
+            if (p != r) {
+                // TODO - parity error
+                continue;
+            }
+        } else if (_parity == UART_PARITY_ODD) {
+            int p = ::_parity(_bits, val);
+            int r = (val & (1 << _bits)) ? 1 : 0;
+            if (p == r) {
+                // TODO - parity error
+                continue;
+            }
+        }
+
+        auto next_writer = _writer + 1;
+        if (next_writer == _fifoSize) {
+            next_writer = 0;
+        }
+        if (next_writer != _reader) {
+            _queue[_writer] = val & ((1 << _bits) -  1);
+            asm volatile("" ::: "memory"); // Ensure the queue is written before the written count advances
+            _writer = next_writer;
+        } else {
+            // TODO: Overflow
+        }
+    }
+}
+
+SerialPIO::SerialPIO(pin_size_t tx, pin_size_t rx, size_t fifoSize) {
+    _tx = tx;
+    _rx = rx;
+    _fifoSize = fifoSize + 1; // Always one unused entry
+    _queue = new uint8_t[_fifoSize];
+    mutex_init(&_mutex);
+}
+
+SerialPIO::~SerialPIO() {
+    end();
+    delete[] _queue;
+}
+
+void SerialPIO::begin(unsigned long baud, uint16_t config) {
+    _baud = baud;
+    switch (config & SERIAL_PARITY_MASK) {
+    case SERIAL_PARITY_EVEN:
+        _parity = UART_PARITY_EVEN;
+        break;
+    case SERIAL_PARITY_ODD:
+        _parity = UART_PARITY_ODD;
+        break;
+    default:
+        _parity = UART_PARITY_NONE;
+        break;
+    }
+    switch (config & SERIAL_STOP_BIT_MASK) {
+    case SERIAL_STOP_BIT_1:
+        _stop = 1;
+        break;
+    default:
+        _stop = 2;
+        break;
+    }
+    switch (config & SERIAL_DATA_MASK) {
+    case SERIAL_DATA_5:
+        _bits = 5;
+        break;
+    case SERIAL_DATA_6:
+        _bits = 6;
+        break;
+    case SERIAL_DATA_7:
+        _bits = 7;
+        break;
+    default:
+        _bits = 8;
+        break;
+    }
+
+    if ((_tx == NOPIN) && (_rx == NOPIN)) {
+        DEBUGCORE("ERROR: No pins specified for SerialPIO\n");
+        return;
+    }
+
+    if (_tx != NOPIN) {
+        _txBits = _bits + _stop + (_parity != UART_PARITY_NONE ? 1 : 0) + 1/*start bit*/;
+        _txPgm = _getTxProgram(_txBits);
+        int off;
+        if (!_txPgm->prepare(&_txPIO, &_txSM, &off)) {
+            DEBUGCORE("ERROR: Unable to allocate PIO TX UART, out of PIO resources\n");
+            // ERROR, no free slots
+            return;
+        }
+
+        digitalWrite(_tx, HIGH);
+        pinMode(_tx, OUTPUT);
+
+        pio_tx_program_init(_txPIO, _txSM, off, _tx);
+        pio_sm_clear_fifos(_txPIO, _txSM); // Remove any existing data
+
+        // Put the divider into ISR w/o using up program space
+        pio_sm_put_blocking(_txPIO, _txSM, clock_get_hz(clk_sys) / _baud - 2);
+        pio_sm_exec(_txPIO, _txSM, pio_encode_pull(false, false));
+        pio_sm_exec(_txPIO, _txSM, pio_encode_mov(pio_isr, pio_osr));
+
+        // Start running!
+        pio_sm_set_enabled(_txPIO, _txSM, true);
+    }
+    if (_rx != NOPIN) {
+        _writer = 0;
+        _reader = 0;
+
+        _rxBits = 2 * (_bits + _stop + (_parity != UART_PARITY_NONE ? 1 : 0) + 1) - 1;
+        _rxPgm = _getRxProgram(_rxBits);
+        int off;
+        if (!_rxPgm->prepare(&_rxPIO, &_rxSM, &off)) {
+            DEBUGCORE("ERROR: Unable to allocate PIO RX UART, out of PIO resources\n");
+            return;
+        }
+        // Stash away the created RX port for the IRQ handler
+        _pioSP[pio_get_index(_rxPIO)][_rxSM] = this;
+
+        pinMode(_rx, INPUT);
+        pio_rx_program_init(_rxPIO, _rxSM, off, _rx);
+        pio_sm_clear_fifos(_rxPIO, _rxSM); // Remove any existing data
+
+        // Put phase divider into OSR w/o using add'l program memory
+        pio_sm_put_blocking(_rxPIO, _rxSM, clock_get_hz(clk_sys) / (_baud * 2) - 2);
+        pio_sm_exec(_rxPIO, _rxSM, pio_encode_pull(false, false));
+
+        // Join the TX FIFO to the RX one now that we don't need it
+        _rxPIO->sm[_rxSM].shiftctrl |= 0x80000000;
+
+        // Enable interrupts on rxfifo
+        switch (_rxSM) {
+        case 0: pio_set_irq0_source_enabled(_rxPIO, pis_sm0_rx_fifo_not_empty, true); break;
+        case 1: pio_set_irq0_source_enabled(_rxPIO, pis_sm1_rx_fifo_not_empty, true); break;
+        case 2: pio_set_irq0_source_enabled(_rxPIO, pis_sm2_rx_fifo_not_empty, true); break;
+        case 3: pio_set_irq0_source_enabled(_rxPIO, pis_sm3_rx_fifo_not_empty, true); break;
+        }
+        auto irqno = pio_get_index(_rxPIO) == 0 ? PIO0_IRQ_0 : PIO1_IRQ_0;
+        irq_set_exclusive_handler(irqno, _fifoIRQ);
+        irq_set_enabled(irqno, true);
+
+        pio_sm_set_enabled(_rxPIO, _rxSM, true);
+    }
+
+    _running = true;
+}
+
+void SerialPIO::end() {
+    if (!_running) {
+        return;
+    }
+    // TODO: Deallocate PIO resources, stop them
+    _pioSP[pio_get_index(_rxPIO)][_rxSM] = nullptr;
+    _running = false;
+}
+
+int SerialPIO::peek() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_rx == NOPIN)) {
+        return -1;
+    }
+    // If there's something in the FIFO now, just peek at it
+    if (_writer != _reader) {
+        return _queue[_reader];
+    }
+    return -1;
+}
+
+int SerialPIO::read() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_rx == NOPIN)) {
+        return -1;
+    }
+    if (_writer != _reader) {
+        auto ret = _queue[_reader];
+        asm volatile("" ::: "memory"); // Ensure the value is read before advancing
+        auto next_reader = (_reader + 1) % _fifoSize;
+        asm volatile("" ::: "memory"); // Ensure the reader value is only written once, correctly
+        _reader = next_reader;
+        return ret;
+    }
+    return -1;
+}
+
+int SerialPIO::available() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_rx == NOPIN)) {
+        return 0;
+    }
+    return (_writer - _reader) % _fifoSize;
+}
+
+int SerialPIO::availableForWrite() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_tx == NOPIN)) {
+        return 0;
+    }
+    return 8 - pio_sm_get_tx_fifo_level(_txPIO, _txSM);
+}
+
+void SerialPIO::flush() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_tx == NOPIN)) {
+        return;
+    }
+    while (!pio_sm_is_tx_fifo_empty(_txPIO, _txSM)) {
+        delay(1); // Wait for all FIFO to be read
+    }
+    // Could have 1 byte being transmitted, so wait for bit times
+    delay((1000 * (_txBits + 1)) / _baud);
+}
+
+size_t SerialPIO::write(uint8_t c) {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_tx == NOPIN)) {
+        return 0;
+    }
+
+    uint32_t val = c;
+    if (_parity == UART_PARITY_NONE) {
+        val |= 7 << _bits; // Set 2 stop bits, the HW will only transmit the required number
+    } else if (_parity == UART_PARITY_EVEN) {
+        val |= ::_parity(_bits, c) << _bits;
+        val |= 7 << (_bits + 1);
+    } else {
+        val |= (1 ^ ::_parity(_bits, c)) << _bits;
+        val |= 7 << (_bits + 1);
+    }
+    val <<= 1;  // Start bit = low
+
+    pio_sm_put_blocking(_txPIO, _txSM, val);
+
+    return 1;
+}
+
+SerialPIO::operator bool() {
+    return _running;
+}

cores/rp2040/SerialPIO.h

@@ -0,0 +1,80 @@
+/*
+    Serial-over-PIO for the Raspberry Pi Pico RP2040
+
+    Copyright (c) 2021 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+#include <Arduino.h>
+#include "api/HardwareSerial.h"
+#include <stdarg.h>
+#include <queue>
+#include <hardware/uart.h>
+#include "CoreMutex.h"
+
+extern "C" typedef struct uart_inst uart_inst_t;
+
+class SerialPIO : public 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);
+    ~SerialPIO();
+
+    void begin(unsigned long baud = 115200) override {
+        begin(baud, SERIAL_8N1);
+    };
+    void begin(unsigned long baud, uint16_t config) override;
+    void end() override;
+
+    virtual int peek() override;
+    virtual int read() override;
+    virtual int available() override;
+    virtual int availableForWrite() override;
+    virtual void flush() override;
+    virtual size_t write(uint8_t c) override;
+    using Print::write;
+    operator bool() override;
+
+    // Not to be called by users, only from the IRQ handler.  In public so that the C-language IQR callback can access it
+    void _handleIRQ();
+
+private:
+    bool _running = false;
+    pin_size_t _tx, _rx;
+    int _baud;
+    int _bits;
+    uart_parity_t _parity;
+    int _stop;
+    mutex_t _mutex;
+
+    PIOProgram *_txPgm;
+    PIO _txPIO;
+    int _txSM;
+    int _txBits;
+
+    PIOProgram *_rxPgm;
+    PIO _rxPIO;
+    int _rxSM;
+    int _rxBits;
+
+    // Lockless, IRQ-handled circular queue
+    size_t   _fifoSize;
+    uint32_t _writer;
+    uint32_t _reader;
+    uint8_t  *_queue;
+};

cores/rp2040/SerialUART.cpp

@@ -65,46 +65,173 @@ bool SerialUART::setTX(pin_size_t pin) {
     return false;
 }
 
-SerialUART::SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx) {
+bool SerialUART::setRTS(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({3, 15, 19}) /* UART0 */,
+                                    __bitset({7, 11, 23, 27})  /* UART1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[uart_get_index(_uart)])) {
+        _rts = pin;
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set Serial%d.RTS while running", uart_get_index(_uart) + 1);
+    } else {
+        panic("FATAL: Attempting to set Serial%d.RTS to illegal pin %d", uart_get_index(_uart) + 1, pin);
+    }
+    return false;
+}
+
+bool SerialUART::setCTS(pin_size_t pin) {
+    constexpr uint32_t valid[2] = { __bitset({2, 14, 18}) /* UART0 */,
+                                    __bitset({6, 10, 22, 26})  /* UART1 */
+                                  };
+    if ((!_running) && ((1 << pin) & valid[uart_get_index(_uart)])) {
+        _cts = pin;
+        return true;
+    }
+
+    if (_running) {
+        panic("FATAL: Attempting to set Serial%d.CTS while running", uart_get_index(_uart) + 1);
+    } else {
+        panic("FATAL: Attempting to set Serial%d.CTS to illegal pin %d", uart_get_index(_uart) + 1, pin);
+    }
+    return false;
+}
+bool SerialUART::setPollingMode(bool mode) {
+    if (_running) {
+        return false;
+    }
+    _polling = mode;
+    return true;
+}
+
+bool SerialUART::setFIFOSize(size_t size) {
+    if (!size || _running) {
+        return false;
+    }
+    _fifoSize = size + 1; // Always 1 unused entry
+    return true;
+}
+
+SerialUART::SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx, pin_size_t rts, pin_size_t cts) {
     _uart = uart;
     _tx = tx;
     _rx = rx;
+    _rts = rts;
+    _cts = cts;
     mutex_init(&_mutex);
+    mutex_init(&_fifoMutex);
 }
 
+static void _uart0IRQ();
+static void _uart1IRQ();
+
 void SerialUART::begin(unsigned long baud, uint16_t config) {
+    if (_running) {
+        end();
+    }
+    _queue = new uint8_t[_fifoSize];
     _baud = baud;
     uart_init(_uart, baud);
     int bits, stop;
     uart_parity_t parity;
     switch (config & SERIAL_PARITY_MASK) {
-    case SERIAL_PARITY_EVEN: parity = UART_PARITY_EVEN; break;
-    case SERIAL_PARITY_ODD: parity = UART_PARITY_ODD; break;
-    default: parity = UART_PARITY_NONE; break;
+    case SERIAL_PARITY_EVEN:
+        parity = UART_PARITY_EVEN;
+        break;
+    case SERIAL_PARITY_ODD:
+        parity = UART_PARITY_ODD;
+        break;
+    default:
+        parity = UART_PARITY_NONE;
+        break;
     }
     switch (config & SERIAL_STOP_BIT_MASK) {
-    case SERIAL_STOP_BIT_1: stop = 1; break;
-    default: stop = 2; break;
+    case SERIAL_STOP_BIT_1:
+        stop = 1;
+        break;
+    default:
+        stop = 2;
+        break;
     }
     switch (config & SERIAL_DATA_MASK) {
-    case SERIAL_DATA_5: bits = 5; break;
-    case SERIAL_DATA_6: bits = 6; break;
-    case SERIAL_DATA_7: bits = 7; break;
-    default: bits = 8; break;
+    case SERIAL_DATA_5:
+        bits = 5;
+        break;
+    case SERIAL_DATA_6:
+        bits = 6;
+        break;
+    case SERIAL_DATA_7:
+        bits = 7;
+        break;
+    default:
+        bits = 8;
+        break;
     }
     uart_set_format(_uart, bits, stop, parity);
     gpio_set_function(_tx, GPIO_FUNC_UART);
     gpio_set_function(_rx, GPIO_FUNC_UART);
+    if (_rts != UART_PIN_NOT_DEFINED) {
+        gpio_set_function(_rts, GPIO_FUNC_UART);
+    }
+    if (_cts != UART_PIN_NOT_DEFINED) {
+        gpio_set_function(_cts, GPIO_FUNC_UART);
+    }
+    uart_set_hw_flow(_uart, _rts != UART_PIN_NOT_DEFINED, _cts != UART_PIN_NOT_DEFINED);
+    _writer = 0;
+    _reader = 0;
+
+    if (!_polling) {
+        if (_uart == uart0) {
+            irq_set_exclusive_handler(UART0_IRQ, _uart0IRQ);
+            irq_set_enabled(UART0_IRQ, true);
+        } else {
+            irq_set_exclusive_handler(UART1_IRQ, _uart1IRQ);
+            irq_set_enabled(UART1_IRQ, true);
+        }
+        // Set the IRQ enables and FIFO level to minimum
+        uart_set_irq_enables(_uart, true, false);
+    } else {
+        // Polling mode has no IRQs used
+    }
     _running = true;
-    _peek = -1;
 }
 
 void SerialUART::end() {
     if (!_running) {
         return;
     }
-    uart_deinit(_uart);
     _running = false;
+    if (!_polling) {
+        if (_uart == uart0) {
+            irq_set_enabled(UART0_IRQ, false);
+        } else {
+            irq_set_enabled(UART1_IRQ, false);
+        }
+    }
+    // Paranoia - ensure nobody else is using anything here at the same time
+    mutex_enter_blocking(&_mutex);
+    mutex_enter_blocking(&_fifoMutex);
+    uart_deinit(_uart);
+    delete[] _queue;
+    // Reset the mutexes once all is off/cleaned up
+    mutex_exit(&_fifoMutex);
+    mutex_exit(&_mutex);
+}
+
+void SerialUART::_pumpFIFO() {
+    // Use the _fifoMutex to guard against the other core potentially
+    // running the IRQ (since we can't disable their IRQ handler).
+    // We guard against this core by disabling the IRQ handler and
+    // re-enabling if it was previously enabled at the end.
+    auto irqno = (_uart == uart0) ? UART0_IRQ : UART1_IRQ;
+    bool enabled = irq_is_enabled(irqno);
+    irq_set_enabled(irqno, false);
+    mutex_enter_blocking(&_fifoMutex);
+    _handleIRQ(false);
+    mutex_exit(&_fifoMutex);
+    irq_set_enabled(irqno, enabled);
 }
 
 int SerialUART::peek() {
@@ -112,15 +239,15 @@ int SerialUART::peek() {
     if (!_running || !m) {
         return -1;
     }
-    if (_peek >= 0) {
-        return _peek;
-    }
-    if (uart_is_readable_within_us(_uart, _timeout * 1000)) {
-        _peek = uart_getc(_uart);
+    if (_polling) {
+        _handleIRQ(false);
     } else {
-        _peek = -1; // Timeout
+        _pumpFIFO();
     }
-    return _peek;
+    if (_writer != _reader) {
+        return _queue[_reader];
+    }
+    return -1;
 }
 
 int SerialUART::read() {
@@ -128,16 +255,20 @@ int SerialUART::read() {
     if (!_running || !m) {
         return -1;
     }
-    if (_peek >= 0) {
-        int ret = _peek;
-        _peek = -1;
+    if (_polling) {
+        _handleIRQ(false);
+    } else {
+        _pumpFIFO();
+    }
+    if (_writer != _reader) {
+        auto ret = _queue[_reader];
+        asm volatile("" ::: "memory"); // Ensure the value is read before advancing
+        auto next_reader = (_reader + 1) % _fifoSize;
+        asm volatile("" ::: "memory"); // Ensure the reader value is only written once, correctly
+        _reader = next_reader;
         return ret;
     }
-    if (uart_is_readable_within_us(_uart, _timeout * 1000)) {
-        return uart_getc(_uart);
-    } else {
-        return -1; // Timeout
-    }
+    return -1;
 }
 
 int SerialUART::available() {
@@ -145,7 +276,12 @@ int SerialUART::available() {
     if (!_running || !m) {
         return 0;
     }
-    return (uart_is_readable(_uart)) ? 1 : 0;
+    if (_polling) {
+        _handleIRQ(false);
+    } else {
+        _pumpFIFO();
+    }
+    return (_writer - _reader) % _fifoSize;
 }
 
 int SerialUART::availableForWrite() {
@@ -153,6 +289,9 @@ int SerialUART::availableForWrite() {
     if (!_running || !m) {
         return 0;
     }
+    if (_polling) {
+        _handleIRQ(false);
+    }
     return (uart_is_writable(_uart)) ? 1 : 0;
 }
 
@@ -161,6 +300,9 @@ void SerialUART::flush() {
     if (!_running || !m) {
         return;
     }
+    if (_polling) {
+        _handleIRQ(false);
+    }
     uart_tx_wait_blocking(_uart);
 }
 
@@ -169,6 +311,9 @@ size_t SerialUART::write(uint8_t c) {
     if (!_running || !m) {
         return 0;
     }
+    if (_polling) {
+        _handleIRQ(false);
+    }
     uart_putc_raw(_uart, c);
     return 1;
 }
@@ -178,6 +323,9 @@ size_t SerialUART::write(const uint8_t *p, size_t len) {
     if (!_running || !m) {
         return 0;
     }
+    if (_polling) {
+        _handleIRQ(false);
+    }
     size_t cnt = len;
     while (cnt) {
         uart_putc_raw(_uart, *p);
@@ -191,8 +339,17 @@ SerialUART::operator bool() {
     return _running;
 }
 
+#if defined(PIN_SERIAL1_RTS)
+SerialUART Serial1(uart0, PIN_SERIAL1_TX, PIN_SERIAL1_RX, PIN_SERIAL1_RTS, PIN_SERIAL1_CTS);
+#else
 SerialUART Serial1(uart0, PIN_SERIAL1_TX, PIN_SERIAL1_RX);
+#endif
+
+#if defined(PIN_SERIAL2_RTS)
+SerialUART Serial2(uart1, PIN_SERIAL2_TX, PIN_SERIAL2_RX, PIN_SERIAL2_RTS, PIN_SERIAL2_CTS);
+#else
 SerialUART Serial2(uart1, PIN_SERIAL2_TX, PIN_SERIAL2_RX);
+#endif
 
 void arduino::serialEvent1Run(void) {
     if (serialEvent1 && Serial1.available()) {
@@ -205,3 +362,43 @@ void arduino::serialEvent2Run(void) {
         serialEvent2();
     }
 }
+
+// IRQ handler, called when FIFO > 1/8 full or when it had held unread data for >32 bit times
+void __not_in_flash_func(SerialUART::_handleIRQ)(bool inIRQ) {
+    if (inIRQ) {
+        uint32_t owner;
+        if (!mutex_try_enter(&_fifoMutex, &owner)) {
+            // Main app on the other core has the mutex so it is
+            // in the process of pulling data out of the HW FIFO
+            return;
+        }
+    }
+    // ICR is write-to-clear
+    uart_get_hw(_uart)->icr = UART_UARTICR_RTIC_BITS | UART_UARTICR_RXIC_BITS;
+    while (uart_is_readable(_uart)) {
+        auto val = uart_getc(_uart);
+        auto next_writer = _writer + 1;
+        if (next_writer == _fifoSize) {
+            next_writer = 0;
+        }
+        if (next_writer != _reader) {
+            _queue[_writer] = val;
+            asm volatile("" ::: "memory"); // Ensure the queue is written before the written count advances
+            // Avoid using division or mod because the HW divider could be in use
+            _writer = next_writer;
+        } else {
+            // TODO: Overflow
+        }
+    }
+    if (inIRQ) {
+        mutex_exit(&_fifoMutex);
+    }
+}
+
+static void __not_in_flash_func(_uart0IRQ)() {
+    Serial1._handleIRQ();
+}
+
+static void __not_in_flash_func(_uart1IRQ)() {
+    Serial2._handleIRQ();
+}

cores/rp2040/SerialUART.h

@@ -23,22 +23,28 @@
 #include <Arduino.h>
 #include "api/HardwareSerial.h"
 #include <stdarg.h>
+#include <queue>
 #include "CoreMutex.h"
 
 extern "C" typedef struct uart_inst uart_inst_t;
 
+#define UART_PIN_NOT_DEFINED      (255u)
 class SerialUART : public HardwareSerial {
 public:
-    SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx);
+    SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx, pin_size_t rts = UART_PIN_NOT_DEFINED, pin_size_t cts = UART_PIN_NOT_DEFINED);
 
     // Select the pinout.  Call before .begin()
     bool setRX(pin_size_t pin);
     bool setTX(pin_size_t pin);
+    bool setRTS(pin_size_t pin);
+    bool setCTS(pin_size_t pin);
     bool setPinout(pin_size_t tx, pin_size_t rx) {
         bool ret = setRX(rx);
         ret &= setTX(tx);
         return ret;
     }
+    bool setFIFOSize(size_t size);
+    bool setPollingMode(bool mode = true);
 
     void begin(unsigned long baud = 115200) override {
         begin(baud, SERIAL_8N1);
@@ -56,13 +62,25 @@ public:
     using Print::write;
     operator bool() override;
 
+    // Not to be called by users, only from the IRQ handler.  In public so that the C-language IQR callback can access it
+    void _handleIRQ(bool inIRQ = true);
+
 private:
     bool _running = false;
     uart_inst_t *_uart;
     pin_size_t _tx, _rx;
+    pin_size_t _rts, _cts;
     int _baud;
-    int _peek;
     mutex_t _mutex;
+    bool _polling = false;
+
+    // Lockless, IRQ-handled circular queue
+    uint32_t _writer;
+    uint32_t _reader;
+    size_t   _fifoSize = 32;
+    uint8_t *_queue;
+    mutex_t  _fifoMutex; // Only needed when non-IRQ updates _writer
+    void _pumpFIFO(); // User space FIFO transfer
 };
 
 extern SerialUART Serial1; // HW UART 0

cores/rp2040/api/Common.h

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

cores/rp2040/api/deprecated-avr-comp/avr/pgmspace.h

@@ -110,11 +110,23 @@ typedef const void* uint_farptr_t;
 #define pgm_read_ptr(addr) (*(void *const *)(addr))
 #else
 // Supports misaligned addresses
-#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
-#define pgm_read_word(addr) ((unsigned short)(pgm_read_byte((intptr_t)addr) | (pgm_read_byte((intptr_t)addr + 1) << 8)))
-#define pgm_read_dword(addr) ((unsigned long)(pgm_read_byte((intptr_t)addr) | (pgm_read_byte((intptr_t)addr + 1) << 8)) | \
-                                             (pgm_read_byte((intptr_t)addr + 2) << 16) | (pgm_read_byte((intptr_t)addr + 3) << 24))
-#define pgm_read_ptr(addr) ((void *)pgm_read_dword(addr))
+#ifdef __cplusplus
+extern "C"{
+#endif
+static inline unsigned char pgm_read_byte(const void *addr) {
+    return *(const unsigned char *)(addr);
+}
+static inline unsigned short pgm_read_word(const void *addr) {
+    const unsigned char *a = (const unsigned char *)addr;
+    return pgm_read_byte(a) | ( pgm_read_byte(a + 1) << 8 );
+}
+static inline unsigned long pgm_read_dword(const void *addr) {
+    const unsigned char *a = (const unsigned char *)addr;
+    return pgm_read_byte(a) | ( pgm_read_byte(a + 1) << 8 ) | ( pgm_read_byte(a + 2) << 16 ) | ( pgm_read_byte(a + 3) << 24 );
+}
+static inline void *pgm_read_ptr(const void *addr) {
+    return (void*) pgm_read_dword(addr);
+}
 static inline float pgm_read_float(const void *addr) {
     union {
         void *p;
@@ -123,6 +135,10 @@ static inline float pgm_read_float(const void *addr) {
     x.p = pgm_read_ptr(addr);
     return x.f;
 }
+#ifdef __cplusplus
+}
+#endif
+
 #endif
 
 #define pgm_read_byte_near(addr) pgm_read_byte(addr)

cores/rp2040/main.cpp

@@ -41,7 +41,7 @@ void initVariant() { }
 // Optional 2nd core setup and loop
 extern void setup1() __attribute__((weak));
 extern void loop1() __attribute__((weak));
-static void main1() {
+extern "C" void main1() {
     rp2040.fifo.registerCore();
     if (setup1) {
         setup1();

cores/rp2040/pio_uart.pio

@@ -0,0 +1,109 @@
+; pio_uart for the Raspberry Pi Pico RP2040
+;
+; Based loosely off of the uart_rx/_tx examples in the pico-examples repo,
+; but heavily modified and optimized to not require changing the PIO
+; clocks so that Tone and Servo won't be affected, and multiple different
+; PIO ports can be run at different baud at the same time.
+;
+; Copyright (c) 2021 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
+
+
+
+.program pio_tx
+.side_set 1 opt
+
+; We shift out the start and stop bit as part of the FIFO
+    set x, 9
+
+    pull               side 1 ; Force stop bit
+
+; Send the bits
+bitloop:
+    out pins, 1
+    mov y, isr                ; ISR is loaded by the setup routine with the period-1 count
+wait_bit:
+    jmp y-- wait_bit
+    jmp x-- bitloop
+
+    
+
+% c-sdk {
+
+static inline void pio_tx_program_init(PIO pio, uint sm, uint offset, uint pin_tx) {
+    // Tell PIO to initially drive output-high on the selected pin, then map PIO
+    // onto that pin with the IO muxes.
+    pio_sm_set_pins_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx);
+    pio_sm_set_pindirs_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx);
+    pio_gpio_init(pio, pin_tx);
+
+    pio_sm_config c = pio_tx_program_get_default_config(offset);
+
+    // OUT shifts to right, no autopull
+    sm_config_set_out_shift(&c, true, false, 32);
+
+    // We are mapping both OUT and side-set to the same pin, because sometimes
+    // we need to assert user data onto the pin (with OUT) and sometimes
+    // assert constant values (start/stop bit)
+    sm_config_set_out_pins(&c, pin_tx, 1);
+    sm_config_set_sideset_pins(&c, pin_tx);
+
+    // We only need TX, so get an 8-deep FIFO!
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);
+
+    pio_sm_init(pio, sm, offset, &c);
+}
+
+%}
+
+
+.program pio_rx
+
+; IN pin 0 and JMP pin are both mapped to the GPIO used as UART RX.
+
+start:
+    set x, 18           ; Preload bit counter...we'll shift in the start bit and stop bit, and each bit will be double-recorded (to be fixed by RP2040 code)
+    wait 0 pin 0        ; Stall until start bit is asserted
+
+bitloop:
+   ; Delay until 1/2 way into the bit time
+    mov y, osr
+wait_half:
+    jmp y-- wait_half
+
+    ; Read in the bit
+    in pins, 1          ; Shift data bit into ISR
+    jmp x-- bitloop     ; Loop all bits
+    
+    push                ; Stuff it and wait for next start
+
+
+% c-sdk {
+static inline void pio_rx_program_init(PIO pio, uint sm, uint offset, uint pin) {
+    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false);
+    pio_gpio_init(pio, pin);
+    gpio_pull_up(pin);
+
+    pio_sm_config c = pio_rx_program_get_default_config(offset);
+    sm_config_set_in_pins(&c, pin); // for WAIT, IN
+    sm_config_set_jmp_pin(&c, pin); // for JMP
+    // Shift to right, autopull disabled
+    sm_config_set_in_shift(&c, true, false, 32);
+
+    pio_sm_init(pio, sm, offset, &c);
+}
+
+%}

cores/rp2040/pio_uart.pio.h

@@ -0,0 +1,107 @@
+// -------------------------------------------------- //
+// This file is autogenerated by pioasm; do not edit! //
+// -------------------------------------------------- //
+
+#if !PICO_NO_HARDWARE
+#include "hardware/pio.h"
+#endif
+
+// ------ //
+// pio_tx //
+// ------ //
+
+#define pio_tx_wrap_target 0
+#define pio_tx_wrap 5
+
+static const uint16_t pio_tx_program_instructions[] = {
+    //     .wrap_target
+    0xe029, //  0: set    x, 9
+    0x98a0, //  1: pull   block           side 1
+    0x6001, //  2: out    pins, 1
+    0xa046, //  3: mov    y, isr
+    0x0084, //  4: jmp    y--, 4
+    0x0042, //  5: jmp    x--, 2
+    //     .wrap
+};
+
+#if !PICO_NO_HARDWARE
+static const struct pio_program pio_tx_program = {
+    .instructions = pio_tx_program_instructions,
+    .length = 6,
+    .origin = -1,
+};
+
+static inline pio_sm_config pio_tx_program_get_default_config(uint offset) {
+    pio_sm_config c = pio_get_default_sm_config();
+    sm_config_set_wrap(&c, offset + pio_tx_wrap_target, offset + pio_tx_wrap);
+    sm_config_set_sideset(&c, 2, true, false);
+    return c;
+}
+
+static inline void pio_tx_program_init(PIO pio, uint sm, uint offset, uint pin_tx) {
+    // Tell PIO to initially drive output-high on the selected pin, then map PIO
+    // onto that pin with the IO muxes.
+    pio_sm_set_pins_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx);
+    pio_sm_set_pindirs_with_mask(pio, sm, 1u << pin_tx, 1u << pin_tx);
+    pio_gpio_init(pio, pin_tx);
+    pio_sm_config c = pio_tx_program_get_default_config(offset);
+    // OUT shifts to right, no autopull
+    sm_config_set_out_shift(&c, true, false, 32);
+    // We are mapping both OUT and side-set to the same pin, because sometimes
+    // we need to assert user data onto the pin (with OUT) and sometimes
+    // assert constant values (start/stop bit)
+    sm_config_set_out_pins(&c, pin_tx, 1);
+    sm_config_set_sideset_pins(&c, pin_tx);
+    // We only need TX, so get an 8-deep FIFO!
+    sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX);
+    pio_sm_init(pio, sm, offset, &c);
+}
+
+#endif
+
+// ------ //
+// pio_rx //
+// ------ //
+
+#define pio_rx_wrap_target 0
+#define pio_rx_wrap 6
+
+static const uint16_t pio_rx_program_instructions[] = {
+    //     .wrap_target
+    0xe032, //  0: set    x, 18
+    0x2020, //  1: wait   0 pin, 0
+    0xa047, //  2: mov    y, osr
+    0x0083, //  3: jmp    y--, 3
+    0x4001, //  4: in     pins, 1
+    0x0042, //  5: jmp    x--, 2
+    0x8020, //  6: push   block
+    //     .wrap
+};
+
+#if !PICO_NO_HARDWARE
+static const struct pio_program pio_rx_program = {
+    .instructions = pio_rx_program_instructions,
+    .length = 7,
+    .origin = -1,
+};
+
+static inline pio_sm_config pio_rx_program_get_default_config(uint offset) {
+    pio_sm_config c = pio_get_default_sm_config();
+    sm_config_set_wrap(&c, offset + pio_rx_wrap_target, offset + pio_rx_wrap);
+    return c;
+}
+
+static inline void pio_rx_program_init(PIO pio, uint sm, uint offset, uint pin) {
+    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false);
+    pio_gpio_init(pio, pin);
+    gpio_pull_up(pin);
+    pio_sm_config c = pio_rx_program_get_default_config(offset);
+    sm_config_set_in_pins(&c, pin); // for WAIT, IN
+    sm_config_set_jmp_pin(&c, pin); // for JMP
+    // Shift to right, autopull disabled
+    sm_config_set_in_shift(&c, true, false, 32);
+    pio_sm_init(pio, sm, offset, &c);
+}
+
+#endif
+

cores/rp2040/wiring_analog.cpp

@@ -117,6 +117,7 @@ extern "C" void analogWrite(pin_size_t pin, int val) {
 }
 
 auto_init_mutex(_adcMutex);
+static int _readBits = 10;
 
 extern "C" int analogRead(pin_size_t pin) {
     CoreMutex m(&_adcMutex);
@@ -133,7 +134,7 @@ extern "C" int analogRead(pin_size_t pin) {
     }
     adc_gpio_init(pin);
     adc_select_input(pin - minPin);
-    return adc_read();
+    return (_readBits < 12) ? adc_read() >> (12 - _readBits) : adc_read() << (_readBits - 12);
 }
 
 extern "C" float analogReadTemp() {
@@ -153,3 +154,10 @@ extern "C" float analogReadTemp() {
     float t = 27.0f - ((v * 3.3f / 4096.0f) - 0.706f) / 0.001721f; // From the datasheet
     return t;
 }
+
+extern "C" void analogReadResolution(int bits) {
+    CoreMutex m(&_adcMutex);
+    if (m && ((bits > 0) && (bits < 32))) {
+        _readBits = bits;
+    }
+}

cores/rp2040/wiring_digital.cpp

@@ -28,6 +28,7 @@ extern "C" void pinMode(pin_size_t ulPin, PinMode ulMode) {
     case INPUT:
         gpio_init(ulPin);
         gpio_set_dir(ulPin, false);
+        gpio_disable_pulls(ulPin);
         break;
     case INPUT_PULLUP:
         gpio_init(ulPin);
@@ -42,7 +43,24 @@ extern "C" void pinMode(pin_size_t ulPin, PinMode ulMode) {
         gpio_put(ulPin, 1);
         break;
     case OUTPUT:
+    case OUTPUT_4MA:
         gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_4MA);
+        gpio_set_dir(ulPin, true);
+        break;
+    case OUTPUT_2MA:
+        gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_2MA);
+        gpio_set_dir(ulPin, true);
+        break;
+    case OUTPUT_8MA:
+        gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_8MA);
+        gpio_set_dir(ulPin, true);
+        break;
+    case OUTPUT_12MA:
+        gpio_init(ulPin);
+        gpio_set_drive_strength(ulPin, GPIO_DRIVE_STRENGTH_12MA);
         gpio_set_dir(ulPin, true);
         break;
     default:

docs/index.rst

@@ -29,6 +29,7 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
    EEPROM <eeprom>
    I2S Audio <i2s>
    Serial USB and UARTs <serial>
+   "Software Serial" PIO UART <piouart>
    Servo <servo>
    SPI <spi>
    Wire(I2C) <wire>

docs/multicore.rst

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

docs/pins.rst

@@ -26,6 +26,8 @@ Serial1 (UART0), Serial2 (UART1)
 
         ::setRX(pin)
         ::setTX(pin)
+        ::setRTS(pin)
+        ::setCTS(pin)
 
 SPI (SPI0), SPI1 (SPI1)
 -----------------------
@@ -59,3 +61,7 @@ it use a non-default pinout with a simple call
         SD.begin(5);
     }
 
+Pad Strength
+============
+
+The Raspberry Pi Pico has the ability to set the current that a pin (actually the pad associated with it) is capable of supplying. The current can be set to values of 2mA, 4mA, 8mA and 12mA. By default, on a reset, the setting is 4mA. A `pinMode(x, OUTPUT)`, where `x` is the pin number, is also the default setting. 4 settings have been added for use with `pinMode`: `OUTPUT_2MA`, `OUTPUT_4MA`, which has the same behavior as `OUTPUT`, `OUTPUT_8MA` and `OUTPUT_12MA`.

docs/piouart.rst

@@ -0,0 +1,23 @@
+"SoftwareSerial" PIO-based UART
+================================
+
+Equivalent to the Arduino SoftwareSerial library, an emulated UART using
+one or two PIO state machines is included in the Arduino-Pico core.  This
+allows for up to 8 additional serial ports to be run from the RP2040 without
+requiring additional CPU resources.
+
+Instantiate a ``SerialPIO(txpin, rxpin, fifosize)`` object in your sketch and then
+use it the same as any other serial port.  Even, odd, and no parity modes
+are supported, as well as data sizes from 5- to 8-bits.  Fifosize, if not
+specified, defaults to 32 bytes.
+
+To instantiate only a serial transmit or receive unit, pass in
+``SerialPIO::NOPIN`` as the ``txpin`` or ``rxpin``.
+
+For example, to make a transmit-only port on GP16
+.. code:: cpp
+
+        SerialPIO transmitter( 16, SerialPIO::NOPIN );
+
+For detailed information about the Serial ports, see the
+Arduino `Serial Reference <https://www.arduino.cc/reference/en/language/functions/communication/serial/>`_ .

docs/platformio.rst

@@ -206,7 +206,7 @@ and 0.5MByte filesystem.
     platform = https://github.com/maxgerhardt/platform-raspberrypi.git
     board = pico
     framework = arduino
-    build_board.core = earlephilhower
+    board_build.core = earlephilhower
     board_build.filesystem_size = 0.5m
     ; note that download link for toolchain is specific for OS. see https://github.com/earlephilhower/pico-quick-toolchain/releases.
     platform_packages = 

docs/serial.rst

@@ -24,5 +24,23 @@ Configure their pins using the ``setXXX`` calls prior to calling ``begin()``
         Serial1.setTX(pin);
         Serial1.begin(baud);
 
+The size of the receive FIFO may also be adjusted from the default 32 bytes by
+using the ``setFIFOSize`` call prior to calling ``begin()``
+
+.. code:: cpp
+        Serial1.setFIFOSize(128);
+        Serial1.begin(baud);
+
+The FIFO is normally handled via an interrupt, which reduced CPU load and
+makes it less likely to lose characters.  However, the FIFO introduces up
+to 32 bit-times of delay before serial data is available to the application.
+
+For applications where this is an issue (i.e. very low baud), use
+``setPollingMode(true)`` before calling ``begin()``
+
+.. code:: cpp
+        Serial1.setPollingMode(true);
+        Serial1.begin(110)
+
 For detailed information about the Serial ports, see the
 Arduino `Serial Reference <https://www.arduino.cc/reference/en/language/functions/communication/serial/>`_ .

keywords.txt

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

lib/pico_base/pico/version.h

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

lib/platform_inc.txt

@@ -15,6 +15,9 @@
 -iwithprefixbefore/pico-sdk/src/common/pico_util/include
 -iwithprefixbefore/pico-sdk/src/rp2040/hardware_regs/include
 -iwithprefixbefore/pico-sdk/src/rp2040/hardware_structs/include
+-iwithprefixbefore/pico-sdk/src/rp2_common/cmsis/include
+-iwithprefixbefore/pico-sdk/src/rp2_common/cmsis/stub/CMSIS/Core/Include
+-iwithprefixbefore/pico-sdk/src/rp2_common/cmsis/stub/CMSIS/Device/RaspberryPi/RP2040/Include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_adc/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_base/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_claim/include
@@ -25,7 +28,9 @@
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_flash/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_gpio/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_i2c/include
+-iwithprefixbefore/pico-sdk/src/rp2_common/hardware_interp/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_irq/include
+-iwithprefixbefore/pico-sdk/src/rp2_common/hardware_rtc/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_pio/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_pll/include
 -iwithprefixbefore/pico-sdk/src/rp2_common/hardware_pwm/include

libraries/LittleFS/examples/SpeedTest/SpeedTest.ino

@@ -13,6 +13,25 @@
 // How large of a file to test
 #define TESTSIZEKB 256
 
+// Format speed in bytes/second.  Static buffer so not re-entrant safe
+const char *rate(unsigned long start, unsigned long stop, unsigned long bytes) {
+  static char buff[64];
+  if (stop == start) {
+    strcpy_P(buff, PSTR("Inf b/s"));
+  } else {
+    unsigned long delta = stop - start;
+    float r = 1000.0 * (float)bytes / (float)delta;
+    if (r >= 1000000.0) {
+      sprintf_P(buff, PSTR("%0.2f MB/s"), r / 1000000.0);
+    } else if (r >= 1000.0) {
+      sprintf_P(buff, PSTR("%0.2f KB/s"), r / 1000.0);
+    } else {
+      sprintf_P(buff, PSTR("%d bytes/s"), (int)r);
+    }
+  }
+  return buff;
+}
+
 void DoTest(FS *fs) {
   if (!fs->format()) {
     Serial.printf("Unable to format(), aborting\n");
@@ -29,7 +48,7 @@ void DoTest(FS *fs) {
   }
 
   Serial.printf("Creating %dKB file, may take a while...\n", TESTSIZEKB);
-  long start = millis();
+  unsigned long start = millis();
   File f = fs->open("/testwrite.bin", "w");
   if (!f) {
     Serial.printf("Unable to open file for writing, aborting\n");
@@ -41,11 +60,11 @@ void DoTest(FS *fs) {
     }
   }
   f.close();
-  long stop = millis();
-  Serial.printf("==> Time to write %dKB in 256b chunks = %ld milliseconds\n", TESTSIZEKB, stop - start);
+  unsigned long stop = millis();
+  Serial.printf("==> Time to write %dKB in 256b chunks = %lu milliseconds\n", TESTSIZEKB, stop - start);
 
   f = fs->open("/testwrite.bin", "r");
-  Serial.printf("==> Created file size = %d\n", f.size());
+  Serial.printf("==> Created file size = %zu\n", f.size());
   f.close();
 
   Serial.printf("Reading %dKB file sequentially in 256b chunks\n", TESTSIZEKB);
@@ -58,7 +77,7 @@ void DoTest(FS *fs) {
   }
   f.close();
   stop = millis();
-  Serial.printf("==> Time to read %dKB sequentially in 256b chunks = %ld milliseconds = %ld bytes/s\n", TESTSIZEKB, stop - start, TESTSIZEKB * 1024 / (stop - start) * 1000);
+  Serial.printf("==> Time to read %dKB sequentially in 256b chunks = %lu milliseconds = %s\n", TESTSIZEKB, stop - start, rate(start, stop, TESTSIZEKB * 1024));
 
   Serial.printf("Reading %dKB file MISALIGNED in flash and RAM sequentially in 256b chunks\n", TESTSIZEKB);
   start = millis();
@@ -71,8 +90,7 @@ void DoTest(FS *fs) {
   }
   f.close();
   stop = millis();
-  Serial.printf("==> Time to read %dKB sequentially MISALIGNED in flash and RAM in 256b chunks = %ld milliseconds = %ld bytes/s\n", TESTSIZEKB, stop - start, TESTSIZEKB * 1024 / (stop - start) * 1000);
-
+  Serial.printf("==> Time to read %dKB sequentially MISALIGNED in flash and RAM in 256b chunks = %lu milliseconds = %s\n", TESTSIZEKB, stop - start, rate(start, stop, TESTSIZEKB * 1024));
 
   Serial.printf("Reading %dKB file in reverse by 256b chunks\n", TESTSIZEKB);
   start = millis();
@@ -91,8 +109,7 @@ void DoTest(FS *fs) {
   }
   f.close();
   stop = millis();
-  Serial.printf("==> Time to read %dKB in reverse in 256b chunks = %ld milliseconds = %ld bytes/s\n", TESTSIZEKB, stop - start, TESTSIZEKB * 1024 / (stop - start) * 1000);
-
+  Serial.printf("==> Time to read %dKB in reverse in 256b chunks = %lu milliseconds = %s\n", TESTSIZEKB, stop - start, rate(start, stop, TESTSIZEKB * 1024));
 
   Serial.printf("Writing 64K file in 1-byte chunks\n");
   start = millis();
@@ -102,7 +119,7 @@ void DoTest(FS *fs) {
   }
   f.close();
   stop = millis();
-  Serial.printf("==> Time to write 64KB in 1b chunks = %ld milliseconds = %ld bytes/s\n", stop - start, 65536 / (stop - start) * 1000);
+  Serial.printf("==> Time to write 64KB in 1b chunks = %lu milliseconds = %s\n", stop - start, rate(start, stop, 65536));
 
   Serial.printf("Reading 64K file in 1-byte chunks\n");
   start = millis();
@@ -113,9 +130,7 @@ void DoTest(FS *fs) {
   }
   f.close();
   stop = millis();
-  Serial.printf("==> Time to read 64KB in 1b chunks = %ld milliseconds = %ld bytes/s\n", stop - start, 65536 / (stop - start) * 1000);
-
-
+  Serial.printf("==> Time to read 64KB in 1b chunks = %lu milliseconds = %s\n", stop - start, rate(start, stop, 65536));
 }
 
 void setup() {
@@ -124,6 +139,7 @@ void setup() {
   Serial.printf("Beginning test\n");
   Serial.flush();
   DoTest(&TESTFS);
+  Serial.println("done");
 }
 
 void loop() {

libraries/PDM/src/PDM.h

@@ -58,6 +58,12 @@ private:
   int _gain;
   int _init;
 
+// Hardware peripherals used
+  uint _dmaChannel;
+  PIO _pio;
+  int _smIdx;
+  int _pgmOffset;
+
   PDMDoubleBuffer _doubleBuffer;
 
   void (*_onReceive)(void);

libraries/PDM/src/rp2040/PDM.cpp

@@ -11,11 +11,7 @@ extern "C" {
 }
 #include "hardware/sync.h" 
 #include "pdm.pio.h"
-
-// Hardware peripherals used
-uint dmaChannel = 0;
-PIO pio = pio0;
-uint sm = 0;
+static PIOProgram _pdmPgm(&pdm_pio_program);
 
 // raw buffers contain PDM data
 #define RAW_BUFFER_SIZE 512 // should be a multiple of (decimation / 8)
@@ -49,7 +45,11 @@ PDMClass::PDMClass(int dinPin, int clkPin, int pwrPin) :
   _gain(-1),
   _channels(-1),
   _samplerate(-1),
-  _init(-1)
+  _init(-1),
+  _dmaChannel(0),
+  _pio(nullptr),
+  _smIdx(-1),
+  _pgmOffset(-1)
 {
 }
 
@@ -89,29 +89,35 @@ int PDMClass::begin(int channels, int sampleRate)
 
   // Configure PIO state machine
   float clkDiv = (float)clock_get_hz(clk_sys) / sampleRate / decimation / 2; 
-  uint offset = pio_add_program(pio, &pdm_pio_program);
-  pdm_pio_program_init(pio, sm, offset, _clkPin, _dinPin, clkDiv);
+
+  if (!_pdmPgm.prepare(&_pio, &_smIdx, &_pgmOffset)) {
+      // ERROR, no free slots
+      return -1;
+  }
+  pdm_pio_program_init(_pio, _smIdx, _pgmOffset, _clkPin, _dinPin, clkDiv);
 
   // Wait for microphone 
   delay(100);
 
   // Configure DMA for transferring PIO rx buffer to raw buffers
-  dma_channel_config c = dma_channel_get_default_config(dmaChannel);
+  _dmaChannel = dma_claim_unused_channel(false);
+  dma_channel_config c = dma_channel_get_default_config(_dmaChannel);
   channel_config_set_read_increment(&c, false);
   channel_config_set_write_increment(&c, true);
-  channel_config_set_dreq(&c, pio_get_dreq(pio, sm, false));
+  channel_config_set_dreq(&c, pio_get_dreq(_pio, _smIdx, false));
   channel_config_set_transfer_data_size(&c, DMA_SIZE_8);
 
   // Clear DMA interrupts
-  dma_hw->ints0 = 1u << dmaChannel; 
+  dma_hw->ints0 = 1u << _dmaChannel; 
   // Enable DMA interrupts
-  dma_channel_set_irq0_enabled(dmaChannel, true);
-  irq_set_exclusive_handler(DMA_IRQ_0, dmaHandler);
+  dma_channel_set_irq0_enabled(_dmaChannel, true);
+  // Share but allocate a high priority to the interrupt
+  irq_add_shared_handler(DMA_IRQ_0, dmaHandler, 0);
   irq_set_enabled(DMA_IRQ_0, true);
 
-  dma_channel_configure(dmaChannel, &c,
+  dma_channel_configure(_dmaChannel, &c,
     rawBuffer[rawBufferIndex],        // Destinatinon pointer
-    &pio->rxf[sm],      // Source pointer
+    &_pio->rxf[_smIdx],      // Source pointer
     RAW_BUFFER_SIZE, // Number of transfers
     true                // Start immediately
   );
@@ -123,7 +129,7 @@ int PDMClass::begin(int channels, int sampleRate)
 
 void PDMClass::end()
 {
-  dma_channel_abort(dmaChannel);
+  dma_channel_abort(_dmaChannel);
   pinMode(_clkPin, INPUT);
 }
 
@@ -171,10 +177,10 @@ void PDMClass::IrqHandler(bool halftranfer)
   static int cutSamples = 100;
 
   // Clear the interrupt request.
-  dma_hw->ints0 = 1u << dmaChannel; 
+  dma_hw->ints0 = 1u << _dmaChannel; 
   // Restart dma pointing to the other buffer 
   int shadowIndex = rawBufferIndex ^ 1;
-  dma_channel_set_write_addr(dmaChannel, rawBuffer[shadowIndex], true);
+  dma_channel_set_write_addr(_dmaChannel, rawBuffer[shadowIndex], true);
 
   if (_doubleBuffer.available()) {
     // buffer overflow, stop

libraries/PDM/src/rp2040/pdm.pio

@@ -26,6 +26,7 @@ static inline void pdm_pio_program_init(PIO pio, uint sm, uint offset, uint clkP
   sm_config_set_in_pins(&c, dataPin);
   sm_config_set_sideset_pins(&c, clkPin);
   sm_config_set_clkdiv(&c, clkDiv);
+  sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX);
 
   pio_sm_set_consecutive_pindirs(pio, sm, dataPin, 1, false);
   pio_sm_set_consecutive_pindirs(pio, sm, clkPin, 1, true);

libraries/PDM/src/rp2040/pdm.pio.h

@@ -43,6 +43,7 @@ static inline void pdm_pio_program_init(PIO pio, uint sm, uint offset, uint clkP
   sm_config_set_in_pins(&c, dataPin);
   sm_config_set_sideset_pins(&c, clkPin);
   sm_config_set_clkdiv(&c, clkDiv);
+  sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX);
   pio_sm_set_consecutive_pindirs(pio, sm, dataPin, 1, false);
   pio_sm_set_consecutive_pindirs(pio, sm, clkPin, 1, true);
   pio_sm_set_pins_with_mask(pio, sm, 0, (1u << clkPin) );

libraries/SD/src/SD.h

@@ -135,8 +135,8 @@ public:
     size_t size() {
         uint64_t sz = size64();
 #ifdef DEBUG_ESP_PORT
-        if (sz > (uint64_t)SIZE_MAX) {
-            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld>= 4GB).  Please update source to use size64().\n"), sz);
+        if (sz > std::numeric_limits<uint32_t>::max()) {
+            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld >= 4GB).  Please update source to use size64().\n"), (long long)sz);
         }
 #endif
         return (size_t)sz;
@@ -191,9 +191,6 @@ private:
 
 
 // Expose FatStructs.h helpers for MS-DOS date/time for use with dateTimeCallback
-static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
-    return (year - 1980) << 9 | month << 5 | day;
-}
 static inline uint16_t FAT_YEAR(uint16_t fatDate) {
     return 1980 + (fatDate >> 9);
 }
@@ -203,9 +200,6 @@ static inline uint8_t FAT_MONTH(uint16_t fatDate) {
 static inline uint8_t FAT_DAY(uint16_t fatDate) {
     return fatDate & 0X1F;
 }
-static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
-    return hour << 11 | minute << 5 | second >> 1;
-}
 static inline uint8_t FAT_HOUR(uint16_t fatTime) {
     return fatTime >> 11;
 }

libraries/SDFS/src/SDFS.cpp

@@ -64,13 +64,13 @@ FileImplPtr SDFSImpl::open(const char* path, OpenMode openMode, AccessMode acces
         }
         free(pathStr);
     }
-    sdfat::File32 fd = _fs.open(path, flags);
+    File32 fd = _fs.open(path, flags);
     if (!fd) {
         DEBUGV("SDFSImpl::openFile: fd=%p path=`%s` openMode=%d accessMode=%d",
                &fd, path, openMode, accessMode);
         return FileImplPtr();
     }
-    auto sharedFd = std::make_shared<sdfat::File32>(fd);
+    auto sharedFd = std::make_shared<File32>(fd);
     return std::make_shared<SDFSFileImpl>(this, sharedFd, path);
 }
 
@@ -90,7 +90,7 @@ DirImplPtr SDFSImpl::openDir(const char* path)
     }
     // At this point we have a name of "/blah/blah/blah" or "blah" or ""
     // If that references a directory, just open it and we're done.
-    sdfat::File32 dirFile;
+    File32 dirFile;
     const char *filter = "";
     if (!pathStr[0]) {
         // openDir("") === openDir("/")
@@ -135,7 +135,7 @@ DirImplPtr SDFSImpl::openDir(const char* path)
         DEBUGV("SDFSImpl::openDir: path=`%s`\n", path);
         return DirImplPtr();
     }
-    auto sharedDir = std::make_shared<sdfat::File32>(dirFile);
+    auto sharedDir = std::make_shared<File32>(dirFile);
     auto ret = std::make_shared<SDFSDirImpl>(filter, this, sharedDir, pathStr);
     free(pathStr);
     return ret;
@@ -145,12 +145,12 @@ bool SDFSImpl::format() {
     if (_mounted) {
         return false;
     }
-    sdfat::SdCardFactory cardFactory;
-    sdfat::SdCard* card = cardFactory.newCard(sdfat::SdSpiConfig(_cfg._csPin, DEDICATED_SPI, _cfg._spiSettings));
+    SdCardFactory cardFactory;
+    SdCard* card = cardFactory.newCard(SdSpiConfig(_cfg._csPin, DEDICATED_SPI, _cfg._spiSettings));
     if (!card || card->errorCode()) {
         return false;
     }
-    sdfat::FatFormatter fatFormatter;
+    FatFormatter fatFormatter;
     uint8_t *sectorBuffer = new uint8_t[512];
     bool ret = fatFormatter.format(card, sectorBuffer, nullptr);
     delete[] sectorBuffer;

libraries/SDFS/src/SDFS.h

@@ -96,11 +96,11 @@ public:
             return false;
         }
         info.maxOpenFiles = 999; // TODO - not valid
-        info.blockSize = _fs.vol()->sectorsPerCluster() * _fs.vol()->bytesPerSector();
+        info.blockSize = _fs.vol()->bytesPerCluster();
         info.pageSize = 0; // TODO ?
         info.maxPathLength = 255; // TODO ?
         info.totalBytes =_fs.vol()->clusterCount() * info.blockSize;
-        info.usedBytes = info.totalBytes - (_fs.vol()->freeClusterCount() * _fs.vol()->sectorsPerCluster() * _fs.vol()->bytesPerSector());
+        info.usedBytes = info.totalBytes - (_fs.vol()->freeClusterCount() * _fs.vol()->bytesPerCluster());
         return true;
     }
 
@@ -114,9 +114,9 @@ public:
         info.maxOpenFiles  = i.maxOpenFiles;
         info.maxPathLength = i.maxPathLength;
 #ifdef DEBUG_ESP_PORT
-        if (i.totalBytes > (uint64_t)SIZE_MAX) {
+        if (i.totalBytes > std::numeric_limits<uint32_t>::max()) {
             // This catches both total and used cases, since used must always be < total.
-            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld>= 4GB).  Please update source to use info64().\n"), i.totalBytes);
+            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld >= 4GB).  Please update source to use info64().\n"), (long long)i.totalBytes);
         }
 #endif
         info.totalBytes    = (size_t)i.totalBytes;
@@ -155,7 +155,7 @@ public:
             format();
             _mounted = _fs.begin(_cfg._csPin, _cfg._spiSettings);
         }
-	sdfat::FsDateTime::setCallback(dateTimeCB);
+	FsDateTime::setCallback(dateTimeCB);
         return _mounted;
     }
 
@@ -184,7 +184,7 @@ public:
         return (totalClusters() / blocksPerCluster());
     }
     size_t clusterSize() {
-        return blocksPerCluster() * _fs.vol()->bytesPerSector();
+        return _fs.vol()->bytesPerCluster();
     }
     size_t size() {
         return (clusterSize() * totalClusters());
@@ -228,7 +228,7 @@ protected:
     friend class SDFileImpl;
     friend class SDFSDirImpl;
 
-    sdfat::SdFat* getFs()
+    SdFat* getFs()
     {
         return &_fs;
     }
@@ -245,16 +245,17 @@ protected:
         if (openMode & OM_TRUNCATE) {
             mode |= O_TRUNC;
         }
-        if (accessMode & AM_READ) {
+        if ((accessMode & (AM_READ | AM_WRITE)) == (AM_READ | AM_WRITE)) {
+            mode |= O_RDWR;
+        } else if (accessMode & AM_READ) {
             mode |= O_READ;
-        }
-        if (accessMode & AM_WRITE) {
+        } else if (accessMode & AM_WRITE) {
             mode |= O_WRITE;
         }
         return mode;
     }
 
-    sdfat::SdFat _fs;
+    SdFat _fs;
     SDFSConfig   _cfg;
     bool         _mounted;
 };
@@ -263,7 +264,7 @@ protected:
 class SDFSFileImpl : public FileImpl
 {
 public:
-    SDFSFileImpl(SDFSImpl *fs, std::shared_ptr<sdfat::File32> fd, const char *name)
+    SDFSFileImpl(SDFSImpl *fs, std::shared_ptr<File32> fd, const char *name)
         : _fs(fs), _fd(fd), _opened(true)
     {
         _name = std::shared_ptr<char>(new char[strlen(name) + 1], std::default_delete<char[]>());
@@ -379,7 +380,7 @@ public:
     time_t getLastWrite() override {
         time_t ftime = 0;
         if (_opened && _fd) {
-            sdfat::DirFat_t tmp;
+            DirFat_t tmp;
             if (_fd.get()->dirEntry(&tmp)) {
                 ftime = SDFSImpl::FatToTimeT(*(uint16_t*)tmp.modifyDate, *(uint16_t*)tmp.modifyTime);
             }
@@ -390,7 +391,7 @@ public:
     time_t getCreationTime() override {
         time_t ftime = 0;
         if (_opened && _fd) {
-            sdfat::DirFat_t tmp;
+            DirFat_t tmp;
             if (_fd.get()->dirEntry(&tmp)) {
                 ftime = SDFSImpl::FatToTimeT(*(uint16_t*)tmp.createDate, *(uint16_t*)tmp.createTime);
             }
@@ -399,16 +400,16 @@ public:
     }
 
 protected:
-    SDFSImpl*                     _fs;
-    std::shared_ptr<sdfat::File32>  _fd;
-    std::shared_ptr<char>         _name;
-    bool                          _opened;
+    SDFSImpl*                _fs;
+    std::shared_ptr<File32>  _fd;
+    std::shared_ptr<char>    _name;
+    bool                     _opened;
 };
 
 class SDFSDirImpl : public DirImpl
 {
 public:
-    SDFSDirImpl(const String& pattern, SDFSImpl* fs, std::shared_ptr<sdfat::File32> dir, const char *dirPath = nullptr)
+    SDFSDirImpl(const String& pattern, SDFSImpl* fs, std::shared_ptr<File32> dir, const char *dirPath = nullptr)
         : _pattern(pattern), _fs(fs), _dir(dir), _valid(false), _dirPath(nullptr)
     {
         if (dirPath) {
@@ -483,14 +484,14 @@ public:
     {
         const int n = _pattern.length();
         do {
-            sdfat::File32 file;
+            File32 file;
             file.openNext(_dir.get(), O_READ);
             if (file) {
                 _valid = 1;
                 _size = file.fileSize();
                 _isFile = file.isFile();
                 _isDirectory = file.isDir();
-                sdfat::DirFat_t tmp;
+                DirFat_t tmp;
                 if (file.dirEntry(&tmp)) {
                     _time = SDFSImpl::FatToTimeT(*(uint16_t*)tmp.modifyDate, *(uint16_t*)tmp.modifyTime);
                     _creation = SDFSImpl::FatToTimeT(*(uint16_t*)tmp.createDate, *(uint16_t*)tmp.createTime);
@@ -515,17 +516,17 @@ public:
     }
 
 protected:
-    String                       _pattern;
-    SDFSImpl*                    _fs;
-    std::shared_ptr<sdfat::File32> _dir;
-    bool                         _valid;
-    char                         _lfn[64];
-    time_t                       _time;
-    time_t                       _creation;
-    std::shared_ptr<char>        _dirPath;
-    uint32_t                     _size;
-    bool                         _isFile;
-    bool                         _isDirectory;
+    String                  _pattern;
+    SDFSImpl*               _fs;
+    std::shared_ptr<File32> _dir;
+    bool                    _valid;
+    char                    _lfn[64];
+    time_t                  _time;
+    time_t                  _creation;
+    std::shared_ptr<char>   _dirPath;
+    uint32_t                _size;
+    bool                    _isFile;
+    bool                    _isDirectory;
 };
 
 }; // namespace sdfs

libraries/SPI/SPI.cpp

@@ -179,23 +179,22 @@ void SPIClassRP2040::transfer(void *txbuf, void *rxbuf, size_t count) {
 
 void SPIClassRP2040::beginTransaction(SPISettings settings) {
     DEBUGSPI("SPI::beginTransaction(clk=%d, bo=%s\n", _spis.getClockFreq(), (_spis.getBitOrder() == MSBFIRST) ? "MSB" : "LSB");
-    _spis = settings;
-    if (_initted) {
-        DEBUGSPI("SPI: deinitting currently active SPI\n");
-        spi_deinit(_spi);
+    if (_initted && settings == _spis) {
+        DEBUGSPI("SPI: Reusing existing initted SPI\n");
+    } else {
+        _spis = settings;
+        if (_initted) {
+            DEBUGSPI("SPI: deinitting currently active SPI\n");
+            spi_deinit(_spi);
+        }
+        DEBUGSPI("SPI: initting SPI\n");
+        spi_init(_spi, _spis.getClockFreq());
+        _initted = true;
     }
-    DEBUGSPI("SPI: initting SPI\n");
-    spi_init(_spi, _spis.getClockFreq());
-    _initted = true;
 }
 
 void SPIClassRP2040::endTransaction(void) {
     DEBUGSPI("SPI::endTransaction()\n");
-    if (_initted) {
-        DEBUGSPI("SPI: deinitting currently active SPI\n");
-        spi_deinit(_spi);
-    }
-    _initted = false;
 }
 
 bool SPIClassRP2040::setRX(pin_size_t pin) {
@@ -281,6 +280,11 @@ void SPIClassRP2040::begin(bool hwCS) {
 
 void SPIClassRP2040::end() {
     DEBUGSPI("SPI::end()\n");
+    if (_initted) {
+        DEBUGSPI("SPI: deinitting currently active SPI\n");
+        _initted = false;
+        spi_deinit(_spi);
+    }
     gpio_set_function(_RX, GPIO_FUNC_SIO);
     if (_hwCS) {
         gpio_set_function(_CS, GPIO_FUNC_SIO);

libraries/Wire/src/Wire.cpp

@@ -83,6 +83,9 @@ bool TwoWire::setSCL(pin_size_t pin) {
 
 void TwoWire::setClock(uint32_t hz) {
     _clkHz = hz;
+    if (_running) {
+        i2c_set_baudrate(_i2c, hz);
+    }
 }
 
 // Master mode
@@ -146,7 +149,7 @@ void TwoWire::onIRQ() {
         _i2c->hw->clr_start_det;
     }
     if (_i2c->hw->intr_stat & (1 << 9)) {
-        if (_onReceiveCallback) {
+        if (_onReceiveCallback && _buffLen) {
             _onReceiveCallback(_buffLen);
         }
         _buffLen = 0;

libraries/Wire/src/Wire.h

@@ -31,7 +31,7 @@
 #define WIRE_HAS_END 1
 
 #ifndef WIRE_BUFFER_SIZE
-#define WIRE_BUFFER_SIZE 128
+#define WIRE_BUFFER_SIZE 256
 #endif
 
 class TwoWire : public HardwareI2C {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-arduinopico",
-  "version": "1.10905.0",
+  "version": "1.11302.0",
   "description": "Arduino Wiring-based Framework (RPi Pico RP2040)",
   "keywords": [
     "framework",

package/README.md

@@ -1,6 +1,12 @@
 Publishing New Releases
 =======================
 
+First, update the version number throughout the repo and push the change:
+
+    ./tools/makever.py --version X.Y.Z
+    git commit -a -m "Update version"
+    git push
+
 GitHub CI Actions are used to automatically build a draft package whenever a tag is pushed to repo:
 
     git tag X.Y.Z

package/package_pico_index.template.json

@@ -26,6 +26,9 @@
                   {
                      "name": "Adafruit ItsyBitsy RP2040"
                   },
+                  {
+                     "name": "Adafruit KB2040"
+                  },
                   {
                      "name": "Adafruit Macropad RP2040"
                   },
@@ -41,12 +44,54 @@
                   {
                      "name": "Arduino Nano RP2040 Connect"
                   },
+                  {
+                     "name": "Cytron Maker Nano RP2040"
+                  },
+                  {
+                     "name": "Cytron Maker Pi RP2040"
+                  },
+                  {
+                     "name": "DeRuiLab FlyBoard2040 Core"
+                  },
+                  {
+                     "name": "DFRobot Beetle RP2040"
+                  },
+                  {
+                     "name": "Invector Labs Challenger RP2040 WiFi"
+                  },
+                  {
+                     "name": "Invector Labs Challenger NB RP2040 WiFi"
+                  },
+                  {
+                     "name": "Invector Labs Challenger RP2040 LTE"
+                  },
+                  {
+                     "name": "Invector Labs Challenger RP2040 LoRa"
+                  },
+                  {
+                     "name": "Invector Labs RPICO32"
+                  },
+                  {
+                     "name": "Seeed XIAO RP2040"
+                  },
+                  {
+                     "name": "Solder Party RP2040 Stamp"
+                  },
                   {
                      "name": "SparkFun ProMicro RP2040"
                   },
+                  {
+                     "name": "SparkFun Thing Plus RP2040"
+                  },
                   {
                      "name": "Melopero Shake RP2040"
                   },
+                  {
+                     "name": "uPesy RP2040 DevKit"
+                  },
+                  {
+                     "name": "WIZnet W5100S-EVB-Pico"
+                  },
                   {
                      "name": "Generic RP2040 Module"
                   }
@@ -54,22 +99,22 @@
                "toolsDependencies": [
                   {
                      "packager": "rp2040",
-                     "version": "1.3.1-a-7855b0c",
+                     "version": "1.3.3-a-ed6d983",
                      "name": "pqt-gcc"
                   },
                   {
                      "packager": "rp2040",
-                     "version": "1.3.1-a-7855b0c",
+                     "version": "1.3.3-a-ed6d983",
                      "name": "pqt-mklittlefs"
                   },
                   {
                      "packager": "rp2040",
-                     "version": "1.3.1-a-7855b0c",
+                     "version": "1.3.3-a-ed6d983",
                      "name": "pqt-elf2uf2"
                   },
                   {
                      "packager": "rp2040",
-                     "version": "1.3.1-a-7855b0c",
+                     "version": "1.3.3-a-ed6d983",
                      "name": "pqt-pioasm"
                   },
                   {
@@ -79,7 +124,7 @@
                   },
                   {
                      "packager": "rp2040",
-                     "version": "1.3.1-a-7855b0c",
+                     "version": "1.3.3-a-ed6d983",
                      "name": "pqt-openocd"
                   }
                ],
@@ -90,57 +135,57 @@
          ],
          "tools": [
             {
-               "version": "1.3.1-a-7855b0c",
+               "version": "1.3.3-a-ed6d983",
                "name": "pqt-openocd",
                "systems": [
                   {
                      "host": "aarch64-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/aarch64-linux-gnu.openocd-e3428fadb.210706.tar.gz",
-                     "archiveFileName": "aarch64-linux-gnu.openocd-e3428fadb.210706.tar.gz",
-                     "checksum": "SHA-256:62662b74a7cbbb5db0998987585d74a3261c3e6f0c1440d7449505832020e095",
-                     "size": "6224364"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/aarch64-linux-gnu.openocd-e3428fadb.220212.tar.gz",
+                     "archiveFileName": "aarch64-linux-gnu.openocd-e3428fadb.220212.tar.gz",
+                     "checksum": "SHA-256:d1d95978101c69c3bc777e61ba70077bf9dc4b3245aa7dd93171acaec4d29fb1",
+                     "size": "5607214"
                   },
                   {
                      "host": "arm-linux-gnueabihf",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/arm-linux-gnueabihf.openocd-e3428fadb.210706.tar.gz",
-                     "archiveFileName": "arm-linux-gnueabihf.openocd-e3428fadb.210706.tar.gz",
-                     "checksum": "SHA-256:15b188279382ee182253984ed45785f3a15387576583a1c6bff2c71d724ff76a",
-                     "size": "5931976"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/arm-linux-gnueabihf.openocd-e3428fadb.220212.tar.gz",
+                     "archiveFileName": "arm-linux-gnueabihf.openocd-e3428fadb.220212.tar.gz",
+                     "checksum": "SHA-256:81373c1e12a88e382a587688343c2e2f2f1f999d38334b7b6ded174929cc9b88",
+                     "size": "5344032"
                   },
                   {
                      "host": "i686-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-linux-gnu.openocd-e3428fadb.210706.tar.gz",
-                     "archiveFileName": "i686-linux-gnu.openocd-e3428fadb.210706.tar.gz",
-                     "checksum": "SHA-256:40a7a417b46875b2ccff582309b0e8ffcfd5c038ad1dc1775d53c683708c363c",
-                     "size": "5728004"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-linux-gnu.openocd-e3428fadb.220212.tar.gz",
+                     "archiveFileName": "i686-linux-gnu.openocd-e3428fadb.220212.tar.gz",
+                     "checksum": "SHA-256:6a4dd98422a187c7725fc349b045b55e4742166c65461847d1bd59537242b0be",
+                     "size": "5168258"
                   },
                   {
                      "host": "i686-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-w64-mingw32.openocd-e3428fadb.210706.zip",
-                     "archiveFileName": "i686-w64-mingw32.openocd-e3428fadb.210706.zip",
-                     "checksum": "SHA-256:945cf4b0de879b935e05af2f438a6964949fbbf6d163e96e507939c55cafbff0",
-                     "size": "8539935"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.openocd-e3428fadb.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.openocd-e3428fadb.220212.zip",
+                     "checksum": "SHA-256:0643903fcd887a8423cb4ba5329565b499c206921f77ad2e59ae32c472a26dd7",
+                     "size": "2156820"
                   },
                   {
                      "host": "x86_64-apple-darwin",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-apple-darwin14.openocd-e3428fadb.210706.tar.gz",
-                     "archiveFileName": "x86_64-apple-darwin14.openocd-e3428fadb.210706.tar.gz",
-                     "checksum": "SHA-256:b28b54580b16e6d7f0229a653acf68aeab8cc3270d8b9dcaf178b8b8c0aafcb7",
-                     "size": "2006182"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-apple-darwin14.openocd-e3428fadb.220212.tar.gz",
+                     "archiveFileName": "x86_64-apple-darwin14.openocd-e3428fadb.220212.tar.gz",
+                     "checksum": "SHA-256:913b65baeeef1b60caf202e69cde4cd5a3ba0ed2f75f2600adfb3dcf4b3899ef",
+                     "size": "2002482"
                   },
                   {
                      "host": "x86_64-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-linux-gnu.openocd-e3428fadb.210706.tar.gz",
-                     "archiveFileName": "x86_64-linux-gnu.openocd-e3428fadb.210706.tar.gz",
-                     "checksum": "SHA-256:90aec3a7818697e04e798a0470133caf62e7583a48f7ae3848b9b536c3180b0b",
-                     "size": "6154827"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-linux-gnu.openocd-e3428fadb.220212.tar.gz",
+                     "archiveFileName": "x86_64-linux-gnu.openocd-e3428fadb.220212.tar.gz",
+                     "checksum": "SHA-256:63b2be48c1438d2a09f4ed65d89e555176f18753886555cf48f861e9288d7dc1",
+                     "size": "5540524"
                   },
                   {
                      "host": "x86_64-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.openocd-e3428fadb.210706.zip",
-                     "archiveFileName": "x86_64-w64-mingw32.openocd-e3428fadb.210706.zip",
-                     "checksum": "SHA-256:86e0341d50723d5e0c2969a903e911273e3b70ed5b794284b7d7ec7a1f09ee2f",
-                     "size": "8929726"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.openocd-e3428fadb.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.openocd-e3428fadb.220212.zip",
+                     "checksum": "SHA-256:0643903fcd887a8423cb4ba5329565b499c206921f77ad2e59ae32c472a26dd7",
+                     "size": "2156820"
                   }
                ]
             },
@@ -207,226 +252,226 @@
                ]
             },
             {
-               "version": "1.3.1-a-7855b0c",
+               "version": "1.3.3-a-ed6d983",
                "name": "pqt-gcc",
                "systems": [
                   {
                      "host": "aarch64-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/aarch64-linux-gnu.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "archiveFileName": "aarch64-linux-gnu.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "checksum": "SHA-256:32f2a28e0f12bd1c8aaefa10bc2646f0f058b77d0030bec3e1e0ec89409d2380",
-                     "size": "103186082"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/aarch64-linux-gnu.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "archiveFileName": "aarch64-linux-gnu.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "checksum": "SHA-256:7773b43b9c0bf5b7cdb2299e9d1b151df97e0a2ded4428809ec68264ac9818a9",
+                     "size": "102741416"
                   },
                   {
                      "host": "arm-linux-gnueabihf",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/arm-linux-gnueabihf.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "archiveFileName": "arm-linux-gnueabihf.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "checksum": "SHA-256:0cca5b4c429acf26eeb093bf21b16c2265fd6c04aafe91ceb304dfee35a662d7",
-                     "size": "95859088"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/arm-linux-gnueabihf.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "archiveFileName": "arm-linux-gnueabihf.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "checksum": "SHA-256:c422910ef0e29528939e037ea3c518a532726111604b85b27f3f245820680ccb",
+                     "size": "95383443"
                   },
                   {
                      "host": "i686-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-linux-gnu.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "archiveFileName": "i686-linux-gnu.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "checksum": "SHA-256:9a1ba7cdcb11d817ddbcb60d53f5b804b787a7a3c2e0bc5a33e86b8bbf653391",
-                     "size": "105956199"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-linux-gnu.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "archiveFileName": "i686-linux-gnu.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "checksum": "SHA-256:6306791b43de955c4a4d0a1b8972e0f696206591a810eefc16b906b157322bd3",
+                     "size": "105350371"
                   },
                   {
                      "host": "i686-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-w64-mingw32.arm-none-eabi-7855b0c.210706.zip",
-                     "archiveFileName": "i686-w64-mingw32.arm-none-eabi-7855b0c.210706.zip",
-                     "checksum": "SHA-256:5b06d0dcfcf78c83b85aadbcbd8b6e3301b60acd14d6319e066e125586331aac",
-                     "size": "105493451"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-w64-mingw32.arm-none-eabi-ed6d983.220212.zip",
+                     "archiveFileName": "i686-w64-mingw32.arm-none-eabi-ed6d983.220212.zip",
+                     "checksum": "SHA-256:b00aa3594d1911bea07c1dbf31b9a63430f4dcb91c7b3b1341f8551d361d405f",
+                     "size": "105568357"
                   },
                   {
                      "host": "x86_64-apple-darwin",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-apple-darwin14.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "archiveFileName": "x86_64-apple-darwin14.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "checksum": "SHA-256:6d4dfd0e032df43687683504b747a0010cea53b2d86f4662f72997fd0cbd8b1a",
-                     "size": "107371801"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-apple-darwin14.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "archiveFileName": "x86_64-apple-darwin14.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "checksum": "SHA-256:e93b967d1fb6ed0fc7cf6a5161e22a597dd05080c1353ac74e2a42ddf8dfe98d",
+                     "size": "107429038"
                   },
                   {
                      "host": "x86_64-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-linux-gnu.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "archiveFileName": "x86_64-linux-gnu.arm-none-eabi-7855b0c.210706.tar.gz",
-                     "checksum": "SHA-256:791b6386a6b6742d627af3277f401db7bb2b407852c8b3f49eaee30fcc5ceb8a",
-                     "size": "107845636"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-linux-gnu.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "archiveFileName": "x86_64-linux-gnu.arm-none-eabi-ed6d983.220212.tar.gz",
+                     "checksum": "SHA-256:047c4d482cf77e09bd8069fc9d5b28b1e0c76440ad81583a0fc3a8e809959bb8",
+                     "size": "106740897"
                   },
                   {
                      "host": "x86_64-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.arm-none-eabi-7855b0c.210706.zip",
-                     "archiveFileName": "x86_64-w64-mingw32.arm-none-eabi-7855b0c.210706.zip",
-                     "checksum": "SHA-256:7f8b591902e9f164904974bb8224808371b025affaf7cbffdeb3f3ff259b9464",
-                     "size": "110342777"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.arm-none-eabi-ed6d983.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.arm-none-eabi-ed6d983.220212.zip",
+                     "checksum": "SHA-256:5c15725628a3dbd47a8fa8f9a9aab7a2221815ec9bf85dc2080ce19166316ae6",
+                     "size": "110420777"
                   }
                ]
             },
             {
-               "version": "1.3.1-a-7855b0c",
+               "version": "1.3.3-a-ed6d983",
                "name": "pqt-elf2uf2",
                "systems": [
                   {
                      "host": "aarch64-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/aarch64-linux-gnu.elf2uf2-fc10a97.210706.tar.gz",
-                     "archiveFileName": "aarch64-linux-gnu.elf2uf2-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:3c67eb63da563c505dd046cd069aee1754ff735e9d0d7dacfd8b003a85a078ca",
-                     "size": "79842"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/aarch64-linux-gnu.elf2uf2-2062372.220212.tar.gz",
+                     "archiveFileName": "aarch64-linux-gnu.elf2uf2-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:8cb7ce703b0fa6f2fce6b124ae6f34ad0b866aa4a58096f22b66b1251c1b11c0",
+                     "size": "79853"
                   },
                   {
                      "host": "arm-linux-gnueabihf",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/arm-linux-gnueabihf.elf2uf2-fc10a97.210706.tar.gz",
-                     "archiveFileName": "arm-linux-gnueabihf.elf2uf2-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:62457fc90b0993d720a3523537e8d55e9378769db1595709ff01357ebc13a3dd",
-                     "size": "54219"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/arm-linux-gnueabihf.elf2uf2-2062372.220212.tar.gz",
+                     "archiveFileName": "arm-linux-gnueabihf.elf2uf2-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:790d46b411c16a4a210a91436eb4bdc81fb34f0119148a8f9c4b09489489a54d",
+                     "size": "54244"
                   },
                   {
                      "host": "i686-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-linux-gnu.elf2uf2-fc10a97.210706.tar.gz",
-                     "archiveFileName": "i686-linux-gnu.elf2uf2-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:59e83f09322a2a292c20a4852512aa8c086b5b0d02842e11dfb9cb122485fb84",
-                     "size": "87881"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-linux-gnu.elf2uf2-2062372.220212.tar.gz",
+                     "archiveFileName": "i686-linux-gnu.elf2uf2-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:7c05c70f761bb6caa986d24ac1065367fe906ff7f0434cf4b0112ace331f74bc",
+                     "size": "87891"
                   },
                   {
                      "host": "i686-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-w64-mingw32.elf2uf2-fc10a97.210706.zip",
-                     "archiveFileName": "i686-w64-mingw32.elf2uf2-fc10a97.210706.zip",
-                     "checksum": "SHA-256:2b7c676fa0ff8a7fb6638dfe770787e6bdd9c6cd2f5a0d86f8c64c267a9bc328",
-                     "size": "70429"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-w64-mingw32.elf2uf2-2062372.220212.zip",
+                     "archiveFileName": "i686-w64-mingw32.elf2uf2-2062372.220212.zip",
+                     "checksum": "SHA-256:e6f0578ea781b160390994d3e95bedfec01e212d47243b1adb84f910a06bcba4",
+                     "size": "70405"
                   },
                   {
                      "host": "x86_64-apple-darwin",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-apple-darwin14.elf2uf2-fc10a97.210706.tar.gz",
-                     "archiveFileName": "x86_64-apple-darwin14.elf2uf2-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:1154dd7bb3186bb66b8b53699d29083a688564ace502f28cf53cf9f15214d816",
-                     "size": "81919"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-apple-darwin14.elf2uf2-2062372.220212.tar.gz",
+                     "archiveFileName": "x86_64-apple-darwin14.elf2uf2-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:d65de7218eaf01c9bf58fa22bd9e1e7c10c054213948b4b62f648a058d09b4de",
+                     "size": "81981"
                   },
                   {
                      "host": "x86_64-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-linux-gnu.elf2uf2-fc10a97.210706.tar.gz",
-                     "archiveFileName": "x86_64-linux-gnu.elf2uf2-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:0ed4a2a3973ee2e7a5edc4932bd2485ac0825750b72fabdb8a96e8d274dc30a4",
-                     "size": "79516"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-linux-gnu.elf2uf2-2062372.220212.tar.gz",
+                     "archiveFileName": "x86_64-linux-gnu.elf2uf2-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:ba7795ed49c54f3f52caee675b0fd078f6fb8498a47bf7e5d7457065271df338",
+                     "size": "79585"
                   },
                   {
                      "host": "x86_64-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.elf2uf2-fc10a97.210706.zip",
-                     "archiveFileName": "x86_64-w64-mingw32.elf2uf2-fc10a97.210706.zip",
-                     "checksum": "SHA-256:81c3c458fda68840439afc7b16133febb21e023a910924761abaee9c011a44db",
-                     "size": "78298"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.elf2uf2-2062372.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.elf2uf2-2062372.220212.zip",
+                     "checksum": "SHA-256:02c7684ed1aea4e18216ec6bbbcedeb482c5f23ad7d5eb9dcb942b8ae6cad5ae",
+                     "size": "78279"
                   }
                ]
             },
             {
-               "version": "1.3.1-a-7855b0c",
+               "version": "1.3.3-a-ed6d983",
                "name": "pqt-pioasm",
                "systems": [
                   {
                      "host": "aarch64-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/aarch64-linux-gnu.pioasm-fc10a97.210706.tar.gz",
-                     "archiveFileName": "aarch64-linux-gnu.pioasm-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:bbc6735939ffab312e700b687c29ecf7873564cec9028588c39b7be5a5b18ba3",
-                     "size": "453297"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/aarch64-linux-gnu.pioasm-2062372.220212.tar.gz",
+                     "archiveFileName": "aarch64-linux-gnu.pioasm-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:9ea17ecf0e492bc6a971f6a78780c3b3c6ee644d52e056cba08a708ac225add2",
+                     "size": "453558"
                   },
                   {
                      "host": "arm-linux-gnueabihf",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/arm-linux-gnueabihf.pioasm-fc10a97.210706.tar.gz",
-                     "archiveFileName": "arm-linux-gnueabihf.pioasm-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:9390b87fa87fa03d1033cf75624c0dd3d2acd7b2d794f5ab91a800ffb7546a17",
-                     "size": "360370"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/arm-linux-gnueabihf.pioasm-2062372.220212.tar.gz",
+                     "archiveFileName": "arm-linux-gnueabihf.pioasm-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:c7af69227a3b3c54ccf87122b18842460a263bd711abf93336794ce5f905c284",
+                     "size": "360559"
                   },
                   {
                      "host": "i686-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-linux-gnu.pioasm-fc10a97.210706.tar.gz",
-                     "archiveFileName": "i686-linux-gnu.pioasm-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:a84e7389c5e959a409b6ce8b1150fad7641fad4ac55c129888439f33c5bfb7cc",
-                     "size": "511409"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-linux-gnu.pioasm-2062372.220212.tar.gz",
+                     "archiveFileName": "i686-linux-gnu.pioasm-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:f66b9bde3d6859d43049b019fb639dd0bfafcd43f1389ffc499d18949bcf1808",
+                     "size": "511397"
                   },
                   {
                      "host": "i686-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-w64-mingw32.pioasm-fc10a97.210706.zip",
-                     "archiveFileName": "i686-w64-mingw32.pioasm-fc10a97.210706.zip",
-                     "checksum": "SHA-256:d1f1e34bd6e4b32301f3e7b147a9eb6710c2b52f816288a11e9aeb619f242355",
-                     "size": "385662"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-w64-mingw32.pioasm-2062372.220212.zip",
+                     "archiveFileName": "i686-w64-mingw32.pioasm-2062372.220212.zip",
+                     "checksum": "SHA-256:89cfa44101dade30000cfaa5985de7f0e7aba93d03dc45ba962f97226ae4e41f",
+                     "size": "385748"
                   },
                   {
                      "host": "x86_64-apple-darwin",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-apple-darwin14.pioasm-fc10a97.210706.tar.gz",
-                     "archiveFileName": "x86_64-apple-darwin14.pioasm-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:f9cb3bf99c84221b8c63d95dd22bbd1cc1ba40bd847530819392ee047962571e",
-                     "size": "480405"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-apple-darwin14.pioasm-2062372.220212.tar.gz",
+                     "archiveFileName": "x86_64-apple-darwin14.pioasm-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:d531c911e6eba0333379af04dd807917659bd4d34be9f4bd6792aeff55ab15a9",
+                     "size": "480495"
                   },
                   {
                      "host": "x86_64-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-linux-gnu.pioasm-fc10a97.210706.tar.gz",
-                     "archiveFileName": "x86_64-linux-gnu.pioasm-fc10a97.210706.tar.gz",
-                     "checksum": "SHA-256:96721566a97f07cbe4af3a1d80d63336a75b129a7cb821a407260d250666a30f",
-                     "size": "458641"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-linux-gnu.pioasm-2062372.220212.tar.gz",
+                     "archiveFileName": "x86_64-linux-gnu.pioasm-2062372.220212.tar.gz",
+                     "checksum": "SHA-256:2cd4aa8af98558461cb7b85b21830ea854a430a3e57668d618c5f1cd5e389809",
+                     "size": "458730"
                   },
                   {
                      "host": "x86_64-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.pioasm-fc10a97.210706.zip",
-                     "archiveFileName": "x86_64-w64-mingw32.pioasm-fc10a97.210706.zip",
-                     "checksum": "SHA-256:15fe69c11ad86ddf78c1ee26610b8b0f9d4a2323af13854e8e6b5e20d5a6fff5",
-                     "size": "408341"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.pioasm-2062372.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.pioasm-2062372.220212.zip",
+                     "checksum": "SHA-256:ba586e67f4b309690a51fca70fdd26f38b68951b0fee4dc8333183ef6429833a",
+                     "size": "408649"
                   }
                ]
             },
             {
-               "version": "1.3.1-a-7855b0c",
+               "version": "1.3.3-a-ed6d983",
                "name": "pqt-mklittlefs",
                "systems": [
                   {
                      "host": "aarch64-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/aarch64-linux-gnu.mklittlefs-6b5c62d.210706.tar.gz",
-                     "archiveFileName": "aarch64-linux-gnu.mklittlefs-6b5c62d.210706.tar.gz",
-                     "checksum": "SHA-256:3b318dbefd8ac36b3f1531d14d018d7aaad26b4f7f259a3a0c116939e74c76f6",
-                     "size": "44788"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/aarch64-linux-gnu.mklittlefs-affa497.220212.tar.gz",
+                     "archiveFileName": "aarch64-linux-gnu.mklittlefs-affa497.220212.tar.gz",
+                     "checksum": "SHA-256:2455f5ca6cb1f7b73ed1cb55d4d2261d249c1b24915bd4e66e28f037a0a13116",
+                     "size": "47271"
                   },
                   {
                      "host": "arm-linux-gnueabihf",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/arm-linux-gnueabihf.mklittlefs-6b5c62d.210706.tar.gz",
-                     "archiveFileName": "arm-linux-gnueabihf.mklittlefs-6b5c62d.210706.tar.gz",
-                     "checksum": "SHA-256:2b67c6ab2d6fd7239944963beeca0664f85fbffb7b68bcf9eaa7c64e81cad7a5",
-                     "size": "38247"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/arm-linux-gnueabihf.mklittlefs-affa497.220212.tar.gz",
+                     "archiveFileName": "arm-linux-gnueabihf.mklittlefs-affa497.220212.tar.gz",
+                     "checksum": "SHA-256:f4b71138f1469e4b9ce82b3b21252aca265a88d56a5d48513dbb5c6d58b19841",
+                     "size": "40807"
                   },
                   {
                      "host": "i686-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-linux-gnu.mklittlefs-6b5c62d.210706.tar.gz",
-                     "archiveFileName": "i686-linux-gnu.mklittlefs-6b5c62d.210706.tar.gz",
-                     "checksum": "SHA-256:791f12a6969e3b78d13e4355b7977a49e5b567261499451a10ce0781a7d08d70",
-                     "size": "48237"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-linux-gnu.mklittlefs-affa497.220212.tar.gz",
+                     "archiveFileName": "i686-linux-gnu.mklittlefs-affa497.220212.tar.gz",
+                     "checksum": "SHA-256:ed1011230c75447dad3d912b7b5607ddcc59e093ee7ebd653fb05274bc876f4c",
+                     "size": "50909"
                   },
                   {
                      "host": "i686-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/i686-w64-mingw32.mklittlefs-6b5c62d.210706.zip",
-                     "archiveFileName": "i686-w64-mingw32.mklittlefs-6b5c62d.210706.zip",
-                     "checksum": "SHA-256:a5bf0308b8f279f5e06c2b5f24f6843d934046ceba84fd7ed5c44ba682b770c4",
-                     "size": "332804"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-w64-mingw32.mklittlefs-affa497.220212.zip",
+                     "archiveFileName": "i686-w64-mingw32.mklittlefs-affa497.220212.zip",
+                     "checksum": "SHA-256:1289f51c674ebdc568843b82c88db21eb4c295f3b15c26398d31266b9da63b4c",
+                     "size": "334050"
                   },
                   {
                      "host": "x86_64-apple-darwin",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-apple-darwin14.mklittlefs-6b5c62d.210706.tar.gz",
-                     "archiveFileName": "x86_64-apple-darwin14.mklittlefs-6b5c62d.210706.tar.gz",
-                     "checksum": "SHA-256:e5dd89a7a4ffe494440975ec511cdf24d5978da07a9bff96429a48ad0a7054e7",
-                     "size": "362810"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-apple-darwin14.mklittlefs-affa497.220212.tar.gz",
+                     "archiveFileName": "x86_64-apple-darwin14.mklittlefs-affa497.220212.tar.gz",
+                     "checksum": "SHA-256:0c0d7d8c80739ed79bc5a41e831d0229b6378e87f4c58f148d884814f1ad46d2",
+                     "size": "365757"
                   },
                   {
                      "host": "x86_64-pc-linux-gnu",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-linux-gnu.mklittlefs-6b5c62d.210706.tar.gz",
-                     "archiveFileName": "x86_64-linux-gnu.mklittlefs-6b5c62d.210706.tar.gz",
-                     "checksum": "SHA-256:f1e3b374c66811bfe07997b12b6cb318c58ac84973c46e6887553aea13276884",
-                     "size": "46915"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-linux-gnu.mklittlefs-affa497.220212.tar.gz",
+                     "archiveFileName": "x86_64-linux-gnu.mklittlefs-affa497.220212.tar.gz",
+                     "checksum": "SHA-256:c504429c24cfea9bf841cbf0caa29bbe0115e72c94c18f949451ffa540d6cacc",
+                     "size": "49766"
                   },
                   {
                      "host": "x86_64-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.mklittlefs-6b5c62d.210706.zip",
-                     "archiveFileName": "x86_64-w64-mingw32.mklittlefs-6b5c62d.210706.zip",
-                     "checksum": "SHA-256:f5d69785c0bb5397eb49cccaa23dd131d32ab013e1124e38c15f758ded799fdb",
-                     "size": "345250"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.mklittlefs-affa497.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.mklittlefs-affa497.220212.zip",
+                     "checksum": "SHA-256:4ada867888513596fa51bf78c98d9e970de9b8f1eec4f88d85e6e7621704fb91",
+                     "size": "347602"
                   }
                ]
             }
          ]
       }
    ]
-}
+}

platform.txt

@@ -20,7 +20,8 @@
 # https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5---3rd-party-Hardware-specification
 
 name=Raspberry Pi RP2040 Boards
-version=0.9.9
+version=1.13.2
+
 runtime.tools.pqt-gcc.path={runtime.platform.path}/system/arm-none-eabi
 runtime.tools.pqt-python3.path={runtime.platform.path}/system/python3
 runtime.tools.pqt-mklittlefs.path={runtime.platform.path}/system/mklittlefs
@@ -29,6 +30,8 @@ runtime.tools.pqt-elf2uf2.path={runtime.platform.path}/system/elf2uf2
 
 compiler.path={runtime.tools.pqt-gcc.path}/bin/
 
+compiler.libraries.ldflags=
+
 # Compile variables
 # -----------------
 
@@ -40,7 +43,7 @@ compiler.warning_flags.all=-Wall -Wextra -Werror=return-type -Wno-ignored-qualif
 
 compiler.defines={build.led} {build.usbstack_flags} -DCFG_TUSB_MCU=OPT_MCU_RP2040 -DUSB_VID={build.vid} -DUSB_PID={build.pid} '-DUSB_MANUFACTURER={build.usb_manufacturer}' '-DUSB_PRODUCT={build.usb_product}'
 compiler.includes="-iprefix{runtime.platform.path}/" "@{runtime.platform.path}/lib/platform_inc.txt"
-compiler.flags=-Os -march=armv6-m -mcpu=cortex-m0plus -mthumb -ffunction-sections -fdata-sections -fno-exceptions
+compiler.flags=-march=armv6-m -mcpu=cortex-m0plus -mthumb -ffunction-sections -fdata-sections -fno-exceptions
 compiler.wrap="@{runtime.platform.path}/lib/platform_wrap.txt"
 compiler.libpico="{runtime.platform.path}/lib/libpico.a"
 compiler.libstdcpp="-lstdc++"
@@ -48,11 +51,11 @@ compiler.libstdcpp="-lstdc++"
 compiler.c.cmd=arm-none-eabi-gcc
 compiler.c.flags=-c {compiler.warning_flags} {compiler.defines} {compiler.flags} {compiler.includes} -std=gnu17 -g
 compiler.c.elf.cmd=arm-none-eabi-g++
-compiler.c.elf.flags={compiler.warning_flags} {compiler.defines} {compiler.flags} -u _printf_float -u _scanf_float
+compiler.c.elf.flags={compiler.warning_flags} {compiler.defines} {compiler.flags} {build.flags.optimize} -u _printf_float -u _scanf_float
 compiler.S.cmd=arm-none-eabi-gcc
 compiler.S.flags=-c {compiler.warning_flags} -g -x assembler-with-cpp -MMD {compiler.includes} -g
 compiler.cpp.cmd=arm-none-eabi-g++
-compiler.cpp.flags=-c {compiler.warning_flags} {compiler.defines} {compiler.flags} {compiler.includes} -fno-rtti -std=gnu++17 -g
+compiler.cpp.flags=-c {compiler.warning_flags} {compiler.defines} {compiler.flags} {compiler.includes} {build.flags.rtti} -std=gnu++17 -g
 
 compiler.ar.cmd=arm-none-eabi-ar
 compiler.ar.flags=rcs
@@ -80,6 +83,8 @@ compiler.elf2hex.extra_flags=
 # Board configuration, set in boards.txt.  Present here to ensure substitution works
 build.flash_length=
 build.eeprom_start=
+build.flags.optimize=-Os
+build.flags.rtti=-fno-rtti
 build.fs_start=
 build.fs_end=
 build.usbstack_flags=
@@ -94,13 +99,13 @@ discovery.rp2040.pattern="{runtime.tools.pqt-python3.path}/python3" -I "{runtime
 # ----------------
 
 ## Compile c files
-recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.flags} {build.usbpid} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DBOARD_NAME="{build.board}" -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} {build.debug_port} {build.debug_level} {includes} "{source_file}" -o "{object_file}"
+recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.flags} {build.usbpid} {build.usbpwr} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DBOARD_NAME="{build.board}" -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} {build.debug_port} {build.debug_level} {build.flags.optimize} {includes} "{source_file}" -o "{object_file}"
 
 ## Compile c++ files
-recipe.cpp.o.pattern="{compiler.path}{compiler.cpp.cmd}" {compiler.cpp.flags} {build.usbpid} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DBOARD_NAME="{build.board}" -DARDUINO_ARCH_{build.arch} {compiler.cpp.extra_flags} {build.extra_flags} {build.debug_port} {build.debug_level} {includes} "{source_file}" -o "{object_file}"
+recipe.cpp.o.pattern="{compiler.path}{compiler.cpp.cmd}" {compiler.cpp.flags} {build.usbpid} {build.usbpwr} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DBOARD_NAME="{build.board}" -DARDUINO_ARCH_{build.arch} {compiler.cpp.extra_flags} {build.extra_flags} {build.debug_port} {build.debug_level} {build.flags.optimize} {includes} "{source_file}" -o "{object_file}"
 
 ## Compile S files
-recipe.S.o.pattern="{compiler.path}{compiler.S.cmd}" {compiler.S.flags} {build.usbpid} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DBOARD_NAME="{build.board}" -DARDUINO_ARCH_{build.arch} {compiler.S.extra_flags} {build.extra_flags} {build.debug_port} {build.debug_level} {includes} "{source_file}" -o "{object_file}"
+recipe.S.o.pattern="{compiler.path}{compiler.S.cmd}" {compiler.S.flags} {build.usbpid} {build.usbpwr} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DBOARD_NAME="{build.board}" -DARDUINO_ARCH_{build.arch} {compiler.S.extra_flags} {build.extra_flags} {build.debug_port} {build.debug_level} {includes} "{source_file}" -o "{object_file}"
 
 ## Create archives
 # archive_file_path is needed for backwards compatibility with IDE 1.6.5 or older, IDE 1.6.6 or newer overrides this value
@@ -114,7 +119,7 @@ recipe.hooks.linking.prelink.1.pattern="{runtime.tools.pqt-python3.path}/python3
 recipe.hooks.linking.prelink.2.pattern="{compiler.path}{compiler.S.cmd}" {compiler.c.elf.flags} {compiler.c.elf.extra_flags} -c "{runtime.platform.path}/boot2/{build.boot2}.S" "-I{runtime.platform.path}/pico-sdk/src/rp2040/hardware_regs/include/" "-I{runtime.platform.path}/pico-sdk/src/common/pico_binary_info/include" -o "{build.path}/boot2.o"
 
 ## Combine gc-sections, archives, and objects
-recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" "-L{build.path}" {compiler.c.elf.flags} {compiler.c.elf.extra_flags} {compiler.ldflags} "-Wl,--script={build.path}/memmap_default.ld" "-Wl,-Map,{build.path}/{build.project_name}.map" -o "{build.path}/{build.project_name}.elf" -Wl,--start-group {object_files} "{build.path}/{archive_file}" "{build.path}/boot2.o" {compiler.libpico} -lm -lc {compiler.libstdcpp} -lc -Wl,--end-group
+recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" "-L{build.path}" {compiler.c.elf.flags} {compiler.c.elf.extra_flags} {compiler.ldflags} "-Wl,--script={build.path}/memmap_default.ld" "-Wl,-Map,{build.path}/{build.project_name}.map" -o "{build.path}/{build.project_name}.elf" -Wl,--start-group {object_files} "{build.path}/{archive_file}" "{build.path}/boot2.o" {compiler.libraries.ldflags} {compiler.libpico} -lm -lc {compiler.libstdcpp} -lc -Wl,--end-group
 
 ## Create output (UF2 file)
 recipe.objcopy.uf2.pattern="{runtime.tools.pqt-elf2uf2.path}/elf2uf2" "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.uf2"

tests/build-tinyusb.sh

@@ -19,8 +19,9 @@ function skip_ino()
 /hid_keyboard/
 /msc_external_flash/
 /msc_external_flash_sdcard/
-/msc_sdfat/
+/msc_internal_flash_samd/
 /msc_sd/
+/msc_sdfat/
 /midi_pizza_box_dj/
 EOL
         echo $ino | grep -q -F "$skiplist"

tests/common.sh

@@ -9,16 +9,13 @@ function skip_ino()
     read -d '' skiplist << EOL || true
 /#attic/
 /AvrAdcLogger/
-/BackwardCompatibility/
 /examplesV1/
-/ExFatFormatter/
-/ExFatLogger/
-/ExFatUnicodeTest/
 /RtcTimestampTest/
 /SoftwareSpi/
-/STM32Test/
+/TeensyDmaAdcLogger/
 /TeensyRtcTimestamp/
 /TeensySdioDemo/
+/TeensySdioLogger/
 /UserChipSelectFunction/
 /UserSPIDriver/
 /Adafruit_TinyUSB_Arduino/

tests/restyle.sh

@@ -2,7 +2,7 @@
 
 for dir in ./cores/rp2040 ./libraries/EEPROM ./libraries/I2S \
            ./libraries/LittleFS/src ./libraries/LittleFS/examples \
-           ./libraries/rp2040 ./libraries/SD ./libraries/SdFat \
+           ./libraries/rp2040 ./libraries/SD ./libraries/ESP8266SdFat \
            ./libraries/Servo ./libraries/SPI ./libraries/Wire; do
     find $dir -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" \) -a  \! -path '*api*' -exec astyle --suffix=none --options=./tests/astyle_core.conf \{\} \;
     find $dir -type f -name "*.ino" -exec astyle --suffix=none --options=./tests/astyle_examples.conf \{\} \;

tools/README.md

@@ -25,11 +25,15 @@ rely on existence of `sed` command.
 
 ## makeboards.py
 Generates `boards.txt` programmatically.  Never edit the `boards.txt` file
-manually, use `python3 tools/makeboards.py > boards.py`.  Change the script
+manually, use `python3 tools/makeboards.py`.  Change the script
 as necessary to add any add'l fields or menus required.  Used because the
 `boards.txt` file is very repetitive and it's safer to generate with code
 than by hand.
 
+## makever.py
+Updates the version info prior to a release in platform.txt, package.json,
+and the version header.   Run from root of the repo.
+
 ## libpico/make-libpico.sh
 Builds the libpico.a file as well as the bootloader stage2 binaries.
 Run whenever the pico-sdk is updated.

tools/json/README.md

@@ -0,0 +1 @@
+This directory contains JSON board definitions for use with Platform.IO

tools/json/adafruit_feather.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_FEATHER_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_feather",
+        "boot2_source": "boot2_w25x10cl_4_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x80f1",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "Feather RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Feather RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/adafruit_itsybitsy.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_ITSYBITSY_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_itsybitsy",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x80fd",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "ItsyBitsy RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "ItsyBitsy RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/adafruit_kb2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_KB2040_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_kb2040",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x8105",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "KB2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "KB2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/adafruit_macropad2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_MACROPAD_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_macropad2040",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x8107",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "MacroPad RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "MacroPad RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/adafruit_qtpy.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_QTPY_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_qtpy",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x80f7",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "QT Py RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "QT Py RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/adafruit_stemmafriend.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_STEMMAFRIEND_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_stemmafriend",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x80e3",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "STEMMA Friend RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "STEMMA Friend RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/adafruit_trinkeyrp2040qt.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ADAFRUIT_TRINKEYQT_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "adafruit_trinkeyrp2040qt",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x239a",
+        "usb_pid": "0x8109",
+        "usb_manufacturer": "Adafruit",
+        "usb_product": "Trinkey RP2040 QT"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Trinkey RP2040 QT",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Adafruit"
+}

tools/json/arduino_nano_connect.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_NANO_RP2040_CONNECT -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "arduino_nano_connect",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2341",
+        "usb_pid": "0x0058",
+        "usb_manufacturer": "Arduino",
+        "usb_product": "Nano RP2040 Connect"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Nano RP2040 Connect",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Arduino"
+}

tools/json/challenger_2040_lora.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_CHALLENGER_2040_LORA_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "challenger_2040_lora",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1023",
+        "usb_manufacturer": "iLabs",
+        "usb_product": "Challenger 2040 LoRa"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Challenger 2040 LoRa",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "iLabs"
+}

tools/json/challenger_2040_lte.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_CHALLENGER_2040_LTE_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "challenger_2040_lte",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x100b",
+        "usb_manufacturer": "iLabs",
+        "usb_product": "Challenger 2040 LTE"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Challenger 2040 LTE",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "iLabs"
+}

tools/json/challenger_2040_wifi.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_CHALLENGER_2040_WIFI_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "challenger_2040_wifi",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1006",
+        "usb_manufacturer": "iLabs",
+        "usb_product": "Challenger 2040 WiFi"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Challenger 2040 WiFi",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "iLabs"
+}

tools/json/challenger_nb_2040_wifi.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_CHALLENGER_NB_2040_WIFI_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "challenger_nb_2040_wifi",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x100b",
+        "usb_manufacturer": "iLabs",
+        "usb_product": "Challenger NB 2040 WiFi"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Challenger NB 2040 WiFi",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "iLabs"
+}

tools/json/cytron_maker_nano_rp2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_CYTRON_MAKER_NANO_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "cytron_maker_nano_rp2040",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x100f",
+        "usb_manufacturer": "Cytron",
+        "usb_product": "Maker Nano RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Maker Nano RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 2097152,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Cytron"
+}

tools/json/cytron_maker_pi_rp2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_CYTRON_MAKER_PI_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "cytron_maker_pi_rp2040",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1000",
+        "usb_manufacturer": "Cytron",
+        "usb_product": "Maker Pi RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Maker Pi RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 2097152,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Cytron"
+}

tools/json/dfrobot_beetle_rp2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_DFROBOT_BEETLE_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "dfrobot_beetle_rp2040",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x3343",
+        "usb_pid": "0x4253",
+        "usb_manufacturer": "DFRobot",
+        "usb_product": "Beetle RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Beetle RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 2097152,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "DFRobot"
+}

tools/json/flyboard2040_core.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_FLYBOARD2040_CORE -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "flyboard2040_core",
+        "boot2_source": "boot2_generic_03h_4_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x008a",
+        "usb_manufacturer": "DeRuiLab",
+        "usb_product": "FlyBoard2040Core"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "FlyBoard2040Core",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 4194304,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "DeRuiLab"
+}

tools/json/generic.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_GENERIC_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "generic",
+        "boot2_source": "boot2_generic_03h_4_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0xf00a",
+        "usb_manufacturer": "Generic",
+        "usb_product": "RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Generic"
+}

tools/json/ilabs_rpico32.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_ILABS_2040_RPICO32_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "ilabs_rpico32",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1010",
+        "usb_manufacturer": "iLabs",
+        "usb_product": "RPICO32"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "RPICO32",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "iLabs"
+}

tools/json/melopero_shake_rp2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_MELOPERO_SHAKE_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "melopero_shake_rp2040",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1005",
+        "usb_manufacturer": "Melopero",
+        "usb_product": "Shake RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Shake RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Melopero"
+}

tools/json/rpipico.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_RASPBERRY_PI_PICO -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "rpipico",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x000a",
+        "usb_manufacturer": "Raspberry Pi",
+        "usb_product": "Pico"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Pico",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 2097152,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Raspberry Pi"
+}

tools/json/solderparty_rp2040_stamp.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_SOLDERPARTY_RP2040_STAMP -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "solderparty_rp2040_stamp",
+        "boot2_source": "boot2_generic_03h_4_padded_checksum.S",
+        "usb_vid": "0x1209",
+        "usb_pid": "0xa182",
+        "usb_manufacturer": "Solder Party",
+        "usb_product": "RP2040 Stamp"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "RP2040 Stamp",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 8388608,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "Solder Party"
+}

tools/json/sparkfun_promicrorp2040.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_SPARKFUN_PROMICRO_RP2040 -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "sparkfun_promicrorp2040",
+        "boot2_source": "boot2_generic_03h_4_padded_checksum.S",
+        "usb_vid": "0x1b4f",
+        "usb_pid": "0x0026",
+        "usb_manufacturer": "SparkFun",
+        "usb_product": "ProMicro RP2040"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "ProMicro RP2040",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "SparkFun"
+}

tools/json/upesy_rp2040_devkit.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_UPESY_RP2040_DEVKIT -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "upesy_rp2040_devkit",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1007",
+        "usb_manufacturer": "uPesy",
+        "usb_product": "RP2040 DevKit"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "RP2040 DevKit",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 2097152,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "uPesy"
+}

tools/json/wiznet_5100s_evb_pico.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_WIZNET_5100S_EVB_PICO -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=250",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "wiznet_5100s_evb_pico",
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x2e8a",
+        "usb_pid": "0x1008",
+        "usb_manufacturer": "WIZnet",
+        "usb_product": "W5100S-EVB-Pico"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "W5100S-EVB-Pico",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 2097152,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "WIZnet"
+}

tools/libpico/CMakeLists.txt

@@ -53,6 +53,7 @@ target_link_libraries(pico
 	hardware_vreg
 	hardware_watchdog
 	hardware_xosc
+	cmsis
 	pico_bit_ops
 	pico_bootrom
 	pico_bootsel_via_double_reset
@@ -70,8 +71,9 @@ target_link_libraries(pico
 	pico_standard_link
 	pico_stdlib
 	pico_unique_id
+	pico_util
 	tinyusb
-        tinyusb_device_unmarked
+	tinyusb_device_unmarked
 	pico_audio
 	pico_audio_i2s
 )

tools/libpico/make-libpico.sh

@@ -23,6 +23,7 @@ for type in boot2_generic_03h boot2_is25lp080 boot2_w25q080 boot2_w25x10cl; do
         arm-none-eabi-gcc -march=armv6-m -mcpu=cortex-m0plus -mthumb -O3 \
                          -DNDEBUG -DPICO_FLASH_SPI_CLKDIV=$div \
                          -c "$PICO_SDK_PATH/src/rp2_common/boot_stage2/$type.S" \
+                         -I "$PICO_SDK_PATH/src/boards/include/boards/" \
                          -I "$PICO_SDK_PATH/src/rp2040/hardware_regs/include/" \
                          -I "$PICO_SDK_PATH/src/rp2_common/pico_platform/include/" \
                          -I "$PICO_SDK_PATH/src/rp2_common/boot_stage2/asminclude/" \

tools/libpico/pico_extras_import.cmake

@@ -26,14 +26,14 @@ if (NOT PICO_EXTRAS_PATH)
             get_filename_component(FETCHCONTENT_BASE_DIR "${PICO_EXTRAS_FETCH_FROM_GIT_PATH}" REALPATH BASE_DIR "${CMAKE_SOURCE_DIR}")
         endif ()
         FetchContent_Declare(
-                PICO_EXTRAS
+                pico_extras
                 GIT_REPOSITORY https://github.com/raspberrypi/pico-extras
                 GIT_TAG master
         )
-        if (NOT PICO_EXTRAS)
-            message("Downloading PICO EXTRAS")
-            FetchContent_Populate(PICO_EXTRAS)
-            set(PICO_EXTRAS_PATH ${PICO_EXTRAS_SOURCE_DIR})
+        if (NOT pico_extras)
+            message("Downloading Raspberry Pi Pico Extras")
+            FetchContent_Populate(pico_extras)
+            set(PICO_EXTRAS_PATH ${pico_extras_SOURCE_DIR})
         endif ()
         set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE})
     else ()
@@ -59,4 +59,4 @@ endif ()
 
 set(PICO_EXTRAS_PATH ${PICO_EXTRAS_PATH} CACHE PATH "Path to the PICO EXTRAS" FORCE)
 
-add_subdirectory(${PICO_EXTRAS_PATH} pico_extras)
+add_subdirectory(${PICO_EXTRAS_PATH} pico_extras)

tools/libpico/pico_sdk_import.cmake

@@ -3,8 +3,6 @@
 # This can be dropped into an external project to help locate this SDK
 # It should be include()ed prior to project()
 
-# todo document
-
 if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH))
     set(PICO_SDK_PATH $ENV{PICO_SDK_PATH})
     message("Using PICO_SDK_PATH from environment ('${PICO_SDK_PATH}')")
@@ -20,8 +18,8 @@ if (DEFINED ENV{PICO_SDK_FETCH_FROM_GIT_PATH} AND (NOT PICO_SDK_FETCH_FROM_GIT_P
     message("Using PICO_SDK_FETCH_FROM_GIT_PATH from environment ('${PICO_SDK_FETCH_FROM_GIT_PATH}')")
 endif ()
 
-set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the PICO SDK")
-set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of PICO SDK from git if not otherwise locatable")
+set(PICO_SDK_PATH "${PICO_SDK_PATH}" CACHE PATH "Path to the Raspberry Pi Pico SDK")
+set(PICO_SDK_FETCH_FROM_GIT "${PICO_SDK_FETCH_FROM_GIT}" CACHE BOOL "Set to ON to fetch copy of SDK from git if not otherwise locatable")
 set(PICO_SDK_FETCH_FROM_GIT_PATH "${PICO_SDK_FETCH_FROM_GIT_PATH}" CACHE FILEPATH "location to download SDK")
 
 if (NOT PICO_SDK_PATH)
@@ -37,14 +35,14 @@ if (NOT PICO_SDK_PATH)
                 GIT_TAG master
         )
         if (NOT pico_sdk)
-            message("Downloading PICO SDK")
+            message("Downloading Raspberry Pi Pico SDK")
             FetchContent_Populate(pico_sdk)
             set(PICO_SDK_PATH ${pico_sdk_SOURCE_DIR})
         endif ()
         set(FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR_SAVE})
     else ()
         message(FATAL_ERROR
-                "PICO SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git."
+                "SDK location was not specified. Please set PICO_SDK_PATH or set PICO_SDK_FETCH_FROM_GIT to on to fetch from git."
                 )
     endif ()
 endif ()
@@ -56,9 +54,9 @@ endif ()
 
 set(PICO_SDK_INIT_CMAKE_FILE ${PICO_SDK_PATH}/pico_sdk_init.cmake)
 if (NOT EXISTS ${PICO_SDK_INIT_CMAKE_FILE})
-    message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the PICO SDK")
+    message(FATAL_ERROR "Directory '${PICO_SDK_PATH}' does not appear to contain the Raspberry Pi Pico SDK")
 endif ()
 
-set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the PICO SDK" FORCE)
+set(PICO_SDK_PATH ${PICO_SDK_PATH} CACHE PATH "Path to the Raspberry Pi Pico SDK" FORCE)
 
 include(${PICO_SDK_INIT_CMAKE_FILE})

tools/makeboards.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+import os
+import sys
 
 def BuildFlashMenu(name, flashsize, fssizelist):
     for fssize in fssizelist:
@@ -36,6 +38,18 @@ def BuildFreq(name):
         print("%s.menu.freq.%s=%s MHz%s" % (name, f, f, warn))
         print("%s.menu.freq.%s.build.f_cpu=%dL" % (name, f, f * 1000000))
 
+def BuildOptimize(name):
+    for l in [ ("Small", "Small", "-Os", " (standard)"), ("Optimize", "Optimize", "-O", ""), ("Optimize2", "Optimize More", "-O2", ""),
+               ("Optimize3", "Optimize Even More", "-O3", ""), ("Fast", "Fast", "-Ofast", " (maybe slower)"), ("Debug", "Debug", "-Og", "") ]:
+        print("%s.menu.opt.%s=%s (%s)%s" % (name, l[0], l[1], l[2], l[3]))
+        print("%s.menu.opt.%s.build.flags.optimize=%s" % (name, l[0], l[2]))
+
+def BuildRTTI(name):
+    print("%s.menu.rtti.Disabled=Disabled" % (name))
+    print("%s.menu.rtti.Disabled.build.flags.rtti=-fno-rtti" % (name))
+    print("%s.menu.rtti.Enabled=Enabled" % (name))
+    print("%s.menu.rtti.Enabled.build.flags.rtti=" % (name))
+
 def BuildBoot(name):
     for l in [ ("Generic SPI /2", "boot2_generic_03h_2_padded_checksum"),  ("Generic SPI /4", "boot2_generic_03h_4_padded_checksum"),
             ("IS25LP080 QSPI /2", "boot2_is25lp080_2_padded_checksum"), ("IS25LP080 QSPI /4", "boot2_is25lp080_4_padded_checksum"),
@@ -54,7 +68,7 @@ def BuildWithoutUSBStack(name):
     print("%s.menu.usbstack.nousb=No USB" % (name))
     print('%s.menu.usbstack.nousb.build.usbstack_flags="-DNO_USB -DDISABLE_USB_SERIAL -I{runtime.platform.path}/tools/libpico"' % (name))
 
-def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, boarddefine, variant, uploadtool, flashsize, ramsize, boot2):
+def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, pwr, boarddefine, variant, uploadtool, flashsize, ramsize, boot2):
     prettyname = vendor_name + " " + product_name
     print()
     print("# -----------------------------------")
@@ -64,6 +78,7 @@ def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, b
     print("%s.vid.0=%s" % (name, vidtouse))
     print("%s.pid.0=%s" % (name, pidtouse))
     print("%s.build.usbpid=-DSERIALUSB_PID=%s" % (name, pid))
+    print("%s.build.usbpwr=-DUSBD_MAX_POWER_MA=%s" % (name, pwr))
     print("%s.build.board=%s" % (name, boarddefine))
     print("%s.build.mcu=cortex-m0plus" % (name))
     print("%s.build.variant=%s" % (name, variant))
@@ -77,7 +92,6 @@ def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, b
     print("%s.build.f_cpu=125000000" % (name))
     print("%s.build.led=" % (name))
     print("%s.build.core=rp2040" % (name))
-    print("%s.build.mcu=rp2040" % (name))
     print("%s.build.ldscript=memmap_default.ld" % (name))
     print("%s.build.ram_length=%dk" % (name, ramsize / 1024))
     print("%s.build.boot2=%s" % (name, boot2))
@@ -86,17 +100,25 @@ def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, b
     print('%s.build.usb_manufacturer="%s"' % (name, vendor_name))
     print('%s.build.usb_product="%s"' % (name, product_name))
 
+def WriteWarning():
+    print("# WARNING - DO NOT EDIT THIS FILE, IT IS MACHINE GENERATED")
+    print("#           To change something here, edit tools/makeboards.py and")
+    print("#           run 'python3 makeboards.py > ../boards.txt' to regenerate")
+    print()
+
 def BuildGlobalMenuList():
     print("menu.BoardModel=Model")
     print("menu.flash=Flash Size")
     print("menu.freq=CPU Speed")
+    print("menu.opt=Optimize")
+    print("menu.rtti=RTTI")
     print("menu.dbgport=Debug Port")
     print("menu.dbglvl=Debug Level")
     print("menu.boot2=Boot Stage 2")
     print("menu.usbstack=USB Stack")
 
 
-def MakeBoard(name, vendor_name, product_name, vid, pid, boarddefine, flashsizemb, boot2):
+def MakeBoard(name, vendor_name, product_name, vid, pid, pwr, boarddefine, flashsizemb, boot2):
     for a, b, c in [ ["", "", "uf2conv"], ["picoprobe", " (Picoprobe)", "picoprobe"], ["picodebug", " (pico-debug)", "picodebug"]]:
         n = name + a
         p = product_name + b
@@ -113,7 +135,7 @@ def MakeBoard(name, vendor_name, product_name, vid, pid, boarddefine, flashsizem
             ramsizekb = 240;
         else:
             pidtouse = pid
-        BuildHeader(n, vendor_name, p, vidtouse, pidtouse, vid, pid, boarddefine, name, c, flashsizemb * 1024 * 1024, ramsizekb * 1024, boot2)
+        BuildHeader(n, vendor_name, p, vidtouse, pidtouse, vid, pid, pwr, boarddefine, name, c, flashsizemb * 1024 * 1024, ramsizekb * 1024, boot2)
         if name == "generic":
             BuildFlashMenu(n, 2*1024*1024, [0, 1*1024*1024])
             BuildFlashMenu(n, 4*1024*1024, [0, 2*1024*1024])
@@ -122,6 +144,8 @@ def MakeBoard(name, vendor_name, product_name, vid, pid, boarddefine, flashsizem
         else:
             BuildFlashMenu(n, flashsizemb * 1024 * 1024, fssizelist)
         BuildFreq(n)
+        BuildOptimize(n)
+        BuildRTTI(n)
         BuildDebugPort(n)
         BuildDebugLevel(n)
         if a == "picodebug":
@@ -130,19 +154,127 @@ def MakeBoard(name, vendor_name, product_name, vid, pid, boarddefine, flashsizem
             BuildUSBStack(n)
         if name == "generic":
             BuildBoot(n)
+    MakeBoardJSON(name, vendor_name, product_name, vid, pid, pwr, boarddefine, flashsizemb, boot2)
 
+def MakeBoardJSON(name, vendor_name, product_name, vid, pid, pwr, boarddefine, flashsizemb, boot2):
+    json = """{
+  "build": {
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_BOARDDEFINE -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=USBPWR",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ]
+    ],
+    "mcu": "rp2040",
+    "arduino": {
+      "earlephilhower": {
+        "variant": "VARIANTNAME",
+        "boot2_source": "BOOT2.S",
+        "usb_vid": "VID",
+        "usb_pid": "PID",
+        "usb_manufacturer": "VENDORNAME",
+        "usb_product": "PRODUCTNAME"
+      }
+    }
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "PRODUCTNAME",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": FLASHSIZE,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "VENDORNAME"
+}""".replace('VARIANTNAME', name).replace('BOARDDEFINE', boarddefine).replace('BOOT2', boot2).replace('VID', vid).replace('PID', pid).replace('VENDORNAME', vendor_name).replace('PRODUCTNAME', product_name).replace('FLASHSIZE', str(1024*1024*flashsizemb)).replace('USBPWR', str(pwr))
+    jsondir = os.path.abspath(os.path.dirname(__file__)) + "/json"
+    f = open(jsondir + "/" + name + ".json", "w")
+    f.write(json)
+    f.close()
 
+sys.stdout = open(os.path.abspath(os.path.dirname(__file__)) + "/../boards.txt", "w")
+WriteWarning()
 BuildGlobalMenuList()
-MakeBoard("rpipico", "Raspberry Pi", "Pico", "0x2e8a", "0x000a", "RASPBERRY_PI_PICO", 2, "boot2_w25q080_2_padded_checksum")
-MakeBoard("adafruit_feather", "Adafruit", "Feather RP2040", "0x239a", "0x80f1", "ADAFRUIT_FEATHER_RP2040", 8, "boot2_w25x10cl_4_padded_checksum")
-MakeBoard("adafruit_itsybitsy", "Adafruit", "ItsyBitsy RP2040", "0x239a", "0x80fd", "ADAFRUIT_ITSYBITSY_RP2040", 8, "boot2_w25q080_2_padded_checksum")
-MakeBoard("adafruit_qtpy", "Adafruit", "QT Py RP2040", "0x239a", "0x80f7", "ADAFRUIT_QTPY_RP2040", 8, "boot2_generic_03h_4_padded_checksum")
-MakeBoard("adafruit_stemmafriend", "Adafruit", "STEMMA Friend RP2040", "0x239a", "0x80e3", "ADAFRUIT_STEMMAFRIEND_RP2040", 8, "boot2_w25q080_2_padded_checksum")
-MakeBoard("adafruit_trinkeyrp2040qt", "Adafruit", "Trinkey RP2040 QT", "0x239a", "0x8109", "ADAFRUIT_TRINKEYQT_RP2040", 8, "boot2_w25q080_2_padded_checksum")
-MakeBoard("adafruit_macropad2040", "Adafruit", "MacroPad RP2040", "0x239a", "0x8107", "ADAFRUIT_MACROPAD_RP2040", 8, "boot2_w25q080_2_padded_checksum")
-MakeBoard("arduino_nano_connect", "Arduino", "Nano RP2040 Connect", "0x2341", "0x0058", "ARDUINO_NANO_RP2040_CONNECT", 16, "boot2_w25q080_2_padded_checksum")
-MakeBoard("sparkfun_promicrorp2040", "SparkFun", "ProMicro RP2040", "0x1b4f", "0x0026", "SPARKFUN_PROMICRO_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
-MakeBoard("generic", "Generic", "RP2040", "0x2e8a", "0xf00a", "GENERIC_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
-MakeBoard("challenger_2040_wifi", "iLabs", "Challenger 2040 WiFi", "0x2e8a", "0x1006", "CHALLENGER_2040_WIFI_RP2040", 8, "boot2_w25q080_2_padded_checksum")
-MakeBoard("challenger_2040_lte", "iLabs", "Challenger 2040 LTE", "0x2e8a", "0x100b", "CHALLENGER_2040_LTE_RP2040", 8, "boot2_w25q080_2_padded_checksum")
-MakeBoard("melopero_shake_rp2040", "Melopero", "Shake RP2040", "0x2e8a", "0x1005", "MELOPERO_SHAKE_RP2040", 16, "boot2_w25q080_2_padded_checksum")
+
+# Note to new board manufacturers:  Please add your board so that it sorts
+# alphabetically starting with the company name and then the board name.
+# Otherwise it is difficult to find a specific board in the menu.
+
+# Raspberry Pi
+MakeBoard("rpipico", "Raspberry Pi", "Pico", "0x2e8a", "0x000a", 250, "RASPBERRY_PI_PICO", 2, "boot2_w25q080_2_padded_checksum")
+
+# Adafruit
+MakeBoard("adafruit_feather", "Adafruit", "Feather RP2040", "0x239a", "0x80f1", 250, "ADAFRUIT_FEATHER_RP2040", 8, "boot2_w25x10cl_4_padded_checksum")
+MakeBoard("adafruit_itsybitsy", "Adafruit", "ItsyBitsy RP2040", "0x239a", "0x80fd", 250, "ADAFRUIT_ITSYBITSY_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("adafruit_qtpy", "Adafruit", "QT Py RP2040", "0x239a", "0x80f7", 250, "ADAFRUIT_QTPY_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("adafruit_stemmafriend", "Adafruit", "STEMMA Friend RP2040", "0x239a", "0x80e3", 250, "ADAFRUIT_STEMMAFRIEND_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("adafruit_trinkeyrp2040qt", "Adafruit", "Trinkey RP2040 QT", "0x239a", "0x8109", 250, "ADAFRUIT_TRINKEYQT_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("adafruit_macropad2040", "Adafruit", "MacroPad RP2040", "0x239a", "0x8107", 250, "ADAFRUIT_MACROPAD_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("adafruit_kb2040", "Adafruit", "KB2040", "0x239a", "0x8105", 250, "ADAFRUIT_KB2040_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+
+# Arduino
+MakeBoard("arduino_nano_connect", "Arduino", "Nano RP2040 Connect", "0x2341", "0x0058", 250, "NANO_RP2040_CONNECT", 16, "boot2_w25q080_2_padded_checksum")
+
+# Cytron
+MakeBoard("cytron_maker_nano_rp2040", "Cytron", "Maker Nano RP2040", "0x2e8a", "0x100f", 250, "CYTRON_MAKER_NANO_RP2040", 2, "boot2_w25q080_2_padded_checksum")
+MakeBoard("cytron_maker_pi_rp2040", "Cytron", "Maker Pi RP2040", "0x2e8a", "0x1000", 250, "CYTRON_MAKER_PI_RP2040", 2, "boot2_w25q080_2_padded_checksum")
+
+# DeRuiLab
+MakeBoard("flyboard2040_core", "DeRuiLab", "FlyBoard2040Core", "0x2e8a", "0x008a", 500, "FLYBOARD2040_CORE", 4, "boot2_generic_03h_4_padded_checksum")
+
+# DFRobot
+MakeBoard("dfrobot_beetle_rp2040", "DFRobot", "Beetle RP2040", "0x3343", "0x4253", 250, "DFROBOT_BEETLE_RP2040", 2, "boot2_w25q080_2_padded_checksum")
+
+# iLabs
+MakeBoard("challenger_2040_lora", "iLabs", "Challenger 2040 LoRa", "0x2e8a", "0x1023", 250, "CHALLENGER_2040_LORA_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("challenger_2040_wifi", "iLabs", "Challenger 2040 WiFi", "0x2e8a", "0x1006", 250, "CHALLENGER_2040_WIFI_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("challenger_2040_lte", "iLabs", "Challenger 2040 LTE", "0x2e8a", "0x100b", 500, "CHALLENGER_2040_LTE_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("challenger_nb_2040_wifi", "iLabs", "Challenger NB 2040 WiFi", "0x2e8a", "0x100b", 500, "CHALLENGER_NB_2040_WIFI_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+MakeBoard("ilabs_rpico32", "iLabs", "RPICO32", "0x2e8a", "0x1010", 250, "ILABS_2040_RPICO32_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+
+# Melopera
+MakeBoard("melopero_shake_rp2040", "Melopero", "Shake RP2040", "0x2e8a", "0x1005", 250, "MELOPERO_SHAKE_RP2040", 16, "boot2_w25q080_2_padded_checksum")
+
+# Solder Party
+MakeBoard("solderparty_rp2040_stamp", "Solder Party", "RP2040 Stamp", "0x1209", "0xa182", 500, "SOLDERPARTY_RP2040_STAMP", 8, "boot2_generic_03h_4_padded_checksum")
+
+# SparkFun
+MakeBoard("sparkfun_promicrorp2040", "SparkFun", "ProMicro RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_PROMICRO_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
+MakeBoard("sparkfun_thingplusrp2040", "SparkFun", "Thing Plus RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_THINGPLUS_RP2040", 16, "boot2_w25q080_2_padded_checksum")
+
+# Upesy
+MakeBoard("upesy_rp2040_devkit", "uPesy", "RP2040 DevKit", "0x2e8a", "0x1007", 250, "UPESY_RP2040_DEVKIT", 2, "boot2_w25q080_2_padded_checksum")
+
+# Seeed
+MakeBoard("seeed_xiao_rp2040", "Seeed", "XAIO RP2040", "0x2e8a", "0x000a", 250, "SEEED_XAIO_RP2040", 2, "boot2_w25q080_2_padded_checksum")
+
+# WIZnet
+MakeBoard("wiznet_5100s_evb_pico", "WIZnet", "W5100S-EVB-Pico", "0x2e8a", "0x1008", 250, "WIZNET_5100S_EVB_PICO", 2, "boot2_w25q080_2_padded_checksum")
+
+# Generic
+MakeBoard("generic", "Generic", "RP2040", "0x2e8a", "0xf00a", 250, "GENERIC_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
+
+
+sys.stdout.close()

tools/makever.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+import sys
+import struct
+import subprocess
+import re
+import os
+import os.path
+import argparse
+import time
+import shutil
+
+def main():
+    parser = argparse.ArgumentParser(description='Version updater')
+    parser.add_argument('-v', '--version', action='store', required=True, help='Version in X.Y.Z form')
+    args = parser.parse_args()
+
+    major, minor, sub = args.version.split(".")
+    # Silly way to check for integer x.y.z
+    major = int(major)
+    minor = int(minor)
+    sub = int(sub)
+
+    # platform.txt
+    with open("platform.txt", "r") as fin:
+        with open("platform.txt.new", "w") as fout:
+            for l in fin:
+                if l.startswith("version="):
+                    l = "version=" + str(args.version) + "\n"
+                fout.write(l);
+    shutil.move("platform.txt.new", "platform.txt")
+
+    # package.json
+    with open("package.json", "r") as fin:
+        with open("package.json.new", "w") as fout:
+            for l in fin:
+                if l.startswith('  "version": '):
+                    l = l.split(":")[0]
+                    l = l + ': "1.' + str(major) + "{:02d}".format(minor) + "{:02d}".format(sub) + '.0",' + "\n"
+                fout.write(l);
+    shutil.move("package.json.new", "package.json")
+
+    # cores/rp2040/RP2040Version.h
+    with open("cores/rp2040/RP2040Version.h", "w") as fout:
+        fout.write("#pragma once\n")
+        fout.write("#define ARDUINO_PICO_MAJOR " + str(major) + "\n")
+        fout.write("#define ARDUINO_PICO_MINOR " + str(minor) + "\n")
+        fout.write("#define ARDUINO_PICO_REVISION " + str(sub) + "\n")
+        fout.write('#define ARDUINO_PICO_VERSION_STR "' + str(args.version) + '"' + "\n")
+
+main()

tools/platformio-build.py

@@ -1,4 +1,5 @@
 # Copyright 2021-present Maximilian Gerhardt <maximilian.gerhardt@rub.de>
+# TinyUSB ignore snippet from https://github.com/episource/
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,7 +20,9 @@ env = DefaultEnvironment()
 platform = env.PioPlatform()
 board = env.BoardConfig()
 upload_protocol = env.subst("$UPLOAD_PROTOCOL") or "picotool"
-ram_size = board.get("upload.maximum_ram_size")
+#ram_size = board.get("upload.maximum_ram_size") # PlatformIO gives 264K here
+# override to correct 256K for RAM section in linkerscript
+ram_size = 256 * 1024 # not the 264K, which is 256K SRAM + 2*4K SCRATCH(X/Y). 
 
 FRAMEWORK_DIR = platform.get_package_dir("framework-arduinopico")
 assert os.path.isdir(FRAMEWORK_DIR)
@@ -84,12 +87,16 @@ env.Append(
 
     LIBSOURCE_DIRS=[os.path.join(FRAMEWORK_DIR, "libraries")],
 
-    LIBPATH=[
-        os.path.join(FRAMEWORK_DIR, "lib")
-    ],
+    # do **NOT** Add lib to LIBPATH, otherwise 
+    # erroneous libstdc++.a will be found that crashes! 
+    #LIBPATH=[
+    #    os.path.join(FRAMEWORK_DIR, "lib")
+    #],
 
-    # link lib/libpico.a
-    LIBS=["pico", "m", "c", "stdc++", "c"]
+    # link lib/libpico.a by full path, ignore libstdc++
+    LIBS=[
+        File(os.path.join(FRAMEWORK_DIR, "lib", "libpico.a")), 
+        "m", "c", "stdc++", "c"]
 )
 
 
@@ -145,6 +152,10 @@ def configure_usb_flags(cpp_defines):
         ("SERIALUSB_PID", usb_pid)
     ])
 
+    if "USBD_MAX_POWER_MA" not in env.Flatten(env.get("CPPDEFINES", [])):
+        env.Append(CPPDEFINES=[("USBD_MAX_POWER_MA", 500)])
+        print("Warning: Undefined USBD_MAX_OWER_MA, assuming 500mA")
+
     # use vidtouse and pidtouse 
     # for USB PID/VID autodetection
     hw_ids = board.get("build.hwids", [["0x2E8A", "0x00C0"]])
@@ -158,6 +169,18 @@ def configure_usb_flags(cpp_defines):
 #
 cpp_defines = env.Flatten(env.get("CPPDEFINES", []))
 
+# Ignore TinyUSB automatically if not active without requiring ldf_mode = chain+
+if not "USE_TINYUSB" in cpp_defines:
+    env_section = "env:" + env["PIOENV"]
+    ignored_libs = platform.config.get(
+            env_section, "lib_ignore", []
+        )
+    if not "Adafruit TinyUSB Library" in ignored_libs:
+        ignored_libs.append("Adafruit TinyUSB Library")
+    platform.config.set(
+            env_section, "lib_ignore", ignored_libs
+        )
+# configure USB stuff
 configure_usb_flags(cpp_defines)
 
 # info about the filesystem is already parsed by the platform's main.py 
@@ -188,9 +211,9 @@ if not board.get("build.ldscript", ""):
 
 libs = []
 
-variant = board.get("build.arduino.earlephilhower.variant", board.get("build.variant", None))
+variant = board.get("build.arduino.earlephilhower.variant", board.get("build.variant", ""))
 
-if variant is not None:
+if variant != "":
     env.Append(CPPPATH=[
         os.path.join(FRAMEWORK_DIR, "variants", variant)
     ])

tools/uf2conv.py

@@ -228,17 +228,29 @@ def to_str(b):
 def get_drives():
     drives = []
     if sys.platform == "win32":
-        r = subprocess.check_output(["wmic", "PATH", "Win32_LogicalDisk",
-                                     "get", "DeviceID,", "VolumeName,",
-                                     "FileSystem,", "DriveType"])
+        try:
+            r = subprocess.check_output(["wmic", "PATH", "Win32_LogicalDisk",
+                                         "get", "DeviceID,", "VolumeName,",
+                                         "FileSystem,", "DriveType"])
+        except:
+            try:
+                nul = open("nul:", "r")
+                r = subprocess.check_output(["powershell", "-NonInteractive", "-Command",
+                                            "Get-WmiObject -class Win32_LogicalDisk | "
+                                            "Format-Table -Property DeviceID, DriveType, Filesystem, VolumeName"],
+                                            stdin = nul)
+                nul.close()
+            except:
+                print("Unable to build drive list");
+                sys.exit(1)
         for line in to_str(r).split('\n'):
             words = re.split('\s+', line)
             if len(words) >= 3 and words[1] == "2" and words[2] == "FAT":
                 drives.append(words[0])
     else:
-        rootpath = "/media"
+        rootpath = "/run/media"
         if not os.path.isdir(rootpath):
-            rootpath = "/run/media"
+            rootpath = "/media"
         if not os.path.isdir(rootpath):
             rootpath = "/opt/media"
         if sys.platform == "darwin":
@@ -318,17 +330,16 @@ def main():
     if args.serial:
         if str(args.serial).startswith("/dev/tty") or str(args.serial).startswith("COM") or str(args.serial).startswith("/dev/cu"):
             try:
-                print("Resetting "+str(args.serial))
+                print("Resetting " + str(args.serial))
                 try:
                     ser = serial.Serial(args.serial, 1200)
                     ser.dtr = False
                 except:
-                    pass
+                    print("Caught exception during reset!")
                 # Probably should be smart and check for device appearance or something
                 time.sleep(10)
             except:
                 pass
-
     if args.list:
         list_drives()
     else:
@@ -359,12 +370,31 @@ def main():
         else:
             drives = get_drives()
             if (len(drives) == 0) and (sys.platform == "linux"):
-                rpidisk = glob.glob("/dev/disk/by-id/usb-RPI_RP2*-part1")
-                try:
-                    subprocess.run(["udisksctl", "mount", "--block-device", os.path.realpath(rpidisk[0])])
-                    drives = get_drives()
-                except:
-                    pass # If it fails, no problem since it was a heroic attempt
+                globexpr = "/dev/disk/by-id/usb-RPI_RP2*-part1"
+                rpidisk = glob.glob(globexpr)
+                if len(rpidisk) == 0:
+                    print("Unable to find disk by ID using expression: {}".format(globexpr))
+                else:
+                    try:
+                        cmd = ["udisksctl", "mount", "--block-device", os.path.realpath(rpidisk[0])]
+                        proc_out = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                        if proc_out.returncode == 0:
+                            stdoutput = proc_out.stdout.decode("UTF-8")
+                            match = re.search(r'Mounted\s+.*\s+at\s+([^\.\r\n]*)', stdoutput)
+                            if match is None:
+                                print("Warn: {} did not print mount point. Attempting to locate mounted drive in file system. StdOut={}".format(cmd[0], stdoutput))
+                                drives = get_drives()
+                            else:
+                                drives = [match.group(1)]
+                        else:
+                            print("Error executing command {}. Return Code: {} Std Output: {} StdError: {}".format(" ".join(cmd), 
+                                                                                                                   proc_out.returncode,
+                                                                                                                   proc_out.stdout.decode("UTF-8"),
+                                                                                                                   proc_out.stderr.decode("UTF-8")))
+
+                    except Exception as ex:
+                        print("Exception executing udisksctl. Exception: {}".format(ex))
+                        # If it fails, no problem since it was a heroic attempt
 
         if args.output:
             write_file(args.output, outbuf)

variants/adafruit_feather/pins_arduino.h

@@ -6,6 +6,9 @@
 // LEDs
 #define PIN_LED        (13u)
 
+// NeoPixel
+#define PIN_NEOPIXEL   (16u)
+
 // Serial
 #define PIN_SERIAL1_TX (0u)
 #define PIN_SERIAL1_RX (1u)

variants/adafruit_itsybitsy/pins_arduino.h

@@ -6,6 +6,10 @@
 // LEDs
 #define PIN_LED        (11u)
 
+// NeoPixel
+#define PIN_NEOPIXEL   (17u)
+#define NEOPIXEL_POWER (16u)
+
 // Serial
 #define PIN_SERIAL1_TX (0u)
 #define PIN_SERIAL1_RX (1u)
@@ -27,15 +31,13 @@
 #define PIN_SPI1_SS    (31u)
 
 // Wire
-#define PIN_WIRE0_SDA  (2u)
-#define PIN_WIRE0_SCL  (3u)
-
-// Not pinned out
-#define PIN_WIRE1_SDA  (31u)
-#define PIN_WIRE1_SCL  (31u)
+#define PIN_WIRE0_SDA  (24u)
+#define PIN_WIRE0_SCL  (25u)
+#define PIN_WIRE1_SDA  (2u)
+#define PIN_WIRE1_SCL  (3u)
 
 #define SERIAL_HOWMANY (2u)
 #define SPI_HOWMANY    (1u)
-#define WIRE_HOWMANY   (1u)
+#define WIRE_HOWMANY   (2u)
 
 #include "../generic/common.h"

variants/adafruit_kb2040/pins_arduino.h

@@ -0,0 +1,42 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://learn.adafruit.com/assets/100337
+
+// LEDs not pinned out
+#define PIN_LED        (31u)
+
+// Serial
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+// Not pinned out
+#define PIN_SERIAL2_TX (31u)
+#define PIN_SERIAL2_RX (31u)
+
+// SPI
+#define PIN_SPI0_MISO  (20u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (31u) // not pinned out
+
+// Not pinned out
+#define PIN_SPI1_MISO  (31u)
+#define PIN_SPI1_MOSI  (31u)
+#define PIN_SPI1_SCK   (31u)
+#define PIN_SPI1_SS    (31u)
+
+// Wire is on the STEMMA QT port
+#define PIN_WIRE0_SDA  (12u)
+#define PIN_WIRE0_SCL  (13u)
+
+// Wire1 is on the breakout pins
+#define PIN_WIRE1_SDA  (2u)
+#define PIN_WIRE1_SCL  (3u)
+
+#define SERIAL_HOWMANY (1u)
+#define SPI_HOWMANY    (1u)
+#define WIRE_HOWMANY   (2u)
+
+#define PIN_NEOPIXEL   (17u)
+#include "../generic/common.h"

variants/adafruit_qtpy/pins_arduino.h

@@ -6,13 +6,17 @@
 // LEDs not pinned out
 #define PIN_LED        (31u)
 
-// Serial
-#define PIN_SERIAL1_TX (20u)
-#define PIN_SERIAL1_RX (5u)
+// NeoPixel
+#define PIN_NEOPIXEL   (12u)
+#define NEOPIXEL_POWER (11u)
 
-// Not pinned out
-#define PIN_SERIAL2_TX (31u)
-#define PIN_SERIAL2_RX (31u)
+// Serial1 not pinned out
+#define PIN_SERIAL1_TX (31u)
+#define PIN_SERIAL1_RX (31u)
+
+// Serial2 is the only one labelled
+#define PIN_SERIAL2_TX (20u)
+#define PIN_SERIAL2_RX (5u)
 
 // SPI
 #define PIN_SPI0_MISO  (4u)
@@ -38,4 +42,10 @@
 #define SPI_HOWMANY    (1u)
 #define WIRE_HOWMANY   (2u)
 
+// Pin overrides specific to the QT Py RP2040
+#define __PIN_A0 (29u)
+#define __PIN_A1 (28u)
+#define __PIN_A2 (27u)
+#define __PIN_A3 (26u)
+
 #include "../generic/common.h"

variants/arduino_nano_connect/nina_pins.cpp

@@ -0,0 +1,9 @@
+#include "nina_pins.h"
+
+NinaPin  LEDR(27);
+NinaPin  LEDG(25);
+NinaPin  LEDB(26);
+NinaPin  A4(34);
+NinaPin  A5(39);
+NinaPin  A6(36);
+NinaPin  A7(35);

variants/arduino_nano_connect/nina_pins.h

@@ -8,41 +8,49 @@
  ******************************************************************************/
 
 #include "Arduino.h"
-//#include "WiFiNINA.h"
-/******************************************************************************
- * PREPROCESSOR-MAGIC
- ******************************************************************************/
-
-#if __has_include("WiFiNINA.h")
-#  define NINA_ATTRIBUTE
-#else
-#  define NINA_ATTRIBUTE __attribute__ ((error("Please include WiFiNINA.h to use this pin")))
-#endif
 
 /******************************************************************************
  * TYPEDEF
  ******************************************************************************/
 
-enum NinaPin {
-  LEDR = 27,
-  LEDG = 25,
-  LEDB = 26//,
-  //A4   = 34,
-  //A5   = 39,
-  //A6   = 36,
-  //A7   = 35
+int getAnalogReadResolution();
+
+class NinaPin {
+public:
+	NinaPin(int _pin) : pin(_pin) {};
+	int get() {
+		return pin;
+	};
+	int analogReadResolution() {
+		return getAnalogReadResolution();
+	};
+	bool operator== (NinaPin const & other) const {
+		return pin == other.pin;
+	}
+	//operator int() = delete;
+	__attribute__ ((error("Change me to a #define"))) operator int();
+private:
+	int pin;
 };
 
+extern NinaPin  LEDR;
+extern NinaPin  LEDG;
+extern NinaPin  LEDB;
+extern NinaPin  A4;
+extern NinaPin  A5;
+extern NinaPin  A6;
+extern NinaPin  A7;
+
+#define NINA_PINS_AS_CLASS
+
 /******************************************************************************
  * FUNCTION DECLARATION
  ******************************************************************************/
 
-void      NINA_ATTRIBUTE pinMode     (NinaPin pin, PinMode mode);
-PinStatus NINA_ATTRIBUTE digitalRead (NinaPin pin);
-void      NINA_ATTRIBUTE digitalWrite(NinaPin pin, PinStatus value);
-int       NINA_ATTRIBUTE analogRead  (NinaPin pin);
-void      NINA_ATTRIBUTE analogWrite (NinaPin pin, int value);
-
-#undef NINA_ATTRIBUTE
+void      pinMode     (NinaPin pin, PinMode mode);
+PinStatus digitalRead (NinaPin pin);
+void      digitalWrite(NinaPin pin, PinStatus value);
+int       analogRead  (NinaPin pin);
+void      analogWrite (NinaPin pin, int value);
 
 #endif /* _NINA_PINS_ */

variants/arduino_nano_connect/pins_arduino.h

@@ -39,8 +39,6 @@ static const uint8_t A0 = (26u);
 static const uint8_t A1 = (27u);
 static const uint8_t A2 = (28u);
 static const uint8_t A3 = (29u);
-static const uint8_t A4 = (12u);
-static const uint8_t A5 = (13u);
 
 // LEDs
 #define PIN_LED        (D13)
@@ -49,26 +47,28 @@ static const uint8_t A5 = (13u);
 #define PIN_SERIAL1_TX (D1)
 #define PIN_SERIAL1_RX (D0)
 
-#define PIN_SERIAL2_TX (D25)
-#define PIN_SERIAL2_RX (D26)
+#define PIN_SERIAL2_TX  (D25)
+#define PIN_SERIAL2_RX  (D26)
+#define PIN_SERIAL2_CTS (D27)
+#define PIN_SERIAL2_RTS (D28)
 
 // SPI
 #define PIN_SPI0_MISO  (D12)
 #define PIN_SPI0_MOSI  (D11)
 #define PIN_SPI0_SCK   (D13)
-#define PIN_SPI0_SS    (13u)//(D10)
+#define PIN_SPI0_SS    (D10)
 
 #define PIN_SPI1_MISO  (D25)
 #define PIN_SPI1_MOSI  (D28)
 #define PIN_SPI1_SCK   (D29)
-#define PIN_SPI1_SS    (13u)
+#define PIN_SPI1_SS    (D10)
 
 // Wire
 #define PIN_WIRE0_SDA  (D18)
 #define PIN_WIRE0_SCL  (D19)
 
-#define PIN_WIRE1_SDA  (26u) //Non c'è
-#define PIN_WIRE1_SCL  (27u) //Non c'è
+#define PIN_WIRE1_SDA  (D14)
+#define PIN_WIRE1_SCL  (D15)
 
 #define SERIAL_HOWMANY (3u)
 #define SPI_HOWMANY    (2u)
@@ -95,7 +95,7 @@ static const uint8_t SCK = PIN_SPI0_SCK;
 #define SerialHCI		Serial2
 
 //#define NINA_GPIOIRQ	(21u) // LEDG pin (GPIO26 on NINA)
-#define NINA_GPIO0		(20u) // real GPIO0 on NINA
+#define NINA_GPIO0		(D20)   // (2u), real GPIO0 on NINA
 
 #define SPIWIFI_SS		(D26)
 #define SPIWIFI_ACK		(D27)

variants/challenger_2040_lora/pins_arduino.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#define PINS_COUNT          (25u)
+#define NUM_DIGITAL_PINS    (25u)
+#define NUM_ANALOG_INPUTS   (4u)
+#define NUM_ANALOG_OUTPUTS  (0u)
+#define ADC_RESOLUTION      (12u)
+
+// LEDs
+#define PIN_LED             (24u)
+
+// Serial
+#define PIN_SERIAL1_TX      (16u)
+#define PIN_SERIAL1_RX      (17u)
+
+// SPI
+#define PIN_SPI0_MISO       (20u)
+#define PIN_SPI0_MOSI       (23u)
+#define PIN_SPI0_SCK        (22u)
+#define PIN_SPI0_SS         (21u)
+
+// Connected to LoRa module
+#define PIN_SPI1_MISO       (12u)
+#define PIN_SPI1_MOSI       (11u)
+#define PIN_SPI1_SCK        (10u)
+#define PIN_SPI1_SS         (9u)
+#define RFM95W_SS           (9u)
+#define RFM95W_DIO0         (14u)
+#define RFM95W_DIO1         (15u)
+#define RFM95W_DIO2         (18u)
+#define RFM95W_RST          (13u)
+#define RFM95W_SPI          SPI1
+
+// Wire
+#define PIN_WIRE0_SDA       (0u)
+#define PIN_WIRE0_SCL       (1u)
+
+// Not pinned out
+#define PIN_WIRE1_SDA       (31u)
+#define PIN_WIRE1_SCL       (31u)
+#define PIN_SERIAL2_RX      (31u)
+#define PIN_SERIAL2_TX      (31u)
+
+#define SERIAL_HOWMANY      (1u)
+#define SPI_HOWMANY         (2u)
+#define WIRE_HOWMANY        (1u)
+
+#define LED_BUILTIN         PIN_LED
+
+static const uint8_t D0 =   (16u);
+static const uint8_t D1 =   (17u);
+static const uint8_t D2 =   (20u);
+static const uint8_t D3 =   (23u);
+static const uint8_t D4 =   (22u);
+static const uint8_t D5 =   (2u);
+static const uint8_t D6 =   (3u);
+static const uint8_t D7 =   (0u);
+static const uint8_t D8 =   (1u);
+static const uint8_t D9 =   (4u);
+static const uint8_t D10 =  (5u);
+static const uint8_t D11 =  (6u);
+static const uint8_t D12 =  (7u);
+static const uint8_t D13 =  (8u);
+static const uint8_t D14 = (13u);
+static const uint8_t D15 = (14u);
+static const uint8_t D16 = (15u);
+static const uint8_t D17 = (18u);
+static const uint8_t D18 = (24u);
+
+static const uint8_t A0 = (26u);
+static const uint8_t A1 = (27u);
+static const uint8_t A2 = (28u);
+static const uint8_t A3 = (29u);
+static const uint8_t A4 = (19u);
+static const uint8_t A5 = (21u);

variants/challenger_2040_lte/ChallengerLTE.cpp

@@ -0,0 +1,133 @@
+/*
+    UBlox SARA helper class for the Challenger RP2040 LTE boards
+
+    Copyright (c) 2021 P. Oldberg <pontus@ilabs.se>
+
+    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 <ChallengerLTE.h>
+
+Challenger2040LTEClass::Challenger2040LTEClass() {
+  pinMode(PIN_SARA_ON, OUTPUT);
+  digitalWrite(PIN_SARA_ON, LOW);           // Output register must always be low
+  pinMode(PIN_SARA_ON, INPUT_PULLUP);
+
+  pinMode(PIN_SARA_RST, INPUT_PULLUP);      // Keep as input for now
+
+  pinMode(PIN_SARA_PWR, OUTPUT);
+  digitalWrite(PIN_SARA_PWR, LOW);          // No power to SARA yet
+  serialPortConfigured = false;
+}
+
+// Do a HW reset by applying a low pulse to the reset line for 1mSec
+bool Challenger2040LTEClass::doPowerOn() {
+  bool ret;
+  digitalWrite(PIN_SARA_PWR, HIGH);         // Make sure LDO is on
+  delay(100);                               // let the power stabilize
+  pinMode(PIN_SARA_ON, OUTPUT);             // Pull power on control low
+  delay(150);                               // For 150mS
+  pinMode(PIN_SARA_ON, INPUT_PULLUP);       // before releasing it again.
+  delay(1000);                              // Now wait for 1 second
+  SARA_SERIAL_PORT.begin(DEFAULT_SARA_BAUDRATE);
+  serialPortConfigured = true;
+  ret = isAlive();                          // Makie sure the modem is
+                                            // up and running
+
+  delay(250);                               // Allow for any extra characters
+  // before flushing the input buffer
+  while(SARA_SERIAL_PORT.available()) SARA_SERIAL_PORT.read();
+
+  return ret;
+}
+
+// Checks to see if the modem responds to the "AT" poll command.
+bool Challenger2040LTEClass::isAlive(uint32_t timeout) {
+  SARA_SERIAL_PORT.setTimeout(100);
+  SARA_SERIAL_PORT.println(F("AT"));
+  String rdy = SARA_SERIAL_PORT.readStringUntil('\n');
+  while(!rdy.startsWith(F("OK")) && --timeout) {
+    SARA_SERIAL_PORT.println(F("AT"));
+    rdy = SARA_SERIAL_PORT.readStringUntil('\n');
+    //Serial.println(rdy);
+  }
+  SARA_SERIAL_PORT.setTimeout(1000);      // Restore serial timeout
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Return the current MNO profile
+// Returns -1 if the serial port is not yet setup or the number of the current
+// MNO profile setting from the modem.
+int Challenger2040LTEClass::getMNOProfile() {
+  if (!serialPortConfigured)
+    return -1;
+  SARA_SERIAL_PORT.println(F("AT+UMNOPROF?"));
+  String resp = getResponse();
+  return resp.substring(resp.indexOf("+UMNOPROF: ") + 11).toInt();
+}
+
+// Set a new MNO profile
+// Returns false if the serial port is not yet setup
+bool Challenger2040LTEClass::setMNOProfile(int profile) {
+  if (!serialPortConfigured)
+    return false;
+  String cmd = "AT+UMNOPROF=" + String(profile) + ",1";
+  SARA_SERIAL_PORT.println(cmd);
+
+  if (!getResponse().endsWith("OK")) {
+    return false;
+  }
+  return true;
+}
+
+// Disable power save features
+bool Challenger2040LTEClass::enablePS(bool enable) {
+  if (!serialPortConfigured)
+    return false;
+  if (enable)
+    SARA_SERIAL_PORT.println(F("AT+CPSMS=1"));
+  else
+    SARA_SERIAL_PORT.println(F("AT+CPSMS=0"));
+
+  if (!getResponse().endsWith("OK")) {
+    return false;
+  }
+  return true;
+}
+
+// Get a response from SARA
+// A default serial timeout of 2 seconds allow for reading really slow
+// responses which should accommodate most replies. Replies are then trimmed
+// from control characters and appended with a tab character as a separator.
+//
+String Challenger2040LTEClass::getResponse(int timeout) {
+  SARA_SERIAL_PORT.setTimeout(2000);            // allow for really slow responses
+
+  String resp = SARA_SERIAL_PORT.readStringUntil('\n');
+  resp.trim();
+  String acc = resp;
+  while(resp.indexOf("OK") == -1 && resp.indexOf("ERROR") == -1 && --timeout) {
+    resp = SARA_SERIAL_PORT.readStringUntil('\n');
+    resp.trim();
+    if (resp.length())
+      acc += "\t" + resp;
+  }
+  return acc;
+}
+
+Challenger2040LTEClass Challenger2040LTE;