rik/jlibusb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- structural changes (Device as instance)

Browse Source 
git-svn-id: https://svn.code.sf.net/p/libusbjava/code/trunk@100 94ad28fe-ef68-46b1-9651-e7ae4fcf1c4c
This commit is contained in:
schlaepfer
2006-02-17 17:04:04 +00:00
parent 718f9fb4c5
commit 27bfb3683f
8 changed files with 234 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
mcdp/src/ch/ntb/usb/Device.java
View File

@@ -5,23 +5,46 @@ import java.util.logging.Level;
import ch.ntb.usb.logger.LogUtil;
import ch.ntb.usb.logger.UsbLogger;
/**
* This class represents an USB device.<br>
* To get an instance of an USB device use <code>USB.getDevice(...)</code>.
*
* @author schlaepfer
*
*/
public class Device {
private static UsbLogger logger = LogUtil.ch_ntb_usb;
private static final int TIMEOUT_ERROR_CODE = -116;
public int MAX_DATA_SIZE = USB.MAX_DATA_SIZE;
private int maxPacketSize;
private int idVendor, idProduct, configuration, interface_, altinterface;
private int usb_dev_handle;
Device(short idVendor, short idProduct) {
protected Device(short idVendor, short idProduct) {
maxPacketSize = -1;
this.idVendor = idVendor;
this.idProduct = idProduct;
}
/**
* Opens the device and claims the specified configuration, interface and
* altinterface.<br>
* First the bus is enumerated. If the device is found its descriptors are
* read and the <code>maxPacketSize</code> value is updated. If no
* endpoints are found in the descriptors an exception is thrown.
*
* @param configuration
* the desired configuration
* @param interface_
* the desired interface
* @param altinterface
* the desired alternative interface
* @throws USBException
*/
public void open(int configuration, int interface_, int altinterface)
throws USBException {
this.configuration = configuration;
@@ -44,6 +67,9 @@ public class Device {
throw new USBException("LibusbWin.usb_get_busses(): "
+ LibusbWin.usb_strerror());
}
maxPacketSize = -1;
// search for device
while (bus != null) {
Usb_Device dev = bus.devices;
@@ -59,6 +85,25 @@ public class Device {
+ LibusbWin.usb_strerror());
} else {
usb_dev_handle = res;
// get endpoint wMaxPacketSize
Usb_Config_Descriptor[] confDesc = dev.config;
for (int i = 0; i < confDesc.length; i++) {
Usb_Interface[] int_ = confDesc[i].interface_;
for (int j = 0; j < int_.length; j++) {
Usb_Interface_Descriptor[] intDesc = int_[j].altsetting;
for (int k = 0; k < intDesc.length; k++) {
Usb_Endpoint_Descriptor[] epDesc = intDesc[k].endpoint;
for (int l = 0; l < epDesc.length; l++) {
Math.max(epDesc[l].wMaxPacketSize,
maxPacketSize);
}
}
}
}
if (maxPacketSize <= 0) {
throw new USBException(
"No USB endpoints found. Check the device configuration");
}
}
}
dev = dev.next;
@@ -71,21 +116,21 @@ public class Device {
+ " and idProduct 0x"
+ Integer.toHexString(idProduct & 0xFFFF) + " not found");
}
USB.claim_interface(usb_dev_handle, configuration, interface_,
altinterface);
claim_interface(usb_dev_handle, configuration, interface_, altinterface);
}
public void close() throws USBException {
if (usb_dev_handle <= 0) {
throw new USBException("invalid device handle");
}
USB.release_interface(usb_dev_handle, interface_);
release_interface(usb_dev_handle, interface_);
if (LibusbWin.usb_close(usb_dev_handle) < 0) {
usb_dev_handle = 0;
throw new USBException("LibusbWin.usb_close: "
+ LibusbWin.usb_strerror());
}
usb_dev_handle = 0;
maxPacketSize = -1;
logger.info("device closed");
}
@@ -107,8 +152,23 @@ public class Device {
logger.info("device reset");
}
public int bulkwrite(int out_ep_address, byte[] data, int length, int timeout)
throws USBException {
/**
* Write data to the device using a bulk transfer.<br>
*
* @param out_ep_address
* endpoint address to write to
* @param data
* data to write to this endpoint
* @param length
* length of the data
* @param timeout
* amount of time in ms the device will try to send the data
* until a timeout exception is thrown
* @return the actual number of bytes written
* @throws USBException
*/
public int bulkwrite(int out_ep_address, byte[] data, int length,
int timeout) throws USBException {
if (usb_dev_handle <= 0) {
throw new USBException("invalid device handle");
}
@@ -118,8 +178,8 @@ public class Device {
if (length <= 0) {
throw new USBException("size must be > 0");
}
int lenWritten = LibusbWin.usb_bulk_write(usb_dev_handle, out_ep_address,
data, length, timeout);
int lenWritten = LibusbWin.usb_bulk_write(usb_dev_handle,
out_ep_address, data, length, timeout);
if (lenWritten < 0) {
if (lenWritten == TIMEOUT_ERROR_CODE) {
throw new USBTimeoutException("LibusbWin.usb_bulk_write: "
@@ -141,6 +201,19 @@ public class Device {
return lenWritten;
}
/**
* @param in_ep_address
* endpoint address to read from
* @param data
* data buffer for the data to be read
* @param size
* the maximum requested data size
* @param timeout
* amount of time in ms the device will try to receive data until
* a timeout exception is thrown
* @return the actual number of bytes read
* @throws USBException
*/
public int bulkread(int in_ep_address, byte[] data, int size, int timeout)
throws USBException {
if (usb_dev_handle <= 0) {
@@ -152,8 +225,8 @@ public class Device {
if (size <= 0) {
throw new USBException("size must be > 0");
}
int lenRead = LibusbWin.usb_bulk_read(usb_dev_handle, in_ep_address, data,
size, timeout);
int lenRead = LibusbWin.usb_bulk_read(usb_dev_handle, in_ep_address,
data, size, timeout);
if (lenRead < 0) {
if (lenRead == TIMEOUT_ERROR_CODE) {
throw new USBTimeoutException("LibusbWin.usb_bulk_read: "
@@ -175,28 +248,112 @@ public class Device {
return lenRead;
}
/**
* Claim an interface to send and receive USB data.
*
* @param usb_dev_handle
* the handle of the device <b>(MUST BE VALID)</b>
* @param configuration
* the configuration to use
* @param interface_
* the interface to claim
* @param altinterface
* the alternative interface to use
* @throws USBException
* throws an USBException if the action fails
*/
private void claim_interface(int usb_dev_handle, int configuration,
int interface_, int altinterface) throws USBException {
if (LibusbWin.usb_set_configuration(usb_dev_handle, configuration) < 0) {
throw new USBException("LibusbWin.usb_set_configuration: "
+ LibusbWin.usb_strerror());
}
if (LibusbWin.usb_claim_interface(usb_dev_handle, interface_) < 0) {
throw new USBException("LibusbWin.usb_claim_interface: "
+ LibusbWin.usb_strerror());
}
if (LibusbWin.usb_set_altinterface(usb_dev_handle, altinterface) < 0) {
throw new USBException("LibusbWin.usb_set_altinterface: "
+ LibusbWin.usb_strerror());
}
logger.info("interface claimed");
}
/**
* Release a previously claimed interface.
*
* @param dev_handle
* the handle of the device <b>(MUST BE VALID)</b>
* @param interface_
* the interface to claim
* @throws USBException
* throws an USBException if the action fails
*/
private void release_interface(int dev_handle, int interface_)
throws USBException {
if (LibusbWin.usb_release_interface(dev_handle, interface_) < 0) {
throw new USBException("LibusbWin.usb_release_interface: "
+ LibusbWin.usb_strerror());
}
logger.info("interface released");
}
/**
* @return the product ID of the device.
*/
public int getIdProduct() {
return idProduct;
}
/**
* @return the vendor ID of the device.
*/
public int getIdVendor() {
return idVendor;
}
/**
* @return the alternative interface. This value is only valid after opening
* the device.
*/
public int getAltinterface() {
return altinterface;
}
/**
* @return the current configuration used. This value is only valid after
* opening the device.
*/
public int getConfiguration() {
return configuration;
}
/**
* @return the current interface. This value is only valid after opening the
* device.
*/
public int getInterface() {
return interface_;
}
/**
* @return the current device handle. This value is only valid after opening
* the device.
*/
public int getUsb_dev_handle() {
return usb_dev_handle;
}
/**
* Returns the maximum packet size in bytes which is allowed to be
* transmitted at once.<br>
* The value is determined by reading the endpoint descriptor(s) when
* opening the device. It is invalid before the device is opened!
*
* @return the maximum packet size
*/
public int getMaxPacketSize() {
return maxPacketSize;
}
}