# Publish chassis-level commands#

What you will need

• A Duckietown robot turned ON and visible on dts fleet discover

What you will get

• Learn how to control the Duckiebot’s chassis linear and angular velocities using a ROS Publisher

## Topic and message type of interest#

The topic used by the Duckiebot to receive Twist commands and compute inverse kinematics to obtain lower level wheel commands is /ROBOT_NAME/car_cmd_switch_node/cmd, while the message type used over this topic is duckietown_msgs/Twist2DStamped which contains the following fields.

std_msgs/Header header
float32 v
float32 omega


where,

• header: is the standard ROS header object;

• v: is the linear velocity in m/s with positive signs in the forward driving direction;

• omega: is the angular velocity in rad/s with positive signs in counter-clockwise direction when looking down to the Duckiebot;

Note

The commanded expected v and omega relies on good kinematic calibration and car model to function.

## Create Publisher ROS Node#

We now use our favorite text editor to create the file twist_control_node.py inside the src/ directory of our catkin package and add the following content,

#!/usr/bin/env python3

import os
import rospy
from duckietown.dtros import DTROS, NodeType
from duckietown_msgs.msg import Twist2DStamped

# Twist command for controlling the linear and angular velocity of the frame
VELOCITY = 0.3  # linear vel    , in m/s    , forward (+)
OMEGA = 4.0     # angular vel   , rad/s     , counter clock wise (+)

class TwistControlNode(DTROS):

def __init__(self, node_name):
# initialize the DTROS parent class
super(TwistControlNode, self).__init__(node_name=node_name, node_type=NodeType.GENERIC)
# static parameters
vehicle_name = os.environ['VEHICLE_NAME']
twist_topic = f"/{vehicle_name}/car_cmd_switch_node/cmd"
# form the message
self._v = VELOCITY
self._omega = OMEGA
# construct publisher
self._publisher = rospy.Publisher(twist_topic, Twist2DStamped, queue_size=1)

def run(self):
# publish 10 messages every second (10 Hz)
rate = rospy.Rate(10)
message = Twist2DStamped(v=self._v, omega=self._omega)
while not rospy.is_shutdown():
self._publisher.publish(message)
rate.sleep()

def on_shutdown(self):
stop = Twist2DStamped(v=0.0, omega=0.0)
self._publisher.publish(stop)

if __name__ == '__main__':
# create the node
node = TwistControlNode(node_name='twist_control_node')
# run node
node.run()
# keep the process from terminating
rospy.spin()


Again, we make our node executable,

chmod +x ./packages/my_package/src/twist_control_node.py


## Define launcher#

We create a new launcher file ./launchers/twist-control.sh with the content,

#!/bin/bash

source /environment.sh

# initialize launch file
dt-launchfile-init

# launch subscriber
rosrun my_package twist_control_node.py

# wait for app to end
dt-launchfile-join


Let us now re-compile our project using the command

dts devel build -f


## Launch the node#

Danger

The robot’s wheels will start moving and spinning as soon as the node is launched. Please, make sure that your robot has enough space to drive around without the risk of harming somebody or himself (e.g., by falling off a desk).

We run the node,

dts devel run -R ROBOT_NAME -L twist-control


And observe the wheels rotate as instructed. If you want to stop it, just use Ctrl+C, and the wheels should stop spinning as per the behavior defined in the function on_shutdown() above.

Congratulations 🎉

You just built and run a ROS node capable of interacting with the Duckiebot and control the wheels by leveraging existing functionalities exposed by the Duckiebot (e.g., inverse kinematics, wheel calibration).