DEV Community: Daniel Guerrero

BIO Baochip/Dabao - FIFO and Events

Daniel Guerrero — Thu, 13 Aug 2026 02:00:00 +0000

FIFO

The BIO has 4 FIFOs mapped to the BIO processors as x16-x19 r/w registers (blocking on read until new data is pushed), and in the host through BIO_BDMA_SFR_TXFx for writing data (PUSH) and BIO_BDMA_SFR_RXFx for reading (POP) data (or returning the last data read if nothing else is found), where x is a number 0-3 for the 4 FIFOs.

So in a BIO processor, an instruction like this:

mv t0, x16      # wait for FIFO0

This will block until there is info in FIFO0.
To unblock it, you need, from another BIO processor:

li x16, 0x10

or from the host processor:

BIO_BDMA_SFR_TXF0 = 0x10; // bio_push_fifo0(0x10); in SDK

To read in the host processor:

uint32_t data = BIO_BDMA_SFR_RXF0; // bio_pop_fifo0(); in SDK

This will always return a value and won't block execution, so for example:

BIO_BDMA_SFR_TXF0 = 0x10; // FIFO0 has 0x10
BIO_BDMA_SFR_TXF0 = 0x20; // FIFO0 has 0x10,0x20

uint32_t data;
data = BIO_BDMA_SFR_RXF0; // data = 0x10
data = BIO_BDMA_SFR_RXF0; // data = 0x20
data = BIO_BDMA_SFR_RXF0; // data = 0x20

So the last data read/popped will always be available to the host.

There is an example here: https://github.com/danguer/embedded-boards101/tree/main/daobao-baochip/bio_multiply_fifo
To test the hardware multiplier in the BIO Processor, the following instructions are needed for BIO:

mv t0, x16      # wait for FIFO0
li t1, 2        # load multiplier
mul x16, t0, t1 # multiply and store back in fifo

So the BIO will get a value from FIFO0, multiply by 2, and store it again in FIFO0.
Because we are reusing the same FIFO, if we read the value before the BIO does the multiplication, we are going to read the original value and not the result (I know this is poor design, as another FIFO should be used, but this is to show the communication with the host).
So the host will do the following:

add the value to FIFO0
read the value from FIFO0
check that the value is different from the original value

bio_start_cores(1);
bio_push_fifo0(multiplicand);
// wait until is multiplied
do {
  result = bio_pop_fifo0();
} while(result == multiplicand);
bio_stop_cores(BIO_CORE);

Even though this code works, the issue is that the FIFO read register will ALWAYS return a value.

To avoid this issue, there is another register called BIO_BDMA_SFR_FLEVEL.
This register will return all the FIFO "levels" (number of entries or length), with 4 bits for each FIFO (as there is a maximum of 16 entries per FIFO). So, to know how many items exist, it can be used like this:

uint8_t fifo0_length = BIO_BDMA_SFR_FLEVEL & 0xF; // or bio_fifo_level(0); in SDK

Still, for this example, the issue is that we need to use another FIFO to avoid collisions:

mv t0, x16      # wait for FIFO0
li t1, 2        # load multiplier
mul x17, t0, t1 # multiply and store in fifo1

bio_push_fifo0(multiplicand);
// wait until fifo1 has data
while(bio_fifo_level(1) == 0);
result = bio_pop_fifo1();

Note that there is a way to "reset" the FIFO levels/length through the register BIO_BDMA_SFR_FIFO_CLR.
This is a 4-bit config where each bit corresponds to a FIFO number, and a 1 means clearing the levels (but not the contents), so for example:

BIO_BDMA_SFR_FIFO_CLR = 0xF;

This resets all the FIFO levels/length.

Events

The events register is a shared 32-bit register, where bits [23:0] are standard bits and can be changed with:

x28 to SET in the BIO Processors (or BIO_BDMA_SFR_EVENT_SET in host, bio_event_set in SDK)
x29 to CLEAR in the BIO Processors (or BIO_BDMA_SFR_EVENT_CLR in host, bio_event_clear in SDK)

In the BIO Processor there are two more registers:

x27 is a mask to only halt on certain events
x30 is a Halt-on-Event register: when you try to read it, it will halt until (x27 & events) != 0 or until an event has happened; reading this will return all the event data, regardless of the event mask

For the host, BIO_BDMA_SFR_EVENT_STATUS is similar to x30, so it is a READ ONLY register.

So, you can wait for a signal, for example:
BIO Processor

mv t0, x16      # wait for FIFO0
mul x17, t0, t1 # multiply and store back in FIFO1
li x28, 0x4     # signal that multiply has finished
j cycle

In the host, this code can be added:

bio_push_fifo0(multiplicand); // sdk

// wait until signal happens
while((BIO_SFR_EVENT_STATUS & 0x4) == 0);

With this, the host will be waiting for a signal from the event register.

Event Thresholds

Bits [31:24] are special bits; for each FIFO there will be 2 comparators, which will set those 8 bits if they match one of three possible options — < (less than), == (equal), > (greater than) — compared against the value of the level/length of the FIFO.

So you can configure logic testing like:
IF FIFO0_LEVEL == 4 OR FIFO_LEVEL > 4

If the comparator matches, it will set the proper event bit. So, let's say the previous example was for Thresh0/Comparator0; then, when it matches, it will set 1 in the Event[24] bit, which can be used in the host or the BIO Processor.

The comparators need to be set in the host through two variables:

BIO_BDMA_SFR_ELEVEL for setting the value to compare
BIO_BDMA_SFR_ETYPE for setting the type of comparator

For the BIO_BDMA_SFR_ELEVEL, there are 8 comparators, and each one can have a value of 4 bits (FIFO has a max of 16 entries). So let's say we want the first comparator (FIFO0, Thresh0) to match the value 4 or 0b0100; it needs to be set like this:

BIO_BDMA_SFR_ELEVEL = 0x4;

The BIO_BDMA_SFR_ETYPE contains 3 groups of 8 bits for:

[7:0] LT or Less Than
[15:8] EQ or Equal
[31:16] GT or Greater Than

As this is 8 bits long for each type, a 1 in the proper bit will set the comparator type; so if we want to check EQ for the first comparator, bit 8 (or 0x100) should be set:

BIO_SFR_ETYPE = 0x100;

In the BIO Processor you can wait for the signal like this:

    li x27, 0x1000000  # mask for event[24]
wait_for_event:
    mv t1, x30      # halt for event
    # run here all the code for event
    j wait_for_event

So what this does is the following:

Asks to only be woken up when the event matches mask 0x1000000
Halts on event by reading x30
When there are 4 items in FIFO0, it will continue

Let's note that the Event Register contains other registers and is not documented yet, so either set the mask through x27 for a specific event, or wait for an event and check through a separate mask whether it is the event you want.

An example that adds 4 values using a signal is here: https://github.com/danguer/embedded-boards101/tree/main/daobao-baochip/bio_add_four

BIO Baochip/Dabao - Introduction and GPIO

Daniel Guerrero — Mon, 10 Aug 2026 09:09:14 +0000

The Baochip is a new MCU using RISC-V which has a BIO feature. This feature contains 4 PicoRV32E processors that can run in parallel with access to memory and GPIO.
It also features 16 special registers (x16-x31) compared to the RV32E specification, which contains only 16 (x0-x15); it also supports the Zmmul extension (integer multiplication).

A brief introduction of the board is here

The official documentation is here and I will use an image from the documentation:

For the SDK, I will use the Dabao SDK, and for compiling BIO I will use the xpack riscv-none-elf-gcc 15.2.0, which is what the SDK uses — though any RISC-V gcc should work.

General Description

The BIO consists of 4 PicoRV32E processors that can run in parallel up to 720 MHz (it takes 3 cycles for each instruction without pipelining, so the real speed is around 240 MHz).
Each processor has 4 kiB of RAM, meaning it can hold up to 1024 instructions. Each processor also has the Zmmul extension, so it has a hardware multiplier.
Each BIO Processor has special registers x16-x31 to communicate with other processors and the Host Processor; some of the registers will halt CPU execution until an external event happens.
The BIO Processor can have access to GPIO, so it allows "bit banging" at higher speeds and running in parallel without main CPU slowdown; it can also have access to host memory.

The special registers are (taken from the official documentation, with more info added):

FIFO - 8-deep fifo head/tail access. Cores halt on overflow/underflow.
Each FIFO can have up to 16 items of 32 bits
- x16 r/w  fifo[0]
- x17 r/w  fifo[1]
- x18 r/w  fifo[2]
- x19 r/w  fifo[3]

Quantum - core will halt until host-configured clock pulse occurs, or an external event comes in a GPIO pin.
- x20 -/w  halt to quantum

GPIO
- x26 r/w  mask GPIO action outputs
- x21 r/w  write: (x26 & x21) -> gpio pins; read: gpio pins -> x21
- x22 -/w  (x26 & x22) -> a `1` in x22 will set corresponding pin on gpio
- x23 -/w  (x26 & ~x23) -> a `0` in x23 will clear corresponding pin on gpio
- x24 -/w  (x26 & x24) -> a `1` in x24 will make corresponding gpio pin an output
- x25 -/w  (x26 & x25) -> a `1` in x25 will make corresponding gpio pin an input


Events
Bits [31:24] are hard-wired to FIFO level flags, configured by the host; writes to bits [31:24] are ignored.
These bits are for comparators against FIFO levels (FIFO length), there are 2 possible comparators for each FIFO, so 8 comparators in total.

- x27 -/w  event mask
- x28 -/w  `1` will set the corresponding event bit. Only [23:0] are wired up.
- x29 -/w  `1` will clear the corresponding event bit. Only [23:0] are wired up.
- x30 r/-  halt until ((x27 & events) != 0), and return unmasked `events` value

Core ID & debug:
- x31 r/-  [31:30] -> core ID; [29:0] -> cpu clocks since reset

BIO Setup

In order to run the BIO, it needs the following:

set the clock settings (SDK: bio_init(FCLK_HZ);)
flush core instructions/fifo and set up stack pointers; this is done in bio_init (other example)
set the code to execute in binary opcodes (SDK: bio_load_code_words(core, *buffer, length))
start the code (SDK: bio_start_cores(core_number_1_to_4))

So you need to compile instructions into RISC-V opcodes for each core; here is a script to compile ASM into bytecode for each core.
The script can be used like this:

GCC_PATH="YOUR_PATH_TO/xpack-riscv-none-elf-gcc-15.2.0-1" ./compile-bio.sh source.s

And will output a block like this:

static const uint32_t bio_program_length = 15;
static const uint32_t bio_program[] = {
    0x010002b7,
    ...
};

You can copy and paste this code into the C implementation. This tool needs xpack (in theory, it can work with any RISC-V gcc compiler) and the hexdump command.

GPIO Handling

Since the GPIO is handled through 32-bit registers, there are up to 32 GPIO pins available to use; here is more info about the internal details.
The 32 pins are:

bits [15:0] -> PB[15:0]
bits [31:16] -> PC[16:0]

In order to use GPIO, you need to:

Set the pin you want to use to AF1 (Alternate Function 1) through the proper register. For example, AFSELBL contains the config for Port B, Pin 0-7 and AFSELBH for Port B, Pin 8-15 Reference
Configure BIOSEL to set the proper bit Reference

So, for example, to use pin PB2, this needs to be done:

AFSELBL = 0x10; // 0b_00_00_00_00_00_01_00_00 or PortB,Pin2=AF1
BIOSEL = 0x4; // 1 << 2 to select Pin2

In the SDK: bio_map_pin(pin_number)

I will use this as an example:
https://github.com/ArmstrongSubero/dabao-sdk/blob/main/examples/bio_blink/bio_blink.c

The name is a bit confusing since the LED won't blink, but it will actually be a PWM using BIO instead of the main CPU.
So in order to generate a PWM, a pulse clock with a certain frequency is needed. For this, x20 will halt until a pulse happens, and this can be configured using the QDIV register for the processor being used, or in the SDK: bio_set_divider(core, divider_int, divider_frac)

Note that in the SDK they use the following example:

bio_set_divider(0, 1750, 0);  /* 100 kHz output (fclk / 1750 / 4) */

I haven't confirmed if this is accurate, since FCLK = 700 MHz (or 700,000) and they use 4 cycles per instruction, but according to the official documentation it is 3 cycles; but maybe this is due to rounding.

So when setting the divider, the x20 or quantum pulse will be delivered every 1/100,000s.
So in ASM, if you do:

addi  x20, x0, 0
# mv x20,x0

This instruction will halt until a quantum pulse happens.

So in order to "blink", the following needs to happen:

setup gpio
wait for quantum pulse
turn ON gpio
wait for quantum pulse
turn OFF gpio
jump to 2.

So the following code is in the example (I'm using pseudo instructions to make it easier to read):

    li x5, 0x4     # bit mask for pin 2
    mv x26, x5     # GPIO mask = pin 2, for this example this is optional
    mv x24, x5     # x24 configures output pins, so pin 2 = output
loop:
    mv x22, x5     # x22 is SET GPIO, so pin 2=HIGH
    mv x20, x0     # wait quantum pulse
    mv x23, x0     # x23 is CLEAR GPIO, so pin 2=LOW
    mv x20, x0     # wait quantum pulse
    j loop         # loop

Starting with ESP32P4-M3-DEV

Daniel Guerrero — Sun, 19 Jul 2026 08:40:20 +0000

I just got a ESP32P4-M3-DEV Board (under several names Guiton ESP32P4-M3-DEV or JC-ESP32P4-M3-DEV)

This board have a module with ESP32-P4 and ESP32-C6 as co-processor for WIFI/Bluetooth.

The board also have a number of helper chips and I/O like Mic, Speaker, 2 USB ports, Camera / Display, Ethernet, Battery, RS485 and Capacitive Touch

The big problem of this board is there is few documentation available, so I started a document to keep track of most of the features and will add some code for testing (even one of the schematics link already have some examples).

The quick details to start are:

You need to connect USB to middle port to power board and enable UART from MCU
You need to select UART as Flash Method
You need to use Rev v1.0 for compiling as chip is revision 1.3 and by default newer sdk use chip version >= 3.x

To use proper revision:

Select Component config -> Hardware Settings -> Chip Revision
Check Select ESP32-P4 revisions <3.0 (No >=3.x Support)
Minimum Supported ESP32-P4 Revision select Rev v1.0

Get the full details
https://danguer.github.io/boards101/guition/jc-esp32p4-m3-dev.html

CH341 with python

Daniel Guerrero — Fri, 03 Apr 2026 22:02:02 +0000

Some time ago I found the CH341a programmer.

The board seems a bit intimidating with its ZIF socket, but once you realize the low component count, it becomes more approachable. When I found a CH341 "dev" board, I started looking for documentation on how to develop with it.

The first step was, of course, finding the datasheet, but it turned out to be quite short. After checking the basics, there was nothing more - no programming guide, no registers, nothing.
Looking for a programming manual, I could only find drivers for Linux, Windows, and Android.

The good news is that this chip has been extensively reverse engineered, so there is a lot of code available. This post is more about the journey of finding all the details.

If you just want to check the code, jump to: https://github.com/danguer/pych341

The Three Modes of CH341

The first thing you will notice is that the CH341 behaves as three different devices depending on some pin configuration.

The modes are:

UART — in this mode the device shows up as a VCOM or Serial Port adapter. There is not much interest in this mode; aside from the full signals available, everything is transparent: you plug it in and it is recognized as a serial device, so no extra work is needed.
PRINT — in this mode it behaves as a "standard Centronics printer interface" and should appear as a parallel printer. This also seems to be a transparent mode, so there is not much interesting here (for now).
EPP/MEM — this is the most interesting mode, as you can use the device as an I2C master, SPI interface, or GPIO controller (it was apparently also designed to read/write parallel memory chips).

The datasheet shows how the pins have different uses under each mode.

Starting with USB Programming

Accessing the USB with pyusb is quite straightforward:

Find a device using the vendor ID and product ID (for EPP/MEM, vendor_id=0x1A86, product_id=0x5512).
List the endpoints.
Find a bulk input (to read) and output (to write).

The write operation is usually wrapped in some special opcodes (more on this later), and the read is transparent - the data you receive comes from GPIO/I2C/SPI without extra frames or opcodes.

Reverse Engineering

Here is where the fun starts. The WCH website contains this file: https://www.wch-ic.com/downloads/CH341PAR_LINUX_ZIP.html, and searching further leads to this repository:
https://github.com/WCHSoftGroup/ch341par_linux

The code is basically:

A demo (testing all functions)
A library
A kernel driver/module

The library calls the kernel driver and passes some arguments. It contains a lot of functions, some for different chips like CH347, and others that seem to not work at all (for example, calls to write/read from parallel memory chips).
This looked like it would just be a matter of reading the source code and following along — except there is no source code for the library.

The README.md from the zip file points to: https://github.com/WCHSoftGroup/ch34x_mphsi_master_linux

This repository contains a much simpler and more straightforward implementation. My first guess was that this was all that was needed, so I started with the I2C implementation.

I2C Implementation

The implementation is based on the ch341_i2c_stream function. The sequence in the original is:

CH341_CMD_I2C_STREAM
CH341_CMD_I2C_STM_STA
CH341_CMD_I2C_STM_OUT (OR with the length of data)
If reading: CH341_CMD_I2C_STM_IN (OR with the length of data)
CH341_CMD_I2C_STM_STO
CH341_CMD_I2C_STM_END

The first thing to note is that there is a "packet" wrapped between CH341_CMD_I2C_STREAM and CH341_CMD_I2C_STM_END, meaning those opcodes are for the chip itself.
After verifying with a logic analyzer and the I2C protocol, CH341_CMD_I2C_STM_STA sends a Start signal and CH341_CMD_I2C_STM_STO sends a Stop signal.

The next thing to note is how you send/receive I2C data. The tricky part is that you must always send the address, which is defined as a 7-bit address plus an R/W bit (Read=1, Write=0). Most libraries handle this automatically, but here you handle the sending and receiving of data directly.

To write data to a device is straightforward:

# send a 0xFF as message to address 0xC0
address = 0xC0
data = 0xFF
cmd = (
  I2CCmd.MODE_STREAM,
  I2CCmd.START,       # start signal
  I2CCmd.DIR_OUT | 2, # sending just 1 byte of data plus 1 byte of address
  address << 1,       # sending 7-bit address and 0 as R/W bit
  data,
  I2CCmd.STOP,        # stop signal
  I2CCmd.END,
)

To read data is a bit different, since you first need to write the address to the device and then read from it. For example, to read 1 byte from the device:

address = 0xC0
cmd = (
  I2CCmd.MODE_STREAM,
  I2CCmd.START,       # start signal
  # write the address
  I2CCmd.DIR_OUT | 1, # sending just 1 byte of address
  (address << 1) | 1, # sending 7-bit address and 1 as R/W bit
  # now actually read data from device
  I2CCmd.DIR_IN | 1,  # just read 1 byte
  I2CCmd.STOP,        # stop signal
  I2CCmd.END,
)

The i2c.py module follows the Arduino Wire library approach.

More information about I2C: https://www.ti.com/lit/an/sbaa565/sbaa565.pdf

GPIO Implementation

This is probably the trickiest part. The first implementation appears to target CH347 and uses a control endpoint instead of bulk:
https://github.com/WCHSoftGroup/ch34x_mphsi_master_linux/blob/main/driver/ch34x_mphsi_master_gpio.c#L345

The driver has CH34xSetOutput and CH34xSet_D5_D0, so I decided to cross-reference this against the older library source code: https://github.com/zoobab/ch341-parport/blob/master/CH341PAR_LINUX/lib/ch34x_lib.c#L593

There is also a simpler implementation here: https://github.com/frank-zago/ch341-i2c-spi-gpio/blob/master/gpio-ch341.c#L198

Writing GPIO

There are some undocumented values, but here is the packet structure:

[byte0] 0xA1 (output command)
[byte1] 0x6A (magic value)
[byte2] enable mask
[byte3] Byte 1 Data (0 for LOW, 1 for HIGH)
[byte4] Byte 1 Direction (0 for INPUT, 1 for OUTPUT)
[byte5] Byte 0 Data (0 for LOW, 1 for HIGH)
[byte6] Byte 0 Direction (0 for INPUT, 1 for OUTPUT)
[byte7] Byte 2 Data (0 for LOW, 1 for HIGH)
[byte8] Byte 2 Direction (should be 0x00)
[byte9] Byte 3 Data (0 for LOW, 1 for HIGH)
[byte10] Byte 3 Direction (should be 0x00)

The packet must be exactly 11 bytes.

GPIO Bytes

There are 4 GPIO bytes in the following order:

Byte 1 (bits 8–15), pins: ERR, PEMP, INT, SLCT, unknown, WAIT, READ, ADDR
Byte 0 (bits 0–7), pins: D0–D7
Byte 2 (bits 16–23), pins: WRITE, SCL
Byte 3 (bits 24–31), pins: SDA

Enable Mask

The enable mask consists of pairs of bits that enable output and direction. Since this function is only for writing outputs, you need to always set both to 1. It follows the same order as the GPIO bytes, meaning the first two bits control enable and data direction for Byte 1 (bits 8–15):

bits 0,1 = Byte 1 Enable, Direction
bits 2,3 = Byte 0 Enable, Direction
bits 4,5 = Byte 2 Enable, Direction
bits 6,7 = Byte 3 Enable, Direction

Note that Byte 2 and Byte 3 only allow output direction, but you need to set Enable=0, Direction=1. The documentation is not very clear about the meaning of "enable" here.

Writing with `CH34xSet_D5_D0`

A special message exists to set only pins D0–D5. The packet is very simple:

cmd = (
    GPIOCmd.UIO_STREAM,              # 0xAB
    GPIOCmd.UIO_DIR | 0x3F,          # 0x40
    GPIOCmd.UIO_OUT | (mask & 0x3F), # 0x80
    GPIOCmd.UIO_STREAM_END,          # 0x20
)

The mask bits represent the pins to set HIGH. For example, to set D0 HIGH use 0x1, and to set D0 and D2 HIGH use 0x5.

Reading

Reading is simple, though it involves some undocumented behavior:

cmd = GPIOCmd.INPUT # 0xA0

After sending the command, read 6 bytes of data:

[byte0] Byte 0 Data
[byte1] Byte 1 Data

All other bytes are undocumented or represent output pins.
To read the value of D0:

d0_value = data[0] & 0x1

SPI Implementation

This is the simplest implementation, but it does require some understanding of SPI. The implementation needs to:

Send X bytes
Read X bytes

This is because SPI is full-duplex, meaning that when you send data you also receive data within the same clock cycle. You must send and read simultaneously, or the buffers will overflow.

The implementation is based on: https://github.com/WCHSoftGroup/ch34x_mphsi_master_linux/blob/main/driver/ch34x_mphsi_master_spi.c#L511

The command is:

def write(self, data: bytes) -> bytes:
  data_len = len(data)
  cmd = bytearray()
  cmd.append(SPICmd.MODE_STREAM) # 0xA8
  cmd += data

  self.device.write(cmd)

  # after writing, read the controller response
  return self.device.read(data_len)

That is all there is to it. To read from SPI, simply call data = write(0xFF).

The one tricky part is that the chip always transmits in LSB-first order, so sending 1 is transmitted as 1 0 0 0 0 0 0 0. Most devices expect MSB-first (0 0 0 0 0 0 0 1), so you can use a lookup table to convert between the two.

Chip Select

The board has CS0, CS1, and CS2, but there is no dedicated command for chip select. Instead, you enable it through GPIO using CH34xSet_D5_D0. For example, set D0 HIGH before a transaction and LOW after to use it as a chip select signal.

Zephyr on Arduino UNO Q MCU

Daniel Guerrero — Fri, 02 Jan 2026 19:53:20 +0000

The Arduino UNO Q have a STM32U585 inside doing all the Arduino stuff, it communicates with main processor and GPIO pins on board; it seems the only way to get a pinout is the schematics:
https://docs.arduino.cc/resources/schematics/ABX00162-schematics.pdf

The pinout image have brief information about the MCU pins

Source

But only shows that pins belong to MCU, and the only indication are on RGB LED 3 and 4 that shows the GPIO used for the MCU.

For this example it will be needed:

Zephyr (on the PC Host, probably can be reused the version in UNO Q)
ADB tools (to connect to the device from PC Host)

Zephyr

You need to install / update Zephyr. Is important to have at least version 4.3.0 as that is the first version with support

Compile example

It can be used the blinky example directly from documentation:

# use the path to your zephyr setup
cd ~/zephyrproject/zephyr
west build -p always -b arduino_uno_q samples/basic/blinky

Upload to device

Once compiled it needs to be copied to UNO Q device using adb:

adb push build/zephyr/zephyr.elf /tmp/

Flash MCU

The only remaining step is to flash the STM32 MCU this can be done with the tools already installed in the UNO Q

adb shell

# following commands must be in the UNO Q
# paths are hardcoded but should work
# probably some paths needs to be updated with proper versions
/home/arduino/.arduino15/packages/arduino/tools/remoteocd/0.0.4-rc.4/remoteocd \
    upload \
    --adb-path "/home/arduino/.arduino15/packages/arduino/tools/adb/32.0.0/adb" \
    -s "{upload.port.properties.serialNumber}" \
    -f "/home/arduino/.arduino15/packages/arduino/hardware/zephyr/0.52.0/variants/arduino_uno_q_stm32u585xx/flash_bootloader.cfg" \
    "--verbose" \
    /tmp/zephyr.elf

If everything is fine, the LED3 will blink with a green color

Restoring Sketch Bootloader

If you use Arduino App Lab and try to upload a new sketch, you will notice there will be error on uploading, this is because the MCU contains a called "Sketch Bootloader" and the sketch code is added on top of that.
But the Arduino UNO Q have the commands to restore:

arduino-cli burn-bootloader -b arduino:zephyr:unoq -P jlink

With this command will upload the Sketch Bootloader so you can upload code from the App Lab. Nice!

References

MAX7219 Example (8 digit segment driver)

Daniel Guerrero — Wed, 31 Dec 2025 20:35:00 +0000

The MAX7219 is a 8 digit segment driver, it can also work as standard 8x8 LED driver, but since there is BCD support, it works much better with 7-segment parts.

The board I used have 8 segments and the MAX7219

The inputs are just Power(GND, VCC), DIN (Serial Data Input), CLK and LOAD/CS
Even it looks like a SPI module, only the MAX7221 supports it, so the input for MAX7219 is serial and is simple to use.

It needs to be sent 16 bit data which are split into lower 8 bits for the data and higher 8 bits for register.

The datasheet is very clear and helpful about all parts, my only complain is the functional diagram suggest the data is loaded with LSB first which is not the case.

For the address, there are few commands:

Digit 0-7 data (0x1 to 0x8)
Decode mode 0x9 (Disable / Enable BCD for each digit)
Intensity 0xA (16 levels of intensity going from 0x0 to 0xF)
Scan Limit 0xB (Disable / Enable digit output)
Shutdown 0xC (Disable / Enable output)
Display Test 0xF (Disable / Enable test mode).

The Display Test just enable all segments and all digits at full intensity.
For Shutdown if data is 0x1 will enable output (TBH a bit odd to use that naming)

Register: Scan Limit

The Scan Limit allows to how many digits to be display, so it can be up to 0x7 (to display 8 digits). As note, the reset value of 0x0 means that will show first digit; if you want to disable all output then you need to use the Shutdown command, or just set the first digit to 0x0 (no segment on) for No Decode mode, or 0xF for BCD mode

Register: Digit

The Digit data will store 8 bits for the specific digit, the data can be stored in two ways:

Standard (No BCD / No Decode)
BCD

In the Standard, you need to select through bits which part to show from the 7-segment, so for example to display a 1 you can store 0x30 or D5=1,D4=1 (B=1,C=1)

In the BCD mode, the value from 0x0 to 0x9 (or 0-9) will be converted into the proper segments on, so if a 0x1 is stored, the driver will properly convert to show segments B=1,C=1.
There are some special characters going from 0xA to 0xF:

0xA = dash(-)
0xB = E
0xC = H
0xD = L
0xE = P
0xF blank, so no output, the same as 0x0 in No Decode Mode

(Yes you can send a HELP message with 0x040C 0x030B 0x020D 0x010E

Register: Decode Mode

The Decode Moderegister allows to use the No Decode/BCD mode, and the register is a bit interesting since is a mask, if the value is 0x0 means no decode so the data are just the segment to set on.
But if you want a specific digit to use BCD, you can use as mask, so for example to enable BCD on:

Digit 0 0x1
Digit 1 0x2
Digit 0 and 1 0x3

Register: Loading Data

The loading data is very simple, when you rise the CLK it will read the DIN and add to serial buffer (MSB to LSB order).
So sending a bit is very simple:

digitalWrite(PIN_CLK, LOW);
// check if MSB bit is on
if (cmd & 0x8000) {
    digitalWrite(PIN_DIN, HIGH);
} else {
    digitalWrite(PIN_DIN, LOW);
}
digitalWrite(PIN_CLK, HIGH);

And to send a 16 bit value:

// enable test mode
// 0x0F is test mode register
// 0x01 is enable data
uint16_t cmd = 0x0F01;
for (int i = 0; i < 16; i++) {
    digitalWrite(PIN_CLK, LOW);
    // check if MSB bit is on
    if (cmd & 0x8000) {
        digitalWrite(PIN_DIN, HIGH);
    } else {
        digitalWrite(PIN_DIN, LOW);
    }
    digitalWrite(PIN_CLK, HIGH);
    // shift one bit
    cmd <<= 1;
}

In the case of the MAX7219 when LOAD rises, it will load the last 16 bits from the DIN input into the decoder and run the command.
So this is achieved after sending the data:

// latch the data
// rise the LOAD pin from low to high and go back into low after that
digitalWrite(PIN_LOAD, LOW);
digitalWrite(PIN_LOAD, HIGH);
digitalWrite(PIN_LOAD, LOW);

Commands

Everything is a 16 bit data, so there is a helper function to build the data:

uint16_t buildCmd(uint8_t registerAddress, uint8_t data)
{
    return ((uint16_t)registerAddress << 8) | data;
}

Note that this can be converted into a macro if is needed better performance.

So the commands are very easy to build, for example to send a number 6 to digit 0 (using BCD):

// 0x1 is the register for digit 0
uint16_t cmd = buildCmd(0x1, 6);
// this is the function using code previously 
// posted to send data to module
sendCmd(cmd);

Or if not using BCD:

// 0x1 is the register for digit 0
// 6 uses A,C,D,E,F,G so is 
// 0101 1111 or 0x5F
uint16_t cmd = buildCmd(0x1, 0x5F);
// this is the function using code previously 
// posted to send data to module
sendCmd(cmd);

Example

The example uses the test mode, but later sets all the registers to "reset" most of them, note that this is not really needed if you only reset the module and never use the test mode.
But I think is good to have it so you can configure everything before use:

cmdSetScanLimit(7); // Enable all 8 digits
cmdSetIntensity(0); // lowest intensity
cmdSetDecodeMode(0xFF); // all digits will use BCD

// set all segments to blank
for (uint8_t i = 0; i < 8; i++) {
  uint16_t cmd = buildCmd(REGISTER_DIGIT0 + i, 0xF);
  sendCmd(cmd);
}

// send all the possible values on BCD, finishing with blank
for (uint8_t i = 0; i < 8; i++) {
  for (uint8_t j = 0; j < 16; j++) {
    uint16_t cmd = buildCmd(REGISTER_DIGIT0 + i, j); 
    sendCmd(cmd);
    delay(200);
  }
}

Example url

https://github.com/danguer/arduino-examples/tree/main/max7219

Datasheet

https://www.analog.com/media/en/technical-documentation/data-sheets/max7219-max7221.pdf

MAX7219 Example (8 digit segment driver)

Daniel Guerrero — Wed, 31 Dec 2025 20:35:00 +0000

The MAX7219 is a 8 digit segment driver, it can also work as standard 8x8 LED driver, but since there is BCD support, it works much better with 7-segment parts.

The board I used have 8 segments and the MAX7219

It needs to be sent 16 bit data which are split into lower 8 bits for the data and higher 8 bits for register.

The datasheet is very clear and helpful about all parts, my only complain is the functional diagram suggest the data is loaded with LSB first which is not the case.

For the address, there are few commands:

Digit 0-7 data (0x1 to 0x8)
Decode mode 0x9 (Disable / Enable BCD for each digit)
Intensity 0xA (16 levels of intensity going from 0x0 to 0xF)
Scan Limit 0xB (Disable / Enable digit output)
Shutdown 0xC (Disable / Enable output)
Display Test 0xF (Disable / Enable test mode).

The Display Test just enable all segments and all digits at full intensity.
For Shutdown if data is 0x1 will enable output (TBH a bit odd to use that naming)

Register: Scan Limit

Register: Digit

The Digit data will store 8 bits for the specific digit, the data can be stored in two ways:

Standard (No BCD / No Decode)
BCD

In the Standard, you need to select through bits which part to show from the 7-segment, so for example to display a 1 you can store 0x30 or D5=1,D4=1 (B=1,C=1)

0xA = dash(-)
0xB = E
0xC = H
0xD = L
0xE = P
0xF blank, so no output, the same as 0x0 in No Decode Mode

(Yes you can send a HELP message with 0x040C 0x030B 0x020D 0x010E

Register: Decode Mode

Digit 0 0x1
Digit 1 0x2
Digit 0 and 1 0x3

Register: Loading Data

The loading data is very simple, when you rise the CLK it will read the DIN and add to serial buffer (MSB to LSB order).
So sending a bit is very simple:

digitalWrite(PIN_CLK, LOW);
// check if MSB bit is on
if (cmd & 0x8000) {
    digitalWrite(PIN_DIN, HIGH);
} else {
    digitalWrite(PIN_DIN, LOW);
}
digitalWrite(PIN_CLK, HIGH);

And to send a 16 bit value:

// enable test mode
// 0x0F is test mode register
// 0x01 is enable data
uint16_t cmd = 0x0F01;
for (int i = 0; i < 16; i++) {
    digitalWrite(PIN_CLK, LOW);
    // check if MSB bit is on
    if (cmd & 0x8000) {
        digitalWrite(PIN_DIN, HIGH);
    } else {
        digitalWrite(PIN_DIN, LOW);
    }
    digitalWrite(PIN_CLK, HIGH);
    // shift one bit
    cmd <<= 1;
}

In the case of the MAX7219 when LOAD rises, it will load the last 16 bits from the DIN input into the decoder and run the command.
So this is achieved after sending the data:

// latch the data
// rise the LOAD pin from low to high and go back into low after that
digitalWrite(PIN_LOAD, LOW);
digitalWrite(PIN_LOAD, HIGH);
digitalWrite(PIN_LOAD, LOW);

Commands

Everything is a 16 bit data, so there is a helper function to build the data:

uint16_t buildCmd(uint8_t registerAddress, uint8_t data)
{
    return ((uint16_t)registerAddress << 8) | data;
}

Note that this can be converted into a macro if is needed better performance.

So the commands are very easy to build, for example to send a number 6 to digit 0 (using BCD):

// 0x1 is the register for digit 0
uint16_t cmd = buildCmd(0x1, 6);
// this is the function using code previously 
// posted to send data to module
sendCmd(cmd);

Or if not using BCD:

// 0x1 is the register for digit 0
// 6 uses A,C,D,E,F,G so is 
// 0101 1111 or 0x5F
uint16_t cmd = buildCmd(0x1, 0x5F);
// this is the function using code previously 
// posted to send data to module
sendCmd(cmd);

Example

cmdSetScanLimit(7); // Enable all 8 digits
cmdSetIntensity(0); // lowest intensity
cmdSetDecodeMode(0xFF); // all digits will use BCD

// set all segments to blank
for (uint8_t i = 0; i < 8; i++) {
  uint16_t cmd = buildCmd(REGISTER_DIGIT0 + i, 0xF);
  sendCmd(cmd);
}

// send all the possible values on BCD, finishing with blank
for (uint8_t i = 0; i < 8; i++) {
  for (uint8_t j = 0; j < 16; j++) {
    uint16_t cmd = buildCmd(REGISTER_DIGIT0 + i, j); 
    sendCmd(cmd);
    delay(200);
  }
}

Example url

https://github.com/danguer/arduino-examples/tree/main/max7219

Datasheet

https://www.analog.com/media/en/technical-documentation/data-sheets/max7219-max7221.pdf

TM1637 Board Arduino Example

Daniel Guerrero — Tue, 18 Nov 2025 07:10:10 +0000

The TM1637 is a 8 segments led controller which can control up to 6 displays and key scan of 16 inputs.
There are multiple boards but the most common is using 4 displays with two dots in the middle so can be used as a timer display.

The protocol is similar to I2C but is simpler as there is no need of device address.
So the protocol is the following:

Start Signal
Command Data Byte
Optional Data Byte(s)
End Signal

Start Signal

CLK must be HIGH
DIO must transition from HIGH to LOW

End Signal

CLK must be HIGH
DIO must transition from LOW to HIGH

Sending Data

DIO must be set to value when CLK is low
Send 8 bits, each clock cycle can be at most 2us (maximum speed of 500Khz)
After 8 bits the 9th clock cycle the chip will send an ACK setting DIO to LOW

There are 3 types of commands:

Data command (write to displays or read key scan)
Address command (which display to use, it can be up to 6 displays, but the board only contain 4)
Display, set displays ON/OFF and set brightness (8 possible levels)

The Data command allows to send a specific address or auto-increment (the most common scenario) so after setting the initial address it can be sent all the data to write in the displays without need to keep setting the address after each command.

The examples in the datasheet shows that Display commands are sent at the end; but there is no need for that, it can be sent before any Data command to set the configuration; after set, there is no need to be changed (except for some reason the display is reset)

The displays in the board are 8 Segments Displays

Actually are 7 Segments Displays as there is no dot and the two dots in the middle are handled by the second display.
The byte order is: Xgfedcba where X is the dot or DP

Arduino Code

To make work in Arduino, you need 2 pin inputs and three functions:

Start Transfer
End Transfer
Byte Write

void dataTransferStart() {
  // according to doc, start must be
  // a transition of DIO from LOW to HIGH
  // when a CLK clock is HIGH
  digitalWrite(PIN_DIO, HIGH);
  digitalWrite(PIN_CLK, HIGH);
  delayClock();
  digitalWrite(PIN_DIO, LOW);
  delayClock();
  digitalWrite(PIN_CLK, LOW);
  delayClock();
}

void dataTransferEnd() {
  // according to doc, end must be
  // a transition of DIO from HIGH to LOW
  // when a CLK clock is HIGH
  digitalWrite(PIN_DIO, LOW);
  digitalWrite(PIN_CLK, HIGH);
  delayClock();
  digitalWrite(PIN_DIO, HIGH);
  digitalWrite(PIN_CLK, LOW);
  delayClock();
}

unsigned char writeByte(unsigned char data) {
  // clock is assumed to be low, but just in case
  digitalWrite(PIN_CLK, LOW);

  for (unsigned char i = 0; i < 8; i++) {
    digitalWrite(PIN_DIO, (data & 0x1) ? HIGH : LOW);
    data = data >> 1;

    // run a clock cycle
    delayClock();
    digitalWrite(PIN_CLK, HIGH);
    delayClock();
    digitalWrite(PIN_CLK, LOW);
  }

  // here the chip does an ACK for one cycle
  pinMode(PIN_DIO, INPUT);
  delayClock();
  unsigned char ack = digitalRead(PIN_DIO);

  // finish clock cycle
  digitalWrite(PIN_CLK, HIGH);
  delayClock();
  digitalWrite(PIN_CLK, LOW);
  pinMode(PIN_DIO, OUTPUT);

  return ack;
}

The commands are very simple, the two MSB bits define the type of command:

01 Data
10 Display
11 Address

The most simple is the display:

void setBrightness(unsigned char brightness) {
  // display settings
  dataTransferStart();
  // this will be 0b10_00_1_XXX
  writeByte(CMD_DISPLAY | CMD_DISPLAY_ON | (brightness & 0x7));
  dataTransferEnd();
}

So the 0b10_00_1_XXX means: 10 is the Display command, the 00 are "irrelevant" items in the datasheet, 1 is to enable the display and XXX is the level of the brightness.

The full code and example is here: https://github.com/danguer/arduino-examples/tree/main/tm1637

HC05 / XBee First Steps

Daniel Guerrero — Sun, 19 Oct 2025 03:17:16 +0000

Long time ago, while researching ways to communicate through arduino, I found XBee modules, I was looking LoRa modules and this seems to fit so I got several of them

since the pins are smaller than regular later I got something called an XBee Explorer to connect to computer

I didn't know at the time much about communication modules so didn't do much research.
Recently I wanted to test the modules again, so I started doing the research.

The original XBee are devices from Zigbee that have a specific shape and specific pins, there are different options for modules, including LoRa, WiFi and Bluetooth

The pinout for the Xbee is this:

Source

Now, the modules I got are labeled "HC05" it turns those are actually a breakout board for a module called HC05 which is soldered to the pin, the module is this:

This module is also a breakout board to only use Serial capabilities

The pinout for the module is this:
Source

So contain a lot of pins that are not used in any board

The HC05 is a Bluetooth module that supports:

Master / Slave Mode
AT Commands
Serial data transmission

So the module is a bit similar to the CH9143 except:

CH9143 is a BLE device and HC05 only supports Bluetooth pairing
Master mode can pair to any other device
There is no USB support on HC05, only Serial
You can set name of the device (among other things)

Connect to module

There is a lot of examples using Arduino to send Serial data, but in this case will be directly connected to computer with python.

So to connect to computer the XBee Explorer seems like a good solution, this contains an USB to Serial solution. The main issue is to enter into AT Commands you need to set AD0 / Key / BTN pin to VCC, otherwise the module will be in pairing and only sending / receiving data but can't configure.

So a solution is to use a USB to Serial module and a breakout board (to convert 2mm pins from xbee to standard 2.5mm, an alternative could be to solder into the pin of the XBee Explorer), so the connection is:

3.3v -> VCC (PIN 1)
RX -> Dout (PIN 2)
TX -> Din (PIN 3)
GND -> Dout (PIN 10)
RTS -> AD0/Key/BTN (PIN 20)

The RTS is needed to enter into AT Mode, the serial code will send this signal to enter and leave after paired with other device.

To test you could use the app Serial Bluetooth Terminal

You can run with:

python3 ch05.py /dev/ttyACM1

The output will show some info about the device and wait until you pair the device in the app

Opening port:  /dev/ttyACM1
Entering into AT mode
Sending AT... (checking if AT is enabled)
Response:  ['ERROR:(0)']
AT+VERSION? ['+VERSION:2.0-20100601', 'OK']
device MAC XX:XX:XX:XX:XX:XX
AT+NAME?: [device name] H-C-2010-06-01
AT+ROLE?: [role, 0=Slave, 1=Master] ['+ROLE:0', 'OK']
AT+ADCN?:  ['+ADCN:7', 'OK']
AT+MRAD? [connected device mac]:  XX:XX:XX:XX:XX:XX
Pair to the device: H-C-2010-06-01 with password 1234
Waiting until is paired
Sending and receiving messages, press CTRL+C to stop
Creating background receiving thread
Sending ping 0
Sending ping 1
Sending ping 2
Sending ping 3

To pair in device, in the app select the three dots, then Devices and later the H-C-2010-06-01 (note that name can be different like HC05 or similar but that will show in the console)

And on device will show the ping

Code:

import serial
import threading
import argparse
import time
from typing import List

keep_reading = True

def read_serial(ser: serial.Serial):
    while keep_reading:
        if ser.in_waiting > 0:
            waiting = ser.in_waiting
            line = ser.read(waiting).decode("utf-8").strip()
            print("Serial Input: ", line)

def send_at_command(ser: serial.Serial, command: str) -> List[str]:
    # send command
    ser.write(f"{command}\r\n".encode("ascii"))
    # read command back
    data = []
    while True:
        line = ser.readline().decode("ascii").strip()
        data.append(line)
        if line == "OK" or "ERROR" in line:
            break

    return data

def clean_mac_response(mac: str) -> str:
    # first part is always from response
    mac = mac.split(":")[1:]
    # make a single string
    mac = "".join(mac)

    # split into groups of 2 values
    mac = [mac[i:i+2] for i in range(0, len(mac), 2)]

    return ":".join(mac)

parser = argparse.ArgumentParser(prog="HC05 Uart Example")
parser.add_argument(
    "serial_port", 
    help="Serial port like /dev/ttyACM0",
)
args = parser.parse_args()

params = {
    "port": args.serial_port,
    "baudrate": 38400,
    "bytesize": serial.EIGHTBITS, 
    "parity": serial.PARITY_NONE, 
    "stopbits": serial.STOPBITS_ONE, 
    "timeout": 1,
}

print("Opening port: ", args.serial_port)
with serial.Serial(**params) as ser:
    print("Entering into AT mode")
    # this will set RTS=3.3v 
    ser.rts = False
    time.sleep(0.1)

    print("Sending AT... (checking if AT is enabled)")
    print("Response: ", send_at_command(ser, "AT..."))
    print("AT+VERSION?", send_at_command(ser, "AT+VERSION?"))

    mac = send_at_command(ser, "AT+ADDR?")[0]
    if "ERROR" not in mac:
        print("device MAC", clean_mac_response(mac))

    device_name = send_at_command(ser, "AT+NAME?")[0].replace("+NAME:", "")
    print("AT+NAME?: [device name]", device_name)
    print("AT+ROLE?: [role, 0=Slave, 1=Master]", send_at_command(ser, "AT+ROLE?"))
    print("AT+ADCN?: ", send_at_command(ser, "AT+ADCN?"))

    mac = send_at_command(ser, "AT+MRAD?")[0]
    if "ERROR" not in mac:
        print("AT+MRAD? [connected device mac]: ", clean_mac_response(mac))

    # wait until is paired
    print(f"Pair to the device: {device_name} with password 1234")
    print("Waiting until is paired")
    while True:
        state = send_at_command(ser, "AT+STATE?")[0]
        if state == "OK" or state == "+STATE:PAIRED" or state == "+STATE:CONNECTED":
            break
        else:
            time.sleep(1)


    # disable AT mode
    ser.rts = True

    # send and receive data
    print("Sending and receiving messages, press CTRL+C to stop")
    print("Creating background receiving thread")
    thread_read = threading.Thread(target=read_serial, args=(ser,))
    thread_read.start()

    try:
        send_idx = 0
        while True:
            print(f"Sending ping {send_idx}")
            ser.write(f"UART PING {send_idx}\n".encode("ascii"))
            send_idx += 1
            time.sleep(1)
    except KeyboardInterrupt:
        pass
    finally:
        print("Finishing reading thread")
        keep_reading = False
        thread_read.join()

You will need pyserial

pip install pyserial

Final Notes

There are more commands in AT mode, here is a simple list of all: https://s3-sa-east-1.amazonaws.com/robocore-lojavirtual/709/HC-05_ATCommandSet.pdf

The HC05 module is actually a MCU BC417 with a flash memory with the firmware.
The MCU seems very capable of different things, including sending audio and controlling several GPIO and SPI, but there is no documentation about how to program it.

Starting With Luckfox Lyra Zero W

Daniel Guerrero — Sat, 04 Oct 2025 21:43:55 +0000

The Luckfox Lyra Zero W is a Development Board with RK3506B Chip, Triple-core Arm Cortex-A7 and Arm Cortex-M0 Processors.

The Ubuntu image is here:
https://github.com/platima/SBC-Images/tree/main/Luckfox/Lyra/Lyra%20Zero%20W

The main issue with image is there no extra disk space so you can't do any resize operation in the same device.

So the options are:

Resize the img file
Resize the SD partition

For both operations you'll need a Linux machine to run the commands

Resize the `img` file

When you have the img file after bunzip it, run the following commands:

# grow the image by 7GB so final will be 8GB, change to proper SD size
dd if=/dev/zero bs=1G count=7 \
  oflag=append conv=notrunc \
  of=Luckfox_Lyra_Zero_W-2503_Ubuntu.img

sudo losetup --find --partscan \
  Luckfox_Lyra_Zero_W-2503_Ubuntu.img

# check with lsblk which loop device 
# (there will be 3 partitions)
# in my case the device is /dev/loop2
lsblk

# data is partition 3 so check for failed sectors
sudo e2fsck -y /dev/loop2p3

# grow partition
sudo growpart -v /dev/loop2 3

# resize ext4 partition
sudo resize2fs /dev/loop2p3

# unmount loop file
sudo losetup --detach /dev/loop2

The new size of the img file will be of 8GB after this so the root will have now 7GB of free space, this is simpler as you don't need to mount the SD card, but the problem is that you will get unused space in the card.

Resize the SD card

Once you write the img to SD using a tool like Balena Etcher or Rufus, you need to do the following:

# check the device used
lsblk

# in my case is /dev/sdd

# if is automatically mounted, unmount it
sudo umount /dev/sdd3

# data is partition 3 so check for failed sectors
sudo e2fsck -y -f /dev/sdd3

# grow partition
sudo growpart -v /dev/sdd 3

# resize ext4 partition
sudo resize2fs /dev/sdd3

Connect through USB

To connect to device, ADB tools can be used

Run adb to list devices

adb devices -l

If a device is present, then connect:

adb shell

WiFi setup

You need to provide the details of your network, for this edit the /etc/wpa_supplicant.conf
The original contents will be:

ctrl_interface=/var/run/wpa_supplicant
ap_scan=1
update_config=1

network={
        ssid="SSID"
        psk="PASSWORD"
        key_mgmt=WPA-PSK
}

Change the SSID and PASSWORD for the details of your WiFi network.
After that create a file /etc/network/interfaces.d/wlan0
And there are two options: dhcp (most common) or static ip

WiFi DHCP

auto wlan0
iface wlan0 inet dhcp
    wpa-conf /etc/wpa_supplicant.conf

WiFi Static IP

Change address, gateway and other params to your proper settings

auto wlan0
iface wlan0 inet static
    wpa-conf /etc/wpa_supplicant.conf
    address 192.168.2.100
    netmask 255.255.255.0
    gateway 192.168.2.1

There is an issue with resolv.conf that image set to a docker nameserver, so needs to be replaced:

echo "nameserver 1.1.1.1 8.8.8.8" > /etc/resolv.conf

Apply the config with:

systemctl restart networking

Example using ST TOF VL53L4CD

Daniel Guerrero — Sun, 21 Sep 2025 06:24:02 +0000

The VL53L4CD is a TOF (Time of Flight) sensor capable of measure distances from 1mm to 1200mm.

Unfortunately the datasheet doesn't provide any register information. But they provide an API but no good documentation about api functions.

The STM32Cube have a package for this: X-CUBE-TOF1 there are several applications but all uses a lot of abstractions to handle all the devices, so my goal was to have a very simple example for this specific board based on that.

To setup the project, you need to do:
Enable I2C1

Enable X-CUBE-TOF1 in the Middleware & Software section

Select Board Part Ranging, and select VL53L4CD

Configure to use the I2C1 and XShut pin

This will create a project that will contain one file called custom_tof_conf.h which contains some defines, for example:

#define USE_CUSTOM_RANGING_VL53L4CD (1U)

#define CUSTOM_VL53L4CD_XSHUT_PORT    GPIOA
#define CUSTOM_VL53L4CD_XSHUT_PIN     GPIO_PIN_1

#define CUSTOM_VL53L4CD_I2C_INIT      BSP_I2C1_Init
#define CUSTOM_VL53L4CD_I2C_DEINIT    BSP_I2C1_DeInit
#define CUSTOM_VL53L4CD_I2C_WRITEREG  BSP_I2C1_Send
#define CUSTOM_VL53L4CD_I2C_READREG   BSP_I2C1_Recv

You need to create a file to use the API, I've created two files: tof.c and tof.h
The code is very simple it will:

Init the device (check device is reachable through I2C and get capabilities)
Configure the device (set device settings and set the measure as continuous)
Get the distance

Is important to note that the XShut pin in the TOF is an enable pin and the API is toggling automatically, so for this example the XShut is connected to VCC (3.3v) to be always enabled, if you have multiple I2C devices, you will need to enable / disable using the CUSTOM_VL53L4CD_XSHUT_PORT and CUSTOM_VL53L4CD_XSHUT_PIN before any API call (or add in the tof.c).

The UM2931 contains more information about how to connect each pin in TOF board and dev board.

The tof.c code:

#include "tof.h"
#include "custom_tof_conf.h"
#include <stdio.h>

VL53L4CD_Object_t   tof_obj;
VL53L4CD_Capabilities_t tof_cap;
VL53L4CD_ProfileConfig_t tof_profile;

static int32_t decimal_part(float_t x)
{
    int32_t int_part = (int32_t) x;
    return (int32_t)((x - int_part) * 100);
}

static void print_result(VL53L4CD_Result_t *result)
{
    uint8_t i;
    uint8_t j;

    for (i = 0; i < result->NumberOfZones; i++)
    {
        if (i > 0) {
            printf("\r\n");
        }
        printf("Targets = %lu", (unsigned long)result->ZoneResult[i].NumberOfTargets);

        for (j = 0; j < result->ZoneResult[i].NumberOfTargets; j++)
        {
            printf("\r\n |---> ");

            printf("Status = %ld, Distance = %5ld mm ",
                (long)result->ZoneResult[i].Status[j],
                (long)result->ZoneResult[i].Distance[j]);

            if (tof_profile.EnableAmbient)
            {
                printf(", Ambient = %ld.%02ld kcps/spad",
                    (long)result->ZoneResult[i].Ambient[j],
                    (long)decimal_part(result->ZoneResult[i].Ambient[j]));
            }

            if (tof_profile.EnableSignal)
            {
                printf(", Signal = %ld.%02ld kcps/spad",
                  (long)result->ZoneResult[i].Signal[j],
                  (long)decimal_part(result->ZoneResult[i].Signal[j]));
            }
        }
    }

    printf("\r\n");
}

int32_t TOF_Init()
{
    int32_t ret;
    VL53L4CD_IO_t              IOCtx;
    uint32_t                   id;

    /* Configure the ranging sensor driver */
    IOCtx.Address     = VL53L4CD_DEVICE_ADDRESS;
    IOCtx.Init        = CUSTOM_VL53L4CD_I2C_INIT;
    IOCtx.DeInit      = CUSTOM_VL53L4CD_I2C_DEINIT;
    IOCtx.WriteReg    = CUSTOM_VL53L4CD_I2C_WRITEREG;
    IOCtx.ReadReg     = CUSTOM_VL53L4CD_I2C_READREG;
    IOCtx.GetTick     = BSP_GetTick;

    if (VL53L4CD_RegisterBusIO(&tof_obj, &IOCtx) != VL53L4CD_OK)
    {
        printf("Cannot register bus\r\n");
        ret = BSP_ERROR_COMPONENT_FAILURE;
    }
    else if ( (ret = VL53L4CD_ReadID(&tof_obj, &id)) != 0)
    {
        printf("Cannot read ID %ld\r\n", ret);
        ret = BSP_ERROR_COMPONENT_FAILURE;
    }
    else
    {
        if (id != VL53L4CD_ID)
        {
            printf("Wrong ID %ld\r\n", id);
            ret = BSP_ERROR_UNKNOWN_COMPONENT;
        }
        else
        {
            printf("Got device id: %ld\r\n", id);

            //init device
            if (VL53L4CD_Init(&tof_obj) != VL53L4CD_OK)
            {
                printf("Cannot init tof\r\n");
                ret = BSP_ERROR_COMPONENT_FAILURE;
            }
            else if (VL53L4CD_GetCapabilities(&tof_obj, &tof_cap) != VL53L4CD_OK)
            {
                printf("Cannot get capabilities\r\n");
                ret = BSP_ERROR_COMPONENT_FAILURE;
            }
            else
            {
                printf("TOF Initialized\r\n");
                ret = BSP_ERROR_NONE;
            }
        }
    }

    return ret;
}

int32_t TOF_Configure()
{
    tof_profile.RangingProfile = VL53L4CD_PROFILE_CONTINUOUS;
    tof_profile.TimingBudget = 30U;
    tof_profile.Frequency = 0; /* Induces intermeasurement period, NOT USED for normal ranging */
    tof_profile.EnableAmbient = 1; /* Enable: 1, Disable: 0 */
    tof_profile.EnableSignal = 1; /* Enable: 1, Disable: 0 */

    /* set the profile if different from default one */
    VL53L4CD_ConfigProfile(&tof_obj, &tof_profile);

    return VL53L4CD_Start(&tof_obj, VL53L4CD_MODE_BLOCKING_CONTINUOUS);
}

int32_t TOF_GetDistance(VL53L4CD_Result_t *result)
{
    int32_t status = VL53L4CD_GetDistance(&tof_obj, result);

    if (status == BSP_ERROR_NONE)
    {
        print_result(result);
    }
    else
    {
        printf("Failed to get measure: %ld\r\n", status);
    }

    return status;
}

tof.h


#ifndef INC_TOF_H_
#define INC_TOF_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "vl53l4cd.h"

int32_t TOF_Init();
int32_t TOF_Configure();
int32_t TOF_GetDistance(VL53L4CD_Result_t *result);

#ifdef __cplusplus
}
#endif
#endif /* INC_TOF_H_ */

The use is very simple:

#include "tof.h"
...
int main(void)
{
  /* USER CODE BEGIN 2 */
  // init TOF device
  int32_t tof_status = TOF_Init();
  if (tof_status != 0)
  {
      printf("Failed to init TOF: %ld\r\n", tof_status);
  }
  else
  {
      TOF_Configure();
  }
  /* USER CODE END 2 */
  ...

  /* USER CODE BEGIN WHILE */
  VL53L4CD_Result_t result;
  while (1)
  {
      /* USER CODE END WHILE */

      /* USER CODE BEGIN 3 */
      TOF_GetDistance(&result);
      HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}

This will initialize the device and configure it.
After that it will get the distance, the tof.c will by default print the results like this:

Targets = 1
 |---> Status = 0, Distance =   110 mm , Ambient = 0.00 kcps/spad, Signal = 112.00 kcps/spad
Targets = 1
 |---> Status = 0, Distance =   112 mm , Ambient = 0.00 kcps/spad, Signal = 113.00 kcps/spad

But can be changed to not print it.

Example using ST TOF VL53L4CD

Daniel Guerrero — Sun, 21 Sep 2025 06:24:02 +0000

The VL53L4CD is a TOF (Time of Flight) sensor capable of measure distances from 1mm to 1200mm.

Unfortunately the datasheet doesn't provide any register information. But they provide an API but no good documentation about api functions.

To setup the project, you need to do:
Enable I2C1

Enable X-CUBE-TOF1 in the Middleware & Software section

Select Board Part Ranging, and select VL53L4CD

Configure to use the I2C1 and XShut pin

This will create a project that will contain one file called custom_tof_conf.h which contains some defines, for example:

#define USE_CUSTOM_RANGING_VL53L4CD (1U)

#define CUSTOM_VL53L4CD_XSHUT_PORT    GPIOA
#define CUSTOM_VL53L4CD_XSHUT_PIN     GPIO_PIN_1

#define CUSTOM_VL53L4CD_I2C_INIT      BSP_I2C1_Init
#define CUSTOM_VL53L4CD_I2C_DEINIT    BSP_I2C1_DeInit
#define CUSTOM_VL53L4CD_I2C_WRITEREG  BSP_I2C1_Send
#define CUSTOM_VL53L4CD_I2C_READREG   BSP_I2C1_Recv

You need to create a file to use the API, I've created two files: tof.c and tof.h
The code is very simple it will:

Init the device (check device is reachable through I2C and get capabilities)
Configure the device (set device settings and set the measure as continuous)
Get the distance

The UM2931 contains more information about how to connect each pin in TOF board and dev board.

The tof.c code:

#include "tof.h"
#include "custom_tof_conf.h"
#include <stdio.h>

VL53L4CD_Object_t   tof_obj;
VL53L4CD_Capabilities_t tof_cap;
VL53L4CD_ProfileConfig_t tof_profile;

static int32_t decimal_part(float_t x)
{
    int32_t int_part = (int32_t) x;
    return (int32_t)((x - int_part) * 100);
}

static void print_result(VL53L4CD_Result_t *result)
{
    uint8_t i;
    uint8_t j;

    for (i = 0; i < result->NumberOfZones; i++)
    {
        if (i > 0) {
            printf("\r\n");
        }
        printf("Targets = %lu", (unsigned long)result->ZoneResult[i].NumberOfTargets);

        for (j = 0; j < result->ZoneResult[i].NumberOfTargets; j++)
        {
            printf("\r\n |---> ");

            printf("Status = %ld, Distance = %5ld mm ",
                (long)result->ZoneResult[i].Status[j],
                (long)result->ZoneResult[i].Distance[j]);

            if (tof_profile.EnableAmbient)
            {
                printf(", Ambient = %ld.%02ld kcps/spad",
                    (long)result->ZoneResult[i].Ambient[j],
                    (long)decimal_part(result->ZoneResult[i].Ambient[j]));
            }

            if (tof_profile.EnableSignal)
            {
                printf(", Signal = %ld.%02ld kcps/spad",
                  (long)result->ZoneResult[i].Signal[j],
                  (long)decimal_part(result->ZoneResult[i].Signal[j]));
            }
        }
    }

    printf("\r\n");
}

int32_t TOF_Init()
{
    int32_t ret;
    VL53L4CD_IO_t              IOCtx;
    uint32_t                   id;

    /* Configure the ranging sensor driver */
    IOCtx.Address     = VL53L4CD_DEVICE_ADDRESS;
    IOCtx.Init        = CUSTOM_VL53L4CD_I2C_INIT;
    IOCtx.DeInit      = CUSTOM_VL53L4CD_I2C_DEINIT;
    IOCtx.WriteReg    = CUSTOM_VL53L4CD_I2C_WRITEREG;
    IOCtx.ReadReg     = CUSTOM_VL53L4CD_I2C_READREG;
    IOCtx.GetTick     = BSP_GetTick;

    if (VL53L4CD_RegisterBusIO(&tof_obj, &IOCtx) != VL53L4CD_OK)
    {
        printf("Cannot register bus\r\n");
        ret = BSP_ERROR_COMPONENT_FAILURE;
    }
    else if ( (ret = VL53L4CD_ReadID(&tof_obj, &id)) != 0)
    {
        printf("Cannot read ID %ld\r\n", ret);
        ret = BSP_ERROR_COMPONENT_FAILURE;
    }
    else
    {
        if (id != VL53L4CD_ID)
        {
            printf("Wrong ID %ld\r\n", id);
            ret = BSP_ERROR_UNKNOWN_COMPONENT;
        }
        else
        {
            printf("Got device id: %ld\r\n", id);

            //init device
            if (VL53L4CD_Init(&tof_obj) != VL53L4CD_OK)
            {
                printf("Cannot init tof\r\n");
                ret = BSP_ERROR_COMPONENT_FAILURE;
            }
            else if (VL53L4CD_GetCapabilities(&tof_obj, &tof_cap) != VL53L4CD_OK)
            {
                printf("Cannot get capabilities\r\n");
                ret = BSP_ERROR_COMPONENT_FAILURE;
            }
            else
            {
                printf("TOF Initialized\r\n");
                ret = BSP_ERROR_NONE;
            }
        }
    }

    return ret;
}

int32_t TOF_Configure()
{
    tof_profile.RangingProfile = VL53L4CD_PROFILE_CONTINUOUS;
    tof_profile.TimingBudget = 30U;
    tof_profile.Frequency = 0; /* Induces intermeasurement period, NOT USED for normal ranging */
    tof_profile.EnableAmbient = 1; /* Enable: 1, Disable: 0 */
    tof_profile.EnableSignal = 1; /* Enable: 1, Disable: 0 */

    /* set the profile if different from default one */
    VL53L4CD_ConfigProfile(&tof_obj, &tof_profile);

    return VL53L4CD_Start(&tof_obj, VL53L4CD_MODE_BLOCKING_CONTINUOUS);
}

int32_t TOF_GetDistance(VL53L4CD_Result_t *result)
{
    int32_t status = VL53L4CD_GetDistance(&tof_obj, result);

    if (status == BSP_ERROR_NONE)
    {
        print_result(result);
    }
    else
    {
        printf("Failed to get measure: %ld\r\n", status);
    }

    return status;
}

tof.h


#ifndef INC_TOF_H_
#define INC_TOF_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "vl53l4cd.h"

int32_t TOF_Init();
int32_t TOF_Configure();
int32_t TOF_GetDistance(VL53L4CD_Result_t *result);

#ifdef __cplusplus
}
#endif
#endif /* INC_TOF_H_ */

The use is very simple:

#include "tof.h"
...
int main(void)
{
  /* USER CODE BEGIN 2 */
  // init TOF device
  int32_t tof_status = TOF_Init();
  if (tof_status != 0)
  {
      printf("Failed to init TOF: %ld\r\n", tof_status);
  }
  else
  {
      TOF_Configure();
  }
  /* USER CODE END 2 */
  ...

  /* USER CODE BEGIN WHILE */
  VL53L4CD_Result_t result;
  while (1)
  {
      /* USER CODE END WHILE */

      /* USER CODE BEGIN 3 */
      TOF_GetDistance(&result);
      HAL_Delay(1000);
  }
  /* USER CODE END 3 */
}

This will initialize the device and configure it.
After that it will get the distance, the tof.c will by default print the results like this:

Targets = 1
 |---> Status = 0, Distance =   110 mm , Ambient = 0.00 kcps/spad, Signal = 112.00 kcps/spad
Targets = 1
 |---> Status = 0, Distance =   112 mm , Ambient = 0.00 kcps/spad, Signal = 113.00 kcps/spad

But can be changed to not print it.

DEV Community: Daniel Guerrero

BIO Baochip/Dabao - FIFO and Events

FIFO

Events

Event Thresholds

BIO Baochip/Dabao - Introduction and GPIO

General Description

BIO Setup

GPIO Handling

Starting with ESP32P4-M3-DEV

CH341 with python

The Three Modes of CH341

Starting with USB Programming

Reverse Engineering

I2C Implementation

GPIO Implementation

Writing GPIO

GPIO Bytes

Enable Mask

Writing with CH34xSet_D5_D0

Reading

SPI Implementation

Chip Select

Zephyr on Arduino UNO Q MCU

Zephyr

Compile example

Upload to device

Flash MCU

Restoring Sketch Bootloader

References

MAX7219 Example (8 digit segment driver)

Register: Scan Limit

Register: Digit

Register: Decode Mode

Register: Loading Data

Commands

Example

Example url

Datasheet

MAX7219 Example (8 digit segment driver)

Register: Scan Limit

Register: Digit

Register: Decode Mode

Register: Loading Data

Commands

Example

Example url

Datasheet

TM1637 Board Arduino Example

Start Signal

End Signal

Sending Data

Arduino Code

Links

HC05 / XBee First Steps

Connect to module

Final Notes

Starting With Luckfox Lyra Zero W

Resize the img file

Resize the SD card

Connect through USB

WiFi setup

WiFi DHCP

WiFi Static IP

Example using ST TOF VL53L4CD

Example using ST TOF VL53L4CD

Writing with `CH34xSet_D5_D0`

Resize the `img` file