Improve net-to-serial proxy

daemons/config.ini

@@ -0,0 +1,10 @@
+[Daemon]
+LogLevel = debug
+ListeningIP = 0.0.0.0
+ListeningPort = 2560
+
+[Serial]
+Port = /dev/ttyACM0
+Baudrate = 115200
+# Timeout in milliseconds
+Timeout = 100

daemons/net-to-serial.py

@@ -1,11 +1,15 @@
+import logging
 import serial
 import asyncio
+import configparser
 
 
 class SerialDaemon:
-    def __init__(self):
-        self.ser = serial.Serial('/dev/pts/7')  # WIP
-        self.ser.baudrate = 115200
+    def __init__(self, config):
+        self.ser = serial.Serial(
+            config["Serial"]["Port"],
+            timeout=int(config["Serial"]["Timeout"])/1000)
+        self.ser.baudrate = config["Serial"]["Baudrate"]
 
     def __del__(self):
         try:
@@ -15,27 +19,48 @@ class SerialDaemon:
 
     async def handle_echo(self, reader, writer):
         data = await reader.read(100)
-        message = data.decode()
         addr = writer.get_extra_info('peername')
 
-        print(f"Received {message!r} from {addr!r}")
+        logging.info("Received {} from {}".format(data, addr[0]))
 
         self.ser.write(data)
-        response = self.read_until()
-        print(f"Send: {response!r}")
+        response = line = self.ser.read()
+        while line.strip():
+            line = self.ser.read_until()
+            if not line.decode().startswith("<*"):
+                response += line
+        logging.info("Send: {}".format(response))
         writer.write(response)
         await writer.drain()
 
-        print("Close the connection")
+        logging.info("Close the connection")
         writer.close()
 
+    async def return_board(self):
+        self.ser.write(b'<s>')
+        self.ser.read_until()  # we need the second line
+        return(self.ser.read_until().decode().strip('\n'))
+
 
 async def main():
-    sd = SerialDaemon()
+    config = configparser.ConfigParser()
+    config.read("config.ini")
+    logging.basicConfig(level=config["Daemon"]["LogLevel"].upper())
+
+    sd = SerialDaemon(config)
     server = await asyncio.start_server(
-        sd.handle_echo, '127.0.0.1', 2560)  # WIP
-    addrs = ', '.join(str(sock.getsockname()) for sock in server.sockets)
-    print(f'Serving on {addrs}')
+        sd.handle_echo,
+        config["Daemon"]["ListeningIP"],
+        config["Daemon"]["ListeningPort"])
+    addr = server.sockets[0].getsockname()
+    logging.warning("Serving on {} port {}".format(addr[0], addr[1]))
+    logging.warning(
+        "Proxying to {} (Baudrate: {}, Timeout: {})".format(
+            config["Serial"]["Port"],
+            config["Serial"]["Baudrate"],
+            config["Serial"]["Timeout"]))
+    logging.warning(
+        await sd.return_board())
 
     async with server:
         await server.serve_forever()

dcc/driver/connector.py

@@ -6,14 +6,12 @@ from driver.models import DriverConfiguration
 class Connector:
 
     def __init__(self):
-        config = DriverConfiguration.get_solo()
-        self.remote_host = config.remote_host
-        self.remote_port = config.remote_port
+        self.config = DriverConfiguration.get_solo()
 
     def __send_data(self, message):
         # to be encoded
         with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            sock.connect((self.remote_host, self.remote_port))
+            sock.connect((self.config.remote_host, self.config.remote_port))
             sock.sendall(message)
             resp = sock.recv(1024)