hwtLib.peripheral.usb.sim package

Subpackages

• hwtLib.peripheral.usb.sim.usbip package
  • Submodules
  • hwtLib.peripheral.usb.sim.usbip.connection module
    • USBIPConnection
      • USBIPConnection.OP_COMMON
      • USBIPConnection.OP_COMMON_SIZE
      • USBIPConnection.OP_SUBMIT
      • USBIPConnection.OP_SUBMIT_SIZE
      • USBIPConnection.__init__()
      • USBIPConnection.connection()
      • USBIPConnection.debug_log()
      • USBIPConnection.getDeviceList()
      • USBIPConnection.handle_op_devlist()
      • USBIPConnection.handle_op_import()
      • USBIPConnection.handle_packet()
      • USBIPConnection.handle_urb_submit()
      • USBIPConnection.handle_urb_unlink()
      • USBIPConnection.make_usbip_header_basic()
      • USBIPConnection.pack_device_desc()
      • USBIPConnection.usbip_ret_submit()
    • USBIPProtocolErrorException
      • USBIPProtocolErrorException.__init__()
  • hwtLib.peripheral.usb.sim.usbip.constants module
  • hwtLib.peripheral.usb.sim.usbip.device module
    • LIBUSB_TRANSFER_STATUS
      • LIBUSB_TRANSFER_STATUS.TRANSFER_CANCELLED
      • LIBUSB_TRANSFER_STATUS.TRANSFER_COMPLETED
      • LIBUSB_TRANSFER_STATUS.TRANSFER_ERROR
      • LIBUSB_TRANSFER_STATUS.TRANSFER_NO_DEVICE
      • LIBUSB_TRANSFER_STATUS.TRANSFER_OVERFLOW
      • LIBUSB_TRANSFER_STATUS.TRANSFER_STALL
      • LIBUSB_TRANSFER_STATUS.TRANSFER_TIMED_OUT
    • USBIPDevice
      • USBIPDevice.__init__()
      • USBIPDevice.packDevid()
    • USBIPOperationPromise
      • USBIPOperationPromise.__init__()
      • USBIPOperationPromise._continue_with_clk_triggering()
      • USBIPOperationPromise._pool_process()
      • USBIPOperationPromise.fulfill()
      • USBIPOperationPromise.pool_sleep_until_fulfil()
      • USBIPOperationPromise.schedule()
    • USBIPPending
      • USBIPPending.__init__()
    • USBIPSimDevice
      • USBIPSimDevice.__init__()
      • USBIPSimDevice.close()
      • USBIPSimDevice.controlRead()
      • USBIPSimDevice.controlWrite()
      • USBIPSimDevice.getBusNumber()
      • USBIPSimDevice.getDevice()
      • USBIPSimDevice.getDeviceAddress()
      • USBIPSimDevice.getDeviceClass()
      • USBIPSimDevice.getDeviceProtocol()
      • USBIPSimDevice.getDeviceSpeed()
      • USBIPSimDevice.getDeviceSubClass()
      • USBIPSimDevice.getNumConfigurations()
      • USBIPSimDevice.getProductID()
      • USBIPSimDevice.getTransfer()
      • USBIPSimDevice.getVendorID()
      • USBIPSimDevice.getbcdDevice()
      • USBIPSimDevice.iterConfigurations()
      • USBIPSimDevice.open()
    • USBIPSimDeviceConfiguration.getConfigurationValue()
    • USBIPSimDeviceConfiguration.getNumInterfaces()
    • USBIPSimDeviceConfiguration.iterInterfaces()
    • USBIPSimDeviceInterface.iterSettings()
    • USBIPSimDeviceInterfaceSetting
      • USBIPSimDeviceInterfaceSetting.__init__()
      • USBIPSimDeviceInterfaceSetting.getClass()
      • USBIPSimDeviceInterfaceSetting.getProtocol()
      • USBIPSimDeviceInterfaceSetting.getSubClass()
    • USBIPTransfer
      • USBIPTransfer.__init__()
      • USBIPTransfer._next_bulk_pid()
      • USBIPTransfer.getActualLength()
      • USBIPTransfer.getBuffer()
      • USBIPTransfer.getStatus()
      • USBIPTransfer.setBulk()
      • USBIPTransfer.submit()
  • hwtLib.peripheral.usb.sim.usbip.server module
    • UsbipServer
      • UsbipServer.__init__()
      • UsbipServer._start_server()
      • UsbipServer.handle_loop_exception()
      • UsbipServer.install_session_recorder()
      • UsbipServer.on_usbip_connection()
      • UsbipServer.run()
      • UsbipServer.terminate()
  • hwtLib.peripheral.usb.sim.usbip.session_recorder module
    • UsbipServerReplayer
      • UsbipServerReplayer.Reader
        • UsbipServerReplayer.Reader.__init__()
        • UsbipServerReplayer.Reader.readexactly()
      • UsbipServerReplayer.Writer
        • UsbipServerReplayer.Writer.__init__()
        • UsbipServerReplayer.Writer.close()
        • UsbipServerReplayer.Writer.drain()
        • UsbipServerReplayer.Writer.get_extra_info()
        • UsbipServerReplayer.Writer.write()
      • UsbipServerReplayer.__annotations__
      • UsbipServerReplayer.__init__()
      • UsbipServerReplayer._start_server()
      • UsbipServerReplayer.on_usbip_connection()
    • UsbipServerSessionRecorder
      • UsbipServerSessionRecorder.Reader
        • UsbipServerSessionRecorder.Reader.__init__()
        • UsbipServerSessionRecorder.Reader.readexactly()
      • UsbipServerSessionRecorder.Writer
        • UsbipServerSessionRecorder.Writer.__init__()
        • UsbipServerSessionRecorder.Writer.close()
        • UsbipServerSessionRecorder.Writer.drain()
        • UsbipServerSessionRecorder.Writer.get_extra_info()
        • UsbipServerSessionRecorder.Writer.write()
      • UsbipServerSessionRecorder.__init__()
      • UsbipServerSessionRecorder.apply()
    • cut_off_empty_time_segments()
    • filter_empty_in()

Submodules

hwtLib.peripheral.usb.sim.agent_base module

class hwtLib.peripheral.usb.sim.agent_base.UsbAgent(rx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake], tx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake])

Bases: object

__init__(rx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake], tx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake])

deparse_packet(p)

Called to convert the packet from types supported by this class before putting into tx/rx queue

parse_packet(p)

Called to convert the packet from tx/rx queues to types supported by this class

receive(packet_cls)

send(p)

send and wait until other side consumes the data

send_ack()

wait_on_ack()

class hwtLib.peripheral.usb.sim.agent_base.UsbPacketData(pid: int, data: List[int])

Bases: object

__init__(pid: int, data: List[int])

__repr__()

Return repr(self).

crc16()

unpack(t: HdlType)

reinterpret data as specified type

class hwtLib.peripheral.usb.sim.agent_base.UsbPacketHandshake(pid: USB_PID)

Bases: object

__init__(pid: USB_PID)

__repr__()

Return repr(self).

class hwtLib.peripheral.usb.sim.agent_base.UsbPacketToken(pid: USB_PID, addr: int, endp: int)

Bases: object

Note:

bits of individual items are sent in LSB first but the items of the packet are sent in the oreder defined by structure of the packet

__init__(pid: USB_PID, addr: int, endp: int)

__repr__()

Return repr(self).

crc5()

classmethod from_pid_and_body_bytes(pid: int, addr_ep_crc_byte_list: HBitsConst | List[HBitsConst])

hwtLib.peripheral.usb.sim.usb_agent_device module

class hwtLib.peripheral.usb.sim.usb_agent_device.UsbDevAgent(rx: Deque[UsbPacketToken | UsbPacketData], tx: Deque[UsbPacketToken | UsbPacketData], descriptors: UsbDescriptorBundle)

Bases: UsbAgent

This agent uses rx and tx queue to comunicate with a USB device. The agnet implements address assignment and descriptor upload and it is meant to be extended with a specific functionality of USB device.

__annotations__ = {}

__init__(rx: Deque[UsbPacketToken | UsbPacketData], tx: Deque[UsbPacketToken | UsbPacketData], descriptors: UsbDescriptorBundle)

get_data_pid()

proc()

send_data(endp: int, pid_init: USB_PID, maxPacketLen: int, data_bytes: List[int])

set_data_pid(pid: USB_PID)

hwtLib.peripheral.usb.sim.usb_agent_host module

class hwtLib.peripheral.usb.sim.usb_agent_host.UsbHostAgent(rx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake], tx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake])

Bases: UsbAgent

This agent uses rx and tx queue to comunicate with a USB device. It performs bus enumerations, sets address to a device and downloads the descriptors. Note that the agent is written in a way which allows for easy extension to a driver which can parse the specific descriptors and comunicate with devices further.

__annotations__ = {}

__init__(rx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake], tx: Deque[UsbPacketToken | UsbPacketData | UsbPacketHandshake])

control_read(addr, bmRequestType_type: USB_REQUEST_TYPE_TYPE, bRequest: int, wValue: int, wIndex: int, wLength: int, bmRequestType_recipient: USB_REQUEST_TYPE_RECIPIENT = 0, bmRequestType_data_transfer_direction: USB_REQUEST_TYPE_DIRECTION = 1)

control_write(addr: int, ep: int, bmRequestType_type: USB_REQUEST_TYPE_TYPE, bRequest: int, wValue: int, wIndex: int, buff: List[int], bmRequestType_recipient: USB_REQUEST_TYPE_RECIPIENT = 0, bmRequestType_data_transfer_direction: USB_REQUEST_TYPE_DIRECTION = 0)

download_descriptor(addr: int, descriptor_t: HStruct | str, index: int, wIndex: int = 0, wLength: int | None = <class 'hwt.constants.NOT_SPECIFIED'>)

get_max_packet_size(addr: int, endp: int, direction: USB_ENDPOINT_DIR)

parse_configuration_descriptor_bundle(data_bytes: List[int])

parse_interface_functional_descriptor(interface_descr: HStructConstBase, data: HBitsConst)

proc()

receive_bulk(addr: int, endp: int, pid_init: USB_PID, size=<class 'hwt.constants.NOT_SPECIFIED'>) → List[int]

transmit_bulk(addr: int, endp: int, pid_init: USB_PID, data_bytes: List[int])