func main() {
flag.Parse()
// Only one context should be needed for an application. It should always be closed.
ctx := usb.NewContext()
defer ctx.Close()
// Debugging can be turned on; this shows some of the inner workings of the libusb package.
ctx.Debug(*debug)
// ListDevices is used to find the devices to open.
devs, err := ctx.ListDevices(func(desc *usb.Descriptor) bool {
// The usbid package can be used to print out human readable information.
fmt.Printf("%03d.%03d %s:%s %s\n", desc.Bus, desc.Address, desc.Vendor, desc.Product, usbid.Describe(desc))
fmt.Printf(" Protocol: %s\n", usbid.Classify(desc))
// The configurations can be examined from the Descriptor, though they can only
// be set once the device is opened. All configuration references must be closed,
// to free up the memory in libusb.
for _, cfg := range desc.Configs {
// This loop just uses more of the built-in and usbid pretty printing to list
// the USB devices.
fmt.Printf(" %s:\n", cfg)
for _, alt := range cfg.Interfaces {
fmt.Printf(" --------------\n")
for _, iface := range alt.Setups {
fmt.Printf(" %s\n", iface)
fmt.Printf(" %s\n", usbid.Classify(iface))
for _, end := range iface.Endpoints {
fmt.Printf(" %s\n", end)
}
}
}
fmt.Printf(" --------------\n")
}
// After inspecting the descriptor, return true or false depending on whether
// the device is "interesting" or not. Any descriptor for which true is returned
// opens a Device which is retuned in a slice (and must be subsequently closed).
return false
})
// All Devices returned from ListDevices must be closed.
defer func() {
for _, d := range devs {
d.Close()
}
}()
// ListDevices can occaionally fail, so be sure to check its return value.
if err != nil {
log.Fatalf("list: %s", err)
}
for _, dev := range devs {
// Once the device has been selected from ListDevices, it is opened
// and can be interacted with.
_ = dev
}
}
func (ctx *AntUsbContext) ListAntUsbDevices() ([]*AntUsbDevice, error) {
devs, err := ctx.usb.ListDevices(func(desc *usb.Descriptor) bool {
log4go.Debug("Found %03d.%03d %s:%s %s\n", desc.Bus, desc.Address, desc.Vendor, desc.Product, usbid.Describe(desc))
// The usbid package can be used to print out human readable information.
log4go.Debug(" Protocol: %s\n", usbid.Classify(desc))
// We are looking for the specific vendor and device
if desc.Vendor == ANT_VENDOR_ID && desc.Product == ANT_PRODUCT_ID {
log4go.Debug("This is an ANT device")
// The configurations can be examined from the Descriptor, though they can only
// be set once the device is opened. All configuration references must be closed,
// to free up the memory in libusb.
for _, cfg := range desc.Configs {
// This loop just uses more of the built-in and usbid pretty printing to list
// the USB devices.
log4go.Debug(" %s:\n", cfg)
for _, alt := range cfg.Interfaces {
log4go.Debug(" --------------\n")
for _, iface := range alt.Setups {
log4go.Debug("(iface) %s\n", iface)
log4go.Debug("(classify) %s\n", usbid.Classify(iface))
for _, end := range iface.Endpoints {
log4go.Debug("(end) %s\n", end)
log4go.Debug(" number: %s\n", end.Number())
log4go.Debug(" address: %s\n", end.Address)
log4go.Debug(" sync: %s\n", end.SynchAddress)
}
}
}
log4go.Debug(" --------------\n")
}
return true
}
return false
})
// ListDevices can occaionally fail, so be sure to check its return value.
if err != nil {
log4go.Critical("list: %s", err)
return nil, err
}
nDevices := len(devs)
channels := make([]*AntUsbDevice, nDevices)
for i := 0; i < len(devs); i++ {
usbDevice := devs[i]
channels[i], err = newAntUsbDevice(usbDevice)
if err != nil {
panic(err)
}
}
return channels, nil
}
func TestEnum(t *testing.T) {
c := NewContext()
defer c.Close()
c.Debug(0)
logDevice := func(t *testing.T, desc *Descriptor) {
t.Logf("%03d.%03d %s", desc.Bus, desc.Address, usbid.Describe(desc))
t.Logf("- Protocol: %s", usbid.Classify(desc))
for _, cfg := range desc.Configs {
t.Logf("- %s:", cfg)
for _, alt := range cfg.Interfaces {
t.Logf(" --------------")
for _, iface := range alt.Setups {
t.Logf(" - %s", iface)
t.Logf(" - %s", usbid.Classify(iface))
for _, end := range iface.Endpoints {
t.Logf(" - %s (packet size: %d bytes)", end, end.MaxPacketSize)
}
}
}
t.Logf(" --------------")
}
}
descs := []*Descriptor{}
devs, err := c.ListDevices(func(desc *Descriptor) bool {
logDevice(t, desc)
descs = append(descs, desc)
return true
})
defer func() {
for _, d := range devs {
d.Close()
}
}()
if err != nil {
t.Fatalf("list: %s", err)
}
if got, want := len(devs), len(descs); got != want {
t.Fatalf("len(devs) = %d, want %d", got, want)
}
for i := range devs {
if got, want := devs[i].Descriptor, descs[i]; got != want {
t.Errorf("dev[%d].Descriptor = %p, want %p", i, got, want)
}
}
}
func main() {
flag.Parse()
// Only one context should be needed for an application. It should always be closed.
ctx := usb.NewContext()
defer ctx.Close()
ctx.Debug(*debug)
log.Printf("Scanning for device %q...", *device)
// ListDevices is used to find the devices to open.
devs, err := ctx.ListDevices(func(desc *usb.Descriptor) bool {
if fmt.Sprintf("%s:%s", desc.Vendor, desc.Product) != *device {
return false
}
// The usbid package can be used to print out human readable information.
fmt.Printf(" Protocol: %s\n", usbid.Classify(desc))
// The configurations can be examined from the Descriptor, though they can only
// be set once the device is opened. All configuration references must be closed,
// to free up the memory in libusb.
for _, cfg := range desc.Configs {
// This loop just uses more of the built-in and usbid pretty printing to list
// the USB devices.
fmt.Printf(" %s:\n", cfg)
for _, alt := range cfg.Interfaces {
fmt.Printf(" --------------\n")
for _, iface := range alt.Setups {
fmt.Printf(" %s\n", iface)
fmt.Printf(" %s\n", usbid.Classify(iface))
for _, end := range iface.Endpoints {
fmt.Printf(" %s\n", end)
}
}
}
fmt.Printf(" --------------\n")
}
return true
})
// All Devices returned from ListDevices must be closed.
defer func() {
for _, d := range devs {
d.Close()
}
}()
// ListDevices can occaionally fail, so be sure to check its return value.
if err != nil {
log.Fatalf("list: %s", err)
}
if len(devs) == 0 {
log.Fatalf("no devices found")
}
dev := devs[0]
log.Printf("Connecting to endpoint...")
log.Printf("- %#v", dev.Descriptor)
ep, err := dev.OpenEndpoint(uint8(*config), uint8(*iface), uint8(*setup), uint8(*endpoint)|uint8(usb.ENDPOINT_DIR_IN))
if err != nil {
log.Fatalf("open: %s", err)
}
_ = ep
}