File: //usr/lib/python3.9/site-packages/usb/__pycache__/core.cpython-39.pyc
a
j��Yp� � @ s< d Z dZg d�ZddlmZ ddlZddlZddlmZ ddl m
Z
ddl m Z
ddlZddlZddlZddlZe�d�ZdZdd� Zd&d d �Zd'd
d�ZG dd� de�Zdd� ZG dd� de�Z G dd� de �Z G dd� de �Z G dd� de�Z!G dd � d e�Z"G d d � d e�Z#G d d � d e
j$�Z%d(d"d#�Z&d)d$d%�Z'dS )*av usb.core - Core USB features.
This module exports:
Device - a class representing a USB device.
Configuration - a class representing a configuration descriptor.
Interface - a class representing an interface descriptor.
Endpoint - a class representing an endpoint descriptor.
find() - a function to find USB devices.
show_devices() - a function to show the devices present.
zWander Lairson Costa)�Device�
Configuration� Interface�Endpoint�find� show_devices� Nzusb.corei� c C s |D ]}t ||t| |�� qd S �N)�setattr�getattr)�input�output�fields�f� r �,/usr/lib/python3.9/site-packages/usb/core.py� _set_attr= s r � �Error Accessing Stringc C sL |dkr|}n:z(|du r&t �| |�}nt �| ||�}W n |}Y n0 |S )z= try to get a string, but return a string no matter what
r N)�util�
get_string)�dev�indexZlangidZdefault_str_i0Zdefault_access_error�stringr r r �_try_get_stringA s
r c C s( z | | }W n t y" |}Y n0 |S )zS try to get a string from the lookup table, return "" instead of key
error
)�KeyError)�table�value�defaultr r r r � _try_lookupQ s
r c @ s e Zd ZdZdd� ZdS )�_DescriptorInfozc this class is used so that when a descriptor is shown on the
terminal it is propely formatted c C s | S r r ��selfr r r �__repr__^ s z_DescriptorInfo.__repr__N)�__name__�
__module__� __qualname__�__doc__r" r r r r r [ s r c s t �� �� fdd��}|S )Nc s> z,| j �� � | g|�R i |��W | j �� S | j �� 0 d S r )�lock�acquire�release)r! �args�kwargs�r r r �wrapperb s
�z synchronized.<locals>.wrapper)� functools�wraps)r r- r r, r � synchronizeda s r0 c @ s� e Zd Zdd� Zedd� �Zedd� �Zedd� �Zed d
� �Zed d � �Z ed
d� �Z
edd� �Z edd� �Z edd� �Z
edd� �Zeddd��ZdS ) �_ResourceManagerc C s6 || _ d | _|| _d | _t�� | _i | _t� � | _
d S r ) �backend�_active_cfg_indexr �handle�_interopZ_set�
_claimed_intf�_ep_info� threading�RLockr' )r! r r2 r r r �__init__l s
z_ResourceManager.__init__c C s | j d u r| j�| j�| _ | j S r )r4 r2 Z open_devicer r r r r � managed_openu s
z _ResourceManager.managed_openc C s" | j d ur | j�| j � d | _ d S r )r4 r2 Z close_devicer r r r �
managed_close{ s
z _ResourceManager.managed_closec C s� |d u r|d }n>t |t�r"|}n.|dkrBG dd� dt�}|� }ntj||d�}|d u rhtdt|� ��| �� | j� | j
|j � |j | _
| j�� d S )Nr c @ s e Zd Zdd� ZdS )zE_ResourceManager.managed_set_configuration.<locals>.MockConfigurationc S s d | _ d| _d S )Nr )r �bConfigurationValuer r r r r: � s zN_ResourceManager.managed_set_configuration.<locals>.MockConfiguration.__init__N)r# r$ r% r: r r r r �MockConfiguration� s r> �r= zInvalid configuration )�
isinstancer �objectr �find_descriptor�
ValueError�strr; r2 �set_configurationr4 r= r r3 r7 �clear)r! �deviceZconfig�cfgr> r r r �managed_set_configuration� s
z*_ResourceManager.managed_set_configurationc C sH | � � t|t�r|j}n|}|| jvrD| j�| j|� | j�|� d S r ) r; r@ r �bInterfaceNumberr6 r2 Zclaim_interfacer4 �add)r! rG �intf�ir r r �managed_claim_interface� s
z(_ResourceManager.managed_claim_interfacec C sr |d u r | � |�}|d j}nt|t�r0|j}n|}|| jv rnz | j�| j|� W | j�|� n| j�|� 0 d S )N�r r ) �get_active_configurationrJ r@ r r6 r2 Zrelease_interfacer4 �remove)r! rG rL rH rM r r r �managed_release_interface� s
z*_ResourceManager.managed_release_interfacec C s� t |t�r|}nD| �|�}|d u r,|d j}|d urFtj|||d�}ntj||d�}| �||� |d u rn|j}| j� | j
|j|� d S )NrO )rJ �bAlternateSetting)rJ ) r@ r rP rJ r rB rN rS r2 �set_interface_altsettingr4 )r! rG rL �altrM rH r r r �managed_set_interface� s
z&_ResourceManager.managed_set_interfacec C s: t |t�r|j}n|}| �||�\}}| �||� ||fS r )r@ r �bEndpointAddress�get_interface_and_endpointrN )r! rG �endpoint�endpoint_addressrL �epr r r �
setup_request� s
z _ResourceManager.setup_requestc C sx z | j | W S tyr | �|�D ]8}tj||d�}|d ur$||f| j |< ||f Y S q$tdt|� ��Y n0 d S )N)rW zInvalid endpoint address )r7 r rP r rB rC �hex)r! rG rZ rL r[ r r r rX � s z+_ResourceManager.get_interface_and_endpointc C sP | j d u rF| �� tj|| j�| j�d�}|d u r:td��|j| _ |S || j S )Nr? zConfiguration not set) r3 r; r rB r2 Zget_configurationr4 �USBErrorr )r! rG rH r r r rP � s
�z)_ResourceManager.get_active_configurationc C s> t � | j�}|D ](}z| �||� W q ty6 Y q0 qd S r )�copyr6 rR r^ )r! rG ZclaimedrM r r r �release_all_interfaces� s z'_ResourceManager.release_all_interfacesTc C s* | � |� |r| �� | j�� d | _d S r )r` r< r7 rF r3 )r! rG Z close_handler r r �dispose s
z_ResourceManager.disposeN)T)r# r$ r% r: r0 r; r< rI rN rR rV r\ rX rP r` ra r r r r r1 k s.
r1 c @ s e Zd ZdZddd�ZdS )r^ z�Exception class for USB errors.
Backends must raise this exception when USB related errors occur. The
backend specific error code is available through the 'backend_error_code'
member variable.
Nc C s t �| ||� || _dS )z�Initialize the object.
This initializes the USBError object. The strerror and errno are passed
to the parent object. The error_code parameter is attributed to the
backend_error_code member variable.
N)�IOErrorr: Zbackend_error_code)r! �strerrorZ
error_code�errnor r r r: s zUSBError.__init__)NN)r# r$ r% r& r: r r r r r^ s r^ c @ s e Zd ZdZdS )�NoBackendErrorz2Exception class when a valid backend is not found.N)r# r$ r% r& r r r r re s re c @ sN e Zd ZdZddd�Zdd� Zdd� Zdd
d �Zdd d
�Zdd� Z dd� Z
d S )r a� Represent an endpoint object.
This class contains all fields of the Endpoint Descriptor according to the
USB Specification. You can access them as class properties. For example, to
access the field bEndpointAddress of the endpoint descriptor, you can do so:
>>> import usb.core
>>> dev = usb.core.find()
>>> for cfg in dev:
>>> for i in cfg:
>>> for e in i:
>>> print e.bEndpointAddress
r c C s: || _ || _|jj}|�|jj||||�}t|| d� dS )a( Initialize the Endpoint object.
The device parameter is the device object returned by the find()
function. endpoint is the endpoint logical index (not the endpoint
address). The configuration parameter is the logical index of the
configuration (not the bConfigurationValue field). The interface
parameter is the interface logical index (not the bInterfaceNumber
field) and alternate_setting is the alternate setting logical index
(not the bAlternateSetting value). An interface may have only one
alternate setting. In this case, the alternate_setting parameter
should be zero. By "logical index" we mean the relative order of the
configurations returned by the peripheral as a result of GET_DESCRIPTOR
request.
) �bLength�bDescriptorTyperW � bmAttributes�wMaxPacketSize� bIntervalZbRefreshZ
bSynchAddress�extra_descriptorsN)rG r �_ctxr2 Zget_endpoint_descriptorr r )r! rG rY � interface�alternate_setting�
configurationr2 �descr r r r: 1 s ��zEndpoint.__init__c C s d| � � d S �N�<�>��_strr r r r r" ^ s zEndpoint.__repr__c C s� d| � � d }t�| j�tjkr(d}nd}d|ddt|� f dd | jf d
d | jtt j
| j�f d
d | j|f d
d
| j t j | j d@ f dd| j
| j
f dd| jf S )Nz � �IN�OUT�%s%s
�=�< z %-17s:%#7x (7 bytes)
rf z %-17s:%#7x %s
rg rW rh � z %-17s:%#7x (%d bytes)
ri z %-17s:%#7xrj )ru r �endpoint_directionrW � ENDPOINT_IN�lenrf rg r �_lu� descriptorsrh �
ep_attributesri rj )r! �headstr� directionr r r �__str__a s: �� ������
��
�zEndpoint.__str__Nc C s | j �| ||�S )a^ Write data to the endpoint.
The parameter data contains the data to be sent to the endpoint and
timeout is the time limit of the operation. The transfer type and
endpoint address are automatically inferred.
The method returns the number of bytes written.
For details, see the Device.write() method.
)rG �write)r! �data�timeoutr r r r� x s zEndpoint.writec C s | j �| ||�S )a� Read data from the endpoint.
The parameter size_or_buffer is either the number of bytes to
read or an array object where the data will be put in and timeout is the
time limit of the operation. The transfer type and endpoint address
are automatically inferred.
The method returns either an array object or the number of bytes
actually read.
For details, see the Device.read() method.
)rG �read)r! �size_or_bufferr� r r r r� � s
z
Endpoint.readc C s | j �| j� dS )z0Clear the halt/status condition of the endpoint.N)rG �
clear_haltrW r r r r r� � s zEndpoint.clear_haltc C s8 t �| j�t jkrd}nd}d| jtj| jd@ |f S )Nrw rx zENDPOINT 0x%X: %s %sr| )r r} rW r~ r� r� rh )r! r� r r r ru � s ��z
Endpoint._str)r r r )N)N) r# r$ r% r& r: r" r� r� r� r� ru r r r r r " s �
-
r c @ sZ e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dS )r a� Represent an interface object.
This class contains all fields of the Interface Descriptor
according to the USB Specification. You may access them as class
properties. For example, to access the field bInterfaceNumber
of the interface descriptor, you can do so:
>>> import usb.core
>>> dev = usb.core.find()
>>> for cfg in dev:
>>> for i in cfg:
>>> print i.bInterfaceNumber
r c C sF || _ || _|| _|| _|jj}|�| j jj|||�}t|| d� dS )a� Initialize the interface object.
The device parameter is the device object returned by the find()
function. The configuration parameter is the logical index of the
configuration (not the bConfigurationValue field). The interface
parameter is the interface logical index (not the bInterfaceNumber
field) and alternate_setting is the alternate setting logical index
(not the bAlternateSetting value). An interface may have only one
alternate setting. In this case, the alternate_setting parameter
should be zero. By "logical index" we mean the relative order of
the configurations returned by the peripheral as a result of
GET_DESCRIPTOR request.
)
rf rg rJ rS �
bNumEndpoints�bInterfaceClass�bInterfaceSubClass�bInterfaceProtocol�
iInterfacerk N) rG �alternate_indexr ro rl r2 Zget_interface_descriptorr r )r! rG rm rn ro r2 rp r r r r: � s ��zInterface.__init__c C s d| � � d S rq rt r r r r r" � s zInterface.__repr__c C s& | � � }| D ]}|dt|� 7 }q |S )z'Show all information for the interface.�
��_get_full_descriptor_strrD )r! r rY r r r r� � s zInterface.__str__c C s t | �S )z*Return a tuple of the interface endpoints.��tupler r r r � endpoints� s zInterface.endpointsc C s | j �| j| j� dS )z$Set the interface alternate setting.N)rG rT rJ rS r r r r �set_altsetting� s �zInterface.set_altsettingc c s. t | j�D ] }t| j|| j| j| j�V q
dS )z,Iterate over all endpoints of the interface.N)�ranger� r rG r r� ro �r! rM r r r �__iter__� s �zInterface.__iter__c C s t | j|| j| j| j�S )z1Return the Endpoint object in the given position.)r rG r r� ro �r! r r r r � __getitem__� s �zInterface.__getitem__c C s4 | j rd| j }nd}d| j|ttj| jdd�f S )Nz, %dr zINTERFACE %d%s: %sz
Unknown Class)r )rS rJ r r� �interface_classesr� )r! Z alt_settingr r r ru s
��zInterface._strc C s� d| � � d }d|ddt|� f dd| jf dd | jttj| j�f d
d | jf d
d | jf d
d
| j f dd| j
ttj | j
�f d
d| j f d
d| j
f dd| jt| j| j�f S )Nz rv ry rz r{ z %-19s:%#7x (9 bytes)
rf z %-19s:%#7x %s
rg z %-19s:%#7x
rJ rS r� r� r� r� z %-19s:%#7x %sr� )ru r rf rg r r� r� rJ rS r� r� r� r� r� r� r rG )r! r� r r r r� sR �� ������
�� ������ ��z"Interface._get_full_descriptor_strN)r r r )
r# r$ r% r& r: r" r� r� r� r� r� ru r� r r r r r � s �
.
r c @ sZ e Zd ZdZddd�Zdd� Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dS )r a� Represent a configuration object.
This class contains all fields of the Configuration Descriptor according to
the USB Specification. You may access them as class properties. For
example, to access the field bConfigurationValue of the configuration
descriptor, you can do so:
>>> import usb.core
>>> dev = usb.core.find()
>>> for cfg in dev:
>>> print cfg.bConfigurationValue
r c C s6 || _ || _|jj}|�| j jj|�}t|| d� dS )a� Initialize the configuration object.
The device parameter is the device object returned by the find()
function. The configuration parameter is the logical index of the
configuration (not the bConfigurationValue field). By "logical index"
we mean the relative order of the configurations returned by the
peripheral as a result of GET_DESCRIPTOR request.
) rf rg � wTotalLength�bNumInterfacesr= �iConfigurationrh � bMaxPowerrk N)rG r rl r2 Z get_configuration_descriptorr r )r! rG ro r2 rp r r r r: : s ��zConfiguration.__init__c C s d| � � d S rq rt r r r r r" ] s zConfiguration.__repr__c C s& | � � }| D ]}|dt|� 7 }q |S )N�
%sr� )r! r rm r r r r� ` s zConfiguration.__str__c C s t | �S )z/Return a tuple of the configuration interfaces.r� r r r r �
interfacesf s zConfiguration.interfacesc C s | j �| j� dS )z)Set this configuration as the active one.N)rG rE r= r r r r �setj s zConfiguration.setc
c sR t | j�D ]B}d}z"t| j||| j�V |d7 }qW q
ttfyJ Y q
0 q
dS )z1Iterate over all interfaces of the configuration.r � N)r� r� r rG r r^ �
IndexError)r! rM rU r r r r� n s zConfiguration.__iter__c C s t | j|d |d | j�S )z�Return the Interface object in the given position.
index is a tuple of two values with interface index and
alternate setting index, respectivally. Example:
>>> interface = config[(0, 0)]
r r� )r rG r r� r r r r� y s zConfiguration.__getitem__c C s d| j tj| j f S )NzCONFIGURATION %d: %d mA)r= r� �MAX_POWER_UNITS_USB2p0r� r r r r ru � s
�zConfiguration._strc C s� d| � � d }| jd@ r d}nd}| jd@ r4d}nd}d |d
d t|� f d d
| jf dd| jttj| j�f dd| j| jf dd| j f dd| j
f dd| j t | j
| j �f dd| j||f dd| jtj| j f S )Nz rv �@ ZSelfZBus� z, Remote Wakeupr ry rz r{ z %-21s:%#7x (9 bytes)
rf z %-21s:%#7x %s
rg z %-21s:%#7x (%d bytes)
r� z %-21s:%#7x
r� r= r� z %-21s:%#7x %s Powered%s
rh z %-21s:%#7x (%d mA)r� )ru rh r rf rg r r� r� r� r� r= r� r rG r� r� )r! r� ZpoweredZ
remote_wakeupr r r r� � sV
�� ��
����
�� ��
��
��z&Configuration._get_full_descriptor_strN)r )
r# r$ r% r& r: r" r� r� r� r� r� ru r� r r r r r , s
# r c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zed
d � �Z ed d
� �Z
edd� �Z edd� �Z edd� �Z
d>dd�Zdd� Zd?dd�Zdd � Zd d � Zd@d d �ZdAd!d"�ZdBd$d%�Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z ee e d<d=�Z!dS )Cr a
Device object.
This class contains all fields of the Device Descriptor according to the
USB Specification. You may access them as class properties. For example,
to access the field bDescriptorType of the device descriptor, you can
do so:
>>> import usb.core
>>> dev = usb.core.find()
>>> dev.bDescriptorType
Additionally, the class provides methods to communicate with the hardware.
Typically, an application will first call the set_configuration() method to
put the device in a known configured state, optionally call the
set_interface_altsetting() to select the alternate setting (if there is
more than one) of the interface used, and call the write() and read()
methods to send and receive data, respectively.
When working in a new hardware, the first try could be like this:
>>> import usb.core
>>> dev = usb.core.find(idVendor=myVendorId, idProduct=myProductId)
>>> dev.set_configuration()
>>> dev.write(1, 'test')
This sample finds the device of interest (myVendorId and myProductId should
be replaced by the corresponding values of your device), then configures
the device (by default, the configuration value is 1, which is a typical
value for most devices) and then writes some data to the endpoint 0x01.
Timeout values for the write, read and ctrl_transfer methods are specified
in miliseconds. If the parameter is omitted, Device.default_timeout value
will be used instead. This property can be set by the user at anytime.
c C s d| � � d S rq rt r r r r r" � s zDevice.__repr__c C st | � � }z | D ]}|dt|� 7 }qW nH tyn z| �� }|d|j 7 }W n tyh |d7 }Y n0 Y n0 |S )Nr� z" USBError Accessing Configurations)r� rD r^ rP �info)r! r ro r r r r� � s zDevice.__str__c C s t | �S )z,Return a tuple of the device configurations.r� r r r r �configurations� s zDevice.configurationsc C s� t ||�| _t| _d\| _| _| _d| _|�|�}t || d� |j
durVt |j
�| _
nd| _
|j durtt |j �| _ nd| _ |j
dur�t |j
�| _
nd| _
|jdur�t |j�| _nd| _dS )aC Initialize the Device object.
Library users should normally get a Device instance through
the find function. The dev parameter is the identification
of a device to the backend and its meaning is opaque outside
of it. The backend parameter is a instance of a backend
object.
)NNNN)rf rg �bcdUSB� bDeviceClass�bDeviceSubClass�bDeviceProtocol�bMaxPacketSize0�idVendor� idProduct� bcdDevice�
iManufacturer�iProduct�
iSerialNumber�bNumConfigurations�address�bus� port_numberZ port_numbers�speed)r1 rl �_DEFAULT_TIMEOUT�_Device__default_timeout�_serial_number�_product�
_manufacturer�_langidsZget_device_descriptorr r� �intr� r� r� )r! r r2 rp r r r r: � s,
�
zDevice.__init__c C s: | j du r4zt�| �| _ W n ty2 d| _ Y n0 | j S )a� Return the USB device's supported language ID codes.
These are 16-bit codes familiar to Windows developers, where for
example instead of en-US you say 0x0409. USB_LANGIDS.pdf on the usb.org
developer site for more info. String requests using a LANGID not
in this array should not be sent to the device.
This property will cause some USB traffic the first time it is accessed
and cache the resulting value for future use.
Nr )r� r Z get_langidsr^ r r r r �langids# s
zDevice.langidsc C s | j du rt�| | j�| _ | j S )z� Return the USB device's serial number string descriptor.
This property will cause some USB traffic the first time it is accessed
and cache the resulting value for future use.
N)r� r r r� r r r r �
serial_number6 s
zDevice.serial_numberc C s | j du rt�| | j�| _ | j S )z� Return the USB device's product string descriptor.
This property will cause some USB traffic the first time it is accessed
and cache the resulting value for future use.
N)r� r r r� r r r r �productA s
zDevice.productc C s | j du rt�| | j�| _ | j S )z� Return the USB device's manufacturer string descriptor.
This property will cause some USB traffic the first time it is accessed
and cache the resulting value for future use.
N)r� r r r� r r r r � manufacturerL s
zDevice.manufacturerc C s | j jS )z,Return the backend being used by the device.)rl r2 r r r r r2 W s zDevice.backendNc C s | j �| |� dS )a� Set the active configuration.
The configuration parameter is the bConfigurationValue field of the
configuration you want to set as active. If you call this method
without parameter, it will use the first configuration found. As a
device hardly ever has more than one configuration, calling the method
without arguments is enough to get the device ready.
N)rl rI )r! ro r r r rE \ s zDevice.set_configurationc C s | j �| �S )zZReturn a Configuration object representing the current
configuration set.
)rl rP r r r r rP g s z Device.get_active_configurationc C s | j �| ||� dS )a} Set the alternate setting for an interface.
When you want to use an interface and it has more than one alternate
setting, you should call this method to select the appropriate
alternate setting. If you call the method without one or the two
parameters, it will be selected the first one found in the Device in
the same way of the set_configuration method.
Commonly, an interface has only one alternate setting and this call is
not necessary. For most devices, either it has more than one
alternate setting or not, it is not harmful to make a call to this
method with no arguments, as devices will silently ignore the request
when there is only one alternate setting, though the USB Spec allows
devices with no additional alternate setting return an error to the
Host in response to a SET_INTERFACE request.
If you are in doubt, you may want to call it with no arguments wrapped
by a try/except clause:
>>> try:
>>> dev.set_interface_altsetting()
>>> except usb.core.USBError:
>>> pass
N)rl rV )r! rm rn r r r rT m s z Device.set_interface_altsettingc C s2 t |t�r|j}| j�� | jj�| jj|� dS )z4 Clear the halt/stall condition for the endpoint ep.N)r@ r rW rl r; r2 r� r4 )r! r[ r r r r� � s
zDevice.clear_haltc C s< | j �� | j �| d� | j j�| j j� | j �| d� dS )zReset the device.FTN)rl r; ra r2 Z reset_devicer4 r r r r �reset� s
z Device.resetc C sj | j j}tj|jtj|jtj|ji}| j � | |�\}}|t�
|j � }|| j j |j
|jt�|�| �|��S )a� Write data to the endpoint.
This method is used to send data to the device. The endpoint parameter
corresponds to the bEndpointAddress member whose endpoint you want to
communicate with.
The data parameter should be a sequence like type convertible to
the array type (see array module).
The timeout is specified in miliseconds.
The method returns the number of bytes written.
)rl r2 r �ENDPOINT_TYPE_BULKZ
bulk_write�ENDPOINT_TYPE_INTRZ
intr_write�ENDPOINT_TYPE_ISOZ iso_writer\ �
endpoint_typerh r4 rW rJ r5 �as_array�_Device__get_timeout) r! rY r� r� r2 �fn_maprL r[ �fnr r r r� � s ��z Device.writec C s� | j j}tj|jtj|jtj|ji}| j � | |�\}}|t�
|j � }t |t
j
�rX|} n
t�|�} || j j|j|j| | �|��}
t |t
j
�r�|
S |
t| �| j kr�| d|
� S | S dS )a� Read data from the endpoint.
This method is used to receive data from the device. The endpoint
parameter corresponds to the bEndpointAddress member whose endpoint
you want to communicate with. The size_or_buffer parameter either
tells how many bytes you want to read or supplies the buffer to
receive the data (it *must* be an object of the type array).
The timeout is specified in miliseconds.
If the size_or_buffer parameter is the number of bytes to read, the
method returns an array object with the data read. If the
size_or_buffer parameter is an array object, it returns the number
of bytes actually read.
N)rl r2 r r� Z bulk_readr� Z intr_readr� Ziso_readr\ r� rh r@ �array�
create_bufferr4 rW rJ r� r �itemsize) r! rY r� r� r2 r� rL r[ r� �buff�retr r r r� � s, �
� z Device.readr c C s� zt �|�}W n ty* t�|�}Y n0 | j�� |d@ }|d@ } |t jkrp| t jkrp|d@ }
| j� | |
� | jj
� | jj |||||| �
|��} t|tj�s�t �|�t jkr�| S | t|�|j kr�|d| � S |S dS )a� Do a control transfer on the endpoint 0.
This method is used to issue a control transfer over the endpoint 0
(endpoint 0 is required to always be a control endpoint).
The parameters bmRequestType, bRequest, wValue and wIndex are the same
of the USB Standard Control Request format.
Control requests may or may not have a data payload to write/read.
In cases which it has, the direction bit of the bmRequestType
field is used to infer the desired request direction. For
host to device requests (OUT), data_or_wLength parameter is
the data payload to send, and it must be a sequence type convertible
to an array object. In this case, the return value is the number
of bytes written in the data payload. For device to host requests
(IN), data_or_wLength is either the wLength parameter of the control
request specifying the number of bytes to read in data payload, and
the return value is an array object with data read, or an array
object which the data will be read to, and the return value is the
number of bytes read.
r| �` � N)r r� � TypeErrorr5 r� rl r; ZCTRL_RECIPIENT_INTERFACEZCTRL_TYPE_VENDORrN r2 �
ctrl_transferr4 r� r@ r� Zctrl_directionZCTRL_OUTr r� ) r! Z
bmRequestTypeZbRequestZwValueZwIndexZdata_or_wLengthr� r� Z recipientZrqtypeZinterface_numberr� r r r r� � s8
�� � zDevice.ctrl_transferc C s | j �� | j j�| j j|�S )z�Determine if there is kernel driver associated with the interface.
If a kernel driver is active, the object will be unable to perform
I/O.
The interface parameter is the device interface number to check.
)rl r; r2 �is_kernel_driver_activer4 �r! rm r r r r� s
�z Device.is_kernel_driver_activec C s" | j �� | j j�| j j|� dS )z�Detach a kernel driver.
If successful, you will then be able to perform I/O.
The interface parameter is the device interface number to detach the
driver from.
N)rl r; r2 �detach_kernel_driverr4 r� r r r r� * s
�zDevice.detach_kernel_driverc C s" | j �� | j j�| j j|� dS )z�Re-attach an interface's kernel driver, which was previously
detached using detach_kernel_driver().
The interface parameter is the device interface number to attach the
driver to.
N)rl r; r2 �attach_kernel_driverr4 r� r r r r� 7 s
�zDevice.attach_kernel_driverc c s t | j�D ]}t| |�V q
dS )z.Iterate over all configurations of the device.N)r� r� r r� r r r r� C s zDevice.__iter__c C s
t | |�S )z6Return the Configuration object in the given position.)r r� r r r r� H s zDevice.__getitem__c C s | j �| � d S r )rl ra r r r r �_finalize_objectL s zDevice._finalize_objectc C s |d ur |S | j S r �r� )r! r� r r r Z
__get_timeoutO s zDevice.__get_timeoutc C s |dk rt d��|| _d S )Nr z"Timeout cannot be a negative value)rC r� )r! Ztmor r r Z
__set_def_tmoT s zDevice.__set_def_tmoc C s | j S r r� r r r r Z
__get_def_tmoY s zDevice.__get_def_tmoc C s d| j | j| j| jf S )Nz,DEVICE ID %04x:%04x on Bus %03d Address %03d)r� r� r� r� r r r r ru \ s �z Device._strc C s� | � � d }| jd@ r&t| jd@ �}nd}| jd@ rDt| jd@ �}nd}d|ddt|� f dd| jf d d
| jttj | j�f d d | j| jd
@ d? | jd@ d? |f d d| j
ttj | j
�f dd| j f dd| j
f dd| j| jf dd| jf dd| jf dd| j| jd
@ d? | jd@ d? |f d d | jt| | j�f d d | jt| | j�f d d | jt| | j�f d d | jf S )!Nrv � r ry rz r{ z %-23s:%#7x (18 bytes)
rf z %-23s:%#7x %s
rg z %-23s:%#7x USB %d.%d%s
r� i � � �� � r� z %-23s:%#7x
r� r� z %-23s:%#7x (%d bytes)
r� z %-23s: %#06x
r� r� z %-23s:%#7x Device %d.%d%s
r� r� r� r� z %-23s:%#7xr� )ru r� rD r� r rf rg r r� r� r� �device_classesr� r� r� r� r� r� r r� r� r� )r! r� Z low_bcd_usbZlow_bcd_devicer r r r� ` s�
�� ���� �� ����
��������
��
��
��"��z Device._get_full_descriptor_strz*Default timeout for transfer I/O functions)�doc)N)NN)N)N)r r NN)"r# r$ r% r& r" r� r� r: �propertyr� r� r� r� r2 rE rP rT r� r� r� r� r� r� r� r� r� r� r� r� Z_Device__set_def_tmoZ_Device__get_def_tmoru r� Zdefault_timeoutr r r r r � sR #
>
!
. �
8
2�r Fc s� � �fdd�}� du r�ddl m m} ddlm m} ddlm m} |||fD ]&}|�� � � durVt� d|j
� q�qVt d��| r�|f i |��S zt �
|f i |���W S ty� Y dS 0 dS )a
Find an USB device and return it.
find() is the function used to discover USB devices. You can pass as
arguments any combination of the USB Device Descriptor fields to match a
device. For example:
find(idVendor=0x3f4, idProduct=0x2009)
will return the Device object for the device with idVendor field equals
to 0x3f4 and idProduct equals to 0x2009.
If there is more than one device which matchs the criteria, the first one
found will be returned. If a matching device cannot be found the function
returns None. If you want to get all devices, you can set the parameter
find_all to True, then find will return an iterator with all matched devices.
If no matching device is found, it will return an empty iterator. Example:
for printer in find(find_all=True, bDeviceClass=7):
print (printer)
This call will get all the USB printers connected to the system. (actually
may be not, because some devices put their class information in the
Interface Descriptor).
You can also use a customized match criteria:
dev = find(custom_match = lambda d: d.idProduct=0x3f4 and d.idvendor=0x2009)
A more accurate printer finder using a customized match would be like
so:
def is_printer(dev):
import usb.util
if dev.bDeviceClass == 7:
return True
for cfg in dev:
if usb.util.find_descriptor(cfg, bInterfaceClass=7) is not None:
return True
for printer in find(find_all=True, custom_match = is_printer):
print (printer)
Now even if the device class code is in the interface descriptor the
printer will be found.
You can combine a customized match with device descriptor fields. In this
case, the fields must match and the custom_match must return True. In the
our previous example, if we would like to get all printers belonging to the
manufacturer 0x3f4, the code would be like so:
printers = list(find(find_all=True, idVendor=0x3f4, custom_match=is_printer))
If you want to use find as a 'list all devices' function, just call
it with find_all = True:
devices = list(find(find_all=True))
Finally, you can pass a custom backend to the find function:
find(backend = MyBackend())
PyUSB has builtin backends for libusb 0.1, libusb 1.0 and OpenUSB. If you
do not supply a backend explicitly, find() function will select one of the
predefineds backends according to system availability.
Backends are explained in the usb.backend module.
c ; sR �� � D ]D}t|��� � fdd�| �� D �}t�|�r�d u sF�� �r� V qd S )Nc 3 s | ]\}}|t � |�kV qd S r )r
)�.0�key�val��dr r � <genexpr>� � z,find.<locals>.device_iter.<locals>.<genexpr>)Zenumerate_devicesr �itemsr5 Z_all)r+ r Ztests�r2 � custom_matchr� r � device_iter� s
zfind.<locals>.device_iterNr zfind(): using backend "%s"zNo backend available)Zusb.backend.libusb1r2 �libusb1Zusb.backend.libusb0�libusb0Zusb.backend.openusb�openusbZ get_backend�_loggerr� r# re r5 Z_next�
StopIteration) �find_allr2 r� r* r� r� r� r� �mr r� r r � s" D r c K s` d|d< t f i |��}d}|D ]8}| sF|d|�� ttj|j�f 7 }q |dt|� 7 }q t|�S )z�Show information about connected devices.
The verbose flag sets to verbose or not.
**kwargs are passed directly to the find() function.
Tr� r z%s, %s
z%s
)r ru r r� r� r� rD r )�verboser+ Zdevices�stringsrG r r r r � s � r )Nr r )r )FNN)F)(r& �
__author__�__all__Zusb.utilr r_ �operatorZ usb._interopr5 Zusb._objfinalizerZ
_objfinalizerZ usb._lookupZ_lookupr� Zloggingr� r8 r. Z getLoggerr� r� r r r rD r r0 rA r1 rb r^ rC re r r r ZAutoFinalizedObjectr r r r r r r �<module> sJ
�
!
o
`