Product Features

Three uses of LM protocol

Working form

Robot body communication and debugging

Multi-platform host computer

Application scenarios

Specification summary

From development to delivery

Directory and reading path

This manual is intended for users who need to connect UCAN-Mini to an engineering system. UCAN-Mini runs the LM protocol; the LM protocol can be presented as a SocketCAN interface through the Linux kernel driver, or the USB TLV protocol can be directly accessed through Python scripts.

Basic transmit and receive workflow

Read by task

1. Product positioning

UCAN-Mini is a USB to dual-channel CAN/CAN FD interface device. The device runs the LM protocol and is used for the following engineering needs:

2. Core features

3. Access path selection

4. USB enumeration and endpoints

4.1 LM mode

5. LM TLV protocol overview

5.1 TLV Header

All LM messages begin with an 8-byte TLV Header, followed by a variable-length payload, with a total length of 4-byte alignment.

offset  size  field      description
0x00 2 type message type
0x02 2 size The total length of the entire message, including the header, 4B aligned
0x04 1 channel CAN channel number, 0xFF represents device level/broadcast
0x05 1 flags message level flags
0x06 2 reserved reserved, set to 0
0x08 ... payload variable length payload

The Wire format is little-endian: <HHBBH.

5.2 Common message types

5.3 Key capabilities

6. Linux kernel driver

UCAN-Mini's LM mode provides an out-of-tree Linux SocketCAN driver. The release package directory is:

kernel_driver

Driver file:

6.1 Environment preparation

Debian/Ubuntu example:

sudo apt update
sudo apt install -y build-essential linux-headers-$(uname -r) can-utils

If the system does not have ip or CAN tools, additional installation:

sudo apt install -y iproute2 can-utils

6.2 Manual compilation and installation

cd kernel_driver
make
sudo make install
sudo depmod -a
sudo modprobe ucan_lm

Confirm module loading:

lsmod | grep ucan_lm
modinfo ucan_lm

Check the kernel log after inserting UCAN-Mini:

dmesg | tail -80
ip link

Under normal circumstances, each CAN channel will be registered as a SocketCAN network interface, such as can0, can1.

6.3 DKMS installation

DKMS is suitable for automatically rebuilding modules with kernel upgrades:

sudo mkdir -p /usr/src/ucan-lm-0.1.0
sudo cp -a kernel_driver/. /usr/src/ucan-lm-0.1.0/
sudo dkms add -m ucan-lm -v 0.1.0
sudo dkms build -m ucan-lm -v 0.1.0
sudo dkms install -m ucan-lm -v 0.1.0
sudo modprobe ucan_lm

Check DKMS status:

dkms status ucan-lm

uninstall:

sudo dkms remove -m ucan-lm -v 0.1.0 --all
sudo modprobe -r ucan_lm

6.4 Module parameters

Temporary loading example:

sudo modprobe ucan_lm tx_window=8 rx_hwts=1 time_sync_interval_ms=500

When you need to persist parameters, you can create /etc/modprobe.d/ucan_lm.conf:

options ucan_lm tx_window=8 rx_hwts=1 time_sync_interval_ms=500

Note: When rx_hwts=1, the driver will bind the MGMT interface for time synchronization. At this time, the user-mode Python management tool may not be able to open the MGMT interface at the same time. The Linux kernel driver does not provide firmware update.

6.5 SocketCAN usage

Classic CAN:

sudo ip link set can0 down 2>/dev/null || true
sudo ip link set can0 up type can bitrate 500000
candump can0
cansend can0 123#11223344

CAN FD：

sudo ip link set can0 down 2>/dev/null || true
sudo ip link set can0 up type can bitrate 1000000 dbitrate 5000000 fd on
candump can0
cansend can0 123##100112233445566778899AABBCCDDEEFF

Dual channel:

sudo ip link set can0 up type can bitrate 1000000 dbitrate 5000000 fd on
sudo ip link set can1 up type can bitrate 1000000 dbitrate 5000000 fd on
candump can0 can1

6.6 Timestamp and TX window

tx_window Limits the number of transmit slots for each channel waiting for TX echo at the same time. It is recommended to keep the window smaller for control services and reduce the queuing of old commands; for throughput tests, the window can be increased appropriately.

rx_hwts=1, the driver uses the MGMT command endpoint for device/host time synchronization and converts the device RX timestamp to the Linux skb hardware timestamp path. If only ordinary SocketCAN transceiver is needed on site, rx_hwts=0 can be used to simplify the interface occupation.

7. Python LM protocol script

The Python scripts are provided in this release package directory:

private_proto

7.1 Install dependencies

cd private_proto
python -m pip install pyusb

Linux requires libusb:

sudo apt install -y libusb-1.0-0-dev

Under Windows, you need to install the WinUSB / libusb driver for the LM interface, such as using Zadig. If there are kernel drivers or other tools occupying the device on the same computer, close the occupying process first.

7.2 Basic commands

python ucan_mini_cli.py list
python ucan_mini_cli.py info
python ucan_mini_cli.py status --ch 0
python ucan_mini_cli.py identify

info goes through the EP0 vendor request, which can be used to confirm the device online, channel number, firmware version and capability information.

7.3 Channel configuration

Set Classic CAN arbitration segment timing:

python ucan_mini_cli.py set-bittiming --ch 0 --brp 10 --tseg1 13 --tseg2 2 --sjw 1
python ucan_mini_cli.py start --ch 0

CAN FD + BRS：

python ucan_mini_cli.py set-bittiming --ch 0 --brp 10 --tseg1 13 --tseg2 2 --sjw 1
python ucan_mini_cli.py set-data-bittiming --ch 0 --brp 2 --tseg1 13 --tseg2 2 --sjw 1
python ucan_mini_cli.py start --ch 0 --mode fd fd_brs tx_echo

Terminal resistor:

python ucan_mini_cli.py set-termination --ch 0 --enable 1
python ucan_mini_cli.py set-termination --ch 1 --enable 1

Stop channel:

python ucan_mini_cli.py stop --ch 0

7.4 Send and receive immediately

Send standard frames:

python ucan_mini_cli.py send --ch 0 --id 0x123 --data "01 02 03 04"

Send extended frame:

python ucan_mini_cli.py send --ch 0 --id 0x12345678 --ext 1 --data "AA BB"

Send CAN FD + BRS:

python ucan_mini_cli.py send --ch 0 --id 0x100 --fd 1 --brs 1 --data "01 02 03 04 05 06 07 08 09 0A"

Send in bulk:

python ucan_mini_cli.py send --ch 0 --id 0x200 --data "FF" --count 100 --interval-ms 10

take over:

python ucan_mini_cli.py receive --ch 0
python ucan_mini_cli.py receive --ch 0 --count 10 --rx-timeout-ms 1000

7.5 Filtering, Options and Status

Filter:

python ucan_mini_cli.py set-filter --ch 0 --type range --index 0 --id1 0x100 --id2 0x1FF
python ucan_mini_cli.py set-filter --ch 0 --type exact --index 0 --id1 0x123
python ucan_mini_cli.py set-filter --ch 0 --type mask --index 0 --id1 0x7F0 --id2 0x100
python ucan_mini_cli.py clear-filter --ch 0

Runtime options:

python ucan_mini_cli.py set-option --ch 0 --options tx_echo error_report bus_load
python ucan_mini_cli.py clear-option --ch 0 --options bus_load
python ucan_mini_cli.py set-auto-recover --ch 0 --enable 1
python ucan_mini_cli.py set-iso-mode --ch 0 --iso 1

Status query:

python ucan_mini_cli.py status --ch 0

The returned information focuses on state_name, started, termination, tx_count, rx_count, tx_err_count, rx_err_count, overrun_count and busload.

7.6 Python API

CanClient is suitable for scripts that require device-level management commands:

from ucan_mini_proto import CanClient, MODE_FD, MODE_FD_BRS, MODE_TX_ECHO

cli = CanClient()
info = cli.get_device_info()
print(info)

cli.set_bittiming(channel=0, brp=10, tseg1=13, tseg2=2, sjw=1)
cli.set_data_bittiming(channel=0, brp=2, tseg1=13, tseg2=2, sjw=1)
cli.start(channel=0, mode_flags=MODE_FD | MODE_FD_BRS | MODE_TX_ECHO)
cli.send(channel=0, can_id=0x123, data=b"\x01\x02\x03", is_fd=True, brs=True)

frame = cli.receive(channel=0, timeout_ms=1000)
print(frame)

cli.stop(channel=0)
cli.close()

ChannelClient is suitable for two independent processes to occupy one CAN DATA interface respectively. It only exposes channel-level commands; device-level operations such as device information, device reset, user Flash, device ID and timestamp sync are still completed through CanClient. Python CLI/API does not provide firmware update.

from ucan_mini_proto import ChannelClient, MODE_FD, MODE_FD_BRS

can0 = ChannelClient(0)
can0.set_bittiming(brp=10, tseg1=13, tseg2=2, sjw=1)
can0.start(mode_flags=MODE_FD | MODE_FD_BRS)
can0.send(can_id=0x123, data=b"\x01\x02")
can0.close()

8. UCAN-Analyzer multi-platform host computer

UCAN-Analyzer is the companion desktop analysis tool for UCAN-Mini, covering CAN/CAN FD device configuration, transmit/receive testing, frame monitoring, filtering, data tracking, curve analysis and firmware updates. It is suitable for interactive debugging, on-site diagnosis and bus visual analysis.

8.1 Supported platforms and release forms

Select the release package that matches the host system. After launching the application and connecting UCAN-Mini, users can configure channels, run transmit/receive tests, analyze the bus and maintain firmware.

8.2 Function module

8.3 Typical debugging process

1. Start UCAN-Analyzer
2. Connect to UCAN-Mini
3. Select CAN0/CAN1, set arbitration bit rate, data bit rate, CAN FD, BRS and terminal resistor
4. Start channel
5. Observe real-time frames in the receive/tracking window
6. Construct single frame, batch frame or periodic sending entries in the sending window
7. Use filtering, triggering, DBC, signal curves or data analysis to locate problems
8. Use UCAN-Analyzer firmware update when maintenance is required

8.4 Suggestions for debugging the robot body

UCAN-Analyzer is suitable for interactive debugging of the CAN/CAN FD network inside the robot body:

9. Schedule delivery

Reservation sending is used to reduce the impact of host scheduling jitter on sending time. The host first synchronizes the device time, and then delivers the frame to be sent and the target time to the device; the device triggers transmission according to the local PTPC time.

9.1 Capabilities and Limitations

9.2 CLI single appointment

The CLI automatically executes timestamp-sync when --start-time-us is not provided, using the current device time plus --delay-us.

python ucan_mini_cli.py set-schedule \
  --ch 0 \
  --slot 0 \
  --enable 1 \
  --delay-us 10000 \
  --can-id 0x100 \
  --data "01 02 03"

This means that the ID 0x100 is sent once after approximately 10 ms.

9.3 CLI CAN FD + BRS scheduled transmit

python ucan_mini_cli.py set-schedule \
  --ch 0 \
  --slot 1 \
  --enable 1 \
  --delay-us 20000 \
  --can-id 0x123 \
  --fd 1 \
  --brs 1 \
  --data "00 01 02 03 04 05 06 07 08 09 0A 0B"

Clear reservation:

python ucan_mini_cli.py clear-schedule --ch 0

9.4 API Schedule Send

import time
from ucan_mini_proto import CanClient, TX_FLAG_FD, TX_FLAG_BRS, len_to_dlc

cli = CanClient()
dev_us, _ = cli.timestamp_sync(int(time.time() * 1_000_000))
data = bytes.fromhex("01 02 03 04")

cli.set_schedule(
    channel=0,
    slot_index=0,
    enable=True,
    start_time_us=dev_us + 10_000,
    can_id=0x100,
    dlc=len_to_dlc(len(data)),
    tx_flags=0,
    data=data,
)

9.5 Troubleshooting suggestions

10. Channel configuration suggestions

10.1 Classic CAN

10.2 CAN FD

11. Button, LED and Firmware Update

11.1 Key function

11.2 LED indication

11.3 Firmware Update

Firmware update is available only in the closed-source UCAN-Analyzer desktop application. The Linux kernel driver and Python CLI/API do not provide firmware update.

12. Debugging and Diagnostics

12.1 USB or driver abnormality

12.2 CAN cannot communicate

Priority checks:

• CANH/CANL/GND and shield connections.
• Are there 120R at both ends of the bus.
• Whether the arbitration segment rate, data segment rate, BRS and CAN FD enablement at both ends are consistent.
• Whether the channel is started, in Warning, Error Passive or Bus-Off.
• Whether CAN0/CAN1, endpoint or SocketCAN interface are used reversely.

12.3 Scheduled transmit exceptions

Priority checks:

• Whether the device capability includes SCHEDULE_TX.
• Whether the channel has been started.
• start_time_us Is it based on device time, not host system time.
• Whether the delivery time is too late, reserve at least 200 us. It is recommended to reserve several ms for engineering testing.
• Whether removed periodic scheduling parameters were used by mistake.

13. Technical specifications

14. Revision History

Copyright (c) 2026 LanMotion.

UCAN-Analyzer User Manual

1. Overview

UCAN-Analyzer is a multi-platform graphical host application for UCAN-Mini. It is used for CAN / CAN FD device configuration, frame transmit and receive, bus monitoring, filtering, data analysis, DBC signal viewing, replay, trigger testing, and maintenance updates.

The software is designed for R&D debugging, field diagnosis, production test verification, and data acquisition. A typical workflow is to connect UCAN-Mini, configure the CAN channel, start the channel, observe live frames, and then send test frames, load DBC files, export logs, or run trigger rules as needed.

Typical debugging workflow:

1. Connect UCAN-Mini and confirm that USB is online.
2. Configure CAN / CAN FD channel parameters and start the channel.
3. Observe field traffic in the receive, trace, and bus-load windows.
4. Use transmit, filter, trigger, replay, and Lua console tools for validation.
5. Save the project or export CSV / ASC / BLF data to keep reproducible records.

2. Installation And Launch

2.1 Windows

Download the Windows x86_64 installer, run UCAN-Analyzer-*-windows-x86_64.exe, and follow the installer steps. After installation, start UCAN-Analyzer.exe from the Start menu or the installation directory.

If the system reports driver or USB permission issues, confirm that UCAN-Mini is connected correctly and avoid opening the same channel from multiple host application instances.

2.2 Linux

Download the Linux x86_64 AppImage:

chmod +x UCAN-Analyzer-*-linux-x86_64.AppImage
./UCAN-Analyzer-*-linux-x86_64.AppImage

If a normal user cannot access the USB device, configure udev rules according to the target system policy, or run the application with a user account that has USB access permission.

2.3 macOS

Download the .dmg or .pkg package. If macOS blocks the first launch of an unsigned application, allow it from the Security settings page.

3. Main Interface

The UCAN-Analyzer main interface includes a menu bar, toolbar, device and channel area, frame views, and analysis tool windows. Common entries are:

3.1 Toolbar Icon Buttons

4. Connecting UCAN-Mini

1. Connect UCAN-Mini through USB.
2. Start UCAN-Analyzer.
3. Refresh the device list in the device area.
4. Select the device and channel, then click connect.
5. After connection succeeds, the status bar shows the online state, and the configuration, receive, transmit, and analysis windows use the current device data.

If connection fails, first check the USB cable, device power, system permission, driver occupation, and whether another program is already using UCAN-Mini.

5. CAN / CAN FD Channel Configuration

Channel configuration sets the CAN controller parameters of UCAN-Mini. Common items include:

Start verification from common project bitrates such as 500 kbit/s, 1 Mbit/s, 2 Mbit/s, or 5 Mbit/s. Adjust sample points and advanced bit timing only when exact field network matching is required.

6. Receive, Trace, And Filtering

The receive and trace windows show live CAN / CAN FD frames. The table usually includes timestamp, direction, channel, CAN ID, DLC, data bytes, and decoded information.

The trace window supports expression filtering. Common fields are:

Examples:

id==0x100 && ch==0
id==0x18FF50E5 && dlc>7
dev==0 && ch==1

Expression filtering is useful for quickly locating target frames. Device-side filtering is useful for reducing host-side data pressure on high-load networks.

7. Frame Transmit And Cyclic Transmit

The transmit window is used to create, edit, and run transmit entries. Each entry usually contains channel, CAN ID, frame format, DLC, data bytes, enable state, and cycle parameters.

Common operations:

1. Add a transmit entry.
2. Set channel, CAN ID, and data content.
3. Click send now to verify a single frame.
4. Enable cyclic transmit and set the period to continuously stimulate the device under test.
5. Save transmit presets for reuse in later debugging sessions.

Before cyclic transmit, confirm the bus load and target device state to avoid affecting the field network with an excessive transmit rate.

8. DBC, Signals, And Curves

UCAN-Analyzer supports loading DBC files and decoding frame signals. After loading a DBC file, use these windows:

Without a DBC file, you can still create data entries manually in the Data Analysis window to temporarily observe sensor values, counters, status bits, or control values.

After frames enter the receive channel and frame store, the same data can feed the trace table, DBC signal decoding, curve display, protocol helper, and export flow. To reproduce a test, import frame data or use replay to inspect the same records again.

9. Bus Load, Errors, And Diagnosis

The bus load window shows current, average, and peak load. It is useful for observing transmit rate, network congestion, and the impact of test scripts.

The error window shows channel error counters, state changes, and warning messages. When an abnormal state appears, check in this order:

1. Confirm that bitrate and sample point match the field network.
2. Confirm that termination and cable wiring are correct.
3. Confirm that CAN_H and CAN_L are not reversed.
4. Reduce transmit rate or pause cyclic transmit.
5. Stop and restart the channel.

10. Replay, Import, And Export

The software can export captured frames to common formats and import historical frames for offline viewing or replay.

Before replaying to a real bus, confirm that the target network allows test frame injection and avoid sending control frames accidentally in production environments.

11. Trigger Rules And Automation

The trigger window can create rules based on channel, CAN ID, DLC, or data fields. When a rule matches, it can record, notify, stop capture, or send preset frames.

The Lua console is used for more flexible automated debugging and test assistance. Validate rules on offline data or a low-risk network before applying them to field devices.

12. Updates And Maintenance

The update entry in the Help menu is used to check software release packages. Release assets are provided through the official website or the project release page. Before installation, confirm the version, target system, and package type.

If the installer includes UCAN-Mini firmware resources, use the matching maintenance workflow for firmware update. Before update, confirm:

• The device connection is stable.
• Do not disconnect USB during update.
• Use a firmware package that matches the device model.
• Reconnect the device after update and verify channel state.

For maintenance, follow this order: check the software version, confirm device connection, run the update, reconnect the device, and verify channel state. Before field-device updates, keep the current project file and necessary frame records.

13. FAQ

13.1 Device list is empty

Check USB connection, device power, system permission, and driver binding. On Linux, focus on udev permission. On Windows, check whether the device is occupied by other software.

13.2 No frames are received after starting the channel

Confirm that the field bus has traffic, bitrate and sample point match, termination is correct, and the active filter condition is not too narrow.

13.3 Many error frames or rapidly increasing error counters appear

First check bitrate, cable, termination, grounding, and CAN_H / CAN_L polarity. Use listen-only mode to observe the network when needed.

13.4 DBC signals have no decoded values

Confirm CAN ID type, extended frame flag, byte order, scaling factor, and whether the signal definition matches the actual frame.

13.5 The software update entry cannot retrieve a new version

Check network connectivity, current system time, and proxy settings. You can also manually download the package for the target system from the official website or project release page.

14. Revision History