一、准备

1.pom依赖 usb4java

<dependency>
    <groupId>org.usb4java</groupId>
    <artifactId>usb4java-javax</artifactId>
    <version>1.2.0</version>
</dependency>

2.添加配置文件

如上图，添加javax.usb.properties配置文件在resources下，内容仅一行

javax.usb.services = org.usb4java.javax.Services

3.确定设备的PID和VID

若已知道PID和VID则跳过本步骤
计算机->管理->设备管理器
在通用串行总线中找到指定的USB设备

可以通过插拔观察设备的增删来确定是哪一个设备。

查找到设备，右击->属性
在详细菜单一栏，选择硬件ID一项

这里十六进制的VID和PID就出来了

4. 安装libusbK

libusbK官网

5.下载zadig替换设备驱动

usb设备默认是windows自带驱动，这个驱动是不可开发访问的，会报出下列错误

USB error 12: Can't open device Bus 001 Device 012: ID 28e9:0289: Operation not supported or unimplemented on this platform

需要下载zadig对驱动进行替换，下面两个下载链接，可以选择一个下载

Zadig Downloads
zadig-2.3

下载后打开zadig，在options菜单中选择list all devices 列出所有设备，选择自己的USB设备

设备选中后，记得后面的驱动用上下小箭头切换到libusb，然后replace driver 替换设备驱动为libusb，这样才能够开发使用。

二、Java开发

1. 查找USB设备

public static void main(String[] args){
	UsbDevice device = findDevice(UsbHostManager.getUsbServices().getRootUsbHub(), vid, pid);
}

public UsbDevice findDevice(UsbHub hub, int vid, int pid) throws UsbException {
    List<UsbDevice> list = hub.getAttachedUsbDevices();
    for (UsbDevice device:list) {
      UsbDeviceDescriptor desc = device.getUsbDeviceDescriptor();
      if (desc.idVendor() == vid && desc.idProduct() == pid) {
        return device;
      }
      if (device.isUsbHub()) {
        device= findDevice((UsbHub) device, vid, pid);
        if(device!=null){
          return device;
        }
      }
    }
    return null;
  }

2. 请求打开设备并接收数据

	// 初始化设备，请求获取、打开并接收数据
	public void initUseDevice(UsbDevice device){
	 if (device.getActiveUsbConfiguration().getUsbInterfaces().size() > 0) {
        iface = (UsbInterface) device.getActiveUsbConfiguration().getUsbInterfaces().get(0);
      }
      if (iface != null) {
        try {
          if(iface.isClaimed()==false){
            iface.claim(usbInterface -> true);
          }
          connectSuccess=true;
          UsbEndpoint receivedUsbEndpoint, sendUsbEndpoint;
          sendUsbEndpoint = (UsbEndpoint) iface.getUsbEndpoints().get(0);
          // 注意管道区别，OUT输usb设备输出数据的管道
          if (!sendUsbEndpoint.getUsbEndpointDescriptor().toString().contains("OUT")) {
            receivedUsbEndpoint = sendUsbEndpoint;
            sendUsbEndpoint = (UsbEndpoint) iface.getUsbEndpoints().get(1);
          } else {
            receivedUsbEndpoint = (UsbEndpoint) iface.getUsbEndpoints().get(1);
          }
          //发送
          UsbPipe sendUsbPipe = sendUsbEndpoint.getUsbPipe();
          if(sendUsbPipe.isOpen()==false){
            sendUsbPipe.open();
          }
          //接收
          final UsbPipe receivedUsbPipe = receivedUsbEndpoint.getUsbPipe();
          if(receivedUsbPipe.isOpen()==false){
            receivedUsbPipe.open();
          }
          // 接收操作放到子线程实现异步回调
          new Thread(() -> {
            try {
              receivedMassge(receivedUsbPipe);
            } catch (Exception e) {
              e.printStackTrace();
            }
          }).start();
        } catch (Exception e) {
          //e.printStackTrace();
        }finally {
        	// 最后一定要关闭usb设备释放资源
          iface.release();
        }
      }
   }

	// 轮询读取USB发送回来的数据
  private void receivedMassge(UsbPipe usbPipe) throws Exception {
    byte[] buffer = new byte[64];
    int length;
    while (true) {
      length = usbPipe.syncSubmit(buffer);
      for (int i = 0; i < length; i++) {
        // do something
      }
    }
  }

3.发送数据到USB设备

	// 发送数据
  public int send(UsbPipe usbPipe,byte[] buffer) throws UsbException {
    return usbPipe.syncSubmit(buffer);//阻塞
    //usbPipe.asyncSubmit(buff);//非阻塞
  }

三、开发注意事项

1.报错操作不支持

在开发过程中遇到了一个错误 USB error 12: Can’t open device Bus 001 Device 012: ID 28e9:0289: Operation not supported or unimplemented on this platform
这是在调用claim时报错的，原因是因为直接在windows原驱动上开发，使用zadig替换驱动为libusb后即可。

2. 报错USB无权限

在项目启动后，若报错Access denied (insufficient permissions)，这是因为未安装libusbK，在步骤1.4中安装libusbK即可。

3.替换驱动后

替换为libusb驱动后，该设备就无法再设备管理器上找到，只能使用libusb（即我们开发方式）访问usb设备，切记！！！

4.关于usb4java

有文章说usb4java仅支持usb2.0的开发，对3.0接口容易出现插拔的bug，关于这点还未验证，不过的确usb4java是相对比较早期的开发库，而且java本身对底层设备的访问支持就不是很良好，有条件还是使用c或c++写个dll库给java使用JNA方式调用更靠谱。

最后

有兴趣的小伙伴可以扫码关注公众号【暴走的怪兽君】，常更新Java干货资讯，免费提供大量教程和工具下载。

                            java使用usb4java连接USB 实现数据通讯 

最近公司接到一个项目，需要连接usb获取/写入数据到数显盒。 查阅了很多资料，发现可以使用usb4java 来实现，然后我就来填坑了！  po代码不易，请各位小伙伴多多关注！

先上代码，代码我并没有优化，有可能有很多函数没有用到但是还写在上面，复制的时候删掉即可！只希望对大家有所帮助！

首先你的POM里需要这个 包 

<dependency>
   <groupId>org.usb4java</groupId>
   <artifactId>usb4java-javax</artifactId>
   <version>1.2.0</version>
</dependency>

其次你需要在你的项目中建立一个 javax.usb.properties 静态文件 内容就一句：

javax.usb.services = org.usb4java.javax.Services  
写好保存即可。

前期准备就完成了！

创建一个java类 xxxx.java

写一个连接方法：

/**
*
* TODO: 连接设备
*@author Zck
*@date 2020/5/20 15:48
*
*/
public Map<String,Object> linkDevice() throws Exception{

    Map<String,Object> mainMap = new HashMap<>();

    mainMap.put("code", usbConnectCSS.USB_CONNECT_TRUE.getCode());

    UsbDevice device = null;
   //去搜索特定的设备！需要用到设备的VID PID  自己百度怎么看！
    if (device == null) {

        device = findDevice(UsbHostManager.getUsbServices()
                .getRootUsbHub());

    }

    if (device == null) {

        mainMap.put("code", usbConnectCSS.USB_CONNECT_NOT_HAVE.getCode());
        mainMap.put("msg", usbConnectCSS.USB_CONNECT_NOT_HAVE.getInfo());
        System.out.println("设备未找到！");
        return mainMap;

    }
    UsbConfiguration configuration = device.getActiveUsbConfiguration();

    UsbInterface iface = null;

    if (configuration.getUsbInterfaces().size() > 0) {
        iface = configuration.getUsbInterface((byte) 0);
    } else {
        //未知错误 没有源码读不懂
        mainMap.put("code",usbConnectCSS.USB_CONNECT_NOT_KNOW.getCode());
        mainMap.put("msg", usbConnectCSS.USB_CONNECT_NOT_KNOW.getInfo());

        return mainMap;
    }
    //todo:claim连接必须打开 claim  。这里 如果设备是连接状态我们把他关闭。因为我这个项目是点对点透传txt
    if (iface.isClaimed()){
        iface.release();

    }
//再开启！
    iface.claim(new UsbInterfacePolicy()
    {
        @Override
        public boolean forceClaim(UsbInterface usbInterface)
        {
            return true;
        }
    });

    /*CacheUtils.put("iface", iface);*/
    mainMap.put("iface", iface);
    return mainMap;
}

/**
 * @Description 搜索特定设备
 **/
public UsbDevice findDevice(UsbHub hub)
{
    UsbDevice device = null;
    List list = (List) hub.getAttachedUsbDevices();
    for (int i = 0;i<list.size();i++)
    {
        device = (UsbDevice)list.get(i);
        UsbDeviceDescriptor desc = device.getUsbDeviceDescriptor();
        System.out.println(i+"___"+desc.idVendor()+"___"+desc.idProduct());
        if (desc.idVendor() == idVendor && desc.idProduct() == idProduct) {return device;}
        if (device.isUsbHub())
        {
            device = findDevice((UsbHub) device);
            if (device != null) return device;
        }
    }
    return null;
}

/**
*
* TODO: 通讯入口
*@author Zck
*@date 2020/5/21 10:29
*map参数 中包含 拼装头（类型，读写，等） data:数据主体
*/
public   static  Map<String,Object> communicate(Map<String,Object> map){
    try {
        /*String data = String.valueOf(map.get("data"));
        map.remove("data");*/
        /**获取usb通讯通道*/
        Map<String,Object> returnMap = new UsbUntil().useUsb(map);

        /**如果code不是连接成功返回错误代码*/
        if (!returnMap.get("code").equals(usbConnectCSS.USB_CONNECT_TRUE.getCode())){
            return returnMap;
        }

        /**连接成功，获取sendUsbPipe*/
        UsbPipe sendUsbPipe = (UsbPipe)returnMap.get("sendUsbPipe");
        
        /**校验sendUsbPipe是否为空*/
        if (sendUsbPipe != null) {
            /**可能有多个包用list装载*/
           // List<Object> list = new ArrayList<>();

            /**先判断读还是写,大家可以无视这些判断,这是我自己的业务逻辑*/
            if (map.get("ReadOrWrite").equals(UsbTypeConstants.WRITE.getCode())){
                //时间不会超过 64字节所以不用考虑包数
                if (map.get("type").equals(UsbTypeConstants.WRITE_TYPE_TIME.getCode())){
                    /**不为空new一个64位字节*/
                    byte[] buff = new byte[64];
                    buff[0] = (byte)0xAA;

                   /**16进制数据 64位发送一次，这里我删除了一点我的逻辑代码。 把buff函数换成你要发送的16进制数据包就行了*/
                    Log.info("进入sendMassge发送数据");
                    sendMassge(sendUsbPipe, buff);

                } 
            }


        } else {
            returnMap.put("code", usbConnectCSS.USB_CONNECT_NOT_KNOW.getCode());
            returnMap.put("msg", usbConnectCSS.USB_CONNECT_NOT_KNOW.getInfo());
        }

        return returnMap;

    } catch (Exception e) {
        CacheUtils.remove("xxxxx","routeData");
        CacheUtils.remove("thisRouteDataFlag","thisRouteDataFlag");
        CacheUtils.remove("xxxxxx","switchData");
        CacheUtils.remove("thisSwitchDataFlag","thisSwitchDataFlag");
        e.printStackTrace();
        Map<String,Object> eroMap = new HashMap<>();
        eroMap.put("code",usbConnectCSS.USB_CONNECT_NOT_OPEN.getCode());
        eroMap.put("msg",usbConnectCSS.USB_CONNECT_NOT_OPEN.getInfo());
        return eroMap;
        }

}

public  Map<String,Object> useUsb(Map<String,Object> map) throws Exception{
    //连接设备
    Map<String,Object> ifaceMap = new HashMap<>();

        ifaceMap = linkDevice();
    UsbInterface iface = (UsbInterface)ifaceMap.get("iface");
     //大家可以无视判断和 map里的参数
        if (!ifaceMap.get("code").equals(usbConnectCSS.USB_CONNECT_TRUE.getCode())){
            return ifaceMap;
        }






    if (iface == null) {
        ifaceMap.put("code",usbConnectCSS.USB_CONNECT_IS_NULL.getCode());
        ifaceMap.put("msg",usbConnectCSS.USB_CONNECT_IS_NULL.getInfo());
        return ifaceMap;
    }
    UsbEndpoint receivedUsbEndpoint,sendUsbEndpoint;

    sendUsbEndpoint = (UsbEndpoint)iface.getUsbEndpoints().get(0);
    if (!sendUsbEndpoint.getUsbEndpointDescriptor().toString().contains("OUT")) {
        receivedUsbEndpoint = sendUsbEndpoint;
        sendUsbEndpoint = (UsbEndpoint)iface.getUsbEndpoints().get(1);
    } else {
        receivedUsbEndpoint = (UsbEndpoint)iface.getUsbEndpoints().get(1);
    }
    //发送：
    UsbPipe sendUsbPipe =  sendUsbEndpoint.getUsbPipe();
    //打开发送通道
    if (sendUsbPipe.isOpen()){
        sendUsbPipe.close();
        sendUsbPipe.open();
      

    } else {
        sendUsbPipe.open();
    }

    //接收
     final UsbPipe receivedUsbPipe =  receivedUsbEndpoint.getUsbPipe();
  
//打开接收通道
    if (!receivedUsbPipe.isOpen()){
      
        receivedUsbPipe.open();
    }
  
    Thread th=  new Thread(new Runnable() {
        public  void run() {
            try {
          //这里不需要map参数，因为业务问题所以我加入了map
                receivedMassge(receivedUsbPipe,map);


            } catch (Exception e) {


                e.printStackTrace();

                return;
            } finally {
                receivedUsbPipe.abortAllSubmissions();
                try {
                    receivedUsbPipe.close();
                }catch (Exception e){

                }
            }

        }
    });
    th.start();
    if (sendUsbPipe.isOpen()){
        ifaceMap.put("sendUsbPipe", sendUsbPipe);

    }
   //这里我监听了线程是否跑完了，所以 map里放了 th
    ifaceMap.put("th",th);
    return ifaceMap;
}

public int syncSubmit(final byte[] data,UsbPipe usbPipe) throws UsbException
{
    final UsbIrp irp = usbPipe.asyncSubmit(data);
   //这里一定要注意，若果你设置的接收时间太短了，你硬件还没反应过来通讯就结束了。建议设置为15秒。
    irp.waitUntilComplete(30000);
    if (irp.isUsbException()) throw irp.getUsbException();
    return irp.getActualLength();
}

public  void  receivedMassge(UsbPipe usbPipe,Map<String,Object> map) throws Exception{
//无视这个map

byte[] b = new byte[64];
int length = 0;
length = syncSubmit(b,usbPipe);//返回数据的长度，我们规定的协议是64位，这里我没有写死循环来监听到底传送完了没有，因为我们的模式是我发一个数据，盒子返回给我一个数据

//这里就是硬件返回给你的数据自己进行10进制处理吧！
for (int i = 0; i < length; i++) {
    System.out.print(Byte.toUnsignedInt(b[i])+" ");
}

}

1、最近在做一个java与usb通信的项目，在我原来的理解中，java是不能读取电脑底层设备信息的，所有就让人用C写一个中间程序来传递数据。但是最近在查询资料的时候，看到usb4java是写好的jar包，可以用java读取硬件设备，虽然最终不知道是什么原因一直无法读取我公司的硬件设备，但是可以查看到鼠标、键盘、手机是否连接usb。做一个参考吧。

2、首先需要查看usb连接的idVendor和idProduct；java需要根据这个来判断是哪个usb

（1）我的电脑右键--管理--设备管理器

(2)点击要查看的设备，点击详细信息，选择硬件ID；下图的idVendor=12D1；idProduct=1082的16进制数

3、代码：

（1）引入的包：

          <dependency>
            <groupId>org.usb4java</g