Update version

Add VCC-GND YD-RP2040 board (#1120 )
Fixes #1109
2023-01-14 14:34:45 -08:00 · 2023-01-14 14:33:52 -08:00 · 2023-01-14 13:35:33 -08:00 · 2023-01-14 12:19:27 -08:00 · 2023-01-13 13:04:24 -08:00 · 2023-01-09 09:55:27 -08:00
61 changed files with 18381 additions and 34010 deletions
@@ -12,6 +12,7 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 # Supported Boards
 * Raspberry Pi Pico
 * Raspberry Pi Pico W
+* 0xCB Helios
 * Adafruit Feather RP2040
 * Adafruit Feather RP2040 SCORPIO
 * Adafruit ItsyBitsy RP2040
@@ -46,6 +47,7 @@ See https://arduino-pico.readthedocs.io/en/latest/ along with the examples for m
 * SparkFun ProMicro RP2040
 * SparkFun Thing Plus RP2040
 * uPesy RP2040 DevKit
+* VCC-GND YD-RP2040
 * Viyalab Mizu RP2040
 * Waveshare RP2040 Zero
 * Waveshare RP2040 One
@@ -168,6 +170,9 @@ The installed tools include a version of OpenOCD (in the pqt-openocd directory)
 * FreeRTOS SMP support
 * Overclocking and underclocking from the menus
 * digitalWrite/Read, shiftIn/Out, tone, analogWrite(PWM)/Read, temperature
+* Analog stereo audio in using DMA and the built-in ADC
+* Analog stereo audio out using PWM hardware
+* USB drive mode for data loggers (SingleFileDrive)
 * Peripherals:  SPI master, Wire(I2C) master/slave, dual UART, emulated EEPROM, I2S audio input, I2S audio output, Servo
 * printf (i.e. debug) output over USB serial

@@ -70,10 +70,14 @@ void noInterrupts();
 #define portModeRegister(port)      ((volatile uint32_t*) sio_hw->gpio_oe)
 #define digitalWriteFast(pin, val)  (val ? sio_hw->gpio_set = (1 << pin) : sio_hw->gpio_clr = (1 << pin))
 #define digitalReadFast(pin)        ((1 << pin) & sio_hw->gpio_in)
+#define sei() interrupts()
+#define cli() noInterrupts()

 // ADC RP2040-specific calls
 void analogReadResolution(int bits);
+#ifdef __cplusplus
 float analogReadTemp(float vref = 3.3);  // Returns core temp in Centigrade
+#endif

 // PWM RP2040-specific calls
 void analogWriteFreq(uint32_t freq);
@@ -33,6 +33,10 @@
 #include "hardware/irq.h"
 #include "pico/mutex.h"
 #include "pico/unique_id.h"
+#include "pico/usb_reset_interface.h"
+#include "hardware/watchdog.h"
+#include "pico/bootrom.h"
+#include <device/usbd_pvt.h>

 // Big, global USB mutex, shared with all USB devices to make sure we don't
 // have multiple cores updating the TUSB state in parallel
@@ -67,6 +71,7 @@ static int __usb_task_irq;
 #define USBD_STR_PRODUCT (0x02)
 #define USBD_STR_SERIAL (0x03)
 #define USBD_STR_CDC (0x04)
+#define USBD_STR_RPI_RESET (0x05)

 #define EPNUM_HID   0x83

@@ -74,6 +79,11 @@ static int __usb_task_irq;
 #define USBD_MSC_EPIN 0x84
 #define USBD_MSC_EPSIZE 64

+#define TUD_RPI_RESET_DESCRIPTOR(_itfnum, _stridx) \
+  /* Interface */\
+  9, TUSB_DESC_INTERFACE, _itfnum, 0, 0, TUSB_CLASS_VENDOR_SPECIFIC, RESET_INTERFACE_SUBCLASS, RESET_INTERFACE_PROTOCOL, _stridx,
+
+
 const uint8_t *tud_descriptor_device_cb(void) {
    static tusb_desc_device_t usbd_desc_device = {
        .bLength = sizeof(tusb_desc_device_t),
@@ -250,6 +260,14 @@ void __SetupUSBDescriptor() {

        int usbd_desc_len = TUD_CONFIG_DESC_LEN + (__USBInstallSerial ? sizeof(cdc_desc) : 0) + (hasHID ? sizeof(hid_desc) : 0) + (__USBInstallMassStorage ? sizeof(msd_desc) : 0);

+#ifdef ENABLE_PICOTOOL_USB
+        uint8_t picotool_itf = interface_count++;
+        uint8_t picotool_desc[] = {
+            TUD_RPI_RESET_DESCRIPTOR(picotool_itf, USBD_STR_RPI_RESET)
+        };
+        usbd_desc_len += sizeof(picotool_desc);
+#endif
+
        uint8_t tud_cfg_desc[TUD_CONFIG_DESC_LEN] = {
            // Config number, interface count, string index, total length, attribute, power in mA
            TUD_CONFIG_DESCRIPTOR(1, interface_count, USBD_STR_0, usbd_desc_len, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, USBD_MAX_POWER_MA)
@@ -274,6 +292,10 @@ void __SetupUSBDescriptor() {
                memcpy(ptr, msd_desc, sizeof(msd_desc));
                ptr += sizeof(msd_desc);
            }
+#ifdef ENABLE_PICOTOOL_USB
+            memcpy(ptr, picotool_desc, sizeof(picotool_desc));
+            ptr += sizeof(picotool_desc);
+#endif
        }
    }
 }
@@ -291,6 +313,9 @@ const uint16_t *tud_descriptor_string_cb(uint8_t index, uint16_t langid) {
        [USBD_STR_PRODUCT] = "PicoArduino",
        [USBD_STR_SERIAL] = idString,
        [USBD_STR_CDC] = "Board CDC",
+#ifdef ENABLE_PICOTOOL_USB
+        [USBD_STR_RPI_RESET] = "Reset",
+#endif
    };

    if (!idString[0]) {
@@ -432,4 +457,84 @@ extern "C" void tud_msc_inquiry_cb(uint8_t lun, uint8_t vendor_id[8], uint8_t pr
 }


+
+#ifdef ENABLE_PICOTOOL_USB
+
+static uint8_t _picotool_itf_num;
+
+static void resetd_init() {
+}
+
+static void resetd_reset(uint8_t rhport) {
+    (void) rhport;
+    _picotool_itf_num = 0;
+}
+
+static uint16_t resetd_open(uint8_t rhport,
+                            tusb_desc_interface_t const *itf_desc, uint16_t max_len) {
+    (void) rhport;
+    TU_VERIFY(TUSB_CLASS_VENDOR_SPECIFIC == itf_desc->bInterfaceClass &&
+              RESET_INTERFACE_SUBCLASS == itf_desc->bInterfaceSubClass &&
+              RESET_INTERFACE_PROTOCOL == itf_desc->bInterfaceProtocol, 0);
+
+    uint16_t const drv_len = sizeof(tusb_desc_interface_t);
+    TU_VERIFY(max_len >= drv_len, 0);
+
+    _picotool_itf_num = itf_desc->bInterfaceNumber;
+    return drv_len;
+}
+
+// Support for parameterized reset via vendor interface control request
+static bool resetd_control_xfer_cb(uint8_t rhport, uint8_t stage,
+                                   tusb_control_request_t const *request) {
+    (void) rhport;
+    // nothing to do with DATA & ACK stage
+    if (stage != CONTROL_STAGE_SETUP) {
+        return true;
+    }
+
+    if (request->wIndex == _picotool_itf_num) {
+        if (request->bRequest == RESET_REQUEST_BOOTSEL) {
+            reset_usb_boot(0, (request->wValue & 0x7f));
+            // does not return, otherwise we'd return true
+        }
+
+        if (request->bRequest == RESET_REQUEST_FLASH) {
+            watchdog_reboot(0, 0, 100);
+            return true;
+        }
+
+    }
+    return false;
+}
+
+static bool resetd_xfer_cb(uint8_t rhport, uint8_t ep_addr,
+                           xfer_result_t result, uint32_t xferred_bytes) {
+    (void) rhport;
+    (void) ep_addr;
+    (void) result;
+    (void) xferred_bytes;
+    return true;
+}
+
+static usbd_class_driver_t const _resetd_driver = {
+#if CFG_TUSB_DEBUG >= 2
+    .name = "RESET",
+#endif
+    .init             = resetd_init,
+    .reset            = resetd_reset,
+    .open             = resetd_open,
+    .control_xfer_cb  = resetd_control_xfer_cb,
+    .xfer_cb          = resetd_xfer_cb,
+    .sof              = NULL
+};
+
+// Implement callback to add our custom driver
+usbd_class_driver_t const *usbd_app_driver_get_cb(uint8_t *driver_count) {
+    *driver_count = 1;
+    return &_resetd_driver;
+}
+#endif
+
+
 #endif
@@ -1,5 +1,5 @@
 #pragma once
 #define ARDUINO_PICO_MAJOR 2
 #define ARDUINO_PICO_MINOR 7
-#define ARDUINO_PICO_REVISION 0
-#define ARDUINO_PICO_VERSION_STR "2.7.0"
+#define ARDUINO_PICO_REVISION 1
+#define ARDUINO_PICO_VERSION_STR "2.7.1"
@@ -109,7 +109,7 @@ void tone(uint8_t pin, unsigned int frequency, unsigned long duration) {
        if (ret > 0) {
            newTone->alarm = ret;
        } else {
-            DEBUGCORE("ERROR: Unable to allocate timer for tone(%d, %d, %d)\n",
+            DEBUGCORE("ERROR: Unable to allocate timer for tone(%d, %d, %lu)\n",
                      pin, frequency, duration);
        }
    }
@@ -0,0 +1 @@
+#include "api/String.h"
@@ -43,10 +43,10 @@ extern "C" void analogWriteFreq(uint32_t freq) {
        return;
    }
    if (freq < 100) {
-        DEBUGCORE("ERROR: analogWriteFreq too low (%d)\n", freq);
+        DEBUGCORE("ERROR: analogWriteFreq too low (%lu)\n", freq);
        analogFreq = 100;
    } else if (freq > 10'000'000) {
-        DEBUGCORE("ERROR: analogWriteFreq too high (%d)\n", freq);
+        DEBUGCORE("ERROR: analogWriteFreq too high (%lu)\n", freq);
        analogFreq = 10'000'000;
    } else {
        analogFreq = freq;
@@ -64,7 +64,7 @@ extern "C" void analogWriteRange(uint32_t range) {
        pwmInitted = 0;
        scaleInitted = false;
    } else {
-        DEBUGCORE("ERROR: analogWriteRange out of range (%d)\n", range);
+        DEBUGCORE("ERROR: analogWriteRange out of range (%lu)\n", range);
    }
 }

@@ -90,14 +90,14 @@ extern "C" void analogWrite(pin_size_t pin, int val) {
        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);
+            DEBUGCORE("Adjusting analogWrite values PS=%d, scale=%lu\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)) < 1.0) && (analogScale >= 6)) {
            analogWriteSlowScale++;
            analogScale /= 2;
-            DEBUGCORE("Adjusting analogWrite values SS=%d, scale=%d\n", analogWriteSlowScale, analogScale);
+            DEBUGCORE("Adjusting analogWrite values SS=%d, scale=%lu\n", analogWriteSlowScale, analogScale);
        }
        scaleInitted = true;
    }
@@ -172,7 +172,7 @@ extern "C" float analogReadTemp(float vref) {
    adc_select_input(4); // Temperature sensor
    int v = adc_read();
    adc_set_temp_sensor_enabled(false);
-    float t = 27.0f - ((v * vref / pow(2, _readBits)) - 0.706f) / 0.001721f; // From the datasheet
+    float t = 27.0f - ((v * vref / 4096.0f) - 0.706f) / 0.001721f; // From the datasheet
    return t;
 }

@@ -0,0 +1,87 @@
+ADC Input Library
+=================
+
+The ADC pins can be sampled and recorded by an application using the same
+interface as the I2S or PWM Audio libraries.  This allows analog devices which
+need to be periodically sampled to be read by applications, easily, such as:
+
+* Analog electret microphones
+
+* Potentiometers
+
+* Light dependent resistors (LDR), etc.
+
+
+Up to 4 analog samples can be recorded by the hardware (``A0`` ... ``A4``), 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).
+
+The interface for the ``ADCInput`` device is very similar to the ``I2S`` input
+device, and most code can be ported simply by instantiating a ``ADCInput``
+object in lieu of an ``I2S`` input object and choosing the pins to record.
+
+Since this uses the ADC hardware, no ``analogRead`` or ``analogReadTemp`` calls are
+allowed while in use.
+
+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
+order (i.e. ``ADCInput(A0, A1);`` is valid, but ``ADCInput(A1, A0)`` is not.
+
+bool setBuffers(size_t buffers, size_t bufferWords)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Set the number of DMA buffers and their size in 32-bit words.  Call before
+``ADCInput::begin()``.
+
+When running at high sample rates, it is recommended to increase the
+``bufferWords`` to 32 or higher (i.e. ``adcinput.setBuffers(4, 32);`` ).
+
+bool setPins(pin_size_t pin [, pin1, pin2, pin3])
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Adjusts the pin to record.  Only legal before ``ADCInput::begin()``.
+
+bool setFrequency(long sampleRate)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets the ADC sampling frequency, but does not start recording (however if the
+device was already running, it will wontinue to run at the new frequency).  Note
+that every pin requested will be sampled at this frequency, one after the other.
+That is, if you have code like this:
+
+.. code:: cpp
+
+    ADCInput adc(A0, A1);
+    adc.setFrequency(1000);
+
+``A0`` will be sampled at 0ms, 1ms, 2ms, etc. and ``A1`` will be sampled at 0.5ms
+1.5ms, 2.5ms, etc.  Each input is sampled at the proper frequency but offset in time
+since there is only one active ADC at a time.
+
+bool begin()/begin(long sampleRate)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Start the ADC input up with the given sample rate, or with the value set
+using the prior ``setFrequency`` call.
+
+void end()
+~~~~~~~~~~
+Stops the ADC Input device.
+
+int read()
+~~~~~~~~~~
+Reads a single sample of recorded ADC data, as a 16-bit value.  When multiple pins are
+recorded the first read will be pin 0, the second will be pin 1, etc.  Applications need
+to keep track of which pin is being returned (normally by always reading out all pins
+at once).  Will not return until data is available.
+
+int available()
+~~~~~~~~~~~~~~~
+Returns the number of samples that can be read without potentially blocking.
+
+void onReceive(void (\*fn)(void))
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets a callback to be called when a ADC input DMA buffer is fully filled.
+Will be in an interrupt context so the specified function must operate
+quickly and not use blocking calls like delay().
@@ -54,9 +54,9 @@ author = u'Earle F. Philhower, III'
 # built documents.
 #
 # The short X.Y version.
-version = u'2.7.0'
+version = u'2.7.1'
 # The full version, including alpha/beta/rc tags.
-release = u'2.7.0'
+release = u'2.7.1'

 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
@@ -58,6 +58,12 @@ Sets the word clock frequency, but does not start the I2S device if not
 already running.  May be called after ``I2S::begin()`` to change the
 sample rate on-the-fly.

+bool setLSBJFormat()
+~~~~~~~~~~~~~~~~~~~~
+Enables LSB-J format for I2S output.  In this mode the MSB comes out at the
+same time as the LRCLK changes, and not the normal 1-cycle delay.  Useful for
+DAC chips like the PT8211.
+
 bool begin()/begin(long sampleRate)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Start the I2S device up with the given sample rate, or with the value set
@@ -30,6 +30,8 @@ For the latest version, always check https://github.com/earlephilhower/arduino-p
   Digital I/O <digital>
   EEPROM <eeprom>
   I2S Audio <i2s>
+   PWM Audio <pwm>
+   Microphone (and Analog Sensor) Input <adc>
   Serial USB and UARTs <serial>
   "Software Serial" PIO UART <piouart>
   Servo <servo>
@@ -9,14 +9,6 @@ installation.

 Installing via Arduino Boards Manager
 -------------------------------------
-**Note for Windows Users**: Please do not use the Windows Store version of
-the actual Arduino application because it has issues detecting attached Pico
-boards.  Use the "Windows ZIP" or plain "Windows" executable (EXE) download
-direct from https://arduino.cc. and allow it to install any device drivers
-it suggests.  Otherwise the Pico board may not be detected.  Also, if trying
-out the 2.0 beta Arduino please install the release 1.8 version beforehand
-to ensure needed device drivers are present.
-
 1. Open up the Arduino IDE and go to File->Preferences.
 2. In the dialog that pops up, enter the following URL in the "Additional Boards Manager URLs" field:  https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

@@ -28,6 +20,24 @@ to ensure needed device drivers are present.

   .. image:: images/install2.png

+Arduino IDE Installation Warning
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+**Note for Windows Users**: Please do not use the Windows Store version of
+the actual Arduino application because it has issues detecting attached Pico
+boards.  Use the "Windows ZIP" or plain "Windows" executable (EXE) download
+direct from https://arduino.cc. and allow it to install any device drivers
+it suggests.  Otherwise the Pico board may not be detected.  Also, if trying
+out the 2.0 beta Arduino please install the release 1.8 version beforehand
+to ensure needed device drivers are present.
+
+**Note for Linux Users**: If you installed the Arduino IDE using Flatpak, which 
+is common in Pop!_OS, Fedora, and Mint, among others, you may need to configure 
+Flatpak to allow the IDE access to files outside your home folder. The RP2040 
+device is sometimes mounted as a folder in /opt or /media, which Flatpak will 
+prevent the Arduino IDE from accessing. For Arduino IDE V2, override the filesystem
+restriction using ``flatpak override --user --filesystem=host cc.arduino.IDE2`` . For 
+For Arduino IDE < V2, use ``flatpak override --user --filesystem=host cc.arduino.arduinoide``.
+
 Installing via GIT
 ------------------
 To install via GIT (for latest and greatest versions):
@@ -125,6 +135,22 @@ For detailed usage information, please check the repo documentation available at

 * https://arduino-pico.readthedocs.io/en/latest/fs.html

+Uploading Sketches with Picotool
+--------------------------------
+Because the Picotool uses a custom device driver in the Pico to handle upload, when using the ``Upload Method->Picotool`` mode custom code needs to be run on the Pico which is not included by default for compatibility and code savings.
+
+So for the first sketch you will need to rebuild (with the ``Upload Method->Picotool`` selected in them menus) and then manually hold down BOOTSEL and insert the Pico USB cable to enter the ROM bootloader.
+
+After the initial upload, as long as the running binary was built using the ``Picotool`` upload method, then the normal upload process should work.
+
+Note that for Ubuntu and other Linux operating systems you may need to add the following lines to a new `udev` config file(``99-picotool.rules``) to allow normal users to access the special USB device the Pico exports:
+
+.. code::
+
+        echo 'SUBSYSTEM=="usb", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="0003", MODE="660", GROUP="plugdev"' | sudo tee -a /etc/udev/rules.d/98-Picotool.rules
+        echo 'SUBSYSTEM=="usb", ATTRS{idVendor}=="2e8a", ATTRS{idProduct}=="000a", MODE="660", GROUP="plugdev"' | sudo tee -a /etc/udev/rules.d/98-Picotool.rules
+        sudo udevadm control --reload
+
 Uploading Sketches with Picoprobe
 ---------------------------------
 If you have built a Raspberry Pi Picoprobe, you can use OpenOCD to handle your sketch uploads and for debugging with GDB.
@@ -0,0 +1,97 @@
+PWM Audio Library
+=================
+
+Relatively good quality analog audio out can be generated by using the
+RP2040 onboard PWM hardware.  It can drive an amplifier for speaker output,
+or be decoupled using a capacitor to drive a headphone-level signal.  Mono
+and stereo signals can be generated.
+
+All samples are sent to the ``PWMAudio`` library as **signed 16 bits per sample**.
+Due to frequency limitations of the PWM hardware, at higher bit rates
+these 16-bits will automatically be reduced to the maximum the hardware
+can handle.
+
+Multiple ``PWMAudio`` devices are supported, depending on availability of
+DMA channels.
+
+The interface for the ``PWMAudio`` device is very similar to the ``I2S``
+device, and most code can be ported simply by instantiating a ``PWMAudio``
+object in lieu of an ``I2S`` object.
+
+PWM Class API
+-------------
+
+PWMAudio(pin)
+~~~~~~~~~~~~~
+Creates a mono PWM output port.  Any pin can be used, but no ``analogWrite``
+calls are allowed to any other pins using that pin's PWM slice hardware.
+See the RP2040 datasheet for more details about PWM slices.
+
+PWMAudio(pin, true)
+~~~~~~~~~~~~~~~~~~~
+Creates a stereo PWM output port.  Only even pins (left signal) can be used, the next odd
+pin will automatically be assigned to the right channel (i.e. ``PWMAudio pwm(0, true);``
+will make GP0 as the left channel, GP1 as the right channel).  The same restriction as
+in mono mode applies.
+
+bool setBuffers(size_t buffers, size_t bufferWords)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Set the number of DMA buffers and their size in 32-bit words.
+Call before ``PWMAudio::begin()``.
+
+When running at high sample rates, it is recommended to increase the
+``bufferWords`` to 32 or higher (i.e. ``pwm.setBuffers(4, 32);`` ).
+
+bool setPin(pin_size_t pin)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Adjusts the pin to connect to the PWM audio output.  Only legal before
+``PWMAudio::begin()``.
+
+bool setStereo(bool stereo)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Adjusts the mono/stereo setting of the PWM audio output.  Only legal before
+``PWMAudio::begin()``.
+
+bool setFrequency(long sampleRate)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets the sample frequency, but does not start the PWM device (however if the
+device was already running, it will wontinue to run at the new frequency).
+
+bool begin()/begin(long sampleRate)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Start the PWM Audio device up with the given sample rate, or with the value set
+using the prior ``setFrequency`` call.
+
+void end()
+~~~~~~~~~~
+Stops the PWMAudio device.
+
+void flush()
+~~~~~~~~~~~~
+Waits until all the PWM Audio buffers have been output.
+
+size_t write(int16_t sample, bool sync = true)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Writes a single 16-bit sample to the buffer.  It is up to the user to keep track
+of left/right channels when in stereo mode.  In mono mode, one sample is written
+per timestep while in stereo mode two ``write()`` calls are required.
+
+This call will block (wait) until space is available to actually write
+the data if ``sync`` is not specified or set to ``true``.
+
+size_t write(const uint8_t \*buffer, size_t size)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Transfers number of bytes from an application buffer to the PWM Audio output buffer.
+Be aware that ``size`` is in *bytes** and not samples.  Size must be a multiple
+of **4 bytes**.  Will not block, so check the return value to find out how
+many bytes were actually written.
+
+int availableForWrite()
+~~~~~~~~~~~~~~~~~~~~~~~
+Returns the number of samples that can be written without potentially blocking.
+
+void onTransmit(void (\*fn)(void))
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Sets a callback to be called when a PWM Audio DMA buffer is fully transmitted.
+Will be in an interrupt context so the specified function must operate
+quickly and not use blocking calls like delay() or write to the PWM Audio.
@@ -9,6 +9,7 @@
 -iwithprefixbefore/pico-sdk/src/common/pico_stdlib/include
 -iwithprefixbefore/pico-sdk/src/common/pico_sync/include
 -iwithprefixbefore/pico-sdk/src/common/pico_time/include
+-iwithprefixbefore/pico-sdk/src/common/pico_usb_reset_interface/include
 -iwithprefixbefore/pico-sdk/src/common/pico_util/include
 -iwithprefixbefore/pico-sdk/src/rp2040/hardware_regs/include
 -iwithprefixbefore/pico-sdk/src/rp2040/hardware_structs/include
@@ -0,0 +1,30 @@
+/*
+   Mono analog microphone example using electret mike on A0
+   Run using the Arduino Serial Plotter to see waveform.
+   Released to the Public Domain by Earle F. Philhower, III
+
+   Wire the mike's VCC to 3.3V on the Pico, connect the mike's
+   GND to a convenient Pico GND, and then connect mike OUT to A0
+*/
+
+#include <ADCInput.h>
+
+ADCInput mike(A0);
+// For stereo/dual mikes, could use this line instead
+//   ADCInput(A0, A1);
+
+void setup() {
+  Serial.begin(115200);
+
+  mike.begin(8000);
+
+  while (1) {
+    Serial.printf("%d\n", mike.read());
+    // For stereo/dual mikes, use this line instead
+    //   Serial.printf("%d %d\n", mike.read(), mike.read());
+  }
+}
+
+void loop() {
+  /* Nothing here */
+}
@@ -0,0 +1,25 @@
+#######################################
+# Syntax Coloring Map
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+ADCInput	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+begin	KEYWORD2
+end	KEYWORD2
+
+setPins	KEYWORD2
+setFrequency	KEYWORD2
+setBuffers	KEYWORD2
+
+onReceive	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
@@ -0,0 +1,10 @@
+name=ADCInput
+version=1.0
+author=Earle F. Philhower, III <earlephilhower@yahoo.com>
+maintainer=Earle F. Philhower, III <earlephilhower@yahoo.com>
+sentence=Records ADC values (i.e. microphone, sensors) and presents an I2S-like callback/immediate read interface
+paragraph=Records ADC values (i.e. microphone, sensors) and presents an I2S-like callback/immediate read interface
+category=Communication
+url=http://github.com/earlephilhower/arduino-pico
+architectures=rp2040
+dot_a_linkage=true
@@ -0,0 +1,172 @@
+/*
+    ADCInput
+    Records ADC values (i.e. microphone, sensors) and presents an I2S-like
+    callback/immediate read interface
+
+    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 "ADCInput.h"
+#include <hardware/adc.h>
+
+ADCInput::ADCInput(pin_size_t p0, pin_size_t p1, pin_size_t p2, pin_size_t p3) {
+    _running = false;
+    setPins(p0, p1, p2, p3);
+    _freq = 48000;
+    _arb = nullptr;
+    _cb = nullptr;
+    _buffers = 8;
+    _bufferWords = 0;
+}
+
+ADCInput::~ADCInput() {
+    end();
+}
+
+bool ADCInput::setBuffers(size_t buffers, size_t bufferWords) {
+    if (_running || (buffers < 3) || (bufferWords < 8)) {
+        return false;
+    }
+    _buffers = buffers;
+    _bufferWords = bufferWords;
+    return true;
+}
+
+int ADCInput::_mask(pin_size_t p) {
+    switch (p) {
+    case 26: return 1;
+    case 27: return 2;
+    case 28: return 4;
+    case 29: return 8;
+    default: return 0;
+    }
+}
+
+bool ADCInput::setPins(pin_size_t pin0, pin_size_t pin1, pin_size_t pin2, pin_size_t pin3) {
+    if (_running) {
+        return false;
+    }
+    _pinMask = _mask(pin0) | _mask(pin1) | _mask(pin2) | _mask(pin3);
+    return true;
+}
+
+bool ADCInput::setFrequency(int newFreq) {
+    _freq = newFreq * __builtin_popcount(_pinMask); // Want to sample all channels at given frequency
+    adc_set_clkdiv(48000000.0f / _freq - 1.0f);
+    return true;
+}
+
+void ADCInput::onReceive(void(*fn)(void)) {
+    _cb = fn;
+    if (_running) {
+        _arb->setCallback(_cb);
+    }
+}
+
+bool ADCInput::begin() {
+    _running = true;
+
+    _isHolding = 0;
+
+    if (!_bufferWords) {
+        _bufferWords = 16;
+    }
+
+    // Set up the GPIOs to go to ADC
+    adc_init();
+    int cnt = 0;
+    for (int mask = 1, pin = 26; pin <= 29; mask <<= 1, pin++) {
+        if (_pinMask & mask) {
+            if (!cnt) {
+                adc_select_input(pin - 26);
+            }
+            cnt++;
+            adc_gpio_init(pin);
+        }
+    }
+    adc_set_round_robin(_pinMask);
+    adc_fifo_setup(true, true, 1, false, false);
+
+    setFrequency(_freq);
+
+    _arb = new AudioBufferManager(_buffers, _bufferWords, 0, INPUT, DMA_SIZE_16);
+    _arb->begin(DREQ_ADC, (volatile void*)&adc_hw->fifo);
+    _arb->setCallback(_cb);
+
+    adc_fifo_drain();
+
+    adc_run(true);
+
+    return true;
+}
+
+void ADCInput::end() {
+    if (_running) {
+        _running = false;
+        delete _arb;
+        _arb = nullptr;
+    }
+    adc_run(false);
+    adc_fifo_drain();
+}
+
+int ADCInput::available() {
+    if (!_running) {
+        return 0;
+    } else {
+        return _arb->available();
+    }
+}
+
+int ADCInput::read() {
+    if (!_running) {
+        return -1;
+    }
+
+    if (_hasPeeked) {
+        _hasPeeked = false;
+        return _peekSaved;
+    }
+
+    if (_isHolding <= 0) {
+        _arb->read(&_holdWord, true);
+        _isHolding = 32;
+    }
+
+    int ret = _holdWord & 0x0fff;
+    _holdWord >>= 16;
+    _isHolding -= 16;
+    return ret;
+}
+
+int ADCInput::peek() {
+    if (!_running) {
+        return -1;
+    }
+    if (!_hasPeeked) {
+        _peekSaved = read();
+        _hasPeeked = true;
+    }
+    return _peekSaved;
+}
+
+void ADCInput::flush() {
+    if (_running) {
+        _arb->flush();
+    }
+}
@@ -0,0 +1,87 @@
+/*
+    ADCInput
+    Records ADC values (i.e. microphone, sensors) and presents an I2S-like
+    callback/immediate read interface
+
+    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 <Arduino.h>
+#include "AudioBufferManager.h"
+
+class ADCInput : public Stream {
+public:
+    ADCInput(pin_size_t pin0, pin_size_t pin1 = 255, pin_size_t pin2 = 255, pin_size_t pin3 = 255);
+    virtual ~ADCInput();
+
+    bool setBuffers(size_t buffers, size_t bufferWords);
+    bool setFrequency(int newFreq);
+    bool setPins(pin_size_t pin0, pin_size_t pin1 = 255, pin_size_t pin2 = 255, pin_size_t pin3 = 255);
+
+    bool begin(long sampleRate) {
+        setFrequency(sampleRate);
+        return begin();
+    }
+
+    bool begin();
+    void end();
+
+    // from Stream
+    virtual int available() override;
+    virtual int read() override;
+    virtual int peek() override;
+    virtual void flush() override;
+
+    // from Print, not supported
+    virtual size_t write(const uint8_t *buffer, size_t size) override {
+        (void) buffer;
+        (void) size;
+        return -1;
+    }
+    virtual size_t write(uint8_t x) override {
+        (void) x;
+        return -1;
+    }
+    virtual int availableForWrite() override {
+        return 0;
+    }
+
+    // Note that these callback are called from **INTERRUPT CONTEXT** and hence
+    // should be in RAM, not FLASH, and should be quick to execute.
+    void onReceive(void(*)(void));
+
+private:
+    uint32_t _pinMask;
+
+    int _freq;
+
+    size_t _buffers;
+    size_t _bufferWords;
+
+    bool _running;
+    void (*_cb)();
+
+    bool _hasPeeked;
+    uint32_t _peekSaved;
+    uint32_t _holdWord = 0;
+    int _isHolding = 0;
+
+    int _mask(pin_size_t pin);
+
+    AudioBufferManager *_arb;
+};
@@ -59,6 +59,7 @@ AudioBufferManager::AudioBufferManager(size_t bufferCount, size_t bufferWords, i
    for (size_t i = 0; i < bufferCount; i++) {
        auto ab = new AudioBuffer;
        ab->buff = new uint32_t[_wordsPerBuffer];
+        bzero(ab->buff, _wordsPerBuffer * 4);
        ab->next = nullptr;
        _addToList(&_empty, ab);
    }
@@ -69,10 +70,12 @@ AudioBufferManager::AudioBufferManager(size_t bufferCount, size_t bufferWords, i

 AudioBufferManager::~AudioBufferManager() {
    if (_running) {
+        _running = false;
        for (auto i = 0; i < 2; i++) {
            dma_channel_set_irq0_enabled(_channelDMA[i], false);
-            dma_channel_unclaim(_channelDMA[i]);
            __channelMap[_channelDMA[i]] = nullptr;
+            dma_channel_abort(_channelDMA[i]);
+            dma_channel_unclaim(_channelDMA[i]);
        }
        __channelCount--;
        if (!__channelCount) {
@@ -133,10 +136,10 @@ bool AudioBufferManager::begin(int dreq, volatile void *pioFIFOAddr) {
        channel_config_set_irq_quiet(&c, false); // Need IRQs

        if (_isOutput) {
-            dma_channel_configure(_channelDMA[i], &c, pioFIFOAddr, _silence->buff, _wordsPerBuffer, false);
+            dma_channel_configure(_channelDMA[i], &c, pioFIFOAddr, _silence->buff, _wordsPerBuffer * (_dmaSize == DMA_SIZE_16 ? 2 : 1), false);
        } else {
            _active[i] = _takeFromList(&_empty);
-            dma_channel_configure(_channelDMA[i], &c, _active[i]->buff, pioFIFOAddr, _wordsPerBuffer, false);
+            dma_channel_configure(_channelDMA[i], &c, _active[i]->buff, pioFIFOAddr, _wordsPerBuffer * (_dmaSize == DMA_SIZE_16 ? 2 : 1), false);
        }
        dma_channel_set_irq0_enabled(_channelDMA[i], true);
        __channelMap[_channelDMA[i]] = this;
@@ -237,6 +240,9 @@ void AudioBufferManager::flush() {
 }

 void __not_in_flash_func(AudioBufferManager::_dmaIRQ)(int channel) {
+    if (!_running) {
+        return;
+    }
    if (_isOutput) {
        if (_active[0] != _silence) {
            _addToList(&_empty, _active[0]);
@@ -259,7 +265,7 @@ void __not_in_flash_func(AudioBufferManager::_dmaIRQ)(int channel) {
        }
        dma_channel_set_write_addr(channel, _active[0]->buff, false);
    }
-    dma_channel_set_trans_count(channel, _wordsPerBuffer, false);
+    dma_channel_set_trans_count(channel, _wordsPerBuffer * (_dmaSize == DMA_SIZE_16 ? 2 : 1), false);
    dma_channel_acknowledge_irq0(channel);
    if (_callback) {
        _callback();
@@ -30,7 +30,7 @@ void ps() {
  Serial.printf("# Tasks: %d\n", tasks);
  Serial.println("ID, NAME, STATE, PRIO, CYCLES");
  for (int i=0; i < tasks; i++) {
-    Serial.printf("%d: %-16s %-10s %d %lu\n", i, pxTaskStatusArray[i].pcTaskName, eTaskStateName[pxTaskStatusArray[i].eCurrentState], pxTaskStatusArray[i].uxCurrentPriority, pxTaskStatusArray[i].ulRunTimeCounter);
+    Serial.printf("%d: %-16s %-10s %d %lu\n", i, pxTaskStatusArray[i].pcTaskName, eTaskStateName[pxTaskStatusArray[i].eCurrentState], (int)pxTaskStatusArray[i].uxCurrentPriority, pxTaskStatusArray[i].ulRunTimeCounter);
  }
  delete[] pxTaskStatusArray;
 }
@@ -19,6 +19,7 @@ setDATA	KEYWORD2
 setBitsPerSample	KEYWORD2
 setFrequency	KEYWORD2
 setBuffers	KEYWORD2
+setLSBJFormat	KEYWORD2

 read8	KEYWORD2
 read16	KEYWORD2
@@ -51,6 +51,7 @@ I2S::I2S(PinMode direction) {
    _buffers = 8;
    _bufferWords = 0;
    _silenceSample = 0;
+    _isLSBJ = false;
 }

 I2S::~I2S() {
@@ -99,6 +100,14 @@ bool I2S::setFrequency(int newFreq) {
    return true;
 }

+bool I2S::setLSBJFormat() {
+    if (_running || !_isOutput) {
+        return false;
+    }
+    _isLSBJ = true;
+    return true;
+}
+
 void I2S::onTransmit(void(*fn)(void)) {
    if (_isOutput) {
        _cb = fn;
@@ -121,10 +130,14 @@ bool I2S::begin() {
    _running = true;
    _hasPeeked = false;
    int off = 0;
-    _i2s = new PIOProgram(_isOutput ? &pio_i2s_out_program : &pio_i2s_in_program);
+    _i2s = new PIOProgram(_isOutput ? (_isLSBJ ? &pio_lsbj_out_program : &pio_i2s_out_program) : &pio_i2s_in_program);
    _i2s->prepare(&_pio, &_sm, &off);
    if (_isOutput) {
-        pio_i2s_out_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps);
+        if (_isLSBJ) {
+            pio_lsbj_out_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps);
+        } else {
+            pio_i2s_out_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps);
+        }
    } else {
        pio_i2s_in_program_init(_pio, _sm, off, _pinDOUT, _pinBCLK, _bps);
    }
@@ -148,11 +161,14 @@ bool I2S::begin() {
 }

 void I2S::end() {
-    _running = false;
-    delete _arb;
-    _arb = nullptr;
-    delete _i2s;
-    _i2s = nullptr;
+    if (_running) {
+        pio_sm_set_enabled(_pio, _sm, false);
+        _running = false;
+        delete _arb;
+        _arb = nullptr;
+        delete _i2s;
+        _i2s = nullptr;
+    }
 }

 int I2S::available() {
@@ -175,9 +191,9 @@ int I2S::read() {
        return _peekSaved;
    }

-    if (_wasHolding <= 0) {
+    if (_isHolding <= 0) {
        read(&_holdWord, true);
-        _wasHolding = 32;
+        _isHolding = 32;
    }

    int ret;
@@ -185,18 +201,18 @@ int I2S::read() {
    case 8:
        ret = _holdWord >> 24;
        _holdWord <<= 8;
-        _wasHolding -= 8;
+        _isHolding -= 8;
        return ret;
    case 16:
        ret = _holdWord >> 16;
        _holdWord <<=  16;
-        _wasHolding -= 32;
+        _isHolding -= 32;
        return ret;
    case 24:
    case 32:
    default:
        ret = _holdWord;
-        _wasHolding = 0;
+        _isHolding = 0;
        return ret;
    }
 }
@@ -225,26 +241,26 @@ size_t I2S::_writeNatural(int32_t s) {
    switch (_bps) {
    case 8:
        _holdWord |= s & 0xff;
-        if (_wasHolding >= 24) {
+        if (_isHolding >= 24) {
            auto ret = write(_holdWord, true);
            _holdWord = 0;
-            _wasHolding = 0;
+            _isHolding = 0;
            return ret;
        } else {
            _holdWord <<= 8;
-            _wasHolding += 8;
+            _isHolding += 8;
            return 1;
        }
    case 16:
        _holdWord |= s & 0xffff;
-        if (_wasHolding) {
+        if (_isHolding) {
            auto ret = write(_holdWord, true);
            _holdWord = 0;
-            _wasHolding = 0;
+            _isHolding = 0;
            return ret;
        } else {
            _holdWord <<= 16;
-            _wasHolding = 16;
+            _isHolding = 16;
            return 1;
        }
    case 24:
@@ -301,13 +317,13 @@ bool I2S::read8(int8_t *l, int8_t *r) {
    if (!_running || _isOutput) {
        return false;
    }
-    if (_wasHolding) {
+    if (_isHolding) {
        *l = (_holdWord >> 8) & 0xff;
        *r = (_holdWord >> 0) & 0xff;
-        _wasHolding = 0;
+        _isHolding = 0;
    } else {
        read(&_holdWord, true);
-        _wasHolding = 16;
+        _isHolding = 16;
        *l = (_holdWord >> 24) & 0xff;
        *r = (_holdWord >> 16) & 0xff;
    }
@@ -33,6 +33,7 @@ public:
    bool setBitsPerSample(int bps);
    bool setBuffers(size_t buffers, size_t bufferWords, int32_t silenceSample = 0);
    bool setFrequency(int newFreq);
+    bool setLSBJFormat();

    bool begin(long sampleRate) {
        setFrequency(sampleRate);
@@ -104,6 +105,7 @@ private:
    size_t _buffers;
    size_t _bufferWords;
    int32_t _silenceSample;
+    bool _isLSBJ;
    bool _isOutput;

    bool _running;
@@ -116,7 +118,7 @@ private:
    bool _writtenHalf;

    int32_t _holdWord = 0;
-    int _wasHolding = 0;
+    int _isHolding = 0;

    void (*_cb)();

@@ -41,6 +41,29 @@ right:
    out pins, 1      side 0b00 ; Last bit of right also has WCLK change
    ; Loop back to beginning...

+
+.program pio_lsbj_out
+.side_set 2   ; 0 = bclk, 1=wclk
+
+; The C code should place (number of bits/sample - 2) in Y and
+; also update the SHIFTCTRL to be 24 or 32 as appropriate
+
+;                           +----- WCLK
+;                           |+---- BCLK
+    mov x, y         side 0b01
+left:
+    out pins, 1      side 0b10
+    jmp x--, left    side 0b11
+    out pins, 1      side 0b10
+
+    mov x, y         side 0b11
+right:
+    out pins, 1      side 0b00
+    jmp x--, right   side 0b01
+    out pins, 1      side 0b00
+    ; Loop back to beginning...
+
+
    
 .program pio_i2s_in ; Note this is the same as _out, just "in" and not "out"
 .side_set 2   ; 0 = bclk, 1=wclk
@@ -73,7 +96,28 @@ static inline void pio_i2s_out_program_init(PIO pio, uint sm, uint offset, uint
    pio_gpio_init(pio, clock_pin_base + 1);

    pio_sm_config sm_config = pio_i2s_out_program_get_default_config(offset);
-    
+
+    sm_config_set_out_pins(&sm_config, data_pin, 1);
+    sm_config_set_sideset_pins(&sm_config, clock_pin_base);
+    sm_config_set_out_shift(&sm_config, false, true, (bits <= 16) ? 2 * bits : bits);
+    sm_config_set_fifo_join(&sm_config, PIO_FIFO_JOIN_TX);
+
+    pio_sm_init(pio, sm, offset, &sm_config);
+
+    uint pin_mask = (1u << data_pin) | (3u << clock_pin_base);
+    pio_sm_set_pindirs_with_mask(pio, sm, pin_mask, pin_mask);
+    pio_sm_set_pins(pio, sm, 0); // clear pins
+
+    pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits - 2));
+}
+
+static inline void pio_lsbj_out_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits) {
+    pio_gpio_init(pio, data_pin);
+    pio_gpio_init(pio, clock_pin_base);
+    pio_gpio_init(pio, clock_pin_base + 1);
+
+    pio_sm_config sm_config = pio_lsbj_out_program_get_default_config(offset);
+
    sm_config_set_out_pins(&sm_config, data_pin, 1);
    sm_config_set_sideset_pins(&sm_config, clock_pin_base);
    sm_config_set_out_shift(&sm_config, false, true, (bits <= 16) ? 2 * bits : bits);
@@ -43,6 +43,41 @@ static inline pio_sm_config pio_i2s_out_program_get_default_config(uint offset)
 }
 #endif

+// ------------ //
+// pio_lsbj_out //
+// ------------ //
+
+#define pio_lsbj_out_wrap_target 0
+#define pio_lsbj_out_wrap 7
+
+static const uint16_t pio_lsbj_out_program_instructions[] = {
+    //     .wrap_target
+    0xa822, //  0: mov    x, y            side 1
+    0x7001, //  1: out    pins, 1         side 2
+    0x1841, //  2: jmp    x--, 1          side 3
+    0x7001, //  3: out    pins, 1         side 2
+    0xb822, //  4: mov    x, y            side 3
+    0x6001, //  5: out    pins, 1         side 0
+    0x0845, //  6: jmp    x--, 5          side 1
+    0x6001, //  7: out    pins, 1         side 0
+    //     .wrap
+};
+
+#if !PICO_NO_HARDWARE
+static const struct pio_program pio_lsbj_out_program = {
+    .instructions = pio_lsbj_out_program_instructions,
+    .length = 8,
+    .origin = -1,
+};
+
+static inline pio_sm_config pio_lsbj_out_program_get_default_config(uint offset) {
+    pio_sm_config c = pio_get_default_sm_config();
+    sm_config_set_wrap(&c, offset + pio_lsbj_out_wrap_target, offset + pio_lsbj_out_wrap);
+    sm_config_set_sideset(&c, 2, false, false);
+    return c;
+}
+#endif
+
 // ---------- //
 // pio_i2s_in //
 // ---------- //
@@ -92,6 +127,21 @@ static inline void pio_i2s_out_program_init(PIO pio, uint sm, uint offset, uint
    pio_sm_set_pins(pio, sm, 0); // clear pins
    pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits - 2));
 }
+static inline void pio_lsbj_out_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits) {
+    pio_gpio_init(pio, data_pin);
+    pio_gpio_init(pio, clock_pin_base);
+    pio_gpio_init(pio, clock_pin_base + 1);
+    pio_sm_config sm_config = pio_lsbj_out_program_get_default_config(offset);
+    sm_config_set_out_pins(&sm_config, data_pin, 1);
+    sm_config_set_sideset_pins(&sm_config, clock_pin_base);
+    sm_config_set_out_shift(&sm_config, false, true, (bits <= 16) ? 2 * bits : bits);
+    sm_config_set_fifo_join(&sm_config, PIO_FIFO_JOIN_TX);
+    pio_sm_init(pio, sm, offset, &sm_config);
+    uint pin_mask = (1u << data_pin) | (3u << clock_pin_base);
+    pio_sm_set_pindirs_with_mask(pio, sm, pin_mask, pin_mask);
+    pio_sm_set_pins(pio, sm, 0); // clear pins
+    pio_sm_exec(pio, sm, pio_encode_set(pio_y, bits - 2));
+}
 static inline void pio_i2s_in_program_init(PIO pio, uint sm, uint offset, uint data_pin, uint clock_pin_base, uint bits) {
    pio_gpio_init(pio, data_pin);
    pio_gpio_init(pio, clock_pin_base);
@@ -109,4 +159,3 @@ static inline void pio_i2s_in_program_init(PIO pio, uint sm, uint offset, uint d
 }

 #endif
-
@@ -457,14 +457,14 @@ public:
                if (_creation) {
                    int rc = lfs_setattr(_fs->getFS(), _name.get(), 'c', (const void *)&_creation, sizeof(_creation));
                    if (rc < 0) {
-                        DEBUGV("Unable to set creation time on '%s' to %d\n", _name.get(), _creation);
+                        DEBUGV("Unable to set creation time on '%s' to %lld\n", _name.get(), _creation);
                    }
                }
                // Add metadata with last write time
                time_t now = _timeCallback();
                int rc = lfs_setattr(_fs->getFS(), _name.get(), 't', (const void *)&now, sizeof(now));
                if (rc < 0) {
-                    DEBUGV("Unable to set last write time on '%s' to %d\n", _name.get(), now);
+                    DEBUGV("Unable to set last write time on '%s' to %lld\n", _name.get(), now);
                }
            }
        }
@@ -0,0 +1,68 @@
+/*
+  This example plays a tune that alternates between left and right channels using a simple sine wave.
+
+  Released to the public domain by Earle F. Philhower, III <earlephilhower@yahoo.com>
+*/
+
+#include <PWMAudio.h>
+
+PWMAudio pwm(0, true); // GP0 = left, GP1 = right
+
+const int freq = 48000; // Output frequency for PWM
+
+int16_t al = 0;
+int16_t ar = 0;
+
+const int notes[] = { 784, 880, 698, 349, 523 };
+const int dly[] =   { 400, 500, 700, 500, 1000 };
+const int noteCnt = sizeof(notes) / sizeof(notes[0]);
+
+int freqL = 1;
+int freqR = 1;
+
+double sineTable[128]; // Precompute sine wave in 128 steps
+
+unsigned int cnt = 0;
+void cb() {
+  while (pwm.availableForWrite()) {
+    double now = ((double)cnt) / (double)freq;
+    int fl = freqL << 7; // Prescale by 128 to avoid FP math later on
+    int fr = freqR << 7; // Prescale by 128 to avoid FP math later on
+    pwm.write((uint16_t)(al * sineTable[(int)(now * fl) & 127]));
+    pwm.write((uint16_t)(ar * sineTable[(int)(now * fr) & 127]));
+    cnt++;
+  }
+}
+
+void setup() {
+  // Set up sine table for waveform generation
+  for (int i = 0; i < 128; i++) {
+    sineTable[i] = sin(i * 2.0 * 3.14159 / 128.0);
+  }
+  pwm.setBuffers(4, 32); // Give larger buffers since we're are 48khz sample rate
+  pwm.onTransmit(cb);
+  pwm.begin(freq);
+}
+
+void loop() {
+  delay(1000);
+
+  // Send it out on the LHS
+  ar = 0;
+  for (int i = 0; i < noteCnt; i++) {
+    freqL = notes[i];
+    al = 5000;
+    delay(dly[i]);
+  }
+  al = 0;
+  delay(1000);
+
+  // Hear reply on RHS
+  for (int i = 0; i < noteCnt; i++) {
+    freqR = notes[i] / 4;
+    ar = 15000;
+    delay(dly[i]);
+  }
+  ar = 0;
+  delay(3000);
+}
@@ -17,6 +17,7 @@ end	KEYWORD2
 setPin	KEYWORD2
 setFrequency	KEYWORD2
 setBuffers	KEYWORD2
+setStereo	KEYWORD2

 onTransmit	KEYWORD2

@@ -23,7 +23,7 @@
 #include <hardware/pwm.h>


-PWMAudio::PWMAudio(pin_size_t pin) {
+PWMAudio::PWMAudio(pin_size_t pin, bool stereo) {
    _running = false;
    _pin = pin;
    _freq = 48000;
@@ -31,9 +31,11 @@ PWMAudio::PWMAudio(pin_size_t pin) {
    _cb = nullptr;
    _buffers = 8;
    _bufferWords = 0;
+    _stereo = stereo;
 }

 PWMAudio::~PWMAudio() {
+    end();
 }

 bool PWMAudio::setBuffers(size_t buffers, size_t bufferWords) {
@@ -45,11 +47,48 @@ bool PWMAudio::setBuffers(size_t buffers, size_t bufferWords) {
    return true;
 }

-bool PWMAudio::setFrequency(int newFreq) {
+bool PWMAudio::setPin(pin_size_t pin) {
    if (_running) {
        return false;
    }
+    _pin = pin;
+    return true;
+}
+
+bool PWMAudio::setStereo(bool stereo) {
+    if (_running) {
+        return false;
+    }
+    _stereo = stereo;
+    return true;
+}
+
+bool PWMAudio::setFrequency(int newFreq) {
    _freq = newFreq;
+
+    // Figure out the scale factor for PWM values
+    float fPWM = 65535.0 * _freq; // ideal
+
+    if (fPWM > clock_get_hz(clk_sys)) {
+        // Need to downscale the range to hit the frequency target
+        float pwmMax = (float) clock_get_hz(clk_sys) / (float) _freq;
+        _pwmScale = pwmMax;
+        fPWM = clock_get_hz(clk_sys);
+    } else {
+        _pwmScale = 1 << 16;
+    }
+
+    pwm_config c = pwm_get_default_config();
+    pwm_config_set_clkdiv(&c, clock_get_hz(clk_sys) / fPWM);
+    pwm_config_set_wrap(&c, _pwmScale);
+    pwm_init(pwm_gpio_to_slice_num(_pin), &c, _running);
+    gpio_set_function(_pin, GPIO_FUNC_PWM);
+    pwm_set_gpio_level(_pin, (0x8000 * _pwmScale) >> 16);
+    if (_stereo) {
+        gpio_set_function(_pin + 1, GPIO_FUNC_PWM);
+        pwm_set_gpio_level(_pin + 1, (0x8000 * _pwmScale) >> 16);
+    }
+
    return true;
 }

@@ -61,30 +100,20 @@ void PWMAudio::onTransmit(void(*fn)(void)) {
 }

 bool PWMAudio::begin() {
+    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");
+        return false;
+    }
+
    _running = true;
+    _wasHolding = false;

    if (!_bufferWords) {
        _bufferWords = 16;
    }

-    // Figure out the scale factor for PWM values
-    float fPWM = 65535.0 * _freq; // ideal
-
-    if (fPWM > clock_get_hz(clk_sys)) {
-        // Need to downscale the range to hit the frequency target
-        float pwmMax = (float) clock_get_hz(clk_sys) /(float) _freq;
-        _pwmScale = pwmMax;
-        fPWM = clock_get_hz(clk_sys);
-    } else {
-        _pwmScale = 1 << 16;
-    }
-
-    pwm_config c = pwm_get_default_config();
-    pwm_config_set_clkdiv(&c, clock_get_hz(clk_sys) / fPWM);
-    pwm_config_set_wrap(&c, _pwmScale);
-    pwm_init(pwm_gpio_to_slice_num(_pin), &c, true);
-    gpio_set_function(_pin, GPIO_FUNC_PWM);
-    pwm_set_gpio_level(_pin, (0x8000 * _pwmScale) >> 16);
+    setFrequency(_freq);

    uint32_t ccAddr = PWM_BASE + PWM_CH0_CC_OFFSET + pwm_gpio_to_slice_num(_pin) * 20;

@@ -96,9 +125,15 @@ bool PWMAudio::begin() {
 }

 void PWMAudio::end() {
-    _running = false;
-    delete _arb;
-    _arb = nullptr;
+    if (_running) {
+        _running = false;
+        pinMode(_pin, OUTPUT);
+        if (_stereo) {
+            pinMode(_pin + 1, OUTPUT);
+        }
+        delete _arb;
+        _arb = nullptr;
+    }
 }

 int PWMAudio::available() {
@@ -131,13 +166,28 @@ size_t PWMAudio::write(int16_t val, bool sync) {
        return 0;
    }
    // Go from signed -32K...32K to unsigned 0...64K
-    uint32_t sample = (uint32_t) (val + 0x8000); 
+    uint32_t sample = (uint32_t)(val + 0x8000);
    // Adjust to the real range
    sample *= _pwmScale;
    sample >>= 16;
-    // Duplicate sample since we don't care which PWM channel
-    sample = (sample & 0xffff) | (sample << 16);
-    return _arb->write(sample, sync);
+    if (!_stereo) {
+        // Duplicate sample since we don't care which PWM channel
+        sample = (sample & 0xffff) | (sample << 16);
+        return _arb->write(sample, sync);
+    } else {
+        if (_wasHolding) {
+            _holdWord = (_holdWord & 0xffff) | (sample << 16);
+            auto ret = _arb->write(_holdWord, sync);
+            if (ret) {
+                _wasHolding = false;
+            }
+            return ret;
+        } else {
+            _holdWord = sample;
+            _wasHolding = true;
+            return true;
+        }
+    }
 }

 size_t PWMAudio::write(const uint8_t *buffer, size_t size) {
@@ -25,11 +25,13 @@

 class PWMAudio : public Stream {
 public:
-    PWMAudio(pin_size_t pin);
+    PWMAudio(pin_size_t pin = 0, bool stereo = false);
    virtual ~PWMAudio();

    bool setBuffers(size_t buffers, size_t bufferWords);
    bool setFrequency(int newFreq);
+    bool setPin(pin_size_t pin);
+    bool setStereo(bool stereo = true);

    bool begin(long sampleRate) {
        setFrequency(sampleRate);
@@ -65,6 +67,8 @@ public:

 private:
    pin_size_t _pin;
+    bool _stereo;
+
    int _freq;

    size_t _buffers;
@@ -74,6 +78,9 @@ private:

    bool _running;

+    bool _wasHolding;
+    uint32_t _holdWord;
+
    void (*_cb)();

    AudioBufferManager *_arb;
@@ -178,7 +178,7 @@ void SPIClassRP2040::transfer(const void *txbuf, void *rxbuf, size_t count) {
 }

 void SPIClassRP2040::beginTransaction(SPISettings settings) {
-    DEBUGSPI("SPI::beginTransaction(clk=%d, bo=%s\n", _spis.getClockFreq(), (_spis.getBitOrder() == MSBFIRST) ? "MSB" : "LSB");
+    DEBUGSPI("SPI::beginTransaction(clk=%lu, bo=%s\n", _spis.getClockFreq(), (_spis.getBitOrder() == MSBFIRST) ? "MSB" : "LSB");
    if (_initted && settings == _spis) {
        DEBUGSPI("SPI: Reusing existing initted SPI\n");
    } else {
@@ -69,7 +69,7 @@ void setup() {
    cnt++;
  }

-  Serial.printf("Starting acquisition at %d\n", cnt);
+  Serial.printf("Starting acquisition at %lu\n", cnt);
 }

 void loop() {
@@ -245,30 +245,29 @@ int32_t SingleFileDrive::read10(uint32_t lba, uint32_t offset, void* buffer, uin
    }

    uint32_t toread = bufsize;
-    char buff[512];
    uint8_t *curbuff = (uint8_t *)buffer;

    while (bufsize > 0) {
        if (lba == 0) {
-            bootSector(buff);
+            bootSector(_sectBuff);
        } else if ((lba == 128) || (lba == 256)) {
-            fatSector(buff);
+            fatSector(_sectBuff);
        } else if (lba == 384) {
-            directorySector(buff);
+            directorySector(_sectBuff);
        } else if (lba >= 640) {
            File f = LittleFS.open(_localFile, "r");
            f.seek((lba - 640) * 512);
-            f.read((uint8_t*)buff, 512);
+            f.read((uint8_t*)_sectBuff, 512);
            f.close();
        } else {
-            memset(buff, 0, sizeof(buff));
+            memset(_sectBuff, 0, sizeof(_sectBuff));
        }

        uint32_t cplen = 512 - offset;
        if (bufsize < cplen) {
            cplen = bufsize;
        }
-        memcpy(curbuff, buff + offset, cplen);
+        memcpy(curbuff, _sectBuff + offset, cplen);
        curbuff += cplen;
        offset = 0;
        lba++;
@@ -50,6 +50,8 @@ private:
    char *_localFile = nullptr;
    char *_dosFile = nullptr;

+    char _sectBuff[512]; // Read sector region
+
    void (*_cbDelete)(uint32_t) = nullptr;
    uint32_t _cbDeleteData = 0;

@@ -129,7 +129,7 @@ bool UpdaterClass::begin(size_t size, int command) {
    _command = command;

 #ifdef DEBUG_UPDATER
-    DEBUG_UPDATER.printf_P(PSTR("[begin] _startAddress:     0x%08X (%d)\n"), _startAddress, _startAddress);
+    DEBUG_UPDATER.printf_P(PSTR("[begin] _startAddress:     0x%08lX (%lu)\n"), _startAddress, _startAddress);
    DEBUG_UPDATER.printf_P(PSTR("[begin] _size:             0x%08zX (%zd)\n"), _size, _size);
 #endif

@@ -188,7 +188,7 @@ bool UpdaterClass::end(bool evenIfRemaining) {
            _fp.read((uint8_t *)&sigLen, sizeof(uint32_t));
        }
 #ifdef DEBUG_UPDATER
-        DEBUG_UPDATER.printf_P(PSTR("[Updater] sigLen: %d\n"), sigLen);
+        DEBUG_UPDATER.printf_P(PSTR("[Updater] sigLen: %lu\n"), sigLen);
 #endif
        if (sigLen != expectedSigLen) {
            _setError(UPDATE_ERROR_SIGN);
@@ -276,7 +276,7 @@ bool UpdaterClass::end(bool evenIfRemaining) {
        picoOTA.addFile("firmware.bin");
        picoOTA.commit();
 #ifdef DEBUG_UPDATER
-        DEBUG_UPDATER.printf_P(PSTR("Staged: address:0x%08X, size:0x%08zX\n"), _startAddress, _size);
+        DEBUG_UPDATER.printf_P(PSTR("Staged: address:0x%08lX, size:0x%08zX\n"), _startAddress, _size);
 #endif
    }

@@ -32,6 +32,7 @@
 #include <WiFiClient.h>
 #include <WebServer.h>
 #include <LEAmDNS.h>
+#include <StreamString.h>

 #ifndef STASSID
 #define STASSID "your-ssid"
@@ -48,14 +49,13 @@ const int led = LED_BUILTIN;
 void handleRoot() {
  static int cnt = 0;
  digitalWrite(led, 1);
-  char temp[400];
  int sec = millis() / 1000;
  int min = sec / 60;
  int hr = min / 60;

-  snprintf(temp, 400,
-
-           "<html>\
+  StreamString temp;
+  temp.reserve(500); // Preallocate a large chunk to avoid memory fragmentation
+  temp.printf("<html>\
  <head>\
    <meta http-equiv='refresh' content='5'/>\
    <title>Pico-W Demo</title>\
@@ -70,9 +70,7 @@ void handleRoot() {
    <p>Page Count: %d</p>\
    <img src=\"/test.svg\" />\
  </body>\
-</html>",
-
-           hr, min % 60, sec % 60, rp2040.getFreeHeap(), ++cnt);
+</html>", hr, min % 60, sec % 60, rp2040.getFreeHeap(), ++cnt);
  server.send(200, "text/html", temp);
  digitalWrite(led, 0);
 }
@@ -0,0 +1,149 @@
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <LEAmDNS.h>
+
+#ifndef STASSID
+#define STASSID "your-ssid"
+#define STAPSK "your-password"
+#endif
+
+const char* ssid = STASSID;
+const char* password = STAPSK;
+
+WebServer server(80);
+
+const int led = LED_BUILTIN;
+
+void handleRoot() {
+  digitalWrite(led, 1);
+  server.send(200, "text/plain", "hello from pico w!\r\n");
+  digitalWrite(led, 0);
+}
+
+void handleNotFound() {
+  digitalWrite(led, 1);
+  String message = "File Not Found\n\n";
+  message += "URI: ";
+  message += server.uri();
+  message += "\nMethod: ";
+  message += (server.method() == HTTP_GET) ? "GET" : "POST";
+  message += "\nArguments: ";
+  message += server.args();
+  message += "\n";
+  for (uint8_t i = 0; i < server.args(); i++) {
+    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
+  }
+  server.send(404, "text/plain", message);
+  digitalWrite(led, 0);
+}
+
+void setup(void) {
+  pinMode(led, OUTPUT);
+  digitalWrite(led, 0);
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  Serial.println("");
+
+  // Wait for connection
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("");
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+
+  if (MDNS.begin("picow")) {
+    Serial.println("MDNS responder started");
+  }
+
+  server.on("/", handleRoot);
+
+  server.on("/inline", []() {
+    server.send(200, "text/plain", "this works as well");
+  });
+
+  server.on("/gif", []() {
+    static const uint8_t gif[] = {
+      0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x10, 0x00, 0x10, 0x00, 0x80, 0x01,
+      0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x2c, 0x00, 0x00, 0x00, 0x00,
+      0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x19, 0x8c, 0x8f, 0xa9, 0xcb, 0x9d,
+      0x00, 0x5f, 0x74, 0xb4, 0x56, 0xb0, 0xb0, 0xd2, 0xf2, 0x35, 0x1e, 0x4c,
+      0x0c, 0x24, 0x5a, 0xe6, 0x89, 0xa6, 0x4d, 0x01, 0x00, 0x3b
+    };
+    char gif_colored[sizeof(gif)];
+    memcpy_P(gif_colored, gif, sizeof(gif));
+    // Set the background to a random set of colors
+    gif_colored[16] = millis() % 256;
+    gif_colored[17] = millis() % 256;
+    gif_colored[18] = millis() % 256;
+    server.send(200, "image/gif", gif_colored, sizeof(gif_colored));
+  });
+
+  server.onNotFound(handleNotFound);
+
+  /////////////////////////////////////////////////////////
+  // Hook examples
+
+  server.addHook([](const String & method, const String & url, WiFiClient * client, WebServer::ContentTypeFunction contentType) {
+    (void)method;       // GET, PUT, ...
+    (void)url;          // example: /root/myfile.html
+    (void)client;       // the webserver tcp client connection
+    (void)contentType;  // contentType(".html") => "text/html"
+    Serial.printf("A useless web hook has passed\n");
+    return WebServer::CLIENT_REQUEST_CAN_CONTINUE;
+  });
+
+  server.addHook([](const String&, const String & url, WiFiClient*, WebServer::ContentTypeFunction) {
+    if (url.startsWith("/fail")) {
+      Serial.printf("An always failing web hook has been triggered\n");
+      return WebServer::CLIENT_MUST_STOP;
+    }
+    return WebServer::CLIENT_REQUEST_CAN_CONTINUE;
+  });
+
+  server.addHook([](const String&, const String & url, WiFiClient * client, WebServer::ContentTypeFunction) {
+    if (url.startsWith("/dump")) {
+      Serial.printf("The dumper web hook is on the run\n");
+
+      // Here the request is not interpreted, so we cannot for sure
+      // swallow the exact amount matching the full request+content,
+      // hence the tcp connection cannot be handled anymore by the
+      auto last = millis();
+      while ((millis() - last) < 500) {
+        char buf[32];
+        size_t len = client->read((uint8_t*)buf, sizeof(buf));
+        if (len > 0) {
+          Serial.printf("(<%d> chars)", (int)len);
+          Serial.write(buf, len);
+          last = millis();
+        }
+      }
+      // Two choices: return MUST STOP and webserver will close it
+      //                       (we already have the example with '/fail' hook)
+      // or                  IS GIVEN and webserver will forget it
+      // trying with IS GIVEN and storing it on a dumb WiFiClient.
+      // check the client connection: it should not immediately be closed
+      // (make another '/dump' one to close the first)
+      Serial.printf("\nTelling server to forget this connection\n");
+      static WiFiClient forgetme = *client;  // stop previous one if present and transfer client refcounter
+      return WebServer::CLIENT_IS_GIVEN;
+    }
+    return WebServer::CLIENT_REQUEST_CAN_CONTINUE;
+  });
+
+  // Hook examples
+  /////////////////////////////////////////////////////////
+
+  server.begin();
+  Serial.println("HTTP server started");
+}
+
+void loop(void) {
+  server.handleClient();
+  MDNS.update();
+}
@@ -249,20 +249,32 @@ void HTTPServer::httpHandleClient() {
        case HC_WAIT_READ:
            // Wait for data from client to become available
            if (_currentClient->available()) {
-                if (_parseRequest(_currentClient)) {
-                    // because HTTP_MAX_SEND_WAIT is expressed in milliseconds,
-                    // it must be divided by 1000
+                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();
-
-                    // Fix for issue with Chrome based browsers: https://github.com/espressif/arduino-esp32/issues/3652
-                    //           if (_currentClient->connected()) {
-                    //             _currentStatus = HC_WAIT_CLOSE;
-                    //             _statusChange = millis();
-                    //             keepCurrentClient = true;
-                    //           }
-                }
+                /* 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;
@@ -48,6 +48,8 @@ enum HTTPAuthMethod { BASIC_AUTH, DIGEST_AUTH };
 #define CONTENT_LENGTH_UNKNOWN ((size_t) -1)
 #define CONTENT_LENGTH_NOT_SET ((size_t) -2)

+#define WEBSERVER_HAS_HOOK 1
+
 class HTTPServer;

 typedef struct {
@@ -183,6 +185,25 @@ public:
        return _currentClient->write(file);
    }

+    // Hook
+    enum ClientFuture { CLIENT_REQUEST_CAN_CONTINUE, CLIENT_REQUEST_IS_HANDLED, CLIENT_MUST_STOP, CLIENT_IS_GIVEN };
+    typedef String(*ContentTypeFunction)(const String&);
+    using HookFunction = std::function<ClientFuture(const String& method, const String& url, WiFiClient* client, ContentTypeFunction contentType)>;
+    void addHook(HookFunction hook) {
+        if (_hook) {
+            auto previousHook = _hook;
+            _hook = [previousHook, hook](const String & method, const String & url, WiFiClient * client, ContentTypeFunction contentType) {
+                auto whatNow = previousHook(method, url, client, contentType);
+                if (whatNow == CLIENT_REQUEST_CAN_CONTINUE) {
+                    return hook(method, url, client, contentType);
+                }
+                return whatNow;
+            };
+        } else {
+            _hook = hook;
+        }
+    }
+
 protected:
    virtual size_t _currentClientWrite(const char* b, size_t l) {
        return _currentClient->write(b, l);
@@ -193,7 +214,7 @@ protected:
    void _addRequestHandler(RequestHandler* handler);
    void _handleRequest();
    void _finalizeResponse();
-    bool _parseRequest(WiFiClient* client);
+    ClientFuture _parseRequest(WiFiClient* client);
    void _parseArguments(String data);
    static String _responseCodeToString(int code);
    bool _parseForm(WiFiClient* client, String boundary, uint32_t len);
@@ -249,4 +270,6 @@ protected:
    String           _snonce;  // Store noance and opaque for future comparison
    String           _sopaque;
    String           _srealm;  // Store the Auth realm between Calls
+
+    HookFunction     _hook;
 };
@@ -78,7 +78,7 @@ static char* readBytesWithTimeout(WiFiClient* client, size_t maxLength, size_t&
    return buf;
 }

-bool HTTPServer::_parseRequest(WiFiClient* client) {
+HTTPServer::ClientFuture HTTPServer::_parseRequest(WiFiClient* client) {
    // Read the first line of HTTP request
    String req = client->readStringUntil('\r');
    client->readStringUntil('\n');
@@ -93,7 +93,7 @@ bool HTTPServer::_parseRequest(WiFiClient* client) {
    int addr_end = req.indexOf(' ', addr_start + 1);
    if (addr_start == -1 || addr_end == -1) {
        log_e("Invalid request: %s", req.c_str());
-        return false;
+        return CLIENT_MUST_STOP;
    }

    String methodStr = req.substring(0, addr_start);
@@ -110,6 +110,13 @@ bool HTTPServer::_parseRequest(WiFiClient* client) {
    _chunked = false;
    _clientContentLength = 0;  // not known yet, or invalid

+    if (_hook) {
+        auto whatNow = _hook(methodStr, url, client, mime::getContentType);
+        if (whatNow != CLIENT_REQUEST_CAN_CONTINUE) {
+            return whatNow;
+        }
+    }
+
    HTTPMethod method = HTTP_ANY;
    size_t num_methods = sizeof(_http_method_str) / sizeof(const char *);
    for (size_t i = 0; i < num_methods; i++) {
@@ -120,7 +127,7 @@ bool HTTPServer::_parseRequest(WiFiClient* client) {
    }
    if (method == HTTP_ANY) {
        log_e("Unknown HTTP Method: %s", methodStr.c_str());
-        return false;
+        return CLIENT_MUST_STOP;
    }
    _currentMethod = method;

@@ -186,7 +193,7 @@ bool HTTPServer::_parseRequest(WiFiClient* client) {
            char* plainBuf = readBytesWithTimeout(client, _clientContentLength, plainLength, HTTP_MAX_POST_WAIT);
            if ((int)plainLength < (int)_clientContentLength) {
                free(plainBuf);
-                return false;
+                return CLIENT_MUST_STOP;
            }
            if (_clientContentLength > 0) {
                if (isEncoded) {
@@ -214,7 +221,7 @@ bool HTTPServer::_parseRequest(WiFiClient* client) {
            // it IS a form
            _parseArguments(searchStr);
            if (!_parseForm(client, boundaryStr, _clientContentLength)) {
-                return false;
+                return CLIENT_MUST_STOP;
            }
        }
    } else {
@@ -249,7 +256,7 @@ bool HTTPServer::_parseRequest(WiFiClient* client) {
    log_v("Request: %s", url.c_str());
    log_v(" Arguments: %s", searchStr.c_str());

-    return true;
+    return CLIENT_REQUEST_CAN_CONTINUE;
 }

 bool HTTPServer::_collectHeader(const char* headerName, const char* headerValue) {
@@ -113,7 +113,7 @@ void loop() {
  client.setTrustAnchors(&cert);
  fetchURL(&client, host, port, path);
  finish = millis();
-  Serial.printf("Total time: %dms\n", finish - start);
+  Serial.printf("Total time: %lums\n", finish - start);

  BearSSL::Session session;
  client.setSession(&session);
@@ -122,21 +122,21 @@ void loop() {
  client.setTrustAnchors(&cert);
  fetchURL(&client, host, port, path);
  finish = millis();
-  Serial.printf("Total time: %dms\n", finish - start);
+  Serial.printf("Total time: %lums\n", finish - start);

  Serial.printf("Connecting with the just initialized session...");
  start = millis();
  client.setTrustAnchors(&cert);
  fetchURL(&client, host, port, path);
  finish = millis();
-  Serial.printf("Total time: %dms\n", finish - start);
+  Serial.printf("Total time: %lums\n", finish - start);

  Serial.printf("Connecting again with the initialized session...");
  start = millis();
  client.setTrustAnchors(&cert);
  fetchURL(&client, host, port, path);
  finish = millis();
-  Serial.printf("Total time: %dms\n", finish - start);
+  Serial.printf("Total time: %lums\n", finish - start);

  delay(10000);  // Avoid DDOSing github
 }
@@ -76,7 +76,7 @@ void fetchURL(BearSSL::WiFiClientSecure *client, const char *host, const uint16_
    } while (millis() < to);
  }
  client->stop();
-  Serial.printf("BSSL stack used: %d\n-------\n\n", stack_thunk_get_max_usage());
+  Serial.printf("BSSL stack used: %lu\n-------\n\n", stack_thunk_get_max_usage());
 }

 void fetchNoConfig() {
@@ -24,7 +24,7 @@ const char *encToString(uint8_t enc) {

 void loop() {
  delay(5000);
-  Serial.printf("Beginning scan at %d\n", millis());
+  Serial.printf("Beginning scan at %lu\n", millis());
  auto cnt = WiFi.scanNetworks();
  if (!cnt) {
    Serial.printf("No networks found\n");
@@ -34,7 +34,7 @@ void loop() {
    for (auto i = 0; i < cnt; i++) {
      uint8_t bssid[6];
      WiFi.BSSID(i, bssid);
-      Serial.printf("%32s %5s %17s %2d %4d\n", WiFi.SSID(i), encToString(WiFi.encryptionType(i)), macToString(bssid), WiFi.channel(i), WiFi.RSSI(i));
+      Serial.printf("%32s %5s %17s %2d %4ld\n", WiFi.SSID(i), encToString(WiFi.encryptionType(i)), macToString(bssid), WiFi.channel(i), WiFi.RSSI(i));
    }
  }
  Serial.printf("\n--- Sleeping ---\n\n\n");
@@ -78,7 +78,7 @@ uint8_t WiFiMulti::run(uint32_t to) {
    for (int i = 0; i < cnt; i++) {
        if (WiFi.RSSI(i) > maxRSSID) {
            for (auto j = _list.begin(); j != _list.end(); j++) {
-                DEBUGV("[WIFIMULTI] Checking for '%s' at %d\n", WiFi.SSID(i), WiFi.RSSI(i));
+                DEBUGV("[WIFIMULTI] Checking for '%s' at %ld\n", WiFi.SSID(i), WiFi.RSSI(i));
                if (!strcmp(j->ssid, WiFi.SSID(i))) {
                    hit = j;
                    maxRSSID = WiFi.RSSI(i);
@@ -184,8 +184,8 @@ static void dhcp_server_process(void *arg, struct udp_pcb *upcb, struct pbuf *p,
    (void)src_addr;
    (void)src_port;

-    // This is around 548 bytes
-    dhcp_msg_t dhcp_msg;
+    // This is around 548 bytes, so make static so it will live in the heap, not the stack (too large)
+    static dhcp_msg_t dhcp_msg;

 #define DHCP_MIN_SIZE (240 + 3)
    if (p->tot_len < DHCP_MIN_SIZE) {
@@ -651,7 +651,7 @@ protected:

    void _error(err_t err) {
        (void) err;
-        DEBUGV(":er %d 0x%08x\r\n", (int) err, (uint32_t) _datasource);
+        DEBUGV(":er %d 0x%08lx\r\n", (int) err, (uint32_t) _datasource);
        tcp_arg(_pcb, nullptr);
        tcp_sent(_pcb, nullptr);
        tcp_recv(_pcb, nullptr);
@@ -182,6 +182,9 @@ void TwoWire::onIRQ() {
        if (_onReceiveCallback && _buffLen) {
            _onReceiveCallback(_buffLen);
        }
+        _buffLen = 0;
+        _buffOff = 0;
+        _slaveStartDet = false;
        _i2c->hw->clr_restart_det;
    }
    // STOP_DET
@@ -6,7 +6,7 @@ void setup() {
  uint32_t a = rp2040.getCycleCount();
  delay(1000);
  uint32_t b = rp2040.getCycleCount();
-  Serial.printf("There are %d cycles in one second.\n\n\n", b - a);
+  Serial.printf("There are %lu cycles in one second.\n\n\n", b - a);

  delay(3000);

@@ -16,6 +16,6 @@ void setup() {
 }

 void loop() {
-  Serial.printf("%15u - %15llu\n", rp2040.getCycleCount(), rp2040.getCycleCount64());
+  Serial.printf("%15lu - %15llu\n", rp2040.getCycleCount(), rp2040.getCycleCount64());
  delay(1500);
 }
@@ -1,6 +1,6 @@
 {
  "name": "framework-arduinopico",
-  "version": "1.20700.0",
+  "version": "1.20701.0",
  "description": "Arduino Wiring-based Framework (RPi Pico RP2040)",
  "keywords": [
    "framework",
@@ -111,6 +111,8 @@ sed 's/^tools.uf2conv.network_cmd=.*//g' | \
 sed 's/^#tools.uf2conv.network_cmd=/tools.uf2conv.network_cmd=/g' | \
 sed 's/^tools.picoprobe.cmd=.*//g' | \
 sed 's/^#tools.picoprobe.cmd=/tools.picoprobe.cmd=/g' | \
+sed 's/^tools.picotool.cmd=.*//g' | \
+sed 's/^#tools.picotool.cmd=/tools.picotool.cmd=/g' | \
 sed 's/^tools.picodebug.cmd=.*//g' | \
 sed 's/^#tools.picodebug.cmd=/tools.picodebug.cmd=/g' | \
 sed 's/^discovery.rp2040.pattern=.*//g' | \
@@ -23,6 +23,9 @@
                  {
                     "name": "Raspberry Pi Pico W"
                  },
+                  {
+                     "name": "0xCB Helios"
+                  },
                  {
                     "name": "Adafruit Feather RP2040"
                  },
@@ -128,6 +131,9 @@
                  {
                     "name": "Seeed XIAO RP2040"
                  },
+                  {
+                     "name": "VCC-GND YD RP2040"
+                  },
                  {
                     "name": "Viyalab Mizu RP2040"
                  },
@@ -192,6 +198,11 @@
                     "packager": "rp2040",
                     "version": "1.5.0-a-5007782",
                     "name": "pqt-openocd"
+                  },
+                  {
+                     "packager": "rp2040",
+                     "version": "1.5.0-a-03f2812",
+                     "name": "pqt-picotool"
                  }
               ],
               "help": {
@@ -200,6 +211,61 @@
            }
         ],
         "tools": [
+            {
+               "version": "1.5.0-a-03f2812",
+               "name": "pqt-picotool",
+               "systems": [
+                  {
+                     "host": "aarch64-linux-gnu",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/aarch64-linux-gnu.picotool-03f2812.230113.tar.gz",
+                     "archiveFileName": "aarch64-linux-gnu.picotool-03f2812.230113.tar.gz",
+                     "checksum": "SHA-256:3816240a6aef8da61895227df3b1b5d7a7f95456a9e7737e25252886f649d2f3",
+                     "size": "171807"
+                  },
+                  {
+                     "host": "arm-linux-gnueabihf",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/arm-linux-gnueabihf.picotool-03f2812.230113.tar.gz",
+                     "archiveFileName": "arm-linux-gnueabihf.picotool-03f2812.230113.tar.gz",
+                     "checksum": "SHA-256:454e1a0ce9a546626bca73cdff74dfb0e06bf6603b13d5a3a4a4f0c0968fd65d",
+                     "size": "152809"
+                  },
+                  {
+                     "host": "i686-pc-linux-gnu",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/i686-linux-gnu.picotool-03f2812.230113.tar.gz",
+                     "archiveFileName": "i686-linux-gnu.picotool-03f2812.230113.tar.gz",
+                     "checksum": "SHA-256:fee7f93d65bb3db42a9fcf5683e2b038ab13875b1d5bedb304facb92e6469a37",
+                     "size": "183571"
+                  },
+                  {
+                     "host": "i686-mingw32",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/i686-w64-mingw32.picotool-03f2812.230112.zip",
+                     "archiveFileName": "i686-w64-mingw32.picotool-03f2812.230112.zip",
+                     "checksum": "SHA-256:8a37063d44e306b9315618962cd8dc14b815e998ba960a38099e45bb14bcda90",
+                     "size": "352766"
+                  },
+                  {
+                     "host": "x86_64-apple-darwin",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/x86_64-apple-darwin14.picotool-03f2812.230112.tar.gz",
+                     "archiveFileName": "x86_64-apple-darwin14.picotool-03f2812.230112.tar.gz",
+                     "checksum": "SHA-256:5b2f77ee33a7a757546ab526d3e477300bf01e787e645f64aa86daac6b19a510",
+                     "size": "852449"
+                  },
+                  {
+                     "host": "x86_64-pc-linux-gnu",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/x86_64-linux-gnu.picotool-03f2812.230113.tar.gz",
+                     "archiveFileName": "x86_64-linux-gnu.picotool-03f2812.230113.tar.gz",
+                     "checksum": "SHA-256:c6168c6948ec781ead9637ecddc357004aa0fbaca19a634a48fbfc4e48860d1a",
+                     "size": "131509"
+                  },
+                  {
+                     "host": "x86_64-mingw32",
+                     "url": "https://github.com/earlephilhower/pico-quick-toolchain/releases/download/1.5.0-a/x86_64-w64-mingw32.picotool-03f2812.230112.zip",
+                     "archiveFileName": "x86_64-w64-mingw32.picotool-03f2812.230112.zip",
+                     "checksum": "SHA-256:a5bded215b886bc8dc35520d2ae696c56e370ef6e92ca7d3a47fe82db362afa7",
+                     "size": "337118"
+                  }
+               ]
+            },
            {
               "version": "1.5.0-a-5007782",
               "name": "pqt-openocd",
@@ -20,7 +20,7 @@
 # https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5---3rd-party-Hardware-specification

 name=Raspberry Pi RP2040 Boards
-version=2.7.0
+version=2.7.1

 runtime.tools.pqt-gcc.path={runtime.platform.path}/system/arm-none-eabi
 runtime.tools.pqt-python3.path={runtime.platform.path}/system/python3
@@ -28,6 +28,7 @@ runtime.tools.pqt-mklittlefs.path={runtime.platform.path}/system/mklittlefs
 runtime.tools.pqt-pioasm.path={runtime.platform.path}/system/pioasm
 runtime.tools.pqt-elf2uf2.path={runtime.platform.path}/system/elf2uf2
 runtime.tools.pqt-openocd.path={runtime.platform.path}/system/openocd
+runtime.tools.pqt-picotool.path={runtime.platform.path}/system/picotool
 compiler.path={runtime.tools.pqt-gcc.path}/bin/

 compiler.libraries.ldflags=
@@ -44,7 +45,7 @@ compiler.warning_flags.all=-Wall -Wextra -Werror=return-type -Wno-ignored-qualif
 compiler.netdefines=-DPICO_CYW43_ARCH_THREADSAFE_BACKGROUND=1 -DCYW43_LWIP=0 {build.lwipdefs} -DLWIP_IGMP=1 -DLWIP_CHECKSUM_CTRL_PER_NETIF=1
 compiler.defines={build.led} {build.usbstack_flags} -DCFG_TUSB_MCU=OPT_MCU_RP2040 -DUSB_VID={build.vid} -DUSB_PID={build.pid} '-DUSB_MANUFACTURER={build.usb_manufacturer}' '-DUSB_PRODUCT={build.usb_product}' {compiler.netdefines} -DARDUINO_VARIANT="{build.variant}" -DTARGET_RP2040
 compiler.includes="-iprefix{runtime.platform.path}/" "@{runtime.platform.path}/lib/platform_inc.txt" "-I{runtime.platform.path}/include"
-compiler.flags=-march=armv6-m -mcpu=cortex-m0plus -mthumb -ffunction-sections -fdata-sections {build.flags.exceptions} {build.flags.stackprotect} {build.flags.cmsis}
+compiler.flags=-march=armv6-m -mcpu=cortex-m0plus -mthumb -ffunction-sections -fdata-sections {build.flags.exceptions} {build.flags.stackprotect} {build.flags.cmsis} {build.picodebugflags}
 compiler.wrap="@{runtime.platform.path}/lib/platform_wrap.txt"
 compiler.libbearssl="{runtime.platform.path}/lib/libbearssl.a"

@@ -97,6 +98,7 @@ build.boot2=boot2_generic_03h_4_padded_checksum
 build.lwipdefs=-DLWIP_IPV6=0 -DLWIP_IPV4=1
 build.wificc=-DWIFICC=CYW43_COUNTRY_WORLDWIDE
 build.debugscript=picoprobe.tcl
+build.picodebugflags=

 # Allow Pico boards do be auto-discovered by the IDE
 #discovery.rp2040.pattern={runtime.tools.pqt-python3.path}/python3 -I "{runtime.platform.path}/tools/pluggable_discovery.py"
@@ -187,6 +189,12 @@ tools.uf2conv-network.upload.params.verbose=
 tools.uf2conv-network.upload.params.quiet=
 tools.uf2conv-network.upload.pattern="{cmd}" -I "{runtime.platform.path}/tools/espota.py" -i "{upload.port.address}" -p "{upload.port.properties.port}" "--auth={upload.field.password}" -f "{build.path}/{build.project_name}.bin"

+#tools.picotool.cmd={runtime.tools.pqt-picotool.path}
+tools.picotool.cmd={runtime.platform.path}/system/picotool
+tools.picotool.upload.protocol=picotool
+tools.picotool.upload.params.verbose=
+tools.picotool.upload.params.quiet=
+tools.picotool.upload.pattern="{cmd}/picotool" load "{build.path}/{build.project_name}.uf2" -f

 #tools.picoprobe.cmd={runtime.tools.pqt-openocd.path}
 tools.picoprobe.cmd={runtime.platform.path}/system/openocd
@@ -1,8 +1,8 @@
 #!/bin/bash

 for dir in ./cores/rp2040 ./libraries/EEPROM ./libraries/I2S ./libraries/SingleFileDrive \
-           ./libraries/LittleFS/src ./libraries/LittleFS/examples \
-           ./libraries/rp2040 ./libraries/SD ./libraries/ESP8266SdFat \
+           ./libraries/LittleFS/src ./libraries/LittleFS/examples ./libraries/PWMAudio \
+           ./libraries/rp2040 ./libraries/SD ./libraries/ESP8266SdFat ./libraries/ADCInput \
           ./libraries/Servo ./libraries/SPI ./libraries/Wire ./libraries/PDM \
           ./libraries/WiFi ./libraries/lwIP_Ethernet ./libraries/lwIP_CYW43 \
           ./libraries/FreeRTOS/src ./libraries/LEAmDNS ./libraries/MD5Builder \
@@ -0,0 +1,54 @@
+{
+  "build": {
+    "arduino": {
+      "earlephilhower": {
+        "boot2_source": "boot2_w25q080_2_padded_checksum.S",
+        "usb_vid": "0x1209",
+        "usb_pid": "0xCB74"
+      }
+    },
+    "core": "earlephilhower",
+    "cpu": "cortex-m0plus",
+    "extra_flags": "-D ARDUINO_0XCB_HELIOS -DARDUINO_ARCH_RP2040 -DUSBD_MAX_POWER_MA=500",
+    "f_cpu": "133000000L",
+    "hwids": [
+      [
+        "0x2E8A",
+        "0x00C0"
+      ],
+      [
+        "0x1209",
+        "0xCB74"
+      ]
+    ],
+    "mcu": "rp2040",
+    "variant": "0xcb_helios"
+  },
+  "debug": {
+    "jlink_device": "RP2040_M0_0",
+    "openocd_target": "rp2040.cfg",
+    "svd_path": "rp2040.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "Helios",
+  "upload": {
+    "maximum_ram_size": 270336,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "native_usb": true,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": false,
+    "protocol": "picotool",
+    "protocols": [
+      "cmsis-dap",
+      "jlink",
+      "raspberrypi-swd",
+      "picotool",
+      "picoprobe"
+    ]
+  },
+  "url": "https://www.raspberrypi.org/products/raspberry-pi-pico/",
+  "vendor": "0xCB"
+}
@@ -79,8 +79,6 @@ def BuildUSBStack(name):
    print('%s.menu.usbstack.picosdk.build.usbstack_flags=' % (name))
    print("%s.menu.usbstack.tinyusb=Adafruit TinyUSB" % (name))
    print('%s.menu.usbstack.tinyusb.build.usbstack_flags=-DUSE_TINYUSB "-I{runtime.platform.path}/libraries/Adafruit_TinyUSB_Arduino/src/arduino"' % (name))
-
-def BuildWithoutUSBStack(name):
    print("%s.menu.usbstack.nousb=No USB" % (name))
    print('%s.menu.usbstack.nousb.build.usbstack_flags="-DNO_USB -DDISABLE_USB_SERIAL -I{runtime.platform.path}/tools/libpico"' % (name))

@@ -103,7 +101,26 @@ def BuildIPStack(name):
    print('%s.menu.ipstack.ipv4ipv6.build.libpico=libpico-ipv6.a' % (name))
    print('%s.menu.ipstack.ipv4ipv6.build.lwipdefs=-DLWIP_IPV6=1 -DLWIP_IPV4=1' % (name))

-def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, pwr, boarddefine, variant, uploadtool, networkuploadtool, flashsize, ramsize, boot2, dbg, extra):
+def BuildUploadMethodMenu(name):
+    for a, b, c, d, e, f in [ ["default", "Default (UF2)", 256, "picoprobe.tcl", "uf2conv", "uf2conv-network"],
+                              ["picotool", "Picotool", 256, "picoprobe.tcl", "picotool", None],
+                              ["picoprobe", "Picoprobe", 256, "picoprobe.tcl", "picoprobe", None],
+                              ["picodebug", "Pico-Debug", 240, "picodebug.tcl", "picodebug", None] ]:
+        print("%s.menu.uploadmethod.%s=%s" % (name, a, b))
+        print("%s.menu.uploadmethod.%s.build.ram_length=%dk" % (name, a, c))
+        print("%s.menu.uploadmethod.%s.build.debugscript=%s" % (name, a, d))
+        # For pico-debug, need to disable USB unconditionally
+        if a == "picodebug":
+            print("%s.menu.uploadmethod.%s.build.picodebugflags=-UUSE_TINYUSB -DNO_USB -DDISABLE_USB_SERIAL -I{runtime.platform.path}/tools/libpico" % (name, a))
+        elif a == "picotool":
+            print("%s.menu.uploadmethod.%s.build.picodebugflags=-DENABLE_PICOTOOL_USB" % (name, a))
+        print("%s.menu.uploadmethod.%s.upload.maximum_data_size=%d" % (name, a, c * 1024))
+        print("%s.menu.uploadmethod.%s.upload.tool=%s" % (name, a, e))
+        print("%s.menu.uploadmethod.%s.upload.tool.default=%s" % (name, a, e))
+        if f != None:
+            print("%s.menu.uploadmethod.%s.upload.tool.network=%s" % (name, a, f))
+
+def BuildHeader(name, vendor_name, product_name, vid, pid, pwr, boarddefine, variant, flashsize, boot2, extra):
    prettyname = vendor_name + " " + product_name
    print()
    print("# -----------------------------------")
@@ -111,17 +128,17 @@ def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, p
    print("# -----------------------------------")
    print("%s.name=%s" % (name, prettyname))
    usb = 0
-    if type(pidtouse) == list:
+    if type(pid) == list:
        for tp in pid:
-            print("%s.vid.%d=%s" % (name, usb, vidtouse))
+            print("%s.vid.%d=%s" % (name, usb, vid))
            print("%s.pid.%d=0x%04x" % (name, usb, int(tp, 16)))
            usb = usb + 1
    else:
        for kb in [ "0", "0x8000" ]:
            for ms in [ "0", "0x4000" ]:
                for jy in [ "0", "0x0100" ]:
-                    thispid = int(pidtouse, 16) | int(kb, 16) | int(ms, 16) | int(jy, 16)
-                    print("%s.vid.%d=%s" % (name, usb, vidtouse))
+                    thispid = int(pid, 16) | int(kb, 16) | int(ms, 16) | int(jy, 16)
+                    print("%s.vid.%d=%s" % (name, usb, vid))
                    print("%s.pid.%d=0x%04x" % (name, usb, thispid))
                    usb = usb + 1
    if type(pid) == list:
@@ -132,12 +149,7 @@ def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, p
    print("%s.build.board=%s" % (name, boarddefine))
    print("%s.build.mcu=cortex-m0plus" % (name))
    print("%s.build.variant=%s" % (name, variant))
-    print("%s.upload.tool=%s" % (name, uploadtool))
-    print("%s.upload.tool.default=%s" % (name, uploadtool))
-    if networkuploadtool != None:
-        print("%s.upload.tool.network=%s" % (name, networkuploadtool))
    print("%s.upload.maximum_size=%d" % (name, flashsize))
-    print("%s.upload.maximum_data_size=%d" % (name, ramsize))
    print("%s.upload.wait_for_upload_port=true" % (name))
    print("%s.upload.erase_cmd=" % (name))
    print("%s.serial.disableDTR=false" % (name))
@@ -146,8 +158,6 @@ def BuildHeader(name, vendor_name, product_name, vidtouse, pidtouse, vid, pid, p
    print("%s.build.led=" % (name))
    print("%s.build.core=rp2040" % (name))
    print("%s.build.ldscript=memmap_default.ld" % (name))
-    print("%s.build.ram_length=%dk" % (name, ramsize / 1024))
-    print("%s.build.debugscript=%s" % (name, dbg))
    print("%s.build.boot2=%s" % (name, boot2))
    print("%s.build.vid=%s" % (name, vid))
    if type(pid) == list:
@@ -182,49 +192,34 @@ def BuildGlobalMenuList():
    print("menu.wificountry=WiFi Region")
    print("menu.usbstack=USB Stack")
    print("menu.ipstack=IP Stack")
+    print("menu.uploadmethod=Upload Method")

 def MakeBoard(name, vendor_name, product_name, vid, pid, pwr, boarddefine, flashsizemb, boot2, extra = None):
-    for a, b, c, d in [ ["", "", "uf2conv", "uf2conv-network"], ["picoprobe", " (Picoprobe)", "picoprobe", None], ["picodebug", " (pico-debug)", "picodebug", None]]:
-        n = name + a
-        p = product_name + b
-        fssizelist = [ 0, 64 * 1024, 128 * 1024, 256 * 1024, 512 * 1024 ]
-        for i in range(1, flashsizemb):
-            fssizelist.append(i * 1024 * 1024)
-        vidtouse = vid;
-        ramsizekb = 256;
-        dbg = "picoprobe.tcl"
-        if a == "picoprobe":
-            pidtouse = '0x0004'
-        elif a == "picodebug":
-            vidtouse = '0x1209'
-            pidtouse = '0x2488'
-            ramsizekb = 240;
-            dbg = "picodebug.tcl"
-        else:
-            pidtouse = pid
-        BuildHeader(n, vendor_name, p, vidtouse, pidtouse, vid, pid, pwr, boarddefine, name, c, d, flashsizemb * 1024 * 1024, ramsizekb * 1024, boot2, dbg, extra)
-        if name == "generic":
-            BuildFlashMenu(n, 2*1024*1024, [0, 1*1024*1024])
-            BuildFlashMenu(n, 4*1024*1024, [0, 2*1024*1024])
-            BuildFlashMenu(n, 8*1024*1024, [0, 4*1024*1024])
-            BuildFlashMenu(n, 16*1024*1024, [0, 8*1024*1024])
-        else:
-            BuildFlashMenu(n, flashsizemb * 1024 * 1024, fssizelist)
-        BuildFreq(n)
-        BuildOptimize(n)
-        BuildRTTI(n)
-        BuildStackProtect(n)
-        BuildExceptions(n)
-        BuildDebugPort(n)
-        BuildDebugLevel(n)
-        if a != "picodebug":
-            BuildUSBStack(n)
-        BuildWithoutUSBStack(n)
-        if name == "rpipicow":
-            BuildCountry(n)
-        BuildIPStack(n)
-        if name == "generic":
-            BuildBoot(n)
+    fssizelist = [ 0, 64 * 1024, 128 * 1024, 256 * 1024, 512 * 1024 ]
+    for i in range(1, flashsizemb):
+        fssizelist.append(i * 1024 * 1024)
+    BuildHeader(name, vendor_name, product_name, vid, pid, pwr, boarddefine, name, flashsizemb * 1024 * 1024, boot2, extra)
+    if name == "generic":
+        BuildFlashMenu(name, 2*1024*1024, [0, 1*1024*1024])
+        BuildFlashMenu(name, 4*1024*1024, [0, 2*1024*1024])
+        BuildFlashMenu(name, 8*1024*1024, [0, 4*1024*1024])
+        BuildFlashMenu(name, 16*1024*1024, [0, 8*1024*1024])
+    else:
+        BuildFlashMenu(name, flashsizemb * 1024 * 1024, fssizelist)
+    BuildFreq(name)
+    BuildOptimize(name)
+    BuildRTTI(name)
+    BuildStackProtect(name)
+    BuildExceptions(name)
+    BuildDebugPort(name)
+    BuildDebugLevel(name)
+    BuildUSBStack(name)
+    if name == "rpipicow":
+        BuildCountry(name)
+    BuildIPStack(name)
+    if name == "generic":
+        BuildBoot(name)
+    BuildUploadMethodMenu(name)
    MakeBoardJSON(name, vendor_name, product_name, vid, pid, pwr, boarddefine, flashsizemb, boot2, extra)
    global pkgjson
    thisbrd = {}
@@ -324,6 +319,9 @@ BuildGlobalMenuList()
 MakeBoard("rpipico", "Raspberry Pi", "Pico", "0x2e8a", "0x000a", 250, "RASPBERRY_PI_PICO", 2, "boot2_w25q080_2_padded_checksum")
 MakeBoard("rpipicow", "Raspberry Pi", "Pico W", "0x2e8a", "0xf00a", 250, "RASPBERRY_PI_PICO_W", 2, "boot2_w25q080_2_padded_checksum")

+# 0xCB
+MakeBoard("0xcb_helios", "0xCB", "Helios", "0x1209", "0xCB74", 500, "0XCB_HELIOS", 16, "boot2_w25q080_2_padded_checksum")
+
 # Adafruit
 MakeBoard("adafruit_feather", "Adafruit", "Feather RP2040", "0x239a", "0x80f1", 250, "ADAFRUIT_FEATHER_RP2040", 8, "boot2_w25x10cl_4_padded_checksum")
 MakeBoard("adafruit_feather_scorpio", "Adafruit", "Feather RP2040 SCORPIO", "0x239a", "0x8121", 250, "ADAFRUIT_FEATHER_RP2040_SCORPIO", 8, "boot2_w25q080_2_padded_checksum")
@@ -393,6 +391,9 @@ MakeBoard("upesy_rp2040_devkit", "uPesy", "RP2040 DevKit", "0x2e8a", "0x1007", 2
 # Seeed
 MakeBoard("seeed_xiao_rp2040", "Seeed", "XIAO RP2040", "0x2e8a", "0x000a", 250, "SEEED_XIAO_RP2040", 2, "boot2_w25q080_2_padded_checksum")

+# VCC-GND YD-2040 - Use generic SPI/4 because boards seem to come with varied flash modules but same name
+MakeBoard('vccgnd_yd_rp2040', "VCC-GND", "YD RP2040", "0x2e8a", "0x800a", 500, "YD_RP2040", 16, "boot2_generic_03h_4_padded_checksum")
+
 # Viyalab
 MakeBoard("viyalab_mizu", "Viyalab", "Mizu RP2040", "0x2e8a", "0x000a", 250, "VIYALAB_MIZU_RP2040", 8, "boot2_generic_03h_4_padded_checksum")

@@ -403,6 +404,7 @@ MakeBoard("waveshare_rp2040_plus_4mb", "Waveshare", "RP2040 Plus 4MB", "0x2e8a",
 MakeBoard("waveshare_rp2040_plus_16mb", "Waveshare", "RP2040 Plus 16MB", "0x2e8a", "0x1020", 500, "WAVESHARE_RP2040_PLUS", 16, "boot2_w25q080_2_padded_checksum")
 MakeBoard("waveshare_rp2040_lcd_0_96", "Waveshare", "RP2040 LCD 0.96", "0x2e8a", "0x1021", 500, "WAVESHARE_RP2040_LCD_0_96", 2, "boot2_w25q16jvxq_4_padded_checksum")
 MakeBoard("waveshare_rp2040_lcd_1_28", "Waveshare", "RP2040 LCD 1.28", "0x2e8a", "0x1039", 500, "WAVESHARE_RP2040_LCD_1_28", 2, "boot2_w25q16jvxq_4_padded_checksum")
+
 # WIZnet
 MakeBoard("wiznet_5100s_evb_pico", "WIZnet", "W5100S-EVB-Pico", "0x2e8a", "0x1027", 250, "WIZNET_5100S_EVB_PICO", 2, "boot2_w25q080_2_padded_checksum")
 MakeBoard("wiznet_wizfi360_evb_pico", "WIZnet", "WizFi360-EVB-Pico", "0x2e8a", "0x1028", 250, "WIZNET_WIZFI360_EVB_PICO", 2, "boot2_w25q080_2_padded_checksum")
@@ -0,0 +1,41 @@
+#pragma once
+
+// Pin definitions taken from: https://raw.githubusercontent.com/0xCB-dev/0xCB-Helios/main/rev1.0/helios.webp
+
+// LEDs
+#define PIN_LED (17u)
+
+// Serial
+#define PIN_SERIAL1_TX (0u)
+#define PIN_SERIAL1_RX (1u)
+
+// Not pinned out
+#define PIN_SERIAL2_TX (31u)
+#define PIN_SERIAL2_RX (31u)
+
+// SPI
+#define PIN_SPI0_MISO (20u)
+#define PIN_SPI0_MOSI (23u)
+#define PIN_SPI0_SCK (22u)
+#define PIN_SPI0_SS (21u)
+
+// Not pinned out
+#define PIN_SPI1_MISO (31u)
+#define PIN_SPI1_MOSI (31u)
+#define PIN_SPI1_SCK (31u)
+#define PIN_SPI1_SS (31u)
+
+// Not pinned out
+#define PIN_WIRE0_SDA (31u)
+#define PIN_WIRE0_SCL (31u)
+
+// Wire
+#define PIN_WIRE1_SDA (2u)
+#define PIN_WIRE1_SCL (3u)
+
+#define SERIAL_HOWMANY (1u)
+#define SPI_HOWMANY (1u)
+#define WIRE_HOWMANY (1u)
+
+#define PIN_NEOPIXEL (25u)
+#include "../generic/common.h"
Author	SHA1	Message	Date
Earle F. Philhower, III	f212720484	Update version	2023-01-14 14:34:45 -08:00
Earle F. Philhower, III	1328f78099	Add VCC-GND YD-RP2040 board (#1120 ) Fixes #1109	2023-01-14 14:33:52 -08:00
Earle F. Philhower, III	4c234310fd	Add hook support to WebServer (#1119 ) Implement the method used in the ESP8266 Web Server to allow user apps to hook into the HTTP server (to support hooked WebSockets, etc._) Add example of hook usage	2023-01-14 13:35:33 -08:00
Conor Burns	f7ee4a868a	Add 0xCB Helios (#1117 )	2023-01-14 12:19:27 -08:00
Earle F. Philhower, III	ae386d4308	Redo boards menu, separate out upload method, add picotool upload (#1112 ) Instead of listing each board three times (normal upload, picoprobe, and pico-debug uploads), list each board once and use a menu to select the actual upload method. Also add in picotool as an upload method for those folks who have trouble with automounting. Fix #1111	2023-01-13 13:04:24 -08:00
Earle F. Philhower, III	ff9f5d3809	Update README.md	2023-01-09 09:55:27 -08:00
Earle F. Philhower, III	ce17a6200b	Update install.rst	2023-01-09 08:08:57 -08:00
AnachronisticPenguin	8289bbd27b	Add additional instructions for Linux Flatpak users (#1105 ) Provide instructions for users to override filesystem access restrictions imposed by Flatpak on some installations of the Arduino IDE	2023-01-09 08:03:30 -08:00
Earle F. Philhower, III	aeb41f3e70	Handle slave mode I2C restarts (#1104 ) Fixes #1100	2023-01-06 12:23:53 -08:00
Earle F. Philhower, III	cefea28539	Stop the I2S PIO when I2S::end called (#1103 )	2023-01-06 12:23:26 -08:00
Earle F. Philhower, III	da26016edf	DMA-based ADC input (microphone, analog sensor) (#1101 ) Mimics the I2S/PWMAudio/Stream interface for ease of use. * Fix non-32b DMA size transfer calculation in ABM * Rename wasHolding to isHolding in the I2S/PWM It is the current number of bits left, not the past number. * Add commented microphone example * Add docs	2023-01-05 16:00:34 -08:00
Earle F. Philhower, III	6bef238772	Update to LittleFS 2.5.1 (only minor updates) (#1099 )	2023-01-03 18:51:28 -08:00
Earle F. Philhower, III	02465b48b3	Allow on-the-fly changes to PWMAudio when possible (#1098 ) Also fix crash on PWMAudio::end()	2023-01-03 16:02:43 -08:00
Earle F. Philhower, III	94abf9d19f	Move analogReadTemp() to C++-only (#1097 ) Now that we have a default parameter, need to only allow it in C++ since default values are not part of C spec. Should not affect any users since only legacy code is in C.	2023-01-03 13:30:11 -08:00
Thomas Combriat	7a4244180b	Set Right and Left correctly for lsbj format (#1096 )	2023-01-03 13:15:08 -08:00
Earle F. Philhower, III	6fe6c474f7	Add LSBJ format support for I2S (#1095 ) Fixes #1094	2023-01-03 11:47:55 -08:00
Earle F. Philhower, III	be34ed1385	Reduce stack usage of several components (#1093 ) Only 4K total stack, so allocating 400 bytes for a local C string or 600 bytes for a DHCP response is dangerous. Use static allocations instead on the heap.	2023-01-02 11:40:51 -08:00
Earle F. Philhower, III	444bb24464	Remove debug printout warnings (#1091 ) Exposed by #1090, remove ugly printf format warnings while in debug mode	2023-01-02 10:51:04 -08:00
NuclearPhoenix	0e6ca28316	Update wiring_analog.cpp (#1092 )	2023-01-02 10:44:49 -08:00
Earle F. Philhower, III	d718b143d2	Warn when `Serial.printf()` format is wrong (#1090 ) Let GCC check the format string to Print::printf(). Will catch when sketches use incorrect parameters to `Serial::printf()`.	2023-01-01 15:26:15 -08:00
Axotron	1e2f1a19ff	Adding sei() and cli() as aliases for interrupts() and noInterrupts(). (#1089 )	2023-01-01 14:18:06 -08:00
Earle F. Philhower, III	1228251bc3	Add stereo support, docs for PWM playback (#1084 ) Limited to consecutive pins (i.e. GPIOs on the same PWM slice). "For free" with PWM since no add'l DMA, buffers, or IRQs are needed.	2023-01-01 11:27:49 -08:00
Earle F. Philhower, III	a781ec2fdd	Add WString.h include redirect for broader compat (#1083 ) See #1079	2022-12-31 11:03:28 -08:00