Fanuc SDK documentation

Reading & Writing Registers

Reminder about FANUC Registers

📚 Overview

FANUC robots use registers to store numeric, positional, and string values essential for calculations, conditions, and data management in robot programs. There are three main types of registers:

Numeric Registers (R[] or N[]) – Store integer or floating-point numbers. 🔢
Position Registers (PR[]) – Store positional data for robot movements. 📍
String Registers (SR[]) – Store text and alphanumeric characters. 🔤

🛠 Accessing Registers

You can access registers directly through the Teach Pendant (TP) or programmatically using TP and KAREL programming:

Teach Pendant:
- Navigate via DATA → REGISTER.
- Select the desired register type (Numeric, Position, or String).
- Manually modify values.
TP Programming:
- Numeric registers: R[n]
- Position registers: PR[n]
- String registers: SR[n]

✨ Numeric Registers Example

R[1] = 100                  ; Set register 1 to 100
R[2] = R[1] + 50            ; Add 50 to R[1], store in R[2]
IF R[2] > 120, JMP LBL[10]  ; Jump conditionally if R[2] > 120

📌 Position Registers Example

PR[1] = LPOS                 ; Save current position into PR[1]
L PR[2] 100mm/sec FINE       ; Move robot to position stored in PR[2]

💬 String Registers Example

SR[1] = 'Hello, World!'      ; Save a greeting message

✅ Best Practices

Always comment your code clearly!
Initialize registers to avoid unexpected behaviors.
Use indirect addressing for dynamic register management (R[R[10]] = 5).

📂 Bulk Reading of Registers via FTP

The SDK provides quick FTP access to POSREG.VA, NUMREG.VA, and STRREG.VA files, including parsers that conveniently convert file data into easily usable objects. 🛎️

The following methods allows you to read registers in bulk:

robot.Ftp.KnownVariableFiles.GetNumregFile() for numeric registers
robot.Ftp.KnownVariableFiles.GetPosregFile() for position registers
robot.Ftp.KnownVariableFiles.GetStrregFile() for string registers

using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Ftp.Variables;
using System;

public class FtpRegisters
{
    public static void Main()
    {
        // Create a FanucRobot instance
        FanucRobot robot = new FanucRobot();

        // Set connection parameters (example values)
        ConnectionParameters parameters = new ConnectionParameters("192.168.0.1");
        parameters.Ftp.Enable = true;
        parameters.Ftp.FtpUser = "user";
        parameters.Ftp.FtpPassword = "ftp password";

        // Connect to the robot with FTP enabled
        robot.Connect(parameters);

        // 1) Reading Numeric Registers
        ReadNumericRegisters(robot);

        // 2) Reading Position Registers
        ReadPositionRegisters(robot);

        // 3) Reading String Registers
        ReadStringRegisters(robot);
    }

    private static void ReadNumericRegisters(FanucRobot robot)
    {
        NumregFile numregFile = robot.Ftp.KnownVariableFiles.GetNumregFile();
        
        for (int i = 0; i < numregFile.Numreg.Length; i++)
        {
            double value = numregFile.Numreg[i];
            Console.WriteLine($"📊 Numeric R[{i}] = {value}");
        }
    }

    private static void ReadPositionRegisters(FanucRobot robot)
    {
        PosregFile posregFile = robot.Ftp.KnownVariableFiles.GetPosregFile();

        // posregFile.Posreg is a 3D array: dimension [1] = group, [2] = register index
        for (int group = 0; group < posregFile.Posreg.GetLength(1); group++)
        {
            Console.WriteLine($"\n🤖 Reading position registers for Group {group}:");

            for (int i = 0; i < posregFile.Posreg.GetLength(2); i++)
            {
                CartesianPositionVariable value = posregFile.Posreg[group, i];
                Console.WriteLine($" - PR[{i}] :");
                Console.WriteLine($"    X = {value.X}");
                Console.WriteLine($"    Y = {value.Y}");
                Console.WriteLine($"    Z = {value.Z}");
                Console.WriteLine($"    W = {value.W}");
                Console.WriteLine($"    P = {value.P}");
                Console.WriteLine($"    R = {value.R}");
                Console.WriteLine("    Configuration :");
                Console.WriteLine($"       ArmFrontBack = {value.Configuration.ArmFrontBack}");
                Console.WriteLine($"       ArmLeftRight = {value.Configuration.ArmLeftRight}");
                Console.WriteLine($"       ArmUpDown = {value.Configuration.ArmUpDown}");
                Console.WriteLine($"       WristFlip = {value.Configuration.WristFlip}");
            }
        }
    }

    private static void ReadStringRegisters(FanucRobot robot)
    {
        StrregFile strregFile = robot.Ftp.KnownVariableFiles.GetStrregFile();
        
        for (int i = 0; i < strregFile.Strreg.Length; i++)
        {
            string value = strregFile.Strreg[i];
            Console.WriteLine($"💬 String SR[{i}] = '{value}'");
        }
    }
}

🔄 Reading and Writing Registers via SNPX

If SNPX is available on your FANUC robot, it provides a very fast way to read and write registers one by one.

🎯 Important: SNPX is currently the only protocol supporting writing operations, notably allowing position registers to be defined in Cartesian or Joint coordinates.

You can use the following methods to read and write the ith register:

Numeric Registers
- Read: robot.Snpx.NumericRegisters.Read(i)
- Write: robot.Snpx.NumericRegisters.Write(i, value)
Position Registers
- Read: robot.Snpx.PositionRegisters.Read(i)
- Write in Cartesian format:
  robot.Snpx.PositionRegisters.Write(i, new CartesianPosition(x, y, z, w, p, r))
- Write in Joint format:
  robot.Snpx.PositionRegisters.Write(i, new JointsPosition() { J1 = ..., J2 = ..., J3 = ..., J4 = ..., J5 = ..., J6 = ... })
String Registers
- Read: robot.Snpx.StringRegisters.Read(i)
- Write: robot.Snpx.StringRegisters.Write(i, "Your String Here")

using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Common;
using System;

public class SnpxRegisters
{
    public static void Main()
    {
        // Create a FanucRobot instance
        FanucRobot robot = new FanucRobot();

        // Set SNPX connection parameters (example values)
        ConnectionParameters parameters = new ConnectionParameters("192.168.0.1");
        parameters.Snpx.Enable = true;

        // Connect with SNPX enabled
        robot.Connect(parameters);

        // 1) Numeric Registers: Read & Write
        ReadWriteNumericRegisters(robot);

        // 2) Position Registers: Read & Write
        ReadWritePositionRegisters(robot);

        // 3) String Registers: Read & Write
        ReadWriteStringRegisters(robot);
    }

    private static void ReadWriteNumericRegisters(FanucRobot robot)
    {
        // Read numeric register R[1]
        float numReg1 = robot.Snpx.NumericRegisters.Read(1);
        Console.WriteLine($"📊 R[1] = {numReg1}");

        // Write numeric register R[1]
        robot.Snpx.NumericRegisters.Write(1, 123.45f);
        Console.WriteLine("✅ Wrote 123.45 to R[1]");
    }

    private static void ReadWritePositionRegisters(FanucRobot robot)
    {
        // Read position register PR[1]
        Position posReg1 = robot.Snpx.PositionRegisters.Read(1);
        Console.WriteLine("\n🤖 Current PR[1]:");
        Console.WriteLine($"   UserFrame = {posReg1.UserFrame}");
        Console.WriteLine($"   UserTool = {posReg1.UserTool}");

        // If the register is Cartesian
        if (posReg1.CartesianPosition != null)
        {
            Console.WriteLine("   CartesianPosition:");
            Console.WriteLine($"      X = {posReg1.CartesianPosition.X}");
            Console.WriteLine($"      Y = {posReg1.CartesianPosition.Y}");
            Console.WriteLine($"      Z = {posReg1.CartesianPosition.Z}");
            Console.WriteLine($"      W = {posReg1.CartesianPosition.W}");
            Console.WriteLine($"      P = {posReg1.CartesianPosition.P}");
            Console.WriteLine($"      R = {posReg1.CartesianPosition.R}");
            Console.WriteLine("      Configuration :");
            Console.WriteLine($"         ArmFrontBack = {posReg1.CartesianPosition.Configuration.ArmFrontBack}");
            Console.WriteLine($"         ArmLeftRight = {posReg1.CartesianPosition.Configuration.ArmLeftRight}");
            Console.WriteLine($"         ArmUpDown = {posReg1.CartesianPosition.Configuration.ArmUpDown}");
            Console.WriteLine($"         WristFlip = {posReg1.CartesianPosition.Configuration.WristFlip}");
        }

        // If the register is Joint-based
        if (posReg1.JointsPosition != null)
        {
            Console.WriteLine("   JointsPosition:");
            Console.WriteLine($"      J1 = {posReg1.JointsPosition.J1}");
            Console.WriteLine($"      J2 = {posReg1.JointsPosition.J2}");
            Console.WriteLine($"      J3 = {posReg1.JointsPosition.J3}");
            Console.WriteLine($"      J4 = {posReg1.JointsPosition.J4}");
            Console.WriteLine($"      J5 = {posReg1.JointsPosition.J5}");
            Console.WriteLine($"      J6 = {posReg1.JointsPosition.J6}");
        }

        // Write a Cartesian position to PR[1]
        Console.WriteLine("\n✅ Writing Cartesian position to PR[1]...");
        robot.Snpx.PositionRegisters.Write(1, new CartesianPosition(x: 0.1f, y: 0.2f, z: 0.3f, w: 0.4f, p: 0.5f, r: 0.6f));

        // Write a Joint position to PR[1]
        Console.WriteLine("✅ Writing Joint position to PR[1]...");
        robot.Snpx.PositionRegisters.Write(1, new JointsPosition { J1 = 0, J2 = 0, J3 = 0, J4 = 0, J5 = 0, J6 = 45 });
    }

    private static void ReadWriteStringRegisters(FanucRobot robot)
    {
        // Read string register SR[1]
        string strReg1 = robot.Snpx.StringRegisters.Read(1);
        Console.WriteLine($"\n💬 SR[1] = '{strReg1}'");

        // Write string register SR[1]
        robot.Snpx.StringRegisters.Write(1, "Hello, Robot!");
        Console.WriteLine("✅ Wrote 'Hello, Robot!' to SR[1]");
    }
}

🧩 Classes to Know

Get familiar with these handy classes for easy integration:

Members of Common.Position :

public class Position {
     public Position()
     public ExtendedCartesianPosition CartesianPosition { get; set; }
     public JointsPosition JointsPosition { get; set; }
     public short UserFrame { get; set; }
     public short UserTool { get; set; }
}

Members of Common.JointsPosition :

public class JointsPosition {
     public JointsPosition()
 
    // Joint 1 in degrees
    public double J1 { get; set; }
 
    // Joint 2 in degrees
    public double J2 { get; set; }
 
    // Joint 3 in degrees
    public double J3 { get; set; }
 
    // Joint 4 in degrees
    public double J4 { get; set; }
 
    // Joint 5 in degrees
    public double J5 { get; set; }
 
    // Joint 6 in degrees
    public double J6 { get; set; }
 
    // Joint 7 in degrees
    public double J7 { get; set; }
 
    // Joint 8 in degrees
    public double J8 { get; set; }
 
    // Joint 9 in degrees
    public double J9 { get; set; }
     public override string ToString()
 
    // Numeric values for each joints
    public double[] Values { get; }
}

Members of Common.ExtendedCartesianPosition :

public class ExtendedCartesianPosition : CartesianPosition {
     public ExtendedCartesianPosition()
     public double E1 { get; set; }
     public double E2 { get; set; }
     public double E3 { get; set; }
     public short T4 { get; set; }
     public short T5 { get; set; }
     public short T6 { get; set; }
}

Members of Common.CartesianPosition :

public class CartesianPosition : XYZPosition {
     public CartesianPosition()
 
    // Position configuration
    public Configuration Configuration { get; }
 
    // P rotation in degrees
    public double P { get; set; }
 
    // R rotation in degrees
    public double R { get; set; }
 
    // W rotation in degrees
    public double W { get; set; }
}

Members of Common.XYZPosition :

public class XYZPosition {
     public XYZPosition()
 
    // X coordinate in meters
    public double X { get; set; }
 
    // Y coordinate in meters
    public double Y { get; set; }
 
    // Z coordinate in meters
    public double Z { get; set; }
}

SNPX

Documentation home

TP editor with breakpoints

Any question?