手机就是开发板

        从今天（2019-11-27）开始捣鼓手机，主要是想把手机当作开发板来用，当作一个上位机来编程，用手机去控制别的设备，我觉得这是个很有创意且可行的想法。首先，闲置的旧手机很好找，不用花钱买，而且手机上的器件比开发板全，相关资料也比较好找。

       第一步，搭建一个合适的开发平台，可行方案：Qt 5.13.2  + Qt 5.9.0

说明：安装 Qt 5.9.0是为了能能在Qt5.13.2上面编译安卓4.9及更低版上运行的APP

这个今天已经搭建好了，并用例程测试通过。

        接下来要学习手机的USB编程，与外设连接通信主要用USB，看了一些贴子，还没有完整的思路，有同样想法的朋友请留言，以后会不定期更新。

HID是Human Interface Device（人机交互的设备，例如键盘、鼠标与游戏杆等）的缩写，关于hid通信的API有三种：

hidapi（http://github.com/signal11/hidapi/downloads）

libusb（https://github.com/libusb/libusb/archive/master.zip）

libhid（http://alioth.debian.org/frs/?group_id=30451）

hidapi和libhid是基于libusb针对hid设备接口进行二次开发而成，hidapi使用简便，但功能也相对单一，仅提供基本的设备初始化、枚举、关闭、读写操作。提供对单一接口、单一端点的控制，它只能控制默认接口、默认端点的数据传输。

hidapi:

int HID_API_EXPORT HID_API_CALL hid_read(hid_device *device,
unsigned char *data,
size_t length
)

libhid:

hid_return hid_interrupt_read(HIDInterface *const hidif,
unsigned int const ep,//指定传输端口
char *const bytes,
unsigned int const size,
unsigned int const timeout    
)

libusb简介
libusb是一套可以比较简单的访问usb设备的api. libusb在不同的语言和不同的系统平台上都有实现,关于libusb的其他优点,可以访问libusb官网(http://libusb.org). 

Linux 平台上的usb驱动开发，主要有内核驱动的开发和基于libusb的无驱设计。

驱动开发向来是内核开发中工作量最多的一块，随着USB设备的普及，大量的USB设备的驱动开发也成为驱动开发者手头上做的最多的事情。本文主要介绍 Linux平台下基于libusb的驱动开发，希望能够给从事Linux驱动开发的朋友带来些帮助，更希望能够给其他平台上的无驱设计带来些帮助。文章是我在工作中使用libusb的一些总结，难免有错误，如有不当的地方，还请指正。

对于内核驱动的大部分设备，诸如带usb接口的hid设备，linux本身已经自带了相关的驱动，只要操作设备文件便可以完成对设备大部分的操作，另外一些诸如自己设计的硬件产品驱动需要编写开发出相关的驱动。内核驱动有它的优点，然而内核驱动在某些情况下会遇到如下的一些问题：

1 同时有多个内核平台，比如同时有2.4也有2.6内核，这时要设计的驱动是要兼容两个平台的，makefile要写两个。

2 要把linux移植到嵌入平台上，原先linux自带的驱动太大，如果嵌入平台是客户的，设备里的系统和你的环境不一样，它没有你要的驱动了，写个内核驱动加载，却发现客户连insmod加载模块的工具都没移植，又不能动他的内核。

这些问题， 可以考试用libusb的无驱动设计

实例讲解：

了解一下libusb, 并以写一个hid设备的驱动来了解如何运用libusb。

一 libusb 介绍

       libusb 设计了一系列的外部API 为应用程序所调用，通过这些API应用程序可以操作硬件，从libusb的源代码可以看出，这些API 调用了内核的底层接口，和kernel driver中所用到的函数所实现的功能差不多，只是libusb更加接近USB 规范。使得libusb的使用也比开发内核驱动相对容易的多。

网上有Libusb 的源码，需要编译安装，查看其中的Readme。

二 libusb 的外部接口

2.1 初始化设备接口

这些接口也可以称为核心函数，它们主要用来初始化并寻找相关设备。

usb_init

函数定义： void usb_init(void);

从函数名称可以看出这个函数是用来初始化相关数据的，这个函数大家只要记住必须调用就行了，而且是一开始就要调用的.

usb_find_busses

函数定义： int usb_find_busses(void);

寻找系统上的usb总线，任何usb设备都通过usb总线和计算机总线通信。进而和其他设备通信。此函数返回总线数。

 

usb_find_devices

函数定义： int usb_find_devices(void);

寻找总线上的usb设备，这个函数必要在调用usb_find_busses()后使用。以上的三个函数都是一开始就要用到的，此函数返回设备数量。

 

usb_get_busses

函数定义： struct usb_bus *usb_get_busses(void);

这个函数返回总线的列表，在高一些的版本中已经用不到了，这在下面的实例中会有讲解

 

 

2.2 操作设备接口

 

    usb_open

函数定义： usb_dev_handle *usb_open(struct *usb_device dev);

打开要使用的设备，在对硬件进行操作前必须要调用usb_open 来打开设备，这里大家看到有两个结构体 usb_dev_handle 和 usb_device 是我们在开发中经常碰到的，有必要把它们的结构看一看。在libusb 中的usb.h和usbi.h中有定义。

这里我们不妨理解为返回的 usb_dev_handle 指针是指向设备的句柄，而行参里输入就是需要打开的设备。

 

   usb_close

   函数定义： int usb_close(usb_dev_handle *dev);

   与usb_open相对应，关闭设备，是必须调用的, 返回0成功，<0 失败。

 

   usb_set_configuration

   函数定义： int usb_set_configuration(usb_dev_handle *dev, int configuration);

   设置当前设备使用的configuration，参数configuration 是你要使用的configurtation descriptoes中的bConfigurationValue, 返回0成功，<0失败( 一个设备可能包含多个configuration,比如同时支持高速和低速的设备就有对应的两个configuration,详细可查看usb标准)

 

   usb_set_altinterface

   函数定义： int usb_set_altinterface(usb_dev_handle *dev, int alternate);

   和名字的意思一样，此函数设置当前设备配置的interface descriptor，参数alternate是指interface descriptor中的bAlternateSetting。返回0成功，<0失败

 

   usb_resetep

   函数定义： int usb_resetep(usb_dev_handle *dev, unsigned int ep);

   复位指定的endpoint，参数ep 是指bEndpointAddress,。这个函数不经常用，被下面介绍的usb_clear_halt函数所替代。

 

   usb_clear_halt

   函数定义： int usb_clear_halt (usb_dev_handle *dev, unsigned int ep);

   复位指定的endpoint，参数ep 是指bEndpointAddress。这个函数用来替代usb_resetep

 

   usb_reset

   函数定义： int usb_reset(usb_dev_handle *dev);

   这个函数现在基本不怎么用，不过这里我也讲一下，和名字所起的意思一样，这个函数reset设备，因为重启设备后还是要重新打开设备，所以用usb_close就已经可以满足要求了。

 

   usb_claim_interface

   函数定义： int usb_claim_interface(usb_dev_handle *dev, int interface);

   注册与操作系统通信的接口，这个函数必须被调用，因为只有注册接口，才能做相应的操作。

Interface 指 bInterfaceNumber. (下面介绍的usb_release_interface 与之相对应，也是必须调用的函数)

 

   usb_release_interface

   函数定义： int usb_release_interface(usb_dev_handle *dev, int interface);

   注销被usb_claim_interface函数调用后的接口，释放资源，和usb_claim_interface对应使用。

 

   2.3 控制传输接口

 

   usb_control_msg

   函数定义：int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, int value, int index, char *bytes, int size, int timeout);

   从默认的管道发送和接受控制数据

 

   usb_get_string

   函数定义： int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf, size_t buflen);

 

   usb_get_string_simple

函数定义： int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, size_t buflen);

 

 

   usb_get_descriptor

   函数定义： int usb_get_descriptor(usb_dev_handle *dev, unsigned char type, unsigned char index, void *buf, int size);

 

   usb_get_descriptor_by_endpoint

   函数定义： int usb_get_descriptor_by_endpoint(usb_dev_handle *dev, int ep, unsigned char type, unsigned char index, void *buf, int size);

 

 

   2.4 批传输接口

 

   usb_bulk_write

   函数定义： int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);

 

    usb_interrupt_read

函数定义： int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);

2.5 中断传输接口

usb_bulk_write

函数定义： int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);

usb_interrupt_read

函数定义： int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);

基本上libusb所经常用到的函数就有这些了，和usb协议确实很接近吧。下面我们实例在介绍一个应用。

实例：

Libusb库的使用

使用libusb之前你的linux系统必须装有usb文件系统，这里还介绍了使用hiddev设备文件来访问设备，目的在于不仅可以比较出usb的易用性，还提供了一个转化成libusb驱动的案例。

3.1 find设备

任何驱动第一步首先是寻找到要操作的设备，我们先来看看HID驱动是怎样寻找到设备的。我们假设寻找设备的函数Device_Find(注：代码只是为了方便解说，不保证代码的健全)

/* 我们简单看一下使用hid驱动寻找设备的实现，然后在看一下libusb是如何寻找设备的 */

int Device_Find()

{

    char dir_str[100];   /* 这个变量我们用来保存设备文件的目录路径 */

    char hiddev[100];    /* 这个变量用来保存设备文件的全路径 */

DIR dir;              

/* 申请的字符串数组清空，这个编程习惯要养成 */

memset (dir_str, 0 , sizeof(dir_str));

memset (hiddev, 0 , sizeof(hiddev));

    /* hiddev 的设备描述符不在/dev/usb/hid下面，就在/dev/usb 下面

这里我们使用opendir函数来检验目录的有效性

打开目录返回的值保存在变量dir里，dir前面有声明

*/

dir=opendir("/dev/usb/hid");

    if(dir){

        /* 程序运行到这里，说明存在 /dev/usb/hid 路径的目录 */

        sprintf(dir_str,"/dev/usb/hid/");

        closedir(dir);

    }else{

        /* 如果不存在hid目录，那么设备文件就在/dev/usb下 */

        sprintf(dir_str,"/dev/usb/");

    }

    /* DEVICE_MINOR 是指设备数，HID一般是16个 */

for(i = 0; i < DEVICE_MINOR; i++) {

    /* 获得全路径的设备文件名，一般hid设备文件名是hiddev0 到 hiddev16 */

        sprintf(hiddev, "%shiddev%d", dir_str,i);

       /* 打开设备文件,获得文件句柄 */

       fd = open(hiddev, O_RDWR);

       if(fd > 0) {

           /* 操作设备获得设备信息 */

          ioctl(fd, HIDIOCGDEVINFO, &info);

   

              /* VENDOR_ID 和 PRODUCT_ID 是标识usb设备厂家和产品ID,驱动都需要这两个参数来寻找设备,到此我们寻找到了设备 */

           if(info.vendor== VENDOR_ID && info.product== PRODUCT_ID) {

                /* 这里添加设备的初始化代码 */

                  

               device_num++;   /* 找到的设备数 */

           }

           close(fd);

       }

    }

    return device_num;         /* 返回寻找的设备数量 */

}

我们再来看libusb是如何来寻找和初始化设备

int Device_Find()

{

struct usb_bus             *busses;

    int                           device_num = 0;

    device_num = 0;       /* 记录设备数量 */

   

    usb_init();            /* 初始化 */

    usb_find_busses();   /* 寻找系统上的usb总线 */

    usb_find_devices(); /* 寻找usb总线上的usb设备 */

   

    /* 获得系统总线链表的句柄 */

busses = usb_get_busses();

    struct usb_bus       *bus;

    /* 遍历总线 */

    for (bus = busses; bus; bus = bus->next) {

        struct usb_device *dev;

        /* 遍历总线上的设备 */

        for (dev = bus->devices; dev; dev = dev->next) {

           /* 寻找到相关设备， */

if(dev->descriptor.idVendor==VENDOR_ID&& dev->descriptor.idProduct == PRODUCT_ID) {

                /* 这里添加设备的初始化代码 */

                  

               device_num++;   /* 找到的设备数 */

}              

        }       

    }

    return device_num;        /* 返回设备数量 */

}

注：在新版本的libusb中，usb_get_busses就可以不用了 ，这个函数是返回系统上的usb总线链表句柄

这里我们直接用usb_busses变量，这个变量在usb.h中被定义为外部变量

所以可以直接写成这样：

struct usb_bus    *bus;

        for (bus = usb_busses; bus; bus = bus->next) {

               struct usb_device *dev;

        for (dev = bus->devices; dev; dev = dev->next) {

           /* 这里添加设备的初始化代码 */

        }

}

3.2 打开设备

假设我们定义的打开设备的函数名是device_open,

/* 使用hid驱动打开设备 */

int Device_Open()

{

    int handle;

    /* 传统HID驱动调用,通过open打开设备文件就可 */

handle = open(“hiddev0”, O_RDONLY);

}

/* 使用libusb打开驱动 */

int Device_Open()

{

/* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 */

struct usb_device*    udev;

usb_dev_handle*        device_handle;

/* 当找到设备后，通过usb_open打开设备，这里的函数就相当open 函数 */

device_handle = usb_open(udev);

}

3.3 读写设备和操作设备

假设我们的设备使用控制传输方式，至于批处理传输和中断传输限于篇幅这里不介绍

我们这里定义三个函数，Device_Write, Device_Read, Device_Report

Device_Report 功能发送接收函数

Device_Write 功能写数据

Device_Read   功能读数据

Device_Write和Device_Read调用Device_Report发送写的信息和读的信息，开发者根据发送的命令协议来设计，我们这里只简单实现发送数据的函数。

假设我们要给设备发送72字节的数据，头8个字节是报告头，是我们定义的和设备相关的规则，后64位是数据。

HID驱动的实现(这里只是用代码来有助理解，代码是伪代码)

int Device_Report(int fd, unsigned char *buffer72)

{

int       ret; /* 保存ioctl函数的返回值 */

int      index;

    unsigned char send_data[72]; /* 发送的数据 */

unsigned char recv_data[72]; /* 接收的数据 */

    struct hiddev_usage_ref uref; /* hid驱动定义的数据包 */

    struct hiddev_report_info rinfo; /* hid驱动定义的

    memset(send_data, 0, sizeof(send_data));

memset(recv_data, 0, sizeof(recv_data));

    memcpy(send_data, buffer72, 72);

   /* 这在发送数据之前必须调用的，初始化设备 */

    ret = ioctl(fd, HIDIOCINITREPORT, 0);

    if( ret !=0) {

        return NOT_OPENED_DEVICE;/* NOT_OPENED_DEVICE 属于自己定义宏 */

    }

    /* HID设备每次传输一个字节的数据包 */

    for(index = 0; index < 72; index++) {

        /* 设置发送数据的状态 */

    uref.report_type = HID_REPORT_TYPE_FEATURE;

    uref.report_id = HID_REPORT_ID_FIRST;

    uref.usage_index = index;

    uref.field_index = 0;

    uref.value = send_data[index];

    ioctl(fd, HIDIOCGUCODE, &uref);

    ret=ioctl(fd, HIDIOCSUSAGE, &uref);

    if(ret != 0 ){

           return UNKNOWN_ERROR;

    }

}

/* 发送数据 */

rinfo.report_type = HID_REPORT_TYPE_FEATURE;

rinfo.report_id = HID_REPORT_ID_FIRST;

rinfo.num_fields = 1;

ret=ioctl(fd, HIDIOCSREPORT, &rinfo);   /* 发送数据 */

if(ret != 0) {

        return WRITE_REPORT;

}

/* 接受数据 */

ret = ioctl(fd, HIDIOCINITREPORT, 0);

for(index = 0; index < 72; index++) {

    uref.report_type = HID_REPORT_TYPE_FEATURE;

    uref.report_id = HID_REPORT_ID_FIRST;

    uref.usage_index = index;

    uref.field_index = 0;

    ioctl(fd, HIDIOCGUCODE, &uref);

    ret = ioctl(fd, HIDIOCGUSAGE, &uref);

    if(ret != 0 ) {

        return UNKNOWN_ERROR;

    }

    recv_data[index] = uref.value;

}

memcpy(buffer72, recv_data, 72);

return SUCCESS;

}

libusb驱动的实现

int Device_Report(int fd, unsigned char *buffer72)

{

    /* 定义设备句柄 */

    usb_dev_handle* Device_handle;

   

    /* save the data of send and receive */

    unsigned char   send_data[72];

    unsigned char   recv_data[72];

   

    int              send_len;

    int             recv_len;

   

    /* 数据置空 */

    memset(send_data, 0 , sizeof(send_data));

    memset(recv_data, 0 , sizeof(recv_data));

   

    /* 这里的g_list是全局的数据变量，里面可以存储相关设备的所需信息，当然我们 也可以从函数形参中传输进来，设备的信息在打开设备时初始化，我们将在后面的总结中详细描述一下 */

    Device_handle = (usb_dev_handle*)(g_list[fd].device_handle);

    if (Device_handle == NULL) {

        return NOT_OPENED_DEVICE;

}

/* 这个函数前面已经说过，在操作设备前是必须调用的, 0是指用默认的设备 */

usb_claim_interface(Device_handle, 0);

/* 发送数据，所用到的宏定义在usb.h可以找到，我列出来大家看一下

        #define USB_ENDPOINT_OUT       0x00

       #define USB_TYPE_CLASS     (0x01 << 5)

       #define USB_RECIP_INTERFACE 0x01

      

       #define HID_REPORT_SET       0x09 */

send_len = usb_control_msg(Device_handle,

USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,

                               HID_REPORT_SET,

                               0x300,

                               0,

                               send_data, 72, USB_TIMEOUT);

/* 发送数据有错误 */

if (send_len < 0) {

        return WRITE_REPORT;

}

if (send_len != 72) {

        return send_len;

}

/* 接受数据

       #define USB_ENDPOINT_IN         0x80

       #define USB_TYPE_CLASS          (0x01 << 5)

       #define USB_RECIP_INTERFACE        0x01

       #define HID_REPORT_GET          0x01

    */

recv_len = usb_control_msg(Device_handle,

USB_ENDPOINT_IN + USB_TYPE_CLASS + USB_RECIP_INTERFACE,

                               HID_REPORT_GET,

                               0x300,

                                 0,

                               recv_data, 72, USB_TIMEOUT);

                                                   

    if (recv_len < 0) {

        printf("failed to retrieve report from USB device!\n");

        return READ_REPORT;

    }

   

    if (recv_len != 72) {

        return recv_len;

    }

   

   

    /* 和usb_claim_interface对应 */

    usb_release_interface(RY2_handle, 0);

    memcpy(buffer72, recv_data, 72);

return SUCCESS;

}

3.4 关闭设备

假设我们定义的关闭设备的函数名是Device_Close()

/* 使用hid驱动关闭设备 */

int Device_Close()

{

    int handle;

   

handle = open(“hiddev0”, O_RDONLY);

/* 传统HID驱动调用,通过close()设备文件就可 */

close( handle );

}

/* 使用libusb关闭驱动 */

int Device_Close()

{

/* LIBUSB 驱动打开设备，这里写的是伪代码，不保证代码有用 */

struct usb_device*    udev;

usb_dev_handle*        device_handle;

device_handle = usb_open(udev);

/* libusb库使用usb_close关闭程序 */

usb_close(device_handle);

}

libusb的驱动框架

前面我们看了些主要的libusb函数的使用，这里我们把前面的内容归纳下：

一般的驱动应该都包含如下接口：

Device_Find(); /* 寻找设备接口 */

Device_Open(); /* 打开设备接口 */

Device_Write(); /* 写设备接口 */

Device_Read(); /* 读设备接口 */

Device_Close(); /* 关闭设备接口 */

具体代码如下：

#include <usb.h>

/* usb.h这个头文件是要包括的，里面包含了必须要用到的数据结构 */

/* 我们将一个设备的属性用一个结构体来概括 */

typedef struct

{

    struct usb_device*    udev;

    usb_dev_handle*        device_handle;

    /* 这里可以添加设备的其他属性，这里只列出每个设备要用到的属性 */

} device_descript;

/* 用来设置传输数据的时间延迟 */

#define USB_TIMEOUT     10000

/* 厂家ID 和产品 ID */

#define VENDOR_ID    0xffff    

#define PRODUCT_ID   0xffff

/* 这里定义数组来保存设备的相关属性，DEVICE_MINOR可以设置能够同时操作的设备数量，用全局变量的目的在于方便保存属性 */

#define DEVICE_MINOR 16

int     g_num;

device_descript g_list[ DEVICE_MINOR ];

/* 我们写个设备先找到设备，并把相关信息保存在 g_list 中 */

int Device_Find()

{

    struct usb_bus       *bus;

    struct usb_device *dev;

    g_num = 0;

    usb_find_busses();

    usb_find_devices();

   

    /* 寻找设备 */

    for (bus = usb_busses; bus; bus = bus->next) {

        for (dev = bus->devices; dev; dev = dev->next) {

if(dev->descriptor.idVendor==VENDOR_ID&& dev->descriptor.idProduct == PRODUCT_ID) {

                    /* 保存设备信息 */

                    if (g_num < DEVICE_MINOR) {

                     g_list[g_num].udev = dev;  

                     g_num ++;

                     }              

            }       

        }

    }

   

    return g_num;

}

/* 找到设备后，我们根据信息打开设备 */

int Device_Open()

{

    /* 根据情况打开你所需要操作的设备，这里我们仅列出伪代码 */

    if(g_list[g_num].udev != NULL) {
        g_list[g_num].device_handle = usb_open(g_list[g_num].udev);

}

}

/* 下面就是操作设备的函数了，我们就不列出来拉，大家可以参考上面的介绍 */

int DeviceWite(int handle)

{

    /* 填写相关代码，具体查看设备协议*/

}

int DeviceOpen(int handle)

{

    /* 填写相关代码，具体查看设备协议 */

}

/* 最后不要忘记关闭设备 */

void Device_close(int handle)

{

    /* 调用usb_close */

}