[Debugger] Implementation of transport over serial connection (#2800)

JerryScript-DCO-1.0-Signed-off-by: Robert Sipka [email protected]

Author: robertsipka

docs/07.DEBUGGER.md

@@ -68,9 +68,11 @@ When using the extension-provided WebSocket transport layer, the
 debugger can be enabled by calling `jerryx_debugger_after_connect
 (jerryx_debugger_tcp_create (debug_port) && jerryx_debugger_ws_create ())`
 after the `jerry_init ()` function. It initializes the debugger and
-blocks until a client connects. (Custom transport layers may be
-implemented and initialized similarly. Currently, `jerryx_debugger_rp_create()` for
-raw packet transport layer is also available.)
+blocks until a client connects.
+(Custom transport layers may be implemented and initialized similarly.
+Currently, `jerryx_debugger_rp_create ()` for raw packet transport layer and
+`jerryx_debugger_serial_create (const char* config)` for serial protocol
+are also available.)
 
 The resource name provided to `jerry_parse ()` is used by the client
 to identify the resource name of the source code. This resource name

jerry-core/api/jerry.c

@@ -193,6 +193,8 @@ jerry_cleanup (void)
 #ifdef JERRY_DEBUGGER
   if (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
   {
+    jerry_debugger_send_type (JERRY_DEBUGGER_CLOSE_CONNECTION);
+
     jerry_debugger_transport_close ();
   }
 #endif /* JERRY_DEBUGGER */

jerry-core/debugger/debugger.c

@@ -38,9 +38,9 @@ typedef struct
  * The number of message types in the debugger should reflect the
  * debugger versioning.
  */
-JERRY_STATIC_ASSERT (JERRY_DEBUGGER_MESSAGES_OUT_MAX_COUNT == 32
+JERRY_STATIC_ASSERT (JERRY_DEBUGGER_MESSAGES_OUT_MAX_COUNT == 33
                      && JERRY_DEBUGGER_MESSAGES_IN_MAX_COUNT == 21
-                     && JERRY_DEBUGGER_VERSION == 8,
+                     && JERRY_DEBUGGER_VERSION == 9,
                      debugger_version_correlates_to_message_type_count);
 
 /**

jerry-core/debugger/debugger.h

@@ -156,6 +156,7 @@ typedef enum
   JERRY_DEBUGGER_SCOPE_CHAIN_END = 29, /**< last output of scope chain */
   JERRY_DEBUGGER_SCOPE_VARIABLES = 30, /**< scope variables */
   JERRY_DEBUGGER_SCOPE_VARIABLES_END = 31, /**< last output of scope variables */
+  JERRY_DEBUGGER_CLOSE_CONNECTION = 32, /**< close connection with the client */
   JERRY_DEBUGGER_MESSAGES_OUT_MAX_COUNT, /**< number of different type of output messages by the debugger */
 
   /* Messages sent by the client to server. */

jerry-core/include/jerryscript-debugger.h

@@ -31,7 +31,7 @@ extern "C"
 /**
  * JerryScript debugger protocol version.
  */
-#define JERRY_DEBUGGER_VERSION (8)
+#define JERRY_DEBUGGER_VERSION (9)
 
 /**
  * Types for the client source wait and run method.

jerry-debugger/jerry_client.py

@@ -24,6 +24,11 @@
 import time
 import jerry_client_main
 
+from jerry_client_websocket import WebSocket
+from jerry_client_rawpacket import RawPacket
+from jerry_client_tcp import Socket
+from jerry_client_serial import Serial
+
 def write(string):
     print(string, end='')
 
@@ -246,14 +251,40 @@ def src_check_args(args):
         print("Error: Non-negative integer number expected: %s" % (val_errno))
         return -1
 
-# pylint: disable=too-many-branches,too-many-locals,too-many-statements
+# pylint: disable=too-many-branches,too-many-locals,too-many-statements,redefined-variable-type
 def main():
     args = jerry_client_main.arguments_parse()
 
-    debugger = jerry_client_main.JerryDebugger(args.address, args.channel)
+    channel = None
+    protocol = None
+
+    if args.protocol == "tcp":
+        address = None
+        if ":" not in args.address:
+            address = (args.address, 5001) # use default port
+        else:
+            host, port = args.address.split(":")
+            address = (host, int(port))
+
+        protocol = Socket(address)
+    elif args.protocol == "serial":
+        protocol = Serial(args.serial_config)
+    else:
+        print("Unsupported transmission protocol")
+        return -1
+
+    if args.channel == "websocket":
+        channel = WebSocket(protocol=protocol)
+    elif args.channel == "rawpacket":
+        channel = RawPacket(protocol=protocol)
+    else:
+        print("Unsupported communication channel")
+        return -1
+
+    debugger = jerry_client_main.JerryDebugger(channel)
     debugger.non_interactive = args.non_interactive
 
-    logging.debug("Connected to JerryScript on %d port", debugger.port)
+    logging.debug("Connected to JerryScript")
 
     prompt = DebuggerPrompt(debugger)
     prompt.prompt = "(jerry-debugger) "

jerry-debugger/jerry_client_main.py

@@ -21,12 +21,9 @@
 import select
 import struct
 import sys
-from jerry_client_websocket import WebSocket
-from jerry_client_rawpacket import RawPacket
-from jerry_client_tcp import Socket
 
 # Expected debugger protocol version.
-JERRY_DEBUGGER_VERSION = 8
+JERRY_DEBUGGER_VERSION = 9
 
 # Messages sent by the server to client.
 JERRY_DEBUGGER_CONFIGURATION = 1
@@ -60,6 +57,7 @@
 JERRY_DEBUGGER_SCOPE_CHAIN_END = 29
 JERRY_DEBUGGER_SCOPE_VARIABLES = 30
 JERRY_DEBUGGER_SCOPE_VARIABLES_END = 31
+JERRY_DEBUGGER_CLOSE_CONNECTION = 32
 
 # Debugger option flags
 JERRY_DEBUGGER_LITTLE_ENDIAN = 0x1
@@ -123,7 +121,7 @@ def arguments_parse():
     parser = argparse.ArgumentParser(description="JerryScript debugger client")
 
     parser.add_argument("address", action="store", nargs="?", default="localhost:5001",
-                        help="specify a unique network address for connection (default: %(default)s)")
+                        help="specify a unique network address for tcp connection (default: %(default)s)")
     parser.add_argument("-v", "--verbose", action="store_true", default=False,
                         help="increase verbosity (default: %(default)s)")
     parser.add_argument("--non-interactive", action="store_true", default=False,
@@ -138,6 +136,10 @@ def arguments_parse():
                         help="specify a javascript source file to execute")
     parser.add_argument("--channel", choices=["websocket", "rawpacket"], default="websocket",
                         help="specify the communication channel (default: %(default)s)")
+    parser.add_argument("--protocol", choices=["tcp", "serial"], default="tcp",
+                        help="specify the transmission protocol over the communication channel (default: %(default)s)")
+    parser.add_argument("--serial-config", metavar="CONFIG_STRING", default="/dev/ttyUSB0,115200,8,N,1",
+                        help="Configure parameters for serial port (default: %(default)s)")
     args = parser.parse_args()
 
     if args.verbose:
@@ -266,17 +268,7 @@ def get_text(self):
 
 class JerryDebugger(object):
     # pylint: disable=too-many-instance-attributes,too-many-statements,too-many-public-methods,no-self-use,redefined-variable-type
-    def __init__(self, address, channel):
-
-        if ":" not in address:
-            self.host = address
-            self.port = 5001  # use default port
-        else:
-            self.host, self.port = address.split(":")
-            self.port = int(self.port)
-
-        print("Connecting to: %s:%s" % (self.host, self.port))
-
+    def __init__(self, channel):
         self.prompt = False
         self.function_list = {}
         self.source = ''
@@ -304,15 +296,7 @@ def __init__(self, address, channel):
         self.non_interactive = False
         self.current_out = b""
         self.current_log = b""
-        self.channel = None
-
-        protocol = Socket()
-        if channel == "websocket":
-            self.channel = WebSocket(address=(self.host, self.port), protocol=protocol)
-        elif channel == "rawpacket":
-            self.channel = RawPacket(address=(self.host, self.port), protocol=protocol)
-        else:
-            raise Exception("Unsupported communication channel")
+        self.channel = channel
 
         config_size = 8
         # The server will send the configuration message after connection established
@@ -697,7 +681,6 @@ def send_no_more_source(self):
     # pylint: disable=too-many-branches,too-many-locals,too-many-statements,too-many-return-statements
     def process_messages(self):
         result = ""
-
         while True:
             data = self.channel.get_message(False)
             if not self.non_interactive:
@@ -846,6 +829,9 @@ def process_messages(self):
 
                 return DebuggerAction(DebuggerAction.TEXT, result)
 
+            elif JERRY_DEBUGGER_CLOSE_CONNECTION:
+                return DebuggerAction(DebuggerAction.END, "")
+
             else:
                 raise Exception("Unknown message")
 

jerry-debugger/jerry_client_rawpacket.py

@@ -20,14 +20,13 @@
 
 class RawPacket(object):
     """ Simplified transmission layer. """
-    def __init__(self, address, protocol):
+    def __init__(self, protocol):
         self.protocol = protocol
         self.data_buffer = b""
-        self.address = address
 
     def connect(self, config_size):
         """  Create connection. """
-        self.protocol.connect(self.address)
+        self.protocol.connect()
         self.data_buffer = b""
 
         # It will return with the Network configurations, which has the following struct:

jerry-debugger/jerry_client_serial.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+
+# Copyright JS Foundation and other contributors, http://js.foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import select
+import serial
+
+class Serial(object):
+    """ Create a new socket using the given address family, socket type and protocol number. """
+    def __init__(self, serial_config):
+        config = serial_config.split(',')
+        config_size = len(config)
+
+        port = config[0] if config_size > 0 else "/dev/ttyUSB0"
+        baudrate = config[1] if config_size > 1 else 115200
+        bytesize = int(config[2]) if config_size > 2 else 8
+        parity = config[3] if config_size > 3 else 'N'
+        stopbits = int(config[4]) if config_size > 4 else 1
+
+        self.ser = serial.Serial(port=port, baudrate=baudrate, parity=parity,
+                                 stopbits=stopbits, bytesize=bytesize, timeout=1)
+
+    def connect(self):
+        """ Connect to the server, write a 'c' to the serial port """
+        self.send_data('c')
+
+    def close(self):
+        """"  close the serial port. """
+        self.ser.close()
+
+    def receive_data(self, max_size=1024):
+        """ The maximum amount of data to be received at once is specified by max_size. """
+        return self.ser.read(max_size)
+
+    def send_data(self, data):
+        """ Write data to the serial port. """
+        return self.ser.write(data)
+
+    def ready(self):
+        """ Monitor the file descriptor. """
+        result = select.select([self.ser.fileno()], [], [], 0)[0]
+
+        return self.ser.fileno() in result

jerry-debugger/jerry_client_tcp.py

@@ -17,17 +17,20 @@
 import socket
 import select
 
+# pylint: disable=too-many-arguments,superfluous-parens
 class Socket(object):
     """ Create a new socket using the given address family, socket type and protocol number. """
-    def __init__(self, socket_family=socket.AF_INET, socket_type=socket.SOCK_STREAM, proto=0, fileno=None):
+    def __init__(self, address, socket_family=socket.AF_INET, socket_type=socket.SOCK_STREAM, proto=0, fileno=None):
+        self.address = address
         self.socket = socket.socket(socket_family, socket_type, proto, fileno)
 
-    def connect(self, address):
+    def connect(self):
         """
         Connect to a remote socket at address (host, port).
         The format of address depends on the address family.
         """
-        self.socket.connect(address)
+        print("Connecting to: %s:%s" % (self.address[0], self.address[1]))
+        self.socket.connect(self.address)
 
     def close(self):
         """" Mark the socket closed. """