Modified 2021-10-30 by liampaull
This section describes the basic procedure for making a submission using the Robot Operating System and the Duckietown software stack.
That you have made a submission with the ROS template and you understand how it works.
You already know something about ROS.
You have a competitive submission.
Modified 2021-11-03 by tanij
Clone this repo
$ git clone git@github.com:duckietown/challenge-aido_LF-baseline-duckietown.git
Change into the directory:
$ cd challenge-aido_LF-baseline-duckietown
Test the submission, either locally with:
$ dts challenges evaluate --challenge CHALLENGE_NAME
or make an official submission when you are ready with
$ dts challenges submit --challenge CHALLENGE_NAME
You can find the list of challenges here. Make sure that it is marked as “Open”.
Modified 2020-11-11 by Liam Paull
The “Duckietown” baseline is based on the ROS template.
Modified 2021-11-03 by tanij
One important fact of the Dockerfile is that we use a “multi-stage build”:
FROM ${DOCKER_REGISTRY}/duckietown/dt-car-interface:${BASE_TAG} AS dt-car-interface
FROM ${DOCKER_REGISTRY}/duckietown/challenge-aido_lf-template-ros:${BASE_TAG} AS template
FROM ${DOCKER_REGISTRY}/duckietown/dt-core:${BASE_TAG} AS base
This allows us to take some elements from each of the first two base images, and copy them into the dt-core
image:
COPY --from=dt-car-interface ${CATKIN_WS_DIR}/src/dt-car-interface ${CATKIN_WS_DIR}/src/dt-car-interface
COPY --from=template /data/config /data/config
COPY --from=template /code/rosagent.py .
As a result, we have the calibration files (from /data/config
) as well as the rosagent.py
from the challenge-aido_lf-template-ros
and all the source files from the dt-car-interface
image.
We also get everything that is in the dt-core
image.
The remainder of the Dockerfile is very similar to the Dockerfile in the ROS template.
solution.py
Modified 2021-11-03 by tanij
There is no solution.py
because it is inherited from the ROS template.
In the event that you wanted to, for example, change the launcher that was run in the final CMD
line.
launchers/
Modified 2021-10-30 by liampaull
There is only one “launcher”, and it deviates slightly from the one in the ROS template:
#!/bin/bash
source /environment.sh
source /opt/ros/noetic/setup.bash
source /code/catkin_ws/devel/setup.bash --extend
source /code/solution/devel/setup.bash --extend
source /code/submission_ws/devel/setup.bash --extend
set -eux
dt-exec-BG roscore
dt-exec-BG roslaunch --wait car_interface all.launch veh:="${VEHICLE_NAME}"
dt-exec-BG roslaunch --wait duckietown_demos lane_following.launch
sleep 5 # for some reason we still need this so that nodes can startup
dt-exec-BG roslaunch --wait duckietown_demos set_state.launch veh:="${VEHICLE_NAME}" state:="LANE_FOLLOWING"
rostopic list
# foreground
dt-exec-FG roslaunch --wait agent agent_node.launch || true
rostopic list
copy-ros-logs
Here we launch the lane_following.launch
launch file from the duckietown_demos
package. We don’t go into the intricate details of everything that is run in this launch file here, but some of the more consequential nodes which are getting launched are the following:
In the event that you wanted to, for example change the launcher that was run in the final CMD
line.
submission_ws/
Modified 2021-11-03 by tanij
The submission_ws
folder contains all the new ROS packages that you would like to include in your submission. It is currently empty, but there is a reference package included in the ROS template.
Importantly, your submissions_ws
is sourced after the existing catkin_ws
that is included in dt-core
. As a result, if you include a node and package in your submission_ws
with the same name as one in dt-core
, the one in submission_ws
will get executed. This is convenient because it means that, as long as you adhere to the same subscriptions and publications, you don’t need to define any new launch file, lane_following.launch
will automatically launch your newly written node.
Modified 2021-10-31 by tanij
For rapid local development, you can make use of the dts exercises
API (unknown ref opmanual_duckiebot/running-exercises),
developed to build and test exercises and assignments in class settings.
Modified 2020-11-13 by Liam Paull
From inside the challenge-aido_LF-baseline-duckietown
folder, you can start by building your code with:
$ dts exercises build
This performs catkin build
inside a docker container. If you go inside the submission_ws
folder you will notice that there are more folders that weren’t there before. These are build artifacts that persist from the building procedure because of mounting.
Modified 2021-11-03 by tanij
You can run your current solution in the gym simulator with:
$ dts exercises test --sim
Then you can look at what’s happening by looking through the browser at http://localhost:8087. This will open a noVNC desktop. In it,
open up the rqt_image_view
, resize it, and choose /agent/camera_node/image/compressed
in the dropdown. You should see the image from the robot in the simulator.
You might want to launch a virtual joystick by opening a terminal and doing:
$ dt-launcher-joystick
By default the Duckiebot is in joystick control mode, so you can freely drive it around. You can also set it to LANE FOLLOWING
mode by pushing the a
button when you have the virtual joystick active. If you do so you will see the robot move forward slowly and never turn.
At the same time, you can see a birds eye overview of the Duckiebot on the track though the browser at http://localhost:8090.
Modified 2021-11-03 by tanij
If you are using a Linux laptop, you have two options, local (i.e., on your laptop) and remote (i.e., on the Duckiebot). To run “locally”
$ dts exercises test --duckiebot_name ROBOT_NAME --local
To run on the Duckiebot:
$ dts exercises test --duckiebot_name ROBOT_NAME
In both cases you should still be able to look at things through noVNC by pointing your browser to http://localhost:8087 . If you are running on Linux, you can load up the virtual joystick and start lane following as above.
If you are Mac user unfortunately you should not use the --local
flag
TODO: should be retested
Since we can’t publish from Mac and have it be received by ROS, we have to do something slightly different. In a new terminal on your Mac do:
$ docker -H ROBOT_NAME.local exec agent launchers/start_lane_following.sh
This will run the start_lane_following.sh
bash script inside the agent container which initiates LANE_FOLLOWING
mode.
Similarly, you can stop your Duckiebot from lane following by doing:
$ docker -H ROBOT_NAME.local exec agent launchers/stop_lane_following.sh
You could also do an equivalent thing through the Portainer interface in the dashboard by opening a new terminal in your agent container and running the corresponding launcher.
Modified 2020-11-11 by Liam Paull
A good way to get started could be to copy one of the packages defined in the Duckietown dt-core repo or the Duckietown dt-car-interface repo into the submission_ws
folder and modify it. Note that your modified package will automatically get run because of the order of the sourcing of the catkin workspaces in the run_and_start.sh
launch file.
If you would like to add a new package and node that includes a functionality not already run by lane_following.launch
or you would like to change the connectivity of interfaces of these nodes, then you will also need:
run_and_start.sh
so that it launches your newly created launchfile. You could equally define a new launchfile, but then make sure that it gets executed in the last line of your Dockerfile
. Modified 2021-11-03 by tanij
All of the normal ROS debugging utilities are available to you through the noVNC desktop. For example,
You might also explore the other outputs that you can look at in rqt_image_view
.
Also useful are some debugging outputs that are published and visualized in RViz
.
You can open RViz
through the terminal in the noVNC desktop by typing:
$ rviz
In the window that opens click “Add” the switch to the topic tab, then find the segment_markers
, and you should see the projected segments appear. Do the same for the pose_markers
.
Another tool that may be useful is rqt_plot
which also can be opened through the terminal in noVNC. This opens a window where you can add “Topics” in the text box at the top left and then you will see the data get plotted live.
All of this data can be viewed as data through the command line also. Take a look at all of the rostopic
command line utilities.