Above is a CAD render of CHAR-01 in Fusion360. I keep it minimal and plan to 3D print it using school printers (hoping for free filament). This project explores ROS2 and Gazebo Ignition while learning CAD robot design and C++ programming. Since I'm broke, I started with simulation before building the real thing. I used a scikit-learn model instead of reinforcement learning to better understand the simulation tools. The most exciting part was connecting a machine learning model to the robot and watching it perform. While autonomous navigation could work with basic sensors, my goal was to deepen learning through ML integration.

Finding current ROS2 and Gazebo resources was challenging given frequent updates. I found an excellent [Udemy course by Raymond Andrade](https://www.udemy.com/course/ros2-cpp-robotics-developer-course/) that stays current with clear, visual explanations covering ROS2 subscribers and packages. For a similar Arduino project, check out [Niko Dembartnik](https://youtu.be/PdSDhdciSpE?si=lA5s7GLW5RZzkDLo). I adapted much of his code for this simulation. For the full code, see the repo [here!](https://github.com/willdphan/char-01.git) Key files: - `char_01_model.sdf` - `char_01_world.sdf` - `lidar_node` - `visualize.py` - `train_model.py` - `predict.py` - `control.cpp` ## Model Design I recreated my CAD design in Gazebo Ignition using an SDF file since URDF conversion failed and simple shapes made SDF faster. Here's CHAR-01 next to a Hummer—a bit oversized, but functional. Code is [here](https://github.com/willdphan/char-01/blob/4210aafeb5c262d53692909b3e651718de7305d2/ros2_pkg/models/char_01/char_01_model.sdf). CHAR-01

The model connects to the `/cmd_vel` topic in `char_01_model.sdf`. `/cmd_vel` carries `geometry_msgs/Twist` messages with linear `(x, y, z)` and angular `(x, y, z)` velocities. ROS nodes subscribe to this topic and translate velocity commands into motor commands. We implemented the diff drive system plugin: ```py left_wheel_joint right_wheel_joint 1.2 0.4 1 cmd_vel ``` ## World Design I created an SDF world file with four neon blue walls to contain CHAR-01, plus lighting. Code is [here](https://github.com/willdphan/char-01/blob/4210aafeb5c262d53692909b3e651718de7305d2/ros2_pkg/worlds/char_01_world.sdf).

## LiDAR Node I followed the ROS2 Documentation: Humble tutorial for LiDAR visualization, then developed this C++ ROS2 node for LiDAR sensor data.

The `LidarNode` class inherits from `rclcpp::Node`. The constructor names the node `lidar_node`, creates a subscription for `sensor_msgs::msg::LaserScan` messages on the lidar topic, and sets `LidarNode::callback` as the callback function. ```cpp class LidarNode : public rclcpp::Node { // Class definition goes here }; public: LidarNode() : Node("lidar_node") { sub_ = this->create_subscription( "lidar", 10, std::bind(&LidarNode::callback, this, std::placeholders::_1)); } ``` The callback function writes range readings to a file: ```cpp private: void callback(const sensor_msgs::msg::LaserScan::SharedPtr msg) { std::ofstream file; std::string package_path = ament_index_cpp::get_package_share_directory("ros2_pkg"); std::string file_path = ".../char-01/ros2_pkg/data"; file.open(file_path, std::ios_base::app); for (const auto& range : msg->ranges) { file << range << " "; } file << "\n"; file.close(); } ``` Main function initializes ROS2, spins the `LidarNode`, and shuts down: ```cpp int main(int argc, char **argv) { rclcpp::init(argc, argv); rclcpp::spin(std::make_shared()); rclcpp::shutdown(); return 0; } ``` Add the new `lidar_node` to your `CMakeLists.txt` when building. For visualization, run `rviz2` and configure "Fixed Frame" as `vehicle_blue/chassis/gpu_lidar` (may vary based on your model setup). Click "Add" to include a display for the lidar.

## Collect Data Manual robot control with lidar would be time-consuming. I used Niko's `all.txt` data and modified his `visualize.py`, `train_model.py`, and `predict.py` files. His sensor data ends with movement labels: - `F` = Forward - `I` = Forward Right - `R` = Right - `G` = Forward Left - `L` = Left ## Visualize Data The `visualize.py` script visualizes LiDAR data by reading `all.txt`, processing it, and generating polar plots for each dataset matching the LiDAR resolution. CHAR-01 Plot

Each data point appears as a black dot, with an orange dot at the center representing the LiDAR sensor/robot location. ```py for line in Lines: distances = GetData(line) print(len(distances)) if (len(distances) == LIDAR_RESOLUTION): # Create a new figure for each line plt.figure() for x in range(VISUALIZATION_RESOLUTION): if distances[x] == 0: distances[x] = 20 a = int(float(distances[x]))/2000 plt.plot(line_positions[x][0]*a+400, line_positions[x][1]*a+400, 'ko') plt.plot(400, 400, 'o', color=(252/255, 132/255, 3/255)) plt.show() ``` ## Train Model The `train_model.py` script preprocesses data, encodes it, selects key features, and trains a [Random Forest Classifier](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html). Reads and loads data: ```py data = pd.read_csv('.../data/[path_to_all.txt]', header=None) ``` Renames the last column to "Label", filters out specific labels `(L, R, H, J)`, and splits into features `(X)` and labels `(y)`: ```py data.rename(columns={data.columns[-1]: 'Label'}, inplace=True) data = data[(data['Label'] != 'L') & (data['Label'] != 'R') & (data['Label'] != 'H') & (data['Label'] != 'J')] data.reset_index(drop=True, inplace=True) X = data.iloc[:, :-1] y = data.iloc[:, -1] ``` Converts categorical labels to numeric format: ```pylabel_encoder = LabelEncoder() y = label_encoder.fit_transform(y) ``` Splits dataset (80% training, 20% testing): ```py X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) ``` Selects top 80 features using ANOVA F-value: ```py k = 80 k_best = SelectKBest(score_func=f_classif, k=k) k_best.fit(X_train, y_train) selected_feature_indices = k_best.get_support(indices=True) print("selected_feature_indices: ", selected_feature_indices) ``` Trains Random Forest Classifier: ```py clf = RandomForestClassifier(max_depth=3, random_state=42) clf.fit(X_train.iloc[:, selected_feature_indices], y_train) ``` Evaluates performance: ```py y_pred = clf.predict(X_test.iloc[:, selected_feature_indices]) accuracy = accuracy_score(y_test, y_pred) print(f'Accuracy: {accuracy}') class_names = label_encoder.classes_ report = classification_report(y_test, y_pred, target_names=class_names, zero_division=0) print('Classification Report:\n', report) ``` Saves model components: ```py joblib.dump(clf, '...data/rf_model/path_to_random_forest_model.pkl') joblib.dump(k_best, '...data/k_best/path_to_k_best.pkl') joblib.dump(label_encoder, '.../data/label_encoder/path_to_label_encoder.pkl') ``` The model achieved 66.69% accuracy. It performs better on forward movements `F` than left `G` or right `I` movements, with good precision but poor recall for forward right `I` movements. ## Predictions The `predict.py` script defines a ROS2 node that makes predictions from LiDAR data using the trained Random Forest Classifier. The `Predictor` class subscribes to the `lidar` topic, loads the trained model, feature selector, and label encoder, then publishes predictions to the `prediction` topic. The `listener_callback` method processes incoming messages, preprocesses data, makes predictions, and publishes results: ```py # the received data is preprocessed and # then passed to the model to make a prediction. def listener_callback(self, msg): print("listener_callback called") # Convert the LaserScan data to a numpy array data = np.array(msg.ranges) # Select a subset of the range readings data = data[:240] # Replace infinities with a large finite number data[data == np.inf] = 1e10 # Preprocess the data data = self.preprocess_data(data) # Make a prediction prediction = self.clf.predict(data) print("Made prediction:", prediction) # Convert the prediction to a string prediction_str = ' '.join(map(str, prediction)) # Create a String message and set its data field prediction_msg = String() prediction_msg.data = prediction_str # Publish the prediction self.publisher_.publish(prediction_msg) ``` The `preprocess_data` method prepares LiDAR data for the ML model: ```py # Preprocess data here def preprocess_data(self, data): # This will depend on how you preprocessed your data when training the model # For example, you might need to select the best features like this: data = self.k_best.transform(data.reshape(1, -1)) return data ``` Main function runs the node: ```py def main(args=None): rclpy.init(args=args) predictor = Predictor() rclpy.spin(predictor) # Destroy the node explicitly # (optional - otherwise it will be done automatically # when the garbage collector destroys the node object) predictor.destroy_node() rclpy.shutdown() if __name__ == '__main__': main() ``` ## Control Node The `control.cpp` file defines a node that listens for predictions and publishes corresponding Twist messages for robot control. The `ControlNode` constructor initializes the node, creates a publisher for `geometry_msgs::msg::Twist` messages on `cmd_vel`, and subscribes to `std_msgs::msg::String` messages on `prediction`: ```cpp public: ControlNode() : Node("control_node") { // publishes to /cmd_vel publisher_ = this->create_publisher("cmd_vel", 10); // listens to prediction subscription_ = this->create_subscription( "prediction", 10, std::bind(&ControlNode::callback, this, std::placeholders::_1)); } ``` The callback function converts predictions to integers, creates Twist messages, and publishes movement commands: ```cpp private: void callback(const std_msgs::msg::String::SharedPtr msg) { geometry_msgs::msg::Twist twist; // Convert the prediction from string to int int prediction = std::stoi(msg->data); if (prediction == 1) { twist.linear.x = 1.0; // Move forward at 1.0 m/s twist.angular.z = 0.0; // No rotation } else if (prediction == 2) { twist.linear.x = 0.0; // No forward movement twist.angular.z = 1.0; // Rotate counter-clockwise at 1.0 rad/s } else if (prediction == 3) { twist.linear.x = 0.0; // No forward movement twist.angular.z = -1.0; // Rotate clockwise at 1.0 rad/s } publisher_->publish(twist); } ``` Main function handles ROS2 initialization and node execution: ```cpp int main(int argc, char **argv) { rclcpp::init(argc, argv); rclcpp::spin(std::make_shared()); rclcpp::shutdown(); return 0; } ``` ## Launch The launch file starts the simulation environment and ROS2 nodes: 1. Starts Ignition Gazebo with the world file 2. Launches `predict_node` for ML predictions from LiDAR data 3. Launches `control_node` for robot control 4. Launches `lidar_node` for LiDAR data handling 5. Sets up ROS2-Gazebo bridges for `/lidar` and `/cmd_vel` topics ```cpp ExecuteProcess( cmd=['ign', 'gazebo', '.../worlds/char_01_world.sdf'], output='screen' ) Node( package="ros2_pkg", executable="predict.py", name="predict_node", output='screen' ) Node( package="ros2_pkg", executable="control", name="control_node", output='screen' ) Node( package="ros2_pkg", executable="lidar_node", name="lidar_node", output='screen' ) ExecuteProcess( cmd=['ros2', 'run', 'ros_gz_bridge', 'parameter_bridge', '/lidar@sensor_msgs/msg/LaserScan@ignition.msgs.LaserScan'], output='screen' ) ExecuteProcess( cmd=['ros2', 'run', 'ros_gz_bridge', 'parameter_bridge', '/cmd_vel@geometry_msgs/msg/Twist@ignition.msgs.Twist'], output='screen' ) ``` The video is sped up 1.5x—watch CHAR-01 move!

This launch file creates a complete system for simulating, controlling, and making predictions for a robot using ROS2 and Ignition Gazebo. ## What's Next? Build the package, source `setup.bash`, then run the launch file to start the simulation! The model occasionally pauses to predict its next move. To clone and run this project, check the [README.md](https://github.com/willdphan/char-01.git). The model isn't perfect and has room for improvement. Different models might yield better results, and reinforcement learning could enable better environment exploration for CHAR-01. This project represents one step in my learning journey, and I'm excited about what's ahead. I'm proud of my progress with ROS2, Gazebo, and C++, and look forward to continuing in this field full of possibilities.