Get started with Python

from underautomation.fanuc.connection_parameters import ConnectionParameters
from underautomation.fanuc.common.languages import Languages
# Create a robot instance
robot = FanucRobot()

# Connect (replace with your robot's IP address)
params = ConnectionParameters('192.168.0.1')

# Set the controller language among English, Japanese and Chinese (optional, defaults to English)
params.language = Languages.English

# Enable Telnet KCL
# Activate Telnet on your robot or ROBOGUIDE : https://underautomation.com/fanuc/documentation/enable-telnet
params.telnet.enable = True
params.telnet.telnet_kcl_password="telnet_password"


# Enable FTP
params.ftp.enable = True
params.ftp.ftp_user = ""
params.ftp.ftp_password = ""

# Enable SNPX
# You need option R553 "HMI Device SNPX" for FANUC America (R650 FRA)
# No additional options needed for FANUC Ltd. (R651 FRL)
params.snpx.enable = True

# Connect to the robot
# If you get a license exception, ask a trial license here: https://underautomation.com/license and call FanucRobot.register_license(...) before connecting
robot.connect(params)

if robot.ftp.connected:
    safety = robot.ftp.get_safety_status()
    print(f"Safety Status:")
    print(f"  External E-Stop  : {safety.external_e_stop}")
    print(f"  SOP E-Stop       : {safety.sope_stop}")
    print(f"  TP E-Stop        : {safety.tpe_stop}")
    print(f"  TP Enable        : {safety.tp_enable}")
    print(f"  TP Deadman       : {safety.tp_deadman}")
    print()

if robot.snpx.connected:
    position = robot.snpx.current_position.read_world_position(1)
    print(position)
    r1 = robot.snpx.numeric_registers.read(1)
    print(f"  R[1] = {r1}")
    print()

if robot.telnet.connected:
    speed_override = robot.telnet.get_variable("$MCR.$GENOVERRIDE")
    print(f"Speed override: {speed_override.raw_value}%")
    print()

# Don't forget to disconnect
robot.disconnect()

from underautomation.fanuc.fanuc_robot import FanucRobot
license_info = FanucRobot.register_license("your-licensee", "your-license-key")
print(license_info)

from underautomation.fanuc.connection_parameters import ConnectionParameters
from underautomation.fanuc.telnet.kcl_ports import KCLPorts
robot = FanucRobot()
params = ConnectionParameters("192.168.0.1")
params.telnet.enable = True
robot.connect(params)

# Read a variable
result = robot.telnet.get_variable("$MCR.$GENOVERRIDE")
print(f"Speed override: {result.raw_value}%")

# Write a variable
robot.telnet.set_variable("$MCR.$GENOVERRIDE", 50)

# Control programs
robot.telnet.run("MyProgram")
robot.telnet.pause("MyProgram")
robot.telnet.abort("MyProgram", force=True)

# Set a digital output
robot.telnet.set_port(KCLPorts.DOUT, 1, 1)  # DOUT[1] = ON

# Simulate an input for testing
robot.telnet.simulate(KCLPorts.DIN, 3, 1)   # DIN[3] simulated to ON
robot.telnet.unsimulate(KCLPorts.DIN, 3)     # Restore normal operation

# Get task info
info = robot.telnet.get_task_information("MAINPROG")
print(f"Status: {info.task_status_str}, Line: {info.current_line}")

# Read current position
pose = robot.telnet.get_current_pose()
print(f"X={pose.position.x}, Y={pose.position.y}, Z={pose.position.z}")

robot.disconnect()

from underautomation.fanuc.fanuc_robot import FanucRobot
from underautomation.fanuc.connection_parameters import ConnectionParameters
robot = FanucRobot()
params = ConnectionParameters("192.168.0.1")
params.snpx.enable = True
robot.connect(params)

# Read a numeric register
value = robot.snpx.numeric_registers.read(1)
print(f"R[1] = {value}")

# Write a numeric register
robot.snpx.numeric_registers.write(1, 42.5)

# Batch read for maximum speed
batch = robot.snpx.numeric_registers.create_batch_assignment(1, 10)
values = batch.read()  # Reads R[1] through R[10] in one call

# Read/write string registers
text = robot.snpx.string_registers.read(1)
robot.snpx.string_registers.write(1, "Hello Fanuc")

# Read a position register
position = robot.snpx.position_registers.read(1)
print(f"PR[1]: X={position.cartesian_position.x}, Y={position.cartesian_position.y}")

# Digital I/O
sdi_values = robot.snpx.sdi.read(1, 8)     # Read SDI[1..8]
robot.snpx.sdo.write(1, [True, False])      # Write SDO[1]=ON, SDO[2]=OFF

# Current position
pos = robot.snpx.current_position.read_world_position(1)
print(f"X={pos.cartesian_position.x}, Y={pos.cartesian_position.y}")

# Alarms
robot.snpx.clear_alarms()

# System variables
speed = robot.snpx.integer_system_variables.read("$MCR.$GENOVERRIDE")
robot.snpx.set_variable("$MCR.$GENOVERRIDE", "50")

robot.disconnect()

from underautomation.fanuc.kinematics.kinematics_utils import KinematicsUtils
from underautomation.fanuc.common.cartesian_position import CartesianPosition
# Get DH parameters for a specific robot model
dh = DhParameters.from_arm_kinematic_model(ArmKinematicModels.CRX10iA)
print(f"a1={dh.a1}, a2={dh.a2}, a3={dh.a3}, d4={dh.d4}, d5={dh.d5}, d6={dh.d6}")

# Forward kinematics: joint angles (radians) → Cartesian position
joints_rad = [math.radians(j) for j in [0, -30, 45, 0, 60, 0]]
fk = KinematicsUtils.forward_kinematics(joints_rad, dh)
print(f"FK → X={fk.x:.2f}, Y={fk.y:.2f}, Z={fk.z:.2f}, W={fk.w:.2f}, P={fk.p:.2f}, R={fk.r:.2f}")

# Inverse kinematics: Cartesian position → all joint solutions
target = CartesianPosition(fk.x, fk.y, fk.z, fk.w, fk.p, fk.r, None)
solutions = KinematicsUtils.inverse_kinematics(target, dh)
for i, sol in enumerate(solutions, 1):
    print(f"  IK #{i}: J1={sol.j1:.2f}, J2={sol.j2:.2f}, J3={sol.j3:.2f}, "
          f"J4={sol.j4:.2f}, J5={sol.j5:.2f}, J6={sol.j6:.2f}")

from underautomation.fanuc.fanuc_robot import FanucRobot
from underautomation.fanuc.connection_parameters import ConnectionParameters
robot = FanucRobot()
params = ConnectionParameters("192.168.0.1")
params.ftp.enable = True
robot.connect(params)

# File operations
robot.ftp.direct_file_handling.upload_file_to_controller("local.tp", "/md:/remote.tp")
robot.ftp.direct_file_handling.download_file_from_controller("backup.va", "/md:/backup.va")
exists = robot.ftp.direct_file_handling.file_exists("/md:/summary.dg")

# Read registers from variable files
numreg = robot.ftp.known_variable_files.get_numreg_file()
for idx, val in enumerate(numreg.numreg, start=1):
    print(f"R[{idx}] = {val}")

posreg = robot.ftp.known_variable_files.get_posreg_file()
strreg = robot.ftp.known_variable_files.get_strreg_file()

# System variables
system = robot.ftp.known_variable_files.get_system_file()
print(f"Robot: {system.robot_name}, Host: {system.hostname}")

# Current position (all groups, all frames)
position = robot.ftp.get_current_position()
for gp in position.groups_position:
    print(f"J1={gp.joints_position.j1}, J2={gp.joints_position.j2}")

# Safety status
safety = robot.ftp.get_safety_status()
print(f"E-Stop: {safety.external_e_stop}, TP Enable: {safety.tp_enable}")

# Error history
errors = robot.ftp.get_all_errors_list()
for err in errors.filter_active_alarms():
    print(f"[{err.error_code}] {err.message}")

# I/O states (all ports at once)
io = robot.ftp.get_io_state()
for signal in io.states:
    print(f"{signal.port}[{signal.id}] = {'ON' if signal.value else 'OFF'}")

# Complete diagnostic in one call
diag = robot.ftp.get_summary_diagnostic()

robot.disconnect()