odrive 0.6.9.dev0__py37-none-win_amd64.whl

odrive/database.py

@@ -0,0 +1,184 @@
+import json
+import os
+from odrive.hw_version import HwVersion
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+
+class NotFoundError(Exception):
+    pass
+
+class Database():
+    def __init__(self, data):
+        self._data = data
+
+    def get_odrive_versions(self):
+        """
+        Returns all known ODrive board versions and their data as a collection
+        of tuples.
+        """
+        print("TODO: deprecated")
+        return self._data['odrives'].items()
+
+    def get_products(self):
+        """
+        Returns all known ODrive Robotics product line and version combinations.
+        The return type is a generator of tuples of the form
+        (product_name, product_data).
+        """
+        return [(k, v) for k, v in self._data['odrives'].items()]
+
+    def get_product(self, board: HwVersion):
+        """
+        Loads data for a particular ODrive Robotics board.
+        board: e.g. (4, 4, 58)
+        """
+        assert isinstance(board, HwVersion)
+        key = board
+        if not key in self._data['odrives']:
+            raise NotFoundError(f"{key} not found in product database")
+        return self._data['odrives'][key]
+
+    def get_motor(self, name: str):
+        """
+        Loads data for a particular motor model.
+        name: e.g. "D6374-150KV"
+        """
+        return self._data['motors'][name]
+
+    def get_brakeR(self, name: str):
+        """
+        Loads data for a particular brake resistor.
+        name: e.g. "500w2rj"
+        """
+        return self._data['brakeRs'][name]
+
+    def get_encoder(self, name: str):
+        """
+        Loads data for a particular encoder model.
+        name: e.g. "AMT10x"
+        """
+        return self._data['encoders'][name]
+
+    def get_encoders(self):
+        return list(self._data['encoders'].keys())
+
+
+def _process_motor(motor):
+    if "kv" in motor:
+        motor["torque_constant"] = 8.27 / motor["kv"]
+    else:
+        motor["kv"] = 8.27 / motor["torque_constant"]
+
+def _process_nothing(x):
+    pass
+
+
+def load(path = None, validate = False):
+    """
+    path: Path of the database folder. If none, the path is detected automatically.
+    validate: Validates all JSON files that are being loaded against their schema.
+    If this feature is used jsonschema must be installed.
+    """
+
+    db_dir0 = os.path.join(script_dir, 'data') # When running from pip install
+    db_dir1 = os.path.join(os.path.dirname(os.path.dirname(script_dir)), 'data') # When running from Git repo
+
+    if path is None:
+        if os.path.isdir(db_dir0):
+            path = db_dir0
+        elif os.path.isdir(db_dir1):
+            path = db_dir1
+        else:
+            raise Exception("Database not found.")
+
+    data = {
+        'odrives': {},
+        'drvs': {},
+        'motors': {},
+        'encoders': {},
+        'brakeRs': {}
+    }
+
+    loaders = {
+        'odrive': [_process_nothing, None],
+        'drv': [_process_nothing, None],
+        'motor': [_process_motor, None],
+        'encoder': [_process_nothing, None], 
+        'brakeR': [_process_nothing, None]
+    }
+
+    if validate:
+        import jsonschema
+        with open(os.path.join(path, "schema.json")) as fp:
+            schema = json.load(fp)
+        loaders['odrive'][1] = jsonschema.Draft4Validator({**schema, **{"$ref": "#/$defs/odrive"}})
+        loaders['drv'][1] = jsonschema.Draft4Validator({**schema, **{"$ref": "#/$defs/drv"}})
+        loaders['motor'][1] = jsonschema.Draft4Validator({**schema, **{"$ref": "#/$defs/motor"}})
+        loaders['encoder'][1] = jsonschema.Draft4Validator({**schema, **{"$ref": "#/$defs/encoder"}})
+        loaders['brakeR'][1] = jsonschema.Draft4Validator({**schema, **{"$ref": "#/$defs/brakeR"}})
+
+
+    for file in os.listdir(path):
+        name, ext = os.path.splitext(file)
+        file = os.path.join(path, file)
+        if os.path.isfile(file) and ext.lower() == '.json':
+            for k, (processor, validator) in loaders.items():
+                try:
+                    if name.startswith(k + '-') and ext.lower() == '.json':
+                        with open(file) as fp:
+                            item = json.load(fp)
+                            items = {item['name']: item}
+
+                    elif name == k + 's':
+                        with open(file) as fp:
+                            items = json.load(fp)
+                        assert(isinstance(items, dict))
+
+                    else:
+                        continue
+
+                    if validate:
+                        for item in items.values():
+                            validator.validate(item)
+
+                    for name, item in items.items():
+                        processor(item)
+                        data[k + 's'][name] = item
+
+                except Exception as ex:
+                    raise Exception("error while processing " + file) from ex
+
+    # Postprocessing: load metadata of gate driver chip for each inverter
+    for odrive in data['odrives'].values():
+        for inv in odrive['inverters']:
+            if len(inv['drv'].keys()) == 1 and '$ref' in inv['drv'].keys():
+                inv['drv'] = data['drvs'][inv['drv']['$ref']]
+
+    # Postprocessing: transform product string keys to board version triplets
+    data['odrives'] = {
+        {
+            'ODrive v3.6-24V': HwVersion(3, 6, 24),
+            'ODrive v3.6-56V': HwVersion(3, 6, 56),
+            'ODrive Pro v4.2-58V': HwVersion(4, 2, 58),
+            'ODrive Pro v4.3-58V': HwVersion(4, 3, 58),
+            'ODrive Pro v4.4-58V': HwVersion(4, 4, 58),
+            'ODrive S1 X1': HwVersion(5, 0, 0),
+            'ODrive S1 X3': HwVersion(5, 1, 0),
+            'ODrive S1 X4': HwVersion(5, 2, 0),
+            'ODrive Micro X1': HwVersion(6, 0, 0),
+            'ODrive Micro X3': HwVersion(6, 1, 0),
+            'ODrive Micro X4': HwVersion(6, 2, 0),
+        }[k]: v
+        for k, v in data['odrives'].items()
+    }
+
+    # Postprocessing: include inherited properties for each encoder
+    for key, encoder in list(data['encoders'].items()):
+        while 'inherits' in encoder:
+            inherited_encoder = data['encoders'][encoder['inherits']]
+            encoder.pop('inherits')
+            encoder = {**inherited_encoder, **encoder}
+        data['encoders'][key] = encoder
+
+    return Database(data)
+

odrive/dfu.py

@@ -0,0 +1,195 @@
+import aiohttp
+import asyncio
+import os
+from typing import Optional
+
+import fibre
+import odrive
+import odrive.firmware
+from odrive.release_api import VersionRelationship, format_version
+from .hw_version import HwVersion
+from .libodrive import Interface, LibODrive, Device, Firmware
+
+class DfuError(Exception):
+    pass
+
+async def enter_dfu_mode(device, discoverer: Interface) -> Device:
+    """
+    Puts the specified device into (new) DFU mode.
+    """
+    serial_number = "{:08X}".format(device.serial_number)
+    print("Putting device {:08X} into DFU mode...".format(device.serial_number))
+    try:
+        result = device.enter_dfu_mode2()
+    except fibre.ObjectLostError:
+        result = True # this is expected because the device reboots
+    if not result:
+        raise DfuError("Failed to enter DFU mode.")
+
+    device = await discoverer.wait_for(serial_number, is_bootloader=True)
+    await device.connect_bootloader()
+    return device
+
+async def write_firmware(device: Device, fw: Firmware, erase_all: bool):
+    def print_progress(new_action_group: bool, action_string: str, action_index: int, n_actions: int):
+        if new_action_group and action_index != 0:
+            print()
+        print(f"DFU: {action_string}    ", end='\r')
+    try:
+        await device.run_installation(fw, erase_all, print_progress)
+    finally:
+        print()
+
+async def await_first(tasks):
+    """
+    Awaits the first of several tasks or futures and cancels the others.
+    """
+    # TODO: is there any standard way to do this in one line?
+    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+    for t in pending:
+        t.cancel()
+    for t in pending:
+        try:
+            await t
+        except asyncio.CancelledError:
+            pass
+    return (await asyncio.gather(*done))[0]
+
+async def get_firmware(board: HwVersion, current_build_id_short: Optional[str], channel: Optional[str], version: Optional[str], logger, interactive: bool, release_type: str = 'firmware'):
+    async with aiohttp.ClientSession() as session:
+        if channel:
+            logger.info(f"Checking online for latest {board.display_name} {release_type} on channel {channel}...")
+        else:
+            logger.info(f"Checking online for {board.display_name} {release_type} version {format_version(version)}...")
+        api_client = odrive.api_client.ApiClient(session)
+        release_api = odrive.release_api.ReleaseApi(api_client)
+
+        firmware_index = await release_api.get_index(release_type)
+
+        # If we're fetching normal firmware, use whatever file the release
+        # server returns as preferred file URL.
+        # If we're fetching the bootloader, need to select between multiple
+        # files on the release server.
+        file = 'bootloader_installer.elf' if release_type == 'bootloader' else None
+
+        try:
+            if channel:
+                manifest = firmware_index.get_latest(channel, app='default', board=board, file=file)
+            else:
+                manifest = firmware_index.get_version(version, app='default', board=board, file=file)
+        except odrive.release_api.ChannelNotFoundError as ex:
+            raise DfuError(ex)
+        except odrive.release_api.FirmwareNotFoundError:
+            raise DfuError(f"No {release_type} found matching the specified criteria.")
+
+        if interactive:
+            version_relationship = firmware_index.compare(current_build_id_short, manifest['commit_hash'], channel, app='default', board=board)
+            prompt = {
+                VersionRelationship.UNKNOWN: "Found compatible firmware ({to_version}). Install now?",
+                VersionRelationship.EQUAL: "Your current firmware ({to_version}) is up to date. Do you want to reinstall this version?",
+                VersionRelationship.UPGRADE: "Found new firmware ({from_hash} => {to_version}). Install now?",
+                VersionRelationship.DOWNGRADE: "Found older firmware ({from_hash} => {to_version}). Install now?",
+            }[version_relationship]
+        
+            if not odrive.utils.yes_no_prompt(prompt.format(from_hash=current_build_id_short, to_version=format_version(manifest['commit_hash'])), True):
+                raise odrive.utils.OperationAbortedException()
+
+        logger.info(f"Downloading {release_type}...")
+        return odrive.firmware.FirmwareFile.from_file(await release_api.load(manifest))
+
+async def run_dfu(libodrive: LibODrive, dfu_discoverer: Interface, serial_number: Optional[str], path: Optional[str], channel: Optional[str], version: Optional[str], erase_all: bool, logger, interactive: bool = True):
+    """
+    See dfu_ui for description.
+    """
+    assert sum([bool(path), bool(channel), bool(version)]) == 1
+
+    logger.info("Waiting for ODrive...")
+
+    # Wait for device either in DFU mode or in normal mode, whichever is
+    # found first.
+    device = await await_first([
+        asyncio.create_task(odrive.find_any_async(serial_number=serial_number)),
+        asyncio.create_task(dfu_discoverer.wait_for(serial_number=serial_number, is_bootloader=True))
+    ])
+
+    found_in_dfu = isinstance(device, Device)
+
+    if not found_in_dfu:
+        bootloader_version = device.bootloader_version if hasattr(device, "bootloader_version") else 0
+        if bootloader_version == 0:
+            raise DfuError(
+                "New DFU system not installed on device {:08X}.\n"
+                "Please follow instructions for one-time setup here:\n"
+                "https://docs.odriverobotics.com/v/latest/guides/new-dfu.html\n"
+                "or use the legacy DFU system (odrivetool legacy-dfu)."
+                .format(device.serial_number)
+            )
+
+        # Note: we don't do ahead of time compatibility check until the
+        # bootloader version has stabilized. Just-in-time checking is
+        # handled in libodrive (when bootloader is already started).
+
+    if found_in_dfu:
+        await device.connect_bootloader()
+
+    if path:
+        assert os.path.isfile(path)
+        assert channel is None
+        file = odrive.firmware.FirmwareFile.from_file(path)
+    else:
+        board: HwVersion = device.hw_version if isinstance(device, Device) else device._board
+        build_id_short: Optional[str] = "{:08x}".format(device.commit_hash) if hasattr(device, 'commit_hash') else None
+        file = await get_firmware(board, build_id_short, channel, version, logger, interactive)
+
+    with libodrive.open_firmware(file.as_buffer()) as firmware:
+        print("loaded firmware: ")
+        print("  Version: " + str(".".join(str(n) for n in firmware.fw_version)))
+        print("  Build ID: " + "".join(f"{b:02x}" for b in firmware.build))
+        print("  Hardware: " + firmware.hw_version.display_name)
+
+        if not isinstance(device, Device):
+            device = await enter_dfu_mode(device, dfu_discoverer)
+
+        assert device.is_bootloader
+        await write_firmware(device, firmware, erase_all)
+
+    logger.info("Waiting for the device to reappear...")
+    device = await odrive.find_any_async(odrive.default_usb_search_path, serial_number)
+    logger.success("Device firmware update successful.")
+
+
+async def dfu_ui(serial_number: Optional[str], path: Optional[str], channel: Optional[str], version: Optional[str], erase_all: bool, logger, interactive: bool = True):
+    """
+    Runs the complete interactive DFU process:
+
+    1. Wait for device in either DFU mode or normal mode. If `serial_number` is
+       None, the first discovered device is selected, otherwise only the
+       specified device is accepted.
+
+    2. If `path` is None, check for the latest or specified firmware, present it
+       to the user and ask whether to continue. Otherwise don't ask and always
+       continue.
+
+    3. If the device is in normal mode, put it into DFU mode.
+
+    4. Erase, write and verify flash memory.
+
+    5. Exit DFU mode.
+
+    Parameters
+    ----------
+    path: Path to a .elf path or None to check online.
+    channel: Channel on which to check for firmware (master, devel, ...)
+    version: Exact firmware version
+    """
+    libodrive = LibODrive(loop=asyncio.get_running_loop())
+
+    try:
+        with libodrive.start_usb_discovery() as dfu_discoverer:
+            libodrive._worker_thread.start()
+            try:
+                await run_dfu(libodrive, dfu_discoverer, serial_number, path, channel, version, erase_all, logger, interactive)
+            finally:
+                libodrive.stop_thread()
+    finally:
+        libodrive.deinit()

odrive/dfuse/DfuDevice.py

@@ -0,0 +1,297 @@
+import usb.util
+import time
+import fractions
+import array
+from enum import Enum
+import time
+import math
+
+class RequestType(Enum):
+    SEND = 0x21
+    RECEIVE = 0xa1
+
+class Request(Enum):
+    DETACH    = 0x00
+    DNLOAD    = 0x01
+    UPLOAD    = 0x02
+    GETSTATUS = 0x03
+    CLRSTATUS = 0x04
+    GETSTATE  = 0x05
+    ABORT     = 0x06
+
+class Command(Enum):
+    SET_ADDRESS_POINTER = 0x21
+    ERASE = 0x41
+    READ_UNPROTECT = 0x92
+
+class DfuState(Enum):
+    APP_IDLE                = 0x00
+    APP_DETACH              = 0x01
+    DFU_IDLE                = 0x02
+    DFU_DOWNLOAD_SYNC       = 0x03
+    DFU_DOWNLOAD_BUSY       = 0x04
+    DFU_DOWNLOAD_IDLE       = 0x05
+    DFU_MANIFEST_SYNC       = 0x06
+    DFU_MANIFEST            = 0x07
+    DFU_MANIFEST_WAIT_RESET = 0x08
+    DFU_UPLOAD_IDLE         = 0x09
+    DFU_ERROR               = 0x0a
+
+class DfuStatus(Enum):
+    OK                 = 0x00
+    ERROR_TARGET       = 0x01
+    ERROR_FILE         = 0x02
+    ERROR_WRITE        = 0x03
+    ERROR_ERASE        = 0x04
+    ERROR_CHECK_ERASED = 0x05
+    ERROR_PROG         = 0x06
+    ERROR_VERIFY       = 0x07
+    ERROR_ADDRESS      = 0x08
+    ERROR_NOTDONE      = 0x09
+    ERROR_FIRMWARE     = 0x0a
+    ERROR_VENDOR       = 0x0b
+    ERROR_USBR         = 0x0c
+    ERROR_POR          = 0x0d
+    ERROR_UNKNOWN      = 0x0e
+    ERROR_STALLEDPKT   = 0x0f
+
+
+SIZE_MULTIPLIERS = {' ': 1, 'K': 1024, 'M' : 1024*1024}
+MAX_TRANSFER_SIZE = 2048
+
+# Order is LSB first
+def _address_to_4bytes(a):
+    return [ a % 256, (a >> 8)%256, (a >> 16)%256, (a >> 24)%256 ]
+
+def _get_dfu_functional_descriptors(interfaces):
+    for intf in interfaces:
+        pos = 0
+        desc = intf.extra_descriptors
+        while len(desc):
+            current_desc = desc[:desc[0]]
+            desc = desc[desc[0]:]
+            if current_desc[1] == 0x21:
+                yield current_desc
+
+
+class DfuError(Exception):
+    def __init__(self, message: str, status: DfuStatus, state: DfuState, text: str):
+        super().__init__(message + " Device responded with {}, {}, \"{}\".".format(status, state, text))
+
+class DfuDevice:
+    def __init__(self, device):
+        self._dev = device
+        self._memory = None
+
+    def init(self):
+        cfg = self._dev[0]
+        cfg.set()
+
+        dfu_desc = list(_get_dfu_functional_descriptors(cfg.interfaces()))
+        assert len(dfu_desc) == 1
+        dfu_desc = dfu_desc[0]
+
+        self._max_transfer_size = dfu_desc[5] + (dfu_desc[6] << 8)
+        assert self._max_transfer_size <= MAX_TRANSFER_SIZE
+
+        self.memories = {}
+        for intf in cfg.interfaces():
+            # example for intf_name:
+            # '@Internal Flash  /0x08000000/04*016Kg,01*064Kg,07*128Kg'
+            intf_name = usb.util.get_string(self._dev, intf.iInterface)
+            if intf_name.count('/') != 2:
+                raise Exception(f"invalid interface name for interface {intf.iInterface}: {intf_name}")
+            label, baseaddr, layout = intf_name.split('/')
+            baseaddr = int(baseaddr, 0) # convert hex to decimal
+            addr = baseaddr
+
+            memory = {
+                'intf': intf,
+                'alt': intf.bAlternateSetting,
+                'sectors': []
+            }
+
+            for sector in layout.split(','):
+                repeat, size = map(int, sector[:-2].split('*'))
+                size *= SIZE_MULTIPLIERS[sector[-2].upper()]
+                mode = sector[-1]
+
+                while repeat > 0:
+                    # TODO: verify if the section is writable
+                    memory['sectors'].append({
+                        'addr': addr,
+                        'len': size,
+                        'mode': mode
+                    })
+
+                    addr += size
+                    repeat -= 1
+
+            name = label.rstrip().lstrip('@')
+            self.memories[name] = memory
+
+    def select_memory(self, name):
+        self._memory = self.memories[name]
+        self._memory['intf'].set_altsetting()
+
+    def _control_msg(self, requestType: RequestType, request: Request, value: int, buffer):
+        if self._memory is None:
+            raise Exception("no memory selected")
+        return self._dev.ctrl_transfer(requestType.value, request.value, value, self._memory['intf'].bInterfaceNumber, buffer, timeout=60000)
+
+    def _detach(self, timeout):
+        """
+        timeout: Timeout in [??]
+        """
+        return self._control_msg(RequestType.SEND, Request.DETACH, timeout, None)
+    
+    def _dnload(self, blockNum, data):
+        """
+        The device's current state must be dfuIDLE or dfuDNLOAD-IDLE state for
+        this command to work (see STM AN3156 Fig 5).
+
+        blockNum: block to write to
+        data: byte-array-like data to write
+        Returns: number of bytes that were written.
+        """
+        cnt = self._control_msg(RequestType.SEND, Request.DNLOAD, blockNum, list(data))
+        return cnt
+    
+    def _upload(self, blockNum, size):
+        """
+        The device's current state must be dfuIDLE or dfuUPLOAD-IDLE state for
+        this command to work (see STM AN3156 Fig 3).
+
+        blockNum: block to read from
+        size: number of bytes to read
+        Returns: byte array containing the data that was read
+        """
+        return self._control_msg(RequestType.RECEIVE, Request.UPLOAD, blockNum, size)
+
+    def _get_status(self):
+        """
+        Returns: A tuple of the form (status: DfuStatus, state: DfuState, text: str)
+        """
+        msg = self._control_msg(RequestType.RECEIVE, Request.GETSTATUS, 0, 6)
+
+        status = DfuStatus(msg[0])
+        state = DfuState(msg[4])
+        poll_timeout_ms = msg[1] + (msg[2] << 8) + (msg[3] << 16)
+        text = usb.util.get_string(self._dev, msg[5])
+
+        if poll_timeout_ms > 10000:
+            raise Exception("Device requested an unreasonable timeout: {} ms".format(poll_timeout_ms))
+
+        time.sleep(float(poll_timeout_ms) / 1000.0)
+        return status, state, text
+    
+    def clear_status(self):
+        if self._get_state() == DfuState.DFU_ERROR:
+            self._control_msg(RequestType.SEND, Request.CLRSTATUS, 0, None)
+
+    def _get_state(self):
+        msg = self._control_msg(RequestType.RECEIVE, Request.GETSTATE, 0, 1)
+        return DfuState(msg[0])
+
+    def _abort(self):
+        self._control_msg(RequestType.SEND, Request.ABORT, 0, None)
+
+    def _read(self, block, size):
+        return self._upload(block + 2, size)
+
+    def _write(self, block, data):
+        return self._dnload(block + 2, data)
+
+    def _set_address(self, addr):
+        self._dnload(0x0, [Command.SET_ADDRESS_POINTER.value] + _address_to_4bytes(addr))
+        self._expect_state(
+            [DfuState.DFU_DOWNLOAD_BUSY], [DfuState.DFU_DOWNLOAD_IDLE],
+            "Failed to set address 0x{:08x}.".format(addr)
+        )
+
+    def unprotect(self):
+        self._dnload(0x0, [Command.READ_UNPROTECT])
+        self._expect_state(
+            [DfuState.DFU_DOWNLOAD_BUSY], [DfuState.DFU_DOWNLOAD_IDLE],
+            "Failed to unprotect."
+        )
+
+    def _erase(self, addr):
+        self._dnload(0x0, [Command.ERASE.value] + _address_to_4bytes(addr))
+        self._expect_state(
+            [DfuState.DFU_DOWNLOAD_BUSY], [DfuState.DFU_DOWNLOAD_IDLE],
+            "Failed to erase sector at 0x{:08x}.".format(addr)
+        )
+
+    def _leave(self):
+        return self._dnload(0x0, []) # Just send an empty data.
+
+    def _expect_state(self, busy_states, target_states, error_text):
+        while True:
+            status, state, text = self._get_status()
+            if state in target_states:
+                return
+            if state not in busy_states:
+                raise DfuError(error_text, status, state, text)
+
+    def erase_sector(self, sector):
+        self._expect_state([], [DfuState.DFU_IDLE, DfuState.DFU_DOWNLOAD_IDLE], "Cannot erase sector")
+        self._erase(sector['addr'])
+
+    def write_sector(self, sector, data):
+        self._expect_state([], [DfuState.DFU_IDLE, DfuState.DFU_DOWNLOAD_IDLE], "Cannot write sector")
+
+        status, state, text = self._get_status()
+        if state not in [DfuState.DFU_IDLE, DfuState.DFU_DOWNLOAD_IDLE]:
+            raise DfuError("Cannot write sector.", status, state, text)
+
+        self._set_address(sector['addr'])
+
+        transfer_size = math.gcd(sector['len'], self._max_transfer_size)
+        
+        for blocknum in range(int(sector['len'] / transfer_size)):
+            block = data[(blocknum * transfer_size):((blocknum + 1) * transfer_size)]
+            n_written = self._write(blocknum, block)
+            assert n_written == len(block), n_written
+            self._expect_state(
+                [DfuState.DFU_DOWNLOAD_BUSY], [DfuState.DFU_DOWNLOAD_IDLE],
+                "Failed to write sector at 0x{:08x}, block {}".format(sector['addr'], blocknum)
+            )
+
+    def read_sector(self, sector):
+        """
+        Reads data from the specified sector
+        Returns: a byte array containing the data
+        """
+        self._expect_state([], [DfuState.DFU_IDLE, DfuState.DFU_DOWNLOAD_IDLE], "Cannot read sector.")
+        self._set_address(sector['addr'])
+
+        self._abort() # exit DNLOAD_IDLE state
+
+        transfer_size = math.gcd(sector['len'], self._max_transfer_size)
+
+        # Device's current state must be dfuIDLE or dfuUPLOAD-IDLE for the subsequent read() commands to work.
+        
+        data = array.array(u'B')
+        for blocknum in range(int(sector['len'] / transfer_size)):
+            device_block = self._read(blocknum, transfer_size)
+            assert len(device_block) == transfer_size, len(device_block)
+            data.extend(device_block)
+
+        self._abort() # take device into DFU_IDLE
+        return data
+
+    def jump_to_application(self, address):
+        self._set_address(address)
+        self._leave()
+
+        try:
+            self._expect_state(
+                [DfuState.DFU_MANIFEST_SYNC], [DfuState.DFU_MANIFEST],
+                "Failed to exit DFU mode."
+            )
+            # on ODrive v3.x this passes
+            # on ODrive v4.x it throws a usb.core.USBError
+        except usb.core.USBError:
+            pass # expected
+

odrive/dfuse/__init__.py

@@ -0,0 +1 @@
+from .DfuDevice import DfuDevice, DfuState, DfuStatus