Merge branch 'vendelin8-master' into dev

examples/digispark_blinkm.go

@@ -0,0 +1,41 @@
+// +build example
+//
+// Do not build by default.
+
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"gobot.io/x/gobot"
+	"gobot.io/x/gobot/drivers/i2c"
+	"gobot.io/x/gobot/platforms/digispark"
+)
+
+func main() {
+	board := digispark.NewAdaptor()
+	blinkm := i2c.NewBlinkMDriver(board)
+
+	work := func() {
+		gobot.Every(3*time.Second, func() {
+			r := byte(gobot.Rand(255))
+			g := byte(gobot.Rand(255))
+			b := byte(gobot.Rand(255))
+			blinkm.Rgb(r, g, b)
+			color, _ := blinkm.Color()
+			fmt.Println("color", color)
+		})
+	}
+
+	robot := gobot.NewRobot("blinkBot",
+		[]gobot.Connection{board},
+		[]gobot.Device{blinkm},
+		work,
+	)
+
+	err := robot.Start()
+	if err != nil {
+		fmt.Println(err)
+	}
+}

examples/digispark_mpl115a2.go

@@ -0,0 +1,40 @@
+// +build example
+//
+// Do not build by default.
+
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"gobot.io/x/gobot"
+	"gobot.io/x/gobot/drivers/i2c"
+	"gobot.io/x/gobot/platforms/digispark"
+)
+
+func main() {
+	board := digispark.NewAdaptor()
+	mpl115a2 := i2c.NewMPL115A2Driver(board)
+
+	work := func() {
+		gobot.Every(1*time.Second, func() {
+			press, _ := mpl115a2.Pressure()
+			fmt.Println("Pressure", press)
+
+			temp, _ := mpl115a2.Temperature()
+			fmt.Println("Temperature", temp)
+		})
+	}
+
+	robot := gobot.NewRobot("blinkBot",
+		[]gobot.Connection{board},
+		[]gobot.Device{mpl115a2},
+		work,
+	)
+
+	err := robot.Start()
+	if err != nil {
+		fmt.Println(err)
+	}
+}

platforms/digispark/digispark_adaptor.go

@@ -2,9 +2,11 @@ package digispark
 
 import (
 	"errors"
+	"fmt"
 	"strconv"
 
 	"gobot.io/x/gobot"
+	"gobot.io/x/gobot/drivers/i2c"
 )
 
 // ErrConnection is the error resulting of a connection error with the digispark
@@ -16,6 +18,7 @@ type Adaptor struct {
 	littleWire lw
 	servo      bool
 	pwm        bool
+	i2c        bool
 	connect    func(*Adaptor) (err error)
 }
 
@@ -89,3 +92,21 @@ func (d *Adaptor) ServoWrite(pin string, angle uint8) (err error) {
 	}
 	return d.littleWire.servoUpdateLocation(angle, angle)
 }
+
+// GetConnection returns an i2c connection to a device on a specified bus.
+// Only supports bus number 0
+func (d *Adaptor) GetConnection(address int, bus int) (connection i2c.Connection, err error) {
+	if bus != 0 {
+		return nil, fmt.Errorf("Invalid bus number %d, only 0 is supported", bus)
+	}
+	c := NewDigisparkI2cConnection(d, uint8(address))
+	if err := c.Init(); err != nil {
+		return nil, err
+	}
+	return i2c.Connection(c), nil
+}
+
+// GetDefaultBus returns the default i2c bus for this platform
+func (d *Adaptor) GetDefaultBus() int {
+	return 0
+}

platforms/digispark/digispark_adaptor_test.go

@@ -2,11 +2,13 @@ package digispark
 
 import (
 	"errors"
+	"fmt"
 	"strings"
 	"testing"
 
 	"gobot.io/x/gobot"
 	"gobot.io/x/gobot/drivers/gpio"
+	"gobot.io/x/gobot/drivers/i2c"
 	"gobot.io/x/gobot/gobottest"
 )
 
@@ -15,6 +17,7 @@ var _ gobot.Adaptor = (*Adaptor)(nil)
 var _ gpio.DigitalWriter = (*Adaptor)(nil)
 var _ gpio.PwmWriter = (*Adaptor)(nil)
 var _ gpio.ServoWriter = (*Adaptor)(nil)
+var _ i2c.Connector = (*Adaptor)(nil)
 
 type mock struct {
 	locationA         uint8
@@ -25,6 +28,9 @@ type mock struct {
 	pin               uint8
 	mode              uint8
 	state             uint8
+	address           int
+	duration          uint
+	direction         uint8
 }
 
 func (l *mock) digitalWrite(pin uint8, state uint8) error {
@@ -58,6 +64,49 @@ func (l *mock) servoUpdateLocation(locationA uint8, locationB uint8) error {
 	return l.error()
 }
 
+const availableI2cAddress = 0x40
+const maxUint8 = ^uint8(0)
+
+var i2cData = []byte{5, 4, 3, 2, 1, 0}
+
+func (l *mock) i2cInit() error {
+	l.direction = maxUint8
+	return l.error()
+}
+
+func (l *mock) i2cStart(address7bit uint8, direction uint8) error {
+	if address7bit != availableI2cAddress {
+		return fmt.Errorf("Invalid address, only %d is supported", availableI2cAddress)
+	}
+	if err := l.error(); err != nil {
+		return err
+	}
+	l.direction = direction
+	return nil
+}
+
+func (l *mock) i2cWrite(sendBuffer []byte, length int, endWithStop uint8) error {
+	l.direction = 0
+	return l.error()
+}
+
+func (l *mock) i2cRead(readBuffer []byte, length int, endWithStop uint8) error {
+	l.direction = 1
+	if len(readBuffer) < length {
+		length = len(readBuffer)
+	}
+	if len(i2cData) < length {
+		length = len(i2cData)
+	}
+	copy(readBuffer[:length], i2cData[:length])
+	return l.error()
+}
+
+func (l *mock) i2cUpdateDelay(duration uint) error {
+	l.duration = duration
+	return l.error()
+}
+
 var errorFunc = func() error { return nil }
 
 func (l *mock) error() error { return errorFunc() }
@@ -79,10 +128,7 @@ func TestDigisparkAdaptorName(t *testing.T) {
 }
 
 func TestAdaptorConnect(t *testing.T) {
-	a := NewAdaptor()
-	gobottest.Assert(t, a.Connect(), ErrConnection)
-
-	a = initTestAdaptor()
+	a := initTestAdaptor()
 	gobottest.Assert(t, a.Connect(), nil)
 }
 
@@ -136,3 +182,45 @@ func TestAdaptorPwmWrite(t *testing.T) {
 	err = a.PwmWrite("1", uint8(100))
 	gobottest.Assert(t, err, errors.New("pwm error"))
 }
+
+func TestAdaptorI2c(t *testing.T) {
+	var c i2c.Connection
+	var err error
+	data := []byte{0, 1, 2, 3, 4}
+	dataLen := len(data)
+	count := 0
+
+	a := initTestAdaptor()
+	c, err = a.GetConnection(0x40, 1)
+	gobottest.Assert(t, err, errors.New("Invalid bus number 1, only 0 is supported"))
+	gobottest.Assert(t, c, nil)
+	// init couldn't run, direction is still 0
+	gobottest.Assert(t, a.littleWire.(*mock).direction, uint8(0))
+
+	// connection inits, but start will fail
+	c, err = a.GetConnection(0x39, a.GetDefaultBus())
+	gobottest.Assert(t, err, nil)
+	gobottest.Refute(t, c, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).direction, maxUint8)
+	err = c.(*digisparkI2cConnection).UpdateDelay(uint(100))
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).duration, uint(100))
+	count, err = c.Write(data)
+	gobottest.Assert(t, count, 0)
+	gobottest.Assert(t, err, fmt.Errorf("Invalid address, only %d is supported", availableI2cAddress))
+	gobottest.Assert(t, a.littleWire.(*mock).direction, maxUint8)
+
+	// connection inits, but start will succeed
+	c, err = a.GetConnection(availableI2cAddress, a.GetDefaultBus())
+	gobottest.Assert(t, err, nil)
+	gobottest.Refute(t, c, nil)
+	count, err = c.Write(data)
+	gobottest.Assert(t, count, dataLen)
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).direction, uint8(0))
+	count, err = c.Read(data)
+	gobottest.Assert(t, count, dataLen)
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, a.littleWire.(*mock).direction, uint8(1))
+	gobottest.Assert(t, data, i2cData[:dataLen])
+}