UNITED INSTITUTE OF TECHNOLOGY, PRAYAGRAJ

INTRODUCTION TO ROBOTICS (MNRB-401)

Introduction to Robot Programming

Robot programming refers to the process of giving instructions to a robot to perform tasks autonomously or
semi-autonomously. These instructions may control movement, interaction with objects, timing, or decision-
making based on sensor inputs. Robot programming is crucial because it translates theoretical control and
planning into real-world robotic behavior, enabling robots to perform complex, repetitive, or hazardous tasks
efficiently. Depending on the application, the complexity of programming ranges from simple pick-and-
place routines to advanced AI-driven behaviors.

Methods of Robot Programming

There are several methods of robot programming, each suitable for different applications:

• Manual Programming: Using physical teaching or pendant devices where the robot is guided
manually through motions.

• Teach Pendant Programming: A user operates a handheld device (pendant) to move the robot and
record positions for tasks.

• Lead-Through Programming: The robot is physically guided through the desired trajectory by a
human, which it memorizes.

• Offline Programming: Programming is done on a computer through a simulation environment and

• Automatic/High-Level Programming: Programs use scripting or AI for complex decision-making

WAIT, SIGNAL, and DELAY Commands

In robot programming, timing and synchronization are essential. Special commands like WAIT, SIGNAL,
and DELAY are used for coordination:
 • WAIT: Causes the robot to pause until a condition is met (e.g., a sensor input becomes active or
another task is completed).

• SIGNAL: Sends a signal (like a digital output) to activate a device, trigger a response, or
communicate with another robot/controller.

• DELAY: Pauses the robot’s actions for a fixed amount of time, useful for letting processes settle or
sequencing actions.

These commands help in synchronizing the robot’s activities with external devices or processes, especially
in automated production lines.

Subroutines in Robot Programming

Subroutines are blocks of reusable code that perform specific tasks. In robotics, subroutines improve
modularity and efficiency by allowing common actions (like "pick object" or "move to home position") to be
reused multiple times. They support cleaner code, easier debugging, and flexibility in making changes.
Subroutines also enable hierarchical task planning, which is vital in complex automation systems.

Generations of Robotic Programming Languages

Robotic programming languages have evolved over generations:

• First Generation: Low-level, hardware-specific machine or assembly languages. Tedious and

• Second Generation: Text-based structured programming languages like VAL and RAIL. Allowed
more readable syntax.

• Third Generation: High-level languages like AML (IBM) and KAREL (FANUC), offering better
abstraction and control flow.

• Fourth Generation: Object-oriented and AI-integrated languages, designed for networked and
intelligent robot systems.

• Fifth Generation and Beyond: Focus on natural language integration, cloud-based interfaces, and
learning-based programming (e.g., Python with AI/ML libraries in ROS).

Overview of Key Robotic Programming Languages

Here are some notable robotic programming languages:

• RAIL (Robot Assembly Interface Language): Designed for assembly and manipulation tasks,
enabling procedural programming.

• AML (A Manufacturing Language): Created by IBM for complex industrial tasks, supporting
advanced features like subroutines and branching.

• KAREL: FANUC's proprietary high-level programming language.

• Python: Widely used in modern robotics due to its readability and integration with machine learning,
vision, and ROS.

• C/C++: Still widely used for performance-critical robotic applications, especially at the firmware or
driver level.

• ROS (Robot Operating System): Not a language but a middleware/framework primarily using
Python and C++. It supports modular development and integration of multiple subsystems
(navigation, perception, control, etc.).

Evolution from WAVE to ROS

The development of robotic languages can be traced back to WAVE (World Automation and
Verification Environment), developed at Stanford in the 1970s. WAVE introduced the idea of task-level
programming where users could specify what needed to be done rather than how. Over time, languages
became more intuitive, efficient, and capable of integrating with sensors, AI, and networked systems.

As robotics systems became more complex and interconnected, the Robot Operating System (ROS)
emerged as a dominant open-source platform. ROS provides tools, libraries, and conventions for writing
robot software. It supports modular development, inter-process communication, sensor integration, and
visualization tools like RViz. The latest version, ROS 2, emphasizes real-time performance, security, and
better support for industrial applications.