コード例 #1
0
ファイル: display.go プロジェクト: MendelGusmao/coldpixels
func (s *Display) OpenDevice() error {
	devices, err := usb.NewContext().ListDevices(func(desc *usb.Descriptor) bool {
		return desc.Vendor == usb.ID(vendorID) && desc.Device == usb.BCD(deviceID)
	})

	if err != nil {
		return err
	}

	if len(devices) == 0 {
		return fmt.Errorf("no lcd detected")
	}

	s.device = devices[0]

	return nil
}
コード例 #2
0
ファイル: cm160.go プロジェクト: diocles/cm160
func isCM160(desc *usb.Descriptor) bool {
	return desc.Vendor == usb.ID(CM160_VENDOR) &&
		desc.Product == usb.ID(CM160_PRODUCT)
}
コード例 #3
0
ファイル: parse.go プロジェクト: kylelemons/gousb
// ParseIDs parses and returns mappings from the given reader.  In general, this
// should not be necessary, as a set of mappings is already embedded in the library.
// If a new or specialized file is obtained, this can be used to retrieve the mappings,
// which can be stored in the global Vendors and Classes map.
func ParseIDs(r io.Reader) (map[usb.ID]*Vendor, map[uint8]*Class, error) {
	vendors := make(map[usb.ID]*Vendor, 2800)
	classes := make(map[uint8]*Class) // TODO(kevlar): count

	split := func(s string) (kind string, level int, id uint64, name string, err error) {
		pieces := strings.SplitN(s, "  ", 2)
		if len(pieces) != 2 {
			err = fmt.Errorf("malformatted line %q", s)
			return
		}

		// Save the name
		name = pieces[1]

		// Parse out the level
		for len(pieces[0]) > 0 && pieces[0][0] == '\t' {
			level, pieces[0] = level+1, pieces[0][1:]
		}

		// Parse the first piece to see if it has a kind
		first := strings.SplitN(pieces[0], " ", 2)
		if len(first) == 2 {
			kind, pieces[0] = first[0], first[1]
		}

		// Parse the ID
		i, err := strconv.ParseUint(pieces[0], 16, 16)
		if err != nil {
			err = fmt.Errorf("malformatted id %q: %s", pieces[0], err)
			return
		}
		id = i

		return
	}

	// Hold the interim values
	var vendor *Vendor
	var device *Product

	parseVendor := func(level int, raw uint64, name string) error {
		id := usb.ID(raw)

		switch level {
		case 0:
			vendor = &Vendor{
				Name: name,
			}
			vendors[id] = vendor

		case 1:
			if vendor == nil {
				return fmt.Errorf("product line without vendor line")
			}

			device = &Product{
				Name: name,
			}
			if vendor.Product == nil {
				vendor.Product = make(map[usb.ID]*Product)
			}
			vendor.Product[id] = device

		case 2:
			if device == nil {
				return fmt.Errorf("interface line without device line")
			}

			if device.Interface == nil {
				device.Interface = make(map[usb.ID]string)
			}
			device.Interface[id] = name

		default:
			return fmt.Errorf("too many levels of nesting for vendor block")
		}

		return nil
	}

	// Hold the interim values
	var class *Class
	var subclass *SubClass

	parseClass := func(level int, raw uint64, name string) error {
		id := uint8(raw)

		switch level {
		case 0:
			class = &Class{
				Name: name,
			}
			classes[id] = class

		case 1:
			if class == nil {
				return fmt.Errorf("subclass line without class line")
			}

			subclass = &SubClass{
				Name: name,
			}
			if class.SubClass == nil {
				class.SubClass = make(map[uint8]*SubClass)
			}
			class.SubClass[id] = subclass

		case 2:
			if subclass == nil {
				return fmt.Errorf("protocol line without subclass line")
			}

			if subclass.Protocol == nil {
				subclass.Protocol = make(map[uint8]string)
			}
			subclass.Protocol[id] = name

		default:
			return fmt.Errorf("too many levels of nesting for class")
		}

		return nil
	}

	// TODO(kevlar): Parse class information, etc
	//var class *Class
	//var subclass *SubClass

	var kind string

	lines := bufio.NewReaderSize(r, 512)
parseLines:
	for lineno := 0; ; lineno++ {
		b, isPrefix, err := lines.ReadLine()
		switch {
		case err == io.EOF:
			break parseLines
		case err != nil:
			return nil, nil, err
		case isPrefix:
			return nil, nil, fmt.Errorf("line %d: line too long", lineno)
		}
		line := string(b)

		if len(line) == 0 || line[0] == '#' {
			continue
		}

		k, level, id, name, err := split(line)
		if err != nil {
			return nil, nil, fmt.Errorf("line %d: %s", lineno, err)
		}
		if k != "" {
			kind = k
		}

		switch kind {
		case "":
			err = parseVendor(level, id, name)
		case "C":
			err = parseClass(level, id, name)
		}
		if err != nil {
			return nil, nil, fmt.Errorf("line %d: %s", lineno, err)
		}
	}

	return vendors, classes, nil
}