Update firmata package

examples/firmata_blink.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"github.com/hybridgroup/gobot"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
+)
+
+func main() {
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
+
+	led := gpio.NewLedDriver(firmataAdaptor)
+	led.Name = "led"
+	led.Pin = "13"
+
+	work := func() {
+		gobot.Every("1s", func() {
+			led.Toggle()
+		})
+	}
+
+	robot := gobot.Robot{
+		Connections: []gobot.Connection{firmataAdaptor},
+		Devices:     []gobot.Device{led},
+		Work:        work,
+	}
+
+	robot.Start()
+}

examples/firmata_blinkm.go

@@ -3,16 +3,16 @@ package main
 import (
 	"fmt"
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-i2c"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/i2c"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	blinkm := gobotI2C.NewBlinkM(firmata)
+	blinkm := i2c.NewBlinkMDriver(firmataAdaptor)
 	blinkm.Name = "blinkm"
 
 	work := func() {
@@ -23,7 +23,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{blinkm},
 		Work:        work,
 	}

examples/firmata_button.go

@@ -2,20 +2,20 @@ package main
 
 import (
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	button := gobotGPIO.NewButton(firmata)
+	button := gpio.NewButtonDriver(firmataAdaptor)
 	button.Name = "button"
 	button.Pin = "2"
 
-	led := gobotGPIO.NewLed(firmata)
+	led := gpio.NewLedDriver(firmataAdaptor)
 	led.Name = "led"
 	led.Pin = "13"
 
@@ -30,7 +30,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{button, led},
 		Work:        work,
 	}

examples/firmata_cat_toy.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+	"github.com/hybridgroup/gobot"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
+	"github.com/hybridgroup/gobot/leap"
+)
+
+func main() {
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
+
+	servo1 := gpio.NewServoDriver(firmataAdaptor)
+	servo1.Name = "servo"
+	servo1.Pin = "5"
+
+	servo2 := gpio.NewServoDriver(firmataAdaptor)
+	servo2.Name = "servo"
+	servo2.Pin = "3"
+
+	leapAdaptor := leap.NewLeapMotionAdaptor()
+	leapAdaptor.Name = "leap"
+	leapAdaptor.Port = "127.0.0.1:6437"
+
+	leapDriver := leap.NewLeapMotionDriver(leapAdaptor)
+	leapDriver.Name = "leap"
+
+	work := func() {
+		x := 90.0
+		z := 90.0
+		gobot.On(leapDriver.Events["Message"], func(data interface{}) {
+			if len(data.(leap.Frame).Hands) > 0 {
+				hand := data.(leap.Frame).Hands[0]
+				x = gobot.ToScale(gobot.FromScale(hand.X(), -300, 300), 30, 150)
+				z = gobot.ToScale(gobot.FromScale(hand.Z(), -300, 300), 30, 150)
+			}
+		})
+		gobot.Every("0.01s", func() {
+			servo1.Move(uint8(x))
+			servo2.Move(uint8(z))
+			fmt.Println("Current Angle: ", servo1.CurrentAngle, ",", servo2.CurrentAngle)
+		})
+	}
+
+	robot := gobot.Robot{
+		Connections: []gobot.Connection{firmataAdaptor, leapAdaptor},
+		Devices:     []gobot.Device{servo1, servo2, leapDriver},
+		Work:        work,
+	}
+
+	robot.Start()
+}

examples/firmata_hmc6352.go

@@ -3,16 +3,16 @@ package main
 import (
 	"fmt"
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-i2c"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/i2c"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	hmc6352 := gobotI2C.NewHMC6352(firmata)
+	hmc6352 := i2c.NewHMC6352Driver(firmataAdaptor)
 	hmc6352.Name = "hmc6352"
 
 	work := func() {
@@ -22,7 +22,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{hmc6352},
 		Work:        work,
 	}

examples/firmata_led_brightness.go

@@ -2,16 +2,16 @@ package main
 
 import (
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	led := gobotGPIO.NewLed(firmata)
+	led := gpio.NewLedDriver(firmataAdaptor)
 	led.Name = "led"
 	led.Pin = "3"
 
@@ -29,7 +29,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{led},
 		Work:        work,
 	}

examples/firmata_led_brightness_with_analog_input.go

@@ -3,27 +3,27 @@ package main
 import (
 	"fmt"
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	sensor := gobotGPIO.NewAnalogSensor(firmata)
+	sensor := gpio.NewAnalogSensor(firmataAdaptor)
 	sensor.Name = "sensor"
 	sensor.Pin = "0"
 
-	led := gobotGPIO.NewLed(firmata)
+	led := gpio.NewLed(firmataAdaptor)
 	led.Name = "led"
 	led.Pin = "3"
 
 	work := func() {
 		gobot.Every("0.1s", func() {
 			val := sensor.Read()
-			brightness := uint8(gobotGPIO.ToPwm(val))
+			brightness := uint8(gpio.ToPwm(val))
 			fmt.Println("sensor", val)
 			fmt.Println("brightness", brightness)
 			led.Brightness(brightness)
@@ -31,7 +31,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{sensor, led},
 		Work:        work,
 	}

examples/firmata_makey_button.go

@@ -2,20 +2,20 @@ package main
 
 import (
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	button := gobotGPIO.NewMakeyButton(firmata)
+	button := gpio.NewMakeyButtonDriver(firmataAdaptor)
 	button.Name = "button"
 	button.Pin = "2"
 
-	led := gobotGPIO.NewLed(firmata)
+	led := gpio.NewLedDriver(firmataAdaptor)
 	led.Name = "led"
 	led.Pin = "13"
 
@@ -30,7 +30,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{button, led},
 		Work:        work,
 	}

examples/firmata_motor.go

@@ -2,16 +2,16 @@ package main
 
 import (
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	motor := gobotGPIO.NewMotor(firmata)
+	motor := gpio.NewMotorDriver(firmataAdaptor)
 	motor.Name = "motor"
 	motor.SpeedPin = "3"
 
@@ -29,7 +29,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{motor},
 		Work:        work,
 	}

examples/firmata_servo.go

@@ -3,17 +3,16 @@ package main
 import (
 	"fmt"
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 )
 
 func main() {
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
-
-	servo := gobotGPIO.NewServo(firmata)
+	servo := gpio.NewServoDriver(firmataAdaptor)
 	servo.Name = "servo"
 	servo.Pin = "3"
 
@@ -26,7 +25,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{servo},
 		Work:        work,
 	}

examples/firmata_travis.go

@@ -4,8 +4,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/gpio"
 	"io/ioutil"
 	"net/http"
 )
@@ -58,21 +58,21 @@ func checkTravis(robot *gobot.Robot) {
 }
 
 func main() {
-	master := gobot.GobotMaster()
+	master := gobot.NewMaster()
 
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	red := gobotGPIO.NewLed(firmata)
+	red := gpio.NewLedDriver(firmata)
 	red.Name = "red"
 	red.Pin = "7"
 
-	green := gobotGPIO.NewLed(firmata)
+	green := gpio.NewLedDriver(firmata)
 	green.Name = "green"
 	green.Pin = "6"
 
-	blue := gobotGPIO.NewLed(firmata)
+	blue := gpio.NewLedDriver(firmata)
 	blue.Name = "blue"
 	blue.Pin = "5"
 
@@ -85,7 +85,7 @@ func main() {
 
 	master.Robots = append(master.Robots, &gobot.Robot{
 		Name:        "travis",
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{red, green, blue},
 		Work:        work,
 	})

examples/firmata_wiichuck.go

@@ -3,16 +3,16 @@ package main
 import (
 	"fmt"
 	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-i2c"
+	"github.com/hybridgroup/gobot/firmata"
+	"github.com/hybridgroup/gobot/i2c"
 )
 
 func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
+	firmataAdaptor := firmata.NewFirmataAdaptor()
+	firmataAdaptor.Name = "firmata"
+	firmataAdaptor.Port = "/dev/ttyACM0"
 
-	wiichuck := gobotI2C.NewWiichuck(firmata)
+	wiichuck := i2c.NewWiichuckDriver(firmataAdaptor)
 	wiichuck.Name = "wiichuck"
 
 	work := func() {
@@ -30,7 +30,7 @@ func main() {
 	}
 
 	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
+		Connections: []gobot.Connection{firmataAdaptor},
 		Devices:     []gobot.Device{wiichuck},
 		Work:        work,
 	}

firmata/examples/blink.go

@@ -1,32 +0,0 @@
-package main
-
-import (
-	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
-)
-
-func main() {
-
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
-
-	led := gobotGPIO.NewLed(firmata)
-	led.Name = "led"
-	led.Pin = "13"
-
-	work := func() {
-		gobot.Every("1s", func() {
-			led.Toggle()
-		})
-	}
-
-	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata},
-		Devices:     []gobot.Device{led},
-		Work:        work,
-	}
-
-	robot.Start()
-}

firmata/examples/cat_toy.go

@@ -1,55 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/hybridgroup/gobot"
-	"github.com/hybridgroup/gobot-firmata"
-	"github.com/hybridgroup/gobot-gpio"
-	"github.com/hybridgroup/gobot-leapmotion"
-)
-
-func main() {
-	firmata := new(gobotFirmata.FirmataAdaptor)
-	firmata.Name = "firmata"
-	firmata.Port = "/dev/ttyACM0"
-
-	servo1 := gobotGPIO.NewServo(firmata)
-	servo1.Name = "servo"
-	servo1.Pin = "5"
-
-	servo2 := gobotGPIO.NewServo(firmata)
-	servo2.Name = "servo"
-	servo2.Pin = "3"
-
-	leapAdaptor := new(gobotLeap.LeapAdaptor)
-	leapAdaptor.Name = "leap"
-	leapAdaptor.Port = "127.0.0.1:6437"
-
-	leap := gobotLeap.NewLeap(leapAdaptor)
-	leap.Name = "leap"
-
-	work := func() {
-		x := 90.0
-		z := 90.0
-		gobot.On(leap.Events["Message"], func(data interface{}) {
-			if len(data.(gobotLeap.LeapFrame).Hands) > 0 {
-				hand := data.(gobotLeap.LeapFrame).Hands[0]
-				x = gobot.ToScale(gobot.FromScale(hand.X(), -300, 300), 30, 150)
-				z = gobot.ToScale(gobot.FromScale(hand.Z(), -300, 300), 30, 150)
-			}
-		})
-		gobot.Every("0.01s", func() {
-			servo1.Move(uint8(x))
-			servo2.Move(uint8(z))
-			fmt.Println("Current Angle: ", servo1.CurrentAngle, ",", servo2.CurrentAngle)
-		})
-	}
-
-	robot := gobot.Robot{
-		Connections: []gobot.Connection{firmata, leapAdaptor},
-		Devices:     []gobot.Device{servo1, servo2, leap},
-		Work:        work,
-	}
-
-	robot.Start()
-}

firmata/firmata.go

@@ -1,4 +1,4 @@
-package gobotFirmata
+package firmata
 
 import (
 	"bytes"

firmata/firmata_adaptor.go

@@ -1,4 +1,4 @@
-package gobotFirmata
+package firmata
 
 import (
 	"fmt"
@@ -11,60 +11,64 @@ type FirmataAdaptor struct {
 	gobot.Adaptor
 	Board      *board
 	i2cAddress byte
+	connect    func(*FirmataAdaptor)
 }
 
-var connect = func(fa *FirmataAdaptor) {
-	sp, err := serial.OpenPort(&serial.Config{Name: fa.Port, Baud: 57600})
-	if err != nil {
-		panic(err)
+func NewFirmataAdaptor() *FirmataAdaptor {
+	return &FirmataAdaptor{
+		connect: func(f *FirmataAdaptor) {
+			sp, err := serial.OpenPort(&serial.Config{Name: f.Port, Baud: 57600})
+			if err != nil {
+				panic(err)
+			}
+			f.Board = newBoard(sp)
+		},
 	}
-	fa.Board = newBoard(sp)
 }
 
-func (fa *FirmataAdaptor) Connect() bool {
-	connect(fa)
-	fa.Board.connect()
-	fa.Connected = true
+func (f *FirmataAdaptor) Connect() bool {
+	f.connect(f)
+	f.Board.connect()
+	f.Connected = true
 	return true
 }
 
-func (da *FirmataAdaptor) Reconnect() bool { return true }
-func (da *FirmataAdaptor) Disconnect() bool {
-	err := da.Board.Serial.Close()
+func (f *FirmataAdaptor) Disconnect() bool {
+	err := f.Board.Serial.Close()
 	if err != nil {
 		fmt.Println(err)
 	}
 	return true
 }
-func (da *FirmataAdaptor) Finalize() bool { return da.Disconnect() }
+func (f *FirmataAdaptor) Finalize() bool { return f.Disconnect() }
 
-func (da *FirmataAdaptor) InitServo() {}
-func (da *FirmataAdaptor) ServoWrite(pin string, angle byte) {
+func (f *FirmataAdaptor) InitServo() {}
+func (f *FirmataAdaptor) ServoWrite(pin string, angle byte) {
 	p, _ := strconv.Atoi(pin)
 
-	da.Board.setPinMode(byte(p), SERVO)
-	da.Board.analogWrite(byte(p), angle)
+	f.Board.setPinMode(byte(p), SERVO)
+	f.Board.analogWrite(byte(p), angle)
 }
 
-func (da *FirmataAdaptor) PwmWrite(pin string, level byte) {
+func (f *FirmataAdaptor) PwmWrite(pin string, level byte) {
 	p, _ := strconv.Atoi(pin)
 
-	da.Board.setPinMode(byte(p), PWM)
-	da.Board.analogWrite(byte(p), level)
+	f.Board.setPinMode(byte(p), PWM)
+	f.Board.analogWrite(byte(p), level)
 }
 
-func (da *FirmataAdaptor) DigitalWrite(pin string, level byte) {
+func (f *FirmataAdaptor) DigitalWrite(pin string, level byte) {
 	p, _ := strconv.Atoi(pin)
 
-	da.Board.setPinMode(byte(p), OUTPUT)
-	da.Board.digitalWrite(byte(p), level)
+	f.Board.setPinMode(byte(p), OUTPUT)
+	f.Board.digitalWrite(byte(p), level)
 }
 
-func (da *FirmataAdaptor) DigitalRead(pin string) int {
+func (f *FirmataAdaptor) DigitalRead(pin string) int {
 	p, _ := strconv.Atoi(pin)
-	da.Board.setPinMode(byte(p), INPUT)
-	da.Board.togglePinReporting(byte(p), HIGH, REPORT_DIGITAL)
-	events := da.Board.findEvents(fmt.Sprintf("digital_read_%v", pin))
+	f.Board.setPinMode(byte(p), INPUT)
+	f.Board.togglePinReporting(byte(p), HIGH, REPORT_DIGITAL)
+	events := f.Board.findEvents(fmt.Sprintf("digital_read_%v", pin))
 	if len(events) > 0 {
 		return int(events[len(events)-1].Data[0])
 	}
@@ -72,12 +76,12 @@ func (da *FirmataAdaptor) DigitalRead(pin string) int {
 }
 
 // NOTE pins are numbered A0-A5, which translate to digital pins 14-19
-func (da *FirmataAdaptor) AnalogRead(pin string) int {
+func (f *FirmataAdaptor) AnalogRead(pin string) int {
 	p, _ := strconv.Atoi(pin)
-	p = da.digitalPin(p)
-	da.Board.setPinMode(byte(p), ANALOG)
-	da.Board.togglePinReporting(byte(p), HIGH, REPORT_ANALOG)
-	events := da.Board.findEvents(fmt.Sprintf("analog_read_%v", pin))
+	p = f.digitalPin(p)
+	f.Board.setPinMode(byte(p), ANALOG)
+	f.Board.togglePinReporting(byte(p), HIGH, REPORT_ANALOG)
+	events := f.Board.findEvents(fmt.Sprintf("analog_read_%v", pin))
 	if len(events) > 0 {
 		event := events[len(events)-1]
 		return int(uint(event.Data[0])<<24 | uint(event.Data[1])<<16 | uint(event.Data[2])<<8 | uint(event.Data[3]))
@@ -85,25 +89,25 @@ func (da *FirmataAdaptor) AnalogRead(pin string) int {
 	return -1
 }
 
-func (da *FirmataAdaptor) digitalPin(pin int) int {
+func (f *FirmataAdaptor) digitalPin(pin int) int {
 	return pin + 14
 }
 
-func (fa *FirmataAdaptor) I2cStart(address byte) {
-	fa.i2cAddress = address
-	fa.Board.i2cConfig([]uint16{0})
+func (f *FirmataAdaptor) I2cStart(address byte) {
+	f.i2cAddress = address
+	f.Board.i2cConfig([]uint16{0})
 }
 
-func (fa *FirmataAdaptor) I2cRead(size uint16) []uint16 {
-	fa.Board.i2cReadRequest(fa.i2cAddress, size)
+func (f *FirmataAdaptor) I2cRead(size uint16) []uint16 {
+	f.Board.i2cReadRequest(f.i2cAddress, size)
 
-	events := fa.Board.findEvents("i2c_reply")
+	events := f.Board.findEvents("i2c_reply")
 	if len(events) > 0 {
 		return events[len(events)-1].I2cReply["data"]
 	}
 	return make([]uint16, 0)
 }
 
-func (fa *FirmataAdaptor) I2cWrite(data []uint16) {
-	fa.Board.i2cWriteRequest(fa.i2cAddress, data)
+func (f *FirmataAdaptor) I2cWrite(data []uint16) {
+	f.Board.i2cWriteRequest(f.i2cAddress, data)
 }

firmata/firmata_adaptor_test.go

@@ -1,4 +1,4 @@
-package gobotFirmata
+package firmata
 
 import (
 	"fmt"
@@ -12,13 +12,13 @@ var _ = Describe("FirmataAdaptor", func() {
 	)
 
 	BeforeEach(func() {
-		connect = func(me *FirmataAdaptor) {
-			me.Board = newBoard(sp{})
-			me.Board.Events = append(me.Board.Events, event{Name: "firmware_query"})
-			me.Board.Events = append(me.Board.Events, event{Name: "capability_query"})
-			me.Board.Events = append(me.Board.Events, event{Name: "analog_mapping_query"})
+		adaptor = NewFirmataAdaptor()
+		adaptor.connect = func(f *FirmataAdaptor) {
+			f.Board = newBoard(sp{})
+			f.Board.Events = append(f.Board.Events, event{Name: "firmware_query"})
+			f.Board.Events = append(f.Board.Events, event{Name: "capability_query"})
+			f.Board.Events = append(f.Board.Events, event{Name: "analog_mapping_query"})
 		}
-		adaptor = new(FirmataAdaptor)
 		adaptor.Connect()
 	})
 
@@ -28,9 +28,6 @@ var _ = Describe("FirmataAdaptor", func() {
 	It("Must be able to Disconnect", func() {
 		Expect(adaptor.Disconnect()).To(Equal(true))
 	})
-	It("Must be able to Reconnect", func() {
-		Expect(adaptor.Reconnect()).To(Equal(true))
-	})
 	It("Must be able to InitServo", func() {
 		adaptor.InitServo()
 	})

firmata/gobot-firmata_suite_test.go

@@ -1,4 +1,4 @@
-package gobotFirmata
+package firmata
 
 import (
 	. "github.com/onsi/ginkgo"

firmata/test_helper.go

@@ -1,13 +1,13 @@
-package gobotFirmata
+package firmata
 
 type sp struct{}
 
-func (me sp) Write(b []byte) (int, error) {
+func (s sp) Write(b []byte) (int, error) {
 	return len(b), nil
 }
-func (me sp) Read(b []byte) (int, error) {
+func (s sp) Read(b []byte) (int, error) {
 	return len(b), nil
 }
-func (me sp) Close() error {
+func (s sp) Close() error {
 	return nil
 }