本文整理汇总了Golang中github.com/hybridgroup/gobot.NewCommander函数的典型用法代码示例。如果您正苦于以下问题:Golang NewCommander函数的具体用法?Golang NewCommander怎么用?Golang NewCommander使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NewCommander函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: NewLedDriver
// 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
}
示例2: NewAdafruitMotorHatDriver
// 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
}
示例3: NewServoDriver
// 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
}
示例4: NewJenkinsconnectDriver
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
}
示例5: NewMCP23017Driver
// 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
}
示例6: NewDirectPinDriver
// 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
}
示例7: NewRgbLedDriver
// 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
}
示例8: NewPebbleDriver
// 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
}
示例9: NewBlinkMDriver
// 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
}
示例10: NewAnalogSensorDriver
// 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
}
示例11: NewAudioDriver
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
}
示例12: NewPingDriver
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
}
示例13: NewGpsdDriver
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
}
示例14: NewFurbyDriver
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
}
示例15: NewRelayDriver
// 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
}