build: upgrade periph.io dependencies

vendor/periph.io/x/conn/v3/conn.go

@@ -0,0 +1,103 @@
+// Copyright 2016 The Periph Authors. All rights reserved.
+// Use of this source code is governed under the Apache License, Version 2.0
+// that can be found in the LICENSE file.
+
+package conn
+
+import "strconv"
+
+// Resource is a basic resource (like a gpio pin) or a device.
+type Resource interface {
+	// String returns a human readable identifier representing this resource in a
+	// descriptive way for the user. It is the same signature as fmt.Stringer.
+	String() string
+	// Halt stops the resource.
+	//
+	// Unlike a Conn, a Resource may not be closable, On the other hand, a
+	// resource can be halted. What halting entails depends on the resource
+	// device but it should stop motion, sensing loop, light emission or PWM
+	// output and go back into an inert state.
+	Halt() error
+}
+
+// Duplex declares whether communication can happen simultaneously both ways.
+//
+// Some protocol can be either depending on configuration settings, like UART.
+type Duplex int
+
+const (
+	// DuplexUnknown is used when the duplex of a connection is yet to be known.
+	//
+	// Some protocol can be configured either as half-duplex or full-duplex and
+	// the connection is not yet is a determinate state.
+	DuplexUnknown Duplex = 0
+	// Half means that communication can only occurs one way at a time.
+	//
+	// Examples include 1-wire and I²C.
+	Half Duplex = 1
+	// Full means that communication occurs simultaneously both ways in a
+	// synchronized manner.
+	//
+	// Examples include SPI (except 3-wire variant).
+	Full Duplex = 2
+)
+
+const duplexName = "DuplexUnknownHalfFull"
+
+var duplexIndex = [...]uint8{0, 13, 17, 21}
+
+func (i Duplex) String() string {
+	if i < 0 || i >= Duplex(len(duplexIndex)-1) {
+		return "Duplex(" + strconv.Itoa(int(i)) + ")"
+	}
+	return duplexName[duplexIndex[i]:duplexIndex[i+1]]
+}
+
+// Conn defines the interface for a connection on a point-to-point
+// communication channel.
+//
+// The connection can either be unidirectional (read-only, write-only) or
+// bidirectional (read-write). It can either be half-duplex or full duplex.
+//
+// This is the lowest common denominator for all point-to-point communication
+// channels.
+//
+// Implementation are expected but not required to also implement the following
+// interfaces:
+//
+// - fmt.Stringer which returns something meaningful to the user like "SPI0.1",
+// "I2C1.76", "COM6", etc.
+//
+// - io.Reader and io.Writer as a way to use io.Copy() for half duplex
+// operation.
+//
+// - io.Closer for the owner of the communication channel.
+type Conn interface {
+	String() string
+	// Tx does a single transaction.
+	//
+	// For full duplex protocols (generally SPI, UART), the two buffers must have
+	// the same length as both reading and writing happen simultaneously.
+	//
+	// For half duplex protocols (I²C), there is no restriction as reading
+	// happens after writing, and r can be nil.
+	//
+	// Query Limits.MaxTxSize() to know if there is a limit on the buffer size
+	// per Tx() call.
+	Tx(w, r []byte) error
+	// Duplex returns the current duplex setting for this point-to-point
+	// connection.
+	//
+	// It is expected to be either Half or Full unless the connection itself is
+	// in an unknown state.
+	Duplex() Duplex
+}
+
+// Limits returns information about the connection's limits.
+type Limits interface {
+	// MaxTxSize returns the maximum allowed data size to be sent as a single
+	// I/O.
+	//
+	// Returns 0 if undefined.
+	MaxTxSize() int
+}