Update version

This should reduce the `git submodule update` space required as well as
avoid the max-path-len errors under Windows in most cases.

.github/workflows/release-to-publish.yml

@@ -19,18 +19,18 @@ jobs:
         key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}
         restore-keys: |
           ${{ runner.os }}-pip-
-    - name: Cache PlatformIO
-      uses: actions/cache@v3
-      with:
-        path: ~/.platformio
-        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
     - uses: actions/setup-python@v4
       with:
-        python-version: '3.x'
-    - name: Install PlatformIO
-      run: |
-        python -m pip install --upgrade pip
-        pip install --upgrade platformio
+        python-version: '3.x'          
+#     - name: Cache PlatformIO
+#       uses: actions/cache@v3
+#       with:
+#         path: ~/.platformio
+#         key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+#     - name: Install PlatformIO
+#       run: |
+#         python -m pip install --upgrade pip
+#         pip install --upgrade platformio
     - name: Deploy updated JSON
       env:
         TRAVIS_BUILD_DIR: ${{ github.workspace }}
@@ -43,5 +43,5 @@ jobs:
            curl -L -o package_rp2040_index.json "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY/releases/download/$TAG/package_rp2040_index.json"
            ./package/update_release.py --token ${CI_GITHUB_API_KEY} --repo "$GITHUB_REPOSITORY" --tag global package_rp2040_index.json
            # Upload to Platform.IO
-           curl -LO $GITHUB_SERVER_URL/$GITHUB_REPOSITORY/releases/download/$TAG/rp2040-$TAG.zip
-           pio package publish rp2040-$TAG.zip --non-interactive
+           # curl -LO $GITHUB_SERVER_URL/$GITHUB_REPOSITORY/releases/download/$TAG/rp2040-$TAG.zip
+           # pio package publish rp2040-$TAG.zip --non-interactive

cores/rp2040/CoreMutex.cpp

@@ -28,14 +28,18 @@ CoreMutex::CoreMutex(mutex_t *mutex, uint8_t option) {
     _mutex = mutex;
     _acquired = false;
     _option = option;
+    _pxHigherPriorityTaskWoken = 0; // pdFALSE
     if (__isFreeRTOS) {
         auto m = __get_freertos_mutex_for_ptr(mutex);
+
         if (__freertos_check_if_in_isr()) {
-            __freertos_mutex_take_from_isr(m);
-        } else {
-            if (!__freertos_mutex_try_take(m)) {
+            if (!__freertos_mutex_take_from_isr(m, &_pxHigherPriorityTaskWoken)) {
                 return;
             }
+            // At this point we have the mutex in ISR
+        } else {
+            // Grab the mutex normally, possibly waking other tasks to get it
+            __freertos_mutex_take(m);
         }
     } else {
         uint32_t owner;
@@ -57,7 +61,7 @@ CoreMutex::~CoreMutex() {
         if (__isFreeRTOS) {
             auto m = __get_freertos_mutex_for_ptr(_mutex);
             if (__freertos_check_if_in_isr()) {
-                __freertos_mutex_give_from_isr(m);
+                __freertos_mutex_give_from_isr(m, &_pxHigherPriorityTaskWoken);
             } else {
                 __freertos_mutex_give(m);
             }

cores/rp2040/CoreMutex.h

@@ -43,4 +43,5 @@ private:
     mutex_t *_mutex;
     bool _acquired;
     uint8_t _option;
+    BaseType_t _pxHigherPriorityTaskWoken;
 };

cores/rp2040/PIOProgram.cpp

@@ -0,0 +1,82 @@
+/*
+    RP2040 PIO utility class
+
+    Copyright (c) 2023 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 "PIOProgram.h"
+#include <map>
+
+static std::map<const pio_program_t *, int> __pioMap[2];
+auto_init_mutex(_pioMutex);
+
+
+PIOProgram::PIOProgram(const pio_program_t *pgm) {
+    _pgm = pgm;
+    _pio = nullptr;
+    _sm = -1;
+}
+
+// We leave the INSN loaded in INSN RAM
+PIOProgram::~PIOProgram() {
+    if (_pio) {
+        pio_sm_unclaim(_pio, _sm);
+    }
+}
+
+// Possibly load into a PIO and allocate a SM
+bool PIOProgram::prepare(PIO *pio, int *sm, int *offset) {
+    CoreMutex m(&_pioMutex);
+    PIO pi[2] = { pio0, pio1 };
+
+    // If it's already loaded into PIO IRAM, try and allocate in that specific PIO
+    for (int o = 0; o < 2; o++) {
+        auto p = __pioMap[o].find(_pgm);
+        if (p != __pioMap[o].end()) {
+            int idx = pio_claim_unused_sm(pi[o], false);
+            if (idx >= 0) {
+                _pio = pi[o];
+                _sm = idx;
+                *pio = pi[o];
+                *sm = idx;
+                *offset = p->second;
+                return true;
+            }
+        }
+    }
+
+    // Not in any PIO IRAM, so try and add
+    for (int o = 0; o < 2; o++) {
+        if (pio_can_add_program(pi[o], _pgm)) {
+            int idx = pio_claim_unused_sm(pi[o], false);
+            if (idx >= 0) {
+                int off = pio_add_program(pi[o], _pgm);
+                __pioMap[o].insert({_pgm, off});
+                _pio = pi[o];
+                _sm = idx;
+                *pio = pi[o];
+                *sm = idx;
+                *offset = off;
+                return true;
+            }
+        }
+    }
+
+    // Nope, no room either for SMs or INSNs
+    return false;
+}

cores/rp2040/PIOProgram.h

@@ -0,0 +1,37 @@
+/*
+    RP2040 PIO utility class
+
+    Copyright (c) 2023 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 <hardware/pio.h>
+
+// Wrapper class for PIO programs, abstracting common operations out
+class PIOProgram {
+public:
+    PIOProgram(const pio_program_t *pgm);
+    ~PIOProgram();
+    // Possibly load into a PIO and allocate a SM
+    bool prepare(PIO *pio, int *sm, int *offset);
+
+private:
+    const pio_program_t *_pgm;
+    PIO _pio;
+    int _sm;
+};

cores/rp2040/RP2040Support.h

@@ -29,7 +29,9 @@
 #include <pico/multicore.h>
 #include <pico/rand.h>
 #include <pico/util/queue.h>
+#include <pico/bootrom.h>
 #include "CoreMutex.h"
+#include "PIOProgram.h"
 #include "ccount.pio.h"
 #include <malloc.h>
 
@@ -153,65 +155,9 @@ private:
 class RP2040;
 extern RP2040 rp2040;
 extern "C" void main1();
-class PIOProgram;
-
 extern "C" char __StackLimit;
 extern "C" char __bss_end__;
 
-// Wrapper class for PIO programs, abstracting common operations out
-// TODO - Add unload/destructor
-class PIOProgram {
-public:
-    PIOProgram(const pio_program_t *pgm) {
-        _pgm = pgm;
-    }
-
-    // Possibly load into a PIO and allocate a SM
-    bool prepare(PIO *pio, int *sm, int *offset) {
-        extern mutex_t _pioMutex;
-        CoreMutex m(&_pioMutex);
-        // Is there an open slot to run in, first?
-        if (!_findFreeSM(pio, sm)) {
-            return false;
-        }
-        // Is it loaded on that PIO?
-        if (_offset[pio_get_index(*pio)] < 0) {
-            // Nope, need to load it
-            if (!pio_can_add_program(*pio, _pgm)) {
-                return false;
-            }
-            _offset[pio_get_index(*pio)] = pio_add_program(*pio, _pgm);
-        }
-        // Here it's guaranteed loaded, return values
-        // PIO and SM already set
-        *offset = _offset[pio_get_index(*pio)];
-        return true;
-    }
-
-private:
-    // Find an unused PIO state machine to grab, returns false when none available
-    static bool _findFreeSM(PIO *pio, int *sm) {
-        int idx = pio_claim_unused_sm(pio0, false);
-        if (idx >= 0) {
-            *pio = pio0;
-            *sm = idx;
-            return true;
-        }
-        idx = pio_claim_unused_sm(pio1, false);
-        if (idx >= 0) {
-            *pio = pio1;
-            *sm = idx;
-            return true;
-        }
-        return false;
-    }
-
-
-private:
-    int _offset[2] = { -1, -1 };
-    const pio_program_t *_pgm;
-};
-
 class RP2040 {
 public:
     RP2040()  { /* noop */ }
@@ -317,6 +263,13 @@ public:
         reboot();
     }
 
+    inline void rebootToBootloader() {
+        reset_usb_boot(0, 0);
+        while (1) {
+            continue;
+        }
+    }
+
     static void enableDoubleResetBootloader();
 
     void wdt_begin(uint32_t delay_ms) {

cores/rp2040/RP2040Version.h

@@ -1,5 +1,5 @@
 #pragma once
 #define ARDUINO_PICO_MAJOR 3
-#define ARDUINO_PICO_MINOR 2
-#define ARDUINO_PICO_REVISION 1
-#define ARDUINO_PICO_VERSION_STR "3.2.1"
+#define ARDUINO_PICO_MINOR 3
+#define ARDUINO_PICO_REVISION 0
+#define ARDUINO_PICO_VERSION_STR "3.3.0"

cores/rp2040/SerialUSB.cpp

@@ -188,7 +188,7 @@ static void CheckSerialReset() {
         reset_block(RESETS_RESET_USBCTRL_BITS);
         unreset_block(RESETS_RESET_USBCTRL_BITS);
         // Delay a bit, so the PC can figure out that we have disconnected.
-        sleep_ms(3);
+        busy_wait_ms(3);
         reset_usb_boot(0, 0);
         while (1); // WDT will fire here
     }

cores/rp2040/_freertos.h

@@ -35,6 +35,7 @@ extern "C" {
     struct QueueDefinition; /* Using old naming convention so as not to break kernel aware debuggers. */
     typedef struct QueueDefinition   * QueueHandle_t;
     typedef QueueHandle_t SemaphoreHandle_t;
+    typedef int32_t BaseType_t;
 #endif
 
     extern bool __freertos_check_if_in_isr() __attribute__((weak));
@@ -43,10 +44,11 @@ extern "C" {
     extern SemaphoreHandle_t _freertos_recursive_mutex_create() __attribute__((weak));
 
     extern void __freertos_mutex_take(SemaphoreHandle_t mtx) __attribute__((weak));
-    extern void __freertos_mutex_take_from_isr(SemaphoreHandle_t mtx) __attribute__((weak));
+
+    extern int __freertos_mutex_take_from_isr(SemaphoreHandle_t mtx, BaseType_t* pxHigherPriorityTaskWoken) __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_mutex_give_from_isr(SemaphoreHandle_t mtx) __attribute__((weak));
+    extern void __freertos_mutex_give_from_isr(SemaphoreHandle_t mtx, BaseType_t* pxHigherPriorityTaskWoken) __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));

cores/rp2040/main.cpp

@@ -29,8 +29,6 @@ extern "C" {
     volatile bool __otherCoreIdled = false;
 };
 
-mutex_t _pioMutex;
-
 extern void setup();
 extern void loop();
 
@@ -91,8 +89,6 @@ extern "C" int main() {
         _REENT_INIT_PTR(_impure_ptr1);
     }
 
-    mutex_init(&_pioMutex);
-
     rp2040.begin();
 
     initVariant();

cores/rp2040/sdkoverride/pico_bootsel_via_double_reset.c

@@ -6,10 +6,9 @@
     SPDX-License-Identifier: BSD-3-Clause
 */
 
-#include "pico.h"
-#include "pico/time.h"
-#include "pico/bootrom.h"
-#include "pico/binary_info.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

docs/adc.rst

@@ -12,7 +12,7 @@ need to be periodically sampled to be read by applications, easily, such as:
 * Light dependent resistors (LDR), etc.
 
 
-Up to 4 analog samples can be recorded by the hardware (``A0`` ... ``A4``), and all
+Up to 4 analog samples can be recorded by the hardware (``A0`` ... ``A3``), and all
 recording is done at 16-bit levels (but be aware that the ADC in the Pico will only
 ever return values between 0...4095).
 
@@ -29,7 +29,7 @@ ADC Input API
 ADCInput(pin0 [, pin1, pin2, pin3])
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Creates an ADC input object which will record the pins specified in the code.
-Only pins ``A0`` ... ``A4`` can be used, and they must be specified in increasing
+Only pins ``A0`` ... ``A3`` can be used, and they must be specified in increasing
 order (i.e. ``ADCInput(A0, A1);`` is valid, but ``ADCInput(A1, A0)`` is not.
 
 bool setBuffers(size_t buffers, size_t bufferWords)

docs/conf.py

@@ -54,9 +54,9 @@ author = u'Earle F. Philhower, III'
 # built documents.
 #
 # The short X.Y version.
-version = u'3.2.1'
+version = u'3.3.0'
 # The full version, including alpha/beta/rc tags.
-release = u'3.2.1'
+release = u'3.3.0'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/httpclient.rst

@@ -1,7 +1,7 @@
 HTTPClient Library
 ==================
 
-A simple HTTP requestor that can handle both HTTP and HTTP requests is
+A simple HTTP requester that can handle both HTTP and HTTPS requests is
 included as the ``HTTPClient`` library.
 
 Check the examples for use under HTTP and HTTPS configurations.  In general,

docs/i2s.rst

@@ -84,6 +84,11 @@ void flush()
 ~~~~~~~~~~~~
 Waits until all the I2S buffers have been output.
 
+void getOverUnderflow()
+~~~~~~~~~~~~~~~~~~~~~~~
+Returns a flag indicating if the I2S system ran our of data to send on output,
+or had to throw away data on input.
+
 size_t write(uint8_t/int8_t/int16_t/int32_t)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Writes a single sample of ``bitsPerSample`` to the buffer.  It is up to the
@@ -112,7 +117,7 @@ many bytes were actually written.
 
 int availableForWrite()
 ~~~~~~~~~~~~~~~~~~~~~~~
-Returns the number of L/R samples that can be written without
+Returns the amount of bytes that can be written without
 potentially blocking.
 
 int read()

docs/rp2040.rst

@@ -95,3 +95,7 @@ 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.
+
+void rp2040.rebootToBootloader()
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Will reboot the RP2040 into USB UF2 upload mode.

include/pico_base/pico/version.h

@@ -13,7 +13,7 @@
 
 #define PICO_SDK_VERSION_MAJOR    1
 #define PICO_SDK_VERSION_MINOR    5
-#define PICO_SDK_VERSION_REVISION 0
-#define PICO_SDK_VERSION_STRING   "1.5.0"
+#define PICO_SDK_VERSION_REVISION 1
+#define PICO_SDK_VERSION_STRING   "1.5.1"
 
 #endif

lib/memmap_default.ld

@@ -94,7 +94,9 @@ SECTIONS
         /* bit of a hack right now to exclude all floating point and time critical (e.g. memset, memcpy) code from
          * FLASH ... we will include any thing excluded here in .data below by default */
         *(.init)
-        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .text*)
+        /* Some of these excludes required for PicoDVI library, won't affect most code */
+        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a: *interp.c.obj *divider.S.obj *PicoDVI.cpp.o *dvi.c.o) .text*)
+
         *(.fini)
         /* Pull all c'tors into .text */
         *crtbegin.o(.ctors)

libraries/ADCInput/src/ADCInput.cpp

@@ -79,6 +79,10 @@ void ADCInput::onReceive(void(*fn)(void)) {
 }
 
 bool ADCInput::begin() {
+    if (_running) {
+        return false;
+    }
+
     _running = true;
 
     _isHolding = 0;
@@ -105,7 +109,11 @@ bool ADCInput::begin() {
     setFrequency(_freq);
 
     _arb = new AudioBufferManager(_buffers, _bufferWords, 0, INPUT, DMA_SIZE_16);
-    _arb->begin(DREQ_ADC, (volatile void*)&adc_hw->fifo);
+    if (!_arb->begin(DREQ_ADC, (volatile void*)&adc_hw->fifo)) {
+        delete _arb;
+        _arb = nullptr;
+        return false;
+    }
     _arb->setCallback(_cb);
 
     adc_fifo_drain();

libraries/AudioBufferManager/src/AudioBufferManager.cpp

@@ -20,8 +20,8 @@
 */
 
 #include <Arduino.h>
-#include "hardware/dma.h"
-#include "hardware/irq.h"
+#include <hardware/dma.h>
+#include <hardware/irq.h>
 #include "AudioBufferManager.h"
 
 static int                 __channelCount = 0;    // # of channels left.  When we hit 0, then remove our handler
@@ -78,8 +78,8 @@ AudioBufferManager::~AudioBufferManager() {
             dma_channel_abort(_channelDMA[i]);
             dma_channel_unclaim(_channelDMA[i]);
             dma_channel_acknowledge_irq0(_channelDMA[i]);
+            __channelCount--;
         }
-        __channelCount--;
         if (!__channelCount) {
             irq_set_enabled(DMA_IRQ_0, false);
             // TODO - how can we know if there are no other parts of the core using DMA0 IRQ??
@@ -114,7 +114,7 @@ bool AudioBufferManager::begin(int dreq, volatile void *pioFIFOAddr) {
 
     // Get ping and pong DMA channels
     for (auto i = 0; i < 2; i++) {
-        _channelDMA[i] = dma_claim_unused_channel(true);
+        _channelDMA[i] = dma_claim_unused_channel(false);
         if (_channelDMA[i] == -1) {
             if (i == 1) {
                 dma_channel_unclaim(_channelDMA[0]);
@@ -257,7 +257,7 @@ void __not_in_flash_func(AudioBufferManager::_dmaIRQ)(int channel) {
             _active[1] = _takeFromList(&_filled);
         }
         _overunderflow = _overunderflow | (_active[1] == _silence);
-        dma_channel_set_read_addr(channel, _active[0]->buff, false);
+        dma_channel_set_read_addr(channel, _active[1]->buff, false);
     } else {
         if (_empty) {
             _addToList(&_filled, _active[0]);
@@ -266,7 +266,7 @@ void __not_in_flash_func(AudioBufferManager::_dmaIRQ)(int channel) {
         } else {
             _overunderflow = true;
         }
-        dma_channel_set_write_addr(channel, _active[0]->buff, false);
+        dma_channel_set_write_addr(channel, _active[1]->buff, false);
     }
     dma_channel_set_trans_count(channel, _wordsPerBuffer * (_dmaSize == DMA_SIZE_16 ? 2 : 1), false);
     dma_channel_acknowledge_irq0(channel);

libraries/AudioBufferManager/src/AudioBufferManager.h

@@ -21,7 +21,7 @@
 
 #pragma once
 #include <Arduino.h>
-#include "hardware/dma.h"
+#include <hardware/dma.h>
 
 class AudioBufferManager {
 public:

libraries/BTstackLib/examples/LEDeviceScanner/LEDeviceScanner.ino

@@ -0,0 +1,68 @@
+#include <BTstackLib.h>
+#include <SPI.h>
+
+/*
+   EXAMPLE_START(LEDeviceScanner): LE Device Scanner
+
+   @text The LE Device Scanner monitors BLE device advertisements,
+   keeping track of one or more known devices as they appear.
+*/
+
+// Application state
+int counter[2] = {0, 0};
+BD_ADDR known_devices[2] = {BD_ADDR("DB:88:B6:70:9E:EB"),
+                            BD_ADDR("C9:60:BD:F2:B4:9D")
+                           };
+
+/*
+   @section Setup
+
+   @text After BTstack.setup(), BTstack is configured to call
+   advertisementCallback whenever an Advertisement was received.
+*/
+/* LISTING_START(LEDeviceScannerSetup): LE Device Scanner Setup */
+void setup(void) {
+  Serial.begin(9600);
+  BTstack.setBLEAdvertisementCallback(advertisementCallback);
+  BTstack.setup();
+  BTstack.bleStartScanning();
+}
+/* LISTING_END(LEDeviceScannerSetup): LE Device Scanner Setup */
+
+/*
+   @section Loop
+
+   @text In the standard Arduino loop() function, BTstack's loop() is called.
+*/
+/* LISTING_START(LEDeviceScannerLoop): Loop */
+void loop(void) {
+  BTstack.loop();
+}
+/* LISTING_END(LEDeviceScannerLoop): Loop */
+
+/*
+   @section Advertisement Callback
+
+   @text Whenever an Advertisement is received, isIBeacon() checks if
+   it contains an iBeacon.
+
+   If it's not an iBeacon, the BD_ADDR is compared to the address we are
+   looking for and the counter is incremented.
+*/
+/* LISTING_START(LEDeviceScannerAdvertisementCallback): Advertisement Callback
+*/
+void advertisementCallback(BLEAdvertisement *bleAdvertisement) {
+  if (!(bleAdvertisement->isIBeacon())) {
+    Serial.print("Device discovered: ");
+    Serial.println(bleAdvertisement->getBdAddr()->getAddressString());
+    for (size_t i = 0; i < sizeof(counter) / sizeof(int); i++) {
+      if (memcmp(bleAdvertisement->getBdAddr()->getAddress(),
+                 known_devices[i].getAddress(), sizeof(known_devices[i])) == 0) {
+        counter[i]++;
+        Serial.printf("Known device: %s, has been discovered %d times.\n",
+                      known_devices[i].getAddressString(), counter[i]);
+      }
+    }
+  }
+}
+/* LISTING_END(LEDeviceScannerAdvertisementCallback): Advertisement Callback */

libraries/BTstackLib/src/BTstackLib.cpp

@@ -396,9 +396,13 @@ BD_ADDR::BD_ADDR(void) {
 }
 
 BD_ADDR::BD_ADDR(const char * address_string, BD_ADDR_TYPE address_type) : address_type(address_type) {
-    (void) address_string;
-    // TODO: implement
-    // log_error("BD_ADDR::BD_ADDR(const char *, BD_ADDR_TYPE) not implemented yet!");
+    int processed = sscanf(address_string, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", address, address + 1,
+                           address + 2, address + 3, address + 4, address + 5);
+    if (processed != 6) { // Set address to zeroes if we did not get six bytes back.
+        for (int i = 0; i < 6; i++) {
+            address[i] = 0;
+        }
+    }
 }
 
 BD_ADDR::BD_ADDR(const uint8_t address[6], BD_ADDR_TYPE address_type) : address_type(address_type) {
@@ -774,6 +778,10 @@ static hci_transport_config_uart_t config = {
 static btstack_packet_callback_registration_t hci_event_callback_registration;
 
 void BTstackManager::setup(void) {
+    setup("BTstack LE Shield");
+}
+
+void BTstackManager::setup(const char * name) {
 
     //#ifdef PIN_LED
     //    pinMode(PIN_LED, OUTPUT);
@@ -822,7 +830,6 @@ void BTstackManager::setup(void) {
     const uint8_t flags[] = { 0x02, 0x01, 0x02 };
     memcpy(&adv_data[pos], flags, sizeof(flags));
     pos += sizeof(flags);
-    const char * name = "BTstack LE Shield";
     adv_data[pos++] = strlen(name) + 1;
     adv_data[pos++] = 0x09;
     memcpy(&adv_data[pos], name, strlen(name));

libraries/BTstackLib/src/BTstackLib.h

@@ -135,6 +135,7 @@ extern "C" {
     public:
         BTstackManager(void);
         void setup(void);
+        void setup(const char * name);
         void loop(void);
 
         void setPublicBdAddr(bd_addr_t addr);

libraries/FreeRTOS/src/variantHooks.cpp

@@ -58,8 +58,8 @@ extern "C" {
         xSemaphoreTake(mtx, portMAX_DELAY);
     }
 
-    void __freertos_mutex_take_from_isr(SemaphoreHandle_t mtx) {
-        xSemaphoreTakeFromISR(mtx, NULL);
+    int __freertos_mutex_take_from_isr(SemaphoreHandle_t mtx, BaseType_t* pxHigherPriorityTaskWoken) {
+        return xSemaphoreTakeFromISR(mtx, pxHigherPriorityTaskWoken);
     }
 
     int __freertos_mutex_try_take(SemaphoreHandle_t mtx) {
@@ -70,8 +70,10 @@ extern "C" {
         xSemaphoreGive(mtx);
     }
 
-    void __freertos_mutex_give_from_isr(SemaphoreHandle_t mtx) {
-        xSemaphoreGiveFromISR(mtx, NULL);
+    void __freertos_mutex_give_from_isr(SemaphoreHandle_t mtx, BaseType_t* pxHigherPriorityTaskWoken) {
+        BaseType_t hiPrio = pxHigherPriorityTaskWoken ? *pxHigherPriorityTaskWoken : pdFALSE;
+        xSemaphoreGiveFromISR(mtx, &hiPrio);
+        portYIELD_FROM_ISR(hiPrio);
     }
 
     void __freertos_recursive_mutex_take(SemaphoreHandle_t mtx) {

libraries/I2S/src/I2S.cpp

@@ -48,7 +48,7 @@ I2S::I2S(PinMode direction) {
     _freq = 48000;
     _arb = nullptr;
     _cb = nullptr;
-    _buffers = 8;
+    _buffers = 6;
     _bufferWords = 0;
     _silenceSample = 0;
     _isLSBJ = false;
@@ -56,6 +56,7 @@ I2S::I2S(PinMode direction) {
 }
 
 I2S::~I2S() {
+    end();
 }
 
 bool I2S::setBCLK(pin_size_t pin) {
@@ -138,13 +139,19 @@ void I2S::onReceive(void(*fn)(void)) {
 bool I2S::begin() {
     _running = true;
     _hasPeeked = false;
+    _isHolding = 0;
     int off = 0;
     if (!_swapClocks) {
         _i2s = new PIOProgram(_isOutput ? (_isLSBJ ? &pio_lsbj_out_program : &pio_i2s_out_program) : &pio_i2s_in_program);
     } else {
         _i2s = new PIOProgram(_isOutput ? (_isLSBJ ? &pio_lsbj_out_swap_program : &pio_i2s_out_swap_program) : &pio_i2s_in_swap_program);
     }
-    _i2s->prepare(&_pio, &_sm, &off);
+    if (!_i2s->prepare(&_pio, &_sm, &off)) {
+        _running = false;
+        delete _i2s;
+        _i2s = nullptr;
+        return false;
+    }
     if (_isOutput) {
         if (_isLSBJ) {
             pio_lsbj_out_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps, _swapClocks);
@@ -163,10 +170,17 @@ bool I2S::begin() {
         _silenceSample = (a << 16) | a;
     }
     if (!_bufferWords) {
-        _bufferWords = 16 * (_bps == 32 ? 2 : 1);
+        _bufferWords = 64 * (_bps == 32 ? 2 : 1);
     }
     _arb = new AudioBufferManager(_buffers, _bufferWords, _silenceSample, _isOutput ? OUTPUT : INPUT);
-    _arb->begin(pio_get_dreq(_pio, _sm, _isOutput), _isOutput ? &_pio->txf[_sm] : (volatile void*)&_pio->rxf[_sm]);
+    if (!_arb->begin(pio_get_dreq(_pio, _sm, _isOutput), _isOutput ? &_pio->txf[_sm] : (volatile void*)&_pio->rxf[_sm])) {
+        _running = false;
+        delete _arb;
+        _arb = nullptr;
+        delete _i2s;
+        _i2s = nullptr;
+        return false;
+    }
     _arb->setCallback(_cb);
     pio_sm_set_enabled(_pio, _sm, true);
 
@@ -187,10 +201,18 @@ void I2S::end() {
 int I2S::available() {
     if (!_running) {
         return 0;
-    } else if (_isOutput) {
-        return availableForWrite(); // Do what I mean, not what I say
     } else {
-        return _arb->available();
+        auto avail = _arb->available();
+        avail *= 4; // 4 samples per 32-bits
+        if (_bps < 24) {
+            if (_isOutput) {
+                // 16- and 8-bit can have holding bytes available
+                avail += (32 - _isHolding) / 8;
+            } else {
+                avail += _isHolding / 8;
+            }
+        }
+        return avail;
     }
 }
 
@@ -219,7 +241,7 @@ int I2S::read() {
     case 16:
         ret = _holdWord >> 16;
         _holdWord <<=  16;
-        _isHolding -= 32;
+        _isHolding -= 16;
         return ret;
     case 24:
     case 32:
@@ -399,5 +421,5 @@ int I2S::availableForWrite() {
     if (!_running || !_isOutput) {
         return 0;
     }
-    return _arb->available();
+    return available();
 }

libraries/I2S/src/I2S.h

@@ -54,6 +54,15 @@ public:
     virtual size_t write(const uint8_t *buffer, size_t size) override;
     virtual int availableForWrite() override;
 
+    // From the AR
+    bool getOverUnderflow() {
+        if (!_running) {
+            return false;
+        } else {
+            return _arb->getOverUnderflow();
+        }
+    }
+
     // Try and make I2S::write() do what makes sense, namely write
     // one sample (L or R) at the I2S configured bit width
     virtual size_t write(uint8_t s) override {

libraries/PDM/src/rp2040/PDM.cpp

@@ -5,11 +5,11 @@
 #include "OpenPDMFilter.h"
 
 extern "C" {
-#include "hardware/pio.h"
-#include "hardware/dma.h"
-#include "hardware/clocks.h"
+#include <hardware/pio.h>
+#include <hardware/dma.h>
+#include <hardware/clocks.h>
 }
-#include "hardware/sync.h"
+#include <hardware/sync.h>
 #include "pdm.pio.h"
 static PIOProgram _pdmPgm(&pdm_pio_program);
 

libraries/PWMAudio/src/PWMAudio.cpp

@@ -100,6 +100,10 @@ void PWMAudio::onTransmit(void(*fn)(void)) {
 }
 
 bool PWMAudio::begin() {
+    if (_running) {
+        return false;
+    }
+
     if (_stereo && (_pin & 1)) {
         // Illegal, need to have consecutive pins on the same PWM slice
         Serial.printf("ERROR: PWMAudio stereo mode requires pin be even\n");
@@ -118,7 +122,13 @@ bool PWMAudio::begin() {
     uint32_t ccAddr = PWM_BASE + PWM_CH0_CC_OFFSET + pwm_gpio_to_slice_num(_pin) * 20;
 
     _arb = new AudioBufferManager(_buffers, _bufferWords, 0x80008000, OUTPUT, DMA_SIZE_32);
-    _arb->begin(pwm_get_dreq(pwm_gpio_to_slice_num(_pin)), (volatile void*)ccAddr);
+    if (!_arb->begin(pwm_get_dreq(pwm_gpio_to_slice_num(_pin)), (volatile void*)ccAddr)) {
+        _running = false;
+        delete _arb;
+        _arb = nullptr;
+        return false;
+    }
+
     _arb->setCallback(_cb);
 
     return true;

libraries/WebServer/src/HTTPServer.cpp

@@ -237,73 +237,6 @@ void HTTPServer::serveStatic(const char* uri, FS& fs, const char* path, const ch
     _addRequestHandler(new StaticRequestHandler(fs, path, uri, cache_header));
 }
 
-void HTTPServer::httpHandleClient() {
-    bool keepCurrentClient = false;
-    bool callYield = false;
-
-    if (_currentClient->connected()) {
-        switch (_currentStatus) {
-        case HC_NONE:
-            // No-op to avoid C++ compiler warning
-            break;
-        case HC_WAIT_READ:
-            // Wait for data from client to become available
-            if (_currentClient->available()) {
-                switch (_parseRequest(_currentClient)) {
-                case CLIENT_REQUEST_CAN_CONTINUE:
-                    // Because HTTP_MAX_SEND_WAIT is expressed in milliseconds, it must be divided by 1000
-                    _currentClient->setTimeout(HTTP_MAX_SEND_WAIT / 1000);
-                    _contentLength = CONTENT_LENGTH_NOT_SET;
-                    _handleRequest();
-                /* fallthrough */
-                case CLIENT_REQUEST_IS_HANDLED:
-                    if (_currentClient->connected() || _currentClient->available()) {
-                        _currentStatus = HC_WAIT_CLOSE;
-                        _statusChange = millis();
-                        keepCurrentClient = true;
-                    } else {
-                        log_v("webserver: peer has closed after served\n");
-                    }
-                    break;
-                case CLIENT_MUST_STOP:
-                    log_v("Close client\n");
-                    _currentClient->stop();
-                    break;
-                case CLIENT_IS_GIVEN:
-                    // client must not be stopped but must not be handled here anymore
-                    // (example: tcp connection given to websocket)
-                    log_v("Give client\n");
-                    break;
-                } // switch _parseRequest()
-            } else { // !_currentClient->available()
-                if (millis() - _statusChange <= HTTP_MAX_DATA_WAIT) {
-                    keepCurrentClient = true;
-                }
-                callYield = true;
-            }
-            break;
-        case HC_WAIT_CLOSE:
-            // Wait for client to close the connection
-            if (millis() - _statusChange <= HTTP_MAX_CLOSE_WAIT) {
-                keepCurrentClient = true;
-                callYield = true;
-            }
-        }
-    }
-
-    if (!keepCurrentClient) {
-        if (_currentClient) {
-            delete _currentClient;
-            _currentClient = nullptr;
-        }
-        _currentStatus = HC_NONE;
-        _currentUpload.reset();
-    }
-
-    if (callYield) {
-        yield();
-    }
-}
 
 void HTTPServer::httpClose() {
     _currentStatus = HC_NONE;

libraries/WebServer/src/HTTPServer.h

@@ -41,6 +41,7 @@ enum HTTPAuthMethod { BASIC_AUTH, DIGEST_AUTH };
 #endif
 
 #define HTTP_MAX_DATA_WAIT 5000 //ms to wait for the client to send the request
+#define HTTP_MAX_DATA_AVAILABLE_WAIT 30 //ms to wait for the client to send the request when there is another client with data available
 #define HTTP_MAX_POST_WAIT 5000 //ms to wait for POST data to arrive
 #define HTTP_MAX_SEND_WAIT 5000 //ms to wait for data chunk to be ACKed
 #define HTTP_MAX_CLOSE_WAIT 2000 //ms to wait for the client to close the connection
@@ -74,7 +75,6 @@ public:
     virtual ~HTTPServer();
 
     virtual void httpClose();
-    virtual void httpHandleClient();
 
     bool authenticate(const char * username, const char * password);
     void requestAuthentication(HTTPAuthMethod mode = BASIC_AUTH, const char* realm = nullptr, const String& authFailMsg = String(""));

libraries/WebServer/src/WebServerTemplate.h

@@ -90,19 +90,93 @@ void WebServerTemplate<ServerType, DefaultPort>::handleClient() {
             _currentClient = nullptr;
         }
 
-        ClientType client = _server.available();
-        if (!client) {
+        _currentClient = new ClientType(_server.available());
+        if (!_currentClient) {
             if (_nullDelay) {
                 delay(1);
             }
             return;
         }
-
-        _currentClient = new ClientType(client);
         _currentStatus = HC_WAIT_READ;
         _statusChange = millis();
     }
-    httpHandleClient();
+    bool keepCurrentClient = false;
+    bool callYield = false;
+
+    if (_currentClient->connected()) {
+        switch (_currentStatus) {
+        case HC_NONE:
+            // No-op to avoid C++ compiler warning
+            break;
+        case HC_WAIT_READ:
+            // Wait for data from client to become available
+            if (_currentClient->available()) {
+                switch (_parseRequest(_currentClient)) {
+                case CLIENT_REQUEST_CAN_CONTINUE:
+                    // Because HTTP_MAX_SEND_WAIT is expressed in milliseconds, it must be divided by 1000
+                    _currentClient->setTimeout(HTTP_MAX_SEND_WAIT / 1000);
+                    _contentLength = CONTENT_LENGTH_NOT_SET;
+                    _handleRequest();
+                /* fallthrough */
+                case CLIENT_REQUEST_IS_HANDLED:
+                    if (_currentClient->connected() || _currentClient->available()) {
+                        _currentStatus = HC_WAIT_CLOSE;
+                        _statusChange = millis();
+                        keepCurrentClient = true;
+                    } else {
+                        //log_v("webserver: peer has closed after served\n");
+                    }
+                    break;
+                case CLIENT_MUST_STOP:
+                    //log_v("Close client\n");
+                    _currentClient->stop();
+                    break;
+                case CLIENT_IS_GIVEN:
+                    // client must not be stopped but must not be handled here anymore
+                    // (example: tcp connection given to websocket)
+                    //log_v("Give client\n");
+                    break;
+                } // switch _parseRequest()
+            } else {
+                // !_currentClient.available(): waiting for more data
+                unsigned long timeSinceChange = millis() - _statusChange;
+                // Use faster connection drop timeout if any other client has data
+                // or the buffer of pending clients is full
+                if ((_server.hasClientData() || _server.hasMaxPendingClients())
+                        && timeSinceChange > HTTP_MAX_DATA_AVAILABLE_WAIT) {
+                    //log_v("webserver: closing since there's another connection to read from\r\n");
+                } else {
+                    if (timeSinceChange > HTTP_MAX_DATA_WAIT) {
+                        //log_v("webserver: closing after read timeout\r\n");
+                    } else {
+                        keepCurrentClient = true;
+                    }
+                }
+                callYield = true;
+            }
+            break;
+        case HC_WAIT_CLOSE:
+            // Wait for client to close the connection
+            if (millis() - _statusChange <= HTTP_MAX_CLOSE_WAIT) {
+                keepCurrentClient = true;
+                callYield = true;
+            }
+        }
+    }
+
+    if (!keepCurrentClient) {
+        if (_currentClient) {
+            delete _currentClient;
+            _currentClient = nullptr;
+        }
+        _currentStatus = HC_NONE;
+        _currentUpload.reset();
+    }
+
+    if (callYield) {
+        yield();
+    }
+
 }
 
 template <typename ServerType, int DefaultPort>

libraries/lwIP_CYW43/src/utility/CYW43shim.cpp

@@ -20,10 +20,10 @@
 
 #include "CYW43shim.h"
 extern "C" {
-#include "cyw43.h"
-#include "cyw43_stats.h"
+#include <cyw43.h>
+#include <cyw43_stats.h>
 }
-#include "pico/cyw43_arch.h"
+#include <pico/cyw43_arch.h>
 #include <Arduino.h>
 
 // From cyw43_ctrl.c

package.json

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

platform.txt

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