mirror of https://github.com/periph/devices
Add GPIO Group support to mcp23xxx
George Sexton
1 year ago
parent
cad22759dd
commit
743985e052
@ -0,0 +1,214 @@
|
|||||||
|
// Copyright 2025 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 mcp23xxx
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"periph.io/x/conn/v3"
|
||||||
|
"periph.io/x/conn/v3/gpio"
|
||||||
|
"periph.io/x/conn/v3/pin"
|
||||||
|
)
|
||||||
|
|
||||||
|
// The internal structure for a group of pins.
|
||||||
|
type pinGroup struct {
|
||||||
|
dev *Dev
|
||||||
|
port int
|
||||||
|
pins []*portpin
|
||||||
|
defaultMask gpio.GPIOValue
|
||||||
|
}
|
||||||
|
|
||||||
|
// Group returns a gpio.Group that is made up of the specified pins.
|
||||||
|
func (dev *Dev) Group(port int, pins []int) *gpio.Group {
|
||||||
|
grouppins := make([]*portpin, len(pins))
|
||||||
|
for ix, number := range pins {
|
||||||
|
pp, ok := dev.Pins[port][number].(*portpin)
|
||||||
|
if !ok {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
grouppins[ix] = pp
|
||||||
|
}
|
||||||
|
defMask := gpio.GPIOValue((1 << len(pins)) - 1)
|
||||||
|
var pgif interface{} = &pinGroup{dev: dev, port: port, pins: grouppins, defaultMask: defMask}
|
||||||
|
if gpiogroup, ok := pgif.(gpio.Group); ok {
|
||||||
|
return &gpiogroup
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Pins returns the set of pin.Pin that make up that group.
|
||||||
|
func (pg *pinGroup) Pins() []pin.Pin {
|
||||||
|
pins := make([]pin.Pin, len(pg.pins))
|
||||||
|
|
||||||
|
for ix, p := range pg.pins {
|
||||||
|
pins[ix] = p
|
||||||
|
}
|
||||||
|
return pins
|
||||||
|
}
|
||||||
|
|
||||||
|
// Given the offset within the group, return the corresponding GPIO pin.
|
||||||
|
func (pg *pinGroup) ByOffset(offset int) pin.Pin {
|
||||||
|
return pg.pins[offset]
|
||||||
|
}
|
||||||
|
|
||||||
|
// Given the specific name of a pin, return it. If it can't be found, nil is
|
||||||
|
// returned.
|
||||||
|
func (pg *pinGroup) ByName(name string) pin.Pin {
|
||||||
|
for _, pin := range pg.pins {
|
||||||
|
if pin.Name() == name {
|
||||||
|
return pin
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Given the GPIO pin number, return that pin from the set.
|
||||||
|
func (pg *pinGroup) ByNumber(number int) pin.Pin {
|
||||||
|
for _, pin := range pg.pins {
|
||||||
|
if pin.Number() == number {
|
||||||
|
return pin
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Out writes value to the specified pins of the device/port. If mask is 0,
|
||||||
|
// the default mask of all pins in the group is used.
|
||||||
|
func (pg *pinGroup) Out(value, mask gpio.GPIOValue) error {
|
||||||
|
if mask == 0 {
|
||||||
|
mask = pg.defaultMask
|
||||||
|
} else {
|
||||||
|
mask &= pg.defaultMask
|
||||||
|
}
|
||||||
|
value &= mask
|
||||||
|
// Convert the write value which is relative to the pins to the
|
||||||
|
// absolute value for the port.
|
||||||
|
wr := uint8(0)
|
||||||
|
wrMask := uint8(0)
|
||||||
|
for bit := range len(pg.pins) {
|
||||||
|
if (mask & (1 << bit)) > 0 {
|
||||||
|
if (value & 0x01) == 0x01 {
|
||||||
|
wr |= 1 << pg.pins[bit].Number()
|
||||||
|
}
|
||||||
|
wrMask |= 1 << pg.pins[bit].Number()
|
||||||
|
}
|
||||||
|
value = value >> 1
|
||||||
|
}
|
||||||
|
port := pg.pins[0].port
|
||||||
|
// Verify pins are set for output
|
||||||
|
outputPins, err := port.iodir.readValue(true)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((outputPins ^ 0xff) & wrMask) != wrMask {
|
||||||
|
outputPins &= (wrMask ^ 0xff)
|
||||||
|
err = port.iodir.writeValue(outputPins, false)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Read the current value
|
||||||
|
currentValue, err := port.olat.readValue(true)
|
||||||
|
// Apply the mask to clear bits we're writing.
|
||||||
|
currentValue &= (0xff ^ wrMask)
|
||||||
|
// Or the value with the bits to modify
|
||||||
|
currentValue |= wr
|
||||||
|
// And, write the value out the port.
|
||||||
|
return port.olat.writeValue(currentValue, true)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Read reads from the device and port and returns the state of the GPIO
|
||||||
|
// pins in the group. If a pin specified by mask is not configured for
|
||||||
|
// input, it is transparently re-configured.
|
||||||
|
func (pg *pinGroup) Read(mask gpio.GPIOValue) (result gpio.GPIOValue, err error) {
|
||||||
|
if mask == 0 {
|
||||||
|
mask = pg.defaultMask
|
||||||
|
} else {
|
||||||
|
mask &= pg.defaultMask
|
||||||
|
}
|
||||||
|
// Compute the read mask
|
||||||
|
rmask := uint8(0)
|
||||||
|
for bit := range 8 {
|
||||||
|
if (mask & (1 << bit)) > 0 {
|
||||||
|
rmask |= (1 << pg.pins[bit].Number())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Make sure the direction for the pins involved in this write read is
|
||||||
|
// Input.
|
||||||
|
port := pg.pins[0].port
|
||||||
|
currentIn, err := port.iodir.readValue(true)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
// We need to make some pins Input. Write the value to the iodir register.
|
||||||
|
if (currentIn & rmask) != rmask {
|
||||||
|
err = port.iodir.writeValue(currentIn|rmask, false)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Now, perform the read itself.
|
||||||
|
v, err := port.gpio.readValue(false)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
// Now convert the set pins into the Group value
|
||||||
|
for ix, pin := range pg.pins {
|
||||||
|
if (v & (1 << pin.Number())) > 0 {
|
||||||
|
result |= 1 << ix
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// WaitForEdge listens for a GPIO pin change event. The MCP23XXXX devices
|
||||||
|
// can't directly signal an edge event. To do this, you must call
|
||||||
|
// Dev.SetEdgePin() with a HOST GPIO pin configured for falling edge
|
||||||
|
// detection. That pin should be connected to the MCP23XXX INT pin. When
|
||||||
|
// a falling edge is detected on the supplied host GPIO pin, the code
|
||||||
|
// will return the GPIO Pin number on the device that changed.
|
||||||
|
//
|
||||||
|
// Note that the MCP23XXX devices only detect change. You can't configure
|
||||||
|
// falling or rising edge. Consequently, the returned edge will always be
|
||||||
|
// gpio.NoEdge.
|
||||||
|
//
|
||||||
|
// For a change event to be detected, the pin must be configured for input.
|
||||||
|
// This function will NOT set pins for input. Additionally, the calling
|
||||||
|
// code must set the INTCON register appropriately. Refer to the datasheet.
|
||||||
|
//
|
||||||
|
// In the event that the changed pin is NOT part of the io group, the
|
||||||
|
// triggering pin number will be returned, along with the error
|
||||||
|
// ErrPinNotInGroup
|
||||||
|
func (pg *pinGroup) WaitForEdge(timeout time.Duration) (number int, edge gpio.Edge, err error) {
|
||||||
|
return -1, gpio.NoEdge, gpio.ErrGroupFeatureNotImplemented
|
||||||
|
}
|
||||||
|
|
||||||
|
// Halt() interrupts a pending WaitForEdge() call if one is in process.
|
||||||
|
func (pg *pinGroup) Halt() error {
|
||||||
|
if pg.dev.edgePin != nil {
|
||||||
|
var ifpin interface{} = pg.dev.edgePin
|
||||||
|
if r, ok := ifpin.(conn.Resource); ok {
|
||||||
|
return r.Halt()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// TODO: I think we want to call Dev.Halt()
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// String returns the device variant name and configured pins for the group.
|
||||||
|
func (pg *pinGroup) String() string {
|
||||||
|
s := fmt.Sprintf("%s - [ ", pg.dev)
|
||||||
|
for ix := range len(pg.pins) {
|
||||||
|
s += fmt.Sprintf("%d ", pg.pins[ix].Number())
|
||||||
|
}
|
||||||
|
s += "]"
|
||||||
|
return s
|
||||||
|
}
|
||||||
|
|
||||||
|
var _ gpio.Group = &pinGroup{}
|
||||||
@ -0,0 +1,132 @@
|
|||||||
|
// Copyright 2025 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 mcp23xxx
|
||||||
|
|
||||||
|
import (
|
||||||
|
"log"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"periph.io/x/conn/v3/gpio"
|
||||||
|
"periph.io/x/conn/v3/i2c/i2creg"
|
||||||
|
"periph.io/x/host/v3"
|
||||||
|
)
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
// Make sure periph is initialized.
|
||||||
|
if _, err := host.Init(); err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestGroup(t *testing.T) {
|
||||||
|
|
||||||
|
// Open default I²C bus.
|
||||||
|
bus, err := i2creg.Open("")
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("failed to open I²C: %v", err)
|
||||||
|
}
|
||||||
|
defer bus.Close()
|
||||||
|
extender, err := NewI2C(bus, MCP23008, 0x20)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
for portnum, port := range extender.Pins {
|
||||||
|
for _, pin := range port {
|
||||||
|
t.Logf("Port: %d Pin: %d %s", portnum, pin.Number(), pin)
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
// My Test fixture has an led on pin 0, and also wires pin 0 -> pin 4.
|
||||||
|
// If I don't set pin 4 for input, then it breaks the LED blinking.
|
||||||
|
reader, _ := interface{}(extender.Pins[0][4]).(gpio.PinIn)
|
||||||
|
_ = reader.In(gpio.PullNoChange, gpio.NoEdge)
|
||||||
|
var ifpin interface{} = extender.Pins[0][0]
|
||||||
|
if writer, ok := ifpin.(gpio.PinOut); ok {
|
||||||
|
l := gpio.High
|
||||||
|
for range 20 {
|
||||||
|
writer.Out(l)
|
||||||
|
l = !l
|
||||||
|
time.Sleep(500 * time.Millisecond)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
t.Error("pin[0] not converted to gpio.PinOut!")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestReadWrite(t *testing.T) {
|
||||||
|
// Open default I²C bus.
|
||||||
|
bus, err := i2creg.Open("")
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("failed to open I²C: %v", err)
|
||||||
|
}
|
||||||
|
defer bus.Close()
|
||||||
|
extender, err := NewI2C(bus, MCP23008, 0x20)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defMask := gpio.GPIOValue(0xf)
|
||||||
|
gOut := *extender.Group(0, []int{0, 1, 2, 3})
|
||||||
|
if gOut == nil {
|
||||||
|
t.Error("gOut is nil!")
|
||||||
|
}
|
||||||
|
gRead := *extender.Group(0, []int{4, 5, 6, 7})
|
||||||
|
if gRead == nil {
|
||||||
|
t.Error("gIn is nil!")
|
||||||
|
}
|
||||||
|
// Turn off the GPIOs
|
||||||
|
defer gOut.Out(0, 0)
|
||||||
|
defer gRead.Out(0, 0)
|
||||||
|
|
||||||
|
for i := range 2 {
|
||||||
|
if i == 1 {
|
||||||
|
/* Now invert it. */
|
||||||
|
x := gRead
|
||||||
|
gRead = gOut
|
||||||
|
gOut = x
|
||||||
|
}
|
||||||
|
for i := range gpio.GPIOValue(16) {
|
||||||
|
err := gOut.Out(i, 0)
|
||||||
|
if err != nil {
|
||||||
|
t.Error(err)
|
||||||
|
}
|
||||||
|
time.Sleep(time.Millisecond)
|
||||||
|
r, err := gRead.Read(defMask)
|
||||||
|
if err != nil {
|
||||||
|
t.Error(err)
|
||||||
|
}
|
||||||
|
if r != i {
|
||||||
|
t.Errorf("Error reading/writing GPIO Group(). Wrote 0x%x Read 0x%x", i, r)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// For this test, write to the pins individually, and then
|
||||||
|
// confirm read on the other set works as expected.
|
||||||
|
x := gRead
|
||||||
|
gRead = gOut
|
||||||
|
gOut = x
|
||||||
|
t.Log(gRead)
|
||||||
|
pinset := extender.Pins[0][:4]
|
||||||
|
for i := range gpio.GPIOValue(16) {
|
||||||
|
wvalue := i
|
||||||
|
for bit := range 4 {
|
||||||
|
if (wvalue & (1 << bit)) == (1 << bit) {
|
||||||
|
pinset[bit].Out(gpio.High)
|
||||||
|
} else {
|
||||||
|
pinset[bit].Out(gpio.Low)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
r, err := gRead.Read(0)
|
||||||
|
if err != nil {
|
||||||
|
t.Error(err)
|
||||||
|
}
|
||||||
|
if r != i {
|
||||||
|
t.Errorf("Error writing GPIO pins and reading back result. Read 0x%x Expected 0x%x", r, i)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue