// NewLedDriver return a new LedDriver given a DigitalWriter, name and pin.
//
// Adds the following API Commands:
// "Brightness" - See LedDriver.Brightness
// "Toggle" - See LedDriver.Toggle
// "On" - See LedDriver.On
// "Off" - See LedDriver.Off
func NewLedDriver(a DigitalWriter, name string, pin string) *LedDriver {
l := &LedDriver{
name: name,
pin: pin,
connection: a,
high: false,
Commander: gobot.NewCommander(),
}
l.AddCommand("Brightness", func(params map[string]interface{}) interface{} {
level := byte(params["level"].(float64))
return l.Brightness(level)
})
l.AddCommand("Toggle", func(params map[string]interface{}) interface{} {
return l.Toggle()
})
l.AddCommand("On", func(params map[string]interface{}) interface{} {
return l.On()
})
l.AddCommand("Off", func(params map[string]interface{}) interface{} {
return l.Off()
})
return l
}
// NewAdafruitMotorHatDriver initializes the internal DCMotor and StepperMotor types.
// Again the Adafruit Motor Hat supports up to four DC motors and up to two stepper motors.
func NewAdafruitMotorHatDriver(a I2c, name string) *AdafruitMotorHatDriver {
var dc []adaFruitDCMotor
var st []adaFruitStepperMotor
for i := 0; i < 4; i++ {
switch {
case i == 0:
dc = append(dc, adaFruitDCMotor{pwmPin: 8, in1Pin: 10, in2Pin: 9})
st = append(st, adaFruitStepperMotor{pwmPinA: 8, pwmPinB: 13,
ain1: 10, ain2: 9, bin1: 11, bin2: 12, revSteps: 200, secPerStep: 0.1})
case i == 1:
dc = append(dc, adaFruitDCMotor{pwmPin: 13, in1Pin: 11, in2Pin: 12})
st = append(st, adaFruitStepperMotor{pwmPinA: 2, pwmPinB: 7,
ain1: 4, ain2: 3, bin1: 5, bin2: 6, revSteps: 200, secPerStep: 0.1})
case i == 2:
dc = append(dc, adaFruitDCMotor{pwmPin: 2, in1Pin: 4, in2Pin: 3})
case i == 3:
dc = append(dc, adaFruitDCMotor{pwmPin: 7, in1Pin: 5, in2Pin: 6})
}
}
driver := &AdafruitMotorHatDriver{
name: name,
connection: a,
Commander: gobot.NewCommander(),
dcMotors: dc,
stepperMotors: st,
}
// TODO: add API funcs?
return driver
}
// NewServoDriver returns a new ServoDriver given a ServoWriter, name and pin.
//
// Adds the following API Commands:
// "Move" - See ServoDriver.Move
// "Min" - See ServoDriver.Min
// "Center" - See ServoDriver.Center
// "Max" - See ServoDriver.Max
func NewServoDriver(a ServoWriter, name string, pin string) *ServoDriver {
s := &ServoDriver{
name: name,
connection: a,
pin: pin,
Commander: gobot.NewCommander(),
CurrentAngle: 0,
}
s.AddCommand("Move", func(params map[string]interface{}) interface{} {
angle := byte(params["angle"].(float64))
return s.Move(angle)
})
s.AddCommand("Min", func(params map[string]interface{}) interface{} {
return s.Min()
})
s.AddCommand("Center", func(params map[string]interface{}) interface{} {
return s.Center()
})
s.AddCommand("Max", func(params map[string]interface{}) interface{} {
return s.Max()
})
return s
}
func NewJenkinsconnectDriver(a *JenkinsconnectAdaptor, name string) *JenkinsconnectDriver {
j := &JenkinsconnectDriver{
name: name,
connection: a,
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
}
j.AddEvent(JobResult)
j.AddCommand("ParseResults", func(params map[string]interface{}) interface{} {
var snapshot JobOutcomeSnapshot
result := ParseJobState(params)
if (JobOutcome{}) != result {
fmt.Printf("Result: %v\n", result)
lastOutcome, ok := jobStates[result.Name]
if ok {
fmt.Printf("Last outcome: %v\n", lastOutcome)
}
snapshot.Outcome = result
snapshot.RanAt = time.Now()
jobStates[result.Name] = snapshot
gobot.Publish(j.Event(JobResult), result)
}
return result
})
return j
}
// NewMCP23017Driver creates a new driver with specified name and i2c interface.
func NewMCP23017Driver(a I2c, name string, conf MCP23017Config, deviceAddress int, v ...time.Duration) *MCP23017Driver {
m := &MCP23017Driver{
name: name,
connection: a,
conf: conf,
mcp23017Address: deviceAddress,
Commander: gobot.NewCommander(),
Eventer: gobot.NewEventer(),
}
m.AddCommand("WriteGPIO", func(params map[string]interface{}) interface{} {
pin := params["pin"].(float64)
val := params["val"].(float64)
port := params["port"].(string)
return m.WriteGPIO(pin, val, port)
})
m.AddCommand("ReadGPIO", func(params map[string]interface{}) interface{} {
pin := params["pin"].(float64)
port := params["port"].(string)
val, err := m.ReadGPIO(pin, port)
return map[string]interface{}{"val": val, "err": err}
})
return m
}
// NewDirectPinDriver return a new DirectPinDriver given a Connection, name and pin.
//
// Adds the following API Commands:
// "DigitalRead" - See DirectPinDriver.DigitalRead
// "DigitalWrite" - See DirectPinDriver.DigitalWrite
// "AnalogRead" - See DirectPinDriver.AnalogRead
// "AnalogWrite" - See DirectPinDriver.AnalogWrite
// "PwmWrite" - See DirectPinDriver.PwmWrite
// "ServoWrite" - See DirectPinDriver.ServoWrite
func NewDirectPinDriver(a gobot.Connection, name string, pin string) *DirectPinDriver {
d := &DirectPinDriver{
name: name,
connection: a,
pin: pin,
Commander: gobot.NewCommander(),
}
d.AddCommand("DigitalRead", func(params map[string]interface{}) interface{} {
val, err := d.DigitalRead()
return map[string]interface{}{"val": val, "err": err}
})
d.AddCommand("DigitalWrite", func(params map[string]interface{}) interface{} {
level, _ := strconv.Atoi(params["level"].(string))
return d.DigitalWrite(byte(level))
})
d.AddCommand("AnalogRead", func(params map[string]interface{}) interface{} {
val, err := d.AnalogRead()
return map[string]interface{}{"val": val, "err": err}
})
d.AddCommand("PwmWrite", func(params map[string]interface{}) interface{} {
level, _ := strconv.Atoi(params["level"].(string))
return d.PwmWrite(byte(level))
})
d.AddCommand("ServoWrite", func(params map[string]interface{}) interface{} {
level, _ := strconv.Atoi(params["level"].(string))
return d.ServoWrite(byte(level))
})
return d
}
// NewRgbLedDriver return a new RgbLedDriver given a DigitalWriter, name and
// 3 pins: redPin, greenPin, and bluePin
//
// Adds the following API Commands:
// "SetRGB" - See RgbLedDriver.SetRGB
// "Toggle" - See RgbLedDriver.Toggle
// "On" - See RgbLedDriver.On
// "Off" - See RgbLedDriver.Off
func NewRgbLedDriver(a DigitalWriter, name string, redPin string, greenPin string, bluePin string) *RgbLedDriver {
l := &RgbLedDriver{
name: name,
pinRed: redPin,
pinGreen: greenPin,
pinBlue: bluePin,
connection: a,
high: false,
Commander: gobot.NewCommander(),
}
l.AddCommand("SetRGB", func(params map[string]interface{}) interface{} {
r := byte(params["r"].(int))
g := byte(params["g"].(int))
b := byte(params["b"].(int))
return l.SetRGB(r, g, b)
})
l.AddCommand("Toggle", func(params map[string]interface{}) interface{} {
return l.Toggle()
})
l.AddCommand("On", func(params map[string]interface{}) interface{} {
return l.On()
})
l.AddCommand("Off", func(params map[string]interface{}) interface{} {
return l.Off()
})
return l
}
// NewPebbleDriver creates a new pebble driver with specified name
// Adds following events:
// button - Sent when a pebble button is pressed
// accel - Pebble watch acceleromenter data
// tab - When a pebble watch tap event is detected
// And the following API commands:
// "publish_event"
// "send_notification"
// "pending_message"
func NewPebbleDriver(adaptor *PebbleAdaptor, name string) *PebbleDriver {
p := &PebbleDriver{
name: name,
connection: adaptor,
Messages: []string{},
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
}
p.AddEvent("button")
p.AddEvent("accel")
p.AddEvent("tap")
p.AddCommand("publish_event", func(params map[string]interface{}) interface{} {
p.PublishEvent(params["name"].(string), params["data"].(string))
return nil
})
p.AddCommand("send_notification", func(params map[string]interface{}) interface{} {
p.SendNotification(params["message"].(string))
return nil
})
p.AddCommand("pending_message", func(params map[string]interface{}) interface{} {
return p.PendingMessage()
})
return p
}
// NewBlinkMDriver creates a new BlinkMDriver with specified name.
//
// Adds the following API commands:
// Rgb - sets RGB color
// Fade - fades the RGB color
// FirmwareVersion - returns the version of the current Frimware
// Color - returns the color of the LED.
func NewBlinkMDriver(a I2c, name string) *BlinkMDriver {
b := &BlinkMDriver{
name: name,
connection: a,
Commander: gobot.NewCommander(),
}
b.AddCommand("Rgb", func(params map[string]interface{}) interface{} {
red := byte(params["red"].(float64))
green := byte(params["green"].(float64))
blue := byte(params["blue"].(float64))
return b.Rgb(red, green, blue)
})
b.AddCommand("Fade", func(params map[string]interface{}) interface{} {
red := byte(params["red"].(float64))
green := byte(params["green"].(float64))
blue := byte(params["blue"].(float64))
return b.Fade(red, green, blue)
})
b.AddCommand("FirmwareVersion", func(params map[string]interface{}) interface{} {
version, err := b.FirmwareVersion()
return map[string]interface{}{"version": version, "err": err}
})
b.AddCommand("Color", func(params map[string]interface{}) interface{} {
color, err := b.Color()
return map[string]interface{}{"color": color, "err": err}
})
return b
}
// NewAnalogSensorDriver returns a new AnalogSensorDriver with a polling interval of
// 10 Milliseconds given an AnalogReader, name and pin.
//
// Optinally accepts:
// time.Duration: Interval at which the AnalogSensor is polled for new information
//
// Adds the following API Commands:
// "Read" - See AnalogSensor.Read
func NewAnalogSensorDriver(a AnalogReader, name string, pin string, v ...time.Duration) *AnalogSensorDriver {
d := &AnalogSensorDriver{
name: name,
connection: a,
pin: pin,
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
interval: 10 * time.Millisecond,
halt: make(chan bool),
}
if len(v) > 0 {
d.interval = v[0]
}
d.AddEvent(Data)
d.AddEvent(Error)
d.AddCommand("Read", func(params map[string]interface{}) interface{} {
val, err := d.Read()
return map[string]interface{}{"val": val, "err": err}
})
return d
}
func NewAudioDriver(a *AudioAdaptor, name string, filename string) *AudioDriver {
d := &AudioDriver{
name: name,
connection: a,
interval: 500 * time.Millisecond,
filename: filename,
halt: make(chan bool, 0),
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
}
return d
}
func NewPingDriver(adaptor *loopbackAdaptor, name string, pin string) *pingDriver {
t := &pingDriver{
name: name,
connection: adaptor,
pin: pin,
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
}
t.AddEvent("ping")
t.AddCommand("ping", func(params map[string]interface{}) interface{} {
return t.Ping()
})
return t
}
func NewGpsdDriver(adaptor *GpsdAdaptor, name string, t ...time.Duration) *GpsdDriver {
gpsd := &GpsdDriver{
name: name,
halt: make(chan bool),
pause: make(chan bool),
interval: time.Second,
r: adaptor,
w: adaptor,
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
}
if len(t) > 0 {
gpsd.interval = t[0]
}
gpsd.AddEvent(TPV)
gpsd.AddEvent(ERROR)
return gpsd
}
func NewFurbyDriver(a gpio.DigitalWriter, name string, pin string, soundQueue chan string) *FurbyDriver {
f := &FurbyDriver{
name: name,
pin: pin,
connection: a,
high: false,
soundQueue: soundQueue,
Commander: gobot.NewCommander(),
}
f.AddCommand("Toggle", func(params map[string]interface{}) interface{} {
return f.Toggle()
})
f.AddCommand("On", func(params map[string]interface{}) interface{} {
return f.On()
})
f.AddCommand("Off", func(params map[string]interface{}) interface{} {
return f.Off()
})
return f
}
// NewRelayDriver return a new RelayDriver given a DigitalWriter, name and pin.
//
// Adds the following API Commands:
// "Toggle" - See RelayDriver.Toggle
// "On" - See RelayDriver.On
// "Off" - See RelayDriver.Off
func NewRelayDriver(a DigitalWriter, name string, pin string) *RelayDriver {
l := &RelayDriver{
name: name,
pin: pin,
connection: a,
high: false,
Commander: gobot.NewCommander(),
}
l.AddCommand("Toggle", func(params map[string]interface{}) interface{} {
return l.Toggle()
})
l.AddCommand("On", func(params map[string]interface{}) interface{} {
return l.On()
})
l.AddCommand("Off", func(params map[string]interface{}) interface{} {
return l.Off()
})
return l
}
func newTestDriver(adaptor *testAdaptor, name string, pin string) *testDriver {
t := &testDriver{
name: name,
connection: adaptor,
pin: pin,
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
}
t.AddEvent("TestEvent")
t.AddCommand("TestDriverCommand", func(params map[string]interface{}) interface{} {
name := params["name"].(string)
return fmt.Sprintf("hello %v", name)
})
t.AddCommand("DriverCommand", func(params map[string]interface{}) interface{} {
name := params["name"].(string)
return fmt.Sprintf("hello %v", name)
})
return t
}
// NewSpheroDriver returns a new SpheroDriver given a SpheroAdaptor and name.
//
// Adds the following API Commands:
// "ConfigureLocator" - See SpheroDriver.ConfigureLocator
// "Roll" - See SpheroDriver.Roll
// "Stop" - See SpheroDriver.Stop
// "GetRGB" - See SpheroDriver.GetRGB
// "ReadLocator" - See SpheroDriver.ReadLocator
// "SetBackLED" - See SpheroDriver.SetBackLED
// "SetHeading" - See SpheroDriver.SetHeading
// "SetStabilization" - See SpheroDriver.SetStabilization
// "SetDataStreaming" - See SpheroDriver.SetDataStreaming
// "SetRotationRate" - See SpheroDriver.SetRotationRate
func NewSpheroDriver(a *SpheroAdaptor, name string) *SpheroDriver {
s := &SpheroDriver{
name: name,
connection: a,
Eventer: gobot.NewEventer(),
Commander: gobot.NewCommander(),
packetChannel: make(chan *packet, 1024),
responseChannel: make(chan []uint8, 1024),
}
s.AddEvent(Error)
s.AddEvent(Collision)
s.AddEvent(SensorData)
s.AddCommand("SetRGB", func(params map[string]interface{}) interface{} {
r := uint8(params["r"].(float64))
g := uint8(params["g"].(float64))
b := uint8(params["b"].(float64))
s.SetRGB(r, g, b)
return nil
})
s.AddCommand("Roll", func(params map[string]interface{}) interface{} {
speed := uint8(params["speed"].(float64))
heading := uint16(params["heading"].(float64))
s.Roll(speed, heading)
return nil
})
s.AddCommand("Stop", func(params map[string]interface{}) interface{} {
s.Stop()
return nil
})
s.AddCommand("GetRGB", func(params map[string]interface{}) interface{} {
return s.GetRGB()
})
s.AddCommand("ReadLocator", func(params map[string]interface{}) interface{} {
return s.ReadLocator()
})
s.AddCommand("SetBackLED", func(params map[string]interface{}) interface{} {
level := uint8(params["level"].(float64))
s.SetBackLED(level)
return nil
})
s.AddCommand("SetRotationRate", func(params map[string]interface{}) interface{} {
level := uint8(params["level"].(float64))
s.SetRotationRate(level)
return nil
})
s.AddCommand("SetHeading", func(params map[string]interface{}) interface{} {
heading := uint16(params["heading"].(float64))
s.SetHeading(heading)
return nil
})
s.AddCommand("SetStabilization", func(params map[string]interface{}) interface{} {
on := params["enable"].(bool)
s.SetStabilization(on)
return nil
})
s.AddCommand("SetDataStreaming", func(params map[string]interface{}) interface{} {
N := uint16(params["N"].(float64))
M := uint16(params["M"].(float64))
Mask := uint32(params["Mask"].(float64))
Pcnt := uint8(params["Pcnt"].(float64))
Mask2 := uint32(params["Mask2"].(float64))
s.SetDataStreaming(DataStreamingConfig{N: N, M: M, Mask2: Mask2, Pcnt: Pcnt, Mask: Mask})
return nil
})
s.AddCommand("ConfigureLocator", func(params map[string]interface{}) interface{} {
Flags := uint8(params["Flags"].(float64))
X := int16(params["X"].(float64))
Y := int16(params["Y"].(float64))
YawTare := int16(params["YawTare"].(float64))
s.ConfigureLocator(LocatorConfig{Flags: Flags, X: X, Y: Y, YawTare: YawTare})
return nil
})
return s
}