I/O signals, devices & networks

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A signal is identified by its network, its device and its name
IoSignalItem signal = robot.Rws.Io.GetSignal("Local", "Board10", "DO_Gripper");

Console.WriteLine(signal.Path);          // Local/Board10/DO_Gripper
Console.WriteLine(signal.Type);          // DigitalOutput
Console.WriteLine(signal.LogicalValue);  // 1
Console.WriteLine(signal.LogicalState);  // NotSimulated
Console.WriteLine(signal.PhysicalValue); // 1
Console.WriteLine(signal.PhysicalState); // Valid


// Every signal of the controller, in one call
IoSignalItem[] signals = robot.Rws.Io.GetSignals();

foreach (IoSignalItem item in signals)
{
    Console.WriteLine($"{item.Path} = {item.LogicalValue} ({item.Type})");
}
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// A digital signal takes 0 or 1
robot.Rws.Io.SetSignalValue("Local", "Board10", "DO_Gripper", 1);

// An analog or a group signal takes any value inside its range
robot.Rws.Io.SetSignalValue("Local", "Board10", "AO_Speed", 12.5f);

// The last argument writes the change in the event log of the controller
robot.Rws.Io.SetSignalValue("Local", "Board10", "DO_Gripper", 0, true);

// The controller applies the value 500 ms later, and answers immediately
robot.Rws.Io.SetSignalValueDelayed("Local", "Board10", "DO_Gripper", 1, 500);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Three pulses to 1, 200 ms active and 200 ms passive
robot.Rws.Io.PulseSignal("Local", "Board10", "DO_Gripper", 1, 3, 200, 200);

// Same, with the pulse lengths configured on the controller
robot.Rws.Io.PulseSignal("Local", "Board10", "DO_Gripper", 1, 1);

// Toggle pulses the signal by starting from the opposite of its current value
robot.Rws.Io.ToggleSignal("Local", "Board10", "DO_Gripper", 1, 2, 200, 200);

// Invert writes the opposite of the current value, once
robot.Rws.Io.InvertSignal("Local", "Board10", "DO_Gripper", 1);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Simulate an input: it keeps the value written by the client
robot.Rws.Io.SetSignalState("Local", "Board10", "DI_PartPresent", true);
robot.Rws.Io.SetSignalValue("Local", "Board10", "DI_PartPresent", 1);

IoSignalItem signal = robot.Rws.Io.GetSignal("Local", "Board10", "DI_PartPresent");
Console.WriteLine(signal.LogicalState); // Simulated

// Give the signal back to its device
robot.Rws.Io.SetSignalState("Local", "Board10", "DI_PartPresent", false);

// Or stop simulating every simulated signal of the controller at once
robot.Rws.Io.UnblockSignals();
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Every digital output of one device
IoSignalSearchCriteria criteria = new IoSignalSearchCriteria();
criteria.DeviceName = "Board10";
criteria.Type = IoSignalType.DigitalOutput;

IoSignalItem[] outputs = robot.Rws.Io.SearchSignals(criteria);

foreach (IoSignalItem signal in outputs)
{
    Console.WriteLine($"{signal.Name} = {signal.LogicalValue}");
}


// The extended search also reports the physical value and the write access level
IoSignalItem[] extended = robot.Rws.Io.SearchSignalsExtended(criteria, null, 0, 50);

Console.WriteLine(extended[0].PhysicalValue);
Console.WriteLine(extended[0].Quality);
Console.WriteLine(extended[0].WriteAccessLevel);

// A second inverted criteria excludes what it matches, here the safety signals
IoSignalSearchCriteria exclude = new IoSignalSearchCriteria();
exclude.Category = "safety";
exclude.Invert = true;

IoSignalItem[] withoutSafety = robot.Rws.Io.SearchSignals(criteria, exclude);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
IoSignalConfiguration config = robot.Rws.Io.GetSignalConfiguration("Local", "Board10", "DO_Gripper");

Console.WriteLine(config.SignalName);   // DO_Gripper
Console.WriteLine(config.SignalBits);   // 1

// Who is allowed to write the signal, and in which operation mode
Console.WriteLine(config.Rapid);        // a RAPID program
Console.WriteLine(config.LocalManual);  // the teach pendant, in manual mode
Console.WriteLine(config.LocalAuto);    // the teach pendant, in auto mode
Console.WriteLine(config.RemoteManual); // a remote client, in manual mode
Console.WriteLine(config.RemoteAuto);   // a remote client, in auto mode
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Every device of every network
IoDeviceItem[] devices = robot.Rws.Io.GetDevices();

foreach (IoDeviceItem item in devices)
{
    Console.WriteLine($"{item.Path} ({item.Type}) {item.PhysicalState} {item.LogicalState}");
}

// One device, with its input and output data
IoDeviceItem device = robot.Rws.Io.GetDevice("Local", "Board10");
Console.WriteLine(device.Address);
Console.WriteLine(device.InputData);
Console.WriteLine(device.OutputData);

// Number of bits and write rights of the device
IoDeviceConfiguration config = robot.Rws.Io.GetDeviceConfiguration("Local", "Board10");
Console.WriteLine($"{config.InputBits} input bits, {config.OutputBits} output bits");

// Disable a device, then enable it again
robot.Rws.Io.SetDeviceState("Local", "Board10", IoDeviceLogicalState.Disabled);
robot.Rws.Io.SetDeviceState("Local", "Board10", IoDeviceLogicalState.Enabled);

// Search by name, by logical state, or by both, optionally inside one network
IoDeviceItem[] enabled = robot.Rws.Io.SearchDevices(null, IoDeviceLogicalState.Enabled, "Local");


// Force the first input byte of a device, on a virtual controller only.
// The mask selects the written bits, here the two lowest ones.
robot.Rws.Io.SetDeviceInputData("Local", "Board10", 0, 0x03, 0x03);
robot.Rws.Io.SetDeviceOutputData("Local", "Board10", 0, 0x01, 0x01);

// Firmware state of a device and of its modules, on a real controller only
IoDeviceUpgradeInfo upgrade = robot.Rws.Io.GetDeviceUpgradeInfo("EtherNetIP", "Local_IO");
Console.WriteLine($"{upgrade.State} {upgrade.Status} {upgrade.ModuleCount} modules");

foreach (IoFirmwareModuleInfo module in upgrade.Modules)
{
    Console.WriteLine($"{module.Index} {module.ProgramName} {module.SerialNumber}");
}

// Send a command to a device, on a real controller only.
// The last two arguments are the length of the value and the timeout in milliseconds.
robot.Rws.Io.SendDeviceCommand("EtherNetIP", "Local_IO", "FIRMWARE_INFO", "", 0, 5000);
robot.Disconnect();
}

AbbController robot = new AbbController();
robot.Connect("192.168.0.1");
// Every network of the controller
IoNetworkItem[] networks = robot.Rws.Io.GetNetworks();

foreach (IoNetworkItem item in networks)
{
    Console.WriteLine($"{item.Name}: {item.PhysicalState}, {item.LogicalState}");
}

IoNetworkItem network = robot.Rws.Io.GetNetwork("Local");

IoNetworkConfiguration config = robot.Rws.Io.GetNetworkConfiguration("Local");
Console.WriteLine($"{config.NetworkName} {config.NetworkType} {config.NetworkAddress}");

// Stop a network, then start it again. Every device of the network follows.
robot.Rws.Io.SetNetworkState("Local", IoNetworkLogicalState.Stopped);
robot.Rws.Io.SetNetworkState("Local", IoNetworkLogicalState.Started);

// Search by name, by physical state, or by both
IoNetworkItem[] running = robot.Rws.Io.SearchNetworks(null, IoNetworkPhysicalState.Running);


// Run the auto configuration of a fieldbus network.
// This rewrites the I/O configuration and cannot be undone.
IoClientAction action = robot.Rws.Io.SetNetworkConfigurationType("DeviceNet", IoNetworkConfigurationType.Scan);

if (action == IoClientAction.Restart)
{
    Console.WriteLine("Restart the controller to apply the new configuration");
}

// Names of the I/O resources the controller exposes
string[] resources = robot.Rws.Io.GetResources();
robot.Disconnect();
}