Tuyển dụng Check with seller Hải Phòng => Cần giảng viên lập trình robot dạy về lập trình robot với ROS2 Foxy

Tuyển dụng giáo viên ngành giáo dục Hải Phòng => Thông tin tuyển dụng, Tôi sẽ đóng vai trò là giảng viên lập trình robot của bạn và cung cấp về lập trình robot với ROS2 Foxy. Chúng ta sẽ đi từ những khái niệm cơ bản đến những ví dụ thực tế.

Mục tiêu của Khóa học:

Hiểu các khái niệm cốt lõi của ROS2 và cách chúng hoạt động.
Cài đặt và cấu hình ROS2 Foxy.
Nắm vững các công cụ dòng lệnh ROS2 (ví dụ: `ros2 node`, `ros2 topic`, `ros2 service`).
Viết các node ROS2 bằng Python và C++.
Làm việc với các thông điệp (messages), dịch vụ (services) và hành động (actions) trong ROS2.
Sử dụng TF2 (Transform Library) để quản lý các hệ tọa độ.
Mô phỏng robot bằng Gazebo.
Điều khiển robot thực tế bằng ROS2.

Cấu trúc Khóa học:

Chúng ta sẽ chia khóa học thành các phần nhỏ hơn, mỗi phần tập trung vào một chủ đề cụ thể. Sau mỗi phần, bạn sẽ có các bài tập thực hành để củng cố kiến thức.

Phần 1: Giới thiệu về ROS2

1. ROS là gì? Tại sao lại cần ROS?

ROS (Robot Operating System) không phải là một hệ điều hành thực sự mà là một framework phần mềm cho phép bạn xây dựng các ứng dụng robot.
ROS cung cấp các công cụ, thư viện và quy ước giúp bạn viết code một cách mô-đun và tái sử dụng được.
Lý do cần ROS:

Mô-đun hóa:

Chia nhỏ hệ thống robot phức tạp thành các thành phần nhỏ, dễ quản lý.

Tái sử dụng:

Sử dụng lại các gói (packages) và node (nodes) đã được phát triển.

Cộng đồng:

Cộng đồng ROS lớn mạnh, hỗ trợ lẫn nhau và chia sẻ kiến thức.

Phần cứng độc lập:

Code ROS có thể chạy trên nhiều loại phần cứng khác nhau.

2. ROS2 là gì? Sự khác biệt giữa ROS1 và ROS2.

ROS2 là phiên bản kế nhiệm của ROS1, được thiết kế để giải quyết các hạn chế của ROS1 và cải thiện tính bảo mật, độ tin cậy và khả năng mở rộng.
Các khác biệt chính:

Middleware:

ROS1 sử dụng ROS Master (một điểm lỗi duy nhất). ROS2 sử dụng DDS (Data Distribution Service) để giao tiếp ngang hàng (peer-to-peer), loại bỏ điểm lỗi duy nhất.

Thời gian thực:

ROS2 được thiết kế để hỗ trợ các ứng dụng thời gian thực.

Bảo mật:

ROS2 tích hợp các tính năng bảo mật để bảo vệ hệ thống khỏi các cuộc tấn công.

Đa nền tảng:

ROS2 hỗ trợ nhiều hệ điều hành (Linux, Windows, macOS).

3. Các khái niệm cốt lõi trong ROS2:

Nodes (Nút):

Các chương trình độc lập thực hiện một chức năng cụ thể.

Topics (Chủ đề):

Kênh giao tiếp không đồng bộ giữa các nodes. Một node có thể publish (xuất bản) thông tin lên một topic và các nodes khác có thể subscribe (đăng ký) để nhận thông tin từ topic đó.

Messages (Thông điệp):

Dữ liệu được truyền qua các topics.

Services (Dịch vụ):

Kênh giao tiếp đồng bộ giữa các nodes. Một node có thể cung cấp một dịch vụ và các nodes khác có thể yêu cầu dịch vụ đó.

Actions (Hành động):

Tương tự như services nhưng cho phép thực hiện các tác vụ dài hạn với phản hồi (feedback) và hủy bỏ (cancellation).

Parameters (Tham số):

Các biến cấu hình cho các nodes.

Workspaces (Không gian làm việc):

Nơi chứa các gói (packages) ROS2 của bạn.

Packages (Gói):

Tập hợp các nodes, thư viện, và các tệp cấu hình liên quan.

Phần 2: Cài đặt và Cấu hình ROS2 Foxy Fitzroy

1. Yêu cầu hệ thống:

Hệ điều hành: Ubuntu 20.04 LTS (khuyến nghị)
RAM: Tối thiểu 4GB (8GB trở lên được khuyến nghị)
Ổ cứng: Tối thiểu 20GB

2. Cài đặt ROS2 Foxy:

Thêm kho lưu trữ ROS2:

```bash
sudo apt update && sudo apt install curl gnupg2 lsb-release
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
echo deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(lsb_release -cs) main | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null
```

Cài đặt ROS2 Foxy:

```bash
sudo apt update
sudo apt install ros-foxy-desktop
```

Cài đặt các công cụ bổ sung (tùy chọn):

```bash
sudo apt install python3-rosdep2 python3-colcon-common-extensions
```

3. Cấu hình môi trường ROS2:

Source setup file:

```bash
source /opt/ros/foxy/setup.bash
```

Thêm lệnh source vào `~/.bashrc` để tự động cấu hình môi trường khi mở terminal:

```bash
echo source /opt/ros/foxy/setup.bash >> ~/.bashrc
source ~/.bashrc
```

4. Kiểm tra cài đặt:

Mở một terminal mới và chạy:

```bash
ros2 --version
```

Nếu bạn thấy phiên bản ROS2 Foxy, cài đặt thành công!

Phần 3: Làm quen với các công cụ dòng lệnh ROS2

1. `ros2 node`:

Quản lý các node.

`ros2 node list`: Liệt kê các node đang chạy.
`ros2 node info `: Hiển thị thông tin về một node cụ thể (topics nó publish/subscribe, services nó cung cấp, etc.).
`ros2 node kill `: Dừng một node.

2. `ros2 topic`:

Quản lý các topics.

`ros2 topic list`: Liệt kê các topics đang hoạt động.
`ros2 topic info `: Hiển thị thông tin về một topic (loại message, số lượng publishers/subscribers).
`ros2 topic echo `: In ra nội dung của các messages được publish lên một topic.
`ros2 topic pub `: Publish một message lên một topic. Ví dụ: `ros2 topic pub /my_topic std_msgs/msg/String data: Hello, ROS2!`

3. `ros2 service`:

Quản lý các services.

`ros2 service list`: Liệt kê các services đang hoạt động.
`ros2 service info `: Hiển thị thông tin về một service (loại request/response).
`ros2 service call `: Gọi một service.

4. `ros2 interface`:

Làm việc với các interface (messages, services, actions).

`ros2 interface list`: Liệt kê các interface có sẵn.
`ros2 interface show `: Hiển thị định nghĩa của một interface.

5. `ros2 param`:

Quản lý các parameters.

`ros2 param list`: Liệt kê các parameters của một node.
`ros2 param get `: Lấy giá trị của một parameter.
`ros2 param set `: Đặt giá trị cho một parameter.

Phần 4: Viết Nodes ROS2 bằng Python

1. Tạo một workspace:

```bash
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws
```

2. Tạo một package:

```bash
ros2 pkg create --build-type ament_python my_package --dependencies rclpy std_msgs
```

3. Cấu trúc package:

```
my_package/
├── my_package/
│ ├── __init__.py
│ └── my_node.py Nơi chứa code của bạn
├── resource/
│ └── my_package
├── setup.py
└── package.xml
```

4. Viết một node publisher đơn giản ( `my_node.py`):

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

class MyPublisher(Node):
def __init__(self):
super().__init__(my_publisher)
self.publisher_ = self.create_publisher(String, my_topic, 10)
timer_period = 0.5 seconds
self.timer = self.create_timer(timer_period, self.timer_callback)
self.i = 0

def timer_callback(self):
msg = String()
msg.data = Hello, ROS2! %d % self.i
self.publisher_.publish(msg)
self.get_logger().info(Publishing: %s % msg.data)
self.i += 1

def main(args=None):
rclpy.init(args=args)

my_publisher = MyPublisher()

rclpy.spin(my_publisher)

Destroy the node explicitly
(optional - otherwise it will be done automatically
when the garbage collector destroys the node object)
my_publisher.destroy_node()
rclpy.shutdown()

if __name__ == __main__:
main()
```

5. Sửa đổi `setup.py` để khai báo executable:

```python
from setuptools import setup

package_name = my_package

setup(
name=package_name,
version=0.0.0,
packages=[package_name],
data_files=[
(share/ament_index/resource_index/packages,
[resource/ + package_name]),
(share/ + package_name, [package.xml]),
],
install_requires=[setuptools],
zip_safe=True,
maintainer=your_name,
maintainer_email=your_email@example.com,
description=A simple ROS2 package,
license=TODO: License declaration,
tests_require=[pytest],
entry_points={
console_scripts: [
my_node = my_package.my_node:main, Khai báo entry point
],
},
)
```

6. Build package:

```bash
cd ~/ros2_ws
colcon build
```

7. Source workspace:

```bash
source install/setup.bash
```

8. Chạy node:

```bash
ros2 run my_package my_node
```

9. Kiểm tra kết quả:

Mở một terminal khác và chạy:

```bash
ros2 topic echo /my_topic
```

Bạn sẽ thấy các messages Hello, ROS2! ... được in ra.

Bài tập thực hành 1:

1. Tạo một package mới tên là `my_subscriber`.
2. Viết một node subscriber (Python) đăng ký vào topic `/my_topic` và in ra nội dung của các messages nhận được.
3. Chạy cả node publisher và node subscriber để kiểm tra xem chúng có giao tiếp với nhau hay không.

Phần 5: Viết Nodes ROS2 bằng C++

1. Tạo một package:

```bash
ros2 pkg create --build-type ament_cmake my_cpp_package --dependencies rclcpp std_msgs
```

2. Cấu trúc package:

```
my_cpp_package/
├── CMakeLists.txt
├── include/
│ └── my_cpp_package/
│ └── my_node.hpp Header file
├── src/
│ └── my_node.cpp Source file
└── package.xml
```

3. Viết header file (`include/my_cpp_package/my_node.hpp`):

```c++
ifndef MY_CPP_PACKAGE__MY_NODE_HPP_
define MY_CPP_PACKAGE__MY_NODE_HPP_

include rclcpp/rclcpp.hpp
include std_msgs/msg/string.hpp

namespace my_cpp_package
{
class MyPublisher : public rclcpp::Node
{
public:
MyPublisher();
private:
void timer_callback();
rclcpp::TimerBase::SharedPtr timer_;
rclcpp::Publisher::SharedPtr publisher_;
size_t count_;
};
} // namespace my_cpp_package

endif // MY_CPP_PACKAGE__MY_NODE_HPP_
```

4. Viết source file (`src/my_node.cpp`):

```c++
include my_cpp_package/my_node.hpp

include
include
include
include

using namespace std::chrono_literals;

namespace my_cpp_package
{
MyPublisher::MyPublisher()
: Node(my_cpp_publisher), count_(0)
{
publisher_ = this->create_publisher(my_topic, 10);
timer_ = this->create_wall_timer(
500ms, std::bind(&MyPublisher::timer_callback, this));
}

void MyPublisher::timer_callback()
{
auto message = std_msgs::msg::String();
message.data = Hello, ROS2! + std::to_string(count_++);
RCLCPP_INFO(this->get_logger(), Publishing: %s, message.data.c_str());
publisher_->publish(message);
}
} // namespace my_cpp_package

int main(int argc, char argv[])
{
rclcpp::init(argc, argv);
rclcpp::spin(std::make_shared());
rclcpp::shutdown();
return 0;
}
```

5. Sửa đổi `CMakeLists.txt`:

```cmake
cmake_minimum_required(VERSION 3.8)
project(my_cpp_package)

if(CMAKE_COMPILER_ID STREQUAL GNU OR CMAKE_CXX_COMPILER_ID MATCHES Clang)
add_compile_options(-Wall -Wextra -Wpedantic)
endif()

find dependencies
find_package(ament_cmake REQUIRED)
find_package(rclcpp REQUIRED)
find_package(std_msgs REQUIRED)

include_directories(
include
)

add executable
add_executable(my_cpp_node src/my_node.cpp)
ament_target_dependencies(my_cpp_node rclcpp std_msgs)

install executable
install(TARGETS my_cpp_node
DESTINATION lib/${PROJECT_NAME})

ament package
ament_package()
```

6. Sửa đổi `package.xml`:

```xml



my_cpp_package
0.0.0
A simple ROS2 C++ package
your_name
TODO: License declaration

ament_cmake

rclcpp
std_msgs

ament_lint_auto
ament_lint_common


ament_cmake


```

7. Build package:

```bash
cd ~/ros2_ws
colcon build
```

8. Source workspace:

```bash
source install/setup.bash
```

9. Chạy node:

```bash
ros2 run my_cpp_package my_cpp_node
```

10.

Kiểm tra kết quả:

Mở một terminal khác và chạy:

```bash
ros2 topic echo /my_topic
```

Bạn sẽ thấy các messages Hello, ROS2! ... được in ra.

Bài tập thực hành 2:

1. Tạo một package mới tên là `my_cpp_subscriber`.
2. Viết một node subscriber (C++) đăng ký vào topic `/my_topic` và in ra nội dung của các messages nhận được.
3. Chạy cả node publisher và node subscriber để kiểm tra xem chúng có giao tiếp với nhau hay không.

Phần 6: Messages, Services và Actions

1. Messages:

Định nghĩa các messages tùy chỉnh trong thư mục `msg/` của package của bạn.
Ví dụ: `msg/MyMessage.msg`:

```
string data
int32 count
float32 value
```

Sửa đổi `CMakeLists.txt` để tạo interface:

```cmake
find_package(rosidl_default_generators REQUIRED)

rosidl_generate_interfaces(${PROJECT_NAME}
msg/MyMessage.msg
)
```

Thêm dependency vào `package.xml`:

```xml
rosidl_default_generators
rosidl_default_runtime
rosidl_interface_packages
```

Build package.
Sử dụng message trong node của bạn:

```python
from my_package.msg import MyMessage

msg = MyMessage()
msg.data = Hello
msg.count = 10
msg.value = 3.14
publisher_.publish(msg)
```

2. Services:

Định nghĩa các services tùy chỉnh trong thư mục `srv/` của package của bạn.
Ví dụ: `srv/MyService.srv`:

```
int32 a
int32 b
---
int32 sum
```

Sửa đổi `CMakeLists.txt` và `package.xml` tương tự như messages.
Viết server (Python):

```python
from my_package.srv import MyService

def add_two_ints_callback(request, response):
response.sum = request.a + request.b
self.get_logger().info(Incoming request
a: %d b: %d % (request.a, request.b))
return response

srv = self.create_service(MyService, add_two_ints, add_two_ints_callback)
```

Viết client (Python):

```python
from my_package.srv import MyService

client = self.create_client(MyService, add_two_ints)
request = MyService.Request()
request.a = 1
request.b = 2
future = client.call_async(request)
rclpy.spin_until_future_complete(self, future)
result = future.result()
self.get_logger().info(Result: %d % result.sum)
```

3. Actions:

Định nghĩa các actions tùy chỉnh trong thư mục `action/` của package của bạn.
Ví dụ: `action/MyAction.action`:

```
int32 goal
---
int32 result
---
int32 feedback
```

Sửa đổi `CMakeLists.txt` và `package.xml` tương tự như messages.
Viết server (Python):

```python
from my_package.action import MyAction
from rclpy.action import ActionServer

def execute_callback(goal_handle):
self.get_logger().info(Executing goal...)
feedback_msg = MyAction.Feedback()
for i in range(goal_handle.request.goal):
feedback_msg.feedback = i
self.get_logger().info(Feedback: {0}.format(feedback_msg.feedback))
goal_handle.publish_feedback(feedback_msg)
time.sleep(1)

goal_handle.succeed()
result = MyAction.Result()
result.result = goal_handle.request.goal
return result

self._action_server = ActionServer(
self,
MyAction,
my_action,
execute_callback)
```

Viết client (Python):

```python
from my_package.action import MyAction
from rclpy.action import ActionClient

self._action_client = ActionClient(self, MyAction, my_action)
goal_msg = MyAction.Goal()
goal_msg.goal = 10
self._action_client.wait_for_server()
self._send_goal_future = self._action_client.send_goal_async(goal_msg, feedback_callback=self.feedback_callback)

def feedback_callback(self, feedback_msg):
self.get_logger().info(Received feedback: {0}.format(feedback_msg.feedback))
```

Bài tập thực hành 3:

1. Tạo một package mới tên là `my_interfaces`.
2. Định nghĩa một message tùy chỉnh, một service tùy chỉnh và một action tùy chỉnh.
3. Viết một node server và một node client cho service và action.
4. Kiểm tra xem chúng có hoạt động đúng cách hay không.

Phần 7: TF2 (Transform Library)

1. TF2 là gì? Tại sao lại cần TF2?

TF2 (Transform Library) là một thư viện cho phép bạn theo dõi các hệ tọa độ khác nhau trong một hệ thống robot.
TF2 giúp bạn chuyển đổi dữ liệu giữa các hệ tọa độ khác nhau, ví dụ như chuyển đổi tọa độ của một vật thể từ hệ tọa độ của camera sang hệ tọa độ của robot.

2. Broadcast và Listen Transforms:

Broadcaster:

Node publish thông tin về mối quan hệ giữa các hệ tọa độ.

Listener:

Node subscribe thông tin về mối quan hệ giữa các hệ tọa độ và sử dụng nó để chuyển đổi dữ liệu.

3. Ví dụ:

Tạo một package mới tên là `my_tf2`.
Viết một node broadcaster (Python hoặc C++) publish transform giữa hai frames, ví dụ `world` và `base_link`.
Viết một node listener (Python hoặc C++) subscribe transform và in ra thông tin về transform.

4. Sử dụng `tf2_ros`:

`tf2_ros.TransformBroadcaster`: Publish transforms.
`tf2_ros.TransformListener`: Subscribe transforms.
`tf2_ros.BufferClient`: Buffer để lưu trữ transforms.

Bài tập thực hành 4:

1. Tạo một package mới tên là `my_tf2_robot`.
2. Giả sử bạn có một robot với camera gắn trên đó.
3. Viết một node broadcaster publish transform giữa `base_link` (hệ tọa độ của robot) và `camera_link` (hệ tọa độ của camera).
4. Viết một node listener subscribe transform và chuyển đổi tọa độ của một điểm từ `camera_link` sang `base_link`.

Phần 8: Mô phỏng Robot với Gazebo

1. Gazebo là gì?

Gazebo là một trình mô phỏng robot 3D mạnh mẽ cho phép bạn mô phỏng các môi trường và robot phức tạp.
Gazebo cung cấp các tính năng như mô phỏng vật lý, cảm biến, và giao diện điều khiển.

2. Cài đặt Gazebo:

```bash
sudo apt install ros-foxy-gazebo-ros-pkgs
```

3. Tạo mô hình robot (SDF hoặc URDF):

URDF (Unified Robot Description Format) là một định dạng XML để mô tả cấu trúc của robot.
SDF (Simulation Description Format) là một định dạng XML khác được sử dụng bởi Gazebo để mô tả thế giới và robot.

4. Launch Gazebo với ROS2:

Tạo một launch file (Python) để khởi động Gazebo và các node ROS2.
Ví dụ:

```python
import os

from ament_index_python.packages import get_package_share_directory

from launch import LaunchDescription
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch_ros.actions import Node

def generate_launch_description():
gazebo_ros_path = get_package_share_directory(gazebo_ros)

Launch Gazebo
gazebo = IncludeLaunchDescription(
PythonLaunchDescriptionSource(
os.path.join(gazebo_ros_path, launch, gazebo.launch.py),
)
)

Spawn robot
spawn_entity = Node(package=gazebo_ros, executable=spawn_entity.py,
arguments=[-topic, robot_description,
-entity, my_robot],
output=screen)

return LaunchDescription([
gazebo,
spawn_entity,
])
```

5. Điều khiển robot trong Gazebo bằng ROS2:

Sử dụng các topics để gửi lệnh điều khiển đến robot.
Ví dụ, bạn có thể sử dụng topic `/cmd_vel` để điều khiển vận tốc của robot.

Bài tập thực hành 5:

1. Tạo một package mới tên là `my_robot_simulation`.
2. Tạo một mô hình robot đơn giản (ví dụ, một robot hình hộp) bằng URDF.
3. Tạo một launch file để khởi động Gazebo và spawn robot của bạn vào thế giới.
4. Viết một node điều khiển (Python hoặc C++) để điều khiển robot di chuyển trong Gazebo.

Phần 9: Điều khiển Robot Thực tế bằng ROS2

1. Kết nối robot với ROS2:

Sử dụng giao thức truyền thông thích hợp (ví dụ, Ethernet, Serial) để kết nối robot với máy tính đang chạy ROS2.
Cài đặt các drivers cần thiết cho robot của bạn.

2. Viết các node điều khiển:

Viết các node ROS2 để đọc dữ liệu từ cảm biến của robot và gửi lệnh điều khiển đến các actuators của robot.

3. Sử dụng các thư viện điều khiển:

Sử dụng các thư viện điều khiển ROS2 (ví dụ, `ros2_control`) để xây dựng các bộ điều khiển phức tạp hơn.

4. Calibration:

Calibration các cảm biến và actuators của robot để đảm bảo độ chính xác.

Lưu ý quan trọng:

Phần này yêu cầu bạn có một robot thực tế để thực hành. Nếu bạn không có robot, bạn có thể bỏ qua phần này hoặc sử dụng một robot ảo trong Gazebo.

Lời khuyên:

Thực hành thường xuyên:

Cách tốt nhất để học ROS2 là thực hành. Hãy thử viết các node và package của riêng bạn để giải quyết các bài toán khác nhau.

Tham khảo tài liệu:

ROS2 có tài liệu rất tốt. Hãy tham khảo tài liệu ROS2 để tìm hiểu thêm về các khái niệm và công cụ khác nhau.

Tham gia cộng đồng:

Tham gia cộng đồng ROS2 để được hỗ trợ và chia sẻ kiến thức với những người khác.

Nguồn tài liệu tham khảo:

ROS2 Documentation:

[https://docs.ros.org/en/foxy/](https://docs.ros.org/en/foxy/)

ROS2 Tutorials:

[https://docs.ros.org/en/foxy/Tutorials.html](https://docs.ros.org/en/foxy/Tutorials.html)

Đây là một để bạn bắt đầu học lập trình robot với ROS2 Foxy. Hãy nhớ rằng, học lập trình robot là một quá trình liên tục. Hãy kiên nhẫn và tiếp tục học hỏi! Chúc bạn thành công!

Nếu bạn có bất kỳ câu hỏi nào, đừng ngần ngại hỏi! Tôi ở đây để giúp bạn.

Contact seller Share

Comments