Read and write system variables ($RMT_MASTER, $MCR.$GENOVERRIDE, etc.) on your Fanuc robot using different protocols.

## SNPX (fastest : ~2 ms)

SNPX supports 4 typed variable categories: integer, real, position, and string.

**C# : SnpxVariables**
```csharp
using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Common;

public class SnpxVariables
{
  public static void Main()
  {
    FanucRobot robot = new FanucRobot();

    ConnectionParameters parameters = new ConnectionParameters("192.168.0.1");
    parameters.Snpx.Enable = true;

    robot.Connect(parameters);

    /**/
    // --- Integer system variables ---
    int rmtMaster = robot.Snpx.IntegerSystemVariables.Read("$RMT_MASTER");
    robot.Snpx.IntegerSystemVariables.Write("$RMT_MASTER", 1);

    // --- Real (float) system variables ---
    float genOverride = robot.Snpx.RealSystemVariables.Read("$MCR.$GENOVERRIDE");
    robot.Snpx.RealSystemVariables.Write("$MCR.$GENOVERRIDE", 50.0f);

    // --- Position system variables ---
    Position cellFloor = robot.Snpx.PositionSystemVariables.Read("$CELL_FLOOR");
    robot.Snpx.PositionSystemVariables.Write("$CELL_FLOOR", cellFloor);

    // --- String system variables ---
    string lastAlm = robot.Snpx.StringSystemVariables.Read("$ALM_IF.$LAST_ALM");
    robot.Snpx.StringSystemVariables.Write("$ALM_IF.$LAST_ALM", "No alarms");

    // --- Karel program variables ---
    int karelVar = robot.Snpx.IntegerSystemVariables.Read("$[MyKarelProg]my_variable");
    robot.Snpx.IntegerSystemVariables.Write("$[MyKarelProg]my_variable", 42);

    // --- Set variable (auto-detects type) ---
    robot.Snpx.SetVariable("$RMT_MASTER", 1);
    /**/
  }
}
```

**Python : SnpxVariables**
```python
from underautomation.fanuc.fanuc_robot import FanucRobot
from underautomation.fanuc.connection_parameters import ConnectionParameters

# Create a robot instance
robot = FanucRobot()

# Configure connection parameters
parameters = ConnectionParameters("192.168.0.1")
parameters.snpx.enable = True

# Connect to the robot
robot.connect(parameters)

##
# --- Integer system variables ---
rmt_master = robot.snpx.integer_system_variables.read("$RMT_MASTER")
robot.snpx.integer_system_variables.write("$RMT_MASTER", 1)

# --- Real (float) system variables ---
gen_override = robot.snpx.real_system_variables.read("$MCR.$GENOVERRIDE")
robot.snpx.real_system_variables.write("$MCR.$GENOVERRIDE", 50.0)

# --- Position system variables ---
cell_floor = robot.snpx.position_system_variables.read("$CELL_FLOOR")
robot.snpx.position_system_variables.write("$CELL_FLOOR", cell_floor)

# --- String system variables ---
last_alm = robot.snpx.string_system_variables.read("$ALM_IF.$LAST_ALM")
robot.snpx.string_system_variables.write("$ALM_IF.$LAST_ALM", "No alarms")

# --- Karel program variables ---
karel_var = robot.snpx.integer_system_variables.read("$[MyKarelProg]my_variable")
robot.snpx.integer_system_variables.write("$[MyKarelProg]my_variable", 42)

# --- Set variable (auto-detects type) ---
robot.snpx.set_variable("$RMT_MASTER", 1)
##
```

See also: [SNPX System variables](/fanuc/documentation/snpx-variables)

## Telnet KCL

Telnet reads and writes any variable using KCL commands:

**C# : ReadWriteSystemVariablesTelnet**
```csharp
using UnderAutomation.Fanuc;

public class ReadWriteSystemVariablesTelnet
{
    static void Main()
    {
        FanucRobot robot = new FanucRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Read a variable
        var result = robot.Telnet.GetVariable("$RMT_MASTER");
        string value = result.RawValue;

        // Write a variable
        robot.Telnet.SetVariable("$RMT_MASTER", "1");
        robot.Telnet.SetVariable("$MCR.$GENOVERRIDE", "50");
        /**/
    }
}
```

**Python : ReadWriteSystemVariablesTelnet**
```python
from underautomation.fanuc.fanuc_robot import FanucRobot

robot = FanucRobot()
robot.connect("192.168.0.1")

##
# Read a variable
value = robot.telnet.get_variable("$RMT_MASTER")

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

See also: [Telnet Variables & I/O](/fanuc/documentation/telnet-variables-io)

## CGTP Web Server

CGTP provides typed variable reading and string-based writing:

**C# : ReadWriteSystemVariablesCgtp**
```csharp
using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Cgtp;

public class ReadWriteSystemVariablesCgtp
{
    static void Main()
    {
        FanucRobot robot = new FanucRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Read with automatic type detection
        CgtpVariableValue var = robot.Cgtp.ReadVariable("$RMT_MASTER");
        int intVal = var.IntegerValue;

        // Write
        robot.Cgtp.WriteVariable("$RMT_MASTER", 1);
        robot.Cgtp.WriteVariable("$MCR.$GENOVERRIDE", 50.0);

        // Read and decode system.va
        SystemFile system = robot.Cgtp.Http.KnownVariableFiles.GetSystemFile();
        int rmtMaster = system.RmtMaster;

        // get all variables with their value and types
        VariableFileList filelist = robot.Cgtp.Http.GetAllVariables();
        /**/
    }
}
```

**Python : ReadWriteSystemVariablesCgtp**
```python
from underautomation.fanuc.fanuc_robot import FanucRobot
from underautomation.fanuc.connection_parameters import ConnectionParameters

robot = FanucRobot()
parameters = ConnectionParameters("192.168.0.1")
parameters.cgtp.enable = True
robot.connect(parameters)

##
# Read with automatic type detection
var = robot.cgtp.read_variable("$RMT_MASTER")
int_val = var.integer_value

# Write
robot.cgtp.write_variable("$RMT_MASTER", 1)
robot.cgtp.write_variable("$MCR.$GENOVERRIDE", 50.0)

# Read and decode system.va
system = robot.cgtp.http.known_variable_files.get_system_file()
rmt_master = system.rmt_master

# get all variables with their value and types
filelist = robot.cgtp.http.get_all_variables()
##
```

See also: [CGTP Registers & variables](/fanuc/documentation/cgtp-registers-variables)

## FTP (offline parsing)

Download variable files and parse them offline:

**C# : ReadWriteSystemVariablesFtp**
```csharp
using System;
using UnderAutomation.Fanuc;
using UnderAutomation.Fanuc.Common;

public class ReadWriteSystemVariablesFtp
{
    static void Main()
    {
        FanucRobot robot = new FanucRobot();
        robot.Connect("192.168.0.1");

        /**/
        // Read and decode system.va
        SystemFile system = robot.Ftp.KnownVariableFiles.GetSystemFile();
        int rmtMaster = system.RmtMaster;

        // get all variables with their value and types
        VariableFileList filelist = robot.Ftp.GetAllVariables();
        /**/
    }
}
```

**Python : ReadWriteSystemVariablesFtp**
```python
from underautomation.fanuc.common import FanucFileReaders

robot = FanucRobot()
parameters = ConnectionParameters("192.168.0.1")
parameters.ftp.enable = True
parameters.ftp.ftp_user = ""
parameters.ftp.ftp_password = ""
robot.connect(parameters)

##
# Read and decode system.va
system = robot.ftp.known_variable_files.get_system_file()
rmt_master = system.rmt_master

# get all variables with their value and types
filelist = robot.ftp.get_all_variables()
##
```

See also: [Offline file parsing](/fanuc/documentation/offline-file-parsing)

## Protocol comparison

| Feature | SNPX | Telnet | CGTP | FTP |
|---------|------|--------|------|-----|
| **Speed** | ~2 ms | ~30 ms | ~50 ms | ~100 ms |
| **Typed read** | Yes (4 types) | No (string) | Yes (auto-detect) | Yes (file parse) |
| **Write** | Yes | Yes | Yes | No |
| **Batch read** | Yes | No | Yes | Yes (all at once) |
| **Karel variables** | Yes | Yes | Yes | No |
| **Batch read all variables** | No | No | Yes | Yes |