【新版CH554评测】---4.2、USB HID例程学习及验证--代码

yang_alex

【新版CH554评测】---4.2、USB HID例程学习及验证--代码 [复制链接]

       USB的数据通讯都是由主机发起的，主机发给从机一个命令（或叫请求），告诉从机，你要发给我什么，你要干什么。所有的USB设备都要求对主机发给自己的控制命令作出响应。在USB规范中，这个命令（或叫请求）是有格式要求的。他的格式如下：
      

       USB主机发给从机的命令（或叫请求）分为标准命令（请求）和HID设备类特定的命令（请求）。

       USB主机发给从机的标准请求如下：
      

       USB主机发给从机的HID设备类特定的请求如下：
      
       在USB的数据传输中，相关信息是分层体现的，具体来说就是：一个【传输】由多个【事务】组成；一个【事务】又由一个或多个【包】组成。
【传输】（Transfer）包括4种不同类型的传输方式：控制传输(Control Transfer)，批量传输(Bulk Transfer)，中断传输(Interrupt Transfer)和实时传输(IsochTransfer)。在HID设备中用到了控制传输和中断传输。所有的HID设备通过USB的控制管道（默认管道，即端点0）和中断管道与主机通信。

【事务】（Transaction）可以分成三类：Setup transaction：主机用来向设备发送控制命令 ；Data IN transaction：主机用来从设备读取数据 ；Data OUT transaction：主机用来向设备发送数据 。

【包】（Packet）可以分成四类：令牌包（Token Packet）、数据包（Data Packet）、握手包（Hand Shake Packet）、特殊包（Special Packet）。 USB通讯是以包（Packet）为单位，包里包含包标识符PID（Packet Identifier），用来说明包的类型。

令牌包(Token Packet):令牌包用来启动一次USB传输。包括下面4种：
输出（OUT）令牌包：用来通知设备将要输出一个数据包
输入（IN）令牌包：用来通知设备返回一个数据包
建立（SETUP）令牌包：只用在控制传输中，和输出令牌包作用一样，也是通知设备将要输出一个数据包，两者区别在于:
SETUP令牌包后只使用DATA0数据包，且只能发送到设备的控制端点，并且设备必须要接收，而OUT令牌包没有这些限制
帧起始（SOF）令牌包：在每帧（或微帧）开始时发送，以广播的形式发送，所有USB全速设备和高速设备都可以接收到SOF包。

数据包（Data Packet）顾名思义数据包就是用来传输数据的，分为下面几种：
DATA0和DATA1（USB1.1规范中定义）
DATA2和MDATA包（USB2.0规范中增加）

握手包（Hand Shake Packet）用来识别传输是否被对方确认。包括下面4种：
ACK，NAK，STALL，NYET

特殊包（Special Packet）特殊场合使用的包。包括下面4种：
PRE，ERR，SPLIT，和PING

了解了上面的基础知识后，我们开始分析代码：
       当检测到 USB 总线复位、USB 总线挂起或唤醒事件，或者当 USB 成功处理完数据发送或者数据接收后，USB 协议处理器都将设置相应的中断标志并产生中断请求。应用程序可以直接查询或在 USB中断服务程序中查询并分析中断标志寄存器 USB_INT_FG，根据 IF_BUS_RST 和 UIF_SUSPEND 进行相应的处理；
   
   并且，如果UIF_TRANSFER 有效，那么还需要继续分析 USB 中断状态寄存器 USB_INT_ST，根据当前端点号 MASK_UIS_ENDP 和当前事务令牌 PID 标识 MASK_UIS_TOKEN 进行相应的处理。   UIS_TOKEN_IN、UIS_TOKEN_OUT、UIS_TOKEN_SETUP分别对应前面提到的【输入（IN）令牌包】、【输出（OUT）令牌包】和【建立（SETUP）令牌包】。
（注意，为了看起来清爽些，我删除了部分代码，留下主要框架）

1. /*******************************************************************************
   
2. * Function Name  : DeviceInterrupt()
   
3. * Description    : CH559USB中断处理函数
   
4. *******************************************************************************/
   
5. void    DeviceInterrupt( void ) interrupt INT_NO_USB using 1            //USB中断服务程序,使用寄存器组1
   
6. {
   
7.     UINT8 len,i;
   
8.     if(UIF_TRANSFER)                                                       //USB传输完成标志
   
9.     {
   
10.         switch (USB_INT_ST & (MASK_UIS_TOKEN | MASK_UIS_ENDP))
    
11.         {
    
12.         case UIS_TOKEN_IN | 2:                                                  //endpoint 2# 端点批量上传
    
13.         case UIS_TOKEN_OUT | 2:                                                 //endpoint 2# 端点批量下传
    
14.         case UIS_TOKEN_SETUP | 0:                                               //SETUP事务
    
15.         case UIS_TOKEN_IN | 0:                                                  //endpoint0 IN
    
16.         case UIS_TOKEN_OUT | 0:                                                 // endpoint0 OUT
    
17.         default:
    
18.         }
    
19.         UIF_TRANSFER = 0;                                                       //写0清空中断
    
20.     }
    
21.     if(UIF_BUS_RST)                                                        //设备模式USB总线复位中断
    
22.     {
    
23.         UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
    
24.         UEP1_CTRL = bUEP_AUTO_TOG | UEP_R_RES_ACK;
    
25.         UEP2_CTRL = bUEP_AUTO_TOG | UEP_R_RES_ACK | UEP_T_RES_NAK;
    
26.         USB_DEV_AD = 0x00;
    
27.         UIF_SUSPEND = 0;
    
28.         UIF_TRANSFER = 0;
    
29.         UIF_BUS_RST = 0;                                                             //清中断标志
    
30.     }
    
31.     if (UIF_SUSPEND)                                                       //USB总线挂起/唤醒完成
    
32.     {
    
33.         UIF_SUSPEND = 0;
    
34.         if ( USB_MIS_ST & bUMS_SUSPEND )                                             //挂起
    
35.         {
    
36.         }
    
37.     }
    
38.     else {                                                                 //意外的中断,不可能发生的情况
    
39.         USB_INT_FG = 0xFF;                                                             //清中断标志
    
40.     }
    
41. }
    

复制代码

       非0端点的令牌包处理起来比较简单：
       如果事先设定了各个端点的 OUT 事务的同步触发位 bUEP_R_TOG，那么可以通过 U_TOG_OK 或 bUIS_TOG_OK判断当前所接收到的数据包的同步触发位是否与该端点的同步触发位匹配，如果数据同步，则数据有效；如果数据不同步，则数据应该被丢弃。每次处理完USB 发送或者接收中断后，都应该正确修改相应端点的同步触发位，用于同步下次所发送的数据包和检测下次所接收的数据包是否同步；另外，通过设置 bUEP_AUTO_TOG 可以实现在发送成功或者接收成功后自动翻转相应的同步触发位。

1.         case UIS_TOKEN_IN | 2:                                                  //endpoint 2# 端点批量上传
   
2.              UEP2_T_LEN = 0;                                                    //预使用发送长度一定要清空
   
3. //           UEP1_CTRL ^= bUEP_T_TOG;                                           //如果不设置自动翻转则需要手动翻转
   
4.              UEP2_CTRL = UEP2_CTRL & ~ MASK_UEP_T_RES | UEP_T_RES_NAK;          //默认应答NAK
   
5.              break;
   
6.         case UIS_TOKEN_OUT | 2:                                                 //endpoint 2# 端点批量下传
   
7.             if ( U_TOG_OK )                                                     // 不同步的数据包将丢弃
   
8.             {
   
9.                 len = USB_RX_LEN;                                               //接收数据长度，数据从Ep2Buffer首地址开始存放
   
10.                 for ( i = 0; i < len; i ++ )
    
11.                 {
    
12.                     Ep2Buffer[MAX_PACKET_SIZE+i] = Ep2Buffer[i] ^ 0xFF;         // OUT数据取反到IN由计算机验证
    
13.                 }
    
14.                 UEP2_T_LEN = len;
    
15.                 UEP2_CTRL = UEP2_CTRL & ~ MASK_UEP_T_RES | UEP_T_RES_ACK;       // 允许上传
    
16.             }
    
17.             break;
    

复制代码

       端点0的令牌包处理起来复杂一些，这是因为设备的各种描述符和主机的命令都是通过端点0传输的。
       先说端点0的建立（SETUP）令牌包处理：识别出建立令牌包后，获取USB接收数据长度，与建立请求的大小比较，如不符合，则错误，进行错误处理。如符合，则进一步处理。通过获取请求类型，来识别是HID类命令还是标准请求。（注意，为了看起来清爽些，我删除了部分代码，留下主要框架）

1.         case UIS_TOKEN_SETUP | 0:                                               //SETUP事务
   
2.             len = USB_RX_LEN;
   
3.             if(len == (sizeof(USB_SETUP_REQ)))
   
4.             {
   
5.                 SetupLen = UsbSetupBuf->wLengthL;
   
6.                 len = 0;                                                         // 默认为成功并且上传0长度
   
7.                 SetupReq = UsbSetupBuf->bRequest;                                                        
   
8.                 if ( ( UsbSetupBuf->bRequestType & USB_REQ_TYP_MASK ) != USB_REQ_TYP_STANDARD )/*HID类命令*/
   
9.                 {                                                               
   
10.                 }
    
11.                 else                                                             //标准请求
    
12.                 {
    
13.                 }
    
14.             }
    
15.             else
    
16.             {
    
17.                 len = 0xff;                                                          //包长度错误
    
18.             }
    
19.             if(len == 0xff)
    
20.             {
    
21.                 SetupReq = 0xFF;
    
22.                 UEP0_CTRL = bUEP_R_TOG | bUEP_T_TOG | UEP_R_RES_STALL | UEP_T_RES_STALL;//STALL
    
23.             }
    
24.             else if(len <= THIS_ENDP0_SIZE)                                         //上传数据或者状态阶段返回0长度包
    
25.             {
    
26.                 UEP0_T_LEN = len;
    
27.                 UEP0_CTRL = bUEP_R_TOG | bUEP_T_TOG | UEP_R_RES_ACK | UEP_T_RES_ACK;//默认数据包是DATA1，返回应答ACK
    
28.             }
    
29.             else
    
30.             {
    
31.                 UEP0_T_LEN = 0;  //虽然尚未到状态阶段，但是提前预置上传0长度数据包以防主机提前进入状态阶段
    
32.                 UEP0_CTRL = bUEP_R_TOG | bUEP_T_TOG | UEP_R_RES_ACK | UEP_T_RES_ACK;//默认数据包是DATA1,返回应答ACK
    
33.             }
    
34.             break;

复制代码

       HID类命令处理：（从代码中可以看出，程序只对HID的Get_Report请求做了简单处理）

1.   if ( ( UsbSetupBuf->bRequestType & USB_REQ_TYP_MASK ) != USB_REQ_TYP_STANDARD )/*HID类命令*/
   
2. {
   
3.       switch( SetupReq )                                             
   
4.       {
   
5.            case 0x01:                                                   //GetReport
   
6.                       pDescr = UserEp2Buf;                                    //控制端点上传输据
   
7.                       if(SetupLen >= THIS_ENDP0_SIZE)                         //大于端点0大小，需要特殊处理
   
8.                      {
   
9.                                len = THIS_ENDP0_SIZE;
   
10.                      }
    
11.                      else
    
12.                      {  
    
13.                                len = SetupLen;
    
14.                      }                                                                        
    
15.                      break;
    
16.            case 0x02:                                                   //GetIdle
    
17.                      break;        
    
18.            case 0x03:                                                   //GetProtocol
    
19.                      break;                                
    
20.            case 0x09:                                                   //SetReport
    
21.                      break;
    
22.            case 0x0A:                                                   //SetIdle
    
23.                       break;        
    
24.            case 0x0B:                                                   //SetProtocol
    
25.                       break;
    
26.           default:
    
27.                       len = 0xFF;                    /*命令不支持*/                                       
    
28.                        break;
    
29.      }        
    
30.      if ( SetupLen > len )
    
31.      {
    
32.           SetupLen = len;    //限制总长度
    
33.      }
    
34.      len = SetupLen >= THIS_ENDP0_SIZE ? THIS_ENDP0_SIZE : SetupLen;//本次传输长度
    
35.      memcpy(Ep0Buffer,pDescr,len);                            //加载上传数据
    
36.      SetupLen -= len;
    
37.      pDescr += len;                                                                        
    
38. }

复制代码

        标准请求处理：（从代码中可以看出，程序分别对GET_DESCRIPTOR、SET_ADDRESS、GET_CONFIGURATION、SET_CONFIGURATION、CLEAR_FEATURE、SET_FEATURE、GET_STATUS7种请求做了处理）

1. else                                                             //标准请求
   
2. {
   
3.     switch(SetupReq)                                             //请求码
   
4.     {
   
5.     case USB_GET_DESCRIPTOR:
   
6.         switch(UsbSetupBuf->wValueH)
   
7.         {
   
8.         }
   
9.         len = SetupLen >= THIS_ENDP0_SIZE ? THIS_ENDP0_SIZE : SetupLen;//本次传输长度
   
10.         memcpy(Ep0Buffer,pDescr,len);                            //加载上传数据
    
11.         SetupLen -= len;
    
12.         pDescr += len;
    
13.         break;
    
14.     case USB_SET_ADDRESS:
    
15.         SetupLen = UsbSetupBuf->wValueL;                         //暂存USB设备地址
    
16.         break;
    
17.     case USB_GET_CONFIGURATION:
    
18.         Ep0Buffer[0] = UsbConfig;
    
19.         if ( SetupLen >= 1 )
    
20.         {
    
21.             len = 1;
    
22.         }
    
23.         break;
    
24.     case USB_SET_CONFIGURATION:
    
25.         UsbConfig = UsbSetupBuf->wValueL;
    
26.         break;
    
27.     case 0x0A:
    
28.         break;
    
29.     case USB_CLEAR_FEATURE:                                      //Clear Feature
    
30.         if ( ( UsbSetupBuf->bRequestType & USB_REQ_RECIP_MASK ) == USB_REQ_RECIP_ENDP )// 端点
    
31.         {
    
32.         }
    
33.         else
    
34.         {
    
35.             len = 0xFF;                                           // 不是端点不支持
    
36.         }
    
37.        break;
    
38.     case USB_SET_FEATURE:                                         /* Set Feature */
    
39.         if( ( UsbSetupBuf->bRequestType & 0x1F ) == 0x00 )        /* 设置设备 */
    
40.         {
    
41.            if( ( ( ( UINT16 )UsbSetupBuf->wValueH << 8 ) | UsbSetupBuf->wValueL ) == 0x01 )
    
42.            {
    
43.                 if( CfgDesc[ 7 ] & 0x20 )
    
44.                 {
    
45.                    /* 设置唤醒使能标志 */
    
46.                 }
    
47.                else
    
48.                {
    
49.                     len = 0xFF;                                    /* 操作失败 */
    
50.                }
    
51.              }
    
52.             else
    
53.             {
    
54.                 len = 0xFF;                                        /* 操作失败 */
    
55.             }
    
56.        }
    
57.        else if( ( UsbSetupBuf->bRequestType & 0x1F ) == 0x02 )    /* 设置端点 */
    
58.        {
    
59.             if( ( ( ( UINT16 )UsbSetupBuf->wValueH << 8 ) | UsbSetupBuf->wValueL ) == 0x00 )
    
60.            {
    
61.                switch( ( ( UINT16 )UsbSetupBuf->wIndexH << 8 ) | UsbSetupBuf->wIndexL )
    
62.                {
    
63.                 case 0x82:
    
64.                     UEP2_CTRL = UEP2_CTRL & (~bUEP_T_TOG) | UEP_T_RES_STALL;/* 设置端点2 IN STALL */
    
65.                     break;
    
66.                 case 0x02:
    
67.                     UEP2_CTRL = UEP2_CTRL & (~bUEP_R_TOG) | UEP_R_RES_STALL;/* 设置端点2 OUT Stall */
    
68.                     break;
    
69.                 case 0x81:
    
70.                     UEP1_CTRL = UEP1_CTRL & (~bUEP_T_TOG) | UEP_T_RES_STALL;/* 设置端点1 IN STALL */
    
71.                     break;
    
72.                 default:
    
73.                     len = 0xFF;                                     /* 操作失败 */
    
74.                     break;
    
75.                 }
    
76.             }
    
77.             else
    
78.             {
    
79.                 len = 0xFF;                                         /* 操作失败 */
    
80.             }
    
81.         }
    
82.         else
    
83.         {
    
84.            len = 0xFF;                                             /* 操作失败 */
    
85.         }
    
86.         break;
    
87.     case USB_GET_STATUS:
    
88.         Ep0Buffer[0] = 0x00;
    
89.         Ep0Buffer[1] = 0x00;
    
90.         if ( SetupLen >= 2 )
    
91.         {
    
92.            len = 2;
    
93.        }
    
94.        else
    
95.        {
    
96.           len = SetupLen;
    
97.        }
    
98.        break;
    
99.     default:
    
100.        len = 0xff;                                                  //操作失败
     
101.        break;
     
102.     }
     
103.   }
     
104. }

复制代码

       再详细看一下对GET_DESCRIPTOR（获得描述符请求）的处理。 GET_DESCRIPTOR请求的wValue字段的高字节表示要取得描述符类型，低字节表示描述符的索引值，描述的类型有：1表示设备描述符，2表示配置描述符，3表示字符串描述符，4表示接口描述符，5表示端点描述符，0x22表示报表描述符。         

1. 
   
2. case USB_GET_DESCRIPTOR:
   
3.      switch(UsbSetupBuf->wValueH)
   
4.      {
   
5.          case 1:                                                  //设备描述符
   
6.              pDescr = DevDesc;                                    //把设备描述符送到要发送的缓冲区
   
7.              len = sizeof(DevDesc);
   
8.              break;
   
9.          case 2:                                                  //配置描述符
   
10.              pDescr = CfgDesc;                                    //把设备描述符送到要发送的缓冲区
    
11.              len = sizeof(CfgDesc);
    
12.              break;
    
13.          case 0x22:                                               //报表描述符
    
14.              pDescr = HIDRepDesc;                                 //数据准备上传
    
15.              len = sizeof(HIDRepDesc);
    
16.              Ready = 1;                           //如果有更多接口，该标准位应该在最后一个接口配置完成后有效
    
17.              break;
    
18.          default:
    
19.              len = 0xff;                                          //不支持的命令或者出错
    
20.              break;
    
21.      }
    
22.      if ( SetupLen > len )
    
23.      {
    
24.          SetupLen = len;    //限制总长度
    
25.      }
    
26.      len = SetupLen >= THIS_ENDP0_SIZE ? THIS_ENDP0_SIZE : SetupLen;//本次传输长度
    
27.      memcpy(Ep0Buffer,pDescr,len);                            //加载上传数据
    
28.      SetupLen -= len;
    
29.      pDescr += len;
    
30.      break;

复制代码

     端点0的输入和输出令牌包处理起来就简单一些了。

1.         case UIS_TOKEN_IN | 0:                                                      //endpoint0 IN
   
2.             switch(SetupReq)
   
3.             {
   
4.             case USB_GET_DESCRIPTOR:
   
5.             case HID_GET_REPORT:                                                        
   
6.                 len = SetupLen >= THIS_ENDP0_SIZE ? THIS_ENDP0_SIZE : SetupLen;     //本次传输长度
   
7.                 memcpy( Ep0Buffer, pDescr, len );                                   //加载上传数据
   
8.                 SetupLen -= len;
   
9.                 pDescr += len;
   
10.                 UEP0_T_LEN = len;
    
11.                 UEP0_CTRL ^= bUEP_T_TOG;                                            //同步标志位翻转
    
12.                 break;
    
13.             case USB_SET_ADDRESS:
    
14.                 USB_DEV_AD = USB_DEV_AD & bUDA_GP_BIT | SetupLen;
    
15.                 UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
    
16.                 break;
    
17.             default:
    
18.                 UEP0_T_LEN = 0;                         //状态阶段完成中断或者是强制上传0长度数据包结束控制传输
    
19.                 UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
    
20.                 break;
    
21.             }
    
22.             break;
    
23.         case UIS_TOKEN_OUT | 0:  // endpoint0 OUT
    
24.             len = USB_RX_LEN;
    
25.             if(SetupReq == 0x09)
    
26.             {
    
27.                 if(Ep0Buffer[0])
    
28.                 {
    
29.                     printf("Light on Num Lock LED!\n");
    
30.                 }
    
31.                 else if(Ep0Buffer[0] == 0)
    
32.                 {
    
33.                     printf("Light off Num Lock LED!\n");
    
34.                 }
    
35.             }
    
36.             UEP0_CTRL ^= bUEP_R_TOG;                                     //同步标志位翻转               
    
37.             break;

复制代码

      到此，USB中断函数就分析完了。      但是大家会不会觉得奇怪：没看到数据包、握手包、帧起始包的处理啊？其实这些包的处理都是被MCU硬件处理了。我们在程序中设置或读取他们的状态标志就可以了。

      烧录到评估板，并运行。找到USB设备（这个没名字，开始找了半天），可以发现PID  2007、VID 5131、 PVN 0000 正是我们前面设备描述符中设置的(0x31,0x51,0x07,0x20,0x00,0x00).通过窗口发送32个HEX数据，结果收到端点2返回64个数据。      

1. /*设备描述符*/
   
2. UINT8C DevDesc[18] = {0x12,0x01,0x10,0x01,0x00,0x00,0x00,THIS_ENDP0_SIZE,
   
3.                       0x31,0x51,0x07,0x20,0x00,0x00,0x00,0x00,
   
4.                       0x00,0x01
   
5.                      };

复制代码

      用监视HID功能，发现发送的数据和返回的数据正好互补。
      
      分析代码可知，是在下面代码处将收到的数据取反，然后放到发送的缓冲区。
     

1.         case UIS_TOKEN_IN | 2:                                                  //endpoint 2# 端点批量上传             UEP2_T_LEN = 0;                                                    //预使用发送长度一定要清空
   
2. //            UEP1_CTRL ^= bUEP_T_TOG;                                          //如果不设置自动翻转则需要手动翻转
   
3.             UEP2_CTRL = UEP2_CTRL & ~ MASK_UEP_T_RES | UEP_T_RES_NAK;           //默认应答NAK
   
4.             break;
   
5.         case UIS_TOKEN_OUT | 2:                                                 //endpoint 2# 端点批量下传
   
6.             if ( U_TOG_OK )                                                     // 不同步的数据包将丢弃
   
7.             {
   
8.                 len = USB_RX_LEN;                                 //接收数据长度，数据从Ep2Buffer首地址开始存放
   
9.                 for ( i = 0; i < len; i ++ )
   
10.                 {
    
11.                  Ep2Buffer[MAX_PACKET_SIZE+i] = Ep2Buffer ^ 0xFF;     // ★★★OUT数据取反到IN由计算机验证★★★
    
12.                 }
    
13.                 UEP2_T_LEN = len;
    
14.                 UEP2_CTRL = UEP2_CTRL & ~ MASK_UEP_T_RES | UEP_T_RES_ACK;       // 允许上传
    
15.             }
    
16.             break;

复制代码

     修改代码，不再取反。重新编译烧录，发现果然返回的数据和发送的数据一样。

1.         case UIS_TOKEN_IN | 2:                                                  //endpoint 2# 端点批量上传
   
2.              UEP2_T_LEN = 0;                                                    //预使用发送长度一定要清空
   
3. //            UEP1_CTRL ^= bUEP_T_TOG;                                          //如果不设置自动翻转则需要手动翻转
   
4.             UEP2_CTRL = UEP2_CTRL & ~ MASK_UEP_T_RES | UEP_T_RES_NAK;           //默认应答NAK
   
5.             break;
   
6.         case UIS_TOKEN_OUT | 2:                                                 //endpoint 2# 端点批量下传
   
7.             if ( U_TOG_OK )                                                     // 不同步的数据包将丢弃
   
8.             {
   
9.                 len = USB_RX_LEN;                          //接收数据长度，数据从Ep2Buffer首地址开始存放
   
10.                 for ( i = 0; i < len; i ++ )
    
11.                 {
    
12.                     Ep2Buffer[MAX_PACKET_SIZE+i] = Ep2Buffer;         // ★★★OUT数据发回计算机验证★★★
    
13.                 }
    
14.                 UEP2_T_LEN = len;
    
15.                 UEP2_CTRL = UEP2_CTRL & ~ MASK_UEP_T_RES | UEP_T_RES_ACK;       // 允许上传
    
16.             }
    
17.             break;

复制代码

      
此内容由EEWORLD论坛网友yang_alex原创，如需转载或用于商业用途需征得作者同意并注明出处

英尚微电子

沁恒USB单片机

lanmanck

我用这个工具，怎么打不开设备？设备管理器是有的，但是这个软件那个下拉框刷新后也没有这个设备。
 

另外它的程序没用到端点1，你为什么可以用ep1发送？？？

lxp33666

大佬，请问一下HID调试的上位机是叫什么？