Refactor pyOCD in preperation for pyDapLink

Prepare pyOCD for daplink by using pyDapLink's interface.
Prior to this patch the board class depending on having both a
transport and an interface.  This caused the code to be more
tightly coupled to interfaces than it could be.

This patch combines most of the logic from the interface and transport
class and moves it into the DapLink class.  The DapLink class is an
implementation of the Link class, which provides all the functions
needed to communicate with a board.

More specific changes:
-Raw packet transfer test removed from speed test since pyDapLink
    will now be responsible for testing this
-References to 'transport' changed to 'link'
-Transport interface removed
-Interface code (usb drivers) moved into the transport folder to
    further isolate it from the rest of the codebase
-File cmsis_dap.py renamed to dap.py and moved into target folder
    for use by cortex_m.py and target_kinetis.py.  In the future
    dap.py will be removed and AP/DP drives will be used in
    its place.

Author: c1728p9

README.rst

@@ -222,17 +222,6 @@ gdb server:
 
 Architecture
 ------------
-
-Interface
-~~~~~~~~~
-
-An interface does the link between the target and the computer.
-This module contains basic functionalities to write and read data to and from
-an interface. You can inherit from ``Interface`` and overwrite
-``read()``, ``write()``, etc
-
-Then declare your interface in ``INTERFACE`` (in ``pyOCD.interface.__init__.py``)
-
 Target
 ~~~~~~
 

pyOCD/__init__.py

@@ -18,7 +18,6 @@
 import board
 import flash
 import gdbserver
-import interface
 import target
 import transport
 import utility

pyOCD/board/board.py

@@ -16,22 +16,18 @@
 """
 
 from pyOCD.target import TARGET
-from pyOCD.transport import TRANSPORT
-from pyOCD.interface import INTERFACE
 from pyOCD.flash import FLASH
 
 import logging
 import traceback
 
 class Board(object):
     """
-    This class associates a target, a flash, a transport and an interface
-    to create a board
+    This class associates a target, a flash and a link to create a board
     """
-    def __init__(self, target, flash, interface, transport="cmsis_dap", frequency=1000000):
-        self.interface = interface
-        self.transport = TRANSPORT[transport](self.interface)
-        self.target = TARGET[target](self.transport)
+    def __init__(self, target, flash, link, frequency=1000000):
+        self.link = link
+        self.target = TARGET[target](self.link)
         self.flash = FLASH[flash](self.target)
         self.target.setFlash(self.flash)
         self.debug_clock_frequency = frequency
@@ -47,22 +43,15 @@ def __exit__(self, type, value, traceback):
 
     def init(self):
         """
-        Initialize the board: interface, transport and target
+        Initialize the board
         """
         logging.debug("init board %s", self)
-        self.interface.init()
-        packet_count = self.getPacketCount()
-        logging.info("board allows %i concurrent packets", packet_count)
-        if packet_count < 1:
-            logging.error('packet count of %i outside of expected range', packet_count)
-            packet_count = 1
-        self.interface.setPacketCount(packet_count)
-        self.transport.init(self.debug_clock_frequency)
+        self.link.set_clock(self.debug_clock_frequency)
         self.target.init()
 
     def uninit(self, resume=True):
         """
-        Uninitialize the board: interface, transport and target.
+        Uninitialize the board: link and target.
         This function resumes the target
         """
         if self.closed:
@@ -77,27 +66,15 @@ def uninit(self, resume=True):
                 logging.error("target exception during uninit:")
                 traceback.print_exc()
         try:
-            self.transport.uninit()
+            self.link.disconnect()
         except:
-            logging.error("transport exception during uninit:")
+            logging.error("link exception during disconnect:")
             traceback.print_exc()
         try:
-            self.interface.close()
+            self.link.close()
         except:
-            logging.error("interface exception during uninit:")
+            logging.error("link exception during uninit:")
             traceback.print_exc()
 
     def getInfo(self):
-        # If the product name starts with the vendor name, we don't want to duplicate
-        # the vendor name, so just return the product name. Otherwise combined the two.
-        if self.interface.product_name.startswith(self.interface.vendor_name):
-            info = self.interface.product_name
-        else:
-            info = self.interface.vendor_name + " " + self.interface.product_name
-        return info
-
-    def getPacketCount(self):
-        """
-        Return the number of commands the remote device's buffer can hold.
-        """
-        return 1
+        return ""

pyOCD/board/mbed_board.py

@@ -20,7 +20,7 @@
 
 from time import sleep
 from board import Board
-from pyOCD.interface import INTERFACE, usb_backend
+from pyOCD.transport.daplink import DapLink
 
 class BoardInfo(object):
     def __init__(self, name, target, binary):
@@ -65,13 +65,15 @@ class MbedBoard(Board):
     Particularly, this class allows you to dynamically determine
     the type of all boards connected based on the id board
     """
-    def __init__(self, interface, board_id, unique_id, target=None, transport="cmsis_dap", frequency=1000000):
+    def __init__(self, link, target=None, frequency=1000000):
         """
         Init the board
         """
         self.name = None
         self.native_target = None
         self.test_binary = None
+        unique_id = link.get_unique_id()
+        board_id = unique_id[0:4]
         if board_id in BOARD_ID_TO_INFO:
             board_info = BOARD_ID_TO_INFO[board_id]
             self.name = board_info.name
@@ -85,7 +87,7 @@ def __init__(self, interface, board_id, unique_id, target=None, transport="cmsis
         if target is None:
             raise Exception("Unknown board target")
 
-        super(MbedBoard, self).__init__(target, target, interface, transport, frequency)
+        super(MbedBoard, self).__init__(target, target, link, frequency)
         self.unique_id = unique_id
         self.target_type = target
 
@@ -120,11 +122,12 @@ def getInfo(self):
         return Board.getInfo(self) + " [" + self.target_type + "]"
 
     @staticmethod
-    def listConnectedBoards(transport="cmsis_dap"):
+    def listConnectedBoards(link_class=DapLink):
         """
         List the connected board info
         """
-        all_mbeds = MbedBoard.getAllConnectedBoards(close=True, blocking=False)
+        all_mbeds = MbedBoard.getAllConnectedBoards(link_class, close=True,
+                                                    blocking=False)
         index = 0
         if len(all_mbeds) > 0:
             for mbed in all_mbeds:
@@ -134,74 +137,44 @@ def listConnectedBoards(transport="cmsis_dap"):
             print("No available boards are connected")
 
     @staticmethod
-    def getAllConnectedBoards(transport="cmsis_dap", close=False, blocking=True,
-                                target_override=None, frequency=1000000):
+    def getAllConnectedBoards(link_class=DapLink, close=False, blocking=True,
+                              target_override=None, frequency=1000000):
         """
         Return an array of all mbed boards connected
         """
-        first = True
-        while True:
-            while True:
-                if not first:
-                    # Don't eat up all the cpu if an unsupported board is connected.
-                    # Sleep before getting connected interfaces.  This way if a keyboard
-                    # exception comes in there will be no resources to close
-                    sleep(0.2)
-
-                all_mbeds = INTERFACE[usb_backend].getAllConnectedInterface(mbed_vid, mbed_pid)
-                if all_mbeds == None:
-                    all_mbeds = []
-
-                if not blocking:
-                    # No blocking so break from loop
-                    break
-
-                if len(all_mbeds) > 0:
-                    # A board has been found so break from loop
-                    break
 
-                if (first == True):
-                    logging.info("Waiting for a USB device connected")
-                    first = False
+        mbed_list = []
+        while True:
 
-            mbed_boards = []
-            for mbed in all_mbeds:
-                try:
-                    mbed.write([0x80])
-                    u_id_ = mbed.read()
-                    board_id = array.array('B', [i for i in u_id_[2:6]]).tostring()
-                    unique_id = array.array('B', [i for i in u_id_[2:2 + u_id_[1]]]).tostring()
-                    if board_id not in BOARD_ID_TO_INFO:
-                        logging.info("Unsupported board found: %s" % board_id)
-                        if target_override is None:
-                            # TODO - if no board can be determined treat this as a generic cortex-m device
-                            logging.info("Target could not be determined.  Specify target manually to use board")
-                            mbed.close()
-                            continue
+            connected_daplinks = link_class.get_connected_devices()
+            for daplink in connected_daplinks:
+                new_mbed = MbedBoard(daplink, target_override, frequency)
+                mbed_list.append(new_mbed)
 
-                    new_mbed = MbedBoard(mbed, board_id, unique_id, target_override, transport, frequency)
-                    logging.info("new board id detected: %s", unique_id)
-                    mbed_boards.append(new_mbed)
-                    if close:
-                        mbed.close()
-                except:
-                    #TODO - close all boards when an exception occurs
-                    mbed.close()
-                    raise
+            #TODO - handle exception on open
+            if not close:
+                for daplink in connected_daplinks:
+                    daplink.open()
 
-            if len(mbed_boards) > 0 or not blocking:
-                return mbed_boards
+            if not blocking:
+                break
+            elif len(mbed_list) > 0:
+                break
+            else:
+                sleep(0.01)
+            assert len(mbed_list) == 0
 
-            if (first == True):
-                logging.info("Waiting for a USB device connected")
-                first = False
+        return mbed_list
 
     @staticmethod
-    def chooseBoard(transport="cmsis_dap", blocking=True, return_first=False, board_id=None, target_override=None, frequency=1000000, init_board=True):
+    def chooseBoard(link_class=DapLink, blocking=True, return_first=False,
+                    board_id=None, target_override=None, frequency=1000000,
+                    init_board=True):
         """
         Allow you to select a board among all boards connected
         """
-        all_mbeds = MbedBoard.getAllConnectedBoards(transport, False, blocking, target_override, frequency)
+        all_mbeds = MbedBoard.getAllConnectedBoards(link_class, False, blocking,
+                                                    target_override, frequency)
 
         # If a board ID is specified close all other boards
         if board_id != None:
@@ -210,7 +183,7 @@ def chooseBoard(transport="cmsis_dap", blocking=True, return_first=False, board_
                 if mbed.unique_id == (board_id):
                     new_mbed_list.append(mbed)
                 else:
-                    mbed.interface.close()
+                    mbed.link.close()
             assert len(new_mbed_list) <= 1
             all_mbeds = new_mbed_list
 
@@ -225,7 +198,7 @@ def chooseBoard(transport="cmsis_dap", blocking=True, return_first=False, board_
         # Select first board and close others if True
         if return_first:
             for i in range(1, len(all_mbeds)):
-                all_mbeds[i].interface.close()
+                all_mbeds[i].link.close()
             all_mbeds = all_mbeds[0:1]
 
         # Ask use to select boards if there is more than 1 left
@@ -255,7 +228,7 @@ def chooseBoard(transport="cmsis_dap", blocking=True, return_first=False, board_
             # close all others mbed connected
             for mbed in all_mbeds:
                 if mbed != all_mbeds[ch]:
-                    mbed.interface.close()
+                    mbed.link.close()
             all_mbeds = all_mbeds[ch:ch + 1]
 
         assert len(all_mbeds) == 1
@@ -264,12 +237,6 @@ def chooseBoard(transport="cmsis_dap", blocking=True, return_first=False, board_
             try:
                 mbed.init()
             except:
-                mbed.interface.close()
+                mbed.link.close()
                 raise
         return mbed
-
-    def getPacketCount(self):
-        """
-        Return the number of commands the remote device's buffer can hold.
-        """
-        return self.transport.info('PACKET_COUNT')

pyOCD/gdbserver/gdbserver.py

@@ -16,7 +16,7 @@
 """
 
 from ..target.target import Target
-from ..transport.transport import Transport
+from ..transport.link import Link
 from ..utility.conversion import hexToByteList, hexEncode, hexDecode
 from gdb_socket import GDBSocket
 from gdb_websocket import GDBWebSocket
@@ -789,7 +789,7 @@ def getMemory(self, data):
                     val += hex(x)[2:4]
                 else:
                     val += '0' + hex(x)[2:3]
-        except Transport.TransferError:
+        except Link.Error:
             logging.debug("getMemory failed at 0x%x" % addr)
             val = 'E01' #EPERM
         return self.createRSPPacket(val)
@@ -813,7 +813,7 @@ def writeMemoryHex(self, data):
                 # Flush so an exception is thrown now if invalid memory was accessed
                 self.target.flush()
             resp = "OK"
-        except Transport.TransferError:
+        except Link.Error:
             logging.debug("writeMemory failed at 0x%x" % addr)
             resp = 'E01' #EPERM
 
@@ -843,7 +843,7 @@ def writeMemory(self, data):
                 # Flush so an exception is thrown now if invalid memory was accessed
                 self.target.flush()
             resp = "OK"
-        except Transport.TransferError:
+        except Link.Error:
             logging.debug("writeMemory failed at 0x%x" % addr)
             resp = 'E01' #EPERM