package main import ( "flag" "fmt" "log" "github.com/kylelemons/gousb/usb" "github.com/kylelemons/gousb/usbid" ) var ( debug = flag.Int("debug", 0, "libusb debug level (0..3)") ) 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\n", desc.Bus, desc.Address, 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 { 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 } }