Read & write RAPID variables

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");
// 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");
// 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");
    // An array of num arrives as one bracketed text : [1,2.5,3]
    string arrayText = robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/myArray").Value;
    string[] items = SplitRapidValue(arrayText);

    double[] numbers = new double[items.Length];
    for (int i = 0; i < items.Length; i++)
        numbers[i] = double.Parse(items[i], CultureInfo.InvariantCulture);

    // Writing takes the same text back. The whole array is written at once.
    robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/MainModule/myArray", "[1,2.5,3]");
    

    // A record is bracketed too, and its fields can be records themselves.
    // A robtarget is [trans, rot, robconf, extax].
    string targetText = robot.Rws.Rapid.GetSymbolValue("RAPID/T_ROB1/MainModule/pHome").Value;
    string[] fields = SplitRapidValue(targetText);

    string[] trans = SplitRapidValue(fields[0]);   // [515,0,712]
    string[] rot = SplitRapidValue(fields[1]);     // [0.707107,0,0.707107,0]

    RobTarget home = new RobTarget();
    home.X = double.Parse(trans[0], CultureInfo.InvariantCulture);
    home.Y = double.Parse(trans[1], CultureInfo.InvariantCulture);
    home.Z = double.Parse(trans[2], CultureInfo.InvariantCulture);
    home.Orientation = new Quaternion(double.Parse(rot[0], CultureInfo.InvariantCulture),
                                      double.Parse(rot[1], CultureInfo.InvariantCulture),
                                      double.Parse(rot[2], CultureInfo.InvariantCulture),
                                      double.Parse(rot[3], CultureInfo.InvariantCulture));

    Console.WriteLine($"pHome is at X={home.X} Y={home.Y} Z={home.Z}");

    // Writing the record back : move it 10 mm up and rebuild the text.
    // The two last fields are kept as they were read.
    home.Z += 10;
    string newValue = "[" + FormatTrans(home) + "," + FormatRot(home) + "," + fields[2] + "," + fields[3] + "]";

    // Ask the controller whether it accepts the text before writing it
    if (robot.Rws.Rapid.ValidateSymbolValue("T_ROB1", "robtarget", newValue))
        robot.Rws.Rapid.SetSymbolValue("RAPID/T_ROB1/MainModule/pHome", newValue);
    

// Splits the top level of a RAPID value : "[[1,2],3]" gives "[1,2]" and "3".
// A value that is not bracketed is returned as a single element.
static string[] SplitRapidValue(string value)
{
    string text = value == null ? "" : value.Trim();

    if (!text.StartsWith("[") || !text.EndsWith("]"))
        return new string[] { text };

    text = text.Substring(1, text.Length - 2);

    List<string> parts = new List<string>();
    StringBuilder current = new StringBuilder();
    int depth = 0;
    bool inString = false;

    foreach (char c in text)
    {
        if (c == '"') inString = !inString;

        if (!inString && c == '[') depth++;
        if (!inString && c == ']') depth--;

        if (!inString && c == ',' && depth == 0)
        {
            parts.Add(current.ToString().Trim());
            current.Length = 0;
        }
        else
        {
            current.Append(c);
        }
    }

    if (current.Length > 0)
        parts.Add(current.ToString().Trim());

    return parts.ToArray();
}

// RAPID always writes numbers with a dot, so does the invariant culture
static string Number(double value)
{
    return value.ToString(CultureInfo.InvariantCulture);
}

static string FormatTrans(RobTarget target)
{
    return "[" + Number(target.X) + "," + Number(target.Y) + "," + Number(target.Z) + "]";
}

static string FormatRot(RobTarget target)
{
    Quaternion q = target.Orientation;
    return "[" + Number(q.Q1) + "," + Number(q.Q2) + "," + Number(q.Q3) + "," + Number(q.Q4) + "]";
}
}

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();
}