ros和java通讯_Android使用ROSBridge与ROS通信简单使用

环境

ROS kinetic

ROS 服务端

安装

sudo apt-get install ros--rosbridge-suite

启动

roslaunch rosbridge_server rosbridge_websocket.launch

在这之前不需要开启 roscore, 因为 rosbridge 会默认执行 roscore

Android客户端

要让 android 接收或者发送 ROS 消息的话&＃xff0c;首先要在 Android上完成 websocket&＃xff0c;然后按照协议解析&＃xff0c;也很麻烦&＃xff0c;不过又要站在巨人的肩膀上了&＃xff0c;找到一个 开源项目:ROSBridgeClient

,这位同学使用 java-websocket 的包在Android上实现了 websocket 的应用&＃xff0c;很棒。

直接把 src/com/jilk/ros

目录复制到 我的 Android 项目里&＃xff0c;

当然会报错啦&＃xff0c;这些代码依赖了第三方库&＃xff0c;加在Android工程的libs 里面 引用

eventbus.jar 用于发送从ROS接收到的消息

java_websocket.jar 用于websocket 的实现

json-simple-1.1.jar 用于 json 解析

复制到项目包里的 代码包含了一个 example .

完全可以使用

public class Example {

public Example() {}

public static void main(String[] args) {

ROSBridgeClient client &＃61; new ROSBridgeClient("ws://162.243.238.80:9090");

client.connect();

//testTopic(client);

try {

testService(client);

}

catch (RuntimeException ex) {

ex.printStackTrace();

}

finally {

client.disconnect();

}

}

public static void testService(ROSBridgeClient client) {

try {

Service timeService &＃61;

new Service("/rosapi/get_time", Empty.class, GetTime.class, client);

timeService.verify();

//System.out.println("Time (secs): " &＃43; timeService.callBlocking(new Empty()).time.sec);

Service serviceTypeService &＃61;

new Service("/rosapi/service_type",

com.jilk.ros.rosapi.message.Service.class, Type.class, client);

serviceTypeService.verify();

String type &＃61; serviceTypeService.callBlocking(new com.jilk.ros.rosapi.message.Service("/rosapi/service_response_details")).type;

Service serviceDetails &＃61;

new Service("/rosapi/service_response_details",

Type.class, MessageDetails.class, client);

serviceDetails.verify();

//serviceDetails.callBlocking(new Type(type)).print();

Topic logTopic &＃61;

new Topic("/rosout", Log.class, client);

logTopic.verify();

/*

System.out.println("Nodes");

for (String s : client.getNodes())

System.out.println(" " &＃43; s);

System.out.println("Topics");

for (String s : client.getTopics()) {

System.out.println(s &＃43; ":");

client.getTopicMessageDetails(s).print();

}

System.out.println("Services");

for (String s : client.getServices()) {

System.out.println(s &＃43; ":");

client.getServiceRequestDetails(s).print();

System.out.println("-----------------");

client.getServiceResponseDetails(s).print();

}

*/

}

catch (InterruptedException ex) {

System.out.println("Process was interrupted.");

}

/*

Service topicService &＃61;

new Service("/rosapi/topics", Empty.class, Topics.class, client);

Service typeService &＃61;

new Service("/rosapi/topic_type", Topic.class, Type.class, client);

Service messageService &＃61;

new Service("/rosapi/message_details", Type.class, MessageDetails.class, client);

try {

Topics topics &＃61; topicService.callBlocking(new Empty());

for (String topicString : topics.topics) {

Topic topic &＃61; new Topic();

topic.topic &＃61; topicString;

Type type &＃61; typeService.callBlocking(topic);

MessageDetails details &＃61; messageService.callBlocking(type);

System.out.println("Topic: " &＃43; topic.topic &＃43; " Type: " &＃43; type.type);

details.print();

System.out.println();

}

Type type &＃61; new Type();

type.type &＃61; "time";

System.out.print("Single type check on \&＃39;time\&＃39;: ");

messageService.callBlocking(type).print();

}

catch (InterruptedException ex) {

System.out.println("testService: process was interrupted.");

}

*/

}

public static void testTopic(ROSBridgeClient client) {

Topic clockTopic &＃61; new Topic("/clock", Clock.class, client);

clockTopic.subscribe();

try {Thread.sleep(20000);} catch(InterruptedException ex) {}

Clock cl &＃61; null;

try {

cl &＃61; clockTopic.take(); // just gets one

}

catch (InterruptedException ex) {}

cl.print();

cl.clock.nsecs&＃43;&＃43;;

clockTopic.unsubscribe();

clockTopic.advertise();

clockTopic.publish(cl);

clockTopic.unadvertise();

}

}

example很好理解

就看了下 topic 相关的东西 testTopic&＃xff0c;我觉得如果有很多topic就要用很多的testXXXTopic了&＃xff0c;有点麻烦&＃xff0c;所以我二次封装了一个 RosBridgeClientManager 来用

连接 ROS master

/**

* 连接 ROS master

* &＃64;param url ROS master IP

* &＃64;param port ROS master 端口

* &＃64;param listener 连接状态监听器

*/

public void connect(final String url, int port, final ROSClient.ConnectionStatusListener listener) {

if (url !&＃61; null && url.equals(mCurUrl)) {

// already connected

} else {

mRosBridgeClient &＃61; new ROSBridgeClient("ws://" &＃43; url &＃43; ":" &＃43; port);

mRosBridgeClient.connect(new ROSClient.ConnectionStatusListener() {

&＃64;Override

public void onConnect() {

// connected successful

mCurUrl &＃61; url;

if (listener !&＃61; null) {

listener.onConnect();

}

}

&＃64;Override

public void onDisconnect(boolean normal, String reason, int code) {

// client disconnected

if (listener !&＃61; null) {

listener.onDisconnect(normal, reason, code);

}

}

&＃64;Override

public void onError(Exception ex) {

// connect error

if (listener !&＃61; null) {

listener.onError(ex);

}

}

});

}

}

加了一个连接监听器&＃xff0c;可以在业务层进行状态判断了。

注册topic 到 ROS

/**

* 注册topic

* &＃64;param topicName topic 名称

* &＃64;param data_type 消息类型

* &＃64;param

*/

public void advertiseTopic(String topicName, T data_type) {

AdvertiseTopicObject topic &＃61; new AdvertiseTopicObject<>(topicName, data_type, mRosBridgeClient);

topic.setMessage_type(data_type);

topic.advertise();

// 利用 反射获取泛型&＃xff0c;主要是得到 T.class,我也没试

// Class entityClass &＃61; (Class ) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

// Topic topic &＃61; new Topic(topicName, entityClass, client);

// topic.advertise();

}

原来的 advertise 已经很简单了&＃xff0c;为什么我还要弄这个东西&＃xff1f;

我也不知道啊

AdvertiseTopicObject.java

public class AdvertiseTopicObject {

private T message_type;

private String topicName;

private ROSBridgeClient client;

public AdvertiseTopicObject(String topicName, T type, ROSBridgeClient rosBridgeClient) {

this.client &＃61; rosBridgeClient;

this.topicName &＃61; topicName;

this.message_type &＃61; type;

}

public void advertise() {

Topic topic &＃61; new Topic(topicName, message_type.getClass(), client);

topic.advertise();

}

}

发布topic 消息

/**

* 发布 topic 消息

* &＃64;param topicName topic名称

* &＃64;param msg 消息

* &＃64;param 消息类型

*/

public void publishTopic(String topicName, T msg) {

PublishTopicObject publishTopicObject &＃61; new PublishTopicObject<>();

publishTopicObject.setTopic(topicName);

publishTopicObject.setMsg(msg);

String msg_str &＃61; mGson.toJson(publishTopicObject);

mRosBridgeClient.send(msg_str);

}

跟上面的 AdvertiseTopicObject 保持一致&＃xff0c;所以有了

PublishTopicObject.java

public class PublishTopicObject {

private String op &＃61; "publish";

private String topic;

private T msg;

}

订阅 topic

/**

* 订阅topic

* &＃64;param topicName topic 名称

* &＃64;param listener 消息监听器

*/

public void subscribeTopic(String topicName, OnRosMessageListener listener

{

SubscribeTopicObject subscribeTopicObject &＃61; new SubscribeTopicObject();

subscribeTopicObject.setTopic(topicName);

String msg_str &＃61; mGson.toJson(subscribeTopicObject);

mRosBridgeClient.send(msg_str);

addROSMessageListener(listener);

}

同理&＃xff1a;跟上面的 PublishTopicObject 保持一致&＃xff0c;所以有了

SubscribeTopicObject.java

public class SubscribeTopicObject {

private String op &＃61; "subscribe";

private String topic;

public String getOp() {

return op;

}

}

取消订阅 topic

/**

* 取消订阅topic

* &＃64;param topicName

* &＃64;param listener

*/

public void unSubscribeTopic(String topicName, OnRosMessageListener listener) {

UnSubscribeTopicObject unSubscribeTopicObject &＃61; new UnSubscribeTopicObject();

unSubscribeTopicObject.setTopic(topicName);

String msg_str &＃61; mGson.toJson(unSubscribeTopicObject);

mRosBridgeClient.send(msg_str);

removeROSMessageListener(listener);

}

还有 UnSubscribeTopicObject.java

public class UnSubscribeTopicObject {

private String op &＃61; "unsubscribe";

private String topic;

}

接收ROS 消息

//Receive data from ROS server, send from ROSBridgeWebSocketClient onMessage()

// using eventbus ?!

public void onEvent(final PublishEvent event) {

Log.d("TAG", event.msg);

for (int index &＃61; 0 ; index

mROSListenerList.get(curIndex).onStringMessageReceive(event.name, stringData);

//mROSListenerList.get(curIndex).onImageMessageReceive(event.name, imageData);

}

}

在 ROSBridgeWebSocketClient.java 里面找到了接收消息后发出来的代码

EventBus.getDefault().post(new PublishEvent(operation,publish.topic,content));

Emmm… 用的是 EventBus&＃xff0c;先用起来再说。

还有就是关于服务的封装了&＃xff0c;没写。