Merge pull request pyocd#207 from c1728p9/pydaplink_preparation

Refactor pyOCD in preperation for pyDAPAccess

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,9 +18,7 @@
 import board
 import flash
 import gdbserver
-import interface
 import target
-import transport
 import utility
 
 from ._version import version as __version__

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.pyDAPAccess import DAPAccess
 
 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.name = ""
         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
 
@@ -117,14 +119,15 @@ def getInfo(self):
         """
         Return info on the board
         """
-        return Board.getInfo(self) + " [" + self.target_type + "]"
+        return self.name + " [" + self.target_type + "]"
 
     @staticmethod
-    def listConnectedBoards(transport="cmsis_dap"):
+    def listConnectedBoards(dap_class=DAPAccess):
         """
         List the connected board info
         """
-        all_mbeds = MbedBoard.getAllConnectedBoards(close=True, blocking=False)
+        all_mbeds = MbedBoard.getAllConnectedBoards(dap_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(dap_class=DAPAccess, 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_daps = dap_class.get_connected_devices()
+            for dap_access in connected_daps:
+                new_mbed = MbedBoard(dap_access, 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 dap_access in connected_daps:
+                    dap_access.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(dap_class=DAPAccess, 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(dap_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 pyOCD.pyDAPAccess import DAPAccess
 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 DAPAccess.TransferError:
             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 DAPAccess.TransferError:
             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 DAPAccess.TransferError:
             logging.debug("writeMemory failed at 0x%x" % addr)
             resp = 'E01' #EPERM
 

pyOCD/transport/__init__.py pyOCD/pyDAPAccess/__init__.py

@@ -14,8 +14,8 @@
  See the License for the specific language governing permissions and
  limitations under the License.
 """
+from .dap_access_api import DAPAccessIntf
+from .dap_access_usb import DAPAccessUSB
 
-from cmsis_dap import CMSIS_DAP
-
-TRANSPORT = {'cmsis_dap': CMSIS_DAP
-            }
+# alias DAPAccessUSB as main DAPAccess class
+DAPAccess = DAPAccessUSB