recom 0.0.1__py3-none-any.whl

recom/__init__.py

@@ -0,0 +1,6 @@
+from recom.device import RecomDevice, DeviceException
+from recom.interface import RecomInterface
+
+__version__ = "0.0.1"   # This will be replaced by setuptools_scm during installation
+
+__all__ = ["RecomDevice", "RecomInterface", "DeviceException"]

recom/__main__.py

@@ -0,0 +1,25 @@
+import sys
+import traceback
+
+from recom.cli import cli
+
+
+def main(argv=None):
+    """Main entry point"""
+
+    if argv==None:
+        argv = sys.argv
+
+    try:
+        return cli(argv[1:])
+    except KeyboardInterrupt:
+        print("Aborted by user")
+    except Exception as e:
+        print("FATAL: ", repr(e))
+        print(traceback.format_exc())
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    sys.exit(main())
+    

recom/backend/uart.py

@@ -0,0 +1,8 @@
+import serial
+import serial.tools.list_ports
+
+def find_serial_device_by_com_port(com_port):
+    return None
+
+def find_serial_device_by_serial(serial):
+    return None

recom/backend/usb.py

@@ -0,0 +1,121 @@
+import enum
+import usb.core
+import usb.util
+
+def find_usb_device_by_vid_pid(vid_pid):
+    if isinstance(vid_pid, tuple):
+        vid = vid_pid[0]
+        pid = vid_pid[1]
+    elif isinstance(vid_pid, str):
+        if ':' in vid_pid:
+            vp_parts = vid_pid.split(':', 1)
+            vid = int(vp_parts[0].strip(), 16) if len(vp_parts[0]) else None
+            pid = int(vp_parts[1].strip(), 16) if len(vp_parts[1]) else None
+        else:
+            vid = int(vid_pid.strip(), 16)
+            pid = None
+    if vid is not None and pid is not None:
+        return list(usb.core.find(find_all=True, idVendor=vid, idProduct=pid))
+    elif vid is not None:
+        return list(usb.core.find(find_all=True, idVendor=vid))
+    elif pid is not None:
+        return list(usb.core.find(find_all=True, idProduct=pid))
+    return None
+
+def find_usb_device_by_serial(serial):
+    return usb.core.find(serial=serial)
+
+class CTRL_REQ(enum.IntEnum):
+    DEVICE_VENDOR_OUT = 0x40
+    DEVICE_VENDOR_IN = 0xC0
+    INTERFACE_VENDOR_OUT = 0x41
+    INTERFACE_VENDOR_IN = 0xC1
+
+
+class USBDevice:
+
+    def __init__(self, dev_handle):
+        self.dev = dev_handle
+        self.interfaces = []
+
+        for cfg in self.dev:
+            for itf in cfg:
+                self.interfaces.append(USBInterface(self.dev, itf))
+        self.dev.set_configuration(1)
+
+    def __repr__(self):
+        return "USB Device 0x%04X:0x%04X" % (self.dev.idVendor, self.dev.idProduct)
+
+    @property
+    def dev_type(self):
+        return 'usb'
+
+    def controlRead(self, request, value=0, index=0, dataLen=512, timeout=1000):
+        return self.dev.ctrl_transfer(CTRL_REQ.DEVICE_VENDOR_IN, request, value, index, dataLen, timeout)
+
+    def controlWrite(self, request, data=b'', value=0, index=0, timeout=1000):
+        return self.dev.ctrl_transfer(CTRL_REQ.DEVICE_VENDOR_OUT, request, value, index, data, timeout)
+
+    def get_interface_list(self):
+        itf_list = []
+        for itf in self.interfaces:
+            itf_list.append([itf.desc.bInterfaceClass, itf.desc.bInterfaceSubClass,
+                             itf.desc.bInterfaceProtocol, itf.itf_str])
+        return itf_list
+
+    def get_interface(self, itf_identifier):
+        if isinstance(itf_identifier, int):
+            # Interface index
+            return self.interfaces[itf_identifier]
+        elif isinstance(itf_identifier, tuple):
+            # Interface subclass/protocol tuple
+            for itf in self.interfaces:
+                if itf.desc.bInterfaceSubClass == itf_identifier[0] and \
+                   itf.desc.bInterfaceProtocol == itf_identifier[1]:
+                    return itf
+        elif isinstance(itf_identifier, str):
+            # Interface description string
+            for itf in self.interfaces:
+                if itf_identifier in itf.itf_str:
+                    return itf
+        return None
+
+
+class USBInterface():
+
+    def __init__(self, dev_handle, itf_desc):
+        self.dev = dev_handle
+        self.desc = itf_desc
+        self.itf_idx = itf_desc.bInterfaceNumber
+        interface = usb.core.Interface(self.dev, self.itf_idx)
+        self.eps = []
+        self.ep_in = usb.util.find_descriptor(interface, custom_match = lambda e: \
+                                            usb.util.endpoint_direction(e.bEndpointAddress) == \
+                                            usb.util.ENDPOINT_IN)
+        self.ep_out = usb.util.find_descriptor(interface, custom_match = lambda e: \
+                                            usb.util.endpoint_direction(e.bEndpointAddress) == \
+                                            usb.util.ENDPOINT_OUT)
+        self.subclass = self.desc.bInterfaceSubClass
+        self.protocol = self.desc.bInterfaceProtocol
+        self.itf_str = usb.util.get_string(self.dev, self.desc.iInterface)
+
+    def __repr__(self):
+        return "%s: Subclass=%d, Protocol=%d, EP_OUT=0x%02X, EP_IN=0x%02X" % \
+                    (self.itf_str, self.subclass, self.protocol, self.ep_out.bEndpointAddress,
+                                                                 self.ep_in.bEndpointAddress)
+
+    @property
+    def itf_string(self):
+        return self.itf_str
+
+    def controlRead(self, request, value=0, index=0, dataLen=512, timeout=1000):
+        return self.dev.ctrl_transfer(CTRL_REQ.INTERFACE_VENDOR_IN, request, value, index, dataLen, timeout)
+
+    def controlWrite(self, request, data=b'', value=0, index=0, timeout=1000):
+        return self.dev.ctrl_transfer(CTRL_REQ.INTERFACE_VENDOR_OUT, request, value, index, data, timeout)
+
+    def read(self, dataLen=64, timeout=1000):
+        return self.ep_in.read(dataLen, timeout)
+
+    def write(self, data, timeout=1000):
+        return self.ep_out.write(data, timeout)

recom/cli.py

@@ -0,0 +1,47 @@
+import argparse
+
+import recom
+from recom.device import RecomDevice, DeviceException
+
+def list_devices(device_id, serial):
+    dev = None
+    print("Finding device")
+    if serial is not None:
+        print(f'Find by serial - {serial}')
+        try:
+            dev = RecomDevice(serial=serial)
+        except DeviceException as dev_exp:
+            print(dev_exp)
+            return
+
+    else:
+        print(f'Find by DeviceID - {device_id}')
+        try:
+            dev = RecomDevice(device_id=device_id)
+        except DeviceException as dev_exp:
+            print(dev_exp)
+            return
+
+    print("Found device: %s" % dev)
+
+    print("\tHW ID/Rev: 0x%04X / 0x%04X" % (dev.hw_id, dev.hw_revision))
+    print("\tFW Rev: %s" % dev.fw_revision)
+    print("\tSerial: %s" % dev.serial)
+    print("\n\tInterfaces:")
+    interfaces = dev.getAllInterfaces()
+    for itf in interfaces:
+        itf_tuple = (itf[1], itf[2])
+        itf_handle = dev.getInterfaceHandleFromID(itf_tuple)
+        print("\t\t%s" % itf_handle)
+
+
+def cli(argv):
+    parser = argparse.ArgumentParser(description="Open a serial port and read/write data.")
+    parser.add_argument('--version', action='version', version=recom.__version__,
+                                                help="Print package version")
+    parser.add_argument('-d', '--device', help='Device ID to search for ([VID:PID] for USB, port for serial)')
+    parser.add_argument('-S', '--serial', help='Serial number to search for')
+
+    args = parser.parse_args(argv)
+
+    list_devices(args.device, args.serial)

recom/device.py

@@ -0,0 +1,137 @@
+#from interface import DeviceInterface
+import enum
+import struct
+from recom.backend.usb import find_usb_device_by_serial, find_usb_device_by_vid_pid
+from recom.backend.uart import find_serial_device_by_serial, find_serial_device_by_com_port
+from recom.backend.usb import USBDevice
+from recom.interface import RecomInterface
+
+class BASE_DEV_CMDS(enum.IntEnum):
+    CMD_SCRATCH_REG     = 0x00,
+    CMD_HW_ID           = 0x01,
+    CMD_HW_REV          = 0x02,
+    CMD_FW_REV          = 0x03,
+    CMD_SERIAL          = 0x04,
+    CMD_RESET           = 0x05
+    CMD_GET_INTERFACES  = 0x06,
+
+class DeviceException(Exception):
+    pass
+
+class BaseDevice:
+
+    def __init__(self, device):
+        self._interfaces = []
+        self._comsBackend = None
+        self.dev = device
+        #print(self.dev)
+
+        # TODO: Detect and setup COMs backend
+        # For now, default to USB
+        self._comsBackend = USBDevice(device)
+
+    def __repr__(self):
+        return repr(self._comsBackend)
+
+    def _detectInterfaces(self):
+        #If USB, get the interfaces from the USB library/descriptor
+        #If UART or other interface, use the control interface to query the available interfaces
+        pass
+
+    def getAllInterfaces(self):
+        """Returns a list of available interfaces"""
+        return self._comsBackend.get_interface_list()
+
+    def getInterfaceHandleFromID(self, itf_id):
+        """Finds an interface based on its ID and returns its handle"""
+        itf = self._comsBackend.get_interface(itf_id)
+        if itf is None:
+            raise DeviceException("Interface not found")
+        return RecomInterface(self, itf)
+
+    def getInterfaceHandleFromNumber(self, itf_num):
+        """Finds an interface based on its number in the interface list and returns its handle"""
+        itf_list = self._comsBackend.get_interface_list()
+        if itf_num >= len(itf_list):
+            raise DeviceException("Interface number out of range")
+        itf = self._comsBackend.get_interface(itf_list[itf_num])
+        return RecomInterface(self, itf)
+
+    def getHwID(self):
+        # The HW ID is a 32-bit number
+        data = self._comsBackend.controlRead(BASE_DEV_CMDS.CMD_HW_ID)
+        return struct.unpack('<I', data)
+
+    def getHwRev(self):
+        # The HW revision is a 32-bit number
+        data = self._comsBackend.controlRead(BASE_DEV_CMDS.CMD_HW_REV)
+        return struct.unpack('<I', data)
+
+    def getFwRev(self):
+        # The FW revision is a string
+        data = self._comsBackend.controlRead(BASE_DEV_CMDS.CMD_FW_REV)
+        return ''.join(chr(x) for x in data)
+
+    def getSerial(self):
+        # The device serial number is a string
+        data = self._comsBackend.controlRead(BASE_DEV_CMDS.CMD_SERIAL)
+        return ''.join(chr(x) for x in data)
+
+    def getScratchReg(self):
+        # The scratch register is a 32-bit number
+        data = self._comsBackend.controlRead(BASE_DEV_CMDS.CMD_SCRATCH_REG)
+        return struct.unpack('<I', data)
+
+    def setScratchReg(self, scratch_value:int):
+        data = struct.pack('<I', scratch_value)
+        return self._comsBackend.controlWrite(BASE_DEV_CMDS.CMD_SCRATCH_REG, data)
+
+class RecomDevice(BaseDevice):
+
+    def __init__(self, serial=None, device_id=None):
+        dev = self._find_device(serial, device_id)
+        if dev is None:
+            raise DeviceException("No device found")
+        super().__init__(dev)
+
+    def _find_device(self, serial, device_id):
+        if serial is not None:
+            # Check if we have a USB device with the specified serial
+            dev = find_usb_device_by_serial(serial)
+            if dev is not None:
+                return dev
+            # Next, check if there is a serial device with the specified serial
+            dev = find_serial_device_by_serial(serial)
+            return dev
+        elif device_id is not None:
+            # Check if we can find a USB device with the specified device_id (VID:PID in this case)
+            dev = find_usb_device_by_vid_pid(device_id)
+            if len(dev) > 1:
+                raise DeviceException("More than one device found!")
+            elif len(dev) == 1:
+                return dev[0]
+            # No USB devices found, now try to find serial devices with the specified device_id (port ID)
+            dev = find_serial_device_by_com_port(device_id)
+            return dev
+
+
+    def reset(self):
+        pass
+
+    @property
+    def hw_id(self):
+        return self.getHwID()[0]
+
+    @property
+    def hw_revision(self):
+        return self.getHwRev()[0]
+
+    @property
+    def fw_revision(self):
+        return self.getFwRev()
+
+    @property
+    def serial(self):
+        return self.getSerial()
+
+

recom/interface.py

@@ -0,0 +1,50 @@
+import enum
+
+class RecomInterface:
+
+    def __init__(self, deviceHandle, interfaceHandle):
+        self._parentDevice = deviceHandle
+        self._handle = interfaceHandle
+
+    def __repr__(self):
+        return f"Interface: {self.name} (Sub={self._handle.subclass}/Prot={self._handle.protocol})"
+
+    def read(self, dataLen=-1):
+        """
+        Reads data from the interface's data endpoint
+        
+        dataLen specifies how many bytes should be read. If not speciied, any
+        available bytes will be returned
+        """
+        if dataLen == -1:
+            return self._handle.read()
+        else:
+            return self._handle.read(dataLen)
+    
+    def write(self, data):
+        """
+        Writes data to the interface's data endpoint
+
+        Returns the number of bytes written to the interface
+        """
+        return self._handle.write(data)
+
+    def controlRead(self, request, value=0, index=0, dataLen=64, timeout=1000):
+        """Reads data from the interface's control endpoint"""
+        return self._handle.controlRead(request=request,
+                                        value=value,
+                                        index=index,
+                                        dataLen=dataLen,
+                                        timeout=timeout)
+
+    def controlWrite(self, request, data=b'', value=0, index=0, timeout=1000):
+        """Writes data to the interface's control endpoint"""
+        return self._handle.controlWrite(request=request,
+                                         data=data,
+                                         value=value,
+                                         index=index,
+                                         timeout=timeout)
+
+    @property
+    def name(self):
+        return self._handle.itf_string

recom-0.0.1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: recom
+Version: 0.0.1
+Summary: Embedded communication backend
+Home-page: https://github.com/redhill-embedded/recom.git
+Author: Adrian Rothenbuhler
+Author-email: adrian@redhill-embedded.com
+License: MIT
+Keywords: embedded communication backedn usb serial
+Requires-Python: >=3.8
+Requires-Dist: pyusb
+Requires-Dist: pyserial
+

recom-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+recom/__init__.py,sha256=qKz9D0bpUY1veQV50yDG5zefBZW34Z0X9JjhLk9-FqM,248
+recom/__main__.py,sha256=6PAkcjlgShgd-tb0CPgBQ_piqLAliD2ut4_b3ZVAszI,424
+recom/cli.py,sha256=kAY52PqNIbbbU91F_PGU4JwFtR3Wb29rAISAj1PqbxE,1558
+recom/device.py,sha256=up-1t7a0NHEKl7od6zGMbzYIZ-viAQ5LdW3vEFQBqVk,4682
+recom/interface.py,sha256=Pgesnm10aL0YXsvbgBvBeZkuWdBPUut42QjpPO0snk8,1785
+recom/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+recom/backend/uart.py,sha256=3hNXg6CRLgjhnJebeh5kDXfvVANcNR1Xj8AcdQrEh30,166
+recom/backend/usb.py,sha256=PQEIjbzt8U9WT-YWeTCoYb_KsO32uF4h0QJ33rcE38Y,4734
+recom-0.0.1.dist-info/METADATA,sha256=UlzKWL4w9WaM5MZITVAEjfEkdTzB1Bo9NypOC_qaVI0,350
+recom-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+recom-0.0.1.dist-info/entry_points.txt,sha256=HilsJbY9JIp1JI9ODFJFZAzVaENiqCNjQAhsAJYqSG8,46
+recom-0.0.1.dist-info/top_level.txt,sha256=ROCpXv7wHDp6Gpq-HyKPmH3U0Iu9_gMJz7F23mF1k7U,6
+recom-0.0.1.dist-info/RECORD,,

recom-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

recom-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+recom = recom.__main__:main

recom-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+recom