DEV Community: DEBIX Industrial Computers

Use Barometric Pressure Sensor module on DEBIX

DEBIX Industrial Computers — Fri, 17 Oct 2025 05:35:22 +0000

Example Device: DEBIX Model A + I/O Board
Overview
The BMP180 is a high-precision barometric pressure sensor with low power consumption and low noise. It comes with an internal temperature sensor to compensate for barometric pressure measurements and uses I2C communication.

Hardware installation

Barometric Pressure Sensor module's VCC terminal is connected to J2 Pin2 of DEBIX Model A I/O board
Barometric Pressure Sensor module's SDA terminal is connected to J2 Pin3 of DEBIX Model A I/O board
Barometric Pressure Sensor module's SCL terminal is connected to J2 Pin5 of DEBIX Model A I/O board
Barometric Pressure Sensor module's GND terminal is connected to J2 Pin39 of DEBIX Model A I/O board
Barometric Pressure Sensor module's 3.3V terminal is connected to J2 Pin1 of DEBIX Model A I/O board

Modify the device tree imx8mp-evk.dts
1.Add a BMP180 node under i2c4 node:

&i2c4 {
    status = "okay";
    BMP180: BMP180@77 {
        compatible = "BMP180";
        reg = <0x77>;
    };

2.Compile and replace the device tree file
Compile the device tree in the source directory: make ARCH=arm64 CROSS_COMPILE=aarch64-none-linux-gnu- dtbs
Copy the compiled new device tree file arch/arm64/boot/dts/freescale/imx8mp-evk.dtb to the /boot directory of DEBIX and restart DEBIX.
3.Check whether dts contains the modified device tree node.
Run the command ls /sys/bus/i2c/devices/

Write and Load Drivers
The driver code is as follows:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/delay.h>
static struct i2c_client* fxs_i2c_client;
typedef struct {
    s16 AC1;
    s16 AC2;
    s16 AC3;
    u16 AC4;
    u16 AC5;
    u16 AC6;
    s16 B1;
    s16 B2;
    s16 MB;
    s16 MC;
    s16 MD;
}BMP180_CalcParam_t;
typedef struct {
    s32 T;
    s32 P;
}BMP180_Result;
BMP180_CalcParam_t BMP180_CalcParams;
static s32 i2c_write_reg(u8 reg_addr, u8 *data, u8 len)
{  
    u8 buff[256];
    struct i2c_msg msgs[] = {
        [0] = {
            .addr = fxs_i2c_client->addr,
            .flags = 0,
            .len = len + 1,
            .buf = buff,
        },
    };
    buff[0] = reg_addr;
    memcpy(&buff[1], data, len);
    return i2c_transfer(fxs_i2c_client->adapter, msgs, 1);
}
static s32 i2c_read_reg(u8 reg,void* data, int len){
    int ret;
    struct i2c_msg msgs[] = {
        [0]={
            .addr   = fxs_i2c_client->addr,
            .flags  = 0,
            .buf    = &reg,
            .len    = sizeof(reg),
        },
        [1]={
            .addr   = fxs_i2c_client->addr,
            .flags  = I2C_M_RD,
            .buf    = data,
            .len    = len,
        },
    };
    ret = i2c_transfer(fxs_i2c_client->adapter,msgs,2);
    if(ret == 2) {
        return ret;
    }else{
        printk("read:i2c_transfer err..\n");
        return -1;
    }
}
static s16 BMP180_Reads16Reg(u8 regh,u8 regl){
    u8 datah,datal;
    s16 val;
    i2c_read_reg(regh,&datah,1);
    i2c_read_reg(regl,&datal,1);
    val = (datah & 0x00ff) << 8;
    val |= datal & 0xff;
    return val;
}
static u16 BMP180_Readu16Reg(u8 regh,u8 regl){
    u8 datah,datal;
    u16 val;
    i2c_read_reg(regh,&datah,1);
    i2c_read_reg(regl,&datal,1);
    val = (datah & 0x00ff) << 8;
    val |= datal & 0xff;
    return val;
}
static s32 BMP180_Read32Reg(u8 regh,u8 regm,u8 regl){
    u8 datah,datam,datal;
    s32 val;
    i2c_read_reg(regh,&datah,1);
    i2c_read_reg(regm,&datam,1);
    i2c_read_reg(regl,&datal,1);
    val = (datah & 0x0000ff) << 16;
    val |= (datam & 0x0000ff) << 8;
    val |= (datal & 0x0000ff) ;
    return val;
}
static void BMP180_Init(void){
    BMP180_CalcParam_t* pBMP180_CP = &BMP180_CalcParams;
    pBMP180_CP->AC1 = BMP180_Reads16Reg(0xaa,0xab);
    pBMP180_CP->AC2 = BMP180_Reads16Reg(0xac,0xad);
    pBMP180_CP->AC3 = BMP180_Reads16Reg(0xae,0xaf);
    pBMP180_CP->AC4 = BMP180_Readu16Reg(0xb0,0xb1);
    pBMP180_CP->AC5 = BMP180_Readu16Reg(0xb2,0xb3);
    pBMP180_CP->AC6 = BMP180_Readu16Reg(0xb4,0xb4);
    pBMP180_CP->B1  = BMP180_Reads16Reg(0xb6,0xb7);
    pBMP180_CP->B2  = BMP180_Reads16Reg(0xb8,0xb9);
    pBMP180_CP->MB  = BMP180_Reads16Reg(0xba,0xbb);
    pBMP180_CP->MC  = BMP180_Reads16Reg(0xbc,0xbd);
    pBMP180_CP->MD  = BMP180_Reads16Reg(0xbe,0xbf);
}
static void BMP180_ReadT_P(s32* T,s32* P){
    BMP180_CalcParam_t* pBMP180_CP = &BMP180_CalcParams;
    u8 data = 0x2e;
    s32 UT,X1,X2,X3,B3,B6,UP,p;
    u32 B4,B7;
    i2c_write_reg(0xf4,&data,1);
    mdelay(20);
    UT = BMP180_Read32Reg(0xf6,0xf7,0xf8) >> 8;
    X1 = (UT-pBMP180_CP->AC6)* pBMP180_CP->AC5 >> 15;
    X2 = (pBMP180_CP->MC << 11) / (X1 + pBMP180_CP->MD);
    *T = (X1 + X2 +8) >> 4 ;
    data = 0x34;
    i2c_write_reg(0xf4,&data,1);
    mdelay(20);
    UP = BMP180_Read32Reg(0xf6,0xf7,0xf8) >> 8;
    B6 = X1 + X2 - 4000;
    X1 = (B6 * B6 >> 12) * pBMP180_CP->B2 >> 11;
    X2 = pBMP180_CP->AC2 * B6 >> 11;
    X3 = X1 + X2;
    B3 = (((pBMP180_CP->AC1 << 2) + X3) + 2) >> 2;
    X1 = pBMP180_CP->AC3 * B6 >> 13;
    X2 = (B6 * B6 >> 12) * pBMP180_CP->B1 >> 16;
    X3 = (X1 + X2 + 2) >> 2; 
    B4 = pBMP180_CP->AC4 * (u32)(X3 + 32768) >> 15;
    B7 = ((u32)UP - B3) * 50000;
    if(B7 < 0x80000000){
        p = (B7 << 1) / B4;  
    }else{
        p = B7/B4 << 1;
    }
    X1 = (p >> 8) * (p >> 8);
    X1 = (X1 * 3038) >> 16;
    X2 = (-7375 * p) >> 16;
    p = p + ((X1 + X2 + 3791) >> 4);
    *P = p;
}
int misc_open (struct inode *inode, struct file *file){
    printk("misc_open..\n");
    BMP180_Init();
    return 0;
}
int misc_release (struct inode *inode, struct file *file){
    printk("misc_release..\n");
    return 0;
}
ssize_t misc_read (struct file *file, char __user *ubuf, size_t size, loff_t *of){
    int ret;
    BMP180_Result BMP180_Result;
    BMP180_ReadT_P(&BMP180_Result.T,&BMP180_Result.P);
    ret = copy_to_user(ubuf,&BMP180_Result,sizeof(BMP180_Result));
    if(ret!=0){
        printk("copy_to_user err..\n");
        return -1;
    }
    return sizeof(BMP180_Result);
}
static const struct file_operations misc_fops={
    .owner          =   THIS_MODULE,
    .open           =   misc_open,
    .release        =   misc_release,
    .read           =   misc_read,
};
static struct miscdevice misc_test={
    .minor      = MISC_DYNAMIC_MINOR,
    .name       = "BMP180",
    .fops       = &misc_fops
};
static int BMP180_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id){
    int ret;
    fxs_i2c_client = client;
    ret = misc_register(&misc_test);
    if(ret<0){
        printk("misc_register err..\n");
        return -1;
    }
    printk("i2c probe success..\n");
    return 0;
}
static int BMP180_i2c_remove(struct i2c_client *client){
    misc_deregister(&misc_test);
    return 0;
}
static const struct i2c_device_id id_BMP180_i2c_driver[] = {
    {"BMP180",0,},
    {}
};
static const struct of_device_id of_BMP180_i2c_driver[] = {
    {.compatible = "BMP180",0,},
    {},
};
static struct i2c_driver BMP180_i2c_driver = {
    .driver = {
        .owner          = THIS_MODULE,
        .name           = "BMP180",
        .of_match_table = of_BMP180_i2c_driver,
    },
    .probe              = BMP180_i2c_probe,
    .remove             = BMP180_i2c_remove,
    .id_table           = id_BMP180_i2c_driver,
};
static int __init i2c_init(void){
    int ret ;
    ret = i2c_add_driver(&BMP180_i2c_driver);
    if(ret < 0){
        printk("i2c_add_driver error..\n");
        return ret;
    }
    printk("i2c_init..\n");
    return 0;
}
static void __exit i2c_exit(void){
    i2c_del_driver(&BMP180_i2c_driver);
    printk("i2c_exit..\n");
}
module_init(i2c_init);
module_exit(i2c_exit);
MODULE_LICENSE("GPL");

1.Run the above command to compile the driver make will get the .ko file
2.Copy the .ko file to DEBIX, run the command sudo insmod BMP180.ko
3.Run the command sudo dmesg | tail -2 , check the driver print information:

4.You can see that the probe function matches the device tree successfully.

Write Application Test Code

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
typedef struct {
    int T;
    int P;
}BMP180_Result;
int main(int argc,char *argv[])
{
    int fd,ret;
    int value;
    BMP180_Result BMP180_Result;
    fd = open("/dev/BMP180", O_RDWR);
    if (fd < 0){
        perror("open error \n");
        return fd;
    }
    while (1){
        read(fd,&BMP180_Result,sizeof(BMP180_Result));     printf("temperature: %d.%dC\n",BMP180_Result.T/10,
BMP180_Result.T%10);
        printf("pressure: %dpa\n",BMP180_Result.P);
        printf("-----------------------\n");
        sleep(1);
    }
    close(fd);
    return 0;
}

Compile the application file, run the command aarch64-none-linux-gnu-gcc app.c -o app, copy the compiled executable file to DEBIX.

Test result
Execute the application test code, and run the command ./app.

Change Debug Uart to Normal Uart on DEBIX Model C

DEBIX Industrial Computers — Thu, 09 Oct 2025 07:20:53 +0000

Modification method:

① uboot：

Modify the file: include/configs/imx93_evk.h

Change console=ttyLP0,115200 earlycon to console=tty0,115200 earlycon

② kernel：

Modify the file: arch/arm64/boot/dts/freescale/imx93-11x11-evk.dts

Comment out stdout-path = &lpuart1;

NOTE

U-Boot and Kernel of the DEBIX Model C (1GB RAM + 3-bit DIP Switch):

U-Boot: https://github.com/debix-tech/uboot/tree/ModelC_uboot_V2023.04
Kernel: https://github.com/debix-tech/linux/tree/ModelC_linux-6.1.36_2.1.0

TSN 802.1Qbv Demonstration with DEBIX Model A and DEBIX SOM A

DEBIX Industrial Computers — Mon, 22 Sep 2025 10:08:16 +0000

Enhanced Function of Traffic Scheduling — Time-Aware Shaper
TSN 802.1Qbv adds the following enhancements to network traffic scheduling:
• It divides Ethernet communication into fixed-length, repeating time cycles, which helps transmit time-critical traffic.
• Each traffic class has an assigned open time window for specific talkers and their listeners to communicate.
• The network path dynamically (T) reserves space for high-priority traffic, ensuring reliable transmission of the talker’s traffic across the entire network with deterministic latency.

Test Environment

Setup Diagram

Test Steps
1、Connect DEBIX SOM A and DEBIX Model A with an Ethernet cable according to the setup diagram.
2、Power on both devices and boot into the system.
3、Since the NXP demo communicates between i.MX8MM and i.MX8MP, if the code is not modified, you need to change the hostname of DEBIX Model A to imx8mm.
4、Run the GoPoint APP on both devices and select TSN 802.1Qbv demo.

DEBIX SOM A will display the device IP.
DEBIX Model A will display the camera selection screen.

5、Select the /dev/video2 camera, then run the demo.
6、
In the TSN Qbv demonstration:

The USB camera generates time-sensitive traffic over Ethernet.
iPerf generates best-effort traffic over Ethernet.
These traffic types are transmitted via TSN ports in different queues with different priorities.
When the Qbv configuration is applied, the traffic is prioritized and scheduled as required. *On the graphical user interface of DEBIX Model A, you can see: *
iPerf bandwidth;
Camera frame rate;
Real-time camera stream.

7、Click the button in the upper left corner of iPerf to switch between different Qbv traffic allocation priorities.

DEBIX SOM A Testing TSN Clock Synchronization with PTP

DEBIX Industrial Computers — Mon, 15 Sep 2025 09:59:18 +0000

Test Environment:

LinuxDevelopment Environment: Yocto 5.0（scarthgap）

U-Boot: U-Boot 2024.04

Kernel: Linux-6.6.36

Linux SDK: L6.6.36-2.1.0

Version: Debix SOM A V1.01_20241024

Devices: 2 * DEBIX SOM A + DEBIX SOM A IO Board

Test Steps:

Power on and run 2 pcs of mainboards, then enter the device console.

Run DebixVersion to check the basic information of the device.

Connect the ETH1 interfaces of the two DEBIX SOM A IO Boards using an Ethernet cable (only ETH1 supports TSN, you can check with the command ethtool -T ens33).

On the master device console, run:

ptp4l -E -4 -H -i ens33 -l 6 -m -q -f /etc/linuxptp/ptp4l.conf

On the slave device console, run:

ptp4l -E -4 -H -i ens33 -s -l 6 -m -q -f /etc/linuxptp/ptp4l.conf

Check the printed log information.

The log shows that the slave device synchronizes with the external master clock 100723.fffe.6df691-1, which corresponds to the master device’s ETH1 port.

Once the test stabilizes, review the data.

Example of the last log entry:

ptp4l[882.689]: master offset 12 s2 freq -8638 path delay 747

ptp4l[882.689]

ptp4l: This is the core daemon implementing the PTP (Precision Time Protocol) on Linux. PTP, also known as IEEE 1588, is a high-precision time synchronization protocol designed to provide sub-microsecond synchronization for devices within a LAN.

[882.689]: Process runtime timestamp in seconds, showing elapsed time since the process started.

master offset: 12

Meaning: The time difference between the local clock (slave) and the remote master clock.

Unit: Nanoseconds (ns).

Interpretation: 12 means the local clock lags behind the master clock by 12 ns. This is extremely precise synchronization (1 second = 1,000,000,000 ns).

s2 freq: -8638

Meaning: The frequency adjustment value calculated by ptp4l to correct clock offset in slave state. s2 refers to the slave state of ptp4l.

Unit: Parts per billion (ppb). This value will be passed to phc2sys (used to synchronize the system clock and hardware clock) or directly to the Linux kernel clock discipline.

Interpretation: -8638 means the local oscillator frequency is reduced by 8638 ppb to catch up with the master. This relatively large adjustment indicates the local clock was initially faster.

path delay: 747

Meaning: The round-trip delay between slave and master.

Unit: Nanoseconds (ns).

Interpretation: 747 ns is very low, suggesting excellent network hardware performance (likely hardware timestamping support). In software-timestamped networks, this value is usually tens to hundreds of microseconds.

Explanation of Test Command Parameters

DEBIX SOM A: Unleashing AI on the Edge with TensorFlow Lite, ONNX Runtime, and PyTorch

DEBIX Industrial Computers — Mon, 01 Sep 2025 08:38:33 +0000

Get started with AI on DEBIX i.MX8M Plus boards. Learn how to use TensorFlow Lite, ONNX Runtime, and PyTorch. Optimize performance with hardware acceleration.

iMX8MPlus #machinelearning #AI #tensorflow #ONNX #pytorch #hardwareacceleration #embedded

DEBIX Model A I/O Board: Serial Port Data Transfer

DEBIX Industrial Computers — Mon, 25 Aug 2025 09:27:29 +0000

In this video, we'll introduce the DEBIX Model A I/O Board and demonstrate how two DEBIX devices can transfer data via serial ports RS232, RS485, and CAN Transceiver.

Compile and Run Joydev Module on DEBIX with Kernel Source Code

DEBIX Industrial Computers — Mon, 18 Aug 2025 03:17:33 +0000

Run the command DebixVersion to check the DEBIX version as follows:

================ Debix Information =================

=====================================================
***HW version : V2.0

***System version : Ubuntu 22.04.1 LTS (V3.3 20230620)

***Lan1 mac : 10:07:23:6d:e7:2a

***Lan2 mac : 10:07:23:6d:e7:29

***Wifi mac : ac:6a:a3:1f:44:89

***BT mac : AC:6A:A3:1F:44:8A

***Kernel : 5.15.71 #1 SMP PREEMPT Tue Jun 20 11:23:38 UTC 2023

***Memory : 2 GB

***CPU : 1.6 GHz

Download the kernel source code from the DEBIX github website:

git clone --depth=1 https://github.com/debix-tech/linux  
cd linux

Generate the configuration file:

make imx_v8_defconfig
make menuconfig

Configure joydev by selecting the item:

-->Device Driver --> Input device support --> Joystick interface
-->Device Driver --> Input device support --> Joysticks/Gamepads

-->Device Driver --> Input device support --> Joysticks/Gamepads --> X-Box gamepad support

-->Device Driver --> Input device support --> Joysticks/Gamepads --> X-Box gamepad support -->[*] X-Box gamepad rumble support

-->Device Driver --> Input device support --> Joysticks/Gamepads --> X-Box gamepad support --> [*] LED Support for Xbox360 controller 'BigX' LED

Compile the kernel:

export CROSS_COMPILE=~/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu/bin/aarch64-none-linux-gnu-
export ARCH=arm64
make -j4
make modules_install  INSTALL_MOD_PATH=out

Add the X-box driver joydev.ko and xpad.ko file:
a. Copy the compiled kernel.tar to DEBIX
scp root@192.168.1.218:/kernel.tar ./

b. Unzip the kernel.tar file
tar -xvf kernel.tar

c. Replace the extracted kernel file with the kernel in the /lib/modules/5.15.71 path on DEBIX
cp -r kernel /lib/modules/5.15.71/

d. Mount joydev.ko
insmod /lib/modules/5.15.71/kernel/drivers/input/joydev.ko

e. Mount xpad.ko
insmod /lib/modules/5.15.71/kernel/drivers/input/joystick/xpad.ko

f. Check if xpad.ko is mounted successfully
lsmod

Hardware Acceleration with Ethos-U on DEBIX Model C

DEBIX Industrial Computers — Mon, 11 Aug 2025 06:07:11 +0000

Follow the official NXP documentation, i.MX_Machine_Learning_User's_Guide.pdf, to run the demo provided in 9.2.3.

Copy the required files and compile the model for Ethos-U using the vela tool.

cd /usr/bin/ethosu/examples/
cp ../../tensorflow-lite-2.11.1/examples/labels.txt ./
cp ../../tensorflow-lite-2.11.1/examples/grace_hopper.bmp ./
vela ../../tensorflow-lite-2.11.1/examples/mobilenet_v1_1.0_224_quant.tflite

Run the model through the TFLite inference engine using Ethos-U Delegate.

cd /usr/bin/tensorflow-lite-2.11.1/examples/
./label_image -m ../../ethosu/examples/output/mobilenet_v1_1.0_224_quant_vela.tflite
--external_delegate_path=/usr/lib/libethosu_delegate.so

DEBIX Camera Support for ROS2

DEBIX Industrial Computers — Mon, 11 Aug 2025 02:35:03 +0000

OS: Ubuntu22.04
ROS2 version: Humble

Install ROS2
Run the command: sudo apt update && sudo apt install locales

Set the language environment, and run the command:

sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
export LANG=en_US.UTF-8

Check the language environment, run Locale to confirm the language is UTF-8.

Authorize the GPG key with apt, run the command: sudo apt update && sudo apt install curl gnupg2 lsb-release

Run the command: sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg

If the command fails: manually download the file from https://raw.githubusercontent.com/ros/rosdistro/master/ros.key, rename it to ros-archive-keyring.gpg, and save it to the /usr/share/keyrings/ directory.

Then add the library to the source code list:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(source /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null

Update apt repository cache, run the command: sudo apt update

Install the full version of ROS2, run the command: sudo apt install ros-humble-desktop -y

Set the environment variables, run the command:

echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc
source ~/.bashrc

Test ROS2
Open two terminals on DEBIX desktop.
Terminal 1 runs the talker node, run the command:
ros2 run demo_nodes_cpp talker
Terminal 2 runs the listener node, run the command:
ros2 run demo_nodes_py listener

The two terminals show that the talker is posting a message and the listener receives the message posted by the talker.

Support DEBIX Camera Module
Install the V4L2 software package, run the command:
sudo apt-get install ros-humble-v4l2-camera

Use of the V4L2 software package

Note:
Take IMX219 camera for example, the device tree is imx8mp-debix-core-ar1335.dtb, and the device node is /dev/video2

Run the camera node
ros2 run v4l2_camera v4l2_camera_node --ros-args -p video_device:=/dev/video2 -p output_encoding:=yuv422_yuy2

View topic
ros2 topic list

Install dependencies
sudo apt-get install qtwayland5

open a terminal on your desktop and run the following command to subscribe and display the image data on the /image_raw topic
ros2 run rqt_image_view rqt_image_view

Select /Image_raw to view the image data on the /image_raw topic.

DEBIX Model A: DIY Webcam Streamer with Crowsnest

DEBIX Industrial Computers — Mon, 04 Aug 2025 02:24:36 +0000

Transform DEBIX Model A single board computer into a powerful webcam streamer using Crowsnest, a lightweight and versatile tool perfect for network monitoring. This guide covers hardware setup and how to access your live stream locally or remotely.

DEBIX Camera support for ROS2

DEBIX Industrial Computers — Wed, 30 Jul 2025 06:05:44 +0000

OS: Ubuntu22.04
ROS2 version: Humble

Install ROS2

Run the command: sudo apt update && sudo apt install locales

Set the language environment, and run the command:

sudo locale-gen en_US en_US.UTF-8

sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8

export LANG=en_US.UTF-8

Check the language environment, run Locale to confirm the language is UTF-8.

Authorize the GPG key with apt, run the command: sudo apt update && sudo apt install curl gnupg2 lsb-release

Run the command:

sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg

Then add the library to the source code list:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(source /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null

Update apt repository cache, run the command:sudo apt update

Install the full version of ROS2, run the command: sudo apt install ros-humble-desktop -y

Set the environment variables, run the command:

echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc

source ~/.bashrc

Test ROS2
Open two terminals on DEBIX desktop.

Terminal 1 runs the talker node, run the command:

ros2 run demo_nodes_cpp talker

Terminal 2 runs the listener node, run the command:

ros2 run demo_nodes_py listener

The two terminals show that the talker is posting a message and the listener receives the message posted by the talker.

Support DEBIX Camera Module

Install the V4L2 software package, run the command:

sudo apt-get install ros-humble-v4l2-camera

Use of the V4L2 software package Note: Take IMX219 camera for example, the device tree is imx8mp-debix-core-ar1335.dtb, and the device node is /dev/video2

Run the camera node ros2 run v4l2_camera v4l2_camera_node --ros-args -p video_device:=/dev/video2 -p output_encoding:=yuv422_yuy2 View topic ros2 topic list

Install dependencies
sudo apt-get install qtwayland5
open a terminal on your desktop and run the following command to subscribe and display the image data on the /image_raw topic
ros2 run rqt_image_view rqt_image_view
Select /Image_raw to view the image data on the /image_raw topic.

DEBIX Camera support for ROS2

DEBIX Industrial Computers — Wed, 30 Jul 2025 06:05:44 +0000

OS: Ubuntu22.04
ROS2 version: Humble

Install ROS2
Run the command:
sudo apt update && sudo apt install locales

Set the language environment, and run the command:

sudo locale-gen en_US en_US.UTF-8

sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8

export LANG=en_US.UTF-8

Check the language environment, run Locale to confirm the language is UTF-8.

Authorize the GPG key with apt, run the command:
sudo apt update && sudo apt install curl gnupg2 lsb-release

Run the command:

sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg

Then add the library to the source code list:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(source /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null

Update apt repository cache, run the command:sudo apt update

Install the full version of ROS2, run the command:
sudo apt install ros-humble-desktop -y

Set the environment variables, run the command:

echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc

source ~/.bashrc

Test ROS2
Open two terminals on DEBIX desktop.

Terminal 1 runs the talker node, run the command:

ros2 run demo_nodes_cpp talker

Terminal 2 runs the listener node, run the command:

ros2 run demo_nodes_py listener

The two terminals show that the talker is posting a message and the listener receives the message posted by the talker.

Support DEBIX Camera Module
Install the V4L2 software package, run the command:

sudo apt-get install ros-humble-v4l2-camera

Use of the V4L2 software package
Note:
Take IMX219 camera for example, the device tree is imx8mp-debix-core-ar1335.dtb, and the device node is /dev/video2

Run the camera node
ros2 run v4l2_camera v4l2_camera_node --ros-args -p video_device:=/dev/video2 -p output_encoding:=yuv422_yuy2
View topic
ros2 topic list

Install dependencies
sudo apt-get install qtwayland5
open a terminal on your desktop and run the following command to subscribe and display the image data on the /image_raw topic
ros2 run rqt_image_view rqt_image_view
Select /Image_raw to view the image data on the /image_raw topic.