RAPID variables & symbols

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A variable declared in the module MainModule of the task T_ROB1
robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/myCounter");

// reg1 and the other predefined registers live in the built-in module "user"
robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/user/reg1");

// A leading slash is accepted, it is removed by the SDK
robot.Rws.Rapid.GetSymbolValue("/RAPID/T_ROB1/user/reg1");

// A module of the task, and the task itself, are symbols too
robot.Rws.Rapid.GetSymbolProperties("RAPID/T_ROB1/MainModule");
robot.Rws.Rapid.GetSymbolProperties("RAPID/T_ROB1");

// A RAPID type has a path of its own, without any task
robot.Rws.Rapid.GetSymbolProperties("RAPID/robtarget");
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A value always comes back as the text RAPID writes it with. Reading needs no mastership.
RapidSymbolValue value = robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/user/reg1");
Console.WriteLine(value.Value);                  // "42"
Console.WriteLine(value.DeclarationPosition);    // where the declaration sits in the module

// num and dnum: parse with the invariant culture, RAPID uses a dot as decimal separator
double number = double.Parse(robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/user/reg1").Value,
                             CultureInfo.InvariantCulture);

// bool: the controller writes TRUE or FALSE
bool flag = robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/myFlag")
                           .Value.Trim().Equals("TRUE", StringComparison.OrdinalIgnoreCase);

// string: the value carries the RAPID quotes, remove them
string text = robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/myText").Value.Trim('"');

Console.WriteLine(number + " " + flag + " " + text);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Writing needs the RAPID mastership. Take it, write, give it back.
robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // num: format with the invariant culture, "1,5" is refused, "1.5" is accepted
    double speed = 1.5;
    robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/user/reg1",
                                   speed.ToString(CultureInfo.InvariantCulture));

    // bool: TRUE or FALSE, in capitals
    robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/MainModule/myFlag", "TRUE");

    // string: the RAPID quotes are part of the value
    robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/MainModule/myText", "\"hello\"");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A record comes back in the bracketed form RAPID writes it with. The SDK does not
// take it apart, you get the text and parse what you need.
RapidSymbolValue target = robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/pHome");
Console.WriteLine(target.Value);
// [[515,0,712],[0,0,1,0],[0,0,0,0],[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]]

// An array is one value too, its elements separated by commas
Console.WriteLine(robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/myArray").Value);  // [1,2,3]

// Build the text with the invariant culture, a comma as decimal separator is refused
double x = 515.5, y = 0, z = 712;
string pose = string.Format(CultureInfo.InvariantCulture,
                            "[[{0},{1},{2}],[0,0,1,0],[0,0,0,0],[9E9,9E9,9E9,9E9,9E9,9E9]]",
                            x, y, z);

robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    // The value has to carry every component the type declares
    robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/MainModule/pHome", pose);
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Ask the controller whether it would take the value, without writing it anywhere
Console.WriteLine(robot.Rws.Rapid.ValidateSymbolValue("T_ROB1", "num", "1.5"));      // true

// A value that does not fit the type gives false, it does not throw
Console.WriteLine(robot.Rws.Rapid.ValidateSymbolValue("T_ROB1", "num", "hello"));    // false

robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    if (robot.Rws.Rapid.ValidateSymbolValue("T_ROB1", "num", "1.5"))
        robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/user/reg1", "1.5");

    // The value written in the declaration, the one the symbol goes back to when the
    // program is reset. This rewrites the source of the module.
    robot.Rws.Rapid.SetSymbolInitialValue("RAPID/T_ROB1/MainModule/myCounter", "0");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Always give a starting point, a search without any criterion walks the whole system
RapidSymbolSearchCriteria criteria = new RapidSymbolSearchCriteria();
criteria.View = RapidSymbolSearchView.Block;
criteria.BlockUrl = "RAPID/T_ROB1";
criteria.Recursive = true;
criteria.NamePattern = "^p[0-9]+$";        // regular expression on the name
criteria.DataType = "robtarget";

// Only the first entry is sent, search again for another kind
criteria.SymbolTypes = new RapidSymbolType[] { RapidSymbolType.Persistent };

foreach (RapidSymbolProperties symbol in robot.Rws.Rapid.SearchSymbols(criteria))
{
    Console.WriteLine(symbol.Name + " (" + symbol.DataType + ")");

    // SymbolUrl is the path the other symbol methods take
    Console.WriteLine(robot.Rws.Rapid.GetSymbolValue(symbol.SymbolUrl).Value);
}

// What one symbol is declared as, without reading its value
RapidSymbolProperties properties = robot.Rws.Rapid.GetSymbolProperties("RAPID/T_ROB1/user/reg1");
Console.WriteLine(properties.SymbolType);   // Variable, Persistent, Constant, ...
Console.WriteLine(properties.DataType);     // num
Console.WriteLine(properties.ReadOnly);     // null when the controller did not report it
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A persistent declared in several tasks holds the same value everywhere, as long as
// the module is synchronized with the other tasks declaring it
Console.WriteLine(robot.Rws.Rapid.GetSyncPersStatus("T_ROB1", "MainModule"));

robot.Rws.Mastership.Request(MastershipDomain.Rapid);
try
{
    robot.Rws.Rapid.SyncPersistentVariables("T_ROB1", "MainModule");
}
finally
{
    robot.Rws.Mastership.Release(MastershipDomain.Rapid);
}
robot.Disconnect();
}