关于怎么用Cubemx生成的USBHID设备实现读取一体的鼠标键盘设备（改进版）

已于 2024-06-09 03:59:47 修改
阅读量1.3k 收藏 30
点赞数 26
分类专栏： stm32 文章标签： stm32 HID HOST USBHOST鼠标键盘 Cubemx生成鼠标键盘 stm32编写鼠键一体设备代码
于 2024-06-07 23:31:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29187987/article/details/139535648
版权

主要最近做了一个要用STM32实现读取鼠标键盘一体的那种USB设备，STM32的界面上要和电脑一样的能通过这个USB接口实现鼠标移动，键盘的按键。然后我就很自然的去参考了正点原子的例程，可是找了一圈，发现正点原子好像用的库函数，还是自己实现的，然后看了半天都看晕了，感觉自己实现不了，然后就主攻Cubemx实现的USB设备读取了。

在网上找了一圈，终于让我发现了一个可以用的博主的，而且实现了USB读取鼠标键盘一体的设备。
参考网址如下：
https://blog.csdn.net/weixin_50969532/article/details/134313495
基于STM32-USB中间库的多接口主机开发实战
感觉这个博主实现的非常好了，主要实现方法我都是参考这个博主的，只是基于Cubemx实现的还是和博主的实现有一点点的出入，我这里主要跟随博主的实现方法，和博主的文章对比着修改下博主的实现方法，并融合一下，并且实现的更好一点。

使用的硬件

根据网上很多的HID实现方法，大多数都是用F103一类的STM32设备，将STM32设置成Device，模拟鼠标键盘和电脑进行通信，相当于就是用STM32做一个鼠标键盘。但是我们要实现的正好是反着来的，我们要用STM32当做是电脑，读取真正的鼠标键盘的数据，然后在STM32上显示鼠标的移动，按键，键盘的按键。下面是我用的主要硬件。

STM32:正点原子的阿波罗F767开发板

鼠标键盘（一体的）：不知道是什么杂牌子，反正写着型号T1，2.4G无线充电鼠标，电压4.2V，载波频率：2402Mhz。

第一步了解USB主机和设备

首先第一步，看下博主的博客。根据博主的说明，我们可以知道，主机和设备之间的USB基础知识。
USB：通用串行总线，是由主机发起通信、从机被动接收的主从机通信机制。

管道：主从机通信的通道，可以理解为两个海岸之间船只来往的航线。要想船只走得通，必须开放这条航线；要想进行通信，必须打开对应的管道。（其实生成的代码里仔细看也会有，生成的Cubemx代码里叫pipe，还分为进出pipe）

端点：主从机传输的最终对象，可以理解为船只来往的码头，航线的两头即端点。要想船只来往，必须开放码头；要想进行通信，必须开放对应的端点。（这个可以理解为Freertos里的队列的进出口，关键Cubemx里也真的是用的队列，队列实现的管道，写入队列和读取队列就是端点）

接口：几个端点的集合，实现某一具体功能。比如这2个码头用来运输食品，这就是一个食品接口；另外4个码头用来运输石油，这是一个石油接口。键鼠一体有两个接口，一个接口是键盘，一个接口是鼠标。（这里就是最重要的，按照博主的说明，接口的数量决定是只有一个鼠标或者一个键盘，还是两个都有。也就是说，如果一个USB的接口插在电脑上，可以接收很多个无线设备的数据，接口几个，就有几个设备）

在这里插入图片描述
这里参考的就是【半路程序媛】https://blog.csdn.net/weixin_50969532/article/details/134313495这位博主的图片，感谢博主的说明。。。

第二步 用Cubemx生成STM32代码

Cubemx来生成的STM32的代码，主要要设置Cubemx的两个部分，第一个，就是USB_OTG_FS，第二个是USB_HOST。（注意，STM32F1都实现不了HOST，只能是Device，所以买错STM32的小伙伴注意了）

然后就是打开Cubemx，选择自己的STM32，我这里用的硬件是F767IGT6，我就选择F767IGT6。
然后就是一般的CUbemx设置，选晶振，设置时钟，配置UART1作为调试接口输出到电脑，Freertos系统配置（是的，我用了系统，没试过不用系统的，但是有系统的话，为啥非要跑裸机呢~）。

好了，设置好了后，就可以开始用Cubemx配置USB设备了，首先是Connectivity里的USB_OTG_FS（我这里有USB_OTG_HS，但是我的设备主要用这个OTG_FS接口）
在这里插入图片描述

这里设置好了后，Middleware and Software里就会有一个USB_HOST（有的Cubemx版本可能不在这里，注意找一下，如果找不到，就是你的STM32不支持HOST），然后就是USB_HOST的配置。
在这里插入图片描述
User Constants不用，就用默认就可以了，然后就是Platform Settings这个设置要说明一下。

Platform Settings设置说明

这个设置的意思是STM32支持其中一个STM32的引脚来控制USB设备的供电，也就是在硬件上要有相同的设置。如果你的硬件电路板上，硬件工程师做了这么一个设置，可以用一个STM32的引脚来给外部USB供电，这个设置你就是必须要设置的，而且一定要问硬件工程师是设置的哪个引脚，引脚要一致。
但是如果你电路板本身就是USB有供电了，那这个的设置就对你毫无用处，随便设置一个不用的引脚吧，就是为了Cubemx能顺利生成代码而已。。而且在生成后的代码里，也没啥用处。。

如果你用的板子和我的一样，都是正点原子的阿波罗，那你要仔细看下硬件原理图了，正点原子的USB的供电引脚是用一个扩展芯片来实现的，叫pcf8574，这个芯片要用IIC驱动才能让USB供电上，不供电的话就算你怎么改代码都读不到USB的。。别被坑了。。。

回到正题，继续配置Cubemx

Cubemx配置好了这两个以后，USB这方面就完成了。然后就是生成代码。下面我们来看下keil5的代码吧。

Keil5上看下生成的代码，修改代码来实现

Keil5生成的代码我们先看下文件树，我这里主要生成的文件是这样的。
在这里插入图片描述
在这里插入图片描述
这三个文件夹是个USB设备有关的，后面我们主要也是要修改这几个文件来实现一体化设备的数据读取。

关于Cubemx生成的代码里，本身是可以直接用的，要实现键盘的话，就本身生成好的就可以直接用。

Cubemx的代码可以直接驱动一个USB设备？

是的，Cubemx的代码确实直接生成好的就是可以直接插上USB设备就能用。
先看main。。。。呃。。我用的freertos的系统，看main没啥用，就不看了，主要看下在哪里初始化USB设备和怎么用吧。

在这里插入图片描述
我这里的这个函数是Cubemx上了freertos系统后，自动生成的一个任务，我直接把初始化放在任务里，然后初始化USB设备，下面的for（；；）里面只用写自己要处理的usb_demo(&hUsbHostFs)就可以了。下面是我的usb_demo。

下面展示一些 内联代码片。

void USB_Demo(USBH_HandleTypeDef * phost)
{
    char c,i;
 
for(i=0;i<USBH_MAX_NUM_INTERFACES;i++)
{
if(InterfaceIndex[i] != 0xff)
{
    if(USBH_HID_GetDeviceType(&hUSBHost)==HID_KEYBOARD)     //键盘设备
    {
         if(Appli_state==APPLICATION_READY)
         {           //获取键盘信息
            if(k_pinfo!=NULL)
            {
                c=USBH_HID_GetASCIICode(k_pinfo);           //转换成ASCII码
                //这里是我自己加的一句，只用输出c就行了
                printf("%c",c);
                MYUSR_KEYBRD_ProcessData(c);                //在LCD上显示出键盘字符
                k_pinfo = NULL;
                memset(k_pinfo ,0,sizeof(HID_KEYBD_Info_TypeDef ));
            }
         }
    }
    else if (USBH_HID_GetDeviceType(&hUSBHost)==HID_MOUSE)  //鼠标设备
    {
        if(Appli_state==APPLICATION_READY)
        {
           // MOUSE_Demo(&hUSBHost);
            if(m_pinfo!=NULL)
            {
                MYUSR_MOUSE_ProcessData(&mouse_info);       //LCD上显示鼠标信息
                m_pinfo = NULL;
                memset(m_pinfo ,0,sizeof(HID_MOUSE_Info_TypeDef ));
            }
        }
    }else                                                   //无法识别的设备
    {
        //printf("无法识别的设备\r\n");
    }
}
}
}

这个代码其实就是楼上博主的demo代码，博主的文章中没有实现的两点是MYUSR_MOUSE_ProcessData(&mouse_info);和 MYUSR_KEYBRD_ProcessData©;
但是这两个函数我们这里可以先不要，因为本身的这个Cubemx生成的代码里，也只能实现键盘的读取，所以，代码运行到了c=USBH_HID_GetASCIICode(k_pinfo);的时候，就可以了，后面只要printf出来c，就是你按下的那个按键。

到这里Cubemx本身的使用就这样子了，实现一个键盘的按键读取，鼠标我还没试过，不过改改也是可以实现的，只是暂时没那个时间啦。
下面就是要根据参考的博主的步伐，改下Cubemx生成的代码，实现一个USB，读取鼠标键盘两个设备。

一个USB，读取鼠标和键盘两个设备

第一步，改代码，主要在usbh_hid.c里

我这里的修改主要对标博主的第三步和第四步。
把原来Cubemx生成的static函数都改成__WEAK，然后自己重写一遍这几个函数，因为这几个函数两个接口都会要用到。
在这里插入图片描述
原来博主的文章里写的是直接改这几个红框后面的函数，我这里按照博主的方法，把这几个函数重写，原来的函数就直接把static改成__WEAK，这样就算再用Cubemx修改生成一遍，改动也会很小。

第二步，重新建立自己的.c和.h文件，把改动都放在自己的文件里

我这里建立的名字是My_USB_MouseKey.h和My_USB_MouseKey.c，第一步的图里的函数都要重写，所以我把重写后的函数都放下面吧，大家复制粘贴一下，然后自己跑一下，看哪里没有包含.h的自己包含一下。

下面展示一些 内联代码片。

My_USB_MouseKey.c
/*------------------函数修改的区域------------------------------*/
uint8_t USBH_HID_GetPollInterval(USBH_HandleTypeDef *phost)
{
	for(int i=0;i<USBH_MAX_NUM_INTERFACES;i++)
	{
		HID_HandleTypeDef *HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData[i];

		if ((phost->gState == HOST_CLASS_REQUEST) ||
				(phost->gState == HOST_INPUT) ||
				(phost->gState == HOST_SET_CONFIGURATION) ||
				(phost->gState == HOST_CHECK_CLASS) ||
				((phost->gState == HOST_CLASS)))
		{
			return (uint8_t)(HID_Handle->poll);
		}
		else
		{
			return 0U;
		}
	}
	return 0U;
}

USBH_StatusTypeDef USBH_HID_SOFProcess(USBH_HandleTypeDef *phost)
{
	for(int i=0;i<USBH_MAX_NUM_INTERFACES;i++)
	{
		HID_HandleTypeDef *HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData[i];

		if (HID_Handle->state == USBH_HID_POLL)
		{
			if ((phost->Timer - HID_Handle->timer) >= HID_Handle->poll)
			{
				HID_Handle->state = USBH_HID_GET_DATA;

			#if (USBH_USE_OS == 1U)
						phost->os_msg = (uint32_t)USBH_URB_EVENT;
			#if (osCMSIS < 0x20000U)
						(void)osMessagePut(phost->os_event, phost->os_msg, 0U);
			#else
						(void)osMessageQueuePut(phost->os_event, &phost->os_msg, 0U, 0U);
			#endif
			#endif
			}
		}
	}
  return USBH_OK;
}

USBH_StatusTypeDef USBH_HID_InterfaceInit(USBH_HandleTypeDef *phost)
{
  USBH_StatusTypeDef status;
  HID_HandleTypeDef *HID_Handle;
  uint8_t max_ep;
  uint8_t num = 0U;
  uint8_t interface;
	for(int i=0;i<USBH_MAX_NUM_INTERFACES;i++)
	{
		interface = USBH_FindInterface(phost, phost->pActiveClass->ClassCode, HID_BOOT_CODE, i+1);
		#include "My_USB_MouseKey.h"
		InterfaceIndex[i] = interface;
		if ((interface == 0xFFU) || (interface >= USBH_MAX_NUM_INTERFACES)) /* No Valid Interface */
		{
			USBH_DbgLog("Cannot Find the interface for %s class.", phost->pActiveClass->Name);
			return USBH_FAIL;
		}

		status = USBH_SelectInterface(phost, interface);

		if (status != USBH_OK)
		{
			return USBH_FAIL;
		}

		phost->pActiveClass->pData[i] = (HID_HandleTypeDef *)USBH_malloc(sizeof(HID_HandleTypeDef));
		HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData[i];

		if (HID_Handle == NULL)
		{
			USBH_DbgLog("Cannot allocate memory for HID Handle");
			return USBH_FAIL;
		}

		/* Initialize hid handler */
		(void)USBH_memset(HID_Handle, 0, sizeof(HID_HandleTypeDef));

		HID_Handle->state = USBH_HID_ERROR;

		/*Decode Bootclass Protocol: Mouse or Keyboard*/
		if (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bInterfaceProtocol == HID_KEYBRD_BOOT_CODE)
		{
			USBH_UsrLog("KeyBoard device found!");
			HID_Handle->Init = USBH_HID_KeybdInit;
		}
		else if (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bInterfaceProtocol  == HID_MOUSE_BOOT_CODE)
		{
			USBH_UsrLog("Mouse device found!");
			HID_Handle->Init = USBH_HID_MouseInit;
		}
		else
		{
			USBH_UsrLog("Protocol not supported.");
			return USBH_FAIL;
		}

		HID_Handle->state     = USBH_HID_INIT;
		HID_Handle->ctl_state = USBH_HID_REQ_INIT;
		HID_Handle->ep_addr   = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bEndpointAddress;
		HID_Handle->length    = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].wMaxPacketSize;
		HID_Handle->poll      = phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[0].bInterval;

		if (HID_Handle->poll  < HID_MIN_POLL)
		{
			HID_Handle->poll = HID_MIN_POLL;
		}

		/* Check of available number of endpoints */
		/* Find the number of EPs in the Interface Descriptor */
		/* Choose the lower number in order not to overrun the buffer allocated */
		max_ep = ((phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bNumEndpoints <= USBH_MAX_NUM_ENDPOINTS) ?
							phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].bNumEndpoints : USBH_MAX_NUM_ENDPOINTS);


		/* Decode endpoint IN and OUT address from interface descriptor */
		for (num = 0U; num < max_ep; num++)
		{
			if ((phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[num].bEndpointAddress & 0x80U) != 0U)
			{
				HID_Handle->InEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[num].bEndpointAddress);
				HID_Handle->InPipe = USBH_AllocPipe(phost, HID_Handle->InEp);

				/* Open pipe for IN endpoint */
				(void)USBH_OpenPipe(phost, HID_Handle->InPipe, HID_Handle->InEp, phost->device.address,
														phost->device.speed, USB_EP_TYPE_INTR, HID_Handle->length);

				(void)USBH_LL_SetToggle(phost, HID_Handle->InPipe, 0U);
			}
			else
			{
				HID_Handle->OutEp = (phost->device.CfgDesc.Itf_Desc[phost->device.current_interface].Ep_Desc[num].bEndpointAddress);
				HID_Handle->OutPipe  = USBH_AllocPipe(phost, HID_Handle->OutEp);

				/* Open pipe for OUT endpoint */
				(void)USBH_OpenPipe(phost, HID_Handle->OutPipe, HID_Handle->OutEp, phost->device.address,
														phost->device.speed, USB_EP_TYPE_INTR, HID_Handle->length);

				(void)USBH_LL_SetToggle(phost, HID_Handle->OutPipe, 0U);
			}
		}
	}
  return USBH_OK;
}

USBH_StatusTypeDef USBH_HID_InterfaceDeInit(USBH_HandleTypeDef *phost)
{
	for(int i=0;i<USBH_MAX_NUM_INTERFACES;i++)
	{
		HID_HandleTypeDef *HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData[i];

		if (HID_Handle->InPipe != 0x00U)
		{
			(void)USBH_ClosePipe(phost, HID_Handle->InPipe);
			(void)USBH_FreePipe(phost, HID_Handle->InPipe);
			HID_Handle->InPipe = 0U;     /* Reset the pipe as Free */
		}

		if (HID_Handle->OutPipe != 0x00U)
		{
			(void)USBH_ClosePipe(phost, HID_Handle->OutPipe);
			(void)USBH_FreePipe(phost, HID_Handle->OutPipe);
			HID_Handle->OutPipe = 0U;     /* Reset the pipe as Free */
		}

		if ((phost->pActiveClass->pData[i]) != NULL)
		{
			USBH_free(phost->pActiveClass->pData[i]);
			phost->pActiveClass->pData[i] = 0U;
		}
	}
  return USBH_OK;
}

USBH_StatusTypeDef USBH_HID_ClassRequest(USBH_HandleTypeDef *phost)
{

  USBH_StatusTypeDef status         = USBH_BUSY;
  USBH_StatusTypeDef classReqStatus = USBH_BUSY;
	for(int i=0;i<USBH_MAX_NUM_INTERFACES;i++)
	{
		HID_HandleTypeDef *HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData[i];

		/* Switch HID state machine */
		switch (HID_Handle->ctl_state)
		{
			case USBH_HID_REQ_INIT:
			case USBH_HID_REQ_GET_HID_DESC:

				USBH_HID_ParseHIDDesc(&HID_Handle->HID_Desc, phost->device.CfgDesc_Raw);

				HID_Handle->ctl_state = USBH_HID_REQ_GET_REPORT_DESC;

				break;
			case USBH_HID_REQ_GET_REPORT_DESC:

				/* Get Report Desc */
				classReqStatus = USBH_HID_GetHIDReportDescriptor(phost, HID_Handle->HID_Desc.wItemLength);
				if (classReqStatus == USBH_OK)
				{
					/* The descriptor is available in phost->device.Data */
					HID_Handle->ctl_state = USBH_HID_REQ_SET_IDLE;
				}
				else if (classReqStatus == USBH_NOT_SUPPORTED)
				{
					USBH_ErrLog("Control error: HID: Device Get Report Descriptor request failed");
					status = USBH_FAIL;
				}
				else
				{
					/* .. */
				}

				break;

			case USBH_HID_REQ_SET_IDLE:

				classReqStatus = USBH_HID_SetIdle(phost, 0U, 0U);

				/* set Idle */
				if (classReqStatus == USBH_OK)
				{
					HID_Handle->ctl_state = USBH_HID_REQ_SET_PROTOCOL;
				}
				else
				{
					if (classReqStatus == USBH_NOT_SUPPORTED)
					{
						HID_Handle->ctl_state = USBH_HID_REQ_SET_PROTOCOL;
					}
				}
				break;

			case USBH_HID_REQ_SET_PROTOCOL:
				/* set protocol */
				classReqStatus = USBH_HID_SetProtocol(phost, 0U);
				if (classReqStatus == USBH_OK)
				{
					HID_Handle->ctl_state = USBH_HID_REQ_IDLE;

					/* all requests performed*/
					phost->pUser(phost, HOST_USER_CLASS_ACTIVE);
					status = USBH_OK;
				}
				else if (classReqStatus == USBH_NOT_SUPPORTED)
				{
					USBH_ErrLog("Control error: HID: Device Set protocol request failed");
					status = USBH_FAIL;
				}
				else
				{
					/* .. */
				}
				break;

			case USBH_HID_REQ_IDLE:
			default:
				break;
		}
	}
  return status;
}

USBH_StatusTypeDef USBH_HID_Process(USBH_HandleTypeDef *phost)
{
  USBH_StatusTypeDef status = USBH_OK;
	for(int i=0;i<USBH_MAX_NUM_INTERFACES;i++)
	{
		HID_HandleTypeDef *HID_Handle = (HID_HandleTypeDef *) phost->pActiveClass->pData[i];
		uint32_t XferSize;

		switch (HID_Handle->state)
		{
			case USBH_HID_INIT:
				HID_Handle->Init(phost);
				HID_Handle->state = USBH_HID_IDLE;

				#if (USBH_USE_OS == 1U)
							phost->os_msg = (uint32_t)USBH_URB_EVENT;
				#if (osCMSIS < 0x20000U)
							(void)osMessagePut(phost->os_event, phost->os_msg, 0U);
				#else
							(void)osMessageQueuePut(phost->os_event, &phost->os_msg, 0U, 0U);
				#endif
				#endif
							break;

			case USBH_HID_IDLE:
				status = USBH_HID_GetReport(phost, 0x01U, 0U, HID_Handle->pData, (uint8_t)HID_Handle->length);
				if (status == USBH_OK)
				{
					HID_Handle->state = USBH_HID_SYNC;
				}
				else if (status == USBH_BUSY)
				{
					HID_Handle->state = USBH_HID_IDLE;
					status = USBH_OK;
				}
				else if (status == USBH_NOT_SUPPORTED)
				{
					HID_Handle->state = USBH_HID_SYNC;
					status = USBH_OK;
				}
				else
				{
					HID_Handle->state = USBH_HID_ERROR;
					status = USBH_FAIL;
				}

	#if (USBH_USE_OS == 1U)
				phost->os_msg = (uint32_t)USBH_URB_EVENT;
	#if (osCMSIS < 0x20000U)
				(void)osMessagePut(phost->os_event, phost->os_msg, 0U);
	#else
				(void)osMessageQueuePut(phost->os_event, &phost->os_msg, 0U, 0U);
	#endif
	#endif
				break;

			case USBH_HID_SYNC:
				/* Sync with start of Even Frame */
				if ((phost->Timer & 1U) != 0U)
				{
					HID_Handle->state = USBH_HID_GET_DATA;
				}

	#if (USBH_USE_OS == 1U)
				phost->os_msg = (uint32_t)USBH_URB_EVENT;
	#if (osCMSIS < 0x20000U)
				(void)osMessagePut(phost->os_event, phost->os_msg, 0U);
	#else
				(void)osMessageQueuePut(phost->os_event, &phost->os_msg, 0U, 0U);
	#endif
	#endif
				break;

			case USBH_HID_GET_DATA:
				(void)USBH_InterruptReceiveData(phost, HID_Handle->pData,
																				(uint8_t)HID_Handle->length,
																				HID_Handle->InPipe);

				HID_Handle->state = USBH_HID_POLL;
				HID_Handle->timer = phost->Timer;
				HID_Handle->DataReady = 0U;
				break;

			case USBH_HID_POLL:
				if (USBH_LL_GetURBState(phost, HID_Handle->InPipe) == USBH_URB_DONE)
				{
					XferSize = USBH_LL_GetLastXferSize(phost, HID_Handle->InPipe);

					if ((HID_Handle->DataReady == 0U) && (XferSize != 0U))
					{
						(void)USBH_HID_FifoWrite(&HID_Handle->fifo, HID_Handle->pData, HID_Handle->length);
						HID_Handle->DataReady = 1U;
						
						USBH_HID_EventCallback(phost,i);

	#if (USBH_USE_OS == 1U)
						phost->os_msg = (uint32_t)USBH_URB_EVENT;
	#if (osCMSIS < 0x20000U)
						(void)osMessagePut(phost->os_event, phost->os_msg, 0U);
	#else
						(void)osMessageQueuePut(phost->os_event, &phost->os_msg, 0U, 0U);
	#endif
	#endif
					}
				}
				else
				{
					/* IN Endpoint Stalled */
					if (USBH_LL_GetURBState(phost, HID_Handle->InPipe) == USBH_URB_STALL)
					{
						/* Issue Clear Feature on interrupt IN endpoint */
						if (USBH_ClrFeature(phost, HID_Handle->ep_addr) == USBH_OK)
						{
							/* Change state to issue next IN token */
							HID_Handle->state = USBH_HID_GET_DATA;
						}
					}
				}
				break;

			default:
				break;
		}
	}
  return status;
}

My_USB_MouseKey.h

下面展示一些 内联代码片。


#ifndef __MY_USB_MOUSEKEY_H__
#define __MY_USB_MOUSEKEY_H__		

#include "main.h"	 
#include "usbh_def.h"
#include "usart.h"
#include "usbh_hid_mouse.h"
#include "usb_host.h"
#include "usbh_hid.h"
#include "usbh_hid_parser.h"
#ifdef __cplusplus
 extern "C" {
#endif

typedef enum{
	EXTRA_NULL=0,
	LEFT_PRESSED,
	RIGHT_PRESSED,
	EXTRA_NULL2,
	MIDDLE_PRESSED,
	EXTRA_NULL3,
	EXTRA_NULL4,
	EXTRA_NULL5,
	SIDE_PRESSED,
	EXTRA_NULL6,
	EXTRA_NULL7,
	EXTRA_NULL8,
	EXTRA_NULL9,
	EXTRA_NULL10,
	EXTRA_NULL11,
	EXTRA_NULL12,
	EXTRA_PRESSED,
}mouse_status;	

typedef enum{
		MOVEMENT_NULL = 0,
		UP,
		DOWN,
		LEFT,
		RIGHT,
		UP_LEFT,
		UP_RIGHT,
		DOWN_LEFT,
		DOWN_RIGHT,
}mouse_movement_status;

extern void USBH_HID_ParseHIDDesc(HID_DescTypeDef *desc, uint8_t *buf);
extern ApplicationTypeDef Appli_state;	 
extern  HID_MOUSE_Info_TypeDef    mouse_info;
#ifdef __cplusplus
}
#endif

#endif

这就是我的两个.c和.h文件，其中有一些要说明一下。先说.h文件。

我的.h文件里的#include不用说，都要包含进来，然后是mouse_status，这个枚举是用来最后对标鼠标按键用的枚举；mouse_movement_status是用来对标鼠标移动的枚举。其他的extern主要都是我自己写的函数要用到，所以要extern出来。

然后是.c文件的说明，上面的.c文件里，都是原来的Cubemx里生成的文件，但是要按照博主的方法修改的函数。

第三步，修改struct

我这里对标的是博主的第二步。

修改类结构体，原定义中只有一个数据接口，将这个改成数组形式，就可实现多个接口/类。
下面展示一些 内联代码片。

/* USB Host Class structure */
typedef struct 
{
  const char          *Name;
  uint8_t              ClassCode;  
  USBH_StatusTypeDef  (*Init)        (struct _USBH_HandleTypeDef *phost);
  USBH_StatusTypeDef  (*DeInit)      (struct _USBH_HandleTypeDef *phost);
  USBH_StatusTypeDef  (*Requests)    (struct _USBH_HandleTypeDef *phost);  
  USBH_StatusTypeDef  (*BgndProcess) (struct _USBH_HandleTypeDef *phost);
  USBH_StatusTypeDef  (*SOFProcess) (struct _USBH_HandleTypeDef *phost);  
  void*                pData[USBH_MAX_NUM_INTERFACES];//原为pData修改为数组形式
} USBH_ClassTypeDef;

第四步，补充USBH_HID_EventCallbcak函数

这里对标博主的第五步。
补充USBH_HID_EventCallbcak函数。此函数被调用于USBH_HID_Process->case HID_POLL,当接收到数据填入fifo后，立即调用USBH_HID_EventCallbcak函数将数据读取到对应的fifo中，防止被下一接口数据覆盖。KeyboardFlag和MouseFlag 用于标记是哪个接口接收了数据。

关于我自己的修改：我这里的修改其实和博主不太一样，因为每次按下键盘或者鼠标都会触发这个函数，所以我把这个函数放在了我自己写的My_USB_MouseKey.h和My_USB_MouseKey.c中。原生的Cubemx的代码我也是直接__WEAK掉了。

Cubemx的代码修改：
在这里插入图片描述

然后自己写了一遍，自己写的如下：
主要实现的函数是USBH_HID_MouseDecode(phost);和USBH_HID_GetASCIICode(k_pinfo);
但是这两个函数是Cubemx生成的，所以可以直接用。自己要写的数据处理函数是mouse_data_process(mouse_info);
keypad_data_process©;
这两个函数。
下面展示一些 内联代码片。

void USBH_HID_EventCallback(USBH_HandleTypeDef *phost,uint8_t flag)
{
  #include "usb_host.h"
	#include "usbh_hid_mouse.h"
  char c;
  HID_KEYBD_Info_TypeDef *k_pinfo;
  HID_MOUSE_Info_TypeDef *m_pinfo;
  if(1 == flag)
	{
		m_pinfo = USBH_HID_GetMouseInfo(phost); 
		if (m_pinfo != NULL)
		{
				//LED_0_State = 0;
				USBH_HID_MouseDecode(phost);
				mouse_data_process(mouse_info);
				memset(m_pinfo ,0,sizeof(HID_MOUSE_Info_TypeDef ));
		}

	}
	else
	{
		k_pinfo = USBH_HID_GetKeybdInfo(phost); /* ?????? */
		if(k_pinfo == NULL)
		{
			 uint8_t err = 0xff;
		}
		if (k_pinfo != NULL)
		{
				c = USBH_HID_GetASCIICode(k_pinfo); /* ???ASCII? */
				keypad_data_process(c);
				
				memset(k_pinfo ,0,sizeof(HID_KEYBD_Info_TypeDef ));
		}
   
	}
}

// An highlighted block

第五步 修改鼠标和键盘初始化里的pdata

系统自动生成的代码里有两个和键盘鼠标有关的.C文件，一个是usbh_hid_keybd.c，另一个就是usbh_hid_mouse.c。这两个文件夹里各有两个函数要修改。

5.1 键盘文件修改

第一个是关于键盘的，里面的USBH_HID_KeybdInit函数的第一行的phost->pActiveClass->pData要改成phost->pActiveClass->pData[0]。
第二个是USBH_HID_KeybdDecode函数的第一行的phost->pActiveClass->pData要改成phost->pActiveClass->pData[0]。

5.2 鼠标文件修改

第一个是关于鼠标的，里面的USBH_HID_MouseInit函数的第一行的phost->pActiveClass->pData要改成phost->pActiveClass->pData[1]。
第二个是USBH_HID_MouseDecode函数的第一行的phost->pActiveClass->pData要改成phost->pActiveClass->pData[1]。

修改理由：
主要是因为0存储的是键盘的协议，1存储的是鼠标的协议。

第六步 注意Cubemx生成的时候的内存

在Cuebmx的界面里我们设置过一个USB_HOST —>Parameter Settings -----> CMSIS_RTOS ----> USBH_PROCESS_STACK_SIZE
这个参数的设置非常重要，必须大于1500，一般在我们的鼠标键盘没有写什么的时候，大于512就可以跑的起来，但是当像我这样写了一些函数来判断后，内存如果小于1500就跑不完，有的时候就连USB的配置符参数都没有读取完成，或者就直接出现系统卡死现象。这个函数就是用来控制整个USB线程能不能正常跑完，不卡死系统的参数。

还有一个参数就是USB_HOST —>Parameter Settings -----> Host_Configuration ----->USBH_MAX_DATA_BUFFER
这个参数也很重要，一般没有写什么在Callback的返回函数里的时候，这个数值要大于1024，小于这个数值就会根本进不了Callback函数，会出现按了键盘鼠标什么都不出现。当写了一些判断函数后，也就是我这里的所有的函数的量后，这个数值要大于1500，越大自然越好。小了后，不管按什么都不会有反应。一般最好要大于2000左右，小了自然就很难找到错误了。

关于参考的博主的第六步和第七步

关于博主的第六步和第七步我都没有去做，第一是我发现做了以后，整个USB就跑不动了，不知道哪里出了问题，第二就是我觉得博主的第七步说的很对，根本不需要跑demo了，直接所有的都在USBH_HID_EventCallback里已经处理了。

关于运行后还有的一些错误

如果你按我的方法这样修改后，KEIL5一定还是会报一些错误，因为原生的Cubemx代码里还是有一些是static定义的，所以如果还有错误，你可以看下错误的地方，把host_hid.c里只要是自己__weak了的函数里的错误的全删除掉，因为只要__weak了，而且你重写了，就不会再跑__WEAK的函数。还可能有一些错误是识别不到函数，就要#include 一下啊，或者有些变量比如pdata或者下面改进的部分会出现的问题，加了Z在鼠标解码的结构体里，就要自己改下加一下。

关于我自己做的一些改进

我根据自己的硬件设备，做了一些读取USB键盘和鼠标的改进，因为原生的Cubemx生成的鼠标还有一些问题，现在的设备的鼠标的数据和Cubemx生成代码的解码还是有一些出入，这里说明一下这些有出入的地方和我自己的改进部分。

键盘的改进

我上面的代码里不是有实现keypad_data_process©;这个函数么，我这个函数就是输出一下按键到UART1这种调试接口，用电脑显示一下，我的函数如下：
下面展示一些 内联代码片。

void keypad_data_process(uint8_t data)
{
	printf("%c",data);
}

鼠标的改进

因为原生的Cubmx生成的代码在鼠标上和现在的键盘鼠标一体的设备的出入比较大，所以在原生的Cubemx生成的代码上，还要做一些修改。

第一步

USBH_StatusTypeDef USBH_HID_MouseDecode(USBH_HandleTypeDef *phost)函数要修改。
修改后的函数如下，大家可以对比下Cubemx生成的代码，看下区别。
在这里插入图片描述

第二步

我这里的是比原生的代码多出来的部分，我这里其实是增加了下面的这个prop_z，这个你们也可以按照我的方法自己加一下，主要是打开usbh_hid_mouse.c文件，差不多150行左右，复制prop_y，粘贴在prop_y下面，并且把mouse_report_data + 2改成mouse_report_data + 3就行了，其他的不变。
在这里插入图片描述

第三步

这个.h里要加一个z，只有z才包含鼠标的上下移动的数据。
在这里插入图片描述

这样就好了，这里我要说明下为啥要加这个。
首先，我发现mouse_info这个变量，也就是用HID_MOUSE_Info_TypeDef定义的是这样的，原生的代码只有x，y，buttons[3]，这三个变量，但是我测试下来发现，x里面只有鼠标按键的左键、右键、中建、边按键、第二个边键的信息。y里面只有鼠标的左右移动的信息，所以还缺失了鼠标上下移动的信息。所以在原生的代码里，还要加上这条，才能实现鼠标的上下移动的代码。关于buttons[3]，这个就没啥用了，但是每次发送回来的数据里button[3]都是一样的数据，所以可以当做是一种验证码，如果哪次发送回来的buttons【3】数据不一样，就说明这次是错误数据。

关于鼠标的解析

因为经过不断的测试，我的鼠标的y和z两个函数和上下左右的关联都有，所以必须要一起处理，单独处理的话，就会很容易解析出错，明明是左移数据，就可能会解析成左和下都有，所以花乐2个小时又不断测试修改，最后成了下面的这些函数。

我自己的鼠标的解析函数如下：

下面展示一些 内联代码片。

int InterfaceIndex[USBH_MAX_NUM_INTERFACES] ={0};
uint8_t Pressed[5]={0};

void CLear_MousePressed()
{
	for(int i =0;i<5;i++)
	{
		Pressed[i]=0;
	}
}

void Show_MousePressed_Status(uint8_t status)
{
	if((status & LEFT_PRESSED) != 0)
	{
		Pressed[0] = 1;
		printf("左键");
	}
	if((status & RIGHT_PRESSED) != 0)
	{
		Pressed[1] = 1;
		printf("右键");
	}
	if((status & MIDDLE_PRESSED) != 0)
	{
		Pressed[2] = 1;
		printf("中建");
	}
	if((status & SIDE_PRESSED) != 0)
	{
		Pressed[3] = 1;
		printf("边按键");
	}
	if((status & EXTRA_PRESSED) != 0)
	{
		Pressed[4] = 1;
		printf("边2按键");
	}
}

uint8_t Movement_Measure(uint8_t status1,uint8_t status2)
{
	
	if(status1 == 0)
	{
		if(status2 != 0)
		{
			if(status2>255/2)
			{
				return UP;
			}
			else
			{
				return DOWN;
			}
		}
		else
		{
			return 0;
		}
	}
	else
	{
		if(status2 != 0)
		{
			if((status1>255/2) && (status2<16))
			{
				return LEFT;//0,253,15
			}
			else
			{
				if((status1>255/2) && (status2>255/2))
				{
					return UP_LEFT;//0,255,239
				}
				else
				{
					if((status1<255/2) && (status2>255/2))
					{
						return UP_RIGHT;//0,3,240
					}
					else
					{
						if((status1>255/2) && (status2<255/2))
						{
							return DOWN_LEFT;//0,254,31
						}
						else
						{
							return DOWN_RIGHT;//0,2,32
						}
					}
				}
			}
		}
		else
		{
			if(status1<255/2 )
			{
				return RIGHT;
			}
			
		}
	}
	return 0;
}


void Show_MouseMoved_Status(uint8_t status1,uint8_t status2)
{
	switch(Movement_Measure(status1,status2))
	{
		case LEFT:{printf("左\r\n");break;}
		case RIGHT:{printf("右\r\n");break;}
		case UP:{printf("上\r\n");break;}
		case DOWN:{printf("下\r\n");break;}
		case UP_LEFT:{printf("左上\r\n");break;}
		case UP_RIGHT:{printf("右上\r\n");break;}
		case DOWN_LEFT:{printf("左下\r\n");break;}
		case DOWN_RIGHT:{printf("右下\r\n");break;}
		default:break;
	}
}
	
void keypad_data_process(uint8_t data)
{
	printf("%c",data);
}	
			 
void mouse_data_process(HID_MOUSE_Info_TypeDef data)
{
	if((data.buttons[0] == 0x00) &&(data.buttons[1] == 0x01)&&(data.buttons[2] == 0x00))
	{
		
		if(data.x !=0)
		{
		//鼠标按键
			Show_MousePressed_Status(data.x);
		}
		if((data.y != 0x00)||(data.z != 0x00))
		{
		//鼠标移动
			Show_MouseMoved_Status(data.y,data.z);
		}
	}
	CLear_MousePressed();
}

关于鼠标的知识

参考这位博主的文章，这位博主的解析是正确的。
链接: Linux之解析鼠标input事件数据

根据博主的解释，对应我们STM32的HID_MOUSE_Info_TypeDef的数据结构可知，x是鼠标按键，而且x是uint8_t的8位数据。
x的第一位是左键按下
x的第二位是右键按下
x的第三位是中键按下
x的第四位是边键按下
x的第5位是边2键按下

博主文章中的，data 数组的第1个字节：表示鼠标的水平位移；
也就是对应我们的y。

博主文章中的，data 数组的第2个字节：表示鼠标的垂直位移；
也就是对应我们自己新加的z。

关于后续

因为我这个项目只需要用到这几个按键，和移动，所以我也就测试到这里了，如果还有需要鼠标滚轮的事件的，可以参考
链接: Linux之解析鼠标input事件数据
这位博主的继续修改代码，读取滚轮的数据。

留在街角
关注
专栏目录
通过STM32CUbeMX建立USB HID的双向通讯
07-01
通过STM32CUbeMX建立USB HID的双向通讯 通过STM32CUbeMX建立USB HID的双向通讯 通过STM32CUbeMX建立USB HID的双向通讯 通过STM32CUbeMX建立USB HID的双向通讯
STM32CubeMx的(stm32f103c8t6)USB复合键盘鼠标个interface两个设备
10-22
以上是关于使用STM32CubeMX配置STM32F103C8T6实现USB复合设备，包含HID键盘和鼠标接口的基本步骤。实际项目可能需要根据具体需求进行更多定制，如添加设备描述符、优化中断处理等。在开发过程中，参考ST官方文档和...
STM32CubeMX实现USB HID keyboard(鼠标改键盘)
最新发布
Manjusaka_ywang的博客
02-27 1905
HID描述符关联于接口描述符，因而如果一个设备只有一个接口描述符，则无论它有几个端点描述符，HID设备只有一个HID描述符。：修改部分为最后面按键输入描述部分，将后面6个按键缩减为2个按键(即：从6个字节缩减到2个字节)，配合上前面2个字节的输入报告，正好是4个字节，刚好符合原来HID端点描述符一次最多发送的大小。的值为 0 或 1， 为1表示HID设备是一个启动设备（BootDevice， 一般对PC机有意义，意思是BIOS启动时能识别所使用的HID设备，且只有标准。pwd=4ghb 提取码：4ghb。
STM32 CubeMX USB_(HID 鼠标和键盘)
电子第一课，点亮LED；第二课，点亮钽电容；第三课，点亮MOS管
08-06 2706
STM32 CubeMX 自动生成的USB_HID是鼠标类型的：键盘类型要做一点小修改；
STM32CubeMX学习笔记-USB接口使用（HID按键）
weixin_41226265的博客
10-04 2224
USB（Universal Serial BUS）通用串行总线，是一个外部总线标准，用于规范电脑与外部设备的连接和通讯。是应用在 PC 领域的接口技术。USB 接口支持设备的即插即用和热插拔功能。USB 是在 1994 年底由英特尔、康柏、IBM、Microsoft 等多家公司联合提出的。USB 发展到现在已经有 USB1.0/1.1/2.0/3.0 等多个版本。目前用的最多的就是 USB1.1 和 USB2.0，USB3.0 目前已经开始普及。
STM32利用CUBEMX建立自定义HID工程，并且完成64字节的IN，OUT传输功能。
Monkey12300的博客
06-30 1409
STM32 Customed HID开发流程 本文介绍的是STM32的cubeMX自定义HID的开发流程 cubeMX配置customed HID模式。更多详细配置壳查看代码CubeMX的配置文件。 修改usbd_custome_hid_if.c 里面的CUSTOM_HID_ReportDesc_FS[USBD_CUSTOM_HID_REPORT_DESC_SIZE] 数组。根据填入...
使用cubeMX生成USB HID设备
专注音频，高效工作，快乐生活！
05-13 645
本文主要介绍如何使用stm32开发板和cubeMX生成HID设备，供参考。
stm32F429使用cubemx生产usbhid进行通信
04-27
在本项目中，我们将探讨如何使用CubeMX工具（版本5.3.0）配置STM32F429，以便实现USB Human Interface Device (HID)通信。USB HID主要用于连接键盘、鼠标等设备，但也可用于其他数据传输应用。 首先，我们需要安装...
stm32 USB HID+CDC 鼠标键盘串口 组合设备配置解析
07-09
在这个专题中，我们将深入探讨如何将STM32配置为一个同时支持USB HID（Human Interface Device）和CDC（Communication Device Class）的设备，实现鼠标、键盘以及串口通信的功能。 USB HID主要用于连接人机交互设备...
usb-hid.rar_C# USB HID设备_USB HID读写_c# usb hid_usb_操作USB
09-24
HID设备通常包括键盘、鼠标、游戏控制器等，它们无需额外驱动程序即可在操作系统中使用。本资源包可能包含了如何在C#环境中实现USB HID设备的读写操作的相关代码示例。 描述中提到的“usb免驱动设备读写操作”，...
通过STM32CUbeMX建立USB HID的双向通讯.rar
10-18
基于STM32CUbeMX建立USB HID的双向通讯源码和上位机测试软件
STM32-customed-HID:利用CUBEMX建立自定义HID工程，并且完成64字节的IN，OUT传输功能
05-10
STM32 Customed HID开发流程 本文介绍的是STM32的cubeMX自定义HID的开发流程 -----------------由淘宝店铺提供，以便电子爱好者交流学习。---------------- cubeMX配置customed HID模式。更多详细配置壳查看代码CubeMX的配置文件。 修改usbd_custome_hid_if.c 里面的CUSTOM_HID_ReportDesc_FS[USBD_CUSTOM_HID_REPORT_DESC_SIZE] 数组。根据填入的数组内容修改宏USBD_CUSTOM_HID_REPORT_DESC_SIZE尺寸为34 __ALIGN_BEGIN static uint8_t CUSTOM_HID_ReportDesc_FS[USBD_CUSTOM_HID_REPORT_DESC_SIZE] __ALIGN_END = { /
基于STM32CubeMX自制三键USB键盘
05-08
其中包括原理图、PCB、PCB封装库、STM32CubeMX文件、STM32代码、参考资料、配套使用软件（USB设备通用）等资源，使用之前建议学习USB协议基础，更加容易上手。目前本项目为第一版测试成功，实现与成品键盘相同的复制、粘贴、退格功能。
HID-report.zip_USB HID 键盘_hid 键盘_report hid _usb hid键盘_usb鼠标键盘
09-19
在这个“HID-report.zip”压缩包中，包含了一份名为“HID report.pdf”的文档，很可能是关于HID设备，尤其是USB HID键盘和鼠标的相关详细报告。 USB HID键盘是计算机系统中最常见的输入设备之一，它遵循USB HID类...
STM32 CubeMX配置USB HID功能，及安装路径
ltqdxl的博客
10-27 2112
STM32CubeMX学习笔记（46）——USB接口使用（HID自定义设备）STM32CubeMX实现STM32 USBHID双向64字节通信(下位机部分)STM32 USB HID设置(STM32CubeMX)关于keil 5安装出现Fail to set path to Software Packs.问题解决方法
STM32CubeMX教程31 USB_DEVICE - HID外设_模拟键盘或鼠标
lc_guo的博客
01-28 2535
使用STM32CubeMX软件配置STM32F407开发板USB_OTG_FS为工作在Human Interface Device Class (HID)（人机接口设备类）模式下的USB_DEVICE（USB从机），利用上下左右四个用户按键模拟在Windwos上的鼠标或键盘操作
利用STM32CubeMX来生成USB_HID_Mouse工程
weixin_30606461的博客
05-11 657
硬件开发板：STM32F103C8 软件平台 好了现在开始利用STM32CubeMX来生成我们的工程 1、新建工程 选择MCU的型号 选择选择时钟 开启usb的模块 选择USB的类 配置时钟树(主要是设置usb的48Mhz) 设置工程路径和编译环境 打开工程 我们现在在main.c进行修改 /...
stm32 USB复合设备 cubeMX库一键生成 多路CDC串口 HID鼠标键盘 Composite Device
KJMetry的博客
11-05 3172
点点鼠标就可以生成一个复合设备，终于不用去修改Hal的代码了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

留在街角

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值