DEV Community: Jiaju_Xie

One small experience to check the node of ros2

Jiaju_Xie — Sat, 14 Mar 2026 16:29:05 +0000

talk and subscribe

base 24.02 ubuntu
jazzy ros2

check the version of ros2
echo $ROS_DISTRO which ros2

1 Ctrl + Alt + T open the first terminal
2 source /opt/ros/jazzy/setup.bash
3 mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
// create package in src workplace ,not in the root
4 creat python package
ros2 pkg create --build-type ament_python my_py_pubsub --dependencies rclpy std_msgs

5 dive into the package dic
cd ~/ros2_ws/src/my_py_pubsub

6
creat talker and listenser code file
cd ~/ros2_ws/src/my_py_pubsub/my_py_pubsub touch talker.py listener.py

7
talker.py

import rclpy
from rclpy.node import Node
from std_msgs.msg import String


class TalkerNode(Node):
    def __init__(self):
        super().__init__('talker_node')
        self.publisher_ = self.create_publisher(String, 'chatter', 10)
        self.timer = self.create_timer(1.0, self.timer_callback)
        self.count = 0

    def timer_callback(self):
        msg = String()
        msg.data = f'Hello World: {self.count}'
        self.publisher_.publish(msg)
        self.get_logger().info(f'Publishing: "{msg.data}"')
        self.count += 1


def main(args=None):
    rclpy.init(args=args)
    node = TalkerNode()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

8
talker.py

import rclpy
from rclpy.node import Node
from std_msgs.msg import String


class ListenerNode(Node):
    def __init__(self):
        super().__init__('listener_node')
        self.subscription = self.create_subscription(
            String,
            'chatter',
            self.listener_callback,
            10
        )

    def listener_callback(self, msg):
        self.get_logger().info(f'I heard: "{msg.data}"')


def main(args=None):
    rclpy.init(args=args)
    node = ListenerNode()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

9 in the first terminal
cd ~/ros2_ws colcon build --packages-select my_py_pubsub source ~/ros2_ws/install/setup.bash ros2 run my_py_pubsub listener

10 in the second terminal
source /opt/ros/jazzy/setup.bash source ~/ros2_ws/install/setup.bash ros2 run my_py_pubsub talker

explain：
这个实验本质上做了什么？

先说结论。

我们刚刚做的事情，本质上是：

建了一个 ROS 2 工作空间

在这个工作空间里创建了一个 Python 类型的 ROS 2 包

在这个包里写了两个节点：

talker.py

listener.py

再通过 colcon build 让 ROS 2 识别这个包

最后通过 ros2 run 运行节点

所以，这不是“随便写了两个 Python 文件”，而是：

我们创建了一个最小的 ROS 2 Python 示例包，用来验证发布/订阅通信机制。

ROS 2 的思路是：

写 node → 放进 package → 放进 workspace → build → 用 ros2 run 运行

*workplace : ros2_ws/ *

以后你可以在这个 workspace 里放很多个 ROS 2 包，比如：

my_py_pubsub

my_robot_control

my_camera_pkg

src/ 是源码目录。

自己写的包，通常都放在这里。
所以常见的习惯就是：

mkdir -p ~/ros2_ws/src

src/ 下面的外层 my_py_pubsub/，
就是你的 ROS 2 包目录。

它的名字就是包名，所以以后你运行的时候会用到这个名字：

ros2 run my_py_pubsub talker

package.xml：这个包的身份证

package.xml 可以理解成 ROS 2 包的“身份证”或者“说明书”。

它通常会记录这些信息：

包名

版本

描述

作者 / 维护者

依赖项

setup.py：告诉系统“这个包怎么装、怎么跑”

setup.py 是 Python 包的安装配置文件。

它的作用包括：

声明 Python 模块

指定包名

配置可执行入口

告诉系统哪些脚本能被当成命令运行

其中最关键的一段，通常长这样：

entry_points={
'console_scripts': [
'talker = my_py_pubsub.talker:main',
'listener = my_py_pubsub.listener:main',
],
}

这段配置非常重要。

它的意思是：

当你执行：

ros2 run my_py_pubsub talker

ROS 2 实际上会去调用：

my_py_pubsub/talker.py

里面的：

main()

函数。

13. talker.py 和 listener.py 分别干嘛？

这两个就是你真正写的 ROS 2 节点代码。

talker.py

它是发布者节点，主要做三件事：

创建一个 publisher

定时生成消息

把消息发到 topic chatter

所以它负责“说话”。

listener.py

它是订阅者节点，主要做两件事：

创建一个 subscriber

收到 chatter 上的消息后打印出来

所以它负责“听话”。

这两个文件合起来，就是 ROS 2 最小的通信实验。

14. build/、install/、log/ 是什么？

这三个目录通常不是你手动创建的，
而是执行下面这个命令后自动生成的：

colcon build

它们分别代表不同阶段的构建结果。

build/

这里是编译过程中的中间文件。
可以理解成构建缓存和临时产物。

install/

这里是构建完成后的“安装结果”。

这个目录非常重要，因为构建完成后你通常要执行：

source ~/ros2_ws/install/setup.bash

这样系统才知道你自己写的包在哪里，才能用 ros2 run 找到它。

log/

这里是构建日志。
如果编译失败，很多时候可以来这里查问题。

所以这三个目录里，初学阶段你最需要理解的是：

install/ 很重要，因为它决定你的包能不能被 ROS 2 正确加载

Linux Common Commands

Jiaju_Xie — Sat, 14 Mar 2026 13:53:11 +0000

Linux Common Commands — English Explanation

参考文档：菜鸟教程 https://www.runoob.com/w3cnote/linux-common-command-2.html

Meaning: list files and directories.

You use ls to see what is inside a folder. It can also show hidden files, file permissions, file size, and modification time.

Common options:

ls -a → show all files, including hidden ones

ls -l → show detailed information

ls -h → show file sizes in human-readable form

ls -t → sort by modification time

ls -S → sort by file size

Example:

ls -lhrt

This means:

-l detailed list

-h readable sizes

-r reverse order

-t sort by time

Meaning: change directory.

Used to move from one folder to another.

Examples:

cd /

Go to the root directory.

cd ~

Go to the home directory.

cd -

Go back to the previous directory.

Meaning: print working directory.

It shows your current directory path.

Example:

pwd
pwd -P

Shows the real path, not the symbolic link path.

mkdir

Meaning: make directory.

Used to create new folders.

Examples:

mkdir t

Create a folder named t.

mkdir -p /tmp/test/t1/t

Create nested directories at once.
-p means create parent directories if needed.

Meaning: remove files or directories.

Examples:

rm -i *.log

Delete .log files, but ask for confirmation first.

rm -rf test

Delete the test directory and everything inside it.

-r recursive

-f force

This command is powerful and dangerous.

rmdir

Meaning: remove empty directories only.

Example:

rmdir -p parent/child/child11

Delete the last empty directory, and also remove parent directories if they become empty.

Meaning: move or rename files.

Examples:

mv test.log test1.txt

Rename test.log to test1.txt.

mv log1.txt log2.txt log3.txt /test3

Move multiple files into /test3.

Meaning: copy files or directories.

Examples:

cp -ai a.txt test

Copy a.txt to test, keep original time, and ask before overwriting.

cp -s a.txt link_a.txt

Create a symbolic link to a.txt.

Meaning: display file content, create files, or combine files.

Examples:

cat filename

Display the whole file.

cat > filename

Create a new file from keyboard input.

cat file1 file2 > file

Combine two files into one.

Also:

cat -n → show line numbers

cat -b → show line numbers only for non-empty lines

Meaning: view a file page by page.

Useful when a file is too long for one screen.

Example:

more +3 text.txt

Start showing the file from line 3.

You can press:

Space → next page

b → previous page

q → quit

less

Meaning: better file viewer than more.

It lets you scroll forward and backward more freely.

Examples:

less 1.log 2.log

Open multiple files.

Useful keys:

/text → search forward

?text → search backward

n → next match

N → previous match

Q → quit

head

Meaning: show the beginning of a file.

Example:

head -n 20 1.log

Show the first 20 lines.

tail

Meaning: show the end of a file.

Example:

tail -f ping.log

Continuously monitor new content added to a log file.

Very useful for watching logs in real time.

which

Meaning: find the location of an executable command.

Example:

which ls

Shows where the ls command is located.

It only searches commands in the PATH.

whereis

Meaning: find the binary file, source code, and manual page of a command.

Example:

whereis locate

Compared with which, whereis gives more related locations.

locate

Meaning: quickly search for files by name using a database.

Example:

locate pwd

It is fast, but may miss very new files because it depends on a database that updates periodically.

find

Meaning: search files and directories in the file system.

This is one of the most important Linux commands.

Examples:

find ./ -name '*.log'

Find all .log files in the current directory.

find /opt -perm 777

Find files with permission 777.

find . -type f -mtime +10 -exec rm -f {} \;

Find files older than 10 days and delete them.

find can search by:

name

type

size

time

owner

permissions

It can also run commands on the results using -exec.

chmod

Meaning: change file permissions.

Linux permissions include:

r = read

w = write

x = execute

Examples:

chmod a+x t.log

Give execute permission to everyone.

chmod 751 t.log

Set permissions numerically:

owner = 7 = rwx

group = 5 = r-x

others = 1 = --x

Meaning: archive files, and often compress them.

Important idea:

archive = pack many files into one

compress = reduce file size

Examples:

tar -zcvf /tmp/etc.tar.gz /etc

Create a compressed archive of /etc.

tar -ztvf /tmp/etc.tar.gz

List contents of a compressed archive.

Common options:

-c create

-x extract

-t list contents

-f specify filename

-z gzip

-j bzip2

-v verbose

chown

Meaning: change file owner and group.

Examples:

chown -c mail:mail log2012.log

Change the owner and group to mail.

chown -cR mail: test/

Recursively change ownership for a directory.

Meaning: display disk space usage.

Example:

df -haT

Show all file systems, in readable format, with file system type.

Use this to check how much disk space is left.

Meaning: show disk usage of files and directories.

Example:

du -ah scf/

Show the size of all files and subdirectories.

du -hc test/ scf/

Show sizes plus a total.

Difference:

df = disk free space of the whole filesystem

du = size used by specific files/folders

Meaning: create links.

Two types:

soft link (ln -s) = like a shortcut

hard link = another name for the same file data

Examples:

ln -sv source.log link.log

Create a symbolic link.

ln -v source.log link1.log

Create a hard link.

date

Meaning: display or set the system date and time.

Examples:

date

Show current date and time.

date -d tomorrow +%Y%m%d

Show tomorrow’s date in YYYYMMDD format.

Useful for scripts.

Meaning: display a calendar.

Examples:

cal 9 2012

Show the calendar for September 2012.

cal -y 2013

Show the full calendar for 2013.

grep

Meaning: search text by pattern.

This is one of the most useful commands in Linux.

Examples:

ps -ef | grep svn

Search for processes containing svn.

grep -lR '^grep' /tmp

Recursively find files in /tmp whose content starts with grep.

Useful options:

-i ignore case

-n show line numbers

-c count matches

-R recursive search

Meaning: count lines, words, and bytes.

Example:

wc text.txt

Shows:

number of lines

number of words

number of bytes

filename

cat test.txt | wc -l

Count lines in output.

Meaning: show current running processes.

Examples:

ps -ef

Show all processes in full format.

ps -aux | grep apache

Find the Apache process.

This command helps you inspect what programs are running.

Meaning: dynamic process monitor.

It shows:

CPU usage

memory usage

running processes

system load

It updates in real time.

Useful interactive keys:

P sort by CPU

m sort by memory

c show full command line

h help

kill

Meaning: send a signal to a process.

Example:

kill -9 PID

Forcefully stop a process.

-9 means SIGKILL, which cannot be ignored.

Safer default:

kill PID

This sends SIGTERM first.

free

Meaning: show memory usage.

Examples:

free -m

Show memory usage in MB.

free -s 10

Refresh every 10 seconds.

Useful for checking RAM and swap usage.

Main idea of the whole article

This article is trying to teach basic Linux command-line operations.
It covers 4 major areas:

File and directory operations

Examples:

pwd

mkdir

File viewing and searching

Examples:

cat

less

head

tail

grep

find

System monitoring

Examples:

top

free

Permissions and archive management

Examples:

chmod

chown

tar

A more natural English summary

You could describe this page like this:

This article introduces commonly used Linux commands for beginners. It explains how to navigate directories, manage files, search for content, check system resources, change file permissions, and handle processes. These commands are essential for daily Linux usage and system administration.

中文意思：

这篇文章向初学者介绍了常用的 Linux 命令，内容包括目录切换、文件管理、内容搜索、系统资源查看、权限修改以及进程管理。这些命令是日常使用 Linux 和进行系统管理的基础。

If you want to study this efficiently

I’d group them like this:

Must learn first

pwd

mkdir

cat

Very practical next

grep

find

head

tail

less

For system monitoring

top

free

For admin tasks

chmod

chown

kill

tar