Robot Programming

Basic Types
• Lead through methods
• Textual robot languages
Lead through Programming Method:
• During this programming method, the traveling of robots is based on
the desired movements, and it is stored in the external controller
memory
• There are two modes of a control system in this method such as a run
mode and teach mode.
• The program is taught in the teach mode, and it is executed in the run
mode.
Types
• The leadthrough programming method can be done by two methods
namely
• Powered Leadthrough Method

• Manual Leadthrough Method

Powered Leadthrough Method
• Common method
• Teach pendent is used to control the motions. ( joints, wrist)
• The playback of an operation is done by recording these points.
• complex geometric moves is difficult toperform in the teach
pendant
• Good for point to point movements. Some of the key applications
are spot welding, machine loading & unloading, and part transfer
process.
https://www.youtube.com/watch?v=v5wcRRdkrsU

https://www.youtube.com/watch?v=BcEcMaKE4BQ

https://www.youtube.com/watch?v=_eL1A8IjXk4
Manual Leadthrough Method

• Endeffector is moved physically bythe programmer at the desired movements.

• also known as Walk Through method
• used to perform continuous path movements
• This method is best for spray painting and arc welding operations.

• https://www.youtube.com/watch?v=neWc5I9IdQ4

• https://www.youtube.com/watch?v=4o0gyzwWoxM
Textual Robotic languages

• WAVE language was developed, and it is the first textual in 1973

( Machine vision and a robot)
• AL Language – Multiple robot arm coordination
• VAL – Common Textual Language
• AML and Other important textual robot languages are Manufacturing
Control Language (MCL), RAIL, and Automatic Programmed Tooling
(APT) languages.

•
Robot program as a path in space
Point to point Cartesian robot

https://www.slideshare.net/anandhd1/rmv-robot-
programming
 First-generation robotic languages
First-generation robotic languages refer to the initial set of programming languages developed for controlling and
programming robots.
• Low-Level Control: First-generation languages offered low-level control over robot motions, allowing programmers to define precise movements and
manipulate I/O operations at a granular level. These languages provided direct access to the hardware and allowed for fine-tuned control of robot
behavior.
• Hardware-Specific: First-generation languages were often tied to specific robot systems or manufacturers. They were designed to work closely with
the hardware and firmware of the robots, providing direct communication and control over the robotic components.
• Limited Abstractions: First-generation languages had minimal or no high-level abstractions. Programmers had to work with the raw commands and
instructions for controlling the robots, without the benefit of pre-built functions or libraries for complex tasks. This required developers to have a
deep understanding of the robot's hardware and low-level programming concepts.
• Task-Oriented: These languages focused on task-specific programming, allowing programmers to define sequences of movements, I/O operations,
and basic decision-making logic. They were primarily designed for automating repetitive tasks in industrial environments, such as assembly lines or
CNC machining.
• Close Integration with Peripherals: First-generation languages provided mechanisms to interface with peripherals such as sensors, equipment, or
external devices. This allowed the robots to perceive and respond to their environment, making them more adaptable and versatile.
• Limited Communication Capabilities: Communication capabilities in first-generation languages were often limited or non-existent. These languages
were primarily focused on controlling the robot itself and lacked built-in features for data communication with other systems or devices.
 First Generation Languages
AML (Adept Motion Language): Language for programming Adept robots, offering low-level control over robot
motions, I/O handling, and coordinate transformations.

Karel: Language for programming Fanuc robots, focusing on basic robot movements, I/O operations, and
conditional branching.

VAL (V+ and VAL II): Proprietary languages for programming Stäubli robots, providing low-level control over
robot motions, I/O handling, and advanced features like sensor integration and error handling.

TP (Teach Pendant Language): Language for programming Yaskawa Motoman robots, allowing interactive
teaching of robot motions and program creation using a teach pendant interface.

RAPID (Robot Application IDE): Proprietary language for programming ABB robots, offering low-level control
over robot motions, I/O handling, and advanced features like error handling and data manipulation.
First Generation Languages
KRL (KUKA Robot Language): Language for programming KUKA robots, enabling control of robot motions, I/O
configuration, and implementation of complex tasks using subroutines, loops, and conditionals.

SCOL (Staubli Command Language): Language for programming Stäubli robots, providing low-level control over
robot motions, I/O handling, and features like trajectory planning, external axes control, and synchronization.

G-code: Standard language for CNC machines, providing instructions for controlling tool movements, spindle
speed, feed rates, and machining parameters.

Ladder Logic: Visual programming language used in PLCs, allowing the creation of logic circuits to control
automation processes, including robotics.
Second-generation
robot language
• Second-generation robot
language systems refer to the
advanced set of programming
languages, frameworks, and tools
used for controlling and
programming robots.
Key Characters

Integration with Robotic Middleware: Second-generation languages often integrate with

robotic middleware systems such as ROS (Robot Operating System) or OROCOS (Open Robot
Control Software). These middleware frameworks provide a standardized communication
infrastructure and a collection of software libraries for building robotic systems.

High-Level Abstractions: Second-generation languages offer higher-level abstractions and

libraries specifically designed for robotic tasks. These abstractions simplify the development
of complex robot behaviors and applications, allowing programmers to focus more on the
logic and functionality rather than low-level details.

Modularity and Reusability: Second-generation language systems promote modularity and

code reusability. They provide tools and frameworks for building and composing robot
software components, making it easier to develop and maintain large-scale robotic systems.

Sensor Integration and Perception: Second-generation languages often offer built-in support
for sensor integration and perception tasks. They provide libraries and APIs for working with
various sensors such as cameras, LIDAR, or depth sensors, enabling robots to perceive and
understand their environment.
Key Characters

4.Simulation and Visualization: Many second-generation language systems

provide simulation and visualization capabilities. These tools allow
programmers to model and simulate robot behavior in virtual environments,
facilitating development, testing, and debugging of robot programs before
deploying them on physical robots.

5.Multi-Robot and Distributed Systems: Second-generation languages often

support multi-robot and distributed systems. They provide mechanisms for
coordinating and controlling multiple robots simultaneously, enabling
collaboration and coordination between robot teams.

5.Cross-Platform Compatibility: Second-generation language systems strive for

cross-platform compatibility, allowing developers to write robot programs that
can be deployed on different robot hardware platforms with minimal
modifications.
Examples of Second generation Robot
Languages
• ROS (Robot Operating System): ROS is a popular open-source framework for robot software
development. It provides a collection of libraries, tools, and conventions for building robotic
systems. ROS allows for modular development, communication between different
components, and offers a wide range of functionalities for perception, control, planning, and
more.
• MATLAB Robotics System Toolbox: MATLAB provides a Robotics System Toolbox that offers a
high-level programming environment for designing and simulating robotic systems. It
includes functions and tools for robot kinematics, dynamics, control, perception, and path
planning. MATLAB's graphical interface makes it user-friendly for developing complex robot
behaviors.
• LabVIEW: LabVIEW is a visual programming language and development environment widely
used in robotics. It offers a graphical programming approach where users can drag and drop
function blocks to create robot control systems. LabVIEW supports integration with various
hardware devices and offers powerful data acquisition and analysis capabilities.
Examples of Second generation Robot
Languages
• Python with Robotics Libraries: Python, a versatile and widely-used programming language, is often
used in robotics due to its simplicity and large ecosystem of libraries. Numerous robotics-specific
libraries such as PyRobot, Pygame, and ROSPy provide high-level abstractions, tools, and APIs for
controlling robots, simulating environments, and performing robotic tasks.
• Simulink: Simulink is a graphical programming environment within MATLAB that allows the modeling,
simulation, and control of dynamic systems, including robots. It provides a block diagram approach for
designing robot control systems, enabling users to visually represent and simulate robot behavior.
• Blockly: Blockly is a visual programming language that simplifies robot programming for beginners and
educational purposes. It uses a block-based interface where users can snap together blocks to create
robot programs. Blockly often serves as an introductory language to teach programming concepts and
robotics.
• Java with Robotics Libraries: Java, a widely-used general-purpose programming language, is also
employed in robotics. Java-based robotics libraries such as LeJOS and Robocode provide frameworks
and APIs for controlling robots, implementing algorithms, and participating in robot competitions.
Robot language
structure
• Second-generation languages
typically refer to assembly
languages or low-level programming
languages that are closer to the
machine code and hardware.
 First Vs Second
Second Generation
Features First Generation Languages Languages
Seamless integration with robot
Robot system integration Limited integration capabilities
systems

Advanced features for

Low-level control with limited controlling joint angles, end-
Manipulator control
functionality effector positions, and
trajectories

Mechanisms to interact with

Limited or no support for
Peripheral interfacing peripherals (sensors,
peripheral interaction
equipment)

Limited or no support for data Support for data communication

Communication capabilities
communication with other computer systems

Minimal or no high-level High-level abstractions and

High-level abstractions
abstractions available libraries for robotic tasks