Addis Ababa University

Addis Ababa Institute of Technology

School of Electrical and Computer Engineering

Robotics assignment

Prepared by: Biruk Tesfaw------------------------ATR/4514/05

Bisratemichael Moges------------- ATR/6015/05
Daniel G/yohanes------------------- ATR/3676/05
Dawit Samuel----------------------- ATR/1378/05
Esubalew Mekuria-----------------ETE/6637/04
Yared Abera-------------------------ENR/1849/04

Submitted to: Dr. Ing. Gossaye Mekonnen

Date of submission: May, 2017

1
Perception-Action
It is a neural architecture for a robot in order to learn how to imitate a sequence of
movements performed by another robot or by a human. The main idea is that the
imitation process does not need to be given to the system but can emerge from a
misinterpretation of the perceived situation at the level of a simple sensory-motor system.
The robot controller is based on a Perception-Action (PerAc) architecture. This
architecture allows an autonomous robot to learn by itself sensory-motor associations
with a delayed reward. Here, we show how the same architecture can also be used by a
student robot to learn to imitate another robot, allowing the student robot to discover by
itself solutions to a particular problem or to learn from another robot what to do. We also
show the difficulty linked to the segmentation of the actions to imitate. This imitation
problem is demonstrated by a task of learning a sequence of movements and their precise
timing. We discuss the importance of imitation processes for the understanding of our
high-level cognitive abilities linked to self-recognition.

We use the following segment of code to start up the project in gazebo and ROS

>roscore

>source catkin_ws/devel/setup.bash

>roslaunch pioneer_gazebo pioneer_traffic_small_world_single.launch

>roslaunch nav_bundle nav_bundle.launch

>roslaunch pioneer_ros pioneer_controller.launch

>roslaunch pioneer_description pioneer_rviz.launch

2
Project creation Steps
-First the workspace for the project was created. In creation of the workspace the src file
was created. We used the src file to create the packages important for the bots function.

-We created the actual robot from a base box, two discs for the left and right wheels, and
a third wheel for structural stability,which where done in Gazebo.

-After that a camera(for vision) and laser sensor for obstacle detection were added to the
bot. Then map of the world was created. Including a map is more preferable as it is
clearly defined, and tested. Newly created maps tend to make the navigation process a
little difficult compared to the other.

-In this step, we added the navigation attribute, putting the laser sensor, the camera and
the whole robot in action. The navigation allows the robot to listen to a goal that is, we
are able to assign the end point of the path. Then it should process the coordinates, and go
to that goal by avoiding the obstacles.

Description of packages under the pioneer bot

There are three packages within pioneer gazebo ros that each contain launch files
or publishers that are called by the main bash script ./Project_gazebo.

I. pioneer_description

This package contains the URDF models (.xacro extensions) of the robot and sensors.
URDF (universal robot description format) is an XML format for representing a robot
model. It contains information regarding the physical components of the model (<links>)
and how these components are connected (<joints>). Links have three main sets of
properties: <visual>, <collision> and <inertial>. Visual properties define how the model
will appear in Gazebo and RViz, collision properties define the physical space that the
link occupies, and inertial properties define the mass and inertia of the link.

The URDF model is used to determine the transformations of each link as the robot
moves. Moreover, it provides a transformation from the sensor frames to the odometry
frame to enable SLAM mapping.

II. pioneer_gazebo

This package contains the .world models and .launch file to spawn the specified robot
model and Gazebo world when running gazebo ros. The Gazebo .world files are in XML

3
format and existing models are easily added into the world by specifying the <uri>, e.g.
model://model name, within the <include> environment. The model name should match a
folder name inside /.gazebo/models/ or a model name from the online model repository
http://gazebosim.org/models. Note that requesting models from the online repository
requires a solid internet connection and will take a minute or so to load, if you need
things to load quickly, it is best to have a local copy in your /.gazebo/models/ folder.

III. pioneer_ros

This package contains the C++ files to perform robot odometry and controller
housekeeping. There are three .cpp files in the /src folder that are each required for the
normal operation of the slam gmapping package and the move base controller. The
pioneer tf broadcaster.cpp file requests the robot state from Gazebo through the
rosservice /gazebo/get model state, which returns the robot pose and twist. A
tf::TransformBroadcaster is then generated to broadcast the transformation from the robot
base link to the odometry frame. The pioneer odom publisher.cpp file works in
conjunction with the broadcaster to perform the transformation and then publish the robot
pose in the odometry frame.

4
Appendix 1 (workspace and package creation)
mkdir -p ~/catkin_ws/src

cd ~/catkin_ws/src

catkin_init_workspace

cd ~/catkin_ws/src

catkin_create_pkg pioneer_gazebo_ros roscpp gazebo_ros

Appendex 2 (pioneer gazebo launch)

<launch>

<arg name="paused" default="false"/>

<arg name="use_sim_time" default="true"/>

<arg name="gui" default="true"/>

<arg name="headless" default="false"/>

<arg name="debug" default="false"/>

<include file="$(find gazebo_ros)/launch/empty_world.launch">

<arg name="world_name" value="$(find

pioneer_gazebo)/worlds/small_world.world"/>

<arg name="debug" value="$(arg debug)" />

<arg name="gui" value="$(arg gui)" />

<arg name="paused" value="$(arg paused)"/>

<arg name="use_sim_time" value="$(arg use_sim_time)"/>

<arg name="headless" value="$(arg headless)"/>

</include>

</launch>

5
Appendex 3 (navigate )
<launch>
<node pkg="gmapping" type="slam_gmapping" name="gmapping">
<remap from="scan" to="base_scan"/>
</node>
<include file="$(find pioneer_2dnav)/move_base.launch"/>
<node pkg="simple_navigation_goals"
type="base_link_navigation_client" name="base_link_goal_client"
output="screen"/>
<node pkg="simple_navigation_goals" type="map_navigation_client"
name="map_goal_client" output="screen"/>
</launch>