目录

USB中断传输

场景介绍

中断传输主要用于主机（Host）接收设备（Device）发送的数据包。设备的端点模式决定了接口支持中断读或中断写，这种传输方式适用于少量的、分散的、不可预测的数据类型的传输，鼠标、键盘和操纵杆等设备均属于这种类型，且此类设备的端点一般只支持中断读操作。

环境准备

[h2]环境要求

[h2]搭建环境

开发指导

[h2]接口说明

接口名 描述
usbSubmitTransfer(transfer: UsbDataTransferParams): void 异步传输接口（支持实时、批量、中断传输）。
usbCancelTransfer(transfer: UsbDataTransferParams): void 取消已提交的异步传输。

更多关于设备管理和传输模式的详细接口介绍，请查阅@ohos.usbManager。

[h2]开发步骤

主机（Host）连接设备（Device），通过usbSubmitTransfer接口进行数据传输。以下步骤描述了如何使用中断传输方式来传输数据：

以下示例代码只是使用中断传输方式来传输数据的必要流程，需要放入具体的方法中执行。在实际调用时，设备开发者需要遵循设备相关协议进行调用，确保数据的正确传输和设备的兼容性。

  1. 导入模块。

    // 导入usbManager模块
import { usbManager, BusinessError } from '@kit.BasicServicesKit';
import { JSON } from '@kit.ArkTS';

  2. 获取设备列表。

    // 获取设备列表。
let deviceList: usbManager.USBDevice[] = [];
try {
  deviceList = usbManager.getDevices();
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`USB getDevices failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] USB getDevices failed: code=' + errorObj.code + ', message=' + errorObj.message;
}

console.info(`deviceList: ${deviceList}`);
this.logInfo_ += '\n[INFO] deviceList: ' + JSON.stringify(deviceList);
if (deviceList === undefined || deviceList.length === 0) {
  console.error('deviceList is empty');
  this.logInfo_ += '\n[ERROR] deviceList is empty';
  return;
}
/*
  deviceList结构示例
  [
    {
      name: '1-1',
      serial: '',
      manufacturerName: '',
      productName: '',
      version: '',
      vendorId: 7531,
      productId: 2,
      clazz: 9,
      subClass: 0,
      protocol: 1,
      devAddress: 1,
      busNum: 1,
      configs: [
        {
          id: 1,
          attributes: 224,
          isRemoteWakeup: true,
          isSelfPowered: true,
          maxPower: 0,
          name: '1-1',
          interfaces: [
            {
              id: 0,
              protocol: 0,
              clazz: 9,
              subClass: 0,
              alternateSetting: 0,
              name: '1-1',
              endpoints: [
                {
                  address: 129,
                  attributes: 3,
                  interval: 12,
                  maxPacketSize: 4,
                  direction: 128,
                  number: 1,
                  type: 3,
                  interfaceId: 0,
                }
              ]
            }
          ]
        }
      ]
    }
  ]
 */
this.deviceList_ = deviceList;

  3. 获取设备操作权限。

    if (this.deviceList_ === undefined || this.deviceList_.length === 0) {
  console.error('deviceList is empty');
  this.logInfo_ += '\n[ERROR] deviceList is empty';
  return;
}
let deviceList: usbManager.USBDevice[] = this.deviceList_;
let deviceName: string = deviceList[0].name;
// 申请操作指定的device的操作权限。
usbManager.requestRight(deviceName).then((hasRight: boolean) => {
  console.info('usb device request right result: ' + hasRight);
  this.logInfo_ += '\n[INFO] usb device request right result: ' + JSON.stringify(hasRight);
}).catch((error: BusinessError) => {
  console.error(`usb device request right failed : code=${error.code}, message=${error.message}`);
  this.logInfo_ += '\n[ERROR] usb device request right failed: code=' + error.code + ', message=' + error.message;
});

  4. 获取通过中断传输读取数据的端点。

    if (this.deviceList_ === undefined || this.deviceList_.length === 0) {
  console.error('deviceList is empty');
  this.logInfo_ += '\n[ERROR] deviceList is empty';
  return;
}
let usbDevice: usbManager.USBDevice = this.deviceList_[0];
try {
  if (!usbManager.hasRight(usbDevice.name)) {
    console.error('permission denied');
    this.logInfo_ += '\n[ERROR] permission denied';
    return;
  }
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`USB hasRight failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] USB hasRight failed: code=' + errorObj.code + ', message=' + errorObj.message;
  return;
}

let devicePipe: usbManager.USBDevicePipe;
try {
  devicePipe = usbManager.connectDevice(usbDevice);
  if (!devicePipe) {
    console.error('connectDevice failed, pipe is undefined');
    this.logInfo_ += '\n[ERROR] connectDevice failed, pipe is undefined';
    return;
  }
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`USB connectDevice failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] USB connectDevice failed: code=' + errorObj.code + ', message=' + errorObj.message;
  return;
}

let usbConfigs: usbManager.USBConfiguration[] = usbDevice.configs;
let usbInterfaces: usbManager.USBInterface[] = [];
let usbInterface: usbManager.USBInterface | undefined = undefined;
let usbEndpoints: usbManager.USBEndpoint[] = [];
let usbEndpoint: usbManager.USBEndpoint | undefined = undefined;
for (let i = 0; i < usbConfigs?.length; i++) {
  usbInterfaces = usbConfigs[i]?.interfaces;
  for (let j = 0; j < usbInterfaces?.length; j++) {
    usbEndpoints = usbInterfaces[j]?.endpoints;
    usbEndpoint = usbEndpoints?.find((value) => {
      return value.direction === 128 && value.type === usbManager.UsbEndpointTransferType.TRANSFER_TYPE_INTERRUPT;
    })
    if (usbEndpoint !== undefined) {
      usbInterface = usbInterfaces[j];
      break;
    }
  }
}
if (usbEndpoint === undefined) {
  console.error(`get usbEndpoint error`)
  this.logInfo_ += '\n[ERROR] get usbEndpoint error';
  return;
}

  5. 连接设备，注册通信接口。

    // 注册通信接口，注册成功返回0，注册失败返回其他错误码。
try {
  let claimInterfaceResult: number = usbManager.claimInterface(devicePipe, usbInterface, true);
  if (claimInterfaceResult !== 0) {
    console.error(`claimInterface error = ${claimInterfaceResult}`)
    this.logInfo_ += '\n[ERROR] claimInterface error = ' + JSON.stringify(claimInterfaceResult);
    return;
  }
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`USB claimInterface failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] USB claimInterface failed: code=' + errorObj.code + ', message=' + errorObj.message;
  return;
}

  6. 传输数据。

    let transferParams: usbManager.UsbDataTransferParams | undefined = undefined;
try {
  // 通信接口注册成功，传输数据
  transferParams = {
    devPipe: devicePipe,
    flags: usbManager.UsbTransferFlags.USB_TRANSFER_SHORT_NOT_OK,
    endpoint: usbEndpoint.address,
    type: usbManager.UsbEndpointTransferType.TRANSFER_TYPE_INTERRUPT,
    timeout: 2000,
    length: 10,
    callback: (err: BusinessError , callBackData: usbManager.SubmitTransferCallback) => {
      if (err) {
        console.error(`transfer error: ${err}`);
        this.logInfo_ += '\n[ERROR] transfer error: ' + JSON.stringify(err);
        return;
      }
      console.info(`callBackData = ${callBackData}`);
      this.logInfo_ += '\n[INFO] callBackData = ' + JSON.stringify(callBackData);
      console.info(`transfer success,result = ${transferParams?.buffer}`);
      this.logInfo_ += '\n[INFO] transfer success,result = ' + JSON.stringify(transferParams?.buffer);
    },
    userData: new Uint8Array(10),
    buffer: new Uint8Array(10),
    isoPacketCount: 2,
  };
  usbManager.usbSubmitTransfer(transferParams);
  console.info('USB transfer request submitted.');
  this.logInfo_ += '\n[INFO] USB transfer request submitted.';
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`USB transfer failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] USB transfer failed: code=' + errorObj.code + ', message=' + errorObj.message;
}

  7. 取消传输，释放接口，关闭设备消息控制通道。

    try {
  if (transferParams) {
    usbManager.usbCancelTransfer(transferParams);
  }
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`usbCancelTransfer failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] usbCancelTransfer failed: code=' + errorObj.code + ', message=' + errorObj.message;
}
try {
  usbManager.releaseInterface(devicePipe, usbInterface);
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`releaseInterface failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] releaseInterface failed: code=' + errorObj.code + ', message=' + errorObj.message;
}
try {
  usbManager.closePipe(devicePipe);
} catch (error) {
  let errorObj: BusinessError = error as BusinessError;
  console.error(`closePipe failed: code=${errorObj.code}, message=${errorObj.message}`);
  this.logInfo_ += '\n[ERROR] closePipe failed: code=' + errorObj.code + ', message=' + errorObj.message;
}

[h2]调测验证

  1. 主机端通过USB接口连接支持中断传输的终端设备（鼠标、键盘等）。
  2. 执行上述代码。
  3. log中搜索关键字transfer success，表示中断传输接口调用成功。