Firmware

Firmware

The Pico and Arduino boards run firmware that belongs to openSciLab: the openSciLab Pico firmware for RP2040/RP2350 boards and the openSciLab Arduino firmware. This page says which boards are supported, how the firmware gets onto a board – from the application or by hand – how to check a board, and how to build the firmware yourself.

Beta. The firmware is built for every board and checked by host tests and by the simulators, which behave like the firmware. Much of it – the new functions of Pico firmware 8 (pins, outputs, generators, analog inputs) and the whole Arduino firmware – has not been checked on real hardware yet. Run the self-test first, and please report what works on your board and what does not.

Always the current firmware

Every version of openSciLab works only with the firmware it comes with. There is no compatibility with older firmware; instead, openSciLab offers the update:

• A Pico board with the openSciLab Pico firmware identifies itself as OPENSCILAB_PICO_<BOARD>_V8_0 and reports protocol 8. openSciLab opens a board only when its protocol is the one of the application.
• A board with older firmware – an earlier openSciLab Pico, PiPiLogicAnalyzer (PIPI_LOGIC_ANALYZER_…) or the original LogicAnalyzer firmware (LOGIC_ANALYZER_…) – is recognised but not opened. openSciLab asks Firmware update needed; Update firmware... opens the connected hardware, where the board's row says update to 8.0. The update takes a few seconds; capture settings and profiles are kept.
• The 8.0 a Pico board shows is the version of its firmware identity (V8_0), which changes with the protocol. The release the image belongs to (0.1.0b1) is written into the image as its program version (picotool info).
• An Arduino board speaks protocol 1 of the openSciLab Arduino firmware. A board with another protocol is refused with a message to install the firmware that comes with the application.

After updating openSciLab, Devices → Connected hardware shows whether your boards need the new firmware too. All boards of a multi device set must run the same version.

Downloads

File (GitHub Releases)	Content
openSciLab-firmware-pico-uf2.zip	every Pico image, openSciLab-pico_<BOARD>[_Turbo].uf2
openSciLab-firmware-arduino.zip	the Arduino images, openSciLab_<environment>.hex or .bin
openSciLab-bridge.apk	the bridge app for the Rigol DHO900

The packaged application contains all Pico images, so installing them from the application needs no download. Each release lists its checksums in SHA256SUMS.txt.

Pico firmware

Boards

Image <BOARD>	Board	Channels	Buffer	Turbo image	Trigger output → input
BOARD_PICO	Raspberry Pi Pico	24	128 KB	yes	GP0 → GP1
BOARD_PICO_2	Raspberry Pi Pico 2	24	384 KB	yes	GP0 → GP1
BOARD_PICO_W	Pico W, data over USB	24	128 KB	–	GP0 → GP1
BOARD_PICO_W_WIFI	Pico W with WiFi	24	128 KB	–	GP0 → GP1
BOARD_PICO_2_W	Pico 2 W, data over USB	24	384 KB	–	GP0 → GP1
BOARD_PICO_2_W_WIFI	Pico 2 W with WiFi	24	384 KB	–	GP0 → GP1
BOARD_ZERO	RP2040-Zero	24	128 KB	yes	GPIO 17 → GPIO 18
BOARD_INTERCEPTOR	LogicAnalyzer Interceptor	28	128 KB	yes	GPIO 0 → GPIO 1

On the Pico boards the channels are GP2–GP22 and GP26–GP28; the three ADC inputs GP26–GP28 also serve as analog channels. The trigger pins link the boards of a multi device set.

A board captures at up to 100 MHz (blast mode 200 MHz). The Turbo images overclock the chip to 400 MHz with a raised core voltage and capture at up to 200 MHz (blast mode 400 MHz). That is outside the specification of the RP2040/RP2350 and can shorten its life; openSciLab installs the normal image unless you choose a Turbo image yourself.

The _WIFI images of the Pico W and Pico 2 W make the board reachable over WiFi as well (set up with Network settings... on the device card, see Devices).

What firmware 8 does

Captures into the board's buffer (with blast mode and bursts) and streams over USB (about 800 kB/s: 800 kHz with 8 channels, 400 kHz with 16, 200 kHz with 24); trigger sequences of up to 8 stages evaluated on the board (up to about 1 MHz on an RP2040 and 1.6 MHz on an RP2350, twice that with Turbo; the board measures and reports its limit); the state mode with an external clock (up to 25 MHz, 50 MHz with Turbo); a pin table with pin modes, outputs, PWM and pulses timed by the board; the monitor; analog inputs in captures and streams; a pattern generator, a square wave on GP22 and UART/SPI/I²C sent by the board; a watchdog that releases the outputs one second after the computer is gone; a self-test, test signals and detailed device information.

The firmware is based on the firmware of the LogicAnalyzer by Agustín Giménez Bernad (gusmanb), version 6.5. The changes and the bugs fixed are listed in firmware/README.md.

Installing from the application

This is the usual way, for a new board as well as for an update:

1. Plug the board in. A Pico without openSciLab firmware: hold its BOOTSEL button while plugging it in. It then shows as Board in bootloader mode (RP2040) (or (RP2350) for a Pico 2). A board that runs other firmware (MicroPython, for example) shows as Raspberry Pi board, one with older openSciLab or PiPiLogicAnalyzer firmware as openSciLab Pico.
2. Open Devices → Connected hardware – also Devices → Install or update firmware..., Hardware... below the device list, or Install firmware... in the notice of the device list. The State column says whether the firmware is up to date, has an update or is missing.
3. Click Install firmware or Update firmware in the row of the board and confirm with Install. openSciLab picks the image that fits the board, restarts the board into its bootloader, writes the image, waits until the board is back and connects it again.

The bootloader cannot tell a Pico from a Pico W (or a Pico 2 from a Pico 2 W). For a board in bootloader mode openSciLab therefore asks Which board is it?. Images built for the other chip (RP2040 or RP2350) are refused.

For a connected board, Update firmware... on the Details tab of its device card does the same.

Choosing an image yourself

Choose an image... in the connected hardware opens the dialog Install or update firmware – for a Turbo image, an image you built, or any other .uf2 file:

1. 1. Board lists boards in bootloader mode (drive RPI-RP2 or RP2350), connected analyzers and Raspberry Pi boards with other firmware. Select a board and press Restart into bootloader, or hold BOOTSEL while plugging it in.
2. 2. Firmware image lists the images openSciLab knows; Browse... adds any .uf2 file. The line below names board, version, chip and size, and Turbo: overclocked and overvolted for a Turbo image.
3. Flash firmware writes it.

openSciLab finds images in the packaged application, in firmware/uf2/ of a source checkout and in the folder firmware of the settings directory.

Installing by hand

1. Hold BOOTSEL while plugging the board in (or press Restart into the bootloader... on the Details tab of its device card). A drive named RPI-RP2 (RP2040) or RP2350 appears.
2. Copy the right openSciLab-pico_<BOARD>.uf2 from openSciLab-firmware-pico-uf2.zip onto the drive. The board restarts with the new firmware and appears as a serial port.

Checking a board

Self-test

Self-test... on the Details tab of the device card, then Run self-test. Disconnect all probes and signals first: the test drives nothing onto the inputs and checks them only with the internal pull resistors.

Test	What it checks	Result
BOARD	board, firmware, channels, buffer size, system clock	information
RAM	the capture buffer, written with two bit patterns and read back	OK / FAIL
TRIGGER_LINK	the trigger output drives the trigger input (Pico: GP0 → GP1)	OK / FAIL / SKIPPED
CH1 … CHn	every input follows its pull-up and pull-down	OK, STUCK_HIGH, STUCK_LOW, INVERTED
SEQUENCE	how fast the board evaluates trigger sequences	information
CAPTURE	a real capture of the pull pattern through PIO and DMA	OK / FAIL / SKIPPED
BLAST_CAPTURE	the same in blast mode at the highest rate	OK / FAIL / SKIPPED
STREAM	a stream of a test counter over USB, checked sample by sample	OK / FAIL

Shorts between two channels cannot be found this way. Boards with input buffers or level shifters report their channels as STUCK_*, because the buffer drives the input – that is expected there. On a multi device set the test runs on every board.

Test signals of the board

Test signals of the board... on the Details tab opens Simulated capture: choose the Pattern (Counter, Walking one or Protocols (UART, SPI, I2C)), the Channels, the Sampling frequency and the Samples, then Start simulation. The board writes the signals into its buffer instead of sampling its pins and transfers them like a real capture – a test of the firmware, the USB or WiFi link and the application, without a single wire.

The protocol pattern carries the text openSciLab: UART on channel 1 (at a tenth of the sampling rate, 100,000 baud at 1 MHz), SPI on channels 2–4 and I²C on channels 5–6. With Add UART, SPI and I2C decoders for the channels the decoders are added to the data view. Data → Test signals... in a data view computes the same signals on the computer, without a board.

Device information

The Details tab shows the identification, board, firmware version and protocol, the build of the firmware (chip and revision, unique board ID, flash size, Pico SDK, build date, system clock, Turbo, WiFi) and the USB data of the port. Copy the details puts it on the clipboard for a bug report.

Arduino firmware

Boards

Environment	Board	Connection	Pins	Capture buffer
uno	Arduino Uno R3	115200 baud	D0–D13 (D0/D1 reserved), A0–A5	448 B
nano	Arduino Nano (Optiboot)	115200 baud	as the Uno, plus A6/A7 (analog only)	448 B
megaatmega2560	Arduino Mega 2560	115200 baud	whole ports: D22–D29, D53–D50/D10–D13, D49–D42, A8–A15	4 KiB
uno_r4_minima	Arduino Uno R4 Minima	USB	D0–D13, A0–A5 (DAC on A0)	12 KiB
esp32dev	ESP32 DevKitC (WROOM-32)	2 Mbaud	26 GPIOs (GPIO1/3 reserved), DAC on GPIO25/26	48 KiB
esp32-s3	ESP32-S3 DevKitC-1	native USB	31 GPIOs (GPIO19/20 reserved)	64 KiB

The rates of the boards are estimates until they have been measured. The board starts with every pin an input. When outputs are driven and no message came from the computer for one second, it releases them. Opening the serial port of an Uno restarts it, which takes a few seconds; that is also what Reconnect on its device card does.

Flashing

With PlatformIO and a checkout of the repository – the simplest way for every board:

pip install platformio
pio run -d firmware/arduino -e uno -t upload       # one board, flashed over USB

Use the environment of your board from the table (nano, megaatmega2560, uno_r4_minima, esp32dev, esp32-s3). PlatformIO uses the board's own bootloader; an ESP32 may need its BOOT button held while the upload starts.

Without PlatformIO, an AVR board can be flashed with the image from openSciLab-firmware-arduino.zip and avrdude (replace the port):

avrdude -p atmega328p -c arduino -P /dev/ttyACM0 -b 115200 -D -U flash:w:openSciLab_uno.hex:i     # Uno, Nano
avrdude -p atmega2560 -c wiring  -P /dev/ttyACM0 -b 115200 -D -U flash:w:openSciLab_megaatmega2560.hex:i

For the Uno R4 Minima and the ESP32 boards use PlatformIO.

Bridge app for the Rigol DHO900

The Rigol DHO900 oscilloscopes run Android. The openSciLab bridge app on the instrument speeds up large captures (an overview first, the details tile by tile), keeps captures in a cache (the Cache tab of the device card) and announces the instrument in the network. Without it openSciLab reads the instrument directly, more slowly. Switch on adb on the instrument, then install the app from the computer:

adb connect <scope-ip>               # add :<port> if the adb port of your instrument differs
adb install -r openSciLab-bridge.apk

Then open openSciLab Bridge on the instrument and press Start. Details are in firmware/bridge-android/README.md. The bridge app has not been tried on an instrument yet.

Building the firmware yourself

Everything is described in firmware/README.md. In short:

Firmware	Tools
Pico	Pico SDK 2.1.1, ARM GNU toolchain 14.2, CMake and Ninja – the Raspberry Pi Pico extension of VS Code installs them in ~/.pico-sdk
Arduino	PlatformIO (pip install platformio)
Bridge app	JDK 17 and the Android command line tools

The dev container of the repository (.devcontainer/) has all of them.

firmware/build_all.sh                          # everything
firmware/build_all.sh --pico                   # every Pico board and Turbo variant -> firmware/uf2/
firmware/build_all.sh BOARD_PICO BOARD_PICO_2  # selected Pico boards
firmware/build_all.sh --arduino                # the Arduino images -> firmware/arduino-images/
firmware/build_all.sh --bridge                 # the bridge app -> firmware/apk/

openSciLab run from the source checkout finds the Pico images in firmware/uf2/ by itself. On Windows, firmware/pico/publish.ps1 builds the Pico images.