16 April 2023 - Hardware Order

Today, I received all the main components that I ordered last week. Most of them are shown in the photo below. The most expensive one is the Raspberry Pi, then comes the Lidar and motors.

I bought them from different sites (Ebay, Amazon, etc.) and more details can be found in the table below (to be updated).

I already tried to use popular devices that hopefully, you can easily find and buy too. But for those of you who don't have a big budget, I will also leave my recommendation in the section where I test each of them. Can't wait to test them out!

18 April 2023 - Install ROS 2

I installed Ubuntu 22 and ROS 2 Humble on my laptop (and later on the Raspberry Pi too). This is the first time I use ROS 2 so it's a bit bewildering because there are many changes.

For the differences between ROS 2 and ROS 1, you can easily ask Google or ChatGPT or here but some of my first impressions after going through some tutorials are:

• ROS 2 uses a new build system called ament instead of catkin. ament provides a number of advantages over catkin, including better support for cross-compiling, more flexible package structures, and better support for non-C++ languages like Python, bla bla bla. The underlying building concept is still similar between the two. ROS 2 provides a build tool named colcon that can build packages of multiple build systems (python, cmake, ament_cmake, ament_python, catkin...). So now instead of doing catkin build, we need to use colcon build.

• No roscore needed! One of the main changes in ROS 2 is the use of DDS (Data Distribution Service) as the default communication middleware. DDS provides a standard API for data communication, which allows nodes to communicate with each other directly, without the need for a central coordinator like roscore. In ROS 2, DDS is used for message passing, service invocation, and discovery of other nodes in the system.

19 April 2023 - Test Lidar

The next thing I tested is the lidar. The one I bought is a Slamtec RPLIDAR A1 which is a 2D rotating lidar. The wire connection is quite straightforward. I just followed the instruction. The only thing I don't like is that there is no Micro-USB cable delivered without which I cannot connect it to my laptop, and I find it stupid. Luckily, I have some of them. After connecting to the laptop, the lidar ran right away.

In order to view the result from the lidar, I found this repository on Github from RpLidar and cloned it to the ros workspace. However, the building ran into some error saying something like error: narrowing conversion of ‘rp::hal::Event::EVENT_TIMEOUT’ from ‘int’ to ‘long unsigned int’ [-Wnarrowing] and I don't know how to solve it.

Then I found out that I can simply run sudo apt install ros-humble-rplidar-ros to install this package for ROS2 Humble. But when I ran it, another error Error, cannot bind to the specified serial port '/dev/ttyUSB0'. I checked if the serial connection /dev/ttyUSB0 exist but it did not, so I guessed the problem may come from the cable. I tried all 3 USB cables that I have and one of them lit up the green LED from the lidar which gave me some hope, but no, the same error happened. I tried another package which was forked from the original repository above and modified for ROS Humble, but the same error. Hmm!?

The last thing I tried is to restart my laptop. And, it worked. Oh my... Now I can see the point cloud from the lidar in rviz. Yay!

01 May 2023 - Test Pi and Motor

Last week, I tried to set up the Raspberry Pi and check if it works fine. However, there was a problem that at first I thought was not a big deal but turns out it was. The board that I mistakenly ordered is a Compute Module 4 (not a Raspberry Pi 4 Model B), which has 8GB RAM and an SSD of 256 GB which are more than enough for this application. It also came with a very nice metal box. I started by flashing the Ubuntu 22 image file to the SSD to install it. However, when the Ubuntu installation window appeared, I could not use my mouse and keyboard. I googled the problem a lot and tried many suggestions like here or here but nothing works. I also tried to boot from an SD Card but wasted an hour (just trying different cards, restarting the board, etc.) just to find out that this Pi version does not accept SD Card since it comes with an SSD already. So in the end, I gave up and ordered a normal Raspberry Pi 4 Model B.

In the meantime, I tested the motor directly with my laptop. This is also one tip to someone who doesn't or cannot buy a Pi, you can simply use your laptop for all the tasks in this series. The Pi is just a more compact solution and it is indeed a computer.

For the motor, I follow this tutorial and it worked quite nicely. I used an Arduino Nano and an L298N motor driver (a 15V adapter, which is not in the image, is connected to the motor driver). The Arduino receives signals from my computer via the serial USB connection and controls the motor. It also reads the encoder values from the motor and sends them back to the laptop for close loop control for example. The code for the Arduino is from this repo and a demo with ROS can be found here. The theory about this step will be one big chapter later in this series so I will not go into detail here.

The wiring is shown below. Note that I just tested with one motor so far but for the second it should be similar. Next, I am trying to find a way to make the chassis (or the base) of the robot. Maybe I will simply start with a box or even a wooden plate. Let's see.

14 May 2023 - Mobile Robot Prototype

First of all, sorry for such a late update. There are so many things going on in my life right now (new baby is coming, new job, finding a new flat, etc.), so it is difficult to make progress.

Install Ubuntu on a Raspberry Pi

I bought a new Raspberry Pi board (Model 4B with 8GB RAM, 4GB verson should also work) and got no problem installing Ubuntu 22. First, I uploaded the installation file (as known as OS image) to an SD card (mine is a 64GB) using an application called Raspberry Pi Imager. You can use Imager on Windows, Linux or Mac OS. After installation, open Imager and plug in the SD card. Click Choose OS > Other general-purpose OS > Ubuntu > Ubuntu Desktop 22.04.2 LTS (64bit), then click Choose storage and select the SD card. Finally, click write to start the uploading. When done, remove the SD card and plug it into the Pi. Turn on the Pi by connecting the power cable and connect it to a monitor with an HDMI cable. Follow the instruction on the screen to install Ubuntu which is pretty straightforward.

Build the first prototype

I have built the first prototype of the robot using a plastic box with a size (Length x Width x Height) of 18x16x8 cm. I mounted the two wheels and a furniture swivel castor under the box like below.

After that, I put the lidar and the Pi camera onto a wooden plate which is then mounted to the lid. All the other electronic parts are put inside the box. It looks a bit messy right now but I think it is fine for the first version.

Next, I will take a look into how to power the robot. Someone suggested using a LiPo battery or a power bank for the Pi plus a set of 8 AA batteries for the motor. I may try the latter first because I find it safer. The other thing I will do is to create a robot description (i.e. URDF) so that I can simulate it in ROS.

24 September 2023 - Access Pi Remotely

The last few months have been a bit tough for me because I have got a second daughter (Yay!), changed my job and moved to a new place. That's why, there is no progress on this project. Sorry for that. Things are getting better now so I will bit by bit continue. Hope you are still interested.

Since the Pi is attached to the mobile robot, accessing it via cable is not feasible anymore. Luckily, we can access the Pi remotely from another computer (the host). The easiest way is to access via SSH (Secure Socket Shell) using tools such as PuTTY or via VNC (Virtual Network Computing). I am using VNC Viewer because it provides access to a graphical user interface (GUI). Here is how to do it:

Step 2: In the Pi, open Settings or simply hit the Windows button and search for Sharing. Turn on the sharing and Go to Remote Desktop. Then follow the steps in the image below: Remote Desktop ON -> Enable Legacy VNC Protocol -> Choose Required a password -> Remote Control ON. Remember the password at the bottom. You can change the User Name and Password as you like but the password will be changed/regenerated every time you reboot the Pi. I will show you how to avoid it in Step 5.

Step 2: Find the IP address of the internet connection on the Pi by using the following command: hostname -I #captial i. Mine is 192.168.0.21.

Step 3: Download and install VNC Viewer on your host PC. Mine is running Ubuntu 22 (VNC Viewer is available on Mac and Windows also). After installing, open VNC Viewer and enter the IP address from Step 2 plus a Name (name is optional). Hit OK to finish.

Step 4: After that, double-click on the robodev icon in the main VNC Viewer window and select Continue. Enter the password from Step 2. Hit OK and the GUI of the Pi should appear on the host PC.

Step 5: Now you can access the Pi from remotely. However, there are still some issues that you may encounter.

• VNC only works when the Pi's display is active (meaning no sleep or screen saver), so we need to go to Power > Screen Blank > Never. You probably also want auto-login so that when you reboot your Pi you don't have to connect to a monitor to enter a password. So just go to Users -> Unlock … -> Enter Password -> Select Automatic Login.

• By default, the remote desktop will automatically generate new authenticated password every time you reboot. To avoid that what you can do is (source): search for Passwords and Keys. On the Passwords tab on the left, remove vnc if it exists by right-clicking on it and selecting Delete. Then Right click on Login > select Change Password \> Enter your username password. Then it will ask you to enter a new password. DON'T type anything here and just click Continue twice. Then go back to Remote Desktop, ensure the password you want is set in Authentication part. Now each time you reboot, that password will then remain the same.

The Idea

The goal of this project is simple: to understand how all the dots in a real robot (hardware, software, and algorithms) actually work and are connected. The reason I want to start with a mobile robot is that it is one of the simple robots with tons of applications: from vacuum cleaners and lawnmowers to Mars exploration rovers. Also, many new technologies can be deployed on a mobile robot, so we can learn a lot by making one.

There are already several awesome open-source projects out there helping you make your own mobile robot from scratch such as this one or this one, but I do not plan to just copy them. For me, a robot should serve a real purpose. Education is of course one of them here in Robodev but I want the robot to have a real-life application as well.

After doing some research, I decide to make a vacuum cleaner robot because it is a genius invention for reducing housework. It probably will cost more than a normal commercial one out there, but hey, building our own robot will enable us to do much more than just vacuum (and money may not be a big problem if someone, like you, is kind enough to sponsor me😀).

The Plan

I plan to make this project agile, meaning I will not do and wait until everything is done, then make posts but I will show you all the steps and the changes along the way. That also means I need support from you. Any comments and suggestions for improvement would be really really appreciated.

A concrete plan will be created soon but this project in general will cover the following topics:

1. Hardware

   What components are required for a mobile robot? Why do we need them and how do they operate? Some hardware parts are mechanical links and joints, microcontrollers, motors, ultrasonic sensors, lidar, camera, IMU, etc.

2. Software

   The main development platform is ROS 2. Programming languages are mainly C++ and Python.

3. Algorithms

   State-of-the-art methods in navigation, control, SLAM (simultaneous Localization And Mapping), object detection, human detection, etc. will be applied.

Call for Cooperation

To be honest, I have never made a mobile robot myself. I worked with some of them from Lego cars to KUKA industrial robots, but creating one is still on my wish list. Now is probably the best time and place to start. However, I do not want it to be a one-man show. It is not because I am unable to handle it myself but doing it alone would be very slow (I have a full-time job and 2 kids) with lots of stupid mistakes along the way (I am not an expert in everything). That's why, I am searching for partners to build up a team for this project. Basically, I need two people, one should have experience with mechanical design (know how to use CAD software, 3D printing, etc.) and the other should have some background in computer vision (SLAM, lidar, detection, etc.). We can do it completely online, or if you are living in Hamburg, Germany, we can also meet up.

So if you want to team up to make this robot, please reach out to me via my LinkedIn. I am looking forward to talking to you. It would be fun!

To be continued ...

Ý tưởng

Ý tưởng để làm phần này thật ra rất đơn giản và cũng không có gì mới. Trong chương trước, chúng ta đã sử dụng rqt_robot_steering, một GUI đơn giản mà ROS cung cấp để điều khiển robot di động. Về cơ bản, nó cho phép bạn thay đổi vận tốc tuyến tính (thanh trượt dọc) để tiến/lùi và vận tốc góc (thanh trượt ngang) để rẽ trái/phải. Các giá trị vận tốc này sau đó được đóng gói vào một Twist message và publish ra topic /robot_diff_drive_controller/cmd_vel.

Bây giờ thay vì sử dụng GUI này, bạn có thể sử dụng webcam để nhận biết các dấu tay (như ở chương 9) và chuyển đổi chúng để có các chức năng tương tự. Ngón trỏ trỏ lên/xuống (Forward/Backward) là để tiến/lùi, ngón cái (Turn Left/Turn Right) là để rẽ trái/phải và tất cả các ngón duỗi ra có nghĩa là dừng (Stop). Tất cả những gì chúng ta cần làm là viết một tập lệnh để chuyển đổi các cử chỉ này thành vận tốc và publish ra topic /robot_diff_drive_controller/cmd_vel.

Nếu bạn muốn thay đổi, thêm hoặc xóa các cử chỉ tay, hãy làm theo hướng dẫn ở phần này trong chương 9.

Hệ thống

Biểu đồ bên dưới mô tả cách toàn bộ hệ thống hoạt động. Các phần màu xanh lục là những gì chúng tôi đã làm từ các chương trước: node /my_camera đọc hình ảnh từ webcam và publish chúng lên topic /image_raw (từ các chương 7 và 8); một Node khác là /hand_sign_recognition subscribe /image_raw, xử lý hình ảnh và publish kết quả ra topic /gesture/hand_sign (từ chương 9). Chúng ta cần triển khai phần màu xanh lam, thực chất là một Node và hãy gọi nó là /hand_sign_control. Node này subscribe topic /gesture/hand_sign, chuyển đổi các ký hiệu tay thành các giá trị điều khiển và publish ra topic /robot_diff_drive_controller/ cmd_vel. Từ topic này, node /gazebo (từ chương 10 và 11) sẽ nhận các giá trị vận tốc và điều khiển rô-bốt tương ứng.

Triển khai

Sau khi có ý tưởng và hiểu cách hệ thống hoạt động, mình tin rằng việc triển khai sẽ khá đơn giản. Có nhiều cách khác nhau để làm và mình sẽ chỉ bạn một trong số đó. Hãy tạo một tập lệnh mới có tên sign_to_controller.py trong thư mục ros_hand_gesture_recognition/src. Về cơ bản, tập lệnh này sẽ xử lý các hoạt động trong phần màu xanh lá ở bên trên. Code được đặt tại đây và bên dưới là giải thích cho những phần code chính.

Đầu tiên, lớp GestureController được tạo. Trong __init__ của nó, các node hand_sign_control, gesture_subscriber và vel_publisher được khởi tạo. gesture_subscriber thực hiện hàm callback bất cứ khi nào nó nhận được mesage từ topic /gesture/hand_sign (tên topic này được định nghĩa trong tệp launch và được gọi bằng hàm rospy.get_param). vel_publisher publishTwist mesage tới topic /robot_diff_drive_controller/cmd_vel.

class GestureController:

    def __init__(self):
        rospy.init_node('hand_sign_control', anonymous=True)
        # Subscriber for subscribing the hand signs
        self.gesture_subcriber = rospy.Subscriber(rospy.get_param("hand_sign_recognition/publish_gesture_topic"), String, self.callback)
        # Publisher for publishing velocities 
        self.vel_publisher = rospy.Publisher("/robot_diff_drive_controller/cmd_vel", Twist, queue_size=10)
        # Velocity message
        self.vel_msg = Twist()
        # Velocity in/decrements
        self.linear_vel = 0.01 #[m/s]
        self.angular_vel = 0.1 #[rad/s]

Twist, một loại ROS mesage, biểu thị vận tốc trong không gian trống. Twist được chia thành 2 phần: tuyến tính và góc. Mỗi phần là một vector có 3 thành phần con x, y, z. Trong trường hợp của chúng ta, rô-bốt được điều khiển bởi hai giá trị: vận tốc tuyến tính dọc theo trục X để tịnh tiến và vận tốc góc dọc theo trục Z để quay, do đó, chỉ có phần tử x trong tuyến tính và phần tử z trong angular là các tín hiệu điều khiển. Chúng được cập nhật trong hàm callback.

Hàm callback là nơi diễn ra quá trình chuyển đổi và publish. Đầu tiên, nó kiểm tra cử chỉ đầu vào là gì. Nếu cử chỉ là Forward hoặc Backward (Tiến/Lùi) thì vận tốc tuyến tính được biểu thị bằng thành phần x của vel_msg.linear được tăng hoặc giảm tương ứng bởi linear_vel được đặt thành 0,01 m/s trong __init__. Nếu cử chỉ là Turn Right hoặc Turn Left (Rẽ Trái/Phải), vận tốc góc được biểu thị bằng thành phần z của vel_msg.angular sẽ được tăng hoặc giảm tương ứng bởi angular_vel được đặt thành 0,1 rad/s trong __init__ . Trong các trường hợp Tiến/Lùi, vận tốc góc này được đặt bằng 0 để rô-bốt đi thẳng mà không bị quay cùng lúc. Nếu cử chỉ là Stop hoặc NONE (NONE có nghĩa là không dấu tay nào được phát hiện), thì tốc độ tuyến tính và tốc độ góc được đặt thành 0 tức là rô-bốt sẽ dừng lại. Cuối cùng, vel_msg được publish bởi vel_publisher.

    def callback(self, gesture):
        if gesture.data ==  "Forward":
            self.vel_msg.linear.x += self.linear_vel
            self.vel_msg.angular.z = 0.
        elif gesture.data ==  "Backward":
            self.vel_msg.linear.x -= self.linear_vel
            self.vel_msg.angular.z = 0.
        elif gesture.data == "Turn Right":
            self.vel_msg.angular.z -= self.angular_vel
        elif gesture.data == "Turn Left":
            self.vel_msg.angular.z += self.angular_vel
        elif gesture.data == "Stop" or gesture.data == "NONE" :
            self.vel_msg.linear.x = 0
            self.vel_msg.angular.z = 0
        self.vel_publisher.publish(self.vel_msg)

Let's launch them all!

Để chạy chương trình cần có 4 tệp: sign_to_controller.py, my_cam.launch từ gói my_cam, hand_sign.launch từ gói ros_hand\ gesturerecognition và drive_robot.launch từ gói ros_mobile_robot. Để tiết kiệm thời gian, bạn có thể nhóm 3 tệp launch đầu tiên vào một để chạy một thể bằng cách sử dụng thẻ include. Hãy gọi tệp này là sign_control.launch và đặt nó vào thư mục launch của package ros_hand_gesture_recognition . Sau đây là nội dung của nó.

<launch>
    <include file="$(find my_cam)/launch/my_cam.launch" />
    <include file="$(find ros_hand_gesture_recognition)/launch/hand_sign.launch" />

    <arg name="publish_gesture_topic" default="/gesture/hand_sign"/>
    <arg name="control_topic" default="/robot_diff_drive_controller/cmd_vel"/>

    <node name="sign_to_controller" pkg="ros_hand_gesture_recognition" type="sign_to_controller.py" output="screen">
        <param name="publish_gesture_topic" type="string" value="$(arg publish_gesture_topic)" />
        <param name="control_topic" type="string" value="$(arg control_topic)" />
    </node>
</launch>

Mở 2 terminal, trong cái đầu tiên chạy:

roslaunch ros_hand_gesture_recognition sign_control.launch

Trong cái thứ hai, chạy:

roslaunch ros_mobile_robot drive_robot.launch

Sau đó, bạn có thể điều khiển robot bằng tay của mình. Để cho thú vị hơn, bạn có thể thêm một số chướng ngại vật như là khối hộp, trụ và cầu trong Gazebo như tôi đã làm ở đây:

Video này là một ví dụ:

Tiếp theo?

Thực sự tuyệt vời khi bạn đã hoàn thành loạt bài này. Bây giờ bạn đã biết gần hết những khái niệm cơ bản về ROS và thậm chí đã tạo ứng dụng ROS đầu tiên của mình. Từ thời điểm này, tùy theo mục đích của mình, bạn có thể bắt đầu khám phá các khía cạnh khác và vô vàn các package tuyệt vời trong ROS. Mình sẽ đặt một số link bên dưới để tham khảo nhưng chắc chắn vẫn còn nhiều cái khác mà mình không biết tới. Hãy để lại bình luận nếu bạn tìm thấy bất kỳ điều thú v gì. Sẽ có thêm nhiều post về chế tạo robot thật, ROS2, AI, v.v. tại Robodev, vì vậy bạn hãy nhớ đăng ký để được cập nhật. Cuối cùng, mình chúc bạn tiếp tục có nhiều niềm vui trong việc tìm tòi và chế tạo robot!

Nguồn tham khảo:

• Awesome robotic repositories on GitHub:

  • https://github.com/shannon112/awesome-ros-mobile-robot

  • https://github.com/jslee02/awesome-robotics-libraries

  • https://github.com/fkromer/awesome-ros2

• DIY Making real mobile robots:

  • https://articulatedrobotics.xyz/

  • https://github.com/ros-mobile-robots/diffbot

The idea

The idea is pretty simple and there is actually nothing new. In the previous chapter, we used rqt_robot_steering, a simple GUI that ROS provides to drive mobile robots. It basically lets you change the linear velocity (the vertical slider) to move forward/backward and the angular velocity (the horizontal slider) to turn left/right. These velocity values are then packed into a Twist message and published to the topic in the box, here is /robot_diff_drive_controller/cmd_vel.

Now instead of using this GUI, we can convert the hand signs detection (from chapter 9) to have the same functionalities. The index finger pointing up/down is for moving forward/backward, the thumb is for turning left/right, and all fingers stretched means stop. All we need is to write a script to convert these signs to velocity commands and publish them as messages to the topic /robot_diff_drive_controller/cmd_vel.

If you want to change, add, or remove signs, please follow this section in chapter 9.

The workflow

The graph below describes the workflow of the complete system (ellipses are nodes and rectangles are topics). Green parts are what we already implemented: a node /my_camera reads images from a webcam and publishes them to the topic /image_raw (from chapters 7 and 8); another Node /hand_sign_recognition subscribes to /image_raw, processes the images, and publishes results to the topic /gesture/hand_sign (from chapter 9). We need to implement the blue part which is basically a node, let's call it /hand_sign_control, that subscribes the /gesture/hand_sign topic, converts the hand signs to control values, and publishes them to the topic /robot_diff_drive_controller/cmd_vel. From this topic, the /gazebo node (from chapters 10 and 11) will read the velocity values and drive the robot accordingly.

The implementation

After getting the idea and the workflow, I believe the implementation should be quite straightforward. There are different ways to make it work and I will show you one of them. Let's create a new script named sign_to_controller.py in the folder ros_hand_gesture_recognition/src. This script will basically handle the activities in the blue part above. The source code is located here and I give below an explanation for the main parts of the code.

First, the class GestureController is created. In its __init__, the node hand_sign_control, the gesture_subscriber and the vel_publisher are initialized. The gesture_subscriber executes the function callback whenever it receives a String message from the topic /gesture/hand_sign (this topic name is defined in the launch file and is read using the function rospy.get_param). The vel_publisher will publish a Twist message to the topic /robot_diff_drive_controller/cmd_vel.

class GestureController:

    def __init__(self):
        rospy.init_node('hand_sign_control', anonymous=True)
        # Subscriber for subscribing the hand signs
        self.gesture_subcriber = rospy.Subscriber(rospy.get_param("hand_sign_recognition/publish_gesture_topic"), String, self.callback)
        # Publisher for publishing velocities 
        self.vel_publisher = rospy.Publisher("/robot_diff_drive_controller/cmd_vel", Twist, queue_size=10)
        # Velocity message
        self.vel_msg = Twist()
        # Velocity in/decrements
        self.linear_vel = 0.01 #[m/s]
        self.angular_vel = 0.1 #[rad/s]

Twist, one type of ROS geometries messages, expresses velocity in free space broken into its linear and angular parts. Each part is one vector with 3 components: x, y, and z of type float. In our case, the robot is controlled by two values: the linear velocity along the X-axis for translation and the angular velocity along the Z-axis for rotation, so only the x element in the linear and the z element in the angular are the control signals. They are derived in the callback function.

The callback function is where the conversion and publishing happen. It first checks what the input gesture is. If the gesture is Forward or Backward, the linear velocity represented by the x component of vel_msg.linear is incremented or decremented respectively by linear_vel which is set to 0.01 m/s in the __init__. If the gesture is Turn Right or Turn Left, the angular velocity represented by the z component of vel_msg.angular is incremented or decremented respectively by angular_vel which is set to 0.1 rad/s in the __init__. In Forward/Backward cases, this angular velocity is set to 0 to make the robot move without rotating at the same time. If the gesture is either Stop or NONE (NONE means no sign detected), the linear and angular speeds are set to zero making the robot stop. Finally, the Twist message vel_msg is published by vel_publisher.

    def callback(self, gesture):
        if gesture.data ==  "Forward":
            self.vel_msg.linear.x += self.linear_vel
            self.vel_msg.angular.z = 0.
        elif gesture.data ==  "Backward":
            self.vel_msg.linear.x -= self.linear_vel
            self.vel_msg.angular.z = 0.
        elif gesture.data == "Turn Right":
            self.vel_msg.angular.z -= self.angular_vel
        elif gesture.data == "Turn Left":
            self.vel_msg.angular.z += self.angular_vel
        elif gesture.data == "Stop" or gesture.data == "NONE" :
            self.vel_msg.linear.x = 0
            self.vel_msg.angular.z = 0
        self.vel_publisher.publish(self.vel_msg)

Let's launch them all!

There are 4 files required to be launched/executed: this sign_to_controller.py script, my_cam.launch from package my_cam, hand_sign.launch from package ros_hand_gesture_recognition and drive_robot.launch from package ros_mobile_robot. In order to save time, you can group the first 3 in one launch file using the include tag. Let's call this file sign_control.launch and put it in the launch folder of ros_hand_gesture_recognition. Following is its content.

<launch>
    <include file="$(find my_cam)/launch/my_cam.launch" />
    <include file="$(find ros_hand_gesture_recognition)/launch/hand_sign.launch" />

    <arg name="publish_gesture_topic" default="/gesture/hand_sign"/>
    <arg name="control_topic" default="/robot_diff_drive_controller/cmd_vel"/>

    <node name="sign_to_controller" pkg="ros_hand_gesture_recognition" type="sign_to_controller.py" output="screen">
        <param name="publish_gesture_topic" type="string" value="$(arg publish_gesture_topic)" />
        <param name="control_topic" type="string" value="$(arg control_topic)" />
    </node>
</launch>

Now open 2 terminals. In the first one run:

roslaunch ros_hand_gesture_recognition sign_control.launch

In the second:

roslaunch ros_mobile_robot drive_robot.launch

After that, you can drive the robot using your hand. To make it more fun, you can add some obstacles with some boxes, cylinders and spheres in Gazebo as I did here:

This video shows you how it works:

I hope you enjoy it!

Now what?

You have done a really great job finishing this series. Now you've got to know all the basics of ROS and even created your very first ROS application. From this point on you can, depending on your interests, start to explore other aspects and many awesome packages in ROS. I will put some links below for reference but there are many more out there that I am not aware of. Feel free to leave me a comment if you find any interesting ones. I plan to make more blog posts about making real robots, ROS2, AI, etc. here in Robodev, so remember to subscribe to get updated. Finally, I wish you keep having fun making robots and happy learning!

Resources:

• Awesome robotic repositories on GitHub:

  • https://github.com/shannon112/awesome-ros-mobile-robot

  • https://github.com/jslee02/awesome-robotics-libraries

  • https://github.com/fkromer/awesome-ros2

• DIY Making real mobile robots:

  • https://articulatedrobotics.xyz/

  • https://github.com/ros-mobile-robots/diffbot

Xacro là gì?

Trong phần trước, chúng ta đã tạo một URDF để mô tả tất cả các liên kết và khớp nối của một robot di động. Tuy nhiên, bạn có thể nhận thấy một số điểm dư thừa trong URDF này, ví dụ: 4 bánh xe có các thành phần gần như giống hệt nhau (ngoại trừ tên và vị trí). Đối với một robot phức tạp hơn, sẽ có nhiều thành phần lặp đi lặp lại hơn nữa và sẽ khiến URDF trở nên cồng kềnh và khó bảo trì. Đó là lý do tại sao Xacro ra đời. Xacro là viết tắt của XML Macro cho phép bạn sử dụng macro trong URDF để tăng tính mô đun và giảm những đoạn mã thừa. Lưu ý rằng Xacro không phải là một giải pháp thay thế cho URDF mà chỉ là một cách viết khác vì cuối cùng, Xacro sẽ được (tự động) chuyển đổi thành URDF trong khi được sử dụng.

Để hiểu cú pháp Xacro, hãy tạo một tệp mô tả mới trong thư mục urdf và đặt tên là mobile_robot.urdf.xacro. Toàn bộ tập tin nằm ở đây và sau đây là giải thích cho các phần chính. Hai dòng đầu tiên tương tự như mobile_robot.urdf, ngoại trừ trong thẻ robot, có dòng xmlns:xacro="http://www.ros.org/wiki/xacro" dùng để định nghĩa không gian tên (namespace) XML cho tệp để có thể đọc được các thẻ (tag) đúng cách.

<?xml version="1.0"?>
<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="mobile_robot">

Có ba đặc tính chúng ta có thể sử dụng với Xacro: property, math, and macro.

Xacro Property

Trong xacro, bạn có thể định nghĩa một hằng số làm một property (thuộc tính) và dùng nó khi nào cần. Ví dụ: trong đoạn mã bên dưới, ba thuộc tính có tên: chiều cao, chiều rộng và chiều sâu (height, width, depth) được tạo với các giá trị lần lượt là 0.4, 0.4 và 0.1 (mét). Sau đó, chúng được sử dụng trong cả thẻ visual và thẻ collision trong liên kết (link) chassis. Để sử dụng property chỉ cần đặt nó vào trong dấu đô la và dấu ngoặc nhọn, ví dụ: <box size="${height} ${width} ${depth}"/>. visual và collision là gì sẽ được giải thích ở bên dưới.

<xacro:property name="height" value="0.4" /> <!-- [m] -->
<xacro:property name="width" value="0.4" /> <!-- [m] -->
<xacro:property name="depth" value="0.1" /> <!-- [m] -->

<!--Chassis-->
<link name="chassis">
  <visual>
    <geometry>
      <box size="${height} ${width} ${depth}"/>
    </geometry>
  </visual>
  <collision>
    <geometry>
      <box size="${height} ${width} ${depth}"/>
    </geometry>
  </collision>
  <inertial>
    <mass value="1.0"/> <!-- [kg] -->
    <inertia ixx="0.014167" ixy="0.0" ixz="0.0" iyy="0.026667" iyz="0.0" izz="0.014167"/>
  </inertial>
</link>

Xacro Macro và Math

Bây giờ đến các bánh xe. Chúng ta đã tạo 4 mô tả riêng cho 4 bánh xe trong URDF từ chương trước, nhưng bây giờ chỉ cần dùng 1 macro để mô tả một bánh xe chung và sau đó sử dụng các tham số để định nghĩa 4 bánh xe sau trong 4 dòng. Bạn có thể coi việc viết macro giống như tạo một hàm với các đối số.

<xacro:property name="wheel_height" value="0.04" /> <!-- [m] -->
<xacro:property name="wheel_radius" value="0.06" /> <!-- [m] -->

<!-- Wheel macro-->
<xacro:macro name="wheel" params="name reflect_x reflect_y reflect_r reflect_axis">

  <!-- Wheel link -->
  <link name="${name}_wheel">
    <visual>
      <geometry>
        <cylinder length="${wheel_height}" radius="${wheel_radius}"/>
      </geometry>
      <material name="blue"/>
    </visual>
    <collision>
      <geometry>
        <cylinder length="${wheel_height}" radius="${wheel_radius}"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.3"/>  <!-- [kg] -->
      <inertia ixx="0.00031" ixy="0.0" ixz="0.0" iyy="0.00031" iyz="0.0" izz="0.00054"/>
    </inertial>
  </link>

  <!-- Wheel joint -->
  <joint name="${name}_wheel_joint" type="continuous">
    <parent link="chassis"/>
    <child link="${name}_wheel"/>
    <origin xyz="${reflect_x*height/2} ${reflect_y*(width/2+0.025)} 0" rpy="${reflect_r*1.5707} 0 0"/>
    <axis xyz="0 0 ${reflect_axis}"/>
  </joint>
</xacro:macro>

Trong đoạn code trên, macro bánh xe (wheel) được định nghĩa với với 5 đối số: name, reflect_x, reflect_y, reflect_r, và reflect_axis. name được sử dụng cho tên của liên kết và khớp. reflect_x, reflect_y, reflect_r, và reflect_axis được dùng cho vị trí của các khớp. Trong phần định nghĩa khớp nối (joint), bạn có thể thấy các phép toán cơ bản (cộng, trừ, nhân, chia) cũng có thể được sử dụng trong xacro, ví dụ: <origin xyz="${reflect_x*height/2} ${reflect_y*(width/2+0.025)} 0" rpy="${reflect_r*1.5707} 0 0"/>.

Khi đã có macro bánh xe này, việc khởi tạo các bánh xe rất đơn giản. Bên dưới là định nghĩa (trong 1 dòng duy nhất) của bánh xe đằng trước bên phải. Bạn có thể kiểm tra xem mô tả này có khớp với URDF cũ hay không bằng cách thay thế các đối số tương ứng trong xacro ở trên bằng các giá trị ở bên dưới. Và hãy tự thử thêm ba bánh còn lại nhé!

<xacro:wheel name="front_right" reflect_x="1" reflect_y="-1" reflect_r="1" reflect_axis="-1"/>

Những Thuộc Tính Va Chạm và Vật Lý

Những gì chúng ta làm cho đến nay là để mô tả các đặc điểm trực quan của robot, nghĩa là việc nó trông như thế nào. Tuy nhiên, để cho phép phát hiện va chạm và mô phỏng robot trong Gazebo một cách thực tế hơn, chúng ta cần thêm các thuộc tính khác.

Collision (Va Chạm)

Bạn có thể đã thấy các thẻ collision trong các liên kết chassis và wheel. Các thuộc tính của collision là (trích dẫn trực tiếp từ ROS wiki):

• collision là phần tử con trực tiếp của link, ở cùng cấp độ với thẻ visual.

• Hình dạng (shape) của collision được định nghĩa bằng thẻ geometry giống như cách thực hiện trong thẻ visual.

Ở đây, các collision có dạng hình học (geometry) giống hệt như các link. Điều này đúng trong nhiều trường hợp nhưng nếu robot của bạn có các hình dạng phức tạp hơn hoặc nếu bạn muốn thể tích của collision to hơn để đảm bảo an toàn thì chúng phải được điều chỉnh cho phù hợp.

Các Thuộc Tính Vật Lý

Trong các nền tảng mô phỏng 3D như Gazebo sẽ luôn có các công cụ (gọi là physical engine) để mô phỏng các đặc tính vật lý trong thế giới thực như trọng lực, ma sát, độ cứng, v.v. Do đó, chúng ta cũng cần thêm một số thuộc tính vật lý quan trọng vào URDF của mình. Một trong số đó là quán tính. Mọi phần tử liên kết được mô phỏng đều cần một thẻ quán tính mà bạn có thể thấy trong các link khung (chassis) và bánh xe (wheel) ở trên. Nó là một thành phần con của thẻ link và cung cấp hai thông tin: mass, khối lượng (tính bằng kilôgam) và inertia, mômen quán tính. Dành cho những bạn chưa biết "Momen quán tính, ký hiệu là I, là một đại lượng vật lý đặc trưng cho mức quán tính của các vật thể trong chuyển động quay, tương tự như khối lượng trong chuyển động thẳng" (nguồn).

inertia được xác định bởi một ma trận 3x3 nhưng ma trận đối xứng nên nó có thể được biểu diễn bằng 6 phần tử (in đậm).

Đối với các hình dạng đơn giản (hình hộp, hình trụ, hình cầu) như trong robot di động của chúng ta, ma trận quán tính có thể được tính bằng cách sử dụng các công thức từ danh sách này. Bảng bên dưới có chỉ ra công thức tính ma trận quán tính cho khung (hình hộp) và bánh xe (hình trụ). Bạn có thể thay các giá trị vào và tính xem có khớp với mã mô tả ở trên hay không. Đối với các mô hình phức tạp hơn, thông tin này có thể được trích xuất trực tiếp từ phần mềm 3D như MeshLab.

Có thể thêm nhiều đặc tính vật lý khác như ma sát, độ cứng và giảm chấn (chi tiết hơn tại đây). Tuy nhiên, vì chúng ta muốn mô phỏng trong Gazebo nên có thể thêm các thuộc tính này bằng thẻ gazebo. Để cho đơn giản, ở đây mình chỉ dùng thẻ material (vật liệu) màu xanh lam cho bánh xe nhưng bạn có thể thêm nhiều thành phần khác (chi tiết tại đây) để mô phỏng chân thực hơn.

  <gazebo reference="${name}_wheel">
    <material>Gazebo/Blue</material>
  </gazebo>

Khởi động và Điều Khiển Robot

Để điều khiển mobile robot của chúng ta trong Gazebo, bạn cần thêm hai thứ nữa vào tệp Xacro. Đầu tiên, mọi khớp truyền động, tức là tất cả các khớp bánh xe trong trường hợp của chúng ta, cần thẻ <transmission> bên trong macro wheel như bên dưới.

  <!-- Adding transmission to wheels -->
  <transmission name="${name}_wheel_trans">
    <type>transmission_interface/SimpleTransmission</type>
    <actuator name="${name}_wheel_motor">
      <mechanicalReduction>1</mechanicalReduction>
    </actuator>
    <joint name="${name}_wheel_joint">
      <hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
    </joint>
  </transmission>

Thứ hai, plugin gazebo_ros_control được thêm vào để phân tích cú pháp các thẻ tranmission và tải các giao diện phần cứng và trình quản lý bộ điều khiển thích hợp trong gazebo.

Launch File

Xacro đã hoàn tất và để khởi chạy nó, hãy tạo một tệp launch khác có tên drive_robot.launch. Tệp đầy đủ nằm ở đây và mình đã thêm comment vào mỗi dòng để giải thích ý nghĩa của chúng nhưng nếu bạn vẫn chưa rõ về bất kỳ điều gì, hãy nhắn mình bằng comment dưới bài viết này.

Một điều quan trọng cần lưu ý là drive_robot.launch này cần 2 tệp (có thể được tải về tại đây và đặt trong thư mục config):

• diffdrive.yaml bao gồm các cấu hình của diff_drive_controller (một trong nhiều bộ điều khiển mà ROS cung cấp và nó được sử dụng đặc biệt để tính toán vận tốc góc trái và phải cho rô-bốt 2 hoặc 4 bánh (bạn có thể tìm thêm chi tiết tại đây)).

• gazebo_ros_control_params.yaml chứa các cài đặt cho control trong Gazebo.

Điều Khiển Robot Trong Gazebo

Mở 2 terminal, trong cái đầu tiên chạy tệp drive_robot.launch:

roslaunch ros_mobile_robot drive_robot.launch

Đợi vài giây cho Gazebo được tải xong.

Trong terminal thứ hai, chạy package rqt_robot_steering cung cấp GUI (giao diện) để điều khiển robot. Về cơ bản, nó cho phép bạn thay đổi vận tốc tuyến tính và tốc độ góc được publish tới topic /robot_diff_drive_controller/cmd_vel để điều khiển rô-bốt. Nếu tên topic không phải là /robot_diff_drive_controller/cmd_vel, hãy gõ lại cho đúng.

rosrun rqt_robot_steering rqt_robot_steering

Thay đổi vận tốc tuyến tính và góc trong GUI để điều khiển robot:

Nếu bạn đang sử dụng máy ảo thì có thể thấy rằng mô phỏng bị lag. Đó là bởi vì Gazebo rất nặng, nếu bạn chạy nó trên máy tính chạy Ubuntu gốc và có card đồ họa tốt thì nó sẽ chạy mượt hơn.

Có thú vị khi thấy robot di chuyển không? Mình cá là có. Bạn đã đi một chặng đường dài và đã làm rất tốt! Chương tiếp theo sẽ là chương cuối của loạt bài này, trong đó bạn sẽ kết hợp mọi thứ bạn đã học được cho đến nay để điều khiển robot bằng cử chỉ tay của mình. See you there!

Xacro

In the last chapter, we created a URDF to describe all the links and joints of a mobile robot. However, you may notice several redundancies in this URDF, for example, the 4 wheels have almost identical components (except for the name, position, and orientation). For a more complex robot, there will be many more repeated components making the URDF both cumbersome and difficult to maintain. That's why Xacro was introduced. Xacro stands for XML Macro which allows you to use macros in a URDF to increase modularity and reduce redundancy. Note that Xacro is not an alternative to URDF but just another way of writing it because in the end a Xacro will be converted to URDF (automatically) while being loaded.

To understand Xacro syntax, let's create a new robot description file in urdf folder and name it mobile_robot.urdf.xacro. The full file is located here and below is the explanation for the main parts. The first two lines are similar to the mobile_robot.urdf, except in the robot tag, there is the line xmlns:xacro="http://www.ros.org/wiki/xacro" which basically defines XML namespace for the file to parse properly.

<?xml version="1.0"?>
<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="mobile_robot">

There are three shortcuts we can use with Xacro: property, math, and macro.

Xacro Property

In xacro, you can define a constant as a property and reuse it when needed. For example, in the snippet below three properties with names: height, width, and depth are defined with values 0.4, 0.4, and 0.1 (meter) respectively. They are then used in both visual and collision tags in the chassis link. The way you use a property is simply by putting it in dollar and curly bracket, for instance, <box size="${height} ${width} ${depth}"/>. The collision and inertial parts will be explained later in this post.

<xacro:property name="height" value="0.4" /> <!-- [m] -->
<xacro:property name="width" value="0.4" /> <!-- [m] -->
<xacro:property name="depth" value="0.1" /> <!-- [m] -->

<!--Chassis-->
<link name="chassis">
  <visual>
    <geometry>
      <box size="${height} ${width} ${depth}"/>
    </geometry>
  </visual>
  <collision>
    <geometry>
      <box size="${height} ${width} ${depth}"/>
    </geometry>
  </collision>
  <inertial>
    <mass value="1.0"/> <!-- [kg] -->
    <inertia ixx="0.014167" ixy="0.0" ixz="0.0" iyy="0.026667" iyz="0.0" izz="0.014167"/>
  </inertial>
</link>

Xacro Macro & Math

Now comes the wheels. Remember we have 4 separate descriptions for 4 wheels in the URDF from the last chapter? Here we can simply use a macro to describe a general wheel only once and use the parameters to define each wheel later in one line. You can think of writing a macro as creating a function with arguments.

<xacro:property name="wheel_height" value="0.04" /> <!-- [m] -->
<xacro:property name="wheel_radius" value="0.06" /> <!-- [m] -->

<!-- Wheel macro-->
<xacro:macro name="wheel" params="name reflect_x reflect_y reflect_r reflect_axis">

  <!-- Wheel link -->
  <link name="${name}_wheel">
    <visual>
      <geometry>
        <cylinder length="${wheel_height}" radius="${wheel_radius}"/>
      </geometry>
      <material name="blue"/>
    </visual>
    <collision>
      <geometry>
        <cylinder length="${wheel_height}" radius="${wheel_radius}"/>
      </geometry>
    </collision>
    <inertial>
      <mass value="0.3"/>  <!-- [kg] -->
      <inertia ixx="0.00031" ixy="0.0" ixz="0.0" iyy="0.00031" iyz="0.0" izz="0.00054"/>
    </inertial>
  </link>

  <!-- Wheel joint -->
  <joint name="${name}_wheel_joint" type="continuous">
    <parent link="chassis"/>
    <child link="${name}_wheel"/>
    <origin xyz="${reflect_x*height/2} ${reflect_y*(width/2+0.025)} 0" rpy="${reflect_r*1.5707} 0 0"/>
    <axis xyz="0 0 ${reflect_axis}"/>
  </joint>
</xacro:macro>

In the code above, the wheel macro is defined with 5 arguments: name, reflect_x, reflect_y, reflect_r, and reflect_axis. name is used for the link and joint names. reflect_x, reflect_y, reflect_r, and reflect_axis are used for the position of the joints. In the joint definition, it is shown how basic math operations can also be used in a xacro, e.g. <origin xyz="${reflect_x*height/2} ${reflect_y*(width/2+0.025)} 0" rpy="${reflect_r*1.5707} 0 0"/>.

Using this wheel macro, for example, the definition of the front right wheel looks like below. You can check if this description matches the old URDF by replacing the corresponding arguments in the xacro above with the values. Also, you should try to make the three remaining wheels by yourself.

<xacro:wheel name="front_right" reflect_x="1" reflect_y="-1" reflect_r="1" reflect_axis="-1"/>

Collision and Physical Properties

All the works we have done so far are for describing the visual characteristics of the robot meaning how it looks like. However, to enable collision detection and to simulate the robot in Gazebo more realistically, we need to add collision and physical properties.

Collision

You may already see the collision tags in the chassis and wheel links. The properties of collision are (quoted directly from the ROS wiki):

• The collision element is a direct subelement of the link object, at the same level as the visual tag.

• The collision element defines its shape the same way the visual element does, with a geometry tag. The format for the geometry tag is exactly the same here as with the visual.

• You can also specify an origin in the same way as a subelement of the collision tag (as with the visual).

You may already notice that the collisions have exactly the same geometry as the links. This is true in many cases but if your robot has more complicated meshes or if you want to enlarge the geometry to ensure safety, then the collisions must be adjusted accordingly.

Physical Properties

In a simulated platform like Gazebo, there is a physics engine that emulates real-world physical properties such as gravity, friction, stiffness, etc. Therefore, we also need to add several important properties to our URDF. One of them is inertia. Every link element being simulated needs an inertial tag which you already can see in the chassis and wheel links above. It is a subelement of a link tag and gives two types of information: mass (in kilogram) and moments of inertia. For those of you who do not know "Moment of inertia, denoted by I, measures the extent to which an object resists rotational acceleration about a particular axis, it is the rotational analogue to mass (which determines an object's resistance to linear acceleration). The moments of inertia of a mass have units of dimension ML²([mass] × [length]²)" (source).

The inertia element is specified by a 3x3 matrix but can be represented by 6 elements since the matrix is symmetrical.

For simple shapes (box, cylinder, sphere) like in our mobile robot, the inertia matrix can be calculated using the formulas from this list of moment of inertia tensors. In the table below, you can calculate the inertia matrix by replacing the parameters in the formulas with values in the description code above. For more complicated meshes, this information can be extracted directly from 3D software such as MeshLab.

There are more physical properties such as friction, stiffness, and damping that you can add (more detail here). However, as we are only working with the simulation in Gazebo, we can use the gazebo tag to do it. For simplicity, I just use the material color Blue here, but you can add more properties (listed here) to make the simulation even more realistic.

  <gazebo reference="${name}_wheel">
    <material>Gazebo/Blue</material>
  </gazebo>

Launch and Drive the Robot

To drive our mobile robot in Gazebo, there are two more things you need to add to the Xacro file. First, every actuating joint, which is all the wheel joints in our case, requires a <transmission> block like below (since this is inside the wheel macro, the name argument is used).

  <!-- Adding transmission to wheels -->
  <transmission name="${name}_wheel_trans">
    <type>transmission_interface/SimpleTransmission</type>
    <actuator name="${name}_wheel_motor">
      <mechanicalReduction>1</mechanicalReduction>
    </actuator>
    <joint name="${name}_wheel_joint">
      <hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
    </joint>
  </transmission>

Second, the gazebo_ros_control plugin is added to parse the transmission tags and load the appropriate hardware interfaces and controller manager in Gazebo.

<!-- Link Gazebo and ROS -->
<gazebo>
  <plugin name="gazebo_ros_control" filename="libgazebo_ros_control.so">
    <robotNamespace>/</robotNamespace>
  </plugin>
</gazebo>

Launch File

The Xacro is now complete and in order to launch it, create another launch file called drive_robot.launch. The full file is located here and I already added as many comments as possible to explain the information inside this file but if you are still unclear about anything, just leave me a message.

One important note is that this drive_robot.launch loads 2 files (can be downloaded from here and put in a config folder):

• diffdrive.yaml which includes the configurations of the diff_drive_controller (differential drive controller), one of many controllers ROS provides and it is specifically used to calculate left and right angular velocities for wheel robots (more details can be found here).

• gazebo_ros_control_params.yaml includes the configurations of controllers in Gazebo.

Drive the Robot in Gazebo

Open 2 terminals. In the first one, launch the file drive_robot.launch:

roslaunch ros_mobile_robot drive_robot.launch

Wait a few seconds for Gazebo to be fully loaded.

In the second terminal, run the rqt_robot_steering package which provides a GUI to steer robots. It basically lets you change the linear and angular velocities which are published to the topic /robot_diff_drive_controller/cmd_vel to drive the robot. If the topic name in the box is not /robot_diff_drive_controller/cmd_vel the same, manually edit it.

rosrun rqt_robot_steering rqt_robot_steering

Change the linear and angular velocities in the GUI to steer the robot:

If you are using a virtual machine, you may notice that the simulation is not so responsive. It is because the simulation needs a lot of computation power. If you run this on a native Linux computer with a good graphics card, it should work better.

Is it exciting to see your robot moves? I bet it is. You have come a long way, very well done! The next chapter will be the last post of this series in which you will combine everything you have learned so far to control the robot with your hand gestures. See you there!

Mô tả Robot

Để mô phỏng rô bốt trong ROS, bạn cần mô tả nó trong trong một file URDF (Unified Robot Description Format). URDF về cơ bản là một tệp XML cho phép bạn mô tả các thuộc tính vật lý quan trọng của rô-bốt chẳng hạn như link (liên kết), joint (khớp nối), hình dạng, màu sắc, collision (va chạm), v.v. Trong hình ví dụ bên dưới, phía bên trái là hình ảnh của một Universal Robot - UR5 trong rviz và phía bên phải hiển thị URDF của nó, trong đó tất cả các thành phần (liên kết và khớp nối) được định nghĩa bằng cách sử dụng tag (tương tự như tệp package.xml và tệp launch từ các chương trước). Phiên bản URDF hoàn chỉnh của rô-bốt UR5 tất nhiên dài hơn nhiều so với phiên bản tối giản bên dưới nhưng đây chỉ giúp bạn hình dung định dạng của một file URDF ra sao.

Tạo URDF cho robot di động

Trong phần này, bạn sẽ học cách tạo URDF cho một robot di động (mobile robot) đơn giản và hiển thị nó trong rviz (sau đó là Gazebo). Nhắc để bạn nhớ, ở phần cuối cùng của loạt bài này, bạn có thể sử dụng cử chỉ tay của mình để điều khiển robot này. Cool huh? Như mọi khi, mình cố gắng giữ các bước đơn giản nhất có thể và luôn khuyến khích bạn đọc và tự làm theo hướng dẫn thay vì copy/paste. Nếu bạn muốn tham khảo thì cả package này nằm tại đây.

1. Tạo một ROS package mới và đặt tên là ros_mobile_robot. Sau đó, build catkin workspace.

    cd ~/catkin_ws/src/
    catkin_create_pkg ros_mobile_robot
    cd ..
    catkin build
   

2. Trong package mới, tạo 2 thư mục có tên: urdf và launch.

   

3. Trong thư mục launch, tạo một tệp tên mobile_robot.launch mà bạn sẽ dùng để gọi rviz để hiển thị URDF mà bạn sẽ viết. Nội dung của tệp này như sau:

    <?xml version="1.0"?>
    <launch>
      <arg name="config" default="urdf"/>
      <param name="robot_description" textfile="$(find ros_mobile_robot)/urdf/mobile_robot.urdf" />
      <node name="joint_state_publisher" pkg="joint_state_publisher" type="joint_state_publisher" />
      <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
      <node name="rviz" pkg="rviz" type="rviz" required="true" args="-d $(find ros_mobile_robot)/urdf/$(arg config).rviz"/>
    </launch>
   

   Giải thích: Dòng đầu tiên <?xml version="1.0"?> là một khai báo XML (XML declaration) dùng để chỉ định phiên bản XML. Bên trong tag launch, một đối số (argument) config được định nghĩa với giá trị mặc định là một chuỗi kí tự "urdf". Sau đó, một tham số (parameter) robot_description được tạo và textfile="$(find ros_mobile_robot)/urdf/mobile_robot.urdf" chỉ đơn giản là đường dẫn đến URDF (tạo ở bước 5). Tiếp theo, hai node joint_state_publisher và robot_state_publisher được gọi để theo dõi các trạng thái của robot chẳng hạn như vị trí & vận tốc của từng khớp và sự chuyển đổi (transform) giữa các liên kết. Cuối cùng, rviz được gọi bằng cách khởi chạy node rviz. Nếu có một tệp .rviz (fiel lưu các thiết lập của rviz) tồn tại trong $(find ros_mobile_robot)/urdf/$(arg config).rviz, nó sẽ được sử dụng. Nếu không, các thiết lập mặc định của rviz được khởi chạy. Vì đối số config theo mặc định là urdf, nên $(arg config).rviz bằng với urdf.rviz (ở bước 6 bạn sẽ biết cách có được file urdf.rviz này).

4. Trong thư mục urdf, tạo một tệp có tên mobile_robot.urdf và thêm các dòng sau

    <?xml version="1.0"?>
    <robot name="my_robot">
   
     <!-- Tất cả các liên kết và khớp nối được khai báo ở đây -->
   
    </robot>
   

   Một URDF luôn bắt đầu và kết thúc bằng thẻ robot. Bây giờ chúng ta sẽ thêm tất cả các mô tả về liên kết và khớp nối vào giữa <robot name="my_robot"> và </robot>.

   Nhưng thực chất liên kết (link) và khớp (joint) là gì? Các liên kết là các phần cứng của robot (giống như xương trong cơ thể chúng ta) và chúng được kết nối với nhau bằng các khớp. Khớp nối là bộ phận của rô-bốt cho phép chuyển động giữa các liên kết.

   

   Trong hình trên, phía bên trái là một robot có năm liên kết và hai khớp còn phía bên phải là URDF của nó. Để mô tả cụ thể các liên kết và khớp nối, bạn cần điền vào chỗ ba chấm mà bạn sẽ biết trong các bước tiếp theo.

5. Thẻ <link> được dùng để thêm liên kết. Thông thường người ta tạo một liên kết làm gốc (origin) cho toàn bộ robot. Đây chỉ đơn giản là một liên kết trống (vì nó chỉ có tên và không có thông tin gì khác). Mình gọi nó là base_link. Thêm những dòng này vào giữa <robot name="my_robot"> và </robot>.

          <link name="base_link">
          </link>
   

   Tiếp theo, tạo một liên kết tên chassis (khung xe), về cơ bản là một hộp có kích thước (dài x rộng x cao) là 0.4 x 0.4 x 0.1 mét.

          <link name="chassis">
            <visual>
              <geometry>
                <box size="0.4 0.4 0.1"/>
              </geometry>
            </visual>
          </link>
   

   Thẻ <link> có ba thành phần: <visual> để mô tả các thuộc tính trực quan (hình dạng của liên kết), <collision> để mô tả thể tích va chạm (để kiểm tra xem các liên kết có va vào nhau không) và <inertial > để xác định mômen quán tính (một thuộc tính vật lý quan trọng cho mô phỏng, ví dụ: trong Gazebo). Sơ đồ bên dưới hiển thị tất cả các thành phần con của <link>. Trong đoạn mã trên, chỉ <visual> và phần tử con của nó <geometry> (và phần tử "cháu" <box>) được sử dụng để tạo một hộp có kích thước 0.4 x 0.4 x 0.1 mét (dài x rộng x chiều cao). <collision> và <inertial> sẽ được thêm vào sau.

   

   Tiếp theo, chúng ta cần thêm một khớp giữa base_link (liên kết mẹ) và chassis (liên kết con). Đây là một khớp tĩnh (fixed) vì không có chuyển động.

          <joint name="chassis_joint" type="fixed">
            <parent link="base_link"/>
            <child link="chassis"/>
          </joint>
   

6. Để hiển thị những gì bạn vừa tạo, hãy chạy mobile_robot.launch từ bước 3 bằng cách chạy lệnh sau trong một terminal:

    roslaunch ros_mobile_robot mobile_robot.launch
   

   Lệnh này mở rviz lên nhưng ban đầu sẽ không có gì hện ra. Để xem mô hình rô-bốt của bạn, hãy làm theo các bước sau (xem ảnh bên dưới): Đầu tiên, thay đổi Fixed Frame thành base_link thay vì map. Sau đó, nhấp vào nút Add và chọn RobotModel trong danh sách. Nhấp vào OK và bạn sẽ thấy một chiếc hộp ở giữa cửa sổ bên phải. Dùng chuột, bạn có thể xoay (nhấp chuột trái), di chuyển X/Y (nhấp chuột giữa) và thu phóng (nhấp chuột phải hoặc con lăn chuột).

   

   Lưu tất cả các cấu hình bạn vừa chỉnh sửa trong rviz vào một tệp bằng cách đi tới File > Save Config As hoặc sử dụng Ctrl+Shift+S. Sau đó, lưu file với tên urdf.rviz trong thư mục ~/catkin_ws/src/ros_mobile_robot/urdf. Đường dẫn đến urdf.rviz này trùng với đường dẫn trong tệp launch ở bước 3, vì thế lần sau khi bạn khởi chạy nó, bạn sẽ không cần phải thêm RobotModel và thay đổi lại Fixed Frame nữa.

   

7. Khung xe đã xong! Giờ hãy thêm bánh xe. Dưới đây là một ví dụ cho thấy cách mô tả bánh trước bên phải (front_wheel_right) và khớp nối của nó với khung xe (chassis).

          <material name="blue">
            <color rgba="0 0 0.8 1"/>
          </material>
   
          <!--right front wheel-->
          <link name="front_wheel_right">
            <visual>
              <geometry>
                <cylinder length="0.04" radius="0.06"/>
              </geometry>
              <material name="blue"/>
            </visual>
          </link>
   
          <joint name="front_wheel_right_joint" type="continuous">
            <parent link="chassis"/>
            <child link="front_wheel_right"/>
            <origin xyz="0.2 -0.225 0" rpy="1.5707 0 0"/>
            <axis xyz="0 0 -1"/>
          </joint>
   

   Giải thích: Đầu tiên, một tag material với màu xanh lam (blue) được tạo (để sơn bánh xe). Liên kết bánh xe khá giống với khung xe chỉ khác là hình trụ thay vì hình hộp. Hình trụ có chiều dài 0.04 m và bán kính 0.06 m. Bánh xe có màu xanh lam (để dễ phân biệt với khung xe). Mối nối giữa khung xe (liên kết mẹ) và bánh trước bên phải (liên kết con) là khớp động (continuous), tức là khớp xoay liên tục quanh trục và không có giới hạn trên và dưới). Thông tin về các loại liên kết khác trong URDF có tại đây.

   

   Thẻ <origin> được dùng để mô tả vị trí và hướng của liên kết con đối với liên kết mẹ. Trong hình trên, bạn có thể thấy rằng vị trí của bánh xe so với gốc là 0.2 m ở X, -0.225 m ở Y và 0 m ở Z. Nó cũng cần xoay 90° (hoặc 1.5707 radian) ngược chiều kim đồng hồ dọc theo trục X của khung xe nếu không thì trục Z (màu xanh lam) của bánh xe sẽ bị hướng lên trên (xem hình ảnh bên dưới). Nếu bạn muốn trực quan hóa các trục, bạn nên nhấp vào nút Add và chọn TF (viết tắt của từ transformation) nằm ngay bên dưới RobotModel trong hộp thoại. Ở đây, X là Đỏ, Y là Lục và Z là Lam (hay XYZ <-> RGB).

   

   Cuối cùng, thẻ <axis> xác định trục quay của bánh là trục Z. Vì vậy, nó được đặt thành xyz="0 0 -1" vì chỉ có chuyển động trên trục Z. Có thể bạn thắc mắc tại sao là -1 thay vì 1. Đó là vì quy ước chung về hướng quay là cùng chiều kim đồng hồ là âm và ngược chiều kim đồng hồ là dương. Trong trường hợp này, khi muốn robot di chuyển về phía trước, các bánh xe bên phải sẽ di chuyển theo chiều kim đồng hồ dọc theo trục Z của nó, nghĩa là âm, do đó -1. Mặt khác, các bánh xe bên trái di chuyển ngược chiều kim đồng hồ khi robot di chuyển về phía trước để chúng có Z dương hay +1 (xem hình ảnh bên dưới).

   

8. Bạn hãy cố gắng làm theo ý tưởng trên và tự thêm 3 bánh xe còn lại. Một bài tập khác dành là thêm một hộp nhỏ ở phí trước của rô-bốt để bạn biết đầu của nó ở đâu. Bạn có thể tham khảo mã nguồn tại đây. Sau đó, khởi chạy lại mobile_robot.launch và kết quả cuối cùng sẽ như sau:

   

Và thế là xong! Bây giờ bạn đã biết cách mô tả một rô-bốt đơn giản bằng URDF và view nó trong rviz. Trong chương tiếp theo, mình sẽ chỉ cho bạn cách thêm nhiều thuộc tính vào file URDF để có thể mô phỏng và di chuyển robot trong Gazebo.

Robot Description

In order to visualize or simulate a robot in ROS, you need to describe it in a robot description file called URDF (Unified Robot Description Format). A URDF is basically an XML file that allows you to describe important physical properties of a robot such as links, joints, shapes, colors, collisions, etc. In the example below, on the left side you can see the visualization of a Universal Robot UR5 in rviz and the right side shows its (incomplete) URDF in which all components (links and joints, see step 4) are defined using tags (similar to package.xml and launch file from previous chapters). The complete URDF version of the UR5 robot is of course much longer than the one I show below but this is just to let you see its format.

Create URDF for a mobile robot

In this part, you will learn to create URDF for a simple mobile robot and view it in rviz (then later in Gazebo). Just as a reminder, at the end of this series, you can use your hand gesture to control this robot. Cool, huh? I try to keep it as simple as possible and as always encourage you to read the instruction and type by yourself instead of copy/paste. The original package is located here.

1. Create a new ROS package and name it ros_mobile_robot. Then build the workspace as well.

    cd ~/catkin_ws/src/
    catkin_create_pkg ros_mobile_robot
    cd ..
    catkin build
   

2. In the new package folder, make 2 new folders named: urdf and launch.

   

3. In the folder launch, create a launch file with the name mobile_robot.launch which you will use to call rviz to visualize the robot description you are going to write. The content of the launch file:

    <?xml version="1.0"?>
    <launch>
      <arg name="config" default="urdf"/>
      <param name="robot_description" textfile="$(find ros_mobile_robot)/urdf/mobile_robot.urdf" />
      <node name="joint_state_publisher" pkg="joint_state_publisher" type="joint_state_publisher" />
      <node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
      <node name="rviz" pkg="rviz" type="rviz" required="true" args="-d $(find ros_mobile_robot)/urdf/$(arg config).rviz"/>
    </launch>
   

   Explain: The first line <?xml version="1.0"?> is an XML declaration which is an optional indication of the version of XML. Inside the launch tag, an argument name config is defined with the default value as a string"urdf". Then, a parameter robot_description is created and textfile="$(find ros_mobile_robot)/urdf/mobile_robot.urdf" is simply the path to the URDF from step 5. Next, two nodes joint_state_publisher and robot_state_publisher are called to keep track of robot states such as the position & velocity of each joint and transformation between links. Finally, the rviz is called by launching the rviz package. If there is a .rviz file (which contains all the settings of rviz) existed in $(find ros_mobile_robot)/urdf/$(arg config).rviz, it will be loaded (otherwise, the default settings of rviz are launched). Since the argument config is by default urdf, this $(arg config).rviz equals to urdf.rviz. To get this urdf.rviz, see step 6.

4. In the folder urdf, create a file named mobile_robot.urdf and add the following lines

    <?xml version="1.0"?>
    <robot name="my_robot">
   
     <!--  All links and joints are declared here -->
   
    </robot>
   

   A URDF always starts and closes with the robot tag. From now on, we will write all the descriptions of links and joints between <robot name="my_robot"> and </robot>.

   But what are links and joints? Links are the rigid pieces of a robot (like bones in our body) and they are connected to each other by joints. Joints are parts of a robot that enable motions between connected links.

   

   In the image above, the left side is a simple robot that has five links and two joints while the right side is its URDF. To concretely describe the links and joints, you need to fill in ... between their tags which you will learn in the next steps.

5. A link can be added using the <link> tag. It is standard in ROS to have a link as the origin of the whole robot. This is simply an empty link and I call it base_link here. Add these lines between <robot name="my_robot"> and </robot>.

      <link name="base_link">
      </link>
   

   Next, define the chassis which is basically a box with dimensions (length x width x height) of 0.4 x 0.4 x 0.1 meters.

      <link name="chassis">
        <visual>
          <geometry>
            <box size="0.4 0.4 0.1"/>
          </geometry>
        </visual>
      </link>
   

   A <link> has three elements: <visual> for describing the visual properties (shape of the link), <collision> for describing collision volumes (to check if links collide), and <inertial> for defining the moment of inertia (a crucial physical property for realistic simulation, e.g. in Gazebo). The diagram below shows all the subcomponents of <link>. In the code above, only the <visual> and its child <geometry> (and its child <box>) is used to create a box with dimensions of 0.4 x 0.4 x 0.1 meters (length x width x height). The <collision> and <inertial> will be added later.

   

   Next, we need to add a joint between base_link (parent link) and chassis (child link) which is a fixed joint because there is no movement here.

      <joint name="chassis_joint" type="fixed">
        <parent link="base_link"/>
        <child link="chassis"/>
      </joint>
   

6. To visualize what you just created, launch the mobile_robot.launch from step 3 by:

    roslaunch ros_mobile_robot mobile_robot.launch
   

   This opens rviz but there is nothing to see at the beginning. In order to view your robot model, follow these steps (see the photo below): First, change the Fixed Frame to base_link instead of map. Then, click Add button and select RobotModel in the list. Click OK and you should see a box in the middle of the grid. With your mouse, you can rotate (left-click), move X/Y (middle-click), and zoom (right-click or mouse wheel).

   

   Save all the configurations you just edited in rviz to a file by going to File > Save Config As or using Ctrl+Shift+S. Then, save this as urdf.rviz in the folder ~/catkin_ws/src/ros_mobile_robot/urdf. The path to this urdf.rviz was already defined in the launch file from step 3 so the next time you launch it, you don't have to add the RobotModel, and change the Fixed Frame again.

   

7. The chassis is done! It's time to add wheels. Below is one example showing the descriptions of the right front wheel and its joint to the chassis look like.

      <material name="blue">
        <color rgba="0 0 0.8 1"/>
      </material>
   
      <!--right front wheel-->
      <link name="front_wheel_right">
        <visual>
          <geometry>
            <cylinder length="0.04" radius="0.06"/>
          </geometry>
          <material name="blue"/>
        </visual>
      </link>
   
      <joint name="front_wheel_right_joint" type="continuous">
        <parent link="chassis"/>
        <child link="front_wheel_right"/>
        <origin xyz="0.2 -0.225 0" rpy="1.5707 0 0"/>
        <axis xyz="0 0 -1"/>
      </joint>
   

   Explain: First, a material tag with blue color is created (to paint the wheel later). The wheel link is pretty similar to the chassis with the geometry now a cylinder instead of a box. The cylinder has a length of 0.04 m and a radius of 0.06 m. The wheel has the color blue (to be easily distinguished from the chassis). The joint between the chassis (parent link) and the right front wheel (child link) is a continuous joint (i.e. a continuous hinge joint that rotates around the axis and has no upper and lower limits). More types of joints in URDF can be found here.

   

   The <origin> is used to describe the position and orientation of the child link with respect to the parent link. In the image above, you can see that the wheel is 0.2 m in X, -0.225m in Y, and 0 m in Z. It also needs to rotate 90° (or 1.5707 radians) counter-clockwise along the X-axis of the chassis otherwise the Z-axis (in blue) of the wheel is pointing upward (see image below). If you want to visualize the axes, you should click on Add button and select TF (stands for transformation) which is right under the RobotModel in the dialog. Here, X is Red, Y is Green and Z is Blue (so XYZ <-> RGB).

   

   Finally, the <axis> tag defines the axis of rotation which is the Z-axis (of the wheel not the chassis) in this case. So it is set to xyz="0 0 -1" since there is only movement on Z-axis. You may wonder why -1 instead of 1. It is because the common convention for rotating direction is that clockwise is negative and counter-clockwise is positive. In this case, when I want the robot to move forward, the right wheels should move clockwise along its Z-axis meaning negative, hence -1. The left wheels, on the other hand, move counter-clockwise when the robot moves forward so they have positive Z or simply 1 (see image below).

   

8. Try to follow the idea above and add the other 3 wheels by yourself. Another exercise for you is to add a small box on the top front of the robot so you know where its head is. You can refer to the source code here. After that, launch the mobile_robot.launch again and the final result should look like this:

   

   And that's it! Now you know how to describe a robot by a URDF and visualize it in rviz. To make a robot look more professional like the UR5 above, you need to create a detailed mesh (CAD) file for each part which is of course not the purpose of this series. In the next chapter, I will show you how to add more properties to links and joints to be able to simulate (and move) the robot in Gazebo. Keep up the good work!

Công nghệ nhận diện cử chỉ tay (Hand Gesture Recognition)

Một hệ thống có thể hiểu cử chỉ tay của con người có vô vàn ứng dụng thực tế. Ví dụ như trong chế tạo rô-bốt, nó có thể giúp chuyển đổi nhận dạng cử chỉ thành tín hiệu điều khiển khiến rô-bốt.

Với sự phát triển gần đây của trí tuệ nhân tạo (AI), việc triển khai hệ thống đó dễ dàng hơn bao giờ hết. Trong chương này, mình muốn giới thiệu với bạn Mediapipe Hands là gói máy học (ML) mã nguồn mở của Google có thể giúp nhận dạng và theo dõi (track) bàn tay người bằng hình ảnh. Về cơ bản, Mediapipe kết hợp hai mô hình (model) học máy: một mô hình palm detection (nhận diện bàn tay) để tìm vị trí của bàn tay và một mô hình mốc (landmark) bàn tay để định vị chính xác 21 tọa độ khớp ngón tay từ vị trí tìm được ở palm detection (xem hình ảnh bên dưới). Nó được train (huấn luyện, đào tạo) với khoảng 30 nghìn dữ liệu thực có gắn nhãn (label) và chạy rất nhanh theo cách thức single-shot. Bạn có thể tìm hiểu thêm thông tin chi tiết về package này tại đây.

Các keypoint (điểm màu đỏ ở trong hình landmark bên trên) được nhận diện từ Mediapipe cần được chuyển đổi thành những hành động có ý nghĩa. Chẳng hạn như từ hình landmark bàn tay ở trên, hệ thống của chúng ta sẽ cho chúng ta biết trạng thái là "Open" vì tất cả các ngón tay đều đang được duỗi thẳng. Để làm được điều đó, cần phải có một model khác để phân loại (classify) các hành động. May mắn là đã có một chương trình có sẵn trên GitHub. Repository (kho lưu trữ) hand-gesture-recognition-mediapipe này chứa các tập lệnh Python giúp người dùng train và triển khai các model để nhận dạng dấu hiệu bàn tay và cử chỉ ngón tay. Mình đã dùng và biến nó thành một ROS package để bạn có thể sao chép (clone) và chạy ngay.

Cài đặt

Đầu tiên, cài đặt các phần phụ thuộc (dependencies) sau bằng cách sử dụng pip3 (hoặc conda nếu bạn dùng Anaconda):

• Mediapipe 0.8.1

• OpenCV 3.4.2 trở lên

• Tensorflow 2.3.0 trở lên

Dưới đây là ba câu lệnh dùng pip3 (bạn phải chạy riêng từng cái một):

pip3 install mediapipe
pip3 install opencv-python
pip3 install tensorflow

Sau đó, sao chép kho lưu trữ này vào thư mục catkin_ws/src:

cd ~/catkin_ws/src
git clone https://github.com/TrinhNC/ros_hand_gesture_recognition.git

Build package:

cd ~/catkin_ws
catkin build

Chạy Package

Sau khi build thành công, bạn có thể chạy demo. Nhớ source không gian làm việc (catkin workspace) bằng command source ~/catkin_ws/devel/setup.bash. Mở 2 terminal. Trong terminal thứ nhất, chạy image publisher (từ chương 7 và nhớ kết nối webcam với máy ảo nếu bạn đang sử dụng máy ảo):

roslaunch my_cam my_cam.launch

Nếu bạn thắc mắc về roslaunch có thể xem lại ở đây. Trong terminal thứ hai, chạy hand gesture recognition:

roslaunch ros_hand_gesture_recognition hand_sign.launch

Kết quả sẽ như thế này:

Trong GIF ở trên, FPS là viết tắt của Frame Per Second, là số lượng hình ảnh được xử lý mỗi giây, Right là tay phải và các từ sau đó (Turn Right, Forward, v.v.) là các nhãn (label) mà mình đã gán cho các dấu tay. Bạn có thể thay đổi các nhãn này bằng cách làm theo phần bên dưới.

Train mô hình nhận dạng dấu tay

Package hiện tại chỉ có thể phân loại được 6 dấu tay (6 lớp/classes) và mình đã gắn nhãn: Stop (Dừng), Go (Đi), Forward (Tiến), Backward (Lùi), Turn Right (Rẽ phải) and Turn Left (Rẽ trái) (xem hình ảnh bên dưới). Chúng sẽ được chuyển đổi thành tín hiệu điều khiển để di chuyển rô-bốt trong các chương sau. Nếu bạn muốn thay đổi hoặc thêm cử chỉ hoặc bạn phát hiện ra rằng trained model của mình chạy chưa tốt lắm thì bạn hoàn toàn có thể tự thu thập dữ liệu (collect data) và train lại.

Có hai jupyter notebook trong thư mục src/notebooks:

• keypoint_classification_EN.ipynb: tập lệnh đào tạo mô hình để nhận dạng ký hiệu tay.

• point_history_classification.ipynb: tập lệnh đào tạo mô hình để nhận dạng cử chỉ ngón tay (có nghĩa là mô hình sau khi đào tạo có thể phát hiện chuyển động của ngón tay của bạn chứ không chỉ là một dấu hiệu tĩnh như trong mô hình bên trên).

Ở trong ROS package hiện tại mình chỉ sử dụng mô hình keypoint classification vì ứng dụng của mình chỉ cần đến thế nhưng bạn có thể dễ dàng thay đổi nó để phù hợp với ứng dụng của bạn.

Trong ví dụ dưới đây, mình sẽ chỉ cho bạn cách thêm một dấu tay nữa. Giả sử chúng ta muốn thêm ký hiệu này✌️và đặt tên là "Hi". Lưu ý: Phần này không liên quan gì tới ROS package tạo ở phần trước nên bạn nhớ tắt chúng đi.

Trước hết, cài những thư viện dưới đây nếu bạn chưa có:

pip3 install -U tf-nightly
pip3 install -U scikit-learn
pip3 install -U matplotlib

Mở keypoint_classifier_label.csv trong thư mục src/model/keypoint_classifier. Ở đây có tất cả các nhãn (hiện có 6 lớp) và bạn cần thêm 'Hi' vào dòng cuối cùng như sau:

Stop
Go
Forward
Backward
Turn Right
Turn Left
Hi

Tiếp theo, bạn cần ghi (record) dữ liệu và thêm (append) vào tệp keypoint.csv trong thư mục src/model/keypoint_classifier. Nếu bạn mở tệp này, bạn sẽ thấy nó chứa 6410 dòng. Số đầu tiên trong mỗi dòng là class ID (số hiệu của lớp) tương ứng với danh sách trên, ví dụ: "Go" có ID 0, "Stop" có ID 1, "Forward" có ID 2, v.v. Sau đó là 42 số hoặc 21 cặp số biểu thị tọa độ của từng keypoint (tức các đốt ngón tay) đối với điểm gốc là cổ tay. Một điều cần lưu ý là ID trong hình bên dưới là ID của keypoint (từ 0 tới 20) khác với class ID (từ 0 tới 6).

Để ghi lại dữ liệu, hãy chạy tập lệnh app.py:

python3 app.py

Nhấn k trên bàn phím và bạn sẽ thấy dòng MODE: Logging Key Point xuất hiện. Sau đó, sử dụng tay phải của bạn để hiển thị dấu✌️. Nhấn và giữ số 6 (class ID của "Hi") bằng tay trái của bạn. Thao tác này sẽ liên tục thêm dữ liệu mới vào tệp keypoint.csv cho đến khi bạn nhả khóa. Bạn cũng có thể thử nhấn và nhả số 6 ngay lập tức và sẽ thấy trong file keypoint.csv có thêm một dòng mới ở cuối bắt đầu bằng số 6 và một danh sách các số tọa tiếp theo sau. Ngoài ra, trong quá trình ghi, nhớ di chuyển tay phải của bạn đến các vị trí khác nhau để làm cho dữ liệu đa dạng hơn.

Sau khi ghi khoảng 10-15 giây, dữ liệu sẽ sẵn sàng và bạn có thể dừng chương trình (bằng phím tắt Ctrl + C trong terminal). Mở notebook keypoint_classification_EN.ipynb. Chỉnh sửa dataset, model_save_path và tflite_save_path để khớp với đường dẫn của bạn. Thay đổi NUM_OF_CLASSES thành 7 thay vì 6: NUM_CLASSES = 7. Sau đó chạy notebook từ đầu đến cuối bằng cách ấn nút Run hoặc chạy từng dòng bằng phím tắt Shift + Enter. Quá trình training được thực hiện trong ô [13] và mất khoảng 2-3 phút. Sau đó, bạn có thể khởi chạy my_cam.launch và hand_sign.launch lại như trong Demo bên trên để xem kết quả.

Code

Tạo một tập lệnh Python mới trong thư mục my_cam và đặt tên cho nó là image_subscriber.py. Nếu bạn đã đọc và làm chương 7 thì code bên dưới sẽ thấy quen vì cấu trúc khá giống với publisher. Mình vẫn khuyên bạn nên làm theo phần giải thích bên dưới và tự code thay vì copy&paste.

#!/usr/bin/python3

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

def callback(image_msg):
    """This function is called to handle the subscribed messages

    Args:
        image_msg (Image): message type Image from sensor_msgs
    """
    try:
        cv_image = bridge.imgmsg_to_cv2(image_msg)
        cv2.imshow('ROS Image Subscriber', cv_image)
        cv2.waitKey(10)
    except CvBridgeError as error:
        print(error)

if __name__=="__main__":
    bridge = CvBridge()
    rospy.init_node("image_subscriber", anonymous=True)
    print("Subscribe images from topic /image_raw ...")

    image_subcriber = rospy.Subscriber("image_raw", Image, callback)

    try:
        # spin() simply keeps python from exiting until this node is stopped
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

Giải thích Code

Phần đầu tiên giống hệt như trong image_publisher.py và về cơ bản là để import tất cả các thư viện cần thiết.

#!/usr/bin/python3

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

Tiếp theo, một hàm callback được định nghĩa nhưng mình muốn giải thích hàm main trước và đến với hàm callback này sau. Tương tự như publisher, trong main bạn cần tạo một đối tượng CvBridge và khởi tạo một Node có tên image_subscriber.

if __name__=="__main__":
    bridge = CvBridge()
    rospy.init_node("image_subscriber", anonymous=True)
    print("Subscribe images from topic /image_raw ...")

Sau đó, một subscriber được khởi tạo bằng cách sử dụng hàm rospy.Subscriber("image_raw", Image, callback) trong đó image_raw là topic mà bạn muốn subscribe, Image là kiểu dữ liệu của image_raw và callback là một hàm sẽ luôn được gọi khi subscriber nhận message mới. Cuối cùng, rospy.spin() được gọi để giữ Node của bạn chạy liên tục cho đến khi nó bị dừng (ví dụ: bằng Ctrl + C).

    image_subcriber = rospy.Subscriber("image_raw", Image, callback)
    try:
        # spin() simply keeps python from exiting until this node is stopped
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

Hàm callback luôn được định nghĩa với message là tham số (argument) đầu tiên.

def callback(image_msg):

Bên trong callback, trước hết bạn cần chuyển ROS message image_msg sang định dạng của OpenCV (mình đặt tên nó ở đây là cv_image) bằng cách sử dụng hàm imgmsg_to_cv2. Sau đó, bạn có thể hiển thị hình ảnh bằng cách sử dụng hàm cv2.imshow. Hàm này có hai tham số: thứ nhất là tên cửa sổ (ở đây là ROS Image Subscriber) và thứ hai là hình ảnh (cv_image). Cuối cùng, cv2.waitKey(10) được sử dụng để delay trong một phần nghìn giây (ms) nhất định (ở đây là 10 mili giây) trước khi chuyển sang khung hình tiếp theo.

    try:
        cv_image = bridge.imgmsg_to_cv2(image_msg)
        cv2.imshow('ROS Image Subscriber', cv_image)
        cv2.waitKey(10)
    except CvBridgeError as error:
        print(error)

Chạy subscriber

Để chạy file Python này từ terminal, thì bạn cũng cần làm cho nó executable (có thể thực thi được) bằng cách nhấp chuột phải vào file và chọn Properties > Permissions và tích Allow executing file as program hoặc sử dụng lệnh sudo chmod +x image_subscriber.py. Sau đó, mở 3 terminal hoặc một terminator với 3 terminal nhỏ như bên dưới.

Trong terminal thứ nhất, chạy ROS Master:

roscore

Trong cái thứ hai, chạy image publisher (nhớ kết nối webcam với máy ảo nếu bạn dùng VMware):

rosrun my_cam image_publisher.py

Trong terminal thứ ba, chạy subscriber:

rosrun my_cam image_subscriber.py

Sau đó, bạn sẽ thấy một cửa sổ có tiêu đề ROS Image Subscriber hiện lên với hình ảnh truyền trực tiếp từ webcam của bạn giống như của mình trong ảnh trên.

Sau khi hoàn thành chương 7 và 8, giờ bạn đã biết cách code ROS publisher và subscriber. Bạn cũng biết cách lấy hình ảnh từ camera, một trong những cảm biến phổ biến nhất trong chế tạo robot. Trong chương tiếp theo, như đã hứa, mình sẽ giúp bạn sử dụng một trong những công cụ có sẵn để khai thác hình ảnh subscribed được thành những thông tin hữu ích thay vì chỉ xem chúng trên màn hình.

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/jade

Kết nối Camera trong VMWare

Nếu đang sử dụng máy ảo (Virtual Machine - VM), bạn cần đảm bảo rằng webcam được kết nối với máy ảo thay vì máy chủ. Trong VMWare Workstation Player, chọn Player > Manage > Virtual Machine Settings... hoặc Ctrl + D.

Chọn tab USB Controller và chọn USB 3.1 trong mục USB compatibility.

Sau đó, đi tới Removable Devices, chọn webcam của bạn (như của mình thì webcam có tên là Sunplus Innovation Integrated_Webcam_HD) và chọn Connect (Disconnect from host). Nhấp vào OK trên bất kỳ hộp thoại bật lên nào sau đó.

Nếu có lỗi hiện lên báo kết nối không thành công thì một mẹo nhỏ là lập tức chuyển sang máy chủ của bạn (trong trường hợp của mình là Windows) và mở webcam của bạn bằng app Camera từ Start. Sau đó quay trở lại máy ảo và bạn sẽ thấy một hộp thoại hiện lên hỏi chọn kết nối webcam với máy chủ hay với máy ảo (xem hình bên dưới). Chọn Connect to a virtual machine.

Cuối cùng, hãy kiểm tra xem kết nối có thực sự được thiết lập hay không bằng cách vào Player > Removeable Devices một lần nữa và bạn sẽ thấy một dấu tích bên cạnh webcam của mình. Nếu không, hãy làm lại các bước trên.

Tạo một image publisher

Đầu tiên, trong thư mục my_cam, hãy tạo một tệp mới với tên image_publisher.py. Toàn bộ code có sẵn tại đây nhưng mình thực sự khuyên bạn làm theo lời giải thích bên dưới và tự code.

Code

#!/usr/bin/python3
import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

def publish_image():
    """Capture frames from a camera and publish it to the topic /image_raw
    """
    image_pub = rospy.Publisher("image_raw", Image, queue_size=10)
    bridge = CvBridge()
    capture = cv2.VideoCapture("/dev/video0")

    while not rospy.is_shutdown():
        # Capture a frame
        ret, img = capture.read()
        if not ret:
            rospy.ERROR("Could not grab a frame!")
            break
        # Publish the image to the topic image_raw
        try:
            img_msg = bridge.cv2_to_imgmsg(img, "bgr8")
            image_pub.publish(img_msg)
        except CvBridgeError as error:
            print(error)

if __name__=="__main__":
    rospy.init_node("my_cam", anonymous=True)
    print("Image is being published to the topic /image_raw ...")
    publish_image()
    try:
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

Giải thích Code

Dòng đầu tiên được gọi là dòng shebang dùng để xác định vị trí của trình thông dịch (intepreter). Ở đây, Python3 (phiên bản Python mặc định trong Ubuntu 20) được sử dụng và nó nằm trong thư mục /usr/bin.

#!/usr/bin/python3

Tiếp đó, tất cả các thư viện cần thiết cần phải được import (liên kết). rospy là Python API để tạo các ứng dụng trong ROS bằng Python. cv2 là OpenCV, một thư viện mã nguồn mở dành cho thị giác máy tính. Ở ví dụ này chúng ta sẽ sử dụng opencv để đọc và hiển thị ảnh từ webcam. CvBridge được sử dụng để chuyển đổi giữa ROS Image message và OpenCV Image vì chúng không cùng một loại (type) dữ liệu. Cuối cùng, bạn cần import loại message Image (thuộc package sensor_msgs) vì dữ liệu được publish ở đây là hình ảnh.

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

Tiếp theo, tạo một hàm có tên publish_image. Trong hàm này, tạo một publisher tên image_raw có kiểu dữ liệu là Image mà mình đã nói ở trên và queue_size là 10 (kích thước của hàng đợi). Một ví dụ cho dễ hiểu khái niệm queue_size là nếu bạn publish hình ảnh ở tốc độ 20 Hz (hoặc 20 khung hình mỗi giây) nhưng queue_size của bạn bằng 10 thì chỉ có 10 hình ảnh được xử lý (đặt vào hàng đợi) trong khi 10 cái còn lại sẽ bị loại bỏ. Trong ví dụ của chúng ta thì bạn không phải quan tâm nhiều đến nó vì bạn chỉ phải xử lý một message. Đây là một bài viết hay về cách chọn queue_size thích hợp.

image_pub = rospy.Publisher("image_raw", Image, queue_size=10)

Tạo một object CvBridge:

bridge = CvBridge()

Tạo video capture object giúp bạn đọc hình ảnh từ webcam của mình. /dev/video0 là tên thiết bị. Nếu bạn sử dụng một máy ảnh ngoài mà không phải webcam tích hợp trong laptop thì tên này có thể khác. Bạn có thể kiểm tra bằng cách sử dụng lệnh sau: ls -ltrh /dev/video*. Trong trường hợp của mình, nó liệt kê cả /dev/video0 và /dev/video1 nhưng chỉ /dev/video0 hoạt động.

capture = cv2.VideoCapture("/dev/video0")

Sau đó, tạo một while loop. Vòng lặp này luôn kiểm tra xem Node có đang chạy hay không bằng cách check rospy.is_shutdown(). Nó bị ngắt nếu có gián đoạn, ví dụ như bạn dừng chương trình bằng cách sử dụng Ctrl + C. capture.read() trả về một biến boolean ret (True nếu ảnh được đọc chính xác và false nếu không) và một hình ảnh img. Ảnh này được mã hóa trong OpenCV ở định dạng 3 kênh (channel) Blue, Green và Red (hay BGR) và mỗi kênh là một ma trận (một mảng 2 chiều). Trong Phụ lục, bên dưới, mình giải thích chi tiết hơn cách một hình ảnh được mã hóa.

Nếu ret trả về False thì đã có lỗi (nhiều khả năng là không thể kết nối được với webcam). Bạn cần check trong terminal xem lỗi là gì và sửa. Trước khi có thể publish ảnh, bạn cần chuyển đổi nó thành ROS message dạng img_msg bằng hàm cv2_to_imgmsg (từ CvBridge) với mã hóa màu "bgr8"(để những subscriber biết thứ tự màu là gì, trong trường hợp này là blue-green-red và 8-bit). Cuối cùng, bạn dùng publisher image_pub mà bạn đã tạo để publish message img_msg bằng hàm publish.

    while not rospy.is_shutdown():
        # Capture a frame
        ret, img = capture.read()
        if not ret:
            rospy.ERROR("Could not grab a frame!")
            break
        # Publish the image to the topic image_raw
        try:
            img_msg = bridge.cv2_to_imgmsg(img, "bgr8")
            image_pub.publish(img_msg)
        except CvBridgeError as error:
            print(error)

Trong hàm main, trước tiên bạn khởi tạo một Node có tên là my_cam. Lưu ý: trong ROS, các Node được đặt tên duy nhất. Nếu hai Node có cùng tên được khởi tạo, thì Node khởi tạo trước sẽ bị tắt. Biến anonymous được đặt True để rospy sẽ chọn một tên duy nhất cho Node publisher của chúng ta (bằng cách thêm các số ngẫu nhiên vào cuối tên) để nhiều publihser có thể chạy đồng thời.

if __name__=="__main__":
    rospy.init_node("my_cam", anonymous=True)
    print("Image is being published to the topic /image_raw ...")
    publish_image()
    try:
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

Sau khi khởi tạo Node, hàm publish_image được gọi. Và bước cuối cùng là gọi rospy.spin(), thao tác này chỉ đơn giản là giữ Node của bạn không tắt cho đến khi Node bị dừng (ví dụ: bằng Ctrl + C). Và thế là xong! Publisher của bạn đã sẵn sàng để chạy.

Chạy Publisher

Để chạy image_publisher.py thì bạn phải làm cho nó execuatble (có thể thực thi) bằng cách sử dụng lệnh

sudo chmod +x image_publisher.py

hoặc nhấp chuột phải vào tệp, chọn Properties > Permissions > Allow executing files as program.

Sau đó, mở 2 terminal hoặc một terminator với 2 terminal. Trong terminal đầu tiên, chạy roscore để bắt đầu ROS Master. Trong terminal thứ hai, chạy rosrun my_cam image_publisher.py trong đó my_cam là tên gói và image_publisher.py là script. Một cách khác để chạy publisher là dùng roslaunch mình có đề cập ở phần Phụ lục bên dưới.

Hiển thị hình ảnh được publish

Bạn sẽ thấy đèn LED bên cạnh webcam sáng lên. Và nếu bạn mở một terminal khác và chạy: rostopic list, bạn sẽ thấy topic /image_raw được liệt kê. Bạn thậm chí có thể nhìn thấy những gì bên trong /image_raw bằng cách chạy lệnh này: rostopic echo /image_raw và nó sẽ in ra các mảng số đại diện cho hình ảnh. Để hiển thị hình ảnh, bạn cần viết một image subscriber (hay Người In Ấn trong ví dụ trước) mà chúng ta sẽ thực hiện trong chương tiếp theo TODO. ROS cũng cung cấp một công cụ để trực quan hóa các loại dữ liệu được publish trong đó có hình ảnh. Chạy rqt trong một terminal và một cửa sổ sẽ hiện ra. Tìm đến Plugin > Visualization > Image View, sau đó chọn /image_raw trong danh sách topic và bạn sẽ thấy hình ảnh trực tiếp từ webcam của bạn.

Phụ lục

Cách máy tính "nhìn" một bức ảnh

Trong thị giác máy tính, một bức ảnh thường được biểu thị bằng Mô hình màu RGB. RGB là viết tắt của Red, Green và Blue, 3 màu cơ bản mà từ đó bạn có thể tạo ra bất kỳ màu nào khác.

Mỗi kênh màu (color channel) được mã hóa trong một ma trận pixel (điểm ảnh). Nếu các pixel ở dạng 8 bit, thì giá trị của chúng nằm trong khoảng từ 0 đến 255 (hoặc 2^8 - 1). Trong ví dụ bên dưới, bạn có thể thấy cách một bức ảnh (với chiều cao 140 pixel và chiều rộng 140 pixel) được phân tách thành 3 kênh khác nhau và mỗi kênh thực chất là một ma trận 140x140. Các kênh này được kết hợp thành một ma trận 3D mà mỗi phần tử chứa các pixel Blue (Xanh lam), Green (Xanh lục), Red (Đỏ). Thứ tự BGR này là thứ tự màu mặc định của OpenCV và nó có thể khác với các thư viện khác.

Chạy Node bằng roslaunch

Ngoài rosrun, một cách phổ biến được dùng nhiều hơn để chạy Node là roslaunch. Những hạn chế của rosrun so với roslaunch:

• rosrun chỉ có thể chạy một lúc một Node từ một package trong khi roslaunch có thể chạy nhiều Node từ nhiều package.

• roslaunch tự khởi động roscore (nếu chưa có) còn rosrun thì không.

• Để dùng được roslaunch cần một tệp .launch và người dùng có thể tùy biến file này như gọi các launch file khác, hoặc thay đổi biến của các hàm, v.v trong khi rosrun không có lựa chọn này.

Một tệp .launch thực chất là một tệp XML nên cách tạo cũng khá dễ dàng. Đầu tiên bạn tạo một folder tên launch rồi tạo một file text đặt tên là my_cam.launch. Nội dung của file này như sau:

<launch>
    <arg name="camera_name" default="/dev/video0"/>
    <node name="my_webcam" pkg="my_cam" type="image_publisher_launch.py" output="screen">
        <param name="camera_name" type="string" value="$(arg camera_name)" />
    </node>
</launch>

Giải thích: Một tệp launch bắt đầu bằng tag <launch> và kết thúc bằng tag </launch>. Đầu tiên mình tạo một biến (argument) có tên camera_name và giá trị mặc định của nó là /dev/video0. Mình sẽ giải thích cách dùng của nó ở bên dưới. Khi muốn dùng biến này trong launch file thì gọi nó bằng $(arg camera_name) như ở dòng thứ 4. Dòng tiếp theo định nghĩa Node mà mình muốn chạy, trong đó name là tên của Node (tên này sẽ được dùng nếu nó khác với tên bạn đặt trong tệp Python), pkg là tên package (ở đây là my_cam), type là tên file (ở đây là image_publisher_launch.py), output là để chọn cách hiển thị các thông tin (nếu là screen thì thông tin sẽ được print ra màn hình, còn là log thì sẽ được lưu trong một file log). Cuối cùng, tạo một tham số (parameter) có tên camera_name với type string và giá trị là giống với biến camera_name bên trên. Bạn có thể sử dụng tham số này trong code và vì thế không cần phải sửa code mỗi khi cần thay đổi một thông tin nào đó. Cụ thể, mình đã tạo một file image_publisher_launch.py. File này nội dung gần giống y hệt như image_publisher.py chỉ khác ở chỗ mình cho nó thành một class và khi khởi tạo class thì có dòng:

self.capture = cv2.VideoCapture(rospy.get_param("my_webcam/camera_name"))

Ở đây thay vì cho một giá trị mặc định như trước thì bạn dùng hàm rospy.get_param để lấy tham số từ launch file. Vì thế nếu ví dụ bạn dùng một camera có tên khác, thì bạn chỉ cần thay đổi launch file. Hoặc cách hay hơn là khi chạy roslaunch bạn có thể dùng biến (argument) đã được tạo ở đây <arg name="camera_name" default="/dev/video0"/>

Chạy roslaunch:

roslaunch my_cam my_cam.launch camera_name:="/dev/video0"

Nếu bạn sử dụng giá trị mặc định của các biến bạn chỉ cần chạy roslaunch my_cam my_cam.launch. Nhưng nếu bạn dùng một camera khác hoặc tên của nó không phải là /dev/video0 thì bạn chỉ cần thay đổi tên ở lệnh bên trên. Rất tiện lợi đúng không?

Ngoài ra, còn nhiều tag khác mà mình không list ra được hết. Các bạn có thể tham khảo thêm ở đây và ở đây.

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/hydro

ROS Master và Node

Để dễ hiểu khái niệm Node, hãy tưởng tượng ra một câu chuyện mà trong đó node của chúng ta là một Nhiếp Ảnh Gia mới bắt đầu làm việc cho một tạp chí. Vào ngày đầu tiên đi làm, anh ta chụp một số bức ảnh và thông báo cho Sếp của mình rằng anh sẽ để những bức ảnh này trên một chiếc Bàn ở giữa văn phòng. Ông Sếp cảm ơn anh ta vì đã thông báo.

Trong câu chuyện, ông Sếp đại diện cho ROS Master, thứ mà bạn luôn phải có khi sử dụng ROS. ROS Master cung cấp các dịch vụ đặt tên và đăng ký (naming and registration) cho các node còn lại trong hệ thống ROS. Nó theo dõi việc publish (truyền) và subscribe (nhận) của các node cũng như các topic và service (xem thêm bên dưới). ROS Master được gọi bằng lệnh roscore. Chỉ có một ROS Master được phép chạy tại một thời điểm. Nếu bạn thử gọi 2 hoặc nhiều cái cùng một lúc, sẽ có báo lỗi. Nhiếp Ảnh Gia đại diện cho một ROS Node thực hiện một tác vụ nào đó (trong trường hợp này là lấy ảnh và đặt lên Bàn) và luôn phải đăng ký (register) với Master khi nó được khởi tạo cũng như Nhiếp Ảnh Gia luôn phải báo cáo với Sếp.

ROS Topic và Message

Các bức ảnh là ROS Message (có thể dịch là tin nhắn hoặc dữ liệu) và chúng thuộc loại sensor_msgs. Đó là lý do tại sao bạn phải bao gồm sensor_msgs khi tạo gói từ chương trước. Hành động để ảnh trên Bàn của Nhiếp Ảnh Gia được gọi là publish (truyền, xuất bản) trong ROS. Cái bàn đóng vai trò là một ROS Topic mà các Node khác có thể subscribe (nhận, đăng ký).

Subscribe là gì? Bây giờ hãy tưởng tượng có một người khác (tức là một Node khác) trong câu chuyện của chúng ta có tên là Người In Ấn. Anh chàng này muốn lấy ảnh từ cái Bàn và in chúng ra. Anh ta sẽ phải làm gì? Việc đầu tiên dĩ nhiên anh ta phải thông báo (notify) cho Sếp và sau đó nếu có ảnh trên Bàn, anh ta sẽ lấy và in chúng. Hành động lấy ảnh từ Bàn được gọi là Subscribe trong ROS.

Sau khi đã thông báo cho Sếp, cả Nhiếp Ảnh Gia và Người In Ấn đều biết về nhau và giờ họ chỉ việc trao/nhận ảnh cho nhau.

ROS Service

Ở phần trước, Nhiếp Ảnh Gia liên tục publish ảnh trong khi Người In Ấn liên tục subscribe những ảnh này. Người In Ấn nói bây giờ chỉ khi nào anh ta yêu cầu thì Nhiếp Ảnh Gia mới chụp ảnh và gửi cho anh ta. Việc request/reply (yêu cầu/phản hồi) này là ý tưởng cơ bản đằng sau ROS Service. Trong ví dụ này, sau khi cả hai đã register (tức là thông báo cho Sếp), Người In Ấn bây giờ đóng vai trò Client (khách) gửi yêu cầu đến Nhiếp Ảnh Gia người đóng vai trò Server (chủ). Sau khi nhận được yêu cầu, Nhiếp Ảnh Gia sẽ chụp ảnh và gửi cho Người In Ấn (thực ra Nhiếp Ảnh Gia vẫn chỉ để chúng trên Bàn như mọi khi).

Bạn vừa tìm hiểu tất cả các khái niệm cốt lõi của ROS. Tất nhiên, còn rất nhiều khái niệm nữa nhưng đối với người mới bắt đầu, đây đã là một bước khá dài rồi. Trong những phần tiếp theo, bạn sẽ học cách tự code các khái niệm này và chạy ứng dụng ROS đầu tiên của mình.

Tóm tắt

1. ROS Master cung cấp các dịch vụ đặt tên và đăng ký (naming and registration) cho các node còn lại trong hệ thống ROS. Nó theo dõi việc publish (truyền) và subscribe (nhận) của các node cũng như các topic và service.

2. ROS Node là một quá trình thực hiện tác vụ cụ thể. Các Node có thể giao tiếp Message (dữ liệu) với nhau bằng cách sử dụng publish/subscribe (truyền/nhận liên tục) hoặc Service (máy khách/máy chủ).

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/fuerte

2. Biểu tượng: https://www.flaticon.com/

Trong ví dụ ở hình bên trên, có 3 package tên: hand_gesture_recognition, my_cam và ros_mobile_robot được đặt trong thư mục src bên trong thư mục workspace có tên catkin_ws. Các thư mục khác: build, devel, và logs được tạo tự động sau khi các package này được build. Tóm lại, package và workspace trong ROS thực chất là các thư mục với một vài yêu cầu cụ thể mà mình sẽ đề cập bên dưới.

Tạo một catkin workspace

Theo trang web chính thức của ROS, "Cái tên catkin xuất phát từ cụm hoa hình đuôi được tìm thấy trên cây liễu -- ám chỉ đến Nhà để xe Willow nơi catkin được tạo ra." Nếu bạn muốn biết thêm về nó, hãy đọc bài này còn hiện tại, bạn chỉ cần nhớ rằng catkin là hệ thống build chính thức của ROS.

Một workspace như đã nói ở trên là một thư mục, vì vậy bạn khởi tạo nó đơn giản bằng cách tạo một thư mục mới. Bạn có thể nhấp chuột phải vào thư mục Home (nơi bạn có thể dễ dàng truy cập thư mục đó) và chọn New Folder hoặc sử dụng phím tắt Ctrl + Shift + N. Sau đó, bạn cũng cần tạo một thư mục src bên trong thư mục workspace. Vì đang dùng Linux, hãy làm việc này bằng cách chạy lệnh dưới đây trong một terminal:

mkdir -p ~/catkin_ws/src

mkdir = making directory (tạo thư mục mới), -p = parents và ~ là viết tắt của thư mục Home. Lệnh này sẽ tạo một thư mục có tên catkin_ws (bạn có thể đặt một tên khác nếu muốn) với một thư mục con có tên src. Khá tiện đúng không? Sau đó, thay đổi đường dẫn tới workspace trong terminal hiện tại bằng cách sử dụng lệnh cd (cd = change directory):

cd ~/catkin_ws

Mặc dù hiện tại không có gói nào trong workspace, bạn vẫn có thể build nó bằng cách sử dụng lệnh catkin_make hoặc catkin build. Mình thích catkin build hơn vì với catkin_make, nó luôn tự động build tất cả các package nên sẽ mất nhiều thời gian nếu có nhiều package trong workpsace. Với catkin build, có thể build từng package riêng lẻ nếu muốn. Nhớ chạy source ~/catkin_ws/build/setup.bash trước nếu bạn chưa chạy khi mở terminal hoặc chưa đặt lệnh này trong .bashrc.

catkin build

Sau khi build xong, terminal của bạn sẽ trông giống như ảnh bên dưới và ba thư mục build, devel, logs cũng được tạo.

Tạo một ROS package

ROS package cũng là một thư mục được đặt trong thư mục src của workspace. Tuy nhiên, có một số yêu cầu bắt buộc phải có trong một package (nguồn):

• Tệp package.xml cung cấp các thông tin về package.

• Tệp CMakeLists.txt dùng cho việc build.

• Ngoài ra, mỗi package phải có thư mục riêng, nghĩa là không có package lồng nhau hoặc nhiều package chia sẻ cùng một thư mục.

Vậy tạo hai tệp package.xml và CMakeLists.txt như thế nào? Chúng chính xác là gì và tại sao chúng ta cần cả hai? Hãy tìm câu trả lời bằng cách thử tạo một package. May mắn là đã có lệnh catkin_create_pkg để làm việc này. Giả sử bạn muốn tạo một gói có tên my_cam để đọc hình ảnh từ webcam và publish những hình ảnh đó (định nghĩa về publish sẽ có trong chương tiếp theo). Mở terminal và hướng nó tới ~/catkin_ws/src:

cd ~/catkin_ws/src

, sau đó chạy

catkin_create_pkg my_cam rospy sensor_msgs

Thao tác này sẽ tạo một package (tức là thư mục) my_cam với hai thành phần phụ thuộc rospy và sensor_msgs (mình sẽ giải thích chúng là gì trong chương tiếp theo). Bên trong my_cam có 2 tệp package.xml và CMakeLists.txt và một thư mục src như bên dưới.

Bên trong package.xml và CMakeLists.txt

Mở file package.xml và bạn sẽ thấy tất cả thông tin về package như tên của người bảo trì, loại giấy phép và các thành phần phụ thuộc, v.v. Rất nhiều dòng là những comment (ví dụ: đây là một comment: <!-- The *depend tags are used to specify dependencies -->). Trong hình dưới đây, mình đã xóa tất cả các comment:

Đối với những bạn chưa từng làm việc với XML, đây là một ngôn ngữ đánh dấu (markup language) tương tự như [HTML](https://vi.wikipedia.org/ wiki/HTML) và nó mô tả các thành phần bằng thẻ (tag*)*. Chẳng hạn, dòng <name>my_cam</name> có nghĩa là tên package được định nghĩa là my_cam bằng cách sử dụng thẻ mở <name> và thẻ đóng </name>.

Tiếp theo, mở CMakeLists.txt. Nó cũng có rất nhiều comment (bắt đầu bằng #) chủ yếu là để hướng dẫn/gợi ý. Nếu bạn đã từng làm việc với C/C++, thì bạn đã biết rằng CMakeLists được sử dụng cho các chương trình như CMake (catkin cũng dùng CMake) để tìm và liên kết tất cả các thư viện cần thiết để build. Tại dòng find_package, bạn có thể thấy hai phụ thuộc rospy và sensor_msgs, mà chúng ta đã khai báo từ lệnh trên. Nếu bạn quên khai báo chúng, chỉ cần mở CMakeLists lên và chỉnh sửa.

find_package(catkin REQUIRED COMPONENTS
  rospy
  sensor_msgs
)

Sự khác biệt giữa package.xml và CMakeLists.txt

Bạn có thể nhận thấy cả package.xml và CMakeLists.txt có nhiều phần thông tin giống nhau như tên dự án, thự viện liên quan, v.v. Có một câu trả lời hay về sự khác biệt và lý do tại sao chúng ta cần cả hai. Bạn chỉ cần nhớ:

• package.xml chứa những thông tin (tác giả, người bảo trì, url, mô tả và giấy phép) không nhất thiết cần thiết để build (hoặc chạy) một package, nhưng vẫn cần để ROS tìm kiếm các thông tin về package (vì thông tin trong CMakeLists không dễ dàng đọc nếu không có CMake). Ngoài ra nó cũng cần cho việc hiển thị thông tin của package trên ROS wiki.

• CMakeLists.txt là build script được dùng cho các chương trình như CMake để tìm và liên kết tất cả các thư viện cần thiết để build package.

Nếu bạn thấy có quá nhiều khái niệm mới trong bài này mà bạn chưa thể nhớ hết được. Đừng nản, bạn sẽ quen với chúng sớm thôi. Hiện tại, chỉ cần nhớ rằng một ROS package luôn yêu cầu 2 tệp package.xml và CMakeLists.txt, cộng với một thư mục src là nơi bạn lưu code của mình.

Trong các phần tiếp theo, chúng ta sẽ tìm hiểu tất cả các khái niệm cốt lõi của ROS: Topic, Node, Publisher, Subscriber, v.v. và viết code để hoàn thành package my_cam.

Tóm tắt

• ROS package là một thư mục chứa các tệp thực thi (executable file) và những tệp hỗ trợ để phục vụ một mục đích cụ thể.

• ROS workspace là một thư mục nơi bạn sửa đổi, build và cài đặt các package bằng các công cụ catkin.

• Một package phải có hai tệp package.xml & CMakeLists.txt. Sử dụng lệnh catkin_create_pkg để tạo 1 package.

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/groovy

Đối với những bạn chưa từng dùng Linux (Ubuntu là một bản phân phối Linux - Linux distribution), bạn sẽ cần học cách sử dụng terminal để thực hiện các câu lệnh.

Mở terminal bằng tổ hợp phím Ctrl + Alt + T hoặc nhấp chuột phải vào khoảng trống trong bất kì thư mục nào và chọn Open in Terminal. Gõ lệnh sau vào:

sudo apt-get update

Câu lệnh trên dùng để update những phần mềm trong Ubuntu nếu chúng có bản cập nhật (release) mới. Trong Linux, khi bạn chạy một lệnh với sudo nghĩa là bạn chạy với tư cách quản trị viên (giống như Run as Administrator trong Windows). Và đừng ngạc nhiên nếu bạn không thấy gì khi nhập mật khẩu vì nó bị ẩn đi. Ấn Enter sau khi nhập và nếu mật khẩu đúng, lệnh sẽ được thực thi.

Cài đặt ROS Noetic

Bước 1: Trong cùng terminal, tiếp tục chạy lệnh này để thiết lập sources.list để máy tính của bạn chấp nhận phần mềm từ packages.ros.org. Lệnh này khá dài, vì vậy bạn chỉ cần copy&paste. Để paste một đoạn text vào terminal, bạn có thể nhấp chuột phải và chọn Paste hoặc sử dụng phím tắt Ctrl + Shift + V (tương tự, để copy nội dung nào đó từ Terminal, chỉ cần sử dụng Ctrl + Shift + C).

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main"> /etc/apt/sources.list.d/ros-latest.list'

Bước 2: Thêm khóa xác thực (authenticated key) để máy của bạn có thể kết nối với máy chủ và tải các gói dữ liệu. Cài curl nếu bạn chưa có: sudo apt install curl. Sau đó, chạy lệnh này:

curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add -

Nếu nó in ra OK, thì key đã được thêm thành công.

Bước 3: Cài ROS Noetic phiên bản Desktop-Full. Trước tiên, chạy cập nhật: sudo apt update. Sau đó bắt đầu cài đặt bằng cách chạy (bước này sẽ mất khoảng 30 phút):

sudo apt install ros-noetic-desktop-full

Bước 4: Sau khi cài đặt xong, để chạy ROS, trước tiên bạn cần gọi lệnh source này trong terminal.

source /opt/ros/noetic/setup.bash

Việc này chỉ cần làm một lần nhưng nếu bạn mở một terminal mới, bạn cần chạy lại nó. Để tránh điều này, bạn có thể thêm lệnh đó vào file.bashrc (có dấu chấm) bằng cách:

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

File .bashrc này chứa tất cả các lệnh được tự động thực thi khi bạn mở một terminal mới. Khi bạn chỉnh sửa file .bashrcvà muốn áp dụng ngay vào terminal hiện tại mà không muốn mở một terminal mới, bạn có thể dùng câu lệnh source:

source ~/.bashrc

Cuối cùng, chạy roscore và nếu terminal của bạn giống hình dưới đây thì xin chúc mừng! Bạn đã cài đặt ROS thành công!

Cài đặt những thư viện liên quan

Có một số phần mềm bạn cần cài đặt để có thể tạo ứng dụng của mình trong ROS. Chúng gọi là những dependencies. Chạy lệnh sau trong một terminal:

sudo apt install python3-rosdep python3-rosinstall python3-rosinstall-generator python3-wstool build-essential python3-catkin-tools python3-osrf-pycommon python3-pip

, sau đó:

sudo rosdep init

, và cuối cùng:

rosdep update

Xong bước này, mọi thứ đã sẵn sàng cho bạn để bắt đầu sử dụng ROS. Làm rất tốt!

Những phần mềm nên có

Phần này chỉ là những đề xuất của mình mà bản thân mình đang sử dụng và thấy rất hữu ích.

• Terminator: Terminal mặc định của Ubuntu có rất hạn chế. Ví dụ: bạn không thể có nhiều terminal nhỏ trong cùng một cửa sổ (các terminal chỉ có thể được sắp xếp theo tab hoặc tách biệt hoàn toàn). Với Terminator, bạn có thể. Trong hình dưới đây, mình có 9 terminal trong một cửa sổ.

Để cài đặt Terminator, hãy chạy lệnh này:

sudo apt install terminator

Mình cũng khuyên bạn nên xem qua danh sách phím tắt của Terminator này và nhớ một vài phím tắt cơ bản như thêm bớt terminal để sử dụng nhanh hơn.

• Visual Studio Code: Đây là một trong những IDE phổ biến nhất. Nó miễn phí, chạy được trên các hệ điều hành khác nhau và có rất nhiều plugin hữu ích cho các developer. Hãy tải về, cài đặt và dùng thử. Mình tin bạn sẽ thích nó. Link to download VS Code.

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/lunar

Nếu bạn đã có máy tính chạy Ubuntu 20, thì bạn có thể bỏ qua phần này. Mình đoán hầu hết các bạn chưa có sẵn Ubuntu, nên ở đây mình sẽ hướng dẫn bạn cài đặt Ubuntu trong VMWare. Mình đang sử dụng Windows 11 trong hướng dẫn này nhưng nó cũng tương tự như các hệ điều hành (HĐH) khác. Bắt đầu nào!

Có rất nhiều cách để cài đặt Ubuntu. Nếu bạn có PC (hoặc thậm chí là máy tính máy tính bo mạch đơn như Raspberry Pi 4 Modell B (8 GB)) dành riêng để chạy Ubuntu, thì bạn có thể tìm thấy nhiều hướng dẫn để cài đặt nó. Nếu không, dưới đây là một số giải pháp thay thế:

• Dual-boot (một máy có nhiều hệ điều hành): Bạn phải phân vùng ổ đĩa của mình sao cho một phần dành cho chạy một HĐH (ví dụ: Windows) và phần còn lại dành cho Ubuntu. Mỗi khi bật máy tính, bạn phải chọn HĐH mà mình muốn sử dụng. Tuy nhiên, mình không khuyến khích cách này nếu bạn là người mới bắt đầu sử dụng Linux.

• WSL - Windows Subsystem for Linux (nếu bạn đang sử dụng Windows): Cách này thực ra rất hay nhưng mình cũng không khuyến khích vì đáng tiếc WSL vẫn chưa chính thức hỗ trợ các kết nối bên ngoài như webcam (cái mà chúng ta cần cho loạt bài này).

• VM - Virtual Machine (Máy ảo): Đây là cách mình khuyên các bạn mới bắt đầu nên dùng (chi tiết bên dưới).

Có thể bạn đang thắc mắc máy ảo (VM) là gì? Để trả lời câu hỏi này, bạn cần hiểu khái niệm ảo hóa: là quá trình chạy một hệ điều hành (guest - máy khách) bên trong một hệ điều hành khác (host - máy chủ). Phần mềm ảo hóa (hay còn gọi là virtualizer) như VMware hay VirtualBox giúp bạn tạo một máy ảo để có thể chạy guest OS. Có nhiều trình ảo hóa khác nhau nhưng VMware và VirtualBox là hai trình ảo hóa phổ biến nhất. Mình đã dùng thử VirtualBox lúc đầu vì nó miễn phí nhưng cảm thấy khó sử dụng và thử kết nối với webcam cũng không thành nên mình đã chọn VMware . Việc kết nối với các thiết bị ngoại vi như webcam, và chuyển file giữa host và guest trên VMware dễ dàng hơn rất nhiều. Hiện tại đang sử dụng phiên bản community hoàn toàn miễn phí của VMware.

Cài đặt VMWare

• Bước 1: Tải tệp .iso Ubuntu 20.04.5 LTS. LTS là viết tắt của Long Term Support - Hỗ trợ dài hạn.

• Bước 2: Tải VMware tại đây và cài đặt.

• Bước 3: Mở VMware Workstation Player và nhấp vào Create a New Virtual Machine (Tạo một máy ảo mới).

  

• Bước 4: Chọn Installer disc image file (iso) và Duyệt đến tệp .iso mà bạn đã tải ở Bước 1. Sau đó chọn Next.

• Bước 5: Nhập tên Ubuntu, tên user và mật khẩu lần lượt vào các ô: User name, Full name, và Password.

  

• Bước 6: Nhập tên máy ảo và duyệt đến thư mục cài đặt mong muốn (ở đây mình chọn mặc định).

  

• Bước 7: Chỉnh dung lượng đĩa. Ở đây mình dùng 30GB.

  

• Bước 8: Kiểm tra lại các thông tin lần cuối và nhấn Finish.

• Bước 9: Sau đó quá trình cài đặt sẽ bắt đầu:

• Bước 10: Khi cài đặt xong VM sẽ tự động được mở lên. Nếu không, hãy quay lại VMware Workstation Player và bạn sẽ thấy VM mới tạo của mình ở đó trong mục Hone. Của mình là robodev.

  

• Kích đúp hoặc nhấn nút Play để bật máy. Nhập mật khẩu từ Bước 5 để đăng nhập.

Và thế là xong! Bạn đã hoàn thành việc cài đặt VMware và tạo một máy ảo Ubuntu. Hãy tiếp tục và bắt đầu cài đặt ROS trong phần tiếp theo.

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/lunar

ROS là gì?

Robot Operating System - ROS là một nền tảng mã nguồn mở (open-sourced) cung cấp những thư viện và công cụ để xây dựng các ứng dụng liên quan tới robot. Sau hơn 10 năm phát hành, ROS đã và đang được sử dụng rộng rãi trên toàn thế giới cả trong nghiên cứu lẫn trong công nghiệp. Dưới đây là một video ngắn tổng hợp những ứng dụng tiêu biểu của ROS vào dịp kỷ niệm 10 năm thành lập.

Ai đang dùng ROS (và để làm gì)?

Để giúp bạn dễ hình dung, đây là một danh sách các công ty đang dùng ROS trong nghiên cứu và phát triển sản phẩm của họ: Link tới danh sách. Như các bạn có thể thấy, nền tảng này được sử dụng trong những công ty lớn như NVIDIA, Microsoft, Apple, Bosch, v.v. tới những công ty startup như ANYbotics. Ngoài ra mình tin chắc là còn rất nhiều công ty khác không được list ra ở đây. Ở những trường đại học và viện nghiên cứu về robot, ROS là một nền tảng không thể thiếu.

Vậy cụ thể thì người ta đang dùng ROS vào những việc gì? Có thể nói rằng bất cứ ứng dụng nào cần phải giao tiếp với hoặc điều khiển các sensor (cảm biến) hay actuator (thiết bị truyền động), người ta đều có thể dùng ROS. Video ở trên có nêu ra một số ứng dụng của ROS-Industrial (một version dành riêng cho công nghiệp) và bạn cũng có thể thấy sự đa dạng của những dự án này. Ngoài ra, ROS còn được dùng rất nhiều trong nghiên cứu ví dụ các lĩnh vực như xe tự hành (autonomous driving), robot nhiều chân (legged robot), robot hình người (humanoid robot), thiết bị bay không người lái (drone), v.v.

ROS không phải là gì?

Trong cuốn sách A Gentle Introduction to ROS, tác giả đã đề cập đến 3 điều không đúng về ROS mà mình cũng đồng ý: ROS không phải là một ngôn ngữ lập trình, ROS không phải (chỉ) là một thư viện và ROS không phải là môi trường phát triển tích hợp (Integrated Development Environment - IDE). Bạn sẽ dần hiểu rõ hơn những điểm này khi bắt đầu làm quen với ROS còn hiện tại chỉ cần nhớ rằng ROS về cơ bản là một nền tảng cung cấp cho bạn các công cụ để tạo ra ứng dụng robot.

Tại sao chọn ROS?

Trên trang chủ của ROS có dòng chữ "Don’t reinvent the wheel. Create something new and do it faster and better by building on ROS!" nôm na nghĩa là không cần phải mất công làm lại những cái có sẵn, ROS giúp bạn dựng lên những thứ mới nhanh và hiệu quả hơn.

Ưu điểm của ROS

1. ROS cung cấp những công cụ chuẩn để giúp việc giao tiếp dễ dàng giữa các tác vụ. Ví dụ, hệ thống của bạn có một camera và một cánh tay robot. Bạn muốn lấy hình ảnh từ camera, xử lý hình ảnh đó và yêu cầu robot gắp vật thể nếu nó xuất hiện ở trong ảnh. Có nhiều cách để thực hiện các bước này, nhưng nếu bạn dùng ROS thì việc truyền nhận thông tin giữa các bước trở nên dễ dàng hơn rất nhiều.

2. ROS có một cộng đồng user và developer vô cùng lớn mạnh. Như mình đã nói ở phần trước, các công ty và viện nghiên cứu lớn trên thế giới đều đã và đang dùng ROS và nó dần trở thành một nền tảng chuẩn cho việc phát triển robot. Điều này có nghĩa là nếu bạn gặp khó khăn khi làm một dự án với ROS thì nhiều khả năng là bạn chỉ cần google là ra câu trả lời, hoặc bạn có thể hỏi trên những diễn đàn và có nhiều người sẵn sàng giúp bạn.

3. Có vô vàn nhiều những thư viện sẵn có cho các tác vụ khác nhau. Từ những công nghệ mới trong AI, thị giác máy tính (computer vision), xử lý ngôn ngữ tự nhiên (natural language processing) hay điều khiển (control) v.v., tất cả đều có những phần mềm mới nhất (state-of-the-art) mà bạn có thể trực tiếp tải xuống và sử dụng ngay. Những phần mềm tiên tiến này đa số tới từ những tổ chức, công ty, trường đại học hoặc thậm chí cá nhân mà đang họ dùng ROS trong công việc hay nghiên cứu của họ và cho công khai (open source) code những dự án của mình.

4. ROS hoàn toàn free và được phép dùng trong sản phẩm thương mại. Đây là lý do vì sao các công ty, tổ chức (kể cả những tập đoàn lớn) rất ưa dùng ROS vì nó dễ dàng thử nghiệm, phát triển và thậm chí thương mại hoá sản phẩm của họ một cách tiết kiệm.

Nhược điểm của ROS

Dĩ nhiên ROS không phải là một nền tảng hoàn hảo cho mọi ứng dụng mà vẫn còn một vài hạn chế như sau:

1. ROS không phù hợp cho những ứng dụng yêu cầu hard real-time (thơi gian thực cứng/tức thì). Hard real-time có nghĩa là hệ thống của bạn phải hoàn thành tác vụ chính xác theo những thời hạn (deadlines) qui định. Chỉ cần lỡ một trong những deadline này thì hệ thống sẽ bị lỗi và có thể gây hậu quả nghiêm trọng. Thông tin thêm về so sánh các loại thời gian thực.

2. ROS phải được chạy trên một cấu hình đủ mạnh để đạt hiệu suất tốt nhất. Để có thể sử dụng ROS thì bạn cần một chiếc máy tính, và tùy vào độ phức tạp của ứng dụng mà có những yêu cầu về cấu hình khác nhau. Đối với những ứng dụng phức tạp, bạn có thể cần phải có một PC với một hoặc nhiều card đồ hoạ, còn nếu ứng dụng đơn giản thì có thể chỉ một chiếc Raspberry Pi (4 - 8 GB RAM) là đủ.

3. Việc quản lý và bảo trì những gói (package) phần mềm trong ROS vẫn còn nhiều bất cập, đặc biệt là cho những sản phẩm thương mại.

Để giải quyết những vấn đề này, ROS 2 đã ra đời và đang trong quá trình phát triển (mình sẽ làm một series về ROS 2 sau).

Bắt đầu với ROS như thế nào?

Thực ra đã có rất nhiều hướng dẫn về ROS mà bạn có thể dễ dàng tìm thấy trên Google, GitHub, v.v. Loạt bài này có thể bao gồm các chủ đề tương tự nhưng mình cố gắng hết sức để giải thích và giúp bạn thực hành với các ví dụ đơng giản và thực tế. Như mình đã nói trong chương đầu tiên, sê-ri này bao gồm 5 bước chính từ việc trả lời cho câu hỏi ROS là gì, cài đặt nó như thế nào cho tới hiểu và áp dụng tất cả các khái niệm cơ bản vào thực tế. Thông qua việc vừa học vừa làm, mình hy vọng việc tìm hiểu về ROS nói riêng và robot nói chung sẽ vừa thú vị, vừa đầy thách thức đối với bạn.

Sau khi trả lời xong ba câu hỏi what, why và how, mình tin bạn đã có cái nhìn tổng quan về ROS và vẫn muốn tiếp tục sê-ri này. Trong phần tiếp theo, hãy cùng bắt đầu bước quan trọng đầu tiên: Cài đặt.

Tóm tắt

1. ROS là một nền tảng để phát triển robot, được sử dụng phổ biến trên toàn thế giới.

2. ROS có thể được dùng bất cứ ứng dụng nào (từ đơn giản tới phức tạp) cần phải giao tiếp với hoặc điều khiển các sensor (cảm biến) hay actuator (thiết bị truyền động).

3. Lý do khiến ROS trở nên phổ biến là vì nó cung cấp cho người dùng những công cụ hữu ích để phát triển phần mềm và có cộng đồng user rất lớn mạnh.

4. ROS vẫn còn nhiều bất cập như chưa dành cho hệ thống thời gian thực (real-time), yêu cầu hardware đủ mạnh và việc quản lý cũng như bảo trì vẫn chưa được tối ưu. Để giải quyết những hạn chế này, ROS 2 đang được phát triển.

Trích dẫn

1. Cover photo: http://wiki.ros.org/noetic

2. Icons: https://www.flaticon.com/

Chúng ta sẽ bắt đầu bằng việc trả lời những câu hỏi: ROS là gì, tại sao mọi người (và bạn cũng nên) chọn ROS và cách bạn sẽ tìm hiểu về nó thông qua sê-ri này. Bước thứ hai là cài đặt ROS và tất cả các phần mềm cần thiết để nó chạy được trên máy tính của bạn. Tiếp theo, chúng ta sẽ xem xét các khái niệm cơ bản nhất của ROS và thực hành sử dụng chúng. Bạn cũng sẽ học cách tạo một robot di động đơn giản, mô phỏng và điều khiển nó. Cuối cùng, chúng ta sẽ tổng hợp mọi thứ đã học để hoàn thành một dự án nhỏ: điều khiển robot bằng ký hiệu tay.

Vậy để hoàn thành tất cả các phần đó cần những yêu cầu gì? Mình biết hầu hết các bạn là người mới bắt đầu trong lĩnh vực này và không có (hoặc thậm chí không đủ khả năng) các công cụ đắt tiền như card đồ họa, động cơ, bộ điều khiển động cơ, v.v. để chế tạo một robot thực sự nhưng không sao hết. Một trong những mục đích chính của sê-ri này là giúp bạn tiếp cận ROS với ít kinh phí và công sức nhất có thể.

Về phần cứng, bạn cần một máy tính và một chiếc USB webcam. Tốt nhất là một chiếc laptop vì thường nó đã tích hợp sẵn webcam. Lý do cần có webcam là vì nó là một chiếc camera hoạt động tương tự như đa số các camera dùng trong công nghiệp (pinhole camera). Ngoài ra, mình chọn camera thay vì các cảm biến khác vì nó phổ biến, thực tiễn và dễ hình dung.

Đối với phần mềm, bạn cần có một chút kiến thức về lập trình Python hoặc C++ vì chúng là hai ngôn ngữ chính được hỗ trợ bởi ROS (Python sẽ được sử dụng chủ yếu trong sê-ri này). Nếu bạn biết về Linux và đã sử dụng qua nó thì đó sẽ là một lợi thế lớn. Nếu không, cũng không có vấn đề gì vì đây là cơ hội để bạn tìm hiểu một trong những hệ điều hành tuyệt vời nhất dành cho developer. Bạn cũng không cần phải có một máy tính khác hoặc cài 2 hệ điều hành song song. Mình sẽ đề cập vấn đề này sau trong chương Cài đặt.

Dưới đây là tổng hợp những yêu cầu về hardware và software bạn cần có:

• Máy tính xách tay hoặc PC (không cần hệ điều hành cụ thể) có webcam tích hợp hoặc USB webcam. Máy tính phải có ít nhất 4GB RAM, Intel® i5 lõi tứ hoặc tương đương và ít nhất 20 GB dung lượng ổ đĩa trống. Một card đồ họa (GPU) không bắt buộc nhưng là một lợi thế.

• Biết một chút về lập trình với Python hoặc C++ (hoặc bất kỳ ngôn ngữ OOP nào)

Và thế là bạn đã sẵn sàng cho hành trình chinh phục ROS. Cùng bắt đầu nhé!

Sê ri ROS cơ bản có tổng cộng 12 chương:

1. Tổng Quan về Series ROS Cơ Bản (bài này)

2. ROS (Robot Operating System) là gì?

3. Cài đặt ROS - Phần 1: Cài đặt Ubuntu 20.04

4. Cài đặt ROS - Phần 2: Cài ROS Noetic và Những Thư Viện Liên Quan

5. ROS Package và Workspace là gì?

6. Những Khái Niệm Cơ Bản trong ROS

7. Tạo một ROS Publisher

8. Tạo một ROS Subscriber

9. Nhận Diện Cử Chỉ Tay trong ROS

10. Mô Phỏng Robot trong ROS - Phần 1

11. Mô Phỏng Robot trong ROS - Phần 2

12. Điều Khiển Robot Bằng Cử Chỉ Tay

Trích dẫn

1. Ảnh bìa: http://wiki.ros.org/cturtle

2. Icons: https://www.flaticon.com/

Hand Gesture Recognition

A system that can understand human hand gestures has enormous applications. In robotics, it helps, for example, convert gesture recognitions into control signals making a robot follow users' hands.

With the recent developments in artificial intelligence (AI), integrating that system is easier than ever. In this chapter, I want to introduce to you the Mediapipe Hands which is an open-source machine learning (ML) package from Google that can help track human hands and fingers using images. Basically what it does is combine two ML models: a palm detection model for detecting initial hand locations and a hand landmark model for precisely localizing the 21 3D hand-knuckle (see image below) coordinates inside the detected hand regions. It was trained with about 30k real labeled data and works in a single-shot manner which is very fast. A good introduction to this package can be found here.

Now we need to turn the detected key points from Mediapipe into meaningful actions, for instance from the hand landmark image above, our system should tell us the status is "Open" since all the fingers are stretched out. In order to do that, another model for classifying the actions is required. Luckily, there is already an existing program for that. This hand-gesture-recognition-mediapipe repository contains Python scripts that help user train and deploy models to recognize hand signs and finger gestures. I have used it myself and converted it into this ROS package so that you can clone it directly. You're welcome!

Installation

First, install the following dependencies using pip3 or conda:

• Mediapipe 0.8.1

• OpenCV 3.4.2 or Later

• Tensorflow 2.3.0 or Later

For example, installing commands with pip:

pip3 install mediapipe
pip3 install opencv-python
pip3 install tensorflow

Then, clone this repository into the folder catkin_ws/src:

cd ~/catkin_ws/src
git clone https://github.com/TrinhNC/ros_hand_gesture_recognition.git

Build the package:

cd ~/catkin_ws
catkin build

Run the package

After building successfully, you can run a demo. Remember to source the workspace by source ~/catkin_ws/devel/setup.bash. Open 2 terminals. In the first terminal run the image publisher (from chapter 7 and make sure the webcam is connected to the virtual machine if you are using one):

roslaunch my_cam my_cam.launch

In the second terminal, run the hand pose recognition:

roslaunch ros_hand_gesture_recognition hand_sign.launch

The result should look like this:

In the GIF above, FPS stands for Frame Per Second which is the number of images being processed per second, Right is the right hand and the words after that (Turn Right, Forward, etc.) are the labels that I assigned to specific hand signs. You can change these labels by following the section below.

Train Hand Sign Recognition (Optional)

The current package can classify only six signs (classes) and I labeled them: Stop, Go, Forward, Backward, Turn Right, and Turn Left (see the image below) which will be converted to control signals to move a robot later in this series. If you want to change or add gestures, or you find out that my trained model does not perform very well with your hand, you can collect data and train it again by yourself.

There are two jupyter notebooks included in the folder src/notebooks:

• keypoint_classification_EN.ipynb: a model training script for hand sign recognition.

• point_history_classification.ipynb: a model training script for finger gesture recognition (meaning the model after training can detect the movement of your fingers and not just a static sign like in the keypoint classification).

I used only the keypoint classification model in the current ROS package because it is enough for the application but you can feel free to adjust it to match yours.

In the example below, I will show you how to add one more sign to the detection. Let's say we want to add this sign✌️and name it "Hi". Remember to end all the commands (using Ctrl + C) from the previous parts because this part is completely separate from ROS.

You may need to install these extra libraries if you have not:

pip3 install -U tf-nightly
pip install -U scikit-learn
pip3 install -U matplotlib

First, open the keypoint_classifier_label.csv in the folder src/model/keypoint_classifier. Here you find all the labels (at the moment 6 classes) and you should add 'Hi' to the end like this:

Stop
Go
Forward
Backward
Turn Right
Turn Left
Hi

Next, you need to record data and append it to the file keypoint.csv in the folder src/model/keypoint_classifier. If you open this file, you will see it contains 6410 lines. The first number in each line is the class ID with respect to the list above, for example, "Go" has ID 0, "Stop" has ID 1, and so on. Then comes 42 numbers or 21 pairs of numbers which represent the coordinates of each keypoint (i.e. the hand knuckle) with respect to the origin which is the wrist. One thing to note is that the IDs in the image below are the key point IDs (0-20) and they are different from the class IDs (0-6).

In order to record data, run the script app.py:

python3 app.py

Press k on the keyboard and you should see the line MODE: Logging Key Point shows up. Then, use your right hand to make the target sign✌️visible. Press and hold the number 6 (class ID of "Hi") with your left hand. This will continuously append the new data to the file keypoint.csv until you release the key. You can also try to press & release 6 immediately and check the file. It should have one new line at the end starting with the number 6 and a list of numbers that follow. Also, during the recording, remember to move your right hand to different positions to make the data varied.

After recording for about 10-15 seconds, the data should be ready and you can stop the program. Open the notebook file keypoint_classification_EN.ipynb. Edit dataset, model_save_path and tflite_save_path to match your paths. Change NUM_OF_CLASSES to 7 instead of 6: NUM_CLASSES = 7. Then run the notebook from beginning to end. The training is executed in the cell [13] and takes around 2-3 minutes. After that, you can launch my_cam.launch and hand_sign.launch like in the Demo to see the result like below.

The Code

Let's create a new Python script in the my_cam folder and name it image_subscriber.py. If you already did the last chapter, the code below should look familiar because the structure is quite the same. Again, I highly recommend you follow the explanation part below and type by yourself instead of copy&paste.

#!/usr/bin/python3

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

def callback(image_msg):
    """This function is called to handle the subscribed messages

    Args:
        image_msg (Image): message type Image from sensor_msgs
    """
    try:
        cv_image = bridge.imgmsg_to_cv2(image_msg)
        cv2.imshow('ROS Image Subscriber', cv_image)
        cv2.waitKey(10)
    except CvBridgeError as error:
        print(error)

if __name__=="__main__":
    bridge = CvBridge()
    rospy.init_node("image_subscriber", anonymous=True)
    print("Subscribe images from topic /image_raw ...")

    image_subcriber = rospy.Subscriber("image_raw", Image, callback)

    try:
        # spin() simply keeps python from exiting until this node is stopped
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

The Code Explain

The first part of the code is exactly the same as in the image_publisher.py. It is basically to import all the necessary libraries.

#!/usr/bin/python3

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

Next, a callback function is created but I want to explain first the main function and come to this callback later. In the main, similar to the publisher, you need to create a CvBridge object and initialize a node whose name is "image_subscriber".

if __name__=="__main__":
    bridge = CvBridge()
    rospy.init_node("image_subscriber", anonymous=True)
    print("Subscribe images from topic /image_raw ...")

Then, the subscriber is created by using the function rospy.Subscriber("image_raw", Image, callback) in which image_raw is the topic you want to subscribe to, Image is the data type of image_raw and callback is a function that will be invoked when new messages are received. Finally, rospy.spin() is called to keep your node from exiting until the node has been stopped (by Ctrl + C for instance).

    image_subcriber = rospy.Subscriber("image_raw", Image, callback)
    try:
        # spin() simply keeps python from exiting until this node is stopped
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

The callback function is defined always with the incoming message as the first argument.

def callback(image_msg):

Inside the callback, you first convert the ROS image message image_msg to OpenCV format (here I named it cv_image) using the imgmsg_to_cv2 function. Then, you can display the image using the cv2.imshow function which takes first the window name (here ROS Image Subscriber) as the first argument and the image cv_image as the second. Finally, cv2.waitKey(10) is used to delay for given milliseconds (here 10ms) or until any key is pressed before switching to the next frame.

    try:
        cv_image = bridge.imgmsg_to_cv2(image_msg)
        cv2.imshow('ROS Image Subscriber', cv_image)
        cv2.waitKey(10)
    except CvBridgeError as error:
        print(error)

Run the Subscriber

In order to start the script above from a terminal, you should make it executable by either right-click on the script and selecting Properties > Permissions and check Allow executing file as program, or using the command sudo chmod +x image_subscriber.py. Then, open 3 terminals or one terminator with 3 sub-terminals as below.

In the first terminal, run ROS Master

roscore

In the second, start the publisher (remember to connect the webcam to your virtual machine).

rosrun my_cam image_publisher.py

In the third, start the subscriber:

rosrun my_cam image_subscriber.py

After that, you should see a window with the title ROS Image Subscriber showing your webcam view like what I have in the photo above (the cute cow is actually one of my assistants :)).

After completing chapters 7 and 8, you now know how to write a ROS publisher and subscriber. You also know how to exploit the images from a camera which is one of the most popular sensors used in robotics. Well done! In the next chapter, as promised, I will help you use one of the available tools to deploy the images and get some useful information instead of just viewing them on screen. Meet you there!

Reference

1. Cover photo: http://wiki.ros.org/jade

Setup Camera in VMWare

First, if you are using a virtual machine (VM), you need to make sure your webcam is connected to your VM instead of your host. In VMWare Workstation Player, go to Player > Manage > Virtual Machine Settings... or Ctrl + D.

Select USB Controller tab and choose USB 3.1 in USB compatibility.

Then go to Removable Devices, select your integrated webcam (in my case it is Sunplus Innovation Integrated_Webcam_HD), and select Connect (Disconnect from host). Click OK on any popup dialogs after that.

If there is an error saying something like the connection is unsuccessful, a trick is to switch your host machine (in my case Windows) and open your webcam by using the Camera app from Start. Return to the virtual machine and you should see a dialog to choose to connect the camera to your host or to your VM (see below). Select Connect to a virtual machine.

Finally, check if the connection is really established by going to Player > Removeable Devices again, and you should see a tick next to your webcam. If not, just redo the steps above.

Write a Camera Image Publisher

First, in the folder my_cam create a new Python script with the name image_publisher.py. The whole code is available here but I highly recommend you follow the explanation below and type it yourself.

The Code

#!/usr/bin/python3
import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

def publish_image():
    """Capture frames from a camera and publish it to the topic /image_raw
    """
    image_pub = rospy.Publisher("image_raw", Image, queue_size=10)
    bridge = CvBridge()
    capture = cv2.VideoCapture("/dev/video0")

    while not rospy.is_shutdown():
        # Capture a frame
        ret, img = capture.read()
        if not ret:
            rospy.ERROR("Could not grab a frame!")
            break
        # Publish the image to the topic image_raw
        try:
            img_msg = bridge.cv2_to_imgmsg(img, "bgr8")
            image_pub.publish(img_msg)
        except CvBridgeError as error:
            print(error)

if __name__=="__main__":
    rospy.init_node("my_cam", anonymous=True)
    print("Image is being published to the topic /image_raw ...")
    publish_image()
    try:
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

The Code Explained

The first line is called shebang line which defines where the interpreter is located. In this case, Python3, the default Python version in Ubuntu 20, is used and it is located in the folder /usr/bin.

#!/usr/bin/python3

All necessary libraries need to be imported. rospy is the Python API for creating ROS applications. cv2 is OpenCV, an open-source library for computer vision. Here we'll use it to capture images from our webcams. CvBridge is used to convert between ROS Image messages and OpenCV images since they are not the same data type. Finally, we have to import the Image message type (which belongs to the package sensor_msgs) because we are dealing with images.

import rospy
import cv2
from cv_bridge import CvBridge, CvBridgeError
from sensor_msgs.msg import Image

Next, define a function named publish_image. In this function, you first create a publisher which has a name ofimage_raw, a data type of Image that I mentioned above, and a queue_size of 10 (the size of the outgoing message queue used for asynchronous publishing). One example to understand queue_size is that if you publish images at a rate of 20 Hz (or 20 frames per second) but your queue_size is only set to 10 then only 10 images are processed (put into a queue) while the other 10 will be discarded. In our example, we actually don't have to care much about it since we have only one message Image. This is also a good article on how to select a proper queue size.

image_pub = rospy.Publisher("image_raw", Image, queue_size=10)

Create a CvBridge object:

bridge = CvBridge()

Define a video capture object which will help us to grab images from our webcam. /dev/video0 is the device name. If you use an external camera or on your computer, the name may be different, you can check it by using this command: ls -ltrh /dev/video*. In my case, it lists out both /dev/video0 and /dev/video1 but only /dev/video0 works.

capture = cv2.VideoCapture("/dev/video0")

We then jump into a loop that does the real job. The loop always checks if the node is running or not by checking the rospy.is_shutdown() flag. It breaks if there is an interruption, for example, you stop the program by using Ctrl + C. capture.read() returns a bool ret (True if the frame is read correctly, and false otherwise) and an image img. The image is encoded in OpenCV in the format of 3 channels Blue, Green, and Red (or BGR) and each channel is a matrix which is a 2-dimensional array. In the Appendix below, I explain in more detail how an image is encoded.

If the ret is false meaning there are some problems like the camera cannot be connected correctly, we throw out an error to the terminal. Before you can publish the image, you need to convert it to a ROS message img_msg using the function cv2_to_imgmsg (from CvBridge) with the color encoding "bgr8"(so that future subscribers will know the color order, in this case, it is blue-green-red and 8-bits). Finally, you can use the publisher image_pub that you created to publish img_msg using the function publish. If this does not work, just throw an exception.

    while not rospy.is_shutdown():
        # Capture a frame
        ret, img = capture.read()
        if not ret:
            rospy.ERROR("Could not grab a frame!")
            break
        # Publish the image to the topic image_raw
        try:
            img_msg = bridge.cv2_to_imgmsg(img, "bgr8")
            image_pub.publish(img_msg)
        except CvBridgeError as error:
            print(error)

The function publish_image is complete. In the main function, you first initialize a node called my_cam. Note that in ROS, nodes are uniquely named. If two nodes with the same name are launched, the previous one is kicked off. The flag anonymous is set True so that rospy will choose a unique name for our publisher node (by adding random numbers to the end of the name) so that multiple publishers can run simultaneously.

if __name__=="__main__":
    rospy.init_node("my_cam", anonymous=True)
    print("Image is being published to the topic /image_raw ...")
    publish_image()
    try:
        rospy.spin()
    except KeyboardInterrupt:
        print("Shutting down!")

After initializing the node, call the publish_image function. And the final step is to call rospy.spin() which simply keeps your node from exiting until the node has been stopped (by Ctrl + C for instance). And that's it! Your publisher code is ready to be run.

Run the Publisher

You first need to make it executable by either using the command

sudo chmod +x image_publisher.py

or right-click on the file, select Properties > Permissions > Allow executing files as program.

Then open 2 terminals or a terminator with 2 sub-terminals. In one, run roscore to start the ROS Master. In the other run, rosrun my_cam image_publisher.py in which my_cam is the package name and image_publisher.py is the script. Another way to run the publisher is by using roslaunch which I mention in the Appendix below.

View Published Images

Now you should see the LED next to your webcam light on. And if you open another terminal and run: rostopic list, you should see the topic /image_raw listed. You can even see what's inside /image_raw by running this command: rostopic echo /image_raw and it will print out arrays of numbers that represent images. In order to display the images, you need to write a subscriber (i.e. the Photocopier) that we are going to do in the next chapter. Luckily, ROS already provides a tool for visualizing different types of published data including images. Run rqt in a terminal and a window will show up. Go to Plugins > Visualization > Image View, then select /image_raw in the drop-down topic list and you should see the live images.

Appendix

How a computer "see" an image

In computer vision, an image is usually represented by the RGB color model. RGB stands for Red, Green, and Blue, the 3 primary colors from which you can create any other colors.

Each color channel is encoded in a matrix (i.e. a 2-Dimensional array) whose values are pixels. If the pixels are in 8-bits, the values should be between 0 and 255 (or 2^8 - 1). In the example below, you can see how an image (with a height of 140 pixels and width of 140 pixels) is decomposed into 3 different channels and each channel is actually a 140x140 matrix. These channels are combined into a 3D matrix whose each element contains Blue, Green, Red pixels (this BGR order is the default color order of OpenCV and it could be different from other libraries).

Run Node with roslaunch

Besides rosrun, a more common way to run a node is by using roslaunch. Limitations of rosrun compared to roslaunch:

• rosrun can only run one node from one package at a time while roslaunch can run multiple nodes from multiple packages.

• roslaunch automatically starts roscore (if not already) while rosrun does not.

• To use roslaunch requires a .launch file and the user can customize this file such as calling other launch files, changing the variables of functions, etc. while rosrun does not have this option.

A launch file is actually an XML file, so it's pretty straightforward to create. First, create a folder named launch and then create a text file named my_cam.launch. The content of this file:

<launch>
     <arg name="camera_name" default="/dev/video0"/>
     <node name="my_webcam" pkg="my_cam" type="image_publisher_launch.py" output="screen">
         <param name="camera_name" type="string" value="$(arg camera_name)" />
     </node>
</launch>

Explanation: A launch file begins with the tag <launch> and ends with the tag </launch>. I begin with creating an argument named camera_name and its default value is /dev/video0. I will explain how to use it below. When you want to use this variable in the launch file, call it with $(arg camera_name) as in line 4. The next line defines the node that you want to run, where name is the name of the Node (this name will overwrite the name you use in your code if the two names are different), pkg is the package name (here my_cam), type is the filename (here image_publisher_launch.py), output is for choosing how to display the information (if screen, the information will be printed to the screen, and if log, it will be saved in a log file). Finally, create a parameter named camera_name with type string and value the same as the argument camera_name above. You can call this parameter in your code and so you don't have to edit the code every time you need to change something. Concretely, I created a file image_publisher_launch.py. This is very similar to image_publisher.py except that I made it a class and when initializing the class, there is the line:

self.capture = cv2.VideoCapture(rospy.get_param("my_webcam/camera_name"))

Here instead of giving a default value as before, the rospy.get_param function is used to get parameters from the launch file. So if for example, you use a camera with a different name, then you just need to change the launch file. Or when running roslaunch you can use the argument "camera_name" like below.

roslaunch my_cam my_cam.launch camera_name:="/dev/video0"

If you use default values of variables (here "/dev/video0"), you can simply run roslaunch my_cam my_cam.launch. But as I said, if you use a different camera or its name is not /dev/video0 then you just need to change the name in the command above. Very convenient, right?

In addition, there are many other tags that I can't list here. You can check them here and here.

Reference

1. Cover image: http://wiki.ros.org/hydro