Update version

Fix deadlock in attachInterruptParam (#953 )
Thanks to @imwoo90 comment in https://github.com/earlephilhower/arduino-pico/issues/878#issuecomment-1302276196
2022-11-03 08:54:31 -07:00 · 2022-11-03 08:40:57 -07:00 · 2022-11-03 08:35:40 -07:00 · 2022-11-02 15:27:02 -07:00 · 2022-10-31 17:10:59 -07:00 · 2022-10-31 17:01:10 -07:00
170 changed files with 9270 additions and 6658 deletions
@@ -6,6 +6,10 @@ name: Arduino-Pico CI
 on:
  pull_request:

+env:
+  TRAVIS_BUILD_DIR: ${{ github.workspace }}
+  TRAVIS_TAG: ${{ github.ref }}
+

 jobs:

@@ -20,7 +24,7 @@ jobs:
    - name: Run codespell
      uses: codespell-project/actions-codespell@master
      with:
-        skip: ./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api,./libraries/FreeRTOS,./tools/libbearssl/bearssl,./include,./libraries/WiFi/examples/BearSSL_Server,./ota/uzlib,./libraries/http-parser/lib,./libraries/WebServer/examples/HelloServerBearSSL/HelloServerBearSSL.ino,./libraries/HTTPUpdateServer/examples/SecureBearSSLUpdater/SecureBearSSLUpdater.ino
+        skip: ./ArduinoCore-API,./libraries/ESP8266SdFat,./libraries/Adafruit_TinyUSB_Arduino,./libraries/LittleFS/lib,./tools/pyserial,./pico-sdk,./.github,./docs/i2s.rst,./cores/rp2040/api,./libraries/FreeRTOS,./tools/libbearssl/bearssl,./include,./libraries/WiFi/examples/BearSSL_Server,./ota/uzlib,./libraries/http-parser/lib,./libraries/WebServer/examples/HelloServerBearSSL/HelloServerBearSSL.ino,./libraries/HTTPUpdateServer/examples/SecureBearSSLUpdater/SecureBearSSLUpdater.ino,./.git
        ignore_words_list: ser,dout

 # Consistent style
@@ -46,10 +50,6 @@ 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

 # Build all examples on linux (core and Arduino IDE)
  build-linux:
@@ -62,19 +62,17 @@ jobs:
    - uses: actions/checkout@v3
      with:
        submodules: true
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
      with:
        python-version: '3.x'
    - name: Cache Linux toolchain
      id: cache-linux
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ./tools/dist
        key: ${{ runner.os }}-${{ hashFiles('package/package_pico_index.template.json', 'tests/common.sh') }}
    - name: Build Sketches
      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-        TRAVIS_TAG: ${{ github.ref }}
        BUILD_PARITY: custom
        mod: 6
        rem: ${{ matrix.chunk }}
@@ -92,19 +90,17 @@ jobs:
    - uses: actions/checkout@v3
      with:
        submodules: true
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
      with:
        python-version: '3.x'
    - name: Cache Linux toolchain
      id: cache-linux
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ./tools/dist
        key: ${{ runner.os }}-${{ hashFiles('package/package_pico_index.template.json', 'tests/common.sh') }}
    - name: Build Sketches
      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-        TRAVIS_TAG: ${{ github.ref }}
        BUILD_PARITY: custom
      run: |
        cd pico-sdk
@@ -120,19 +116,17 @@ jobs:
    - uses: actions/checkout@v3
      with:
        submodules: true
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
      with:
        python-version: '3.x'
    - name: Cache Windows toolchain
      id: cache-windows
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ./tools/dist
        key: ${{ runner.os }}-${{ hashFiles('package/package_pico_index.template.json', 'tests/common.sh') }}
    - name: Build Sketch
      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-        TRAVIS_TAG: ${{ github.ref }}
        WINDOWS: 1
        BUILD_PARITY: custom
        mod: 500
@@ -150,24 +144,22 @@ jobs:
 # Single build under macOS to ensure the Mac toolchain is good.
  build-mac:
    name: Mac
-    runs-on: macOS-latest
+    runs-on: macOS-12
    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
      with:
        python-version: '3.x'
    - name: Cache Mac toolchain
      id: cache-mac
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ./tools/dist
        key: ${{ runner.os }}-${{ hashFiles('package/package_pico_index.template.json', 'tests/common.sh') }}
    - name: Build Sketch
      env:
-        TRAVIS_BUILD_DIR: ${{ github.workspace }}
-        TRAVIS_TAG: ${{ github.ref }}
        MACOSX: 1
        BUILD_PARITY: custom
        mod: 500
@@ -194,19 +186,21 @@ jobs:
        git submodule update --init
        cd ../..
    - name: Cache pip
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
        restore-keys: |
          ${{ runner.os }}-pip-
    - name: Cache PlatformIO
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ~/.platformio
        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
    - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
    - name: Install PlatformIO
      run: |
        python -m pip install --upgrade pip
@@ -9,22 +9,22 @@ jobs:
    name: Update master JSON file
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
      with:
        submodules: true
    - name: Cache pip
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
        restore-keys: |
          ${{ runner.os }}-pip-
    - name: Cache PlatformIO
-      uses: actions/cache@v2
+      uses: actions/cache@v3
      with:
        path: ~/.platformio
        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
      with:
        python-version: '3.x'
    - name: Install PlatformIO
@@ -15,11 +15,11 @@ jobs:
    name: Package
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
      with:
        submodules: true
        fetch-depth: 0
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v4
      with:
        python-version: '3.x'
    - name: Build package JSON
@@ -20,8 +20,10 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 * Adafruit STEMMA Friend RP2040
 * Adafruit Trinkey RP2040 QT
 * Arduino Nano RP2040 Connect
+* BridgeTek IDM2040-7A
 * Cytron Maker Pi RP2040
 * Cytron Maker Nano RP2040
+* Degz Mizu
 * DeRuiLab FlyBoard2040 Core
 * DFRobot Beetle RP2040
 * ElectronicCats Hunter Cat NFC
@@ -34,7 +36,9 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 * Invector Labs Challenger RP2040 SubGHz
 * Invector Labs Challenger RP2040 SD/RTC
 * Invector Labs RPICO32
+* Melopero Cookie RP2040
 * Melopero Shake RP2040
+* Pimoroni PGA2040
 * Seeed XIAO RP2040
 * Solder Party RP2040 Stamp
 * SparkFun ProMicro RP2040
@@ -173,6 +177,7 @@ Here are some links to coverage and additional tutorials for using `arduino-pico
 * Pre-release Adafruit QT Py RP2040 - https://www.youtube.com/watch?v=sfC1msqXX0I
 * Adafruit Feather RP2040 running LCD + TMP117 - https://www.youtube.com/watch?v=fKDeqZiIwHg
 * Demonstration of Servos and I2C in Korean - https://cafe.naver.com/arduinoshield/1201
+* Home Assistant Pico W integration starter project using Arduino - https://github.com/daniloc/PicoW_HomeAssistant_Starter

 # Contributing
 If you want to contribute or have bugfixes, drop me a note at <earlephilhower@yahoo.com> or open an issue/PR here.
@@ -0,0 +1,23 @@
+// Padded and checksummed version of: boot2_w25q64jv.4.bin
+
+.cpu cortex-m0plus
+.thumb
+
+.section .boot2, "ax"
+
+.byte 0xf7, 0xb5, 0x73, 0x46, 0x21, 0x22, 0x02, 0x25, 0x01, 0x93, 0x29, 0x4b, 0xc0, 0x24, 0x5a, 0x60
+.byte 0x9a, 0x68, 0x01, 0x26, 0xaa, 0x43, 0xda, 0x60, 0x9a, 0x60, 0x1a, 0x61, 0x5a, 0x61, 0x00, 0x23
+.byte 0x64, 0x05, 0xa3, 0x60, 0x04, 0x33, 0x63, 0x61, 0x22, 0x4b, 0x28, 0x00, 0x1e, 0x60, 0xe0, 0x23
+.byte 0xdb, 0x02, 0x23, 0x60, 0x35, 0x23, 0xa6, 0x60, 0x23, 0x66, 0x23, 0x66, 0x00, 0xf0, 0x4a, 0xf8
+.byte 0xc0, 0xb2, 0xa8, 0x42, 0x12, 0xd0, 0x06, 0x23, 0x30, 0x00, 0x23, 0x66, 0x00, 0xf0, 0x42, 0xf8
+.byte 0x31, 0x23, 0x28, 0x00, 0x23, 0x66, 0x25, 0x66, 0x00, 0xf0, 0x3c, 0xf8, 0x03, 0x35, 0x25, 0x66
+.byte 0x02, 0x20, 0x25, 0x66, 0x00, 0xf0, 0x36, 0xf8, 0x30, 0x42, 0xf8, 0xd1, 0x00, 0x25, 0x12, 0x4b
+.byte 0xa5, 0x60, 0x12, 0x4f, 0x23, 0x60, 0x12, 0x4b, 0x65, 0x60, 0x01, 0x26, 0x3b, 0x60, 0xeb, 0x23
+.byte 0xa6, 0x60, 0x23, 0x66, 0x4b, 0x3b, 0x23, 0x66, 0x02, 0x20, 0x00, 0xf0, 0x23, 0xf8, 0x0d, 0x4b
+.byte 0xa5, 0x60, 0x3b, 0x60, 0xa6, 0x60, 0x01, 0x9b, 0xab, 0x42, 0x08, 0xd1, 0x0a, 0x4b, 0x0b, 0x4a
+.byte 0x13, 0x60, 0x1b, 0x68, 0x83, 0xf3, 0x08, 0x88, 0x09, 0x4b, 0x1b, 0x68, 0x18, 0x47, 0xf7, 0xbd
+.byte 0x00, 0x00, 0x02, 0x40, 0xf0, 0x00, 0x00, 0x18, 0x00, 0x03, 0x5f, 0x00, 0xf4, 0x00, 0x00, 0x18
+.byte 0x21, 0x22, 0x00, 0x00, 0x22, 0x20, 0x00, 0xa0, 0x00, 0x01, 0x00, 0x10, 0x08, 0xed, 0x00, 0xe0
+.byte 0x04, 0x01, 0x00, 0x10, 0xc0, 0x23, 0x02, 0x00, 0x04, 0x21, 0x5b, 0x05, 0x98, 0x6a, 0x08, 0x42
+.byte 0xfc, 0xd0, 0x01, 0x21, 0x98, 0x6a, 0x08, 0x42, 0xfc, 0xd1, 0x18, 0x6e, 0x01, 0x2a, 0x00, 0xd0
+.byte 0x18, 0x6e, 0x70, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x2d, 0x68, 0xca
@@ -0,0 +1,57 @@
+/*
+    CoreMutex for the Raspberry Pi Pico RP2040
+
+    Implements a deadlock-safe multicore mutex for sharing things like the
+    USB or UARTs.
+
+    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 "Arduino.h"
+#include "CoreMutex.h"
+
+CoreMutex::CoreMutex(mutex_t *mutex, bool debugEnable) {
+    _mutex = mutex;
+    _acquired = false;
+    if (__isFreeRTOS) {
+        auto m = __get_freertos_mutex_for_ptr(mutex);
+        __freertos_mutex_take(m);
+    } else {
+        uint32_t owner;
+        if (!mutex_try_enter(_mutex, &owner)) {
+            if (owner == get_core_num()) { // Deadlock!
+                if (debugEnable) {
+                    DEBUGCORE("CoreMutex - Deadlock detected!\n");
+                }
+                return;
+            }
+            mutex_enter_blocking(_mutex);
+        }
+    }
+    _acquired = true;
+}
+
+CoreMutex::~CoreMutex() {
+    if (_acquired) {
+        if (__isFreeRTOS) {
+            auto m = __get_freertos_mutex_for_ptr(_mutex);
+            __freertos_mutex_give(m);
+        } else {
+            mutex_exit(_mutex);
+        }
+    }
+}
@@ -24,30 +24,12 @@
 #pragma once

 #include "pico/mutex.h"
+#include "_freertos.h"

 class CoreMutex {
 public:
-    CoreMutex(mutex_t *mutex, bool debugEnable = true) {
-        uint32_t owner;
-        _mutex = mutex;
-        _acquired = false;
-        if (!mutex_try_enter(_mutex, &owner)) {
-            if (owner == get_core_num()) { // Deadlock!
-                if (debugEnable) {
-                    DEBUGCORE("CoreMutex - Deadlock detected!\n");
-                }
-                return;
-            }
-            mutex_enter_blocking(_mutex);
-        }
-        _acquired = true;
-    }
-
-    ~CoreMutex() {
-        if (_acquired) {
-            mutex_exit(_mutex);
-        }
-    }
+    CoreMutex(mutex_t *mutex, bool debugEnable = true);
+    ~CoreMutex();

    operator bool() {
        return _acquired;
@@ -240,7 +240,7 @@ protected:
    }
    time_t (*_timeCallback)(void) = nullptr;
    static time_t _defaultTimeCB(void) {
-        return time(NULL);
+        return time(nullptr);
    }
 };

@@ -129,10 +129,10 @@ struct TimeUnit {
    }
 };

-using TimeMillis     = TimeUnit< TimeSourceMillis,       1000 >;
-using TimeFastMillis = TimeUnit< TimeSourceCycles,       1000 >;
-using TimeFastMicros = TimeUnit< TimeSourceCycles,    1000000 >;
-using TimeFastNanos  = TimeUnit< TimeSourceCycles, 1000000000 >;
+using TimeMillis     = TimeUnit < TimeSourceMillis, 1'000 >;
+using TimeFastMillis = TimeUnit < TimeSourceCycles, 1'000 >;
+using TimeFastMicros = TimeUnit < TimeSourceCycles, 1'000'000 >;
+using TimeFastNanos  = TimeUnit < TimeSourceCycles, 1'000'000'000 >;

 } //TimePolicy

@@ -1,10 +1,7 @@
 /*
-    WiFiMutex.h - Ensure the timer-driven sys_check_timeouts doesn't
-                  get executed while we're in the user-level TCP stack.
-    Copyright (c) 2022 Earle F. Philhower, III.  All rights reserved.
+    RP2040 utility class

-    Implements the API defined by the Arduino WiFiNINA library,
-    copyright (c) 2018 Arduino SA. All rights reserved.
+    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
@@ -21,21 +18,16 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

-#pragma once
+#include <Arduino.h>
+#include <hardware/structs/psm.h>

-extern "C" volatile bool __inLWIP;
+extern "C" void boot_double_tap_check();

-class LWIPMutex {
-public:
-    LWIPMutex() {
-        __inLWIP = true;
-        _ref++;
+// The following check will never actually execute, but it will cause the boot reset
+// checker to be linked in as part of the constructors.
+
+void RP2040::enableDoubleResetBootloader() {
+    if (psm_hw->done == 0) {
+        boot_double_tap_check();
    }
-    ~LWIPMutex() {
-        if (0 == --_ref) {
-            __inLWIP = false;
-        }
-    }
-private:
-    static int _ref;
-};
+}
@@ -32,20 +32,10 @@
 #include "ccount.pio.h"
 #include <malloc.h>

+#include "_freertos.h"
+
 extern "C" volatile bool __otherCoreIdled;

-// Halt the FreeRTOS PendSV task switching magic
-extern "C" int __holdUpPendSV;
-
-// FreeRTOS weak functions, to be overridden when we really are running FreeRTOS
-extern "C" {
-    extern void vTaskSuspendAll() __attribute__((weak));
-    extern int32_t xTaskResumeAll() __attribute__((weak));
-    typedef struct tskTaskControlBlock * TaskHandle_t;
-    extern void vTaskPreemptionDisable(TaskHandle_t p) __attribute__((weak));
-    extern void vTaskPreemptionEnable(TaskHandle_t p) __attribute__((weak));
-}
-
 class _MFIFO {
 public:
    _MFIFO() { /* noop */ };
@@ -248,7 +238,7 @@ public:
    // Convert from microseconds to PIO clock cycles
    static int usToPIOCycles(int us) {
        // Parenthesis needed to guarantee order of operations to avoid 32bit overflow
-        return (us * (clock_get_hz(clk_sys) / 1000000));
+        return (us * (clock_get_hz(clk_sys) / 1'000'000));
    }

    // Get current clock frequency
@@ -324,8 +314,18 @@ public:
        reboot();
    }

+    static void enableDoubleResetBootloader();
+
+    void wdt_begin(uint32_t delay_ms) {
+        watchdog_enable(delay_ms, 1);
+    }
+
+    void wdt_reset() {
+        watchdog_update();
+    }
+
    const char *getChipID() {
-        static char id[PICO_UNIQUE_BOARD_ID_SIZE_BYTES + 1] = { 0 };
+        static char id[2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES + 1] = { 0 };
        if (!id[0]) {
            pico_get_unique_board_id_string(id, sizeof(id));
        }
@@ -71,8 +71,6 @@ static int __usb_task_irq;

 #define EPNUM_HID   0x83

-#define EPNUM_MIDI   0x01
-

 const uint8_t *tud_descriptor_device_cb(void) {
    static tusb_desc_device_t usbd_desc_device = {
@@ -91,7 +89,7 @@ const uint8_t *tud_descriptor_device_cb(void) {
        .iSerialNumber = USBD_STR_SERIAL,
        .bNumConfigurations = 1
    };
-    if (__USBInstallSerial && !__USBInstallKeyboard && !__USBInstallMouse && !__USBInstallJoystick && !__USBInstallMIDI) {
+    if (__USBInstallSerial && !__USBInstallKeyboard && !__USBInstallMouse && !__USBInstallJoystick) {
        // Can use as-is, this is the default USB case
        return (const uint8_t *)&usbd_desc_device;
    }
@@ -105,9 +103,6 @@ const uint8_t *tud_descriptor_device_cb(void) {
    if (__USBInstallJoystick) {
        usbd_desc_device.idProduct |= 0x0100;
    }
-    if (__USBInstallMIDI) {
-        usbd_desc_device.idProduct |= 0x2000;
-    }
    // Set the device class to 0 to indicate multiple device classes
    usbd_desc_device.bDeviceClass = 0;
    usbd_desc_device.bDeviceSubClass = 0;
@@ -228,7 +223,7 @@ void __SetupUSBDescriptor() {
    if (!usbd_desc_cfg) {
        bool hasHID = __USBInstallKeyboard || __USBInstallMouse || __USBInstallJoystick;

-        uint8_t interface_count = (__USBInstallSerial ? 2 : 0) + (hasHID ? 1 : 0) + (__USBInstallMIDI ? 2 : 0);
+        uint8_t interface_count = (__USBInstallSerial ? 2 : 0) + (hasHID ? 1 : 0);

        uint8_t cdc_desc[TUD_CDC_DESC_LEN] = {
            // Interface number, string index, protocol, report descriptor len, EP In & Out address, size & polling interval
@@ -243,13 +238,7 @@ void __SetupUSBDescriptor() {
            TUD_HID_DESCRIPTOR(hid_itf, 0, HID_ITF_PROTOCOL_NONE, hid_report_len, EPNUM_HID, CFG_TUD_HID_EP_BUFSIZE, 10)
        };

-        uint8_t midi_itf = hid_itf + (hasHID ? 1 : 0);
-        uint8_t midi_desc[TUD_MIDI_DESC_LEN] = {
-            // Interface number, string index, EP Out & EP In address, EP size
-            TUD_MIDI_DESCRIPTOR(midi_itf, 0, EPNUM_MIDI, 0x80 | EPNUM_MIDI, 64)
-        };
-
-        int usbd_desc_len = TUD_CONFIG_DESC_LEN + (__USBInstallSerial ? sizeof(cdc_desc) : 0) + (hasHID ? sizeof(hid_desc) : 0) + (__USBInstallMIDI ? sizeof(midi_desc) : 0);
+        int usbd_desc_len = TUD_CONFIG_DESC_LEN + (__USBInstallSerial ? sizeof(cdc_desc) : 0) + (hasHID ? sizeof(hid_desc) : 0);

        uint8_t tud_cfg_desc[TUD_CONFIG_DESC_LEN] = {
            // Config number, interface count, string index, total length, attribute, power in mA
@@ -271,9 +260,6 @@ void __SetupUSBDescriptor() {
                memcpy(ptr, hid_desc, sizeof(hid_desc));
                ptr += sizeof(hid_desc);
            }
-            if (__USBInstallMIDI) {
-                memcpy(ptr, midi_desc, sizeof(midi_desc));
-            }
        }
    }
 }
@@ -303,7 +289,7 @@ const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
        len = 1;
    } else {
        if (index >= sizeof(usbd_desc_str) / sizeof(usbd_desc_str[0])) {
-            return NULL;
+            return nullptr;
        }
        const char *str = usbd_desc_str[index];
        for (len = 0; len < DESC_STR_MAX - 1 && str[len]; ++len) {
@@ -322,7 +308,7 @@ static void usb_irq() {
    // if the mutex is already owned, then we are in user code
    // in this file which will do a tud_task itself, so we'll just do nothing
    // until the next tick; we won't starve
-    if (mutex_try_enter(&__usb_mutex, NULL)) {
+    if (mutex_try_enter(&__usb_mutex, nullptr)) {
        tud_task();
        mutex_exit(&__usb_mutex);
    }
@@ -352,7 +338,7 @@ void __USBStart() {
    irq_set_exclusive_handler(__usb_task_irq, usb_irq);
    irq_set_enabled(__usb_task_irq, true);

-    add_alarm_in_us(USB_TASK_INTERVAL, timer_task, NULL, true);
+    add_alarm_in_us(USB_TASK_INTERVAL, timer_task, nullptr, true);
 }


@@ -26,7 +26,6 @@ extern void __USBInstallSerial() __attribute__((weak));
 extern void __USBInstallKeyboard() __attribute__((weak));
 extern void __USBInstallJoystick() __attribute__((weak));
 extern void __USBInstallMouse() __attribute__((weak));
-extern void __USBInstallMIDI() __attribute__((weak));

 // Big, global USB mutex, shared with all USB devices to make sure we don't
 // have multiple cores updating the TUSB state in parallel
@@ -1,5 +1,5 @@
 #pragma once
 #define ARDUINO_PICO_MAJOR 2
-#define ARDUINO_PICO_MINOR 5
-#define ARDUINO_PICO_REVISION 0
-#define ARDUINO_PICO_VERSION_STR "2.5.0"
+#define ARDUINO_PICO_MINOR 6
+#define ARDUINO_PICO_REVISION 3
+#define ARDUINO_PICO_VERSION_STR "2.6.3"
@@ -230,7 +230,7 @@ void SerialPIO::begin(unsigned long baud, uint16_t config) {
        pio_sm_clear_fifos(_rxPIO, _rxSM); // Remove any existing data

        // Put phase divider into OSR w/o using add'l program memory
-        pio_sm_put_blocking(_rxPIO, _rxSM, clock_get_hz(clk_sys) / (_baud * 2) - 5 /* insns in PIO halfbit loop */);
+        pio_sm_put_blocking(_rxPIO, _rxSM, clock_get_hz(clk_sys) / (_baud * 2) - 7 /* insns in PIO halfbit loop */);
        pio_sm_exec(_rxPIO, _rxSM, pio_encode_pull(false, false));

        // Join the TX FIFO to the RX one now that we don't need it
@@ -259,9 +259,11 @@ void SerialPIO::end() {
    }
    if (_tx != NOPIN) {
        pio_sm_set_enabled(_txPIO, _txSM, false);
+        pio_sm_unclaim(_txPIO, _txSM);
    }
    if (_rx != NOPIN) {
        pio_sm_set_enabled(_rxPIO, _rxSM, false);
+        pio_sm_unclaim(_rxPIO, _rxSM);
        _pioSP[pio_get_index(_rxPIO)][_rxSM] = nullptr;
        // If no more active, disable the IRQ
        auto pioNum = pio_get_index(_rxPIO);
@@ -370,3 +372,8 @@ size_t SerialPIO::write(uint8_t c) {
 SerialPIO::operator bool() {
    return _running;
 }
+
+#ifdef ARDUINO_NANO_RP2040_CONNECT
+// NINA updates
+SerialPIO Serial3(SERIAL3_TX, SERIAL3_RX);
+#endif
@@ -80,3 +80,8 @@ protected:
    uint32_t _reader;
    uint8_t  *_queue;
 };
+
+#ifdef ARDUINO_NANO_RP2040_CONNECT
+// NINA updates
+extern SerialPIO Serial3;
+#endif
@@ -69,7 +69,7 @@ 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)])) {
+    if ((!_running) && ((pin == UART_PIN_NOT_DEFINED) || ((1 << pin) & valid[uart_get_index(_uart)]))) {
        _rts = pin;
        return true;
    }
@@ -86,7 +86,7 @@ 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)])) {
+    if ((!_running) && ((pin == UART_PIN_NOT_DEFINED) || ((1 << pin) & valid[uart_get_index(_uart)]))) {
        _cts = pin;
        return true;
    }
@@ -171,12 +171,16 @@ void SerialUART::begin(unsigned long baud, uint16_t config) {
        break;
    }
    uart_set_format(_uart, bits, stop, parity);
+    _fcnTx = gpio_get_function(_tx);
+    _fcnRx = gpio_get_function(_rx);
    gpio_set_function(_tx, GPIO_FUNC_UART);
    gpio_set_function(_rx, GPIO_FUNC_UART);
    if (_rts != UART_PIN_NOT_DEFINED) {
+        _fcnRts = gpio_get_function(_rts);
        gpio_set_function(_rts, GPIO_FUNC_UART);
    }
    if (_cts != UART_PIN_NOT_DEFINED) {
+        _fcnCts = gpio_get_function(_cts);
        gpio_set_function(_cts, GPIO_FUNC_UART);
    }
    uart_set_hw_flow(_uart, _rts != UART_PIN_NOT_DEFINED, _cts != UART_PIN_NOT_DEFINED);
@@ -211,6 +215,7 @@ 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);
@@ -219,6 +224,16 @@ void SerialUART::end() {
    // Reset the mutexes once all is off/cleaned up
    mutex_exit(&_fifoMutex);
    mutex_exit(&_mutex);
+
+    // Restore pin functions
+    gpio_set_function(_tx, _fcnTx);
+    gpio_set_function(_rx, _fcnRx);
+    if (_rts != UART_PIN_NOT_DEFINED) {
+        gpio_set_function(_rts, _fcnRts);
+    }
+    if (_cts != UART_PIN_NOT_DEFINED) {
+        gpio_set_function(_cts, _fcnCts);
+    }
 }

 void SerialUART::_pumpFIFO() {
@@ -71,6 +71,7 @@ private:
    uart_inst_t *_uart;
    pin_size_t _tx, _rx;
    pin_size_t _rts, _cts;
+    enum gpio_function _fcnTx, _fcnRx, _fcnRts, _fcnCts;
    int _baud;
    mutex_t _mutex;
    bool _polling = false;
@@ -70,6 +70,7 @@ int SerialUSB::peek() {
    }

    uint8_t c;
+    tud_task();
    return tud_cdc_peek(&c) ? (int) c : -1;
 }

@@ -79,7 +80,8 @@ int SerialUSB::read() {
        return -1;
    }

-    if (tud_cdc_connected() && tud_cdc_available()) {
+    tud_task();
+    if (tud_cdc_available()) {
        return tud_cdc_read_char();
    }
    return -1;
@@ -91,6 +93,7 @@ int SerialUSB::available() {
        return 0;
    }

+    tud_task();
    return tud_cdc_available();
 }

@@ -100,6 +103,7 @@ int SerialUSB::availableForWrite() {
        return 0;
    }

+    tud_task();
    return tud_cdc_write_available();
 }

@@ -110,6 +114,7 @@ void SerialUSB::flush() {
    }

    tud_cdc_write_flush();
+    tud_task();
 }

 size_t SerialUSB::write(uint8_t c) {
@@ -142,7 +147,7 @@ size_t SerialUSB::write(const uint8_t *buf, size_t length) {
                tud_task();
                tud_cdc_write_flush();
                if (!tud_cdc_connected() ||
-                        (!tud_cdc_write_available() && time_us_64() > last_avail_time + 1000000 /* 1 second */)) {
+                        (!tud_cdc_write_available() && time_us_64() > last_avail_time + 1'000'000 /* 1 second */)) {
                    break;
                }
            }
@@ -151,6 +156,7 @@ size_t SerialUSB::write(const uint8_t *buf, size_t length) {
        // reset our timeout
        last_avail_time = 0;
    }
+    tud_task();
    return written;
 }

@@ -28,6 +28,7 @@ typedef struct {
    pin_size_t pin;
    PIO pio;
    int sm;
+    int off;
    alarm_id_t alarm;
 } Tone;

@@ -38,10 +39,18 @@ auto_init_mutex(_toneMutex);
 static PIOProgram _tone2Pgm(&tone2_program);
 static std::map<pin_size_t, Tone *> _toneMap;

+static inline bool pio_sm_get_enabled(PIO pio, uint sm) {
+    check_pio_param(pio);
+    check_sm_param(sm);
+    return (pio->ctrl & ~(1u << sm)) & (1 << sm);
+}
+
 int64_t _stopTonePIO(alarm_id_t id, void *user_data) {
    (void) id;
    Tone *tone = (Tone *)user_data;
    tone->alarm = 0;
+    digitalWrite(tone->pin, LOW);
+    pinMode(tone->pin, OUTPUT);
    pio_sm_set_enabled(tone->pio, tone->sm, false);
    return 0;
 }
@@ -62,7 +71,7 @@ void tone(uint8_t pin, unsigned int frequency, unsigned long duration) {
        return;    // Weird deadlock case
    }

-    int us = 1000000 / frequency / 2;
+    int us = 1'000'000 / frequency / 2;
    if (us < 5) {
        us = 5;
    }
@@ -72,14 +81,12 @@ void tone(uint8_t pin, unsigned int frequency, unsigned long duration) {
        newTone = new Tone();
        newTone->pin = pin;
        pinMode(pin, OUTPUT);
-        int off;
-        if (!_tone2Pgm.prepare(&newTone->pio, &newTone->sm, &off)) {
+        if (!_tone2Pgm.prepare(&newTone->pio, &newTone->sm, &newTone->off)) {
            DEBUGCORE("ERROR: tone unable to start, out of PIO resources\n");
            // ERROR, no free slots
            delete newTone;
            return;
        }
-        tone2_program_init(newTone->pio, newTone->sm, off, pin);
        newTone->alarm = 0;
    } else {
        newTone = entry->second;
@@ -88,6 +95,9 @@ void tone(uint8_t pin, unsigned int frequency, unsigned long duration) {
            newTone->alarm = 0;
        }
    }
+    if (!pio_sm_get_enabled(newTone->pio, newTone->sm)) {
+        tone2_program_init(newTone->pio, newTone->sm, newTone->off, pin);
+    }
    pio_sm_clear_fifos(newTone->pio, newTone->sm); // Remove any old updates that haven't yet taken effect
    pio_sm_put_blocking(newTone->pio, newTone->sm, RP2040::usToPIOCycles(us));
    pio_sm_set_enabled(newTone->pio, newTone->sm, true);
@@ -0,0 +1,56 @@
+/*
+    _freertos.cpp - Internal core definitions for FreeRTOS
+
+    Copyright (c) 2022 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "_freertos.h"
+#include "pico/mutex.h"
+#include <stdlib.h>
+
+typedef struct {
+    mutex_t *src;
+    SemaphoreHandle_t dst;
+} FMMap;
+
+static FMMap *_map = nullptr;
+extern "C" SemaphoreHandle_t __get_freertos_mutex_for_ptr(mutex_t *m) {
+    if (!_map) {
+        _map = (FMMap *)calloc(sizeof(FMMap), 16);
+    }
+    // Pre-existing map
+    for (int i = 0; i < 16; i++) {
+        if (m == _map[i].src) {
+            return _map[i].dst;
+        }
+    }
+
+    for (int i = 0; i < 16; i++) {
+        if (_map[i].src == nullptr) {
+            // Make a new mutex
+            SemaphoreHandle_t fm = __freertos_mutex_create();
+            if (fm == nullptr) {
+                return nullptr;
+            }
+
+            _map[i].src = m;
+            _map[i].dst = fm;
+            return fm;
+        }
+    }
+    return nullptr; // Need to make space for more mutex maps!
+}
@@ -0,0 +1,64 @@
+/*
+    _freertos.h - Internal core definitions for FreeRTOS
+
+    Copyright (c) 2022 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+#include "pico/mutex.h"
+
+// Cannot include refs to FreeRTOS's actual semaphore calls because they
+// are implemented as macros, so we have a wrapper in our variant hook
+// to handle it.
+
+extern bool __isFreeRTOS;
+
+// FreeRTOS has been set up
+extern volatile bool __freeRTOSinitted;
+
+extern "C" {
+#ifndef INC_FREERTOS_H
+    struct QueueDefinition; /* Using old naming convention so as not to break kernel aware debuggers. */
+    typedef struct QueueDefinition   * QueueHandle_t;
+    typedef QueueHandle_t SemaphoreHandle_t;
+#endif
+
+    extern SemaphoreHandle_t __freertos_mutex_create() __attribute__((weak));
+    extern SemaphoreHandle_t _freertos_recursive_mutex_create() __attribute__((weak));
+
+    extern void __freertos_mutex_take(SemaphoreHandle_t mtx) __attribute__((weak));
+    extern int __freertos_mutex_try_take(SemaphoreHandle_t mtx) __attribute__((weak));
+    extern void __freertos_mutex_give(SemaphoreHandle_t mtx) __attribute__((weak));
+
+    extern void __freertos_recursive_mutex_take(SemaphoreHandle_t mtx) __attribute__((weak));
+    extern int __freertos_recursive_mutex_try_take(SemaphoreHandle_t mtx) __attribute__((weak));
+    extern void __freertos_recursive_mutex_give(SemaphoreHandle_t mtx) __attribute__((weak));
+
+#ifndef INC_FREERTOS_H
+    extern void vTaskSuspendAll() __attribute__((weak));
+    extern int32_t xTaskResumeAll() __attribute__((weak));
+
+    typedef struct tskTaskControlBlock * TaskHandle_t;
+    extern void vTaskPreemptionDisable(TaskHandle_t p) __attribute__((weak));
+    extern void vTaskPreemptionEnable(TaskHandle_t p) __attribute__((weak));
+#endif
+
+    extern SemaphoreHandle_t __get_freertos_mutex_for_ptr(mutex_t *m);
+}
+
+// Halt the FreeRTOS PendSV task switching magic
+extern "C" int __holdUpPendSV;
@@ -1,57 +1,2 @@
-/*
-  Arduino API main include
-  Copyright (c) 2016 Arduino LLC. All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-*/
-
-#ifndef ARDUINO_API_H
-#define ARDUINO_API_H
-
-// version 1.2.0
-#define ARDUINO_API_VERSION 10200
-
-#include "Binary.h"
-
-#ifdef __cplusplus
-#include "Interrupts.h"
-#include "IPAddress.h"
-#include "Print.h"
-#include "Printable.h"
-#include "PluggableUSB.h"
-#include "Server.h"
-#include "String.h"
-#include "Stream.h"
-#include "Udp.h"
-#include "USBAPI.h"
-#include "WCharacter.h"
-#endif
-
-/* Standard C library includes */
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <math.h>
-
-// Misc Arduino core functions
-#include "Common.h"
-
-#ifdef __cplusplus
-// Compatibility layer for older code
-#include "Compat.h"
-#endif
-
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/ArduinoAPI.h"
@@ -1,552 +1,2 @@
-/*
-  binary.h - Definitions for binary constants
-  Deprecated -- use 0b binary literals instead
-  Copyright (c) 2006 David A. Mellis.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-*/
-
-#ifndef Binary_h
-#define Binary_h
-
-/* If supported, 0b binary literals are preferable to these constants.
- * In that case, warn the user about these being deprecated (if possible). */
-#if __cplusplus >= 201402L
-  /* C++14 introduces binary literals; C++11 introduces [[deprecated()]] */
-  #define DEPRECATED(x) [[deprecated("use " #x " instead")]]
-#elif __GNUC__ >= 6
-  /* GCC 4.3 supports binary literals; GCC 6 supports __deprecated__ on enums*/
-  #define DEPRECATED(x) __attribute__ ((__deprecated__ ("use " #x " instead")))
-#else
-  /* binary literals not supported, or "deprecated" warning not displayable */
-  #define DEPRECATED(x)
-#endif
-
-enum {
-  B0        DEPRECATED(0b0       ) = 0,
-  B00       DEPRECATED(0b00      ) = 0,
-  B000      DEPRECATED(0b000     ) = 0,
-  B0000     DEPRECATED(0b0000    ) = 0,
-  B00000    DEPRECATED(0b00000   ) = 0,
-  B000000   DEPRECATED(0b000000  ) = 0,
-  B0000000  DEPRECATED(0b0000000 ) = 0,
-  B00000000 DEPRECATED(0b00000000) = 0,
-  B1        DEPRECATED(0b1       ) = 1,
-  B01       DEPRECATED(0b01      ) = 1,
-  B001      DEPRECATED(0b001     ) = 1,
-  B0001     DEPRECATED(0b0001    ) = 1,
-  B00001    DEPRECATED(0b00001   ) = 1,
-  B000001   DEPRECATED(0b000001  ) = 1,
-  B0000001  DEPRECATED(0b0000001 ) = 1,
-  B00000001 DEPRECATED(0b00000001) = 1,
-  B10       DEPRECATED(0b10      ) = 2,
-  B010      DEPRECATED(0b010     ) = 2,
-  B0010     DEPRECATED(0b0010    ) = 2,
-  B00010    DEPRECATED(0b00010   ) = 2,
-  B000010   DEPRECATED(0b000010  ) = 2,
-  B0000010  DEPRECATED(0b0000010 ) = 2,
-  B00000010 DEPRECATED(0b00000010) = 2,
-  B11       DEPRECATED(0b11      ) = 3,
-  B011      DEPRECATED(0b011     ) = 3,
-  B0011     DEPRECATED(0b0011    ) = 3,
-  B00011    DEPRECATED(0b00011   ) = 3,
-  B000011   DEPRECATED(0b000011  ) = 3,
-  B0000011  DEPRECATED(0b0000011 ) = 3,
-  B00000011 DEPRECATED(0b00000011) = 3,
-  B100      DEPRECATED(0b100     ) = 4,
-  B0100     DEPRECATED(0b0100    ) = 4,
-  B00100    DEPRECATED(0b00100   ) = 4,
-  B000100   DEPRECATED(0b000100  ) = 4,
-  B0000100  DEPRECATED(0b0000100 ) = 4,
-  B00000100 DEPRECATED(0b00000100) = 4,
-  B101      DEPRECATED(0b101     ) = 5,
-  B0101     DEPRECATED(0b0101    ) = 5,
-  B00101    DEPRECATED(0b00101   ) = 5,
-  B000101   DEPRECATED(0b000101  ) = 5,
-  B0000101  DEPRECATED(0b0000101 ) = 5,
-  B00000101 DEPRECATED(0b00000101) = 5,
-  B110      DEPRECATED(0b110     ) = 6,
-  B0110     DEPRECATED(0b0110    ) = 6,
-  B00110    DEPRECATED(0b00110   ) = 6,
-  B000110   DEPRECATED(0b000110  ) = 6,
-  B0000110  DEPRECATED(0b0000110 ) = 6,
-  B00000110 DEPRECATED(0b00000110) = 6,
-  B111      DEPRECATED(0b111     ) = 7,
-  B0111     DEPRECATED(0b0111    ) = 7,
-  B00111    DEPRECATED(0b00111   ) = 7,
-  B000111   DEPRECATED(0b000111  ) = 7,
-  B0000111  DEPRECATED(0b0000111 ) = 7,
-  B00000111 DEPRECATED(0b00000111) = 7,
-  B1000     DEPRECATED(0b1000    ) = 8,
-  B01000    DEPRECATED(0b01000   ) = 8,
-  B001000   DEPRECATED(0b001000  ) = 8,
-  B0001000  DEPRECATED(0b0001000 ) = 8,
-  B00001000 DEPRECATED(0b00001000) = 8,
-  B1001     DEPRECATED(0b1001    ) = 9,
-  B01001    DEPRECATED(0b01001   ) = 9,
-  B001001   DEPRECATED(0b001001  ) = 9,
-  B0001001  DEPRECATED(0b0001001 ) = 9,
-  B00001001 DEPRECATED(0b00001001) = 9,
-  B1010     DEPRECATED(0b1010    ) = 10,
-  B01010    DEPRECATED(0b01010   ) = 10,
-  B001010   DEPRECATED(0b001010  ) = 10,
-  B0001010  DEPRECATED(0b0001010 ) = 10,
-  B00001010 DEPRECATED(0b00001010) = 10,
-  B1011     DEPRECATED(0b1011    ) = 11,
-  B01011    DEPRECATED(0b01011   ) = 11,
-  B001011   DEPRECATED(0b001011  ) = 11,
-  B0001011  DEPRECATED(0b0001011 ) = 11,
-  B00001011 DEPRECATED(0b00001011) = 11,
-  B1100     DEPRECATED(0b1100    ) = 12,
-  B01100    DEPRECATED(0b01100   ) = 12,
-  B001100   DEPRECATED(0b001100  ) = 12,
-  B0001100  DEPRECATED(0b0001100 ) = 12,
-  B00001100 DEPRECATED(0b00001100) = 12,
-  B1101     DEPRECATED(0b1101    ) = 13,
-  B01101    DEPRECATED(0b01101   ) = 13,
-  B001101   DEPRECATED(0b001101  ) = 13,
-  B0001101  DEPRECATED(0b0001101 ) = 13,
-  B00001101 DEPRECATED(0b00001101) = 13,
-  B1110     DEPRECATED(0b1110    ) = 14,
-  B01110    DEPRECATED(0b01110   ) = 14,
-  B001110   DEPRECATED(0b001110  ) = 14,
-  B0001110  DEPRECATED(0b0001110 ) = 14,
-  B00001110 DEPRECATED(0b00001110) = 14,
-  B1111     DEPRECATED(0b1111    ) = 15,
-  B01111    DEPRECATED(0b01111   ) = 15,
-  B001111   DEPRECATED(0b001111  ) = 15,
-  B0001111  DEPRECATED(0b0001111 ) = 15,
-  B00001111 DEPRECATED(0b00001111) = 15,
-  B10000    DEPRECATED(0b10000   ) = 16,
-  B010000   DEPRECATED(0b010000  ) = 16,
-  B0010000  DEPRECATED(0b0010000 ) = 16,
-  B00010000 DEPRECATED(0b00010000) = 16,
-  B10001    DEPRECATED(0b10001   ) = 17,
-  B010001   DEPRECATED(0b010001  ) = 17,
-  B0010001  DEPRECATED(0b0010001 ) = 17,
-  B00010001 DEPRECATED(0b00010001) = 17,
-  B10010    DEPRECATED(0b10010   ) = 18,
-  B010010   DEPRECATED(0b010010  ) = 18,
-  B0010010  DEPRECATED(0b0010010 ) = 18,
-  B00010010 DEPRECATED(0b00010010) = 18,
-  B10011    DEPRECATED(0b10011   ) = 19,
-  B010011   DEPRECATED(0b010011  ) = 19,
-  B0010011  DEPRECATED(0b0010011 ) = 19,
-  B00010011 DEPRECATED(0b00010011) = 19,
-  B10100    DEPRECATED(0b10100   ) = 20,
-  B010100   DEPRECATED(0b010100  ) = 20,
-  B0010100  DEPRECATED(0b0010100 ) = 20,
-  B00010100 DEPRECATED(0b00010100) = 20,
-  B10101    DEPRECATED(0b10101   ) = 21,
-  B010101   DEPRECATED(0b010101  ) = 21,
-  B0010101  DEPRECATED(0b0010101 ) = 21,
-  B00010101 DEPRECATED(0b00010101) = 21,
-  B10110    DEPRECATED(0b10110   ) = 22,
-  B010110   DEPRECATED(0b010110  ) = 22,
-  B0010110  DEPRECATED(0b0010110 ) = 22,
-  B00010110 DEPRECATED(0b00010110) = 22,
-  B10111    DEPRECATED(0b10111   ) = 23,
-  B010111   DEPRECATED(0b010111  ) = 23,
-  B0010111  DEPRECATED(0b0010111 ) = 23,
-  B00010111 DEPRECATED(0b00010111) = 23,
-  B11000    DEPRECATED(0b11000   ) = 24,
-  B011000   DEPRECATED(0b011000  ) = 24,
-  B0011000  DEPRECATED(0b0011000 ) = 24,
-  B00011000 DEPRECATED(0b00011000) = 24,
-  B11001    DEPRECATED(0b11001   ) = 25,
-  B011001   DEPRECATED(0b011001  ) = 25,
-  B0011001  DEPRECATED(0b0011001 ) = 25,
-  B00011001 DEPRECATED(0b00011001) = 25,
-  B11010    DEPRECATED(0b11010   ) = 26,
-  B011010   DEPRECATED(0b011010  ) = 26,
-  B0011010  DEPRECATED(0b0011010 ) = 26,
-  B00011010 DEPRECATED(0b00011010) = 26,
-  B11011    DEPRECATED(0b11011   ) = 27,
-  B011011   DEPRECATED(0b011011  ) = 27,
-  B0011011  DEPRECATED(0b0011011 ) = 27,
-  B00011011 DEPRECATED(0b00011011) = 27,
-  B11100    DEPRECATED(0b11100   ) = 28,
-  B011100   DEPRECATED(0b011100  ) = 28,
-  B0011100  DEPRECATED(0b0011100 ) = 28,
-  B00011100 DEPRECATED(0b00011100) = 28,
-  B11101    DEPRECATED(0b11101   ) = 29,
-  B011101   DEPRECATED(0b011101  ) = 29,
-  B0011101  DEPRECATED(0b0011101 ) = 29,
-  B00011101 DEPRECATED(0b00011101) = 29,
-  B11110    DEPRECATED(0b11110   ) = 30,
-  B011110   DEPRECATED(0b011110  ) = 30,
-  B0011110  DEPRECATED(0b0011110 ) = 30,
-  B00011110 DEPRECATED(0b00011110) = 30,
-  B11111    DEPRECATED(0b11111   ) = 31,
-  B011111   DEPRECATED(0b011111  ) = 31,
-  B0011111  DEPRECATED(0b0011111 ) = 31,
-  B00011111 DEPRECATED(0b00011111) = 31,
-  B100000   DEPRECATED(0b100000  ) = 32,
-  B0100000  DEPRECATED(0b0100000 ) = 32,
-  B00100000 DEPRECATED(0b00100000) = 32,
-  B100001   DEPRECATED(0b100001  ) = 33,
-  B0100001  DEPRECATED(0b0100001 ) = 33,
-  B00100001 DEPRECATED(0b00100001) = 33,
-  B100010   DEPRECATED(0b100010  ) = 34,
-  B0100010  DEPRECATED(0b0100010 ) = 34,
-  B00100010 DEPRECATED(0b00100010) = 34,
-  B100011   DEPRECATED(0b100011  ) = 35,
-  B0100011  DEPRECATED(0b0100011 ) = 35,
-  B00100011 DEPRECATED(0b00100011) = 35,
-  B100100   DEPRECATED(0b100100  ) = 36,
-  B0100100  DEPRECATED(0b0100100 ) = 36,
-  B00100100 DEPRECATED(0b00100100) = 36,
-  B100101   DEPRECATED(0b100101  ) = 37,
-  B0100101  DEPRECATED(0b0100101 ) = 37,
-  B00100101 DEPRECATED(0b00100101) = 37,
-  B100110   DEPRECATED(0b100110  ) = 38,
-  B0100110  DEPRECATED(0b0100110 ) = 38,
-  B00100110 DEPRECATED(0b00100110) = 38,
-  B100111   DEPRECATED(0b100111  ) = 39,
-  B0100111  DEPRECATED(0b0100111 ) = 39,
-  B00100111 DEPRECATED(0b00100111) = 39,
-  B101000   DEPRECATED(0b101000  ) = 40,
-  B0101000  DEPRECATED(0b0101000 ) = 40,
-  B00101000 DEPRECATED(0b00101000) = 40,
-  B101001   DEPRECATED(0b101001  ) = 41,
-  B0101001  DEPRECATED(0b0101001 ) = 41,
-  B00101001 DEPRECATED(0b00101001) = 41,
-  B101010   DEPRECATED(0b101010  ) = 42,
-  B0101010  DEPRECATED(0b0101010 ) = 42,
-  B00101010 DEPRECATED(0b00101010) = 42,
-  B101011   DEPRECATED(0b101011  ) = 43,
-  B0101011  DEPRECATED(0b0101011 ) = 43,
-  B00101011 DEPRECATED(0b00101011) = 43,
-  B101100   DEPRECATED(0b101100  ) = 44,
-  B0101100  DEPRECATED(0b0101100 ) = 44,
-  B00101100 DEPRECATED(0b00101100) = 44,
-  B101101   DEPRECATED(0b101101  ) = 45,
-  B0101101  DEPRECATED(0b0101101 ) = 45,
-  B00101101 DEPRECATED(0b00101101) = 45,
-  B101110   DEPRECATED(0b101110  ) = 46,
-  B0101110  DEPRECATED(0b0101110 ) = 46,
-  B00101110 DEPRECATED(0b00101110) = 46,
-  B101111   DEPRECATED(0b101111  ) = 47,
-  B0101111  DEPRECATED(0b0101111 ) = 47,
-  B00101111 DEPRECATED(0b00101111) = 47,
-  B110000   DEPRECATED(0b110000  ) = 48,
-  B0110000  DEPRECATED(0b0110000 ) = 48,
-  B00110000 DEPRECATED(0b00110000) = 48,
-  B110001   DEPRECATED(0b110001  ) = 49,
-  B0110001  DEPRECATED(0b0110001 ) = 49,
-  B00110001 DEPRECATED(0b00110001) = 49,
-  B110010   DEPRECATED(0b110010  ) = 50,
-  B0110010  DEPRECATED(0b0110010 ) = 50,
-  B00110010 DEPRECATED(0b00110010) = 50,
-  B110011   DEPRECATED(0b110011  ) = 51,
-  B0110011  DEPRECATED(0b0110011 ) = 51,
-  B00110011 DEPRECATED(0b00110011) = 51,
-  B110100   DEPRECATED(0b110100  ) = 52,
-  B0110100  DEPRECATED(0b0110100 ) = 52,
-  B00110100 DEPRECATED(0b00110100) = 52,
-  B110101   DEPRECATED(0b110101  ) = 53,
-  B0110101  DEPRECATED(0b0110101 ) = 53,
-  B00110101 DEPRECATED(0b00110101) = 53,
-  B110110   DEPRECATED(0b110110  ) = 54,
-  B0110110  DEPRECATED(0b0110110 ) = 54,
-  B00110110 DEPRECATED(0b00110110) = 54,
-  B110111   DEPRECATED(0b110111  ) = 55,
-  B0110111  DEPRECATED(0b0110111 ) = 55,
-  B00110111 DEPRECATED(0b00110111) = 55,
-  B111000   DEPRECATED(0b111000  ) = 56,
-  B0111000  DEPRECATED(0b0111000 ) = 56,
-  B00111000 DEPRECATED(0b00111000) = 56,
-  B111001   DEPRECATED(0b111001  ) = 57,
-  B0111001  DEPRECATED(0b0111001 ) = 57,
-  B00111001 DEPRECATED(0b00111001) = 57,
-  B111010   DEPRECATED(0b111010  ) = 58,
-  B0111010  DEPRECATED(0b0111010 ) = 58,
-  B00111010 DEPRECATED(0b00111010) = 58,
-  B111011   DEPRECATED(0b111011  ) = 59,
-  B0111011  DEPRECATED(0b0111011 ) = 59,
-  B00111011 DEPRECATED(0b00111011) = 59,
-  B111100   DEPRECATED(0b111100  ) = 60,
-  B0111100  DEPRECATED(0b0111100 ) = 60,
-  B00111100 DEPRECATED(0b00111100) = 60,
-  B111101   DEPRECATED(0b111101  ) = 61,
-  B0111101  DEPRECATED(0b0111101 ) = 61,
-  B00111101 DEPRECATED(0b00111101) = 61,
-  B111110   DEPRECATED(0b111110  ) = 62,
-  B0111110  DEPRECATED(0b0111110 ) = 62,
-  B00111110 DEPRECATED(0b00111110) = 62,
-  B111111   DEPRECATED(0b111111  ) = 63,
-  B0111111  DEPRECATED(0b0111111 ) = 63,
-  B00111111 DEPRECATED(0b00111111) = 63,
-  B1000000  DEPRECATED(0b1000000 ) = 64,
-  B01000000 DEPRECATED(0b01000000) = 64,
-  B1000001  DEPRECATED(0b1000001 ) = 65,
-  B01000001 DEPRECATED(0b01000001) = 65,
-  B1000010  DEPRECATED(0b1000010 ) = 66,
-  B01000010 DEPRECATED(0b01000010) = 66,
-  B1000011  DEPRECATED(0b1000011 ) = 67,
-  B01000011 DEPRECATED(0b01000011) = 67,
-  B1000100  DEPRECATED(0b1000100 ) = 68,
-  B01000100 DEPRECATED(0b01000100) = 68,
-  B1000101  DEPRECATED(0b1000101 ) = 69,
-  B01000101 DEPRECATED(0b01000101) = 69,
-  B1000110  DEPRECATED(0b1000110 ) = 70,
-  B01000110 DEPRECATED(0b01000110) = 70,
-  B1000111  DEPRECATED(0b1000111 ) = 71,
-  B01000111 DEPRECATED(0b01000111) = 71,
-  B1001000  DEPRECATED(0b1001000 ) = 72,
-  B01001000 DEPRECATED(0b01001000) = 72,
-  B1001001  DEPRECATED(0b1001001 ) = 73,
-  B01001001 DEPRECATED(0b01001001) = 73,
-  B1001010  DEPRECATED(0b1001010 ) = 74,
-  B01001010 DEPRECATED(0b01001010) = 74,
-  B1001011  DEPRECATED(0b1001011 ) = 75,
-  B01001011 DEPRECATED(0b01001011) = 75,
-  B1001100  DEPRECATED(0b1001100 ) = 76,
-  B01001100 DEPRECATED(0b01001100) = 76,
-  B1001101  DEPRECATED(0b1001101 ) = 77,
-  B01001101 DEPRECATED(0b01001101) = 77,
-  B1001110  DEPRECATED(0b1001110 ) = 78,
-  B01001110 DEPRECATED(0b01001110) = 78,
-  B1001111  DEPRECATED(0b1001111 ) = 79,
-  B01001111 DEPRECATED(0b01001111) = 79,
-  B1010000  DEPRECATED(0b1010000 ) = 80,
-  B01010000 DEPRECATED(0b01010000) = 80,
-  B1010001  DEPRECATED(0b1010001 ) = 81,
-  B01010001 DEPRECATED(0b01010001) = 81,
-  B1010010  DEPRECATED(0b1010010 ) = 82,
-  B01010010 DEPRECATED(0b01010010) = 82,
-  B1010011  DEPRECATED(0b1010011 ) = 83,
-  B01010011 DEPRECATED(0b01010011) = 83,
-  B1010100  DEPRECATED(0b1010100 ) = 84,
-  B01010100 DEPRECATED(0b01010100) = 84,
-  B1010101  DEPRECATED(0b1010101 ) = 85,
-  B01010101 DEPRECATED(0b01010101) = 85,
-  B1010110  DEPRECATED(0b1010110 ) = 86,
-  B01010110 DEPRECATED(0b01010110) = 86,
-  B1010111  DEPRECATED(0b1010111 ) = 87,
-  B01010111 DEPRECATED(0b01010111) = 87,
-  B1011000  DEPRECATED(0b1011000 ) = 88,
-  B01011000 DEPRECATED(0b01011000) = 88,
-  B1011001  DEPRECATED(0b1011001 ) = 89,
-  B01011001 DEPRECATED(0b01011001) = 89,
-  B1011010  DEPRECATED(0b1011010 ) = 90,
-  B01011010 DEPRECATED(0b01011010) = 90,
-  B1011011  DEPRECATED(0b1011011 ) = 91,
-  B01011011 DEPRECATED(0b01011011) = 91,
-  B1011100  DEPRECATED(0b1011100 ) = 92,
-  B01011100 DEPRECATED(0b01011100) = 92,
-  B1011101  DEPRECATED(0b1011101 ) = 93,
-  B01011101 DEPRECATED(0b01011101) = 93,
-  B1011110  DEPRECATED(0b1011110 ) = 94,
-  B01011110 DEPRECATED(0b01011110) = 94,
-  B1011111  DEPRECATED(0b1011111 ) = 95,
-  B01011111 DEPRECATED(0b01011111) = 95,
-  B1100000  DEPRECATED(0b1100000 ) = 96,
-  B01100000 DEPRECATED(0b01100000) = 96,
-  B1100001  DEPRECATED(0b1100001 ) = 97,
-  B01100001 DEPRECATED(0b01100001) = 97,
-  B1100010  DEPRECATED(0b1100010 ) = 98,
-  B01100010 DEPRECATED(0b01100010) = 98,
-  B1100011  DEPRECATED(0b1100011 ) = 99,
-  B01100011 DEPRECATED(0b01100011) = 99,
-  B1100100  DEPRECATED(0b1100100 ) = 100,
-  B01100100 DEPRECATED(0b01100100) = 100,
-  B1100101  DEPRECATED(0b1100101 ) = 101,
-  B01100101 DEPRECATED(0b01100101) = 101,
-  B1100110  DEPRECATED(0b1100110 ) = 102,
-  B01100110 DEPRECATED(0b01100110) = 102,
-  B1100111  DEPRECATED(0b1100111 ) = 103,
-  B01100111 DEPRECATED(0b01100111) = 103,
-  B1101000  DEPRECATED(0b1101000 ) = 104,
-  B01101000 DEPRECATED(0b01101000) = 104,
-  B1101001  DEPRECATED(0b1101001 ) = 105,
-  B01101001 DEPRECATED(0b01101001) = 105,
-  B1101010  DEPRECATED(0b1101010 ) = 106,
-  B01101010 DEPRECATED(0b01101010) = 106,
-  B1101011  DEPRECATED(0b1101011 ) = 107,
-  B01101011 DEPRECATED(0b01101011) = 107,
-  B1101100  DEPRECATED(0b1101100 ) = 108,
-  B01101100 DEPRECATED(0b01101100) = 108,
-  B1101101  DEPRECATED(0b1101101 ) = 109,
-  B01101101 DEPRECATED(0b01101101) = 109,
-  B1101110  DEPRECATED(0b1101110 ) = 110,
-  B01101110 DEPRECATED(0b01101110) = 110,
-  B1101111  DEPRECATED(0b1101111 ) = 111,
-  B01101111 DEPRECATED(0b01101111) = 111,
-  B1110000  DEPRECATED(0b1110000 ) = 112,
-  B01110000 DEPRECATED(0b01110000) = 112,
-  B1110001  DEPRECATED(0b1110001 ) = 113,
-  B01110001 DEPRECATED(0b01110001) = 113,
-  B1110010  DEPRECATED(0b1110010 ) = 114,
-  B01110010 DEPRECATED(0b01110010) = 114,
-  B1110011  DEPRECATED(0b1110011 ) = 115,
-  B01110011 DEPRECATED(0b01110011) = 115,
-  B1110100  DEPRECATED(0b1110100 ) = 116,
-  B01110100 DEPRECATED(0b01110100) = 116,
-  B1110101  DEPRECATED(0b1110101 ) = 117,
-  B01110101 DEPRECATED(0b01110101) = 117,
-  B1110110  DEPRECATED(0b1110110 ) = 118,
-  B01110110 DEPRECATED(0b01110110) = 118,
-  B1110111  DEPRECATED(0b1110111 ) = 119,
-  B01110111 DEPRECATED(0b01110111) = 119,
-  B1111000  DEPRECATED(0b1111000 ) = 120,
-  B01111000 DEPRECATED(0b01111000) = 120,
-  B1111001  DEPRECATED(0b1111001 ) = 121,
-  B01111001 DEPRECATED(0b01111001) = 121,
-  B1111010  DEPRECATED(0b1111010 ) = 122,
-  B01111010 DEPRECATED(0b01111010) = 122,
-  B1111011  DEPRECATED(0b1111011 ) = 123,
-  B01111011 DEPRECATED(0b01111011) = 123,
-  B1111100  DEPRECATED(0b1111100 ) = 124,
-  B01111100 DEPRECATED(0b01111100) = 124,
-  B1111101  DEPRECATED(0b1111101 ) = 125,
-  B01111101 DEPRECATED(0b01111101) = 125,
-  B1111110  DEPRECATED(0b1111110 ) = 126,
-  B01111110 DEPRECATED(0b01111110) = 126,
-  B1111111  DEPRECATED(0b1111111 ) = 127,
-  B01111111 DEPRECATED(0b01111111) = 127,
-  B10000000 DEPRECATED(0b10000000) = 128,
-  B10000001 DEPRECATED(0b10000001) = 129,
-  B10000010 DEPRECATED(0b10000010) = 130,
-  B10000011 DEPRECATED(0b10000011) = 131,
-  B10000100 DEPRECATED(0b10000100) = 132,
-  B10000101 DEPRECATED(0b10000101) = 133,
-  B10000110 DEPRECATED(0b10000110) = 134,
-  B10000111 DEPRECATED(0b10000111) = 135,
-  B10001000 DEPRECATED(0b10001000) = 136,
-  B10001001 DEPRECATED(0b10001001) = 137,
-  B10001010 DEPRECATED(0b10001010) = 138,
-  B10001011 DEPRECATED(0b10001011) = 139,
-  B10001100 DEPRECATED(0b10001100) = 140,
-  B10001101 DEPRECATED(0b10001101) = 141,
-  B10001110 DEPRECATED(0b10001110) = 142,
-  B10001111 DEPRECATED(0b10001111) = 143,
-  B10010000 DEPRECATED(0b10010000) = 144,
-  B10010001 DEPRECATED(0b10010001) = 145,
-  B10010010 DEPRECATED(0b10010010) = 146,
-  B10010011 DEPRECATED(0b10010011) = 147,
-  B10010100 DEPRECATED(0b10010100) = 148,
-  B10010101 DEPRECATED(0b10010101) = 149,
-  B10010110 DEPRECATED(0b10010110) = 150,
-  B10010111 DEPRECATED(0b10010111) = 151,
-  B10011000 DEPRECATED(0b10011000) = 152,
-  B10011001 DEPRECATED(0b10011001) = 153,
-  B10011010 DEPRECATED(0b10011010) = 154,
-  B10011011 DEPRECATED(0b10011011) = 155,
-  B10011100 DEPRECATED(0b10011100) = 156,
-  B10011101 DEPRECATED(0b10011101) = 157,
-  B10011110 DEPRECATED(0b10011110) = 158,
-  B10011111 DEPRECATED(0b10011111) = 159,
-  B10100000 DEPRECATED(0b10100000) = 160,
-  B10100001 DEPRECATED(0b10100001) = 161,
-  B10100010 DEPRECATED(0b10100010) = 162,
-  B10100011 DEPRECATED(0b10100011) = 163,
-  B10100100 DEPRECATED(0b10100100) = 164,
-  B10100101 DEPRECATED(0b10100101) = 165,
-  B10100110 DEPRECATED(0b10100110) = 166,
-  B10100111 DEPRECATED(0b10100111) = 167,
-  B10101000 DEPRECATED(0b10101000) = 168,
-  B10101001 DEPRECATED(0b10101001) = 169,
-  B10101010 DEPRECATED(0b10101010) = 170,
-  B10101011 DEPRECATED(0b10101011) = 171,
-  B10101100 DEPRECATED(0b10101100) = 172,
-  B10101101 DEPRECATED(0b10101101) = 173,
-  B10101110 DEPRECATED(0b10101110) = 174,
-  B10101111 DEPRECATED(0b10101111) = 175,
-  B10110000 DEPRECATED(0b10110000) = 176,
-  B10110001 DEPRECATED(0b10110001) = 177,
-  B10110010 DEPRECATED(0b10110010) = 178,
-  B10110011 DEPRECATED(0b10110011) = 179,
-  B10110100 DEPRECATED(0b10110100) = 180,
-  B10110101 DEPRECATED(0b10110101) = 181,
-  B10110110 DEPRECATED(0b10110110) = 182,
-  B10110111 DEPRECATED(0b10110111) = 183,
-  B10111000 DEPRECATED(0b10111000) = 184,
-  B10111001 DEPRECATED(0b10111001) = 185,
-  B10111010 DEPRECATED(0b10111010) = 186,
-  B10111011 DEPRECATED(0b10111011) = 187,
-  B10111100 DEPRECATED(0b10111100) = 188,
-  B10111101 DEPRECATED(0b10111101) = 189,
-  B10111110 DEPRECATED(0b10111110) = 190,
-  B10111111 DEPRECATED(0b10111111) = 191,
-  B11000000 DEPRECATED(0b11000000) = 192,
-  B11000001 DEPRECATED(0b11000001) = 193,
-  B11000010 DEPRECATED(0b11000010) = 194,
-  B11000011 DEPRECATED(0b11000011) = 195,
-  B11000100 DEPRECATED(0b11000100) = 196,
-  B11000101 DEPRECATED(0b11000101) = 197,
-  B11000110 DEPRECATED(0b11000110) = 198,
-  B11000111 DEPRECATED(0b11000111) = 199,
-  B11001000 DEPRECATED(0b11001000) = 200,
-  B11001001 DEPRECATED(0b11001001) = 201,
-  B11001010 DEPRECATED(0b11001010) = 202,
-  B11001011 DEPRECATED(0b11001011) = 203,
-  B11001100 DEPRECATED(0b11001100) = 204,
-  B11001101 DEPRECATED(0b11001101) = 205,
-  B11001110 DEPRECATED(0b11001110) = 206,
-  B11001111 DEPRECATED(0b11001111) = 207,
-  B11010000 DEPRECATED(0b11010000) = 208,
-  B11010001 DEPRECATED(0b11010001) = 209,
-  B11010010 DEPRECATED(0b11010010) = 210,
-  B11010011 DEPRECATED(0b11010011) = 211,
-  B11010100 DEPRECATED(0b11010100) = 212,
-  B11010101 DEPRECATED(0b11010101) = 213,
-  B11010110 DEPRECATED(0b11010110) = 214,
-  B11010111 DEPRECATED(0b11010111) = 215,
-  B11011000 DEPRECATED(0b11011000) = 216,
-  B11011001 DEPRECATED(0b11011001) = 217,
-  B11011010 DEPRECATED(0b11011010) = 218,
-  B11011011 DEPRECATED(0b11011011) = 219,
-  B11011100 DEPRECATED(0b11011100) = 220,
-  B11011101 DEPRECATED(0b11011101) = 221,
-  B11011110 DEPRECATED(0b11011110) = 222,
-  B11011111 DEPRECATED(0b11011111) = 223,
-  B11100000 DEPRECATED(0b11100000) = 224,
-  B11100001 DEPRECATED(0b11100001) = 225,
-  B11100010 DEPRECATED(0b11100010) = 226,
-  B11100011 DEPRECATED(0b11100011) = 227,
-  B11100100 DEPRECATED(0b11100100) = 228,
-  B11100101 DEPRECATED(0b11100101) = 229,
-  B11100110 DEPRECATED(0b11100110) = 230,
-  B11100111 DEPRECATED(0b11100111) = 231,
-  B11101000 DEPRECATED(0b11101000) = 232,
-  B11101001 DEPRECATED(0b11101001) = 233,
-  B11101010 DEPRECATED(0b11101010) = 234,
-  B11101011 DEPRECATED(0b11101011) = 235,
-  B11101100 DEPRECATED(0b11101100) = 236,
-  B11101101 DEPRECATED(0b11101101) = 237,
-  B11101110 DEPRECATED(0b11101110) = 238,
-  B11101111 DEPRECATED(0b11101111) = 239,
-  B11110000 DEPRECATED(0b11110000) = 240,
-  B11110001 DEPRECATED(0b11110001) = 241,
-  B11110010 DEPRECATED(0b11110010) = 242,
-  B11110011 DEPRECATED(0b11110011) = 243,
-  B11110100 DEPRECATED(0b11110100) = 244,
-  B11110101 DEPRECATED(0b11110101) = 245,
-  B11110110 DEPRECATED(0b11110110) = 246,
-  B11110111 DEPRECATED(0b11110111) = 247,
-  B11111000 DEPRECATED(0b11111000) = 248,
-  B11111001 DEPRECATED(0b11111001) = 249,
-  B11111010 DEPRECATED(0b11111010) = 250,
-  B11111011 DEPRECATED(0b11111011) = 251,
-  B11111100 DEPRECATED(0b11111100) = 252,
-  B11111101 DEPRECATED(0b11111101) = 253,
-  B11111110 DEPRECATED(0b11111110) = 254,
-  B11111111 DEPRECATED(0b11111111) = 255
-};
-
-#undef DEPRECATED
-
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/Binary.h"
@@ -1,46 +1,2 @@
-/*
-  Client.h - Base class that provides Client
-  Copyright (c) 2011 Adrian McEwen.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 "Stream.h"
-#include "IPAddress.h"
-
-namespace arduino {
-
-class Client : public Stream {
-
-public:
-  virtual int connect(IPAddress ip, uint16_t port) =0;
-  virtual int connect(const char *host, uint16_t port) =0;
-  virtual size_t write(uint8_t) =0;
-  virtual size_t write(const uint8_t *buf, size_t size) =0;
-  virtual int available() = 0;
-  virtual int read() = 0;
-  virtual int read(uint8_t *buf, size_t size) = 0;
-  virtual int peek() = 0;
-  virtual void flush() = 0;
-  virtual void stop() = 0;
-  virtual uint8_t connected() = 0;
-  virtual operator bool() = 0;
-protected:
-  uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
-};
-
-}
+#include "../../../ArduinoCore-API/api/Client.h"
@@ -1,10 +1 @@
-#include "Common.h"
-
-/* C++ prototypes */
-long map(long x, long in_min, long in_max, long out_min, long out_max)
-{
-  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
-
-uint16_t makeWord(uint16_t w) { return w; }
-uint16_t makeWord(uint8_t h, uint8_t l) { return (h << 8) | l; }
+#include "../../../ArduinoCore-API/api/Common.cpp"
@@ -1,173 +1,2 @@
 #pragma once
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-void yield(void);
-
-typedef enum {
-  LOW     = 0,
-  HIGH    = 1,
-  CHANGE  = 2,
-  FALLING = 3,
-  RISING  = 4,
-} PinStatus;
-
-typedef enum {
-  INPUT           = 0x0,
-  OUTPUT          = 0x1,
-  INPUT_PULLUP    = 0x2,
-  INPUT_PULLDOWN  = 0x3,
-  OUTPUT_2MA      = 0x4,
-  OUTPUT_4MA      = 0x5,
-  OUTPUT_8MA      = 0x6,
-  OUTPUT_12MA     = 0x7,
-} PinMode;
-
-typedef enum {
-  LSBFIRST = 0,
-  MSBFIRST = 1,
-} BitOrder;
-
-#define PI          3.1415926535897932384626433832795
-#define HALF_PI     1.5707963267948966192313216916398
-#define TWO_PI      6.283185307179586476925286766559
-#define DEG_TO_RAD  0.017453292519943295769236907684886
-#define RAD_TO_DEG  57.295779513082320876798154814105
-#define EULER       2.718281828459045235360287471352
-
-#define SERIAL      0x0
-#define DISPLAY     0x1
-
-#ifndef constrain
-#define constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt)))
-#endif
-
-#ifndef radians
-#define radians(deg) ((deg)*DEG_TO_RAD)
-#endif
-
-#ifndef degrees
-#define degrees(rad) ((rad)*RAD_TO_DEG)
-#endif
-
-#ifndef sq
-#define sq(x) ((x)*(x))
-#endif
-
-typedef void (*voidFuncPtr)(void);
-typedef void (*voidFuncPtrParam)(void*);
-
-// interrupts() / noInterrupts() must be defined by the core
-
-#define lowByte(w) ((uint8_t) ((w) & 0xff))
-#define highByte(w) ((uint8_t) ((w) >> 8))
-
-#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
-#define bitSet(value, bit) ((value) |= (1UL << (bit)))
-#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
-#define bitToggle(value, bit) ((value) ^= (1UL << (bit)))
-#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
-
-#ifndef bit
-#define bit(b) (1UL << (b))
-#endif
-
-/* TODO: request for removal */
-typedef bool      boolean;
-typedef uint8_t   byte;
-typedef uint16_t  word;
-
-void init(void);
-void initVariant(void);
-
-#ifndef HOST
-int atexit(void (*func)()) __attribute__((weak));
-#endif
-int main() __attribute__((weak));
-
-#ifdef EXTENDED_PIN_MODE
-// Platforms who wnat to declare more than 256 pins need to define EXTENDED_PIN_MODE globally
-typedef uint32_t pin_size_t;
-#else
-typedef uint8_t pin_size_t;
-#endif
-
-void pinMode(pin_size_t pinNumber, PinMode pinMode);
-void digitalWrite(pin_size_t pinNumber, PinStatus status);
-PinStatus digitalRead(pin_size_t pinNumber);
-int analogRead(pin_size_t pinNumber);
-void analogReference(uint8_t mode);
-void analogWrite(pin_size_t pinNumber, int value);
-
-unsigned long millis(void);
-unsigned long micros(void);
-void delay(unsigned long);
-void delayMicroseconds(unsigned int us);
-unsigned long pulseIn(pin_size_t pin, uint8_t state, unsigned long timeout);
-unsigned long pulseInLong(pin_size_t pin, uint8_t state, unsigned long timeout);
-
-void shiftOut(pin_size_t dataPin, pin_size_t clockPin, BitOrder bitOrder, uint8_t val);
-uint8_t shiftIn(pin_size_t dataPin, pin_size_t clockPin, BitOrder bitOrder);
-
-void attachInterrupt(pin_size_t interruptNumber, voidFuncPtr callback, PinStatus mode);
-void attachInterruptParam(pin_size_t interruptNumber, voidFuncPtrParam callback, PinStatus mode, void* param);
-void detachInterrupt(pin_size_t interruptNumber);
-
-void setup(void);
-void loop(void);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#ifdef __cplusplus
-  template<class T, class L> 
-  auto min(const T& a, const L& b) -> decltype((b < a) ? b : a)
-  {
-    return (b < a) ? b : a;
-  }
-
-  template<class T, class L> 
-  auto max(const T& a, const L& b) -> decltype((b < a) ? b : a)
-  {
-    return (a < b) ? b : a;
-  }
-#else
-#ifndef min
-#define min(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a < _b ? _a : _b; })
-#endif
-#ifndef max
-#define max(a,b) \
-   ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-     _a > _b ? _a : _b; })
-#endif
-#endif
-
-#ifdef __cplusplus
-
-/* C++ prototypes */
-uint16_t makeWord(uint16_t w);
-uint16_t makeWord(byte h, byte l);
-
-#define word(...) makeWord(__VA_ARGS__)
-
-unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
-unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
-
-void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);
-void noTone(uint8_t _pin);
-
-// WMath prototypes
-long random(long);
-long random(long, long);
-void randomSeed(unsigned long);
-long map(long, long, long, long, long);
-
-#endif // __cplusplus
+#include "../../../ArduinoCore-API/api/Common.h"
@@ -1,16 +1,2 @@
-#ifndef __COMPAT_H__
-#define __COMPAT_H__
-
-namespace arduino {
-
-inline void pinMode(pin_size_t pinNumber, int mode) {
-	pinMode(pinNumber, (PinMode)mode);
-};
-
-inline void digitalWrite(pin_size_t pinNumber, int status) {
-	digitalWrite(pinNumber, (PinStatus)status);
-};
-
-}
-
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/Compat.h"
@@ -1,47 +1,2 @@
-/*
-  Copyright (c) 2016 Arduino LLC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 <inttypes.h>
-#include "Stream.h"
-
-namespace arduino {
-
-class HardwareI2C : public Stream
-{
-  public:
-    virtual void begin() = 0;
-    virtual void begin(uint8_t address) = 0;
-    virtual void end() = 0;
-
-    virtual void setClock(uint32_t freq) = 0;
-  
-    virtual void beginTransmission(uint8_t address) = 0;
-    virtual uint8_t endTransmission(bool stopBit) = 0;
-    virtual uint8_t endTransmission(void) = 0;
-
-    virtual size_t requestFrom(uint8_t address, size_t len, bool stopBit) = 0;
-    virtual size_t requestFrom(uint8_t address, size_t len) = 0;
-
-    virtual void onReceive(void(*)(int)) = 0;
-    virtual void onRequest(void(*)(void)) = 0;
-};
-
-}
-
+#include "../../../ArduinoCore-API/api/HardwareI2C.h"
@@ -1,130 +1,2 @@
-/*
-  Copyright (c) 2018 Arduino LLC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 "Common.h"
-#include <inttypes.h>
-#include "Stream.h"
-
-#define SPI_HAS_TRANSACTION
-
-namespace arduino {
-
-typedef enum {
-  SPI_MODE0 = 0,
-  SPI_MODE1 = 1,
-  SPI_MODE2 = 2,
-  SPI_MODE3 = 3,
-} SPIMode;
-
-
-class SPISettings {
-  public:
-  SPISettings(uint32_t clock, BitOrder bitOrder, SPIMode dataMode) {
-    if (__builtin_constant_p(clock)) {
-      init_AlwaysInline(clock, bitOrder, dataMode);
-    } else {
-      init_MightInline(clock, bitOrder, dataMode);
-    }
-  }
-
-  SPISettings(uint32_t clock, BitOrder bitOrder, int dataMode) {
-    if (__builtin_constant_p(clock)) {
-      init_AlwaysInline(clock, bitOrder, (SPIMode)dataMode);
-    } else {
-      init_MightInline(clock, bitOrder, (SPIMode)dataMode);
-    }
-  }
-
-  // Default speed set to 4MHz, SPI mode set to MODE 0 and Bit order set to MSB first.
-  SPISettings() { init_AlwaysInline(4000000, MSBFIRST, SPI_MODE0); }
-
-  bool operator==(const SPISettings& rhs) const
-  {
-    if ((this->clockFreq == rhs.clockFreq) &&
-        (this->bitOrder == rhs.bitOrder) &&
-        (this->dataMode == rhs.dataMode)) {
-      return true;
-    }
-    return false;
-  }
-
-  bool operator!=(const SPISettings& rhs) const
-  {
-    return !(*this == rhs);
-  }
-
-  uint32_t getClockFreq() const {
-    return clockFreq;
-  }
-  SPIMode getDataMode() const {
-    return dataMode;
-  }
-  BitOrder getBitOrder() const {
-    return (bitOrder);
-  }
-
-  private:
-  void init_MightInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode) {
-    init_AlwaysInline(clock, bitOrder, dataMode);
-  }
-
-  // Core developer MUST use an helper function in beginTransaction() to use this data
-  void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode) __attribute__((__always_inline__)) {
-    this->clockFreq = clock;
-    this->dataMode = dataMode;
-    this->bitOrder = bitOrder;
-  }
-
-  uint32_t clockFreq;
-  SPIMode dataMode;
-  BitOrder bitOrder;
-
-  friend class HardwareSPI;
-};
-
-const SPISettings DEFAULT_SPI_SETTINGS = SPISettings();
-
-class HardwareSPI
-{
-  public:
-    virtual ~HardwareSPI() { }
-
-    virtual uint8_t transfer(uint8_t data) = 0;
-    virtual uint16_t transfer16(uint16_t data) = 0;
-    virtual void transfer(void *buf, size_t count) = 0;
-
-    // Transaction Functions
-    virtual void usingInterrupt(int interruptNumber) = 0;
-    virtual void notUsingInterrupt(int interruptNumber) = 0;
-    virtual void beginTransaction(SPISettings settings) = 0;
-    virtual void endTransaction(void) = 0;
-
-    // SPI Configuration methods
-    virtual void attachInterrupt() = 0;
-    virtual void detachInterrupt() = 0;
-
-    virtual void begin() = 0;
-    virtual void end() = 0;
-};
-
-// Alias SPIClass to HardwareSPI since it's already the defacto standard for SPI classe name
-typedef HardwareSPI SPIClass;
-
-}
+#include "../../../ArduinoCore-API/api/HardwareSPI.h"
@@ -1,105 +1,2 @@
-/*
-  Copyright (c) 2016 Arduino LLC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 <inttypes.h>
-#include "Stream.h"
-
-namespace arduino {
-
-// XXX: Those constants should be defined as const int / enums?
-// XXX: shall we use namespaces too?
-#define SERIAL_PARITY_EVEN   (0x1ul)
-#define SERIAL_PARITY_ODD    (0x2ul)
-#define SERIAL_PARITY_NONE   (0x3ul)
-#define SERIAL_PARITY_MARK   (0x4ul)
-#define SERIAL_PARITY_SPACE  (0x5ul)
-#define SERIAL_PARITY_MASK   (0xFul)
-
-#define SERIAL_STOP_BIT_1    (0x10ul)
-#define SERIAL_STOP_BIT_1_5  (0x20ul)
-#define SERIAL_STOP_BIT_2    (0x30ul)
-#define SERIAL_STOP_BIT_MASK (0xF0ul)
-
-#define SERIAL_DATA_5        (0x100ul)
-#define SERIAL_DATA_6        (0x200ul)
-#define SERIAL_DATA_7        (0x300ul)
-#define SERIAL_DATA_8        (0x400ul)
-#define SERIAL_DATA_MASK     (0xF00ul)
-
-#define SERIAL_5N1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_NONE  | SERIAL_DATA_5)
-#define SERIAL_6N1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_NONE  | SERIAL_DATA_6)
-#define SERIAL_7N1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_NONE  | SERIAL_DATA_7)
-#define SERIAL_8N1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_NONE  | SERIAL_DATA_8)
-#define SERIAL_5N2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_NONE  | SERIAL_DATA_5)
-#define SERIAL_6N2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_NONE  | SERIAL_DATA_6)
-#define SERIAL_7N2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_NONE  | SERIAL_DATA_7)
-#define SERIAL_8N2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_NONE  | SERIAL_DATA_8)
-#define SERIAL_5E1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_EVEN  | SERIAL_DATA_5)
-#define SERIAL_6E1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_EVEN  | SERIAL_DATA_6)
-#define SERIAL_7E1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_EVEN  | SERIAL_DATA_7)
-#define SERIAL_8E1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_EVEN  | SERIAL_DATA_8)
-#define SERIAL_5E2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_EVEN  | SERIAL_DATA_5)
-#define SERIAL_6E2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_EVEN  | SERIAL_DATA_6)
-#define SERIAL_7E2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_EVEN  | SERIAL_DATA_7)
-#define SERIAL_8E2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_EVEN  | SERIAL_DATA_8)
-#define SERIAL_5O1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_ODD   | SERIAL_DATA_5)
-#define SERIAL_6O1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_ODD   | SERIAL_DATA_6)
-#define SERIAL_7O1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_ODD   | SERIAL_DATA_7)
-#define SERIAL_8O1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_ODD   | SERIAL_DATA_8)
-#define SERIAL_5O2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_ODD   | SERIAL_DATA_5)
-#define SERIAL_6O2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_ODD   | SERIAL_DATA_6)
-#define SERIAL_7O2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_ODD   | SERIAL_DATA_7)
-#define SERIAL_8O2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_ODD   | SERIAL_DATA_8)
-#define SERIAL_5M1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_MARK  | SERIAL_DATA_5)
-#define SERIAL_6M1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_MARK  | SERIAL_DATA_6)
-#define SERIAL_7M1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_MARK  | SERIAL_DATA_7)
-#define SERIAL_8M1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_MARK  | SERIAL_DATA_8)
-#define SERIAL_5M2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_MARK  | SERIAL_DATA_5)
-#define SERIAL_6M2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_MARK  | SERIAL_DATA_6)
-#define SERIAL_7M2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_MARK  | SERIAL_DATA_7)
-#define SERIAL_8M2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_MARK  | SERIAL_DATA_8)
-#define SERIAL_5S1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_SPACE | SERIAL_DATA_5)
-#define SERIAL_6S1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_SPACE | SERIAL_DATA_6)
-#define SERIAL_7S1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_SPACE | SERIAL_DATA_7)
-#define SERIAL_8S1           (SERIAL_STOP_BIT_1 | SERIAL_PARITY_SPACE | SERIAL_DATA_8)
-#define SERIAL_5S2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_SPACE | SERIAL_DATA_5)
-#define SERIAL_6S2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_SPACE | SERIAL_DATA_6)
-#define SERIAL_7S2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_SPACE | SERIAL_DATA_7)
-#define SERIAL_8S2           (SERIAL_STOP_BIT_2 | SERIAL_PARITY_SPACE | SERIAL_DATA_8)
-
-class HardwareSerial : public Stream
-{
-  public:
-    virtual void begin(unsigned long) = 0;
-    virtual void begin(unsigned long baudrate, uint16_t config) = 0;
-    virtual void end() = 0;
-    virtual int available(void) = 0;
-    virtual int peek(void) = 0;
-    virtual int read(void) = 0;
-    virtual void flush(void) = 0;
-    virtual size_t write(uint8_t) = 0;
-    using Print::write; // pull in write(str) and write(buf, size) from Print
-    virtual operator bool() = 0;
-};
-
-// XXX: Are we keeping the serialEvent API?
-extern void serialEventRun(void) __attribute__((weak));
-
-}
+#include "../../../ArduinoCore-API/api/HardwareSerial.h"
@@ -1,248 +1 @@
-/*
- IPAddress.cpp - Base class that provides IPAddress
- Copyright (c) 2011 Adrian McEwen.  All right reserved.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is 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 <IPAddress.h>
-#include <Print.h>
-
-IPAddress::IPAddress(const IPAddress& from)
-{
-    ip_addr_copy(_ip, from._ip);
-}
-
-IPAddress::IPAddress() {
-    _ip = *IP_ANY_TYPE; // lwIP's v4-or-v6 generic address
-}
-
-bool IPAddress::isSet () const {
-    return !ip_addr_isany(&_ip) && ((*this) != IPADDR_NONE);
-}
-
-IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet) {
-    setV4();
-    (*this)[0] = first_octet;
-    (*this)[1] = second_octet;
-    (*this)[2] = third_octet;
-    (*this)[3] = fourth_octet;
-}
-
-void IPAddress::ctor32(uint32_t address) {
-    setV4();
-    v4() = address;
-}
-
-IPAddress::IPAddress(const uint8_t *address) {
-    setV4();
-    (*this)[0] = address[0];
-    (*this)[1] = address[1];
-    (*this)[2] = address[2];
-    (*this)[3] = address[3];
-}
-
-bool IPAddress::fromString(const char *address) {
-    if (!fromString4(address)) {
-#if LWIP_IPV6
-        return fromString6(address);
-#else
-        return false;
-#endif
-    }
-    return true;
-}
-
-bool IPAddress::fromString4(const char *address) {
-    // TODO: (IPv4) add support for "a", "a.b", "a.b.c" formats
-
-    uint16_t acc = 0; // Accumulator
-    uint8_t dots = 0;
-
-    while (*address)
-    {
-        char c = *address++;
-        if (c >= '0' && c <= '9')
-        {
-            acc = acc * 10 + (c - '0');
-            if (acc > 255) {
-                // Value out of [0..255] range
-                return false;
-            }
-        }
-        else if (c == '.')
-        {
-            if (dots == 3) {
-                // Too much dots (there must be 3 dots)
-                return false;
-            }
-            (*this)[dots++] = acc;
-            acc = 0;
-        }
-        else
-        {
-            // Invalid char
-            return false;
-        }
-    }
-
-    if (dots != 3) {
-        // Too few dots (there must be 3 dots)
-        return false;
-    }
-    (*this)[3] = acc;
-
-    setV4();
-    return true;
-}
-
-IPAddress& IPAddress::operator=(const uint8_t *address) {
-    setV4();
-    v4() = *reinterpret_cast<const uint32_t*>(address);
-    return *this;
-}
-
-IPAddress& IPAddress::operator=(uint32_t address) {
-    setV4();
-    v4() = address;
-    return *this;
-}
-
-bool IPAddress::operator==(const uint8_t* addr) const {
-    return isV4() && v4() == *reinterpret_cast<const uint32_t*>(addr);
-}
-
-size_t IPAddress::printTo(Print& p) const {
-    String s = toString();
-    return p.print(s);
-}
-
-String IPAddress::toString() const
-{
-    String s;
-
-    if (!isSet())
-        return "(IP unset)";
-
-#if LWIP_IPV6
-    if (isV6()) {
-        int count0 = 0;
-        for (int i = 0; i < 8; i++) {
-            uint16_t bit = PP_NTOHS(raw6()[i]);
-            if (bit || count0 < 0) {
-                char buff[64];
-                snprintf(buff, 64, "%x", bit);
-                buff[63] = 0;
-                s += buff;
-                if (count0 > 0)
-                    // no more hiding 0
-                    count0 = -8;
-            } else
-                count0++;
-            if ((i != 7 && count0 < 2) || count0 == 7)
-                s += ':';
-        }
-        return s;
-    }
-#endif
-
-    for(int i = 0; i < 4; i++) {
-        char buff[16];
-        snprintf(buff, 16, "%d", (*this)[i]);
-        buff[15] = 0;
-        s += buff;
-        if (i != 3)
-            s += '.';
-    }
-    return s;
-
-}
-
-bool IPAddress::isValid(const String& arg) {
-	return IPAddress().fromString(arg);
-}
-
-bool IPAddress::isValid(const char* arg) {
-	return IPAddress().fromString(arg);
-}
-
-namespace arduino {
-const IPAddress INADDR_ANY; // generic "0.0.0.0" for IPv4 & IPv6
-const IPAddress INADDR_NONE(255,255,255,255);
-};
-
-void IPAddress::clear() {
-    (*this) = INADDR_ANY;
-}
-
-/**************************************/
-
-#if LWIP_IPV6
-
-bool IPAddress::fromString6(const char *address) {
-    // TODO: test test test
-
-    uint32_t acc = 0; // Accumulator
-    int dots = 0, doubledots = -1;
-
-    while (*address)
-    {
-        char c = tolower(*address++);
-        if (isalnum(c)) {
-            if (c >= 'a')
-                c -= 'a' - '0' - 10;
-            acc = acc * 16 + (c - '0');
-            if (acc > 0xffff)
-                // Value out of range
-                return false;
-        }
-        else if (c == ':') {
-            if (*address == ':') {
-                if (doubledots >= 0)
-                    // :: allowed once
-                    return false;
-                // remember location
-                doubledots = dots + !!acc;
-                address++;
-            }
-            if (dots == 7)
-                // too many separators
-                return false;
-            raw6()[dots++] = PP_HTONS(acc);
-            acc = 0;
-        }
-        else
-            // Invalid char
-            return false;
-    }
-
-    if (doubledots == -1 && dots != 7)
-        // Too few separators
-        return false;
-    raw6()[dots++] = PP_HTONS(acc);
-
-    if (doubledots != -1) {
-        for (int i = dots - doubledots - 1; i >= 0; i--)
-            raw6()[8 - dots + doubledots + i] = raw6()[doubledots + i];
-        for (int i = doubledots; i < 8 - dots + doubledots; i++)
-            raw6()[i] = 0;
-    }
-
-    setV6();
-    return true;
-}
-
-#endif
+#include "../../../ArduinoCore-API/api/IPAddress.cpp"
@@ -1,236 +1,2 @@
-/*
- IPAddress.h - Base class that provides IPAddress
- Copyright (c) 2011 Adrian McEwen.  All right reserved.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is 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 <stdint.h>
-#include <api/String.h>
-#include <Printable.h>
-
-#include <lwip/init.h>
-#include <lwip/ip_addr.h>
-#include <lwip/ip4_addr.h>
-
-
-// forward declarations of global name space friend classes
-class EthernetClass;
-class DhcpClass;
-class DNSClient;
-
-
-namespace arduino {
-
-// to display a netif id with printf:
-#define NETIFID_STR        "%c%c%u"
-#define NETIFID_VAL(netif) \
-        ((netif)? (netif)->name[0]: '-'),     \
-        ((netif)? (netif)->name[1]: '-'),     \
-        ((netif)? netif_get_index(netif): 42)
-
-// A class to make it easier to handle and pass around IP addresses
-// IPv6 update:
-// IPAddress is now a decorator class for lwIP's ip_addr_t
-// fully backward compatible with legacy IPv4-only Arduino's
-// with unchanged footprint when IPv6 is disabled
-
-class IPAddress: public Printable {
-    private:
-#if !LWIP_IPV6
-        // Ugly hack to allow Arduino Ethernet library to twiddle internal bits.
-        // This can only work in IPv4-only mode, of course.
-        union {
-            ip_addr_t _ip;
-            struct {
-                uint8_t bytes[4];
-            } _address;
-        };
-        static_assert(sizeof(_ip) == sizeof(_address), "IP_ADDR_T size != _ADDRESS size");
-#else
-        ip_addr_t _ip;
-#endif
-
-        // Access the raw byte array containing the address.  Because this returns a pointer
-        // to the internal structure rather than a copy of the address this function should only
-        // be used when you know that the usage of the returned uint8_t* will be transient and not
-        // stored.
-        uint8_t* raw_address() {
-            return reinterpret_cast<uint8_t*>(&v4());
-        }
-        const uint8_t* raw_address() const {
-            return reinterpret_cast<const uint8_t*>(&v4());
-        }
-
-        void ctor32 (uint32_t);
-
-    public:
-        // Constructors
-        IPAddress();
-        IPAddress(const IPAddress& from);
-        IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
-        IPAddress(uint32_t address) { ctor32(address); }
-//        IPAddress(unsigned long address) { ctor32(address); }
-        IPAddress(int address) { ctor32(address); }
-        IPAddress(const uint8_t *address);
-
-        bool fromString(const char *address);
-        bool fromString(const String &address) { return fromString(address.c_str()); }
-
-        // Overloaded cast operator to allow IPAddress objects to be used where a pointer
-        // to a four-byte uint8_t array is expected
-        operator uint32_t() const { return isV4()? v4(): (uint32_t)0; }
-        operator uint32_t()       { return isV4()? v4(): (uint32_t)0; }
-
-        bool isSet () const;
-        operator bool () const { return isSet(); } // <-
-        operator bool ()       { return isSet(); } // <- both are needed
-
-        // generic IPv4 wrapper to uint32-view like arduino loves to see it
-        const uint32_t& v4() const { return ip_2_ip4(&_ip)->addr; } // for raw_address(const)
-              uint32_t& v4()       { return ip_2_ip4(&_ip)->addr; }
-
-        bool operator==(const IPAddress& addr) const {
-            return ip_addr_cmp(&_ip, &addr._ip);
-        }
-        bool operator!=(const IPAddress& addr) const {
-            return !ip_addr_cmp(&_ip, &addr._ip);
-        }
-        bool operator==(uint32_t addr) const {
-            return isV4() && v4() == addr;
-        }
-//        bool operator==(unsigned long addr) const {
-//            return isV4() && v4() == (uint32_t)addr;
-//        }
-        bool operator!=(uint32_t addr) const {
-            return !(isV4() && v4() == addr);
-        }
-//        bool operator!=(unsigned long addr) const {
-//            return isV4() && v4() != (uint32_t)addr;
-//        }
-        bool operator==(const uint8_t* addr) const;
-
-        int operator>>(int n) const {
-            return isV4()? v4() >> n: 0;
-        }
-
-        // Overloaded index operator to allow getting and setting individual octets of the address
-        uint8_t operator[](int index) const {
-            return isV4()? *(raw_address() + index): 0;
-        }
-        uint8_t& operator[](int index) {
-            setV4();
-            return *(raw_address() + index);
-        }
-
-        // Overloaded copy operators to allow initialisation of IPAddress objects from other types
-        IPAddress& operator=(const uint8_t *address);
-        IPAddress& operator=(uint32_t address);
-        IPAddress& operator=(const IPAddress&) = default;
-
-        virtual size_t printTo(Print& p) const;
-        String toString() const;
-
-        void clear();
-
-        /*
-                check if input string(arg) is a valid IPV4 address or not.
-                return true on valid.
-                return false on invalid.
-        */
-        static bool isValid(const String& arg);
-        static bool isValid(const char* arg);
-
-        friend class WiFiClass;
-        friend class EthernetClass;
-        friend class UDP;
-        friend class Client;
-        friend class Server;
-        friend class DhcpClass;
-        friend class DNSClient;
-
-        friend ::EthernetClass;
-        friend ::DhcpClass;
-        friend ::DNSClient;
-
-        /*
-               lwIP address compatibility
-        */
-        //IPAddress(const ipv4_addr& fw_addr)   { setV4(); v4() = fw_addr.addr; }
-        //IPAddress(const ipv4_addr* fw_addr)   { setV4(); v4() = fw_addr->addr; }
-
-        //IPAddress& operator=(const ipv4_addr& fw_addr)   { setV4(); v4() = fw_addr.addr;  return *this; }
-        //IPAddress& operator=(const ipv4_addr* fw_addr)   { setV4(); v4() = fw_addr->addr; return *this; }
-
-        operator       ip_addr_t () const { return  _ip; }
-        operator const ip_addr_t*() const { return &_ip; }
-        operator       ip_addr_t*()       { return &_ip; }
-
-        bool isV4() const { return IP_IS_V4_VAL(_ip); }
-        void setV4() { IP_SET_TYPE_VAL(_ip, IPADDR_TYPE_V4); }
-
-        bool isLocal () const { return ip_addr_islinklocal(&_ip); }
-
-
-        IPAddress(const ip_addr_t& lwip_addr) { ip_addr_copy(_ip, lwip_addr); }
-        IPAddress(const ip_addr_t* lwip_addr) { ip_addr_copy(_ip, *lwip_addr); }
-
-        IPAddress& operator=(const ip_addr_t& lwip_addr) { ip_addr_copy(_ip, lwip_addr); return *this; }
-        IPAddress& operator=(const ip_addr_t* lwip_addr) { ip_addr_copy(_ip, *lwip_addr); return *this; }
-
-#if LWIP_IPV6
-        uint16_t* raw6()
-        {
-            setV6();
-            return reinterpret_cast<uint16_t*>(ip_2_ip6(&_ip));
-        }
-
-        const uint16_t* raw6() const
-        {
-            return isV6()? reinterpret_cast<const uint16_t*>(ip_2_ip6(&_ip)): nullptr;
-        }
-
-        // when not IPv6, ip_addr_t == ip4_addr_t so this one would be ambiguous
-        // required otherwise
-        operator const ip4_addr_t*() const { return isV4()? ip_2_ip4(&_ip): nullptr; }
-
-        bool isV6() const { return IP_IS_V6_VAL(_ip); }
-        void setV6() { IP_SET_TYPE_VAL(_ip, IPADDR_TYPE_V6); }
-
-    protected:
-        bool fromString6(const char *address);
-
-#else
-
-        // allow portable code when IPv6 is not enabled
-
-        uint16_t* raw6() { return nullptr; }
-        const uint16_t* raw6() const { return nullptr; }
-        bool isV6() const { return false; }
-        void setV6() { }
-
-#endif
-
-    protected:
-        bool fromString4(const char *address);
-
-};
-
-extern const IPAddress INADDR_ANY;
-extern const IPAddress INADDR_NONE;
-
-}
+#include "../../../ArduinoCore-API/api/IPAddress.h"
@@ -1,44 +1,2 @@
-#ifndef W_INTERRUPTS_CPP
-#define W_INTERRUPTS_CPP
-#ifdef __cplusplus
-
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include "Common.h"
-
-namespace arduino {
-
-template <typename T>
-using voidTemplateFuncPtrParam =  void (*)(T param);
-
-template<typename T> struct __container__ {
-  void* param;
-  voidTemplateFuncPtrParam<T> function;
-};
-
-// C++ only overloaded version of attachInterrupt function
-template<typename T> void attachInterrupt(pin_size_t interruptNum, voidTemplateFuncPtrParam<T> userFunc, PinStatus mode, T& param) {
-
-  struct __container__<T> *cont = new __container__<T>();
-  cont->param = &param;
-  cont->function = userFunc;
-
-  // TODO: check lambda scope
-  // TODO: add structure to delete(__container__) when detachInterrupt() is called
-  auto f = [](void* a) -> void
-  {
-    T param = *(T*)((struct __container__<T>*)a)->param;
-    (((struct __container__<T>*)a)->function)(param);
-  };
-
-  attachInterruptParam(interruptNum, f, mode, cont);
-}
-
-template<typename T> void attachInterrupt(pin_size_t interruptNum, voidTemplateFuncPtrParam<T*> userFunc, PinStatus mode, T* param) {
-  attachInterruptParam(interruptNum, (voidFuncPtrParam)userFunc, mode, (void*)param);
-}
-
-}
-#endif
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/Interrupts.h"
@@ -1,101 +1 @@
-/*
-  PluggableUSB.cpp
-  Copyright (c) 2015 Arduino LLC
-
-  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 "USBAPI.h"
-#include "PluggableUSB.h"
-
-using namespace arduino;
-
-int PluggableUSB_::getInterface(uint8_t* interfaceCount)
-{
-	int sent = 0;
-	PluggableUSBModule* node;
-	for (node = rootNode; node; node = node->next) {
-		int res = node->getInterface(interfaceCount);
-		if (res < 0)
-			return -1;
-		sent += res;
-	}
-	return sent;
-}
-
-int PluggableUSB_::getDescriptor(USBSetup& setup)
-{
-	PluggableUSBModule* node;
-	for (node = rootNode; node; node = node->next) {
-		int ret = node->getDescriptor(setup);
-		// ret!=0 -> request has been processed
-		if (ret)
-			return ret;
-	}
-	return 0;
-}
-
-void PluggableUSB_::getShortName(char *iSerialNum)
-{
-	PluggableUSBModule* node;
-	for (node = rootNode; node; node = node->next) {
-		iSerialNum += node->getShortName(iSerialNum);
-	}
-	*iSerialNum = 0;
-}
-
-bool PluggableUSB_::setup(USBSetup& setup)
-{
-	PluggableUSBModule* node;
-	for (node = rootNode; node; node = node->next) {
-		if (node->setup(setup)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-bool PluggableUSB_::plug(PluggableUSBModule *node)
-{
-	if ((lastEp + node->numEndpoints) > totalEP) {
-		return false;
-	}
-
-	if (!rootNode) {
-		rootNode = node;
-	} else {
-		PluggableUSBModule *current = rootNode;
-		while (current->next) {
-			current = current->next;
-		}
-		current->next = node;
-	}
-
-	node->pluggedInterface = lastIf;
-	node->pluggedEndpoint = lastEp;
-	lastIf += node->numInterfaces;
-	for (uint8_t i = 0; i < node->numEndpoints; i++) {
-		*(unsigned int*)(epBuffer(lastEp)) = node->endpointType[i];
-		lastEp++;
-	}
-	return true;
-	// restart USB layer???
-}
-
-PluggableUSB_& PluggableUSB()
-{
-	static PluggableUSB_ obj;
-	return obj;
-}
+#include "../../../ArduinoCore-API/api/PluggableUSB.cpp"
@@ -1,78 +1,2 @@
-/*
-  PluggableUSB.h
-  Copyright (c) 2015 Arduino LLC
-
-  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
-*/
-
-#ifndef PUSB_h
-#define PUSB_h
-
-#include "USBAPI.h"
-#include <stdint.h>
-#include <stddef.h>
-
-namespace arduino {
-
-class PluggableUSBModule {
-public:
-  PluggableUSBModule(uint8_t numEps, uint8_t numIfs, unsigned int *epType) :
-    numEndpoints(numEps), numInterfaces(numIfs), endpointType(epType)
-  { }
-
-protected:
-  virtual bool setup(USBSetup& setup) = 0;
-  virtual int getInterface(uint8_t* interfaceCount) = 0;
-  virtual int getDescriptor(USBSetup& setup) = 0;
-  virtual uint8_t getShortName(char *name) { name[0] = 'A'+pluggedInterface; return 1; }
-
-  uint8_t pluggedInterface;
-  uint8_t pluggedEndpoint;
-
-  const uint8_t numEndpoints;
-  const uint8_t numInterfaces;
-  const unsigned int *endpointType;
-
-  PluggableUSBModule *next = NULL;
-
-  friend class PluggableUSB_;
-};
-
-class PluggableUSB_ {
-public:
-  PluggableUSB_();
-  bool plug(PluggableUSBModule *node);
-  int getInterface(uint8_t* interfaceCount);
-  int getDescriptor(USBSetup& setup);
-  bool setup(USBSetup& setup);
-  void getShortName(char *iSerialNum);
-
-private:
-  uint8_t lastIf;
-  uint8_t lastEp;
-  PluggableUSBModule* rootNode;
-  uint8_t totalEP;
-};
-}
-
-// core need to define
-void* epBuffer(unsigned int n); // -> returns a pointer to the Nth element of the EP buffer structure
-
-// Replacement for global singleton.
-// This function prevents static-initialization-order-fiasco
-// https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use
-arduino::PluggableUSB_& PluggableUSB();
-
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/PluggableUSB.h"
@@ -1,429 +1 @@
-/*
-  Copyright (c) 2014 Arduino.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 <stdarg.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-
-#include "Print.h"
-
-using namespace arduino;
-
-// Public Methods //////////////////////////////////////////////////////////////
-
-/* default implementation: may be overridden */
-size_t Print::write(const uint8_t *buffer, size_t size)
-{
-  size_t n = 0;
-  while (size--) {
-    if (write(*buffer++)) n++;
-    else break;
-  }
-  return n;
-}
-
-size_t Print::print(const __FlashStringHelper *ifsh)
-{
-#if defined(__AVR__)
-  PGM_P p = reinterpret_cast<PGM_P>(ifsh);
-  size_t n = 0;
-  while (1) {
-    unsigned char c = pgm_read_byte(p++);
-    if (c == 0) break;
-    if (write(c)) n++;
-    else break;
-  }
-  return n;
-#else
-  return print(reinterpret_cast<const char *>(ifsh));
-#endif
-}
-
-size_t Print::print(const String &s)
-{
-  return write(s.c_str(), s.length());
-}
-
-size_t Print::print(const char str[])
-{
-  return write(str);
-}
-
-size_t Print::print(char c)
-{
-  return write(c);
-}
-
-size_t Print::print(unsigned char b, int base)
-{
-  return print((unsigned long) b, base);
-}
-
-size_t Print::print(int n, int base)
-{
-  return print((long) n, base);
-}
-
-size_t Print::print(unsigned int n, int base)
-{
-  return print((unsigned long) n, base);
-}
-
-size_t Print::print(long n, int base)
-{
-  if (base == 0) {
-    return write(n);
-  } else if (base == 10) {
-    if (n < 0) {
-      int t = print('-');
-      n = -n;
-      return printNumber(n, 10) + t;
-    }
-    return printNumber(n, 10);
-  } else {
-    return printNumber(n, base);
-  }
-}
-
-size_t Print::print(unsigned long n, int base)
-{
-  if (base == 0) return write(n);
-  else return printNumber(n, base);
-}
-
-size_t Print::print(long long n, int base)
-{
-  if (base == 0) {
-    return write(n);
-  } else if (base == 10) {
-    if (n < 0) {
-      int t = print('-');
-      n = -n;
-      return printULLNumber(n, 10) + t;
-    }
-    return printULLNumber(n, 10);
-  } else {
-    return printULLNumber(n, base);
-  }
-}
-
-size_t Print::print(unsigned long long n, int base)
-{
-  if (base == 0) return write(n);
-  else return printULLNumber(n, base);
-}
-
-size_t Print::print(double n, int digits)
-{
-  return printFloat(n, digits);
-}
-
-size_t Print::println(const __FlashStringHelper *ifsh)
-{
-  size_t n = print(ifsh);
-  n += println();
-  return n;
-}
-
-size_t Print::print(const Printable& x)
-{
-  return x.printTo(*this);
-}
-
-size_t Print::println(void)
-{
-  return write("\r\n");
-}
-
-size_t Print::println(const String &s)
-{
-  size_t n = print(s);
-  n += println();
-  return n;
-}
-
-size_t Print::println(const char c[])
-{
-  size_t n = print(c);
-  n += println();
-  return n;
-}
-
-size_t Print::println(char c)
-{
-  size_t n = print(c);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned char b, int base)
-{
-  size_t n = print(b, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(int num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned int num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(long num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned long num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(long long num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(unsigned long long num, int base)
-{
-  size_t n = print(num, base);
-  n += println();
-  return n;
-}
-
-size_t Print::println(double num, int digits)
-{
-  size_t n = print(num, digits);
-  n += println();
-  return n;
-}
-
-size_t Print::println(const Printable& x)
-{
-  size_t n = print(x);
-  n += println();
-  return n;
-}
-
-size_t Print::printf(const char *format, ...) {
-    va_list arg;
-    va_start(arg, format);
-    char temp[64];
-    char* buffer = temp;
-    size_t len = vsnprintf(temp, sizeof(temp), format, arg);
-    va_end(arg);
-    if (len > sizeof(temp) - 1) {
-        buffer = new char[len + 1];
-        if (!buffer) {
-            return 0;
-        }
-        va_start(arg, format);
-        vsnprintf(buffer, len + 1, format, arg);
-        va_end(arg);
-    }
-    len = write((const uint8_t*) buffer, len);
-    if (buffer != temp) {
-        delete[] buffer;
-    }
-    return len;
-}
-
-// TODO - must be better way than cut-n-paste!
-size_t Print::printf_P(const char *format, ...) {
-    va_list arg;
-    va_start(arg, format);
-    char temp[64];
-    char* buffer = temp;
-    size_t len = vsnprintf(temp, sizeof(temp), format, arg);
-    va_end(arg);
-    if (len > sizeof(temp) - 1) {
-        buffer = new char[len + 1];
-        if (!buffer) {
-            return 0;
-        }
-        va_start(arg, format);
-        vsnprintf(buffer, len + 1, format, arg);
-        va_end(arg);
-    }
-    len = write((const uint8_t*) buffer, len);
-    if (buffer != temp) {
-        delete[] buffer;
-    }
-    return len;
-}
-
-// Private Methods /////////////////////////////////////////////////////////////
-
-size_t Print::printNumber(unsigned long n, uint8_t base)
-{
-  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
-  char *str = &buf[sizeof(buf) - 1];
-
-  *str = '\0';
-
-  // prevent crash if called with base == 1
-  if (base < 2) base = 10;
-
-  do {
-    char c = n % base;
-    n /= base;
-
-    *--str = c < 10 ? c + '0' : c + 'A' - 10;
-  } while(n);
-
-  return write(str);
-}
-
-// REFERENCE IMPLEMENTATION FOR ULL
-// size_t Print::printULLNumber(unsigned long long n, uint8_t base)
-// {
-  // // if limited to base 10 and 16 the bufsize can be smaller
-  // char buf[65];
-  // char *str = &buf[64];
-
-  // *str = '\0';
-
-  // // prevent crash if called with base == 1
-  // if (base < 2) base = 10;
-
-    // do {
-      // unsigned long long t = n / base;
-      // char c = n - t * base;  // faster than c = n%base;
-      // n = t;
-      // *--str = c < 10 ? c + '0' : c + 'A' - 10;
-  // } while(n);
-
-  // return write(str);
-// }
-
-// FAST IMPLEMENTATION FOR ULL
-size_t Print::printULLNumber(unsigned long long n64, uint8_t base)
-{
-  // if limited to base 10 and 16 the bufsize can be 20
-  char buf[64];
-  uint8_t i = 0;
-  uint8_t innerLoops = 0;
-
-  // prevent crash if called with base == 1
-  if (base < 2) base = 10;
-
-  // process chunks that fit in "16 bit math".
-  uint16_t top = 0xFFFF / base;
-  uint16_t th16 = 1;
-  while (th16 < top)
-  {
-    th16 *= base;
-    innerLoops++;
-  }
-
-  while (n64 > th16)
-  {
-    // 64 bit math part
-    uint64_t q = n64 / th16;
-    uint16_t r = n64 - q*th16;
-    n64 = q;
-
-    // 16 bit math loop to do remainder. (note buffer is filled reverse)
-    for (uint8_t j=0; j < innerLoops; j++)
-    {
-      uint16_t qq = r/base;
-      buf[i++] = r - qq*base;
-      r = qq;
-    }
-  }
-
-  uint16_t n16 = n64;
-  while (n16 > 0)
-  {
-    uint16_t qq = n16/base;
-    buf[i++] = n16 - qq*base;
-    n16 = qq;
-  }
-
-  size_t bytes = i;
-  for (; i > 0; i--)
-    write((char) (buf[i - 1] < 10 ?
-    '0' + buf[i - 1] :
-    'A' + buf[i - 1] - 10));
-
-  return bytes;
-}
-
-size_t Print::printFloat(double number, int digits)
-{
-  if (digits < 0)
-    digits = 2;
-
-  size_t n = 0;
-
-  if (isnan(number)) return print("nan");
-  if (isinf(number)) return print("inf");
-  if (number > 4294967040.0) return print ("ovf");  // constant determined empirically
-  if (number <-4294967040.0) return print ("ovf");  // constant determined empirically
-
-  // Handle negative numbers
-  if (number < 0.0)
-  {
-     n += print('-');
-     number = -number;
-  }
-
-  // Round correctly so that print(1.999, 2) prints as "2.00"
-  double rounding = 0.5;
-  for (uint8_t i=0; i<digits; ++i)
-    rounding /= 10.0;
-
-  number += rounding;
-
-  // Extract the integer part of the number and print it
-  unsigned long int_part = (unsigned long)number;
-  double remainder = number - (double)int_part;
-  n += print(int_part);
-
-  // Print the decimal point, but only if there are digits beyond
-  if (digits > 0) {
-    n += print(".");
-  }
-
-  // Extract digits from the remainder one at a time
-  while (digits-- > 0)
-  {
-    remainder *= 10.0;
-    unsigned int toPrint = (unsigned int)remainder;
-    n += print(toPrint);
-    remainder -= toPrint;
-  }
-
-  return n;
-}
+#include "../../../ArduinoCore-API/api/Print.cpp"
@@ -1,100 +1,2 @@
-/*
-  Copyright (c) 2016 Arduino LLC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 <inttypes.h>
-#include <stdio.h> // for size_t
-
-#include "String.h"
-#include "Printable.h"
-
-#define DEC 10
-#define HEX 16
-#define OCT 8
-#define BIN 2
-
-namespace arduino {
-
-class Print
-{
-  private:
-    int write_error;
-    size_t printNumber(unsigned long, uint8_t);
-    size_t printULLNumber(unsigned long long, uint8_t);
-    size_t printFloat(double, int);
-  protected:
-    void setWriteError(int err = 1) { write_error = err; }
-  public:
-    Print() : write_error(0) {}
-
-    int getWriteError() { return write_error; }
-    void clearWriteError() { setWriteError(0); }
-
-    virtual size_t write(uint8_t) = 0;
-    size_t write(const char *str) {
-      if (str == NULL) return 0;
-      return write((const uint8_t *)str, strlen(str));
-    }
-    virtual size_t write(const uint8_t *buffer, size_t size);
-    size_t write(const char *buffer, size_t size) {
-      return write((const uint8_t *)buffer, size);
-    }
-
-    // default to zero, meaning "a single write may block"
-    // should be overriden by subclasses with buffering
-    virtual int availableForWrite() { return 0; }
-
-    size_t print(const __FlashStringHelper *);
-    size_t print(const String &);
-    size_t print(const char[]);
-    size_t print(char);
-    size_t print(unsigned char, int = DEC);
-    size_t print(int, int = DEC);
-    size_t print(unsigned int, int = DEC);
-    size_t print(long, int = DEC);
-    size_t print(unsigned long, int = DEC);
-    size_t print(long long, int = DEC);
-    size_t print(unsigned long long, int = DEC);
-    size_t print(double, int = 2);
-    size_t print(const Printable&);
-
-    size_t println(const __FlashStringHelper *);
-    size_t println(const String &s);
-    size_t println(const char[]);
-    size_t println(char);
-    size_t println(unsigned char, int = DEC);
-    size_t println(int, int = DEC);
-    size_t println(unsigned int, int = DEC);
-    size_t println(long, int = DEC);
-    size_t println(unsigned long, int = DEC);
-    size_t println(long long, int = DEC);
-    size_t println(unsigned long long, int = DEC);
-    size_t println(double, int = 2);
-    size_t println(const Printable&);
-    size_t println(void);
-
-    // EFP3 - Add printf() to make life so much easier...
-    size_t printf(const char *format, ...);
-    size_t printf_P(const char *format, ...);
-
-    virtual void flush() { /* Empty implementation for backward compatibility */ }
-};
-
-}
-using namespace arduino;
+#include "../../../ArduinoCore-API/api/Print.h"
@@ -1,39 +1,2 @@
-/*
-  Copyright (c) 2016 Arduino LLC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 <stdlib.h>
-
-namespace arduino {
-
-class Print;
-
-/** The Printable class provides a way for new classes to allow themselves to be printed.
-    By deriving from Printable and implementing the printTo method, it will then be possible
-    for users to print out instances of this class by passing them into the usual
-    Print::print and Print::println methods.
-*/
-
-class Printable
-{
-  public:
-    virtual size_t printTo(Print& p) const = 0;
-};
-
-}
+#include "../../../ArduinoCore-API/api/Printable.h"
@@ -1,141 +1 @@
-/*
-  Copyright (c) 2014 Arduino.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-*/
-
-#ifdef __cplusplus
-
-#ifndef _RING_BUFFER_
-#define _RING_BUFFER_
-
-#include <stdint.h>
-#include <string.h>
-
-namespace arduino {
-
-// Define constants and variables for buffering incoming serial data.  We're
-// using a ring buffer (I think), in which head is the index of the location
-// to which to write the next incoming character and tail is the index of the
-// location from which to read.
-#define SERIAL_BUFFER_SIZE 64
-
-template <int N>
-class RingBufferN
-{
-  public:
-    uint8_t _aucBuffer[N] ;
-    volatile int _iHead ;
-    volatile int _iTail ;
-    volatile int _numElems;
-
-  public:
-    RingBufferN( void ) ;
-    void store_char( uint8_t c ) ;
-    void clear();
-    int read_char();
-    int available();
-    int availableForStore();
-    int peek();
-    bool isFull();
-
-  private:
-    int nextIndex(int index);
-    inline bool isEmpty() const { return (_numElems == 0); }
-};
-
-typedef RingBufferN<SERIAL_BUFFER_SIZE> RingBuffer;
-
-
-template <int N>
-RingBufferN<N>::RingBufferN( void )
-{
-    memset( _aucBuffer, 0, N ) ;
-    clear();
-}
-
-template <int N>
-void RingBufferN<N>::store_char( uint8_t c )
-{
-  // if we should be storing the received character into the location
-  // just before the tail (meaning that the head would advance to the
-  // current location of the tail), we're about to overflow the buffer
-  // and so we don't write the character or advance the head.
-  if (!isFull())
-  {
-    _aucBuffer[_iHead] = c ;
-    _iHead = nextIndex(_iHead);
-    _numElems++;
-  }
-}
-
-template <int N>
-void RingBufferN<N>::clear()
-{
-  _iHead = 0;
-  _iTail = 0;
-  _numElems = 0;
-}
-
-template <int N>
-int RingBufferN<N>::read_char()
-{
-  if (isEmpty())
-    return -1;
-
-  uint8_t value = _aucBuffer[_iTail];
-  _iTail = nextIndex(_iTail);
-  _numElems--;
-
-  return value;
-}
-
-template <int N>
-int RingBufferN<N>::available()
-{
-  return _numElems;
-}
-
-template <int N>
-int RingBufferN<N>::availableForStore()
-{
-  return (N - _numElems);
-}
-
-template <int N>
-int RingBufferN<N>::peek()
-{
-  if (isEmpty())
-    return -1;
-
-  return _aucBuffer[_iTail];
-}
-
-template <int N>
-int RingBufferN<N>::nextIndex(int index)
-{
-  return (uint32_t)(index + 1) % N;
-}
-
-template <int N>
-bool RingBufferN<N>::isFull()
-{
-  return (_numElems == N);
-}
-
-}
-
-#endif /* _RING_BUFFER_ */
-#endif /* __cplusplus */
+#include "../../../ArduinoCore-API/api/RingBuffer.h"
@@ -1,31 +1,2 @@
-/*
-  Server.h - Base class that provides Server
-  Copyright (c) 2011 Adrian McEwen.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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 "Print.h"
-
-namespace arduino {
-
-class Server : public Print {
-  public:
-    virtual void begin() = 0;
-};
-
-}
+#include "../../../ArduinoCore-API/api/Server.h"
@@ -1,321 +1 @@
-/*
- Stream.cpp - adds parsing methods to Stream class
- Copyright (c) 2008 David A. Mellis.  All right reserved.
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is 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
-
- Created July 2011
- parsing functions based on TextFinder library by Michael Margolis
-
- findMulti/findUntil routines written by Jim Leonard/Xuth
- */
-
-#include "Common.h"
-#include "Stream.h"
-
-#define PARSE_TIMEOUT 1000  // default number of milli-seconds to wait
-
-using namespace arduino;
-
-// private method to read stream with timeout
-int Stream::timedRead()
-{
-  int c;
-  _startMillis = millis();
-  do {
-    c = read();
-    if (c >= 0) return c;
-  } while(millis() - _startMillis < _timeout);
-  return -1;     // -1 indicates timeout
-}
-
-// private method to peek stream with timeout
-int Stream::timedPeek()
-{
-  int c;
-  _startMillis = millis();
-  do {
-    c = peek();
-    if (c >= 0) return c;
-  } while(millis() - _startMillis < _timeout);
-  return -1;     // -1 indicates timeout
-}
-
-// returns peek of the next digit in the stream or -1 if timeout
-// discards non-numeric characters
-int Stream::peekNextDigit(LookaheadMode lookahead, bool detectDecimal)
-{
-  int c;
-  while (1) {
-    c = timedPeek();
-
-    if( c < 0 ||
-        c == '-' ||
-        (c >= '0' && c <= '9') ||
-        (detectDecimal && c == '.')) return c;
-
-    switch( lookahead ){
-        case SKIP_NONE: return -1; // Fail code.
-        case SKIP_WHITESPACE:
-            switch( c ){
-                case ' ':
-                case '\t':
-                case '\r':
-                case '\n': break;
-                default: return -1; // Fail code.
-            }
-        case SKIP_ALL:
-            break;
-    }
-    read();  // discard non-numeric
-  }
-}
-
-// Public Methods
-//////////////////////////////////////////////////////////////
-
-void Stream::setTimeout(unsigned long timeout)  // sets the maximum number of milliseconds to wait
-{
-  _timeout = timeout;
-}
-
- // find returns true if the target string is found
-bool  Stream::find(const char *target)
-{
-  return findUntil(target, strlen(target), NULL, 0);
-}
-
-// reads data from the stream until the target string of given length is found
-// returns true if target string is found, false if timed out
-bool Stream::find(const char *target, size_t length)
-{
-  return findUntil(target, length, NULL, 0);
-}
-
-// as find but search ends if the terminator string is found
-bool  Stream::findUntil(const char *target, const char *terminator)
-{
-  return findUntil(target, strlen(target), terminator, strlen(terminator));
-}
-
-// reads data from the stream until the target string of the given length is found
-// search terminated if the terminator string is found
-// returns true if target string is found, false if terminated or timed out
-bool Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen)
-{
-  if (terminator == NULL) {
-    MultiTarget t[1] = {{target, targetLen, 0}};
-    return findMulti(t, 1) == 0;
-  } else {
-    MultiTarget t[2] = {{target, targetLen, 0}, {terminator, termLen, 0}};
-    return findMulti(t, 2) == 0;
-  }
-}
-
-// returns the first valid (long) integer value from the current position.
-// lookahead determines how parseInt looks ahead in the stream.
-// See LookaheadMode enumeration at the top of the file.
-// Lookahead is terminated by the first character that is not a valid part of an integer.
-// Once parsing commences, 'ignore' will be skipped in the stream.
-long Stream::parseInt(LookaheadMode lookahead, char ignore)
-{
-  bool isNegative = false;
-  long value = 0;
-  int c;
-
-  c = peekNextDigit(lookahead, false);
-  // ignore non numeric leading characters
-  if(c < 0)
-    return 0; // zero returned if timeout
-
-  do{
-    if((char)c == ignore)
-      ; // ignore this character
-    else if(c == '-')
-      isNegative = true;
-    else if(c >= '0' && c <= '9')        // is c a digit?
-      value = value * 10 + c - '0';
-    read();  // consume the character we got with peek
-    c = timedPeek();
-  }
-  while( (c >= '0' && c <= '9') || (char)c == ignore );
-
-  if(isNegative)
-    value = -value;
-  return value;
-}
-
-// as parseInt but returns a floating point value
-float Stream::parseFloat(LookaheadMode lookahead, char ignore)
-{
-  bool isNegative = false;
-  bool isFraction = false;
-  double value = 0.0;
-  int c;
-  double fraction = 1.0;
-
-  c = peekNextDigit(lookahead, true);
-    // ignore non numeric leading characters
-  if(c < 0)
-    return 0; // zero returned if timeout
-
-  do{
-    if((char)c == ignore)
-      ; // ignore
-    else if(c == '-')
-      isNegative = true;
-    else if (c == '.')
-      isFraction = true;
-    else if(c >= '0' && c <= '9')  {      // is c a digit?
-      if(isFraction) {
-        fraction *= 0.1;
-        value = value + fraction * (c - '0');
-      } else {
-        value = value * 10 + c - '0';
-      }
-    }
-    read();  // consume the character we got with peek
-    c = timedPeek();
-  }
-  while( (c >= '0' && c <= '9')  || (c == '.' && !isFraction) || (char)c == ignore );
-
-  if(isNegative)
-    value = -value;
-
-  return value;
-}
-
-// read characters from stream into buffer
-// terminates if length characters have been read, or timeout (see setTimeout)
-// returns the number of characters placed in the buffer
-// the buffer is NOT null terminated.
-//
-size_t Stream::readBytes(char *buffer, size_t length)
-{
-  size_t count = 0;
-  while (count < length) {
-    int c = timedRead();
-    if (c < 0) break;
-    *buffer++ = (char)c;
-    count++;
-  }
-  return count;
-}
-
-
-// as readBytes with terminator character
-// terminates if length characters have been read, timeout, or if the terminator character  detected
-// returns the number of characters placed in the buffer (0 means no valid data found)
-
-size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length)
-{
-  size_t index = 0;
-  while (index < length) {
-    int c = timedRead();
-    if (c < 0 || (char)c == terminator) break;
-    *buffer++ = (char)c;
-    index++;
-  }
-  return index; // return number of characters, not including null terminator
-}
-
-String Stream::readString()
-{
-  String ret;
-  int c = timedRead();
-  while (c >= 0)
-  {
-    ret += (char)c;
-    c = timedRead();
-  }
-  return ret;
-}
-
-String Stream::readStringUntil(char terminator)
-{
-  String ret;
-  int c = timedRead();
-  while (c >= 0 && (char)c != terminator)
-  {
-    ret += (char)c;
-    c = timedRead();
-  }
-  return ret;
-}
-
-int Stream::findMulti( struct Stream::MultiTarget *targets, int tCount) {
-  // any zero length target string automatically matches and would make
-  // a mess of the rest of the algorithm.
-  for (struct MultiTarget *t = targets; t < targets+tCount; ++t) {
-    if (t->len <= 0)
-      return t - targets;
-  }
-
-  while (1) {
-    int c = timedRead();
-    if (c < 0)
-      return -1;
-
-    for (struct MultiTarget *t = targets; t < targets+tCount; ++t) {
-      // the simple case is if we match, deal with that first.
-      if ((char)c == t->str[t->index]) {
-        if (++t->index == t->len)
-          return t - targets;
-        else
-          continue;
-      }
-
-      // if not we need to walk back and see if we could have matched further
-      // down the stream (ie '1112' doesn't match the first position in '11112'
-      // but it will match the second position so we can't just reset the current
-      // index to 0 when we find a mismatch.
-      if (t->index == 0)
-        continue;
-
-      int origIndex = t->index;
-      do {
-        --t->index;
-        // first check if current char works against the new current index
-        if ((char)c != t->str[t->index])
-          continue;
-
-        // if it's the only char then we're good, nothing more to check
-        if (t->index == 0) {
-          t->index++;
-          break;
-        }
-
-        // otherwise we need to check the rest of the found string
-        int diff = origIndex - t->index;
-        size_t i;
-        for (i = 0; i < t->index; ++i) {
-          if (t->str[i] != t->str[i + diff])
-            break;
-        }
-
-        // if we successfully got through the previous loop then our current
-        // index is good.
-        if (i == t->index) {
-          t->index++;
-          break;
-        }
-
-        // otherwise we just try the next index
-      } while (t->index);
-    }
-  }
-  // unreachable
-  return -1;
-}
+#include "../../../ArduinoCore-API/api/Stream.cpp"
@@ -1,131 +1,2 @@
-/*
-  Stream.h - base class for character-based streams.
-  Copyright (c) 2010 David A. Mellis.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-
-  parsing functions based on TextFinder library by Michael Margolis
-*/
-
 #pragma once
-
-#include <inttypes.h>
-#include "Print.h"
-
-// compatability macros for testing
-/*
-#define   getInt()            parseInt()
-#define   getInt(ignore)      parseInt(ignore)
-#define   getFloat()          parseFloat()
-#define   getFloat(ignore)    parseFloat(ignore)
-#define   getString( pre_string, post_string, buffer, length)
-readBytesBetween( pre_string, terminator, buffer, length)
-*/
-
-namespace arduino {
-
-// This enumeration provides the lookahead options for parseInt(), parseFloat()
-// The rules set out here are used until either the first valid character is found
-// or a time out occurs due to lack of input.
-enum LookaheadMode{
-    SKIP_ALL,       // All invalid characters are ignored.
-    SKIP_NONE,      // Nothing is skipped, and the stream is not touched unless the first waiting character is valid.
-    SKIP_WHITESPACE // Only tabs, spaces, line feeds & carriage returns are skipped.
-};
-
-#define NO_IGNORE_CHAR  '\x01' // a char not found in a valid ASCII numeric field
-
-class Stream : public Print
-{
-  protected:
-    unsigned long _timeout;      // number of milliseconds to wait for the next char before aborting timed read
-    unsigned long _startMillis;  // used for timeout measurement
-    int timedRead();    // private method to read stream with timeout
-    int timedPeek();    // private method to peek stream with timeout
-    int peekNextDigit(LookaheadMode lookahead, bool detectDecimal); // returns the next numeric digit in the stream or -1 if timeout
-
-  public:
-    virtual int available() = 0;
-    virtual int read() = 0;
-    virtual int peek() = 0;
-
-    Stream() {_timeout=1000;}
-
-// parsing methods
-
-  void setTimeout(unsigned long timeout);  // sets maximum milliseconds to wait for stream data, default is 1 second
-  unsigned long getTimeout(void) { return _timeout; }
-  
-  bool find(const char *target);   // reads data from the stream until the target string is found
-  bool find(const uint8_t *target) { return find ((const char *)target); }
-  // returns true if target string is found, false if timed out (see setTimeout)
-
-  bool find(const char *target, size_t length);   // reads data from the stream until the target string of given length is found
-  bool find(const uint8_t *target, size_t length) { return find ((const char *)target, length); }
-  // returns true if target string is found, false if timed out
-
-  bool find(char target) { return find (&target, 1); }
-
-  bool findUntil(const char *target, const char *terminator);   // as find but search ends if the terminator string is found
-  bool findUntil(const uint8_t *target, const char *terminator) { return findUntil((const char *)target, terminator); }
-
-  bool findUntil(const char *target, size_t targetLen, const char *terminate, size_t termLen);   // as above but search ends if the terminate string is found
-  bool findUntil(const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen) {return findUntil((const char *)target, targetLen, terminate, termLen); }
-
-  long parseInt(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR);
-  // returns the first valid (long) integer value from the current position.
-  // lookahead determines how parseInt looks ahead in the stream.
-  // See LookaheadMode enumeration at the top of the file.
-  // Lookahead is terminated by the first character that is not a valid part of an integer.
-  // Once parsing commences, 'ignore' will be skipped in the stream.
-
-  float parseFloat(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR);
-  // float version of parseInt
-
-  size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer
-  size_t readBytes( uint8_t *buffer, size_t length) { return readBytes((char *)buffer, length); }
-  // terminates if length characters have been read or timeout (see setTimeout)
-  // returns the number of characters placed in the buffer (0 means no valid data found)
-
-  size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character
-  size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
-  // terminates if length characters have been read, timeout, or if the terminator character  detected
-  // returns the number of characters placed in the buffer (0 means no valid data found)
-
-  // Arduino String functions to be added here
-  String readString();
-  String readStringUntil(char terminator);
-
-  protected:
-  long parseInt(char ignore) { return parseInt(SKIP_ALL, ignore); }
-  float parseFloat(char ignore) { return parseFloat(SKIP_ALL, ignore); }
-  // These overload exists for compatibility with any class that has derived
-  // Stream and used parseFloat/Int with a custom ignore character. To keep
-  // the public API simple, these overload remains protected.
-
-  struct MultiTarget {
-    const char *str;  // string you're searching for
-    size_t len;       // length of string you're searching for
-    size_t index;     // index used by the search routine.
-  };
-
-  // This allows you to search for an arbitrary number of strings.
-  // Returns index of the target that is found first or -1 if timeout occurs.
-  int findMulti(struct MultiTarget *targets, int tCount);
-};
-
-#undef NO_IGNORE_CHAR
-
-}
+#include "../../../ArduinoCore-API/api/Stream.h"
@@ -1,768 +1 @@
-/*
-  String library for Wiring & Arduino
-  ...mostly rewritten by Paul Stoffregen...
-  Copyright (c) 2009-10 Hernando Barragan.  All rights reserved.
-  Copyright 2011, Paul Stoffregen, paul@pjrc.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 "String.h"
-#include "Common.h"
-#include "itoa.h"
-#include "deprecated-avr-comp/avr/dtostrf.h"
-
-#include <float.h>
-
-namespace arduino {
-
-/*********************************************/
-/*  Static Member Initialisation             */
-/*********************************************/
-
-size_t const String::FLT_MAX_DECIMAL_PLACES;
-size_t const String::DBL_MAX_DECIMAL_PLACES;
-
-/*********************************************/
-/*  Constructors                             */
-/*********************************************/
-
-String::String(const char *cstr)
-{
-	init();
-	if (cstr) copy(cstr, strlen(cstr));
-}
-
-String::String(const char *cstr, unsigned int length)
-{
-	init();
-	if (cstr) copy(cstr, length);
-}
-
-String::String(const String &value)
-{
-	init();
-	*this = value;
-}
-
-String::String(const __FlashStringHelper *pstr)
-{
-	init();
-	*this = pstr;
-}
-
-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-String::String(String &&rval)
-{
-	init();
-	move(rval);
-}
-String::String(StringSumHelper &&rval)
-{
-	init();
-	move(rval);
-}
-#endif
-
-String::String(char c)
-{
-	init();
-	char buf[2];
-	buf[0] = c;
-	buf[1] = 0;
-	*this = buf;
-}
-
-String::String(unsigned char value, unsigned char base)
-{
-	init();
-	char buf[1 + 8 * sizeof(unsigned char)];
-	utoa(value, buf, base);
-	*this = buf;
-}
-
-String::String(int value, unsigned char base)
-{
-	init();
-	char buf[2 + 8 * sizeof(int)];
-	itoa(value, buf, base);
-	*this = buf;
-}
-
-String::String(unsigned int value, unsigned char base)
-{
-	init();
-	char buf[1 + 8 * sizeof(unsigned int)];
-	utoa(value, buf, base);
-	*this = buf;
-}
-
-String::String(long value, unsigned char base)
-{
-	init();
-	char buf[2 + 8 * sizeof(long)];
-	ltoa(value, buf, base);
-	*this = buf;
-}
-
-String::String(unsigned long value, unsigned char base)
-{
-	init();
-	char buf[1 + 8 * sizeof(unsigned long)];
-	ultoa(value, buf, base);
-	*this = buf;
-}
-
-String::String(float value, unsigned char decimalPlaces)
-{
-	static size_t const FLOAT_BUF_SIZE = FLT_MAX_10_EXP + FLT_MAX_DECIMAL_PLACES + 1 /* '-' */ + 1 /* '.' */ + 1 /* '\0' */;
-	init();
-	char buf[FLOAT_BUF_SIZE];
-	decimalPlaces = min(decimalPlaces, FLT_MAX_DECIMAL_PLACES);
-	*this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
-}
-
-String::String(double value, unsigned char decimalPlaces)
-{
-	static size_t const DOUBLE_BUF_SIZE = DBL_MAX_10_EXP + DBL_MAX_DECIMAL_PLACES + 1 /* '-' */ + 1 /* '.' */ + 1 /* '\0' */;
-	init();
-	char buf[DOUBLE_BUF_SIZE];
-	decimalPlaces = min(decimalPlaces, DBL_MAX_DECIMAL_PLACES);
-	*this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
-}
-
-String::~String()
-{
-	if (buffer) free(buffer);
-}
-
-/*********************************************/
-/*  Memory Management                        */
-/*********************************************/
-
-inline void String::init(void)
-{
-	buffer = NULL;
-	capacity = 0;
-	len = 0;
-}
-
-void String::invalidate(void)
-{
-	if (buffer) free(buffer);
-	buffer = NULL;
-	capacity = len = 0;
-}
-
-unsigned char String::reserve(unsigned int size)
-{
-	if (buffer && capacity >= size) return 1;
-	if (changeBuffer(size)) {
-		if (len == 0) buffer[0] = 0;
-		return 1;
-	}
-	return 0;
-}
-
-unsigned char String::changeBuffer(unsigned int maxStrLen)
-{
-	char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
-	if (newbuffer) {
-		buffer = newbuffer;
-		capacity = maxStrLen;
-		return 1;
-	}
-	return 0;
-}
-
-/*********************************************/
-/*  Copy and Move                            */
-/*********************************************/
-
-String & String::copy(const char *cstr, unsigned int length)
-{
-	if (!reserve(length)) {
-		invalidate();
-		return *this;
-	}
-	len = length;
-	memcpy(buffer, cstr, length);
-	buffer[len] = '\0';
-	return *this;
-}
-
-String & String::copy(const __FlashStringHelper *pstr, unsigned int length)
-{
-	if (!reserve(length)) {
-		invalidate();
-		return *this;
-	}
-	len = length;
-	strcpy_P(buffer, (PGM_P)pstr);
-	return *this;
-}
-
-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-void String::move(String &rhs)
-{
-	if (buffer) {
-		if (rhs && capacity >= rhs.len) {
-			memcpy(buffer, rhs.buffer, rhs.len);
-			len = rhs.len;
-			buffer[len] = '\0';
-			rhs.len = 0;
-			return;
-		} else {
-			free(buffer);
-		}
-	}
-	buffer = rhs.buffer;
-	capacity = rhs.capacity;
-	len = rhs.len;
-	rhs.buffer = NULL;
-	rhs.capacity = 0;
-	rhs.len = 0;
-}
-#endif
-
-String & String::operator = (const String &rhs)
-{
-	if (this == &rhs) return *this;
-	
-	if (rhs.buffer) copy(rhs.buffer, rhs.len);
-	else invalidate();
-	
-	return *this;
-}
-
-#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-String & String::operator = (String &&rval)
-{
-	if (this != &rval) move(rval);
-	return *this;
-}
-
-String & String::operator = (StringSumHelper &&rval)
-{
-	if (this != &rval) move(rval);
-	return *this;
-}
-#endif
-
-String & String::operator = (const char *cstr)
-{
-	if (cstr) copy(cstr, strlen(cstr));
-	else invalidate();
-	
-	return *this;
-}
-
-String & String::operator = (const __FlashStringHelper *pstr)
-{
-	if (pstr) copy(pstr, strlen_P((PGM_P)pstr));
-	else invalidate();
-
-	return *this;
-}
-
-/*********************************************/
-/*  concat                                   */
-/*********************************************/
-
-unsigned char String::concat(const String &s)
-{
-	return concat(s.buffer, s.len);
-}
-
-unsigned char String::concat(const char *cstr, unsigned int length)
-{
-	unsigned int newlen = len + length;
-	if (!cstr) return 0;
-	if (length == 0) return 1;
-	if (!reserve(newlen)) return 0;
-	memcpy(buffer + len, cstr, length);
-	len = newlen;
-	buffer[len] = '\0';
-	return 1;
-}
-
-unsigned char String::concat(const char *cstr)
-{
-	if (!cstr) return 0;
-	return concat(cstr, strlen(cstr));
-}
-
-unsigned char String::concat(char c)
-{
-	return concat(&c, 1);
-}
-
-unsigned char String::concat(unsigned char num)
-{
-	char buf[1 + 3 * sizeof(unsigned char)];
-	itoa(num, buf, 10);
-	return concat(buf);
-}
-
-unsigned char String::concat(int num)
-{
-	char buf[2 + 3 * sizeof(int)];
-	itoa(num, buf, 10);
-	return concat(buf);
-}
-
-unsigned char String::concat(unsigned int num)
-{
-	char buf[1 + 3 * sizeof(unsigned int)];
-	utoa(num, buf, 10);
-	return concat(buf);
-}
-
-unsigned char String::concat(long num)
-{
-	char buf[2 + 3 * sizeof(long)];
-	ltoa(num, buf, 10);
-	return concat(buf);
-}
-
-unsigned char String::concat(unsigned long num)
-{
-	char buf[1 + 3 * sizeof(unsigned long)];
-	ultoa(num, buf, 10);
-	return concat(buf);
-}
-
-unsigned char String::concat(float num)
-{
-	char buf[20];
-	char* string = dtostrf(num, 4, 2, buf);
-	return concat(string);
-}
-
-unsigned char String::concat(double num)
-{
-	char buf[20];
-	char* string = dtostrf(num, 4, 2, buf);
-	return concat(string);
-}
-
-unsigned char String::concat(const __FlashStringHelper * str)
-{
-	if (!str) return 0;
-	int length = strlen_P((const char *) str);
-	if (length == 0) return 1;
-	unsigned int newlen = len + length;
-	if (!reserve(newlen)) return 0;
-	strcpy_P(buffer + len, (const char *) str);
-	len = newlen;
-	return 1;
-}
-
-/*********************************************/
-/*  Concatenate                              */
-/*********************************************/
-
-StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(rhs.buffer, rhs.len)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!cstr || !a.concat(cstr)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, char c)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(c)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, int num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, long num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, float num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, double num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(rhs))	a.invalidate();
-	return a;
-}
-
-/*********************************************/
-/*  Comparison                               */
-/*********************************************/
-
-int String::compareTo(const String &s) const
-{
-	if (!buffer || !s.buffer) {
-		if (s.buffer && s.len > 0) return 0 - *(unsigned char *)s.buffer;
-		if (buffer && len > 0) return *(unsigned char *)buffer;
-		return 0;
-	}
-	return strcmp(buffer, s.buffer);
-}
-
-int String::compareTo(const char *cstr) const
-{
-	if (!buffer || !cstr) {
-		if (cstr && *cstr) return 0 - *(unsigned char *)cstr;
-		if (buffer && len > 0) return *(unsigned char *)buffer;
-		return 0;
-	}
-	return strcmp(buffer, cstr);
-}
-
-unsigned char String::equals(const String &s2) const
-{
-	return (len == s2.len && compareTo(s2) == 0);
-}
-
-unsigned char String::equals(const char *cstr) const
-{
-	if (len == 0) return (cstr == NULL || *cstr == 0);
-	if (cstr == NULL) return buffer[0] == 0;
-	return strcmp(buffer, cstr) == 0;
-}
-
-unsigned char String::equalsIgnoreCase( const String &s2 ) const
-{
-	if (this == &s2) return 1;
-	if (len != s2.len) return 0;
-	if (len == 0) return 1;
-	const char *p1 = buffer;
-	const char *p2 = s2.buffer;
-	while (*p1) {
-		if (tolower(*p1++) != tolower(*p2++)) return 0;
-	} 
-	return 1;
-}
-
-unsigned char String::startsWith( const String &s2 ) const
-{
-	if (len < s2.len) return 0;
-	return startsWith(s2, 0);
-}
-
-unsigned char String::startsWith( const String &s2, unsigned int offset ) const
-{
-	if (offset > len - s2.len || !buffer || !s2.buffer) return 0;
-	return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0;
-}
-
-unsigned char String::endsWith( const String &s2 ) const
-{
-	if ( len < s2.len || !buffer || !s2.buffer) return 0;
-	return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
-}
-
-/*********************************************/
-/*  Character Access                         */
-/*********************************************/
-
-char String::charAt(unsigned int loc) const
-{
-	return operator[](loc);
-}
-
-void String::setCharAt(unsigned int loc, char c) 
-{
-	if (loc < len) buffer[loc] = c;
-}
-
-char & String::operator[](unsigned int index)
-{
-	static char dummy_writable_char;
-	if (index >= len || !buffer) {
-		dummy_writable_char = 0;
-		return dummy_writable_char;
-	}
-	return buffer[index];
-}
-
-char String::operator[]( unsigned int index ) const
-{
-	if (index >= len || !buffer) return 0;
-	return buffer[index];
-}
-
-void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const
-{
-	if (!bufsize || !buf) return;
-	if (index >= len) {
-		buf[0] = 0;
-		return;
-	}
-	unsigned int n = bufsize - 1;
-	if (n > len - index) n = len - index;
-	strncpy((char *)buf, buffer + index, n);
-	buf[n] = 0;
-}
-
-/*********************************************/
-/*  Search                                   */
-/*********************************************/
-
-int String::indexOf(char c) const
-{
-	return indexOf(c, 0);
-}
-
-int String::indexOf( char ch, unsigned int fromIndex ) const
-{
-	if (fromIndex >= len) return -1;
-	const char* temp = strchr(buffer + fromIndex, ch);
-	if (temp == NULL) return -1;
-	return temp - buffer;
-}
-
-int String::indexOf(const String &s2) const
-{
-	return indexOf(s2, 0);
-}
-
-int String::indexOf(const String &s2, unsigned int fromIndex) const
-{
-	if (fromIndex >= len) return -1;
-	const char *found = strstr(buffer + fromIndex, s2.buffer);
-	if (found == NULL) return -1;
-	return found - buffer;
-}
-
-int String::lastIndexOf( char theChar ) const
-{
-	return lastIndexOf(theChar, len - 1);
-}
-
-int String::lastIndexOf(char ch, unsigned int fromIndex) const
-{
-	if (fromIndex >= len) return -1;
-	char tempchar = buffer[fromIndex + 1];
-	buffer[fromIndex + 1] = '\0';
-	char* temp = strrchr( buffer, ch );
-	buffer[fromIndex + 1] = tempchar;
-	if (temp == NULL) return -1;
-	return temp - buffer;
-}
-
-int String::lastIndexOf(const String &s2) const
-{
-	return lastIndexOf(s2, len - s2.len);
-}
-
-int String::lastIndexOf(const String &s2, unsigned int fromIndex) const
-{
-	if (s2.len == 0 || len == 0 || s2.len > len) return -1;
-	if (fromIndex >= len) fromIndex = len - 1;
-	int found = -1;
-	for (char *p = buffer; p <= buffer + fromIndex; p++) {
-		p = strstr(p, s2.buffer);
-		if (!p) break;
-		if ((unsigned int)(p - buffer) <= fromIndex) found = p - buffer;
-	}
-	return found;
-}
-
-String String::substring(unsigned int left, unsigned int right) const
-{
-	if (left > right) {
-		unsigned int temp = right;
-		right = left;
-		left = temp;
-	}
-	String out;
-	if (left >= len) return out;
-	if (right > len) right = len;
-	out.copy(buffer + left, right - left);
-	return out;
-}
-
-/*********************************************/
-/*  Modification                             */
-/*********************************************/
-
-void String::replace(char find, char replace)
-{
-	if (!buffer) return;
-	for (char *p = buffer; *p; p++) {
-		if (*p == find) *p = replace;
-	}
-}
-
-void String::replace(const String& find, const String& replace)
-{
-	if (len == 0 || find.len == 0) return;
-	int diff = replace.len - find.len;
-	char *readFrom = buffer;
-	char *foundAt;
-	if (diff == 0) {
-		while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
-			memcpy(foundAt, replace.buffer, replace.len);
-			readFrom = foundAt + replace.len;
-		}
-	} else if (diff < 0) {
-		unsigned int size = len; // compute size needed for result
-		while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
-			readFrom = foundAt + find.len;
-			diff = 0 - diff;
-			size -= diff;
-		}
-		if (size == len) return;
-		int index = len - 1;
-		while (index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
-			readFrom = buffer + index + find.len;
-			memmove(readFrom - diff, readFrom, len - (readFrom - buffer));
-			len -= diff;
-			buffer[len] = 0;
-			memcpy(buffer + index, replace.buffer, replace.len);
-			index--;
-		}
-	} else {
-		unsigned int size = len; // compute size needed for result
-		while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
-			readFrom = foundAt + find.len;
-			size += diff;
-		}
-		if (size == len) return;
-		if (size > capacity && !changeBuffer(size)) return; // XXX: tell user!
-		int index = len - 1;
-		while (index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
-			readFrom = buffer + index + find.len;
-			memmove(readFrom + diff, readFrom, len - (readFrom - buffer));
-			len += diff;
-			buffer[len] = 0;
-			memcpy(buffer + index, replace.buffer, replace.len);
-			index--;
-		}
-	}
-}
-
-void String::remove(unsigned int index){
-	// Pass the biggest integer as the count. The remove method
-	// below will take care of truncating it at the end of the
-	// string.
-	remove(index, (unsigned int)-1);
-}
-
-void String::remove(unsigned int index, unsigned int count){
-	if (index >= len) { return; }
-	if (count <= 0) { return; }
-	if (count > len - index) { count = len - index; }
-	char *writeTo = buffer + index;
-	len = len - count;
-	memmove(writeTo, buffer + index + count,len - index);
-	buffer[len] = 0;
-}
-
-void String::toLowerCase(void)
-{
-	if (!buffer) return;
-	for (char *p = buffer; *p; p++) {
-		*p = tolower(*p);
-	}
-}
-
-void String::toUpperCase(void)
-{
-	if (!buffer) return;
-	for (char *p = buffer; *p; p++) {
-		*p = toupper(*p);
-	}
-}
-
-void String::trim(void)
-{
-	if (!buffer || len == 0) return;
-	char *begin = buffer;
-	while (isspace(*begin)) begin++;
-	char *end = buffer + len - 1;
-	while (isspace(*end) && end >= begin) end--;
-	len = end + 1 - begin;
-	if (begin > buffer) memmove(buffer, begin, len);
-	buffer[len] = 0;
-}
-
-/*********************************************/
-/*  Parsing / Conversion                     */
-/*********************************************/
-
-long String::toInt(void) const
-{
-	if (buffer) return atol(buffer);
-	return 0;
-}
-
-float String::toFloat(void) const
-{
-	return float(toDouble());
-}
-
-double String::toDouble(void) const
-{
-	if (buffer) return atof(buffer);
-	return 0;
-}
-
-} // namespace arduino
+#include "../../../ArduinoCore-API/api/String.cpp"
@@ -1,259 +1,2 @@
-/*
-  String library for Wiring & Arduino
-  ...mostly rewritten by Paul Stoffregen...
-  Copyright (c) 2009-10 Hernando Barragan.  All right reserved.
-  Copyright 2011, Paul Stoffregen, paul@pjrc.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
-*/
-
-#ifdef __cplusplus
-
-#ifndef __ARDUINO_STRINGS__
-#define __ARDUINO_STRINGS__
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#if defined(__AVR__)
-#include "avr/pgmspace.h"
-#else
-#include "deprecated-avr-comp/avr/pgmspace.h"
-#endif
-
-namespace arduino {
-
-// When compiling programs with this class, the following gcc parameters
-// dramatically increase performance and memory (RAM) efficiency, typically
-// with little or no increase in code size.
-//     -felide-constructors
-//     -std=c++0x
-
-class __FlashStringHelper;
-#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
-
-// An inherited class for holding the result of a concatenation.  These
-// result objects are assumed to be writable by subsequent concatenations.
-class StringSumHelper;
-
-// The string class
-class String
-{
-	friend class StringSumHelper;
-	// use a function pointer to allow for "if (s)" without the
-	// complications of an operator bool(). for more information, see:
-	// http://www.artima.com/cppsource/safebool.html
-	typedef void (String::*StringIfHelperType)() const;
-	void StringIfHelper() const {}
-
-	static size_t const FLT_MAX_DECIMAL_PLACES = 10;
-	static size_t const DBL_MAX_DECIMAL_PLACES = FLT_MAX_DECIMAL_PLACES;
-
-public:
-	// constructors
-	// creates a copy of the initial value.
-	// if the initial value is null or invalid, or if memory allocation
-	// fails, the string will be marked as invalid (i.e. "if (s)" will
-	// be false).
-	String(const char *cstr = "");
-	String(const char *cstr, unsigned int length);
-	String(const uint8_t *cstr, unsigned int length) : String((const char*)cstr, length) {}
-	String(const String &str);
-	String(const __FlashStringHelper *str);
-	#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-	String(String &&rval);
-	String(StringSumHelper &&rval);
-	#endif
-	explicit String(char c);
-	explicit String(unsigned char, unsigned char base=10);
-	explicit String(int, unsigned char base=10);
-	explicit String(unsigned int, unsigned char base=10);
-	explicit String(long, unsigned char base=10);
-	explicit String(unsigned long, unsigned char base=10);
-	explicit String(float, unsigned char decimalPlaces=2);
-	explicit String(double, unsigned char decimalPlaces=2);
-	~String(void);
-
-	// memory management
-	// return true on success, false on failure (in which case, the string
-	// is left unchanged).  reserve(0), if successful, will validate an
-	// invalid string (i.e., "if (s)" will be true afterwards)
-	unsigned char reserve(unsigned int size);
-	inline unsigned int length(void) const {return len;}
-
-	// creates a copy of the assigned value.  if the value is null or
-	// invalid, or if the memory allocation fails, the string will be
-	// marked as invalid ("if (s)" will be false).
-	String & operator = (const String &rhs);
-	String & operator = (const char *cstr);
-	String & operator = (const __FlashStringHelper *str);
-	#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-	String & operator = (String &&rval);
-	String & operator = (StringSumHelper &&rval);
-	#endif
-
-	// concatenate (works w/ built-in types)
-
-	// returns true on success, false on failure (in which case, the string
-	// is left unchanged).  if the argument is null or invalid, the
-	// concatenation is considered unsucessful.
-	unsigned char concat(const String &str);
-	unsigned char concat(const char *cstr);
-	unsigned char concat(const char *cstr, unsigned int length);
-	unsigned char concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
-	unsigned char concat(char c);
-	unsigned char concat(unsigned char num);
-	unsigned char concat(int num);
-	unsigned char concat(unsigned int num);
-	unsigned char concat(long num);
-	unsigned char concat(unsigned long num);
-	unsigned char concat(float num);
-	unsigned char concat(double num);
-	unsigned char concat(const __FlashStringHelper * str);
-
-	// if there's not enough memory for the concatenated value, the string
-	// will be left unchanged (but this isn't signalled in any way)
-	String & operator += (const String &rhs)	{concat(rhs); return (*this);}
-	String & operator += (const char *cstr)		{concat(cstr); return (*this);}
-	String & operator += (char c)			{concat(c); return (*this);}
-	String & operator += (unsigned char num)		{concat(num); return (*this);}
-	String & operator += (int num)			{concat(num); return (*this);}
-	String & operator += (unsigned int num)		{concat(num); return (*this);}
-	String & operator += (long num)			{concat(num); return (*this);}
-	String & operator += (unsigned long num)	{concat(num); return (*this);}
-	String & operator += (float num)		{concat(num); return (*this);}
-	String & operator += (double num)		{concat(num); return (*this);}
-	String & operator += (const __FlashStringHelper *str){concat(str); return (*this);}
-
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, char c);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, int num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, long num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, float num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, double num);
-	friend StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs);
-
-	// comparison (only works w/ Strings and "strings")
-	operator StringIfHelperType() const { return buffer ? &String::StringIfHelper : 0; }
-	int compareTo(const String &s) const;
-	int compareTo(const char *cstr) const;
-	unsigned char equals(const String &s) const;
-	unsigned char equals(const char *cstr) const;
-
-	friend unsigned char operator == (const String &a, const String &b) { return a.equals(b); }
-	friend unsigned char operator == (const String &a, const char   *b) { return a.equals(b); }
-	friend unsigned char operator == (const char   *a, const String &b) { return b == a; }
-	friend unsigned char operator <  (const String &a, const String &b) { return a.compareTo(b) < 0; }
-	friend unsigned char operator <  (const String &a, const char   *b) { return a.compareTo(b) < 0; }
-	friend unsigned char operator <  (const char   *a, const String &b) { return b.compareTo(a) > 0; }
-
-	friend unsigned char operator != (const String &a, const String &b) { return !(a == b); }
-	friend unsigned char operator != (const String &a, const char   *b) { return !(a == b); }
-	friend unsigned char operator != (const char   *a, const String &b) { return !(a == b); }
-	friend unsigned char operator >  (const String &a, const String &b) { return b < a; }
-	friend unsigned char operator >  (const String &a, const char   *b) { return b < a; }
-	friend unsigned char operator >  (const char   *a, const String &b) { return b < a; }
-	friend unsigned char operator <= (const String &a, const String &b) { return !(b < a); }
-	friend unsigned char operator <= (const String &a, const char   *b) { return !(b < a); }
-	friend unsigned char operator <= (const char   *a, const String &b) { return !(b < a); }
-	friend unsigned char operator >= (const String &a, const String &b) { return !(a < b); }
-	friend unsigned char operator >= (const String &a, const char   *b) { return !(a < b); }
-	friend unsigned char operator >= (const char   *a, const String &b) { return !(a < b); }
-
-	unsigned char equalsIgnoreCase(const String &s) const;
-	unsigned char startsWith( const String &prefix) const;
-	unsigned char startsWith(const String &prefix, unsigned int offset) const;
-	unsigned char endsWith(const String &suffix) const;
-
-	// character acccess
-	char charAt(unsigned int index) const;
-	void setCharAt(unsigned int index, char c);
-	char operator [] (unsigned int index) const;
-	char& operator [] (unsigned int index);
-	void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const;
-	void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const
-		{ getBytes((unsigned char *)buf, bufsize, index); }
-	const char* c_str() const { return buffer; }
-	char* begin() { return buffer; }
-	char* end() { return buffer + length(); }
-	const char* begin() const { return c_str(); }
-	const char* end() const { return c_str() + length(); }
-
-	// search
-	int indexOf( char ch ) const;
-	int indexOf( char ch, unsigned int fromIndex ) const;
-	int indexOf( const String &str ) const;
-	int indexOf( const String &str, unsigned int fromIndex ) const;
-	int lastIndexOf( char ch ) const;
-	int lastIndexOf( char ch, unsigned int fromIndex ) const;
-	int lastIndexOf( const String &str ) const;
-	int lastIndexOf( const String &str, unsigned int fromIndex ) const;
-	String substring( unsigned int beginIndex ) const { return substring(beginIndex, len); };
-	String substring( unsigned int beginIndex, unsigned int endIndex ) const;
-
-	// modification
-	void replace(char find, char replace);
-	void replace(const String& find, const String& replace);
-	void remove(unsigned int index);
-	void remove(unsigned int index, unsigned int count);
-	void toLowerCase(void);
-	void toUpperCase(void);
-	void trim(void);
-
-	// parsing/conversion
-	long toInt(void) const;
-	float toFloat(void) const;
-	double toDouble(void) const;
-
-protected:
-	char *buffer;	        // the actual char array
-	unsigned int capacity;  // the array length minus one (for the '\0')
-	unsigned int len;       // the String length (not counting the '\0')
-protected:
-	void init(void);
-	void invalidate(void);
-	unsigned char changeBuffer(unsigned int maxStrLen);
-
-	// copy and move
-	String & copy(const char *cstr, unsigned int length);
-	String & copy(const __FlashStringHelper *pstr, unsigned int length);
-	#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-	void move(String &rhs);
-	#endif
-};
-
-class StringSumHelper : public String
-{
-public:
-    StringSumHelper(const String &s) : String(s) {}
-    StringSumHelper(const char *p) : String(p) {}
-    StringSumHelper(char c) : String(c) {}
-    StringSumHelper(unsigned char num) : String(num) {}
-    StringSumHelper(int num) : String(num) {}
-    StringSumHelper(unsigned int num) : String(num) {}
-    StringSumHelper(long num) : String(num) {}
-    StringSumHelper(unsigned long num) : String(num) {}
-    StringSumHelper(float num) : String(num) {}
-    StringSumHelper(double num) : String(num) {}
-};
-
-} // namespace arduino
-
-#endif  // __cplusplus
-#endif  // __ARDUINO_STRINGS__
+#pragma once
+#include "../../../ArduinoCore-API/api/String.h"
@@ -1,64 +1,2 @@
-/*
-  USBAPI.h
-  Copyright (c) 2005-2014 Arduino.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-*/
-
-#ifndef __USBAPI__
-#define __USBAPI__
-
-#include <stdint.h>
-
-namespace arduino {
-//================================================================================
-//================================================================================
-//  Low level API
-
-typedef struct __attribute__((packed))
-{
-  union {
-    uint8_t bmRequestType;
-    struct {
-      uint8_t direction : 5;
-      uint8_t type : 2;
-      uint8_t transferDirection : 1;
-    };
-  };
-	uint8_t 	bRequest;
-	uint8_t 	wValueL;
-	uint8_t 	wValueH;
-	uint16_t 	wIndex;
-	uint16_t 	wLength;
-} USBSetup;
-
-}
-
-//================================================================================
-// USB APIs (C scope)
-//================================================================================
-
-int USB_SendControl(uint8_t flags, const void* d, int len);
-int USB_RecvControl(void* d, int len);
-int USB_RecvControlLong(void* d, int len);
-
-uint8_t	USB_Available(uint8_t ep);
-uint8_t USB_SendSpace(uint8_t ep);
-int USB_Send(uint8_t ep, const void* data, int len);	// blocking
-int USB_Recv(uint8_t ep, void* data, int len);		// non-blocking
-int USB_Recv(uint8_t ep);							// non-blocking
-void USB_Flush(uint8_t ep);
-
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/USBAPI.h"
@@ -1,92 +1,2 @@
-/*
- *  Udp.cpp: Library to send/receive UDP packets.
- *
- * NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
- * 1) UDP does not guarantee the order in which assembled UDP packets are received. This
- * might not happen often in practice, but in larger network topologies, a UDP
- * packet can be received out of sequence. 
- * 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
- * aware of it. Again, this may not be a concern in practice on small local networks.
- * For more information, see http://www.cafeaulait.org/course/week12/35.html
- *
- * MIT License:
- * Copyright (c) 2008 Bjoern Hartmann
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- * bjoern@cs.stanford.edu 12/30/2008
- */
-
 #pragma once
-
-#include "Stream.h"
-#include "IPAddress.h"
-
-namespace arduino {
-
-class UDP : public Stream {
-
-public:
-  virtual uint8_t begin(uint16_t) =0;  // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
-  virtual uint8_t beginMulticast(IPAddress, uint16_t) { return 0; }  // initialize, start listening on specified multicast IP address and port. Returns 1 if successful, 0 on failure
-  virtual void stop() =0;  // Finish with the UDP socket
-
-  // Sending UDP packets
-  
-  // Start building up a packet to send to the remote host specific in ip and port
-  // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
-  virtual int beginPacket(IPAddress ip, uint16_t port) =0;
-  // Start building up a packet to send to the remote host specific in host and port
-  // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
-  virtual int beginPacket(const char *host, uint16_t port) =0;
-  // Finish off this packet and send it
-  // Returns 1 if the packet was sent successfully, 0 if there was an error
-  virtual int endPacket() =0;
-  // Write a single byte into the packet
-  virtual size_t write(uint8_t) =0;
-  // Write size bytes from buffer into the packet
-  virtual size_t write(const uint8_t *buffer, size_t size) =0;
-
-  // Start processing the next available incoming packet
-  // Returns the size of the packet in bytes, or 0 if no packets are available
-  virtual int parsePacket() =0;
-  // Number of bytes remaining in the current packet
-  virtual int available() =0;
-  // Read a single byte from the current packet
-  virtual int read() =0;
-  // Read up to len bytes from the current packet and place them into buffer
-  // Returns the number of bytes read, or 0 if none are available
-  virtual int read(unsigned char* buffer, size_t len) =0;
-  // Read up to len characters from the current packet and place them into buffer
-  // Returns the number of characters read, or 0 if none are available
-  virtual int read(char* buffer, size_t len) =0;
-  // Return the next byte from the current packet without moving on to the next byte
-  virtual int peek() =0;
-  virtual void flush() =0;	// Finish reading the current packet
-
-  // Return the IP address of the host who sent the current incoming packet
-  virtual IPAddress remoteIP() =0;
-  // Return the port of the host who sent the current incoming packet
-  virtual uint16_t remotePort() =0;
-protected:
-  uint8_t* rawIPAddress(IPAddress& addr) { return addr.raw_address(); };
-};
-
-}
-
-using namespace arduino;
+#include "../../../ArduinoCore-API/api/Udp.h"
@@ -1,171 +1,2 @@
-/*
- WCharacter.h - Character utility functions for Wiring & Arduino
- Copyright (c) 2010 Hernando Barragan.  All right reserved.
- 
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
- 
- This library is 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
- */
-
-#ifndef Character_h
-#define Character_h
-
-#include <ctype.h>
-
-namespace arduino {
-
-// WCharacter.h prototypes
-inline bool isAlphaNumeric(int c) __attribute__((always_inline));
-inline bool isAlpha(int c) __attribute__((always_inline));
-inline bool isAscii(int c) __attribute__((always_inline));
-inline bool isWhitespace(int c) __attribute__((always_inline));
-inline bool isControl(int c) __attribute__((always_inline));
-inline bool isDigit(int c) __attribute__((always_inline));
-inline bool isGraph(int c) __attribute__((always_inline));
-inline bool isLowerCase(int c) __attribute__((always_inline));
-inline bool isPrintable(int c) __attribute__((always_inline));
-inline bool isPunct(int c) __attribute__((always_inline));
-inline bool isSpace(int c) __attribute__((always_inline));
-inline bool isUpperCase(int c) __attribute__((always_inline));
-inline bool isHexadecimalDigit(int c) __attribute__((always_inline));
-inline int toAscii(int c) __attribute__((always_inline));
-inline int toLowerCase(int c) __attribute__((always_inline));
-inline int toUpperCase(int c)__attribute__((always_inline));
-
-
-// Checks for an alphanumeric character. 
-// It is equivalent to (isalpha(c) || isdigit(c)).
-inline bool isAlphaNumeric(int c) 
-{
-  return ( isalnum(c) == 0 ? false : true);
-}
-
-
-// Checks for an alphabetic character. 
-// It is equivalent to (isupper(c) || islower(c)).
-inline bool isAlpha(int c)
-{
-  return ( isalpha(c) == 0 ? false : true);
-}
-
-
-// Checks whether c is a 7-bit unsigned char value 
-// that fits into the ASCII character set.
-inline bool isAscii(int c)
-{
-  return ( isascii (c) == 0 ? false : true);
-}
-
-
-// Checks for a blank character, that is, a space or a tab.
-inline bool isWhitespace(int c)
-{
-  return ( isblank (c) == 0 ? false : true);
-}
-
-
-// Checks for a control character.
-inline bool isControl(int c)
-{
-  return ( iscntrl (c) == 0 ? false : true);
-}
-
-
-// Checks for a digit (0 through 9).
-inline bool isDigit(int c)
-{
-  return ( isdigit (c) == 0 ? false : true);
-}
-
-
-// Checks for any printable character except space.
-inline bool isGraph(int c)
-{
-  return ( isgraph (c) == 0 ? false : true);
-}
-
-
-// Checks for a lower-case character.
-inline bool isLowerCase(int c)
-{
-  return (islower (c) == 0 ? false : true);
-}
-
-
-// Checks for any printable character including space.
-inline bool isPrintable(int c)
-{
-  return ( isprint (c) == 0 ? false : true);
-}
-
-
-// Checks for any printable character which is not a space 
-// or an alphanumeric character.
-inline bool isPunct(int c)
-{
-  return ( ispunct (c) == 0 ? false : true);
-}
-
-
-// Checks for white-space characters. For the avr-libc library, 
-// these are: space, formfeed ('\f'), newline ('\n'), carriage 
-// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v').
-inline bool isSpace(int c)
-{
-  return ( isspace (c) == 0 ? false : true);
-}
-
-
-// Checks for an uppercase letter.
-inline bool isUpperCase(int c)
-{
-  return ( isupper (c) == 0 ? false : true);
-}
-
-
-// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7 
-// 8 9 a b c d e f A B C D E F.
-inline bool isHexadecimalDigit(int c)
-{
-  return ( isxdigit (c) == 0 ? false : true);
-}
-
-
-// Converts c to a 7-bit unsigned char value that fits into the 
-// ASCII character set, by clearing the high-order bits.
-inline int toAscii(int c)
-{
-  return toascii (c);
-}
-
-
-// Warning:
-// Many people will be unhappy if you use this function. 
-// This function will convert accented letters into random 
-// characters.
-
-// Converts the letter c to lower case, if possible.
-inline int toLowerCase(int c)
-{
-  return tolower (c);
-}
-
-
-// Converts the letter c to upper case, if possible.
-inline int toUpperCase(int c)
-{
-  return toupper (c);
-}
-
-}
-#endif
+#pragma once
+#include "../../../ArduinoCore-API/api/WCharacter.h"
@@ -1,37 +1 @@
-/*
-  dtostrf - Emulation for dtostrf function from avr-libc
-  Copyright (c) 2016 Arduino LLC.  All rights reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-// This is a default implementation for dtostrf function.
-// This file should be used if the standard lib doesn't provide an
-// implementation of dtostrf.
-
-// Create a file called "dtostrf.c" with the following include:
-// #include "api/deprecated-avr-comp/avr/dtostrf.c.impl"
-
-#include <stdio.h>
-
-char *dtostrf (double val, signed char width, unsigned char prec, char *sout) {
-  asm(".global _printf_float");
-
-  char fmt[20];
-  sprintf(fmt, "%%%d.%df", width, prec);
-  sprintf(sout, fmt, val);
-  return sout;
-}
-
+#include "../../../../../ArduinoCore-API/api/deprecated-avr-comp/avr/dtostrf.c.impl"
@@ -1,34 +1,2 @@
-/*
-  dtostrf - Emulation for dtostrf function from avr-libc
-  Copyright (c) 2015 Arduino LLC.  All rights reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
 #pragma once
-
-#if !defined(ARDUINO_ARCH_AVR)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-char *dtostrf(double val, signed char width, unsigned char prec, char *sout);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+#include "../../../../../ArduinoCore-API/api/deprecated-avr-comp/avr/dtostrf.h"
@@ -1,23 +1,2 @@
-/*
-  Copyright (c) 2015 Arduino LCC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-*/
-
-/*
-  Empty file.
-  This file is here to allow compatibility with sketches (made for AVR)
-  that includes <AVR/interrupt.h>
-*/
+#pragma once
+#include "../../../../../ArduinoCore-API/api/deprecated-avr-comp/avr/interrupt.h"
@@ -1,158 +1,2 @@
-/*
-  pgmspace.h - Definitions for compatibility with AVR pgmspace macros
-
-  Copyright (c) 2015 Arduino LLC
-
-  Based on work of Paul Stoffregen on Teensy 3 (http://pjrc.com)
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE
-*/
-
-#ifndef __PGMSPACE_H_
-#define __PGMSPACE_H_ 1
-
-#include <inttypes.h>
-
-#define PROGMEM
-#define PGM_P  const char *
-#define PSTR(str) (str)
-
-#define _SFR_BYTE(n) (n)
-
-typedef void prog_void;
-typedef char prog_char;
-typedef unsigned char prog_uchar;
-typedef int8_t prog_int8_t;
-typedef uint8_t prog_uint8_t;
-typedef int16_t prog_int16_t;
-typedef uint16_t prog_uint16_t;
-typedef int32_t prog_int32_t;
-typedef uint32_t prog_uint32_t;
-typedef int64_t prog_int64_t;
-typedef uint64_t prog_uint64_t;
-
-typedef const void* int_farptr_t;
-typedef const void* uint_farptr_t;
-
-#define memchr_P(s, c, n) memchr((s), (c), (n))
-#define memcmp_P(s1, s2, n) memcmp((s1), (s2), (n))
-#define memccpy_P(dest, src, c, n) memccpy((dest), (src), (c), (n))
-#define memcpy_P(dest, src, n) memcpy((dest), (src), (n))
-#define memmem_P(haystack, haystacklen, needle, needlelen) memmem((haystack), (haystacklen), (needle), (needlelen))
-#define memrchr_P(s, c, n) memrchr((s), (c), (n))
-#define strcat_P(dest, src) strcat((dest), (src))
-#define strchr_P(s, c) strchr((s), (c))
-#define strchrnul_P(s, c) strchrnul((s), (c))
-#define strcmp_P(a, b) strcmp((a), (b))
-#define strcpy_P(dest, src) strcpy((dest), (src))
-#define strcasecmp_P(s1, s2) strcasecmp((s1), (s2))
-#define strcasestr_P(haystack, needle) strcasestr((haystack), (needle))
-#define strcspn_P(s, accept) strcspn((s), (accept))
-#define strlcat_P(s1, s2, n) strlcat((s1), (s2), (n))
-#define strlcpy_P(s1, s2, n) strlcpy((s1), (s2), (n))
-#define strlen_P(a) strlen((a))
-#define strnlen_P(s, n) strnlen((s), (n))
-#define strncmp_P(s1, s2, n) strncmp((s1), (s2), (n))
-#define strncasecmp_P(s1, s2, n) strncasecmp((s1), (s2), (n))
-#define strncat_P(s1, s2, n) strncat((s1), (s2), (n))
-#define strncpy_P(s1, s2, n) strncpy((s1), (s2), (n))
-#define strpbrk_P(s, accept) strpbrk((s), (accept))
-#define strrchr_P(s, c) strrchr((s), (c))
-#define strsep_P(sp, delim) strsep((sp), (delim))
-#define strspn_P(s, accept) strspn((s), (accept))
-#define strstr_P(a, b) strstr((a), (b))
-#define strtok_P(s, delim) strtok((s), (delim))
-#define strtok_rP(s, delim, last) strtok((s), (delim), (last))
-
-#define strlen_PF(a) strlen((a))
-#define strnlen_PF(src, len) strnlen((src), (len))
-#define memcpy_PF(dest, src, len) memcpy((dest), (src), (len))
-#define strcpy_PF(dest, src) strcpy((dest), (src))
-#define strncpy_PF(dest, src, len) strncpy((dest), (src), (len))
-#define strcat_PF(dest, src) strcat((dest), (src))
-#define strlcat_PF(dest, src, len) strlcat((dest), (src), (len))
-#define strncat_PF(dest, src, len) strncat((dest), (src), (len))
-#define strcmp_PF(s1, s2) strcmp((s1), (s2))
-#define strncmp_PF(s1, s2, n) strncmp((s1), (s2), (n))
-#define strcasecmp_PF(s1, s2) strcasecmp((s1), (s2))
-#define strncasecmp_PF(s1, s2, n) strncasecmp((s1), (s2), (n))
-#define strstr_PF(s1, s2) strstr((s1), (s2))
-#define strlcpy_PF(dest, src, n) strlcpy((dest), (src), (n))
-#define memcmp_PF(s1, s2, n) memcmp((s1), (s2), (n))
-
-#define sprintf_P(s, f, ...) sprintf((s), (f), __VA_ARGS__)
-#define snprintf_P(s, f, ...) snprintf((s), (f), __VA_ARGS__)
-#define vsprintf_P(s, f, ...) vsprintf((s), (f), __VA_ARGS__)
-#define vsnprintf_P(s, f, ...) vsnprintf((s), (f), __VA_ARGS__)
-
-#if 0
-// Requires natural aligned addresses
-#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
-#define pgm_read_word(addr) (*(const unsigned short *)(addr))
-#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
-#define pgm_read_float(addr) (*(const float *)(addr))
-#define pgm_read_ptr(addr) (*(void *const *)(addr))
-#else
-// Supports misaligned addresses
-#ifdef __cplusplus
-extern "C"{
-#endif
-static inline unsigned char pgm_read_byte(const void *addr) {
-    return *(const unsigned char *)(addr);
-}
-static inline unsigned short pgm_read_word(const void *addr) {
-    const unsigned char *a = (const unsigned char *)addr;
-    return pgm_read_byte(a) | ( pgm_read_byte(a + 1) << 8 );
-}
-static inline unsigned long pgm_read_dword(const void *addr) {
-    const unsigned char *a = (const unsigned char *)addr;
-    return pgm_read_byte(a) | ( pgm_read_byte(a + 1) << 8 ) | ( pgm_read_byte(a + 2) << 16 ) | ( pgm_read_byte(a + 3) << 24 );
-}
-static inline void *pgm_read_ptr(const void *addr) {
-    return (void*) pgm_read_dword(addr);
-}
-static inline float pgm_read_float(const void *addr) {
-    union {
-        void *p;
-        float f;
-    } x;
-    x.p = pgm_read_ptr(addr);
-    return x.f;
-}
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#define pgm_read_byte_near(addr) pgm_read_byte(addr)
-#define pgm_read_word_near(addr) pgm_read_word(addr)
-#define pgm_read_dword_near(addr) pgm_read_dword(addr)
-#define pgm_read_float_near(addr) pgm_read_float(addr)
-#define pgm_read_ptr_near(addr) pgm_read_ptr(addr)
-
-#define pgm_read_byte_far(addr) pgm_read_byte(addr)
-#define pgm_read_word_far(addr) pgm_read_word(addr)
-#define pgm_read_dword_far(addr) pgm_read_dword(addr)
-#define pgm_read_float_far(addr) pgm_read_float(addr)
-#define pgm_read_ptr_far(addr) pgm_read_ptr(addr)
-
-#define pgm_get_far_address(addr) (&(addr))
-
-#endif
+#pragma once
+#include "../../../../../ArduinoCore-API/api/deprecated-avr-comp/avr/pgmspace.h"
@@ -1,37 +1,2 @@
-/*
-  Copyright (c) 2016 Arduino LLC.  All right reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is 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
-
-// Standard C functions required in Arduino API
-// If these functions are not provided by the standard library, the
-// core should supply an implementation of them.
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern char* itoa(int value, char *string, int radix);
-extern char* ltoa(long value, char *string, int radix);
-extern char* utoa(unsigned value, char *string, int radix);
-extern char* ultoa(unsigned long value, char *string, int radix);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
+#include "../../../ArduinoCore-API/api/itoa.h"
@@ -25,6 +25,8 @@
 #include <pico/mutex.h>
 #include <sys/lock.h>

+#include "_freertos.h"
+
 // HACK ALERT
 // Pico-SDK defines mutex which can be at global scope, but when the auto_init_
 // macros are used they are defined as static.  Newlib needs global access to
@@ -42,12 +44,75 @@ auto_init_mutex(__lock___dd_hash_mutex);
 auto_init_mutex(__lock___arc4random_mutex);
 #undef static

+// FreeRTOS hack - Allow Newlib to use FreeRTOS mutexes which preserve TASKID which
+// is needed to support multithread
+
+SemaphoreHandle_t __lock___sinit_recursive_mutex_freertos;
+SemaphoreHandle_t __lock___sfp_recursive_mutex_freertos;
+SemaphoreHandle_t __lock___atexit_recursive_mutex_freertos;
+SemaphoreHandle_t __lock___at_quick_exit_mutex_freertos;
+SemaphoreHandle_t __lock___malloc_recursive_mutex_freertos;
+SemaphoreHandle_t __lock___env_recursive_mutex_freertos;
+SemaphoreHandle_t __lock___tz_mutex_freertos;
+SemaphoreHandle_t __lock___dd_hash_mutex_freertos;
+SemaphoreHandle_t __lock___arc4random_mutex_freertos;
+
+void __initFreeRTOSMutexes() {
+    __lock___sinit_recursive_mutex_freertos = _freertos_recursive_mutex_create();
+    __lock___sfp_recursive_mutex_freertos = _freertos_recursive_mutex_create();
+    __lock___atexit_recursive_mutex_freertos = _freertos_recursive_mutex_create();
+    __lock___at_quick_exit_mutex_freertos = __freertos_mutex_create();
+    __lock___malloc_recursive_mutex_freertos = _freertos_recursive_mutex_create();
+    __lock___env_recursive_mutex_freertos = _freertos_recursive_mutex_create();
+    __lock___tz_mutex_freertos = __freertos_mutex_create();
+    __lock___dd_hash_mutex_freertos = __freertos_mutex_create();
+    __lock___arc4random_mutex_freertos = __freertos_mutex_create();
+}
+
+static SemaphoreHandle_t __getFreeRTOSMutex(_LOCK_T lock) {
+    mutex_t *l = (mutex_t *)lock;
+    if (l == &__lock___at_quick_exit_mutex) {
+        return __lock___at_quick_exit_mutex_freertos;
+    } else if (l == &__lock___tz_mutex) {
+        return __lock___tz_mutex_freertos;
+    } else if (l == &__lock___dd_hash_mutex) {
+        return __lock___dd_hash_mutex_freertos;
+    } else if (l == &__lock___arc4random_mutex) {
+        return __lock___arc4random_mutex_freertos;
+    }
+    return nullptr;
+}
+
+static SemaphoreHandle_t __getFreeRTOSRecursiveMutex(_LOCK_T lock) {
+    recursive_mutex_t *l = (recursive_mutex_t *)lock;
+    if (l  == &__lock___sinit_recursive_mutex) {
+        return __lock___sinit_recursive_mutex_freertos;
+    } else if (l == &__lock___sfp_recursive_mutex) {
+        return __lock___sfp_recursive_mutex_freertos;
+    } else if (l == &__lock___atexit_recursive_mutex) {
+        return __lock___atexit_recursive_mutex_freertos;
+    } else if (l == &__lock___malloc_recursive_mutex) {
+        return __lock___malloc_recursive_mutex_freertos;
+    } else if (l == &__lock___env_recursive_mutex) {
+        return __lock___env_recursive_mutex_freertos;
+    }
+    return nullptr;
+}
+
 void __retarget_lock_init(_LOCK_T *lock) {
-    mutex_init((mutex_t*) lock);
+    if (__freeRTOSinitted) {
+        /* Already done in initFreeRTOSMutexes() */
+    } else {
+        mutex_init((mutex_t*) lock);
+    }
 }

 void __retarget_lock_init_recursive(_LOCK_T *lock) {
-    recursive_mutex_init((recursive_mutex_t*) lock);
+    if (__freeRTOSinitted) {
+        /* Already done in initFreeRTOSMutexes() */
+    } else {
+        recursive_mutex_init((recursive_mutex_t*) lock);
+    }
 }

 void __retarget_lock_close(_LOCK_T lock) {
@@ -59,25 +124,59 @@ void __retarget_lock_close_recursive(_LOCK_T lock) {
 }

 void __retarget_lock_acquire(_LOCK_T lock) {
-    mutex_enter_blocking((mutex_t*)lock);
+    if (__freeRTOSinitted) {
+        auto mtx = __getFreeRTOSMutex(lock);
+        __freertos_mutex_take(mtx);
+    } else {
+        mutex_enter_blocking((mutex_t*)lock);
+    }
 }

 void __retarget_lock_acquire_recursive(_LOCK_T lock) {
-    recursive_mutex_enter_blocking((recursive_mutex_t*)lock);
+    if (__freeRTOSinitted) {
+        auto mtx = __getFreeRTOSRecursiveMutex(lock);
+        __freertos_recursive_mutex_take(mtx);
+    } else {
+        recursive_mutex_enter_blocking((recursive_mutex_t*)lock);
+    }
 }

 int __retarget_lock_try_acquire(_LOCK_T lock) {
-    return mutex_try_enter((mutex_t *)lock, NULL);
+    int ret;
+    if (__freeRTOSinitted) {
+        auto mtx = __getFreeRTOSMutex(lock);
+        ret = __freertos_mutex_try_take(mtx);
+    } else {
+        ret = mutex_try_enter((mutex_t *)lock, nullptr);
+    }
+    return ret;
 }

 int __retarget_lock_try_acquire_recursive(_LOCK_T lock) {
-    return recursive_mutex_try_enter((recursive_mutex_t*)lock, NULL);
+    int ret;
+    if (__freeRTOSinitted) {
+        auto mtx = __getFreeRTOSRecursiveMutex(lock);
+        ret = __freertos_recursive_mutex_try_take(mtx);
+    } else {
+        ret = recursive_mutex_try_enter((recursive_mutex_t*)lock, nullptr);
+    }
+    return ret;
 }

 void __retarget_lock_release(_LOCK_T lock) {
-    mutex_exit((mutex_t*)lock);
+    if (__freeRTOSinitted) {
+        auto mtx = __getFreeRTOSMutex(lock);
+        __freertos_mutex_give(mtx);
+    } else {
+        mutex_exit((mutex_t*)lock);
+    }
 }

 void __retarget_lock_release_recursive(_LOCK_T lock) {
-    recursive_mutex_exit((recursive_mutex_t*)lock);
+    if (__freeRTOSinitted) {
+        auto mtx = __getFreeRTOSRecursiveMutex(lock);
+        __freertos_recursive_mutex_give(mtx);
+    } else {
+        recursive_mutex_exit((recursive_mutex_t*)lock);
+    }
 }
@@ -0,0 +1,326 @@
+/*
+    LWIP wrappers to protect against timer-based re-entrancy
+
+    Copyright (c) 202s Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "pico/mutex.h"
+#include "lwip/pbuf.h"
+#include "lwip/udp.h"
+#include "lwip/tcp.h"
+#include "lwip/dns.h"
+#include "lwip/raw.h"
+#include "lwip/timeouts.h"
+
+// Global indicator that we're inside an LWIP block
+extern "C" {
+    volatile bool __inLWIP = false;
+}
+
+auto_init_recursive_mutex(__mtxLWIP);
+
+class LWIPMutex {
+public:
+    LWIPMutex() {
+        noInterrupts();
+        recursive_mutex_enter_blocking(&__mtxLWIP);
+        __inLWIP = true;
+        _ref++;
+        interrupts();
+    }
+
+    ~LWIPMutex() {
+        noInterrupts();
+        if (0 == --_ref) {
+            __inLWIP = false;
+        }
+        recursive_mutex_exit(&__mtxLWIP);
+        interrupts();
+    }
+
+private:
+    static int _ref;
+};
+int LWIPMutex::_ref = 0;
+
+
+extern "C" {
+
+    extern u8_t __real_pbuf_header(struct pbuf *p, s16_t header_size);
+    u8_t __wrap_pbuf_header(struct pbuf *p, s16_t header_size) {
+        LWIPMutex m;
+        return __real_pbuf_header(p, header_size);
+    }
+
+    extern u8_t __real_pbuf_free(struct pbuf *p);
+    u8_t __wrap_pbuf_free(struct pbuf *p) {
+        LWIPMutex m;
+        return __real_pbuf_free(p);
+    }
+
+    extern struct pbuf *__real_pbuf_alloc(pbuf_layer l, u16_t length, pbuf_type type);
+    struct pbuf *__wrap_pbuf_alloc(pbuf_layer l, u16_t length, pbuf_type type) {
+        LWIPMutex m;
+        return __real_pbuf_alloc(l, length, type);
+    }
+
+    extern err_t __real_pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len);
+    err_t __wrap_pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len) {
+        LWIPMutex m;
+        return __real_pbuf_take(buf, dataptr, len);
+    }
+
+    extern u16_t __real_pbuf_copy_partial(const struct pbuf *p, void *dataptr, u16_t len, u16_t offset);
+    u16_t __wrap_pbuf_copy_partial(const struct pbuf *p, void *dataptr, u16_t len, u16_t offset) {
+        LWIPMutex m;
+        return __real_pbuf_copy_partial(p, dataptr, len, offset);
+    }
+
+    extern void __real_pbuf_ref(struct pbuf *p);
+    void __wrap_pbuf_ref(struct pbuf *p) {
+        LWIPMutex m;
+        __real_pbuf_ref(p);
+    }
+
+    extern u8_t __real_pbuf_get_at(const struct pbuf* p, u16_t offset);
+    u8_t __wrap_pbuf_get_at(const struct pbuf* p, u16_t offset) {
+        LWIPMutex m;
+        return __real_pbuf_get_at(p, offset);
+    }
+
+    extern void *__real_pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset);
+    void *__wrap_pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset) {
+        LWIPMutex m;
+        return __real_pbuf_get_contiguous(p, buffer, bufsize, len, offset);
+    }
+
+    extern void __real_pbuf_cat(struct pbuf *head, struct pbuf *tail);
+    void __wrap_pbuf_cat(struct pbuf *head, struct pbuf *tail) {
+        LWIPMutex m;
+        __real_pbuf_cat(head, tail);
+    }
+
+    extern void __real_tcp_arg(struct tcp_pcb *pcb, void *arg);
+    void __wrap_tcp_arg(struct tcp_pcb *pcb, void *arg) {
+        LWIPMutex m;
+        __real_tcp_arg(pcb, arg);
+    }
+
+    extern struct tcp_pcb *__real_tcp_new(void);
+    struct tcp_pcb *__wrap_tcp_new(void) {
+        LWIPMutex m;
+        return __real_tcp_new();
+    }
+
+    extern err_t __real_tcp_bind(struct tcp_pcb *pcb, ip_addr_t *ipaddr, u16_t port);
+    err_t __wrap_tcp_bind(struct tcp_pcb *pcb, ip_addr_t *ipaddr, u16_t port) {
+        LWIPMutex m;
+        return __real_tcp_bind(pcb, ipaddr, port);
+    }
+
+    extern struct tcp_pcb *__real_tcp_listen(struct tcp_pcb *pcb);
+    struct tcp_pcb *__wrap_tcp_listen(struct tcp_pcb *pcb) {
+        LWIPMutex m;
+        return __real_tcp_listen(pcb);
+    }
+
+    extern struct tcp_pcb *__real_tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog);
+    struct tcp_pcb *__wrap_tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog) {
+        LWIPMutex m;
+        return __real_tcp_listen_with_backlog(pcb, backlog);
+    }
+
+    extern void __real_tcp_accept(struct tcp_pcb *pcb, err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err));
+    void __wrap_tcp_accept(struct tcp_pcb *pcb, err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err)) {
+        LWIPMutex m;
+        __real_tcp_accept(pcb, accept);
+    }
+
+    extern err_t __real_tcp_connect(struct tcp_pcb *pcb, ip_addr_t *ipaddr, u16_t port, err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err));
+    err_t __wrap_tcp_connect(struct tcp_pcb *pcb, ip_addr_t *ipaddr, u16_t port, err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err)) {
+        LWIPMutex m;
+        return __real_tcp_connect(pcb, ipaddr, port, connected);
+    }
+
+    extern err_t __real_tcp_write(struct tcp_pcb *pcb, const void *dataptr, u16_t len, u8_t apiflags);
+    err_t __wrap_tcp_write(struct tcp_pcb *pcb, const void *dataptr, u16_t len, u8_t apiflags) {
+        LWIPMutex m;
+        return __real_tcp_write(pcb, dataptr, len, apiflags);
+    }
+
+    extern void __real_tcp_sent(struct tcp_pcb *pcb, err_t (* sent)(void *arg, struct tcp_pcb *tpcb, u16_t len));
+    void __wrap_tcp_sent(struct tcp_pcb *pcb, err_t (* sent)(void *arg, struct tcp_pcb *tpcb, u16_t len)) {
+        LWIPMutex m;
+        __real_tcp_sent(pcb, sent);
+    }
+
+    extern void __real_tcp_recv(struct tcp_pcb *pcb, err_t (* recv)(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err));
+    void __wrap_tcp_recv(struct tcp_pcb *pcb, err_t (* recv)(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)) {
+        LWIPMutex m;
+        __real_tcp_recv(pcb, recv);
+    }
+
+    extern void __real_tcp_recved(struct tcp_pcb *pcb, u16_t len);
+    void __wrap_tcp_recved(struct tcp_pcb *pcb, u16_t len) {
+        LWIPMutex m;
+        __real_tcp_recved(pcb, len);
+    }
+
+    extern void __real_tcp_poll(struct tcp_pcb *pcb, err_t (* poll)(void *arg, struct tcp_pcb *tpcb), u8_t interval);
+    void __wrap_tcp_poll(struct tcp_pcb *pcb, err_t (* poll)(void *arg, struct tcp_pcb *tpcb), u8_t interval) {
+        LWIPMutex m;
+        __real_tcp_poll(pcb, poll, interval);
+    }
+
+    extern err_t __real_tcp_close(struct tcp_pcb *pcb);
+    err_t __wrap_tcp_close(struct tcp_pcb *pcb) {
+        LWIPMutex m;
+        return __real_tcp_close(pcb);
+    }
+
+    extern void __real_tcp_abort(struct tcp_pcb *pcb);
+    void __wrap_tcp_abort(struct tcp_pcb *pcb) {
+        LWIPMutex m;
+        __real_tcp_abort(pcb);
+    }
+
+    extern void __real_tcp_err(struct tcp_pcb *pcb, void (* err)(void *arg, err_t err));
+    void __wrap_tcp_err(struct tcp_pcb *pcb, void (* err)(void *arg, err_t err)) {
+        LWIPMutex m;
+        __real_tcp_err(pcb, err);
+    }
+
+    extern err_t __real_tcp_output(struct tcp_pcb *pcb);
+    err_t __wrap_tcp_output(struct tcp_pcb *pcb) {
+        LWIPMutex m;
+        return __real_tcp_output(pcb);
+    }
+
+    extern void __real_tcp_setprio(struct tcp_pcb *pcb, u8_t prio);
+    void __wrap_tcp_setprio(struct tcp_pcb *pcb, u8_t prio) {
+        LWIPMutex m;
+        return __real_tcp_setprio(pcb, prio);
+    }
+
+    extern void __real_tcp_backlog_delayed(struct tcp_pcb* pcb);
+    void __wrap_tcp_backlog_delayed(struct tcp_pcb* pcb) {
+        LWIPMutex m;
+        return __real_tcp_backlog_delayed(pcb);
+    }
+
+    extern void __real_tcp_backlog_accepted(struct tcp_pcb* pcb);
+    void __wrap_tcp_backlog_accepted(struct tcp_pcb* pcb) {
+        LWIPMutex m;
+        return __real_tcp_backlog_accepted(pcb);
+    }
+    extern struct udp_pcb *__real_udp_new(void);
+    struct udp_pcb *__wrap_udp_new(void) {
+        LWIPMutex m;
+        return __real_udp_new();
+    }
+
+    extern void __real_udp_remove(struct udp_pcb *pcb);
+    void __wrap_udp_remove(struct udp_pcb *pcb) {
+        LWIPMutex m;
+        __real_udp_remove(pcb);
+    }
+
+    extern err_t __real_udp_bind(struct udp_pcb *pcb, ip_addr_t *ipaddr, u16_t port);
+    err_t __wrap_udp_bind(struct udp_pcb *pcb, ip_addr_t *ipaddr, u16_t port) {
+        LWIPMutex m;
+        return __real_udp_bind(pcb, ipaddr, port);
+    }
+
+    extern err_t __real_udp_connect(struct udp_pcb *pcb, ip_addr_t *ipaddr, u16_t port);
+    err_t __wrap_udp_connect(struct udp_pcb *pcb, ip_addr_t *ipaddr, u16_t port) {
+        LWIPMutex m;
+        return __real_udp_connect(pcb, ipaddr, port);
+    }
+
+    extern err_t __real_udp_disconnect(struct udp_pcb *pcb);
+    err_t __wrap_udp_disconnect(struct udp_pcb *pcb) {
+        LWIPMutex m;
+        return __real_udp_disconnect(pcb);
+    }
+
+    extern err_t __real_udp_send(struct udp_pcb *pcb, struct pbuf *p);
+    err_t __wrap_udp_send(struct udp_pcb *pcb, struct pbuf *p) {
+        LWIPMutex m;
+        return __real_udp_send(pcb, p);
+    }
+
+    extern void __real_udp_recv(struct udp_pcb *pcb, void (* recv)(void *arg, struct udp_pcb *upcb, struct pbuf *p, ip_addr_t *addr, u16_t port), void *recv_arg);
+    void __wrap_udp_recv(struct udp_pcb *pcb, void (* recv)(void *arg, struct udp_pcb *upcb, struct pbuf *p, ip_addr_t *addr, u16_t port), void *recv_arg) {
+        LWIPMutex m;
+        __real_udp_recv(pcb, recv, recv_arg);
+    }
+
+    extern err_t __real_udp_sendto_if(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif);
+    err_t __wrap_udp_sendto_if(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif) {
+        LWIPMutex m;
+        return __real_udp_sendto_if(pcb, p, dst_ip, dst_port, netif);
+    }
+
+    extern void __real_sys_check_timeouts(void);
+    void __wrap_sys_check_timeouts(void) {
+        LWIPMutex m;
+        __real_sys_check_timeouts();
+    }
+
+    extern err_t __real_dns_gethostbyname(const char *hostname, ip_addr_t *addr, dns_found_callback found, void *callback_arg);
+    err_t __wrap_dns_gethostbyname(const char *hostname, ip_addr_t *addr, dns_found_callback found, void *callback_arg) {
+        LWIPMutex m;
+        return __real_dns_gethostbyname(hostname, addr, found, callback_arg);
+    }
+
+    extern err_t __real_dns_gethostbyname_addrtype(const char *hostname, ip_addr_t *addr, dns_found_callback found, void *callback_arg, u8_t dns_addrtype);
+    err_t __wrap_dns_gethostbyname_addrtype(const char *hostname, ip_addr_t *addr, dns_found_callback found, void *callback_arg, u8_t dns_addrtype) {
+        LWIPMutex m;
+        return __real_dns_gethostbyname_addrtype(hostname, addr, found, callback_arg, dns_addrtype);
+    }
+
+    extern struct raw_pcb *__real_raw_new(u8_t proto);
+    struct raw_pcb *__wrap_raw_new(u8_t proto) {
+        LWIPMutex m;
+        return __real_raw_new(proto);
+    }
+
+    extern void __real_raw_recv(struct raw_pcb *pcb, raw_recv_fn recv, void *recv_arg);
+    void __wrap_raw_recv(struct raw_pcb *pcb, raw_recv_fn recv, void *recv_arg) {
+        LWIPMutex m;
+        __real_raw_recv(pcb, recv, recv_arg);
+    }
+
+    extern err_t __real_raw_bind(struct raw_pcb *pcb, const ip_addr_t *ipaddr);
+    err_t __wrap_raw_bind(struct raw_pcb *pcb, const ip_addr_t *ipaddr) {
+        LWIPMutex m;
+        return __real_raw_bind(pcb, ipaddr);
+    }
+
+    extern err_t __real_raw_sendto(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *ipaddr);
+    err_t __wrap_raw_sendto(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *ipaddr) {
+        LWIPMutex m;
+        return __real_raw_sendto(pcb, p, ipaddr);
+    }
+
+    extern void __real_raw_remove(struct raw_pcb *pcb);
+    void __wrap_raw_remove(struct raw_pcb *pcb) {
+        LWIPMutex m;
+        __real_raw_remove(pcb);
+    }
+
+}; // extern "C"
@@ -22,7 +22,6 @@
 #include "RP2040USB.h"
 #include <pico/stdlib.h>
 #include <pico/multicore.h>
-#include "LWIPMutex.h"
 #include <reent.h>

 RP2040 rp2040;
@@ -33,8 +32,6 @@ extern "C" {

 mutex_t _pioMutex;

-int LWIPMutex::_ref = 0;
-
 extern void setup();
 extern void loop();

@@ -42,6 +39,8 @@ extern void loop();
 extern void initFreeRTOS() __attribute__((weak));
 extern void startFreeRTOS() __attribute__((weak));
 bool __isFreeRTOS;
+volatile bool __freeRTOSinitted;
+

 // Weak empty variant initialization. May be redefined by variant files.
 void initVariant() __attribute__((weak));
@@ -166,8 +165,6 @@ extern "C" void __register_impure_ptr(struct _reent *p) {
    }
 }

-
-// TODO:  FreeRTOS should implement this based on thread ID (and each thread should have its own struct _reent
 extern "C" struct _reent *__wrap___getreent() {
    if (get_core_num() == 0) {
        return _impure_ptr;
@@ -0,0 +1,53 @@
+/*
+    Malloc/etc. interrupt locking wrappers
+
+    Copyright (c) 2022 Earle F. Philhower, III <earlephilhower@yahoo.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <Arduino.h>
+
+extern "C" void *__real_malloc(size_t size);
+extern "C" void *__real_calloc(size_t count, size_t size);
+extern "C" void *__real_realloc(void *mem, size_t size);
+extern "C" void __real_free(void *mem);
+
+extern "C" void *__wrap_malloc(size_t size) {
+    noInterrupts();
+    void *rc = __real_malloc(size);
+    interrupts();
+    return rc;
+}
+
+extern "C" void *__wrap_calloc(size_t count, size_t size) {
+    noInterrupts();
+    void *rc = __real_calloc(count, size);
+    interrupts();
+    return rc;
+}
+
+extern "C" void *__wrap_realloc(void *mem, size_t size) {
+    noInterrupts();
+    void *rc = __real_realloc(mem, size);
+    interrupts();
+    return rc;
+}
+
+extern "C" void __wrap_free(void *mem) {
+    noInterrupts();
+    __real_free(mem);
+    interrupts();
+}
@@ -90,8 +90,8 @@ extern "C" int _gettimeofday(struct timeval *tv, void *tz) {
    (void) tz;
    uint64_t now_us = to_us_since_boot(get_absolute_time()) + __timedelta_us;
    if (tv) {
-        tv->tv_sec = now_us / 1000000L;
-        tv->tv_usec = now_us % 1000000L;
+        tv->tv_sec = now_us / 1'000'000L;
+        tv->tv_usec = now_us % 1'000'000L;
    }
    return 0;
 }
@@ -101,7 +101,7 @@ extern "C" int settimeofday(const struct timeval *tv, const struct timezone *tz)
    uint64_t now_us = to_us_since_boot(get_absolute_time());
    if (tv) {
        uint64_t newnow_us;
-        newnow_us = tv->tv_sec * 1000000L;
+        newnow_us = tv->tv_sec * 1'000'000L;
        newnow_us += tv->tv_usec;
        __timedelta_us = newnow_us - now_us;
    }
@@ -111,7 +111,7 @@ extern "C" int settimeofday(const struct timeval *tv, const struct timezone *tz)
 // For NTP
 extern "C" void __setSystemTime(unsigned long long sec, unsigned long usec) {
    uint64_t now_us = to_us_since_boot(get_absolute_time());
-    uint64_t newnow_us = sec * 1000000LL + usec;
+    uint64_t newnow_us = sec * 1'000'000LL + usec;
    __timedelta_us = newnow_us - now_us;
 }

@@ -36,7 +36,7 @@
 #define CYW43_WL_GPIO_LED_PIN 0
 #endif

-volatile bool __inLWIP = false;
+extern volatile bool __inLWIP;

 // note same code
 #if PICO_CYW43_ARCH_THREADSAFE_BACKGROUND
@@ -145,7 +145,7 @@ static void gpio_irq_handler(void) {
 static void low_priority_irq_handler(void) {
    assert(cyw43_core_num == get_core_num());
    if (recursive_mutex_try_enter(&cyw43_mutex, NULL)) {
-        if (recursive_mutex_enter_count(&cyw43_mutex) != 1) {
+        if (__inLWIP || (recursive_mutex_enter_count(&cyw43_mutex) != 1)) {
            low_priority_irq_missed = true;
            CYW43_STAT_INC(PENDSV_DISABLED_COUNT);
        } else {
@@ -0,0 +1,90 @@
+/*
+    Copyright (c) 2021 Raspberry Pi (Trading) Ltd.
+
+    Hacked by EFP3 to allow disabling unless requested
+
+    SPDX-License-Identifier: BSD-3-Clause
+*/
+
+#include "pico.h"
+#include "pico/time.h"
+#include "pico/bootrom.h"
+#include "pico/binary_info.h"
+
+// PICO_CONFIG: PICO_BOOTSEL_VIA_DOUBLE_RESET_TIMEOUT_MS, Window of opportunity for a second press of a reset button to enter BOOTSEL mode (milliseconds), type=int, default=200, group=pico_bootsel_via_double_reset
+#ifndef PICO_BOOTSEL_VIA_DOUBLE_RESET_TIMEOUT_MS
+#define PICO_BOOTSEL_VIA_DOUBLE_RESET_TIMEOUT_MS 350
+#endif
+
+// PICO_CONFIG: PICO_BOOTSEL_VIA_DOUBLE_RESET_ACTIVITY_LED, Optionally define a pin to use as bootloader activity LED when BOOTSEL mode is entered via reset double tap, type=int, min=0, max=29, group=pico_bootsel_via_double_reset
+
+// PICO_CONFIG: PICO_BOOTSEL_VIA_DOUBLE_RESET_INTERFACE_DISABLE_MASK, Optionally disable either the mass storage interface (bit 0) or the PICOBOOT interface (bit 1) when entering BOOTSEL mode via double reset, type=int, min=0, max=3, default=0, group=pico_bootsel_via_double_reset
+#ifndef PICO_BOOTSEL_VIA_DOUBLE_RESET_INTERFACE_DISABLE_MASK
+#define PICO_BOOTSEL_VIA_DOUBLE_RESET_INTERFACE_DISABLE_MASK 0u
+#endif
+
+/** \defgroup pico_bootsel_via_double_reset pico_bootsel_via_double_reset
+
+    When the 'pico_bootsel_via_double_reset' library is linked, a function is
+    injected before main() which will detect when the system has been reset
+    twice in quick succession, and enter the USB ROM bootloader (BOOTSEL mode)
+    when this happens. This allows a double tap of a reset button on a
+    development board to be used to enter the ROM bootloader, provided this
+    library is always linked.
+*/
+
+#if !PICO_NO_BI_BOOTSEL_VIA_DOUBLE_RESET
+bi_decl(bi_program_feature("double reset -> BOOTSEL"));
+#endif
+
+// Doesn't make any sense for a RAM only binary
+#if !PICO_NO_FLASH
+static const uint32_t magic_token[] = {
+    0xf01681de, 0xbd729b29, 0xd359be7a,
+};
+
+// Place our marker on the 2nd core's stack...which will not have been touched when this code is executing
+static uint32_t *magic_location = (uint32_t*)0x20040000;
+//static uint32_t __uninitialized_ram(magic_location)[count_of(magic_token)];
+
+/*  Check for double reset and enter BOOTSEL mode if detected
+
+    This function is registered to run automatically before main(). The
+    algorithm is:
+
+     1. Check for magic token in memory; enter BOOTSEL mode if found.
+     2. Initialise that memory with that magic token.
+     3. Do nothing for a short while (few hundred ms).
+     4. Clear the magic token.
+     5. Continue with normal boot.
+
+    Resetting the device twice quickly will interrupt step 3, leaving the token
+    in place so that the second boot will go to the bootloader.
+*/
+
+/*static*/ void __attribute__((constructor)) boot_double_tap_check(void) {
+    for (uint i = 0; i < count_of(magic_token); i++) {
+        if (magic_location[i] != magic_token[i]) {
+            // Arm, wait, then disarm and continue booting
+            for (i = 0; i < count_of(magic_token); i++) {
+                magic_location[i] = magic_token[i];
+            }
+            busy_wait_us(PICO_BOOTSEL_VIA_DOUBLE_RESET_TIMEOUT_MS * 1000);
+            magic_location[0] = 0;
+            return;
+        }
+    }
+    // Detected a double reset, so enter USB bootloader
+    magic_location[0] = 0;
+#ifdef PICO_BOOTSEL_VIA_DOUBLE_RESET_ACTIVITY_LED
+    const uint32_t led_mask = 1u << PICO_BOOTSEL_VIA_DOUBLE_RESET_ACTIVITY_LED;
+#else
+    const uint32_t led_mask = 0u;
+#endif
+    reset_usb_boot(
+        led_mask,
+        PICO_BOOTSEL_VIA_DOUBLE_RESET_INTERFACE_DISABLE_MASK
+    );
+}
+
+#endif
@@ -28,7 +28,7 @@

 static uint32_t analogScale = 255;
 static uint32_t analogFreq = 1000;
-static bool pwmInitted = false;
+static uint32_t pwmInitted = 0;
 static bool adcInitted = false;
 static uint16_t analogWritePseudoScale = 1;
 static uint16_t analogWriteSlowScale = 1;
@@ -42,29 +42,29 @@ extern "C" void analogWriteFreq(uint32_t freq) {
    if (freq < 100) {
        DEBUGCORE("ERROR: analogWriteFreq too low (%d)\n", freq);
        analogFreq = 100;
-    } else if (freq > 1000000) {
+    } else if (freq > 10'000'000) {
        DEBUGCORE("ERROR: analogWriteFreq too high (%d)\n", freq);
-        analogFreq = 1000000;
+        analogFreq = 10'000'000;
    } else {
        analogFreq = freq;
    }
-    pwmInitted = false;
+    pwmInitted = 0;
 }

 extern "C" void analogWriteRange(uint32_t range) {
    if (range == analogScale) {
        return;
    }
-    if ((range >= 15) && (range <= 65535)) {
+    if ((range >= 3) && (range <= 65535)) {
        analogScale = range;
-        pwmInitted = false;
+        pwmInitted = 0;
    } else {
        DEBUGCORE("ERROR: analogWriteRange out of range (%d)\n", range);
    }
 }

 extern "C" void analogWriteResolution(int res) {
-    if ((res >= 4) && (res <= 16)) {
+    if ((res >= 2) && (res <= 16)) {
        analogWriteRange((1 << res) - 1);
    } else {
        DEBUGCORE("ERROR: analogWriteResolution out of range (%d)\n", res);
@@ -78,29 +78,26 @@ extern "C" void analogWrite(pin_size_t pin, int val) {
        DEBUGCORE("ERROR: Illegal analogWrite pin (%d)\n", pin);
        return;
    }
-    if (!pwmInitted) {
+    if (!(pwmInitted & (1 << pin))) {
        // For low frequencies, we need to scale the output max value up to achieve lower periods
        analogWritePseudoScale = 1;
-        while (((clock_get_hz(clk_sys) / (float)(analogScale * analogFreq)) > 255.0) && (analogScale < 32678)) {
+        while (((clock_get_hz(clk_sys) / ((float)analogScale * analogFreq)) > 255.0) && (analogScale < 32678)) {
            analogWritePseudoScale++;
            analogScale *= 2;
            DEBUGCORE("Adjusting analogWrite values PS=%d, scale=%d\n", analogWritePseudoScale, analogScale);
        }
        // For high frequencies, we need to scale the output max value down to actually hit the frequency target
        analogWriteSlowScale = 1;
-        while (((clock_get_hz(clk_sys) / (float)(analogScale * analogFreq)) < 2.0) && (analogScale > 32)) {
+        while (((clock_get_hz(clk_sys) / ((float)analogScale * analogFreq)) < 1.0) && (analogScale >= 6)) {
            analogWriteSlowScale++;
            analogScale /= 2;
            DEBUGCORE("Adjusting analogWrite values SS=%d, scale=%d\n", analogWriteSlowScale, analogScale);
        }
-
        pwm_config c = pwm_get_default_config();
-        pwm_config_set_clkdiv(&c, clock_get_hz(clk_sys) / (float)(analogScale * analogFreq));
-        pwm_config_set_wrap(&c, analogScale);
-        for (int i = 0; i < 30; i++) {
-            pwm_init(pwm_gpio_to_slice_num(i), &c, true);
-        }
-        pwmInitted = true;
+        pwm_config_set_clkdiv(&c, clock_get_hz(clk_sys) / ((float)analogScale * analogFreq));
+        pwm_config_set_wrap(&c, analogScale - 1);
+        pwm_init(pwm_gpio_to_slice_num(pin), &c, true);
+        pwmInitted |= 1 << pin;
    }

    val <<= analogWritePseudoScale;
@@ -131,6 +128,7 @@ extern "C" int analogRead(pin_size_t pin) {
    }
    if (!adcInitted) {
        adc_init();
+        adcInitted = true;
    }
    adc_gpio_init(pin);
    adc_select_input(pin - minPin);
@@ -145,6 +143,7 @@ extern "C" float analogReadTemp() {
    }
    if (!adcInitted) {
        adc_init();
+        adcInitted = true;
    }
    adc_set_temp_sensor_enabled(true);
    delay(1); // Allow things to settle.  Without this, readings can be erratic
@@ -22,24 +22,30 @@
 #include <CoreMutex.h>
 #include <hardware/gpio.h>
 #include <hardware/sync.h>
-#include <stack>
 #include <map>

 // Support nested IRQ disable/re-enable
-static std::stack<uint32_t> _irqStack[2];
+#define maxIRQs 15
+static uint32_t _irqStackTop[2] = { 0, 0 };
+static uint32_t _irqStack[2][maxIRQs];

 extern "C" void interrupts() {
-    if (_irqStack[get_core_num()].empty()) {
+    auto core = get_core_num();
+    if (!_irqStackTop[core]) {
        // ERROR
        return;
    }
-    auto oldIrqs = _irqStack[get_core_num()].top();
-    _irqStack[get_core_num()].pop();
-    restore_interrupts(oldIrqs);
+    restore_interrupts(_irqStack[core][--_irqStackTop[core]]);
 }

 extern "C" void noInterrupts() {
-    _irqStack[get_core_num()].push(save_and_disable_interrupts());
+    auto core = get_core_num();
+    if (_irqStackTop[core] == maxIRQs) {
+        // ERROR
+        panic("IRQ stack overflow");
+    }
+
+    _irqStack[core][_irqStackTop[core]++] = save_and_disable_interrupts();
 }

 // Only 1 GPIO IRQ callback for all pins, so we need to look at the pin it's for and
@@ -81,6 +87,15 @@ void _gpioInterruptDispatcher(uint gpio, uint32_t events) {
    }
 }

+// To be called when appropriately protected w/IRQ and mutex protects
+static void _detachInterruptInternal(pin_size_t pin) {
+    auto irq = _map.find(pin);
+    if (irq != _map.end()) {
+        gpio_set_irq_enabled(pin, 0x0f /* all */, false);
+        _map.erase(pin);
+    }
+}
+
 extern "C" void attachInterrupt(pin_size_t pin, voidFuncPtr callback, PinStatus mode) {
    CoreMutex m(&_irqMutex);
    if (!m) {
@@ -97,7 +112,7 @@ extern "C" void attachInterrupt(pin_size_t pin, voidFuncPtr callback, PinStatus
    default:      return;  // ERROR
    }
    noInterrupts();
-    detachInterrupt(pin);
+    _detachInterruptInternal(pin);
    CBInfo cb(callback);
    _map.insert({pin, cb});
    gpio_set_irq_enabled_with_callback(pin, events, true, _gpioInterruptDispatcher);
@@ -120,7 +135,7 @@ void attachInterruptParam(pin_size_t pin, voidFuncPtrParam callback, PinStatus m
    default:      return;  // ERROR
    }
    noInterrupts();
-    detachInterrupt(pin);
+    _detachInterruptInternal(pin);
    CBInfo cb(callback, param);
    _map.insert({pin, cb});
    gpio_set_irq_enabled_with_callback(pin, events, true, _gpioInterruptDispatcher);
@@ -134,10 +149,6 @@ extern "C" void detachInterrupt(pin_size_t pin) {
    }

    noInterrupts();
-    auto irq = _map.find(pin);
-    if (irq != _map.end()) {
-        gpio_set_irq_enabled(pin, 0x0f /* all */, false);
-        _map.erase(pin);
-    }
+    _detachInterruptInternal(pin);
    interrupts();
 }
@@ -54,9 +54,9 @@ author = u'Earle F. Philhower, III'
 # built documents.
 #
 # The short X.Y version.
-version = u'2.5.0'
+version = u'2.6.3'
 # The full version, including alpha/beta/rc tags.
-release = u'2.5.0'
+release = u'2.6.3'

 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -27,12 +27,12 @@ WiFiClientSecure documentation for more details.

    // Error checking is left as an exercise for the reader...
    HTTPClient https;
-    https.setInsecure(); // Use certs, but do not check their authenticity
+    https.setInsecure();  // Use certs, but do not check their authenticity
    if (https.begin("https://my.secure.server/url")) {
-        if (http.GET() > 0) {
-            String data = http.getString();
+        if (https.GET() > 0) {
+            String data = https.getString();
        }
-        http.end();
+        https.end();
    }

 Unlike the ESP8266 and ESP32 ``HTTPClient`` implementations it is not necessary
@@ -65,25 +65,14 @@ Them hit the upload button and your sketch should upload and run.
 In some cases the Pico will encounter a hard hang and its USB port will not respond to the auto-reset request.  Should this happen, just
 follow the initial procedure of holding the BOOTSEL button down while plugging in the Pico to enter the ROM bootloader.

-Unable to Upload First Sketch
-----------------------------
-If the Arduino IDE has never seen a serial port from a working device (Pico, AVR, or any other serial port), you
-may not be able to install using the prior directions because the ``Tools->Port`` menu will be grayed out and
-empty.  In this case, a special workaround identified by @fjansson in `this issue report <https://github.com/earlephilhower/arduino-pico/issues/688>`_ .
-
-To allow subsequent uploads to automatically work, you will need to manually install a UF2 binary onto the Raspberry Pi Pico one time to
-allow it to present a Serial port for the Arduino IDE to detect and save. 
-
-Perform the following steps to program a dummy sketch:
-
-1. Open a new, empty sketch (doesn't work with a read-only example sketch).
-2. Compile it by pressing the "Verify" checkmark button.
-3. Select the ``Sketch -> Export Compiled Binary`` menu. Select a location e.g. the desktop. A folder is created there, containing a file ending in .uf2
-4. Copy this file to the Pico's drive, by drag and drop in the Explorer.
-
-The Pico restarts and now now has a serial port. Now the Port menu in Arduino is not gray anymore, select the port there.
-After this, normal uploading from the Arduino editor should work.
+Uploading the First Sketch
+--------------------------
+The first time you upload a sketch to a board, you'll need to use the built-in ROM bootloader to handle the upload and not a serial port.

+1. Hold the BOOTSEL button while plugging in the board.
+2. Select ``Tools->Port->UF2 Board`` from the menu.
+3. Upload as normal.
+4. After the board boots up, select the new serial port from the ``Tools->Port`` menu.

 Windows 7 Driver Notes
 ----------------------
@@ -37,6 +37,20 @@ void rp2040.reboot()
 ~~~~~~~~~~~~~~~~~~~~
 Forces a hardware reboot of the Pico.

+Hardware Watchdog
+_________________
+
+void rp2040.wdt_begin(uint32_t delay_ms)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Enables the hardware watchdog timer with a delay value of delay_ms
+microseconds. Note that on the RP2040, once this function has called, the
+hardware watchdog can _not_ be disabled.
+
+void rp2040.wdt_reset()
+~~~~~~~~~~~~~~~~
+Reloads the watchdog's counter with the amount of time set by wdt_begin.
+
+
 Memory Information
 ------------------

@@ -56,3 +70,12 @@ int rp2040.getTotalHeap()
 Returns the total heap that was available to this program at compile time (i.e.
 the Pico RAM size minus things like the ``.data`` and ``.bss`` sections and other
 overhead).
+
+Bootloader
+----------
+
+void rp2040.enableDoubleResetBootloader()
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Add a call anywhere in the sketch to ``rp2040.enableDoubleResetBootloader()`` and
+the core will check for a double-tap on reset, and if found will start the USB
+bootloader.
@@ -40,8 +40,6 @@ Please note that WiFi on the Pico W is a work-in-progress and there are some imp

  * Combined STA/AP mode is not supported

-  * Certain WiFi status values (RSSI, BSSID, etc.) are not available.
-
 * Multicore is supported, but only one core may run ``WiFi`` code.

  * FreeRTOS is not yet supported due to the requirement for a very different LWIP implementation.  PRs always appreciated!
@@ -54,6 +54,8 @@ SerialPIO	KEYWORD2
 setFIFOSize	KEYWORD2
 setPollingMode	KEYWORD2

+enableDoubleResetBootloader	KEYWORD2
+
 OUTPUT_2MA	LITERAL1
 OUTPUT_4MA	LITERAL1
 OUTPUT_8MA	LITERAL1
@@ -132,15 +132,6 @@ SECTIONS
    } > FLASH
    __exidx_end = .;

-    /* Machine inspectable binary information */
-    . = ALIGN(4);
-    __binary_info_start = .;
-    .binary_info :
-    {
-        KEEP(*(.binary_info.keep.*))
-        *(.binary_info.*)
-    } > FLASH
-    __binary_info_end = .;
    . = ALIGN(4);

    /* End of .text-like segments */
@@ -0,0 +1 @@
+source [find board/pico-debug.cfg]
@@ -0,0 +1,2 @@
+source [find interface/picoprobe.cfg]
+source [find target/rp2040.cfg]
@@ -144,4 +144,59 @@
 -Wl,--wrap=tanhf
 -Wl,--wrap=trunc
 -Wl,--wrap=truncf
+
 -Wl,--wrap=__getreent
+
+-Wl,--wrap=malloc
+-Wl,--wrap=calloc
+-Wl,--wrap=realloc
+-Wl,--wrap=free
+
+-Wl,--wrap=pbuf_header
+-Wl,--wrap=pbuf_free
+-Wl,--wrap=pbuf_alloc
+-Wl,--wrap=pbuf_take
+-Wl,--wrap=pbuf_copy_partial
+-Wl,--wrap=pbuf_ref
+-Wl,--wrap=pbuf_get_at
+-Wl,--wrap=pbuf_get_contiguous
+-Wl,--wrap=pbuf_cat
+
+-Wl,--wrap=tcp_arg
+-Wl,--wrap=tcp_new
+-Wl,--wrap=tcp_listen
+-Wl,--wrap=tcp_listen_with_backlog
+-Wl,--wrap=tcp_accept
+-Wl,--wrap=tcp_connect
+-Wl,--wrap=tcp_write
+-Wl,--wrap=tcp_sent
+-Wl,--wrap=tcp_recv
+-Wl,--wrap=tcp_recved
+-Wl,--wrap=tcp_poll
+-Wl,--wrap=tcp_close
+-Wl,--wrap=tcp_abort
+-Wl,--wrap=tcp_err
+-Wl,--wrap=tcp_output
+-Wl,--wrap=tcp_setprio
+-Wl,--wrap=tcp_backlog_delayed
+-Wl,--wrap=tcp_backlog_accepted
+
+-Wl,--wrap=udp_new
+-Wl,--wrap=udp_remove
+-Wl,--wrap=udp_bind
+-Wl,--wrap=udp_connect
+-Wl,--wrap=udp_disconnect
+-Wl,--wrap=udp_send
+-Wl,--wrap=udp_recv
+-Wl,--wrap=udp_sendto_if
+
+-Wl,--wrap=sys_check_timeouts
+
+-Wl,--wrap=dns_gethostbyname
+-Wl,--wrap=dns_gethostbyname_addrtype
+
+-Wl,--wrap=raw_new
+-Wl,--wrap=raw_recv
+-Wl,--wrap=raw_bind
+-Wl,--wrap=raw_sendto
+-Wl,--wrap=raw_remove
@@ -1,3 +1,24 @@
+/*
+    Arduino OTA.cpp - Simple Arduino IDE OTA handler
+    Modified 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Taken from the ESP8266 core libraries, (c) various authors.
+
+    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 <functional>
 #include <WiFiUdp.h>
 #include "ArduinoOTA.h"
@@ -89,7 +110,7 @@ void ArduinoOTAClass::begin(bool useMDNS) {
    _useMDNS = useMDNS;

    if (!_hostname.length()) {
-        char tmp[15];
+        char tmp[2 * PICO_UNIQUE_BOARD_ID_SIZE_BYTES + 6];
        sprintf(tmp, "pico-%s", rp2040.getChipID());
        _hostname = tmp;
    }
@@ -1,3 +1,24 @@
+/*
+    Arduino OTA.h - Simple Arduino IDE OTA handler
+    Modified 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Taken from the ESP8266 core libraries, (c) various authors.
+
+    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 <WiFi.h>
@@ -38,10 +59,10 @@ public:
    void setHostname(const char *hostname);
    String getHostname();

-    //Sets the password that will be required for OTA. Default NULL
+    //Sets the password that will be required for OTA. Default nullptr
    void setPassword(const char *password);

-    //Sets the password as above but in the form MD5(password). Default NULL
+    //Sets the password as above but in the form MD5(password). Default nullptr
    void setPasswordHash(const char *password);

    //Sets if the device should be rebooted after successful update. Default true
@@ -133,7 +133,9 @@ void loop() {
        WiFi.disconnect();
      }
    }
-    if (s == WL_CONNECTED) { MDNS.update(); }
+    if (s == WL_CONNECTED) {
+      MDNS.update();
+    }
  }
  // Do work:
  // DNS
@@ -57,21 +57,23 @@ void handleWifi() {
          + String(softAP_ssid) + F("</td></tr>"
                                    "<tr><td>IP ")
          + toStringIp(WiFi.softAPIP()) + F("</td></tr>"
-                                            "</table>"
-                                            "\r\n<br />"
-                                            "<table><tr><th align='left'>WLAN config</th></tr>"
-                                            "<tr><td>SSID ")
+              "</table>"
+              "\r\n<br />"
+              "<table><tr><th align='left'>WLAN config</th></tr>"
+              "<tr><td>SSID ")
          + String(ssid) + F("</td></tr>"
                             "<tr><td>IP ")
          + toStringIp(WiFi.localIP()) + F("</td></tr>"
-                                           "</table>"
-                                           "\r\n<br />"
-                                           "<table><tr><th align='left'>WLAN list (refresh if any missing)</th></tr>");
+              "</table>"
+              "\r\n<br />"
+              "<table><tr><th align='left'>WLAN list (refresh if any missing)</th></tr>");
  Serial.println("scan start");
  int n = WiFi.scanNetworks();
  Serial.println("scan done");
  if (n > 0) {
-    for (int i = 0; i < n; i++) { Page += String(F("\r\n<tr><td>SSID ")) + WiFi.SSID(i) + ((WiFi.encryptionType(i) == ENC_TYPE_NONE) ? F(" ") : F(" *")) + F(" (") + WiFi.RSSI(i) + F(")</td></tr>"); }
+    for (int i = 0; i < n; i++) {
+      Page += String(F("\r\n<tr><td>SSID ")) + WiFi.SSID(i) + ((WiFi.encryptionType(i) == ENC_TYPE_NONE) ? F(" ") : F(" *")) + F(" (") + WiFi.RSSI(i) + F(")</td></tr>");
+    }
  } else {
    Page += F("<tr><td>No WLAN found</td></tr>");
  }
@@ -114,7 +116,9 @@ void handleNotFound() {
  message += server.args();
  message += F("\n");

-  for (uint8_t i = 0; i < server.args(); i++) { message += String(F(" ")) + server.argName(i) + F(": ") + server.arg(i) + F("\n"); }
+  for (uint8_t i = 0; i < server.args(); i++) {
+    message += String(F(" ")) + server.argName(i) + F(": ") + server.arg(i) + F("\n");
+  }
  server.sendHeader("Cache-Control", "no-cache, no-store, must-revalidate");
  server.sendHeader("Pragma", "no-cache");
  server.sendHeader("Expires", "-1");
@@ -2,7 +2,9 @@
 boolean isIp(String str) {
  for (size_t i = 0; i < str.length(); i++) {
    int c = str.charAt(i);
-    if (c != '.' && (c < '0' || c > '9')) { return false; }
+    if (c != '.' && (c < '0' || c > '9')) {
+      return false;
+    }
  }
  return true;
 }
@@ -10,7 +12,9 @@ boolean isIp(String str) {
 /** IP to String? */
 String toStringIp(IPAddress ip) {
  String res = "";
-  for (int i = 0; i < 3; i++) { res += String((ip >> (8 * i)) & 0xFF) + "."; }
+  for (int i = 0; i < 3; i++) {
+    res += String((ip >> (8 * i)) & 0xFF) + ".";
+  }
  res += String(((ip >> 8 * 3)) & 0xFF);
  return res;
 }
@@ -1,10 +1,29 @@
+/*
+    DNSServer.cpp - Simple DNS server for the Pico
+    Modified 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Taken from the ESP8266 core libraries, (c) various authors.
+
+    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 "WiFi.h"
 #include "DNSServer.h"
 #include <lwip/def.h>
 #include <Arduino.h>

-extern struct rst_info resetInfo;
-
 #ifdef DEBUG_ESP_PORT
 #define CONSOLE DEBUG_ESP_PORT
 #else
@@ -49,399 +68,389 @@ extern struct rst_info resetInfo;
 // Want to keep IDs unique across restarts and continquious
 static uint32_t _ids __attribute__((section(".noinit")));

-DNSServer::DNSServer()
-{
-  // I have observed that using 0 for captive and non-zero (600) when
-  // forwarding, will help Android devices recognize the change in connectivity.
-  // They will then report connected.
-  _ttl = lwip_htonl(60);
+DNSServer::DNSServer() {
+    // I have observed that using 0 for captive and non-zero (600) when
+    // forwarding, will help Android devices recognize the change in connectivity.
+    // They will then report connected.
+    _ttl = lwip_htonl(60);

-  srand(rp2040.getCycleCount());
-  _ids = random(0, (1UL << 16) - 1);
+    srand(rp2040.getCycleCount());
+    _ids = random(0, (1UL << 16) - 1);

-  _errorReplyCode = DNSReplyCode::NonExistentDomain;
+    _errorReplyCode = DNSReplyCode::NonExistentDomain;
 }

-void DNSServer::disableForwarder(const String &domainName, bool freeResources)
-{
-  _forwarder = false;
-  if (domainName != "") {
-    _domainName = domainName;
-    downcaseAndRemoveWwwPrefix(_domainName);
-  }
-  if (freeResources) {
-    _dns = (uint32_t)0;
-    if (_que) {
-      _que = nullptr;
-      DEBUG_PRINTF("from stop, deleted _que\r\n");
-      DEBUG_(({
-        if (_que_ov) {
-          DEBUG_PRINTLN2("DNS forwarder que overflow or no reply to request: ", (_que_ov));
+void DNSServer::disableForwarder(const String &domainName, bool freeResources) {
+    _forwarder = false;
+    if (domainName != "") {
+        _domainName = domainName;
+        downcaseAndRemoveWwwPrefix(_domainName);
+    }
+    if (freeResources) {
+        _dns = (uint32_t)0;
+        if (_que) {
+            _que = nullptr;
+            DEBUG_PRINTF("from stop, deleted _que\r\n");
+            DEBUG_(({
+                if (_que_ov) {
+                    DEBUG_PRINTLN2("DNS forwarder que overflow or no reply to request: ", (_que_ov));
+                }
+                if (_que_drop) {
+                    DEBUG_PRINTLN2("DNS forwarder que wrapped, reply dropped: ", (_que_drop));
+                }
+            }));
        }
-        if (_que_drop) {
-          DEBUG_PRINTLN2("DNS forwarder que wrapped, reply dropped: ", (_que_drop));
-        }
-      }));
    }
-  }
 }

-bool DNSServer::enableForwarder(const String &domainName, const IPAddress &dns)
-{
-  disableForwarder(domainName, false); // Just happens to have the same logic needed here.
+bool DNSServer::enableForwarder(const String &domainName, const IPAddress &dns) {
+    disableForwarder(domainName, false); // Just happens to have the same logic needed here.

-  if (dns.isSet()) {
-    _dns = dns;
-  }
+    if (dns.isSet()) {
+        _dns = dns;
+    }

-  if (_dns.isSet()) {
-    if (!_que) {
-      _que = std::unique_ptr<DNSS_REQUESTER[]> (new (std::nothrow) DNSS_REQUESTER[kDNSSQueSize]);
-      DEBUG_PRINTF("Created new _que\r\n");
-      if (_que) {
-        for (size_t i = 0; i < kDNSSQueSize; i++) {
-          _que[i].ip = 0;
+    if (_dns.isSet()) {
+        if (!_que) {
+            _que = std::unique_ptr<DNSS_REQUESTER[]> (new (std::nothrow) DNSS_REQUESTER[kDNSSQueSize]);
+            DEBUG_PRINTF("Created new _que\r\n");
+            if (_que) {
+                for (size_t i = 0; i < kDNSSQueSize; i++) {
+                    _que[i].ip = 0;
+                }
+                DEBUG_((_que_ov = 0));
+                DEBUG_((_que_drop = 0));
+            }
+        }
+        if (_que) {
+            _forwarder = true;
        }
-        DEBUG_((_que_ov = 0));
-        DEBUG_((_que_drop = 0));
-      }
    }
-    if (_que) {
-      _forwarder = true;
-    }
-  }
-  return _forwarder;
+    return _forwarder;
 }

 bool DNSServer::start(const uint16_t &port, const String &domainName,
-                     const IPAddress &resolvedIP, const IPAddress &dns)
-{
-  _port = (port) ? port : IANA_DNS_PORT;
+                      const IPAddress &resolvedIP, const IPAddress &dns) {
+    _port = (port) ? port : IANA_DNS_PORT;

-  _resolvedIP[0] = resolvedIP[0];
-  _resolvedIP[1] = resolvedIP[1];
-  _resolvedIP[2] = resolvedIP[2];
-  _resolvedIP[3] = resolvedIP[3];
+    _resolvedIP[0] = resolvedIP[0];
+    _resolvedIP[1] = resolvedIP[1];
+    _resolvedIP[2] = resolvedIP[2];
+    _resolvedIP[3] = resolvedIP[3];

-  if (!enableForwarder(domainName, dns) && (dns.isSet() || _dns.isSet())) {
-    return false;
-  }
-
-  return _udp.begin(_port) == 1;
-}
-
-void DNSServer::setErrorReplyCode(const DNSReplyCode &replyCode)
-{
-  _errorReplyCode = replyCode;
-}
-
-void DNSServer::setTTL(const uint32_t &ttl)
-{
-  _ttl = lwip_htonl(ttl);
-}
-
-uint32_t DNSServer::getTTL()
-{
-  return lwip_ntohl(_ttl);
-}
-
-void DNSServer::stop()
-{
-  _udp.stop();
-  disableForwarder("", true);
-}
-
-void DNSServer::downcaseAndRemoveWwwPrefix(String &domainName)
-{
-  domainName.toLowerCase();
-  if (domainName.startsWith("www."))
-      domainName.remove(0, 4);
-}
-
-void DNSServer::forwardReply(uint8_t *buffer, size_t length)
-{
-  if (!_forwarder || !_que) {
-    return;
-  }
-  DNSHeader *dnsHeader = (DNSHeader *)buffer;
-  uint16_t id = dnsHeader->ID;
-  // if (kDNSSQueSize <= (uint16_t)((uint16_t)_ids - id)) {
-  if ((uint16_t)kDNSSQueSize <= (uint16_t)_ids - id) {
-    DEBUG_((++_que_drop));
-    DEBUG_PRINTLN2("Forward reply ID: 0x", (String(id, HEX) + F(" dropped!")));
-    return;
-  }
-  size_t i = id & (kDNSSQueSize - 1);
-
-  // Drop duplicate packets
-  if (0 == _que[i].ip) {
-    DEBUG_PRINTLN2("Duplicate reply dropped ID: 0x", String(id, HEX));
-    return;
-  }
-  dnsHeader->ID = _que[i].id;
-  _udp.beginPacket(_que[i].ip, _que[i].port);
-  _udp.write(buffer, length);
-  _udp.endPacket();
-  DEBUG_PRINTLN2("Forward reply ID: 0x", (String(id, HEX) + F(" to ") + IPAddress(_que[i].ip).toString()));
-  _que[i].ip = 0; // This gets used to detect duplicate packets and overflow
-}
-
-void DNSServer::forwardRequest(uint8_t *buffer, size_t length)
-{
-  if (!_forwarder || !_dns.isSet() || !_que) {
-    return;
-  }
-  DNSHeader *dnsHeader = (DNSHeader *)buffer;
-  ++_ids;
-  size_t i = _ids & (kDNSSQueSize - 1);
-  DEBUG_(({
-    if (0  != _que[i].ip) {
-      ++_que_ov;
+    if (!enableForwarder(domainName, dns) && (dns.isSet() || _dns.isSet())) {
+        return false;
    }
-  }));
-  _que[i].ip = _udp.remoteIP();
-  _que[i].port = _udp.remotePort();
-  _que[i].id = dnsHeader->ID;
-  dnsHeader->ID = (uint16_t)_ids;
-  _udp.beginPacket(_dns, IANA_DNS_PORT);
-  _udp.write(buffer, length);
-  _udp.endPacket();
-  DEBUG_PRINTLN2("Forward request ID: 0x", (String(dnsHeader->ID, HEX) + F(" to ") + _dns.toString()));
+
+    return _udp.begin(_port) == 1;
 }

-bool DNSServer::respondToRequest(uint8_t *buffer, size_t length)
-{
-  DNSHeader *dnsHeader;
-  uint8_t *query, *start;
-  const char *matchString;
-  size_t remaining, labelLength, queryLength;
-  uint16_t qtype, qclass;
+void DNSServer::setErrorReplyCode(const DNSReplyCode &replyCode) {
+    _errorReplyCode = replyCode;
+}

-  dnsHeader = (DNSHeader *)buffer;
+void DNSServer::setTTL(const uint32_t &ttl) {
+    _ttl = lwip_htonl(ttl);
+}

-  // Must be a query for us to do anything with it
-  if (dnsHeader->QR != DNS_QR_QUERY) {
-    return false;
-  }
+uint32_t DNSServer::getTTL() {
+    return lwip_ntohl(_ttl);
+}

-  // If operation is anything other than query, we don't do it
-  if (dnsHeader->OPCode != DNS_OPCODE_QUERY) {
-    replyWithError(dnsHeader, DNSReplyCode::NotImplemented);
-    return false;
-  }
+void DNSServer::stop() {
+    _udp.stop();
+    disableForwarder("", true);
+}

-  // Only support requests containing single queries - everything else
-  // is badly defined
-  if (dnsHeader->QDCount != lwip_htons(1)) {
-    replyWithError(dnsHeader, DNSReplyCode::FormError);
-    return false;
-  }
-
-  // We must return a FormError in the case of a non-zero ARCount to
-  // be minimally compatible with EDNS resolvers
-  if (dnsHeader->ANCount != 0 || dnsHeader->NSCount != 0
-      || dnsHeader->ARCount != 0) {
-    replyWithError(dnsHeader, DNSReplyCode::FormError);
-    return false;
-  }
-
-  // Even if we're not going to use the query, we need to parse it
-  // so we can check the address type that's being queried
-
-  query = start = buffer + DNS_HEADER_SIZE;
-  remaining = length - DNS_HEADER_SIZE;
-  while (remaining != 0 && *start != 0) {
-    labelLength = *start;
-    if (labelLength + 1 > remaining) {
-      replyWithError(dnsHeader, DNSReplyCode::FormError);
-      return false;
+void DNSServer::downcaseAndRemoveWwwPrefix(String &domainName) {
+    domainName.toLowerCase();
+    if (domainName.startsWith("www.")) {
+        domainName.remove(0, 4);
    }
-    remaining -= (labelLength + 1);
-    start += (labelLength + 1);
-  }
+}

-  // 1 octet labelLength, 2 octet qtype, 2 octet qclass
-  if (remaining < 5)  {
-    replyWithError(dnsHeader, DNSReplyCode::FormError);
-    return false;
-  }
-
-  start += 1; // Skip the 0 length label that we found above
-
-  memcpy(&qtype, start, sizeof(qtype));
-  start += 2;
-  memcpy(&qclass, start, sizeof(qclass));
-  start += 2;
-
-  queryLength = start - query;
-
-  if (qclass != lwip_htons(DNS_QCLASS_ANY)
-      && qclass != lwip_htons(DNS_QCLASS_IN)) {
-    replyWithError(dnsHeader, DNSReplyCode::NonExistentDomain, query, queryLength);
-    return false;
-  }
-
-  if (qtype != lwip_htons(DNS_QTYPE_A)
-      && qtype != lwip_htons(DNS_QTYPE_ANY)) {
-    replyWithError(dnsHeader, DNSReplyCode::NonExistentDomain, query, queryLength);
-    return false;
-  }
-
-  // If we have no domain name configured, just return an error
-  if (_domainName == "") {
-    if (_forwarder) {
-      return true;
-    } else {
-      replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
-      return false;
+void DNSServer::forwardReply(uint8_t *buffer, size_t length) {
+    if (!_forwarder || !_que) {
+        return;
    }
-  }
+    DNSHeader *dnsHeader = (DNSHeader *)buffer;
+    uint16_t id = dnsHeader->ID;
+    // if (kDNSSQueSize <= (uint16_t)((uint16_t)_ids - id)) {
+    if ((uint16_t)kDNSSQueSize <= (uint16_t)_ids - id) {
+        DEBUG_((++_que_drop));
+        DEBUG_PRINTLN2("Forward reply ID: 0x", (String(id, HEX) + F(" dropped!")));
+        return;
+    }
+    size_t i = id & (kDNSSQueSize - 1);

-  // If we're running with a wildcard we can just return a result now
-  if (_domainName == "*") {
-    DEBUG_PRINTF("dnsServer - replyWithIP\r\n");
-    replyWithIP(dnsHeader, query, queryLength);
-    return false;
-  }
+    // Drop duplicate packets
+    if (0 == _que[i].ip) {
+        DEBUG_PRINTLN2("Duplicate reply dropped ID: 0x", String(id, HEX));
+        return;
+    }
+    dnsHeader->ID = _que[i].id;
+    _udp.beginPacket(_que[i].ip, _que[i].port);
+    _udp.write(buffer, length);
+    _udp.endPacket();
+    DEBUG_PRINTLN2("Forward reply ID: 0x", (String(id, HEX) + F(" to ") + IPAddress(_que[i].ip).toString()));
+    _que[i].ip = 0; // This gets used to detect duplicate packets and overflow
+}

-  matchString = _domainName.c_str();
-
-  start = query;
-
-  // If there's a leading 'www', skip it
-  if (*start == 3 && strncasecmp("www", (char *) start + 1, 3) == 0)
-      start += 4;
-
-  while (*start != 0) {
-    labelLength = *start;
-    start += 1;
-    while (labelLength > 0) {
-      if (tolower(*start) != *matchString) {
-        if (_forwarder) {
-          return true;
-        } else {
-          replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
-          return false;
+void DNSServer::forwardRequest(uint8_t *buffer, size_t length) {
+    if (!_forwarder || !_dns.isSet() || !_que) {
+        return;
+    }
+    DNSHeader *dnsHeader = (DNSHeader *)buffer;
+    ++_ids;
+    size_t i = _ids & (kDNSSQueSize - 1);
+    DEBUG_(({
+        if (0  != _que[i].ip) {
+            ++_que_ov;
        }
-      }
-      ++start;
-      ++matchString;
-      --labelLength;
-    }
-    if (*start == 0 && *matchString == '\0') {
-      replyWithIP(dnsHeader, query, queryLength);
-      return false;
-    }
-
-    if (*matchString != '.') {
-      replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
-      return false;
-    }
-    ++matchString;
-  }
-
-  replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
-  return false;
+    }));
+    _que[i].ip = _udp.remoteIP();
+    _que[i].port = _udp.remotePort();
+    _que[i].id = dnsHeader->ID;
+    dnsHeader->ID = (uint16_t)_ids;
+    _udp.beginPacket(_dns, IANA_DNS_PORT);
+    _udp.write(buffer, length);
+    _udp.endPacket();
+    DEBUG_PRINTLN2("Forward request ID: 0x", (String(dnsHeader->ID, HEX) + F(" to ") + _dns.toString()));
 }

-void DNSServer::processNextRequest()
-{
-  size_t currentPacketSize;
+bool DNSServer::respondToRequest(uint8_t *buffer, size_t length) {
+    DNSHeader *dnsHeader;
+    uint8_t *query, *start;
+    const char *matchString;
+    size_t remaining, labelLength, queryLength;
+    uint16_t qtype, qclass;

-  currentPacketSize = _udp.parsePacket();
-  if (currentPacketSize == 0)
-    return;
+    dnsHeader = (DNSHeader *)buffer;

-  // The DNS RFC requires that DNS packets be less than 512 bytes in size,
-  // so just discard them if they are larger
-  if (currentPacketSize > MAX_DNS_PACKETSIZE)
-    return;
+    // Must be a query for us to do anything with it
+    if (dnsHeader->QR != DNS_QR_QUERY) {
+        return false;
+    }

-  // If the packet size is smaller than the DNS header, then someone is
-  // messing with us
-  if (currentPacketSize < DNS_HEADER_SIZE)
-    return;
+    // If operation is anything other than query, we don't do it
+    if (dnsHeader->OPCode != DNS_OPCODE_QUERY) {
+        replyWithError(dnsHeader, DNSReplyCode::NotImplemented);
+        return false;
+    }

-  std::unique_ptr<uint8_t[]> buffer(new (std::nothrow) uint8_t[currentPacketSize]);
-  if (buffer == nullptr)
-    return;
+    // Only support requests containing single queries - everything else
+    // is badly defined
+    if (dnsHeader->QDCount != lwip_htons(1)) {
+        replyWithError(dnsHeader, DNSReplyCode::FormError);
+        return false;
+    }

-  _udp.read(buffer.get(), currentPacketSize);
-  if (_dns.isSet() && _udp.remoteIP() == _dns) {
-    // _forwarder may have been set to false; however, for now allow in-flight
-    // replies to finish. //??
-    forwardReply(buffer.get(), currentPacketSize);
-  } else
-  if (respondToRequest(buffer.get(), currentPacketSize)) {
-    forwardRequest(buffer.get(), currentPacketSize);
-  }
+    // We must return a FormError in the case of a non-zero ARCount to
+    // be minimally compatible with EDNS resolvers
+    if (dnsHeader->ANCount != 0 || dnsHeader->NSCount != 0
+            || dnsHeader->ARCount != 0) {
+        replyWithError(dnsHeader, DNSReplyCode::FormError);
+        return false;
+    }
+
+    // Even if we're not going to use the query, we need to parse it
+    // so we can check the address type that's being queried
+
+    query = start = buffer + DNS_HEADER_SIZE;
+    remaining = length - DNS_HEADER_SIZE;
+    while (remaining != 0 && *start != 0) {
+        labelLength = *start;
+        if (labelLength + 1 > remaining) {
+            replyWithError(dnsHeader, DNSReplyCode::FormError);
+            return false;
+        }
+        remaining -= (labelLength + 1);
+        start += (labelLength + 1);
+    }
+
+    // 1 octet labelLength, 2 octet qtype, 2 octet qclass
+    if (remaining < 5)  {
+        replyWithError(dnsHeader, DNSReplyCode::FormError);
+        return false;
+    }
+
+    start += 1; // Skip the 0 length label that we found above
+
+    memcpy(&qtype, start, sizeof(qtype));
+    start += 2;
+    memcpy(&qclass, start, sizeof(qclass));
+    start += 2;
+
+    queryLength = start - query;
+
+    if (qclass != lwip_htons(DNS_QCLASS_ANY)
+            && qclass != lwip_htons(DNS_QCLASS_IN)) {
+        replyWithError(dnsHeader, DNSReplyCode::NonExistentDomain, query, queryLength);
+        return false;
+    }
+
+    if (qtype != lwip_htons(DNS_QTYPE_A)
+            && qtype != lwip_htons(DNS_QTYPE_ANY)) {
+        replyWithError(dnsHeader, DNSReplyCode::NonExistentDomain, query, queryLength);
+        return false;
+    }
+
+    // If we have no domain name configured, just return an error
+    if (_domainName == "") {
+        if (_forwarder) {
+            return true;
+        } else {
+            replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
+            return false;
+        }
+    }
+
+    // If we're running with a wildcard we can just return a result now
+    if (_domainName == "*") {
+        DEBUG_PRINTF("dnsServer - replyWithIP\r\n");
+        replyWithIP(dnsHeader, query, queryLength);
+        return false;
+    }
+
+    matchString = _domainName.c_str();
+
+    start = query;
+
+    // If there's a leading 'www', skip it
+    if (*start == 3 && strncasecmp("www", (char *) start + 1, 3) == 0) {
+        start += 4;
+    }
+
+    while (*start != 0) {
+        labelLength = *start;
+        start += 1;
+        while (labelLength > 0) {
+            if (tolower(*start) != *matchString) {
+                if (_forwarder) {
+                    return true;
+                } else {
+                    replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
+                    return false;
+                }
+            }
+            ++start;
+            ++matchString;
+            --labelLength;
+        }
+        if (*start == 0 && *matchString == '\0') {
+            replyWithIP(dnsHeader, query, queryLength);
+            return false;
+        }
+
+        if (*matchString != '.') {
+            replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
+            return false;
+        }
+        ++matchString;
+    }
+
+    replyWithError(dnsHeader, _errorReplyCode, query, queryLength);
+    return false;
 }

-void DNSServer::writeNBOShort(uint16_t value)
-{
-   _udp.write((unsigned char *)&value, 2);
+void DNSServer::processNextRequest() {
+    size_t currentPacketSize;
+
+    currentPacketSize = _udp.parsePacket();
+    if (currentPacketSize == 0) {
+        return;
+    }
+
+    // The DNS RFC requires that DNS packets be less than 512 bytes in size,
+    // so just discard them if they are larger
+    if (currentPacketSize > MAX_DNS_PACKETSIZE) {
+        return;
+    }
+
+    // If the packet size is smaller than the DNS header, then someone is
+    // messing with us
+    if (currentPacketSize < DNS_HEADER_SIZE) {
+        return;
+    }
+
+    std::unique_ptr<uint8_t[]> buffer(new (std::nothrow) uint8_t[currentPacketSize]);
+    if (buffer == nullptr) {
+        return;
+    }
+
+    _udp.read(buffer.get(), currentPacketSize);
+    if (_dns.isSet() && _udp.remoteIP() == _dns) {
+        // _forwarder may have been set to false; however, for now allow in-flight
+        // replies to finish. //??
+        forwardReply(buffer.get(), currentPacketSize);
+    } else if (respondToRequest(buffer.get(), currentPacketSize)) {
+        forwardRequest(buffer.get(), currentPacketSize);
+    }
+}
+
+void DNSServer::writeNBOShort(uint16_t value) {
+    _udp.write((unsigned char *)&value, 2);
 }

 void DNSServer::replyWithIP(DNSHeader *dnsHeader,
-			    unsigned char * query,
-			    size_t queryLength)
-{
-  uint16_t value;
+                            unsigned char * query,
+                            size_t queryLength) {
+    uint16_t value;

-  dnsHeader->QR = DNS_QR_RESPONSE;
-  dnsHeader->QDCount = lwip_htons(1);
-  dnsHeader->ANCount = lwip_htons(1);
-  dnsHeader->NSCount = 0;
-  dnsHeader->ARCount = 0;
+    dnsHeader->QR = DNS_QR_RESPONSE;
+    dnsHeader->QDCount = lwip_htons(1);
+    dnsHeader->ANCount = lwip_htons(1);
+    dnsHeader->NSCount = 0;
+    dnsHeader->ARCount = 0;

-  _udp.beginPacket(_udp.remoteIP(), _udp.remotePort());
-  _udp.write((unsigned char *) dnsHeader, sizeof(DNSHeader));
-  _udp.write(query, queryLength);
+    _udp.beginPacket(_udp.remoteIP(), _udp.remotePort());
+    _udp.write((unsigned char *) dnsHeader, sizeof(DNSHeader));
+    _udp.write(query, queryLength);

-  // Rather than restate the name here, we use a pointer to the name contained
-  // in the query section. Pointers have the top two bits set.
-  value = 0xC000 | DNS_HEADER_SIZE;
-  writeNBOShort(lwip_htons(value));
+    // Rather than restate the name here, we use a pointer to the name contained
+    // in the query section. Pointers have the top two bits set.
+    value = 0xC000 | DNS_HEADER_SIZE;
+    writeNBOShort(lwip_htons(value));

-  // Answer is type A (an IPv4 address)
-  writeNBOShort(lwip_htons(DNS_QTYPE_A));
+    // Answer is type A (an IPv4 address)
+    writeNBOShort(lwip_htons(DNS_QTYPE_A));

-  // Answer is in the Internet Class
-  writeNBOShort(lwip_htons(DNS_QCLASS_IN));
+    // Answer is in the Internet Class
+    writeNBOShort(lwip_htons(DNS_QCLASS_IN));

-  // Output TTL (already NBO)
-  _udp.write((unsigned char*)&_ttl, 4);
+    // Output TTL (already NBO)
+    _udp.write((unsigned char*)&_ttl, 4);

-  // Length of RData is 4 bytes (because, in this case, RData is IPv4)
-  writeNBOShort(lwip_htons(sizeof(_resolvedIP)));
-  _udp.write(_resolvedIP, sizeof(_resolvedIP));
-  _udp.endPacket();
+    // Length of RData is 4 bytes (because, in this case, RData is IPv4)
+    writeNBOShort(lwip_htons(sizeof(_resolvedIP)));
+    _udp.write(_resolvedIP, sizeof(_resolvedIP));
+    _udp.endPacket();
 }

 void DNSServer::replyWithError(DNSHeader *dnsHeader,
-			       DNSReplyCode rcode,
-			       unsigned char *query,
-			       size_t queryLength)
-{
-  dnsHeader->QR = DNS_QR_RESPONSE;
-  dnsHeader->RCode = (unsigned char) rcode;
-  if (query)
-     dnsHeader->QDCount = lwip_htons(1);
-  else
-     dnsHeader->QDCount = 0;
-  dnsHeader->ANCount = 0;
-  dnsHeader->NSCount = 0;
-  dnsHeader->ARCount = 0;
+                               DNSReplyCode rcode,
+                               unsigned char *query,
+                               size_t queryLength) {
+    dnsHeader->QR = DNS_QR_RESPONSE;
+    dnsHeader->RCode = (unsigned char) rcode;
+    if (query) {
+        dnsHeader->QDCount = lwip_htons(1);
+    } else {
+        dnsHeader->QDCount = 0;
+    }
+    dnsHeader->ANCount = 0;
+    dnsHeader->NSCount = 0;
+    dnsHeader->ARCount = 0;

-  _udp.beginPacket(_udp.remoteIP(), _udp.remotePort());
-  _udp.write((unsigned char *)dnsHeader, sizeof(DNSHeader));
-  if (query != NULL)
-     _udp.write(query, queryLength);
-  _udp.endPacket();
+    _udp.beginPacket(_udp.remoteIP(), _udp.remotePort());
+    _udp.write((unsigned char *)dnsHeader, sizeof(DNSHeader));
+    if (query != nullptr) {
+        _udp.write(query, queryLength);
+    }
+    _udp.endPacket();
 }

 void DNSServer::replyWithError(DNSHeader *dnsHeader,
-			       DNSReplyCode rcode)
-{
-  replyWithError(dnsHeader, rcode, NULL, 0);
+                               DNSReplyCode rcode) {
+    replyWithError(dnsHeader, rcode, nullptr, 0);
 }
@@ -1,5 +1,25 @@
-#ifndef DNSServer_h
-#define DNSServer_h
+/*
+    DNSServer.h - Simple DNS server for the Pico
+    Modified 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Taken from the ESP8266 core libraries, (c) various authors.
+
+    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 <memory>
 #include <WiFiUdp.h>
@@ -25,90 +45,97 @@ constexpr inline uint16_t kIanaDnsPort = IANA_DNS_PORT;
 #define MAX_DNSNAME_LENGTH 253
 #define MAX_DNS_PACKETSIZE 512

-enum class DNSReplyCode
-{
-  NoError = 0,
-  FormError = 1,
-  ServerFailure = 2,
-  NonExistentDomain = 3,
-  NotImplemented = 4,
-  Refused = 5,
-  YXDomain = 6,
-  YXRRSet = 7,
-  NXRRSet = 8
+enum class DNSReplyCode {
+    NoError = 0,
+    FormError = 1,
+    ServerFailure = 2,
+    NonExistentDomain = 3,
+    NotImplemented = 4,
+    Refused = 5,
+    YXDomain = 6,
+    YXRRSet = 7,
+    NXRRSet = 8
 };

-struct DNSHeader
-{
-  uint16_t ID;               // identification number
-  unsigned char RD : 1;      // recursion desired
-  unsigned char TC : 1;      // truncated message
-  unsigned char AA : 1;      // authoritative answer
-  unsigned char OPCode : 4;  // message_type
-  unsigned char QR : 1;      // query/response flag
-  unsigned char RCode : 4;   // response code
-  unsigned char Z : 3;       // its z! reserved
-  unsigned char RA : 1;      // recursion available
-  uint16_t QDCount;          // number of question entries
-  uint16_t ANCount;          // number of answer entries
-  uint16_t NSCount;          // number of authority entries
-  uint16_t ARCount;          // number of resource entries
+struct DNSHeader {
+    uint16_t ID;               // identification number
+    unsigned char RD : 1;      // recursion desired
+    unsigned char TC : 1;      // truncated message
+    unsigned char AA : 1;      // authoritative answer
+    unsigned char OPCode : 4;  // message_type
+    unsigned char QR : 1;      // query/response flag
+    unsigned char RCode : 4;   // response code
+    unsigned char Z : 3;       // its z! reserved
+    unsigned char RA : 1;      // recursion available
+    uint16_t QDCount;          // number of question entries
+    uint16_t ANCount;          // number of answer entries
+    uint16_t NSCount;          // number of authority entries
+    uint16_t ARCount;          // number of resource entries
 };

 constexpr inline size_t kDNSSQueSizeAddrBits = 3; // The number of bits used to address que entries
-constexpr inline size_t kDNSSQueSize =  (1UL << (kDNSSQueSizeAddrBits));
+constexpr inline size_t kDNSSQueSize = (1UL << (kDNSSQueSizeAddrBits));

 struct DNSS_REQUESTER {
-  uint32_t ip;
-  uint16_t port;
-  uint16_t id;
+    uint32_t ip;
+    uint16_t port;
+    uint16_t id;
 };

-class DNSServer
-{
-  public:
+class DNSServer {
+public:
    DNSServer();
    ~DNSServer() {
        stop();
    };
    /*
-      If specified, `enableForwarder` will update the `domainName` that is used
-      to match DNS request to this AP's IP Address. A non-matching request will
-      be forwarded to the DNS server specified by `dns`.
+        If specified, `enableForwarder` will update the `domainName` that is used
+        to match DNS request to this AP's IP Address. A non-matching request will
+        be forwarded to the DNS server specified by `dns`.

-      Returns `true` on success.
+        Returns `true` on success.

-      Returns `false`,
-        * when forwarding `dns` is not set, or
-        * unable to allocate resources for managing the DNS forward function.
+        Returns `false`,
+          when forwarding `dns` is not set, or
+          unable to allocate resources for managing the DNS forward function.
    */
    bool enableForwarder(const String &domainName = String(""), const IPAddress &dns = (uint32_t)0);
    /*
-      `disableForwarder` will stop forwarding DNS requests. If specified,
-      updates the `domainName` that is matched for returning this AP's IP Address.
-      Optionally, resources used for the DNS forward function can be freed.
+        `disableForwarder` will stop forwarding DNS requests. If specified,
+        updates the `domainName` that is matched for returning this AP's IP Address.
+        Optionally, resources used for the DNS forward function can be freed.
    */
    void disableForwarder(const String &domainName = String(""), bool freeResources = false);
-    bool isForwarding() { return _forwarder && _dns.isSet(); }
-    void setDNS(const IPAddress& dns) { _dns = dns; }
-    IPAddress getDNS() { return _dns; }
-    bool isDNSSet() { return _dns.isSet(); }
+    bool isForwarding() {
+        return _forwarder && _dns.isSet();
+    }
+    void setDNS(const IPAddress& dns) {
+        _dns = dns;
+    }
+    IPAddress getDNS() {
+        return _dns;
+    }
+    bool isDNSSet() {
+        return _dns.isSet();
+    }

    void processNextRequest();
    void setErrorReplyCode(const DNSReplyCode &replyCode);
    void setTTL(const uint32_t &ttl);
    uint32_t getTTL();
-    String getDomainName() { return _domainName; }
+    String getDomainName() {
+        return _domainName;
+    }

    // Returns true if successful, false if there are no sockets available
    bool start(const uint16_t &port,
-              const String &domainName,
-              const IPAddress &resolvedIP,
-              const IPAddress &dns = (uint32_t)0);
+               const String &domainName,
+               const IPAddress &resolvedIP,
+               const IPAddress &dns = (uint32_t)0);
    // stops the DNS server
    void stop();

-  private:
+private:
    WiFiUDP _udp;
    String _domainName;
    IPAddress _dns;
@@ -128,17 +155,16 @@ class DNSServer

    void downcaseAndRemoveWwwPrefix(String &domainName);
    void replyWithIP(DNSHeader *dnsHeader,
-		     unsigned char * query,
-		     size_t queryLength);
+                     unsigned char * query,
+                     size_t queryLength);
    void replyWithError(DNSHeader *dnsHeader,
-			DNSReplyCode rcode,
-			unsigned char *query,
-			size_t queryLength);
+                        DNSReplyCode rcode,
+                        unsigned char *query,
+                        size_t queryLength);
    void replyWithError(DNSHeader *dnsHeader,
-			DNSReplyCode rcode);
+                        DNSReplyCode rcode);
    bool respondToRequest(uint8_t *buffer, size_t length);
    void forwardRequest(uint8_t *buffer, size_t length);
    void forwardReply(uint8_t *buffer, size_t length);
    void writeNBOShort(uint16_t value);
 };
-#endif
@@ -19,8 +19,7 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

-#ifndef EEPROM_h
-#define EEPROM_h
+#pragma once

 #include <stddef.h>
 #include <stdint.h>
@@ -85,6 +84,3 @@ protected:
 };

 extern EEPROMClass EEPROM;
-
-#endif
-
@@ -0,0 +1,80 @@
+/* The code in this example is mostly derived from the official FreeRTOS
+ * code examples.
+ * 
+ * For more information on static allocation and to read the original
+ * code visit the following links:
+ * https://www.freertos.org/Static_Vs_Dynamic_Memory_Allocation.html
+ * https://www.freertos.org/xTaskCreateStatic.html
+ * https://www.freertos.org/xSemaphoreCreateMutexStatic.html
+ */
+
+#include <FreeRTOS.h>
+#include <task.h>
+#include <semphr.h>
+
+#define SERIAL_PORT Serial1
+#define BLINK_ON_TIME   250
+#define BLINK_OFF_TIME  500
+
+/* Dimensions of the buffer that the task being created will use as its stack.
+  NOTE:  This is the number of words the stack will hold, not the number of
+  bytes.  For example, if each stack item is 32-bits, and this is set to 100,
+  then 400 bytes (100 * 32-bits) will be allocated. */
+#define STACK_SIZE 200
+
+/* Structure that will hold the TCB of the task being created. */
+StaticTask_t xTaskBuffer_A;
+StaticTask_t xTaskBuffer_B;
+
+/* Buffer that the task being created will use as its stack.  Note this is
+  an array of StackType_t variables.  The size of StackType_t is dependent on
+  the RTOS port. */
+StackType_t xStack_A[ STACK_SIZE ];
+StackType_t xStack_B[ STACK_SIZE ];
+
+SemaphoreHandle_t xSemaphore = NULL;
+StaticSemaphore_t xMutexBuffer;
+
+void setup() {
+  SERIAL_PORT.begin(115200);
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  /* Create a mutex semaphore without using any dynamic memory
+    allocation.  The mutex's data structures will be saved into
+    the xMutexBuffer variable. */
+  xSemaphore = xSemaphoreCreateMutexStatic( &xMutexBuffer );
+
+  xTaskCreateStatic(led_ON, "led_ON", STACK_SIZE, NULL, configMAX_PRIORITIES - 1, xStack_A, &xTaskBuffer_A);
+  xTaskCreateStatic(led_OFF, "led_OFF", STACK_SIZE, NULL, configMAX_PRIORITIES - 1, xStack_B, &xTaskBuffer_B);
+}
+
+void led_ON(void *pvParameters)
+{
+  (void) pvParameters;
+  while (1)
+  {
+    xSemaphoreTake( xSemaphore, ( TickType_t ) portMAX_DELAY );
+    SERIAL_PORT.println("LED ON!");
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(BLINK_ON_TIME);
+    xSemaphoreGive( xSemaphore );
+  }
+}
+
+void led_OFF(void *pvParameters)
+{
+  (void) pvParameters;
+  while (1)
+  {
+    xSemaphoreTake( xSemaphore, ( TickType_t ) portMAX_DELAY );
+    SERIAL_PORT.println("LED OFF!");
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(BLINK_OFF_TIME);
+    xSemaphoreGive( xSemaphore );
+  }
+}
+
+void loop() {
+  SERIAL_PORT.println("Hello!");
+  delay(1000);
+}
@@ -0,0 +1,319 @@
+// FreeRTOS system call/mutex stress test
+
+#include <Arduino.h>
+#include <FreeRTOS.h>
+#include <task.h>
+#include <semphr.h>
+#define DELAY 1
+#define SERIAL_DEBUG Serial1
+#define STACK_SIZE 512
+#define CORE_0 (1 << 0)
+#define CORE_1 (1 << 1)
+
+void semphrTakeConditional(bool useMutexOn, SemaphoreHandle_t xSemaphore);
+void semphrGiveConditional(bool useMutexOn, SemaphoreHandle_t xSemaphore);
+
+/*
+  I want to keep the possibility of using different and independent
+  mutexes for each of the functions that operate on the heap.
+
+  If you want to enable the use of these mutexes remove the defines
+  on lines 30 and 31 and enable the their initialization in setup()
+*/
+SemaphoreHandle_t xSemaphoreMalloc = NULL;
+// SemaphoreHandle_t xSemaphoreRealloc = NULL;
+// SemaphoreHandle_t xSemaphoreFree = NULL;
+
+/*
+  A lazy way to use the same mutex for malloc, realloc and free
+  in order to bring us back to the same situation as the MCVE
+  posted here: https://github.com/earlephilhower/arduino-pico/issues/795#issuecomment-1227122082
+*/
+#define xSemaphoreRealloc xSemaphoreMalloc
+#define xSemaphoreFree xSemaphoreMalloc
+
+const bool useMutexOnMalloc = false;
+const bool useMutexOnRealloc = false;
+const bool useMutexOnFree = false;
+
+/*
+  Enabling this, a realloc will be performed and the string "_realloc"
+  will be concateneted to *tmp
+*/
+const bool tryRealloc = true;
+
+TaskHandle_t loop2Handle = NULL;
+TaskHandle_t loop3Handle = NULL;
+TaskHandle_t loop4Handle = NULL;
+TaskHandle_t loop5Handle = NULL;
+TaskHandle_t loop6Handle = NULL;
+TaskHandle_t loop7Handle = NULL;
+
+void loop2(void *pvPramaters);
+void loop3(void *pvPramaters);
+void loop4(void *pvPramaters);
+void loop5(void *pvPramaters);
+void loop6(void *pvPramaters);
+void loop7(void *pvPramaters);
+
+void setup()
+{
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  xSemaphoreMalloc = xSemaphoreCreateMutex();
+  // xSemaphoreRealloc = xSemaphoreCreateMutex();
+  // xSemaphoreFree = xSemaphoreCreateMutex();
+
+  xTaskCreate(loop2, "loop2", STACK_SIZE, NULL, 1, &loop2Handle);
+  vTaskCoreAffinitySet(loop2Handle, CORE_0);
+  xTaskCreate(loop3, "loop3", STACK_SIZE, NULL, 1, &loop3Handle);
+  vTaskCoreAffinitySet(loop3Handle, CORE_1);
+  xTaskCreate(loop4, "loop4", STACK_SIZE, NULL, 1, &loop4Handle);
+  vTaskCoreAffinitySet(loop4Handle, CORE_0);
+  xTaskCreate(loop5, "loop5", STACK_SIZE, NULL, 1, &loop5Handle);
+  vTaskCoreAffinitySet(loop5Handle, CORE_1);
+  // xTaskCreate(loop6, "loop6", STACK_SIZE, NULL, 1, &loop6Handle);
+  // vTaskCoreAffinitySet(loop6Handle, CORE_0);
+  // xTaskCreate(loop7, "loop7", STACK_SIZE, NULL, 1, &loop7Handle);
+  // vTaskCoreAffinitySet(loop7Handle, CORE_1);
+}
+static int _loop[8];
+
+void loop()
+{
+  while (1)
+  {
+    _loop[0]++;
+    digitalWrite(LED_BUILTIN, HIGH);
+    delay(500);
+    digitalWrite(LED_BUILTIN, LOW);
+    delay(500);
+    for (int i=0; i<8; i++) Serial.printf("%d ", _loop[i]);
+    Serial.println("");
+  }
+}
+
+void loop1()
+{
+  while (1)
+  {
+    _loop[1]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "foo");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void loop2(void *pvPramaters)
+{
+  (void) pvPramaters;
+  while (1)
+  {
+    _loop[2]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "bar");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void loop3(void *pvPramaters)
+{
+  (void) pvPramaters;
+  while (1)
+  {
+    _loop[3]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "yeah");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void loop4(void *pvPramaters)
+{
+  (void) pvPramaters;
+  while (1)
+  {
+    _loop[4]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "baz");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void loop5(void *pvPramaters)
+{
+  (void) pvPramaters;
+  while (1)
+  {
+    _loop[5]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "asd");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void loop6(void *pvPramaters)
+{
+  (void) pvPramaters;
+  while (1)
+  {
+    _loop[6]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "lol");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void loop7(void *pvPramaters)
+{
+  (void) pvPramaters;
+  while (1)
+  {
+    _loop[7]++;
+    char *tmp;
+
+    semphrTakeConditional(useMutexOnMalloc, xSemaphoreMalloc);
+    tmp = (char *)malloc(10 * sizeof(char));
+    semphrGiveConditional(useMutexOnMalloc, xSemaphoreMalloc);
+
+    strcpy(tmp, "yay");
+
+    if (tryRealloc)
+    {
+      semphrTakeConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      tmp = (char *)realloc(tmp, 20 * sizeof(char));
+      semphrGiveConditional(useMutexOnRealloc, xSemaphoreRealloc);
+      strcat(tmp, "_realloc");
+    }
+
+    semphrTakeConditional(useMutexOnFree, xSemaphoreFree);
+    free(tmp);
+    semphrGiveConditional(useMutexOnFree, xSemaphoreFree);
+
+    delay(DELAY);
+  }
+}
+
+void semphrTakeConditional(bool useMutexOn, SemaphoreHandle_t xSemaphore)
+{
+  if (useMutexOn)
+  {
+    xSemaphoreTake(xSemaphore, TickType_t(portMAX_DELAY));
+  }
+}
+
+void semphrGiveConditional(bool useMutexOn, SemaphoreHandle_t xSemaphore)
+{
+  if (useMutexOn)
+  {
+    xSemaphoreGive(xSemaphore);
+  }
+}
@@ -24,7 +24,7 @@
 #define configUSE_COUNTING_SEMAPHORES	1
 #define configUSE_QUEUE_SETS			1
 #define configSUPPORT_DYNAMIC_ALLOCATION 1
-#define configSUPPORT_STATIC_ALLOCATION 0
+#define configSUPPORT_STATIC_ALLOCATION 1
 #define configSTACK_DEPTH_TYPE			uint32_t
 #define configUSE_TASK_PREEMPTION_DISABLE 1

@@ -25,24 +25,28 @@
 */
 #include <stdlib.h>

+/* FreeRTOS includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "timers.h"
+#include "semphr.h"
+
 /* Arduino Core includes */
 #include <Arduino.h>
 #include <RP2040USB.h>
 #include "tusb.h"

-
 /* Raspberry PI Pico includes */
 #include <pico.h>
 #include <pico/time.h>

-/* FreeRTOS includes. */
-#include "FreeRTOS.h"
-#include "task.h"
-#include "timers.h"
+#include "_freertos.h"

 /*-----------------------------------------------------------*/

+extern void __initFreeRTOSMutexes();
 void initFreeRTOS(void) {
+    __initFreeRTOSMutexes();
 }

 extern void setup() __attribute__((weak));
@@ -107,7 +111,7 @@ extern "C" void yield() {
 extern mutex_t __usb_mutex;
 static TaskHandle_t __usbTask;
 static void __usb(void *param);
-
+extern volatile bool __freeRTOSinitted;
 void startFreeRTOS(void) {

    TaskHandle_t c0;
@@ -121,6 +125,7 @@ void startFreeRTOS(void) {
    }

    // Initialise and run the freeRTOS scheduler. Execution should never return here.
+    __freeRTOSinitted = true;
    vTaskStartScheduler();

    while (true) {
@@ -392,3 +397,42 @@ void __USBStart() {
    xTaskCreate(__usb, "USB", 256, 0, configMAX_PRIORITIES - 1, &__usbTask);
    vTaskCoreAffinitySet(__usbTask, 1 << 0);
 }
+
+
+// Interfaces for the main core to use FreeRTOS mutexes
+extern "C" {
+
+    SemaphoreHandle_t __freertos_mutex_create() {
+        return xSemaphoreCreateMutex();
+    }
+
+    SemaphoreHandle_t _freertos_recursive_mutex_create() {
+        return xSemaphoreCreateRecursiveMutex();
+    }
+
+    void __freertos_mutex_take(SemaphoreHandle_t mtx) {
+        xSemaphoreTake(mtx, portMAX_DELAY);
+    }
+
+    int __freertos_mutex_try_take(SemaphoreHandle_t mtx) {
+        return xSemaphoreTake(mtx, 0);
+    }
+
+    void __freertos_mutex_give(SemaphoreHandle_t mtx) {
+        xSemaphoreGive(mtx);
+    }
+
+    void __freertos_recursive_mutex_take(SemaphoreHandle_t mtx) {
+        xSemaphoreTakeRecursive(mtx, portMAX_DELAY);
+    }
+
+    int __freertos_recursive_mutex_try_take(SemaphoreHandle_t mtx) {
+        return xSemaphoreTakeRecursive(mtx, 0);
+    }
+
+    void __freertos_recursive_mutex_give(SemaphoreHandle_t mtx) {
+        xSemaphoreGiveRecursive(mtx);
+    }
+
+}
+
@@ -807,7 +807,7 @@ int HTTPClient::writeToPrint(Print * print) {
            DEBUG_HTTPCLIENT("[HTTP-Client] chunk header: '%s'\n", chunkHeader.c_str());

            // read size of chunk
-            len = (uint32_t) strtol((const char *) chunkHeader.c_str(), NULL, 16);
+            len = (uint32_t) strtol((const char *) chunkHeader.c_str(), nullptr, 16);
            size += len;
            DEBUG_HTTPCLIENT("[HTTP-Client] read chunk len: %d\n", len);

@@ -205,7 +205,7 @@ public:
    int PATCH(const uint8_t* payload, size_t size);
    int PATCH(const String& payload);
    int sendRequest(const char* type, const String& payload);
-    int sendRequest(const char* type, const uint8_t* payload = NULL, size_t size = 0);
+    int sendRequest(const char* type, const uint8_t* payload = nullptr, size_t size = 0);
    int sendRequest(const char* type, Stream * stream, size_t size = 0);

    void addHeader(const String& name, const String& value, bool first = false, bool replace = true);
@@ -1,3 +1,24 @@
+/*
+    HTTPUpdateServer - Support simple web based OTA
+    Modified 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Ported from the ESP8266 Arduino core, (c) copyright multiple authors
+
+    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>
@@ -39,7 +60,7 @@ static const char successResponse[] PROGMEM =
 template <typename ServerType, int ServerPort>
 HTTPUpdateServerTemplate<ServerType, ServerPort>::HTTPUpdateServerTemplate(bool serial_debug) {
    _serial_output = serial_debug;
-    _server = NULL;
+    _server = nullptr;
    _username = "";
    _password = "";
    _authenticated = false;
@@ -1,3 +1,24 @@
+/*
+    HTTPUpdateServer - Support simple web based OTA
+    Modified 2022 Earle F. Philhower, III.  All rights reserved.
+
+    Ported from the ESP8266 Arduino core, (c) copyright multiple authors
+
+    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 <WebServer.h>
@@ -28,7 +28,6 @@
 #include "ESP8266mDNS.h"
 #include "LEAmDNS_Priv.h"
 #include <LwipIntf.h>  // LwipIntf::stateUpCB()
-#include <LWIPMutex.h>  // LwipIntf::stateUpCB()
 #include <lwip/igmp.h>
 #include <lwip/prot/dns.h>

@@ -22,8 +22,7 @@

 */

-#ifndef MDNS_PRIV_H
-#define MDNS_PRIV_H
+#pragma once

 namespace esp8266 {

@@ -186,5 +185,3 @@ namespace MDNSImplementation {

 // Include the main header, so the submodlues only need to include this header
 #include "LEAmDNS.h"
-
-#endif  // MDNS_PRIV_H
@@ -22,9 +22,6 @@

 */

-#ifndef MDNS_LWIPDEFS_H
-#define MDNS_LWIPDEFS_H
+#pragma once

 #include <lwip/prot/dns.h>  // DNS_RRTYPE_xxx, DNS_MQUERY_PORT
-
-#endif  // MDNS_LWIPDEFS_H
@@ -3,6 +3,7 @@

 #include <FS.h>
 #include <LittleFS.h>
+#include <SDFS.h>

 // Choose the filesystem to test
 // WARNING:  The filesystem will be formatted at the start of the test!
@@ -23,9 +23,7 @@
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

-
-#ifndef __LITTLEFS_H
-#define __LITTLEFS_H
+#pragma once

 #include <limits>
 #include <FS.h>
@@ -681,6 +679,3 @@ protected:
 extern FS LittleFS;
 using littlefs_impl::LittleFSConfig;
 #endif // ARDUINO
-
-
-#endif // !defined(__LITTLEFS_H)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Earle F. Philhower, III	40855c90fb	Update version	2022-11-03 08:54:31 -07:00
Earle F. Philhower, III	6570c4856b	Fix deadlock in attachInterruptParam (#953 ) Thanks to @imwoo90 comment in https://github.com/earlephilhower/arduino-pico/issues/878#issuecomment-1302276196	2022-11-03 08:40:57 -07:00
风飘雨	008c4d62ef	Fix SerialPIO bit length, update flyboard2040 pins (#950 )	2022-11-03 08:35:40 -07:00
Earle F. Philhower, III	63dfd9ab6b	Properly disable Ethernet IRQ, don't drop packets (#951 ) Fix #944	2022-11-02 15:27:02 -07:00
Earle F. Philhower, III	9b28fc3e17	Free PIO SM on SerialPIO::end (#949 ) Fixes #945	2022-10-31 17:10:59 -07:00
Drzony	6bbaf64daf	Async scan + bugfixes (#947 ) * Support asynchronous WiFi scan * Fixed buffer overflow in getChipId * ESP compatibility fixes * fixup! ESP compatibility fixes	2022-10-31 17:01:10 -07:00
AngeloGioacchino Del Regno	44eeebbc6f	cores/rp2040: _freertos.cpp: Avoid memory leak and unnecessary allocation (#948 ) There's a memory leak around the corner: creating the mutex means that we allocate memory for it, but if we cannot find any free slot in the FMMap array, we're simply returning a nullptr without ever freeing the previously allocated memory. Instead of allocating it out of the free-slot check, do it inside. While at it, also check if the mutex creation succeeded before assigning it to a FMMap slot.	2022-10-31 14:29:00 -07:00
Earle F. Philhower, III	ec7631096b	Update GH actions to non-deprecated versions (#938 )	2022-10-27 14:35:52 -07:00
Earle F. Philhower, III	07a1484d72	Add WiFi.channel() reporting (#937 ) Also return error conditions when WiFi status is inquired while not connected.	2022-10-27 13:02:09 -07:00
Earle F. Philhower, III	9503620525	Add WiFi.BSSID() undocumented call (#936 ) Using same method as #934 and Infineon wifi-host-driver sources	2022-10-27 09:09:48 -07:00
mecparts	e05a3b8ad0	Add a way to return the RSSI value (#934 ) See https://forums.raspberrypi.com/viewtopic.php?t=341774	2022-10-27 08:00:59 -07:00
Earle F. Philhower, III	9d0b9bef67	Update version	2022-10-25 08:02:54 -07:00
per1234	0446b732fa	Add protocol-explicit `upload.tool` properties required for pluggable discovery compatibility (#933 ) A new flexible and powerful "pluggable discovery" system was added to the Arduino boards platform framework. This system makes it easy for Arduino boards platform authors to use any arbitrary communication channel between the board and development tools. Boards platform configurations that use the old property syntax are automatically translated to the new syntax by Arduino CLI: https://arduino.github.io/arduino-cli/latest/platform-specification/#sketch-upload-configuration > For backward compatibility with IDE 1.8.15 and older the previous syntax is still supported This translation is only done in platforms that use the old syntax exclusively. If `pluggable_discovery` properties are defined for the platform then the new pluggable discovery-style `upload.tool.<protocol_name>` properties must be defined for each board as well. This platform includes a "UF2 Devices" discovery tool for `uf2conv` protocol ports. This tool now uses the modern Arduino pluggable discovery system. `pluggable_discovery` properties were added to `platform.txt` in order to configure the Arduino development tools to use this pluggable discovery tool. The `upload.tool.<protocol_name>` properties in `boards.txt` were not updated at that time. Global properties of that name were added to platform.txt, but this approach is not provided for by the Arduino Platform specification: https://arduino.github.io/arduino-cli/latest/platform-specification/#sketch-upload-configuration > A specific upload.tool.<protocol_name> property should be defined for every board in boards.txt: Those missing properties caused uploads to fail for users of the recent versions of Arduino IDE and Arduino CLI with an error of the form: Error during Upload: Property 'upload.tool.<protocol_name>' is undefined (where `<protocol_name>` is the protocol of the selected port, if any) It is also important to provide compatibility with versions of Arduino development tools from before the introduction of the modern pluggable discovery system. For this reason, the old style `<board ID>.upload.tool` properties are retained. Old versions of the development tools will treat the `<board ID>.upload.tool.<protocol_name>` properties as an unused arbitrary user defined property with no special significance and the new versions of the development tools will do the same for the `upload.tool` properties.	2022-10-24 08:50:13 -07:00
Earle F. Philhower, III	c3da4ada61	Add basic Pimoroni PGA2040 board definition (#930 ) Because the board needs a unique BOOT2.S, add a definition to make it easier to use.	2022-10-22 10:19:30 -07:00
Earle F. Philhower, III	4fdcc6e5ac	Only init PWM on requested pin (#926 ) Avoid glitches on other pins, fix #919	2022-10-20 04:56:44 -07:00
Maximilian Gerhardt	b82336c8d9	Add W25Q64JV QSPI /4 Boot2 file (#929 ) Fixes #927	2022-10-20 04:25:37 -07:00
Earle F. Philhower, III	075958883f	Update version	2022-10-16 10:50:29 -07:00
Fredrik Jansson	fe632cde4b	Increase analogWrite frequency range, bugfixes (#918 ) * analogWrite: fix overflow and wrap value (#917) -avoid overflow when calculating analogScale * analogFreq, perform the multiplication in floating point. -use analogScale - 1 to set the PWM wrap value. Wrap is the highest value the counter reaches, not the counter period. * analogWrite: increase frequency range (#917) - increase frequency range to 10 MHz - decrease the lowest allowed resolution to 2 bits, and the minimal analogRange value to 3. This makes 10 MHz output possible with system clock frequencies down to 50 MHz. - allow clkdiv values >= 1.0, was 2.0. This makes it possible to manually set frequency and analogRange so that frequency * analogRange = system clock frequency. This gives the best possible frequency accuracy and resolution.	2022-10-16 10:43:49 -07:00
Earle F. Philhower, III	10090b60a9	Rewrite PicoW LWIP interface for stability (#916 ) Random crashes, infinite loops, and other lockups were happening to the PicoW while under high load from multiple clients. This seems to have been due to two issues: * The periodic sys_check_timeouts() call from an alarm/IRQ was happening while the core was in LWIP code. LWIP is not re-entrant or multi-core/thread safe so this is a bad thing. Some calls may not have been locked with a manual addition of the LWIPMutex object to hit this. * The WiFi driver supplies packet data during an interrupt. PBUF work is legal in an interrupt, but actually calling netif->input() from an IRQ to queue up the Ethernet packet for processing is illegal if LWIP is already in progress. Rearchitect the LWIP interface to fix these problems: * Disable interrupts during malloc/etc. to avoid the possibility of the periodic LWIP timeout check interrupting and potentially calling user code which did a memory operation * Wrap all used LWIP calls to note LWIP code will be executing, instead of manually eyeballing and adding in protection in user code. * Remove all user code LWIPMutex blocking, the wrapping takes care of it. * When an Ethernet packet is received by interrupt and we're in LWIP code, just throw the packet away for now. The upper layers can handle retransmit. (A possible optimization would be to set the packet aside and add a housekeeping portion to the LWIP wrappers to netif->input() them when safe). * Ignore callbacks during TCP connection teardown when the ClientContext passed from LWIP == nullptr	2022-10-15 12:00:35 -07:00
Earle F. Philhower, III	a6bdb27178	Use static allocation for IRQ stack (#915 ) noInterrupts/interrupts use a stack to allow multiple calls to work properly. The original code was using a std::stack which will use malloc() to allocate entry space. This seems like a bad idea, and makes it so it's impossible to disable interrupts for malloc/free, etc. Define a fixed stack size and use straight C code to manage the IRQ stacks. Slightly more fixed memory requirements, but significantly lower total RAM requirements and no malloc() dependency.	2022-10-14 13:46:00 -07:00
brtchip-tuannguyen	62ed93f12a	Add board BridgeTek IDM2040-7A (#912 )	2022-10-13 08:26:11 -07:00
Earle F. Philhower, III	e89ce78c79	Fix memory leak in WebServer (#914 ) Fixes #908	2022-10-12 11:25:56 -07:00
Earle F. Philhower, III	98c4b921b8	Un-hardcode LED pin in AdvancedWebServer example (#909 ) Partial #908	2022-10-11 09:30:41 -07:00
Sabas	86765cebb2	Update VID&PID HunterCatNFC 2040 (#907 )	2022-10-11 09:12:56 -07:00
Earle F. Philhower, III	25ceb08f93	Clear LWIP started flag on LWIPIntfDev::end (#905 ) When moving between different modes or even WiFi.begin/ends, any setting of the IPs will fail because the internal flag _started was not cleared. Clear _started on a ::end call. Fixes #884	2022-10-09 18:25:24 -07:00
Mücahid Kamber	205983e206	Adds Degz Mizu board (#904 )	2022-10-07 15:52:18 -07:00
Earle F. Philhower, III	1e7098c1cb	Add OpenOCD/GDB support for IDE 2.0 (#900 ) Add (undocumented) support for the debugger in the IDE 2.0.	2022-10-05 12:19:18 -07:00
Earle F. Philhower, III	68ecdfc023	Update README.md	2022-10-05 07:15:50 -07:00
Melopero	a9356ceca5	Add Melopero Cookie RP2040 (#899 )	2022-10-05 07:10:07 -07:00
Earle F. Philhower, III	69ab736cf8	Update version	2022-10-04 17:14:52 -07:00
Earle F. Philhower, III	3e758dcebb	Add TARGET_RP2040 to build defines (#898 ) Fixes #896 since it seems the Arduino.cc core defines this constant	2022-10-04 17:04:25 -07:00
Earle F. Philhower, III	b249811e28	Support IDE2, detect UF2 volumes (#897 ) Allow the IDE to detect UF2 volumes (i.e. when you hold BOOTDEL and plug in the board). Allows the IDE2 to properly upload using OTA and serial. Fixes #890 and others	2022-10-04 16:52:36 -07:00
Earle F. Philhower, III	7f216f35ab	Allow double-reset to jump to USB bootloader (#893 ) Call `rp2040.enableDoubleResetBootloader()` anywhere in the code to enable the check. W/o that call, the checker will be linked in. See #892 CORE1 doesn't start until well after the C runtime initialization, so the flag won't be overwritten. Also increase timeout to 350ms because OTA bootup can be slow.	2022-10-04 14:04:40 -07:00
Earle F. Philhower, III	029471ecca	Drive pin LOW after Tone(period) timeout (#887 ) Fixes #886	2022-09-29 13:03:49 -07:00
Earle F. Philhower, III	4cc6c36c37	Fix Serial1/2 debug output mode in CoreMutex (#883 ) Fixes #882	2022-09-26 14:19:00 -07:00
Earle F. Philhower, III	0cd5b0ac47	Allow setCTS/RTS(UART_PIN_NOT_DEFINED) (#881 ) Fixes #880	2022-09-26 08:13:44 -07:00
Earle F. Philhower, III	939c83127e	Fix deadlock during attachInterrupt (#879 ) Fixes #878	2022-09-25 10:02:48 -07:00
Tim Boldt	3768aa7e1f	Fix typo in HttpClient HTTPS example (#876 )	2022-09-24 19:23:56 -07:00
Earle F. Philhower, III	7a85c3917f	Allow setting the WiFi region for PicoW (#875 ) Fixes #874	2022-09-23 12:22:22 -07:00
Earle F. Philhower, III	cd0e83843f	Update version	2022-09-21 19:19:24 -07:00
Earle F. Philhower, III	78ce055165	Ensure ArduinoCore API is included in package (#871 )	2022-09-21 19:18:53 -07:00
Earle F. Philhower, III	d9478801ed	Update version	2022-09-21 17:56:26 -07:00
Earle F. Philhower, III	77fe24f798	Update Cytron Pico SPI pinout (#869 ) See #851. Add SPI1.	2022-09-21 17:55:41 -07:00
Brent Rubell	4e77ee02e8	Add WDT functions to RP2040 Helper (#862 )	2022-09-21 17:51:42 -07:00
Pontus Oldberg	91b4bdb58f	Adds Challenger RP2040 NFC board (#846 )	2022-09-09 07:41:33 -07:00
Dario GogliandoloandDario Gogliandolo	d6628972c5	Enabled static memory allocation with example (#842 ) Co-authored-by: Dario Gogliandolo <dario.gogliandolo@smartme.io>	2022-09-08 07:09:38 -07:00
Earle F. Philhower, III	b0d0e292c9	Minor - Add number separators (#845 )	2022-09-07 15:19:12 -07:00
Earle F. Philhower, III	e2b04e7405	Minor tweak, NULL=>nullptr (#844 )	2022-09-07 14:41:04 -07:00
Earle F. Philhower, III	f79b0867b6	Remove duplicated ArduinoCore-API files (#840 ) Use #include .... to reference them from the cores directory to ensure they keep up to date.	2022-09-06 13:21:49 -07:00
Earle F. Philhower, III	db337a9b36	Increase SerialUSB speed (#833 ) Add calls to `tud_task` to pump the USB interface in the SerialUSB methods. See #832 for more info.	2022-09-06 12:44:34 -07:00
Khoi Hoang	1303ef55b2	Add Serial3 for Arduino Nano Connect RP2040. Fix #807 (#838 )	2022-09-06 12:34:49 -07:00
Earle F. Philhower, III	85d39cf242	Restore GPIO functions on SerialUART::end (#836 ) Fix #834	2022-09-04 19:23:51 -07:00
Earle F. Philhower, III	2d777accc6	Update README.md	2022-09-04 11:38:58 -07:00
Earle F. Philhower, III	3f36f7fab1	Update README.md	2022-09-04 11:38:46 -07:00
Earle F. Philhower, III	1812b829dc	Update version	2022-09-03 09:34:46 -07:00
Earle F. Philhower, III	36d5cebde6	Remove binary info header, was crashing picotool (#831 ) Because OTA has changed the flash map from standard, picotool ends up crashing or hanging while trying to operate on the current built files. Remove the binary_info calls and structures completely to avoid any issue. Fixes #803	2022-09-02 23:17:03 -07:00
Earle F. Philhower, III	34d311fd81	Update version	2022-09-02 08:59:01 -07:00
Earle F. Philhower, III	59bd3b5144	Update DNSServer.h	2022-09-01 21:04:41 -07:00
Earle F. Philhower, III	805d20d199	Use pipes between GCC stages (#827 ) Should speed builds up slightly, depending on the OS and virus scanning.	2022-09-01 18:49:05 -07:00
Earle F. Philhower, III	166f63f955	Update PicoOTA.h	2022-08-31 14:40:53 -07:00
Earle F. Philhower, III	d2beb2da19	Add upsteam multicast compatibility APIs (#821 ) Fixes #747 while remaining ESP8266 compatible	2022-08-31 11:06:18 -07:00
Earle F. Philhower, III	7ef44d9878	Clean up WebServer send() methods (#820 ) Avoid creating Strings when sending out results.	2022-08-31 08:21:16 -07:00
Earle F. Philhower, III	408813c387	Add SDFS header to SpeedTest to simplify use	2022-08-31 08:09:42 -07:00
Earle F. Philhower, III	4d2f64a12b	Add bidirectional bulk SPI transfer, update SdFAT (#819 ) Should speed up SD transfers significantly (2.5x+). See #801	2022-08-31 07:42:34 -07:00
Earle F. Philhower, III	9997461e3a	Shrink MIME table flash usage by ~500 bytes (#818 ) Decreases WebServer sketch sizes.	2022-08-30 19:21:57 -07:00
Earle F. Philhower, III	4699522299	Remove completed TODO	2022-08-30 16:28:24 -07:00
Earle F. Philhower, III	a582ca7b95	Avoid potential lockup w/Serial.read unconnected (#817 ) Fixes #816 If a byte is available, return it even if the USB stack reports disconnected.	2022-08-30 12:05:08 -07:00
Filipe Mendonça	024ae9bb42	Fix WiFi MAC Address string output (#812 ) Fixes #811	2022-08-29 17:51:40 -07:00
Earle F. Philhower, III	38bcf4f956	Minor WebServer style/unused var cleanup (#810 )	2022-08-29 13:25:32 -07:00
Earle F. Philhower, III	486caf42a0	Remove microscopic malloc() from WebServer (#809 ) Don't try and heap allocate temporaty <16b chunks.	2022-08-29 12:35:14 -07:00
Earle F. Philhower, III	92f2ca9108	Don't re-initialize ADC for every reading (#808 )	2022-08-29 11:46:05 -07:00
Earle F. Philhower, III	bde4da2b7e	Protect core/Newlib mutexes from task preemption under FreeRTOS (#798 ) Fixes #795 Replace all CoreMutex and Newlib mutex accesses with FreeRTOS calls when in FreeRTOS mode. Avoid issues with hange/etc. due to priority inversion. No changes to normal operating mode. Add a FreeRTOS stress test that caught the issue fixed here.	2022-08-29 08:56:59 -07:00
Earle F. Philhower, III	b4b1c39049	Add ExteremeElectric JSON	2022-08-28 12:38:14 -07:00
Earle F. Philhower, III	b233cb6e7f	Identify boards when in compound USB device mode (#806 ) Allows the IDE to detect boards when using the Keyboard, Joystick, or Mouse libraries. Thanks @DaleMitchell for the idea!	2022-08-28 12:34:06 -07:00
Danilo Campos	95d1bfb760	Add Home Assistant starter to tutorials listing (#804 )	2022-08-28 09:45:49 -07:00
Earle F. Philhower, III	064dd4794f	Minor header/directrory cleanup (#802 )	2022-08-27 13:04:57 -07:00