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
+}

host/generic/digitalpin_test.go

@@ -0,0 +1,26 @@
+package generic
+
+import (
+	"testing"
+
+	"github.com/kidoman/embd"
+)
+
+func TestDigitalPinClose(t *testing.T) {
+	pinMap := embd.PinMap{
+		&embd.PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: embd.CapDigital},
+	}
+	driver := embd.NewGPIODriver(pinMap, NewDigitalPin, nil, nil)
+	pin, err := driver.DigitalPin(1)
+	if err != nil {
+		t.Fatalf("Looking up digital pin 1: got %v", err)
+	}
+	pin.Close()
+	pin2, err := driver.DigitalPin(1)
+	if err != nil {
+		t.Fatalf("Looking up digital pin 1: got %v", err)
+	}
+	if pin == pin2 {
+		t.Fatal("Looking up closed digital pin 1: but got the old instance")
+	}
+}

host/generic/doc.go

@@ -0,0 +1,10 @@
+/*
+	Package generic provides generic (to Linux) drivers for functionalities like
+
+	Digital I/O
+	I²C
+	LED control
+
+	They are used by the hosts to satiate the HAL.
+*/
+package generic

host/generic/i2cbus.go

@@ -0,0 +1,288 @@
+// I²C support.
+
+package generic
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"sync"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/kidoman/embd"
+)
+
+const (
+	delay = 20
+
+	slaveCmd = 0x0703 // Cmd to set slave address
+	rdrwCmd  = 0x0707 // Cmd to read/write data together
+
+	rd = 0x0001
+)
+
+type i2c_msg struct {
+	addr  uint16
+	flags uint16
+	len   uint16
+	buf   uintptr
+}
+
+type i2c_rdwr_ioctl_data struct {
+	msgs uintptr
+	nmsg uint32
+}
+
+type i2cBus struct {
+	l    byte
+	file *os.File
+	addr byte
+	mu   sync.Mutex
+
+	initialized bool
+}
+
+func NewI2CBus(l byte) embd.I2CBus {
+	return &i2cBus{l: l}
+}
+
+func (b *i2cBus) init() error {
+	if b.initialized {
+		return nil
+	}
+
+	var err error
+	if b.file, err = os.OpenFile(fmt.Sprintf("/dev/i2c-%v", b.l), os.O_RDWR, os.ModeExclusive); err != nil {
+		return err
+	}
+
+	b.initialized = true
+
+	return nil
+}
+
+func (b *i2cBus) setAddress(addr byte) error {
+	if addr != b.addr {
+		if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, b.file.Fd(), slaveCmd, uintptr(addr)); errno != 0 {
+			return syscall.Errno(errno)
+		}
+
+		b.addr = addr
+	}
+
+	return nil
+}
+
+func (b *i2cBus) ReadByte(addr byte) (byte, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return 0, err
+	}
+
+	bytes := make([]byte, 1)
+	n, _ := b.file.Read(bytes)
+
+	if n != 1 {
+		return 0, fmt.Errorf("i2c: Unexpected number (%v) of bytes read", n)
+	}
+
+	return bytes[0], nil
+}
+
+func (b *i2cBus) WriteByte(addr, value byte) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return err
+	}
+
+	n, err := b.file.Write([]byte{value})
+
+	if n != 1 {
+		err = fmt.Errorf("i2c: Unexpected number (%v) of bytes written in WriteByte", n)
+	}
+
+	return err
+}
+
+func (b *i2cBus) WriteBytes(addr byte, value []byte) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return err
+	}
+
+	for i := range value {
+		n, err := b.file.Write([]byte{value[i]})
+
+		if n != 1 {
+			return fmt.Errorf("i2c: Unexpected number (%v) of bytes written in WriteBytes", n)
+		}
+		if err != nil {
+			return err
+		}
+
+		time.Sleep(delay * time.Millisecond)
+	}
+
+	return nil
+}
+
+func (b *i2cBus) ReadFromReg(addr, reg byte, value []byte) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return err
+	}
+
+	hdrp := (*reflect.SliceHeader)(unsafe.Pointer(&value))
+
+	var messages [2]i2c_msg
+	messages[0].addr = uint16(addr)
+	messages[0].flags = 0
+	messages[0].len = 1
+	messages[0].buf = uintptr(unsafe.Pointer(&reg))
+
+	messages[1].addr = uint16(addr)
+	messages[1].flags = rd
+	messages[1].len = uint16(len(value))
+	messages[1].buf = uintptr(unsafe.Pointer(hdrp.Data))
+
+	var packets i2c_rdwr_ioctl_data
+
+	packets.msgs = uintptr(unsafe.Pointer(&messages))
+	packets.nmsg = 2
+
+	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, b.file.Fd(), rdrwCmd, uintptr(unsafe.Pointer(&packets))); errno != 0 {
+		return syscall.Errno(errno)
+	}
+
+	return nil
+}
+
+func (b *i2cBus) ReadByteFromReg(addr, reg byte) (byte, error) {
+	buf := make([]byte, 1)
+	if err := b.ReadFromReg(addr, reg, buf); err != nil {
+		return 0, err
+	}
+	return buf[0], nil
+}
+
+func (b *i2cBus) ReadWordFromReg(addr, reg byte) (uint16, error) {
+	buf := make([]byte, 2)
+	if err := b.ReadFromReg(addr, reg, buf); err != nil {
+		return 0, err
+	}
+	return uint16((uint16(buf[0]) << 8) | uint16(buf[1])), nil
+}
+
+func (b *i2cBus) WriteToReg(addr, reg byte, value []byte) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return err
+	}
+
+	outbuf := append([]byte{reg}, value...)
+
+	hdrp := (*reflect.SliceHeader)(unsafe.Pointer(&outbuf))
+
+	var message i2c_msg
+	message.addr = uint16(addr)
+	message.flags = 0
+	message.len = uint16(len(outbuf))
+	message.buf = uintptr(unsafe.Pointer(&hdrp.Data))
+
+	var packets i2c_rdwr_ioctl_data
+
+	packets.msgs = uintptr(unsafe.Pointer(&message))
+	packets.nmsg = 1
+
+	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, b.file.Fd(), rdrwCmd, uintptr(unsafe.Pointer(&packets))); errno != 0 {
+		return syscall.Errno(errno)
+	}
+
+	return nil
+}
+
+func (b *i2cBus) WriteByteToReg(addr, reg, value byte) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return err
+	}
+
+	outbuf := [...]byte{
+		reg,
+		value,
+	}
+
+	var message i2c_msg
+	message.addr = uint16(addr)
+	message.flags = 0
+	message.len = uint16(len(outbuf))
+	message.buf = uintptr(unsafe.Pointer(&outbuf))
+
+	var packets i2c_rdwr_ioctl_data
+
+	packets.msgs = uintptr(unsafe.Pointer(&message))
+	packets.nmsg = 1
+
+	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, b.file.Fd(), rdrwCmd, uintptr(unsafe.Pointer(&packets))); errno != 0 {
+		return syscall.Errno(errno)
+	}
+
+	return nil
+}
+
+func (b *i2cBus) WriteWordToReg(addr, reg byte, value uint16) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if err := b.setAddress(addr); err != nil {
+		return err
+	}
+
+	outbuf := [...]byte{
+		reg,
+		byte(value >> 8),
+		byte(value),
+	}
+
+	var messages i2c_msg
+	messages.addr = uint16(addr)
+	messages.flags = 0
+	messages.len = uint16(len(outbuf))
+	messages.buf = uintptr(unsafe.Pointer(&outbuf))
+
+	var packets i2c_rdwr_ioctl_data
+
+	packets.msgs = uintptr(unsafe.Pointer(&messages))
+	packets.nmsg = 1
+
+	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, b.file.Fd(), rdrwCmd, uintptr(unsafe.Pointer(&packets))); errno != 0 {
+		return syscall.Errno(errno)
+	}
+
+	return nil
+}
+
+func (b *i2cBus) Close() error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if !b.initialized {
+		return nil
+	}
+
+	return b.file.Close()
+}

host/generic/led.go

@@ -0,0 +1,113 @@
+// LED control support.
+
+package generic
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/kidoman/embd"
+)
+
+type led struct {
+	id string
+
+	brightness *os.File
+
+	initialized bool
+}
+
+func NewLED(id string) embd.LED {
+	return &led{id: id}
+}
+
+func (l *led) init() error {
+	if l.initialized {
+		return nil
+	}
+
+	var err error
+	if l.brightness, err = l.brightnessFile(); err != nil {
+		return err
+	}
+
+	l.initialized = true
+
+	return nil
+}
+
+func (l *led) brightnessFilePath() string {
+	return fmt.Sprintf("/sys/class/leds/%v/brightness", l.id)
+}
+
+func (l *led) openFile(path string) (*os.File, error) {
+	return os.OpenFile(path, os.O_RDWR, os.ModeExclusive)
+}
+
+func (l *led) brightnessFile() (*os.File, error) {
+	return l.openFile(l.brightnessFilePath())
+}
+
+func (l *led) On() error {
+	if err := l.init(); err != nil {
+		return err
+	}
+
+	_, err := l.brightness.WriteString("1")
+	return err
+}
+
+func (l *led) Off() error {
+	if err := l.init(); err != nil {
+		return err
+	}
+
+	_, err := l.brightness.WriteString("0")
+	return err
+}
+
+func (l *led) isOn() (bool, error) {
+	l.brightness.Seek(0, 0)
+	bytes, err := ioutil.ReadAll(l.brightness)
+	if err != nil {
+		return false, err
+	}
+	str := string(bytes)
+	str = strings.TrimSpace(str)
+	if str == "1" {
+		return true, nil
+	}
+	return false, nil
+}
+
+func (l *led) Toggle() error {
+	if err := l.init(); err != nil {
+		return err
+	}
+
+	state, err := l.isOn()
+	if err != nil {
+		return err
+	}
+
+	if state {
+		return l.Off()
+	}
+	return l.On()
+}
+
+func (l *led) Close() error {
+	if !l.initialized {
+		return nil
+	}
+
+	if err := l.brightness.Close(); err != nil {
+		return err
+	}
+
+	l.initialized = false
+
+	return nil
+}