UNit 4

Explanation for the following codes

CALL, IF, JMP, LBL, L, J, UTOOL, UFRAME, WAIT—are commonly used

in robot programming, especially in FANUC robots and similar industrial
robotic systems. These are control or motion commands in robot
programming languages like KAREL or TP (Teach Pendant) programming.
Here's an explanation for each, along with examples:

1. CALL
Purpose: Executes a separate program or subroutine from within the main
program.
Example:
tp
CopyEdit
CALL PALLETIZE

This would call a program named PALLETIZE and run it from the current
point in the main program.

2. IF
Purpose: Conditional statement that executes a line if the condition is true.
Example:
tp
CopyEdit
IF R[1]=1,JMP LBL[10]

If register R[1] equals 1, then jump to label 10.

3. JMP
Purpose: Jumps to a label (LBL) unconditionally or conditionally, used for
loops or branching.
Example:
tp
CopyEdit
JMP LBL[20]

Jump to label 20 immediately.

4. LBL
Purpose: Label used as a marker in the program to jump to using JMP.
Example:
tp
CopyEdit
LBL[20]
! This is a comment or code section at label 20

5. L
Purpose: Linear movement. The robot moves in a straight line from one
point to another.
Example:
tp
CopyEdit
L P[1] 100mm/sec FINE

Move linearly to position P[1] at 100 mm/sec speed with FINE termination
(stop exactly at that point).
6. J
Purpose: Joint movement. The robot moves using joint interpolation (faster
but less predictable path).
Example:
tp
CopyEdit
J P[2] 20% FINE

Move the robot's joints to position P[2] at 20% of maximum speed.

7. UTOOL
Purpose: Sets the active tool frame (the robot’s understanding of the tool’s
position and orientation).
Example:
tp
CopyEdit
UTOOL_NUM=2

Set the current tool frame to tool number 2.

8. UFRAME
Purpose: Sets the active user frame (defines the coordinate system used for
positions).
Example:
tp
CopyEdit
UFRAME_NUM=1

Set the current user frame to frame number 1.

9. WAIT
Purpose: Pauses program execution until a condition is met.
Example:
tp
CopyEdit
WAIT R[5]=1

Pause the program until register R[5] equals 1.

Another version:
tp
CopyEdit
WAIT 2.00(sec)

Wait for 2 seconds.

Summary Table
Command Description Example
CALL Call another program CALL PICK_PART
IF Conditional logic IF R[1]=1,JMP LBL[10]
JMP Jump to a label JMP LBL[5]
LBL Label for jumping LBL[5]
L Linear move L P[3] 200mm/sec FINE
J Joint move J P[4] 50% CNT100
UTOOL Set tool frame UTOOL_NUM=1
UFRAME Set user frame UFRAME_NUM=2
WAIT Wait for time or WAIT 1.50(sec) or WAIT
condition DI[1]=ON
Introduction to FANUC Robot Programming
FANUC is one of the leading manufacturers of industrial robots worldwide.
FANUC robots are widely used in industries like automotive, electronics,
packaging, welding, and material handling due to their reliability, flexibility,
and easy integration into manufacturing systems.
What Is FANUC Robot Programming?
FANUC robot programming involves writing instructions that tell the robot
how to move, what tasks to perform, and how to interact with other
equipment. This is done primarily through:
1.​ Teach Pendant (TP) Programming – Using a handheld controller
with a built-in display.
2.​ KAREL Programming – A higher-level language similar to Pascal,
used for more complex logic and data handling.
3.​ Offline Programming – Programming robots using software on a PC
(like RoboGuide) before deploying to the actual robot.
Basic Components of a FANUC TP Program
●​ Motion Commands: Move the robot to specific positions.
○​ J (Joint move)
○​ L (Linear move)
●​ Control Commands: Logic and decision-making.
○​ IF, JMP, LBL, CALL
●​ I/O Commands: Interacting with external devices (sensors,
actuators).
●​ Tool and Frame Settings: Setting coordinate systems.
○​ UTOOL, UFRAME
●​ Delays/Waiting:
○​ WAIT

Types of FANUC Programs

1.​ Motion Programs – Move the robot to handle materials, perform
welding, painting, etc.
2.​ Condition Monitoring Programs – Monitor sensors or system states.
3.​ Background Logic Programs – Run continuously for tasks like
monitoring inputs.
4.​ KAREL Programs – Handle complex data, file I/O, and background
tasks.
Teach Pendant Overview
●​ TP (Teach Pendant) is the main interface for creating and managing
robot programs.
●​ Users can:
○​ Teach points (robot positions).
○​ Write or edit TP programs.
○​ Monitor and control robot motion.
○​ Configure system settings.

Example: Basic FANUC TP Program

tp
CopyEdit
: UTOOL_NUM=1 ;
: UFRAME_NUM=2 ;
: J P[1] 20% FINE ;
: L P[2] 500mm/sec FINE ;
: WAIT DI[1]=ON ;
: CALL PLACE_PART ;
: JMP LBL[10] ;
: LBL[10] ;

Explanation:
●​ Sets tool and user frames.
●​ Moves to positions P[1] and P[2].
●​ Waits for a digital input to be ON.
●​ Calls a subprogram PLACE_PART.
●​ Jumps to label 10.

Why Use FANUC Robots?

●​ High-speed and precise operation.
●​ Easy to program with TP interface.
●​ Excellent support and compatibility with automation systems.
●​ Scalable and flexible for many applications.
Types of FANUC Robot Controllers
A controller is the brain of the robot. It stores programs, processes
commands, and controls all the motors, I/O, and safety systems.
Here are the most common FANUC robot controllers:
R-J3iB Controller
●​ Older model but still in use.
●​ Supports Ethernet and DeviceNet.
●​ TP programs and KAREL support.
●​ Less compact compared to newer models.

🔸 R-30iA Controller
●​ Next-gen version of R-J3iB.
●​ Improved processing power and I/O capacity.
●​ Integrated vision support.
●​ USB ports added for easy backup.
●​ Fanuc iPendant available (color screen).

🔸 R-30iB Controller
●​ Smaller, more compact design.
●​ More efficient and faster than R-30iA.
●​ Comes in 3 variations:
○​ R-30iB Standard (full-size cabinet)
○​ R-30iB Mate (smaller footprint)
○​ R-30iB Mini (ultra-compact)

🔸 R-30iB Plus Controller

●​ Latest generation (as of 2023).
●​ Faster boot time, improved graphics.
●​ Enhanced iPendant Touch with high-res color touchscreen.
●​ Expanded storage and memory.
●​ Easier integration with vision and force sensors.
🔸 R-30iB MiniMate or Mate Plus
●​ Designed for small to mid-size robots.
●​ Lightweight, wall- or shelf-mountable.
●​ Ideal for compact cells or mobile systems.
Cabinet Types in FANUC Systems
Cabinets house the controller hardware and electrical components.
Depending on the application and environment, different sizes are used:

🔹 Standard Cabinet
●​ Full-size enclosure with complete controller setup.
●​ Used for large robots and complex systems with multiple I/Os.
●​ Easy to service and install.

🔹 Mate Cabinet
●​ Compact version of the standard cabinet.
●​ Often used with smaller robots (like LR Mate series).
●​ Saves space while maintaining functionality.

🔹 Open Air Cabinet / Panel Mount

●​ Controller components are mounted directly onto a backplate or in an
open panel.
●​ Used inside custom-built electrical enclosures.
●​ Common in OEM or integrator-built systems.

🔹 Mini Cabinet
●​ Extremely compact.
●​ Supports lightweight robots in tight spaces.
●​ Often seen in education or desktop automation setups.
Summary Table
Controller Notes Cabinet Type
R-J3iB Legacy, large, basic UI Standard
R-30iA Ethernet, vision-ready Standard/Mate
R-30iB Compact, improved performance Standard/Mate/
Mini
R-30iB Fast boot, modern UI, touchscreen All sizes
Plus iPendant
R-30iB Small footprint for compact robots Mate
Mate
R-30iB Ultra-compact Mini/Open Air
Mini

When selecting a controller/cabinet:

●​ Use a standard cabinet for high I/O systems or heavy-duty robots.
●​ Mate or Mini cabinets are great for compact robotic cells or mobile
units.
●​ Always check compatibility with the robot model and payload.

A, B, Mate, Open Air – which are important to understand when working

with different setups or installations.

A-Cabinet
●​ Full-size industrial cabinet
●​ Designed for larger robots or complex systems that require a lot of
I/O, safety hardware, and additional options (like 7th-axis control).
●​ Comes with more internal space for:
○​ Servo amplifiers
○​ I/O modules
○​ Safety relays
○​ External power supplies
●​ Typically used in fixed-floor installations.
Use Case: Large material handling, welding, or painting robots in
automotive factories.

B-Cabinet
●​ Medium-sized cabinet
●​ Slightly more compact than the A-cabinet but still capable of housing
advanced functionality.
●​ Supports mid-size robots and offers a balance between expandability
and space-saving.
●​ Often wall- or pedestal-mounted.
Use Case: General industrial automation where space is limited but some
expansion is still needed.

Mate Cabinet (R-30iB Mate / Mate Plus)

●​ Compact and portable cabinet.
●​ Designed for small robots, especially the LR Mate series or SCARA
robots.
●​ Limited space for expansion but includes core components like:
○​ Servo drives
○​ Main CPU board
○​ Power supplies
●​ Often used in labs, schools, and compact robotic cells.
Use Case: Desktop automation, light material handling, pick-and-place in
tight spaces.

Open Air (or Panel-Mount Controller)

●​ Controller components are mounted openly on a backplate or DIN
rail inside a custom enclosure.
●​ No traditional cabinet shell.
●​ Used by OEMs or integrators who want to integrate FANUC controller
hardware into custom-built control panels.
●​ Saves space and allows custom layout.
Use Case: Integrated machines, robots embedded into CNC systems, or
where a custom electrical panel is used.

Summary Table
Cabinet Size Expandabi Typical Use Robot Types
Type lity
A-Cabine Large High Large robots, M-20iA,
t complex systems R-2000iC
B-Cabine Mediu Medium Mid-size robots, M-10iA, M-20iB
t m flexible systems
Mate Compa Low Small robots, limited LR Mate 200iD,
Cabinet ct space CRX
Open Air No Customiza OEM integrations, Varies (depends
cabinet ble custom panels on robot)

Registers in FANUC Robot Programming

Registers in FANUC robots are memory storage areas used to store and
manipulate numeric or positional data. You can think of them like
variables in regular programming.
There are mainly two types:
1.​ Numeric Registers (R[])
2.​ Position Registers (PR[])
1. Numeric Registers (R[n])
These store integers or real numbers and are used for logic control, loops,
counters, calculations, etc.
Syntax
tp
CopyEdit
R[1] = 10 -- Assign value 10 to Register 1
R[2] = R[1] + 5 -- R[2] becomes 15
IF R[1] = 10, JMP LBL[5] -- Conditional jump
WAIT R[3] = 1 -- Wait until R[3] is 1

Common Uses
●​ Loop counters
●​ Flags
●​ Calculation of positions or speeds
●​ Storing sensor values

2. Position Registers (PR[n])

These store robot positions (like X, Y, Z, W, P, R coordinates) and can be
used in motion commands. Position registers are global, meaning they can
be used across multiple programs.
Syntax
tp
CopyEdit
PR[1] = P[3] -- Copy taught point P[3] into PR[1]
L PR[1] 100mm/sec FINE -- Linear move to PR[1]
PR[2,1] = 200.0 -- Set X value of PR[2] to 200.0
PR[3,6] = 180.0 -- Set R (rotation around Z) of PR[3] to
180 degrees

Note: PR[n, m] accesses a specific component of the position:

●​ 1: X
●​ 2: Y
●​ 3: Z
●​ 4: W (Rotation around X)
●​ 5: P (Rotation around Y)
●​ 6: R (Rotation around Z)

Example: Using Both Registers

tp
CopyEdit
R[1] = 1
LBL[1]
IF R[1] > 5, JMP LBL[99]
PR[1,1] = R[1]*100 -- Set PR[1]'s X to R[1] × 100
L PR[1] 200mm/sec FINE
R[1] = R[1] + 1
JMP LBL[1]
LBL[99]

What it does:
●​ Moves the robot to 5 positions, each 100mm apart along X-axis
●​ Uses R[1] as a counter and to compute new X positions
●​ PR[1] is updated each loop

Summary Table
Type Syntax Purpose
Numeric R[1] = 10 Store numbers, logic, flags
Register
Position PR[2] = Store robot positions (X, Y,
Register P[5] Z…)
Component PR[2,3] = Set Z-axis of position
Access 150.0

Flags, Frames, and Main Routines in FANUC robot programming — core

concepts every programmer should understand when building or
troubleshooting robot jobs.
Flags
What Are Flags?
Flags (F[n]) are Boolean (ON/OFF) indicators used for controlling logic flow.
Think of them like digital switches (true/false, 1/0). Flags don’t store
numbers — just ON or OFF status.
Syntax
tp
CopyEdit
F[1] = ON -- Turn Flag 1 ON
F[2] = OFF -- Turn Flag 2 OFF
IF F[1]=ON, JMP LBL[10] -- Conditional jump if Flag 1 is ON
WAIT F[2]=ON -- Wait until Flag 2 becomes ON

Use Cases
●​ Simple interlocks between programs
●​ Monitoring conditions without using numeric registers
●​ Triggering state changes

Frames
What Are Frames?
Frames define coordinate systems that the robot uses to understand
positions. There are two main types:

UFRAME (User Frame)

Defines a custom coordinate system in space (e.g., a pallet, conveyor, or jig
location).
Syntax:
tp
CopyEdit
UFRAME_NUM=1
 ●​ All positions will be relative to User Frame 1.
●​ Used when the workpiece is not aligned with the robot's base.

UTOOL (Tool Frame)

Defines the location/orientation of the robot’s tool (e.g., gripper, welder,
camera).
Syntax:
tp
CopyEdit
UTOOL_NUM=2

●​ All movements are calculated from the tool’s tip (TCP).

●​ Important for accurate motion in complex applications.

Example:
tp
CopyEdit
UTOOL_NUM=1
UFRAME_NUM=3
L P[5] 200mm/sec FINE

Robot moves to P[5] using Tool 1 and Frame 3 for coordinate

reference.

Main Routines
What Are Main Routines?
The main routine is the primary program that the robot controller runs first
or uses as an entry point. It typically contains the high-level logic and calls
subprograms as needed.
Syntax Example:
tp
CopyEdit
PROGRAM: MAIN_ROUTINE
CALL PICK_PART
CALL PLACE_PART
JMP LBL[100]
LBL[100]
WAIT DI[1]=ON
CALL MAIN_ROUTINE

●​ MAIN_ROUTINE is your central logic loop.

●​ Calls subroutines like PICK_PART, PLACE_PART.
●​ Can include jumps, waits, and loops.

How It's Used:

●​ Declared as the "main program" in the robot’s settings or startup
configuration.
●​ Handles startup, task sequencing, looping, and shutdown
conditions.

Summary Table
Concept Purpose Syntax Example
Flag (F[n]) ON/OFF logic control IF F[1]=ON, JMP
LBL[10]

UTOOL Defines tool’s UTOOL_NUM=1

position/orientation
UFRAME Defines work area UFRAME_NUM=2
coordinates
Main Main logic/program flow CALL PICK_PART
Routine
CALL – Call a Subprogram
Purpose:
The CALL instruction is used to invoke another program (subroutine) from
within your main program. This promotes modular programming, making
your code cleaner, reusable, and easier to debug.
Syntax:
tp
CopyEdit
CALL PROGRAM_NAME

●​ PROGRAM_NAME is the name of the program you want to call.

●​ Control returns to the calling program once the subroutine finishes.
●​

Use Case:
tp
CopyEdit
CALL PICK_PART
CALL PLACE_PART

Here, the robot calls two subprograms: one to pick a part and another to
place it.

IF – Conditional Execution
Purpose:
IF is used to execute instructions only when a specified condition is true.
It allows decision-making in programs (like branching logic).
Syntax:
tp
CopyEdit
IF R[1]=1, JMP LBL[100]

●​ If the value in register R[1] is 1, the program will jump to label 100.
Use Case:
tp
CopyEdit
IF DI[1]=ON, CALL START_CONVEYOR

Start the conveyor if a part is detected.

JMP – Jump to a Label

Purpose:
JMP is used to unconditionally or conditionally skip to another section
of the program, marked by a LBL.
Syntax:
tp
CopyEdit
JMP LBL[10]

●​ Moves program control to label 10, skipping lines in between.

Use Case:
tp
CopyEdit
IF R[1] > 5, JMP LBL[999]

If a loop counter exceeds a limit, jump to the end of the program.

LBL – Label or Marker

Purpose:
LBL defines a destination point in the program, used by JMP or IF to
redirect program flow.
Syntax:
tp
CopyEdit
LBL[10]

●​ Can be used multiple times as jump targets or loop points.

Use Case:
tp
CopyEdit
LBL[1]
-- code
JMP LBL[1] -- creates a loop

L – Linear Motion
Purpose:
The L command tells the robot to move in a straight line (Cartesian path)
to a specific point in space.
Syntax:
tp
CopyEdit
L P[5] 500mm/sec FINE

●​ P[5]: Target position

●​ 500mm/sec: Speed
●​ FINE: Stop exactly at the point (vs. CNT for continuous motion)

Use Case:
Used when the robot must maintain a straight path, such as in welding,
glue dispensing, or avoiding collisions.
J – Joint Motion
Purpose:
The J command makes the robot move using joint interpolation, meaning
each joint moves at its own speed to reach the target. It is usually faster but
not in a straight line.
Syntax:
tp
CopyEdit
J P[2] 30% FINE

●​ 30%: Speed as a percentage of max joint speed.

Use Case:
Ideal for fast travel between non-critical points, such as moving between
workstations or returning to home position.

UTOOL – Tool Frame Definition

Purpose:
UTOOL_NUM selects which tool frame the robot uses to interpret motion
commands. It defines the position and orientation of the tool's tip (TCP –
Tool Center Point).
Syntax:
tp
CopyEdit
UTOOL_NUM=1

●​ Sets tool frame 1 as active.

●​ Used when the robot has multiple end effectors or tools.
Use Case:
Pick-and-place with different grippers, welding torch alignment, or changing
the working end of the robot.

UFRAME – User Frame Definition

Purpose:
UFRAME_NUM sets the coordinate system used for robot positions. This allows
the robot to operate in a coordinate system relative to a fixture, conveyor,
or part location, instead of its own base.
Syntax:
tp
CopyEdit
UFRAME_NUM=2

●​ Sets the active user frame to Frame 2.

Use Case:
Different user frames for different pallet zones, parts on a moving line, or
reconfigurable fixtures.

WAIT – Pause or Wait for Condition

Purpose:
WAIT pauses program execution until a condition is met or a time delay
elapses.
Syntax:
tp
CopyEdit
WAIT R[5]=1 -- Wait until register 5 equals 1
WAIT DI[1]=ON -- Wait until digital input 1 is ON
WAIT 1.50(sec) -- Wait for 1.5 seconds

Use Case:
 ●​ Wait for a part to be placed
●​ Wait for a machine to finish
●​ Delay for safety or timing purposes

Example: Combined Usage

tp
CopyEdit
PROGRAM: MAIN_ROUTINE
UTOOL_NUM=1
UFRAME_NUM=1

R[1] = 0
LBL[1]
R[1] = R[1] + 1
PR[1,1] = R[1] * 100 -- Move X axis 100mm per loop
L PR[1] 500mm/sec FINE

IF R[1] >= 5, JMP LBL[99]

WAIT 0.50(sec)
JMP LBL[1]

LBL[99]
CALL FINISH_ROUTINE

What It Does:
●​ Sets the tool and user frame.
●​ Loops 5 times, moving linearly to a new X-position each time.
●​ Uses a register to calculate position.
●​ Waits 0.5 seconds between movements.
●​ Jumps to the end and calls a finishing subroutine.

Key Takeaways
Comma Type Role in Program Logic
nd
CALL Program Calls other programs (subroutines)
Control
IF Logic Conditional decision-making
JMP Logic Jumps to another point in the
program
LBL Logic Label or anchor for jumps and loops
L Motion Linear, precise movement
J Motion Joint (faster, not linear) movement
UTOOL Setup Defines the tool's frame of reference
UFRAME Setup Defines the workspace's coordinate
system
WAIT Timing/Logic Waits for time or condition before
continuing
Robot Programming – Teach Pendant

Teach Pendant, specifically for FANUC robots. The Teach Pendant is the
primary interface between the programmer/operator and the robot, and
mastering it is essential for efficient programming, teaching, and
troubleshooting.

What Is the Teach Pendant?

The Teach Pendant (TP) is a handheld controller used to:
●​ Teach the robot positions
●​ Create and edit programs
●​ Monitor robot and I/O status
●​ Set frames, tools, and system parameters
●​ Manually jog the robot
In FANUC robots, it’s the main tool for TP programming (also called TPP or
Teach Pendant Programming).

Feature Description
iPendant Modern touchscreen-based version with color
display
F-buttons Soft keys for menus that change contextually
(F1–F5)
Arrow Keys Navigation through menus and code
Shift Key Modifier for accessing alternate commands
Jog Keys Move robot manually in joint, world, tool, or
user frame
Deadman Safety switch that must be held to move robot
Switch
Emergency Immediately halts all motion for safety
Stop 🖥️ Key
Edit Mode T1 (Teach), T2 (Teach High-Speed), AUTO
Selector (Automatic)
Function Keys Access to Data, Status, Program, I/O,
Frames, etc.
Features of the FANUC Teach Pendant

Modes of Robot Movement via Teach Pendant

You can move (jog) the robot manually using these coordinate systems:
Mode Description
Joint Move each axis individually
(J)
World Move along the robot’s base X, Y, Z
Tool Move relative to the tool’s
orientation (TCP)
User Move relative to a user-defined
frame
These are accessed via the COORD softkey.

Creating a Program Using Teach Pendant

Step-by-Step Guide
1. Create a Program
tp
CopyEdit
MENU → SELECT → F2 (CREATE) → Enter program name (e.g.,
"MAIN") → ENTER

2. Set UTOOL and UFRAME

tp
CopyEdit
UTOOL_NUM = 1
UFRAME_NUM = 1

These define the coordinate system and tool orientation.

3. Teach Positions
●​ Move robot to desired position using JOG keys.
●​ Press SHIFT + F5 (RECORD) to save the position.
●​ Choose motion type: J (Joint), L (Linear), C (Circular)
●​ Set speed and termination type (FINE or CNT).
Example:
tp
CopyEdit
J P[1] 30% FINE
L P[2] 500mm/sec CNT100

Teaching Frames & Tools

Tool Frame (UTOOL)
Used to define the TCP (Tool Center Point) of the end effector.
●​ Access: MENU → SETUP → TOOL
●​ Use the 6-point method or direct entry.
User Frame (UFRAME)
Used to define the coordinate system relative to a fixture, table, pallet, etc.
●​ Access: MENU → SETUP → FRAME
●​ Use 3-point or 6-point method.

Programming Commands Available in Teach Pendant

 Comma Description
nd
CALL Call another TP program
IF Conditional logic
JMP Jump to label
LBL Label (used with JMP)
WAIT Wait for a condition or delay
R[n] Numeric register for logic or
counters
PR[n] Position register for dynamic
movement
DI/DO Digital inputs and outputs
F[n] Flags (ON/OFF status bits)

Program Structure Example

tp
CopyEdit
: UTOOL_NUM=1 ;
: UFRAME_NUM=2 ;
: J P[1] 20% FINE ;
: L P[2] 400mm/sec FINE ;
: WAIT DI[1]=ON ;
: CALL GRIP_PART ;
: IF R[1]=5, JMP LBL[99] ;
: R[1] = R[1] + 1 ;
: JMP LBL[1] ;
: LBL[99] ;

Breakdown:
●​ Sets the tool and frame
●​ Moves to positions
 ●​ Waits for input from sensor
●​ Calls subroutine to grip part
●​ Uses a register as a loop counter
●​ Loops 5 times then jumps to label 99

Additional Teach Pendant Functions

●​ I/O Menu: Set or monitor digital/analog signals
●​ Data Menu: View or edit registers, positions, etc.
●​ Status Menu: Monitor alarms, runtime data
●​ System Config: Configure startup behavior, override settings

Safety and Teach Pendant Usage

●​ Deadman Switch must be held for jog and teaching.
●​ Robot moves slower in T1 Mode (safe for teaching).
●​ Fast movement is possible in T2 Mode, but requires additional safety.
●​ AUTO Mode is used for full-speed program execution without the TP.

Advantages of Teach Pendant Programming

●​ Visual and hands-on — you see what the robot will do.
●​ Excellent for quick job setup or one-off tasks.
●​ Easy to learn for new users.
●​ Great for small to medium complexity applications.

Pro Tip:
For complex logic, file operations, or background processes, combine TP
programming with KAREL programming (FANUC's high-level language).
Example

Sample Exercise: Pick-and-Place Task

Objective:
Move the robot from a home position, pick up a part, and place it at a
different location — using J, L, WAIT, CALL, and Registers.

Step 1: Setup
➤ Create 3 Positions:
●​ P[1]: Home position
●​ P[2]: Pick position
●​ P[3]: Place position

Use JOG mode to move the robot to each point, then press SHIFT + F5
(RECORD) to save the position.

Step 2: Create a Program

On the pendant:
text
CopyEdit
MENU → SELECT → F2 (CREATE) → Name: PICK_PLACE

Step 3: Write the Program

Code in PICK_PLACE:
tp
CopyEdit
1: UTOOL_NUM=1 ; -- Set tool frame
2: UFRAME_NUM=1 ; -- Set user frame
3: J P[1] 20% FINE ; -- Move to home position
4: L P[2] 500mm/sec FINE ; -- Move linearly to pick
position
5: WAIT DI[1]=ON ; -- Wait for part present sensor
6: CALL CLOSE_GRIPPER ; -- Call subprogram to close
gripper
7: L P[3] 500mm/sec FINE ; -- Move to place position
8: CALL OPEN_GRIPPER ; -- Release the part
9: J P[1] 20% FINE ; -- Return to home

Step 4: Create Gripper Subprograms

➤ CLOSE_GRIPPER
tp
CopyEdit
1: DO[1]=ON ; -- Turn on output to close gripper
2: WAIT 0.50(sec) ;
3: END ;

➤ OPEN_GRIPPER
tp
CopyEdit
1: DO[1]=OFF ; -- Turn off output to open gripper
2: WAIT 0.50(sec) ;
3: END ;

Step 5: Test Your Program

1.​ Set the robot to T1 mode.
On Teach Pendant:​
text​
CopyEdit​
MENU → SELECT → PICK_PLACE → ENTER

2.​
3.​ Press SHIFT + FWD to step through the program slowly.
4.​ Watch for:
○​ Correct movement
○​ Part sensor triggering (DI[1])
○​ Gripper signals (DO[1])

Graphical Programming
What is Graphical Programming in FANUC Robots?
Graphical Programming refers to programming the robot using a visual,
block-based interface rather than traditional line-by-line code. It’s designed
to make robot programming more intuitive, especially for:
●​ Beginners
●​ Educational environments
●​ Quick prototyping
●​ Collaborative robots (like FANUC CRX series)
In FANUC robots, this concept is realized mainly through:
FANUC's Tablet Teach Pendant
●​ A modern, touchscreen-based pendant.
●​ Used with CRX collaborative robots.
●​ Allows drag-and-drop programming blocks to control motion, I/O,
loops, conditions, etc.
●​ Programs can be generated graphically and then converted into TP
code in the background.
Key Features of FANUC Graphical Programming
Feature Description
Block-Based Logic Create programs by connecting logic blocks (move,
wait, loop, etc.)
Touchscreen Tap and drag blocks to build the flow visually
Interaction
Real-Time See the robot’s motion paths and simulate behavior
Simulation
Convert to TP The graphical program gets converted into standard
Program Teach Pendant code automatically
Save & Edit Later Graphical programs can be saved and reused or
edited in the future

Common Programming Blocks

 Block Example
Type
Motion Move to position, set speed, choose motion
type (J or L)
I/O Turn outputs ON/OFF, wait for inputs
Logic IF, ELSE, LOOP, WAIT
Utilities Set Tool Frame, User Frame, Call subroutine

Why Use Graphical Programming?

●​ Easy to learn – no need to memorize syntax.
●​ Visual logic flow – better understanding of process.
●​ Fast prototyping – ideal for quick cell setup or testing.
●​ Safe – well-integrated into FANUC’s safety system (especially with
CRX).

Example: Pick-and-Place Flow (Graphical Style)

The blocks might look like this:
pgsql
CopyEdit
[Set Tool Frame = 1]
[Set User Frame = 1]
[Move to Home (J)]
[Move to Pick (L)]
[Wait for DI[1] = ON]
[Turn ON DO[1] (gripper)]
[Move to Place (L)]
[Turn OFF DO[1]]
[Move to Home (J)]
[End]

Each block is a touchable icon that you configure with dropdowns and
values.
Graphical Programming Used?
●​ FANUC CRX Series Robots – via Tablet Teach Pendant
●​ Education/Training Environments
●​ Rapid Deployment Cells
●​ Collaborative Workspaces – where speed, safety, and simplicity are
crucial
Graphical Simulators
FANUC also provides RoboGuide (PC-based simulation software), which
isn’t fully graphical in the same way as block programming, but supports
offline TP programming with 3D visualization. However, for true
drag-and-drop programming, the Tablet TP is the go-to.
Robot Simulation — a crucial part of modern robotics engineering,
especially when working with FANUC robots.

What is Robot Simulation?

Robot Simulation is the process of creating a virtual model of a robot and
its working environment to test and visualize movements, program logic,
and interactions before deploying to the real robot.
For FANUC robots, simulation is most commonly done using:
FANUC RoboGuide
It’s FANUC’s official simulation software suite, offering a powerful offline
environment to:
●​ Design robotic workcells
●​ Create, test, and debug TP programs
●​ Check reach, cycle time, and collision detection
●​ Visualize robot paths and movements in 3D

Why Use Robot Simulation?

Benefit Description
Safety Avoid crashing into fixtures or tooling
Time-saving Develop and test programs offline while production
continues
Cost-effective Reduce downtime and minimize the need for trial and
error on the actual robot
Optimization Analyze robot cycle time, reach, workspace efficiency,
and payload
Layout Design cell layout and test robot positioning in 3D
Planning

FANUC RoboGuide Overview

Key Modules
●​ HandlingPRO – Material handling simulations
●​ WeldPRO – Robotic welding simulation
●​ PaintPRO – Robotic painting simulation
●​ PickPRO – High-speed picking (e.g., Delta robots)
●​ PalletPRO – Palletizing/Depalletizing tasks

Main Features
Feature Description
3D Robot Models Load accurate FANUC robot models
TP Programming Create, edit, and run Teach Pendant
programs
Motion Path Testing Visualize movements in real time
Tooling & Fixtures Import CAD models or create objects inside
RoboGuide
Collision Detection Warns if robot collides with anything in the
scene
Cycle Time Analysis Automatically estimates time taken per cycle

Example Use Case: Pick and Place Simulation

1.​ Create a new HandlingPRO project.
2.​ Choose your robot (e.g., LR Mate 200iD).
3.​ Import or create a workcell layout (table, parts, conveyor).
4.​ Define a tool frame and user frame.
5.​ Write a pick-and-place TP program.
6.​ Simulate and watch the robot in 3D.
7.​ Make changes and test again before downloading the program to the
actual robot.

How Simulation Supports Offline Programming

With simulation software:
 ●​ You can write and debug code in your PC.
●​ Once verified, download it to the real robot via USB, FTP, or
network.
●​ This is especially useful when physical access to the robot is limited.

System Requirements for RoboGuide

Spec Recommended
CPU Intel i5 or higher
RAM 8 GB or more
GPU Dedicated graphics card
(NVIDIA/AMD)
OS Windows 10 or 11
Stora 10+ GB free space
ge

Summary Table
Aspect Teach RoboGuide
Pendant Simulation
Programming On robot On PC (offline)
Method
Visual Feedback Text only 3D Visualization
Safety Testing Limited Full collision check
Cycle Time Manual Automatic
Analysis estimate
Real Robot Yes No
Required?
Offline Programming (OLP) in the context of FANUC robots — a powerful
method used in modern industrial automation to develop, test, and
optimize robot programs without stopping production.

What is Offline Programming (OLP)?

Offline Programming means creating, editing, and testing robot programs
on a PC using simulation software — instead of writing code directly on the
robot's Teach Pendant.
Once complete and verified, the program can be transferred to the real
robot.

Why Use Offline Programming?

Benefit Description
Minimize Program while robot is running production
Downtime
Safe Testing Test logic and motion paths in a virtual environment
Cost-Effective No need to stop machines or hire extra robot time
Better Planning Simulate cycle time, reach, robot layout, and
optimize code
Complex Logic Easier to write, review, and debug structured
programs on a computer

FANUC Offline Programming Tools

RoboGuide
●​ FANUC’s official PC-based simulation and offline programming tool.
●​ Full 3D simulation with real robot models.
●​ Create and test TP (Teach Pendant) programs.
●​ Ideal for:
○​ Material handling
○​ Palletizing
 ○​ Arc welding
○​ Painting
RoboGuide Modules:
●​ HandlingPRO
●​ WeldPRO
●​ PaintPRO
●​ PalletPRO
●​ PickPRO

Features of Offline Programming with RoboGuide

Feature Description
TP Program Editor Write TP code directly on PC
Cell Layout Tools Build the robot’s environment in 3D
I/O Mapping Simulate digital inputs/outputs
Motion Simulation Visualize robot paths with joint limits and
speed settings
Cycle Time Automatically calculate time per cycle
Estimation
File Transfer Export programs to USB, FTP, or Ethernet

Offline Programming Workflow

Step-by-Step Example
Objective: Create a Pick-and-Place program offline and deploy it to a
FANUC robot.
1.​ Start RoboGuide​
○​ Create a new HandlingPRO cell.
○​ Select your robot model (e.g., M-10iD/12).
2.​ Build the Environment​
○​ Add tables, parts, conveyors, or import CAD models.
 ○​ Define tool and user frames.
3.​ Write the Program​

Use the TP editor to code the robot’s motion:​

tp​
CopyEdit​
UTOOL_NUM=1 ;
UFRAME_NUM=2 ;
J P[1] 30% FINE ;
L P[2] 500mm/sec FINE ;
WAIT DI[1]=ON ;
CALL GRIP_PART ;

○​
4.​ Simulate the Program​
○​ Check paths, verify no collisions, and test logic.
○​ Adjust positions and speeds as needed.
5.​ Export the Program​
○​ Save the .TP or .LS file.
○​ Transfer via:
■​ USB
■​ Ethernet/FTP
■​ RoboGuide-to-robot integration
6.​ Run on Real Robot​
○​ Load program on Teach Pendant.
○​ Test in T1 mode for safety.
○​ Adjust live if needed.

OLP vs. Teach Pendant Programming

Feature Offline Teach Pendant
Programming Programming
Interface PC-based On the robot's TP
(RoboGuide)
Programming Fast (keyboard, Slower (manual input)
Speed GUI)
Visual 3D motion and No visual feedback
Simulation collision
Safety Risk Low (virtual testing) Higher (on real hardware)
Deployment Must transfer to Already on robot
robot
Productivity None Robot must be idle
Impact

FANUC File Types in OLP

File Description
Type
.TP Compiled TP program – ready for the robot
.LS ASCII readable TP program – can be edited
manually
.VR Variable data (registers, I/O, etc.)
.DG Diagnostics data
.DT Robot settings and configuration

Pro Tips for Effective Offline Programming

●​ Use Position Registers (PR[]) instead of static points for flexible code.
●​ Use simulation speed adjustment to test long cycles quickly.
●​ Always verify tool and frame setup in the robot matches your
simulation.
●​ Back up your robot before uploading programs.
●​ Use labels and modular programming (CALL, LBL, JMP) for reusable
logic.
Macro Programming in FANUC robots — an advanced and powerful
feature that lets you trigger robot actions using external devices (like HMI
buttons or PLC signals) without manually running a program from the
teach pendant.

What is Macro Programming in FANUC Robots?

A macro in FANUC is a Teach Pendant program that can be triggered
automatically or externally by:
●​ A Digital Input (DI)
●​ A User-defined softkey or button
●​ A System variable
●​ A PLC or HMI
It’s a way to bind a TP program to an external signal, allowing you to
perform complex actions — like gripping, resetting faults, or changing tools
— at the press of a button.

Where is Macro Programming Used?

Application Example

Operator Pressing a "Cycle Start" button on the HMI runs a

pushbuttons robot program

PLC-based control PLC turns on a Digital Output, which triggers the

robot macro

Error recovery Run a reset or homing macro on demand

routines
Tool changes Automatic tool-change sequences triggered by
macros

Simplifying user Map robot actions to easy softkeys

interface

How Macro Programming Works

Step 1: Create the TP Program (Macro logic)
Example program: GRIPPER_CLOSE
tp
CopyEdit
1: DO[1] = ON ; -- Turn on gripper

2: WAIT 0.50(sec) ;

3: END ;

Step 2: Assign the Program as a Macro

Go to:
tp
CopyEdit
MENU → SETUP → MACRO

You’ll see a list of macro slots: MACRO #1, #2, etc.

●​ Assign your TP program to a macro number
 ●​ Define the trigger: Digital Input (DI) or a button
●​ Choose if it runs with or without the pendant in remote mode
Example:

Macro Program Name Activation Trigg

Number Type er

1 GRIPPER_CLO Digital Input DI[1]

SE

This means: when DI[1] turns ON, the robot will run the
GRIPPER_CLOSE program automatically.

Triggering Methods for Macros

Trigger Type Description

Digital Input Physical input signal (from sensor, PLC, etc.)

(DI)

PMC Address Internal bit from FANUC’s own logic controller

(advanced)

Softkey (UI) Manual button press from teach pendant or HMI

KAREL or TP Called from another program using RUN or CALL

Call

System Triggered via system-level logic (less common)

Variable
CALL vs. Macro

Feature CALL MACRO

How it’s From another TP External device or input

triggered program signal

Requires TP? Yes No (can run remotely)

Use Case Logic flow, HMI buttons, IO triggers

subroutines

Safety Considerations
●​ Use Macro Lock to prevent unauthorized editing.
●​ Macros can bypass safety checks — always use interlocks and safe
zones!
●​ Be careful if triggering macros during robot motion — avoid collisions!

Pro Tips for Macro Programming

●​ Use RUN instead of CALL inside macros if you want the macro to run
in parallel without blocking the main program.
●​ Use a status register or flag to avoid re-triggering or overlapping
macros.
●​ Combine macros with background logic for more advanced control.

Example Use Case: Gripper Control via PLC

Hardware Setup:
 ●​ PLC sets DO[10] = ON to request a grip.
●​ Robot receives it as DI[1].
Robot Macro Table:
tp
CopyEdit
Macro #1: GRIPPER_CLOSE → Trigger: DI[1]

GRIPPER_CLOSE Program:
tp
CopyEdit
1: DO[1] = ON ;

2: WAIT 0.3(sec) ;

3: DO[2] = ON ; -- Indicate "grip done" to PLC

4: END ;

Summary

Term Description

Macro TP program that runs when triggered

Program externally

Trigger DI, Softkey, HMI, PLC signal

Types

Setup MENU → SETUP → MACRO

Location
Use Cases Gripper control, cycle start, reset, tool
change

Safety Notes Use caution; macros bypass pendant

control

Sensor-Based Programming in FANUC robots, which plays a key role in

making robots adaptive, responsive, and intelligent in real-world
industrial environments.

What is Sensor-Based Programming?

Sensor-based programming allows the robot to make decisions or trigger
actions based on real-time feedback from sensors. It enhances flexibility
and reliability by enabling robots to interact with changing environments.
Common Sensors Used with FANUC Robots:

Sensor Type Function

Proximity Detect part presence or metal

Sensor objects

Photoelectric Detect parts on a conveyor

Sensor

Vision Sensor Locate parts, read barcodes,

quality check
Force/Torque Sense contact forces or assembly
Sensor pressure

Laser Sensor Measure distance or alignment

Limit Switch Detect mechanical position or

limits

How FANUC Robots Read Sensor Input

Digital Input (DI)
Sensors typically connect to the robot controller via Digital Inputs (DI).
Syntax:
WAIT DI[1]=ON -- Wait for sensor signal
IF DI[2]=OFF, JMP LBL[10] -- Conditional jump

You can also use:

! Read status of part-detect sensor
IF DI[10]=ON, CALL GRIP_PART

Digital Inputs (DI) are typically 0 (OFF) or 1 (ON), corresponding

to low/high voltage signals from the sensor.

Basic Workflow for Sensor-Based Control

Example: Pick When Part is Detected
LBL[1]
WAIT DI[1]=ON -- Wait for part to arrive
CALL GRIPPER_CLOSE -- Close gripper
L P[2] 300mm/sec FINE -- Move to place location
CALL GRIPPER_OPEN -- Release part
JMP LBL[1] -- Repeat

This allows the robot to wait for a part presence sensor before picking.

Sensor Integration Scenarios

1. Part Detection (DI)
Used to check if a part is present before picking:
WAIT DI[5]=ON

2. Safety Sensors / Area Scanners

Prevent robot motion unless the area is clear:
IF DI[20]=OFF, JMP LBL[STOP]

3. Vision Sensors (2D/3D)

Used with iRVision or external cameras:
●​ Locate parts with variable positions.
●​ Perform quality inspections.
●​ Guide robot motion dynamically.
4. Force Sensors
Used for:
 ●​ Adaptive assembly
●​ Surface following
●​ Insertion tasks Requires specialized Force Control options in
FANUC.

Sensor-Based Example Program: Conveyor Pick

PROGRAM: CONVEYOR_PICK
UTOOL_NUM=1 ;
UFRAME_NUM=2 ;

WAIT DI[10]=ON ; -- Wait for sensor to detect part

J P[1] 30% FINE ; -- Approach pick position
CALL GRIPPER_CLOSE ;
L P[2] 400mm/sec FINE ; -- Move to drop point
CALL GRIPPER_OPEN ;
WAIT DI[10]=OFF ; -- Wait for next part to arrive
JMP LBL[1]

Sensor DI[10] acts as a signal from a part-detect sensor.

How Sensors are Connected

Connection Type Description

DI/DO via Robot I/O Sensor wires connected directly to controller's

Module I/O terminals
Through PLC PLC receives sensor input and sends digital
output to robot

EtherNet/IP, Profibus, Sensor data via industrial fieldbus (for smart

Profinet sensors)

iRVision Integrated FANUC vision system (no external

hardware needed)

Safety & Sensor Tips

●​ Debounce sensors in logic if they flicker (e.g., use WAIT or timer).
●​ Use input masking to filter noise or unwanted triggers.
●​ Combine sensor + timer for smarter decision-making.
●​ For vision, calibrate properly using a grid or part reference.

Component Purpose Example Command

Proximity Detect object presence WAIT DI[1]=ON

Sensor

Photo Sensor Detect moving parts on IF DI[2]=ON, CALL

conveyor PICK

Limit Switch Detect end of travel WAIT DI[5]=OFF

Vision Sensor Part location / quality RUN VISION_LOCATE

check
Force Sensor Measure pressure during (Advanced Force
assembly Control)
Hand-Guided Collaborative Teaching — a feature that makes teaching
robot paths faster, easier, and safer, especially in FANUC collaborative
robots like the CRX or CR series.

What is Hand-Guided Teaching?

Hand-Guided Teaching allows you to physically move the robot arm with
your hands to teach positions — instead of using the Teach Pendant and jog
buttons.
It’s a key feature in collaborative robots (cobots), designed to be:
●​ User-friendly
●​ Fast to program
●​ Safe for human interaction

Where Is It Used?
This is common in:
●​ FANUC CRX series (CRX-10iA, CRX-25iA, etc.)
●​ FANUC CR series (like CR-15iA, CR-35iA)
●​ Systems requiring frequent path adjustments or low-volume,
high-mix production
●​ Environments where non-programmers or operators need to teach
robots quickly

How Does It Work?

1.​ Enable hand-guided mode (via a button on the arm or TP).
2.​ The robot enters a gravity-compensated free-motion state.
3.​ You physically move the arm to a desired position/orientation.
4.​ Press a “record” button to save that point in the program.
5.​ Repeat for multiple positions.
6.​ Play back the recorded path as a regular TP program.

Features of FANUC Hand-Guided Teaching

 Feature Description

Physical path Move the robot by hand into position

teaching

Gravity Robot resists gravity but allows free motion

compensation

TCP control Maintain orientation of the Tool Center Point

Point recording Use buttons on arm or tablet to record positions

Flexible playback Positions stored in a standard TP program or

graphical block

Teaching Process on FANUC CRX (Example)

Step-by-Step: Hand-Guided Teaching on CRX
1.​ Enable Hand Guidance:​
○​ Press the Enable Hand Guidance button on the robot arm (or
on the tablet TP).
○​ Hold the deadman switch if required.
2.​ Move the Arm:​
○​ Use your hands to position the robot.
○​ You can move in all 6 axes (X, Y, Z, Rx, Ry, Rz).
3.​ Record the Position:​
○​ Press the “Save” or “Record” button on the CRX’s wrist or tablet
TP.
 4.​ Repeat for More Points:​
Continue positioning and recording steps.
○​
5.​ Run the Program:​
○​ Press “Play” on the tablet or teach pendant to run your new
path.

Video/Visual Workflow (Conceptual)

CopyEdit
[Enable Guidance] → [Move Robot by Hand] → [Record Position] →
[Build Sequence] → [Play Program]

Technical Notes
●​ Positions recorded this way are stored as taught points (P[n]) in the
TP program.
●​ On CRX, you can use block-based graphical programming or convert
them to standard TP lines.
●​ Force sensors or internal torque sensing allow the robot to detect
your hand motion.

Advantages of Hand-Guided Teaching

Advantage Benefit

Easy for No coding or TP knowledge needed

non-programmers
Fast setup Teach new paths in seconds

Precise tool guidance Align tool angles easily by hand

Ideal for small-batch Perfect for high-mix, low-volume

tasks production

Safe and collaborative No need for fencing, easy to

stop/resume

Safety Features in Collaborative Teaching

FANUC collaborative robots include:
●​ Force-limiting joints: Stop when contact is detected.
●​ Speed and zone monitoring: Keep robot in safe ranges.
●​ Manual override: Stop robot anytime with physical force or buttons.

Use Case Example

Task: Box Pick-and-Place
1.​ Enable hand guidance.
2.​ Move robot to pickup point — record.
3.​ Move to drop location — record.
4.​ Save program.
5.​ Run with CRX safely next to a human co-worker.

Feature Hand-Guided Teaching

Used in FANUC CR/CRX robots

Programming Physical motion teaching

style

Interface Robot arm + tablet TP

Control method Hand movement + buttons

Ideal for Quick path setup, flexible

tasks

Safety features Force sensing, collaborative

mode

What is ROS (Robot Operating System)?

ROS is a modular software framework designed to develop and control
robotic systems. It provides everything needed for robot perception,
control, navigation, communication, and simulation — all in a
distributed and scalable way.

Key Concepts of ROS

Concept Description

Nodes Small programs or processes that do one task (e.g., camera

input, motion control)
Topics Communication channels used for publishing and
subscribing data between nodes

Messages The data format passed through topics (e.g., sensor values,
position commands)

Services Request-response interactions (like function calls) between

nodes

Actions Asynchronous goal-based communication (e.g., move to

goal with feedback)

Packages Reusable sets of code, nodes, and configuration (like

software modules)

Launch Files XML/YAML files used to start multiple nodes at once

What Does ROS Provide?

Component Purpose

Hardware Standard interfaces for controlling hardware (e.g.,

Abstraction motors, sensors)

Device Drivers Drivers for cameras, LiDAR, GPS, IMUs, etc.

Simulation Tools like Gazebo and RViz for testing without real
hardware
Visualization Real-time 3D views of the robot and environment
(using RViz)

Navigation Stack Autonomous navigation, SLAM (Simultaneous

Localization and Mapping)

Motion Planning With MoveIt!, for trajectory generation and path

planning

Perception For computer vision, object detection, and recognition

Libraries

Diagnostics & Tools to debug, log, and analyze robot behavior

Logging

Popular ROS Tools

Tool Function

RViz 3D visualization of robot sensors, states, and

environment

Gazebo Physics-based 3D simulation environment

RQT Graphical tools for introspection (e.g., rqt_graph,

rqt_plot)

rosbag Records and plays back data from ROS topics

TF (Transform Tracks coordinate frames over time (robot base,
Library) tool, world, etc.)

ROS Architecture Overview

+---------------------+

| Your Robot |

| (motors, sensors) |

+----------+----------+

+----------v----------+

| Hardware Drivers |

+----------+----------+

+----------v----------+

| ROS Middleware |

| (topics, nodes...) |

+----------+----------+

+----------v----------+

| High-Level Logic |

| (navigation, vision)|
+----------+----------+

+----------v----------+

| User Interface |

| (teleop, GUI, etc.) |

+---------------------+

Basic ROS Communication Flow

Let’s say you have a robot that’s avoiding obstacles using a laser sensor:
●​ Node A: Publishes laser scan data → /scan topic
●​ Node B: Subscribes to /scan → calculates safe movement
●​ Node B: Publishes velocity to /cmd_vel
●​ Node C: Subscribes to /cmd_vel → controls robot motors

Example ROS Use Case: Mobile Robot Navigation

1.​ Sensor Node publishes data from LiDAR
2.​ SLAM Node builds a map from sensor data
3.​ Navigation Node plans a path to goal
4.​ Control Node sends velocity commands
5.​ Robot Base Node drives the motors

ROS Versions

Version Notes
ROS 1 (Melodic, Original ROS, widely used; Noetic is the last LTS
Noetic) release

ROS 2 (Foxy, Modern version; real-time, multi-robot, secure, and

Humble, Iron) better middleware (DDS-based)

ROS-Industrial Extension of ROS for industrial robots (e.g., FANUC,

ABB, KUKA)

FANUC + ROS (ROS-Industrial)

FANUC robots can work with ROS through:
●​ ROS-Industrial drivers for FANUC (via Ethernet/IP or PMC)
●​ Joint control via FANUC R-30iA/B with an interface module
●​ External PC running ROS controlling robot via motion streaming or
offline control
Note: FANUC is proprietary, so real-time integration requires
licensed drivers or middleware (like PCDK, KAREL, or
ROS-Industrial bridge).

Advantages of Using ROS

Advantage Description

Modular Easy to break tasks into small, testable units

Simulatable Can test logic in Gazebo or RViz before real

deployment
Community Huge community and open-source packages

Reusable Packages can be reused across robots and

platforms

Smart Built-in support for AI, SLAM, machine

learning, etc.

Challenges with ROS

●​ Steep learning curve (especially ROS 2)
●​ Not real-time by default (ROS 1)
●​ Integration with proprietary hardware (like FANUC) may require
bridges
●​ Complex debugging in large systems

Summary

Feature ROS

Type Middleware / Framework

Platform Linux (Ubuntu), some support on Windows

Latest ROS 2 (Humble, Iron)

Version

Used For Autonomous robots, drones, arms, AGVs, cobots

Integrates Gazebo, MoveIt, OpenCV, TensorFlow, FANUC
with (via ROS-I)

Use Cases
●​ Autonomous mobile robots (AMRs)
●​ Robotic arms (pick-and-place, welding)
●​ Drone control and navigation
●​ Vision-based robotic inspection
●​ Human-robot collaboration (cobots)
●​ Industrial automation with ROS-Industrial