Update package.json

Update to latest upstream LittleFS (#425 )
Also clean up output in SpeedTest, make more human friendly
2022-01-20 08:54:58 -08:00 · 2022-01-19 18:09:40 -08:00 · 2022-01-19 17:46:31 -08:00 · 2022-01-19 16:16:39 -08:00 · 2022-01-19 12:30:12 -08:00 · 2022-01-15 09:40:31 -08:00
73 changed files with 7309 additions and 271 deletions
@@ -13,14 +13,23 @@ 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)
+* Cytron Maker Pi RP2040
+* Cytron Maker Nano RP2040
 * Invector Labs Challenger RP2040 WiFi
+* Invector Labs Challenger NB RP2040 WiFi
 * Invector Labs Challenger RP2040 LTE
+* Invector Labs RPICO32
+* Melopero Shake RP2040
+* Solder Party RP2040 Stamp
 * SparkFun ProMicro RP2040
+* uPesy RP2040 DevKit
+* WIZnet W5100S-EVB-Pico
 * Generic (configurable flash, I/O pins)

 # Installing via Arduino Boards Manager
@@ -138,6 +147,7 @@ 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`
@@ -30,6 +30,7 @@
 #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()
@@ -95,7 +96,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
@@ -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)
@@ -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);
+    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;
+            }
+        }
+
+        if ((_writer + 1) % _fifosize != _reader) {
+            _queue[_writer] = val & ((1 << _bits) -  1);
+            asm volatile("" ::: "memory"); // Ensure the queue is written before the written count advances
+            _writer = (_writer + 1) % _fifosize;
+        } 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;
+        }
+        irq_set_exclusive_handler(PIO0_IRQ_0, _fifoIRQ);
+        irq_set_enabled(PIO0_IRQ_0, 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
+    uint32_t start = millis();
+    uint32_t now = millis();
+    while ((now - start) < _timeout) {
+        if (_writer != _reader) {
+            return _queue[_reader];
+        }
+        delay(1);
+        now = millis();
+    }
+    return -1; // Nothing available before timeout
+}
+
+int SerialPIO::read() {
+    CoreMutex m(&_mutex);
+    if (!_running || !m || (_rx == NOPIN)) {
+        return -1;
+    }
+    uint32_t start = millis();
+    uint32_t now = millis();
+    while ((now - start) < _timeout) {
+        if (_writer != _reader) {
+            auto ret = _queue[_reader];
+            _reader = (_reader + 1) % _fifosize;
+            return ret;
+        }
+        delay(1);
+        now = millis();
+    }
+    return -1; // Timeout
+}
+
+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;
+}
@@ -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;
+};
@@ -65,6 +65,14 @@ bool SerialUART::setTX(pin_size_t pin) {
    return false;
 }

+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) {
    _uart = uart;
    _tx = tx;
@@ -72,38 +80,76 @@ SerialUART::SerialUART(uart_inst_t *uart, pin_size_t tx, pin_size_t rx) {
    mutex_init(&_mutex);
 }

+static void _uart0IRQ();
+static void _uart1IRQ();
+
 void SerialUART::begin(unsigned long baud, uint16_t config) {
+    _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);
+    _writer = 0;
+    _reader = 0;
+
+    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);
+    }
+    uart_get_hw(_uart)->imsc |= UART_UARTIMSC_RXIM_BITS | UART_UARTIMSC_RTIM_BITS;
    _running = true;
-    _peek = -1;
 }

 void SerialUART::end() {
    if (!_running) {
        return;
    }
+    if (_uart == uart0) {
+        irq_set_enabled(UART0_IRQ, false);
+    } else {
+        irq_set_enabled(UART1_IRQ, false);
+    }
    uart_deinit(_uart);
+    delete[] _queue;
    _running = false;
 }

@@ -112,15 +158,16 @@ int SerialUART::peek() {
    if (!_running || !m) {
        return -1;
    }
-    if (_peek >= 0) {
-        return _peek;
+    uint32_t start = millis();
+    uint32_t now = millis();
+    while ((now - start) < _timeout) {
+        if (_writer != _reader) {
+            return _queue[_reader];
+        }
+        delay(1);
+        now = millis();
    }
-    if (uart_is_readable_within_us(_uart, _timeout * 1000)) {
-        _peek = uart_getc(_uart);
-    } else {
-        _peek = -1; // Timeout
-    }
-    return _peek;
+    return -1; // Nothing available before timeout
 }

 int SerialUART::read() {
@@ -128,16 +175,18 @@ int SerialUART::read() {
    if (!_running || !m) {
        return -1;
    }
-    if (_peek >= 0) {
-        int ret = _peek;
-        _peek = -1;
-        return ret;
-    }
-    if (uart_is_readable_within_us(_uart, _timeout * 1000)) {
-        return uart_getc(_uart);
-    } else {
-        return -1; // Timeout
+    uint32_t start = millis();
+    uint32_t now = millis();
+    while ((now - start) < _timeout) {
+        if (_writer != _reader) {
+            auto ret = _queue[_reader];
+            _reader = (_reader + 1) % _fifoSize;
+            return ret;
+        }
+        delay(1);
+        now = millis();
    }
+    return -1; // Timeout
 }

 int SerialUART::available() {
@@ -145,7 +194,7 @@ int SerialUART::available() {
    if (!_running || !m) {
        return 0;
    }
-    return (uart_is_readable(_uart)) ? 1 : 0;
+    return (_writer - _reader) % _fifoSize;
 }

 int SerialUART::availableForWrite() {
@@ -205,3 +254,26 @@ void arduino::serialEvent2Run(void) {
        serialEvent2();
    }
 }
+
+// IRQ handler, called when FIFO > 1/4 full or when it had held unread data for >32 bit times
+void __not_in_flash_func(SerialUART::_handleIRQ)() {
+    uart_get_hw(_uart)->icr |= UART_UARTICR_RTIC_BITS | UART_UARTICR_RXIC_BITS;
+    while (uart_is_readable(_uart)) {
+        auto val = uart_getc(_uart);
+        if ((_writer + 1) % _fifoSize != _reader) {
+            _queue[_writer] = val;
+            asm volatile("" ::: "memory"); // Ensure the queue is written before the written count advances
+            _writer = (_writer + 1) % _fifoSize;
+        } else {
+            // TODO: Overflow
+        }
+    }
+}
+
+static void __not_in_flash_func(_uart0IRQ)() {
+    Serial1._handleIRQ();
+}
+
+static void __not_in_flash_func(_uart1IRQ)() {
+    Serial2._handleIRQ();
+}
@@ -23,6 +23,7 @@
 #include <Arduino.h>
 #include "api/HardwareSerial.h"
 #include <stdarg.h>
+#include <queue>
 #include "CoreMutex.h"

 extern "C" typedef struct uart_inst uart_inst_t;
@@ -39,6 +40,7 @@ public:
        ret &= setTX(tx);
        return ret;
    }
+    bool setFIFOSize(size_t size);

    void begin(unsigned long baud = 115200) override {
        begin(baud, SERIAL_8N1);
@@ -56,13 +58,21 @@ 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();
+
 private:
    bool _running = false;
    uart_inst_t *_uart;
    pin_size_t _tx, _rx;
    int _baud;
-    int _peek;
    mutex_t _mutex;
+
+    // Lockless, IRQ-handled circular queue
+    uint32_t _writer;
+    uint32_t _reader;
+    size_t   _fifoSize = 32;
+    uint8_t  *_queue;
 };

 extern SerialUART Serial1; // HW UART 0
@@ -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);
+}
+
+%}
@@ -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
+
@@ -121,7 +121,10 @@ auto_init_mutex(_adcMutex);
 extern "C" int analogRead(pin_size_t pin) {
    CoreMutex m(&_adcMutex);

-    if ((pin < A0) || (pin > A3) || !m) {
+    pin_size_t maxPin = max(A0, A3);
+    pin_size_t minPin = min(A0, A3);
+
+    if ((pin < minPin) || (pin > maxPin) || !m) {
        DEBUGCORE("ERROR: Illegal analogRead pin (%d)\n", pin);
        return 0;
    }
@@ -129,7 +132,7 @@ extern "C" int analogRead(pin_size_t pin) {
        adc_init();
    }
    adc_gpio_init(pin);
-    adc_select_input(pin - A0);
+    adc_select_input(pin - minPin);
    return adc_read();
 }

@@ -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);
@@ -38,7 +38,7 @@ extern "C" unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeo
    }

    // Wait for assert
-    while ((!!gpio_get(pin) != !state) && (time_us_64() < abort));
+    while ((!!gpio_get(pin) != !!state) && (time_us_64() < abort));
    uint64_t begin = time_us_64();
    if (begin >= abort) {
        return 0;
@@ -20,6 +20,8 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
   Installation <install>
   IDE Menus <ide>

+   Platform.IO Integration <platformio>
+
   Pin (Re)Assignment <pins>

   Analog I/O <analog>
@@ -27,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>
@@ -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/>`_ .
@@ -0,0 +1,219 @@
+Using this core with PlatformIO
+===============================
+
+What is PlatformIO? 
+-------------------
+
+`PlatformIO <https://platformio.org/>`__  is a free, open-source build-tool written in Python, which also integrates into VSCode code as an extension.
+
+PlatformIO significantly simplifies writing embedded software by offering a unified build system, yet being able to create project files for many different IDEs, including VSCode, Eclipse, CLion, etc. 
+Through this, PlatformIO can offer extensive features such as IntelliSense (autocomplete), debugging, unit testing etc., which not available in the standard Arduino IDE.
+
+The Arduino IDE experience:
+
+.. image:: images/the_arduinoide_experience.png
+
+The PlatformIO experience:
+
+.. image:: images/the_platformio_experience.png
+
+Refer to the general documentation at https://docs.platformio.org/.
+
+Especially useful is the `Getting started with VSCode + PlatformIO <https://docs.platformio.org/en/latest/integration/ide/vscode.html#installation), [CLI reference](https://docs.platformio.org/en/latest/core/index.html) and [platformio.ini options](https://docs.platformio.org/en/latest/projectconf/index.html)>`__ page.
+
+Hereafter it is assumed that you have a basic understanding of PlatformIO in regards to project creation, project file structure and building and uploading PlatformIO projects, through reading the above pages.
+
+Current state of development
+----------------------------
+
+At the time of writing, PlatformIO integration for this core is a work-in-progress and not yet merged into mainline PlatformIO. This is subject to change soon.
+
+If you want to use the PlatformIO integration right now, make sure you first create a standard Raspberry Pi Pico + Arduino project within PlatformIO. 
+This will give you a project with the ``platformio.ini`` 
+
+.. code:: ini
+
+    [env:pico]
+    platform = raspberrypi
+    board = pico
+    framework = arduino
+
+Here, you need to change the `platform` to take advantage of the features described hereunder. 
+You *also* need to inject two PlatformIO packages, one for the compiler toolchain and one for the Arduino core package.
+
+.. code:: ini
+
+    [env:pico]
+    platform = https://github.com/maxgerhardt/platform-raspberrypi.git
+    board = pico
+    framework = arduino
+    ; note that download link for toolchain is specific for OS. see https://github.com/earlephilhower/pico-quick-toolchain/releases.
+    platform_packages = 
+        maxgerhardt/framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git
+        maxgerhardt/toolchain-pico@https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.arm-none-eabi-7855b0c.210706.zip
+    
+When the support for this core has been merged into mainline PlatformIO, this notice will be removed and a standard `platformio.ini` as shown above will work as a base.
+
+Selecting the new core
+----------------------
+
+Prerequisite for using this core is to tell PlatformIO to switch to it.
+There will be board definition files where the Earle-Philhower core will
+be the default since it's a board that only exists in this core (and not
+the other https://github.com/arduino/ArduinoCore-mbed). To switch boards
+for which this is not the default core (e.g. the standard
+``board = pico``), the directive
+
+.. code:: ini
+
+    board_build.core = earlephilhower
+
+must be added to the ``platformio.ini``. This controls the `core
+switching
+logic <https://github.com/maxgerhardt/platform-raspberrypi/blob/77e0d3a29d1dbf00fd3ec3271104e3bf4820869c/builder/frameworks/arduino/arduino.py#L27-L32>`__.
+
+Flash size
+----------
+
+Controlled via specifying the size allocated for the filesystem.
+Available sketch size is calculated accordingly by using (as in
+``makeboards.py``) that number and the (constant) EEPROM size (4096
+bytes) and the total flash size as known to PlatformIO via the board
+definition file. The expression on the right can involve "b","k","m"
+(bytes/kilobytes/megabytes) and floating point numbers. This makes it
+actually more flexible than in the Arduino IDE where there is a finite
+list of choices. Calculations happen in `the
+platform <https://github.com/maxgerhardt/platform-raspberrypi/blob/77e0d3a29d1dbf00fd3ec3271104e3bf4820869c/builder/main.py#L118-L184>`__.
+
+.. code:: ini
+
+    ; in reference to a board = pico config (2MB flash)
+    ; Flash Size: 2MB (Sketch: 1MB, FS:1MB)
+    board_build.filesystem_size = 1m
+    ; Flash Size: 2MB (No FS)
+    board_build.filesystem_size = 0m
+    ; Flash Size: 2MB (Sketch: 0.5MB, FS:1.5MB)
+    board_build.filesystem_size = 1.5m
+
+CPU Speed
+---------
+
+As for all other PlatformIO platforms, the ``f_cpu`` macro value (which
+is passed to the core) can be changed as
+`documented <https://docs.platformio.org/en/latest/boards/raspberrypi/pico.html#configuration>`__
+
+.. code:: ini
+
+    ; 133MHz
+    board_build.f_cpu = 133000000L
+
+Debug Port
+----------
+
+Via
+`build_flags <https://docs.platformio.org/en/latest/projectconf/section_env_build.html#build-flags>`__
+as done for many other cores
+(`example <https://docs.platformio.org/en/latest/platforms/ststm32.html#configuration>`__).
+
+.. code:: ini
+
+    ; Debug Port: Serial
+    build_flags = -DDEBUG_RP2040_PORT=Serial
+    ; Debug Port: Serial 1
+    build_flags = -DDEBUG_RP2040_PORT=Serial1
+    ; Debug Port: Serial 2
+    build_flags = -DDEBUG_RP2040_PORT=Serial2
+
+Debug Level
+-----------
+
+Done again by directly adding the needed `build
+flags <https://github.com/earlephilhower/arduino-pico/blob/05356da2c5552413a442f742e209c6fa92823666/boards.txt#L104-L114>`__.
+When wanting to define multiple build flags, they must be accumulated in
+either a sing line or a newline-separated expression.
+
+.. code:: ini
+
+    ; Debug level: Core
+    build_flags = -DDEBUG_RP2040_CORE
+    ; Debug level: SPI
+    build_flags = -DDEBUG_RP2040_SPI
+    ; Debug level: Wire
+    build_flags = -DDEBUG_RP2040_WIRE
+    ; Debug level: All
+    build_flags = -DDEBUG_RP2040_WIRE -DDEBUG_RP2040_SPI -DDEBUG_RP2040_CORE
+    ; Debug level: NDEBUG
+    build_flags = -DNDEBUG
+
+    ; example: Debug port on serial 2 and all debug output
+    build_flags = -DDEBUG_RP2040_WIRE -DDEBUG_RP2040_SPI -DDEBUG_RP2040_CORE -DDEBUG_RP2040_PORT=Serial2
+    ; equivalent to above
+    build_flags = 
+       -DDEBUG_RP2040_WIRE
+       -DDEBUG_RP2040_SPI
+       -DDEBUG_RP2040_CORE
+       -DDEBUG_RP2040_PORT=Serial2
+
+USB Stack
+---------
+
+Not specifying any special build flags regarding this gives one the
+default Pico SDK USB stack. To change it, add
+
+.. code:: ini
+
+    ; Adafruit TinyUSB
+    build_flags = -DUSE_TINYUSB
+    ; No USB stack
+    build_flags = -DPIO_FRAMEWORK_ARDUINO_NO_USB
+
+Note that the special "No USB" setting is also supported, through the
+shortcut-define ``PIO_FRAMEWORK_ARDUINO_NO_USB``.
+
+
+Selecting a different core version
+----------------------------------
+
+If you wish to use a different version of the core, e.g., the latest git
+``master`` version, you can use a
+`platform_packages <https://docs.platformio.org/en/latest/projectconf/section_env_platform.html#platform-packages>`__
+directive to do so. Simply specify that the framework package
+(``framework-arduinopico``) comes from a different source.
+
+.. code:: ini
+
+    platform_packages =
+       framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git#master
+
+Whereas the ``#master`` can also be replaced by a ``#branchname`` or a
+``#commithash``. If left out, it will pull the default branch, which is ``master``.
+
+The ``file://`` pseudo-protocol can also be used instead of ``https://`` to point to a
+local copy of the core (with e.g. some modifications) on disk.
+
+Note that this can only be done for versions that have the PlatformIO
+builder script it in, so versions before 1.9.2 are not supported.
+
+Examples 
+--------
+
+The following example ``platformio.ini`` can be used for a Raspberry Pi Pico
+and 0.5MByte filesystem. 
+
+.. code:: ini
+
+    [env:pico]
+    platform = https://github.com/maxgerhardt/platform-raspberrypi.git
+    board = pico
+    framework = arduino
+    board_build.core = earlephilhower
+    board_build.filesystem_size = 0.5m
+    ; note that download link for toolchain is specific for OS. see https://github.com/earlephilhower/pico-quick-toolchain/releases.
+    platform_packages = 
+        maxgerhardt/framework-arduinopico@https://github.com/earlephilhower/arduino-pico.git
+        maxgerhardt/toolchain-pico@https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.1-a/x86_64-w64-mingw32.arm-none-eabi-7855b0c.210706.zip
+
+
+The initial project structure should be generated just creating a new
+project for the Pico and the Arduino framework, after which the
+auto-generated ``platformio.ini`` can be adapted per above.
@@ -24,5 +24,12 @@ 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);
+
 For detailed information about the Serial ports, see the
 Arduino `Serial Reference <https://www.arduino.cc/reference/en/language/functions/communication/serial/>`_ .
@@ -33,3 +33,5 @@ resumeOtherCore	KEYWORD2

 PIOProgram	KEYWORD2
 prepare	KEYWORD2
+SerialPIO	KEYWORD2
+setFIFOSize	KEYWORD2
@@ -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
@@ -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
@@ -26,6 +29,7 @@
 -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_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
@@ -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() {
@@ -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;
 }
@@ -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;
@@ -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
@@ -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);
@@ -146,7 +146,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;
@@ -181,6 +181,8 @@ void TwoWire::end() {
        return;
    }
    i2c_deinit(_i2c);
+    pinMode(_sda, INPUT);
+    pinMode(_scl, INPUT);
    _running = false;
    _txBegun = false;
 }
@@ -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 {
@@ -1,6 +1,17 @@
 {
-    "name": "framework-arduinopico",
-    "description": "Arduino Wiring-based Framework (RPi Pico RP2040)",
-    "url": "https://github.com/earlephilhower/arduino-pico",
-    "version": "0.9.2"
+  "name": "framework-arduinopico",
+  "version": "1.10914.0",
+  "description": "Arduino Wiring-based Framework (RPi Pico RP2040)",
+  "keywords": [
+    "framework",
+    "arduino",
+    "Cortex-M",
+    "Raspberry Pi",
+    "RP2040"
+  ],
+  "homepage": "https://arduino-pico.readthedocs.io/en/latest/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/earlephilhower/arduino-pico"
+  }
 }
@@ -26,6 +26,9 @@
                  {
                     "name": "Adafruit ItsyBitsy RP2040"
                  },
+                  {
+                     "name": "Adafruit KB2040"
+                  },
                  {
                     "name": "Adafruit Macropad RP2040"
                  },
@@ -41,9 +44,39 @@
                  {
                     "name": "Arduino Nano RP2040 Connect"
                  },
+                  {
+                     "name": "Cytron Maker Nano RP2040"
+                  },
+                  {
+                     "name": "Cytron Maker Pi RP2040"
+                  },
+                  {
+                     "name": "Invector Labs Challenger RP2040 WiFi"
+                  },
+                  {
+                     "name": "Invector Labs Challenger NB RP2040 WiFi"
+                  },
+                  {
+                     "name": "Invector Labs Challenger RP2040 LTE"
+                  },
+                  {
+                     "name": "Invector Labs RPICO32"
+                  },
+                  {
+                     "name": "Solder Party RP2040 Stamp"
+                  },
                  {
                     "name": "SparkFun ProMicro RP2040"
                  },
+                  {
+                     "name": "Melopero Shake RP2040"
+                  },
+                  {
+                     "name": "uPesy RP2040 DevKit"
+                  },
+                  {
+                     "name": "WIZnet W5100S-EVB-Pico"
+                  },
                  {
                     "name": "Generic RP2040 Module"
                  }
@@ -426,4 +459,4 @@
         ]
      }
   ]
-}
+}
@@ -20,7 +20,7 @@
 # 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.9.13
 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 +29,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 +42,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 +50,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 +82,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 +98,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 +118,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"
@@ -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/
@@ -13,9 +13,11 @@ pico_sdk_init()

 add_library(pico STATIC)

+# Use a longer XOSC startup time, to accommodate Adafruit and other boards that may need it.
 target_compile_definitions(pico PUBLIC
 	PICO_PRINTF_ALWAYS_INCLUDED=1
 	PICO_FLASH_SIZE_BYTES=16777216
+	PICO_XOSC_STARTUP_DELAY_MULTIPLIER=64
 )

 target_compile_options(pico PUBLIC
@@ -25,7 +27,7 @@ target_compile_options(pico PUBLIC

 include_directories(BEFORE ${PICO_SDK_PATH}/../tools/libpico)

-target_link_libraries(pico 
+target_link_libraries(pico
 	boot_stage2
 	hardware_adc
 	hardware_base
@@ -51,6 +53,7 @@ target_link_libraries(pico
 	hardware_vreg
 	hardware_watchdog
 	hardware_xosc
+	cmsis
 	pico_bit_ops
 	pico_bootrom
 	pico_bootsel_via_double_reset
@@ -68,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
 )
@@ -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/" \
@@ -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)
@@ -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})
@@ -36,6 +36,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 +66,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 +76,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 +90,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 +98,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 +133,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 +142,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":
@@ -131,17 +153,26 @@ def MakeBoard(name, vendor_name, product_name, vid, pid, boarddefine, flashsizem
        if name == "generic":
            BuildBoot(n)

-
+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("rpipico", "Raspberry Pi", "Pico", "0x2e8a", "0x000a", 250, "RASPBERRY_PI_PICO", 2, "boot2_w25q080_2_padded_checksum")
+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")
+MakeBoard("arduino_nano_connect", "Arduino", "Nano RP2040 Connect", "0x2341", "0x0058", 250, "NANO_RP2040_CONNECT", 16, "boot2_w25q080_2_padded_checksum")
+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")
+MakeBoard("sparkfun_promicrorp2040", "SparkFun", "ProMicro RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_PROMICRO_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
+MakeBoard("generic", "Generic", "RP2040", "0x2e8a", "0xf00a", 250, "GENERIC_RP2040", 16, "boot2_generic_03h_4_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")
+MakeBoard("melopero_shake_rp2040", "Melopero", "Shake RP2040", "0x2e8a", "0x1005", 250, "MELOPERO_SHAKE_RP2040", 16, "boot2_w25q080_2_padded_checksum")
+MakeBoard("solderparty_rp2040_stamp", "Solder Party", "RP2040 Stamp", "0x1209", "0xa182", 500, "SOLDERPARTY_RP2040_STAMP", 8, "boot2_generic_03h_4_padded_checksum")
+MakeBoard("upesy_rp2040_devkit", "uPesy", "RP2040 DevKit", "0x2e8a", "0x1007", 250, "UPESY_RP2040_DEVKIT", 2, "boot2_w25q080_2_padded_checksum")
+MakeBoard("wiznet_5100s_evb_pico", "WIZnet", "W5100S-EVB-Pico", "0x2e8a", "0x1008", 250, "WIZNET_5100S_EVB_PICO", 2, "boot2_w25q080_2_padded_checksum")
@@ -0,0 +1,229 @@
+# Copyright 2021-present Maximilian Gerhardt <maximilian.gerhardt@rub.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os, re, sys
+from SCons.Script import DefaultEnvironment, Builder, AlwaysBuild
+
+env = DefaultEnvironment()
+platform = env.PioPlatform()
+board = env.BoardConfig()
+upload_protocol = env.subst("$UPLOAD_PROTOCOL") or "picotool"
+ram_size = board.get("upload.maximum_ram_size")
+
+FRAMEWORK_DIR = platform.get_package_dir("framework-arduinopico")
+assert os.path.isdir(FRAMEWORK_DIR)
+
+# update progsize expression to also check for bootloader.
+env.Replace(
+    SIZEPROGREGEXP=r"^(?:\.boot2|\.text|\.data|\.rodata|\.text.align|\.ARM.exidx)\s+(\d+).*"
+)
+
+env.Append(
+    ASFLAGS=env.get("CCFLAGS", [])[:],
+
+    CCFLAGS=[
+        "-Werror=return-type",
+        "-march=armv6-m",
+        "-mcpu=cortex-m0plus",
+        "-mthumb",
+        "-ffunction-sections",
+        "-fdata-sections",
+        "-iprefix" + os.path.join(FRAMEWORK_DIR),
+        "@%s" % os.path.join(FRAMEWORK_DIR, "lib", "platform_inc.txt")
+    ],
+
+    CFLAGS=[
+        "-std=gnu17"
+    ],
+
+    CXXFLAGS=[
+        "-std=gnu++17",
+        "-fno-exceptions",
+        "-fno-rtti",
+    ],
+
+    CPPDEFINES=[
+        ("ARDUINO", 10810),
+        "ARDUINO_ARCH_RP2040",
+        ("F_CPU", "$BOARD_F_CPU"),
+        ("BOARD_NAME", '\\"%s\\"' % env.subst("$BOARD")),
+    ],
+
+    CPPPATH=[
+        os.path.join(FRAMEWORK_DIR, "cores", "rp2040"),
+        os.path.join(FRAMEWORK_DIR, "cores", "rp2040", "api", "deprecated"),
+        os.path.join(FRAMEWORK_DIR, "cores", "rp2040",
+                     "api", "deprecated-avr-comp")
+    ],
+
+    LINKFLAGS=[
+        "-march=armv6-m",
+        "-mcpu=cortex-m0plus",
+        "-mthumb",
+        "@%s" % os.path.join(FRAMEWORK_DIR, "lib", "platform_wrap.txt"),
+        "-u_printf_float",
+        "-u_scanf_float",
+        # no cross-reference table, heavily spams the output
+        # "-Wl,--cref",
+        "-Wl,--check-sections",
+        "-Wl,--gc-sections",
+        "-Wl,--unresolved-symbols=report-all",
+        "-Wl,--warn-common"
+    ],
+
+    LIBSOURCE_DIRS=[os.path.join(FRAMEWORK_DIR, "libraries")],
+
+    LIBPATH=[
+        os.path.join(FRAMEWORK_DIR, "lib")
+    ],
+
+    # link lib/libpico.a
+    LIBS=["pico", "m", "c", "stdc++", "c"]
+)
+
+
+def configure_usb_flags(cpp_defines):
+    global ram_size
+    if "USE_TINYUSB" in cpp_defines:
+        env.Append(CPPPATH=[os.path.join(
+            FRAMEWORK_DIR, "libraries", "Adafruit_TinyUSB_Arduino", "src", "arduino")])
+    elif "PIO_FRAMEWORK_ARDUINO_NO_USB" in cpp_defines:
+        env.Append(
+            CPPPATH=[os.path.join(FRAMEWORK_DIR, "tools", "libpico")],
+            CPPDEFINES=[
+                "NO_USB",
+                "DISABLE_USB_SERIAL" 
+            ]
+        )
+        # do not further add more USB flags or update sizes. no USB used.
+        return
+    else:
+        # standard Pico SDK USB stack used.
+        env.Append(CPPPATH=[os.path.join(FRAMEWORK_DIR, "tools", "libpico")])
+    # in any case, add standard flags
+    # preferably use USB information from arduino.earlephilhower section,
+    # but fallback to sensible values derived from other parts otherwise.
+    usb_pid = board.get("build.arduino.earlephilhower.usb_pid",
+                        board.get("build.hwids", [[0, 0]])[0][1])
+    usb_vid = board.get("build.arduino.earlephilhower.usb_vid",
+                        board.get("build.hwids", [[0, 0]])[0][0])
+    usb_manufacturer = board.get(
+        "build.arduino.earlephilhower.usb_manufacturer", board.get("vendor", "Raspberry Pi"))
+    usb_product = board.get(
+        "build.arduino.earlephilhower.usb_product", board.get("name", "Pico"))
+
+    # Copy logic from makeboards.py. 
+    # Depending on whether a certain upload / debug method is used, change
+    # the PID/VID.
+    # https://github.com/earlephilhower/arduino-pico/blob/master/tools/makeboards.py
+    vidtouse = usb_vid
+    pidtouse = usb_pid
+    if upload_protocol == "picoprobe": 
+        pidtouse = '0x0004'
+    elif upload_protocol == "picodebug":
+        vidtouse = '0x1209'
+        pidtouse = '0x2488'
+        ram_size = 240 * 1024
+
+    env.Append(CPPDEFINES=[
+        ("CFG_TUSB_MCU", "OPT_MCU_RP2040"),
+        ("USB_VID", usb_vid),
+        ("USB_PID", usb_pid),
+        ("USB_MANUFACTURER", '\\"%s\\"' % usb_manufacturer),
+        ("USB_PRODUCT", '\\"%s\\"' % usb_product),
+        ("SERIALUSB_PID", usb_pid),
+        ("USBD_MAX_POWER_MA", 250)
+    ])
+
+    # use vidtouse and pidtouse 
+    # for USB PID/VID autodetection
+    hw_ids = board.get("build.hwids", [["0x2E8A", "0x00C0"]])
+    hw_ids[0][0] = vidtouse
+    hw_ids[0][1] = pidtouse
+    board.update("build.hwids", hw_ids)
+    board.update("upload.maximum_ram_size", ram_size)
+
+#
+# Process configuration flags
+#
+cpp_defines = env.Flatten(env.get("CPPDEFINES", []))
+
+configure_usb_flags(cpp_defines)
+
+# info about the filesystem is already parsed by the platform's main.py 
+# script. We can just use the info here
+ 
+linkerscript_cmd = env.Command(
+    os.path.join("$BUILD_DIR", "memmap_default.ld"),  # $TARGET
+    os.path.join(FRAMEWORK_DIR, "lib", "memmap_default.ld"),  # $SOURCE
+    env.VerboseAction(" ".join([
+        '"$PYTHONEXE" "%s"' % os.path.join(
+            FRAMEWORK_DIR, "tools", "simplesub.py"),
+        "--input", "$SOURCE",
+        "--out", "$TARGET",
+        "--sub", "__FLASH_LENGTH__", "$PICO_FLASH_LENGTH",
+        "--sub", "__EEPROM_START__", "$PICO_EEPROM_START",
+        "--sub", "__FS_START__", "$FS_START",
+        "--sub", "__FS_END__", "$FS_END",
+        "--sub", "__RAM_LENGTH__", "%dk" % (ram_size // 1024),
+    ]), "Generating linkerscript $BUILD_DIR/memmap_default.ld")
+)
+
+# if no custom linker script is provided, we use the command that we prepared to generate one.
+if not board.get("build.ldscript", ""):
+    # execute fetch filesystem info stored in env to alawys have that info ready
+    env["fetch_fs_size"](env)
+    env.Depends("$BUILD_DIR/${PROGNAME}.elf", linkerscript_cmd)
+    env.Replace(LDSCRIPT_PATH=os.path.join("$BUILD_DIR", "memmap_default.ld"))
+
+libs = []
+
+variant = board.get("build.arduino.earlephilhower.variant", board.get("build.variant", None))
+
+if variant is not None:
+    env.Append(CPPPATH=[
+        os.path.join(FRAMEWORK_DIR, "variants", variant)
+    ])
+
+    libs.append(
+        env.BuildLibrary(
+            os.path.join("$BUILD_DIR", "FrameworkArduinoVariant"),
+            os.path.join(FRAMEWORK_DIR, "variants", variant)))
+
+libs.append(
+    env.BuildLibrary(
+        os.path.join("$BUILD_DIR", "FrameworkArduino"),
+        os.path.join(FRAMEWORK_DIR, "cores", "rp2040")))
+
+bootloader_src_file = board.get(
+    "build.arduino.earlephilhower.boot2_source", "boot2_generic_03h_2_padded_checksum.S")
+
+# Add bootloader file (boot2.o)
+# Only build the needed .S file, exclude all others via src_filter.
+env.BuildSources(
+    os.path.join("$BUILD_DIR", "FrameworkArduinoBootloader"),
+    os.path.join(FRAMEWORK_DIR, "boot2"),
+    "-<*> +<%s>" % bootloader_src_file,
+)
+# Add include flags for all .S assembly file builds
+env.Append(
+    ASFLAGS=[
+        "-I", os.path.join(FRAMEWORK_DIR, "pico-sdk", "src",
+                           "rp2040", "hardware_regs", "include"),
+        "-I", os.path.join(FRAMEWORK_DIR, "pico-sdk", "src",
+                           "common", "pico_binary_info", "include")
+    ]
+)
+
+env.Prepend(LIBS=libs)
@@ -27,12 +27,10 @@
 #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)
@@ -27,15 +27,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"
@@ -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"
@@ -38,4 +38,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"
@@ -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);
@@ -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_ */
@@ -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)
@@ -56,19 +54,19 @@ static const uint8_t A5 = (13u);
 #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 +93,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)
@@ -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;
@@ -0,0 +1,38 @@
+/*
+    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
+*/
+#pragma once
+
+#define DEFAULT_SARA_BAUDRATE      115200
+
+class Challenger2040LTEClass {
+  public:
+    Challenger2040LTEClass();
+    bool doPowerOn();
+    bool isAlive(uint32_t timeout = 50);
+    int getMNOProfile();
+    bool setMNOProfile(int profile);
+    bool enablePS(bool enable = true);
+    String getResponse(int timeout = 5);
+
+  private:
+    bool serialPortConfigured;
+};
+
+extern Challenger2040LTEClass Challenger2040LTE;
@@ -21,6 +21,7 @@
 #define PIN_SARA_ON         (13u)
 #define PIN_SARA_RST        (14u)
 #define PIN_SARA_PWR        (15u)
+#define SARA_SERIAL_PORT    Serial2

 // SPI
 #define PIN_SPI0_MISO       (24u)
@@ -67,9 +68,9 @@ static const uint8_t D15 =  (14u);
 static const uint8_t D16 =  (15u);
 static const uint8_t D17 =  (19u);

-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 A0 =   (29u);
+static const uint8_t A1 =   (28u);
+static const uint8_t A2 =   (27u);
+static const uint8_t A3 =   (26u);
 static const uint8_t A4 =   (25u);
 static const uint8_t A5 =   (21u);
@@ -0,0 +1,107 @@
+/*
+    ESP8285 helper class for the Challenger RP2040 WiFi 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 <ChallengerWiFi.h>
+
+Challenger2040WiFiClass::Challenger2040WiFiClass() {
+  pinMode(PIN_ESP8285_RST, OUTPUT);
+  digitalWrite(PIN_ESP8285_RST, LOW);       // Hold ESP8285 in reset
+  pinMode(PIN_ESP8285_MODE, OUTPUT);
+  digitalWrite(PIN_ESP8285_MODE, HIGH);     // Prepare for normal start
+}
+
+// Do a HW reset by applying a low pulse to the reset line for 1mSec
+void Challenger2040WiFiClass::doHWReset() {
+  digitalWrite(PIN_ESP8285_RST, LOW);       // Hold ESP8285 in reset
+  delay(1);
+  digitalWrite(PIN_ESP8285_RST, HIGH);      // Release ESP8285 reset
+}
+
+// Set the mode flag high to indicate normal run operation and do a HW
+// reset.
+void Challenger2040WiFiClass::runReset() {  // Prepare ESP8285 for normal op
+  digitalWrite(PIN_ESP8285_MODE, HIGH);     // Prepare for normal start
+  doHWReset();
+}
+
+// Set the mode flag low to indicate flash operation and do a HW
+// reset.
+void Challenger2040WiFiClass::flashReset() { // Prepare ESP8285 for flashing
+  digitalWrite(PIN_ESP8285_MODE, LOW);       // Prepare for normal start
+  doHWReset();
+}
+
+// Wait for the modem to reply with a "ready" prompt. This can be done
+// after a sw or hw reset have been performed to ensure that the AT
+// interpreter is up and running.
+bool Challenger2040WiFiClass::waitForReady() {
+  int timeout = 20;                         // Aprox max 2 sec
+
+  Serial2.begin(DEFAULT_ESP8285_BAUDRATE);
+  Serial2.setTimeout(100);
+  String rdy = Serial2.readStringUntil('\n');
+  while(!rdy.startsWith("ready") && timeout--) {
+    rdy = Serial2.readStringUntil('\n');
+  }
+  Serial2.setTimeout(1000);  // Reset default timeout to 1000
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Reset the ESP8285 and wait for the "ready" prompt to be returned.
+bool Challenger2040WiFiClass::reset() {
+  runReset();
+  return waitForReady();
+}
+
+// Checks to see if the modem responds to the "AT" poll command.
+bool Challenger2040WiFiClass::isAlive() {
+  int timeout = 5;
+
+  Serial2.setTimeout(250);
+  Serial2.println(F("AT"));
+  String rdy = Serial2.readStringUntil('\n');
+  while(!rdy.startsWith(F("OK")) && timeout--) {
+    rdy = Serial2.readStringUntil('\n');
+  }
+  Serial2.setTimeout(1000);
+
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Change the baud rate of the ESP8285 as well as the local UART.
+// No checking is done on the input baud rate so the user must know what
+// baud rates are valid. The function ends by checking if the ESP8285 is
+// reachable by doing an "AT" poll.
+bool Challenger2040WiFiClass::changeBaudRate(int baud) {
+  Serial2.print(F("AT+UART_CUR="));
+  Serial2.print(baud);
+  Serial2.println(F(",8,1,0,0"));
+  delay(100);
+  Serial2.end();
+  Serial2.begin(baud);
+  return isAlive();
+}
+
+Challenger2040WiFiClass Challenger2040WiFi;
@@ -0,0 +1,36 @@
+/*
+    ESP8285 helper class for the Challenger RP2040 WiFi 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
+*/
+#pragma once
+
+#define DEFAULT_ESP8285_BAUDRATE      115200
+
+class Challenger2040WiFiClass {
+  public:
+    Challenger2040WiFiClass();
+    void doHWReset();
+    void runReset();
+    void flashReset();
+    bool waitForReady();
+    bool reset();
+    bool isAlive();
+    bool changeBaudRate(int baud);
+};
+
+extern Challenger2040WiFiClass Challenger2040WiFi;
@@ -16,6 +16,8 @@
 // Connected to ESP8285
 #define PIN_SERIAL2_TX      (4u)
 #define PIN_SERIAL2_RX      (5u)
+#define PIN_ESP8285_RST     (19u)
+#define PIN_ESP8285_MODE    (13u)

 // SPI
 #define PIN_SPI0_MISO       (24u)
@@ -0,0 +1,107 @@
+/*
+    ESP8285 helper class for the Challenger RP2040 WiFi 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 <ChallengerWiFi.h>
+
+Challenger2040WiFiClass::Challenger2040WiFiClass() {
+  pinMode(PIN_ESP8285_RST, OUTPUT);
+  digitalWrite(PIN_ESP8285_RST, LOW);       // Hold ESP8285 in reset
+  pinMode(PIN_ESP8285_MODE, OUTPUT);
+  digitalWrite(PIN_ESP8285_MODE, HIGH);     // Prepare for normal start
+}
+
+// Do a HW reset by applying a low pulse to the reset line for 1mSec
+void Challenger2040WiFiClass::doHWReset() {
+  digitalWrite(PIN_ESP8285_RST, LOW);       // Hold ESP8285 in reset
+  delay(1);
+  digitalWrite(PIN_ESP8285_RST, HIGH);      // Release ESP8285 reset
+}
+
+// Set the mode flag high to indicate normal run operation and do a HW
+// reset.
+void Challenger2040WiFiClass::runReset() {  // Prepare ESP8285 for normal op
+  digitalWrite(PIN_ESP8285_MODE, HIGH);     // Prepare for normal start
+  doHWReset();
+}
+
+// Set the mode flag low to indicate flash operation and do a HW
+// reset.
+void Challenger2040WiFiClass::flashReset() { // Prepare ESP8285 for flashing
+  digitalWrite(PIN_ESP8285_MODE, LOW);       // Prepare for normal start
+  doHWReset();
+}
+
+// Wait for the modem to reply with a "ready" prompt. This can be done
+// after a sw or hw reset have been performed to ensure that the AT
+// interpreter is up and running.
+bool Challenger2040WiFiClass::waitForReady() {
+  int timeout = 20;                         // Aprox max 2 sec
+
+  Serial2.begin(DEFAULT_ESP8285_BAUDRATE);
+  Serial2.setTimeout(100);
+  String rdy = Serial2.readStringUntil('\n');
+  while(!rdy.startsWith("ready") && timeout--) {
+    rdy = Serial2.readStringUntil('\n');
+  }
+  Serial2.setTimeout(1000);  // Reset default timeout to 1000
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Reset the ESP8285 and wait for the "ready" prompt to be returned.
+bool Challenger2040WiFiClass::reset() {
+  runReset();
+  return waitForReady();
+}
+
+// Checks to see if the modem responds to the "AT" poll command.
+bool Challenger2040WiFiClass::isAlive() {
+  int timeout = 5;
+
+  Serial2.setTimeout(250);
+  Serial2.println(F("AT"));
+  String rdy = Serial2.readStringUntil('\n');
+  while(!rdy.startsWith(F("OK")) && timeout--) {
+    rdy = Serial2.readStringUntil('\n');
+  }
+  Serial2.setTimeout(1000);
+
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Change the baud rate of the ESP8285 as well as the local UART.
+// No checking is done on the input baud rate so the user must know what
+// baud rates are valid. The function ends by checking if the ESP8285 is
+// reachable by doing an "AT" poll.
+bool Challenger2040WiFiClass::changeBaudRate(int baud) {
+  Serial2.print(F("AT+UART_CUR="));
+  Serial2.print(baud);
+  Serial2.println(F(",8,1,0,0"));
+  delay(100);
+  Serial2.end();
+  Serial2.begin(baud);
+  return isAlive();
+}
+
+Challenger2040WiFiClass Challenger2040WiFi;
@@ -0,0 +1,36 @@
+/*
+    ESP8285 helper class for the Challenger RP2040 WiFi 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
+*/
+#pragma once
+
+#define DEFAULT_ESP8285_BAUDRATE      115200
+
+class Challenger2040WiFiClass {
+  public:
+    Challenger2040WiFiClass();
+    void doHWReset();
+    void runReset();
+    void flashReset();
+    bool waitForReady();
+    bool reset();
+    bool isAlive();
+    bool changeBaudRate(int baud);
+};
+
+extern Challenger2040WiFiClass Challenger2040WiFi;
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <ChallengerWiFi.h>
+
+#define PINS_COUNT          (24u)
+#define NUM_DIGITAL_PINS    (24u)
+#define NUM_ANALOG_INPUTS   (4u)
+#define NUM_ANALOG_OUTPUTS  (0u)
+#define ADC_RESOLUTION      (12u)
+
+// LEDs
+#define PIN_LED             (12u)
+
+// Serial
+#define PIN_SERIAL1_TX      (16u)
+#define PIN_SERIAL1_RX      (17u)
+
+// Connected to ESP8285
+#define PIN_SERIAL2_TX      (4u)
+#define PIN_SERIAL2_RX      (5u)
+#define PIN_ESP8285_RST     (19u)
+#define PIN_ESP8285_MODE    (13u)
+
+// SPI
+#define PIN_SPI0_MISO       (24u)
+#define PIN_SPI0_MOSI       (23u)
+#define PIN_SPI0_SCK        (22u)
+#define PIN_SPI0_SS         (21u)
+
+// Not pinned out
+#define PIN_SPI1_MISO       (31u)
+#define PIN_SPI1_MOSI       (31u)
+#define PIN_SPI1_SCK        (31u)
+#define PIN_SPI1_SS         (31u)
+
+// 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 SERIAL_HOWMANY      (2u)
+#define SPI_HOWMANY         (1u)
+#define WIRE_HOWMANY        (1u)
+
+#define LED_BUILTIN         PIN_LED
+#define NEOPIXEL            (11u)
+
+static const uint8_t D0 =   (16u);
+static const uint8_t D1 =   (17u);
+static const uint8_t D2 =   (24u);
+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 =   (6u);
+static const uint8_t D10 =  (7u);
+static const uint8_t D11 =  (8u);
+static const uint8_t D12 =  (9u);
+static const uint8_t D13 = (10u);
+static const uint8_t D14 = (14u);
+static const uint8_t D15 = (15u);
+static const uint8_t D16 = (18u);
+static const uint8_t D17 = (20u);
+
+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 = (25u);
+static const uint8_t A5 = (21u);
@@ -0,0 +1,52 @@
+#pragma once
+
+// LEDs
+#define PIN_LED             (2u)
+
+// Neopixel
+#define PIN_NEOPIXEL        (11u)
+#define NUM_NEOPIXEL        (2u)
+#define PIN_RGB             PIN_NEOPIXEL
+
+// Buzzer
+#define PIN_BUZZER          (22u)
+
+// Button
+#define PIN_BUTTON			(20u)
+
+
+
+// Serial 1
+#define PIN_SERIAL1_TX      (0u)
+#define PIN_SERIAL1_RX      (1u)
+
+// Serial 2 (Not pinned out)
+#define PIN_SERIAL2_TX      (31u)
+#define PIN_SERIAL2_RX      (31u)
+
+// SPI 0
+#define PIN_SPI0_MISO       (16u)
+#define PIN_SPI0_MOSI       (19u)
+#define PIN_SPI0_SCK        (18u)
+#define PIN_SPI0_SS         (17u)
+
+// SPI 1 (Not pinned out)
+#define PIN_SPI1_MISO       (31u)
+#define PIN_SPI1_MOSI       (31u)
+#define PIN_SPI1_SCK        (31u)
+#define PIN_SPI1_SS         (31u)
+
+// Wire
+#define PIN_WIRE0_SDA       (0u)
+#define PIN_WIRE0_SCL       (1u)
+
+#define PIN_WIRE1_SDA       (26u)
+#define PIN_WIRE1_SCL       (27u)
+
+
+
+#define SERIAL_HOWMANY      (1u)
+#define SPI_HOWMANY         (1u)
+#define WIRE_HOWMANY        (2u)
+
+#include "../generic/common.h"
@@ -0,0 +1,57 @@
+#pragma once
+
+// LEDs
+#define PIN_LED             (3u)
+
+// Neopixel
+#define PIN_NEOPIXEL        (18u)
+#define NUM_NEOPIXEL        (2u)
+#define PIN_RGB             PIN_NEOPIXEL
+
+// Buzzer
+#define PIN_BUZZER          (22u)
+
+// Motor Driver
+#define PIN_M1A	            (8u)
+#define PIN_M1B	            (9u)
+#define PIN_M2A	            (10u)
+#define PIN_M2B	            (11u)
+
+// Voltage Monitor
+#define PIN_VBATT           (29u)
+#define PIN_VOLTAGE_MONITOR PIN_VBATT
+
+
+
+// Serial
+#define PIN_SERIAL1_TX      (0u)
+#define PIN_SERIAL1_RX      (1u)
+
+#define PIN_SERIAL2_TX      (4u)
+#define PIN_SERIAL2_RX      (5u)
+
+// SPI (Not pinned out)
+#define PIN_SPI0_MISO       (31u)
+#define PIN_SPI0_MOSI       (31u)
+#define PIN_SPI0_SCK        (31u)
+#define PIN_SPI0_SS         (31u)
+
+#define PIN_SPI1_MISO       (31u)
+#define PIN_SPI1_MOSI       (31u)
+#define PIN_SPI1_SCK        (31u)
+#define PIN_SPI1_SS         (31u)
+
+// Wire
+#define PIN_WIRE0_SDA       (16u)
+#define PIN_WIRE0_SCL       (17u)
+
+#define PIN_WIRE1_SDA       (2u)
+#define PIN_WIRE1_SCL       (3u)
+
+
+
+#define SERIAL_HOWMANY      (2u)
+#define SPI_HOWMANY         (0u)
+#define WIRE_HOWMANY        (2u)
+
+#include "../generic/common.h"
@@ -39,12 +39,34 @@ static const uint8_t D27 = (27u);
 static const uint8_t D28 = (28u);
 static const uint8_t D29 = (29u);

-static const uint8_t A0 = (26u);
-static const uint8_t A1 = (27u);
-static const uint8_t A2 = (28u);
-static const uint8_t A3 = (29u);
+#ifdef __PIN_A0
+	static const uint8_t A0 = __PIN_A0;
+#else
+	static const uint8_t A0 = (26u);
+#endif
+
+#ifdef __PIN_A1
+	static const uint8_t A1 = __PIN_A1;
+#else
+	static const uint8_t A1 = (27u);
+#endif
+
+#ifdef __PIN_A2
+	static const uint8_t A2 = __PIN_A2;
+#else
+	static const uint8_t A2 = (28u);
+#endif
+
+#ifdef __PIN_A3
+	static const uint8_t A3 = __PIN_A3;
+#else
+	static const uint8_t A3 = (29u);
+#endif

 static const uint8_t SS = PIN_SPI0_SS;
 static const uint8_t MOSI = PIN_SPI0_MOSI;
 static const uint8_t MISO = PIN_SPI0_MISO;
 static const uint8_t SCK = PIN_SPI0_SCK;
+
+static const uint8_t SDA = PIN_WIRE0_SDA;
+static const uint8_t SCL = PIN_WIRE0_SCL;
@@ -0,0 +1,107 @@
+/*
+    ESP8285 helper class for the Challenger RP2040 WiFi 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 <Ilabs2040WiFiClass.h>
+
+Ilabs2040WiFiClass::Ilabs2040WiFiClass() {
+  pinMode(PIN_ESP_RESET, OUTPUT);
+  digitalWrite(PIN_ESP_RESET, LOW);     // Hold ESP8285 in reset
+  pinMode(PIN_ESP_MODE, OUTPUT);
+  digitalWrite(PIN_ESP_MODE, HIGH);     // Prepare for normal start
+}
+
+// Do a HW reset by applying a low pulse to the reset line for 1mSec
+void Ilabs2040WiFiClass::doHWReset() {
+  digitalWrite(PIN_ESP_RESET, LOW);     // Hold ESP8285 in reset
+  delay(1);
+  digitalWrite(PIN_ESP_RESET, HIGH);    // Release ESP8285 reset
+}
+
+// Set the mode flag high to indicate normal run operation and do a HW
+// reset.
+void Ilabs2040WiFiClass::runReset() {   // Prepare ESP8285 for normal op
+  digitalWrite(PIN_ESP_MODE, HIGH);     // Prepare for normal start
+  doHWReset();
+}
+
+// Set the mode flag low to indicate flash operation and do a HW
+// reset.
+void Ilabs2040WiFiClass::flashReset() { // Prepare ESP8285 for flashing
+  digitalWrite(PIN_ESP_MODE, LOW);      // Prepare for normal start
+  doHWReset();
+}
+
+// Wait for the modem to reply with a "ready" prompt. This can be done
+// after a sw or hw reset have been performed to ensure that the AT
+// interpreter is up and running.
+bool Ilabs2040WiFiClass::waitForReady() {
+  int timeout = 20;                     // Aprox max 2 sec
+
+  ESP_SERIAL_PORT.begin(DEFAULT_ESP8285_BAUDRATE);
+  ESP_SERIAL_PORT.setTimeout(100);
+  String rdy = ESP_SERIAL_PORT.readStringUntil('\n');
+  while(!rdy.startsWith("ready") && timeout--) {
+    rdy = ESP_SERIAL_PORT.readStringUntil('\n');
+  }
+  ESP_SERIAL_PORT.setTimeout(1000);   // Reset default timeout to 1000
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Reset the ESP8285 and wait for the "ready" prompt to be returned.
+bool Ilabs2040WiFiClass::reset() {
+  runReset();
+  return waitForReady();
+}
+
+// Checks to see if the modem responds to the "AT" poll command.
+bool Ilabs2040WiFiClass::isAlive() {
+  int timeout = 5;
+
+  ESP_SERIAL_PORT.setTimeout(250);
+  ESP_SERIAL_PORT.println(F("AT"));
+  String rdy = ESP_SERIAL_PORT.readStringUntil('\n');
+  while(!rdy.startsWith(F("OK")) && timeout--) {
+    rdy = ESP_SERIAL_PORT.readStringUntil('\n');
+  }
+  ESP_SERIAL_PORT.setTimeout(1000);
+
+  if (timeout)
+    return true;
+  return false;
+}
+
+// Change the baud rate of the ESP8285 as well as the local UART.
+// No checking is done on the input baud rate so the user must know what
+// baud rates are valid. The function ends by checking if the ESP8285 is
+// reachable by doing an "AT" poll.
+bool Ilabs2040WiFiClass::changeBaudRate(int baud) {
+  ESP_SERIAL_PORT.print(F("AT+UART_CUR="));
+  ESP_SERIAL_PORT.print(baud);
+  ESP_SERIAL_PORT.println(F(",8,1,0,0"));
+  delay(100);
+  ESP_SERIAL_PORT.end();
+  ESP_SERIAL_PORT.begin(baud);
+  return isAlive();
+}
+
+Ilabs2040WiFiClass Ilabs2040WiFi;
@@ -1,7 +1,7 @@
 /*
-    Millis() for the Raspberry Pi Pico RP2040
+    ESP8285 helper class for the Challenger RP2040 WiFi boards

-    Copyright (c) 2021 Earle F. Philhower, III <earlephilhower@yahoo.com>
+    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
@@ -17,13 +17,20 @@
    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 <pico/time.h>
+#define DEFAULT_ESP8285_BAUDRATE      115200

-extern "C" unsigned long millis() {
-    return to_ms_since_boot(get_absolute_time());
-}
+class Ilabs2040WiFiClass {
+  public:
+    Ilabs2040WiFiClass();
+    void doHWReset();
+    void runReset();
+    void flashReset();
+    bool waitForReady();
+    bool reset();
+    bool isAlive();
+    bool changeBaudRate(int baud);
+};

-extern "C" unsigned long micros() {
-    return time_us_32();
-}
+extern Ilabs2040WiFiClass Ilabs2040WiFi;
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <Ilabs2040WiFiClass.h>
+
+#define PINS_COUNT          (26u)
+#define NUM_DIGITAL_PINS    (26u)
+#define NUM_ANALOG_INPUTS   (4u)
+#define NUM_ANALOG_OUTPUTS  (0u)
+#define ADC_RESOLUTION      (12u)
+
+// Connected to ESP8285
+#define PIN_SERIAL1_TX      (0u)
+#define PIN_SERIAL1_RX      (1u)
+#define PIN_ESP_RESET       (2u)
+#define PIN_ESP_MODE        (3u)
+#define PIN_ESP_TXD         PIN_SERIAL1_TX
+#define PIN_ESP_RXD         PIN_SERIAL1_RX
+#define ESP_SERIAL_PORT     Serial1
+
+// Serial
+#define PIN_SERIAL2_TX      (8u)
+#define PIN_SERIAL2_RX      (9u)
+
+// SPI
+#define PIN_SPI0_MISO       (24u)
+#define PIN_SPI0_MOSI       (23u)
+#define PIN_SPI0_SCK        (22u)
+#define PIN_SPI0_SS         (21u)
+
+// Not pinned out
+#define PIN_SPI1_MISO       (31u)
+#define PIN_SPI1_MOSI       (31u)
+#define PIN_SPI1_SCK        (31u)
+#define PIN_SPI1_SS         (31u)
+
+// Wire
+#define PIN_WIRE0_SDA       (4u)
+#define PIN_WIRE0_SCL       (5u)
+
+// Not pinned out
+#define PIN_WIRE1_SDA       (31u)
+#define PIN_WIRE1_SCL       (31u)
+
+#define SERIAL_HOWMANY      (2u)
+#define SPI_HOWMANY         (1u)
+#define WIRE_HOWMANY        (1u)
+
+static const uint8_t D0 = (0u);     // Internal to the board
+static const uint8_t D1 = (1u);     // Internal to the board
+static const uint8_t D2 = (2u);     // Internal to the board
+static const uint8_t D3 = (3u);     // Internal to the board
+static const uint8_t D4 = (4u);
+static const uint8_t D5 = (5u);
+static const uint8_t D6 = (6u);
+static const uint8_t D7 = (7u);
+static const uint8_t D8 = (8u);
+static const uint8_t D9 = (9u);
+static const uint8_t D10 = (10u);
+static const uint8_t D11 = (11u);
+static const uint8_t D12 = (12u);
+static const uint8_t D13 = (13u);
+static const uint8_t D14 = (14u);
+static const uint8_t D15 = (15u);
+static const uint8_t D16 = (16u);
+static const uint8_t D17 = (17u);
+static const uint8_t D18 = (18u);
+static const uint8_t D19 = (19u);
+static const uint8_t D20 = (20u);
+static const uint8_t D21 = (21u);
+static const uint8_t D22 = (22u);
+static const uint8_t D23 = (23u);
+static const uint8_t D24 = (24u);
+static const uint8_t D25 = (25u);
+static const uint8_t D26 = (26u);
+static const uint8_t D27 = (27u);
+static const uint8_t D28 = (28u);
+static const uint8_t D29 = (29u);
+
+static const uint8_t A0 = (26u);
+static const uint8_t A1 = (27u);
+static const uint8_t A2 = (28u);
+static const uint8_t A3 = (29u);
@@ -0,0 +1,39 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://datasheets.raspberrypi.org/pico/pico-datasheet.pdf
+
+
+// LEDs
+#define PIN_LED        (25u)
+
+// Serial
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+#define PIN_SERIAL2_TX (8u)
+#define PIN_SERIAL2_RX (9u)
+
+// SPI
+#define PIN_SPI0_MISO  (20u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (1u)
+
+#define PIN_SPI1_MISO  (12u)
+#define PIN_SPI1_MOSI  (11u)
+#define PIN_SPI1_SCK   (10u)
+#define PIN_SPI1_SS    (13u)
+
+// Wire
+#define PIN_WIRE0_SDA  (8u) 
+#define PIN_WIRE0_SCL  (9u)
+
+#define PIN_WIRE1_SDA  (2u) 
+#define PIN_WIRE1_SCL  (3u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (2u)
+
+#include "../generic/common.h"
@@ -0,0 +1,40 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://rp2040-stamp.solder.party/carrier
+
+// LEDs
+#define PIN_LED        (20u)
+
+// Serial
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+#define PIN_SERIAL2_TX (24u)
+#define PIN_SERIAL2_RX (25u)
+
+// SPI
+#define PIN_SPI0_MISO  (16u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (17u)
+
+#define PIN_SPI1_MISO  (8u)
+#define PIN_SPI1_MOSI  (11u)
+#define PIN_SPI1_SCK   (10u)
+#define PIN_SPI1_SS    (9u)
+
+// Wire
+#define PIN_WIRE0_SDA  (4u)
+#define PIN_WIRE0_SCL  (5u)
+
+#define PIN_WIRE1_SDA  (2u)
+#define PIN_WIRE1_SCL  (3u)
+
+#define SERIAL_HOWMANY (2u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (2u)
+
+#define PIN_NEOPIXEL   (21u)
+
+#include "../generic/common.h"
@@ -0,0 +1,39 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://datasheets.raspberrypi.org/pico/pico-datasheet.pdf
+
+
+// LEDs
+#define PIN_LED        (25u)
+
+// Serial
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+#define PIN_SERIAL2_TX (8u)
+#define PIN_SERIAL2_RX (9u)
+
+// SPI
+#define PIN_SPI0_MISO  (16u)
+#define PIN_SPI0_MOSI  (19u)
+#define PIN_SPI0_SCK   (18u)
+#define PIN_SPI0_SS    (17u)
+
+#define PIN_SPI1_MISO  (12u)
+#define PIN_SPI1_MOSI  (15u)
+#define PIN_SPI1_SCK   (14u)
+#define PIN_SPI1_SS    (13u)
+
+// Wire
+#define PIN_WIRE0_SDA  (4u)
+#define PIN_WIRE0_SCL  (5u)
+
+#define PIN_WIRE1_SDA  (22u)
+#define PIN_WIRE1_SCL  (23u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (2u)
+#define WIRE_HOWMANY   (2u)
+
+#include "../generic/common.h"
@@ -0,0 +1 @@
+#include "../generic/pins_arduino.h"
Author	SHA1	Message	Date
Earle F. Philhower, III	d51fa99b70	Update package.json	2022-01-20 08:54:58 -08:00
Earle F. Philhower, III	2c97bffc54	Update to latest upstream LittleFS (#425 ) Also clean up output in SpeedTest, make more human friendly	2022-01-19 18:09:40 -08:00
Earle F. Philhower, III	626b62c413	Update to latest upstream Keyboard/Mouse (#424 ) Keyboard class now has support for non-en_US layouts, and documentation has been added to the Mouse class. Thanks to @rico0260 for letting me know about the update, and for the initial PR!	2022-01-19 17:46:31 -08:00
Earle F. Philhower, III	25b9ca821e	Only call Wire.onReceive if data is available (#423 ) The Pico HW seems to generate an interrupt on the end of every I2C write cycle, even if the slave address wasn't actually targeted. This would cause the onReceive method to be called with a 0-len parameter for every write on the I2C bus. Now, only call onReceive if there is 1 or more bytes of data available.	2022-01-19 16:16:39 -08:00
Earle F. Philhower, III	d5ddf4cd7f	Move SdFat to master/head (#422 ) SdFat used to point to unnamed commit in the ESP8266SdFat repo. Master in that repo has now been moved to that commit, so make this core use the master branch for sanity's sake.	2022-01-19 12:30:12 -08:00
Earle F. Philhower, III	d43dcbcf8c	Remove duplicate millis/micros definitions (#419 ) Fixes #418	2022-01-15 09:40:31 -08:00
Juraj Andrássy	1fdc0ab7c1	Arduino Nano R2040 Connect Nina pins access with WiFiNINA lib (#404 )	2022-01-09 09:11:27 -08:00
Khoi Hoang	9408b7e2c4	Fix WiFiNINA issue for Arduino Nano Connect (#403 ) Fixes #373	2022-01-09 08:03:53 -08:00
Earle F. Philhower, III	12f3505eea	Update the platform release version	2022-01-05 12:16:21 -08:00
Earle F. Philhower, III	464ee85884	Make Wire buffer default to 256 for MBED compatibility (#412 ) Fixes #411	2022-01-05 12:14:34 -08:00
Earle F. Philhower, III	87d745d5dc	Add missing board names	2022-01-05 07:45:09 -08:00
Earle F. Philhower, III	576f8941d6	Add setFIFOSize to UART Serial ports (#410 ) Allow setting the size of the receive buffer by the application using a call to Serial1/2.setFIFOSize(xxx) before the begin() call.	2022-01-04 19:02:38 -08:00
Earle F. Philhower, III	039cbcf2cf	Update package.json	2022-01-04 18:53:31 -08:00
arturo182	f91c4b3b9d	Add the RP2040 Stamp board (#407 )	2022-01-03 11:38:05 -08:00
Earle F. Philhower, III	83b9486985	Allow setting the SerialPIO FIFO depth in the constructor (#405 ) Defaults to 32 bytes, like the HW Serial ports, but can be set to any desired value when instantiated.	2022-01-02 11:31:06 -08:00
Earle F. Philhower, III	dc54eeb8d0	Update package.json	2022-01-02 09:45:44 -08:00
Earle F. Philhower, III	3a2a7f8cf1	Fix hang on Serial overflow, PIOSerial stop bit handling (#401 ) When the Serial software FIFOs overeflowed, the IRQ handler would not read any more data from the hardware FIFOs. This would cause the IRQ handler to be continually called as soon as it exited since the HW FIFOS were not empty. Now always read every available HW FIFO entry and throw out any that don't fit in the SW FIFO. Also fix a too long by half stop bit timing in the PIOSerial receiver.	2022-01-02 05:46:33 -08:00
Khoi Hoang	52a22e5185	Fix Nano_RP2040_Connect pinout issue (#400 ) Fix issues with [WiFiNINA](https://github.com/arduino-libraries/WiFiNINA) and [WiFiNINA_Generic](https://github.com/khoih-prog/WiFiNINA_Generic) libraries Fixes #373 Fixes #375 Fixes #376	2022-01-01 13:05:25 -08:00
Earle F. Philhower, III	cae8c70e51	Add the PIO UARTs to the list	2021-12-30 16:02:15 -08:00
Earle F. Philhower, III	513bd81810	Add SDA/SCL variables like other cores export (#398 ) Fixes #368. Thanks @bperrybap!	2021-12-30 15:57:13 -08:00
Earle F. Philhower, III	891f653ead	Update package.json	2021-12-30 09:56:59 -08:00
Ken Piper	5b270aab61	Fix A0-A3 pin definitions for Adafruit QT Py RP2040 (#397 )	2021-12-30 09:56:38 -08:00
Maximilian Gerhardt	6591da9acf	Fix PlatformIO build (#395 ) Defines USBD_MAX_POWER_MA as a static 250mA, which is correct for all the boards supported in platform-raspberrypi (aka, RaspberryPi Pico and Nano RP2040 Connect)	2021-12-29 09:19:47 -08:00
Earle F. Philhower, III	c80c08d32c	Update package.json	2021-12-28 08:27:34 -08:00
Earle F. Philhower, III	ce7d337c5c	Add SoftwareSerial-like PIO based UARTs (#391 ) Adds support to the core for PIO-based, software-created UARTs, up to 8 (the number of PIO state machines) possible. By using a custom program on the PIO state machines, it allows for very high bit rates and does not require CPU or interrupts. Bit widths from 5- to 8-bits, 1 or 2 stop bits, and even/odd/none parity are supported.	2021-12-28 08:27:08 -08:00
Earle F. Philhower, III	dc1198bd9c	Use interrupts to capture Serial UART data, not polling (#393 ) PR #379 was an ugly hack which works only if you poll the Serial port more frequently than ~8 byte times. This PR replaces the polling with an IRQ based lockless writer/reader queue so that even if you only read every 32 byte times, the Serial1/2 port should not lose data. It also should use less CPU and allow for somewhat higher throughput.	2021-12-28 08:21:03 -08:00
Earle F. Philhower, III	f46d7cc84f	Speed up SPI by not reinitting if the paramters are the same as before (#394 ) Leave the SPI port initted after a transaction, and when a new one comes in check if it is the same settings we're already running. If so, do nothing. If not, deinit and reinit. In general the settings will be identical, so this will speed things up massively. Fixes #392	2021-12-27 12:25:12 -08:00
Earle F. Philhower, III	5ee764390e	Update README.md	2021-12-26 05:29:10 -08:00
Limor "Ladyada" Fried	894a82f54f	Add Adafruit KB2040 (#390 )	2021-12-26 05:28:50 -08:00
Earle F. Philhower, III	5cc9835303	Add warning not to edit boards.txt (#383 )	2021-12-23 08:09:59 -08:00
Earle F. Philhower, III	48877984b7	Remove redundant board.mcu in boards.txt, fix precompiled libs (#382 ) * Remove redundant/wrong second board.mcu in boards.txt Fixes #380 Boards.txt had the setting board.mcu twice. The first one was correct, while the second one wasn't and shouldn't have been there. Remove it. * Include fix from @rei-vilo in #381	2021-12-23 07:55:34 -08:00
Earle F. Philhower, III	a58f49018a	Add a poor-man's software FIFO for serial UART reads (#379 ) Because the hardware FIFO is quite small and doesn't report the actual number of bytes available, implement a software FIFO that will pull all available bytes out of the HW FIFO on any Serial call. It's not as efficient or as bulletproof as an IRQ based method, but it is simpler to implement and can help with issues like #378	2021-12-23 07:41:34 -08:00
Earle F. Philhower, III	7120a1508c	Update to SDK version 1.3.0 (#371 )	2021-12-14 18:59:24 -08:00
Pontus Oldberg	a808f4ae6a	Adds option for setting USB max power in makeboards.py (#370 )	2021-12-10 04:11:22 -08:00
Pontus Oldberg	4d1f5baa7e	Adds a lightweight support class for LTE functionality (#367 )	2021-12-09 09:55:09 -08:00
Pontus Oldberg	f106035100	Adds support for Challenger NB RP2040 WiFi board and RPICO32 module (#366 )	2021-12-07 09:44:38 -08:00
Earle F. Philhower, III	21f49d032b	Update README.md	2021-12-06 00:03:11 -08:00
Wai Weng	341307cb8d	Added new variant: Cytron Maker Nano RP2040. (#365 )	2021-12-06 00:02:54 -08:00
Earle F. Philhower, III	85990ff51d	Support CMSIS and rename conflicting header file (#362 )	2021-12-03 12:49:34 -08:00
Eric Lind	238a6c83db	Update pins_arduino.h for challenger_2040_wifi (#356 ) Adding definitions for internal reset and mode pins for ESP8285.	2021-12-01 08:08:37 -08:00
Earle F. Philhower, III	77f03a44b6	Add WIZnet W5100S-EVB-Pico board (#355 )	2021-11-30 17:11:08 -08:00
Earle F. Philhower, III	29756de336	Update to SDFat 2.1.1 with UTF-8 support (#343 )	2021-11-30 17:06:58 -08:00
Earle F. Philhower, III	1afbbaba63	Add RTC headers to path and pico_utils to link (#353 ) Fixes #348 Add the RTC header path in the SDK to the Arduino build path. Also add pico_utils to the libpico.a for the datetime_to_str call. Note that the pico_sdk has a bug in the datetime.h header so you need to manually bracket the include file as "C": extern "C" { #include "pico/util/datetime.h" }	2021-11-28 09:00:14 -08:00
Maximilian Gerhardt	52b3120448	Correct typo in PlatformIO docs (#342 )	2021-11-02 08:54:47 -07:00
Earle F. Philhower, III	b7d76bd51d	Add RTTI menu to support apps which need RTTI (#338 ) By default RTTI (Run-Time Type Information) is disabled because most apps don't need run time type info enabled. However, certain libraries expect to be able to query types of objects at runtime, so add a menu to enable it.	2021-10-29 08:22:27 -07:00
Earle F. Philhower, III	c0411eefeb	Update README.md	2021-10-29 08:13:08 -07:00
uPesy Electronics	3d821f73a4	Add board variant for uPesy RP2040 DevKit (#335 )	2021-10-29 08:12:45 -07:00
Earle F. Philhower, III	1726f56a27	Update README.md	2021-10-29 08:04:33 -07:00
Wai Weng	a305b30d90	Added board variants Cytron Maker Pi RP2040. (#340 )	2021-10-29 08:04:15 -07:00
Giampiero Baggiani	9bed59858b	Disable pull-up/pull-down when setting pin as input (#332 ) In `pinMode()` I think it would be better to call `gpio_disable_pulls()` on the ulPin when ulMode == INPUT. Adding `gpio_disable_pulls(RP_PIN);` after `pinMode(RP_PIN, INPUT);` solves the issue.	2021-10-06 03:26:11 -07:00
apendley	cf63040c5a	Fix Wire pin definitions on ItsyBitsy (#325 )	2021-09-26 18:19:49 -07:00
Leonardo La Rocca	e8ec79290b	Reverted Wire and Wire1 for Melopero (#323 )	2021-09-26 18:11:25 -07:00
Mike Lynch	0c22150fdb	Add compiler Optimize option (#322 )	2021-09-26 18:05:35 -07:00
Ha Thach	423476dc87	Change qtpy boot2 to w25q080_2_padded (#321 )	2021-09-22 07:40:03 -07:00
Leonardo La Rocca	bfa3819b0d	Melopero Shake: Switched Wire1 with Wire for simpler use (#320 )	2021-09-22 07:39:25 -07:00
Earle F. Philhower, III	adf1c88c27	Fix spelling and update readme. Prep for 1.9.5 (#319 )	2021-09-19 13:43:26 -07:00
Dan Halbert	ad905ae992	Build libpico.a with PICO_XOSC_STARTUP_DELAY_MULTIPLIER=64 (#315 ) Fixes #312	2021-09-19 13:31:39 -07:00
Leonardo La Rocca	608a5da480	Adds board variant definition for Melopero Shake RP2040 (#318 )	2021-09-19 13:26:33 -07:00
Maximilian Gerhardt	3df3f0741a	Add PlatformIO support (#250 ) * Add package.json To make package easily integratable with PlatformIO * Correct name back to original one * Format package.json * Add first shot at builder script * Add USB stack flags, fix compile flags * Formatting * Add more link & USB flags * Build Boot2 bootloader * Formatting * Generate linkerscript, linker fixes * Fix linkflags, make firmware runnable * Update USB flags and RAM size * Correct USB flags, add dynamic sketch partitioning * Restructure filesystem size and flash size logic into platform code * Move C++ only flags to CXXFLAGS * Add PlatformIO documentation * Link to new platform.io document in the docs TOC * Fix typos in platformio docs * Fix one additional typo in platformio.rst * Update docs * Remove wrongly commited build folder	2021-09-13 21:28:07 -07:00
SirSydom	3585c58688	Reset the SDA and SCL pins to INPUT at Wire.end() to prevent multiple pins connected to I2C when changing pins (#302 )	2021-09-03 08:40:18 -07:00
Earle F. Philhower, III	a8121f31d4	Fix pulseIn detection (#293 ) Fixes #289	2021-08-30 12:40:38 -07:00
AustinMorris	38c005c208	Fix wire defines on feather (#281 )	2021-08-23 20:45:12 -07:00
Pontus Oldberg	cd91d3ef0f	Added minimal HW support for onboard WiFi modem. (#287 )	2021-08-23 20:34:25 -07:00
Pontus Oldberg	02e8577f45	Add support for reverse numbering of analog pins. (#283 )	2021-08-17 09:44:28 -07:00