Java NodeConfiguration类代码示例

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
protected void init(NodeMainExecutor nodeMainExecutor)
{
    cameraId = 0;

    rosCameraPreviewView.setCamera(getCamera());

    try {
        java.net.Socket socket = new java.net.Socket(getMasterUri().getHost(), getMasterUri().getPort());
        java.net.InetAddress local_network_address = socket.getLocalAddress();
        socket.close();
        NodeConfiguration nodeConfiguration =
                NodeConfiguration.newPublic(local_network_address.getHostAddress(), getMasterUri());
        nodeMainExecutor.execute(rosCameraPreviewView, nodeConfiguration);
    } catch (IOException e) {
        // Socket problem
        Log.e("Camera Tutorial", "socket error trying to get networking information from the master uri");
    }

}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
protected void init(NodeMainExecutor node) {
    mSimpleNode = new SimpleNode();
    mSimpleNode.setListener(new SimpleNode.OnMessageListener() {
        @Override
        public void onMessage(final String msg) {
            mMainHandler.post(new Runnable() {
                @Override
                public void run() {
                    mRecvText.setText(msg);
                }
            });
        }
    });

    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(getRosHostname());
    nodeConfiguration.setMasterUri(getMasterUri());

    node.execute(mSimpleNode, nodeConfiguration);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
    protected void init(NodeMainExecutor nodeMainExecutor) {
//        rosTextView.setText("test");
//        rosTextView.setTopicName("testtopic");
//        rosTextView.setMessageType("std_msgs/String");

        node = new ROSNode();

        try {
            java.net.Socket socket = new java.net.Socket(getMasterUri().getHost(), getMasterUri().getPort());
            java.net.InetAddress local_network_address = socket.getLocalAddress();
            socket.close();
            NodeConfiguration nodeConfiguration =
                    NodeConfiguration.newPublic(local_network_address.getHostAddress(), getMasterUri());

            //nodeConfiguration.setNodeName()

            nodeMainExecutor.execute(node, nodeConfiguration);
        } catch (IOException e) {
            // Socket problem
            Log.e("MainActivity", "socket error trying to get networking information from the master uri");
        }

    }
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
private void startMoveBaseNode() {
    // Create ROS node for base move
    mLog.info("Starting move base native node");
    mRosNavigationStatusIndicator.updateStatus(ModuleStatusIndicator.Status.LOADING);
    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(mHostName);
    nodeConfiguration.setMasterUri(mMasterUri);
    nodeConfiguration.setNodeName(MoveBaseNode.NODE_NAME);
    mMoveBaseNode = new MoveBaseNode();
    mNodeMainExecutor.execute(mMoveBaseNode, nodeConfiguration,
            new ArrayList<NodeListener>(){{
                add(new DefaultNodeListener() {
                    @Override
                    public void onStart(ConnectedNode connectedNode) {
                        mRosNavigationStatusIndicator.updateStatus(ModuleStatusIndicator.Status.OK);
                    }

                    @Override
                    public void onError(Node node, Throwable throwable) {
                        mRosNavigationStatusIndicator.updateStatus(ModuleStatusIndicator.Status.ERROR);
                    }
                });
            }});
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
protected void init(NodeMainExecutor node) {
    guestScienceDemoNode = GuestScienceRosMessages.getSingletonInstance();
    guestScienceDemoNode.setListener(new GuestScienceRosMessages.OnMessageListener() {
        @Override
        public void onMessage(final String msg) {
            mMainHandler.post(new Runnable() {
                @Override
                public void run() {
                    AndroidRosBridgeService.setMsgRobotToService(msg);
                }
            });
        }
    });

    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic("10.0.42.15");
    nodeConfiguration.setMasterUri(getMasterUri());

    node.execute(guestScienceDemoNode, nodeConfiguration);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
protected void init(final NodeMainExecutor node) {
    NodeConfiguration nodeConfiguration =
            NodeConfiguration.newPublic(
                    ROS_HOSTNAME, ROS_MASTER_URI);

    final PointCloudNode pcn = new PointCloudNode();
    node.execute(pcn, nodeConfiguration);
    mShutdownFuture = node.getScheduledExecutorService().schedule(new Runnable() {
        @Override
        public void run() {
            node.shutdownNodeMain(pcn);
            MainActivity.this.nodeMainExecutorService.forceShutdown();
        }
    }, 3, TimeUnit.SECONDS);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
NodeConfiguration build() {
    final NodeConfiguration config = NodeConfiguration.newPublic(getHost());
    config.setMasterUri(getMasterUri());
    config.setParentResolver(buildParentResolver());
    config.setRosRoot(null);
    config.setRosPackagePath(getRosPackagePath());
    if (m_nodeName != null) {
        config.setNodeName(m_nodeName);
    }
    if (m_tcpPort > 0) {
        config.setTcpRosBindAddress(BindAddress.newPublic(m_tcpPort));
    }
    if (m_rpcPort > 0) {
        config.setXmlRpcBindAddress(BindAddress.newPublic(m_rpcPort));
    }
    return config;
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
/**
* A rosjava callback for RosActivity which gives one the opportunity to spawn
* nodes (subclasses of NodeMain).
*/
@Override
protected void init(NodeMainExecutor nodeMainExecutor)
/*************************************************************************/
{
    NodeConfiguration nodeConfiguration1 =
        NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostAddress(),
            getMasterUri());
    nodeConfiguration1.setNodeName("ShieldTeleop/ImageView");

    NodeConfiguration nodeConfiguration2 =
            NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostAddress(),
                    getMasterUri());
    nodeConfiguration2.setNodeName("ShieldTeleop/JoystickNode");

    //Here we start each node thread (subclass of NodeMain) which run inside an Android service
    //(i.e. basically a persistent background daemon).
    nodeMainExecutor.execute(videoStreamView_, nodeConfiguration1);
    nodeMainExecutor.execute(joystickHandler_, nodeConfiguration2);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
private void startExtrinsicsPublisherNodes() {
    // Create ROS node for extrinsics publisher node
    mLog.info("Starting extrinsics publishers");
    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(mHostName);
    nodeConfiguration.setMasterUri(mMasterUri);
    nodeConfiguration.setNodeName(DefaultMapTfPublisherNode.NODE_NAME);
    mMapExtrinsicsTfPublisherNode = new DefaultMapTfPublisherNode();
    mNodeMainExecutor.execute(mMapExtrinsicsTfPublisherNode, nodeConfiguration);

    nodeConfiguration.setNodeName(DefaultRobotTfPublisherNode.NODE_NAME);
    mRobotExtrinsicsTfPublisherNode = new DefaultRobotTfPublisherNode(getDeviceTransform());
    mNodeMainExecutor.execute(mRobotExtrinsicsTfPublisherNode, nodeConfiguration);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
private void startMapServerNode() {
    // Create ROS node to publish the map
    mLog.info("Starting map server");
    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(mHostName);
    nodeConfiguration.setMasterUri(mMasterUri);
    nodeConfiguration.setNodeName(OccupancyGridPublisherNode.NODE_NAME);
    mOccupancyGridPublisherNode = new OccupancyGridPublisherNode(new EmptyMapGenerator());
    mNodeMainExecutor.execute(mOccupancyGridPublisherNode, nodeConfiguration);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
private void startDeviceBatteryPublisherNode() {
    mLog.info("Starting device battery publisher");
    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(mHostName);
    nodeConfiguration.setMasterUri(mMasterUri);
    nodeConfiguration.setNodeName(DeviceBatteryPublisherNode.NODE_NAME);
    mDeviceBatteryPublisherNode = new DeviceBatteryPublisherNode(getApplicationContext());
    mNodeMainExecutor.execute(mDeviceBatteryPublisherNode, nodeConfiguration);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
public NodeMain[] startNodes(UsbDevice baseUsbDevice, UsbManager usbManager) throws Exception {
    if(baseUsbDevice == null) {
        throw new Exception("null USB device provided");
    }
    log.info("Starting base node");

    // Wrap the UsbDevice in the HoHo Driver
    UsbSerialDriver driver = serialDriverForDevice(baseUsbDevice, usbManager);
    UsbDeviceConnection connection = serialConnectionForDevice(usbManager, driver);

    if (connection == null) {
        throw new Exception("No USB connection available to initialize device");
    }

    UsbSerialPort port = serialPortForDevice(driver);

    // Choose the appropriate BaseDevice implementation for the particular
    // robot base, using the corresponding subclass
    BaseDevice baseDevice = getBaseDevice(port, connection);

    // Create the ROS nodes
    log.info("Create base controller node");
    mBaseControllerNode = new BaseControllerNode(baseDevice, "/cmd_vel");
    NodeConfiguration baseControllerNodeConf = NodeConfiguration.newPublic(mRosHostname);
    baseControllerNodeConf.setNodeName(GraphName.of("base_controller"));
    baseControllerNodeConf.setMasterUri(mRosMasterUri);
    mNodeMainExecutor.execute(mBaseControllerNode, baseControllerNodeConf);

    mBatteryPublisherNode = new RobotBatteryPublisherNode(baseDevice);
    NodeConfiguration batteryPublisherConf = NodeConfiguration.newPublic(mRosHostname);
    batteryPublisherConf.setNodeName(mBaseControllerNode.getDefaultNodeName());
    batteryPublisherConf.setMasterUri(mRosMasterUri);
    mNodeMainExecutor.execute(mBatteryPublisherNode, batteryPublisherConf);

    return new NodeMain[]{mBaseControllerNode, mBaseOdomPublisher};
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
protected void init(NodeMainExecutor nodeMainExecutor) {
    this.getBaseContext();
    final ManagerNode node = ManagerNode.INSTANCE();
    final NodeConfiguration config = NodeConfiguration.newPublic(ROS_HOSTNAME, ROS_MASTER_URI);
    node.setContext(this.getBaseContext());
    node.setStartTimer(mStartTimer);
    nodeMainExecutor.execute(node, config);
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
public void onStart(ConnectedNode connectedNode) {
    Publisher<ff_msgs.CommandStamped> publisher = connectedNode.newPublisher(
            "command", ff_msgs.CommandStamped._TYPE);
    mPublisher = publisher;

    Subscriber<AckStamped> subscriber = connectedNode.newSubscriber(
            "mgt/ack", ff_msgs.AckStamped._TYPE);
    subscriber.addMessageListener(this);

    mNodeConfig = NodeConfiguration.newPrivate();
    mMsgFac = mNodeConfig.getTopicMessageFactory();
}
 

import org.ros.node.NodeConfiguration; //导入依赖的package包/类
@Override
public void onStart(ConnectedNode connectedNode) {
    Publisher<ff_msgs.CommandStamped> publisher = connectedNode.newPublisher(
            "command", ff_msgs.CommandStamped._TYPE);
    mPublisher = publisher;

    Subscriber<ff_msgs.AckStamped> subscriber = connectedNode.newSubscriber(
            "mgt/ack", ff_msgs.AckStamped._TYPE);
    subscriber.addMessageListener(this);

    mNodeConfig = NodeConfiguration.newPrivate();
    mMsgFac = mNodeConfig.getTopicMessageFactory();
}