VAL Programming Language – Detailed Explanation
What is VAL?
VAL (Variable Assembly Language) is a robot programming language originally developed by Unimation
for controlling industrial robots such as the PUMA series (Programmable Universal Machine for Assembly).
It is a high-level robot control language designed to:
• Control robot motion
• Interface with sensors
• Define robot tasks
• Execute automated sequences
• Provide supervisory and real-time robot commands
Key Features of VAL Language
Feature Description
High-level Language Similar to BASIC; simple and readable syntax
Interactive Commands executed in real-time at the console
Supports Online & Offline Programming Can program robot while running or via simulation
Built-in Robot Commands Motion, sensor, I/O, speed control, tool control
Teach Pendant Support User can teach positions manually
Procedure-Based Supports creation & calling of procedures
VAL System Architecture
VAL system consists of:
1. Interpreter
2. Robot controller
3. Teach pendant
4. Memory storage
5. Console terminal
Programs are executed through controller firmware.
VAL Programming Elements
Element Description Example
Variables Storage of values A = 10
Procedures Set of commands DEFINE PICKPART
Element Description Example
Motion Commands Move robot MOVE P1
I/O Commands Activate devices SET ON 1
Speed Control Control velocity SPEED 20
Tool Control Control end effectors OPEN, CLOSE
Important VAL Commands
1. Motion Commands
Command Purpose
MOVE p Move robot to point p (continuous path)
MOVES p Move in straight line to point p
SPEED n Set robot velocity
APPRO p, dist Move near position p by dist mm
DEPART dist Move back from current position
Example:
SPEED 20
MOVE P1
MOVES P2
APPRO P3, 50
DEPART 50
2. End-Effector Commands
Command Function
OPEN Open gripper
CLOSE Close gripper
Example:
CLOSE
MOVE P1
OPEN
3. Sensor & I/O Commands
Command Function
SET n Turn ON output n
Command Function
RESET n Turn OFF output n
SENSE n Read input n
Example:
SET 1 ; Turn on motor
RESET 1 ; Turn off motor
IF SENSE(5) THEN CLOSE
4. Program Definition Commands
Command Function
DEFINE name Start procedure
END End procedure
CALL name Execute a procedure
Example:
DEFINE PICKPLACE
MOVE HOME
MOVE P1
CLOSE
MOVE P2
OPEN
END
5. Position Definition
P1 = TRANS(300, 200, 100, 0, 0, 0)
Complete Example Program – Pick & Place
DEFINE PICKPLACE
SPEED 30
MOVE HOME
MOVE P1
APPRO P1, 50
MOVES P1
CLOSE ; pick part
DEPART 50
MOVE P2
APPRO P2, 50
MOVES P2
OPEN ; release part
DEPART 50
MOVE HOME
END
Call the program:
CALL PICKPLACE
VAL Program – Sensor Based Operation
DEFINE SORTING
SPEED 25
MOVE HOME
IF SENSE(1) THEN
MOVE P_FEED
CLOSE
MOVE P_BIN1
OPEN
ELSE
MOVE P_FEED
CLOSE
MOVE P_BIN2
OPEN
ENDIF
END
Advantages of VAL
• Easy to learn (simple syntax)
• Real-time control & monitoring
• Good for industrial automation tasks
• Rich motion control functions
Limitations
• Platform-dependent (Unimation robots only)
• Not suited for advanced AI tasks
• Old language (modern robots use RAPID, KAREL, RoboDK, ROS)
Exam Point Summary
Key Point Description
Invented by Unimation
Used in PUMA robots
Type High-level robot language
Features Interactive, procedure-based, motion & I/O support
Commands MOVE, MOVES, SPEED, OPEN, CLOSE, SET, SENSE
Memory Tips for Exams
• VAL = Unimation robot language
• Key commands: MOVE, MOVES, SPEED, OPEN, CLOSE, SET, SENSE
• Supports offline + online programming
• Used mainly for Pick & Place industrial robots
You said:
Develop a program in VAL Il to command a PUMA robot to unload a cylindrical part of 10mm diameter from
machine 1 positioned at point P1 and load the part on machine 2 positioned at P2. The speed of robot motion is
40 in./s. However, because of safety precautions, the speed is reduced to 10 in./s. while moving to a machine for
an unloading or loading operation.
ChatGPT said:
Below is the final exam-ready VAL-II program for the given task.
VAL-II Program: Unload From Machine-1 (P1) → Load to Machine-2 (P2)
Task: Pick 10 mm cylinder from machine-1 at P1, place into machine-2 at P2
Normal speed = 40 in/s, safety speed near machines = 10 in/s
Program
DEFINE UNLOAD_LOAD
; ------------------ INITIAL SETTINGS ------------------
SPEED 40 ; Normal robot speed
MOVE HOME ; Move robot to home position
; ------------------ UNLOAD CYLINDRICAL PART FROM MACHINE 1 ------------------
MOVE P1A ; Move to approach point above Machine 1
SPEED 10 ; Reduce speed near machine for safety
MOVES P1 ; Move straight to pickup point inside machine
CLOSE ; Grip cylindrical part (10 mm diameter)
DEPART 50 ; Move upward 50 mm for safe clearance
SPEED 40 ; Restore normal speed
MOVE P1A ; Move away from machine area
; ------------------ LOAD PART INTO MACHINE 2 ------------------
MOVE P2A ; Move to approach point above Machine 2
SPEED 10 ; Reduce speed near machine for loading
MOVES P2 ; Move straight to drop position
OPEN ; Release cylindrical part
DEPART 50 ; Lift tool away safely
; ------------------ RETURN HOME ------------------
SPEED 40
MOVE HOME
END
Program Call
CALL UNLOAD_LOAD
Key Points to Write in Theory
Requirement Used Command
Robot moves fast between machines SPEED 40
Slow speed near machine SPEED 10
Pick part CLOSE
Place part OPEN
Safe entry/exit P1A, P2A, DEPART, MOVES
Straight motion inside machine MOVES
Explanation (Short for Exam)
• Robot starts from HOME and moves at 40 in/s
• Approaches Machine-1 using P1A
• Reduces speed to 10 in/s due to safety
• Executes pick using MOVES, CLOSE, DEPART
• Moves to Machine-2, again slows down to 10 in/s
• Executes placement using MOVES, OPEN, DEPART
• Returns to HOME at normal speed
Classification of Robot Programming Languages
Robot programming languages are classified based on control method, abstraction level, and application
environment.
1. Based on Programming Method
Type Description
Teach Pendant Programming Operator teaches robot positions manually
Lead-Through Programming Physically guiding robot arm to positions
Offline Programming Program in computer, then download to robot
Text-Based / High-Level Languages Coding in robot languages (e.g., VAL, RAPID)
Graphical / Simulation-Based Virtual environment programming (e.g., RoboDK, ROS-MoveIt
Languages GUIs)
2. Based on Language Structure
Category Examples
Low-Level Languages VAL, AML, KRL (KUKA)
High-Level Languages RAPID (ABB), KAREL (Fanuc), URScript
Category Examples
Object-Oriented Robot Languages ROS-Python, C++ robot frameworks
Task-Oriented / Domain-Specific Robot-BASIC, AL, RPL
3. Based on Application Layer
Layer Examples
Hardware-level Assembly language
Controller-level VAL-II, KRL, RAPID
System-level ROS (Robot Operating System)
Simulation-level V-REP, RoboDK, Gazebo
Explanation of Four Robot Programming Languages with Applications
1) VAL / VAL-II (Unimation – PUMA Robots)
Features
• Procedural, high-level robot language
• Real-time control through terminal or teach pendant
• Motion control, gripper control, I/O logic
Syntax Example
SPEED 30
MOVE P1
CLOSE
MOVE P2
OPEN
Industrial Application
• Pick and place operations in assembly
• Palletizing and machine loading
Use Case:
PUMA robots used in automotive small-part assembly.
2) RAPID (ABB Robots)
Features
• High-level structured robot language
• Strong variable, data type, and motion control support
• Error handling, multitasking, sensing
Syntax Example
MoveJ pPick, v100, z10, tool1;
GripON;
MoveL pPlace, v50, z5, tool1;
GripOFF;
Industrial Application
• Welding, material handling, painting, machine tending
Use Case:
ABB IRB robots in automotive MIG welding lines
3) KUKA KRL (KUKA Robot Language)
Features
• Procedural language, similar to Pascal
• Precise path control and industrial communication
Syntax Example
PTP P1
GRIPPER_CLOSE()
LIN P2
GRIPPER_OPEN()
Industrial Application
• Laser cutting, spot welding, CNC-type robotic machining
Use Case:
KUKA KR series in sheet metal laser cutting
4) FANUC KAREL / TP Language
Features
• KAREL: Pascal-like full programming environment
• TP (Teach Pendant) for motion-centric programming
Syntax Example (TP)
J P1 100% FINE
CALL CLOSE_GRIP
L P2 150mm/sec FINE
CALL OPEN_GRIP
Industrial Application
• Robotic packaging, palletizing, arc welding
Use Case:
FANUC M-10/M-20 robots in FMCG packaging plants
Optional Additional Languages (for bonus marks)
Language Vendor Application
URScript Universal Robots Cobots, material handling
AML IBM Early research robots
ROS Python/C++ Open source Autonomous robots, simulation
Conclusion / Key Summary Points
• Industrial robots use specialized programming languages
• Classified by method, level, and application
• Example languages: VAL, RAPID, KRL, KAREL
• Applications include assembly, welding, material handling, packaging
