Rfc0012 configuration file

.vscode/settings.json

@@ -4,7 +4,8 @@
       "GPIO",
       "Jetson",
       "mjpeg",
-      "teleop"
+      "teleop",
+      "VESC"
     ],
     "python.analysis.typeCheckingMode": "off",
     "liveServer.settings.port": 5501,

BYODR_utils/common/__init__.py

@@ -174,6 +174,8 @@ def run(self):
 
 
 class ApplicationExit(object):
+    """Encapsulate the logic for checking if an application should exit and then performing the necessary action to shut down the application. It's designed as a callable object (using the __call__ method) so that it can be used like a function."""
+
     def __init__(self, event, cb):
         self._event = event
         self._cb = cb

jetson_runtime/coms/Dockerfile

@@ -0,0 +1,26 @@
+FROM centipede2donald/ubuntu-bionic:python36-opencv32-gstreamer10
+
+RUN apt-get update && apt-get install -y \
+  build-essential \
+  libssl-dev \
+  libffi-dev \
+  python3-dev \
+  python3-pip \
+  libxml2-dev \
+  libxslt1-dev \
+  unzip  
+
+RUN python3 -m pip install -U pip
+RUN pip3 install paramiko pythonping
+
+
+# Copy application files
+COPY ./BYODR_utils/common/ /app/BYODR_utils/common/
+COPY ./BYODR_utils/JETSON_specific/ /app/BYODR_utils/JETSON_specific/
+
+COPY ./coms/coms /app/coms
+ENV PYTHONPATH "/app:${PYTHONPATH}"
+WORKDIR /app/coms
+
+# CMD ["ls"]
+CMD ["python3", "app.py","--name", "coms"]

jetson_runtime/coms/coms/app.py

@@ -0,0 +1,55 @@
+import argparse
+import logging
+import multiprocessing
+import signal
+
+
+from coms.common_utils import *
+from coms.robot_comm import *
+
+# This flag starts as false
+quit_event = multiprocessing.Event()
+quit_event.clear()
+
+signal.signal(signal.SIGINT, lambda sig, frame: _interrupt())
+signal.signal(signal.SIGTERM, lambda sig, frame: _interrupt())
+
+
+# Set the flag as true when we receive interrupt signals
+def _interrupt():
+    logger.info("Received interrupt, quitting.")
+    quit_event.set()
+
+
+def main():
+    # Adding the parser here for a static design pattern between all services
+    parser = argparse.ArgumentParser(description="Communication sockets server.")
+    parser.add_argument("--name", type=str, default="none", help="Process name.")
+    parser.add_argument("--config", type=str, default="/config", help="Config directory path.")
+    args = parser.parse_args()
+
+    application = ComsApplication(event=quit_event, config_dir=args.config)
+    application.setup()
+    tel_chatter = TeleopChatter(application.get_robot_config_file(), application.get_user_config_file())
+    socket_manager = SocketManager(tel_chatter, quit_event=quit_event)
+
+    socket_manager.start_threads()
+
+    logger.info("Ready")
+    try:
+        while not quit_event.is_set():
+            socket_manager.get_teleop_chatter()
+    except KeyboardInterrupt:
+        quit_event.set()
+    finally:
+        socket_manager.join_threads()
+
+    return 0
+
+
+if __name__ == "__main__":
+    # Declaring the logger
+    logging.basicConfig(format="%(levelname)s: %(asctime)s %(filename)s %(funcName)s %(message)s", datefmt="%Y%m%d:%H:%M:%S %p %Z")
+    logging.getLogger().setLevel(logging.INFO)
+    logger = logging.getLogger(__name__)
+    main()

jetson_runtime/coms/coms/client.py

@@ -0,0 +1,71 @@
+import socket
+import logging
+import time
+import json
+from BYODR_utils.JETSON_specific.utilities import Nano
+nano_ip = Nano.get_ip_address()
+
+
+# Declaring the logger
+logger = logging.getLogger(__name__)
+log_format = "%(levelname)s: %(filename)s %(funcName)s %(message)s"
+
+
+class Segment_client():
+
+    # Method that is called after the class is being initiated, to give it its values
+    def __init__(self, arg_server_ip, arg_server_port, arg_timeout):
+
+        # Giving the class the values from the class call
+        self.server_ip = arg_server_ip # The IP of the server that the client will connect to
+        self.server_port = arg_server_port # The port of the server that the client will connect to
+        self.timeout = arg_timeout # Maybe 100ms
+        self.socket_initialized = False # Variable that keeps track if we have a functioning socket to a server
+        self.msg_to_server = None
+        self.msg_from_server = None
+
+        # The client socket that will connect to the server
+        self.client_socket = None
+
+
+    # Establish the connection to the server
+    def connect_to_server(self):
+
+        try:
+            # Close the current socket, if it exists
+            self.close_connection()
+
+            self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Remake the socket and reconnect
+            self.client_socket.settimeout(self.timeout) # Set the timeout for all the back and forth between the server/client
+            self.client_socket.connect((self.server_ip, self.server_port)) # Connect to the server
+            logger.info("[Client] Connected to server.")
+            self.socket_initialized = True
+
+        except Exception as e:
+            logger.warning(f"[Client] Got error trying to connect to the server: {e}.\nTrying to reconnect...")
+            time.sleep(2)  # Wait for a while before retrying
+
+
+    # Close the malfunctioning socket if we lose connection to the server.
+    # We will make a new one and try to reconnect
+    def close_connection(self):
+
+        while self.socket_initialized:
+            try:
+                self.client_socket.shutdown(socket.SHUT_RDWR)
+                self.client_socket.close()
+                self.socket_initialized = False
+            except Exception as e:
+                logger.warning(f"[Client] Error while closing socket: {e}")
+                time.sleep(2)
+
+
+    # Sending data to the server
+    def send_to_FL(self):
+        message_to_send = json.dumps(self.msg_to_server)
+        self.client_socket.send(message_to_send.encode("utf-8"))
+
+
+    # Receiving data from the server
+    def recv_from_FL(self):
+        self.msg_from_server = self.client_socket.recv(512).decode("utf-8")

jetson_runtime/coms/coms/command_processor.py

@@ -0,0 +1,22 @@
+import logging
+from BYODR_utils.common import timestamp
+
+
+# Declaring the logger
+logger = logging.getLogger(__name__)
+log_format = "%(levelname)s: %(filename)s %(funcName)s %(message)s"
+
+
+
+def process(movement_command):
+
+    if type(movement_command) is dict:
+
+        # We reverse throttle and inverse steering
+        movement_command["throttle"] = -(movement_command["throttle"])
+        movement_command["steering"] = -(movement_command["steering"])
+
+        # Replacing the received command's timestamp with a current one
+        movement_command["time"] = timestamp()
+
+    return movement_command