ROS y turtlebot

Imprimir
Creado en Miércoles, 08 Enero 2014 Última actualización el Miércoles, 22 Enero 2014 Escrito por Ibra!
AddThis Social Bookmark Button

Nota: Este articulo fue escrito con la colaboración de Juan Carlos Hernández en su trabajo como pasante de la Universidad Militar Nueva Granada en tdrobotica.

En este tutorial vamos a continuar trabajando con turtlebot y ROS pero entrando más en detalle de como es la arquitectura del sistema ROS. El objetivo es desarrollar un nodo totalmente desde cero para crear una interacción entre las entradas y salidas del turtlebot, esto es que al presionar un pulsador se encienda un LED del robot. Con este sencillo tutorial exploraremos la forma de leer entradas y activar salidas a través de un nodo en ROS.

371

Ten en cuenta que para seguir estos pasos es bueno que realices los tutoriales anteriores en tu maquina y en tu robot. Lo primero que se debe hacer luego de la previa instalación de ROS en el computador, es crear un paquete ROS el cual nos permite colocar nuestros archivos y programas en las librerías de ROS para que posteriormente las pueda utilizar el sistema e interactuar con el robot.

En este punto hay dos opciones en el entorno ROS. Una es crear un espacio de trabajo Catkin o usar un espacio de trabajo rosbuild, siendo el más reciente Catkin pero es más sencillo utilizarlo con rosbuild. En este caso vamos a usar rosbuild para este paquete y se debe entrar a la carpeta de archivos de ROS ($ cd /opt/ros/electric/stacks) y digitar el siguiente comando:

$ roscreate-pkg kobuki_controller_tutorial roscpp yocs_controllers std_msgs kobuki_msgs nodelet

Lo que significa este codigo es, simplemente crear un paquete entre los archivos de ROS llamado kobuki_controller_tutorial con las dependencias roscpp y las demás que le siguen.

Estas dependencias se indican en un archivo .xml el cual hace referencia a lo que va a usar esa carpeta, los tipos de archivo que va a necesitar o crear para que al momento de compilar la carpeta sea eficiente y comprensible para ROS.

Al momento de digitar el comando puede que genere un error de permisos por lo que debe habilitar la carpeta de ROS para aceptar lectura y escritura con el siguiente comando:

$ sudo chown –R nombredeUsuario /opt/ros/electric/stacks

Una vez realizado este procedimiento puede ingresar al paquete creado e interactuar con él, para este ejemplo debemos ingresar a la carpeta llamada kobuki_controller_tutorial con el comando roscd:

$ roscd kobuki_controller_tutorial/

Ahora el paso a seguir es ingresar a la carpeta general de ROS donde se encuentran los archivos que interactúan con el robot y el sistema llamado “include”, para esto ingresamos asi:

$ cd /opt/ros/groovy/include

En esta carpeta se debe crear una carpeta adicional con el nombre preferiblemente de la carpeta creada anteriormente.

$ mkdir kobuki_controller_tutorial

A continuación se debe crear el programa que necesitamos para que ejecute alguna acción, para este tutorial lo que queremos es que al golpear el bumper pueda encender un LED.

Creamos el archivo bump_blink_controller.hpp

$ sudo gedit bump_blink_controller.hpp 

 El código es el siguiente: 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
#include <ros/ros.h>
#include <std_msgs/Empty.h>
#include <yocs_controllers/default_controller.hpp>
#include <kobuki_msgs/BumperEvent.h>
#include <kobuki_msgs/Led.h>
namespace kobuki
{
* @ brief A simple bump-blink-controller
*
* A simple nodelet-based controller for Kobuki, which makes one of Kobuki's LEDs blink, when a bumper is pressed.
*/
class BumpBlinkController : public yocs::Controller
{
public:
BumpBlinkController(ros::NodeHandle& nh, std::string& name) : Controller(), nh_(nh), name_(name){};
~BumpBlinkController(){};
/**
* Set-up necessary publishers/subscribers
* @return true, if successful
*/
bool init()
{
enable_controller_subscriber_ = nh_.subscribe("enable", 10, &BumpBlinkController::enableCB, this);
disable_controller_subscriber_ = nh_.subscribe("disable", 10, &BumpBlinkController::disableCB, this);
bumper_event_subscriber_ = nh_.subscribe("events/bumper", 10, &BumpBlinkController::bumperEventCB, this);
// choose between led1 and led2
blink_publisher_ = nh_.advertise< kobuki_msgs::Led >("commands/led1", 10);
return true;
};
private:
ros::NodeHandle nh_;
std::string name_;
ros::Subscriber enable_controller_subscriber_, disable_controller_subscriber_;
ros::Subscriber bumper_event_subscriber_;
ros::Publisher blink_publisher_;
/**
* @brief ROS logging output for enabling the controller
* @param msg incoming topic message
*/
void enableCB(const std_msgs::EmptyConstPtr msg);
/**
* @brief ROS logging output for disabling the controller
* @param msg incoming topic message
*/
void disableCB(const std_msgs::EmptyConstPtr msg);
/**
* @brief Turns on/off a LED, when a bumper is pressed/released
* @param msg incoming topic message
*/
void bumperEventCB(const kobuki_msgs::BumperEventConstPtr msg);
};
void BumpBlinkController::enableCB(const std_msgs::EmptyConstPtr msg)
{
if (this->enable())
{
ROS_INFO_STREAM("Controller has been enabled. [" << name_ << "]");
}
else
{
ROS_INFO_STREAM("Controller was already enabled. [" << name_ <<"]");
}
};
void BumpBlinkController::disableCB(const std_msgs::EmptyConstPtr msg)
{
if (this->disable())
{
ROS_INFO_STREAM("Controller has been disabled. [" << name_ <<"]");
}
else
{
ROS_INFO_STREAM("Controller was already disabled. [" << name_ <<"]");
}
};
void BumpBlinkController::bumperEventCB(const kobuki_msgs::BumperEventConstPtr msg)
{
if (this->getState()) // check, if the controller is active
{
// Preparing LED message
kobuki_msgs::LedPtr led_msg_ptr;
led_msg_ptr.reset(new kobuki_msgs::Led());
if (msg->state == kobuki_msgs::BumperEvent::PRESSED)
{
ROS_INFO_STREAM("Bumper pressed. Turning LED on. [" << name_ << "]");
led_msg_ptr->value = kobuki_msgs::Led::GREEN;
blink_publisher_.publish(led_msg_ptr);
}
else // kobuki_msgs::BumperEvent::RELEASED
{
ROS_INFO_STREAM("Bumper released. Turning LED off. [" << name_ << "]");
led_msg_ptr->value = kobuki_msgs::Led::BLACK;
blink_publisher_.publish(led_msg_ptr);
}
}
};
}

 A continuación se debe volver a la carpeta kobuki_controller_tutorial que se creó primero, y se deben crear dos carpetas, una llamada /plugins y otra llamada /launch.

$ mkdir plugins
$ mkdir launch

 En la carpeta de plugins vamos a crear un archivo .xml con el siguiente código.

$ sudo gedit nodelet_plugins.xml

 

1
2
3
4
5
6
7
8
<library path="lib/libbump_blink_controller_nodelet">
<class name="kobuki_controller_tutorial/BumpBlinkControllerNodelet" type="kobuki::BumpBlinkControllerNodelet" base_class_type="nodelet::Nodelet">
<description>
Nodelet for a simple blink when bump controller
</description>
</class>
</library>

 Luego en guardamos y salimos de la carpeta de plugins para modificar el archivo manifest.xml de la siguiente forma.

$ sudo gedit manifest.xml

 En la línea antes de </package> se coloca lo siguiente: 

1
2
3
<export>
<nodelet plugin="${prefix}/plugins/nodelet_plugins.xml" />
</export>

Guardamos el archivo y compilamos.

$ make

 *Puede que el sistema ROS no tenga la librería yocs_controllers por eso es necesario revisar utilizando el comando roscd. 

$ cd /opt/ros/groovy/include/yocs_controller 

$ ls

Debe aparecer un archivo llamado default_controller.hpp de lo contrario debe ser creado de la misma forma que se creó el bump_blink_controller.hpp con las siguientes líneas de código: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*****************************************************************************
** Ifdefs
*****************************************************************************/
#ifndef DEFAULT_CONTROLLER_HPP_
#define DEFAULT_CONTROLLER_HPP_
/*****************************************************************************
** Includes
*****************************************************************************/
namespace yocs
{
class Controller
{
public:
Controller() : controller_active_(false)
{};
virtual ~Controller(){};
virtual bool init() = 0;
bool enable()
{
if (controller_active_)
{
return false;
}
else
{
controller_active_ = true;
return true;
}
};
bool disable()
{
if (!controller_active_)
{
return false;
}
else
{
controller_active_ = false;
return true;
}
};
bool getState()
{
return controller_active_;
}
virtual void spin()
{
// do nothing
};
private:
bool controller_active_;
};
} // namespace yocs
#endif /* DEFAULT_CONTROLLER_HPP_ */

Luego de compilar procedemos a ingresar a la carpeta /launch y crear un archivo .launch para que pueda ser ejecutado por ROS el archivo que se ha realizado.

$ sudo gedit kobuki_bumper.launch

Se escribe lo siguiente: 

1
2
3
4
5
6
<launch>
<node pkg="nodelet" type="nodelet" name="bump_blink_controller" args="load kobuki_controller_tutorial/BumpBlinkControllerNodelet kobuki">
<remap from="bump_blink_controller/events/bumper" to="mobile_base/events/bumper"/>
<remap from="bump_blink_controller/commands/led1" to="mobile_base/commands/led1"/>
</node>
</launch>

Luego de guardar el archivo se puede lanzar el programa creado. Primero se debe ejecutar el minimal para lanzar los nodos y topics que se necesitan.

$ roslaunch kobuki_node minimal.launch --screen

 Luego se lanza el programa que se creó.

$ roslaunch kobuki_controller_tutorial bump_blink_app.launch --screen

Por último se publica el topic que va a activar el programa.

$ rostopic pub /bump_blink_controller/enable std_msgs/Empty

Ahora cada vez que se golpea va a encender el LED.

Hola mundo Turtlebot

Imprimir
Creado en Lunes, 07 Octubre 2013 Última actualización el Miércoles, 08 Enero 2014 Escrito por Ibra!
AddThis Social Bookmark Button

Nota: Este articulo fue escrito con la colaboración de Juan Carlos Hernández en su trabajo como pasante de la Universidad Militar Nueva Granada en tdrobotica.

Este articulo hace parte de la serie de tutoriales escritos sobre ROS y turtlebot. Si no conoce el turtlebot te recomendamos el siguiente articulo y si quieres realizar este tutorial te recomendamos antes instalar el ROS.

365

El funcionamiento del turtlebot se realiza a través de ROS (Robot Operating System) por lo tanto vamos a iniciar descargando los paquetes y configurando todo el entorno de desarrollo. Ten en cuenta que ROS funciona especialmente bien en Ubuntu, para nuestro caso hemos usado en el PC de desarrollo el Ubuntu 12.10 y el ROS Groovy y en el equipo del turtlebot Ubuntu 12.04 LTS y ROS Groovy.

Estas instrucciones estan muy bien descritas en el sitio web de ROS, sin embargo las hemos dejado también acá para explicar algunos procesos y pasos que los expertos pueden no conocer. El primer paso es descargar los paquetes de turtlebot. 

$sudo apt-get install ros-hydro-turtlebot ros-hydro-turtlebot-apps ros-hydro-turtlebot-viz ros-hydro-turtlebot-simulator

Instalación: http://wiki.ros.org/turtlebot/Tutorials/hydro/Installation

Es conveniente para efectos prácticos realizar la siguiente modificación para que al ingresar al terminal se habilite el siguiente archivo. 

$ echo "source /opt/ros/hydro/setup.bash" >> ~/.bashrc

 Para preparar el sistema debemos ahora, digitar:

$ sudo apt-get install python-rosdep python-wstool ros-hydro-ros
$ sudo rosdep init
$ rosdep update

 Luego de estos pasos se debe descargar el protocolo de tiempo de red, para esto descargamos el paquete:

$ sudo apt-get install chrony

 A continuación el computador debe estar conectado al turtlebot y este debe estar encendido.

 Configurar conexión de red:

Debemos configurar la red entre el turtlebot y el computador, para eso vamos a usar los siguientes comandos:

$echo export ROS_MASTER_URI=http://”Ip que tiene el computador”:11311 >>.bashrc 
$echo export ROS_HOSTNAME=”Ip que tiene el computador” >> .bashrc

 Puede realizar esta operación de forma diferente si presenta algún error (Si más adelante puede encontrar un error de conexión y puede seguir este paso para realizar las respectivas modificaciones de red), o le resulta más fácil de este modo.

$ sudo gedit ~/.bashrc

 Con este comando debe abrir un archivo de texto con todo el contenido del archivo. Al final del archivo debe observar algo como lo anterior:

echo export ROS_MASTER_URI=http://”Ip que tiene el computador”:11311 >>.bashrc
echo export ROS_HOSTNAME=”Ip que tiene el computador” >> .bashrc

Si no ha aparece debe ingresar las mismas líneas y guardar el archivo. 

Después de este procedimiento, se debe inicializar el proceso para que se conecte internamente el robot y el computador.

$roslaunch turtlebot_bringup minimal.launch

Turtlebot debe emitir un sonido luego de algunos Segundos lo que significa que hubo conexión, de lo contrario debe revisar el terminal para comprobar que tipo de error se presento.

*Cuando carga el paquete no debe cerrarlo, debe abrir un nuevo terminal para seguir trabajando.

Para comprobar que la conexión este correcta se debe introducir el comando rostopic list  y, si hay conexión mostrara todo un listado de temas para seleccionar. De lo contrario debe aparecer un error de comunicación como el siguiente: 

ERROR: Unable to communicate with master!
 
 Si sale este error debe observar la Ip del Master y la Ip del Host, para esto debe digitar lo siguiente: 
$echo $ROS_MASTER_URI

$echo $ROS_HOSTNAME

En las dos líneas de código debe aparecer la misma Ip que es la dirección que toma el computador en la red. (Puede confirmarla desde el terminal con el comando Ifconfig).

 Una vez solucionado el problema puede ver el estado del turtlebot con la siguiente instrucción:

$roslaunch turtlebot_dashboard turtlebot_dashboard.launch

Antes de esta instrucción puede seleccionar que desea diagnosticar, dando uso a lo siguiente:

$ rqt -s kobuki_dashboard

Con esto puede observar el diagnostico de como se encuentra el turtlebot.

Una primera operación sencilla es controlar el turtlebot digitando el siguiente comando:

roslaunch turtlebot_teleop keyboard_teleop.launch

 *Si desea controlarlo de de forma remota (Es decir con otro computador diferente al que está conectado al turtlebot) lo que se debe hacer, son dos pasos sencillos; configurar el ordenador remoto, descargando los paquetes de Ros y los del turtlebot (Es decir realizar el Post#2 y Post#3) y   a seguir, recurrir al modo SSh (El ordenador remoto debe tener configurado el ROS_MASTER_URI con la Ip del turtlebot y el ROS_HOSTNAME con la Ip del ordenador remoto, esto siguiendo los pasos de configuración de red), el cual se va a explicar a continuación.

 Para acceder a un terminal remoto, se usa el comando SSH cuya traducción es intérprete de comandos seguro. 

 Solo debe ingresar desde el ordenador remoto: 

ssh turtlebot@IP_OF_TURTLEBOT>

Turtlebot es el nombre del root o super usuario, es el nombre que aparece en el terminal antes de la @. Luego debe digitar la Ip que tiene el computador que está conectado al turtlebot. 

Luego de ingresar estos datos va a pedir un password que es el mismo con el que se accede al inicio de Ubuntu.

Luego de esto puede digitar la instrucción para operar el turtlebot.

roslaunch turtlebot_teleop keyboard_teleop.launch

 En la parte superior del terminal, indica los botones para operar el turtlebot:

Los botones u, i, o, controlan los movimientos hacia adelante, es decir diagonal izquierda, hacia adelante y diagonal derecha, respectivamente, todos movimientos hacia el frente.

Los botones j, k, l, controlan el giro hacia la izquierda, la detención forzosa y giro a la derecha.

Los botones m , y . Son los movimientos inversos a los que realiza hacia adelante.

Los controles de max speed o de velocidad controlan la máxima velocidad que alcanza en tramos largos.

Los controles de linear speed  es la velocidad con la que se mueve desde el inicio.

Los controles de angular speed es la velocidad de giro.

 

Hola mundo ROS

Imprimir
Creado en Lunes, 07 Octubre 2013 Última actualización el Miércoles, 08 Enero 2014 Escrito por Ibra!
AddThis Social Bookmark Button

Nota: Este articulo fue escrito con la colaboración de Juan Carlos Hernández en su trabajo como pasante de la Universidad Militar Nueva Granada en tdrobotica.

Para empezar a manejar ya sea la base kobuki o el turtlebot debemos tener un computador que tenga instalado el sistema operativo Linux, más específicamente Ubuntu 12.04 o posterior. ROS ha sido desarrollado principalmente para Ubuntu y nos ahorraremos trabajo si utilizamos este sistema operativo. Como se comentó anteriormente todas nuestras pruebas se han realizado en Ubuntu 12.04 y ROS Groovy.

366

Cuando se tiene el computador con Linux Ubuntu el siguiente paso es instalar ROS (Sistema Operativo para Robots). ROS es una compilación de librerías de robótica que se instalan sobre el sistema operativo Ubuntu. Hay que tener en cuenta que ROS ha sido desarrollado principalmente por investigadores del área de robótica en todo el mundo, la arquitectura hace que sea muy robusto para iniciar a trabajar aunque esto también se traduce en que la curva de aprendizaje sea lenta.

En la página de ros.org se puede encontrar mucha información de cómo se trabaja con ROS, así como tutoriales en ingles y aplicaciones prácticas. Sin embargo en tdrobotica hemos decidido documentar los pasos que hemos realizado en nuestro caso puntual y que han funcionado satisfactoriamente hasta el momento. No pretendemos reemplazar la documentación del sitio web oficial, sino por el contrario documentar nuestro propio proceso, dificultades y soluciones.

Cuando accedemos a Linux para poder descargar sin complicaciones los paquetes y archivos de ROS, debemos hacer dos cosas. Primero debemos acceder a update manager para acceder a “restricted”, “universe” y “multiverse”. Estos son repositories o depósitos,  esto debe habilitarse para que pueda encontrar las actualizaciones que se necesitan.

Puedes encontrar el update manager en el sistema de búsqueda de Ubuntu. Posteriormente se busca la pestaña other software y se debe añadir la siguiente dirección:

http://packages.ros.org/ros/ubuntu precise main
Puede ver con mas detalle los pasos a seguir en este tutorial.

Esto con el fin de que encuentre todos los paquetes que provengan de ROS.

Luego debemos abrir el terminal de Linux para descargar las llaves y poder descargar los paquetes ROS. Esto se hace digitando en el terminal:

$wget http://packages.ros.org/ros.key -O - | sudo apt-key add -

Luego nos debemos asegurar de que estén todos los paquetes actualizados para que pueda descargarlos e instalarlos, para eso debemos teclear:

$sudo apt-get update

Ahora si se puede descargar los paquetes de ROS.

Para descargar un paquete desde el terminal solo se debe digitar:

sudo apt-get install “Nombre del paquete”

 Si se desea instalar todo el paquete de ROS Groovy se debe colocar:

$sudo apt-get install ros-groovy-desktop-full

Si quisiera ver los paquetes que pueden descargar individualmente solo debe colocar:

apt-cache search ros-groovy

Una vez instalados los paquetes de ROS y antes de empezar a interactuar con este nuevo sistema se debe iniciar el Rosdep, con el cual nos va a permitir instalar algunos complementos y ejecutar otros componentes.

$sudo rosdep init
$rosdep update

Por último se debe instalar Rosinstall, con el que se hará más fácil descargar arboles de código fuente para todo lo que proviene de ROS y con un solo comando.

sudo apt-get install python-rosinstall

Con estos pasos ya podemos empezar a trabajar con el robot, pero antes hay que conocer algunos fundamentos del uso de ROS para entender los códigos que se usan para interactuar con el turtlebot.

 MANEJO DE ROS:

En el sistema de Ros se puede contemplar diferentes librerías y funciones para realizar distintas operaciones por eso es importante comenzar a manejar los paquetes, saber cómo buscarlos, como ingresar, como moverme dentro del entorno de ROS.

Lo primero que se debe aprender es a buscar paquetes, esto se realiza con el comando rospack seguido del comando find:

# rospack find “Nombre del paquete”

Otro comando que puede ser muy usado es el comando echo que nos permite observar que contiene un paquete, de la siguiente forma.

# echo $ROS_PACKAGE_PATH

 Crear un paquete catkin:

Para un paquete ser considerado un paquete catkin debe cumplir una serie de requisitos:

  • El paquete debe contener un archivo package.xml compatible.
  • Ese archivo package.xml proporciona información de metadatos sobre el paquete.
  • El paquete debe contener una CMakeLists.txt. Metapaquetes Catkin. deben tener un archivo CMakeLists.txt repetitivo.
  • No puede haber más de un paquete en cada carpeta.

Esto significa que no hay paquetes anidados ni varios paquetes que comparten el mismo directorio. Para conocer más de catkin y su uso práctico puede ingresar al link:

http://wiki.ros.org/ROS/Tutorials/CreatingPackage

 Para crear un paquete de catkin se utiliza el comando catkin_create_pkg, se debe realizar de la siguiente forma:

$ cd ~/catkin_ws/src
$ catkin_create_pkg empezando_tutorial std_msgs rospy roscpp

 En este paso anterior se crea el archivo empezando tutorial que depende de std_msgs, rospy y roscpp. Las dependencias deben ir después del nombre del paquete. Para mayor información favor remitirse a http://wiki.ros.org/ROS/Tutorials/CreatingPackage

Construir paquetes:

catkin_make es una herramienta de línea de comandos que añade comodidad para el flujo de trabajo catkin estándar. Se puede decir que catkin_make combina las cmake y Make en el flujo de trabajo CMake estándar.

$ catkin_make [make_targets] [-DCMAKE_VARIABLES=...]

Para las personas que no están familiarizados con el flujo de trabajo CMake estándar, se descompone de la siguiente manera:

$ mkdir build
$ cd build
$ cmake ..
$ make
$ make install  # (opcional)

Para obtener más información y realizar un paquete de prueba debe igresar a:

http://wiki.ros.org/ROS/Tutorials/BuildingPackages

Los nodes y topics:

El funcionamiento de los Nodes es simplemente un archivo ejecutable que utiliza ROS para comunicarse con otros Nodes.

Un Node es un ejecutable en un paquete de ROS. Utiliza una biblioteca Client ROS para comunicarse con otros Nodes. Los Nodes pueden publicar o suscribirse a un Topic. Los Nodes también pueden proporcionar o utilizar un servicio.

Existen también otros comandos de Ros importantes como el Rosrun, Roscore y se pueden observar con más detalle en el siguiente Link: http://wiki.ros.org/ROS/Tutorials/UnderstandingNodes

Los Topics son mensajes que publica un Node a otro Node, así como también puede ser una suscripción  del Node para recibir mensajes.

Para ver cómo funcionan los topics en Ros es necesario, primero que este habilitado roscore para que pueda funcionar el ejemplo que vamos a realizar.

Los topics o temas de ROS se pueden observar en el terminal a través del comando rostopic, a su vez es también cuenta con un sub comando de ayuda para poder encontrar lo que necesita.

Puede acceder a la lista de rostopic de dos formas:

·         $ rostopic -h

 O la otra forma es digitar rostopic y presionar dos veces la tecla de tabulación.

Para realizar una práctica del funcionamiento de rostopic, debe dirigirse a la página web:

http://wiki.ros.org/ROS/Tutorials/UnderstandingTopics

 Lo que vamos a usar más adelante para observar la lista de topics en el turtlebot es el comando:

·         $ rostopic list

Con este comando podemos observar los distintos topics que se encuentran en el robot.

Si se quiere observar el comportamiento o que datos contiene cada uno de los topics se debe recurrir al comando echo en rostopic para observar el contenido de cada uno. 

·         $ rostopic echo “Nombre del tema”
·         $ rostopic list /odom

En este caso se debe mostrar en la pantalla la odometria del robot. Si coloco peso al robot debe mostrarme nuevos datos acerca de lo que está sucediendo en el momento.

Para observar las diferentes funciones que se pueden realizar en Rostopic debe recurrir al link: http://wiki.ros.org/ROS/Tutorials/UnderstandingTopics

El uso de roslaunch:

Al usar el roslaunch podemos iniciar nodes definidos en el sistema.

$ roslaunch [paquete] [nombre_archivo.launch]

Con este comando se puede empezar a trabajar con el turtlebot, encender diferentes aplicaciones para observar el funcionamiento del mismo. 

Turtlebot 2

Imprimir
Creado en Lunes, 07 Octubre 2013 Última actualización el Miércoles, 08 Enero 2014 Escrito por Ibra!
AddThis Social Bookmark Button

Nota: Este articulo fue escrito con la colaboración de Juan Carlos Hernández en su trabajo como pasante de la Universidad Militar Nueva Granada en tdrobotica.

En tdrobotica hemos estado buscando las mejores plataformas de robótica móvil para el nivel de investigación. En este proceso hemos estado trabajando con la plataforma turtlebot, que es la plataforma básica para trabajar con ROS (Robot Operating System) y algoritmos avanzados de SLAM, visión artificial, cámaras RGB-D y nubes de puntos.

El robot esta compuesto por una base móvil Kobuki que incluye un sistema diferencial de movimiento con encoders y giroscopio electrónico. Adicionalmente tiene un kinect que es su sensor, cámara y en general el dispositivo por el cual adquiere información del espacio que lo rodea. Y todo esta integrado desde un computador netbook a través de sistema operativo de robots ROS.

365 03

Kobuki es un robot similar al irobot roomba, de la empresa irobot, donde su principal función era el aseo y la limpieza de viviendas. El Kobuki cuenta con sensores infrarojos para detectar escaleras, tiene un bumper que le ayuda a recibir el golpe y reaccionar ante el evento, cuenta con un giroscopior para controlar la odometria, llantas especiales para pasar por encima de obstáculos y moverse en cualquier superficie, botones de accionamiento, LEDs programables, entradas y voltajes para alimentación, puerto Usb y Un puerto DB-25.

Puertos de la base kobuki de la empresa youjin

El kinect le da la capacidad de detectar objetos, calcular distancias, crear mapas y posteriormente navegar sobre el mapa de un lugar a otro. Hay que tener en cuenta que el kinect es un hito en la historia de la robótica por sus características y su buena relación de precio, sin embargo se queda corto cuando las aplicaciones son en exteriores. La explosión de aplicaciones para el kinect en robótica, visión artificial, e investigación son amplias y adicionalmente la difusión de la información también.

365

 

Esperas más adelante nuestras primeras experiencias con el turtlebot, kobuki, kinect y ROS en Colombia por tdrobotica.