/// <summary>
/// Asynchronous version by TAP (Task-based Asynchronous Pattern)
/// </summary>
static void AsyncMainTAP()
{
Ros.InitNodeAsync("/Talker")
.ContinueWith(node =>
{
return(node.Result.PublisherAsync <RosSharp.std_msgs.String>("/chatter"));
})
.Unwrap()
.ContinueWith(publisher =>
{
int i = 0;
while (true)
{
var data = new RosSharp.std_msgs.String()
{
data = "test : " + i++
};
Console.WriteLine("data = {0}", data.data);
publisher.Result.OnNext(data);
Thread.Sleep(TimeSpan.FromSeconds(1));
}
})
.ContinueWith(res =>
{
Console.WriteLine(res.Exception.InnerException.Message);
}, TaskContinuationOptions.OnlyOnFaulted);
}
public void CreateProxy_Error()
{
Ros.MasterUri = new Uri("http://localhost:9999/");
var node = Ros.InitNodeAsync("test", enableLogger: false).Result;
AssertEx.Throws <AggregateException>(() => node.ServiceProxyAsync <AddTwoInts>("/chatter").Wait());
}
static void Main(string[] args)
{
Ros.HostName = "localhost";
Ros.MasterUri = new Uri("http://localhost:11311/");
Ros.TopicTimeout = 10000;
Ros.XmlRpcTimeout = 10000;
var masterServer = new MasterServer(11311);
var runner = new TestRunner()
{
TestCount = 500, PrintCount = 10
};
// runner.Run(new NodeTest());
//runner.Run(new PublisherTest());
//runner.Run(new SubscriberTest());
//runner.Run(new ServiceServerTest());
//runner.Run(new ServiceProxyTest());
runner.Run(new ParameterTest());
masterServer.Dispose();
Ros.Dispose();
GC.Collect();
Console.WriteLine("Memory={0}, Message=final", GC.GetTotalMemory(false));
Console.WriteLine("Finished All Memory Leak Test.");
Console.WriteLine("Press Any Key.");
Console.ReadKey();
}
public void CreatePublisher_Error()
{
Ros.MasterUri = new Uri("http://localhost:9999/");
var node = Ros.InitNodeAsync("test", enableLogger: false).Result;
AssertEx.Throws <AggregateException>(() => node.PublisherAsync <std_msgs.String>("test_topic").Wait());
}
public void RegisterService_Error()
{
Ros.MasterUri = new Uri("http://localhost:9999/");
var node = Ros.InitNodeAsync("test", enableLogger: false).Result;
AssertEx.Throws <AggregateException>(() => node.AdvertiseServiceAsync("/chatter", new AddTwoInts(_ => new AddTwoInts.Response())).Wait());
}
public void Do(int index)
{
var nodeName = "test" + index;
var node = Ros.InitNodeAsync(nodeName, enableLogger: false).Result;
node.Dispose();
}
/// <summary>
/// Asynchronous version by TAP (Task-based Asynchronous Pattern)
/// </summary>
static void AsyncMainTAP()
{
Ros.InitNodeAsync("/Client")
.ContinueWith(node =>
{
return(node.Result.WaitForService("/add_two_ints").ContinueWith(_ => node.Result));
})
.Unwrap()
.ContinueWith(node =>
{
return(node.Result.ServiceProxyAsync <AddTwoInts>("/add_two_ints"));
})
.Unwrap()
.ContinueWith(proxy =>
{
return(proxy.Result.InvokeAsync(new AddTwoInts.Request()
{
a = 1, b = 2
}));
})
.Unwrap()
.ContinueWith(res =>
{
Console.WriteLine("Sum = {0}", res.Result.sum);
})
.ContinueWith(res =>
{
Console.WriteLine(res.Exception.InnerException.Message);
}, TaskContinuationOptions.OnlyOnFaulted);
}
public void LargeData()
{
var observer = new OneLineCacheSubject <std_msgs.ByteMultiArray>();
var node = Ros.InitNodeAsync("test").Result;
var publisher = node.PublisherAsync <std_msgs.ByteMultiArray>("test_topic").Result;
var subscriber = node.SubscriberAsync <std_msgs.ByteMultiArray>("test_topic").Result;
publisher.WaitForConnection(TestTimeout);
subscriber.WaitForConnection(TestTimeout);
subscriber.Subscribe(observer);
publisher.OnNext(new ByteMultiArray()
{
data = Enumerable.Range(0, 5000).Select(x => (byte)(x % 256)).ToList()
});
var data = observer.Timeout(TestTimeout).First();
data.data.Count.Is(5000);
subscriber.Dispose();
publisher.Dispose();
node.Dispose();
}
public void DisposeParameter()
{
var node = Ros.InitNodeAsync("test").Result;
var param = node.PrimitiveParameterAsync <int>("param").Result;
param.Dispose();
}
static void Main(string[] args)
{
//SyncMain();
AsyncMainTAP();
//AsyncMain();
Console.WriteLine("Press Any Key.");
Console.ReadKey();
Ros.Dispose();
}
public void DisposePublisher()
{
var node = Ros.InitNodeAsync("test").Result;
var pub = node.PublisherAsync <std_msgs.String>("test_topic").Result;
var sub = node.SubscriberAsync <std_msgs.String>("test_topic").Result;
pub.Dispose();
node.Dispose();
}
public void Initialize()
{
_node = Ros.InitNodeAsync("test", enableLogger: false).Result;
_serviceServer = _node
.AdvertiseServiceAsync("add_two_ints", new AddTwoInts(req => new AddTwoInts.Response()
{
sum = req.a + req.b
}))
.Result;
}
/// <summary>
/// Synchronous version
/// </summary>
static void SyncMain()
{
try
{
var node = Ros.InitNodeAsync("/Server").Result;
var server = node.AdvertiseServiceAsync("/add_two_ints", new AddTwoInts(add_two_ints)).Result;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void DisposeService()
{
var node = Ros.InitNodeAsync("test").Result;
var service = node.AdvertiseServiceAsync(
"myservice", new AddTwoInts(req => new AddTwoInts.Response()
{
sum = req.a + req.b
})).Result;
service.Dispose();
}
public void Dispose()
{
Ros.GetNodes().Count.Is(0);
var node = Ros.InitNodeAsync("test").Result;
Ros.GetNodes().Count.Is(1);
Ros.Dispose();
Ros.GetNodes().Count.Is(0);
}
public void StringParameter()
{
var node = Ros.InitNodeAsync("test").Result;
var param = node.PrimitiveParameterAsync <string>("test_param").Result;
param.Subscribe(x => Console.WriteLine("param = {0}", x), ex => Console.WriteLine(ex));
for (int i = 0; i < 10; i++)
{
param.Value = i.ToString();
}
}
public void IntParameter()
{
var node = Ros.InitNodeAsync("test", enableLogger: false).Result;
var param = node.PrimitiveParameterAsync <int>("test_param").Result;
param.Subscribe(x => Console.WriteLine("param = {0}", x), ex => Console.WriteLine(ex));
for (int i = 0; i < 10; i++)
{
param.Value = i;
}
}
public void DoubleParameter()
{
var node = Ros.InitNodeAsync("test").Result;
var param = node.PrimitiveParameterAsync <double>("test_param").Result;
param.Subscribe(x => Console.WriteLine("param = {0}", x), ex => Console.WriteLine(ex));
for (double i = 0.0; i < 10.0; i += 1.1)
{
param.Value = i;
}
}
/// <summary>
/// Synchronous version
/// </summary>
static void SyncMain()
{
try
{
var node = Ros.InitNodeAsync("/Listener").Result;
var subscriber = node.SubscriberAsync <RosSharp.std_msgs.String>("/chatter").Result;
subscriber.Subscribe(x => Console.WriteLine(x.data));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void DictionaryParameter()
{
var node = Ros.InitNodeAsync("test").Result;
var param = node.DynamicParameterAsync("test_param").Result;
param.Subscribe(x => Console.WriteLine("param = {0}", x), ex => Console.WriteLine(ex));
for (int i = 0; i < 10; i++)
{
dynamic val = param.Value;
val.IntValue = i;
val.StringValue = i.ToString();
}
}
/// <summary>
/// Synchronous version
/// </summary>
static void SyncMain()
{
try
{
var node = Ros.InitNodeAsync("/ParameterSample").Result;
var param = node.PrimitiveParameterAsync <string>("/test_param").Result;
param.Subscribe(x => Console.WriteLine(x));
param.Value = "test";
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void PublishAndSubscribe()
{
var scheduler = new TestScheduler();
var observer = new OneLineCacheSubject <std_msgs.String>();
var obs = scheduler.CreateHotObservable(
OnNext(10, new std_msgs.String()
{
data = "abc"
}),
OnNext(20, new std_msgs.String()
{
data = "defg"
}),
OnNext(30, new std_msgs.String()
{
data = "hijklmn"
})
);
var node = Ros.InitNodeAsync("test").Result;
var publisher = node.PublisherAsync <std_msgs.String>("test_topic").Result;
var subscriber = node.SubscriberAsync <std_msgs.String>("test_topic").Result;
publisher.WaitForConnection(TestTimeout);
subscriber.WaitForConnection(TestTimeout);
subscriber.Subscribe(observer);
obs.Subscribe(publisher);
scheduler.AdvanceBy(10);
observer.Timeout(TestTimeout).First().data.Is("abc");
scheduler.AdvanceBy(10);
observer.Timeout(TestTimeout).First().data.Is("defg");
scheduler.AdvanceBy(10);
observer.Timeout(TestTimeout).First().data.Is("hijklmn");
subscriber.Dispose();
publisher.Dispose();
node.Dispose();
}
public void ListParameter()
{
var node = Ros.InitNodeAsync("test").Result;
var param = node.ListParameterAsync <int>("test_param").Result;
param.Subscribe(xs => Console.WriteLine("param = {0}", string.Join(",", xs)), ex => Console.WriteLine(ex));
for (int i = 0; i < 10; i++)
{
param.Value = new List <int>()
{
i, i + 1, i + 2, i + 3
};
}
}
public void DisposeNode()
{
var node = Ros.InitNodeAsync("test").Result;
var pub = node.PublisherAsync <std_msgs.String>("test_topic").Result;
var sub = node.SubscriberAsync <std_msgs.String>("test_topic").Result;
var service = node.AdvertiseServiceAsync(
"myservice", new AddTwoInts(req => new AddTwoInts.Response()
{
sum = req.a + req.b
}));
var param = node.PrimitiveParameterAsync <int>("param").Result;
node.Dispose();
Ros.GetNodes().Count.Is(0);
}
static void Main(string[] args)
{
int P;
string[] name;
double[] pay;
string[] posada;
string[] viddil;
string[] email;
string[] age;
Ros sort = new Ros();
Console.WriteLine("Input N size: ");
P = Convert.ToInt32(Console.ReadLine());
sort.Size(P);
name = new string[P];
pay = new double[P];
posada = new string[P];
viddil = new string[P];
email = new string[P];
age = new string[P];
Console.WriteLine("");
for (int i = 0; i < P; i++)
{
name[i] = Console.ReadLine();
pay[i] = Convert.ToDouble(Console.ReadLine());
posada[i] = Console.ReadLine();
viddil[i] = Console.ReadLine();
email[i] = Console.ReadLine();
age[i] = Console.ReadLine();
sort.Add(name[i], pay[i], posada[i], viddil[i], email[i], age[i], i);
Console.WriteLine("");
}
sort.Sort();
sort.Make();
Console.ReadKey();
}
/// <summary>
/// Asynchronous version by TAP (Task-based Asynchronous Pattern)
/// </summary>
static void AsyncMainTAP()
{
Ros.InitNodeAsync("/Server")
.ContinueWith(node =>
{
return(node.Result.AdvertiseServiceAsync("/add_two_ints", new AddTwoInts(add_two_ints)));
})
.Unwrap()
.ContinueWith(server =>
{
server.Wait();
})
.ContinueWith(res =>
{
Console.WriteLine(res.Exception.InnerException.Message);
}, TaskContinuationOptions.OnlyOnFaulted);
}
/// <summary>
/// Asynchronous version by TAP (Task-based Asynchronous Pattern)
/// </summary>
static void AsyncMainTAP()
{
Ros.InitNodeAsync("/Listener")
.ContinueWith(node =>
{
return(node.Result.SubscriberAsync <RosSharp.std_msgs.String>("/chatter"));
})
.Unwrap()
.ContinueWith(subscriber =>
{
subscriber.Result.Subscribe(x => Console.WriteLine(x.data));
})
.ContinueWith(res =>
{
Console.WriteLine(res.Exception.InnerException.Message);
}, TaskContinuationOptions.OnlyOnFaulted);
}
/// <summary>
/// Asynchronous version by TAP (Task-based Asynchronous Pattern)
/// </summary>
static void AsyncMainTAP()
{
Ros.InitNodeAsync("/ParameterSample")
.ContinueWith(node =>
{
return(node.Result.PrimitiveParameterAsync <string>("/test_param"));
})
.Unwrap()
.ContinueWith(param =>
{
param.Result.Subscribe(x => Console.WriteLine(x));
param.Result.Value = "test";
})
.ContinueWith(res =>
{
Console.WriteLine(res.Exception.InnerException.Message);
}, TaskContinuationOptions.OnlyOnFaulted);
}
public void ServerAndProxy()
{
var node = Ros.InitNodeAsync("test").Result;
node.AdvertiseServiceAsync("/add_two_ints", new AddTwoInts(add_two_ints)).Wait();
var proxy = node.ServiceProxyAsync <AddTwoInts>("/add_two_ints").Result;
var res = proxy.InvokeAsync(new AddTwoInts.Request()
{
a = 1, b = 2
})
.ToObservable()
.Timeout(TimeSpan.FromSeconds(3))
.First();
res.sum.Is(3);
}
/// <summary>
/// Synchronous version
/// </summary>
static void SyncMain()
{
try
{
var node = Ros.InitNodeAsync("/Client").Result;
node.WaitForService("add_two_ints").Wait(TimeSpan.FromSeconds(10));
var proxy = node.ServiceProxyAsync <AddTwoInts>("add_two_ints").Result;
var res = proxy.Invoke(new AddTwoInts.Request()
{
a = 1, b = 2
});
Console.WriteLine("Sum = {0}", res.sum);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
