Storage Information Of The Exhibits

This document outlines the process of creating an interactive map that enables a robot to navigate to, recognize, and describe exhibits. It details the methods used to embed exhibit information into the map and how these were integrated into a robotic simulation using Gazebo and the mapdesc tool.

Map Creation Using mapdesc

The mapdesc tool allows for the importation of different data sources and their conversion into formats suitable for robotic simulations and navigation tasks.

1.1 Inputs for Map Creation:

ROS Map (YAML and PNG Files): These files provide the robot with essential navigation and obstacle data. The YAML file is used by the SLAM Toolbox for creating and updating the map.

1.2 Generating the Map:

We used the mapdesc tool to generate a YAML file from the initial layout of the entrance hall.

This YAML file serves as the primary format for the ROS-based navigation system and includes definitions for walls, static objects, and other obstacles as perceived by the robot.

Generated map

Annotating the Map with Exhibit Information

2.1 Placement of Markers:

Markers were placed using the mapdesc tool, indicating the locations of exhibits, the reception, elevator and staircase. These markers are crucial for the robot to identify the positions where it should stop and provide information to the guest interacting with the robot.

Map with areas and markers

(Each marker is linked to a specific set of data about the exhibit, including its description and any relevant multimedia information that the robot may present to visitors.)

The request to get marker information from the map is handled in the navigation node.py.

node.py

def get_marker(self):
        # request marker from service
        self.wait_for_service(self.marker_cli)
        request = ListMarker.Request()
        future = self.marker_cli.call_async(request)
        future.add_done_callback(self.get_marker_callback)

2.2 YAML File Usage:

The map with the markers was exported as a YAML file. This file is used further for the robot’s navigation system to recognize exhibit- and other locations and navigate accurately within the mapped area. Example markers are defined as follows:

rh1_eg.yml

marker:
    [
      {
          name: underwatertestroom,
          radius: 0.2,
          color: [ 255, 0, 0 ],
          pose:
            {
              position: [ -12.715923309326172, 0.20743985105929, 0 ],
              orientation: [ 0, 0, 0, 1 ]
            }
        },

Simulation and Testing in Gazebo

3.1 Setting Up the Simulation:

SDF Files

These files were used for 
detailed descriptions of the 
physical properties of
objects within the simulation, 
ensuring that the robot 
interacts with the environment 
as realistically as possible.

Gazebo Environment: We used the Gazebo simulation environment to test the navigation capabilities of the robot with the newly created map. The simulation helps in verifying the accuracy of the map and the effectiveness of marker placements.

The robot's navigation to markers and its interaction are handled in the navigation node.py:

node.py

def get_marker_callback(self, future: Future):
        _marker = future.result().marker
        self.get_logger().info(f'Received {len(_marker)} marker 👍!')
        if len(_marker) == 0:
            return
        while True:
            for marker in _marker:
                self.get_logger().info(
                    f"Will move to waypoint {marker.name} - "
                    f"x: {marker.pose.position.x} "
                    f"y: {marker.pose.position.y}")
                self.move_to_waypoint(
                    self._create_pose_stamped(marker.pose))

    def move_to_waypoint(self, pose: PoseStamped):
        nav = self.nav
        try:
            nav.goToPose(pose)
            while not nav.isTaskComplete():
                nav.getFeedback()
                # feedback = nav.getFeedback()
                # self.get_logger().info(feedback)
            result = nav.getResult()
            print(result)
            # self.get_logger().info(result)
        except KeyboardInterrupt:
            self.get_logger().info("Keyboard interrupt!")
            nav.cancelTask()

This ensures that the robot receives the positions of the exhibits (markers) and navigates to each one to present it to visitors.

3.2 Navigation Testing:

(The robot was programmed to navigate to each marker and simulate an interaction where it would provide information about the exhibit. This step was crucial to ensure that the waypoints and markers are accurately placed and that the robot can successfully retrieve and display the exhibit information.)