Unity server update (#49)

LaurieCheers-unity · web-flow · commit 14605fcb36d6 · 2020-11-23T12:47:31.000-08:00
ROSConnection runs a listen server with auto IP detection
diff --git a/tutorials/pick_and_place/2_ros_tcp.md b/tutorials/pick_and_place/2_ros_tcp.md
@@ -187,11 +187,10 @@ Most of the ROS setup has been provided via the `niryo_moveit` package. This sec
    sudo -H pip install rospkg jsonpickle
    ```
 
-   > In your ROS workspace, find the directory `src/niryo_moveit/scripts`. Note the file `server_endpoint.py`. This script imports the necessary dependencies from tcp_endpoint, defines the TCP host address and port values, and starts the server. `rospy.spin()` ensures the node does not exit until it is shut down.
+   > In your ROS workspace, find the directory `src/niryo_moveit/scripts`. Note the file `server_endpoint.py`. This script imports the necessary dependencies from tcp_endpoint and starts the server. `rospy.spin()` ensures the node does not exit until it is shut down.
 
    ```python
    ...
-   tcp_server = TCPServer(ros_tcp_ip, ros_tcp_port, ros_node_name, source_destination_dict)
    tcp_server.start()
    rospy.spin()
    ...
@@ -203,32 +202,18 @@ Most of the ROS setup has been provided via the `niryo_moveit` package. This sec
 
 1. The ROS parameters will need to be set to your configuration in order to allow the server endpoint to fetch values for the TCP connection. Navigate to `src/niryo_moveit/config/params.yaml` and open the file for editing. You will need to know the IP address of your ROS machine as well as the IP address of the machine running Unity. 
    - The ROS machine IP, i.e. `ROS_IP` should be the same value as the one set as `Host Name` on the RosConnect component in Unity.
-   - Finding the IP address of your local machine (the one running Unity), i.e. `UNITY_IP` depends on your operating system. 
-     - On a Mac, open `System Preferences > Network`. Your IP address should be listed on the active connection.
-     - On Windows, click the Wi-Fi icon on the taskbar, and open `Properties`. Your IP address should be listed near the bottom, next to "IPv4 address."
-
-   - Update the `ROS_IP` and `UNITY_IP` below with the appropriate addresses and copy the contents into the `params.yaml` file.
+   - Update the `ROS_IP` below with the appropriate addresses and copy the contents into the `params.yaml` file.
 
       ```yaml
       ROS_IP: <your ROS IP>
-      ROS_TCP_PORT: 10000
-      UNITY_IP: <your Unity IP>
-      UNITY_SERVER_PORT: 5005
-      rosdistro: 'melodic'
       ```
       
       e.g.
 
       ```yaml
       ROS_IP: 192.168.50.149
-      ROS_TCP_PORT: 10000
-      UNITY_IP: 192.168.50.13
-      UNITY_SERVER_PORT: 5005
-      rosdistro: 'melodic'
       ```
 
-      Ensure that the `ROS_TCP_PORT` is set to 10000, and the `UNITY_SERVER_PORT` is set to 5005.
-
       > Note: Learn more about the server endpoint and ROS parameters [here](../ros_unity_integration/server_endpoint.md).
 
    > This YAML file is `rosparam set` from the launch files provided for this tutorial, which has been copied below for reference. Additionally, the server_endpoint and trajectory_subscriber nodes are launched from this file. 
diff --git a/tutorials/pick_and_place/PickAndPlaceProject/Packages/manifest.json b/tutorials/pick_and_place/PickAndPlaceProject/Packages/manifest.json
@@ -4,8 +4,8 @@
     "com.unity.ide.rider": "2.0.7",
     "com.unity.ide.visualstudio": "2.0.3",
     "com.unity.ide.vscode": "1.2.2",
-    "com.unity.robotics.urdf-importer": "git+https://github.com/Unity-Technologies/URDF-Importer.git#v0.0.4",
-    "com.unity.robotics.ros-tcp-connector": "git+https://github.com/Unity-Technologies/ROS-TCP-Connector.git#v0.0.2",
+    "com.unity.robotics.urdf-importer": "https://github.com/Unity-Technologies/URDF-Importer.git#v0.0.4",
+    "com.unity.robotics.ros-tcp-connector": "https://github.com/Unity-Technologies/ROS-TCP-Connector.git#v0.0.3",
     "com.unity.test-framework": "1.1.18",
     "com.unity.textmeshpro": "3.0.1",
     "com.unity.timeline": "1.4.3",
diff --git a/tutorials/pick_and_place/PickAndPlaceProject/Packages/packages-lock.json b/tutorials/pick_and_place/PickAndPlaceProject/Packages/packages-lock.json
@@ -38,14 +38,14 @@
       "url": "https://packages.unity.com"
     },
     "com.unity.robotics.ros-tcp-connector": {
-      "version": "git+https://github.com/Unity-Technologies/ROS-TCP-Connector.git#v0.0.2",
+      "version": "https://github.com/Unity-Technologies/ROS-TCP-Connector.git#v0.0.3",
       "depth": 0,
       "source": "git",
       "dependencies": {},
-      "hash": "0e963defca4eb075316d30e1e4224dee276c22cb"
+      "hash": "251c159b0a4bab0950c43e6a3be4524876d2549f"
     },
     "com.unity.robotics.urdf-importer": {
-      "version": "git+https://github.com/Unity-Technologies/URDF-Importer.git#v0.0.4",
+      "version": "https://github.com/Unity-Technologies/URDF-Importer.git#v0.0.4",
       "depth": 0,
       "source": "git",
       "dependencies": {},
diff --git a/tutorials/pick_and_place/ROS/src/niryo_moveit/config/params.yaml b/tutorials/pick_and_place/ROS/src/niryo_moveit/config/params.yaml
@@ -1,5 +1 @@
-ROS_IP: 192.168.50.149
-ROS_TCP_PORT: 10000
-UNITY_IP: 192.168.50.13
-UNITY_SERVER_PORT: 5005
-rosdistro: 'melodic'
+ROS_IP: 127.0.0.1
diff --git a/tutorials/pick_and_place/ROS/src/niryo_moveit/scripts/server_endpoint.py b/tutorials/pick_and_place/ROS/src/niryo_moveit/scripts/server_endpoint.py
@@ -11,28 +11,18 @@
 from niryo_moveit.srv import MoverService
 
 def main():
-    # Get variables set in rosparam used for
-    # server/node communication
-    ros_tcp_ip = rospy.get_param("/ROS_IP")
-    ros_tcp_port = rospy.get_param("/ROS_TCP_PORT")
-
     ros_node_name = rospy.get_param("/TCP_NODE_NAME", 'TCPServer')
-
-    unity_machine_ip = rospy.get_param("/UNITY_IP")
-    unity_machine_port = rospy.get_param("/UNITY_SERVER_PORT")
-
-    rospy.init_node(ros_node_name, anonymous=True)
-    rate = rospy.Rate(10)  # 10hz
+    tcp_server = TCPServer(ros_node_name)
 
     # Create ROS communication objects dictionary for routing messages
-    source_destination_dict = {
+    tcp_server.source_destination_dict = {
         'SourceDestination_input': RosPublisher('SourceDestination', NiryoMoveitJoints, queue_size=10),
-        'NiryoTrajectory': RosSubscriber('NiryoTrajectory', NiryoTrajectory, unity_machine_ip, unity_machine_port),
+        'NiryoTrajectory': RosSubscriber('NiryoTrajectory', NiryoTrajectory, tcp_server),
         'niryo_moveit': RosService('niryo_moveit', MoverService)
     }
 
     # Start the Server Endpoint
-    tcp_server = TCPServer(ros_tcp_ip, ros_tcp_port, ros_node_name, source_destination_dict)
+    rospy.init_node(ros_node_name, anonymous=True)
     tcp_server.start()
     rospy.spin()
 
diff --git a/tutorials/pick_and_place/ROS/src/ros_tcp_endpoint b/tutorials/pick_and_place/ROS/src/ros_tcp_endpoint
@@ -1 +1 @@
-Subproject commit 34c498d14d471b4643e38c606cc4489ad3032027
+Subproject commit 68ade1ccc078e9cfb090e2eeeeb62a2a8c394a9c
diff --git a/tutorials/ros_packages/robotics_demo/scripts/server_endpoint.py b/tutorials/ros_packages/robotics_demo/scripts/server_endpoint.py
@@ -10,28 +10,19 @@
 from robotics_demo.msg import PosRot, UnityColor
 from robotics_demo.srv import PositionService
 
-
 def main():
-    ros_tcp_ip = rospy.get_param("/ROS_IP")
-    ros_tcp_port = rospy.get_param("/ROS_TCP_PORT")
-
     ros_node_name = rospy.get_param("/TCP_NODE_NAME", 'TCPServer')
     buffer_size = rospy.get_param("/TCP_BUFFER_SIZE", 1024)
     connections = rospy.get_param("/TCP_CONNECTIONS", 10)
+    tcp_server = TCPServer(ros_node_name, buffer_size, connections)
 
-    unity_machine_ip = rospy.get_param("/UNITY_IP")
-    unity_machine_port = rospy.get_param("/UNITY_SERVER_PORT")
-
-    rospy.init_node(ros_node_name, anonymous=True)
-    rate = rospy.Rate(10)  # 10hz
-
-    source_destination_dict = {
+    tcp_server.source_destination_dict = {
         'pos_srv': RosService('position_service', PositionService),
         'pos_rot': RosPublisher('pos_rot', PosRot, queue_size=10),
-        'color': RosSubscriber('color', UnityColor, unity_machine_ip, unity_machine_port),
+        'color': RosSubscriber('color', UnityColor, tcp_server)
     }
 
-    tcp_server = TCPServer(ros_tcp_ip, ros_tcp_port, ros_node_name, source_destination_dict, buffer_size, connections)
+    rospy.init_node(ros_node_name, anonymous=True)
     tcp_server.start()
     rospy.spin()
 
diff --git a/tutorials/ros_unity_integration/server_endpoint.md b/tutorials/ros_unity_integration/server_endpoint.md
@@ -22,37 +22,25 @@ from tcp_endpoint.RosService import RosService
 from robotics_demo.msg import PosRot, UnityColor
 from robotics_demo.srv import PositionService
 
-
 def main():
-	 # Get variables set in rosparam used for 
-	 # server/node communication 
-    ros_tcp_ip = rospy.get_param("/ROS_IP")
-    ros_tcp_port = rospy.get_param("/ROS_TCP_PORT")
-
     ros_node_name = rospy.get_param("/TCP_NODE_NAME", 'TCPServer')
+    buffer_size = rospy.get_param("/TCP_BUFFER_SIZE", 1024)
+    connections = rospy.get_param("/TCP_CONNECTIONS", 10)
+    tcp_server = TCPServer(ros_node_name, buffer_size, connections)
 
-    unity_machine_ip = rospy.get_param("/UNITY_IP")
-    unity_machine_port = rospy.get_param("/UNITY_SERVER_PORT")
-
-    rospy.init_node(ros_node_name, anonymous=True)
-    rate = rospy.Rate(10)  # 10hz
-
-    # Create ROS communication objects dictionary for routing messages
-    source_destination_dict = {
+    tcp_server.source_destination_dict = {
         'pos_srv': RosService('position_service', PositionService),
         'pos_rot': RosPublisher('pos_rot', PosRot, queue_size=10),
-        'color': RosSubscriber('color', UnityColor, unity_machine_ip, unity_machine_port),
+        'color': RosSubscriber('color', UnityColor, tcp_server)
     }
 
-    # Start the Server Endpoint
-    tcp_server = TCPServer(ros_tcp_ip, ros_tcp_port, ros_node_name, source_destination_dict)
+    rospy.init_node(ros_node_name, anonymous=True)
     tcp_server.start()
     rospy.spin()
 
 
 if __name__ == "__main__":
     main()
-
 ```
 
 
@@ -74,7 +62,6 @@ from robotics_demo.srv import PositionService
 
 ```python
     rospy.init_node(ros_node_name, anonymous=True)
-    rate = rospy.Rate(10)  # 10hz
 ```
 
 ## ROS Publisher
@@ -86,14 +73,13 @@ A ROS Publisher requires three components:
 
 `RosPublisher('pos_rot', PosRot, queue_size=10)`
 ## ROS Subscriber
-A ROS Subscriber requires four components:
+A ROS Subscriber requires three components:
 
 - Topic name
 - ROS message class generated from running `catkin_make` command
-- IP address of machine running Unity
-- Corresponding TCP port of machine running Unity
+- The tcp server that will connect to Unity
 
-`RosSubscriber('color', UnityColor, unity_machine_ip, unity_machine_port)`
+`RosSubscriber('color', UnityColor, tcp_server)`
 
 ## ROS Service
 A ROS Service requires two components:
@@ -103,48 +89,47 @@ A ROS Service requires two components:
 
 `RosService('position_service', PositionService)`
 
+## Creating the Server
+
+Requires:
+
+- The ROS node name
+
+```python
+    tcp_server = TCPServer(ros_node_name)
+```
+
 ## Source Destination Dictionary
 
 Create a dictionary keyed by topic or service with the corresponding ROS communication class as the value. The dictionary is used by the TCP server to direct messages to and from the ROS network.
 
 ```python
-    source_destination_dict = {
+    tcp_server.source_destination_dict = {
         'pos_srv': RosService('position_service', PositionService),
         'pos_rot': RosPublisher('pos_rot', PosRot, queue_size=10),
-        'color': RosSubscriber('color', Color, unity_machine_ip, unity_machine_port),
+        'color': RosSubscriber('color', Color, tcp_server),
     }
 ```
 
-
 ## Starting the Server
 
-Requires:
-
-- IP of machine the script will be executing on
-- The port to open for incoming connections
-- The ROS node name
-- Dictionary of service or topic names to corresponding class
-
 ```python
-    tcp_server = TCPServer(ros_tcp_ip, ros_tcp_port, ros_node_name, source_destination_dict)
     tcp_server.start()
     rospy.spin()
     
 ```
 
 
-These values can be hardcoded, but for the sake of portability, we recommend setting the parameters using the `rosparam set` command, or a `rosparam` YAML file.
+The following parameters can be hardcoded, but for the sake of portability, we recommend setting the parameters using the `rosparam set` command, or a `rosparam` YAML file.
 
 ```python
-    ros_tcp_ip = rospy.get_param("/ROS_IP")
-    ros_tcp_port = rospy.get_param("/ROS_TCP_PORT")
-
     ros_node_name = rospy.get_param("/TCP_NODE_NAME", 'TCPServer')
-
-    unity_machine_ip = rospy.get_param("/UNITY_IP")
-    unity_machine_port = rospy.get_param("/UNITY_SERVER_PORT")
+    buffer_size = rospy.get_param("/TCP_BUFFER_SIZE", 1024)
+    connections = rospy.get_param("/TCP_CONNECTIONS", 10)
 ```
 
+In addition, the TCPServer class uses the ROS parameters ROS_IP and ROS_TCP_PORT to determine what ip & port to listen on.
+
 > Note: Read more about the ROS Parameter Server [here](http://wiki.ros.org/Parameter%20Server).
 
 ## Launch File
@@ -160,9 +145,6 @@ An example launch file that will set the appropriate ROSPARAM values required fo
     <param name="ROS_TCP_PORT" type="int" value="10000" />
     <param name="TCP_NODE_NAME" type="str" value="TCPServer" />
 
-    <param name="UNITY_IP" type="str" value="192.168.1.105" />
-    <param name="UNITY_SERVER_PORT" type="int" value="5005" />
-
 	<group ns="position_service_and_endpoint">
 	       <node pkg="robotics_demo" name="position_service" type="position_service.py"/>
 	       <node pkg="robotics_demo" name="server_endpoint" type="server_endpoint.py"/>
diff --git a/tutorials/ros_unity_integration/service.md b/tutorials/ros_unity_integration/service.md
@@ -98,7 +98,7 @@ public class RosServiceExample : MonoBehaviour
 }
 ```
 
-- Create an empty GameObject, name it `RosConnection`, and attach the `Plugins/TCPConnection/ROSConnection` script to it.
+- Create an empty GameObject, name it `RosConnection`, and attach the `Plugins/TCPConnection/ROSConnection` script to it. (Or, if you're reusing the same scene from the previous tutorials, you can just keep the existing RosConnection object.)
 - In the Inspector window of the Editor change the `Host Name` variable on the `RosConnection` GameObject to the ROS IP.
 - Create another empty GameObject and name it `RosService`.
 - Attach the `RosServiceExample` script to the `RosService` GameObject. Drag the cube GameObject onto its `cube` parameter and the RosConnection GameObject onto its `Ros` parameter.
diff --git a/tutorials/ros_unity_integration/setup.md b/tutorials/ros_unity_integration/setup.md
@@ -19,19 +19,13 @@ Once ROS Core has started, it will print `started core service [/rosout]` to the
 
 1. Note that in the `server_endpoint`, the script fetches parameters for the TCP connection. You will need to know the IP address of your ROS machine as well as the IP address of the machine running Unity. 
    - The ROS machine IP, i.e. `ROS_IP` should be the same value as the one set as `Host Name` on the RosConnect component in Unity.
-   - Finding the IP address of your local machine (the one running Unity), i.e. `UNITY_IP` depends on your operating system. 
-     - On a Mac, open `System Preferences > Network`. Your IP address should be listed on the active connection.
-     - On Windows, click the Wi-Fi icon on the taskbar, and open `Properties`. Your IP address should be listed near the bottom, next to "IPv4 address."
-
 1. The ROS parameter values can be set using a YAML file. Create a `params.yaml` file in your package, e.g. `./config/params.yaml`. Open the file for editing. 
 
-1. Update the `ROS_IP` and `UNITY_IP` below with the appropriate addresses and copy the contents into the `params.yaml` file.
+1. Update the `ROS_IP` below with the appropriate address and copy the contents into the `params.yaml` file.
 
     ```yaml
     ROS_IP: <your ROS IP>
     ROS_TCP_PORT: 10000
-    UNITY_IP: <your Unity IP>
-    UNITY_SERVER_PORT: 5005
     rosdistro: 'melodic'
     ```
     
@@ -40,12 +34,10 @@ Once ROS Core has started, it will print `started core service [/rosout]` to the
     ```yaml
     ROS_IP: 192.168.50.149
     ROS_TCP_PORT: 10000
-    UNITY_IP: 192.168.50.13
-    UNITY_SERVER_PORT: 5005
     rosdistro: 'melodic'
     ```
 
-    Ensure that the `ROS_TCP_PORT` is set to 10000, and the `UNITY_SERVER_PORT` is set to 5005.
+    Ensure that the `ROS_TCP_PORT` is set to 10000.
 
 1. Set these newly defined parameters by running `rosparam load`, e.g.:
 
diff --git a/tutorials/ros_unity_integration/subscriber.md b/tutorials/ros_unity_integration/subscriber.md
@@ -30,38 +30,34 @@ Once the server_endpoint has started, it will print something similar to `[INFO]
 	- **Note** Script can be found at `tutorials/ros_unity_integration/unity_scripts`
 
 ```csharp
-using System.Net.Sockets;
-using System.Threading.Tasks;
 using UnityEngine;
 using RosColor = RosMessageTypes.RoboticsDemo.UnityColor;
 
-public class RosSubscriberExample : RosSubscriber
+public class RosSubscriberExample : MonoBehaviour
 {
+    public ROSConnection ros;
     public GameObject cube;
 
-    protected override async Task HandleConnectionAsync(TcpClient tcpClient)
+    void Start()
     {
-        await Task.Yield();
-
-        using (var networkStream = tcpClient.GetStream())
-        {
-            RosColor colorMessage = (RosColor)ReadMessage(networkStream, new RosColor());
-            Debug.Log("Color(" + colorMessage.r + ", "+ colorMessage.g + ", "+ colorMessage.b + ", "+ colorMessage.a +")");
-            cube.GetComponent<Renderer>().material.color = new Color32((byte)colorMessage.r, (byte)colorMessage.g, (byte)colorMessage.b, (byte)colorMessage.a);
-        }
+        ros.Subscribe<RosColor>("color", ColorChange);
     }
 
-    void Start()
+    void ColorChange(RosColor colorMessage)
     {
-        StartMessageServer();
+        cube.GetComponent<Renderer>().material.color = new Color32((byte)colorMessage.r, (byte)colorMessage.g, (byte)colorMessage.b, (byte)colorMessage.a);
     }
-
 }
 ```
 
+- Create an empty GameObject, name it `RosConnection` and attach the `Plugins/TcpConnector/ROSConnection` script. (Or, if you're reusing the same scene from the Publisher tutorial, you can just keep the existing RosConnection object.)
+	- Change the host name and port to match the ROS IP and port variables defined when you set up ROS.
+	- The IP for Unity to listen on should be determined automatically, but if you're having trouble, you can set it manually in the `Override Unity IP` field. Finding the IP address of your local machine (the one running Unity) depends on your operating system.
+		- On a Mac, open `System Preferences > Network`. Your IP address should be listed on the active connection.
+		- On Windows, click the Wi-Fi icon on the taskbar, and open `Properties`. Your IP address should be listed near the bottom, next to "IPv4 address."
+
 - Create an empty GameObject and name it `RosSubscriber`
-- Attach the `RosSubscriberExample` script to the `RosSubscriber` GameObject and drag the cube GameObject onto the `cube` parameter in the Inspector window.
-- In the Inspector window of the Editor change the `unityHostName` parameter on the `RosSubscriber ` GameObject to the Unity machine's URI. (Note for Windows users: the connection will be rejected unless you put the actual IP address ROS is connecting to. That's not necessarily the same as your machine's main IP address.)
+- Attach the `RosSubscriberExample` script to the `RosSubscriber` GameObject, drag the cube GameObject onto the `cube` parameter in the Inspector window and the `RosConnection` object onto the `ros` parameter.
 - Press play in the editor
 
 ### In ROS Terminal Window
diff --git a/tutorials/ros_unity_integration/unity_scripts/RosSubscriberExample.cs b/tutorials/ros_unity_integration/unity_scripts/RosSubscriberExample.cs

Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ public class RosServiceExample : MonoBehaviour`
`98`	`98`	`}`
`99`	`99`	```
`100`	`100`
`101`		-- Create an empty GameObject, name it `RosConnection`, and attach the `Plugins/TCPConnection/ROSConnection` script to it.
	`101`	+- Create an empty GameObject, name it `RosConnection`, and attach the `Plugins/TCPConnection/ROSConnection` script to it. (Or, if you're reusing the same scene from the previous tutorials, you can just keep the existing RosConnection object.)
`102`	`102`	- In the Inspector window of the Editor change the `Host Name` variable on the `RosConnection` GameObject to the ROS IP.
`103`	`103`	- Create another empty GameObject and name it `RosService`.
`104`	`104`	- Attach the `RosServiceExample` script to the `RosService` GameObject. Drag the cube GameObject onto its `cube` parameter and the RosConnection GameObject onto its `Ros` parameter.