Welcome to MicroROS Self-balancing Robot Car repository

Gmapping Mapping

Note: The virtual machine needs to be in the same LAN as the car, and the ROS_DOMAIN_ID needs to be consistent. You can check [Must Read Before Use] to set the IP and ROS_DOMAIN_ID on the board.

1. Introduction to Gmapping

• gmapping is only applicable to points with less than 1440 points in a single frame of two-dimensional laser points. If the number of laser points in a single frame is greater than 1440, then [[mapping-4] process has died] will appear.
• Gmapping is a commonly used open source SLAM algorithm based on the filter SLAM framework.
• Gmapping is based on the RBpf particle filter algorithm, and the real-time positioning and mapping processes are separated. Positioning is performed first and then mapping.
• Gmapping has made two major improvements on the RBpf algorithm: improved proposal distribution and selective resampling.

Advantages: Gmapping can build indoor maps in real time, and the amount of calculation required to build small scene maps is small and the accuracy is high.

Disadvantages: As the scene increases, the number of particles required increases. Because each particle carries a map, the memory and calculation required to build a large map will increase. Therefore, it is not suitable for building large scene maps. And there is no loop detection, so the map may be misaligned when the loop is closed. Although increasing the number of particles can make the map closed, it comes at the cost of increasing the amount of calculation and memory.

2. Program function description

The car connects to the proxy and runs the program. The map building interface will be displayed in rviz. Use the keyboard or handle to control the movement of the car until the map is built. Then run the command to save the map.

Note: Before running the program, the car needs to be restarted in a stable standing position to ensure that all sensors are reset

3. Start and connect the agent

Take the supporting virtual machine as an example, enter the following command to start the agent,

xxxxxxxxxx
sudo docker run -it --rm -v /dev:/dev -v /dev/shm:/dev/shm --privileged --net=host microros/micro-ros-agent:humble udp4 --port 8899 -v4

Then, turn on the car switch and wait for the car to connect to the proxy. The connection is successful as shown in the figure below.

4. Start the program

4.1 Run the command

Take the matching virtual machine as an example, enter in the terminal,

xxxxxxxxxx
ros2 launch yahboomcar_bringup yahboomcar_bringup_launch.py mode:=slam

xxxxxxxxxx
#Parameter description, the speed of the car will be adjusted. This is the map building mode
mode:=slam

First, start the car to process the underlying data program.

Next, run the graph building node, input in the terminal, and wait for rviz to open automatically.

xxxxxxxxxx
ros2 launch yahboomcar_nav map_gmapping_launch.py use_rviz:=true

xxxxxxxxxx
#Parameter description, select whether to open rviz, true means open, false means not open
use_rviz:=true

Then run handle control or keyboard control, choose one of the two, terminal input,

xxxxxxxxxx
#Keyboard Control
ros2 run yahboomcar_ctrl yahboom_keyboard
#handle control
ros2 launch yahboomcar_ctrl yahboomcar_joy_launch.py

Then control the car to slowly walk through the area that needs to be mapped. After the map is built, enter the following command to save the map. Enter in the terminal:

xxxxxxxxxx
ros2 launch yahboomcar_nav save_map_launch.py

A map named yahboom_map will be saved. This map is saved in,

Take the matching virtual machine as an example code path:

xxxxxxxxxx
/home/yahboom/yahboomcar_ws/src/yahboomcar_nav/maps

There will be two files generated, one is yahboom_map.pgm, the other is yahboom_map.yaml, look at the contents of yaml,

xxxxxxxxxx
image: yahboom_map.pgm
mode: trinary
resolution: 0.05
origin: [-10, -10, 0]
negate: 0
occupied_thresh: 0.65
free_thresh: 0.25

• image: the image representing the map, i.e. yahboom_map.pgm
• mode: this property can be one of trinary, scale or raw, depending on the selected mode, trinary mode is the default mode
• resolution: the resolution of the map, meters/pixels
• origin: the 2D pose (x,y,yaw) of the lower left corner of the map, where yaw is rotated counterclockwise (yaw=0 means no rotation). Currently many parts of the system ignore the yaw value.
• negate: whether to invert the meaning of white/black and free/occupied (the interpretation of the threshold is not affected)
• occupied_thresh: pixels with an occupied probability greater than this threshold are considered fully occupied.
• free_thresh: pixels with an occupied probability less than this threshold are considered fully free.

5. View the node communication diagram

Terminal input,

xxxxxxxxxx
ros2 run rqt_graph rqt_graph

If it is not displayed at first, select [Nodes/Topics (all)] and click the refresh button in the upper left corner.

6. View TF tree

Terminal input,

xxxxxxxxxx
ros2 run tf2_tools view_frames

After the execution is complete, two files, .gv and .pdf, will be generated in the terminal directory. The pdf file is the TF tree.

7. Code analysis

Take the virtual machine as an example, here we only explain the map_gmapping_launch.py ​​file for building the map. The file path is,

xxxxxxxxxx
/home/yahboom/yahboomcar_ws/src/yahboomcar_nav/launch

map_gmapping_launch.py

​x
from launch.substitutions import LaunchConfiguration
from launch import LaunchDescription
from launch_ros.actions import Node
from launch.actions import IncludeLaunchDescription,DeclareLaunchArgument
from launch.launch_description_sources import PythonLaunchDescriptionSource
from ament_index_python.packages import get_package_share_directory,get_package_share_path
import os

def generate_launch_description():

    package_path = get_package_share_path('yahboomcar_nav')
    default_rviz_config_path = package_path / 'rviz/view.rviz'
    rviz_arg = DeclareLaunchArgument(name='rvizconfig', default_value=str(default_rviz_config_path),
                                     description='Absolute path to rviz config file')
    
    slam_gmapping_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([os.path.join(
        get_package_share_directory('slam_gmapping'), 'launch'),
         '/slam_gmapping.launch.py'])
    )

    base_link_to_laser_tf_node = Node(
     package='tf2_ros',
     executable='static_transform_publisher',
     name='base_link_to_base_laser',
     arguments=['0.0', '0.0', '0.138', '0', '0', '0', 'base_link', 'laser_frame']
    )

    rviz_node = Node(
        package='rviz2',
        executable='rviz2',
        name='rviz2',
        output='screen',
        arguments=['-d', LaunchConfiguration('rvizconfig')],
    )
    
    return LaunchDescription([rviz_arg,rviz_node,slam_gmapping_launch,base_link_to_laser_tf_node])

Here, a launch file - slam_gmapping_launch and a node that publishes static transformations - base_link_to_laser_tf_node are started.

Take the virtual machine as an example, and take a closer look at slam_gmapping_launch. The file is located at,

xxxxxxxxxx
/home/yahboom/gmapping_ws/src/slam_gmapping/launch

slam_gmapping.launch.py，

xxxxxxxxxx
from launch import LaunchDescription
from launch.substitutions import EnvironmentVariable
import launch.actions
import launch_ros.actions
import os
from ament_index_python.packages import get_package_share_directory

def generate_launch_description():
    return LaunchDescription([
        launch_ros.actions.Node(
            package='slam_gmapping', 
            executable='slam_gmapping', 
            output='screen', 
            parameters=[os.path.join(get_package_share_directory("slam_gmapping"), "params", "slam_gmapping1.yaml")]),
    ])

Here, the slam_gmapping node is started and the slam_gmapping1.yaml parameter file is loaded.

The parameter file is located in (taking the matching virtual machine as an example),

xxxxxxxxxx
/home/yahboom/gmapping_ws/src/slam_gmapping/params

slam_gmapping1.yaml

xxxxxxxxxx
/slam_gmapping:
  ros__parameters:
    angularUpdate: 1.0
    astep: 0.10
    base_frame: base_footprint
    map_frame: map
    odom_frame: odom
    delta: 0.05
    iterations: 5
    kernelSize: 1
    lasamplerange: 0.005
    lasamplestep: 0.005
    linearUpdate: 0.2
    llsamplerange: 0.01
    llsamplestep: 0.01
    lsigma: 0.075
    lskip: 2
    lstep: 0.10
    map_update_interval: 0.3
    maxRange: 6.0
    maxUrange: 4.0
    minimum_score: 0.0
    occ_thresh: 0.25
    ogain: 3.0
    particles: 15
    qos_overrides:
      /parameter_events:
        publisher:
          depth: 1000
          durability: volatile
          history: keep_all
          reliability: reliable
      /tf:
        publisher:
          depth: 1000
          durability: volatile
          history: keep_last
          reliability: reliable
    resampleThreshold: 0.5
    sigma: 0.05
    srr: 0.2
    srt: 0.0
    str: 0.0
    stt: 0.0
    temporalUpdate: 1.0
    transform_publish_period: 0.05
    use_sim_time: false
    xmax: 20.0
    xmin: -20.0
    ymax: 20.0
    ymin: -20.0