RV Institute of Technology & Management®

Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

Department of Mechanical Engineering

Course Name: AUTOMATION AND ROBOTICS

Course Code: 21ME71

ME VII Semester
2021 Scheme

Module-5
Robot programming

❖ Introduction, levels of robot programming

❖ Requirements of robot programming language
❖ Problems pertaining to robot programming languages
❖ Offline programming systems, central issues in OLP systems,
automating subtasks in OLP systems
❖ Simple programs on robot applications.

Dr. Shanthala K.
Assistant Professor,
Department of Mechanical Engineering
RVITM, Bengaluru – 560076

Email: shanthalak.rvitm@rvei.edu.in
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

Module-5
Robot programming

Robot programming involves creating and implementing algorithms that enable robots to
perform specific tasks either autonomously or semi-autonomously. This process includes
defining the sequence of operations, movements, and actions required for the robot to achieve
its goals.

The complexity of programming can vary significantly based on the robot type, its application,
and the operating environment. Techniques in robot programming range from basic scripting
to advanced methods involving machine learning and artificial intelligence. The primary
objective is to ensure the robot operates efficiently, accurately, and safely, particularly in
dynamic or unpredictable conditions.

Over time, robot programming has advanced from simple teach-by-showing techniques to
sophisticated task-level programming. Modern methods often employ specialized robot
programming languages or extend general-purpose languages with robot-specific libraries.
Task-level programming seeks to simplify the process by allowing users to specify high-level
goals, with the system handling detailed actions and planning, though it continues to be a
developing area of research.

5.1 The Three Levels of Robot Programming

A) Teach by Showing (Teach Pendant Programming)

Teach by showing is one of the earliest methods of programming robots. This approach
involves manually guiding the robot to a desired position and recording the robot’s position
data. The process includes:

• Teaching Phase: The user moves the robot to target positions manually or with a teach
pendant, which is a handheld device used to control the robot's joints or Cartesian
degrees of freedom.
• Recording Positions: During this phase, the robot’s positions are recorded in memory.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

• Playback: The recorded positions are played back to repeat the same movements.

Teach pendants often come with features like alphanumeric displays and allow for basic logic
operations, making them somewhat similar to hand-held terminals. For example, the GMF
S380 used in automobile-body spot-welding applications is programmed using a teach pendant
interface.

B) Explicit Robot Programming Languages

With the advent of powerful computers, programming robots began to shift towards using
explicit robot programming languages (RPLs). These languages are designed to address the
specific needs of robot control and are categorized into three main types:

• Specialized Manipulation Languages: These are entirely new languages created for
robot control but may lack general programming features. For example, VAL (used by
Unimation, Inc.) and its successors V-Il and V+ were designed specifically for
manipulating robots. Similarly, AL developed at Stanford University included features
for force control and parallelism.
• Robot Libraries for Existing Computer Languages: These languages are built by
adding robot-specific libraries to popular general-purpose languages. Examples include
AR-BASIC (a library for BASIC) and JARS (based on Pascal, developed by NASA).
• Robot Libraries for New General-Purpose Languages: These involve creating a new
general-purpose language and then adding robot-specific libraries. Examples include
RAPID (by ABB Robotics), AML (by IBM), and KAREL (by GMF Robotics).

Most real-world robotic applications involve a significant amount of non-robot-specific

programming, such as initialization, logic testing, and communication. This has led to a trend
towards extending general-purpose languages rather than creating entirely new robot-specific
languages.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

C) Task-Level Programming Languages

Task-level programming languages represent the highest level of abstraction in robot

programming. These languages allow users to specify tasks in terms of high-level goals rather
than detailing every individual action. Characteristics include:

• High-Level Instructions: Users provide commands like "grasp the bolt" without
specifying the exact steps for the robot to achieve the goal.
• Automatic Planning: The system autonomously plans paths, avoids obstacles, and
chooses grasp points.
• Automatic Execution: The robot performs the task based on the high-level
instructions, with detailed actions handled by the system itself.

Task-level programming is distinct from explicit robot programming languages due to its focus
on high-level task goals rather than low-level control. Although true task-level programming
is still a developing area, it represents a significant step towards simplifying robot
programming and enhancing flexibility.

5.2 Requirements of a Robot Programming Language

A robot programming language must meet several key requirements to effectively control
robotic systems and enable them to perform complex tasks. These requirements ensure that
the language is both practical for developers and efficient for robotic applications.

a. Hardware Abstraction: The language should provide an abstraction layer that

simplifies interaction with the robot's hardware components, such as sensors, actuators,
and controllers. This allows programmers to focus on high-level tasks without needing
to manage low-level hardware details.
b. Real-Time Processing: Robots often operate in environments where real-time
decision-making is critical. Therefore, the programming language must support real-
time processing to ensure timely responses to sensor inputs and control commands. This
is essential for applications like robotic surgery, autonomous vehicles, or industrial
automation.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

c. Concurrency and Multithreading: A robot programming language must handle

multiple tasks simultaneously, such as processing sensor data, controlling actuators,
and communicating with other systems. Support for concurrency and multithreading is
crucial to manage these parallel processes efficiently.
d. Modularity and Reusability : The language should support modularity, allowing code
to be organized into reusable components or modules. This makes it easier to develop,
test, and maintain complex robot applications by breaking them down into smaller,
manageable parts.
e. Flexibility and Extensibility : Robotics applications can vary widely, from simple
tasks like object manipulation to complex ones like human-robot interaction. The
programming language must be flexible and extensible, allowing for the integration of
new functionalities, libraries, or hardware as needed.
f. Support for Sensor Integration : Robots rely on various sensors to perceive their
environment. The language should offer robust support for integrating and processing
data from different types of sensors, such as cameras, lidar, GPS, and tactile sensors.
This is vital for tasks like navigation, obstacle avoidance, and object recognition.
g. Error Handling and Debugging Tools : Given the complexity of robotic systems,
robust error handling and debugging tools are essential. The language should provide
clear and manageable ways to detect, report, and handle errors, helping developers
quickly identify and fix issues.
h. Communication and Networking Capabilities : Many robotic systems need to
communicate with other robots, computers, or networks. The programming language
must support communication protocols and networking features, enabling robots to
exchange data, coordinate actions, or receive remote commands.
i. Scalability : As robotic systems grow in complexity, the programming language must
scale accordingly. This includes supporting a wide range of applications, from simple
single-robot setups to complex multi-robot systems or distributed robotic networks.
j. Cross-Platform Compatibility : Robots often run on different hardware and operating
systems. A good robot programming language should be cross-platform compatible,
allowing code to be deployed across various devices and environments without
significant modification.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

k. Community and Ecosystem Support : A strong community and ecosystem are vital
for the continued development and support of a programming language. This includes
access to libraries, frameworks, documentation, and forums where developers can share
knowledge and collaborate on projects.

5.3 Problems pertaining to robot programming languages

Robot programming languages, while essential for enabling the precise control and operation
of robotic systems, come with several challenges and limitations. These issues can affect the
efficiency, flexibility, and ease of use of robot programming, impacting the development and
deployment of robotic applications.

a. Complexity and Steep Learning Curve: Robot programming languages often require
a deep understanding of both programming concepts and the robot's hardware. The
complexity of these languages can create a steep learning curve, making it difficult for
beginners or those without a strong technical background to effectively program robots.
This complexity can also lead to longer development times and increased costs.
b. Lack of Standardization: The field of robotics lacks a universally accepted standard
for robot programming languages. Different manufacturers often use proprietary
languages or frameworks, leading to compatibility issues when integrating robots from
different vendors or when upgrading systems. This fragmentation can hinder
collaboration, increase costs, and limit the reusability of code across different
platforms.
c. Difficulty in Debugging and Error Handling : Debugging robotic programs can be
particularly challenging due to the real-time nature of robotic operations and the
interaction with complex physical environments. Errors in robot programming can lead
to unpredictable behavior, potentially causing damage to equipment or posing safety
risks. Robust debugging tools and error-handling mechanisms are often lacking in many
robot programming environments, complicating the development process.
d. Real-Time Constraints : Robots often need to process data and respond to events in
real-time, which places significant demands on the programming language. Ensuring
that the language can handle real-time processing without delays or latency is crucial,
especially in applications where timing is critical, such as autonomous vehicles or
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

medical robots. Many programming languages struggle with maintaining real-time

performance, particularly when dealing with complex algorithms or large amounts of
sensor data.
e. Limited Flexibility and Scalability: Robot programming languages are often designed
for specific types of robots or applications, which can limit their flexibility. Adapting a
language to new or evolving tasks can be challenging, requiring significant
reprogramming or even the use of entirely different languages. Additionally, as robotic
systems become more complex and interconnected, scalability becomes an issue, with
some languages unable to efficiently manage multiple robots or large-scale systems.
f. Integration Challenges: Robots frequently need to interact with other systems, such
as databases, cloud services, or other robots. Integrating these systems with the robot's
programming language can be difficult, particularly if the language lacks built-in
support for modern communication protocols, APIs, or external libraries. This can lead
to additional development overhead and increased potential for errors.
g. High Resource Consumption: Some robot programming languages can be resource-
intensive, requiring significant computational power and memory. This can be
problematic in resource-constrained environments, such as embedded systems or small-
scale robots, where hardware limitations must be carefully managed. High resource
consumption can also lead to reduced battery life, slower performance, and increased
costs.
h. Dependence on Specific Hardware: Many robot programming languages are tightly
coupled with specific hardware platforms, making it difficult to port programs to
different robots or upgrade hardware without significant rework. This dependency
limits the flexibility of robotic systems and can increase the time and cost of
development, particularly in rapidly evolving fields where hardware is frequently
updated.
i. Limited Support for AI and Machine Learning : As robots increasingly rely on
artificial intelligence (AI) and machine learning (ML) to perform complex tasks, many
traditional robot programming languages struggle to integrate these advanced
technologies effectively. Limited support for AI and ML algorithms can constrain the
capabilities of robotic systems, requiring additional tools or languages to achieve
desired outcomes.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

j. Usability and User Interface Issues: Many robot programming environments are not
user-friendly, with interfaces that are difficult to navigate or poorly designed for the
needs of programmers. This can slow down the development process, increase the
likelihood of errors, and create frustration for users. Improving the usability of these
environments is crucial for making robot programming more accessible and efficient.

5.4 Offline programming systems

Offline programming (OLP) systems allow robots to be programmed in a virtual environment

rather than directly on the factory floor or production site. This involves creating and testing
robot programs using simulation software before transferring the programs to the actual robot.
The key advantage of OLP is that it minimizes downtime since robots do not need to be taken
offline for programming. It also allows for the optimization of tasks and the identification of
potential issues before deployment.

Benefits of OLP Systems:

• Reduced Downtime: Production continues uninterrupted while programming is done

offline.
• Increased Safety: Testing in a virtual environment reduces the risk of accidents during
the programming phase.
• Optimization: Programs can be optimized for efficiency, reducing the time and
resources required for actual operations.
• Flexibility: Allows for easy modifications and updates to the robot's tasks without
disrupting ongoing processes

5.4.1 Central Issues in OLP Systems

a. Accuracy of Simulation Models: The effectiveness of OLP depends heavily on the

accuracy of the simulation models used. Discrepancies between the virtual environment
and the real world can lead to errors in the robot's performance. Ensuring that the
simulation accurately reflects the physical characteristics and constraints of the actual
workspace is critical.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

b. Calibration and Alignment: Proper calibration is essential to ensure that the

coordinates and movements programmed in the offline environment match those in the
real-world setup. Misalignment can result in the robot missing targets or performing
tasks incorrectly, necessitating additional adjustments after deployment.
c. Complexity of Robot Tasks: For complex tasks that involve intricate movements or
interactions with various objects, programming can become challenging. OLP systems
must be capable of handling these complexities, which may require advanced
algorithms or machine learning techniques.
d. Integration with Existing Systems: OLP systems must seamlessly integrate with the
existing hardware and software infrastructure. This includes compatibility with the
robot’s control system, sensors, and any other relevant equipment. Ensuring smooth
communication between the OLP system and the actual robot is vital for successful
implementation.
e. Validation and Testing: Even with accurate simulations, real-world testing is essential
to validate the program. OLP systems need robust testing tools to verify that the robot's
actions will be safe and effective when transferred from the virtual environment to the
physical world.

5.4.2 Automating Subtasks in OLP Systems

a. Path Planning and Optimization: One of the primary subtasks in robot programming
is path planning, where the robot's movements are mapped out to complete a task
efficiently. In OLP systems, automating path planning involves using algorithms that
automatically calculate the optimal path for the robot to follow, considering factors
such as speed, collision avoidance, and energy efficiency.
b. Collision Detection: Automating collision detection is crucial in OLP systems to
prevent the robot from coming into contact with objects or obstacles in its environment.
This is typically done through simulation software that continuously monitors the
robot's movements and provides real-time feedback on potential collisions, allowing
for automatic adjustments.
c. Task Sequencing: Task sequencing involves determining the order in which the robot
should perform various actions. Automating this process in OLP systems ensures that
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

tasks are executed in the most logical and efficient sequence, reducing the likelihood of
errors or unnecessary movements.
d. Tool and Workpiece Management: OLP systems can automate the management of
tools and workpieces, including selecting the appropriate tools for specific tasks,
positioning them correctly, and switching between them as needed. This automation
reduces manual intervention and streamlines the production process.
e. Error Handling and Recovery: Automating error handling in OLP systems involves
creating predefined responses to potential errors, such as mechanical failures or
unexpected obstacles. This ensures that the robot can either correct the error
autonomously or alert operators to take appropriate action, minimizing downtime.
f. Data Collection and Analysis: Finally, automating data collection and analysis in OLP
systems allows for continuous monitoring of the robot's performance. This data can be
used to make further improvements to the programming, optimize operations, and
predict maintenance needs.

5.5 Simple programs on robot applications

Robot programming involves writing instructions that tell a robot what to do. These
instructions are written in a programming language that the robot's control system can
understand. The goal is to automate tasks that might be repetitive, precise, or even dangerous
for humans.

5.5.1 Basic Concepts in Robot Programming

• Kinematics: Refers to the movement of the robot's joints and links. Understanding
kinematics helps in determining how the robot moves from one position to another.
• Control Systems: These are the brains of the robot. They process the program and send
signals to the robot's motors and actuators to execute tasks.
• Sensors and Actuators: Sensors provide feedback about the environment (e.g.,
distance to objects), and actuators (like motors) move the robot's parts.
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

5.5.2 Levels of Robot Programming

• Low-Level Programming: Directly controls the robot’s motors and sensors. It

involves detailed commands for each movement.
• High-Level Programming: Focuses on the overall task the robot needs to perform,
such as moving an object from one place to another.

5.5.3 Requirements of a Robot Programming Language

• Flexibility: The language should allow the robot to perform various tasks.
• Ease of Use: It should be easy for programmers to write and modify instructions.
• Real-Time Processing: The language should support real-time control, where the
robot can respond immediately to changes in its environment.

5.6 Example: Simple Pick-and-Place Operation

Scenario

Imagine a robot on an assembly line. Its job is to pick up a part from one spot and place it in
another. This is a common task in factories where robots help in assembling products.

Program Overview

The robot follows a sequence of commands to:

1. Move to the part's location.

2. Pick up the part.
3. Move to the destination.
4. Place the part down.
5. Return to its starting position.

Detailed Program Explanation

1. Move to Pick Position

✓ Command: move_to_pick_position()
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

✓ This command tells the robot to move its arm to the location where the part is
ready to be picked up.
✓ Real-World Example: Like moving your hand over to pick up a book from a
table.

2. Activate Gripper

✓ Command: activate_gripper()
✓ The gripper (the robot’s hand) closes around the part to hold it securely.
✓ Real-World Example: Imagine closing your hand around the book to pick it
up.

3. Move to Place Position

✓ Command: move_to_place_position()
✓ The robot, now holding the part, moves to the location where the part needs to
be placed.
✓ Real-World Example: Moving your hand with the book over to a bookshelf.

4. Release Gripper

✓ Command: release_gripper()
✓ The gripper opens, releasing the part in its new location.
✓ Real-World Example: Letting go of the book so it rests on the shelf.

5. Return to Home Position

✓ Command: return_to_home_position()
✓ The robot moves back to its starting position, ready to repeat the task.
✓ Real-World Example: Moving your hand back to your side after placing the
book.

5.6.1 Understanding the Commands

 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

• Commands: These are specific instructions given to the robot. Each command tells the
robot to perform a specific action, like moving to a location or gripping an object.
• Functions: In programming, a command might be part of a larger function that groups
several actions together. For example, a function called pick_and_place() might include
all the steps needed to move an object from one spot to another.

5.6.2 Some simple robot programs for mechanical applications

a. Pick and Place Operation

Application: Automated assembly lines.

Description: A robot arm is programmed to pick up parts from one location and place
them in another. This task is commonly used in assembly operations, such as placing
components on a conveyor belt.

Program:
move_to_pick_position()
activate_gripper()
move_to_place_position()
release_gripper()
return_to_home_position()

b. Welding Task

Application: Automotive and aerospace manufacturing.

Description: A robot is programmed to perform spot welding on a metal assembly. This

task involves moving the welding torch to specific coordinates and executing the weld.

Program:

move_to_weld_position(x, y, z)
activate_welder()
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

hold_position()
deactivate_welder()
move_to_next_weld_position()

c. Painting a Surface

Application: Surface finishing in manufacturing.

Description: A robot is programmed to paint a component's surface uniformly. The

program ensures even coverage by controlling the robot's speed and spray pattern.

Program:

move_to_start_position()
start_spray()
move_along_surface_path()
adjust_spray_pattern(speed)
stop_spray()
return_to_home_position()

d. CNC Machining Operation

Application: Precision manufacturing.

Description: A robot arm loads and unloads workpieces into a CNC machine. The
robot handles the positioning and removal of parts after machining.

Program:
move_to_load_position()
activate_gripper()
place_workpiece_in_CNC()
wait_for_machining_completion()
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

remove_workpiece()
place_in_finished_goods_area()

e. Quality Inspection

Application: Quality control in production lines.

Description: A robot equipped with a camera inspects parts for defects, such as
surface imperfections or dimensional inaccuracies, by moving the camera over
specific areas.

Program:
move_to_inspection_position()
capture_image()
analyze_image_for_defects()
mark_defective_parts()
move_to_next_inspection_point()

f. Material Handling and Sorting

Application: Warehouse and inventory management.

Description: A robot sorts different materials (e.g., metal, plastic) into designated bins
based on size or type, which is useful in recycling or sorting processes.

Program:
identify_material_type()
move_to_pick_position()
activate_gripper()
move_to_designated_bin()
release_material()
return_to_start_position()
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

g. Grinding and Polishing

Application: Finishing operations in manufacturing.

Description: A robot grinds or polishes surfaces to achieve the desired finish. The
program controls the force applied and the movement pattern to ensure uniformity.

Program:
move_to_start_position()
start_grinding_tool()
apply_force_to_surface()
move_along_grinding_path()
adjust_tool_speed()
stop_grinding_tool()

h. Screw Driving

Application: Assembly operations.

Description: A robot is programmed to drive screws into pre-drilled holes. The robot
controls the torque and depth of the screw to ensure proper fastening.

Program:
move_to_screw_position()
align_screwdriver()
activate_screwdriver()
control_torque_and_depth()
move_to_next_screw_position()
 RV Institute of Technology & Management®
Sy.No.171/5, Kothanur,8th Phase, JP Nagar, Bengaluru-560076

i. Robot drilling

Application: Drilling in automotive and aerospace industries.

Description: A robot drills holes in a component at specified locations and depths,

which are essential for parts that require precision drilling.

Program:
move_to_drill_position(x, y, z)
start_drill()
control_drill_speed()
drill_to_specified_depth()
retract_drill()
move_to_next_drill_position()

j. Assembly of Parts
Application: Automated assembly of mechanical components.
Description: A robot assembles parts by fitting them together, such as aligning and
pressing bearings into a housing.

Program:
pick_part_A()
move_to_assembly_position()
align_with_part_B()
press_part_A_into_part_B()
verify_assembly()
move_to_next_assembly_point()