《MiniPRO H750开发指南》第六十章 USB鼠标键盘(Host)实验

正点原子运营

第六十章 USB鼠标键盘(Host)实验

1）实验平台：正点原子MiniPro STM32H750开发板

2) 章节摘自【正点原子】MiniPro STM32H750 开发指南_V1.1

3）购买链接:https://detail.tmall.com/item.htm?id=677017430560

4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/stm32/zdyz_stm32h750_minipro.html

5）正点原子官方B站：https://space.bilibili.com/394620890

6）MiniPro STM32H750技术交流QQ群:170313895

本章我们介绍如何使用STM32H750的USB HOST来驱动USB鼠标/键盘。

本章分为如下几个小节：

60.1 USB鼠标键盘简介

60.2 硬件设计

60.3 程序设计

60.4 下载验证

60.1 USB鼠标键盘简介

传统的鼠标和键盘是采用PS/2接口和电脑通信的，但是现在PS/2接口在电脑上逐渐消失，所以现在越来越多的鼠标键盘采用的是USB接口，而不是PS/2接口的了。

USB鼠标键盘属于USB HID设备。USB HID即：Human Interface Device（人机交互设备）的缩写，键盘、鼠标与游戏杆等都属于此类设备。不过HID设备并不一定要有人机接口，只要符合HID类别规范的设备都是HID设备。关于USB HID的知识，我们这里就不详细介绍了，请大家自行百度学习。

本章，我们同上一章一样，我们直接移植官方的USB HID例程，官方例程路径：光盘→8，STM32参考资料→1，STM32CubeH7固件包→STM32Cube_FW_H7_V1.6.0→Projects→STM32H743I-EVAL→Applications→USB_Host→HID_Standalone，该例程支持USB鼠标和键盘等USB HID设备，本章我们将移植这个例程到我们的开发板上。

60.2 硬件设计
1. 例程功能

本实验代码，开机的时候先显示一些提示信息，然后初始化USB HOST，并不断轮询。当检测到USB鼠标/键盘的插入后，显示设备类型，并显示设备输入数据：

如果是USB鼠标：将显示鼠标移动的坐标（X，Y坐标），滚轮滚动数值（Z坐标）以及按键（左中右）。

如果是USB键盘：将显示键盘输入的数字/字母等内容（不是所有按键都支持，部分按键没有做解码支持，比如F1~F12）。

2. 硬件资源

1）RGB灯

     RED ：LED0 - PB4

     GREEN ：LED1 - PE6

2）串口1(PA9/PA10连接在板载USB转串口芯片CH340上面)

3）正点原子2.8/3.5/4.3/7/10寸TFTLCD模块(仅限MCU屏，16位8080并口驱动)

4）USB_HOST接口(D-/D+连接在PA11/PA12上)

60.3 程序设计
60.3.1 程序流程图

  

图60.3.1.1 USB鼠标键盘实验(Host)程序流程图

60.3.2 程序解析

这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。

本实验，我们在上一个实验的基础上修改，对照官方HID例子，然后，我们在工程里面添加USB HID相关代码，如图60.3.2.1所示：

图60.3.2.1 USB鼠标键盘工程分组

可以看到，USB部分代码，同上一章的在结构上是一模一样的，只是.c文件有些变化。我们重点介绍下USB_HOST里面的usbh_hid_mouse.c这个文件，该文件拷贝自ST官方例程，但是ST官方例程对鼠标的支持不好（兼容性差，不支持滚轮等），我们重写了该文件，下面介绍该文件。

1. USB驱动代码

usbh_hid_mouse.h，首先介绍usbh_hid_mouse.h里面定义的一个结构体，具体如下：

1. /* 鼠标信息结构体*/
   
2. typedef struct _HID_MOUSE_Info
   
3. {
   
4.   uint8_t              x;          /* x轴增量（强制转换成signed char后使用）*/
   
5.   uint8_t              y;          /* y轴增量（强制转换成signed char后使用）*/
   
6.   uint8_t              z;          /* z轴增量（强制转换成signed char后使用）*/
   
7.   uint8_t              button;     /* 将buttons修改为button,存储按键状态 */
   
8. }
   
9. HID_MOUSE_Info_TypeDef;

复制代码

HID_MOUSE_Info_TypeDef结构体中，成员x和y表示鼠标的横向/纵向移动的增量值，成员z表示鼠标的滚轮的滚动增量值，在使用的时候，需要强制转换成unsigned char类型后使用（有±）。button的bit0、bit1、bit2分别表示鼠标的：左键、右键和滚轮键的按下状态。我们通过这个结构体，就可以获得当前鼠标的输入状态。

usbh_hid_mouse.c，总共有三个函数，首先介绍的是USBH鼠标初始化函数，其定义如下：

1. /* 鼠标信息(坐标+按钮状态)*/
   
2. HID_MOUSE_Info_TypeDef    mouse_info;         
   
3. /* 鼠标上报数据长度,最多HID_QUEUE_SIZE个字节*/
   
4. uint8_t mouse_report_data[HID_QUEUE_SIZE];      
   
5. /**
   
6. *@brief       USBH 鼠标初始化
   
7. *@param       phost       : USBH句柄指针
   
8. *@retval      USB状态
   
9. *   @arg      USBH_OK(0)   , 正常;
   
10. *  @arg       USBH_BUSY(1) , 忙;
    
11. *  @arg       其他         , 失败;
    
12. */
    
13. USBH_StatusTypeDef USBH_HID_MouseInit(USBH_HandleTypeDef *phost)
    
14. {
    
15. HID_HandleTypeDef *HID_Handle =  
    
16. (HID_HandleTypeDef *) phost->pActiveClass->pData;
    
17.    mouse_info.x = 0;
    
18.    mouse_info.y = 0;
    
19.    mouse_info.button = 0;
    
20.     if (HID_Handle->length > sizeof(mouse_report_data))
    
21.     {
    
22.        HID_Handle->length = sizeof(mouse_report_data);
    
23.     }
    
24.    HID_Handle->pData = (uint8_t *)mouse_report_data;
    
25.    USBH_HID_FifoInit(&HID_Handle->fifo, phost->device.Data, HID_QUEUE_SIZE);
    
26.     return USBH_OK;
    
27. }

复制代码

USBH_HID_MouseInit函数，用于初始化鼠标，指定USB鼠标输出数据的缓存，初始化FIFO等，该函数在USBH_HID_Process函数里面被调用。

接下来介绍的是USBH获取鼠标信息函数，其定义如下：

1. /**
   
2. *@brief       USBH 获取鼠标信息
   
3. *@param       phost       : USBH句柄指针
   
4. *@retval      鼠标信息(HID_MOUSE_Info_TypeDef)
   
5. */
   
6. HID_MOUSE_Info_TypeDef *USBH_HID_GetMouseInfo(USBH_HandleTypeDef *phost)
   
7. {
   
8.     if (USBH_HID_MouseDecode(phost) == USBH_OK)
   
9.     {
   
10.        return &mouse_info;
    
11.     }
    
12.     else
    
13.     {
    
14.        return NULL;
    
15.     }
    
16. }

复制代码

USBH_HID_GetMouseInfo函数，用于获取鼠标信息，通过USBH_HID_MouseDecode函数获取当前鼠标传回来的数据。该函数在USB_Demo函数里面被调用。

最后介绍的是USBH 鼠标数据解析函数，其定义如下：

1. /**
   
2. *@brief       USBH 鼠标数据解析函数
   
3. *@param       phost       : USBH句柄指针
   
4. *@retval      USB状态
   
5. *  @arg       USBH_OK(0)   , 正常;
   
6. *  @arg       USBH_BUSY(1) , 忙;
   
7. *  @arg       其他           , 失败;
   
8. */
   
9. USBH_StatusTypeDef USBH_HID_MouseDecode(USBH_HandleTypeDef *phost)
   
10. {
    
11. HID_HandleTypeDef *HID_Handle =
    
12. (HID_HandleTypeDef *) phost->pActiveClass->pData;
    
13.     if (HID_Handle->length == 0)return USBH_FAIL;
    
14. if (USBH_HID_FifoRead(&HID_Handle->fifo, &mouse_report_data,
    
15. HID_Handle->length) == HID_Handle->length) /* 读取FIFO*/
    
16.     {
    
17.        mouse_info.button =mouse_report_data[0];
    
18.        mouse_info.x      = mouse_report_data[1];
    
19.        mouse_info.y      = mouse_report_data[2];
    
20.        mouse_info.z      = mouse_report_data[3];
    
21.        return USBH_OK;
    
22.     }
    
23.     return   USBH_FAIL;
    
24. }

复制代码

USBH_HID_MouseDecode函数，用于解析USB HOST获取到的USB鼠标数据，并存放到mouse_info结构体里面。该函数被USBH_HID_GetMouseInfo函数调用。

另外，为了提高对鼠标键盘的识别率和兼容性，对usbh_hid_core.c里面的两处代码进行了修改：

1，在usbh_hid.c里面，USBH_HID_Process函数，修改case HID_IDLE部分代码（366行）为：

1. caseHID_IDLE:
   
2.     status = USBH_HID_GetReport(phost, 0X01U,0U, HID_Handle->pData, (uint8_t)
   
3. HID_Handle->length);
   
4.     if(status == USBH_OK)
   
5.     {   
   
6.      fifo_write(&HID_Handle->fifo, HID_Handle->pData,HID_Handle->length);  
   
7.      HID_Handle->state = HID_SYNC;
   
8.     }else if (status == USBH_BUSY)
   
9.     {
   
10.      HID_Handle->state = HID_IDLE;
    
11.      status = USBH_OK;
    
12.     }else if (status == USBH_NOT_SUPPORTED)
    
13.     {
    
14.      HID_Handle->state = HID_SYNC;
    
15.      status = USBH_OK;
    
16.     }else
    
17.     {
    
18.      HID_Handle->state = HID_ERROR;
    
19.       status = USBH_FAIL;
    
20.     }
    
21. #if(USBH_USE_OS == 1)
    
22.     osMessagePut ( phost->os_event,USBH_URB_EVENT, 0);
    
23. #endif      
    
24.     break;

复制代码

2，在usbh_ctlreq.c里面，USBH_CtlReq函数，修改case CMD_WAIT代码（552行）为：

1. caseCMD_WAIT:
   
2.     status = USBH_HandleControl(phost);
   
3.     if (status == USBH_OK)
   
4.     {
   
5.       /* Commands successfully sent andResponse Received  */      
   
6.       phost->RequestState = CMD_SEND;
   
7.       phost->Control.state =CTRL_IDLE;  
   
8.       status = USBH_OK;      
   
9.     }else if (status == USBH_FAIL)
   
10.     {
    
11.       /*Failure Mode */
    
12.       phost->RequestState = CMD_SEND;
    
13.       status = USBH_FAIL;
    
14.     }else if(status == USBH_NOT_SUPPORTED)
    
15.     {
    
16.       phost->RequestState = CMD_SEND;
    
17.     }   
    
18.     break;

复制代码

经过以上两处修改，可以显著提高USB鼠标的兼容性，基本上各种鼠标都可以正常识别和使用了。

2. main.c代码

下面是main.c的程序，具体如下：

1. USBH_HandleTypeDef hUSBHost;    /* USB Host处理结构体 */
   
2. /* 应用状态结构体类型定义 */
   
3. typedef enum
   
4. {
   
5.    APPLICATION_IDLE = 0,         /* 挂起状态 */
   
6.    APPLICATION_DISCONNECT,      /* 断开连接 */
   
7.    APPLICATION_START,            /* 应用开始（连接上了） */
   
8.    APPLICATION_READY,            /* 准备完成（可以执行相关应用代码了） */
   
9.    APPLICATION_RUNNING,         /* 运行中 */
   
10. }HID_ApplicationTypeDef;
    
11. extern HID_MOUSE_Info_TypeDef mouse_info;
    
12. HID_ApplicationTypeDef App_State = APPLICATION_IDLE;
    
13. uint8_t g_usb_first_plugin_flag = 0; /* USB第一次插入标志,如果为1,说明是第一次插入 */
    
14. /**
    
15. *@brief       USB信息显示
    
16. *@param       msg   : 信息类型
    
17. *  @arg               0, USB无连接
    
18. *  @arg               1, USB键盘
    
19. *  @arg               2, USB鼠标
    
20. *  @arg               3, 不支持的USB设备
    
21. *@retval      无
    
22. */
    
23. voidusbh_msg_show(uint8_t msgx)
    
24. {
    
25.     switch (msgx)
    
26.     {
    
27.        case 0: /* USB无连接 */
    
28.            lcd_show_string(30, 130, 200, 16, 16, "USBConnecting...", RED);
    
29.            lcd_fill(0, 150, lcddev.width, lcddev.height, WHITE);
    
30.            break;
    
31.        case 1: /* USB键盘 */
    
32.            lcd_show_string(30, 130, 200, 16, 16, "USBConnected    ", RED);
    
33.            lcd_show_string(30, 150, 200, 16, 16, "USBKeyBoard", RED);
    
34.            lcd_show_string(30, 180, 210, 16, 16, "KEYVAL:", RED);
    
35.            lcd_show_string(30, 200, 210, 16, 16, "INPUTSTRING:", RED);
    
36.            break;
    
37.        case 2: /* USB鼠标 */
    
38.            lcd_show_string(30, 130, 200, 16, 16, "USBConnected    ", RED);
    
39.            lcd_show_string(30, 150, 200, 16, 16, "USBMouse", RED);
    
40.            lcd_show_string(30, 180, 210, 16, 16, "BUTTON:", RED);
    
41.            lcd_show_string(30, 200, 210, 16, 16, "XPOS:", RED);
    
42.            lcd_show_string(30, 220, 210, 16, 16, "Y POS:", RED);
    
43.            lcd_show_string(30, 240, 210, 16, 16, "ZPOS:", RED);
    
44.            break;
    
45.        case 3: /* 不支持的USB设备 */
    
46.            lcd_show_string(30, 130, 200, 16, 16, "USBConnected    ", RED);
    
47.            lcd_show_string(30, 150, 200, 16, 16, "UnknowDevice", RED);
    
48.            break;
    
49.     }
    
50. }
    
51. /**
    
52. *@brief       完成USBH不同用户状态下的数据处理
    
53. *@param       phost : USBH句柄指针
    
54. *@param       id    : USBH当前的用户状态
    
55. *@retval      无
    
56. */
    
57. voidUSBH_UserProcess(USBH_HandleTypeDef *phost, uint8_t id)
    
58. {
    
59.     uint8_t dev_type = 0XFF;    /* 设备类型,1,键盘;2,鼠标;其他,不支持的设备 */
    
60.     switch (id)
    
61.     {
    
62.        caseHOST_USER_SELECT_CONFIGURATION:
    
63.            break;
    
64.        caseHOST_USER_DISCONNECTION:
    
65.            usbh_msg_show(0);   /* 显示已经断开连接,准备重新连接 */
    
66.            App_State = APPLICATION_DISCONNECT;
    
67.            break;
    
68.        caseHOST_USER_CLASS_ACTIVE:
    
69.            App_State = APPLICATION_READY;
    
70.            dev_type = phost->device.CfgDesc.Itf_Desc[phost->
    
71. device.current_interface].bInterfaceProtocol;
    
72.            if (dev_type ==HID_KEYBRD_BOOT_CODE)        /* 键盘设备 */
    
73.            {
    
74.                 g_usb_first_plugin_flag = 1;               /* 标记第一次插入 */
    
75.                 usbh_msg_show(1);                             /* 显示键盘界面 */
    
76.            }
    
77.            else if (dev_type ==HID_MOUSE_BOOT_CODE)    /* 鼠标设备 */
    
78.            {
    
79.                 g_usb_first_plugin_flag = 1;               /* 标记第一次插入 */
    
80.                 usbh_msg_show(2);                             /* 显示鼠标界面 */
    
81.            }
    
82.            else
    
83.            {
    
84.                 usbh_msg_show(3);   /* 显示不支持 */
    
85.            }
    
86.            break;
    
87.        caseHOST_USER_CONNECTION:
    
88.            App_State = APPLICATION_START;
    
89.            break;
    
90.        default:
    
91.            break;
    
92.     }
    
93. }
    
94. /* 临时数组,用于存放鼠标坐标/键盘输入内容(4.3屏,最大可以输入2016字节) */
    
95. __align(4) uint8_t g_temp_buffer[2017];
    
96. /**
    
97. *@brief       USB鼠标数据处理
    
98. *@param       data  : USB鼠标数据结构体指针
    
99. *@retval      无
    
100. */
     
101. voidmouse_data_process(HID_MOUSE_Info_TypeDef *data)
     
102. {
     
103.     static signed short x, y, z;
     
104.     if (g_usb_first_plugin_flag)    /* 第一次插入,将数据清零 */
     
105.     {
     
106.        g_usb_first_plugin_flag = 0;
     
107.        x = y = z = 0;
     
108.     }
     
109.     x += (signed char)data->x;
     
110.     if (x > 9999)x = 9999;
     
111.     if (x < -9999)x = -9999;
     
112.     y += (signed char)data->y;
     
113.     if (y > 9999)y = 9999;
     
114.     if (y < -9999)y = -9999;
     
115.     z += (signed char)data->z;
     
116.     if (z > 9999)z = 9999;
     
117.     if (z < -9999)z = -9999;
     
118.    sprintf((char *)g_temp_buffer, "BUTTON:");
     
119.     if (data->button & 0X01)strcat((char *)g_temp_buffer, "LEFT ");
     
120.     if ((data->button & 0X03) == 0X02)
     
121.     {
     
122.        strcat((char *)g_temp_buffer, "RIGHT");
     
123.     }
     
124.     else
     
125.     {
     
126.        if ((data->button & 0X03) == 0X03)strcat((char *)g_temp_buffer,"+RIGHT");
     
127.     }
     
128.     if ((data->button & 0X07) == 0X04)
     
129.     {
     
130.        strcat((char *)g_temp_buffer, "MID  ");
     
131.     }
     
132.     else
     
133.     {
     
134.        if ((data->button & 0X07) > 0X04)strcat((char *)g_temp_buffer, "+MID");
     
135.     }
     
136.    
     
137.    lcd_fill(30 + 56, 180, lcddev.width - 1, 180 + 16, WHITE);
     
138.    lcd_show_string(30, 180, 210, 16, 16, (char *)g_temp_buffer, BLUE);
     
139.    sprintf((char *)g_temp_buffer, "XPOS:%05d", x);
     
140.    lcd_show_string(30, 200, 200, 16, 16, (char *)g_temp_buffer, BLUE);
     
141.    sprintf((char *)g_temp_buffer, "YPOS:%05d", y);
     
142.    lcd_show_string(30, 220, 200, 16, 16, (char *)g_temp_buffer, BLUE);
     
143.    sprintf((char *)g_temp_buffer, "ZPOS:%05d", z);
     
144.    lcd_show_string(30, 240, 200, 16, 16, (char *)g_temp_buffer, BLUE);
     
145. //printf("btn,X,Y,Z:0x%x,%d,%d,%d\r\n",data->button,(signedchar)
     
146. data->x,(signed char)data->y,(signedchar)data->z);
     
147. }
     
148. /**
     
149. *@brief       USB键盘数据处理
     
150. *@param       data  : USB键盘键值
     
151. *@retval      无
     
152. */
     
153. void  keybrd_data_process(uint8_t data)
     
154. {
     
155.     static uint16_t pos;
     
156.     static uint16_t endx, endy;
     
157.     static uint16_t maxinputchar;
     
158.     uint8_t buf[4];
     
159.     if (g_usb_first_plugin_flag)    /* 第一次插入,将数据清零 */
     
160.     {
     
161.        g_usb_first_plugin_flag = 0;
     
162.        endx = ((lcddev.width - 30) / 8) * 8 + 30;      /* 得到endx值 */
     
163.        endy = ((lcddev.height - 220) / 16) * 16 + 220;/* 得到endy值 */
     
164.        maxinputchar = ((lcddev.width - 30) / 8);
     
165.        maxinputchar *= (lcddev.height - 220) / 16;/* 当前LCD最大可以显示的字符数 */
     
166.        pos = 0;
     
167.     }
     
168.    sprintf((char *)buf, "%02X", data);
     
169.    lcd_show_string(30 + 56, 180, 200, 16, 16, (char *)buf, BLUE);  /* 显示键值 */
     
170.     if (data >= ' ' && data <= '~')
     
171.     {
     
172.        g_temp_buffer[pos++] = data;
     
173.        g_temp_buffer[pos] = 0; /* 添加结束符 */
     
174.        if (pos > maxinputchar)pos = maxinputchar;  /* 最大输入这么多 */
     
175.     }
     
176.     else if (data == 0X0D)      /* 退格键 */
     
177.     {
     
178.        if (pos)pos--;
     
179.        g_temp_buffer[pos] = 0; /* 添加结束符 */
     
180.     }
     
181.     if (pos <= maxinputchar)    /* 没有超过显示区 */
     
182.     {
     
183.        lcd_fill(30, 220, endx, endy, WHITE);
     
184.        lcd_show_string(30, 220, endx - 30, endy - 220, 16,
     
185. (char *)g_temp_buffer, BLUE);
     
186.     }
     
187.     //printf("KEY Board Value:%02X\r\n",data);
     
188.     //printf("KEY Board Char:%c\r\n",data);
     
189. }
     
190. /**
     
191. *@brief       USB键盘/鼠标演示demo数据处理
     
192. *@param       phost : USBH句柄指针
     
193. *@retval      无
     
194. */
     
195. void usb_demo(USBH_HandleTypeDef *phost)
     
196. {
     
197.     char c;
     
198.    HID_KEYBD_Info_TypeDef *k_pinfo;
     
199.    HID_MOUSE_Info_TypeDef *m_pinfo;
     
200.     if (App_State == APPLICATION_READY)
     
201.     {
     
202.        if (USBH_HID_GetDeviceType(phost) == HID_KEYBOARD)  /* 键盘设备 */
     
203.        {
     
204.            k_pinfo =USBH_HID_GetKeybdInfo(phost);           /* 获取键盘信息 */
     
205.            if (k_pinfo != NULL)
     
206.            {
     
207.                 c = USBH_HID_GetASCIICode(k_pinfo);        /* 转换成ASCII码 */
     
208.                 keybrd_data_process(c);                     /* 在LCD上显示出键盘字符 */
     
209.            }
     
210.        }
     
211.        else if (USBH_HID_GetDeviceType(phost) == HID_MOUSE)/* 鼠标设备 */
     
212.        {
     
213.            m_pinfo =USBH_HID_GetMouseInfo(phost);      /* 获取鼠标信息 */
     
214.            if (m_pinfo != NULL)
     
215.            {
     
216.                 mouse_data_process(&mouse_info);           /* LCD上显示鼠标信息 */
     
217.            }
     
218.        }
     
219.     }
     
220. }
     
221. int main(void)
     
222. {
     
223.    sys_cache_enable();                    /* 打开L1-Cache */
     
224.    HAL_Init();                              /* 初始化HAL库 */
     
225.    sys_stm32_clock_init(240, 2, 2, 4); /* 设置时钟, 480Mhz */
     
226.    delay_init(480);                       /* 延时初始化 */
     
227.    usart_init(115200);                    /* 串口初始化为115200 */
     
228.    mpu_memory_protection();              /* 保护相关存储区域 */
     
229.    led_init();                              /* 初始化LED */
     
230.    lcd_init();                              /* 初始化LCD */
     
231.    key_init();                              /* 初始化按键 */
     
232.    my_mem_init(SRAMIN);                   /* 初始化内部内存池(AXI) */
     
233.    my_mem_init(SRAM12);                   /* 初始化SRAM12内存池(SRAM1+SRAM2)*/
     
234.    my_mem_init(SRAM4);                    /* 初始化SRAM4内存池(SRAM4) */
     
235.    my_mem_init(SRAMDTCM);                /* 初始化DTCM内存池(DTCM) */
     
236.    my_mem_init(SRAMITCM);                /* 初始化ITCM内存池(ITCM) */
     
237.    lcd_show_string(30, 50, 200, 16, 16, "STM32", RED);
     
238.    lcd_show_string(30, 70, 200, 16, 16, "USBMOUSE/KEYBOARD TEST", RED);
     
239.    lcd_show_string(30, 90, 200, 16, 16, "ATOM@ALIENTEK", RED);
     
240.    lcd_show_string(30, 110, 200, 16, 16, "USBConnecting...", RED);
     
241.    USBH_Init(&hUSBHost,USBH_UserProcess, 0);
     
242.    USBH_RegisterClass(&hUSBHost, USBH_HID_CLASS);
     
243.    USBH_Start(&hUSBHost);
     
244.     while (1)
     
245.     {
     
246.        USBH_Process(&hUSBHost);
     
247.        usb_demo(&hUSBHost);
     
248.     }
     
249. }

复制代码

这里总共六个函数：

usbh_msg_show函数，用于显示一些提示信息，在USBH_UserProcess函数里面被调用。

USBH_UserProcess函数，用于执行USB主机不同用户状态下的数据处理，在usbh_core.c等相关文件里面被调用，该函数仅针对两个状态进行处理：

1、HOST_USER_DISCONNECTION，表示连接断开了，我们在屏幕显示连接断开，并设置App_State状态为APPLICATION_DISCONNECT；

2、HOST_USER_CLASS_ACTIVE，表示USB主机类激活，即接入USB设备已经准备就绪，可以正常工作了，我们设置App_State状态为：APPLICATION_READY，并根据接入设备的不同（鼠标/键盘）显示不同的信息。

mouse_data_process函数，用于处理USB鼠标数据，在液晶屏上面显示鼠标的移动坐标值和按键状态等信息，该函数在USB_Demo函数里面被调用。

keybrd_data_process函数，用于处理键盘数据，在液晶屏上面显示键盘的输入内容，最多支持2017个字符的输入显示。该函数在USB_Demo函数里面被调用。

usb_demo函数，根据当前用户状态和USB接入设备的类型，执行不同的数据处理。该函数在main函数里面被调用。

main函数，初始化各个外设后，通过USBH_Init等3个函数初始化并启动USB主机通信，然后进入死循环，不停的调用USBH_Process和usb_demo，执行各种USB处理。

60.4 下载验证

将程序下载到开发板后，然后在USB_HOST端子插入USB鼠标/键盘，注意：此时USB SLAVE口不要插USB线到电脑，否则会干扰！

等USB鼠标/键盘成功识别后，便可以看到LCD显示USB Connected，并显示设备类型：USB Mouse或者USB KeyBoard，同时也会显示输入的数据，如图60.4.1和图60.4.2所示：

图60.4.1 USB鼠标测试

图60.4.2 USB键盘测试

其中，图60.4.1是USB鼠标测试界面，图60.4.2是USB键盘测试界面。

最后，特别提醒大家，由于例程的HID内核，只处理了第一个接口描述符，所以对于USB符合设备，只能识别第一个描述符所代表的设备。体现到实际使用中，就是：USB无线鼠标，一般是无法使用（被识别为键盘），而USB无线键盘，可以使用，因为键盘在第一个描述符，鼠标在第二个描述符  。