static int Main(string[] args)
{
var now = RobotRaconteurNode.s.NowUTC;
bool shouldShowHelp = false;
string robot_info_file = null;
bool left_arm = false;
bool right_arm = false;
bool left_electric_gripper = false;
bool right_electric_gripper = false;
string left_gripper_info_file = null;
string right_gripper_info_file = null;
var options = new OptionSet {
{ "robot-info-file=", n => robot_info_file = n },
{ "left-arm", n => left_arm = n != null },
{ "right-arm", n => right_arm = n != null },
{ "left-electric-gripper", n => left_electric_gripper = n != null },
{ "right-electric-gripper", n => right_electric_gripper = n != null },
{ "left-gripper-info-file=", n => left_gripper_info_file = n },
{ "right-gripper-info-file=", n => right_gripper_info_file = n },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("BaxterRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `BaxterRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: BaxterRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return(0);
}
if (robot_info_file == null)
{
Console.WriteLine("error: robot-info-file must be specified");
return(1);
}
string nodename = "baxter_robot";
BaxterRobotArmSelection arm_selection;
if ((!left_arm && !right_arm) || right_arm && left_arm)
{
arm_selection = BaxterRobotArmSelection.both;
}
else if (left_arm)
{
arm_selection = BaxterRobotArmSelection.left;
nodename = "baxter_robot_left_arm";
}
else if (right_arm)
{
arm_selection = BaxterRobotArmSelection.right;
nodename = "baxter_robot_right_arm";
}
else
{
throw new ArgumentException("Invalid arm selection");
}
ushort port = 58660;
if (arm_selection == BaxterRobotArmSelection.right)
{
port = 58661;
}
Tuple <RobotInfo, LocalIdentifierLocks> robot_info = null;
Tuple <ToolInfo, LocalIdentifierLocks> left_tool_info = null;
Tuple <ToolInfo, LocalIdentifierLocks> right_tool_info = null;
BaxterRobot robot = null;
BaxterElectricGripper left_gripper = null;
BaxterElectricGripper right_gripper = null;
try
{
robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file);
if (left_electric_gripper)
{
left_tool_info = ToolInfoParser.LoadToolInfoYamlWithIdentifierLocks(left_gripper_info_file);
left_tool_info.Item1.device_info.parent_device = robot_info.Item1.device_info.device;
left_tool_info.Item1.device_info.device_origin_pose = new NamedPose
{
parent_frame = new Identifier {
name = "left_hand"
},
pose = new Pose {
orientation = new Quaternion {
w = 1
}
}
};
}
if (right_electric_gripper)
{
right_tool_info = ToolInfoParser.LoadToolInfoYamlWithIdentifierLocks(right_gripper_info_file);
right_tool_info.Item1.device_info.parent_device = robot_info.Item1.device_info.device;
right_tool_info.Item1.device_info.device_origin_pose = new NamedPose
{
parent_frame = new Identifier {
name = "right_hand"
},
pose = new Pose {
orientation = new Quaternion {
w = 1
}
}
};
}
ros_csharp_interop.ros_csharp_interop.init_ros(args, "baxter_robotraconteur_driver", true);
robot = new BaxterRobot(robot_info.Item1, arm_selection, "");
robot._start_robot();
if (left_tool_info != null)
{
left_gripper = new BaxterElectricGripper(left_tool_info.Item1, "left_gripper", "");
left_gripper._start_tool();
}
if (right_tool_info != null)
{
right_gripper = new BaxterElectricGripper(right_tool_info.Item1, "right_gripper", "");
right_gripper._start_tool();
}
using (var node_setup = new ServerNodeSetup(nodename, port, args))
{
RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot);
if (left_gripper != null)
{
RobotRaconteurNode.s.RegisterService("left_gripper", "com.robotraconteur.robotics.tool", left_gripper);
}
if (right_gripper != null)
{
RobotRaconteurNode.s.RegisterService("right_gripper", "com.robotraconteur.robotics.tool", right_gripper);
}
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
}
finally
{
robot_info?.Item2?.Dispose();
left_tool_info?.Item2?.Dispose();
right_tool_info?.Item2?.Dispose();
robot?.Dispose();
left_gripper?.Dispose();
right_gripper?.Dispose();
}
return(0);
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string robot_info_file = null;
string robot_name = null;
bool wait_signal = false;
bool electric_gripper = false;
bool vacuum_gripper = false;
string gripper_info_file = null;
string gripper_name = null;
var options = new OptionSet {
{ "robot-info-file=", "the robot info YAML file", n => robot_info_file = n },
{ "robot-name=", "override the robot device name", n => robot_name = n },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null },
{ "electric-gripper", "rethink electric gripper is attached", n => electric_gripper = n != null },
{ "vacuum-gripper", "rethink vacuum gripper is attached", n => vacuum_gripper = n != null },
{ "gripper-info-file=", "gripper info file", n => gripper_info_file = n },
{ "gripper-name=", "override the gripper device name", n => gripper_name = n },
{ "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("SawyerRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `SawyerRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: SawyerRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return(0);
}
if (robot_info_file == null)
{
Console.WriteLine("error: robot-info-file must be specified");
return(1);
}
if (vacuum_gripper && electric_gripper)
{
throw new ArgumentException("--vacuum-gripper and --electric-gripper are mutually exclusive");
}
Tuple <RobotInfo, LocalIdentifierLocks> robot_info = null;
Tuple <ToolInfo, LocalIdentifierLocks> tool_info = null;
SawyerRobot robot = null;
ISawyerGripper gripper = null;
try
{
robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file, robot_name);
ros_csharp_interop.ros_csharp_interop.init_ros(args, "sawyer_robotraconteur_driver", false);
if (electric_gripper || vacuum_gripper)
{
tool_info = ToolInfoParser.LoadToolInfoYamlWithIdentifierLocks(gripper_info_file, gripper_name);
tool_info.Item1.device_info.parent_device = robot_info.Item1.device_info.device;
tool_info.Item1.device_info.device_origin_pose = new NamedPose
{
parent_frame = new Identifier {
name = "right_hand", uuid = new com.robotraconteur.uuid.UUID
{
uuid_bytes = new byte[16]
}
},
pose = new Pose {
orientation = new Quaternion {
w = 1
}
}
};
}
robot = new SawyerRobot(robot_info.Item1, "");
if (electric_gripper)
{
gripper = new SawyerElectricGripper(tool_info.Item1, "right_gripper", "");
gripper._start_tool();
}
else if (vacuum_gripper)
{
gripper = new SawyerVacuumGripper(tool_info.Item1, "right_vacuum_gripper", "");
gripper._start_tool();
}
robot._start_robot();
using (var node_setup = new ServerNodeSetup("sawyer_robot", 58653, args))
{
var robot_service_ctx = RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot);
robot_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(robot_info.Item1.device_info));
if (gripper != null)
{
var tool_service_ctx = RobotRaconteurNode.s.RegisterService("gripper", "com.robotraconteur.robotics.tool", gripper);
tool_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(tool_info.Item1.device_info));
}
if (!wait_signal)
{
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
else
{
UnixSignal[] signals = new UnixSignal[] {
new UnixSignal(Mono.Unix.Native.Signum.SIGINT),
new UnixSignal(Mono.Unix.Native.Signum.SIGTERM),
};
Console.WriteLine("Press Ctrl-C to exit");
// block until a SIGINT or SIGTERM signal is generated.
int which = UnixSignal.WaitAny(signals, -1);
Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum);
}
}
}
finally
{
robot_info?.Item2?.Dispose();
tool_info?.Item2?.Dispose();
robot?.Dispose();
gripper?.Dispose();
}
return(0);
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string robot_info_file = null;
var options = new OptionSet {
{ "robot-info-file=", n => robot_info_file = n },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("MotomanHSCRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `MotomanHSCRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: MotomanHSCRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return(0);
}
if (robot_info_file == null)
{
Console.WriteLine("error: robot-info-file must be specified");
return(1);
}
var robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file);
using (robot_info.Item2)
{
using (var robot = new MotomanHSCRobot(robot_info.Item1))
{
robot._start_robot();
using (var node_setup = new ServerNodeSetup("Motoman_robot", 58651, args))
{
RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot);
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
}
}
return(0);
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string robot_info_file = null;
string robot_name = null;
ushort tcp_port = 58653;
string node_name = "gazebo_robot";
string model_name = null;
string gazebo_url = null;
var options = new OptionSet {
{ "robot-info-file=", n => robot_info_file = n },
{ "robot-name=", "override the robot device name", n => robot_name = n },
{ "model-name=", "the gazebo model to control", n => model_name = n },
{ "gazebo-url=", "url for the Robot Raconteur Gazebo plugin", n => gazebo_url = n },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("GazeboModelRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `GazeboModelRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: GazeboModelRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return(0);
}
if (robot_info_file == null)
{
Console.WriteLine("error: robot-info-file must be specified");
return(1);
}
if (model_name == null)
{
Console.WriteLine("error: model-name must be specified");
return(1);
}
if (gazebo_url == null)
{
Console.WriteLine("error: gazebo_url must be specified");
return(1);
}
var robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file, robot_name);
robot_info.Item1.robot_capabilities &= (uint)(RobotCapabilities.jog_command | RobotCapabilities.position_command | RobotCapabilities.trajectory_command);
RobotOperationalMode robot_op_mode = RobotOperationalMode.auto;
var robot_class = robot_info.Item1?.device_info?.device_classes?.Find(x => x?.class_identifier?.name == "robot");
if (robot_class?.subclasses != null)
{
if (robot_class.subclasses.Contains("cobot"))
{
robot_op_mode = RobotOperationalMode.cobot;
}
}
using (robot_info.Item2)
{
using (var node_setup = new ServerNodeSetup(node_name, tcp_port, args))
{
using (var robot = new GazeboRobot(robot_info.Item1, gazebo_url, model_name, robot_op_mode))
{
robot._start_robot();
var robot_service_ctx = RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot);
robot_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(robot_info.Item1.device_info));
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
}
}
return(0);
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string tool_info_file = null;
string gripper_ip = null;
bool wait_signal = false;
var options = new OptionSet {
{ "tool-info-file=", n => tool_info_file = n },
{ "gripper-ip=", "the ip address of the gripper", n => gripper_ip = n },
{ "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("RobotiqThreeFingerGripperRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `RobotiqThreeFingerGripperRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: RobotiqThreeFingerGripperRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
Console.WriteLine("Also supports standard --robotraconteur- node options");
return(0);
}
if (tool_info_file == null)
{
//Console.WriteLine("error: robot-info-file must be specified");
//return 1;
}
if (gripper_ip == null)
{
Console.WriteLine("error: gripper-ip must be specified");
return(1);
}
using (var node_setup = new ServerNodeSetup("robotiq_gripper", 58323, args))
{
using (var tool = new RobotiqThreeFingerGripper(gripper_ip))
{
tool._start_tool();
RobotRaconteurNode.s.RegisterService("tool", "com.robotraconteur.robotics.tool", tool);
if (!wait_signal)
{
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
else
{
UnixSignal[] signals = new UnixSignal[] {
new UnixSignal(Mono.Unix.Native.Signum.SIGINT),
new UnixSignal(Mono.Unix.Native.Signum.SIGTERM),
};
Console.WriteLine("Press Ctrl-C to exit");
// block until a SIGINT or SIGTERM signal is generated.
int which = UnixSignal.WaitAny(signals, -1);
Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum);
}
}
}
return(0);
}
static void Main(string[] args)
{
//string path = @"C:\Users\wasonj\Documents\RobotRaconteur2\bin_devel\out_debug\NET\Native\RobotRaconteurNETNative.dll";
//Environment.SetEnvironmentVariable("PATH", Path.GetDirectoryName(path) + ";" + Environment.GetEnvironmentVariable("PATH"));
string exepath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
MultiDimArrayTest.testdatapath = System.IO.Path.Combine(exepath, System.IO.Path.Combine("..", "testdata"));
RobotRaconteurNode.s.SetExceptionHandler(delegate(Exception e)
{
Console.WriteLine(e.ToString());
});
string command = "loopback";
if (args.Length >= 1)
{
command = args[0];
}
if (command == "loopback")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
TcpTransport t = new TcpTransport();
t.StartServer(2323);
t.EnableNodeDiscoveryListening();
t.EnableNodeAnnounce();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
MultiDimArrayTest.Test();
RobotRaconteurTestServiceSupport sup = new RobotRaconteurTestServiceSupport();
sup.RegisterServices(t);
int count = 1;
if (args.Length >= 2)
{
count = int.Parse(args[1]);
}
for (int i = 0; i < count; i++)
{
ServiceTestClient c = new ServiceTestClient();
c.RunFullTest("tcp://localhost:2323/{0}/RobotRaconteurTestService", "tcp://localhost:2323/{0}/RobotRaconteurTestService_auth");
//System.Threading.Thread.Sleep(100);
}
/* c = new ServiceTestClient();
* c.RunFullTest("tcp://localhost:2323/{0}/RobotRaconteurTestService", "tcp://localhost:2323/{0}/RobotRaconteurTestService_auth");
* System.Threading.Thread.Sleep(1000);*/
/*System.Threading.Thread.Sleep(10000);
*
* ServiceInfo2[] services = RobotRaconteurNode.s.FindServiceByType("RobotRaconteurTestService.testroot", new string[] { "tcp" });*/
try
{
object o = RobotRaconteurNode.s.ConnectService("tcp://localhost:2323/{0}/RobotRaconteurTestService");
}
catch { }
//System.Threading.Thread.Sleep(17000);
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test completed");
return;
}
if (command == "loopback2")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
using (var setup = new ServerNodeSetup("com.robotraconteur.testing.TestService2", 4565,
RobotRaconteurNodeSetupFlags.ENABLE_TCP_TRANSPORT | RobotRaconteurNodeSetupFlags.TCP_TRANSPORT_START_SERVER))
{
MultiDimArrayTest.Test();
RobotRaconteurTestServiceSupport2 sup = new RobotRaconteurTestServiceSupport2();
sup.RegisterServices(setup.TcpTransport);
ServiceTestClient2 c = new ServiceTestClient2();
c.RunFullTest("rr+tcp://localhost:4565/?service=RobotRaconteurTestService2");
}
Console.WriteLine("Test completed");
return;
}
if (command == "loopback3")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
using (var setup = new ServerNodeSetup("com.robotraconteur.testing.TestService3", 4567,
RobotRaconteurNodeSetupFlags.ENABLE_TCP_TRANSPORT | RobotRaconteurNodeSetupFlags.TCP_TRANSPORT_START_SERVER))
{
RobotRaconteurTestServiceSupport3 sup = new RobotRaconteurTestServiceSupport3();
sup.RegisterServices();
ServiceTestClient3 c = new ServiceTestClient3();
c.RunFullTest("rr+tcp://localhost:4567/?service=RobotRaconteurTestService3");
}
Console.WriteLine("Test completed");
return;
}
if (command == "client")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string url = args[1];
string url_auth = args[2];
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
HardwareTransport t4 = new HardwareTransport();
RobotRaconteurNode.s.RegisterTransport(t4);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
MultiDimArrayTest.Test();
RobotRaconteurTestServiceSupport sup = new RobotRaconteurTestServiceSupport();
sup.RegisterServices(t);
int count = 1;
if (args.Length >= 4)
{
count = int.Parse(args[3]);
}
for (int i = 0; i < count; i++)
{
ServiceTestClient c = new ServiceTestClient();
c.RunFullTest(url, url_auth);
//System.Threading.Thread.Sleep(100);
}
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test completed");
return;
}
if (command == "client2")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string url = args[1];
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService3.com__robotraconteur__testing__TestService3Factory());
MultiDimArrayTest.Test();
RobotRaconteurTestServiceSupport2 sup = new RobotRaconteurTestServiceSupport2();
sup.RegisterServices(t);
ServiceTestClient2 c = new ServiceTestClient2();
c.RunFullTest(url);
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test completed");
return;
}
if (command == "client3")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string url = args[1];
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService5.com__robotraconteur__testing__TestService5Factory());
ServiceTestClient3 c = new ServiceTestClient3();
c.RunFullTest(url);
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test completed");
return;
}
if (command == "server")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
int port;
if (args[1] == "sharer")
{
port = -1;
}
else
{
port = Int32.Parse(args[1]);
}
string name = args[2];
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
t2.StartServerAsNodeName(name);
TcpTransport t = new TcpTransport();
t.EnableNodeAnnounce();
if (port > 0)
{
t.StartServer(port);
}
else
{
t.StartServerUsingPortSharer();
}
try
{
t.LoadTlsNodeCertificate();
}
catch (Exception)
{
Console.WriteLine("warning: Could not load local node certificate");
}
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService3.com__robotraconteur__testing__TestService3Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService5.com__robotraconteur__testing__TestService5Factory());
RobotRaconteurTestServiceSupport sup = new RobotRaconteurTestServiceSupport();
sup.RegisterServices(t);
RobotRaconteurTestServiceSupport2 sup2 = new RobotRaconteurTestServiceSupport2();
sup2.RegisterServices(t);
RobotRaconteurTestServiceSupport2 sup3 = new RobotRaconteurTestServiceSupport2();
sup3.RegisterServices(t);
Console.WriteLine("Server started, press enter to quit");
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test complete, no error detected");
return;
}
if (command == "findservicebytype")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string type = args[1];
string[] tschemes = args[2].Split(new char[] { ',' });
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
System.Threading.Thread.Sleep(6000);
ServiceInfo2[] ret = RobotRaconteurNode.s.FindServiceByType(type, tschemes);
foreach (ServiceInfo2 r in ret)
{
print_ServiceInfo2(r);
}
var t1 = RobotRaconteurNode.s.AsyncFindServiceByType(type, tschemes);
t1.Wait();
var ret2 = t1.Result;
{
foreach (ServiceInfo2 r in ret2)
{
print_ServiceInfo2(r);
}
}
System.Threading.Thread.Sleep(10000);
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "findnodebyid")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
NodeID id = new NodeID(args[1]);
string[] tschemes = args[2].Split(new char[] { ',' });
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
System.Threading.Thread.Sleep(6000);
NodeInfo2[] ret = RobotRaconteurNode.s.FindNodeByID(id, tschemes);
foreach (NodeInfo2 r in ret)
{
print_NodeInfo2(r);
}
var ts1 = RobotRaconteurNode.s.AsyncFindNodeByID(id, tschemes);
ts1.Wait();
var ret2 = ts1.Result;
{
foreach (NodeInfo2 r in ret2)
{
print_NodeInfo2(r);
}
}
System.Threading.Thread.Sleep(10000);
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "findnodebyname")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string name = args[1];
string[] tschemes = args[2].Split(new char[] { ',' });
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
System.Threading.Thread.Sleep(6000);
NodeInfo2[] ret = RobotRaconteurNode.s.FindNodeByName(name, tschemes);
foreach (NodeInfo2 r in ret)
{
print_NodeInfo2(r);
}
var ts1 = RobotRaconteurNode.s.AsyncFindNodeByName(name, tschemes);
ts1.Wait();
var ret2 = ts1.Result;
{
foreach (NodeInfo2 r in ret2)
{
print_NodeInfo2(r);
}
}
System.Threading.Thread.Sleep(10000);
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "stresstestclient")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string url1 = args[1];
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
servicetest_count = 0;
servicetest_keepgoing = true;
object obj = RobotRaconteurNode.s.ConnectService(url1);
async_testroot o = (async_testroot)obj;
testroot o2 = (testroot)obj;
o.async_func3(1, 2).ContinueWith(ts1 => servicetest2(o, ts1));
Pipe <double> .PipeEndpoint p = o2.broadcastpipe.Connect(-1);
p.PacketReceivedEvent += servicetest7;
Wire <double> .WireConnection w = o2.broadcastwire.Connect();
RobotRaconteur.Timer tt = RobotRaconteurNode.s.CreateTimer(40, delegate(TimerEvent ev) { servicetest5(p, w, ev); });
tt.Start();
Console.WriteLine("Press enter to quit");
Console.ReadLine();
servicetest_keepgoing = false;
tt.Stop();
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "latencytestclient" || command == "latencytestclient2")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
string url1 = args[1];
LocalTransport t2 = new LocalTransport();
RobotRaconteurNode.s.RegisterTransport(t2);
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
servicetest_count = 0;
servicetest_keepgoing = true;
object obj = RobotRaconteurNode.s.ConnectService(url1);
async_testroot o = (async_testroot)obj;
testroot o2 = (testroot)obj;
var o3 = o2.get_o1();
int iters = 100000;
var d = new double[10];
DateTime start;
DateTime end;
if (command == "latencytestclient")
{
start = DateTime.UtcNow;
for (int i = 0; i < iters; i++)
{
o3.d1 = d;
}
end = DateTime.UtcNow;
}
else
{
start = DateTime.UtcNow;
for (int i = 0; i < iters; i++)
{
var dummy = o2.struct1;
}
end = DateTime.UtcNow;
}
var diff = (end - start).Ticks / (TimeSpan.TicksPerMillisecond / 1000);
double period = ((double)diff) / ((double)iters);
Console.WriteLine("Period = {0}", period);
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "peeridentity")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
if (args.Length < 2)
{
Console.WriteLine("Usage for peeridentity: RobotRaconteurTest peeridentity url [nodeid]");
return;
}
var url1 = args[1];
Console.WriteLine(url1);
var c = new TcpTransport();
if (args.Length > 2)
{
var nodeid = args[2];
var id = new NodeID(nodeid);
RobotRaconteurNode.s.NodeID = id;
try
{
c.LoadTlsNodeCertificate();
}
catch (Exception)
{
Console.WriteLine("warning: Could not load local node certificate");
}
}
Console.WriteLine(RobotRaconteurNode.s.NodeID);
var c2 = new LocalTransport();
var c5 = new HardwareTransport();
RobotRaconteurNode.s.RegisterTransport(c);
RobotRaconteurNode.s.RegisterTransport(c2);
RobotRaconteurNode.s.RegisterTransport(c5);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
var oo = (testroot)RobotRaconteurNode.s.ConnectService(url1);
oo.func3(1.0, 2.3);
if (c.IsTransportConnectionSecure(oo))
{
Console.WriteLine("Connection is secure");
if (c.IsSecurePeerIdentityVerified(oo))
{
Console.WriteLine("Peer identity is verified: " + c.GetSecurePeerIdentity(oo));
}
else
{
Console.WriteLine("Peer identity is not verified");
}
}
else
{
Console.WriteLine("Connection is not secure");
}
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test completed, no errors detected");
return;
}
if (command == "multidimarraytest")
{
MultiDimArrayTest.Test();
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "subscribertest")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
if (args.Length < 2)
{
Console.WriteLine("Usage for subscribertest: RobotRaconteurTest subscribertest servicetype");
return;
}
var servicetype = args[1];
LocalTransport t2 = new LocalTransport();
t2.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t2);
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
HardwareTransport t3 = new HardwareTransport();
RobotRaconteurNode.s.RegisterTransport(t3);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
var subscription = RobotRaconteurNode.s.SubscribeServiceByType(new string[] { servicetype });
subscription.ClientConnected += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, object e)
{
Console.WriteLine("Client connected: " + d.NodeID.ToString() + ", " + d.ServiceName);
testroot e1 = (testroot)e;
Console.WriteLine("d1 = " + e1.d1);
};
subscription.ClientDisconnected += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, object e)
{
Console.WriteLine("Client disconnected: " + d.NodeID.ToString() + ", " + d.ServiceName);
};
var wire_subscription = subscription.SubscribeWire <double>("broadcastwire");
wire_subscription.WireValueChanged += delegate(WireSubscription <double> c, double d, TimeSpec e)
{
//Console.WriteLine("Wire value changed: " + d);
};
var pipe_subscription = subscription.SubscribePipe <double>("broadcastpipe");
pipe_subscription.PipePacketReceived += delegate(PipeSubscription <double> c)
{
double val;
while (c.TryReceivePacket(out val))
{
Console.WriteLine("Received pipe packet: " + val);
}
};
System.Threading.Thread.Sleep(6000);
var connected_clients = subscription.GetConnectedClients();
foreach (var c in connected_clients)
{
Console.WriteLine("Client: " + c.Key.NodeID + ", " + c.Key.ServiceName);
}
TimeSpec w1_time = null;
double w1_value;
var w1_res = wire_subscription.TryGetInValue(out w1_value);
if (w1_res)
{
Console.WriteLine("Got broadcastwire value: " + w1_value + " " + w1_time?.seconds);
}
Console.WriteLine("Waiting for services...");
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "subscriberurltest")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
if (args.Length < 2)
{
Console.WriteLine("Usage for subscriberurltest: RobotRaconteurTest subscriberurltest url");
return;
}
var url = args[1];
LocalTransport t2 = new LocalTransport();
t2.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t2);
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
HardwareTransport t3 = new HardwareTransport();
RobotRaconteurNode.s.RegisterTransport(t3);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
var subscription = RobotRaconteurNode.s.SubscribeService(url);
subscription.ClientConnected += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, object e)
{
Console.WriteLine("Client connected: " + d.NodeID.ToString() + ", " + d.ServiceName);
testroot e1 = (testroot)e;
Console.WriteLine("d1 = " + e1.d1);
};
subscription.ClientDisconnected += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, object e)
{
Console.WriteLine("Client disconnected: " + d.NodeID.ToString() + ", " + d.ServiceName);
};
subscription.ClientConnectFailed += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, string[] url2, Exception err)
{
Console.WriteLine("Client connect failed: " + d.NodeID.ToString() + " url: " + String.Join(",", url2) + err.ToString());
};
subscription.AsyncGetDefaultClient(1000).ContinueWith(delegate(Task <object> res)
{
if (res.IsFaulted)
{
Console.WriteLine("AsyncGetDefaultClient failed");
}
else if (res.Result == null)
{
Console.WriteLine("AsyncGetDefaultClient returned null");
}
else
{
Console.WriteLine($"AsyncGetDefaultClient successful: {res.Result}");
}
});
var client2 = subscription.GetDefaultClientWait(6000);
object client3;
var try_res = subscription.TryGetDefaultClientWait(out client3, 6000);
Console.WriteLine($"try_res = {try_res}");
var connected_clients = subscription.GetConnectedClients();
foreach (var c in connected_clients)
{
Console.WriteLine("Client: " + c.Key.NodeID + ", " + c.Key.ServiceName);
}
try
{
Console.WriteLine(((testroot)subscription.GetDefaultClient()).d1);
}
catch (Exception)
{
Console.WriteLine("Client not connected");
}
object client1;
subscription.TryGetDefaultClient(out client1);
Console.WriteLine("Waiting for services...");
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "subscriberfiltertest")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
if (args.Length < 2)
{
throw new Exception("Usage for subscriberfiltertest: RobotRaconteurTest subscriberfiltertest servicetype");
}
var servicetype = args[1];
var f = new ServiceSubscriptionFilter();
if (args.Length >= 3)
{
var subcommand = args[2];
if (subcommand == "nodeid")
{
if (args.Length < 4)
{
throw new Exception("Usage for subscriberfiltertest: RobotRaconteurTest subscriberfiltertest nodeid <nodeid>");
}
var n = new ServiceSubscriptionFilterNode();
n.NodeID = new NodeID(args[3]);
f.Nodes = new ServiceSubscriptionFilterNode[] { n };
}
else if (subcommand == "nodename")
{
if (args.Length < 4)
{
throw new Exception("Usage for subscriberfiltertest: RobotRaconteurTest subscriberfiltertest nodename <nodename>");
}
var n = new ServiceSubscriptionFilterNode();
n.NodeName = args[3];
f.Nodes = new ServiceSubscriptionFilterNode[] { n };
}
else
if (subcommand == "nodeidscheme")
{
if (args.Length < 5)
{
throw new Exception("Usage for subscriberfiltertest: RobotRaconteurTest subscriberfiltertest nodeidscheme <nodeid> <schemes>");
}
var n = new ServiceSubscriptionFilterNode();
n.NodeID = new NodeID(args[3]);
f.Nodes = new ServiceSubscriptionFilterNode[] { n };
f.TransportSchemes = args[4].Split(new char[] { ',' });
}
else
if (subcommand == "nodeidauth")
{
if (args.Length < 6)
{
throw new Exception("Usage for subscriberfiltertest: RobotRaconteurTest subscriberfiltertest nodeidauth <nodeid> <username> <password>");
}
var n = new ServiceSubscriptionFilterNode();
n.NodeID = new NodeID(args[3]);
n.Username = args[4];
n.Credentials = new Dictionary <string, object>()
{
{ "password", args[5] }
};
f.Nodes = new ServiceSubscriptionFilterNode[] { n };
}
else
if (subcommand == "servicename")
{
if (args.Length < 4)
{
throw new Exception("Usage for subscriberfiltertest: RobotRaconteurTest subscriberfiltertest servicename <servicename>");
}
var n = new ServiceSubscriptionFilterNode();
f.ServiceNames = new string[] { args[3] };
}
else if (subcommand == "predicate")
{
f.Predicate = delegate(ServiceInfo2 info)
{
Console.WriteLine("Predicate: " + info.NodeName);
return(info.NodeName == "testprog");
};
}
else
{
throw new Exception("Unknown subscriberfiltertest command");
}
LocalTransport t2 = new LocalTransport();
t2.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t2);
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
HardwareTransport t3 = new HardwareTransport();
RobotRaconteurNode.s.RegisterTransport(t3);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
var subscription = RobotRaconteurNode.s.SubscribeServiceByType(new string[] { servicetype }, f);
subscription.ClientConnected += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, object e)
{
Console.WriteLine("Client connected: " + d.NodeID.ToString() + ", " + d.ServiceName);
testroot e1 = (testroot)e;
Console.WriteLine("d1 = " + e1.d1);
};
subscription.ClientDisconnected += delegate(ServiceSubscription c, ServiceSubscriptionClientID d, object e)
{
Console.WriteLine("Client disconnected: " + d.NodeID.ToString() + ", " + d.ServiceName);
};
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
return;
}
return;
}
if (command == "serviceinfo2subscribertest")
{
RobotRaconteurNode.s.SetLogLevelFromEnvVariable();
if (args.Length < 2)
{
Console.WriteLine("Usage for subscribertest: RobotRaconteurTest subscribertest servicetype");
return;
}
var servicetype = args[1];
LocalTransport t2 = new LocalTransport();
t2.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t2);
TcpTransport t = new TcpTransport();
t.EnableNodeDiscoveryListening();
RobotRaconteurNode.s.RegisterTransport(t);
HardwareTransport t3 = new HardwareTransport();
RobotRaconteurNode.s.RegisterTransport(t3);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
var subscription = RobotRaconteurNode.s.SubscribeServiceInfo2(new string[] { servicetype });
subscription.ServiceDetected += delegate(ServiceInfo2Subscription sub, ServiceSubscriptionClientID id, ServiceInfo2 info)
{
Console.WriteLine("Service detected: " + info.NodeID.ToString() + ", " + info.Name);
};
subscription.ServiceLost += delegate(ServiceInfo2Subscription sub, ServiceSubscriptionClientID id, ServiceInfo2 info)
{
Console.WriteLine("Service lost: " + info.NodeID.ToString() + ", " + info.Name);
};
System.Threading.Thread.Sleep(6000);
var connected_clients = subscription.GetDetectedServiceInfo2();
foreach (var c in connected_clients)
{
Console.WriteLine("Client: " + c.Key.NodeID + ", " + c.Key.ServiceName);
}
Console.WriteLine("Waiting for services...");
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "nowutc")
{
Console.WriteLine(RobotRaconteurNode.s.NowUTC);
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "testlogging")
{
var r = new RRLogRecord();
var node = RobotRaconteurNode.s;
var nodeid = node.NodeID;
r.Node = node;
r.Time = DateTime.UtcNow;
r.Level = LogLevel.LogLevel_Warning;
r.Message = "This is a test warning";
RobotRaconteurNode.s.LogRecord(r);
RobotRaconteurNode.s.Shutdown();
return;
}
if (command == "testloghandler")
{
var user_log_handler = new UserLogRecordHandler(x => Console.WriteLine("csharp handler: " + x.ToString()));
RobotRaconteurNode.s.SetLogRecordHandler(user_log_handler);
RobotRaconteurNode.s.SetLogLevel(LogLevel.LogLevel_Debug);
TcpTransport t = new TcpTransport();
t.StartServer(2323);
RobotRaconteurNode.s.RegisterTransport(t);
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService1.com__robotraconteur__testing__TestService1Factory());
RobotRaconteurNode.s.RegisterServiceType(new com.robotraconteur.testing.TestService2.com__robotraconteur__testing__TestService2Factory());
RobotRaconteurTestServiceSupport sup = new RobotRaconteurTestServiceSupport();
sup.RegisterServices(t);
ServiceTestClient c = new ServiceTestClient();
c.RunFullTest("tcp://localhost:2323/{0}/RobotRaconteurTestService", "tcp://localhost:2323/{0}/RobotRaconteurTestService_auth");
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test completed");
return;
}
if (command == "server2")
{
ServerNodeSetup node_setup = new ServerNodeSetup("testprog", 22222, args);
using (node_setup)
{
var t = node_setup.TcpTransport;
RobotRaconteurTestServiceSupport sup = new RobotRaconteurTestServiceSupport();
sup.RegisterServices(t);
RobotRaconteurTestServiceSupport2 sup2 = new RobotRaconteurTestServiceSupport2();
sup2.RegisterServices(t);
RobotRaconteurTestServiceSupport3 sup3 = new RobotRaconteurTestServiceSupport3();
sup3.RegisterServices();
Console.WriteLine("Server started, press enter to quit");
Console.ReadLine();
RobotRaconteurNode.s.Shutdown();
Console.WriteLine("Test complete, no error detected");
return;
}
}
throw new Exception("Unknown command");
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string tool_info_file = null;
string robot_url = null;
List <SignalCommand> open_commands = new List <SignalCommand>();
List <SignalCommand> close_commands = new List <SignalCommand>();
bool wait_signal = false;
var options = new OptionSet {
{ "tool-info-file=", n => tool_info_file = n },
{ "robot-url=", "url for the robot with signals", n => robot_url = n },
{ "open-signal-command=", "add signal to send to open gripper with form <signal_name>,<value>", s => open_commands.Add(parse_signal_command(s)) },
{ "close-signal-command=", "add signal to send to open gripper with form <signal_name>,<value>", s => close_commands.Add(parse_signal_command(s)) },
{ "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("RobotSignalToolRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `RobotSignalToolRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: RobotSignalToolRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
Console.WriteLine("Also supports standard --robotraconteur- node options");
return(0);
}
if (tool_info_file == null)
{
//Console.WriteLine("error: robot-info-file must be specified");
//return 1;
}
if (robot_url == null)
{
Console.WriteLine("error: robot-url must be specified");
return(1);
}
using (var node_setup = new ServerNodeSetup("robot_signal_tool", 58323, args))
{
using (var tool = new RobotSignalTool(robot_url, open_commands.ToArray(), close_commands.ToArray()))
{
RobotRaconteurNode.s.RegisterService("tool", "com.robotraconteur.robotics.tool", tool);
if (!wait_signal)
{
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
else
{
UnixSignal[] signals = new UnixSignal[] {
new UnixSignal(Mono.Unix.Native.Signum.SIGINT),
new UnixSignal(Mono.Unix.Native.Signum.SIGTERM),
};
Console.WriteLine("Press Ctrl-C to exit");
// block until a SIGINT or SIGTERM signal is generated.
int which = UnixSignal.WaitAny(signals, -1);
Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum);
}
}
}
return(0);
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string tool_info_file = null;
string robot_url = null;
bool wait_signal = false;
var options = new OptionSet {
{ "tool-info-file=", n => tool_info_file = n },
{ "robot-url=", "url for the robot with signals", n => robot_url = n },
{ "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("RobotSignalToolRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `RobotSignalToolRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: RobotSignalToolRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
Console.WriteLine("Also supports standard --robotraconteur- node options");
return(0);
}
if (tool_info_file == null)
{
Console.WriteLine("error: robot-info-file must be specified");
return(1);
}
if (robot_url == null)
{
Console.WriteLine("error: robot-url must be specified");
return(1);
}
Tuple <ToolInfo, LocalIdentifierLocks> tool_info = null;
tool_info = ToolInfoParser.LoadToolInfoYamlWithIdentifierLocks(tool_info_file);
using (tool_info.Item2)
using (var node_setup = new ServerNodeSetup("robot_signal_tool", 58323, args))
{
using (var tool = new UR_CB2_SoftGripper(robot_url, tool_info.Item1))
{
var tool_service_ctx = RobotRaconteurNode.s.RegisterService("tool", "com.robotraconteur.robotics.tool", tool);
tool_service_ctx.SetServiceAttributes(AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(tool_info.Item1.device_info));
if (!wait_signal)
{
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
else
{
UnixSignal[] signals = new UnixSignal[] {
new UnixSignal(Mono.Unix.Native.Signum.SIGINT),
new UnixSignal(Mono.Unix.Native.Signum.SIGTERM),
};
Console.WriteLine("Press Ctrl-C to exit");
// block until a SIGINT or SIGTERM signal is generated.
int which = UnixSignal.WaitAny(signals, -1);
Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum);
}
}
}
return(0);
}
static int Main(string[] args)
{
bool shouldShowHelp = false;
string robot_info_file = null;
bool wait_signal = false;
string robot_name = null;
var options = new OptionSet {
{ "robot-info-file=", n => robot_info_file = n },
{ "robot-name=", "override the robot device name", n => robot_name = n },
{ "h|help", "show this message and exit", h => shouldShowHelp = h != null },
{ "wait-signal", "wait for POSIX sigint or sigkill to exit", n => wait_signal = n != null }
};
List <string> extra;
try
{
// parse the command line
extra = options.Parse(args);
}
catch (OptionException e)
{
// output some error message
Console.Write("ABBRobotRaconteurDriver: ");
Console.WriteLine(e.Message);
Console.WriteLine("Try `ABBRobotRaconteurDriver --help' for more information.");
return(1);
}
if (shouldShowHelp)
{
Console.WriteLine("Usage: ABBRobotRaconteurDriver [Options+]");
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return(0);
}
if (robot_info_file == null)
{
Console.WriteLine("error: robot-info-file must be specified");
return(1);
}
var robot_info = RobotInfoParser.LoadRobotInfoYamlWithIdentifierLocks(robot_info_file, robot_name);
using (robot_info.Item2)
{
using (var robot = new ABBRobot(robot_info.Item1))
{
robot._start_robot();
using (var node_setup = new ServerNodeSetup("ABB_robot", 58651, args))
{
var service_ctx = RobotRaconteurNode.s.RegisterService("robot", "com.robotraconteur.robotics.robot", robot);
service_ctx.SetServiceAttributes(RobotRaconteur.Companion.Util.AttributesUtil.GetDefaultServiceAtributesFromDeviceInfo(robot_info.Item1.device_info));
if (!wait_signal)
{
Console.WriteLine("Press enter to exit");
Console.ReadKey();
}
else
{
UnixSignal[] signals = new UnixSignal[] {
new UnixSignal(Mono.Unix.Native.Signum.SIGINT),
new UnixSignal(Mono.Unix.Native.Signum.SIGTERM),
};
Console.WriteLine("Press Ctrl-C to exit");
// block until a SIGINT or SIGTERM signal is generated.
int which = UnixSignal.WaitAny(signals, -1);
Console.WriteLine("Got a {0} signal, exiting", signals[which].Signum);
}
}
}
}
return(0);
}
