descriptor_hid descriptor tool下载 - CSDN
精华内容
参与话题
  • usb-descriptor(一 )

    千次阅读 2016-12-29 17:29:50
    USB协议为USB设备定义了一套描述设备功能和属性的有固定结构的描述符,包括标准的描述符: 1. 设备描述符 2. 配置描述符 3. 接口描述符 4. 端点描述符 5. 字符串描述符 6. 百标准描述符,如类描述符。...

    USB协议为USB设备定义了一套描述设备功能和属性的有固定结构的描述符,包括标准的描述符:
    1. 设备描述符
    2. 配置描述符
    3. 接口描述符
    4. 端点描述符
    5. 字符串描述符
    6. 百标准描述符,如类描述符。
    USB设备通过这些描述符向USB主机汇报设备的各种各样属性,主机通过对这些描述符的访问对设备进行类型识别、配置并为其提供相应的客户端驱动程序。

      USB设备通过描述符反映自己的设备特性。USB描述符是由特定格式排列的一组数据结构组成。

      在USB设备枚举过程中,主机端的协义软件需要解析从USB设备读取的所有描述符信息。在USB主向设备发送读取描述符的请求后,USB设备将所有的描述符以连续的数据流方式传输给USB主机。主机从第一个读到的字符开始,根据双方规定好的数据格式,顺序地解析读到的数据流。

      USB描述符包含标准描述符、类描述符和厂商特定描述3种形式。任何一种设备必须USB标准描述符(队字符串描述符可选外)。

      在USB1.X中,规定了5种标准描述符:设备描述符(Device Descriptor)、配置描述符(Configuration Descriptor)、接口描述符(Interface Descriptor)、端点描述符(Endpoint Descriptor)和字符串描述符(String Descriptor)。

      每个USB设备只有一个设备描述符,而一个设备中可包含一个或多个配置描述符,即USB设备可以有多种配置。设备的每一个配置中又可以包含一个或多个接口描述符,即USB设备可以支持多种功能(接口),接口的特性通过描述符提供。

      在USB主机访问USB设备的描述符时,USB设备依照设备描述符、配置描述符、接口描述符、端点描述符、字符串描述符顺序将所有描述符传给主机。一设备至少要包含设备描述符、配置描述符和接口描述符,如果USB设备没有端点描述符,则它仅仅用默认管道与主机进行数据传输。

    设备描述符

      设备描述符给出了USB设备的一般信息,包括对设备及在设备配置中起全程作用的信息,包括制造商标识号ID、产品序列号、所属设备类号、默认端点的最大包长度和配置描述符的个数等。一个USB设备必须有且仅有一个设备描述符。设备描述符是设备连接到总线上时USB主机所读取的第一个描述符,它包含了14个字段,结构如下:


    偏移量 大小 描述
    0 bLength 1 数字 此描述表的字节数
    1 bDecriptorType 1 常量 描述符的类型(此处应为0x01,即设备描述符)
    2 bcdUSB 2 BCD码 此设备与描述表兼容的USB设备说明版本号(BCD 码)
    4 bDeviceClass 1 设备类码: 如果此域的值为0则一个设置下每个接口指出它自己的类,各个接口各自独立工作。 如果此域的值处于1~FEH之间,则设备在不同的接口上支持不同的类。并这些接口可能不能独立工作。此值指出了这些接口集体的类定义。 如果此域设为FFH,则此设备的类由厂商定义。
    5 bDeviceSubClass 1 子类 子类挖码 这些码值的具体含义根据bDeviceClass 域来看。 如bDeviceClass 域为零,此域也须为零 如bDeviceClass 域为FFH,此域的所有值保留。
    6 bDevicePortocol 1 协议 协议码 这些码的值视bDeviceClass 和 bDeviceSubClass 的值而定。 如果设备支持设备类相关的协议,此码标志了设备类的值。如果此域的值为零,则此设备不支持设备类相关的协议,然而,可能它的接口支持设备类相关的协议。如果此域的值为FFH,此设备使用厂商定义的协议。
    7 bMaxPacketSize0 1 数字 端点0的最大包大小(仅8,16,32,64 为合法值)
    8 idVendor 2 ID 厂商标志(由USB-IF组织赋值)
    10 idProduct 2 ID 产品标志(由厂商赋值)
    12 bcdDevice 2 BCD 码 设备发行号(BCD 码)
    14 iManufacturer 1 索引 描述厂商信息的字符串描述符的索引值。
    15 iProduct 1 索引 描述产品信息的字串描述符的索引值。
    16 iSerialNumber 1 索引 描述设备序列号信息的字串描述符的索引值。
    17 bNumConfigurations 1 数字 可能的配置描述符数目

    其中bDescriptorType为描述符的类型,其含义可查下表(此表也适用于标准命令Get_Descriptor中wValue域高字节的取值含义):

    表5、USB描述符的类型值

    类型 描述符 描述符值
    标准描述符 设备描述符(Device Descriptor) 0x01
    配置描述符(Configuration Descriptor) 0x02
    字符串描述符(String Descriptor) 0x03
    接口描述符(Interface Descriptor) 0x04
    端点描述符(EndPont Descriptor) 0x05
    类描述符 集线器类描述符(Hub Descriptor) 0x29
    人机接口类描述符(HID) 0x21
    厂商定义的描述符 0xFF

    设备类代码bDeviceClass可查下表:

    表6、设备的类别(bDeviceClass)

    值(十进制) 值(十六进制) 说明
    0 0x00 接口描述符中提供类的值
    2 0x02 通信类
    9 0x09 集线器类
    220 0xDC 用于诊断用途的设备类
    224 0xE0 无线通信设备类
    255 0xFF 厂商定义的设备类

    下表列出了一个USB鼠标的设备描述符的例子,供大家分析一下:

    表7、一种鼠标的设备描述符示例

    字段 描述符值(十六制)
    bLength 0x12
    bDecriptorType 0x01
    bcdUSB x0110
    DeviceClass 0x00
    bDeviceSubClass 0x00
    bDevicePortocol 0x00
    bMaxPacketSize0 0x08
    idVendor 0x045E(Microsoft Corporation)
    idProduct 0x0047
    bcdDevice 0x300
    iManufacturer 0x01
    iProduct 0x03
    iSerialNumber 0x00
    bNumConfigurations 0x01

    2、配置描述符

      配置描述符中包括了描述符的长度(属于此描述符的所有接口描述符和端点描述符的长度的和)、供电方式(自供电/总线供电)、最大耗电量等。主果主机发出USB标准命令Get_Descriptor要求得到设备的某个配置描述符,那么除了此配置描述符以外,此配置包含的所有接口描述符与端点描述符都将提供给USB主机。

    表8、USB配置描述符的结构

    偏移量 大小 描述
    0 bLength 1 数字 此描述表的字节数长度。
    1 bDescriptorType 1 常量 配置描述表类型(此处为0x02)
    2 wTotalLength 2 数字 此配置信息的总长(包括配置,接口,端点和设备类及厂商定义的描述符)
    4 bNumInterfaces 1 数字 此配置所支持的接口个数
    5 bCongfigurationValue 1 数字 在SetConfiguration()请求中用作参数来选定此配置。
    6 iConfiguration 1 索引 描述此配置的字串描述表索引
    7 bmAttributes 1 位图 配置特性: D7: 保留(设为一) D6: 自给电源 D5: 远程唤醒 D4..0:保留(设为一)
    8 MaxPower 1 mA 在此配置下的总线电源耗费量。以 2mA 为一个单位。

    下面是一种硬盘的配置描述符示例:

    表9、一种硬盘的配置描述符示例

    字段 描述符值(十六进制)
    bLength 0x09
    bDescriptorType 0x02
    wTotalLength 0x01F
    bNumInterfaces 0x01
    bCongfigurationValue 0x01
    iConfiguration 0x00
    bmAttributes 0x0C
    MaxPower 0x32
    展开全文
  • 在我的印象中,类中的函数是可以有两种调用方式的,如下:class ...B.func(b) 于是,在之前研究descriptor的时候,我就有了几点困惑 我将代码更换成了如下两个版本版本1import time class LazyProperty(object):...

    在我的印象中,类中的函数是可以有两种调用方式的,如下:

    class B:
        def func(self):
            return 10
    
    b = B()
    b.func()
    B.func(b)   

        于是,在之前研究descriptor的时候,我就有了几点困惑

        我将代码更换成了如下两个版本

    版本1

    import time
    
    
    class LazyProperty(object):
        def __init__(self, func):
            self.func = func
    
        def __get__(self, instance, owner):
            if instance is None:
                return self
            else:
                value = owner.func(instance)
                setattr(instance, self.func.__name__, value)
                return value
    
    
    class A:
        @LazyProperty
        def func(self):
            time.sleep(1)
            return 10
    
    a = A()
    print(a.func)

        这个版本出现的错误是:TypeError: 'LazyProperty' object is not callable。

        为什么会出现这个问题呢?

        由于instance不为None,所以会调用owner.func(instance)。

        也就是会调用A.func(a),但是呢A.func并不是一个函数,而是一个LazyProperty的实例。

        并且这个实例没有实现__call__方法,是不能像函数一样调用的。    

    版本2    

    import time
    
    
    class LazyProperty(object):
        def __init__(self, func):
            self.func = func
    
        def __get__(self, instance, owner):
            value = owner.func(instance)
            setattr(instance, self.func.__name__, value)
            return value
    
    
    class A:
        @LazyProperty
        def func(self):
            time.sleep(1)
            return 10
    
    a = A()
    print(a.func)

        表面上一看,这个应该和上个版本出现一样的问题。

        但是并不是和之前出现的是一样的错误。

        这次出现的错误是:RecursionError: maximum recursion depth exceeded

        这个是为什么呢?

        还记得我之前说的函数的调用是分为三步的吗?

        定义不用说了,现在就谈谈后面两步。

        owner.func(instance)

        在上面代码中的含义是不是A.func(a)?

        后面两步中的第一步就是找到这个A.func对象。

        记不记得A中的func其实是一个descriptor,并不是一个函数对象。

        所以A.func会返回什么呢?

        会返回descriptor中的__get__()返回的对象

        但是这个这个__get__()函数中的第一步是什么?

        对的,你没看错,还是这个owner.func(instance)。

        所以,还会继续寻找owner.func这个对象。

        有么有发现这是一个坑,会无限跳转下去?

        于是就有了错误,RecursionError: maximum recursion depth exceeded。

       终结,想要获取value值,不能通过别的方式。

        其实,还有一个问题,那就是为什么可以通过self.func(instance)来实现呢?

        想要调用类中的一个函数不是只有开头说的两个方式的吗?

        错了,错了。

        还是有第三种方式的。

        那就是在类中就调用,这个就和作用域一样了。

        在一个类中是可以直接调用其函数的。

        func = LazyProperty(func)

        其实可以换一种理解方式.

        lazyProperty = LazyProperty(func)

        要获取A.lazyProperty,就要通过__get__函数。

        然而,这个lazyProperty是不是在类A的内部。

        是不是就可以直接调用类A中定义的func方法。

        于是就是lazyProperty.func(instance),得出了所想要的结果了呢!

    展开全文
  • Descriptor

    2016-08-24 17:48:52
    /// /// Descriptor information. /// public class Descriptor { /// /// Key. /// public K Key { get; set; } /// /// Name. ///
    /// <summary>
        /// Descriptor information.
        /// </summary>
        public class Descriptor<K> {
    
            /// <summary>
            /// Key.
            /// </summary>
            public K Key { get; set; }
    
            /// <summary>
            /// Name.
            /// </summary>
            public String Name { get; set; }
    
            /// <summary>
            /// Description
            /// </summary>
            public String Description { get; set; }
    
            /// <summary>
            /// Get descriptor caption.
            /// </summary>
            public String Caption {
                get {
                    if (String.IsNullOrEmpty(Description))
                        return Name;
    
                    return String.Format("{0} - {1}", Name, Description);
                }
            }
    
            /// <summary>
            /// To String
            /// </summary>
            /// <returns>Default string display on binding list</returns>
            public override string ToString() {
                return Caption;
            }
    
            /// <summary>
            /// Equals
            /// </summary>
            /// <param name="obj">Equals object</param>
            /// <returns>When object has same key return true else return false</returns>
            public override bool Equals(object obj) {
                if (obj is Descriptor<K>) {
                    return ((Descriptor<K>)obj).Key.Equals(Key);
                }
    
                return base.Equals(obj);
            }
    
            /// <summary>
            /// Get hashcode.
            /// </summary>
            /// <returns>Hashcode</returns>
            public override int GetHashCode() {
                return Key.GetHashCode();
            }
        }


            /// <summary>
            /// Get all resource descriptors.
            /// </summary>
            /// <returns>Resource descriptor list</returns>
            public static async Task<IList<Descriptor<Int32>>> GetAllDescriptors() {
                using (MesproContext db = GetContext()) {
                    return await db.Resources
                                   .OrderBy(m => m.Name)
                                   .Select(m => new Descriptor<Int32>() { Key = m.ID, Name = m.Name, Description = m.Description })
                                   .ToListAsync();
                }
            }


    展开全文
  • Python中的descriptor

    2018-10-06 11:06:08
    1. 一切皆对象  在python中不仅仅是类的实例是对象,包括类和函数也是对象。 2.函数对象  可以看看下面的outer 返回的是什么 def outer(): def inner(): return 10 return inner ...l...

    1. 一切皆对象

        在python中不仅仅是类的实例是对象,包括类和函数也是对象。

    2.函数对象

           可以看看下面的outer 返回的是什么

    def outer():
        def inner():
            return 10
        return inner
    func = outer()
    print(func)

        可以看出,func为一个函数对象:<function outer.<locals>.inner at 0x0000021BAFB4C620>。

        并且这个函数对象是可以调用的。

    def outer():
        def inner():
            return 10
        return inner
    func = outer()
    print(func())

        这个打印的结果为10。

        我在这里觉得函数的调用是分三步的,

    1. 定义一个函数func对象
    2. 发现一个func对象
    3. 调用这个func()对象

    3.descriptor

        一个类中定义了__set__, __get__和__delete__中的一个或多个就是descriptor。

        __get__函数定义的时候需要的参数为三个,分别为self, instance, owner。

        __set__函数定义的时候需要的参数为三个,分别是self, instance, value。

        可以通过一个例子来看看这三个参数分别是什么。

    class A:
        def __init__(self, val):
            self.val = val
        def __get__(self, instance, owner):
            print('self is ', self)
            print('instance is ', instance)
            print('owner is ', owner)
            return self.val
    
    class B:
        a = A(10)
    
    b = B()
    print(b.a)

        打印的结果为:

    self is  <__main__.A object at 0x000001AACC2FCDD8>
    instance is  <__main__.B object at 0x000001AACC4A1438>
    owner is  <class '__main__.B'>
    10

        可以知道,self很简单,就是descriptor的实例;instance就是descriptor所在类中的实例;owner指的是descriptor所在的类。

        还可以看出来的是,打印的b.a不是一个是实例对象,而是通过调用a.__get__()函数返回的值。

        所以我感觉这个descriptor叫做描述器(借鉴于decorator)似乎更合适。。。

        因为这个descriptor似乎是用来描述所在的实例的。。。

        总结:通过实例调用(b.a)这个descriptor对象,返回的并不是这个descriptor(你可以尝试打印一个实例对象,看看返回的是什么),而是该descriptor调用__get__返回的值,所以这个a像是b的描述器。

    4.一个descriptor用来做decorator的实例。

    class LazyProperty(object):
        def __init__(self, func):
            self.func = func
    
        def __get__(self, instance, owner):
            if instance is None:
                return self
            else:
                value = self.func(instance)
                setattr(instance, self.func.__name__, value)
                return value
    
    class A:
        @LazyProperty
        def func(self):
            time.sleep(1)
            return 10

        看见装饰器,刚开始没习惯可能会有点困扰。其实没那么复杂,根据定义一步步解读就好了。

        类A中的func被LazyProperty所装饰,那么其实它可以简单的转化为两步

    class A:
        def func(self):
            time.sleep(1)
            return 10
        func = LazyProperty(func)

        于是,这个func是不是就是转化成为了一个descriptor呢?

        对的,你没猜错,这个func就是A的描述器!!!

        那么通过如下调用返回的结果是什么呢???

    a = A()
    print(a.func)

        当然是这个func(需要注意的是,这个func并不是类A中定义的func函数,而是LazyProperty的实例)通过调用__get__返回的值呀!

        由于是通过A的实例a来取得其中的func的值,所以__get__中的参数instance并不是None,而是a(那么什么时候这个instance为None呢?那就是通过类来调用这个属性,也就是A.func)。

        所以会通过setattr函数为实例a添加属性func.__name__,并对其赋值为调用类A中定义的func函数返回的值。

        那么,之后再次调用a.func返回的是什么呢?

    import time
    class LazyProperty(object):
        def __init__(self, func):
            self.func = func
    
        def __get__(self, instance, owner):
            if instance is None:
                return self
            else:
                value = self.func(instance)
                setattr(instance, self.func.__name__, value)
                return value
    
    class A:
        @LazyProperty
        def func(self):
            time.sleep(1)
            return 10
    a = A()
    print(a.func)
    print(a.func)

        可以看出来的是两个打印的值在程序运行1秒之后是几乎同时出现的, 第一次打印的a.func是sleep(1)后返回的结果。而第二次基本上和第一次打印a.func同时出现。

        为什么会不是等第一个出现需要1秒钟,等第二个出现再需要1秒钟呢?怎么两个几乎同时出现呢?

        这个当时困扰我很久,,,甚至懵逼很久。

        但是是相当简单的,第二次就是应该直接返回的数值10。

        因为实例a的属性func,变成了数值10。是通过setattr()来实现的。

        可以等价的换为如下问题:

        下面第二次打印a的值是什么呢?

    a = 10
    print(a)
    a = 11
    print(a)

        这个问题很简单了把,当然是11啦!!!

       在Django框架中,也用到了同样的方式,在django.utils.functional

       代码如下:

    class cached_property:
        """
        Decorator that converts a method with a single self argument into a
        property cached on the instance.
    
        Optional ``name`` argument allows you to make cached properties of other
        methods. (e.g.  url = cached_property(get_absolute_url, name='url') )
        """
        def __init__(self, func, name=None):
            self.func = func
            self.__doc__ = getattr(func, '__doc__')
            self.name = name or func.__name__
    
        def __get__(self, instance, cls=None):
            """
            Call the function and put the return value in instance.__dict__ so that
            subsequent attribute access on the instance returns the cached value
            instead of calling cached_property.__get__().
            """
            if instance is None:
                return self
            res = instance.__dict__[self.name] = self.func(instance)
            return res

      在flask中同样用到了

    class cached_property(property):
    
        """A decorator that converts a function into a lazy property.  The
        function wrapped is called the first time to retrieve the result
        and then that calculated result is used the next time you access
        the value::
    
            class Foo(object):
    
                @cached_property
                def foo(self):
                    # calculate something important here
                    return 42
    
        The class has to have a `__dict__` in order for this property to
        work.
        """
    
        # implementation detail: A subclass of python's builtin property
        # decorator, we override __get__ to check for a cached value. If one
        # choses to invoke __get__ by hand the property will still work as
        # expected because the lookup logic is replicated in __get__ for
        # manual invocation.
    
        def __init__(self, func, name=None, doc=None):
            self.__name__ = name or func.__name__
            self.__module__ = func.__module__
            self.__doc__ = doc or func.__doc__
            self.func = func
    
        def __set__(self, obj, value):
            obj.__dict__[self.__name__] = value
    
        def __get__(self, obj, type=None):
            if obj is None:
                return self
            value = obj.__dict__.get(self.__name__, _missing)
            if value is _missing:
                value = self.func(obj)
                obj.__dict__[self.__name__] = value
            return value

     

    给大家留个问题思考

    1. __get__函数中的获取value值可不可以通过owner.func(instance)来获得呢?

    展开全文
  • @descriptor

    2018-10-08 14:02:01
    const log = (target, name, descriptor) =&gt; { //ES6实现AOP const _handler = descriptor.value; descriptor.value = function(){ console.log(arguments); _handler.apply(this,arguments); }; ...
  • Python描述符 (descriptor) 详解

    千次阅读 2019-05-29 10:37:53
    1、什么是描述符? python描述符是一个“绑定行为”的对象属性,在描述符协议中,它可以通过方法重写属性的访问。这些方法有 get(), set(), 和__delete__()。如果这些方法中的任何一个被定义在一个对象中,这个对象...
  • JS中的descriptor

    2020-04-25 21:51:33
    JS中的descriptor,属性描述对象,在Object.defineProperty()中会用到,其值如下: { value: 属性值, enumerable: false, // 是否可枚举 configurable: true, // 是否可配置 writable: true // 是否可写 } ....
  • 对于报 'Bad file descriptor'错误的原因

    万次阅读 2015-11-29 15:21:53
    reason: '*** -[NSConcreteFileHandle writeData:]: Bad file descriptor’ 原因是在创建文件句柄的时候:把方法  NSFileHandle *handle =[NSFileHandlefileHandleForWritingAtPath:filePath]; 写成...
  • socket编程时 send: Bad file descriptor

    万次阅读 2011-05-31 17:34:00
    reason: It could be that you are closing the client socket before the thread gets a chance to run, or it could be that your thread is improperly setup.
  • python socket.error: [Errno 9] Bad file descriptor的解决办法这个错误很明显 ,是因为你关闭了套接字对象后,又再次去调用了套接字对象,此时套接字链接已经被关闭,你不能再去调用,所以才会出现这种错误,复查...
  • 启动eclipse之后,进行相关操作时,弹出界面,提示:loading descriptor for xxx   解决方法: 在Eclipse左侧的Project Explorer 最右上角有一个小钮,鼠标移上去时提示"View Menu". 你点一下,在弹出的上...
  • 我想大概会有人出错的。hhhh Fail to load plugin descriptor from file MyBatis-4.02.jar 只需要把jar包改为zip格式即可。 这种方式是先下载好jar包。其它博客有怎么下载。 ...
  • ![就和这个一样](https://img-ask.csdn.net/upload/201702/20/1487574502_407072.png) ![正常应该是这样啊](https://img-ask.csdn.net/upload/201702/20/1487574543_545863.png)
  • bad file descriptor

    万次阅读 2017-12-21 16:36:46
    以下代码在进行文件写入时,报了一个panic: write defer-file.txt: bad file descriptor错误 func writeString(){ var f *os.File var err error if checkFileIsExist(path){ f,err = os.OpenFile(path,os.O...
  • 如图所示 !... !... 如图所示,这两幅图是不同的...应该是缺少了Deployment Descriptor。但这是为什么呢? 另外不要回答 右键项目----属性----project fact 勾选Dynamic Web Module 我已经试过了,不行的,有没有懂的?
  • Failed to read artifact descriptor for xxx:jar

    万次阅读 多人点赞 2017-10-11 10:38:01
    在MyEclipse中执行Maven的install命令时,报“Failed to read artifact descriptor for xxx:jar ”的错误。这可能是在下载过程中文件出现错误。  解决办法:从本地的maven库中删除相关的jar包,然后右单击项目,...
  • 想学学python网络编程,按书上写了两个服务器和客户端小程序,结果发现报错: Traceback (most recent call last):  File "./tsTserv.py", line 20, in  data = tcpCliSock.recv(BUFSIZ)  File "/usr/lib/...
  • 错误提示为: Can not find the tag library descriptor for "http://java.sun.com/jsp/jstl/core" 解决此问题的方法为以下: 在WEB-INF/lib里加入 jstl.jar
  • Tomcat Error deploying configuration descriptor...的错误处理   错误日志如下;  Error deploying configuration descriptor jeecg.xml  org.apache.tomcat.util.bcel.classfile.ClassFormatException: Invalid...
  • 问题现象:mount时,出现“Bad file descriptor” 解决方案: 1、关闭10.0.1.2 虚拟机的防火墙 命令:service iptables stop 2、重启10.0.1.2 虚拟机的nfs服务 命令:service nfs restart 然后重新...
1 2 3 4 5 ... 20
收藏数 137,479
精华内容 54,991
关键字:

descriptor