## page was copied from ROS/Tutorials/UnderstandingTopics
####################################
##FILL ME IN
####################################
## links to any required tutorials
## note.0= [[es/ROS/Tutoriales/ComprendiendoNodosROS|Comprendiendo Nodos ROS]]
## descriptive title for the tutorial
## title = Comprendiendo Tópicos ROS
## multi-line description to be displayed in search 
## description = Este tutorial es una introducción a los Tópicos de ROS y al uso de las herramientas de línea de comando [[rostopic]] y [[rqt_plot]].
## the next tutorial description 
## next =
## links to next tutorial
## next.0.link= [[es/ROS/Tutoriales/ComprendiendoServiciosParametros|Comprendiendo Servicios y Parametros ROS]]
## what level user is this tutorial for
## level= BeginnerCategory
####################################

<<IncludeCSTemplate(TutorialCSHeaderTemplate)>>

<<TOC(4)>>

== Configuración ==

=== roscore ===
Comencemos asegurándonos de que roscore esta corriendo, '''en una nueva terminal''':
{{{
$ roscore
}}}
Si dejaste roscore corriendo desde el tutorial anterior, veras el siguiente mensaje de error:
 {{{
roscore cannot run as another roscore/master is already running. 
Please kill other roscore/master processes before relaunching
}}}
Esto esta bien. Solo es necesario que corra un nucleo ROS (ROS Core) a la vez.


=== turtlesim ===
Para este tutorial usaremos nuevamente turtlesim.  Corra '''en una nueva terminal''':
{{{
$ rosrun turtlesim turtlesim_node
}}} 

=== operando turtle mediante teclado ===
Tambien necesitamos algo para manejar la tortuga por ahí y que no se nos escape. Por favor corra '''en una nueva terminal''':
{{{
$ rosrun turtlesim turtle_teleop_key
}}}

 {{{
[ INFO] 1254264546.878445000: Started node [/teleop_turtle], pid [5528], bound on [aqy], xmlrpc port [43918], tcpros port [55936], logging to [~/ros/ros/log/teleop_turtle_5528.log], using [real] time
Reading from keyboard
---------------------------
Use arrow keys to move the turtle.
}}}

Ahora podemos usar las teclas con flechas del teclado para mover por ahí a la tortuga. Si 
 la misma no se mueve '''seleccione la ventana de terminal que está corriendo turtle_teleop_key''' para asegurarse que los golpes de tecla son registrados. 

 {{attachment:turtle_key.png}}

Ahora que podemos mover la tortuga por ahí, veamos que está sucediendo tras bambalinas. 

== Tópicos ROS (ROS Topics) ==

El nodo `turtlesim_node` y el nodo` turtle_teleop_key` se comunican entre sí a través de un '''Tópico''' ROS (ROS Topic). `turtle_teleop_key` está '''publicando''' las pulsaciones de tecla sobre un tópico, mientras que` turtlesim` '''suscribe''' al mismo tópico para recibir las pulsaciones de tecla. Usemos [[rqt_graph]] que nos muestra los nodos y temas que se están ejecutando actualmente.

Nota: Si está usando `electric` o una versión anterior,` rqt` no estara disponible. Utilice `rxgraph` en su lugar.

=== Usando rqt_graph ===

`rqt_graph` crea un gráfico dinámico de lo que está sucediendo en el sistema. rqt_graph es parte del paquete `rqt`. A menos que ya lo tenga instalado, ejecute:

  {{{
$ sudo apt-get install ros-<distro>-rqt
$ sudo apt-get install ros-<distro>-rqt-common-plugins
}}}
reemplazando <distro> con el nombre de su [[Distributions|distribuciones ROS]] (por ejemplo, índigo, jade, cinético, lunar ...)

'''En una nueva terminal''':

{{{
$ rosrun rqt_graph rqt_graph
}}}

Usted verá algo similar a esto: 

{{attachment:rqt_graph_turtle_key.png||width=100%}}

Si coloca el mouse sobre `/turtle1/command_velocity`, resaltará los nodos ROS (aquí azul y verde) y los tópicos (aquí rojo). Como puede ver, los nodos `turtlesim_node` y` turtle_teleop_key` se están comunicando mediante el tópico llamado `/turtle1/command_velocity`.

{{attachment:rqt_graph_turtle_key2.png||width=100%}}

=== Introducción a rostopic ===

La herramienta `rostopic` le permite obtener información sobre los Tópicos (topics) '' 'ROS' ''.
Puede utilizar la opción de ayuda para obtener los subcomandos disponibles para {{{rostopic}}}

{{{
$ rostopic -h
}}}
 {{{
rostopic bw     display bandwidth used by topic
rostopic echo   print messages to screen
rostopic hz     display publishing rate of topic    
rostopic list   print information about active topics
rostopic pub    publish data to topic
rostopic type   print topic type
}}}

O presionar la tecla de `tabulación` después de `rostopic` y se le presentaran las distintas opciones de subcomandos:

{{{
$ rostopic 
bw    echo  find  hz    info  list  pub   type 
}}}

Usemos algunos de estos subcomandos de temas para examinar turtlesim.

=== Usando rostopic echo ===
`rostopic echo` muestra la información publicada por un tópico.

Uso: 
{{{
rostopic echo [topic]
}}}

Veamos los datos de velocidad del comando publicados por el nodo `turtle_teleop_key`.

''Para ROS Hydro y posteriores,'' esta información es publicada en el tópico `/turtle1/cmd_vel`. '''En una nueva terminar corra:'''
{{{
$ rostopic echo /turtle1/cmd_vel
}}}
''Para ROS Groovy y anteriores,'' esta información sera publicada en el tópico`/turtle1/command_velocity`. '''En una nueva terminal corra:'''
{{{
$ rostopic echo /turtle1/command_velocity
}}}

Probablemente no verá que suceda nada porque no se están publicando datos sobre el tópico. Hagamos que `turtle_teleop_key` publique datos presionando las teclas de flecha. '''Recuerde que si la tortuga no se está moviendo, debe seleccionar la terminal `turtle_teleop_key` nuevamente.'''

''Para ROS Hydro y posteriores,'' ahora debería ver lo siguiente cuando presione la tecla arriba:
{{{
linear: 
  x: 2.0
  y: 0.0
  z: 0.0
angular: 
  x: 0.0
  y: 0.0
  z: 0.0
---
linear: 
  x: 2.0
  y: 0.0
  z: 0.0
angular: 
  x: 0.0
  y: 0.0
  z: 0.0
---

}}}
''Para ROS Groovy y anteriores,'' ahora debería ver lo siguiente:
{{{
---
linear: 2.0
angular: 0.0
---
linear: 2.0
angular: 0.0
---
linear: 2.0
angular: 0.0
---
linear: 2.0
angular: 0.0
---
linear: 2.0
angular: 0.0
}}}

Ahora echemos un vistazo a `rqt_graph` nuevamente. Presione el botón de actualización en la parte superior izquierda para mostrar el nuevo nodo. Como puede ver, `rostopic echo`, que se muestra aquí en rojo, ahora también está '''suscrito''' al tópico `turtle1/command_velocity`.

{{attachment:rqt_graph_echo.png||width=100%}}

=== Usando rostopic list ===
`rostopic list` devuelve una lista de todos los tópicos actualmente suscritos y publicados.

Averigüemos qué argumento necesita el subcomando `list`. En una '''nueva terminal''' ejecute:

{{{ 
$ rostopic list -h
}}}
 {{{
Usage: rostopic list [/topic]

Options:
  -h, --help            show this help message and exit
  -b BAGFILE, --bag=BAGFILE
                        list topics in .bag file
  -v, --verbose         list full details about each topic
  -p                    list only publishers
  -s                    list only subscribers
}}}

Para {{{rostopic list}}} use la opcion '''verbose''':

{{{
$ rostopic list -v
}}}
Esto muestra una lista detallada de temas para publicar y suscribirse y su tipo.

''Para ROS Hydro y posteriores,''
 {{{
Published topics:
 * /turtle1/color_sensor [turtlesim/Color] 1 publisher
 * /turtle1/cmd_vel [geometry_msgs/Twist] 1 publisher
 * /rosout [rosgraph_msgs/Log] 2 publishers
 * /rosout_agg [rosgraph_msgs/Log] 1 publisher
 * /turtle1/pose [turtlesim/Pose] 1 publisher

Subscribed topics:
 * /turtle1/cmd_vel [geometry_msgs/Twist] 1 subscriber
 * /rosout [rosgraph_msgs/Log] 1 subscriber
}}}
''Para ROS Groovy y anteriores,''
 {{{
Published topics:
 * /turtle1/color_sensor [turtlesim/Color] 1 publisher
 * /turtle1/command_velocity [turtlesim/Velocity] 1 publisher
 * /rosout [roslib/Log] 2 publishers
 * /rosout_agg [roslib/Log] 1 publisher
 * /turtle1/pose [turtlesim/Pose] 1 publisher

Subscribed topics:
 * /turtle1/command_velocity [turtlesim/Velocity] 1 subscriber
 * /rosout [roslib/Log] 1 subscriber

}}}


== Mensajes ROS (ROS Messages) ==

La comunicación sobre los tópicos ocurre enviando '''mensajes''' ROS (ROS Messages) entre nodos. Para que el editor (`turtle_teleop_key`) y el suscriptor (` turtlesim_node`) se comuniquen, el editor y el suscriptor deben enviar y recibir el mismo '''tipo''' de mensaje. Esto significa que un tópico '''tipo''' está definido por el mensaje '''tipo''' publicado en él. El '''tipo''' del mensaje enviado sobre un tópico se puede determinar usando `rostopic type`.

=== Usando rostopic type ===
{{{rostopic type}}} devuelve el tipo de mensaje de un determinado tópico que está siendo  publicado.

Uso: 
{{{
rostopic type [topic]
}}}

''Para ROS Hydro y posteriores,'' use:

{{{
$ rostopic type /turtle1/cmd_vel
}}}

Usted debería obtener como resultado:
{{{
geometry_msgs/Twist
}}}

Podemos ver los detalles del mensaje mediante el uso de `rosmsg`:

{{{
$ rosmsg show geometry_msgs/Twist
}}}

{{{
geometry_msgs/Vector3 linear
  float64 x
  float64 y
  float64 z
geometry_msgs/Vector3 angular
  float64 x
  float64 y
  float64 z
}}}

''Para ROS Groovy y anteriores,'' utilice:

{{{
$ rostopic type /turtle1/command_velocity
}}}
y usted deberia obtener como resultado en la consola la siguiente salida:

{{{
turtlesim/Velocity
}}}

y pude ver mas en detalle la salida del mensaje mediante el uso de`rosmsg`:

{{{
$ rosmsg show turtlesim/Velocity
}}}

{{{
float32 linear
float32 angular
}}}

Ahora que sabemos qué tipo de mensaje espera turtlesim, podemos publicar comandos en nuestra tortuga.

== rostopic adicional ==
Ahora que hemos aprendido acerca de los '''mensajes''' de ROS (ROS messages), usemos rostopic con mensajes.

=== Usando rostopic pub ===
`rostopic pub` publica datos en un tópico que ya está siendo emitido.

Uso: 
{{{
rostopic pub [topic] [msg_type] [args]
}}}
''Para ROS Hydro y posteriores,'' utilice este ejemplo:
{{{
$ rostopic pub -1 /turtle1/cmd_vel geometry_msgs/Twist -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]'
}}}
''Para ROS Groovy y anteriores,'' utilice este ejemplo:
{{{
$ rostopic pub -1 /turtle1/command_velocity turtlesim/Velocity  -- 2.0  1.8
}}}

El comando anterior enviará un solo mensaje a turtlesim diciéndole que se mueva con una velocidad lineal de 2.0 y una velocidad angular de 1.8.

 {{attachment:turtle(rostopicpub).png}}

Si bien el comando es corto este es un ejemplo complejo, así que repasemos cada argumento en detalle.

''Para ROS Hydro y posteriores,''
 * This command will publish messages to a given topic: {{{
rostopic pub}}}  
 * This option (dash-one) causes rostopic to only publish one message then exit: {{{
 -1 }}} 
 * This is the name of the topic to publish to: {{{
/turtle1/cmd_vel}}}
 * This is the message type to use when publishing to the topic: {{{
geometry_msgs/Twist}}} 
 * This option (double-dash) tells the option parser that none of the following arguments is an option.  This is required in cases where your arguments have a leading dash `-`, like negative numbers.{{{
--}}} 
 * As noted before, a geometry_msgs/Twist msg has two vectors of three floating point elements each: {{{linear}}} and {{{angular}}}.  In this case, {{{'[2.0, 0.0, 0.0]'}}} becomes the linear value with `x=2.0`, `y=0.0`, and `z=0.0`, and {{{'[0.0, 0.0, 1.8]'}}} is the {{{angular}}} value with `x=0.0`, `y=0.0`, and `z=1.8`.  These arguments are actually in YAML syntax, which is described more in the [[ROS/YAMLCommandLine|YAML command line documentation]]. {{{ 
'[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]' }}}

''Para ROS Groovy y anteriores,''
 * This command will publish messages to a given topic: {{{
rostopic pub}}}  
 * This option (dash-one) causes rostopic to only publish one message then exit: {{{
 -1 }}} 
 * This is the name of the topic to publish to: {{{
/turtle1/command_velocity}}}
 * This is the message type to use when publishing to the topic: {{{
turtlesim/Velocity}}} 
 * This option (double-dash) tells the option parser that none of the following arguments is an option.  This is required in cases where your arguments have a leading dash `-`, like negative numbers.{{{
--}}} 
 * As noted before, a turtlesim/Velocity msg has two floating point elements : {{{linear}}} and {{{angular}}}.  In this case, {{{2.0}}} becomes the linear value, and {{{1.8}}} is the {{{angular}}} value.  These arguments are actually in YAML syntax, which is described more in the [[ROS/YAMLCommandLine|YAML command line documentation]]. {{{ 
2.0 1.8 }}}

Puede que hayas notado que la tortuga ha dejado de moverse; esto se debe a que la tortuga requiere un flujo constante de comandos a 1 Hz para seguir moviéndose. Podemos publicar un flujo constante de comandos usando el comando `rostopic pub -r`:

''Para ROS Hydro y posteriores,''
 {{{
$ rostopic pub /turtle1/cmd_vel geometry_msgs/Twist -r 1 -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, -1.8]'
}}}
''Para ROS Groovy y anteriores,''
 {{{
$ rostopic pub /turtle1/command_velocity turtlesim/Velocity -r 1 -- 2.0  -1.8
}}}
Esto publica los comandos de velocidad a una frecuencia de 1 Hz sobre el tema de la velocidad.
 
 {{attachment:turtle(rostopicpub)2.png}}

También podemos ver lo que está sucediendo en `rqt_graph`. Presiona el botón de actualización en la parte superior izquierda. El nodo rostopic pub (aquí en rojo) se está comunicando con el rostopic echo node (aquí en verde):

{{attachment:rqt_graph_pub.png||width=100%}}

Como puede ver, la tortuga corre en un círculo continuo. En una '' 'nueva terminal' '', podemos usar `rostopic echo` para ver los datos publicados por nuestro turtlesim:

{{{
rostopic echo /turtle1/pose
}}}

=== Usando rostopic hz ===
`rostopic hz` informa la velocidad a la que se publican los datos.

Uso:
{{{
rostopic hz [topic]
}}}
Veamos que tan rápido `turtlesim_node` esta publicando `/turtle1/pose`:
{{{
$ rostopic hz /turtle1/pose
}}}
Usted verá:
 {{{
subscribed to [/turtle1/pose]
average rate: 59.354
	min: 0.005s max: 0.027s std dev: 0.00284s window: 58
average rate: 59.459
	min: 0.005s max: 0.027s std dev: 0.00271s window: 118
average rate: 59.539
	min: 0.004s max: 0.030s std dev: 0.00339s window: 177
average rate: 59.492
	min: 0.004s max: 0.030s std dev: 0.00380s window: 237
average rate: 59.463
	min: 0.004s max: 0.030s std dev: 0.00380s window: 290
}}}
Ahora podemos decir que turtlesim está publicando datos sobre nuestra tortuga a una frecuencia de 60 Hz. También podemos usar `rostopic type` junto con `rosmsg show` para obtener información detallada sobre un tópico:

''Para ROS Hydro y posteriores,''
 {{{
$ rostopic type /turtle1/cmd_vel | rosmsg show
}}}
''Para ROS Groovy y anteriores,''
 {{{
$ rostopic type /turtle1/command_velocity | rosmsg show
}}}


Ahora que hemos examinado los tópicos usando `rostopic`, usemos otra herramienta para ver los datos publicados por nuestro turtlesim:

== Usando rqt_plot ==
Nota: Si esta usando `electric` o anteriores, `rqt` no esta disponible. En su lugar use `rxplot`.

`rqt_plot` muestra un gráfico de desplazamiento de tiempo de los datos publicados en los tópicos. Aquí usaremos `rqt_plot` para monitorear los datos que se están publicando sobre el tópico `/turtle1/pose`. Primero, inicie rqt_plot escribiendo

{{{
$ rosrun rqt_plot rqt_plot
}}}

en una nueva terminal. En la nueva ventana que debería aparecer, un cuadro de texto en la esquina superior izquierda le brinda la posibilidad de agregar cualquier tema a la trama. Al escribir `/turtle1/pose/x` se resaltará el botón `más`, previamente deshabilitado. Presiónelo y repita el mismo procedimiento con el tópico `/turtle1/pose/y`. Ahora verá la ubicación x-y de la tortuga trazada en el gráfico.

{{attachment:rqt_plot.png||width=100%}}

Al presionar el botón menos se muestra un menú que le permite ocultar el tópico especificado de la trama. Ocultar los tópicos que acaba de agregar y agregar `/turtle1/pose/theta` dará como resultado el gráfico que se muestra en la siguiente figura.

{{attachment:rqt_plot2.png||width=100%}}


Eso es todo para esta sección, use `Ctrl-C` para finalizar (kill) las terminales `rostopic`; pero mantenga su turtlesim funcionando.

Ahora que comprende cómo funcionan los temas de ROS, veamos cómo funcionan [[es/ROS/Tutoriales/ComprendiendoServiciosParametros|Comprendiendo Servicios y Parametros ROS]].

== Video Tutorial ==

El siguiente video presenta un pequeño tutorial usando turtlesim en nodos ROS y temas ROS

<<Youtube(Yx_vGAt74sk)>>
## AUTOGENERATED DO NOT DELETE 
## TutorialCategory
## ROSTutorialCategory
## TutorialTurtlesim