1. 了解STM32 USB SLAVE结构。
2. 了解STM32 USB SLAVE特征。
3. 掌握USB SLAVE HID的使用方法。
4. 掌握STM32 HAL库中USB SLAVE属性的配置方法。
5. 掌握KEIL MDK 集成开发环境使用方法。

1. iCore4 双核心板点击购买。
2. JLINK（或相同功能）仿真器点击购买。
3. Micro USB线缆。
4. Keil MDK 开发平台。
5. STM32CubeMX开发平台。
6. 装有WIN XP（及更高版本）系统的计算机。

• USB HID是Human Interface Device的缩写，由其名称可以了解HID设备是直接与人交互的设备，例如键盘、鼠标与游戏杆等。不过HID设备并不一定要有人机接口，只要符合HID类别规范的设备都是HID设备。
• 交换的数据存储在称为报表(report)的结构内，设备的固件必须支持HID报表的格式。主机在控制与中断传输中传送与要求报表，来传送与接收数据。报表的格式非常有弹性，可以处理任何类别的数据。
• 设备除了HID接口之外，它可能同时还包含有其他的USB接口。例如影像显示设备可能使用HID接口来做亮度，对比，与更新率的软件控制，而使用传统的影 像接口来传送要显示的数据。USB扩音器可以使用实时传输来播放语音，同时使用HID接口来控制音量，震荡，与低音等。HID接口通常比传统的控制接口来得便宜。
• Windows操作系统最先支持的HID设备。在windows98以及后来的版本中内置有HID设备的驱动程序，应用程序可以直接使用这些驱动程序来与设备通信。
• 在设计一个USB接口的计算机外部设备时，如果HID类型的设备可以满足需要，可以将其设计为HID类型设备，这样可以省去比较复杂的USB驱动程序的编写，直接利用Windows操作系统对标准的HID类型USB设备的支持。

• 1、交换的数据储存在称为报表（Report）的结构内，设备的固件必须支持HID报表的格式。主机通过控制和中断传输中的传送和请求报表来传送和接收数据。报表的格式非常灵活。
• 2、每一笔事务可以携带小量或中量的数据。低速设备每一笔事务最大是8B，全速设备每一笔事务最大是64B，高速设备每一笔事务最大是1024B。一个报表可以使用多笔事务。
• 3、设备可以在未预期的时间传送信息给主机，例如键盘的按键或是鼠标的移动。所以主机会定时轮询设备，以取得最新的数据。
• 4、HID设备的最大传输速度有限制。主机可以保证低速的中断端点每10ms内最多1笔事务，每一秒最多是800B。保证全速端点每lms一笔事务，每一秒最多是64000B。保证高速端点每125us三笔事务，每一秒最多是24.576MB。
• 5、HID设备没有保证的传输速率。如果设备是设置在10ms的时距，事务之间的时间可能等于或小于10ms。除非设备是设置在全速时在每个帧传输数据，或是在高速时在每个微帧传输数据。这是最快的轮询速率，所以端点可以保证有正确的带宽可供使用。
• HID设备除了传送数据给主机外，它也会从主机接收数据。只要能够符合HID类别规范的设备都可以是HID设备。
• 设备除了HID接口之外，它可能同时还包含有其他的USB接口。例如影像显示设备可能使用HID接口来做亮度、对比度的软件控制，而使用传统的影像接口来传送要显示的数据。USB扩音器可以使用实时传输来播放语音，同时使用HID接口来控制音量、低音等。
• HID类别设备的规范文件主要是以下两份：
  • Device Class Definition for Human interface Devices
  • HID Usabe Tables

• USB HID设备无需驱动程序，Windows系统自带HID类的驱动程序。通过移植ST官方提供的代码来实现iCore4的USB HID双向数据传输，点击测试软件的灯控按钮来控制iCore4上的LED灯的亮灭，实现下位机向上位机传输数据并解析相应的命令。按下iCore4的ARM_KEY按钮，来测试软件显示ARM_KEY的状态，实现了下位机向上位机的数据传输。

int main(void)
{
    int i;
    unsigned char buffer[64];
    unsigned char send_buffer[64];
    static int counter;
    RTC_DateTypeDef sDate;
    RTC_TimeTypeDef sTime; 
  /* USER CODE END 1 */
 
  /* MCU Configuration-------
  /* MCU配置*/
  /* 重置所有外围设别, 初始化Flash接口和ystick. */
  HAL_Init();
  /* 配置系统时钟 */
  SystemClock_Config();
  /* 初始化所有已配置的外围设备*/
  MX_GPIO_Init();
  MX_USB_DEVICE_Init();
  MX_RTC_Init();
  /* 无限循环 */
  while (1)
  {
        if(systick.second_flag == 1){
            systick.second_flag = 0;
            if(hUsbDeviceHS.dev_state == USBD_STATE_CONFIGURED){
                if(counter ++ % 2){
                    HAL_RTC_GetTime(&hrtc, &sTime, RTC_FORMAT_BIN);
                    //获取当前时间
                    HAL_RTC_GetDate(&hrtc, &sDate, RTC_FORMAT_BIN);
                    //获取当前日期
                    memset(send_buffer,0,64);
                    sprintf((char *)send_buffer,"time:%02d:%02d:%02d  %02d-%02d-%02d",
                    sTime.Hours,sTime.Minutes,sTime.Seconds,sDate.Year,sDate.Month,sDate.Date); //打印时间日期
                    USBD_HID_SendReport(&hUsbDeviceHS,send_buffer,64); //发送报文
                }else{
                    memset(send_buffer,0,64);
                    if(ARM_KEY_STATE == KEY_DOWN) //判断按键是否按下
                        sprintf((char *)send_buffer,"key:KEY PRESS");
                    else
                        sprintf((char *)send_buffer,"key:");
                    USBD_HID_SendReport(&hUsbDeviceHS,send_buffer,64);    
                }    
            }    
        }
        //接受命令处理
        if(usb_receive_flag == 1){
            usb_receive_flag = 0;
            memcpy(buffer,usb_receive_buffer,usb_receive_counter);
            memset(usb_receive_buffer,0,usb_receive_counter);
            for(i = 0;i < 64;i++){
                buffer[i] = tolower(buffer[i]);
                }
           command_process(buffer);
        }    
  }
}

void MX_USB_DEVICE_Init(void)
{
  /* 初始化设备库，添加支持的类并启动该库*/
  /* 初始化设备堆栈并加载类驱动程序*/
  USBD_Init(&hUsbDeviceHS, &HS_Desc, DEVICE_HS);/
  /* 将类驱动程序链接到设备核心*/
  USBD_RegisterClass(&hUsbDeviceHS, &USBD_HID);
  /* 启动USB设备核心 */
  USBD_Start(&hUsbDeviceHS);
}
 

static uint8_t  USBD_HID_Init (USBD_HandleTypeDef *pdev, 
                               uint8_t cfgidx)
{
  uint8_t ret = 0;
  /* 打开 EP IN */
  USBD_LL_OpenEP(pdev,
                 HID_EPIN_ADDR,
                 USBD_EP_TYPE_INTR,
                 HID_EPIN_SIZE); 
    /* 打开 EP Out */
    USBD_LL_OpenEP(pdev,
                 HID_EPOUT_ADDR,
                 USBD_EP_TYPE_INTR,
                 HID_EPOUT_SIZE); 
     /* 准备输出端点以接收下一个数据包 */
    USBD_LL_PrepareReceive(pdev,
                           HID_EPOUT_ADDR,
                           usb_receive_buffer,
                           HID_EPOUT_SIZE);
 
  pdev->pClassData = USBD_malloc(sizeof (USBD_HID_HandleTypeDef));
  if(pdev->pClassData == NULL)
  {
    ret = 1; 
  }
  else
  {
    ((USBD_HID_HandleTypeDef *)pdev->pClassData)->state = HID_IDLE;
  }
  return ret;
}

/**
  * @brief  USBD_HID_SendReport 
  *         发送HID报文
  * @param  pdev: 设备实例
  * @param  buff: 报文指针
  * @retval status
  */
uint8_t USBD_HID_SendReport     (USBD_HandleTypeDef  *pdev, 
                                 uint8_t *report,
                                 uint16_t len)
{
  USBD_HID_HandleTypeDef     *hhid = (USBD_HID_HandleTypeDef*)pdev->pClassData;
  if (pdev->dev_state == USBD_STATE_CONFIGURED )
  {
    if(hhid->state == HID_IDLE)
    {
      hhid->state = HID_BUSY;
      USBD_LL_Transmit (pdev, 
                        HID_EPIN_ADDR,                                    
                        report,
                        len); //通过端点传输数据。
    }
  }
  return USBD_OK;
}
 

static int command_process(unsigned char * buffer)
{
    char *p;
    unsigned char hour;
    unsigned char min;
    unsigned char sec;
    unsigned char year;
    unsigned char month;
    unsigned char date;
    unsigned char week;
 
    p = (char *)buffer;
    //led灯命令处理
    if(memcmp(p,"led_red_on",strlen("led_red_on")) == 0){
        LED_RED_ON;
    }else if(memcmp(p,"led_red_off",strlen("led_red_off")) == 0){
        LED_RED_OFF;
    }else if(memcmp(p,"led_green_on",strlen("led_green_on")) == 0){
        LED_GREEN_ON;
    }else if(memcmp(p,"led_green_off",strlen("led_green_off")) == 0){
        LED_GREEN_OFF;
    }else if(memcmp(p,"led_blue_on",strlen("led_blue_on")) == 0){
        LED_BLUE_ON;
    }else if(memcmp(p,"led_blue_off",strlen("led_blue_off")) == 0){
        LED_BLUE_OFF;
    }else {
        //校准rtc命令处理
        p = strchr(p,'0');
        p ++;
        year = strtol(p,NULL,0);
        p = strchr(p,'/');
        p ++;
        month = strtol(p,NULL,0);
        p = strchr(p,'/');
        p ++;
        date = strtol(p,NULL,0);
        p = strchr(p,' ');
        p ++;
        hour = strtol(p,NULL,0);
        p = strchr(p,':');
        p ++;
        min = strtol(p,NULL,0);
        p = strchr(p,':');
        p ++;
        sec = strtol(p,NULL,0);
        p = strchr(p,' ');
        week = strtol(p,NULL,0);
        my_rtc.set_date(year,month,date,week);
        my_rtc.set_time(hour,min,sec);
    }
    return 0;
}
 

• 此上位机测试软件使用Microsoft Visual Studio开发平台编写，用于实现上位机和下位机的双向数据传输，部分源码如下：

 public partial class Form1 : Form
    {
        usb_hid_class usbhid = null;
        bool red_flag = true;
        bool green_flag = true;
        bool blue_flag = true;
        System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
        TimeSpan timespan;
        double ms;
        double speed_value;
        long counter = 0;
        int first_run = 0;
        public Form1()
        {
            InitializeComponent();
            usbhid = new usb_hid_class();
            button_red_on.Enabled = false;
            button_green_on.Enabled = false;
            button_blue_on.Enabled = false;
            rtc_button.Enabled = false;
            usbhid.DataReceived += usb_hid_data_receive;
            usbhid.DeviceRemoved += usb_hid_device_remove;          
        }
        void usb_hid_device_remove(object sender, EventArgs e)
        {
            //report myRP = (report)e;
            if (InvokeRequired)
            {
                Invoke(new EventHandler(usb_hid_device_remove), new object[] { sender, e });
            }
            else
            {
                MessageBox.Show("设备移除","提示");
            }
        }
        void usb_hid_data_receive(object sender, EventArgs e)
        {
            string str;
            long cnt = 0;
            report myRP = (report)e;
 
            if (InvokeRequired)
            {
                Invoke(new EventHandler(usb_hid_data_receive), new object[] { sender, e });
            }
            else
            {
                if(first_run == 0)
                {
                    first_run = 1;
                    stopwatch.Reset();
                    stopwatch.Start();
                }
                str = usb_hid_class.ByteToHexString(myRP.reportBuff);
                cnt = str.Length;
                counter += cnt;
                if(counter >= 1024 * 1024)
                {
                    first_run = 0;
                    counter = 0;
                    stopwatch.Stop();
                    timespan = stopwatch.Elapsed;
                    ms = timespan.TotalMilliseconds;
                    speed_value = 1000.0 / ms;
                    rtc_display.Text = speed_value.ToString("00.0000");
                }
                counter++;
            }
        }
        private void button_connect_Click(object sender, EventArgs e)
        {
            int temp;
            foreach (string device in usbhid.GetDeviceList())
            {
                temp = device.IndexOf("#vid_0483&pid_5720#");
                if(temp >= 0)
                {
                    usbhid.OpenUSBHid(device);
                    button_red_on.Enabled = true;
                    button_green_on.Enabled = true;
                    button_blue_on.Enabled = true;
                    rtc_button.Enabled = true;
                    return;
                }
            }
            MessageBox.Show("未发现设备", "提示");
        }
        private void button_red_on_Click(object sender, EventArgs e)
        {
            string data;
            if (red_flag)
            {
                red_flag = false;
                button_red_on.Text = "红灯灭";
                data = " led_red_on";
                while (data.Length < 1025)
                {
                    data += ' ';
                }
                usbhid.WriteUSBHID(data);
                stopwatch.Start();
            }
            else
            {
                red_flag = true;
                button_red_on.Text = "红灯亮";
                data = " led_red_off";
                while (data.Length < 1025)
                {
                    data += ' ';
                }
                usbhid.WriteUSBHID(data);
            }
        }
        private void button_green_on_Click(object sender, EventArgs e)
        {
            string data;
            if (green_flag)
            {
                green_flag = false;
                button_green_on.Text = "绿灯灭";
                data = " led_green_on";
                while (data.Length < 1025)
                {
                    data += ' ';
                }
                usbhid.WriteUSBHID(data);
            }
            else
            {
                green_flag = true;
                button_green_on.Text = "绿灯亮";
                data = " led_green_off";
                while (data.Length < 1025)
                {
                    data += ' ';
                }
                usbhid.WriteUSBHID(data);
            }
        }
        private void button_blue_on_Click(object sender, EventArgs e)
        {
            string data;
            if (blue_flag)
            {
                blue_flag = false;
                button_blue_on.Text = "蓝灯灭";
                data = " led_blue_on";
                while (data.Length < 1025)
                {
                    data += ' ';
                }
                usbhid.WriteUSBHID(data);
            }
            else
            {
                blue_flag = true;
                button_blue_on.Text = "蓝灯亮";
                data = " led_blue_off";
                while (data.Length < 1025)
                {
                    data += ' ';
                }
                usbhid.WriteUSBHID(data);
            }
        }
        private void rtc_button_Click(object sender, EventArgs e)
        {
            string data;
            Int16 week;
            data = " ";
            data += System.DateTime.Now.ToString();
            week = Convert.ToInt16(System.DateTime.Now.DayOfWeek);
            data += ' ';
            data += week.ToString();
            while(data.Length < 65)
            {
                data += ' ';
            }
            usbhid.WriteUSBHID(data);
        }
        private void Form1_Load(object sender, EventArgs e)
        {
        }
    }
}

1. 把仿真器与iCore4的SWD调试口相连（直接相连或者通过转接器相连）；
2. 将条线帽插到USB OTG；
3. 把iCore4（USB OTG）通过Micro USB线与计算机相连，为iCore4供电；
4. 打开Keil MDK 开发环境，并打开本实验工程；
5. 烧写程序到iCore4上；
6. 打开\soft\usb_hid.exe进行验证；
7. 也可以进入Debug模式，单步运行或设置断点验证程序逻辑。

• 点击测试软件的LED控制按钮，iCore4上的LED灯状态将发生变化，按下iCore4上的ARM-KEY，按键状态栏将显示按键的状态。（如下图所示）