Gamecontroller can Bind to a Different Port Based on Command Line Argument

src/software/field_tests/field_test_fixture.py

@@ -313,13 +313,34 @@ def load_command_line_arguments():
         help="Estop Baudrate",
     )
 
+    parser.add_argument(
+        "--gamecontroller_port",
+        type=int,
+        default=None,
+        help="The port number for the game controller.",
+    )
+
     parser.add_argument(
         "--run_yellow",
         action="store_true",
         default=False,
         help="Run the test with friendly robots in yellow mode",
     )
 
+    parser.add_argument(
+        "--sslvision_multicast_address",
+        type=str,
+        default=SSL_VISION_ADDRESS,
+        help="the multicast address for ssl vision",
+    )
+
+    parser.add_argument(
+        "--sslreferee_multicast_address",
+        type=str,
+        default=SSL_REFEREE_ADDRESS,
+        help="the multicast address for referee (game controller likely)",
+    )
+
     estop_group = parser.add_mutually_exclusive_group()
     estop_group.add_argument(
         "--keyboard_estop",
@@ -380,9 +401,12 @@ def field_test_runner():
         estop_mode=estop_mode,
         estop_path=estop_path,
         enable_radio=args.enable_radio,
+        referee_address=args.sslreferee_multicast_address,
+        sslvision_address=args.sslvision_multicast_address,
     ) as rc_friendly:
         with Gamecontroller(
-            supress_logs=(not args.show_gamecontroller_logs)
+            supress_logs=(not args.show_gamecontroller_logs),
+            gamecontroller_port=args.gamecontroller_port,
         ) as gamecontroller:
             friendly_fs.setup_proto_unix_io(friendly_proto_unix_io)
             rc_friendly.setup_for_fullsystem()

src/software/networking/ssl_proto_communication.py

@@ -34,9 +34,14 @@ def __init__(self, port: int) -> None:
 
         :param port the port to bind to
         """
-        # bind to all local interfaces, TCP
-        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.socket.connect(("", port))
+        try:
+            # bind to all local interfaces, TCP
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.socket.connect(("", port))
+        except ConnectionRefusedError:
+            raise ConnectionRefusedError(
+                f"SSL Socket connection refused on port {port}. Is binary already running in a separate process?"
+            )
 
     def send(self, proto: protobuf_message.Message) -> None:
         """

src/software/simulated_tests/simulated_test_fixture.py

@@ -493,6 +493,13 @@ def load_command_line_arguments():
         default=False,
         help="Use realism in the simulator",
     )
+
+    parser.add_argument(
+        "--gamecontroller_port",
+        type=int,
+        default=None,
+        help="The port number for the game controller.",
+    )
     return parser.parse_args()
 
 
@@ -542,7 +549,8 @@ def simulated_test_runner():
         should_restart_on_crash=False,
     ) as yellow_fs:
         with Gamecontroller(
-            supress_logs=(not args.show_gamecontroller_logs)
+            supress_logs=(not args.show_gamecontroller_logs),
+            gamecontroller_port=args.gamecontroller_port,
         ) as gamecontroller:
 
             blue_fs.setup_proto_unix_io(blue_full_system_proto_unix_io)

src/software/thunderscope/binary_context_managers/game_controller.py

@@ -27,17 +27,33 @@ class Gamecontroller(object):
     REFEREE_IP = "224.5.23.1"
     CI_MODE_OUTPUT_RECEIVE_BUFFER_SIZE = 9000
 
-    def __init__(self, supress_logs: bool = False) -> None:
+    def __init__(
+        self,
+        supress_logs: bool = False,
+        gamecontroller_port: int = None,
+        referee_addresse: int = None,
+    ) -> None:
         """Run Gamecontroller
 
         :param supress_logs: Whether to suppress the logs
+        :param gamecontroller_port: the port that the gamecontroller would bind to 
+        :param referee_address: the address the referee binds to
         """
         self.supress_logs = supress_logs
 
         # We need to find 2 free ports to use for the gamecontroller
         # so that we can run multiple gamecontroller instances in parallel
         self.referee_port = self.next_free_port()
-        self.ci_port = self.next_free_port()
+
+        self.REFEREE_IP = referee_addresse
+        if referee_addresse is None:
+            self.REFEREE_IP = "224.5.23.1"
+
+        self.ci_port = gamecontroller_port
+        if self.ci_port is None:
+            self.ci_port = self.next_free_port(40000)
+        else:
+            self.ci_port = self.next_free_port(self.ci_port)
 
         # this allows gamecontroller to listen to override commands
         self.command_override_buffer = ThreadSafeBuffer(
@@ -102,24 +118,35 @@ def refresh(self):
             )
             manual_command = self.command_override_buffer.get(return_cached=False)
 
-    def next_free_port(self, port: int = 40000, max_port: int = 65535) -> None:
+    def is_valid_port(self, port: int) -> bool:
+        """
+        Check if a port is available 
+
+        :param port: the port we are checking
+        :return: True if the port is available, False otherwise
+        """
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+        try:
+            sock.bind(("", port))
+            sock.close()
+            return True
+        except OSError:
+            return False
+
+    def next_free_port(self, start_port: int = 40000, max_port: int = 65535) -> int:
         """Find the next free port. We need to find 2 free ports to use for the gamecontroller
         so that we can run multiple gamecontroller instances in parallel.
 
-        :param port: The port to start looking from
+        :param start_port: The port to start looking from
         :param max_port: The maximum port to look up to
         :return: The next free port
 
         """
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-
-        while port <= max_port:
-            try:
-                sock.bind(("", port))
-                sock.close()
-                return port
-            except OSError:
-                port += 1
+        while start_port <= max_port:
+            if self.is_valid_port(start_port):
+                return start_port
+            start_port += 1
 
         raise IOError("no free ports")
 
@@ -150,7 +177,7 @@ def __send_referee_command(data: Referee) -> None:
                 autoref_proto_unix_io.send_proto(Referee, data)
 
         self.receive_referee_command = tbots_cpp.SSLRefereeProtoListener(
-            Gamecontroller.REFEREE_IP, self.referee_port, __send_referee_command, True,
+            self.REFEREE_IP, self.referee_port, __send_referee_command, True,
         )
 
         blue_full_system_proto_unix_io.register_observer(

src/software/thunderscope/robot_communication.py

@@ -27,6 +27,8 @@ def __init__(
         estop_path: os.PathLike = None,
         estop_baudrate: int = 115200,
         enable_radio: bool = False,
+        referee_address: str = None,
+        sslvision_address: str = None,
     ):
         """Initialize the communication with the robots
 
@@ -39,6 +41,15 @@ def __init__(
         :param enable_radio: Whether to use radio to send primitives to robots
 
         """
+        # setting up the ssl vision and referee addresses
+        self.ssl_vision_address = sslvision_address
+        if self.ssl_vision_address is None:
+            self.ssl_vision_address = SSL_VISION_ADDRESS
+
+        self.referee_address = referee_address
+        if self.referee_address is None:
+            self.referee_address = SSL_REFEREE_ADDRESS
+
         self.receive_ssl_referee_proto = None
         self.receive_ssl_wrapper = None
         self.sequence_number = 0
@@ -105,14 +116,14 @@ def setup_for_fullsystem(self) -> None:
         Sets up a listener for SSL vision and referee data, and connects all robots to fullsystem as default
         """
         self.receive_ssl_wrapper = tbots_cpp.SSLWrapperPacketProtoListener(
-            SSL_VISION_ADDRESS,
+            self.ssl_vision_address,
             SSL_VISION_PORT,
             lambda data: self.__forward_to_proto_unix_io(SSL_WrapperPacket, data),
             True,
         )
 
         self.receive_ssl_referee_proto = tbots_cpp.SSLRefereeProtoListener(
-            SSL_REFEREE_ADDRESS,
+            self.referee_address,
             SSL_REFEREE_PORT,
             lambda data: self.current_proto_unix_io.send_proto(Referee, data),
             True,

src/software/thunderscope/thunderscope_main.py

@@ -27,6 +27,7 @@
 from software.thunderscope.binary_context_managers.full_system import FullSystem
 from software.thunderscope.binary_context_managers.simulator import Simulator
 from software.thunderscope.binary_context_managers.game_controller import Gamecontroller
+
 from software.thunderscope.binary_context_managers.tigers_autoref import TigersAutoref
 
 
@@ -218,6 +219,27 @@
         help="Whether to populate with default robot positions (False) or start with an empty field (True) for AI vs AI",
     )
 
+    parser.add_argument(
+        "--gamecontroller_port",
+        type=int,
+        default=None,
+        help="The port number for the game controller.",
+    )
+
+    parser.add_argument(
+        "--sslvision_multicast_address",
+        type=str,
+        default=SSL_VISION_ADDRESS,
+        help="the multicast address for ssl vision",
+    )
+
+    parser.add_argument(
+        "--sslreferee_multicast_address",
+        type=str,
+        default=SSL_REFEREE_ADDRESS,
+        help="the multicast address for referee (game controller likely)",
+    )
+
     args = parser.parse_args()
 
     # Sanity check that an interface was provided
@@ -317,6 +339,8 @@
             estop_mode=estop_mode,
             estop_path=estop_path,
             enable_radio=args.enable_radio,
+            referee_address=args.sslreferee_multicast_address,
+            sslvision_address=args.sslvision_multicast_address,
         ) as robot_communication:
 
             if estop_mode == EstopMode.KEYBOARD_ESTOP:
@@ -428,7 +452,9 @@ def __ticker(tick_rate_ms: int) -> None:
             should_restart_on_crash=False,
             run_sudo=args.sudo,
         ) as yellow_fs, Gamecontroller(
-            supress_logs=(not args.verbose)
+            supress_logs=(not args.verbose),
+            gamecontroller_port=args.gamecontroller_port,
+            referee_addresse=args.sslreferee_multicast_address,
         ) as gamecontroller, (
             # Here we only initialize autoref if the --enable_autoref flag is requested.
             # To avoid nested Python withs, the autoref is initialized as None when this flag doesn't exist.