host specific drivers can now be loaded separately

this ensures cleaner abstractions/code and will ensure that the produced
binary is as small as possible. a convenience package is provided to
easily load all hosts easily: "github.com/kidoman/embd/host/all"

host/generic/digitalpin.go

@@ -0,0 +1,255 @@
+// Digital IO support.
+// This driver requires kernel version 3.8+ and should work uniformly
+// across all supported devices.
+
+package generic
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"strconv"
+	"time"
+
+	"github.com/kidoman/embd"
+)
+
+type digitalPin struct {
+	id string
+	n  int
+
+	drv embd.GPIODriver
+
+	dir       *os.File
+	val       *os.File
+	activeLow *os.File
+
+	readBuf []byte
+
+	initialized bool
+}
+
+func NewDigitalPin(pd *embd.PinDesc, drv embd.GPIODriver) embd.DigitalPin {
+	return &digitalPin{id: pd.ID, n: pd.DigitalLogical, drv: drv, readBuf: make([]byte, 1)}
+}
+
+func (p *digitalPin) N() int {
+	return p.n
+}
+
+func (p *digitalPin) init() error {
+	if p.initialized {
+		return nil
+	}
+
+	var err error
+	if err = p.export(); err != nil {
+		return err
+	}
+	if p.dir, err = p.directionFile(); err != nil {
+		return err
+	}
+	if p.val, err = p.valueFile(); err != nil {
+		return err
+	}
+	if p.activeLow, err = p.activeLowFile(); err != nil {
+		return err
+	}
+
+	p.initialized = true
+
+	return nil
+}
+
+func (p *digitalPin) export() error {
+	exporter, err := os.OpenFile("/sys/class/gpio/export", os.O_WRONLY, os.ModeExclusive)
+	if err != nil {
+		return err
+	}
+	defer exporter.Close()
+	_, err = exporter.WriteString(strconv.Itoa(p.n))
+	return err
+}
+
+func (p *digitalPin) unexport() error {
+	unexporter, err := os.OpenFile("/sys/class/gpio/unexport", os.O_WRONLY, os.ModeExclusive)
+	if err != nil {
+		return err
+	}
+	defer unexporter.Close()
+	_, err = unexporter.WriteString(strconv.Itoa(p.n))
+	return err
+}
+
+func (p *digitalPin) basePath() string {
+	return fmt.Sprintf("/sys/class/gpio/gpio%v", p.n)
+}
+
+func (p *digitalPin) openFile(path string) (*os.File, error) {
+	return os.OpenFile(path, os.O_RDWR, os.ModeExclusive)
+}
+
+func (p *digitalPin) directionFile() (*os.File, error) {
+	return p.openFile(path.Join(p.basePath(), "direction"))
+}
+
+func (p *digitalPin) valueFile() (*os.File, error) {
+	return p.openFile(path.Join(p.basePath(), "value"))
+}
+
+func (p *digitalPin) activeLowFile() (*os.File, error) {
+	return p.openFile(path.Join(p.basePath(), "active_low"))
+}
+
+func (p *digitalPin) SetDirection(dir embd.Direction) error {
+	if err := p.init(); err != nil {
+		return err
+	}
+
+	str := "in"
+	if dir == embd.Out {
+		str = "out"
+	}
+	_, err := p.dir.WriteString(str)
+	return err
+}
+
+func (p *digitalPin) read() (int, error) {
+	if _, err := p.val.ReadAt(p.readBuf, 0); err != nil {
+		return 0, err
+	}
+	if p.readBuf[0] == 49 {
+		return 1, nil
+	}
+	return 0, nil
+}
+
+func (p *digitalPin) Read() (int, error) {
+	if err := p.init(); err != nil {
+		return 0, err
+	}
+
+	return p.read()
+}
+
+var (
+	lowBytes  = []byte{48}
+	highBytes = []byte{49}
+)
+
+func (p *digitalPin) write(val int) error {
+	bytes := lowBytes
+	if val == embd.High {
+		bytes = highBytes
+	}
+	_, err := p.val.Write(bytes)
+	return err
+}
+
+func (p *digitalPin) Write(val int) error {
+	if err := p.init(); err != nil {
+		return err
+	}
+
+	return p.write(val)
+}
+
+func (p *digitalPin) TimePulse(state int) (time.Duration, error) {
+	if err := p.init(); err != nil {
+		return 0, err
+	}
+
+	aroundState := embd.Low
+	if state == embd.Low {
+		aroundState = embd.High
+	}
+
+	// Wait for any previous pulse to end
+	for {
+		v, err := p.read()
+		if err != nil {
+			return 0, err
+		}
+
+		if v == aroundState {
+			break
+		}
+	}
+
+	// Wait until ECHO goes high
+	for {
+		v, err := p.read()
+		if err != nil {
+			return 0, err
+		}
+
+		if v == state {
+			break
+		}
+	}
+
+	startTime := time.Now() // Record time when ECHO goes high
+
+	// Wait until ECHO goes low
+	for {
+		v, err := p.read()
+		if err != nil {
+			return 0, err
+		}
+
+		if v == aroundState {
+			break
+		}
+	}
+
+	return time.Since(startTime), nil // Calculate time lapsed for ECHO to transition from high to low
+}
+
+func (p *digitalPin) ActiveLow(b bool) error {
+	if err := p.init(); err != nil {
+		return err
+	}
+
+	str := "0"
+	if b {
+		str = "1"
+	}
+	_, err := p.activeLow.WriteString(str)
+	return err
+}
+
+func (p *digitalPin) PullUp() error {
+	return errors.New("gpio: not implemented")
+}
+
+func (p *digitalPin) PullDown() error {
+	return errors.New("gpio: not implemented")
+}
+
+func (p *digitalPin) Close() error {
+	if err := p.drv.Unregister(p.id); err != nil {
+		return err
+	}
+
+	if !p.initialized {
+		return nil
+	}
+
+	if err := p.dir.Close(); err != nil {
+		return err
+	}
+	if err := p.val.Close(); err != nil {
+		return err
+	}
+	if err := p.activeLow.Close(); err != nil {
+		return err
+	}
+	if err := p.unexport(); err != nil {
+		return err
+	}
+
+	p.initialized = false
+
+	return nil
+}