Forem: Daniel Guerrero

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.

Example Code for CH9143

Daniel Guerrero — Thu, 21 Aug 2025 06:40:57 +0000

The CH9143 is an UART to BLE transceiver.
When connected will be a Peripheral/Slave BLE device advertising as CH9143BLE2U name. When a Central/Master is connected it will have two characteristic (channels) one for reading (Notifications) and other for writing.
When you write from Central you can read from Serial and when you write to Serial you will get a notification in the Central.

The board is from WeAct: https://github.com/WeActStudio/WeActStudio.CH9143_BLE2USB2UART

The chip contains two modes that can be set through Low/High levels:

Master and Slave modes (BLE_MODE pin in IC). The master setting only works to pair with other CH9143 / CH9140 / CH9141 creating a point to point serial communication. If don't find any other device to pair in the first seconds after powered, it will just go into Slave mode.
AT Mode (AT pin in IC) this allows to set the chip in AT mode so from UART can be send AT commands to set some settings like device MAC, paired device MAC, TX Power or UART settings. If the AT mode is disabled then is in "transparent mode" which is sending and receiving data through serial console. Is important to note that when AT mode is enabled, you won't receive or send data to BLE Central device.

The following image shows the switch in the board and what enables each position.

To test you will need to connect the CH9143 board either through USB or through a USB to TTL converter. As a note, use either USB or RX/TX pins, if you use both you will get garbled data in the RX/TX

You need also a BLE device available, to check if you have it, you can try with hcitool dev:

$ hcitool dev
Devices:
    hci0    XX:XX:XX:XX:XX:XX

The code can be found here: https://github.com/danguer/embedded-boards101/tree/main/weact-ch9143 and there are two parts: UART and BLE

UART

requirements.txt

pyserial==3.5

uart.py

import serial
import threading
import argparse
import time

keep_reading = True
send_idx = 0

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")
            print("Serial Input: ", line)

def send_at_command(ser: serial.Serial, command: str) -> str:
    # send command
    ser.write(f"{command}\r\n".encode("ascii"))
    # read command back
    return ser.readline().decode("ascii").strip()

parser = argparse.ArgumentParser(prog="CH9143 Uart Example")
parser.add_argument(
    "--use-at-commands", 
    help="Use AT Commands", 
    action=argparse.BooleanOptionalAction,
)
parser.add_argument(
    "serial_port", 
    help="Serial port like /dev/ttyACM0",
)
args = parser.parse_args()

params = {
    "port": args.serial_port,
    "baudrate": 115200,
    "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:
    if args.use_at_commands:
        print("Sending AT... (checking if AT is enabled)")
        print("Response: ", send_at_command(ser, "AT..."))
        print("Sending AT+MAC? (checking current MAC)")
        mac = send_at_command(ser, "AT+MAC?")
        if mac:
            mac = mac.split(":")
            mac.reverse()
            mac = ":".join(mac)

        print("Response: ", mac)
        print("Sending AT+CCADD? (checking connected MAC)")
        print("Response: ", send_at_command(ser, "AT+CCADD?"))


    print("Creating background receiving thread")
    thread_read = threading.Thread(target=read_serial, args=(ser,))
    thread_read.start()

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

To run:

python3 uart/uart.py /dev/ttyACM0

And the output will look like this:

Opening port:  /dev/ttyACM0
Creating background receiving thread
Sending ping 0
Sending ping 1
Sending ping 2
Sending ping 3
Sending ping 4
Serial Input:  HOST PING 0
Sending ping 5
Serial Input:  HOST PING 1
Sending ping 6
Serial Input:  HOST PING 2
Sending ping 7
Sending ping 8

The HOST PING messages are when the BLE central is connected

BLE

For the BLE Central side will be under ble folder:
requirements.txt

bleak==0.22.3

ble-central.py

import asyncio
import argparse
import time
import sys
from bleak import *

async def discover_mac():
    scanner = BleakScanner()
    device = await scanner.find_device_by_name("CH9143BLE2U")
    if not device:
        print("Failed to find CH9143BLE2U device")
        sys.exit(1)

    print("Found device:", device)
    return device.address

def notify_callback(sender: BleakGATTCharacteristic, data: bytearray):
    print("Got from device:", data.decode("utf-8"))

async def connect_to_mac(device_mac: str):
    print("Connecting to mac", device_mac)
    client = BleakClient(device_mac)
    await client.connect()
    print("Listing services")
    uuid_write = None
    uuid_read = None
    for service in client.services:
        print("[Service] {0}: {1}".format(service.uuid, service.description))
        if service.uuid[0:4] == "0000" and service.uuid[4:8] == "fff0":
            print("Found transparent service") 
            for char in service.characteristics:
                # print("Char", char, char.properties) # debug printing
                if char.uuid[4:8] == "fff1":
                    uuid_read = char.uuid
                elif char.uuid[4:8] == "fff2":
                    uuid_write = char.uuid

    if uuid_read and uuid_write:
        print(
            "Found needed characteristics, read:", 
            uuid_read, 
            ", write:",
            uuid_write,
        )
        send_idx = 0
        await client.start_notify(uuid_read, notify_callback)
        try:
            while True:
                print(f"Sending ping {send_idx}")
                await client.write_gatt_char(
                    uuid_write,
                    f"HOST PING {send_idx}".encode("ascii"),
                )
                send_idx += 1
                time.sleep(1)
        except KeyboardInterrupt:
            pass
        finally:
            print("Finishing app")

async def main():
    parser = argparse.ArgumentParser(prog="BLE CH9143 Host")
    parser.add_argument(
        "--device-mac",
        default=None,
        type=str,
        help="Device MAC to connect",
    )

    args = parser.parse_args()
    if not args.device_mac:
        device_mac = await discover_mac()
    else:
        device_mac = args.device_mac

    await connect_to_mac(device_mac)

asyncio.run(main())

You can run like this:

python3 ble/ble-central.py

This will discover a device with CH9143BLE2U, if you have multiple devices then you need to supply the mac as will connect to the first device it finds
The output looks like:

Found device: XX:XX:XX:XX:XX:XX: CH9143BLE2U
Connecting to mac XX:XX:XX:XX:XX:XX
Listing services
[Service] 0000fff0-0000-1000-8000-00805f9b34fb: Vendor specific
Found transparent service
[Service] 00001801-0000-1000-8000-00805f9b34fb: Generic Attribute Profile
Found needed characteristics, read: 0000fff1-0000-1000-8000-00805f9b34fb , write: 0000fff2-0000-1000-8000-00805f9b34fb
Sending ping 0
Sending ping 1
Got from device: UART PING 5
Sending ping 2
Got from device: UART PING 6
Got from device: UART PING 7

The UART PING are messages received from the UART serial data

This chip is a tool to easily create a BLE device and pass data to a MCU through UART; but lacking things like ability to set device name it will limit the number of applications. Also switching to AT mode can receive wrong data from previous packets received so data needs to be cleaned. In the case of the board, this setting is through a physical switch which make it impossible for real apps to use it as AT modes are things that needs to be switched through a MCU

Compiling Docker in RISC-V

Daniel Guerrero — Sat, 09 Aug 2025 18:45:41 +0000

Docker CE is not supported in Ubuntu 24 for RISC-V, probably it will be soon for this support as is really easy to compile and use it.
Here are the instructions for make it work.

I've tested the following in OrangePi RV2 and qemu-riscv.

Note that I'm using static releases but shared should also work.
Also the configuration files through heredoc are directly from docker-ce packages so should work the same as official packages

dependencies

You need a compiler and make:

sudo apt update && \
sudo apt install -y build-essential make

go

You need go to compile docker, but the version in Ubuntu 24 is old to compile latest version, so can be setup directly from compiled binaries:

cd /tmp && \
wget https://go.dev/dl/go1.24.4.linux-riscv64.tar.gz && \
sudo tar -C /usr/local -xzf go1.24.4.linux-riscv64.tar.gz && \
rm -f go1.24.4.linux-riscv64.tar.gz

# set the path in bash or copy into /etc/profile or .bashrc
export PATH=$PATH:/usr/local/go/bin

runc

this is already compiled so just copy to your system

cd /tmp && /
wget -O runc https://github.com/opencontainers/runc/releases/download/v1.3.0/runc.riscv64 && \
chmod +x runc && \
sudo mv runc /usr/bin/

containerd

cd /tmp && \
wget -O containerd-2.1.3.tar.gz https://github.com/containerd/containerd/archive/refs/tags/v2.1.3.tar.gz && \
tar zxf containerd-2.1.3.tar.gz && \
cd containerd-2.1.3 && \
make VERSION=2 REVISION=1.3 static-release && \
sudo cp ./bin/containerd /usr/local/bin && \
sudo cp ./bin/containerd-shim-runc-v2 /usr/local/bin && \
sudo cp ./bin/ctr /usr/local/bin && \
sudo cp ./containerd.service /lib/systemd/system/ && \
{ cat <<-EOF > /tmp/config.toml
#   Copyright 2018-2022 Docker Inc.

#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at

#       http://www.apache.org/licenses/LICENSE-2.0

#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.

disabled_plugins = ["cri"]

#root = "/var/lib/containerd"
#state = "/run/containerd"
#subreaper = true
#oom_score = 0

#[grpc]
#  address = "/run/containerd/containerd.sock"
#  uid = 0
#  gid = 0

#[debug]
#  address = "/run/containerd/debug.sock"
#  uid = 0
#  gid = 0
#  level = "info"
EOF
} && sudo mkdir -p /etc/containerd/ && \
sudo mv /tmp/config.toml /etc/containerd/ && \
sudo systemctl --system daemon-reload && \
sudo systemctl enable containerd && \
sudo systemctl start containerd && \
cd /tmp && \
rm -rf containerd-2.1.3 containerd-2.1.3.tar.gz

docker daemon (moby)

cd /tmp && \
wget -O moby-28.3.1.tar.gz https://github.com/moby/moby/archive/refs/tags/v28.3.1.tar.gz && \
tar -zxf moby-28.3.1.tar.gz && \
cd moby-28.3.1 && \
DOCKER_GITCOMMIT=5beb93de84f02bf7e167cbb87ce81355ddd8f560 ./hack/make.sh binary && \
sudo cp bundles/binary-daemon/* /usr/bin/ && \
sudo cp ./contrib/dockerd-rootless.sh /usr/bin/ && \
sudo cp ./contrib/dockerd-rootless-setuptool.sh /usr/bin/ && \
sudo mkdir -p /etc/docker && \
{ cat <<-EOF > /tmp/docker
# Docker SysVinit configuration file

#
# THIS FILE DOES NOT APPLY TO SYSTEMD
#
#   Please see the documentation for "systemd drop-ins":
#   https://docs.docker.com/engine/admin/systemd/
#

# Customize location of Docker binary (especially for development testing).
#DOCKERD="/usr/local/bin/dockerd"

# Use DOCKER_OPTS to modify the daemon startup options.
#DOCKER_OPTS="--dns 8.8.8.8 --dns 8.8.4.4"

# If you need Docker to use an HTTP proxy, it can also be specified here.
#export http_proxy="http://127.0.0.1:3128/"

# This is also a handy place to tweak where Docker's temporary files go.
#export DOCKER_TMPDIR="/mnt/bigdrive/docker-tmp"
EOF
} && \
sudo mv /tmp/docker /etc/default/ && \
{ cat <<-EOF > /tmp/docker.socket
[Unit]
Description=Docker Socket for the API

[Socket]
# If /var/run is not implemented as a symlink to /run, you may need to
# specify ListenStream=/var/run/docker.sock instead.
ListenStream=/run/docker.sock
SocketMode=0660
SocketUser=root
SocketGroup=docker

[Install]
WantedBy=sockets.target
EOF
} && sudo mv /tmp/docker.socket /usr/lib/systemd/system/ && \
{ cat <<-EOF > /tmp/docker.service
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
After=network-online.target nss-lookup.target docker.socket firewalld.service containerd.service time-set.target
Wants=network-online.target containerd.service
Requires=docker.socket
StartLimitBurst=3
StartLimitIntervalSec=60

[Service]
Type=notify
# the default is not to use systemd for cgroups because the delegate issues still
# exists and systemd currently does not support the cgroup feature set required
# for containers run by docker
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutStartSec=0
RestartSec=2
Restart=always

# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNPROC=infinity
LimitCORE=infinity

# Comment TasksMax if your systemd version does not support it.
# Only systemd 226 and above support this option.
TasksMax=infinity

# set delegate yes so that systemd does not reset the cgroups of docker containers
Delegate=yes

# kill only the docker process, not all processes in the cgroup
KillMode=process
OOMScoreAdjust=-500

[Install]
WantedBy=multi-user.target
EOF
} && \
sudo mv /tmp/docker.service /usr/lib/systemd/system/ && \
sudo systemctl --system daemon-reload && \
sudo systemctl enable docker.socket docker.service && \
sudo systemctl start docker.socket docker.service && \
cd /tmp && \
rm -rf moby-28.3.1.tar.gz moby-28.3.1

docker-cli

With previous steps you will have docker daemon running in your system, but the easy way to interact is with docker-cli (or docker command)

cd /tmp && \
wget -O cli-28.3.1.tar.gz https://github.com/docker/cli/archive/refs/tags/v28.3.1.tar.gz && \
tar -zxf cli-28.3.1.tar.gz && \
cd cli-28.3.1 && \
mkdir -p .gopath/src/github.com/docker && \
export GOPATH=/tmp/cli-28.3.1/.gopath && \
ln -s `pwd` .gopath/src/github.com/docker/cli && \
DISABLE_WARN_OUTSIDE_CONTAINER=1 make binary && \
sudo cp build/docker-linux-riscv64 /usr/bin && \
sudo cp build/docker /usr/bin && \
cd /tmp && \
rm -rf cli-28.3.1.tar.gz cli-28.3.1

docker-cli extensions

buildkit and docker compose are fundamental for any setup, so must be setup, good thing is that are already compiled for riscv, so just need to be copied into proper dir.
Note that documentation suggest a lot of possible local/global paths, /usr/libexec/docker/cli-plugins worked for me, but feel free to setup other dirs if you need.

sudo mkdir -p /usr/libexec/docker/cli-plugins
# docker compose
cd /tmp && \
wget -O docker-compose https://github.com/docker/compose/releases/download/v2.38.2/docker-compose-linux-riscv64 && \
chmod +x docker-compose && \
sudo mv docker-compose /usr/libexec/docker/cli-plugins && \
wget -O docker-buildx https://github.com/docker/buildx/releases/download/v0.26.1/buildx-v0.26.1.linux-riscv64 && \
chmod +x docker-buildx && \
sudo mv docker-buildx /usr/libexec/docker/cli-plugins

Nvidia NeMo Speech Recognition Starting Guide

Daniel Guerrero — Fri, 08 Aug 2025 06:57:17 +0000

After reading an article that nvidia had several models in top of HF ASR Leaderboard I wanted to test in my local computer.
Even the code seems pretty simple from HF it turns didn't work for nvidia/canary-qwen-2.5b so I started to dig a bit more and test several features.

Base Setup

To test you will need a base setup, I'm using docker so the options are:

Using Nvidia PyTorch container
Using python with cuda enabled libraries

Nvidia PyTorch container

This is the simplest, but of course could contain a lot of libraries not needed, the size of the container is 12.78GB

docker run \
  --gpus all \
  -it \
  --rm \
  --shm-size=16g \
  --ulimit memlock=-1 \
  --ulimit stack=67108864 \
  nvcr.io/nvidia/pytorch:25.06-py3

Python image with cuda libraries

docker run \
  --gpus all \
  -it \
  --rm \
  python:3.12-bookworm \
  /bin/bash

Setup cuda libraries:

apt update && \
  apt install -y wget && \
  wget https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64/cuda-keyring_1.1-1_all.deb && \
  dpkg -i cuda-keyring_1.1-1_all.deb && \
  apt-get update && \
  apt-get -y install --no-install-recommends cuda-toolkit-12-9

Note: the image is around 11.5Gb so probably is not really much different from Nvidia container image.

Setup NeMo libraries

This is pretty simple:

pip install nemo-toolkit[asr]

Setup ffmpeg

For the examples should not be needed but libraries will report missing and is good to have for creating proper input files

cd /tmp
wget https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz
tar xvf ffmpeg-master-latest-linux64-gpl.tar.xz 
cp ffmpeg-master-latest-linux64-gpl/bin/* /usr/bin/
rm -rf ffmpeg-master-latest-linux64-gpl ffmpeg-master-latest-linux64-gpl.tar.xz

Get audio samples

You need audio samples that are:

1 single channel
16Khz Sample Rate
less than 20 seconds

An example used on several examples is this:
https://dldata-public.s3.us-east-2.amazonaws.com/2086-149220-0033.wav

so you can download:

wget https://dldata-public.s3.us-east-2.amazonaws.com/2086-149220-0033.wav

This sample have the previous requirements, so is not needed to process; but if you want to have a proper sample from any file you can do with ffmpeg:

ffmpeg -i INPUT_FILE -ac 1 -ar 16000 example.wav

A more complex can be to extract just a part of the audio, the following will get 10 seconds, starting at second 29 so will extract audio from 29s - 39s:

ffmpeg -i INPUT_FILE -s 29 -t 10 -ac 1 -ar 16000 example.wav

Code example

The following file (asr_example.py) will help you to test the different models:

import nemo.collections.asr as nemo_asr
import argparse

parser = argparse.ArgumentParser(prog="ASR NeMo Example")
parser.add_argument(
    "--enable-timestamps", 
    help="Enable timestamps", 
    action=argparse.BooleanOptionalAction,
)

parser.add_argument(
    "model_name", 
     help="Name of the model like 'nvidia/canary-1b-flash'",
)

parser.add_argument(
    "input_file", 
    help="Path of the wav file, must be 16000Hz and 1 channel",
)
args = parser.parse_args()

asr_model = nemo_asr.models.ASRModel.from_pretrained(args.model_name)

transcriptions = asr_model.transcribe(
    args.input_file, 
    timestamps=args.enable_timestamps,
)
for idx, transcript in enumerate(transcriptions):
    print(f"[{idx}] {transcript.text}")
    if args.enable_timestamps:
        for stamp in transcript.timestamp["word"]:
            word = stamp['word']
            output_line = f"{stamp['start']:0>5.2f}"
            output_line += f"-{stamp['end']:0>5.2f}"
            output_line += f": {word}"

            print(output_line)

Here is a list of models: https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/asr/models.html
Note that list is not fully updated as the most recent is nvidia/canary-qwen-2.5b but this won't work with current code.

Testing the code

You need to provide the model name and the input file, so you can call like this:

python3 asr_example.py \
  nvidia/canary-1b-flash \
  2086-149220-0033.wav

This will output:

[0] Well, I don't wish to see it any more, observed Phoebe, turning away her eyes. It is certainly very like the old portrait.

You can enable the timestamps per word (not all the models support timestamps, but it will trigger an error if doesn't support it)

python3 asr_example.py \
  --enable-timestamps \
  nvidia/canary-1b-flash \
  2086-149220-0033.wav

This will output:

[0] Well I don't wish to see it any more observed Phoebe turning away her eyes it is certainly very like the old portrait
00.32-00.40: Well
00.56-00.72: I
00.72-01.04: don't
01.04-01.28: wish
01.28-01.36: to
01.44-01.52: see
01.60-01.68: it
01.76-01.84: any
01.92-02.00: more
02.24-02.64: observed
02.64-03.12: Phoebe
03.36-03.68: turning
03.76-03.84: away
04.08-04.16: her
04.24-04.48: eyes
04.96-05.04: it
05.12-05.20: is
05.36-05.76: certainly
05.84-05.92: very
06.08-06.16: like
06.24-06.32: the
06.40-06.48: old
06.64-07.12: portrait

Multilanguage

One of the cool features of the Canary family is the support of multiple input languages (English, German, French, Spanish) and can even translate the output.
I will use one file from this dataset: https://www.kaggle.com/datasets/carlfm01/120h-spanish-speech

In the case of the language instead of passing the wav file, it needs to be created an input manifest json.
The format is like this:

{
    "audio_filepath": "FILE.wav",
    "duration": 10, 
    "source_lang": "es",
    "target_lang": "en"
}

But the trick is the input file is actually a text file where each line is a json entry, so the input-spanish.json must be:

{"audio_filepath": "0000df16-47ea-428f-8367-df2ce365d5c4.wav","duration": 9, "source_lang": "es","target_lang": "es"}

And to run with:

python3 asr_example.py \
  --enable-timestamps \
  nvidia/canary-1b-flash \
  input-spanish.json

The output will be:

[0] con efeto, su lenguaje y singulares maneras me divertían extraordinariamente, porque nuestro hombre era un verdadero andaluz,
00.00-00.08: con
00.48-01.04: efeto,
01.12-01.20: su
01.36-01.84: lenguaje
01.92-02.00: y
02.08-02.64: singulares
02.72-03.04: maneras
03.20-03.28: me
03.36-03.92: divertían
04.08-05.92: extraordinariamente,
05.92-06.00: porque
06.40-06.48: nuestro
06.88-06.96: hombre
07.28-07.36: era
07.52-07.60: un
07.68-08.16: verdadero
08.24-08.96: andaluz,

And if you want to translate into english, the input-spanish.json must be:

{"audio_filepath": "0000df16-47ea-428f-8367-df2ce365d5c4.wav","duration": 9, "source_lang": "es","target_lang": "en"}

In this case the output of the same command will be:

[0] with effect his language and singular manners amused me extraordinarily because our man was a true Andalusian
00.00-00.08: with
00.48-00.56: effect
01.12-01.20: his
01.36-01.76: language
01.84-01.92: and
02.00-02.56: singular
02.64-03.04: manners
03.20-03.84: amused
04.08-04.16: me
04.24-05.28: extraordinarily
05.92-06.00: because
06.40-06.48: our
06.80-06.88: man
07.20-07.28: was
07.44-07.52: a
07.60-07.68: true
08.16-08.80: Andalusian

Forem: Daniel Guerrero

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

Example Code for CH9143

UART

BLE

Compiling Docker in RISC-V

dependencies

go

runc

containerd

docker daemon (moby)

docker-cli

docker-cli extensions

Nvidia NeMo Speech Recognition Starting Guide

Base Setup

Nvidia PyTorch container

Python image with cuda libraries

Setup NeMo libraries

Setup ffmpeg

Get audio samples

Code example

Testing the code

Multilanguage

Writing with `CH34xSet_D5_D0`

Resize the `img` file