func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Get("/brain/:a", func(res http.ResponseWriter, req *http.Request) {
path := req.URL.Path
t := strings.Split(path, "/")
buf, err := Asset("assets/" + t[2])
if err != nil {
http.Error(res, err.Error(), http.StatusNotFound)
return
}
t = strings.Split(path, ".")
if t[len(t)-1] == "js" {
res.Header().Set("Content-Type", "text/javascript; charset=utf-8")
} else if t[len(t)-1] == "css" {
res.Header().Set("Content-Type", "text/css; charset=utf-8")
}
res.Write(buf)
})
adaptor := neurosky.NewNeuroskyAdaptor("neurosky", "/dev/rfcomm0")
neuro := neurosky.NewNeuroskyDriver(adaptor, "neurosky")
gbot.AddRobot(gobot.NewRobot("brain",
[]gobot.Connection{adaptor},
[]gobot.Device{neuro},
))
a.Start()
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Start()
board := edison.NewEdisonAdaptor("edison")
button = gpio.NewGroveButtonDriver(board, "button", "2")
blue = gpio.NewGroveLedDriver(board, "blue", "3")
green = gpio.NewGroveLedDriver(board, "green", "4")
work := func() {
Reset()
gobot.On(button.Event(gpio.Push), func(data interface{}) {
TurnOff()
fmt.Println("On!")
blue.On()
})
gobot.On(button.Event(gpio.Release), func(data interface{}) {
Reset()
})
}
robot := gobot.NewRobot("airlock",
[]gobot.Connection{board},
[]gobot.Device{button, blue, green},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.AddHandler(api.BasicAuth("gort", "klatuu"))
a.Debug()
a.AddHandler(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q \n", html.EscapeString(r.URL.Path))
})
a.Start()
gbot.AddCommand("custom_gobot_command",
func(params map[string]interface{}) interface{} {
return "This command is attached to the mcp!"
})
hello := gbot.AddRobot(gobot.NewRobot("hello"))
hello.AddCommand("hi_there", func(params map[string]interface{}) interface{} {
return fmt.Sprintf("This command is attached to the robot %v", hello.Name)
})
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Port = "8080"
a.Start()
pebbleAdaptor := pebble.NewPebbleAdaptor("pebble")
pebbleDriver := pebble.NewPebbleDriver(pebbleAdaptor, "pebble")
work := func() {
gobot.On(pebbleDriver.Event("accel"), func(data interface{}) {
fmt.Println(data.(string))
})
}
robot := gobot.NewRobot("pebble",
[]gobot.Connection{pebbleAdaptor},
[]gobot.Device{pebbleDriver},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
gbot.AddCommand("echo", func(params map[string]interface{}) interface{} {
return params["a"]
})
loopback := NewLoopbackAdaptor("loopback", "/dev/null")
ping := NewPingDriver(loopback, "ping", "1")
work := func() {
gobot.Every(5*time.Second, func() {
fmt.Println(ping.Ping())
})
}
r := gobot.NewRobot("TestBot",
[]gobot.Connection{loopback},
[]gobot.Device{ping},
work,
)
r.AddCommand("hello", func(params map[string]interface{}) interface{} {
return fmt.Sprintf("Hello, %v!", params["greeting"])
})
gbot.AddRobot(r)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Start()
// digital
board := edison.NewEdisonAdaptor("edison")
button = gpio.NewGroveButtonDriver(board, "button", "2")
blue = gpio.NewGroveLedDriver(board, "blue", "3")
green = gpio.NewGroveLedDriver(board, "green", "4")
red = gpio.NewGroveLedDriver(board, "red", "5")
buzzer = gpio.NewGroveBuzzerDriver(board, "buzzer", "7")
touch = gpio.NewGroveTouchDriver(board, "touch", "8")
// analog
rotary = gpio.NewGroveRotaryDriver(board, "rotary", "0")
sensor = gpio.NewGroveTemperatureSensorDriver(board, "sensor", "1")
sound = gpio.NewGroveSoundSensorDriver(board, "sound", "2")
work := func() {
Reset()
gobot.On(button.Event(gpio.Push), func(data interface{}) {
TurnOff()
fmt.Println("On!")
blue.On()
})
gobot.On(button.Event(gpio.Release), func(data interface{}) {
Reset()
})
gobot.On(touch.Event(gpio.Push), func(data interface{}) {
Doorbell()
})
gobot.On(rotary.Event("data"), func(data interface{}) {
fmt.Println("rotary", data)
})
gobot.On(sound.Event("data"), func(data interface{}) {
DetectSound(data.(int))
})
gobot.Every(1*time.Second, func() {
CheckFireAlarm()
})
}
robot := gobot.NewRobot("airlock",
[]gobot.Connection{board},
[]gobot.Device{button, blue, green, red, buzzer, touch, rotary, sensor, sound},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
e := edison.NewEdisonAdaptor("edison")
button := gpio.NewButtonDriver(e, "myButton", "2")
led := gpio.NewLedDriver(e, "myLed", "4")
work := func() {
gobot.On(button.Event("push"), func(data interface{}) {
led.On()
})
gobot.On(button.Event("release"), func(data interface{}) {
led.Off()
})
}
robot := gobot.NewRobot("buttonBot",
[]gobot.Connection{e},
[]gobot.Device{led, button},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api := api.NewAPI(gbot)
api.Port = "8080"
api.Start()
pebbleAdaptor := pebble.NewPebbleAdaptor("pebble")
pebbleDriver := pebble.NewPebbleDriver(pebbleAdaptor, "pebble")
work := func() {
pebbleDriver.SendNotification("Hello Pebble!")
pebbleDriver.On(pebbleDriver.Event("button"), func(data interface{}) {
fmt.Println("Button pushed: " + data.(string))
})
pebbleDriver.On(pebbleDriver.Event("tap"), func(data interface{}) {
fmt.Println("Tap event detected")
})
}
robot := gobot.NewRobot("pebble",
[]gobot.Connection{pebbleAdaptor},
[]gobot.Device{pebbleDriver},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
spheros := map[string]string{
"Sphero-BPO": "/dev/rfcomm0",
}
for name, port := range spheros {
spheroAdaptor := sphero.NewSpheroAdaptor("sphero", port)
spheroDriver := sphero.NewSpheroDriver(spheroAdaptor, "sphero")
work := func() {
spheroDriver.SetRGB(uint8(255), uint8(0), uint8(0))
}
robot := gobot.NewRobot(name,
[]gobot.Connection{spheroAdaptor},
[]gobot.Device{spheroDriver},
work,
)
robot.AddCommand("turn_blue", func(params map[string]interface{}) interface{} {
spheroDriver.SetRGB(uint8(0), uint8(0), uint8(255))
return nil
})
gbot.AddRobot(robot)
}
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
e := edison.NewEdisonAdaptor("edison")
board_led := gpio.NewLedDriver(e, "led", "13")
red_led := gpio.NewLedDriver(e, "led", "3")
green_led := gpio.NewLedDriver(e, "led", "2")
buzzer := gpio.NewBuzzerDriver(e, "buzzer", "4")
// Blink the Board LED
board_blink_work := func() {
gobot.Every(10*time.Second, func() {
board_led.Toggle()
})
}
// Ring the buzzer
buzzer_work := func() {
gobot.Every(4*time.Second, func() {
buzzer.Tone(gpio.G5, gpio.Eighth)
})
}
board_blink_bot := gobot.NewRobot("Board LED",
[]gobot.Connection{e},
[]gobot.Device{board_led},
board_blink_work,
)
buzz_bot := gobot.NewRobot("buzzBot",
[]gobot.Connection{e},
[]gobot.Device{buzzer},
buzzer_work,
)
red_blink_bot := gobot.NewRobot("Red LED",
[]gobot.Connection{e},
[]gobot.Device{red_led},
)
green_blink_bot := gobot.NewRobot("Green LED",
[]gobot.Connection{e},
[]gobot.Device{green_led},
)
gbot.AddRobot(board_blink_bot)
gbot.AddRobot(green_blink_bot)
gbot.AddRobot(red_blink_bot)
gbot.AddRobot(buzz_bot)
a := api.NewAPI(gbot)
a.Debug()
a.Start()
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
digisparkAdaptor := digispark.NewDigisparkAdaptor("Digispark")
led := gpio.NewLedDriver(digisparkAdaptor, "led", "0")
gbot.Robots = append(gbot.Robots,
gobot.NewRobot("digispark", []gobot.Connection{digisparkAdaptor}, []gobot.Device{led}, nil))
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Start()
board := firmata.NewFirmataAdaptor("arduino", os.Args[1])
// digital devices
button = gpio.NewButtonDriver(board, "button", "2")
blue = gpio.NewLedDriver(board, "blue", "3")
green = gpio.NewLedDriver(board, "green", "4")
buzzer = gpio.NewGroveBuzzerDriver(board, "buzzer", "7")
touch = gpio.NewButtonDriver(board, "touch", "8")
// analog devices
light = gpio.NewAnalogSensorDriver(board, "light", "0")
work := func() {
Reset()
gobot.On(button.Event(gpio.Push), func(data interface{}) {
TurnOff()
fmt.Println("On!")
blue.On()
})
gobot.On(button.Event(gpio.Release), func(data interface{}) {
Reset()
})
gobot.On(touch.Event(gpio.Push), func(data interface{}) {
Doorbell()
})
gobot.On(light.Event("data"), func(data interface{}) {
fmt.Println("light", data)
})
}
robot := gobot.NewRobot("airlock",
[]gobot.Connection{board},
[]gobot.Device{button, blue, green, buzzer, touch, light},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
gbot.AddCommand("CustomGobotCommand", func(params map[string]interface{}) interface{} {
return "This command is attached to the master!"
})
hello := gbot.AddRobot(gobot.NewRobot("hello"))
hello.AddCommand("HiThere", func(params map[string]interface{}) interface{} {
return fmt.Sprintf("This command is attached to the robot %v", hello.Name)
})
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
gbot.AddCommand("pump", func(params map[string]interface{}) interface{} {
return gbot.Robot("mqtt").Connection("mqtt").(*mqtt.MqttAdaptor).Publish("startPump", []byte{})
})
gbot.AddCommand("fault", func(params map[string]interface{}) interface{} {
return gbot.Robot("mqtt").Connection("mqtt").(*mqtt.MqttAdaptor).Publish("startFault", []byte{})
})
gbot.AddRobot(hqRobot())
gbot.AddRobot(pebbleRobot())
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
server := api.NewAPI(gbot)
server.Username = "******"
server.Password = "******"
server.Start()
hello := gbot.AddRobot(gobot.NewRobot("hello"))
hello.AddCommand("hi_there", func(params map[string]interface{}) interface{} {
return []string{fmt.Sprintf("Hey"), fmt.Sprintf("dude!")}
})
gbot.Start()
}
func main() {
fmt.Println("[+] Relay going HIGH")
setDirectPin(ON)
time.Sleep(2000 * time.Millisecond)
fmt.Println("[+] Relay going LOW")
setDirectPin(OFF)
// Create our collection of 'robots'
gbot := gobot.NewGobot()
// Start our web server for REST-based control/information
server := api.NewAPI(gbot)
server.Port = "7337"
server.Start()
blinkLedOverAndOver(gbot)
}
func main() {
master := gobot.NewGobot()
server := api.NewAPI(master)
server.Username = "******"
server.Password = "******"
server.Start()
hello := gobot.NewRobot("hello", nil, nil, nil)
hello.AddCommand("HiThere", func(params map[string]interface{}) interface{} {
return []string{fmt.Sprintf("Hey"), fmt.Sprintf("dude!")}
})
master.Robots = append(master.Robots, hello)
master.Start()
}
func main() {
master := gobot.NewGobot()
api.NewAPI(master).Start()
sparkCore := spark.NewSparkCoreAdaptor("spark", "device_id", "access_token")
led := gpio.NewLedDriver(sparkCore, "led", "D7")
work := func() {
gobot.Every(1*time.Second, func() {
led.Toggle()
})
}
master.Robots = append(master.Robots,
gobot.NewRobot("spark", []gobot.Connection{sparkCore}, []gobot.Device{led}, work))
master.Start()
}
func main() {
master := gobot.NewGobot()
api.NewAPI(master).Start()
pebbleAdaptor := pebble.NewPebbleAdaptor("pebble")
pebbleDriver := pebble.NewPebbleDriver(pebbleAdaptor, "pebble")
work := func() {
gobot.On(pebbleDriver.Events["accel"], func(data interface{}) {
fmt.Println(data.(string))
})
}
robot := gobot.NewRobot("pebble", []gobot.Connection{pebbleAdaptor}, []gobot.Device{pebbleDriver}, work)
master.Robots = append(master.Robots, robot)
master.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
firmataAdaptor := firmata.NewFirmataAdaptor("arduino", "/dev/ttyACM0")
led11 := gpio.NewLedDriver(firmataAdaptor, "led11", "11")
led12 := gpio.NewLedDriver(firmataAdaptor, "led12", "12")
led13 := gpio.NewLedDriver(firmataAdaptor, "led13", "13")
robot := gobot.NewRobot("minions-bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{led11, led12, led13},
nil,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
sparkCore := spark.NewSparkCoreAdaptor("spark", "device_id", "access_token")
led := gpio.NewLedDriver(sparkCore, "led", "D7")
work := func() {
gobot.Every(1*time.Second, func() {
led.Toggle()
})
}
robot := gobot.NewRobot("spark",
[]gobot.Connection{sparkCore},
[]gobot.Device{led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
master := gobot.NewGobot()
api.NewAPI(master).Start()
pebbleAdaptor := pebble.NewPebbleAdaptor("pebble")
pebbleDriver := pebble.NewPebbleDriver(pebbleAdaptor, "pebble")
work := func() {
pebbleDriver.SendNotification("Hello Pebble!")
gobot.On(pebbleDriver.Events["button"], func(data interface{}) {
fmt.Println("Button pushed: " + data.(string))
})
gobot.On(pebbleDriver.Events["tap"], func(data interface{}) {
fmt.Println("Tap event detected")
})
}
robot := gobot.NewRobot("pebble", []gobot.Connection{pebbleAdaptor}, []gobot.Device{pebbleDriver}, work)
master.Robots = append(master.Robots, robot)
master.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Start()
board := firmata.NewFirmataAdaptor("arduino", os.Args[1])
// digital devices
button = gpio.NewButtonDriver(board, "button", "2")
blue = gpio.NewLedDriver(board, "blue", "3")
green = gpio.NewLedDriver(board, "green", "4")
work := func() {
Reset()
gobot.On(button.Event(gpio.Push), func(data interface{}) {
TurnOff()
fmt.Println("On!")
blue.On()
})
gobot.On(button.Event(gpio.Release), func(data interface{}) {
Reset()
})
}
robot := gobot.NewRobot("airlock",
[]gobot.Connection{board},
[]gobot.Device{button, blue, green},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Start()
conn := sphero.NewSpheroAdaptor("Sphero", "/dev/rfcomm0")
ball := sphero.NewSpheroDriver(conn, "sphero")
robot := gobot.NewRobot("sphero-dpad",
[]gobot.Connection{conn},
[]gobot.Device{ball},
)
robot.AddCommand("move", func(params map[string]interface{}) interface{} {
direction := params["direction"].(string)
switch direction {
case "up":
ball.Roll(100, 0)
case "down":
ball.Roll(100, 180)
case "left":
ball.Roll(100, 270)
case "right":
ball.Roll(100, 90)
}
time.Sleep(2 * time.Second)
ball.Stop()
return "ok"
})
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
if gobot.Version() != "0.7.dev" {
panic("this requires the dev branch!")
}
summary := &telemetry{Status: "STANDBY"}
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Get("/mavlink/:a", func(res http.ResponseWriter, req *http.Request) {
path := req.URL.Path
t := strings.Split(path, "/")
buf, err := Asset("assets/" + t[2])
if err != nil {
http.Error(res, err.Error(), http.StatusNotFound)
return
}
t = strings.Split(path, ".")
if t[len(t)-1] == "js" {
res.Header().Set("Content-Type", "text/javascript; charset=utf-8")
} else if t[len(t)-1] == "css" {
res.Header().Set("Content-Type", "text/css; charset=utf-8")
}
res.Write(buf)
})
adaptor := mavlink.NewMavlinkAdaptor("iris", "/dev/ttyACM0")
iris := mavlink.NewMavlinkDriver(adaptor, "iris")
work := func() {
iris.AddEvent("telemetry")
gobot.Once(iris.Event("packet"), func(data interface{}) {
fmt.Println(data)
packet := data.(*common.MAVLinkPacket)
dataStream := common.NewRequestDataStream(10,
packet.SystemID,
packet.ComponentID,
0,
1,
)
iris.SendPacket(common.CraftMAVLinkPacket(packet.SystemID,
packet.ComponentID,
dataStream,
))
})
gobot.On(iris.Event("message"), func(data interface{}) {
fmt.Println("message: ", data.(common.MAVLinkMessage).Id())
if data.(common.MAVLinkMessage).Id() == 0 {
statusCodes := map[uint8]string{
1: "BOOT",
2: "CALIBRATING",
3: "STANDBY",
4: "ACTIVE",
5: "CRITICAL",
6: "EMERGENCY",
7: "POWEROFF",
8: "ENUM_END",
}
summary.Status = statusCodes[data.(*common.Heartbeat).SYSTEM_STATUS]
if summary.Status != "" {
gobot.Publish(iris.Event("telemetry"), summary)
}
}
if data.(common.MAVLinkMessage).Id() == 30 {
roll := data.(*common.Attitude).ROLL
pitch := data.(*common.Attitude).PITCH
yaw := data.(*common.Attitude).YAW
if roll < 4 || roll > -4 {
summary.Roll = (roll * 180 / 3.14)
}
if yaw < 4 || roll > -4 {
summary.Yaw = (yaw * 180 / 3.14)
}
if pitch < 4 || roll > -4 {
summary.Pitch = (pitch * 180 / 3.14)
}
gobot.Publish(iris.Event("telemetry"), summary)
}
if data.(common.MAVLinkMessage).Id() == 33 {
summary.Latitude = float32(data.(*common.GlobalPositionInt).LAT) / 10000000.0
summary.Longitude = float32(data.(*common.GlobalPositionInt).LON) / 10000000.0
summary.Altitude = data.(*common.GlobalPositionInt).ALT
summary.Heading = float32(data.(*common.GlobalPositionInt).HDG) / 100
gobot.Publish(iris.Event("telemetry"), summary)
}
})
}
gbot.AddRobot(gobot.NewRobot("irisBot",
[]gobot.Connection{adaptor},
[]gobot.Device{iris},
work,
))
a.Start()
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
a := api.NewAPI(gbot)
a.Start()
board := edison.NewEdisonAdaptor("edison")
red := gpio.NewLedDriver(board, "red", "3")
green := gpio.NewLedDriver(board, "green", "5")
blue := gpio.NewLedDriver(board, "blue", "6")
button := gpio.NewButtonDriver(board, "button", "7")
enabled := true
work := func() {
red.Brightness(0xff)
green.Brightness(0x00)
blue.Brightness(0x00)
flash := false
on := true
gobot.Every(250*time.Millisecond, func() {
if enabled {
if flash {
if on {
red.Brightness(0x00)
green.Brightness(0xff)
blue.Brightness(0x00)
on = false
} else {
red.Brightness(0xff)
green.Brightness(0x00)
blue.Brightness(0x00)
on = true
}
}
}
})
button.On(gpio.ButtonPush, func(data interface{}) {
flash = true
})
button.On(gpio.ButtonRelease, func(data interface{}) {
flash = false
red.Brightness(0x00)
green.Brightness(0x00)
blue.Brightness(0xff)
})
}
robot := gobot.NewRobot(
"square of fire",
[]gobot.Connection{board},
[]gobot.Device{red, green, blue, button},
work,
)
robot.AddCommand("enable", func(params map[string]interface{}) interface{} {
enabled = !enabled
return enabled
})
gbot.AddRobot(robot)
gbot.Start()
}
func (roc *Roc) apiCreate() {
a := api.NewAPI(roc.Gobot)
a.Start()
}
// furbyBotCmd represents the furbyBot command
var furbyBotCmd = &cobra.Command{
Use: "furbyBot",
Short: "Primary command for project - set up gobot Furby interaction",
Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:
Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
Run: func(cmd *cobra.Command, args []string) {
fmt.Println("furbyBot called")
gbot := gobot.NewGobot()
api.NewAPI(gbot).Start()
r := raspi.NewRaspiAdaptor("raspi")
audioAdaptor := audio.NewAudioAdaptor("sound")
jenkinsAdaptor := jenkinsconnect.NewJenkinsconnectAdaptor("jenkins")
// Set up asynchronous channel - if we get more than 3 sounds being played in a row, something's up
csoundFiles := make(chan string, 3)
furby := furby.NewFurbyDriver(r, "furby", "16", csoundFiles)
audioDriver := audio.NewAudioDriver(audioAdaptor, "sounds", csoundFiles)
jenkinsDriver := jenkinsconnect.NewJenkinsconnectDriver(jenkinsAdaptor, "jenkins-command")
screen := i2c.NewGroveLcdDriver(r, "screen")
work := func() {
screen.Clear()
