Linux: An open-source operating system modeled on UNIX.
Distro: Short for distribution. Each Linux Distro differs in their package manager, release cadence, user interfaces, and overall philosophical goals. Different versions of ROS may also be referred to as distros.
Python: A declarative high-level programming language with abstractions of lower level functionality to allow the programmer to focus on functionality.
Declarative: A programming paradigm that focuses on what the desired outcome is, rather than how to achieve it by explicitly detailing step-by-step instructions.
Abstraction: The process of simplifying complex systems by hiding unnecessary details and focusing on essential components.
Package Manager: A collection of software tools that automates the process of installing, upgrading, configuring, and removing software packages.
GUI: Graphical-user interface; the use of visual interactions rather than text-based commands helps minimize the knowledge overhead and provide useful visualizations.
Terminal: More formally, a terminal emulator is a graphical application that provides a text-based interface to interact with the shell.
Shell: A form of command-line interface that operates through a text-based interface, allowing the user to type commands which the shell interprets then executes by interacting with the underlying operating system.
Bash: Bourne Again SHell, or Bash, is the most popular and often default shell in many Linux distributions.
Zsh: Z Shell, or Zsh is known for its advanced features like improved tab completion and spell correction along its extensibility by using extensions.
ROS: Robot Operating System, or ROS, provides a layer of abstraction that allows developers to write hardware-independent code. This allows the same high-level commands to work across different robot platforms stopping the need to "reinvent the wheel" by rewriting existing code. ROS also provides robust tooling for networking information across nodes along with useful simulation and visualization tools. Currently, ROS has two versions, ROS1 and ROS2, each with different iterations such as Jazzy Jalisco or our current distro, Humble Hawkesbill.
Robust: Software that is robust consistently performs as expected and is resilient to errors and unexpected conditions.
Node: This most atomic portion of a ROS program serving as a modular process that executes a certain function within a robotic system. Nodes are designed to be independent building blocks that communicate through. In Python, nodes are built as classes that can be run directly by using the ros2 run command or an instance can be created through a launch file.
Topic: A bus for nodes to exchange messages through asynchronous, unidirectional communication, allowing nodes to publish and subscribe to messages of a specific type. Topics are defined by a path-like structure, starting with a leading slash to be resolved absolutely in a robot (e.g. /odom or /camera/depth/image_rect_raw), or without a leading slash when being used in a namespace with multiple robots (e.g. a swarm of robots each prefixed with /nth_swarm_bot and each with their own camera/depth/image_rect_raw).
Message: An object containing data assigned a name and an explicit type (e.g. uint16_t rather than int). ROS messages may not contain multi-dimensional arrays, so they must be flattened into a 1-D representation. Messages may contain data in the form of other message types (e.g. the PointField[] and Header types used in the PointCloud2.msg).
Data Type: A classification that specifies the kind of value a variable can hold and a set of functions that can be performed on that value (e.g. int, float, char, bool, string, and user-defined types through classes, and ROS messages).
Class: Serves as a blueprint or a template for creating objects. It defines the structure (attributes or properties) and behavior (methods or functions) that objects created from that class will possess.
Object: An self-contained instance of a class that has its own attributes.
Attributes: Data properties associated with an object representing its current state (e.g. name, age, weight, etc. for a person object).
Methods: A function utility or action that an object can perform (e.g. a person object may have walk, talk, and work methods). Often used synonymously with the word "function."
Object-Oriented Programming: A programming paradigm that organizes software around objects, promoting concepts such as inheritance and polymorphism to build reusable, modular, and maintainable code.
Function: An encapsulated block of code used to improve reusability and abstract logic.
Inheritance: A mechanism where a new class (the subclass or child class) acquires the properties and behaviors (fields and methods) of an existing class (the superclass or parent class).
Polymorphism: A concept that allows a single interface or method to behave differently based on the object it is acting on or the context it is used in. For instance, in the context of objects, you may have a single shape interface that has a draw() function implemented by a square, triangle, and circle class.
Interface: A blueprint or contract that defines a set of methods a class must implement. Interfaces are most commonly used in polymorphism to ensure consistent shared functionality with specialized implementations to account for the nuances of each class.
Launch File: A ROS script containing multiple Nodes with parameters to package together needed components to accomplish a shared goal. Launch files are generally used to launch multiple nodes for a robot and end with the .launch.py file extension.
Package: Bundles together nodes, libraries, datasets, configuration files, and other resources to accomplish a specific task. Packages are built by using colcon build in the src directory and sourced by running source install/setup.sh.
SLAM: Simultaneous localization and mapping; the computational problem of building a map of an unknown environment while simultaneously keeping track of the robot's location within it.
Navigation Stack: A collection of ROS packages for robot navigation. It allows a robot to navigate from a starting point to a goal while avoiding obstacles.
Gazebo: A piece of simulation software aimed at emulating sensor inputs from a real-world environment. These sensors publish to known topics on the network and can be used to test the logical component of robot code.
Feedback: A method used for improving control of machines. It involves measuring a certain parameter (e.g. the position of a robot), comparing it to a desired value, and based on the discrepancy, making a correction (turning or accelerating/decelerating the robot). This process repeats continually and is known as feedback loop.
IMU: Inertial measurement unit: A sensor system that typically combines accelerometers, gyroscopes, and electronic compasses. It measures orientation, velocity, and inertial forces.
LIDAR: Light detection and ranging. A LIDAR system (or laser range finder) sends out beams of light and measures the time that the beam takes to bounce off of an object and return to the sensor. This gives the distance from the sensor to the object, generating a 3-D point cloud of the surrounding environment.
PID: Proportional integral derivative controller; uses three tuned gains to correct a given parameter with closed-loop control to account for real-world error. The proportional gain is directly proportional to the error (e.g. distance from a desired goal) and nears 0 the lower the error. The integral gain incrementally increases by the current error over time, accumulating to account for the time spent with error. The derivative gain aims to dampen overshooting caused by the integral gain by fighting against suddent changes in error.
Computer Vision: A specialized type of neural network that teaches computers to interpret camera input to accomplish things such as detecting visible objects in the frame.
YOLO: You Only Look Once; a computer vision object-detection framework that simplifies the process of employing an object-detection model.
GitHub: A cloud platform for handling Git repositories with various project management tools. It acts as a way to host our code and collaborate as a team.
Git: A version management tool that tracks changes to a repository, enabling simpler identification of breaking changes and code sharing.
OpenCV: An image processing tool used to handle and manipulate raw images for improved object-detection accuracy and image manipulation.
NumPy: A Python library with fast, vectorized mathematical functions implemented under the hood with C++ for better performance optimization.
Library: A collection of reusable code bundled in a downloadable package with related functionalities placed in a single organized unit (e.g. NumPy, OpenCV, and YOLO).
Nav2: A ROS navigation package with modular extensions abstracting common navigation algorithms used in robotics such as path-planning, path following, position correction, object avoidance, etc.
Motor Controller: A device used to translate rotational and speed inputs from a separate controller into electric pulses with the a stable voltage and current to control a motor.
PWM: Pulse-width modulation; a technique for controlling the average power delivered to a device by rapidly switching the power on and off commonly used to encode analog input or control motor speeds.
NVIDIA Jetson Xavier: A computer board with components such as serial ports (USB) and a GPU to run computationally expensive processes. Needed to run the ROS code locally on the boat.
Cube Orange: A module containing an IMU, GPIO ports to communicate with motors, and connection to MAVROS, a software used for GPS-based navigation and teleoperated control.
RTK: Real-time kinematic; a high-precision satellite-based navigation technique that achieves centimeter-level accuracy by comparing signals from a fixed base station to a mobile rover to correct for GPS signal errors in real-time.
Ubuntu: A Debian-based Linux operating system that uses the apt package manager and provides a user-friendly user interface and prepackaged functionality.
Arch: A lightweight and flexible Linux distro that takes a "do it yourself" approach to everything. All higher-level funtionality including display management, terminals, audio management, network management, bluetooth connections, wallpaper management, etc. must be installed and configured by the user; however, this comes with significant performance, knowledge, and customizability benefits. NOT FOR BEGINNERS.
IDE: Integrated development environment; a software application that combines essential developer tools for writing, testing, and debugging code into a single GUI.
VSCode: A (somewhat) lightweight IDE that includes support for extensions and has a high degree of customizability.
Neovim: An improved version of Vim, a lightweight, portable text editing language/editor that recognizes that most developers spend their time reading and editing code. Neovim offers lua-based extensions and can be customized to fit your exact desires. Vim keybindings can take time to learn, but are highly rewarding, saving significant time while navigating and editing code when used correctly.
Docker: A platform that uses operating-system-level virtualization to deliver software in packages called containers. These containers are isolated, self-contained units that bundle an application and all its dependencies, including code, runtime, system tools, system libraries, and settings.