private void addRobotSpecificModuleCommunicators(HashMap<NetworkPorts, PacketDestination> ports) { for (Entry<NetworkPorts, PacketDestination> entry : ports.entrySet()) { NetworkPorts port = entry.getKey(); PacketDestination destinationId = entry.getValue(); PacketCommunicator packetCommunicator = PacketCommunicator.createIntraprocessPacketCommunicator(port, NET_CLASS_LIST); packetRouter.attachPacketCommunicator(destinationId, packetCommunicator); try { packetCommunicator.connect(); } catch (IOException e) { e.printStackTrace(); } printModuleConnectedDebugStatement(destinationId, "addRobotSpecificModuleCommunicators"); } }
@ContinuousIntegrationTest(estimatedDuration = 0.5) @Test(timeout = 30000) public void testDoubleForwarder() throws IOException { connectCommunicators(); networkProcessor.setPacketRedirects(TestPacketDestinations.A, TestPacketDestinations.B); boolean threwException = false; try { networkProcessor.setPacketRedirects(TestPacketDestinations.B, TestPacketDestinations.C); } catch(IllegalArgumentException e) { threwException = true; } disconnectCommunicators(); assertTrue(threwException); }
if (shouldPrintDebugStatement(sourceCommunicator, packet.getDestination(), packet)) T destination = getPacketDestination(sourceCommunicator, packet); if (isBroadcast(destination)) broadcastPacket(sourceCommunicator, packet); if (shouldPrintDebugStatement(sourceCommunicator, destination.ordinal(), packet)) forwardPacket(packet, destinationCommunicator);
/** * sends the packet to every communicator once, except the sender or any * communicators with redirects **/ private void broadcastPacket(PacketCommunicator sourceCommunicator, Packet<?> packet) { for (T destination : destinationConstants) { if (isBroadcast(destination) || !communicators.containsKey(destination)) { continue; } PacketCommunicator destinationCommunicator = communicators.get(destination); if (sourceCommunicator != destinationCommunicator && !redirects.containsKey(destination)) { if (destinationCommunicator != null && destinationCommunicator.isConnected()) { if (shouldPrintDebugStatement(sourceCommunicator, destination.ordinal(), packet)) { PrintTools.debug(this, "Sending " + packet.getClass().getSimpleName() + " from " + communicatorDestinations.get(sourceCommunicator) + " to " + destination + " at " + System.nanoTime()); } forwardPacket(packet, destinationCommunicator); } } } }
PacketRouter<PacketDestination> packetRouter = new PacketRouter<>(PacketDestination.class); packetRouter.attachPacketCommunicator(PacketDestination.ROS_API, rosAPI_communicator_client); packetRouter.attachPacketCommunicator(PacketDestination.CONTROLLER, controllerCommunicatorClient);
public DRCNetworkProcessor(DRCRobotModel robotModel, DRCNetworkModuleParameters params) { packetRouter = new PacketRouter<>(PacketDestination.class); try { setupControllerCommunicator(params); setupUiModule(params); setupSensorModule(robotModel, params); setupBehaviorModule(robotModel, params); setupHandModules(robotModel, params); setupRosModule(robotModel, params); setupROSAPIModule(params); setupMocapModule(params); setupZeroPoseRobotConfigurationPublisherModule(robotModel, params); setupMultisenseManualTestModule(robotModel, params); setupDrillDetectionModule(params); setupKinematicsToolboxModule(robotModel, params); addRobotSpecificModuleCommunicators(params.getRobotSpecificModuleCommunicatorPorts()); addTextToSpeechEngine(params); setupRobotEnvironmentAwarenessModule(params); } catch (IOException e) { throw new RuntimeException(e); } }
packetCommunicatorFClient.disconnect(); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.A); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.B); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.C); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.D); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.E); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.F);
public void attachPacketCommunicator(T destination, final PacketCommunicator packetCommunicator) { checkCommunicatorId(destination); // check if this communicator already points to the other destination GlobalPacketConsumer packetRoutingAction = null; T otherDestination = communicatorDestinations.get(packetCommunicator); if (otherDestination != null) { packetRoutingAction = consumers.get(otherDestination); // this listener is already attached to that communicator } else { packetRoutingAction = new PacketRoutingAction(packetCommunicator); packetCommunicator.attachGlobalListener(packetRoutingAction); } consumers.put(destination, packetRoutingAction); communicators.put(destination, packetCommunicator); communicatorDestinations.put(packetCommunicator, destination); PrintTools.debug(DEBUG, this, "Attached " + destination + " to the network processor"); }
public DRCNetworkProcessor(DRCRobotModel robotModel, DRCNetworkModuleParameters params) { packetRouter = new PacketRouter<>(PacketDestination.class); try { setupControllerCommunicator(params); setupUiModule(params); setupSensorModule(robotModel, params); setupBehaviorModule(robotModel, params); setupHandModules(robotModel, params); setupRosModule(robotModel, params); setupROSAPIModule(params); setupMocapModule(params); setupZeroPoseRobotConfigurationPublisherModule(robotModel, params); setupMultisenseManualTestModule(robotModel, params); setupDrillDetectionModule(params); setupKinematicsToolboxModule(robotModel, params); setupFootstepPlanningToolboxModule(robotModel, params); addRobotSpecificModuleCommunicators(params.getRobotSpecificModuleCommunicatorPorts()); addTextToSpeechEngine(params); setupHeightQuadTreeToolboxModule(robotModel, params); setupLidarScanLogger(); setupRemoteObjectDetectionFeedbackEndpoint(params); } catch (IOException e) { throw new RuntimeException(e); } }
@ContinuousIntegrationTest(estimatedDuration = 0.7) @Test(timeout = 30000) public void testDetatchObjectCommunicator() throws IOException { connectCommunicators(); ArrayList<Packet<?>> packetsForA = createRandomPackets(TestPacketDestinations.A); ArrayList<Packet<?>> packetsForB = createRandomPackets(TestPacketDestinations.B); ArrayList<Packet<?>> packetsForE = createRandomPackets(TestPacketDestinations.E); ArrayList<ConcurrentPacketQueue<?>> consumersForA = createConsumers(packetsForA, packetCommunicatorAServer); ArrayList<ConcurrentPacketQueue<?>> consumersForB = createConsumers(packetsForB, packetCommunicatorBServer); ArrayList<ConcurrentPacketQueue<?>> consumersForE = createConsumers(packetsForE, packetCommunicatorEServer); sendPackets(packetCommunicatorAServer, packetsForB); assertTrue(checkIfPacketsGoThroughTheWire(packetsForB, consumersForB)); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.B); sendPackets(packetCommunicatorAServer, packetsForB); sendPackets(packetCommunicatorBServer, packetsForA); assertFalse(checkIfPacketsGoThroughTheWire(packetsForB, consumersForB)); assertFalse(checkIfPacketsGoThroughTheWire(packetsForA, consumersForA)); sendPackets(packetCommunicatorAServer, packetsForE); assertTrue(checkIfPacketsGoThroughTheWire(packetsForE, consumersForE)); networkProcessor.detatchObjectCommunicator(TestPacketDestinations.E); sendPackets(packetCommunicatorAServer, packetsForE); sendPackets(packetCommunicatorEServer, packetsForA); assertFalse(checkIfPacketsGoThroughTheWire(packetsForE, consumersForE)); assertFalse(checkIfPacketsGoThroughTheWire(packetsForA, consumersForA)); disconnectCommunicators(); }
private void addRobotSpecificModuleCommunicators(HashMap<NetworkPorts, PacketDestination> ports) { for (Entry<NetworkPorts, PacketDestination> entry : ports.entrySet()) { NetworkPorts port = entry.getKey(); PacketDestination destinationId = entry.getValue(); PacketCommunicator packetCommunicator = PacketCommunicator.createIntraprocessPacketCommunicator(port, NET_CLASS_LIST); packetRouter.attachPacketCommunicator(destinationId, packetCommunicator); try { packetCommunicator.connect(); } catch (IOException e) { e.printStackTrace(); } printModuleConnectedDebugStatement(destinationId, "addRobotSpecificModuleCommunicators"); } }
public UiPacketToRosMsgRedirector(DRCRobotModel robotModel, URI rosCoreURI, PacketCommunicator rosAPI_communicator, PacketRouter<PacketDestination> packetRouter, String namespace) { ROS_NAMESPACE = namespace; rosMainNode = new RosMainNode(rosCoreURI, ROS_NAMESPACE, true); this.nodeConfiguration = NodeConfiguration.newPrivate(); this.messageFactory = nodeConfiguration.getTopicMessageFactory(); this.publishers = new ArrayList<RosTopicPublisher<?>>(); packetRouter.setPacketRedirects(PacketDestination.CONTROLLER, PacketDestination.ROS_API); setupMsgTopics(rosAPI_communicator); rosMainNode.execute(); // rosAPI_communicator.attachGlobalListener(this); }
public void connectCommunicators() throws IOException { packetCommunicatorAServer.connect(); packetCommunicatorBServer.connect(); packetCommunicatorCServer.connect(); packetCommunicatorDServer.connect(); packetCommunicatorEServer.connect(); packetCommunicatorFServer.connect(); networkProcessor.attachPacketCommunicator(TestPacketDestinations.A, packetCommunicatorAClient); networkProcessor.attachPacketCommunicator(TestPacketDestinations.B, packetCommunicatorBClient); networkProcessor.attachPacketCommunicator(TestPacketDestinations.C, packetCommunicatorCClient); networkProcessor.attachPacketCommunicator(TestPacketDestinations.D, packetCommunicatorDClient); networkProcessor.attachPacketCommunicator(TestPacketDestinations.E, packetCommunicatorEClient); networkProcessor.attachPacketCommunicator(TestPacketDestinations.F, packetCommunicatorFClient); packetCommunicatorAClient.connect(); packetCommunicatorBClient.connect(); packetCommunicatorCClient.connect(); packetCommunicatorDClient.connect(); packetCommunicatorEClient.connect(); packetCommunicatorFClient.connect(); }
public UiPacketToRosMsgRedirector(DRCRobotModel robotModel, URI rosCoreURI, PacketCommunicator rosAPI_communicator, PacketRouter<PacketDestination> packetRouter, String namespace) { ROS_NAMESPACE = namespace; rosMainNode = new RosMainNode(rosCoreURI, ROS_NAMESPACE, true); this.nodeConfiguration = NodeConfiguration.newPrivate(); this.messageFactory = nodeConfiguration.getTopicMessageFactory(); this.publishers = new ArrayList<RosTopicPublisher<?>>(); packetRouter.setPacketRedirects(PacketDestination.CONTROLLER, PacketDestination.ROS_API); setupMsgTopics(rosAPI_communicator); rosMainNode.execute(); // rosAPI_communicator.attachGlobalListener(this); }
private void setupRobotEnvironmentAwarenessModule(DRCNetworkModuleParameters parameters) throws IOException { if (parameters.isRobotEnvironmentAwerenessModuleEnabled()) { PacketCommunicator reaCommunicator = PacketCommunicator.createTCPPacketCommunicatorServer(NetworkPorts.REA_MODULE_PORT, NET_CLASS_LIST); packetRouter.attachPacketCommunicator(PacketDestination.REA_MODULE, reaCommunicator); reaCommunicator.connect(); } }
public UiPacketToRosMsgRedirector(DRCRobotModel robotModel, URI rosCoreURI, PacketCommunicator rosAPI_communicator, PacketRouter<PacketDestination> packetRouter, String namespace) { ROS_NAMESPACE = namespace; rosMainNode = new RosMainNode(rosCoreURI, ROS_NAMESPACE, true); this.nodeConfiguration = NodeConfiguration.newPrivate(); this.messageFactory = nodeConfiguration.getTopicMessageFactory(); this.publishers = new ArrayList<RosTopicPublisher<?>>(); packetRouter.setPacketRedirects(PacketDestination.CONTROLLER, PacketDestination.ROS_API); setupMsgTopics(rosAPI_communicator); rosMainNode.execute(); // rosAPI_communicator.attachGlobalListener(this); }
private void setupLidarScanLogger() throws IOException { PacketCommunicator lidarScanLoggerCommunicator = PacketCommunicator .createTCPPacketCommunicatorServer(NetworkPorts.LIDAR_SCAN_LOGGER_PORT, NET_CLASS_LIST); packetRouter.attachPacketCommunicator(PacketDestination.LIDAR_SCAN_LOGGER, lidarScanLoggerCommunicator); lidarScanLoggerCommunicator.connect(); String methodName = "setupLidarScanLogger"; printModuleConnectedDebugStatement(PacketDestination.LIDAR_SCAN_LOGGER, methodName); }
@ContinuousIntegrationTest(estimatedDuration = 0.6) @Test(timeout = 30000) public void testForwarder() throws IOException { connectCommunicators(); networkProcessor.setPacketRedirects(TestPacketDestinations.A, TestPacketDestinations.B); networkProcessor.setPacketRedirects(TestPacketDestinations.E, TestPacketDestinations.C); ArrayList<Packet<?>> packetsForA = createRandomPackets(TestPacketDestinations.A); ArrayList<Packet<?>> packetsForE = createRandomPackets(TestPacketDestinations.E); ArrayList<ConcurrentPacketQueue<?>> consumersForB = createConsumers(packetsForA, packetCommunicatorBServer); ArrayList<ConcurrentPacketQueue<?>> consumersForA = createConsumers(packetsForA, packetCommunicatorAServer); ArrayList<ConcurrentPacketQueue<?>> consumersForC = createConsumers(packetsForE, packetCommunicatorCServer); ArrayList<ConcurrentPacketQueue<?>> consumersForE = createConsumers(packetsForE, packetCommunicatorEServer); sendPackets(packetCommunicatorCServer, packetsForA); sendPackets(packetCommunicatorDServer, packetsForE); assertFalse(checkIfPacketsGoThroughTheWire(packetsForA, consumersForA)); assertFalse(checkIfPacketsGoThroughTheWire(packetsForE, consumersForE)); assertTrue(checkIfPacketsGoThroughTheWire(packetsForA, consumersForB)); assertTrue(checkIfPacketsGoThroughTheWire(packetsForE, consumersForC)); disconnectCommunicators(); }
private void setupDrillDetectionModule(DRCNetworkModuleParameters params) { if (params.isDrillDetectionModuleEnabled()) { PacketCommunicator drillDetectorModuleCommunicator = PacketCommunicator.createTCPPacketCommunicatorServer(NetworkPorts.DRILL_DETECTOR, NET_CLASS_LIST); packetRouter.attachPacketCommunicator(PacketDestination.DRILL_DETECTOR, drillDetectorModuleCommunicator); try { drillDetectorModuleCommunicator.connect(); } catch (IOException e) { e.printStackTrace(); } String methodName = "setupDrillDetectionModule"; printModuleConnectedDebugStatement(PacketDestination.DRILL_DETECTOR, methodName); } }
private void setupZeroPoseRobotConfigurationPublisherModule(DRCRobotModel robotModel, DRCNetworkModuleParameters params) { if (params.isZeroPoseRobotConfigurationPublisherEnabled()) { PacketCommunicator zeroPosePublisherCommunicator = PacketCommunicator.createIntraprocessPacketCommunicator(NetworkPorts.ZERO_POSE_PRODUCER, NET_CLASS_LIST); packetRouter.attachPacketCommunicator(PacketDestination.ZERO_POSE_PRODUCER, zeroPosePublisherCommunicator); try { zeroPosePublisherCommunicator.connect(); new ZeroPoseMockRobotConfigurationDataPublisherModule(robotModel); } catch (IOException e) { e.printStackTrace(); } } }