Merge 3e9ce063db into 6ad940090c

gpio.go

@@ -23,8 +23,39 @@ const (
 	High
 )
 
+// Edge trigger for GPIO Interrupt
+type Edge string
+
+// IRQ event function definition
+type IRQEvent func(pin DigitalPin)
+
+// Available Edge trigger for Interrupt
+const (
+	EdgeNone    Edge = "none"
+	EdgeRising  Edge = "rising"
+	EdgeFalling Edge = "falling"
+	EdgeBoth    Edge = "both"
+)
+
+// InterruptPin implements access to a Interruptable capable GPIO pin.
+type InterruptPin interface {
+	// return file handler for GPIO
+	Fd() int
+
+	// Start watching this pin for interrupt
+	Watch(edge Edge, callback IRQEvent) error
+
+	// Stop watching this pin for interrupt
+	StopWatching() error
+
+	// Signal that an Interrupt has happened
+	Signal()
+}
+
 // DigitalPin implements access to a digital IO capable GPIO pin.
 type DigitalPin interface {
+	InterruptPin
+
 	// N returns the logical GPIO number.
 	N() int
 
@@ -101,8 +132,18 @@ type PWMPin interface {
 	Close() error
 }
 
+type GPIOInterrupt interface {
+	// Register a pin as an interrupt
+	RegisterInterrupt(p InterruptPin) error
+
+	// Unregister a pin as an interrupt
+	UnregisterInterrupt(p InterruptPin) error
+}
+
 // GPIODriver implements a generic GPIO driver.
 type GPIODriver interface {
+	GPIOInterrupt
+
 	// Unregister unregisters the pin from the driver. Should be called when the pin is closed.
 	Unregister(string) error
 
@@ -219,6 +260,22 @@ func PullDown(key interface{}) error {
 	return pin.PullDown()
 }
 
+func Watch(key interface{}, edge Edge, callback IRQEvent) error {
+	pin, err := NewDigitalPin(key)
+	if err != nil {
+		return err
+	}
+	return pin.Watch(edge, callback)
+}
+
+func StopWatching(key interface{}) error {
+	pin, err := NewDigitalPin(key)
+	if err != nil {
+		return err
+	}
+	return pin.StopWatching()
+}
+
 // NewAnalogPin returns a AnalogPin interface which allows control over
 // the analog GPIO pin.
 func NewAnalogPin(key interface{}) (AnalogPin, error) {

gpiodriver.go

@@ -5,6 +5,11 @@ package embd
 import (
 	"errors"
 	"fmt"
+	"syscall"
+)
+
+const (
+	MaxGPIOInterrupt = 64
 )
 
 type pin interface {
@@ -22,7 +27,8 @@ type gpioDriver struct {
 	apf analogPinFactory
 	ppf pwmPinFactory
 
-	initializedPins map[string]pin
+	watchEventCallbacks map[int]InterruptPin
+	initializedPins     map[string]pin
 }
 
 // NewGPIODriver returns a GPIODriver interface which allows control
@@ -34,10 +40,85 @@ func NewGPIODriver(pinMap PinMap, dpf digitalPinFactory, apf analogPinFactory, p
 		apf:    apf,
 		ppf:    ppf,
 
-		initializedPins: map[string]pin{},
+		watchEventCallbacks: map[int]InterruptPin{},
+		initializedPins:     map[string]pin{},
 	}
 }
 
+var epollFD int
+
+func (io *gpioDriver) initializeEpoll() {
+	var err error
+	epollFD, err = syscall.EpollCreate1(0)
+	if err != nil {
+		panic(fmt.Sprintf("Unable to create epoll FD: ", err.Error()))
+	}
+
+	go func() {
+		var epollEvents [MaxGPIOInterrupt]syscall.EpollEvent
+
+		for {
+			numEvents, err := syscall.EpollWait(epollFD, epollEvents[:], -1)
+			if err != nil {
+				panic(fmt.Sprintf("EpollWait error: %s", err.Error()))
+			}
+			for i := 0; i < numEvents; i++ {
+				if eventPin, exists := io.watchEventCallbacks[int(epollEvents[i].Fd)]; exists {
+					eventPin.Signal()
+				}
+			}
+		}
+	}()
+}
+
+func (io *gpioDriver) RegisterInterrupt(p InterruptPin) error {
+
+	if epollFD == 0 {
+		io.initializeEpoll()
+	}
+
+	fd := p.Fd()
+
+	var event syscall.EpollEvent
+	event.Events = syscall.EPOLLIN | (syscall.EPOLLET & 0xffffffff) | syscall.EPOLLPRI
+
+	io.watchEventCallbacks[fd] = p
+
+	if err := syscall.SetNonblock(fd, true); err != nil {
+		return err
+	}
+
+	event.Fd = int32(fd)
+
+	if err := syscall.EpollCtl(epollFD, syscall.EPOLL_CTL_ADD, fd, &event); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (io *gpioDriver) UnregisterInterrupt(p InterruptPin) error {
+
+	fd := p.Fd()
+
+	// check if we are watching this pin
+	if _, ok := io.watchEventCallbacks[fd]; !ok {
+		return nil
+	}
+
+	if err := syscall.EpollCtl(epollFD, syscall.EPOLL_CTL_DEL, fd, nil); err != nil {
+		return err
+	}
+
+	if err := syscall.SetNonblock(fd, false); err != nil {
+		return err
+	}
+
+	delete(io.watchEventCallbacks, fd)
+
+	return nil
+}
+
 func (io *gpioDriver) Unregister(id string) error {
 	if _, ok := io.initializedPins[id]; !ok {
 		return fmt.Errorf("gpio: pin %v is not registered yet, cannot unregister", id)

host/generic/digitalpin.go

@@ -28,10 +28,19 @@ type digitalPin struct {
 	readBuf []byte
 
 	initialized bool
+
+	epollInitialTrigger bool
+	callback            embd.IRQEvent
 }
 
 func NewDigitalPin(pd *embd.PinDesc, drv embd.GPIODriver) embd.DigitalPin {
-	return &digitalPin{id: pd.ID, n: pd.DigitalLogical, drv: drv, readBuf: make([]byte, 1)}
+	return &digitalPin{
+		id:                  pd.ID,
+		n:                   pd.DigitalLogical,
+		drv:                 drv,
+		epollInitialTrigger: true,
+		readBuf:             make([]byte, 1),
+	}
 }
 
 func (p *digitalPin) N() int {
@@ -102,6 +111,45 @@ func (p *digitalPin) activeLowFile() (*os.File, error) {
 	return p.openFile(path.Join(p.basePath(), "active_low"))
 }
 
+func (p *digitalPin) Fd() int {
+	return int(p.val.Fd())
+}
+
+func (p *digitalPin) setEdge(edge embd.Edge) error {
+	file, err := p.openFile(path.Join(p.basePath(), "edge"))
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	_, err = file.Write([]byte(edge))
+	return err
+}
+
+func (p *digitalPin) Watch(edge embd.Edge, callback embd.IRQEvent) error {
+	if err := p.SetDirection(embd.In); err != nil {
+		return err
+	}
+
+	if err := p.setEdge(edge); err != nil {
+		return err
+	}
+	p.callback = callback
+	return p.drv.RegisterInterrupt(p)
+}
+
+func (p *digitalPin) StopWatching() error {
+	return p.drv.UnregisterInterrupt(p)
+}
+
+func (p *digitalPin) Signal() {
+	if p.epollInitialTrigger {
+		p.epollInitialTrigger = false
+	} else {
+		p.callback(embd.DigitalPin(p))
+	}
+}
+
 func (p *digitalPin) SetDirection(dir embd.Direction) error {
 	if err := p.init(); err != nil {
 		return err
@@ -232,6 +280,10 @@ func (p *digitalPin) Close() error {
 		return err
 	}
 
+	if err := p.StopWatching(); err != nil {
+		return err
+	}
+
 	if !p.initialized {
 		return nil
 	}