精华内容
下载资源
问答
  • STM32 USB驱动程序源代码,C语言编写,包括对应的库函数。
  • STM32F103 usb的驱动程序USB驱动生成工具,使用STM32CubeMX生成该工程,测试可用。参考链接:https://blog.csdn.net/d4l6c8/article/details/116268953?spm=1001.2014.3001.5501
  • 一、使用STM32CubeMX生成USB驱动程序 打开STM32CubeMX软件,选择Start My project formMCU,点ACCESS TO MCU SELECTOR。 选择相应的芯片信号,点击Start Project 配置RCC的High Speed Clock为图中所示,...

    一、使用STM32CubeMX生成USB驱动程序

    打开STM32CubeMX软件,选择Start My project formMCU,点ACCESS TO MCU SELECTOR。

    选择相应的芯片信号,点击Start Project

    配置RCC的High Speed Clock为图中所示,位置为外部时钟。

    选择SYS的Debug为Serial Wire,开启调试,否则下载程序后无法再次下载。具体解决方法参考链接:

    ST-LINK无法下载程序的解决方法

    在Connectivety下选择USB,勾选Device(FS),配置NVIC的中断,打上对勾,开启中断。

    在USB_DEVICE中的mode,选择Communication Device Class配置,在Device Descriptor中配置USB的信息,根据图片自行修改。

    在Clock configuration中,选择HES外部晶振,选择PLLCLK。在HCLK(MHz)下,填入72,点回车,等待系统自动配置时钟,配置完成后,USB时钟为48MHz,注意USB必须为48MHz。

    在Project Manager中,一次填写工程名称,路径,IDE选择MDK-ARM,Minimum Heap Size改为0x400或者0x800,否则可能出现USB在调用USBD_malloc() 申请内存是失败,导致数据无法接收的情况。点击右上角GENERATE CODE。

    打开工程文件,编译后下载到板子上,会在设备管理器看到这个设备

    测试中出现电脑上检测不到USB设备的情况,经过查阅资料,USB的DP引脚必须上拉1.5K欧的电阻,才能检测到,否则电脑上检测不到。

     

    电脑检测到USB的设备后,还需要安装相应的驱动。使用inf-wizard工具生成USB驱动。

    打开后,选择对应的设备,一路NEXT下去,等一会就会生成对应的驱动,安装该驱动,设备就能被电脑识别。

     

    工程文件和USB驱动生成工具稍后附上链接。

    下载链接:

    STM32F103的USB工程及USB驱动生成工具

     

     

    展开全文
  • 主要内容:1,单片机为STM32F103,USB配置为Bulk传输,两个IN端点,两个OUT端点; 2,PC端基于libusb的实现USB端点数据发送与接收,并封装成DLL动态链接库; 3,PC端调用2封装的动态链接库实现USB端点的数据发送与接收...

    主要内容:
    1,单片机为STM32F103,USB配置为Bulk传输,两个IN端点,两个OUT端点;
    2,PC端基于libusb的实现USB端点数据发送与接收,并封装成DLL动态链接库;
    3,PC端调用2封装的动态链接库实现USB端点的数据发送与接收;
    4,机器人端通过调用系统提供的USB函数,并再次封装为罐文件(类似于DLL);
    5,Android端调用4封装的jar文件实现USB端点的数据发送与接收;
    以上内容源码毫无保留,完全奉献出来,若转载请注明出处,谢谢!
    本文链接:

    1,STM32端的程序就不多说了,具体移植可以参考如下帖子:


    主函数的功能也很简单,就是初始化配置USB和串口(用于打印一些调试信息),然后判断USB是否接收到数据,若接收到数据则将该数据原样返回
    具体代码如下:

    int main(void)
    
    {
    
            uint8_t data[256];
    
            uint32_t i=0;
    
            Set_System();//系统时钟初始化
    
            USART_Configuration();//串口1初始化
    
            printf("\x0c\0");printf("\x0c\0");//超级终端清屏
    
            printf("\033[1;40;32m");//设置超级终端背景为黑色,字符为绿色
    
            printf("\r\n*******************************************************************************");
    
            printf("\r\n************************ Copyright 2009-2012, EmbedNet ************************");
    
            printf("\r\n*************************** [url=http://www.embed-net.com]http://www.embed-net.com[/url] **************************");
    
            printf("\r\n***************************** All Rights Reserved *****************************");
    
            printf("\r\n*******************************************************************************");
    
            printf("\r\n");
    
     
    
            USB_Interrupts_Config();
    
            Set_USBClock();
    
            USB_Init();
    
     
    
            while(1)
    
            {
    
                    if(EP1_ReceivedCount > 0){
    
                            USB_GetData(ENDP1,data,EP1_ReceivedCount);
    
                            USB_SendData(ENDP1,data,EP1_ReceivedCount);
    
                            printf("usb EP1 get data %d byte data\n\r",EP1_ReceivedCount);
    
                            for(i=0;i<EP1_ReceivedCount;i++){
    
                                    printf("0x%02X ",data[i]);
    
                            }
    
                            printf("\n\r");
    
                            EP1_ReceivedCount=0;
    
                    }
    
                    if(EP2_ReceivedCount > 0){
    
                            USB_GetData(ENDP2,data,EP2_ReceivedCount);
    
                            USB_SendData(ENDP2,data,EP2_ReceivedCount);
    
                            printf("usb EP2 get data %d byte data\n\r",EP2_ReceivedCount);
    
                            for(i=0;i<EP2_ReceivedCount;i++){
    
                                    printf("0x%02X ",data[i]);
    
                            }
    
                            printf("\n\r");
    
                            EP2_ReceivedCount=0;       
    
                    }
    
            }
    
    }
    
    


    USB数据接收回调函数在usb_endp.c文件中,两个端点的接收函数如下:

    
    
    void EP1_OUT_Callback(void)
    
    {
    
            EP1_ReceivedCount = GetEPRxCount(ENDP1);
    
            PMAToUserBufferCopy(USB_Receive_Buffer, ENDP1_RXADDR, EP1_ReceivedCount);
    
            SetEPRxStatus(ENDP1, EP_RX_VALID);
    
    }
    
    
    void EP2_OUT_Callback(void)
    
    {
    
            EP2_ReceivedCount = GetEPRxCount(ENDP2);
    
            PMAToUserBufferCopy(USB_Receive_Buffer, ENDP2_RXADDR, EP2_ReceivedCount);
    
            SetEPRxStatus(ENDP2, EP_RX_VALID);
    
    }


    运行PC端测试程序后,串口输出如下信息:2,PC端的USB驱动程序设计,主要是调用libusb的函数实现扫描设备,打开设备,端点读写,关闭设备等功能,其相关源码如下:
     

    /**
    
      * @brief  查找指定的USB设备个数
    
      * @param  pBoard 设备句柄存放地址
    
      * @retval 识别到的指定设备个数
    
      */
    
    static int scan_dev(struct usb_device *pBoard[])
    
    {
    
        struct usb_bus *bus;
    
        struct usb_device *dev;
    
            int devnum=0,i=0;
    
        for (bus = usb_get_busses(); bus; bus = bus->next)
    
        {
    
            for (dev = bus->devices; dev; dev = dev->next)
    
            {
    
                if (dev->descriptor.idVendor == USB_VID
    
                        && dev->descriptor.idProduct == USB_PID)
    
                {
    
                                    pBoard[devnum] = dev;
    
                                    devnum++;
    
                }
    
            }
    
        }
    
            for(i=devnum;i<100;i++){
    
                    pBoard[i] = NULL;
    
            }
    
        return devnum;
    
    }
    
    /**
    
      * @brief  扫描设备连接数
    
      * @param  NeedInit 是否需要初始化,第一次调用该函数需要初始化
    
      * @retval 识别到的指定设备个数
    
      */
    
    int __stdcall USBScanDev(int NeedInit)
    
    {
    
            if(NeedInit){
    
                    usb_init(); /* initialize the library */
    
                    usb_find_busses(); /* find all busses */
    
                    usb_find_devices(); /* find all connected devices */
    
            }
    
            return scan_dev(pBoard);
    
    }
    
     
    
    /**
    
      * @brief  打开指定的USB设备
    
      * @param  devNum        需要打开的设备号
    
      * @param        pBoard        设备句柄存放地址
    
      * @retval 已经打开了的设备句柄
    
      */
    
    static usb_dev_handle * open_dev(int devNum,struct usb_device *pBoard[])
    
    {
    
        struct usb_bus *bus;
    
        struct usb_device *dev;
    
            int devnum=0;
    
        for (bus = usb_get_busses(); bus; bus = bus->next)
    
        {
    
            for (dev = bus->devices; dev; dev = dev->next)
    
            {
    
                if (dev->descriptor.idVendor == USB_VID
    
                        && dev->descriptor.idProduct == USB_PID)
    
                {
    
                    if(devnum==devNum){
    
                                            return usb_open(pBoard[devNum]);
    
                                    }
    
                                    devnum++;
    
                }
    
            }
    
        }
    
        return NULL;
    
    }
    
     
    
    /**
    
      * @brief  打开指定的USB设备
    
      * @param  devNum        需要打开的设备号
    
      * @retval 打开状态
    
      */
    
    int __stdcall USBOpenDev(int DevIndex)
    
    {
    
            pBoardHandle[DevIndex] = open_dev(DevIndex,pBoard);
    
            if(pBoardHandle[DevIndex]==NULL){
    
                    return SEVERITY_ERROR;
    
            }else{
    
                    return SEVERITY_SUCCESS;
    
            }
    
    }
    
    /**
    
      * @brief  关闭指定的USB设备
    
      * @param  devNum        需要关闭的设备号
    
      * @param  pBoardHandle        开打了的设备句柄
    
      * @retval 已经打开了的设备句柄
    
      */
    
    static int close_dev(int devNum,struct usb_dev_handle *pBoardHandle[])
    
    {
    
        struct usb_bus *bus;
    
        struct usb_device *dev;
    
            int devnum=0;
    
        for (bus = usb_get_busses(); bus; bus = bus->next)
    
        {
    
            for (dev = bus->devices; dev; dev = dev->next)
    
            {
    
                if (dev->descriptor.idVendor == USB_VID
    
                        && dev->descriptor.idProduct == USB_PID)
    
                {
    
                    if(devnum==devNum){
    
                                            return usb_close(pBoardHandle[devNum]);
    
                                    }
    
                                    devnum++;
    
                }
    
            }
    
        }
    
        return NULL;
    
    }
    
     
    
    /**
    
      * @brief  关闭指定的USB设备
    
      * @param  devNum        需要关闭的设备号
    
      * @retval 打开状态
    
      */
    
    int __stdcall USBCloseDev(int DevIndex)
    
    {
    
            return close_dev(DevIndex,pBoardHandle);
    
    }
    
     
    
    /*
    
    * Read/Write using async transfer functions.
    
    *
    
    * NOTE: This function waits for the transfer to complete essentially making
    
    * it a sync transfer function so it only serves as an example of how one might
    
    * implement async transfers into thier own code.
    
    */
    
    static int transfer_bulk_async(usb_dev_handle *dev,
    
                                   int ep,
    
                                   char *bytes,
    
                                   int size,
    
                                   int timeout)
    
    {
    
        // Each async transfer requires it's own context. A transfer
    
        // context can be re-used.  When no longer needed they must be
    
        // freed with usb_free_async().
    
        //
    
        void* async_context = NULL;
    
        int ret;
    
     
    
        // Setup the async transfer.  This only needs to be done once
    
        // for multiple submit/reaps. (more below)
    
        //
    
        ret = usb_bulk_setup_async(dev, &async_context, ep);
    
        if (ret < 0)
    
        {
    
            //printf("error usb_bulk_setup_async:\n%s\n", usb_strerror());
    
            goto Done;
    
        }
    
     
    
        // Submit this transfer.  This function returns immediately and the
    
        // transfer is on it's way to the device.
    
        //
    
        ret = usb_submit_async(async_context, bytes, size);
    
        if (ret < 0)
    
        {
    
            //printf("error usb_submit_async:\n%s\n", usb_strerror());
    
            usb_free_async(&async_context);
    
            goto Done;
    
        }
    
     
    
        // Wait for the transfer to complete.  If it doesn't complete in the
    
        // specified time it is cancelled.  see also usb_reap_async_nocancel().
    
        //
    
        ret = usb_reap_async(async_context, timeout);
    
     
    
        // Free the context.
    
        usb_free_async(&async_context);
    
     
    
    Done:
    
        return ret;
    
    }
    
     
    
    /**
    
      * @brief  USB Bulk端点写数据
    
      * @param  nBoardID 设备号
    
      * @param  pipenum 端点号
    
      * @param  sendbuffer 发送数据缓冲区
    
      * @param  len 发送数据字节数
    
      * @param  waittime 超时时间
    
      * @retval 成功发送的数据字节数
    
      */
    
     
    
    int __stdcall USBBulkWriteData(unsigned int nBoardID,int pipenum,char *sendbuffer,int len,int waittime)
    
    {
    
            int ret=0;
    
            if(pBoardHandle[nBoardID] == NULL){
    
                    return SEVERITY_ERROR;
    
            }
    
    #ifdef TEST_SET_CONFIGURATION
    
        if (usb_set_configuration(pBoardHandle[nBoardID], MY_CONFIG) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #ifdef TEST_CLAIM_INTERFACE
    
        if (usb_claim_interface(pBoardHandle[nBoardID], 0) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #if TEST_ASYNC
    
        // Running an async write test
    
        ret = transfer_bulk_async(dev, pipenum, sendbuffer, len, waittime);
    
    #else
    
            ret = usb_bulk_write(pBoardHandle[nBoardID], pipenum, sendbuffer, len, waittime);
    
            /*if((len%64) == 0){
    
                    usb_bulk_write(pBoardHandle[nBoardID], pipenum, sendbuffer, 0, waittime);
    
            }*/
    
    #endif
    
    #ifdef TEST_CLAIM_INTERFACE
    
        usb_release_interface(pBoardHandle[nBoardID], 0);
    
    #endif
    
        return ret;
    
    }
    
     
    
    /**
    
      * @brief  USB interrupt端点写数据
    
      * @param  nBoardID 设备号
    
      * @param  pipenum 端点号
    
      * @param  sendbuffer 发送数据缓冲区
    
      * @param  len 发送数据字节数
    
      * @param  waittime 超时时间
    
      * @retval 成功发送的数据字节数
    
      */
    
    int __stdcall USBIntWriteData(unsigned int nBoardID,int pipenum,char *sendbuffer,int len,int waittime)
    
    {
    
            int ret=0;
    
            if(pBoardHandle[nBoardID] == NULL){
    
                    return SEVERITY_ERROR;
    
            }
    
    #ifdef TEST_SET_CONFIGURATION
    
        if (usb_set_configuration(pBoardHandle[nBoardID], MY_CONFIG) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #ifdef TEST_CLAIM_INTERFACE
    
        if (usb_claim_interface(pBoardHandle[nBoardID], 0) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
            ret = usb_interrupt_write(pBoardHandle[nBoardID], pipenum, sendbuffer, len, waittime);
    
    #ifdef TEST_CLAIM_INTERFACE
    
        usb_release_interface(pBoardHandle[nBoardID], 0);
    
    #endif
    
        return ret;
    
    }
    
     
    
    /**
    
      * @brief  USB 控制端点写数据
    
      * @param  nBoardID 设备号
    
      * @param  pipenum 端点号
    
      * @param  sendbuffer 发送数据缓冲区
    
      * @param  len 发送数据字节数
    
      * @param  waittime 超时时间
    
      * @retval 成功发送的数据字节数
    
      */
    
    int __stdcall USBCtrlData(unsigned int nBoardID,int requesttype,int request,int value, int index, char *bytes, int size,int waittime)
    
    {
    
            int ret=0;
    
            if(pBoardHandle[nBoardID] == NULL){
    
                    return SEVERITY_ERROR;
    
            }
    
    #ifdef TEST_SET_CONFIGURATION
    
        if (usb_set_configuration(pBoardHandle[nBoardID], MY_CONFIG) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #ifdef TEST_CLAIM_INTERFACE
    
        if (usb_claim_interface(pBoardHandle[nBoardID], 0) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
            ret = usb_control_msg(pBoardHandle[nBoardID], requesttype, request,value, index, bytes, size,waittime);
    
    #ifdef TEST_CLAIM_INTERFACE
    
        usb_release_interface(pBoardHandle[nBoardID], 0);
    
    #endif
    
        return ret;
    
    }
    
     
    
    /**
    
      * @brief  USB Bulk读数据
    
      * @param  nBoardID 设备号
    
      * @param  pipenum 端点号
    
      * @param  readbuffer 读取数据缓冲区
    
      * @param  len 读取数据字节数
    
      * @param  waittime 超时时间
    
      * @retval 读到的数据字节数
    
      */
    
    int __stdcall USBBulkReadData(unsigned int nBoardID,int pipenum,char *readbuffer,int len,int waittime)
    
    {
    
            int ret=0;
    
            if(pBoardHandle[nBoardID] == NULL){
    
                    return SEVERITY_ERROR;
    
            }
    
    #ifdef TEST_SET_CONFIGURATION
    
        if (usb_set_configuration(pBoardHandle[nBoardID], MY_CONFIG) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #ifdef TEST_CLAIM_INTERFACE
    
        if (usb_claim_interface(pBoardHandle[nBoardID], 0) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #if TEST_ASYNC
    
        // Running an async read test
    
        ret = transfer_bulk_async(pGinkgoBoardHandle[nBoardID], pipenum, sendbuffer, len, waittime);
    
    #else
    
            ret = usb_bulk_read(pBoardHandle[nBoardID], pipenum, readbuffer, len, waittime);
    
    #endif
    
    #ifdef TEST_CLAIM_INTERFACE
    
        usb_release_interface(pBoardHandle[nBoardID], 0);
    
    #endif
    
        return ret;
    
    }
    
     
    
    /**
    
      * @brief  USB interrupt读数据
    
      * @param  nBoardID 设备号
    
      * @param  pipenum 端点号
    
      * @param  readbuffer 读取数据缓冲区
    
      * @param  len 读取数据字节数
    
      * @param  waittime 超时时间
    
      * @retval 读到的数据字节数
    
      */
    
    int __stdcall USBIntReadData(unsigned int nBoardID,int pipenum,char *readbuffer,int len,int waittime)
    
    {
    
            int ret=0;
    
            if(pBoardHandle[nBoardID] == NULL){
    
                    return SEVERITY_ERROR;
    
            }
    
    #ifdef TEST_SET_CONFIGURATION
    
        if (usb_set_configuration(pGinkgoBoardHandle[nBoardID], MY_CONFIG) < 0)
    
        {
    
            usb_close(pGinkgoBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
     
    
    #ifdef TEST_CLAIM_INTERFACE
    
        if (usb_claim_interface(pBoardHandle[nBoardID], 0) < 0)
    
        {
    
            usb_close(pBoardHandle[nBoardID]);
    
            return SEVERITY_ERROR;
    
        }
    
    #endif
    
            ret = usb_interrupt_read(pBoardHandle[nBoardID], pipenum, readbuffer, len, waittime);
    
    #ifdef TEST_CLAIM_INTERFACE
    
        usb_release_interface(pBoardHandle[nBoardID], 0);
    
    #endif
    
        return ret;
    
    }
    
    


    以上程序包含了散装端点读写,中断端点读写,控制端点读写,几个函数我都亲自测试过,不过也不敢保证没任何问题,大家在调试的时候若发现问题可以在这里反馈
    这套程序最后是生成USB_Driver.dll和USB_Driver.lib文件,测试程序导入这两个文件就可以调用里面封装的函数了,当然还要包含USB_Driver.h头文件

    .3,PC端测试程序,这个程序功能相对简单,就是实现查找设备,打开设备,端点数据发送读取这样的功能,其源码如下:

    #define        EP1_OUT_SIZE        64
    
    #define        EP1_IN_SIZE        64
    
     
    
    int _tmain(int argc, _TCHAR* argv[])
    
    {
    
            int DevNum;
    
            int ret;
    
            char WriteTestData[256]={1,2,3,4,5,6,7,8,9};
    
            char ReadTestData[256]={0};
    
            for(int i=0;i<256;i++){
    
                    WriteTestData[i] = i;
    
            }
    
            //扫描设备连接数,需要初始化
    
            DevNum = USBScanDev(1);
    
            printf("设备连接数为:%d\n",DevNum);
    
            //打开设备0
    
            ret = USBOpenDev(0);
    
            if(ret == SEVERITY_ERROR){
    
                    printf("打开设备失败!\n");
    
                    return SEVERITY_ERROR;
    
            }else{
    
                    printf("打开设备成功!\n");
    
            }
    
     
    
            //端点1写数据
    
            ret = USBBulkWriteData(0,EP1_OUT,WriteTestData,EP1_OUT_SIZE,500);
    
            if(ret != EP1_OUT_SIZE){
    
                    printf("端点1写数据失败!%d\n",ret);
    
                    return SEVERITY_ERROR;
    
            }else{
    
                    printf("端点1写数据成功!\n");
    
            }
    
            //端点1读数据
    
            ret = USBBulkReadData(0,EP1_IN,ReadTestData,EP1_IN_SIZE,500);
    
            if(ret != EP1_IN_SIZE){
    
                    printf("端点1读数据失败!%d\n",ret);
    
                    return SEVERITY_ERROR;
    
            }else{
    
                    printf("端点1读数据成功!\n");
    
                    for(int i=0;i<EP1_IN_SIZE;i++){
    
                            printf("%02X ",ReadTestData[i]);
    
                            if(((i+1)%16)==0){
    
                                    printf("\n");
    
                            }
    
                    }
    
                    printf("\n");
    
            }
    
            Sleep(100);
    
            //端点2写数据
    
            ret = USBBulkWriteData(0,EP2_OUT,WriteTestData+64,64,500);
    
            if(ret != 64){
    
                    printf("端点2写数据失败!%d\n",ret);
    
                    return SEVERITY_ERROR;
    
            }else{
    
                    printf("端点2写数据成功!\n");
    
            }
    
            //端点2读数据
    
            ret = USBBulkReadData(0,EP2_IN,ReadTestData,64,500);
    
            if(ret != 64){
    
                    printf("端点2读数据失败!%d\n",ret);
    
                    return SEVERITY_ERROR;
    
            }else{
    
                    printf("端点2读数据成功!\n");
    
                    for(int i=0;i<64;i++){
    
                            printf("%02X ",ReadTestData[i]);
    
                            if(((i+1)%16)==0){
    
                                    printf("\n");
    
                            }
    
                    }
    
                    printf("\n");
    
            }
    
            getchar();
    
            return 0;
    
    }


    以上就是在PC端开发的相关程序,PC端测试程序输出为:下面介绍下在Android端的USB驱动程序开发.4,和PC端程序开发一样,我们在Android端也先封装成一个库,封装后的文件为usb_driver.jar,开发平台我们采用官方提供的eclipse平台,其版本为adt-bundle-windows-x86-20140702 Android端封装的程序和PC端类似,也是扫描设备,打开设备,端点发送或者接收,其源码如下:
     


     

    package com.viewtool.USBDriver;
    
     
    
    import java.util.HashMap;
    
    import android.app.PendingIntent;
    
    import android.hardware.usb.UsbConstants;
    
    import android.hardware.usb.UsbDevice;
    
    import android.hardware.usb.UsbDeviceConnection;
    
    import android.hardware.usb.UsbEndpoint;
    
    import android.hardware.usb.UsbInterface;
    
    import android.hardware.usb.UsbManager;
    
    import android.util.Log;
    
     
    
     
    
    public class UsbDriver{
    
            private UsbManager usbManager;
    
            private UsbDevice usbDevice;
    
            private UsbInterface usbInterface;
    
            private UsbEndpoint[] BulkInEndpoint = new UsbEndpoint[2];
    
            private UsbEndpoint[] BulkOutEndpoint = new UsbEndpoint[2];
    
            private UsbDeviceConnection connection;
    
            private PendingIntent pendingIntent;
    
            public UsbDriver(UsbManager usbManager,PendingIntent pendingIntent) {
    
                    super();
    
                    this.usbManager = usbManager;
    
                    this.pendingIntent = pendingIntent;
    
            }
    
            /**
    
             * Scan Device
    
             * @return
    
             */
    
            public UsbDevice ScanDevices() {
    
                    HashMap<String, UsbDevice> map = this.usbManager.getDeviceList();
    
                    for(UsbDevice device : map.values()){
    
                            Log.e("device", "vid:"+device.getVendorId()+"   pid:"+device.getProductId()+"   "+device.getDeviceName());
    
                            if(0x1483 == device.getVendorId() && 0x5751 == device.getProductId()){
    
                                    usbDevice = device;
    
                                    System.out.println( "Start ScanDevices" ); 
    
                                    usbManager.requestPermission(usbDevice, pendingIntent);
    
                                    return usbDevice;
    
                            }
    
                    }
    
                    return null;
    
            }
    
            /**
    
             * Open Device
    
             * @return
    
             */
    
            public int OpenDevice(){
    
                    this.usbInterface = usbDevice.getInterface(0);
    
                    int i=0;
    
                    int j=0;
    
                    int k=0;
    
            for (i = 0; i < usbInterface.getEndpointCount(); i++) { 
    
                UsbEndpoint ep = usbInterface.getEndpoint(i); 
    
                // look for bulk endpoint
    
                if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
    
                    if (ep.getDirection() == UsbConstants.USB_DIR_OUT) { 
    
                            BulkOutEndpoint[j++] = ep;
    
                    } else { 
    
                            BulkInEndpoint[k++] = ep; 
    
                    } 
    
                }
    
            }
    
            if(((BulkOutEndpoint[0]==null)||(BulkInEndpoint[0]==null))&&(usbInterface.getEndpointCount()==1)){
    
                    return ErrorType.ERR_OPEN_DEVICE;
    
            }
    
            if(((BulkOutEndpoint[1]==null)||(BulkInEndpoint[1]==null))&&(usbInterface.getEndpointCount()==2)){
    
                    return ErrorType.ERR_OPEN_DEVICE;
    
            }
    
                    //判断是否有权限
    
                    if(usbManager.hasPermission(usbDevice)){
    
                            this.connection = usbManager.openDevice(usbDevice);
    
                            if(this.connection == null){
    
                                    return ErrorType.ERR_OPEN_DEVICE;
    
                            }else{
    
                                    this.connection.claimInterface(usbInterface, true);
    
                            }
    
                    }else{
    
                            return  ErrorType.ERR_NO_PERMISSIONS;
    
                    }
    
                    return ErrorType.ERR_SUCCESS;
    
            }
    
            /**
    
             * Write data to USB
    
             * @param epNum Endpoint No.
    
             * @param writebuffer Write Data buffer
    
             * @param length Write Data Length
    
             * @param timeout Time Out
    
             * @return Write Data Length
    
             */
    
            public int USBWriteData(int epNum,byte[] writebuffer,int length,int timeout){
    
                    int count = 0;
    
                    if(epNum==BulkOutEndpoint[0].getEndpointNumber()){
    
                            count = connection.bulkTransfer(BulkOutEndpoint[0], writebuffer, length, timeout);
    
                            if((length%64)==0){
    
                                    connection.bulkTransfer(BulkOutEndpoint[0], writebuffer, 0, timeout);
    
                            }
    
                            return count;
    
                    }
    
                    if(epNum==BulkOutEndpoint[1].getEndpointNumber()){
    
                            count = connection.bulkTransfer(BulkOutEndpoint[1], writebuffer, length, timeout);
    
                            if((length%64)==0){
    
                                    connection.bulkTransfer(BulkOutEndpoint[0], writebuffer, 0, timeout);
    
                            }
    
                            return count;
    
                    }
    
                    return count;
    
            }
    
            /**
    
             * Read data From USB
    
             * @param epNum Endpoint No.
    
             * @param readbuffer Read Data Buffer
    
             * @param length Read data length
    
             * @param timeout Time out
    
             * @return Read data length
    
             */
    
            public int USBReadData(int epNum,byte[] readbuffer,int length,int timeout){
    
                    if(epNum==(BulkInEndpoint[0].getEndpointNumber()|0x80)){
    
                            return connection.bulkTransfer(BulkInEndpoint[0], readbuffer, length, timeout);
    
                    }
    
                    if(epNum==(BulkInEndpoint[1].getEndpointNumber()|0x80)){
    
                            return connection.bulkTransfer(BulkInEndpoint[1], readbuffer, length, timeout);
    
                    }
    
                    return 0;
    
            }
    
    }
    
    
    

    代码应该容易理解,若有不理解的可以回帖提问,我会尽我所能进行解答

    .5,Android端驱动写好后,下面我们来写个简单的测试程序测试下这个驱动,测试程序所做的事情和PC端的测试程序所做的功能一样,也是扫描设备,打开设备,端点数据发送接收,关闭设备。
    在这里简单的介绍下几个关键的地方,代码完整附件在中可以下载
    首先新的英文一个USBDriver的类,也就是我们第4步的类,在这里需要获取USB访问权限,具体效果就是在你运行这个软件,准备对USB进行操作的时候会弹出一个授权对话框,你选择允许即可,其源码如下:

    /**
    
     * 配置usb
    
     */
    
    private void config_usb() {
    
            // TODO Auto-generated method stub
    
            mUsbManager = (UsbManager) getSystemService(MainActivity.USB_SERVICE);
    
            pendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(
    
                            ACTION_USB_PERMISSION), 0);
    
     
    
            mUsbDriver = new UsbDriver(mUsbManager, pendingIntent);
    
            mUsbDevice = mUsbDriver.ScanDevices();
    
     
    
            if (mUsbDevice != null) {
    
                    mStringBuffer_Console_Text.append("Find device sucessful.\n");
    
                    mTextView_ShowConsole.setText(mStringBuffer_Console_Text);
    
                    run_set();
    
            } else {
    
                    mStringBuffer_Console_Text.append("No device connected.\n");
    
                    mTextView_ShowConsole.setText(mStringBuffer_Console_Text);
    
                    return;
    
            }
    
            // run_set();
    
    }


    run_set()函数就是实现打开设备,端点数据发送和读取了,由于代码比较多,这里就不贴出来了,有兴趣的同学可以在附件下载源码
    .Android端测试程序输出效果:
      

     

     

    基本介绍就到这里了,下面是源码大放送:
    1,
    PCM生成USB_Driver.dll文件的源码工程(vs2010):
    3,PC端测试程序源码下载(vs2010):
    4 ,Android端生成usb_driver.jar的工程及源码下载:
    5,Android端测试程序源码下载
    6,Android端编译生成的APK文件下载:
    7,PC端的USB驱动器(inf文件,libusb工具生成):

    展开全文
  • stm32全系列驱动是一款官方发布的通用版USBHost驱动库,缺少该驱动库,电脑无法正常运行,小编为大家整理了详细的host移植方法,操作简单直观,需要的朋友欢迎在下载!stm32驱动介绍2014年10月5日官方最新发布的STM...
  • 基于STM32F107的各种USB驱动程序

    热门讨论 2013-03-11 13:40:00
    基于STM32F107的各种USB驱动程序,以上程序皆已调试成功,可以放心使用
  • STM32 USB转串口驱动

    2019-01-02 22:43:26
    STM32 USB转串口驱动,STM32 USB转串口驱动用于bf调参,F3、F4飞控的硬件驱动程序,完全适用于windows系统的基本程序
  • 基于STM32L152RBT6的HAL库,修改usbd_cdc_if.c文件CDC_Receive_FS函数 收什么发什么亲测可用。
  • STM32 USB 上位机程序实现

    千次阅读 2017-08-08 12:17:43
    libusb是开源的C库,使用该库是的用户可以在应用程序中直接访问 USB 设备,无需为 USB 设备编写内核驱动。libusb支持多个平台 (Linux, window, iOS),所以可以很方便地将应用程序移植到其他平台。 linux ...

    libusb 介绍

    libusb是开源的C库,使用该库是的用户可以在应用程序中直接访问 USB 设备,无需为 USB 设备编写内核驱动。libusb支持多个平台 (Linux, window, iOS),所以可以很方便地将应用程序移植到其他平台。

    linux libusb 安装

    从网上下载libusb的源码,下载地址:http://www.libusb.org/, 下载后编译安装。

    # tar jxvf libusb-1.0.20.tar.bz2
    
    # cd libusb-1.0.20
    # ./configure
    # make
    # sudo make install
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    ubuntu下可以通过以下命令快速安装。

    sudo apt-get isntall libusb*
    • 1
    • 1

    安装后,libusb的头文件被安装在/usr/local/include/libusb-1.0 ,链接库被安装在/usr/loacal/lib目录下。

    usb bulk 传输例程

    这个例程演示如何使用 libusb 库,编写 USB bulk xfer 上位机demo,可以正常接收和发送数据。注意,修改程序中的 VID 和 PID 的值和你 device 板子上所定义的一致,传输数据块的大小不要超过 device 定义的最大传输长度。

    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    #include "libusb.h"
    
    #define VID 0x8888
    #define PID 0x0088
    
    #define edp2in 0x82
    #define edp2out 0x02
    
    int main(void)
    {
        libusb_device **devs, *dev;
        int ret, i;
        ssize_t cnt;
        usb_pro_t usb_pro;
        struct libusb_device_handle *handle = NULL;
        libusb_context *ctx = NULL;
    
        ret = libusb_init(&ctx);
        if (ret < 0)
            return -1;
    
        libusb_set_debug(ctx, 3);
    
        cnt = libusb_get_device_list(NULL, &devs);
        if (cnt < 0) {
            printf("no usb dev on bus\r\n");
            return  -1;
        }
    
        i = 0;
        while((dev = devs[i++]) != NULL) {
    
            ret = libusb_get_device_descriptor(dev,&desc);
            if (ret < 0) {
                printf("failed to get device descriptor");
                goto error;
            }
    
            if ((desc.idVendor == VID) && (desc.idProduct == PID)) {
                printf("bLength: 0x%04x\r\n", desc.bLength);
                printf("bDescriptorType: 0x%04x\r\n", desc.bDescriptorType);
                printf("bcdUSB: 0x%04x\r\n", desc.bcdUSB);
                printf("bDeviceClass: 0x%04x\r\n", desc.bDeviceClass);
                printf("bDeviceSubClass: 0x%04x\r\n", desc.bDeviceSubClass);
                printf("bDeviceProtocol: 0x%04x\r\n", desc.bDeviceProtocol);
                printf("bMaxPacketSize0: 0x%04x\r\n", desc.bMaxPacketSize0);
                printf("vendor id: 0x%04x\r\n", desc.idVendor);
                printf("product id: 0x%04x\r\n", desc.idProduct);
                printf("bcdDevice: 0x%04x\r\n", desc.bcdDevice);
                printf("iManufacturer: 0x%04x\r\n", desc.iManufacturer);
                printf("iProduct: 0x%04x\r\n", desc.iProduct);
                printf("iSerialNumber: 0x%04x\r\n", desc.iSerialNumber);
                printf("bNumConfigurations: 0x%04x\r\n", desc.bNumConfigurations);
    
            }
    
        }
    
        handle = libusb_open_device_with_vid_pid(ctx, VID, PID);
    
        if (handle == NULL) {
            printf("cant't open device\r\n");
            goto error;
        } else {
            printf("open device\r\n");
        }
    
        libusb_free_device_list(devs, 1);
    
        if (libusb_kernel_driver_active(handle, 0) ==1) {
            printf("kernel driver active, detach it \r\n");
    
            if (libusb_detach_kernel_driver(handle, 0) == 0) {
                printf("detached kernel driver\r\n");
            }
            else {
                goto error;
            }
        }
    
        ret = libusb_claim_interface(handle, 0);
        if (ret < 0) {
            printf("can't claim interface\r\n");
            goto error;
        } else {
            printf("claimed interface\r\n");
        }
    
        char data[64];
        int actual_len = 0;
        int didi = 1000;
        for (int i = 0; i< 1000; i++) {
            memset(data, 0, sizeof(data));
            /*  receive data from device  */
            /*
            ret = libusb_bulk_transfer(handle, edp2in, data, 64, &actual_len, 0);
    
            if (actual_len = 0) {
                printf("received nothing\r\n");
            } else {
                printf("bulk transfer: %s\r\n", data);
            }
    
            usleep(200000);
            */
    
            char *str = "am host";
    
            sprintf(data, "am host %d\r\n", i);
    
            ret = libusb_bulk_transfer(handle, edp2out, data, strlen(data), &actual_len, 0);
    
            if (actual_len != 0) {
                printf("send data: %s\r\n", data);
            }
    
            usleep(200000); 
        }
    
        libusb_close(handle);
    
    error:
    
        printf("free device list\r\n");
        libusb_free_device_list(devs, 1);
    
        libusb_exit(NULL);
    
        return 0;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137

    编译

    编译代码可以使用 makefile 文件,也可以是使用命令行命令编译,这里给出两种编译方法。

    • makefile
    
    CC = gcc
    
    # your libusb library path, be careful your path.
    LDIR = /usr/loacal/lib
    
    # link flag
    LFLAG = -lusb-1.0
    
    # libusb hearder file path
    INCLUDES = /usr/local/include/libusb-1.0
    
    CFLAGS = -I$(INCLUDES) -std=c99
    
    src = $(wildcard *.c)
    
    obj = $(patsubst %.c, %.o, $(src))
    
    .PHONY: all clean
    
    all: main
    
    main: $(obj)
        $(CC)   $(obj) -o main -L$(LDIR) $(LFLAG)
    
    %.o:%.c
        $(CC) $(CFLAGS) -c $< -o $@
    
    clean:
        @-rm -f main $(obj)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 命令行编译 
      命令中-I/usr/local/include/libusb-1.0 告诉编译器 libusb 的头文件所在的路径。-L/usr/local/lib/ 告诉链接器所要链接的库文件路径。-lusb-1.0 告诉编译器需要链接 libusb-1.0.so这个库。
     gcc -I/usr/local/include/libusb-1.0 -std=c99 main.c -o main -L/usr/local/lib/ -lusb-1.0
    
    • 1
    • 2
    • 1
    • 2

    运行

    编译后会在当前目录下生成一个名叫“main“的可执行文件,运行这个文件。如果打开USB设备时出错提示permission error,那么使用

    # sudo ./main
    • 1
    • 1

    运行后,HOST每隔200ms 向 device 发送一个数据包。

    源码下载

    我的源码已上传到http://download.csdn.net/detail/chengwenyang/9479835 ,包含STM32F4Discovery板子的 usb bulk 传输的工程文件和 使用 libusb 编写的上位机程序。

    展开全文
  • STM32 USB虚拟串口驱动源码文档,包含win7 win8驱动程序源码,测试源码
  • STM32USB上位机,动态库,STM32端原代码,驱动程序,全套源码
  • http://www.embed-net.com/thread-94-1-1.html
    展开全文
  • 基于stm32的usb程序开发,详细解析了usb驱动的实现过程
  • 一个stm32f4驱动usb蓝牙适配器的程序代码,具有一定的参考价值,使用的开发工具可能是IAR
  • stm32 usbhid通信

    热门讨论 2017-04-24 14:00:55
    stm32 usb hid通信驱动程序
  • STM32-USB程序

    2015-10-07 14:07:40
    STM32USB官方驱动库。HOST和Device都有。
  • STM32USB自定义设备的上位程序+驱动+D12固件源代码.rar
  • STM32_USB_HID_学习心得:基于STM32USB程序开发笔记、修改STM32USB例程为自己所用、初涉USB,初学者USB入门总结——枚举。 STM32_固件库说明文档:STM32_USB_Demo例子的中文说明文档。 STM32F107 鼠标USB改 HID...
  • STM32 USB虚拟串口驱动

    热门讨论 2012-03-19 17:38:50
    程序里实现了USB虚拟串口,说明了发送数据的长度、缓冲、偏移、端点包大小以及当前的控制状态,并说明了发送的数据长度。
  • stm32l4usb设备驱动代码

    2018-09-19 15:01:34
    stm32l4XX的usb设备驱动程序,在网上找了好久没找到就自己生成了一个
  • 友来说确实存在许多的知识壁垒,本 着开源精神,在此对 STM32USB 固件程序的编写、DriverStudio + WindowsXP DDK + VC6 驱 动开发以及应用程序做了一些介绍,为更好理解,请仔细学习 STM32 USB 的参考手册以及 ...
  • STM32 USB HOST CDC 驱动CH340串口

    千次阅读 热门讨论 2020-07-11 18:28:27
    本文主要讲述的是在STM32F407VE板子上通过STMCube生成的USB HOST CDC 程序驱动CH340进行数据传输。 创作背景: 打算用RT1052开发一个项目,由于项目中用到的传感器比较多,像雷达,ublox等需要通过UART进行通讯,...
  • usb pc驱动stm32usb数据交换

    千次阅读 2011-10-11 09:39:54
    usb pc驱动及stm32usb数据交换 要实现usb数据传输,如下要求: 1、数据量200M以内 ,速度不要太慢; 2、设备不需要安装驱动程序; 自己情况分析: 1、下位机:自己之初步学习过usb方面的知识,...
  • STM32USB上位机(VC++源码),动态库(VC++源码),STM32端原代码,驱动程序,全套源码,有调试文件说明,
  • stm32VCP驱动

    2015-08-27 16:31:19
    stm32usb转串口驱动安装程序vcp
  • 1:STM32的参考手册,这对于设备底层USB的硬件配置以及事件驱动机制的了解尤为重要,你需要了解各个寄存器的功能以及如何操作,比如CNTR、ISTR、EPnR、DADDR等等,如果你想学习USB,这个手册是必须的。 2:USB2.0 ...
  •  1、按照STM32F4 开发笔记8:解决USB CDC “该设备无法启动”问题介绍的过程生成驱动程序后,找到如下图所示的文件加入到自己的项目工程中。  2、打开usbd_cdc_if.c文件,可以看到其中有,如下4个函数,其中Init...
  • 前些时间玩了把STM32,原来想做一个USB接口的单片机,FLASH编程器,感觉不错。代码涉及USB上位机(VC++源码),动态库(VC++源码),STM32下位机,如果正在学习USB相关的可以参考,上位机提供了动态库及源码,如果写...
  • STM32 WinUSB

    2018-11-02 09:56:32
    stm32无需安装vcp驱动程序了 1 修改stm32 cdc,将stm cdc变为winusb类型设备 2 制作一个inf,插入usb时可作为驱动的选择 3 winusb .net中间件来作为上位机与stm32usb通讯模块

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 316
精华内容 126
关键字:

stm32usb驱动程序