fossasia/pslab-esp01-firmware: giving the Pocket Science Lab a wireless link, one ESP-01 at a time

What the ESP-01 adds to the PSLab

The Pocket Science Lab is an open hardware platform for doing science and engineering experiments, and its built-in instruments are the reason it exists. The list is a small lab in one board: an oscilloscope, a waveform generator, a frequency counter, programmable voltage and current sources, and a logic analyzer.

The board also exposes UART, I2C and SPI buses, so external devices can be connected and controlled through them.

This repository holds the firmware for the ESP8266 ESP-01 chip that implements wireless connectivity for that platform. The ESP-01 is the module that carries that wireless link, and in the PSLab ecosystem it is the piece that lets the instrument talk to the phone or laptop running the app without a cable.

The project is part of a deliberately complete open stack. FOSSASIA provides the hardware, the bootloader, the main firmware, the Python library and the app, each in its own repository under open source licences. This repository is the wireless peripheral, and it is deliberately the smallest piece of that system, which is why its documentation is about wiring and flashing rather than about features.

The device is open source rather than a commercial product, and there is a shop and a list of resellers for anyone who does not want to build the hardware themselves.

The hardware you need is an Arduino UNO and two resistors

The prerequisites list is short, and every item has a reason.

The Arduino UNO, with a USB cable, acts as a bridge to program the ESP01 chip. Jumper wires connect the ESP-01 to the UNO. Resistors are listed as optional but are described as useful for logic level conversion to protect the ESP01 from higher voltage signals, and a breadboard is optional for convenient and secure connections. On the software side the only requirement is the Arduino IDE, described as the development environment for writing and uploading firmware to the ESP01.

That optional resistor is not optional in practice. The additional notes say the RX pin connection between the UNO and the ESP-01 should be made through a voltage divider, since the ESP-01 operates on a 3.3 V logic level and receiving 5 V logic level from the UNO could damage it. A simple 3.3V voltage divider can be made very conveniently using two resistors, 10K and 20K.

The connection table in the README is explicit about which pins go where:

| Arduino UNO | ESP-01 | |-------------|-----------------| | RX | RX | | TX | TX | | 3.3 V | VCC | | GND | GND | | RESET | GND | | GND | GPIO_0 | | 3.3 V | CH_PD or CH_EN | | GND | RESET |

The notes underneath say that all ground pins from the UNO and the ESP-01 are common, that the 3.3 V connections are common from the UNO, and that RX must go through the divider.

Preparing the IDE and the bridge board

The setup has two halves. The first is the Arduino IDE, which needs the ESP8266 board support package installed through a custom board manager URL. The steps are: open the IDE, go to `File > Preferences`, and in the Additional Board Manager URLs field add the ESP8266 index:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

If there are existing URLs, separate them with a comma. After saving, go to `Tools > Board > Boards Manager`, type ESP8266 in the search bar, select the latest version of the `esp8266 by ESP8266 Community` package and click Install.

The second half is the UNO itself, and the reason is specific. Before flashing the ESP-01, a bare minimum sketch is uploaded to the Arduino UNO, so that the board is in a known state and can act as a bridge for programming. The steps are to connect the UNO with the USB cable, open `File > Examples > 01.Basics > BareMinimum`, select the Arduino UNO board and the appropriate COM port, and click Upload.

That step is easy to skip and the failure is confusing when you do, because a UNO running an unrelated sketch or an old one behaves unpredictably as a serial bridge. The documentation treats it as a prerequisite rather than a tip.

Flashing, and the one second RESET trick

The flashing procedure is a sequence of IDE actions interrupted by one physical action, and that physical action is the part people get wrong.

After cloning the repository, open the file containing the firmware, `ESP01Firmware.ino`, in the Arduino IDE. Select the `Generic ESP8266 Module` board and the appropriate COM port, then click Upload and wait for the sketch to compile and the upload to begin. The output window will show something like the connecting screenshot the README includes.

At that moment, the RESET pin of the ESP-01 has to be connected to GND for a short interval, so that the firmware can be uploaded. The instruction is to wait for the output, then, after approximately 1s, disconnect the RESET pin from GND.

The program then connects to the chip, and the output shows a connected message, which indicates that firmware flashing has begun, and finally a successful message, which indicates the firmware has been flashed successfully to the ESP-01 chip. The README includes a screenshot for each of these three states, which is what makes the sequence followable, since the whole thing is driven by a serial log rather than by a progress bar.

It is worth noting that this is a two board procedure with a timing sensitive step in the middle, and that the flashing is done from the IDE rather than from a command line, which is unusual for a firmware repository in 2026 and is a direct consequence of targeting the ESP8266 through the Arduino toolchain.

The PSLab side, and the USB side effect

With the firmware on the ESP-01, the next step is to flash the appropriate firmware onto the PSLab board itself, to enable communication over the UART2 bus. The image to use is `pslab-firmware_v6_esp01.hex` from the PSLab firmware release page, and the README sends you to the flashing instructions in the pslab-firmware repository for the details. After that, the ESP-01 chip is plugged into the header on the board and the setup is complete.

There is a consequence that the documentation flags in a note, and it is the kind of thing that surprises people. After flashing this firmware to the PSLab, it will no longer communicate over the USB port. To restore the ability to communicate with the PSLab over USB, you flash the `pslab-firmware_v6.hex` image instead, and the note adds that the PSLab always communicates over USB while in bootloader mode regardless of which application firmware is loaded.

So the two images are a pair of modes rather than two versions, and the practical advice is to keep both files on hand. Flashing the plain `pslab-firmware_v6.hex` gets you back a USB-connected lab, and flashing the `_esp01` variant turns the board into a wireless instrument.

The communication channels for the support side are the FOSSASIA Gitter chat channel and the PSLab mailing list on Google Groups, which is where questions about a board that does not enumerate or a wireless link that will not pair belong.

Building the firmware without the Arduino IDE

There is a second build path for people who do not want the IDE, and it is a command line workflow.

The requirements are git, python and make. The steps begin in the working directory, which is the repository itself. The ESP8266 toolchain is obtained by cloning the esp8266 Arduino repository, updating its submodules and running the Python installer:

git clone https://github.com/esp8266/Arduino esp8266
cd esp8266
git submodule update --init
cd tools
python get.py
cd ../..
export ESP_ROOT=$(readlink -f esp8266)

The `ESP_ROOT` environment variable is what points the build at the toolchain you just fetched, and the rest of the sequence continues in the README with fetching the makefile and building.

The trade between the two paths is straightforward. The IDE path is easier for a first time user, because the board support package and the upload are handled by the tool, but it gives you no control over the toolchain version beyond what the Boards Manager offers. The command line path pins the toolchain in your checkout, which is what you want in CI or when you are reproducing a build, at the cost of running the download yourself.

The repository itself is small: a `src/` directory with the firmware sources, `docs/` with the images used in the instructions, a `formatter.sh` script and the licence and readme files. The licence is Apache-2.0, the releases are v0.1.0 from 2025-02-03 and v0.2.0 from 2026-08-11, and the last push to the repository was on 2026-10-12.

Editorial conclusion

Adopt this firmware if you have a Pocket Science Lab and want to drive its instruments wirelessly from the PSLab app, since the ESP-01 is the supported way to get that link and the documentation covers the whole chain from board manager setup to the flashing sequence. Do not adopt it if you do not have the PSLab board, since the firmware is a companion to it and depends on the matching PSLab firmware image, and do not plan to keep using the USB connection for the board while this firmware is loaded, because the README says the board stops communicating over USB once the ESP-01 firmware is in place. Verify first that your ESP-01 is wired through a voltage divider rather than directly to the UNO's 5 V logic, that you have the matching `pslab-firmware_v6_esp01.hex` image from the PSLab firmware release page, and that you keep the plain `pslab-firmware_v6.hex` image handy for restoring USB communication.

Frequently asked questions

Official sources

1. fossasia/pslab-esp01-firmware on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases