Fanuc communication SDK

<?xml version="1.0"?>
<PASSWORD>
  <PWD level="0" const="1" access="1"/>
</PASSWORD>

using UnderAutomation.Fanuc;

var robot = new FanucRobot();

var parameters = new ConnectionParameters();
parameters.Address = "192.168.0.1";
parameters.RemoteCommands.Enable = true;
parameters.RemoteCommands.TelnetKclPassword = "telnet pass";

parameters.MemoryAccess.Enable = true;
parameters.MemoryAccess.FtpUser = "ftp username";
parameters.MemoryAccess.FtpPassword = "ftp password";

// Connect to the robot with previous parameters
var robot = new FanucRobot();
robot.Connect(parameters);

parameters.Address = @"C:\path to the robot directory";

/// Enables servo power after an error condition has shut off servo power, provided the cause of the error has been cleared.
/// The command also clears the message line on the CRT/KB display. The error message remains displayed if the error condition still exists.
/// The Reset() command has no effect on a program that is being executed. It has the same effect as the FAULT RESET button on the operator panel and the RESET function key on the teach pendant RESET screen.
robot.RemoteCommands.Reset();

/// Assigns the specified value to the specified variable. You can assign constant values or variable values, but the value must be of the data type that has been declared for the variable.
/// You can assign values to system variables with KCL write access, to program variables, or to standard and user-defined variables and fields. You can assign only one ARRAY element.
/// Use brackets ([]) after the variable name to specify an element.
/// Certain data types like positions and vectors might have more than one value specified.
robot.RemoteCommands.SetVariable("VariableName", NewValue);

public enum KCLPorts {
    DIN,
    DOUT,
    RDO,
    OPOUT,
    TPOUT,
    WDI,
    WDO,
    AIN,
    AOUT,
    GIN,
    GOUT
}

/// Assigns the specified value to a specified input or output port. SET PORT can be used  either physical Or simulated output ports, but only With simulated input ports.
robot.RemoteCommands.SetPort(KCLPorts.DOUT, 2, 0);

/// Simulating I/O allows you to test a program that uses I/O. Simulating I/O does not actually send output signals or receive input signals.
/// When simulating a port value, you can specify its initial simulated value or allow the initial value to be the same as the physical port value. If no value is specified, the current physical port value is used. 
robot.RemoteCommands.Simulate(KCLPorts.DIN, 3, 1);
robot.RemoteCommands.Unsimulate(KCLPorts.DIN, 3);
robot.RemoteCommands.UnsimulateAll();

// BTW, you can use the SDK to write these values, for example just after your app has connected to the robot
robot.RemoteCommands.SetVariable("$REMOTE_CFG.$REMOTE_TYPE", 1);
robot.RemoteCommands.SetVariable("$RMT_MASTER", 1);

/// Executes the specified program (TP or Karel). The program must be loaded in memory
/// If no program is specified the default program is run. If uninitialized variables are encountered, program execution is paused.
/// Execution begins at the first executable line.
/// RUN is a motion command; therefore, the device from which it is issued must have motion control. If a RUN command is issued in a command file, it is executed as a NOWAIT command.
/// Therefore, the statement following the RUN command will be executed immediately after the RUN command is issued without waiting for the program, specified by the RUN command, to end.
robot.RemoteCommands.Run("MyPrg");

/// Aborts the specified running or paused task. If prog_ name is not specified, the default program Is used.
/// Execution of the current program statement Is completed before the task aborts except for the current motion, DELAY, WAIT, Or READ statements, which are canceled.
robot.RemoteCommands.Abort("MyPrg", force: true);
robot.RemoteCommands.AbortAll(force: true);

/// Pauses the specified running task. If program is not specified, the default program is used.
/// Execution of the current motion segment and the current program statement is completed before the task is paused.
/// Condition handlers remain active. If the condition handler action is NOPAUSE and the condition is satisfied, task execution resumes.
/// If the statement is a WAIT FOR and the wait condition is satisfied while the task is paused, the statement following the WAIT FOR is executed immediately when the task is resumed.
/// If the statement is a DELAY, timing will continue while the task is paused.
/// If the delay time is finished while the task is paused, the statement following the DELAY is immediately executed when the task is resumed.
/// If the statement is a READ, it will accept input even though the task is paused.
/// The Continue() command resumes execution of a paused task.
/// When a task is paused, the CYCLE START button on the operator panel has the same effect as the KCL> CONTINUE command.
robot.RemoteCommands.Pause(cbPrograms.Text, force: true);

/// Pauses the specified or default program that is being executed and holds motion at the current position (after a normal deceleration).
/// Use the Continue() command Or the CYCLE START button On the Operator panel To resume program execution.
robot.RemoteCommands.Hold("MyPrg");

/// Continues program execution of the specified task (or all paused tasks if program argument is null) that has been paused by a hold, pause, or test run operation.
/// If the program Is aborted, the program execution Is started at the first executable line.
/// When a task Is paused, the CYCLE START button on the operator panel has the same effect as the Continue() command.
/// Continue is a motion command; therefore, the device from which it Is issued must have motion control.
robot.RemoteCommands.Continue("MyPrg");

/// Clears the program data from memory for the specified or default program.
robot.RemoteCommands.ClearProgram("MyPrg"); 

/// Clears the variable and type data associated with the specified or default program from memory.
/// Variables And types that are referenced by a loaded program are Not cleared.
robot.RemoteCommands.ClearVars("MyPrg");

robot.MemoryAccess.DirectFileHandling.DownloadFileFromController(@"C:\temp\MyPrg.tp", "md:/MyPrg.tp);
robot.MemoryAccess.DirectFileHandling.UploadFileToController(@"C:\temp\MyPrg.tp", "md:/MyPrg.tp);
robot.MemoryAccess.DirectFileHandling.DeleteFile("md:/MyPrg.tp");

robot.MemoryAccess.DirectFileHandling.CreateDirectory("md:/NewDirectory");
robot.MemoryAccess.DirectFileHandling.DeleteDirectory("md:/NewDirectory");

// Enumerates variables files
FtpListItem[] VariablesFiles = robot.MemoryAccess.EnumerateVariableFiles();

// Get all variables declared in the controller
var allVariables = robot.MemoryAccess.GetAllVariables();

// Get all variables declared in one specific file
var variables = robot.MemoryAccess.GetVariablesFromFile("myFile.va");

// For known variables, you can access it directly.
// Example with $RMT_MASTER :
int RmtMaster = robot.MemoryAccess.KnownVariableFiles.GetSystemFile().RmtMaster;

// Example with CellGrp
CartesianPositionVariable cellFrame = robot.MemoryAccess.KnownVariableFiles.GetSysframeFile().CellGrp[0].CellFrame;
// cellFrame.X => 0.2
// cellFrame.Y => -0.1
// cellFrame.Z => 0
// cellFrame.Configuration.ArmFront => Back
// cellFrame.Configuration.WristFlip => NoFlip

SafetyStatus safetyStatus = robot.MemoryAccess.GetSafetyStatus();

public class SafetyStatus
{
    /// External emergency stop active
    public bool ExternalEStop { get; internal set; }

    /// Emergency stop active by SOP signal
    public bool SOPEStop { get; internal set; }

    /// Emergency stop active on teach peandant
    public bool TPEStop { get; internal set; }
    public bool HandBroken { get; internal set; }
    public bool OverTravel { get; internal set; }
    public bool LowAirAlarm { get; internal set; }
    public bool FenceOpen { get; internal set; }
    public bool BeltBroken { get; internal set; }

    /// Teach pendant is enabled
    public bool TPEnable { get; internal set; }

    /// The deadman switch of the teach pendant is active
    public bool TPDeadman { get; internal set; }
    public bool SVOFFDetect { get; internal set; }
    public bool NonTeacherEnb { get; internal set; }
}

IOState ioState = robot.MemoryAccess.GetIOState();

CurrentPosition currentPosition = robot.MemoryAccess.GetCurrentPosition();

// Example :

Position register1 = robot.Snpx.PositionRegisters.Read(1);

bool UI1 = robot.Snpx.UI.Read(1);

FanucRobot.RegisterLicense("licensee name", "Secret key provided by UnderAutomation");