` with your ROS version (e.g., kinetic, melodic, noetic).
+
+### Computational Graph Demonstration
+
+Next, we'll demonstrate the computational graph using ROS's built-in turtle simulation.
+
+1. **Run the Example:**
+ Follow the previous instructions to run the turtle simulation.
+
+2. **View the Computational Graph:**
+ Open a new terminal and enter:
+ ```bash
+ rqt_graph
+ ```
+ or
+ ```bash
+ rosrun rqt_graph rqt_graph
+ ```
+
+You will see a network topology graph that displays the relationships between different nodes, similar to the image below.
+
+ 
\ No newline at end of file
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.3-ROS Architecture/images/computatioinal.png b/6-Robotics/6.1-Introduction to ROS/6.1.3-ROS Architecture/images/computatioinal.png
new file mode 100644
index 0000000..3f0a15f
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.3-ROS Architecture/images/computatioinal.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.3-ROS Architecture/images/filesystem.jpg b/6-Robotics/6.1-Introduction to ROS/6.1.3-ROS Architecture/images/filesystem.jpg
new file mode 100644
index 0000000..ea44b12
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.3-ROS Architecture/images/filesystem.jpg differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/README.md b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/README.md
new file mode 100644
index 0000000..a19059b
--- /dev/null
+++ b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/README.md
@@ -0,0 +1,935 @@
+# 6.1.4-ROS Communication Mechanism:
+
+## Topic Communication Tutorial
+
+### Introduction to Topic Communication
+
+In ROS, topic communication is one of the fundamental ways for nodes to exchange information. This tutorial will guide you through the process of setting up basic topic communication using both C++ and Python. We will implement a simple publisher-subscriber model where the publisher sends text messages at a frequency of 10Hz, and the subscriber receives and prints these messages.
+
+
+
+ 
+
+
+#### 1. Theoretical Model
+
+Topic communication involves three main components:
+- **ROS Master**: Manages the registration and connection of nodes.
+- **Talker** (Publisher): Sends messages.
+- **Listener** (Subscriber): Receives messages.
+
+The ROS Master helps establish connections between Talkers and Listeners. Here's a step-by-step breakdown of how the communication happens:
+
+- **Talker Registration**: The Talker registers itself with the ROS Master, including the topic name of its messages.
+- **Listener Registration**: The Listener registers itself with the ROS Master, specifying the topic it wants to subscribe to.
+- **Matching**: The ROS Master matches the Talker and Listener based on the topic name and sends the necessary connection information.
+- **Connection Establishment**: The Listener requests a connection to the Talker, and the Talker confirms it.
+- **Message Exchange**: Once connected, the Talker starts sending messages to the Listener.
+
+**Key Points**:
+- The ROS Master is only needed for establishing the connection.
+- The communication continues even if the ROS Master is shut down after the connection is established.
+- Multiple Talkers and Listeners can exist, and they can start in any order.
+
+#### 2. Basic Topic Communication Operations (C++)
+
+**Objective**: Create a publisher node that sends text messages at 10Hz and a subscriber node that prints the received messages.
+
+**Steps**:
+
+0. **[Create package](../6.1.2-Quick%20Experience%20with%20HelloWorld%20for%20ROS/README.md)**
+ ```bash
+ cd ~/seeed_ws/src/
+ catkin_create_pkg listener_and_talker roscpp rospy std_msgs
+ cd ~/seeed_ws/src/listener_and_talker/src
+ touch listener.cpp talker.cpp
+ ```
+
+1. **Publisher Implementation**:
+
+ `talker.cpp`
+ ```cpp
+ #include "ros/ros.h"
+ #include "std_msgs/String.h"
+ #include
+
+ int main(int argc, char *argv[]) {
+ // Set locale for printing messages in the local language
+ setlocale(LC_ALL, "");
+ // Initialize the ROS node with a unique name
+ ros::init(argc, argv, "talker");
+ // Create a ROS node handle
+ ros::NodeHandle nh;
+ // Create a publisher object
+ ros::Publisher pub = nh.advertise("chatter", 10);
+
+ std_msgs::String msg;
+ std::string msg_front = "Hello Seeed";
+ int count = 0;
+ ros::Rate r(10); // 10Hz
+
+ while (ros::ok()) {
+ std::stringstream ss;
+ ss << msg_front << count;
+ msg.data = ss.str();
+ pub.publish(msg);
+ ROS_INFO("Sent message: %s", msg.data.c_str());
+ r.sleep();
+ count++;
+ }
+ return 0;
+ }
+ ```
+
+2. **Subscriber Implementation**:
+
+ `listener.cpp`
+ ```cpp
+ #include "ros/ros.h"
+ #include "std_msgs/String.h"
+
+ void doMsg(const std_msgs::String::ConstPtr& msg_p) {
+ ROS_INFO("Heard: %s", msg_p->data.c_str());
+ }
+
+ int main(int argc, char *argv[]) {
+ setlocale(LC_ALL, "");
+ ros::init(argc, argv, "listener");
+ ros::NodeHandle nh;
+ ros::Subscriber sub = nh.subscribe("chatter", 10, doMsg);
+ ros::spin();
+ return 0;
+ }
+ ```
+
+3. **CMakeLists.txt Configuration**:
+
+ Add flowing code in the end of your packages's `CMakeLists.txt`:
+ ```cmake
+ add_executable(listener src/listener.cpp)
+ add_executable(talker src/talker.cpp)
+
+ target_link_libraries(listener ${catkin_LIBRARIES})
+ target_link_libraries(talker ${catkin_LIBRARIES})
+ ```
+
+
+ 
+
+
+
+4. **Running the Code**:
+ - Open a terminal and start `roscore`:
+ ```bash
+ roscore
+ ```
+ - In a new terminal, navigate to your workspace and run the publisher node:
+ ```bash
+ rosrun listener_and_talker listener
+ ```
+ - In another terminal, run the subscriber node:
+ ```bash
+ rosrun listener_and_talker talker
+ ```
+
+
+ 
+
+
+
+
+
+ 
+
+
+
+You should see messages being published and received, displayed in the terminal.
+
+#### 3. Basic Topic Communication Operations (Python)
+
+**Objective**: Create a publisher node that sends text messages at 10Hz and a subscriber node that prints the received messages.
+
+**Steps**:
+
+0. **[Create package](../6.1.2-Quick%20Experience%20with%20HelloWorld%20for%20ROS/README.md)**
+ ```bash
+ cd ~/seeed_ws/src/
+ catkin_create_pkg listener_and_talker roscpp rospy std_msgs
+ mkdir ~/seeed_ws/src/listener_and_talker/script
+ cd ~/seeed_ws/src/listener_and_talker/script
+ touch listener.py talker.py
+ ```
+
+1. **Publisher Implementation**:
+
+ `talker.py`
+ ```python
+ #!/usr/bin/env python
+ import rospy
+ from std_msgs.msg import String
+
+ if __name__ == "__main__":
+ rospy.init_node("talker_p")
+ pub = rospy.Publisher("chatter", String, queue_size=10)
+ msg = String()
+ msg_front = "hello ä½ å„½"
+ count = 0
+ rate = rospy.Rate(10) # 10Hz
+
+ while not rospy.is_shutdown():
+ msg.data = msg_front + str(count)
+ pub.publish(msg)
+ rospy.loginfo("Sent message: %s", msg.data)
+ rate.sleep()
+ count += 1
+ ```
+
+2. **Subscriber Implementation**:
+
+ `listener.py`
+ ```python
+ #!/usr/bin/env python
+ import rospy
+ from std_msgs.msg import String
+
+ def doMsg(msg):
+ rospy.loginfo("Heard: %s", msg.data)
+
+ if __name__ == "__main__":
+ rospy.init_node("listener_p")
+ sub = rospy.Subscriber("chatter", String, doMsg, queue_size=10)
+ rospy.spin()
+ ```
+
+3. **Add Executable Permissions**:
+ ```bash
+ sudo chmod +x *.py
+ ```
+
+4. **CMakeLists.txt Configuration**:
+
+ Add flowing code in the end of your packages's `CMakeLists.txt`:
+ ```cmake
+ catkin_install_python(PROGRAMS
+ scripts/talker.py
+ scripts/listener.py
+ DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+ )
+ ```
+
+5. **Running the Code**:
+ - Open a terminal and start `roscore`:
+ ```bash
+ roscore
+ ```
+ - In a new terminal, navigate to your workspace and run the publisher node:
+ ```bash
+ rosrun listener_and_talker talker.py
+ ```
+ - In another terminal, run the subscriber node:
+ ```bash
+ rosrun listener_and_talker listener.py
+ ```
+
+You should see messages being published and received, displayed in the terminal.
+
+### ROS Topic Common Commands
+
+- `rostopic bw`: Display bandwidth usage of a topic
+- `rostopic delay`: Display delay of a topic with a header
+- `rostopic echo`: Print messages to the screen
+- `rostopic find`: Find topics by type
+- `rostopic hz`: Display publishing frequency of a topic
+- `rostopic info`: Display information about a topic
+- `rostopic list`: List all active topics
+- `rostopic pub`: Publish data to a topic
+- `rostopic type`: Print the type of a topic
+
+----
+## Introduction to Service Communication
+
+Service communication in ROS differs from topic communication by being bidirectional. It allows not only the sending of messages but also receiving feedback. This model consists of two main parts:
+1. **Client**: The entity that sends a request.
+2. **Server**: The entity that processes the request and sends back a response.
+
+When a client sends a request to a server, it waits for the server to process the request and return a response. This mechanism follows a "request-reply" structure, completing the communication.
+
+#### How it work?
+- **Node B** (the server) provides a service interface, usually named something like `/service_name`.
+- **Node A** (the client) sends a request to Node B.
+- Node B processes the request and sends back a response.
+
+The communication process can be illustrated as follows:
+
+1. **Talker Node advertises a service via ROS Master:**
+ - The Talker node advertises a service (e.g., `advertiseService("bar", foo:1234)`) via the ROS Master, indicating its availability.
+
+2. **Listener Node looks up the service via ROS Master:**
+ - The Listener node sends a request to the ROS Master to find the service (e.g., `lookupService("bar")`).
+
+3. **ROS Master returns the service address:**
+ - The ROS Master responds with the service address (e.g., `foo:3456`) for the Listener node to connect.
+
+4. **Listener Node requests data from Talker Node:**
+ - The Listener node sends a service request to the Talker node, using XML/RPC for communication.
+
+5. **Talker Node replies with the requested data:**
+ - The Talker node processes the request and sends back the reply data over TCP.
+
+
+
+ 
+
+
+**Key Points**:
+- The client is blocked until it receives a response from the server.
+- Service communication is efficient, as it only consumes resources when needed (i.e., when a request is made).
+
+#### Theoretical Model
+
+The service communication model involves three key components:
+
+1. **ROS Master**: Manages the registration of both servers and clients, helping to establish connections based on matching service names.
+2. **Server**: Provides the service.
+3. **Client**: Requests the service.
+
+**Process Overview**:
+
+1. **Server Registration**:
+ - The server registers itself with the ROS Master, including the service name it provides.
+
+2. **Client Registration**:
+ - The client registers itself with the ROS Master, specifying the service it wants to use.
+
+3. **Matching and Connection**:
+ - The ROS Master matches the client and server based on the service name and facilitates the connection.
+
+4. **Request-Response Cycle**:
+ - The client sends a request to the server, which processes the request and returns a response.
+
+#### Topic vs. Service Communication
+
+Let's compare these two most common ROS communication methods to deepen our understanding:
+
+| **Aspect** | **Topic Communication** | **Service Communication** |
+|--------------------|-------------------------|---------------------------|
+| Communication Type | Asynchronous | Synchronous |
+| Protocol | TCP/IP | TCP/IP |
+| Communication Model| Publish-Subscribe | Request-Reply |
+| Relationship | Many-to-Many | One-to-Many |
+| Characteristics | Callback-based | Remote Procedure Call (RPC)|
+| Use Cases | Continuous, high-frequency data | Low-frequency, specific tasks |
+| Example | Publishing LiDAR data | Triggering a sensor or taking a photo |
+
+**Note**: Remote Procedure Call (RPC) refers to executing a function on a different process as if it were local.
+
+#### 5. Creating a Custom Service (srv) in ROS
+
+Let's dive into a hands-on example where we create a custom service that sums two integers sent by the client. The server will process this request and return the sum to the client.
+
+**Steps to Implement**:
+1. **Create a New Package**
+ ```bash
+ cd ~/seeed_ws/src
+ catkin_create_pkg service_communication roscpp rospy std_msgs
+ cd ~/seeed_ws
+ catkin_make
+ ```
+1. **Define the srv File**:
+ The `srv` file defines the structure of the request and response. In this case, the request will contain two integers, and the response will contain their sum.
+ Create a new directory called `srv` in your package and add a file named `AddInts.srv`:
+ ```bash
+ mkdir ~/seeed_ws/src/service_communication/srv
+ cd ~/seeed_ws/src/service_communication/srv
+ touch AddInts.srv
+ ```
+ Copy flowing to `AddInts.srv`:
+ ```srv
+ int32 num1
+ int32 num2
+ ---
+ int32 sum
+ ```
+
+
+ 
+
+
+
+2. **Update the package.xml**:
+ Add the necessary dependencies for generating message files in package's `package.xml`:
+ ```xml
+ message_generation
+ message_runtime
+ ```
+
+
+ 
+
+
+3. **Update CMakeLists.txt**:
+ - Include the necessary configurations to generate the service files in package's `CMakeLists.txt`:
+ ```cmake
+ find_package(catkin REQUIRED COMPONENTS
+ roscpp
+ rospy
+ std_msgs
+ message_generation
+ )
+
+ add_service_files(
+ FILES
+ AddInts.srv
+ )
+
+ generate_messages(
+ DEPENDENCIES
+ std_msgs
+ )
+ ```
+
+
+ 
+
+
+
+
+4. **Compile Your Package**:
+ - Compile your package to generate the service message headers:
+ ```bash
+ cd ~/seeed_ws
+ catkin_make
+ source devel/setup.bash
+ ```
+
+### Implementing Service Communication (C++)
+
+This example demonstrates how to implement service communication in ROS using C++. We will create a simple service where the server adds two integers provided by the client and returns the sum.
+
+**1. Server Implementation:**
+
+`add_two_ints_server.cpp`
+```cpp
+#include "ros/ros.h"
+#include "service_communication/AddInts.h"
+
+// Callback function to handle the client's request
+bool add(service_communication::AddInts::Request &req,
+ service_communication::AddInts::Response &res) {
+ res.sum = req.num1 + req.num2; // Compute the sum
+ ROS_INFO("Request: a=%ld, b=%ld", (long int)req.num1, (long int)req.num2);
+ ROS_INFO("Sending back response: [%ld]", (long int)res.sum);
+ return true;
+}
+
+int main(int argc, char **argv) {
+ ros::init(argc, argv, "add_two_ints_server");
+ ros::NodeHandle nh;
+
+ // Advertise the service to the ROS master
+ ros::ServiceServer service = nh.advertiseService("add_two_ints", add);
+ ROS_INFO("Ready to add two integers.");
+ ros::spin();
+
+ return 0;
+}
+```
+
+**2. Client Implementation:**
+
+`add_two_ints_client.cpp`
+```cpp
+#include "ros/ros.h"
+#include "service_communication/AddInts.h"
+#include
+
+int main(int argc, char **argv) {
+ ros::init(argc, argv, "add_two_ints_client");
+ if (argc != 3) {
+ ROS_INFO("Usage: add_two_ints_client X Y");
+ return 1;
+ }
+
+ ros::NodeHandle nh;
+ ros::ServiceClient client = nh.serviceClient("add_two_ints");
+
+ // Prepare the service request
+ service_communication::AddInts srv;
+ srv.request.num1 = atoll(argv[1]);
+ srv.request.num2 = atoll(argv[2]);
+
+ // Call the service and check if it was successful
+ if (client.call(srv)) {
+ ROS_INFO("Sum: %ld", (long int)srv.response.sum);
+ } else {
+ ROS_ERROR("Failed to call service add_two_ints");
+ return 1;
+ }
+
+ return 0;
+}
+```
+
+**CMakeLists.txt Configuration:**
+
+Make sure to add the following lines in the end of `CMakeLists.txt` to compile both the server and client:
+
+```cmake
+add_executable(add_two_ints_server src/add_two_ints_server.cpp)
+add_executable(add_two_ints_client src/add_two_ints_client.cpp)
+
+add_dependencies(add_two_ints_server ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+add_dependencies(add_two_ints_client ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
+
+target_link_libraries(add_two_ints_server ${catkin_LIBRARIES})
+target_link_libraries(add_two_ints_client ${catkin_LIBRARIES})
+```
+
+#### Compile and run demo
+Open one terminal:
+```bash
+cd ~/seeed_ws
+catkin_make
+roscore
+```
+Open another terminal:
+```bash
+cd ~/seeed_ws
+source devel/setup.bash
+ rosrun service_communication server
+```
+
+Open another terminal:
+```bash
+cd ~/seeed_ws
+source devel/setup.bash
+rosrun service_communication client 1 5
+```
+
+
+
+ 
+
+
+
+#### Implementing Service Communication (Python)
+
+This Python example achieves the same functionality as the C++ example, where a service is used to add two integers.
+
+Create a `scripts` folder under the package and create `add_two_ints_server.py` and `add_two_ints_client.py` files inside it.
+```bash
+cd ~/seeed/src/service_communication/
+mkdir scripts
+cd scripts
+touch add_two_ints_server.py add_two_ints_client.py
+```
+
+**1. Server Implementation:**
+
+`add_two_ints_server.py`
+```python
+#!/usr/bin/env python
+import rospy
+from service_communication.srv import AddInts,AddIntsRequest, AddIntsResponse
+def doReq(req):
+ sum = req.num1 + req.num2
+ rospy.loginfo("data:num1 = %d, num2 = %d, sum = %d",req.num1, req.num2, sum)
+ resp = AddIntsResponse(sum)
+ return resp
+if __name__ == "__main__":
+ rospy.init_node("addints_server_p")
+ server = rospy.Service("AddInts",AddInts,doReq)
+ rospy.spin()
+```
+
+**2. Client Implementation:**
+
+`add_two_ints_client.py`
+```python
+#!/usr/bin/env python
+
+import sys
+import rospy
+from service_communication.srv import *
+
+if __name__ == "__main__":
+ if len(sys.argv) != 3:
+ rospy.logerr("error")
+ sys.exit(1)
+ rospy.init_node("AddInts_Client_p")
+ client = rospy.ServiceProxy("AddInts",AddInts)
+ client.wait_for_service()
+ req = AddIntsRequest()
+ req.num1 = int(sys.argv[1])
+ req.num2 = int(sys.argv[2])
+ resp = client.call(req)
+ rospy.loginfo("result:%d",resp.sum)
+```
+
+**CMakeLists.txt Configuration:**
+
+Add the following lines in your `CMakeLists.txt` for the Python scripts:
+
+```cmake
+catkin_install_python(PROGRAMS
+ scripts/add_two_ints_server.py
+ scripts/add_two_ints_client.py
+ DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+```
+
+#### Compile and run demo
+Open one terminal:
+```bash
+cd ~/seeed_ws
+catkin_make
+roscore
+```
+Open another terminal:
+```bash
+cd ~/seeed_ws
+source devel/setup.bash
+rosrun service_communication add_two_ints_server.py
+```
+
+Open another terminal:
+```bash
+cd ~/seeed_ws
+source devel/setup.bash
+rosrun service_communication add_two_ints_client.py 1 5
+```
+
+
+#### Service Communication Commands
+
+To work with services in ROS, you'll use the `rosservice` command. Here's a list of common `rosservice` commands and their functions:
+
+- `rosservice args`: Print the arguments required by a service
+- `rosservice call`: Call a service with the provided arguments
+- `rosservice find`: Find services by type
+- `rosservice info`: Print information about a service
+- `rosservice list`: List all active services
+- `rosservice type`: Print the type of a service
+- `rosservice uri`: Print the ROSRPC URI of a service
+
+
+---
+## Introduction to the ROS Parameter Server
+
+The ROS Parameter Server is a shared, multi-user, network-accessible storage space for parameters. It provides a way to store and retrieve parameters at runtime, which can be used to configure nodes or share data between them. Parameters on the server can be of various data types, including integers, booleans, strings, doubles, lists, and dictionaries. The Parameter Server is managed by the **ROS Master**, and nodes interact with it by setting, retrieving, or deleting parameters.
+
+### Theoretical Model of the Parameter Server
+
+
+The Parameter Server involves three main roles:
+1. **ROS Master**: Manages the Parameter Server, acting as a central storage for parameters.
+2. **Talker**: A node that sets parameters on the server.
+3. **Listener**: A node that retrieves parameters from the server.
+
+
+The process of interacting with the Parameter Server typically involves the following steps:
+
+1. **Setting Parameters (Talker)**:
+ - The Talker node sends a parameter to the Parameter Server via RPC (Remote Procedure Call), including the parameter's name and value. The ROS Master stores this parameter in its list.
+
+2. **Retrieving Parameters (Listener)**:
+ - The Listener node requests a parameter from the Parameter Server by sending a query with the parameter's name.
+
+3. **Returning Parameters (ROS Master)**:
+ - The ROS Master searches for the requested parameter in its storage and returns the corresponding value to the Listener.
+
+
+
+ 
+
+
+**Supported Data Types**:
+- 32-bit integers
+- Booleans
+- Strings
+- Doubles
+- ISO8601 dates
+- Lists
+- Base64-encoded binary data
+- Dictionaries
+
+### C++ Implementation
+
+**Setting Parameters (C++):**
+
+We'll start by setting various types of parameters on the Parameter Server using two different APIs: `ros::NodeHandle` and `ros::param`.
+
+`set_parameters.cpp`
+```cpp
+#include "ros/ros.h"
+
+int main(int argc, char *argv[]) {
+ ros::init(argc, argv, "set_parameters");
+
+ std::vector students = {"Alice", "Bob", "Charlie", "David"};
+ std::map friends = {{"John", "Doe"}, {"Jane", "Smith"}};
+
+ // Using ros::NodeHandle to set parameters
+ ros::NodeHandle nh;
+ nh.setParam("int_param", 42);
+ nh.setParam("double_param", 3.14159);
+ nh.setParam("bool_param", true);
+ nh.setParam("string_param", "Hello ROS");
+ nh.setParam("vector_param", students);
+ nh.setParam("map_param", friends);
+
+ // Using ros::param to set parameters
+ ros::param::set("int_param_param", 84);
+ ros::param::set("double_param_param", 6.28318);
+ ros::param::set("bool_param_param", false);
+ ros::param::set("string_param_param", "Goodbye ROS");
+ ros::param::set("vector_param_param", students);
+ ros::param::set("map_param_param", friends);
+
+ return 0;
+}
+```
+ Add flowing code in end of your package's `CMakeLists.txt`:
+
+ ```cmake
+ add_executable(set_parameters src/set_parameters.cpp)
+ target_link_libraries(set_parameters ${catkin_LIBRARIES})
+ ```
+
+In this example:
+- We set various types of parameters on the Parameter Server, including integers, doubles, booleans, strings, vectors, and maps.
+- We used both `ros::NodeHandle` and `ros::param` APIs to set the parameters.
+
+**Retrieving Parameters (C++):**
+
+Next, we'll retrieve the parameters that we previously set on the Parameter Server.
+
+`get_parameters.cpp`
+```cpp
+#include "ros/ros.h"
+
+int main(int argc, char *argv[]) {
+ ros::init(argc, argv, "get_parameters");
+
+ // Using ros::NodeHandle to retrieve parameters
+ ros::NodeHandle nh;
+ int int_value;
+ double double_value;
+ bool bool_value;
+ std::string string_value;
+ std::vector students;
+ std::map friends;
+
+ nh.getParam("int_param", int_value);
+ nh.getParam("double_param", double_value);
+ nh.getParam("bool_param", bool_value);
+ nh.getParam("string_param", string_value);
+ nh.getParam("vector_param", students);
+ nh.getParam("map_param", friends);
+
+ ROS_INFO("Retrieved values:");
+ ROS_INFO("int_param: %d", int_value);
+ ROS_INFO("double_param: %.5f", double_value);
+ ROS_INFO("bool_param: %d", bool_value);
+ ROS_INFO("string_param: %s", string_value.c_str());
+
+ for (const auto &student : students) {
+ ROS_INFO("Student: %s", student.c_str());
+ }
+
+ for (const auto &friend_pair : friends) {
+ ROS_INFO("Friend: %s = %s", friend_pair.first.c_str(), friend_pair.second.c_str());
+ }
+
+ return 0;
+}
+```
+
+Add flowing code in end of your package's `CMakeLists.txt`:
+
+```cmake
+add_executable(get_parameters src/get_parameters.cpp)
+target_link_libraries(get_parameters ${catkin_LIBRARIES})
+```
+
+In this example:
+- We retrieve the parameters set on the server using the `ros::NodeHandle` API.
+- The retrieved parameters are then printed to the ROS log for verification.
+
+**Deleting Parameters (C++):**
+
+Finally, let's see how to delete parameters from the Parameter Server.
+
+``delete_parameters.cpp``
+```cpp
+#include "ros/ros.h"
+
+int main(int argc, char *argv[]) {
+ ros::init(argc, argv, "delete_parameters");
+
+ ros::NodeHandle nh;
+ bool success;
+
+ // Using ros::NodeHandle to delete parameters
+ success = nh.deleteParam("int_param");
+ ROS_INFO("Delete int_param: %s", success ? "Success" : "Failure");
+
+ // Using ros::param to delete parameters
+ success = ros::param::del("int_param_param");
+ ROS_INFO("Delete int_param_param: %s", success ? "Success" : "Failure");
+
+ return 0;
+}
+```
+Add flowing code in end of your package's `CMakeLists.txt`:
+
+```cmake
+add_executable(delete_parameters src/delete_parameters.cpp)
+target_link_libraries(delete_parameters ${catkin_LIBRARIES})
+```
+
+In this example:
+- We use both `ros::NodeHandle` and `ros::param` APIs to delete parameters from the server.
+- The success of the deletion is logged.
+
+### 2.2 Python Implementation
+
+**Setting Parameters (Python):**
+
+Let's now set parameters using Python. The process is very similar to the C++ version.
+
+```python
+#!/usr/bin/env python
+
+import rospy
+
+if __name__ == "__main__":
+ rospy.init_node("set_parameters_py")
+
+ # Setting various types of parameters
+ rospy.set_param("int_param", 42)
+ rospy.set_param("double_param", 3.14159)
+ rospy.set_param("bool_param", True)
+ rospy.set_param("string_param", "Hello ROS")
+ rospy.set_param("list_param", ["apple", "banana", "cherry"])
+ rospy.set_param("dict_param", {"first_name": "John", "last_name": "Doe"})
+
+ # Modifying a parameter
+ rospy.set_param("int_param", 84)
+```
+
+Add flowing code in end of your package's `CMakeLists.txt`:
+
+```cmake
+catkin_install_python(PROGRAMS
+ scripts/set_parameters_py.py
+ DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+```
+
+In this example:
+- We set various types of parameters, including integers, doubles, booleans, strings, lists, and dictionaries.
+- We also demonstrate modifying an existing parameter.
+
+**Retrieving Parameters (Python):**
+
+Next, we'll retrieve the parameters that we set.
+
+```python
+#!/usr/bin/env python
+
+import rospy
+
+if __name__ == "__main__":
+ rospy.init_node("get_parameters_py")
+
+ # Retrieving parameters
+ int_value = rospy.get_param("int_param", 0)
+ double_value = rospy.get_param("double_param", 0.0)
+ bool_value = rospy.get_param("bool_param", False)
+ string_value = rospy.get_param("string_param", "")
+ list_value = rospy.get_param("list_param", [])
+ dict_value = rospy.get_param("dict_param", {})
+
+ rospy.loginfo("Retrieved values:")
+ rospy.loginfo("int_param: %d", int_value)
+ rospy.loginfo("double_param: %.5f", double_value)
+ rospy.loginfo("bool_param: %s", bool_value)
+ rospy.loginfo("string_param: %s", string_value)
+ rospy.loginfo("list_param: %s", list_value)
+ rospy.loginfo("dict_param: %s", dict_value)
+```
+
+Add flowing code in end of your package's `CMakeLists.txt`:
+```cmake
+catkin_install_python(PROGRAMS
+ scripts/set_parameters_py.py
+ scripts/get_parameters_py.py
+ DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+```
+
+
+In this example:
+- We use `rospy.get_param` to retrieve parameters set on the server.
+- The retrieved values are logged using `rospy.loginfo`.
+
+**Deleting Parameters (Python):**
+
+Finally, let's delete parameters from the Parameter Server using Python.
+
+```python
+#!/usr/bin/env python
+
+import rospy
+
+if __name__ == "__main__":
+ rospy.init_node("delete_parameters_py")
+
+ try:
+ rospy.delete_param("int_param")
+ rospy.loginfo("int_param deleted successfully.")
+ except KeyError:
+ rospy.logwarn("int_param does not exist.")
+
+ try:
+ rospy.delete_param("non_existent_param")
+ rospy.loginfo("non_existent_param deleted successfully.")
+ except KeyError:
+ rospy.logwarn("non_existent_param does not exist.")
+```
+
+Add flowing code in end of your package's `CMakeLists.txt`:
+```cmake
+catkin_install_python(PROGRAMS
+ scripts/set_parameters_py.py
+ scripts/get_parameters_py.py
+ scripts/delete_parameters_py.py
+ DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+```
+
+In this example:
+- We attempt to delete a parameter and handle the case where the parameter does not exist using exception handling (`KeyError`).
+
+### ROS Parameter Server Common Commands
+`rosparam` includes command-line tools for getting and setting ROS parameters on the parameter server, using YAML-encoded files.
+
+- `rosparam set`: Set a parameter
+- `rosparam get`: Get a parameter
+- `rosparam load`: Load parameters from an external file
+- `rosparam dump`: Dump parameters to an external file
+- `rosparam delete`: Delete a parameter
+- `rosparam list`: List all parameters
+
+Examples:
+
+- `rosparam list`: List all parameters on the parameter server.
+- `rosparam set `: Set a parameter with a specific value.
+- `rosparam get `: Get the value of a specific parameter.
+- `rosparam delete `: Delete a specific parameter.
+- `rosparam load `: Load parameters from a YAML file.
+- `rosparam dump `: Dump the current parameters to a YAML file.
+
+
+
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/CMakeLists.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/CMakeLists.png
new file mode 100644
index 0000000..2f39f35
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/CMakeLists.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Parameter_Server.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Parameter_Server.png
new file mode 100644
index 0000000..e46aaec
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Parameter_Server.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Service.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Service.png
new file mode 100644
index 0000000..45e7ed3
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Service.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Topic.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Topic.png
new file mode 100644
index 0000000..87eff46
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/Topic.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/computatioinal.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/computatioinal.png
new file mode 100644
index 0000000..3f0a15f
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/computatioinal.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/filesystem.jpg b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/filesystem.jpg
new file mode 100644
index 0000000..ea44b12
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/filesystem.jpg differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/package_xml.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/package_xml.png
new file mode 100644
index 0000000..86113af
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/package_xml.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_listener_and_talker.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_listener_and_talker.png
new file mode 100644
index 0000000..56bce4c
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_listener_and_talker.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_listener_and_talker_result.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_listener_and_talker_result.png
new file mode 100644
index 0000000..a367401
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_listener_and_talker_result.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_service_c.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_service_c.png
new file mode 100644
index 0000000..57a0a67
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/run_service_c.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/srv_cmakelists.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/srv_cmakelists.png
new file mode 100644
index 0000000..41cb7c3
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/srv_cmakelists.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/srv_code.png b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/srv_code.png
new file mode 100644
index 0000000..f963e62
Binary files /dev/null and b/6-Robotics/6.1-Introduction to ROS/6.1.4-ROS Communication Mechanism/images/srv_code.png differ
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.5-Common ROS Commands/README.md b/6-Robotics/6.1-Introduction to ROS/6.1.5-Common ROS Commands/README.md
new file mode 100644
index 0000000..725806a
--- /dev/null
+++ b/6-Robotics/6.1-Introduction to ROS/6.1.5-Common ROS Commands/README.md
@@ -0,0 +1,126 @@
+# Common ROS Commands
+
+In a robot system, there may be a few to dozens of nodes running simultaneously. Each node has a unique name, and they communicate using topics, services, messages, parameters, and more. A common challenge arises: when you need to customize a node to communicate with another existing node, how do you retrieve the topic and the message format being used by the other node?
+
+ROS provides a set of useful command-line tools to obtain various information about different nodes. The commonly used commands are as follows:
+
+- **rosnode**: Manage nodes
+- **rostopic**: Manage topics
+- **rosservice**: Manage services
+- **rosmsg**: Manage message types (msg)
+- **rossrv**: Manage service message types (srv)
+- **rosparam**: Manage parameters
+
+These commands are dynamic, unlike the static file system commands. After the ROS program starts, these commands allow you to dynamically retrieve information about running nodes or parameters.
+
+## rosnode
+`rosnode` is used to retrieve information about ROS nodes.
+
+- `rosnode ping`: Test the connectivity status to a node
+- `rosnode list`: List all active nodes
+- `rosnode info`: Print information about a node
+- `rosnode machine`: List nodes running on a specific machine
+- `rosnode kill`: Terminate a node
+- `rosnode cleanup`: Clean up unreachable nodes
+
+## rostopic
+`rostopic` includes command-line tools to display debugging information about ROS topics, such as publishers, subscribers, publishing frequency, and ROS messages. It also includes an experimental Python library for dynamically retrieving information about topics and interacting with them.
+
+- `rostopic bw`: Display bandwidth usage of a topic
+- `rostopic delay`: Display delay of a topic with a header
+- `rostopic echo`: Print messages to the screen
+- `rostopic find`: Find topics by type
+- `rostopic hz`: Display publishing frequency of a topic
+- `rostopic info`: Display information about a topic
+- `rostopic list`: List all active topics
+- `rostopic pub`: Publish data to a topic
+- `rostopic type`: Print the type of a topic
+
+Examples:
+
+- `rostopic list(-v)`: Print the names of topics currently running (with `-v` for detailed information like the number of publishers and subscribers).
+- `rostopic pub /topic_name msg_type "msg_content"`: Publish a message to a topic.
+- `rostopic echo /topic_name`: Retrieve and print the current message being published on a topic.
+- `rostopic info /topic_name`: Get detailed information about a topic, including message type, publisher, and subscriber information.
+- `rostopic hz /topic_name`: Display the publishing frequency of a topic.
+- `rostopic bw /topic_name`: Display the bandwidth usage of a topic.
+
+## 2.4.3 rosmsg
+`rosmsg` is a command-line tool for displaying information about ROS message types.
+
+- `rosmsg show`: Display the description of a message
+- `rosmsg info`: Display detailed information about a message
+- `rosmsg list`: List all message types
+- `rosmsg md5`: Display the MD5 checksum of a message
+- `rosmsg package`: List all messages in a package
+- `rosmsg packages`: List all packages that contain messages
+
+Examples:
+
+- `rosmsg list`: List all message types in the current ROS environment.
+- `rosmsg packages`: List all packages containing message types.
+- `rosmsg package `: List all messages in a specific package.
+- `rosmsg show `: Display the description of a specific message.
+- `rosmsg info `: Similar to `rosmsg show`, it provides information about a message type.
+- `rosmsg md5 `: Generate the MD5 checksum of a message for data integrity checks.
+
+## 2.4.4 rosservice
+`rosservice` includes command-line tools to list and query ROS services.
+
+- `rosservice args`: Print the arguments required by a service
+- `rosservice call`: Call a service with the provided arguments
+- `rosservice find`: Find services by type
+- `rosservice info`: Print information about a service
+- `rosservice list`: List all active services
+- `rosservice type`: Print the type of a service
+- `rosservice uri`: Print the ROSRPC URI of a service
+
+Examples:
+
+- `rosservice list`: List all active services.
+- `rosservice args /service_name`: Print the arguments required by a specific service.
+- `rosservice call /service_name "args"`: Call a service with the provided arguments.
+- `rosservice find `: Find services by their message type.
+- `rosservice info /service_name`: Get detailed information about a service.
+- `rosservice type /service_name`: Get the type of a service.
+- `rosservice uri /service_name`: Get the URI of a service.
+
+## 2.4.5 rossrv
+`rossrv` is a command-line tool for displaying information about ROS service types. It is very similar to `rosmsg` in syntax.
+
+- `rossrv show`: Display the description of a service message
+- `rossrv info`: Display detailed information about a service message
+- `rossrv list`: List all service message types
+- `rossrv md5`: Display the MD5 checksum of a service message
+- `rossrv package`: List all service messages in a package
+- `rossrv packages`: List all packages that contain service messages
+
+Examples:
+
+- `rossrv list`: List all service message types in the current ROS environment.
+- `rossrv packages`: List all packages containing service messages.
+- `rossrv package `: List all service messages in a specific package.
+- `rossrv show `: Display the description of a specific service message.
+- `rossrv info `: Similar to `rossrv show`, it provides information about a service message type.
+- `rossrv md5 `: Generate the MD5 checksum of a service message for data integrity checks.
+
+## 2.4.6 rosparam
+`rosparam` includes command-line tools for getting and setting ROS parameters on the parameter server, using YAML-encoded files.
+
+- `rosparam set`: Set a parameter
+- `rosparam get`: Get a parameter
+- `rosparam load`: Load parameters from an external file
+- `rosparam dump`: Dump parameters to an external file
+- `rosparam delete`: Delete a parameter
+- `rosparam list`: List all parameters
+
+Examples:
+
+- `rosparam list`: List all parameters on the parameter server.
+- `rosparam set `: Set a parameter with a specific value.
+- `rosparam get `: Get the value of a specific parameter.
+- `rosparam delete `: Delete a specific parameter.
+- `rosparam load `: Load parameters from a YAML file.
+- `rosparam dump `: Dump the current parameters to a YAML file.
+
+These commands allow you to interact with different components of the ROS ecosystem dynamically, providing a powerful way to manage and monitor your ROS-based robot system.
\ No newline at end of file
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.6-ROS Operation Management/README.md b/6-Robotics/6.1-Introduction to ROS/6.1.6-ROS Operation Management/README.md
new file mode 100644
index 0000000..8c3d4a6
--- /dev/null
+++ b/6-Robotics/6.1-Introduction to ROS/6.1.6-ROS Operation Management/README.md
@@ -0,0 +1,868 @@
+# 6.1.6-ROS Operation Management
+
+## Managing ROS Nodes with Launch Files
+
+Launch files in ROS are XML-formatted files used to start and manage multiple ROS nodes efficiently. This section covers the various tags available in launch files, including their attributes and use cases.
+
+### The `` Tag
+
+The `` tag is the root of every launch file and acts as a container for all other tags.
+
+#### 1. Attributes
+- **deprecated="deprecation statement"**
+ Indicates to the user that the current launch file has been deprecated.
+
+#### 2. Child Tags
+- All other tags in a launch file are child elements of the `` tag.
+
+#### Example:
+```xml
+
+
+
+```
+
+### The `` Tag
+
+The `` tag is used to specify a ROS node to be launched. It's one of the most commonly used tags in a launch file. Note that the `roslaunch` command does not guarantee that nodes will start in the order they are declared, as the node startup process is multi-threaded.
+
+#### 1. Attributes
+- **pkg="package_name"**
+ Specifies the package to which the node belongs.
+
+- **type="nodeType"**
+ The type of the node, which corresponds to the executable file name.
+
+- **name="nodeName"**
+ The name of the node within the ROS network topology.
+
+- **args="xxx xxx xxx"** (optional)
+ Passes arguments to the node.
+
+- **machine="machine_name"**
+ Specifies the machine on which the node should be launched.
+
+- **respawn="true | false"** (optional)
+ Determines whether the node should automatically restart if it exits.
+
+- **respawn_delay="N"** (optional)
+ If `respawn` is set to true, this defines a delay of N seconds before the node is restarted.
+
+- **required="true | false"** (optional)
+ Indicates whether this node is critical. If set to true, the entire `roslaunch` process will be terminated if the node exits.
+
+- **ns="namespace"** (optional)
+ Launches the node within the specified namespace.
+
+- **clear_params="true | false"** (optional)
+ Clears all parameters in the node's private namespace before the node starts.
+
+- **output="log | screen"** (optional)
+ Determines where the log output should be sent: either to a log file or the screen. The default is `log`.
+
+#### 2. Child Tags
+- **env**: Used for setting environment variables.
+- **remap**: Used for remapping topic or service names.
+- **rosparam**: Used for setting parameters.
+- **param**: Used for setting parameters.
+
+#### Example:
+```xml
+
+
+
+
+
+
+```
+
+### The `` Tag
+
+The `` tag is used to include another XML-formatted launch file into the current launch file. This allows for modular and reusable configurations.
+
+#### 1. Attributes
+- **file="$(find package_name)/path/to/file.launch"**
+ Specifies the path to the launch file to be included.
+
+- **ns="namespace"** (optional)
+ Includes the file under the specified namespace.
+
+#### 2. Child Tags
+- **env**: Used for setting environment variables.
+- **arg**: Used to pass arguments to the included launch file.
+
+#### Example:
+```xml
+
+
+
+```
+
+### The `` Tag
+
+The `` tag is used to remap ROS topic or service names. This is useful for avoiding name conflicts or standardizing names across different nodes.
+
+#### 1. Attributes
+- **from="xxx"**
+ The original topic or service name.
+
+- **to="yyy"**
+ The new name for the topic or service.
+
+#### 2. Child Tags
+- None
+
+#### Example:
+```xml
+
+
+
+
+
+```
+
+### The `` Tag
+
+The `` tag is used to set parameters on the ROS parameter server. The source of the parameter can be specified directly in the tag or loaded from an external file. When used inside a `` tag, the parameter is set within the node's private namespace.
+
+#### 1. Attributes
+- **name="namespace/parameter_name"**
+ The name of the parameter, which can include a namespace.
+
+- **value="xxx"** (optional)
+ Defines the value of the parameter. If omitted, an external file must be specified as the parameter source.
+
+- **type="str | int | double | bool | yaml"** (optional)
+ Specifies the type of the parameter. If not specified, `roslaunch` will attempt to infer the type based on the value:
+ - Numbers with a `.` are parsed as floating-point (double).
+ - The strings "true" and "false" are parsed as boolean values (case-insensitive).
+ - Everything else is parsed as a string.
+
+#### 2. Child Tags
+- None
+
+#### Example:
+```xml
+
+
+
+
+
+```
+
+### The `` Tag
+
+The `` tag allows parameters to be loaded from a YAML file, exported to a YAML file, or deleted. When used inside a `` tag, the parameters are considered private.
+
+#### 1. Attributes
+- **command="load | dump | delete"** (optional, default is `load`)
+ Specifies the operation to perform: load parameters from a file, export them to a file, or delete them.
+
+- **file="$(find package_name)/path/to/file.yaml"**
+ Specifies the YAML file to load or export parameters.
+
+- **param="parameter_name"**
+ The name of the parameter.
+
+- **ns="namespace"** (optional)
+ Specifies the namespace for the parameters.
+
+#### 2. Child Tags
+- None
+
+#### Example:
+```xml
+
+
+
+```
+
+## The `` Tag
+
+The `` tag is used to group nodes and other tags, and it allows for applying a namespace or other settings to the group as a whole.
+
+#### 1. Attributes
+- **ns="namespace"** (optional)
+ Applies a namespace to all nodes and parameters within the group.
+
+- **clear_params="true | false"** (optional)
+ Clears all parameters in the group's namespace before the group is launched. Use with caution as this can remove critical parameters.
+
+#### 2. Child Tags
+- Any tags except the `` tag can be children of ``.
+
+#### Example:
+```xml
+
+
+
+
+
+
+```
+
+### The `` Tag
+
+The `` tag is used to define dynamic arguments that can be passed to the launch file at runtime, similar to function parameters. This increases the flexibility of launch files.
+
+#### 1. Attributes
+- **name="argument_name"**
+ The name of the argument.
+
+- **default="default_value"** (optional)
+ Specifies the default value for the argument.
+
+- **value="value"** (optional)
+ Specifies the value for the argument. Cannot be used simultaneously with `default`.
+
+- **doc="description"**
+ Provides a description of the argument.
+
+#### 2. Child Tags
+- None
+
+#### 3. Example
+Launch file with argument syntax, `hello.launch`:
+
+```xml
+
+
+
+
+```
+
+Command-line invocation with argument passing:
+
+```bash
+roslaunch hello.launch robot_name:=robot_value
+```
+## ROS Workspace Overlay
+
+Imagine you have two custom workspaces, Workspace A and Workspace B, both containing a package named `turtlesim`. Additionally, the system's built-in workspace also has a package named `turtlesim`. When you invoke the `turtlesim` package, which one will be used?
+
+### Implementation Steps
+
+#### Step 0: Create Workspaces A and B
+First, create two separate workspaces, A and B. Within each workspace, create a package named `turtlesim`.
+
+#### Step 1: Modify the `~/.bashrc` File
+Add the following lines to your `~/.bashrc` file to source the setup files for both workspaces:
+
+```bash
+source /home/user/path/to/workspaceA/devel/setup.bash
+source /home/user/path/to/workspaceB/devel/setup.bash
+```
+
+Replace `/home/user/path/to/` with the actual paths to your workspaces.
+
+#### Step 2: Load Environment Variables
+Open a new terminal and run the following command to load the updated environment variables:
+
+```bash
+source ~/.bashrc
+```
+
+#### Step 3: Check ROS Environment Variables
+To verify the ROS package paths, run:
+
+```bash
+echo $ROS_PACKAGE_PATH
+```
+
+**Result:** The output will show the paths in the following order: Workspace B ā Workspace A ā System Built-in Workspace.
+
+#### Step 4: Invoke the `turtlesim` Package
+Now, run the following command to navigate to the `turtlesim` package:
+
+```bash
+roscd turtlesim
+```
+
+**Result:** You will be directed to the `turtlesim` package within Workspace B.
+
+
+## Handling ROS Node Name Conflicts
+
+### Scenario
+In ROS, each node has a name, which is defined during node initialization. In C++, this is done using the `ros::init(argc, argv, "node_name");` API, while in Python, it's done with `rospy.init_node("node_name")`. In a ROS network topology, nodes must have unique names because if multiple nodes share the same name, it can cause confusion during invocation. Specifically, if a node with a duplicate name is started, the existing node with that name will be shut down automatically. But what if you need to run multiple instances of the same node or deal with name conflicts?
+
+ROS provides two strategies to handle such situations: **namespaces** and **name remapping**.
+
+- **Namespaces** add a prefix to node names.
+- **Name remapping** assigns an alias to a node name.
+
+Both strategies can resolve node name conflicts, and they can be implemented in several ways:
+
+1. Using the `rosrun` command.
+2. Through launch files.
+3. In the node's code.
+
+This section will demonstrate how to use these three methods to avoid node name conflicts.
+
+### Example Scenario
+Let's start two `turtlesim_node` nodes. If you open two terminals and start the nodes directly without any changes, the first node will be shut down when you start the second one. You'll see a warning message:
+
+```plaintext
+[ WARN] [1578812836.351049332]: Shutdown request received.
+[ WARN] [1578812836.351207362]: Reason given for shutdown: [new node registered with same name]
+```
+
+Since nodes cannot share the same name, we'll explore several strategies to address this issue.
+
+## Using `rosrun` for Namespaces and Remapping
+
+### 1. Setting a Namespace with `rosrun`
+
+You can set a namespace for a node using the following syntax:
+
+```bash
+rosrun package_name node_name __ns:=/new_namespace
+```
+
+#### Example:
+```bash
+rosrun turtlesim turtlesim_node __ns:=/xxx
+rosrun turtlesim turtlesim_node __ns:=/yyy
+```
+
+With these commands, both nodes will run without issues.
+
+#### Results:
+Use `rosnode list` to check the nodes:
+
+```plaintext
+/xxx/turtlesim
+/yyy/turtlesim
+```
+
+### 2. Remapping Node Names with `rosrun`
+
+You can also remap a node's name, effectively giving it an alias, using the following syntax:
+
+```bash
+rosrun package_name node_name __name:=new_name
+```
+
+#### Example:
+```bash
+rosrun turtlesim turtlesim_node __name:=t1
+rosrun turtlesim turtlesim_node __name:=t2
+```
+
+With these commands, both nodes will run with their new names.
+
+#### Results:
+Use `rosnode list` to check the nodes:
+
+```plaintext
+/t1
+/t2
+```
+
+### 3. Combining Namespace and Name Remapping with `rosrun`
+
+You can combine both techniques, setting a namespace and remapping the node name simultaneously:
+
+```bash
+rosrun package_name node_name __ns:=/new_namespace __name:=new_name
+```
+
+#### Example:
+```bash
+rosrun turtlesim turtlesim_node __ns:=/xxx __name:=tn
+```
+
+#### Results:
+Use `rosnode list` to check the node:
+
+```plaintext
+/xxx/tn
+```
+
+Alternatively, you can set the namespace using an environment variable before starting the node:
+
+```bash
+export ROS_NAMESPACE=xxxx
+```
+
+## Using Launch Files for Namespaces and Remapping
+
+In launch files, the `` tag includes two important attributes: `name` and `ns`. These are used for name remapping and setting namespaces, respectively. Using a launch file to handle namespaces and name remapping is straightforward.
+
+### 1. Launch File Example
+
+Here's how you can set namespaces and name remapping in a launch file:
+
+```xml
+
+
+
+
+
+```
+
+In this example, the `name` attribute is mandatory, while `ns` is optional.
+
+### 2. Running the Launch File
+
+Run the launch file and then use `rosnode list` to see the results:
+
+```plaintext
+/t1
+/t2
+/hello/t1
+```
+
+## Setting Namespaces and Remapping in Code
+
+If you're implementing custom nodes, you have more flexibility in setting namespaces and name remapping directly in your code.
+
+### 1. C++ Implementation: Name Remapping
+
+You can set a name alias using the following code:
+
+```cpp
+ros::init(argc, argv, "zhangsan", ros::init_options::AnonymousName);
+```
+
+#### Execution:
+This will append a timestamp to the node's name, ensuring it's unique.
+
+### 2. C++ Implementation: Setting a Namespace
+
+You can set a namespace directly in the code like this:
+
+```cpp
+std::map map;
+map["__ns"] = "xxxx";
+ros::init(map, "wangqiang");
+```
+
+#### Execution:
+This sets a namespace for the node, allowing it to run without conflicts.
+
+### 3. Python Implementation: Name Remapping
+
+In Python, you can achieve similar functionality by using the following code:
+
+```python
+rospy.init_node("lisi", anonymous=True)
+```
+---
+## Topic Name Remapping in ROS
+
+In ROS, topic name remapping allows you to change the name of a topic that a node subscribes to or publishes to without modifying the node's code. This is particularly useful when integrating multiple nodes that need to communicate over different topic names. There are three primary methods to remap topic names in ROS:
+
+1. Using the `rosrun` command.
+2. Through launch files.
+3. By directly modifying the code in C++ or Python.
+
+### Using `rosrun` to Remap Topics
+
+The syntax for remapping a topic name with `rosrun` is:
+
+```bash
+rosrun package_name node_name old_topic_name:=new_topic_name
+```
+
+### Example: Integrating `teleop_twist_keyboard` with `turtlesim`
+
+There are two ways to set up communication between the `teleop_twist_keyboard` node and the `turtlesim` display node:
+
+#### 1. Solution 1: Remap `teleop_twist_keyboard` Topic
+
+In this approach, we remap the `teleop_twist_keyboard` node's topic to `/turtle1/cmd_vel`.
+
+- **Start the keyboard control node:**
+
+ ```bash
+ rosrun teleop_twist_keyboard teleop_twist_keyboard.py /cmd_vel:=/turtle1/cmd_vel
+ ```
+
+- **Start the turtlesim display node:**
+
+ ```bash
+ rosrun turtlesim turtlesim_node
+ ```
+
+Both nodes will communicate correctly using the `/turtle1/cmd_vel` topic.
+
+#### 2. Solution 2: Remap `turtlesim` Topic
+
+Alternatively, we can remap the `turtlesim` node's topic to `/cmd_vel`.
+
+- **Start the keyboard control node:**
+
+ ```bash
+ rosrun teleop_twist_keyboard teleop_twist_keyboard.py
+ ```
+
+- **Start the turtlesim display node:**
+
+ ```bash
+ rosrun turtlesim turtlesim_node /turtle1/cmd_vel:=/cmd_vel
+ ```
+
+Both nodes will communicate correctly using the `/cmd_vel` topic.
+
+### Using Launch Files to Remap Topics
+
+You can also remap topics in a launch file. The syntax for remapping a topic in a launch file is:
+
+```xml
+
+
+
+```
+
+### Example: Integrating `teleop_twist_keyboard` with `turtlesim` Using Launch Files
+
+Again, there are two solutions:
+
+#### 1. Solution 1: Remap `teleop_twist_keyboard` Topic
+
+In this approach, we remap the `teleop_twist_keyboard` node's topic to `/turtle1/cmd_vel`.
+
+```xml
+
+
+
+
+
+
+```
+
+Both nodes will communicate correctly.
+
+#### 2. Solution 2: Remap `turtlesim` Topic
+
+In this approach, we remap the `turtlesim` node's topic to `/cmd_vel`.
+
+```xml
+
+
+
+
+
+
+```
+
+Both nodes will communicate correctly.
+
+### Remapping Topics in Code
+
+The topic name in ROS is influenced by the node's namespace, the node's name, and the topic's own name. Topic names can generally be categorized into three types:
+
+1. **Global:** The topic name is absolute and starts with a `/`, making it independent of the node's namespace.
+2. **Relative:** The topic name is relative and does not start with `/`, meaning it is interpreted within the node's namespace.
+3. **Private:** The topic name is private and starts with `~`, meaning it is resolved relative to the node's private namespace.
+
+Let's explore these concepts through examples in C++ and Python.
+
+### 1. C++ Implementation
+
+#### Example Preparation:
+
+1. **Initialize the node with a name:**
+
+ ```cpp
+ ros::init(argc, argv, "hello");
+ ```
+
+2. **Set different types of topic names.**
+3. **Pass a `__ns:=xxx` argument when launching the node.**
+4. **After the node starts, use `rostopic` to check the topic information.**
+
+#### Global Topic Name
+
+Global topic names start with a `/` and are independent of the node's name or namespace.
+
+- **Example 1:**
+
+ ```cpp
+ ros::Publisher pub = nh.advertise("/chatter", 1000);
+ ```
+
+ **Result:** `/chatter`
+
+- **Example 2:**
+
+ ```cpp
+ ros::Publisher pub = nh.advertise("/chatter/money", 1000);
+ ```
+
+ **Result:** `/chatter/money`
+
+#### Relative Topic Name
+
+Relative topic names do not start with a `/` and are resolved relative to the node's namespace.
+
+- **Example 1:**
+
+ ```cpp
+ ros::Publisher pub = nh.advertise("chatter", 1000);
+ ```
+
+ **Result:** `xxx/chatter`
+
+- **Example 2:**
+
+ ```cpp
+ ros::Publisher pub = nh.advertise("chatter/money", 1000);
+ ```
+
+ **Result:** `xxx/chatter/money`
+
+#### Private Topic Name
+
+Private topic names start with `~` and are resolved relative to the node's private namespace.
+
+- **Example 1:**
+
+ ```cpp
+ ros::NodeHandle nh("~");
+ ros::Publisher pub = nh.advertise("chatter", 1000);
+ ```
+
+ **Result:** `/xxx/hello/chatter`
+
+- **Example 2:**
+
+ ```cpp
+ ros::NodeHandle nh("~");
+ ros::Publisher pub = nh.advertise("chatter/money", 1000);
+ ```
+
+ **Result:** `/xxx/hello/chatter/money`
+
+- **Special Case:** When using `~`, if the topic name starts with `/`, the topic name is treated as absolute.
+
+ ```cpp
+ ros::NodeHandle nh("~");
+ ros::Publisher pub = nh.advertise("/chatter/money", 1000);
+ ```
+
+ **Result:** `/chatter/money`
+
+### Python Implementation
+
+#### Example Preparation:
+
+1. **Initialize the node with a name:**
+
+ ```python
+ rospy.init_node("hello")
+ ```
+
+2. **Set different types of topic names.**
+3. **Pass a `__ns:=xxx` argument when launching the node.**
+4. **After the node starts, use `rostopic` to check the topic information.**
+
+#### Global Topic Name
+
+Global topic names start with a `/` and are independent of the node's name or namespace.
+
+- **Example 1:**
+
+ ```python
+ pub = rospy.Publisher("/chatter", String, queue_size=1000)
+ ```
+
+ **Result:** `/chatter`
+
+- **Example 2:**
+
+ ```python
+ pub = rospy.Publisher("/chatter/money", String, queue_size=1000)
+ ```
+
+ **Result:** `/chatter/money`
+
+### Relative Topic Name
+
+Relative topic names do not start with a `/` and are resolved relative to the node's namespace.
+
+- **Example 1:**
+
+ ```python
+ pub = rospy.Publisher("chatter", String, queue_size=1000)
+ ```
+
+ **Result:** `xxx/chatter`
+
+- **Example 2:**
+
+ ```python
+ pub = rospy.Publisher("chatter/money", String, queue_size=1000)
+ ```
+
+ **Result:** `xxx/chatter/money`
+
+#### Private Topic Name
+
+Private topic names start with `~` and are resolved relative to the node's private namespace.
+
+- **Example 1:**
+
+ ```python
+ pub = rospy.Publisher("~chatter", String, queue_size=1000)
+ ```
+
+ **Result:** `/xxx/hello/chatter`
+
+- **Example 2:**
+
+ ```python
+ pub = rospy.Publisher("~chatter/money", String, queue_size=1000)
+ ```
+
+ **Result:** `/xxx/hello/chatter/money`
+
+---
+## Setting Parameters in ROS
+
+In ROS, parameters are used to configure nodes at runtime. They can be set in various ways: using the `rosrun` command, within launch files, or directly in the code. Parameters can be global, relative, or private, depending on how they are defined.
+
+### Setting Parameters with `rosrun`
+
+You can set parameters when launching a node with the `rosrun` command. The syntax for setting parameters is:
+
+```bash
+rosrun package_name node_name _parameter_name:=parameter_value
+```
+
+#### Example: Setting a Parameter for the Turtlesim Node
+
+Let's start the `turtlesim_node` and set a parameter `A = 100`.
+
+```bash
+rosrun turtlesim turtlesim_node _A:=100
+```
+
+#### Check the Parameters
+
+You can use the following command to list all parameters and check the results:
+
+```bash
+rosparam list
+```
+
+**Output:**
+
+```plaintext
+/turtlesim/A
+/turtlesim/background_b
+/turtlesim/background_g
+/turtlesim/background_r
+```
+
+**Explanation:** The parameter `A` is prefixed with the node name (`/turtlesim/`), indicating that when `rosrun` is used to set a parameter, it does so in the private namespace mode.
+
+## Setting Parameters in Launch Files
+
+As previously discussed, parameters can be set in launch files using either the `` or `` tags. Parameters set outside the `` tag are global, while those set within the `` tag are private and relative to the node's namespace.
+
+### Example: Setting Parameters with the `` Tag
+
+Hereās an example where we set a global parameter and a private parameter:
+
+```xml
+
+
+
+
+
+
+```
+
+### Check the Parameters
+
+After running the launch file, you can check the parameters with:
+
+```bash
+rosparam list
+```
+
+**Output:**
+
+```plaintext
+/p1
+/t1/p2
+```
+
+**Explanation:** The parameter `p1` is global, while `p2` is private to the `t1` node, as indicated by the namespace.
+
+## Setting Parameters in Code
+
+Setting parameters in code provides greater flexibility, allowing you to define global, relative, and private parameters programmatically.
+
+### 1. C++ Implementation
+
+In C++, parameters can be set using the `ros::param` API or through a `ros::NodeHandle` object.
+
+#### 1.1 Using `ros::param` to Set Parameters
+
+The `ros::param::set` function is used to set parameters. The functionās first argument is the parameter name, and the second is the parameter value. If the parameter name starts with `/`, it's a global parameter. If it starts with `~`, it's a private parameter. Otherwise, itās a relative parameter.
+
+**Example:**
+
+```cpp
+ros::param::set("/set_A", 100); // Global, independent of namespace and node name
+ros::param::set("set_B", 100); // Relative, dependent on namespace
+ros::param::set("~set_C", 100); // Private, dependent on namespace and node name
+```
+
+Assuming the namespace is `xxx` and the node name is `yyy`, checking the parameters with `rosparam list` would show:
+
+```plaintext
+/set_A
+/xxx/set_B
+/xxx/yyy/set_C
+```
+
+#### Using `ros::NodeHandle` to Set Parameters
+
+To set parameters using `ros::NodeHandle`, first create a `NodeHandle` object, then call the `setParam` method. If the parameter name starts with `/`, it's global. If it doesnāt start with `/`, whether itās relative or private depends on how the `NodeHandle` object was created.
+
+**Example:**
+
+```cpp
+ros::NodeHandle nh;
+nh.setParam("/nh_A", 100); // Global, independent of namespace and node name
+
+nh.setParam("nh_B", 100); // Relative, dependent on namespace
+
+ros::NodeHandle nh_private("~");
+nh_private.setParam("nh_C", 100); // Private, dependent on namespace and node name
+```
+
+Assuming the namespace is `xxx` and the node name is `yyy`, checking the parameters with `rosparam list` would show:
+
+```plaintext
+/nh_A
+/xxx/nh_B
+/xxx/yyy/nh_C
+```
+
+### 2. Python Implementation
+
+In Python, setting parameters is slightly simpler than in C++. The `rospy.set_param` function is used to set parameters. The first argument is the parameter name, and the second is the parameter value. As with C++, if the parameter name starts with `/`, itās global. If it starts with `~`, itās private. Otherwise, itās relative.
+
+**Example:**
+
+```python
+rospy.set_param("/py_A", 100) # Global, independent of namespace and node name
+rospy.set_param("py_B", 100) # Relative, dependent on namespace
+rospy.set_param("~py_C", 100) # Private, dependent on namespace and node name
+```
+
+Assuming the namespace is `xxx` and the node name is `yyy`, checking the parameters with `rosparam list` would show:
+
+```plaintext
+/py_A
+/xxx/py_B
+/xxx/yyy/py_C
+```
+
+
+
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.7-Common Components and Features of ROS/README.md b/6-Robotics/6.1-Introduction to ROS/6.1.7-Common Components and Features of ROS/README.md
new file mode 100644
index 0000000..9bf4aff
--- /dev/null
+++ b/6-Robotics/6.1-Introduction to ROS/6.1.7-Common Components and Features of ROS/README.md
@@ -0,0 +1,89 @@
+# 6.1.7-Common Components and Features of ROS
+
+## Distributed Communication in ROS
+
+ROS (Robot Operating System) is designed as a distributed computing environment. This means that a running ROS system can consist of multiple nodes spread across multiple machines. Depending on the configuration, any node may need to communicate with any other node at any time.
+
+To facilitate this, ROS has specific networking requirements:
+
+1. There must be full bidirectional connectivity between all machines on all ports.
+2. Each machine must announce itself using a name that can be resolved by all other machines.
+
+### Implementation Steps
+
+#### 1. Preparation
+
+Before configuring ROS for distributed communication, ensure that the different computers are on the same network. Ideally, each computer should be assigned a static IP address. If you are using virtual machines, you need to change the network adapter setting to "Bridged Mode" to allow them to interact on the same network.
+
+#### 2. Modify Configuration Files
+
+On each computer, you need to modify the `/etc/hosts` file to include the IP addresses and hostnames of the other machines.
+
+- **On the Host Machine:**
+
+ Add the IP address and hostname of the slave machine.
+
+ ```plaintext
+
+ ```
+
+- **On the Slave Machine:**
+
+ Add the IP address and hostname of the host machine.
+
+ ```plaintext
+
+ ```
+
+After updating the `/etc/hosts` files, use the `ping` command to test if the machines can communicate with each other:
+
+- **Check IP Address:** Use `ifconfig` or `ip addr show`.
+- **Check Hostname:** Use `hostname`.
+
+#### 3. Configure the Host Machine's IP Address
+
+On the host machine, you need to configure the IP address by adding the following lines to the `~/.bashrc` file:
+
+```bash
+export ROS_MASTER_URI=http://:11311
+export ROS_HOSTNAME=
+```
+
+These lines set the `ROS_MASTER_URI` to the host machine's IP address, which tells ROS where the master node (`roscore`) is running. The `ROS_HOSTNAME` sets the hostname for the machine that ROS will use.
+
+#### 4. Configure the Slave Machine's IP Address
+
+On each slave machine (you can have multiple slaves), you also need to modify the `~/.bashrc` file by adding:
+
+```bash
+export ROS_MASTER_URI=http://:11311
+export ROS_HOSTNAME=
+```
+
+This configuration points each slave machine to the host's ROS master, enabling them to join the ROS network.
+
+### Testing the Setup
+
+#### 1. Start `roscore` on the Host Machine
+
+On the host machine, start the ROS master node by running:
+
+```bash
+roscore
+```
+
+This step is crucial because the ROS master node manages the communication between different nodes in the ROS network.
+
+#### 2. Test Communication from the Host to the Slave
+
+- **On the Host Machine:** Start a subscriber node.
+- **On the Slave Machine:** Start a publisher node.
+
+Check if the nodes can communicate as expected.
+
+#### 3. Test Communication from the Slave to the Host
+
+- **On the Slave Machine:** Start a subscriber node.
+- **On the Host Machine:** Start a publisher node.
+
+Again, verify that communication between the nodes is functioning correctly.
diff --git a/6-Robotics/6.1-Introduction to ROS/6.1.8-TF Coordinate Transformation in ROS/README.md b/6-Robotics/6.1-Introduction to ROS/6.1.8-TF Coordinate Transformation in ROS/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/6-Robotics/6.3-Development with Physical ROS Robots/6.3.1-Get started with ROS robots/Basic motion control methods.md b/6-Robotics/6.3-Development with Physical ROS Robots/6.3.1-Get started with ROS robots/Basic motion control methods.md
new file mode 100644
index 0000000..e9ae8ca
--- /dev/null
+++ b/6-Robotics/6.3-Development with Physical ROS Robots/6.3.1-Get started with ROS robots/Basic motion control methods.md
@@ -0,0 +1,71 @@
+
+# Basic motion control methods
+
+### Introduction
+
+This section will introduce how to perform simple motion control of the robot chassis using APP, PS2 controller, or keyboard. All three control methods transmit control commands via Bluetooth.
+
+![]()
+
+---
+
+### Use APP to control robots
+
+##### Obtain Bluetooth APP
+
+For users with Android phones, you can download the documentation we provide to obtain the Bluetooth app. For example, for the ROS robot model XXX, the app file name is as follows *WHEELTEC_1.1.5.apk*
+
+For users with iPhones, you only need to search for WHEELTEC in the App Store to download and use it.
+
+##### Bluetooth connection to robot
+
+1. **Power the robot**
+
+Ā Ā Ā Ā Ā Ā Ā After turning on the robot's power switch, you will see the red indicator light of the Bluetooth module blinking, indicating that the Bluetooth module is inĀ anĀ unconnected state.
+
+ 
+
+2. **Open Bluetooth app**
+
+ Open the Bluetooth app installed in the *"Obtain Bluetooth APP"*, and you will see an interface like the one shown below:
+
+ 
+
+3. **Connect Bluetooth module**
+
+ Open the following interface by clicking the button consisting of three horizontal bars in the upper left corner, then search for the Bluetooth named BT-04A and connect. The connected pairing code is 1234. After the connection is successful, the Bluetooth module indicator light becomes solid.
+
+ 
+
+---
+
+### APP usage instructions
+
+Introduction to the functions of the APP homepage:
+
+
+
+| Number | Name | Function Description |
+| ------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ā | APP Joystick | Used to control the robot's movement. (For details, refer to Chapter 3) |
+| ā” | Control Mode | Used to switch the robot's movement control mode. |
+| ā¢ | Angle Information Bar | Used to display the Z-axis speed information of the robot. |
+| ā£ | Debug Bar | Used to display the real-time information received by the APP and the sent signals. |
+| ā¤ | Left and Right Encoder | Used to display the speed information of motors A and B of the robot. The left and right encoders correspond to motors A and B, respectively. |
+| ā„ | Battery Progress Bar | Used to display the robot's battery level in percentage form. For some models using lithium iron phosphate batteries, the voltage and capacity do not have a linear relationship, so 0% to 100% corresponds to a battery voltage of 20V-25.2V or 10-12.6V. |
+| ā¦/ā§ | Speed Control Buttons | Adjust the robot's movement speed. Each click increases the speed by 0.1m/s; reducing speed is similar. |
+
+After connecting the Bluetooth APP to the robot's Bluetooth module, the robot's control mode will not switch immediately. The control mode of the robot will be displayed in real-time in the lower-left corner of the OLED screen on the robot.
+
+Once the connection is established, lightly push the control joystick forward on the main page of the APP to switch the robot's control mode to APP control mode. After switching to the APP control mode, you will be able to control the robot, view waveforms, and adjust parameters using the APP.
+ (The above four components are mounted on a frame to form a chassis)
+
+
+---
+ **If you want to know about related products, you can click the link below:**
+
+ [ReComputer J1020 v2 nano. ](https://www.seeedstudio.com/reComputer-J1020-v2-p-5498.html)
+
+ [Ros robot kit. ](https://www.aliexpress.us/item/3256801169020544.html?gatewayAdapt=glo2usa)
+
+
diff --git a/6-Robotics/6.3-Development with Physical ROS Robots/6.3.1-Get started with ROS robots/Overview of the ROS robot system.md b/6-Robotics/6.3-Development with Physical ROS Robots/6.3.1-Get started with ROS robots/Overview of the ROS robot system.md
new file mode 100644
index 0000000..5c5ef36
--- /dev/null
+++ b/6-Robotics/6.3-Development with Physical ROS Robots/6.3.1-Get started with ROS robots/Overview of the ROS robot system.md
@@ -0,0 +1,79 @@
+# Overview of the ROS robot system
+
+### Introduction
+
+This section will introduce the system architecture of the ROS robot and provide a list of the hardware components. The ROS robot system is primarily composed of two main parts:
+
+1. The upper-level component of perception and decision.
+2. The lower-level component of motion control.
+
+---
+
+### The upper-level component of perception and decision
+
+This part requires high computational power but has low real-time requirements. It is typically run on a general-purpose operating system on high-performance devices. Programs are written to perform perception and decision-making functions based on input data from various types of sensors.
+
+**The programs for the perception and decision-making functions of the ROS robot are executed by** [reComputer J1020 v2 nano. ](https://www.seeedstudio.com/reComputer-J1020-v2-p-5498.html)
+
+
+The role of the reComputer is to gather data from various sensors, process and analyze the data as needed, and then control (decide) the robot's actions, such as movement and grasping.
+
+For example, to enable the robot to follow a red object, the camera sensor first captures the environmental image information. The reComputer processes the image to identify the position of the red object and then directs the robot to approach the object.
+
+The reComputer can be considered a computer capable of running ROS. Since it needs to be installed inside the robot, the computer must be relatively compact.
+
+**The input data for the perception and decision-making programs are provided by various types of sensors, including ļ¼**
+
+* **Motor encoders**
+
+ 
+ (Obtain the robot's motion information)
+* **IMU&GNSS modules**
+
+ 
+ (Obtain external motion information)
+* **Single-line LiDAR**
+
+
+
+(Obtain a two-dimensional laser point cloud)
+
+* **Multi-line LiDAR**
+ 
+ (Obtain three-dimensional laser point cloud)
+
+* **Depth camras**
+ 
+ (Obtain depth-informed images)
+
+---
+
+### The lower-level component of motion control
+
+This part has low computational power requirements but high real-time requirements. The programs for motion control are written in C and run on a microcontroller. Their primary role is to execute the motion control commands issued by the upper-level system and provide feedback on the robot's current state.
+
+**The list of hardware used for motion control is as follows:**
+
+* **Power Battery**
+ 
+
+ (Provide energy for ROS robots)
+* **Controller and Driver**
+ 
+ (The controller generates control signals, and the driver amplifies these signals to drive the motor. They can be designed as an integrated unit)
+* **Motor and Servo**
+ 
+ (Devices that convert electrical energy into kinetic energy)
+* **Chassis**
+
+ 
+
+ (The above four components are mounted on a frame to form a chassis)
+---
+ **If you want to know about related products, you can click the link below:**
+
+ [ReComputer J1020 v2 nano. ](https://www.seeedstudio.com/reComputer-J1020-v2-p-5498.html)
+
+ [Ros robot kit. ](https://www.aliexpress.us/item/3256801169020544.html?gatewayAdapt=glo2usa)
+
+
diff --git a/6-Robotics/6.3-Development with Physical ROS Robots/6.3.2-Common sensor uses in robots/Depth camera sensor.md b/6-Robotics/6.3-Development with Physical ROS Robots/6.3.2-Common sensor uses in robots/Depth camera sensor.md
new file mode 100644
index 0000000..63f59c2
--- /dev/null
+++ b/6-Robotics/6.3-Development with Physical ROS Robots/6.3.2-Common sensor uses in robots/Depth camera sensor.md
@@ -0,0 +1,69 @@
+# Depth camera sensor
+
+### Introduction
+
+This chapter briefly introduces the depth camera on the ROS robot and teaches you how to get started quickly.
+
+Orbbec Gemini 2 is a binocular structured light 3D camera equipped with Orbbec's new MX6600 depth engine chip. It features three depth operating modes, providing high-quality depth data for a variety of application scenarios. With a wide field of view, it offers a depth measurement range from 0.15 to 10 meters, and integrates auxiliary point ranging functionality, enabling zero-blind-spot depth measurement within a maximum range of 10 meters.
+
+
+---
+
+### Depth camera usage
+
+
+#### Get source code
+
+```bash
+git clone https://github.com/orbbec/OrbbecSDK.git
+```
+
+Alternatively, you can install via binary packages, please refer to [installation guidance](doc/tutorial/English/Installation_guidance.md) for more information.
+
+### Environment setup
+
+* Linux:
+
+If you installed via a debian package, you can skip the installation of the udev rules file. If not, please install it using the following commands:
+
+```bash
+cd OrbbecSDK/misc/scripts
+sudo chmod +x ./install_udev_rules.sh
+sudo ./install_udev_rules.sh
+sudo udevadm control --reload && sudo udevadm trigger
+```
+
+
+## Examples
+
+The sample code is located in the `./examples` directory and can be built using CMake.
+
+### Build
+
+```bash
+cd OrbbecSDK && mkdir build && cd build && cmake .. && cmake --build . --config Release
+```
+
+### Run example
+
+To connect your Orbbec camera to your PC, run the following steps:
+
+```bash
+cd OrbbecSDK/build/bin # build output dir
+./OBMultiStream # OBMultiStream.exe on Windows
+```
+
+The following image is the result of running MultiStream on the Gemini2 device. Other Devices run result maybe different.
+
+
+
+
+---
+ **If you want to know about related products, you can click the link below:**
+
+ [ReComputer J1020 v2 nano. ](https://www.seeedstudio.com/reComputer-J1020-v2-p-5498.html)
+
+ [Ros robot kit. ](https://www.aliexpress.us/item/3256801169020544.html?gatewayAdapt=glo2usa)
+
+
+
diff --git a/6-Robotics/README.MD b/6-Robotics/README.MD
new file mode 100644
index 0000000..520a941
--- /dev/null
+++ b/6-Robotics/README.MD
@@ -0,0 +1,17 @@
+
+## š Table of ROS Robotics
+| **Chapter** | **Content** |
+|:-----------:|:------------------------------------------------:|
+| Module 6.1 | **Introduction to ROS** |
+| | [Overview of ROS and Environment Setup](./6.1-Introduction%20to%20ROS/6.1.1-Overview%20of%20ROS%20and%20Environment%20Setup/README.md) |
+| | [Quick Experience with HelloWorld for ROS](./6.1-Introduction%20to%20ROS/6.1.2-Quick%20Experience%20with%20HelloWorld%20for%20ROS/README.md) |
+| | [ROS Architecture](./6.1-Introduction%20to%20ROS/6.1.3-ROS%20Architecture/README.md)|
+| | [ROS Communication Mechanism](./6.1-Introduction%20to%20ROS/6.1.4-ROS%20Communication%20Mechanism/README.md) |
+| | [Common ROS Commands](./6.1-Introduction%20to%20ROS/6.1.5-Common%20ROS%20Commands/README.md) |
+| | [ROS Operation Management](./6.1-Introduction%20to%20ROS/6.1.6-ROS%20Operation%20Management/README.md) |
+| | [Common Components and Features of ROS](./6.1-Introduction%20to%20ROS/6.1.7-Common%20Components%20and%20Features%20of%20ROS/README.md) |
+| | [TF Coordinate Transformation in ROS](./6.1-Introduction%20to%20ROS/6.1.8-TF%20Coordinate%20Transformation%20in%20ROS/README.md) |
+| Module 6.2| **ROS Robot Simulation** |
+| Module 6.3| **Development with Physical ROS Robots** |
+| Module 6.4| **ROS Project Practice: Advanced Features** |
+
diff --git a/7-Algorithm-Optimization-and-Deployment/README.md b/7-Algorithm-Optimization-and-Deployment/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/8-Practical-Applications-of-the-Jetson-Platform/README.md b/8-Practical-Applications-of-the-Jetson-Platform/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/9-Course-Summary-and-Outlook/README.md b/9-Course-Summary-and-Outlook/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/README.md b/README.md
index 319042b..58ff76f 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,74 @@
# reComputer-Jetson-for-Beginners
-Beginner's Guide to reComputer Jetson
+
+
+
+Welcome to the reComputer Jetson Orin Beginner Guide! Dive deep into the NVIDIA Jetson Orin platform with this comprehensive guide designed to help developers harness Jetson Orinās powerful AI computing capabilities. By leveraging cutting-edge technology, you will be well-equipped to innovate in AI and robotics. Join us to explore the vast potential of Jetson and set the stage for pioneering developments in the industry!
+
+
+
+ 
+
+
+
+## š¦ Features
+
+- **From Beginner to Master**:
+ - Start with the basics and progress to mastering advanced AI applications.
+ - Modules cover the Jetson Orin software stack, computer vision, video analytics, robotics, and generative AI.
+
+
+- **Comprehensive Tool Coverage**:
+ - Master NVIDIA's core technologies: CUDA, JetPack SDK, TensorRT, and Deepstream.
+ - Utilize popular AI frameworks such as PyTorch and TensorFlow.
+
+- **Hands on Industry-Relevant and cutting-edge Projects**:
+ - Build an end-to-end single AI Network Video Recorder (NVR) system in the Computer Vision module.
+ - Assemble a complete Autonomous Mobile Robot (AMR) in the Robotics module.
+ - Deploy cutting-edge large language models like Llama 3 and Ollma to create your own chatbot.
+
+- **Step-by-Step Tutorials**:
+ - Receive clear, incremental instructions that guide you from basic programming to the development of complex AI applications on the Jetson platform.
+
+
+## š Preparation
+Before beginning, ensure you have:
+1. Basic knowledge of Linux commands.
+2. A Jetson deviceā[Seeed reComputer J4012](https://www.seeedstudio.com/reComputer-J4012-p-5586.html) recommended.
+
+> Note: While all Nvidia Jetson Orin-based devices are suitable, ensure your device has at least 8GB of memory.
+
+## About reComputer Jetson Orin
+
+[](https://www.youtube.com/watch?v=-KAyUHzRxHc "Click to watch the video")
+
+The [reComputer Jetson Orin](https://www.seeedstudio.com/tag/nvidia.html) is a compact yet powerful intelligent edge box that delivers modern AI performance of up to 100 TOPS to the edge. It features an NVIDIA Jetson Orin module, an open-source carrier board, a heatsink, and a power adapter. Key specifications include 4x USB 3.2, HDMI, GbE, M.2 key E for WIFI, M.2 Key M for SSD, RTC, CAN, and a 40-pin connector. Preinstalled with Jetpack, reComputer simplifies development and is ideal for edge AI solution providers focusing on video analytics, object detection, natural language processing, medical imaging, and robotics in smart cities, security, and industrial automation.
+
+## š Table of Contents
+Explore a broad range of topics from Jetson platform basics to generative AI deployment:
+
+| **Chapter** | **Content** |
+|:-----------:|:------------------------------------------------:|
+| **Module 1**| **Introduction** (incomplete)|
+| **Module 2**| [**reComputer Jetson Platform Overview**](./2-reComputer-Jetson-Platform-Overview/README.md)|
+| **Module 3**| [**Basic Tools and Getting Started**](./3-Basic-Tools-and-Getting-Started/README.MD)|
+| **Module 4**| [**Computer Vision Applications**](./4-Computer-Vision/README.md)|
+| **Module 5**| [**Generative AI Applications**](./5-Generative-AI/README.md)|
+| **Module 6** | [**ROS Robotics**](./6-Robotics/README.MD)|
+| **Module 7**| **Algorithm Optimization and Deployment** (incomplete)|
+| **Module 8**| **Practical Applications of the Jetson Platform** (incomplete)|
+| **Module 9**| **Course Summary and Outlook** (incomplete)|
+
+
+
+## š License
+This project is licensed under the [MIT License](https://github.com/Seeed-Projects/reComputer-Jetson-for-Beginners/blob/main/LICENSE).
+
+
+
+## š Reference
+- [AI for Beginners - Microsoft](https://github.com/microsoft/AI-For-Beginners)
+- [Seeed Projects - Jetson Examples](https://github.com/Seeed-Projects/jetson-examples)
+- [jetson-containers](https://github.com/dusty-nv/jetson-containers)
+- [jetson-inference](https://github.com/dusty-nv/jetson-inference)
diff --git a/Table-of-Contents.md b/Table-of-Contents.md
new file mode 100644
index 0000000..4465358
--- /dev/null
+++ b/Table-of-Contents.md
@@ -0,0 +1,42 @@
+
+## š Table of Contents
+Explore a broad range of topics from Jetson platform basics to generative AI deployment:
+
+| **Chapter** | **Content** |
+|:-----------:|:------------------------------------------------:|
+| **Module 1**| **Introduction** |
+| **Module 2**| **reComputer Jetson Platform Overview** |
+| **Module 3**| **Basic Tools and Getting Started** |
+| Module 3.1 | [Python and Programming Fundamentals](./3-Basic-Tools-and-Getting-Started/3.1-Python-and-Programming-Fundamentals/README.md) |
+| Module 3.2 | [AI and ML](./3-Basic-Tools-and-Getting-Started/3.2-AI-and-ML/README.md) |
+| Module 3.3 | [Pytorch and TensorFlow](./3-Basic-Tools-and-Getting-Started/3.3-Pytorch-and-Tensorflow/README.md) |
+| Module 3.4 | [CUDA](./3-Basic-Tools-and-Getting-Started/3.4-CUDA/README.md) |
+| Module 3.5 | [TensorRT](./3-Basic-Tools-and-Getting-Started/3.5-TensorRT/README.md) |
+| Module 3.6 | [Docker](./3-Basic-Tools-and-Getting-Started/3.6-Docker/README.md) |
+| Module 3.7 | [ROS1/ROS2](./3-Basic-Tools-and-Getting-Started/3.7-ROS/README.md) |
+| Module 3.8 | [Opencv with CUDA](./3-Basic-Tools-and-Getting-Started/3.8-OpenCV-with-CUDA/README.md) |
+| **Module 4**| **Computer Vision Applications** |
+| Module 4.1| [Overview-of-Computer-Vision](./4-Computer-Vision/4.1-Overview-of-Computer-Vision/README.md)|
+| Module 4.2| [Real-time-Video-Processing](./4-Computer-Vision/4.2-Real-time-Video-Processing/README.md)|
+| **Module 4.3**| **Object Detection and Recognition**|
+| Module 4.3.1| [Train and Deploy YOLOv8](./4-Computer-Vision/4.3-Object%20Detection%20and%20Recognition/4.3.1-Train%20and%20Deploy%20YOLOv8%20on%20reComputer/README.md)|
+| Module 4.3.2| [Deploy YOLOv8 using TensorRT and DeepStream SDK Support](./4-Computer-Vision/4.3-Object%20Detection%20and%20Recognition/4.3.2-Deploy%20YOLOv8%20on%20NVIDIA%20Jetson%20using%20TensorRT%20and%20DeepStream%20SDK%20Support/README.md)|
+| **Module 4.4**| [**Project Practice-Intelligent Surveillance System**](./4-Computer-Vision/4.4-Project%20Practice-Intelligent%20Surveillance%20System/README.md)|
+| **Module 5**| **Generative AI Applications** |
+| **Module 6** | **ROS Robotics** |
+| Module 6.1 | Introduction to ROS |
+| Module 6.1.1 | [Overview of ROS and Environment Setup](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.1-Overview%20of%20ROS%20and%20Environment%20Setup/README.md) |
+| Module 6.1.2 | [Quick Experience with HelloWorld for ROS](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.2-Quick%20Experience%20with%20HelloWorld%20for%20ROS/README.md) |
+| Module 6.1.3 | [ROS Architecture](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.3-ROS%20Architecture/README.md)|
+| Module 6.1.4 | [ROS Communication Mechanism](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.4-ROS%20Communication%20Mechanism/README.md) |
+| Module 6.1.5 | [Common ROS Commands](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.5-Common%20ROS%20Commands/README.md) |
+| Module 6.1.6 | [ROS Operation Management](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.6-ROS%20Operation%20Management/README.md) |
+| Module 6.1.7 | [Common Components and Features of ROS](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.7-Common%20Components%20and%20Features%20of%20ROS/README.md) |
+| Module 6.1.8 | [TF Coordinate Transformation in ROS](./6-Robotics/6.1-Introduction%20to%20ROS/6.1.8-TF%20Coordinate%20Transformation%20in%20ROS/README.md) |
+| Module 6.2| ROS Robot Simulation |
+| Module 6.3| Development with Physical ROS Robots |
+| Module 6.4| ROS Project Practice: Advanced Features |
+| **Module 7**| **Algorithm Optimization and Deployment** |
+| **Module 8**| **Practical Applications of the Jetson Platform** |
+| **Module 9**| **Course Summary and Outlook** |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Install the Docker service on Jetson
+
+------
+
+### Install Docker CE
+
+First, update the apt package indexļ¼
+
+```bash
+sudo apt update
+sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
+```
+
+Add the official Docker GPG keyļ¼
+
+```bash
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
+```
+
+Add the official Docker repositoryļ¼
+
+```
+echo \
+ "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
+ https://download.docker.com/linux/ubuntu \
+ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+```
+
+Install Docker CEļ¼
+
+```
+sudo apt update
+sudo apt install -y docker-ce docker-ce-cli containerd.io
+```
+
+Check the installation:
+
+```
+docker --version
+```
+
+------
+
+
+
+If the version number can be displayed normally, it indicates that the installation was successful.
+
+### Install NVIDIA Container Toolkit
+
+ā **NVIDIA Container Toolkit** is a software suite that enables Docker containers to access NVIDIA GPUs. While Docker itself provides containerization for applications and their dependencies, it does not natively support GPU acceleration. The NVIDIA Container Toolkit bridges this gap by allowing containers to utilize the hostās GPU hardware. It maps NVIDIA drivers, CUDA libraries, and other necessary components into the container, enabling GPU-accelerated workloads such as AI, deep learning, and high-performance computing.
+
+Add NVIDIA GPG keyļ¼
+
+```bash
+sudo apt-get install curl -y
+
+distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+
+curl -s -L https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
+
+curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
+ sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
+ sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
+```
+
+
+
+Install NVIDIA Container Toolkit:
+
+```bash
+sudo apt update
+sudo apt install -y nvidia-container-toolkit
+```
+
+Configure Docker to use NVIDIA runtimeļ¼
+
+```
+sudo nvidia-ctk runtime configure --runtime=docker
+sudo systemctl restart docker
+```
+
+------
+
+Test whether the GPU can be used in the Docker container.
+
+```bash
+sudo docker run --rm --runtime=nvidia --gpus all --network host ubuntu nvidia-smi
+```
+
+
+
+If the above output indicates that CUDA can be used normally within the Docker image, then it is possible to use CUDA within the Docker container.
+
+### [Optional]: Allow non-root users to run Docker
+
+```
+sudo usermod -aG docker $USER
+newgrp docker
+```
+
+After that, you can directly use `docker run` instead of `sudo`.
+
+## Common operation commands of docker
+
+### Pull a docker image from docker hub
+
+```bash
+docker pull ultralytics/ultralytics:8.3.201-jetson-jetpack6
+```
+
+
+
+View the pulled image:
+
+```bash
+docker image list
+```
+
+
+
+enter docker container:
+
+```bash
+docker run --runtime nvidia -it --rm --network=host ultralytics/ultralytics:8.3.201-jetson-jetpack6
+```
+
+- **--runtime** nvidia Specify that the container uses **NVIDIA Container Runtime**, so that the container can access the GPU of Jetson.
+- **-it** `-i` Indicating the interactive mode, `-t` assigns a pseudo-terminal.
+- **--rm** The container will be automatically deleted after it exits.
+- **--network=host** Allow the container to directly use the host machine's network.
+
+
+
+Enter the container and verify whether CUDA can be called normally.
+
+
+
+It can be seen that CUDA can be called normally.
+
+```bash
+#Check the name of the Docker container
+docker ps -a
+```
+
+
+
+### File transfer
+
+This part is designed to enable the transfer of host files to the container interior or the transfer of files from the container interior to the host.
+
+```bash
+#jetson to docker image
+docker cp 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+