Linux and the command line for robotics

Open the case of almost any research robot, warehouse robot or university competition robot and you will find a small computer running Linux. The robot's software, from the drivers that talk to its motors to the programs that plan its path, is installed, started, configured and repaired through a text-based command line. This course teaches you to program robots with Python and the Robot Operating System 2, known as ROS 2, and every one of those skills rests on being comfortable at a Linux terminal. In this lesson you will learn why Linux dominates robotics, how a Linux system is organized, how to move around the file system, run and combine commands, use environment variables and install software safely. By the end you will be able to log in to a robot's computer, find your way around and prepare it for ROS 2.

You do not need to have used Linux before. You do need the Python basics from CMPUT-174: variables, functions, loops and simple data structures. Wherever this course shows commands, type them yourself on a Linux computer, a virtual machine or a single-board computer such as a Raspberry Pi. Reading about the command line is like reading about swimming: it only makes sense once you are in the water.

Why robots run Linux

Robots need an operating system that is free to install on many machines, that runs on small, low-power processors as well as powerful workstations, that gives programmers full control of the hardware and that can be inspected and modified when something goes wrong. Linux meets all of these needs. It is open source, so a robotics company can ship it on thousands of robots without license fees and can read or patch the source code of a misbehaving driver. It runs on the x86 processors in laptops and on the ARM processors in boards such as the Raspberry Pi and NVIDIA Jetson modules that are common on mobile robots. And it can be stripped down to a minimal system with no graphical desktop, which saves memory, power and start-up time on a robot that has no screen.

Linux has also become more suitable for control. For years, robots that needed tight timing ran a separate real-time operating system or applied a set of real-time patches called PREEMPT_RT to the Linux kernel. Those patches were merged into the main Linux kernel in version 6.12, released in late 2024, so a standard kernel can now be configured for much more predictable timing. Hard real-time control loops still often run on dedicated microcontrollers, as you will see in ROB-200 and ROB-320, but the main robot computer increasingly runs a single Linux system.

The deciding factor for most robot programmers, though, is ROS 2. ROS 2 is a large collection of open-source libraries and tools for building robot software, and its main supported platform is Ubuntu Linux. Each ROS 2 release, called a distribution, is built and tested against a specific Ubuntu long-term support version. Releases in even-numbered years are long-term support releases maintained for five years; releases in odd-numbered years are supported for about a year and a half. Choosing a distribution therefore also chooses your version of Ubuntu.

For a new project in late 2026, the usual choice is Lyrical Luth on Ubuntu 26.04, or Jazzy Jalisco on Ubuntu 24.04 if you depend on packages that have not yet been released for Lyrical. The examples in this course work on both. A short-term release such as Kilted is useful for trying new features, but it reaches end of life quickly, so it is rarely the right choice for a robot you need to maintain. ROS 2 also runs on Windows 11 and some other Linux distributions, but most tutorials, packages and robots assume Ubuntu, and so do we.

How a Linux system is organized

It helps to picture a Linux system as layers. At the bottom is the hardware: processor, memory, storage, network interfaces and the USB, serial and camera ports that connect sensors and motor controllers. Above it sits the kernel, the core program that manages memory, schedules processes, and talks to the hardware through device drivers. The kernel presents each device as something programs can open, often as a special file under the /dev directory: a USB serial adapter might appear as /dev/ttyUSB0 and a camera as /dev/video0. Above the kernel run system services, started at boot by an init system called systemd, which handles networking, logging and remote login. At the top are the programs you run, including the shell that interprets your commands and, eventually, your robot software.

A Linux distribution, such as Ubuntu, Debian or Fedora, bundles the kernel with a selection of services, libraries, tools and a package manager for installing more. Ubuntu comes in a desktop edition with a graphical interface and a server edition without one. On a robot you will often install the server edition, or a minimal image made for your board, and connect to it from a laptop over the network.

The shell and the file system

The shell is a program that reads the commands you type, runs them and shows their output. Ubuntu's default shell is Bash. You reach it by opening a terminal window on a desktop or by logging in remotely, as lesson 2 explains. The shell shows a prompt such as student@robot:~$, which tells you the user name, the computer's host name, the current directory and, with the dollar sign, that you are an ordinary user rather than the administrator.

Everything in Linux lives in a single tree of directories that starts at the root, written as a single forward slash. There are no drive letters. A path such as /home/student/ros2_ws/src lists the directories from the root down. A path that starts with a slash is absolute; a path that does not, such as ros2_ws/src, is relative to the current directory. The tilde is shorthand for your home directory, a single dot means the current directory and two dots mean its parent. A few top-level directories matter to robot programmers:

• /home holds each user's personal directory, where you will keep your ROS 2 workspaces and code.
• /etc holds system configuration files, such as network settings and the rules that set permissions on devices.
• /dev holds device files for serial ports, cameras, joysticks and other hardware.
• /opt holds optional add-on software. A ROS 2 installation from Ubuntu packages lives in /opt/ros followed by the distribution name, for example /opt/ros/lyrical.
• /var/log holds system logs, and /tmp holds temporary files that disappear at reboot.

The commands below show a first session at the prompt. Lines starting with a hash are comments and are ignored by the shell.

# where am I?
pwd
# list files, long format, including hidden ones
ls -la
# make a workspace with a src folder inside
mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
# go up one level, then back home
cd ..
cd ~

The ls command lists a directory. Its options, written after a dash, change its behavior: -l gives a long listing with permissions, owner, size and date, and -a includes hidden files, whose names begin with a dot, such as the .bashrc file that configures your shell. The mkdir command makes directories, and its -p option creates any missing parent directories too. Most commands accept --help, and the man command, as in man ls, opens the full manual page. Pressing the Tab key completes file and command names, which saves typing and prevents spelling mistakes; pressing the up arrow recalls earlier commands.

Essential commands

A small set of commands covers most daily work on a robot. You do not need to memorize them all today: keep the table handy and they will become automatic within a few weeks of practice.

Be careful with rm. Linux has no recycle bin at the command line: rm deletes immediately, and rm -r deletes a directory and everything in it. A classic mistake is to type a path with a stray space or a wrong wildcard and remove far more than intended. Before deleting with a wildcard, run ls with the same pattern to see exactly what it matches.

Pipes, redirection and finding things

Linux commands are designed to do one job well and to be combined. The output of one command can be sent into another with the pipe symbol, a vertical bar. For example, ls /dev | grep tty lists the devices and keeps only lines containing tty, which is a quick way to find a newly plugged-in serial adapter. Output can also be redirected to a file: a single greater-than sign writes or overwrites a file, and two of them append to it. An error stream is kept separate from normal output, so 2> sends only error messages to a file. These tools let you build useful one-line programs without writing any code.

# which serial devices exist right now?
ls /dev | grep -E 'ttyUSB|ttyACM'
# search a workspace for a topic name
grep -rn 'cmd_vel' ~/ros2_ws/src
# keep the last 50 lines of a log in a file
tail -n 50 /var/log/syslog > ~/last50.txt
# count launch files in the workspace
find ~/ros2_ws/src -name '*.launch.py' | wc -l

The grep command searches text for a pattern. Its -r option searches a whole directory tree, -n prints line numbers and -i ignores case. The find command searches for files by name, type, size or age, and its results can be piped onward. The wc -l command counts lines, so a pipe ending in wc -l counts whatever the earlier commands produced. When a robot misbehaves, a few grep and find commands often locate the configuration file or log message that explains why faster than any graphical tool.

Environment variables and sourcing

Every running program carries a set of named values called environment variables, which programs read to find files and settings. You can display one with echo, as in echo $HOME, and list them all with printenv. The most important is PATH, a colon-separated list of directories that the shell searches, in order, when you type a command name. If a command is not found, its directory is usually missing from PATH.

ROS 2 relies heavily on environment variables. An installed ROS 2 distribution includes a setup script that adds its programs to PATH, tells Python where to find ROS 2 libraries and sets variables such as ROS_DISTRO. You run this script with the source command, which executes it inside your current shell rather than in a separate one, so that its settings stay in effect. Because every new terminal starts fresh, most people add the source line to the end of their .bashrc file, which Bash runs whenever it starts.

# make ROS 2 available in this terminal
source /opt/ros/lyrical/setup.bash
echo $ROS_DISTRO
# make it automatic for every new terminal
echo 'source /opt/ros/lyrical/setup.bash' >> ~/.bashrc
# which ros2 program will run?
which ros2

Note the two greater-than signs in the second echo command. With a single one, you would overwrite your whole .bashrc file with one line, losing every other setting in it. When something about ROS 2 behaves strangely, a good first check is printenv | grep ROS, which shows the ROS-related variables in your current shell. Two terminals with different variables, for example one sourced for Jazzy and one for Lyrical, will not work together.

Installing software safely

Ubuntu installs software from online repositories with the apt package manager. Because installing software changes the system, apt must be run with sudo, which asks for your password and runs a single command with administrator rights. The usual pattern is sudo apt update to refresh the list of available packages, followed by sudo apt install and the package name. ROS 2 packages released for your distribution follow a naming pattern: ros-lyrical-teleop-twist-keyboard, for example, installs the keyboard teleoperation tool for Lyrical. Keep the system current with sudo apt upgrade, but on a robot that is working, schedule upgrades deliberately rather than just before a demonstration.

Python packages need more care. Recent Ubuntu versions mark the system Python as externally managed, so pip refuses to install packages into it, because doing so could break tools that Ubuntu itself depends on. The safe options are to install the Ubuntu package where one exists, such as python3-numpy, or to create a virtual environment for your own projects with python3 -m venv. ROS 2 also provides rosdep, a tool that reads a package's list of dependencies and installs the right system packages for your distribution, which you will use in lesson 8.

Budgets like this one matter because software choices have physical consequences on a robot. A program that busy-waits instead of sleeping, a camera streaming at full resolution when a quarter would do or a forgotten debugging tool left running all draw power from the same battery. Commands such as htop let you see what is running and how hard the processor is working, and later lessons show how to measure message rates and data volumes in ROS 2.