func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
mma7660 := i2c.NewMMA7660Driver(firmataAdaptor, "mma7660")
work := func() {
gobot.Every(500*time.Millisecond, func() {
if x, y, z, err := mma7660.XYZ(); err == nil {
fmt.Println(x, y, z)
fmt.Println(mma7660.Acceleration(x, y, z))
} else {
fmt.Println(err)
}
})
}
robot := gobot.NewRobot("mma76602Bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{mma7660},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
e := edison.NewEdisonAdaptor("edison")
button := gpio.NewGroveButtonDriver(e, "button", "2")
work := func() {
gobot.On(button.Event(gpio.Push), func(data interface{}) {
fmt.Println("On!")
})
gobot.On(button.Event(gpio.Release), func(data interface{}) {
fmt.Println("Off!")
})
}
robot := gobot.NewRobot("bot",
[]gobot.Connection{e},
[]gobot.Device{button},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
beagleboneAdaptor := beaglebone.NewBeagleboneAdaptor("beaglebone")
led := gpio.NewLedDriver(beagleboneAdaptor, "led", "P9_14")
work := func() {
brightness := uint8(0)
fadeAmount := uint8(5)
gobot.Every(100*time.Millisecond, func() {
led.Brightness(brightness)
brightness = brightness + fadeAmount
if brightness == 0 || brightness == 255 {
fadeAmount = -fadeAmount
}
})
}
robot := gobot.NewRobot("pwmBot",
[]gobot.Connection{beagleboneAdaptor},
[]gobot.Device{led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
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()
adaptor := sphero.NewSpheroAdaptor("sphero", "/dev/tty.Sphero-BRB-AMP-SPP")
driver := sphero.NewSpheroDriver(adaptor, "sphero")
work := func() {
gobot.Every(100*time.Millisecond, func() {
driver.SetRGB(
uint8(gobot.Rand(255)),
uint8(gobot.Rand(255)),
uint8(gobot.Rand(255)))
})
}
robot := gobot.NewRobot("sphero",
[]gobot.Connection{adaptor},
[]gobot.Device{driver},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
board := edison.NewEdisonAdaptor("edison")
screen := i2c.NewGroveLcdDriver(board, "screen")
work := func() {
screen.Write("hello")
screen.SetRGB(255, 0, 0)
gobot.After(5*time.Second, func() {
screen.Clear()
screen.Home()
screen.SetRGB(0, 255, 0)
screen.Write("goodbye")
})
screen.Home()
<-time.After(1 * time.Second)
screen.SetRGB(0, 0, 255)
}
robot := gobot.NewRobot("screenBot",
[]gobot.Connection{board},
[]gobot.Device{screen},
work,
)
gbot.AddRobot(robot)
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()
sparkCore := spark.NewSparkCoreAdaptor("spark", "device_id", "access_token")
led := gpio.NewLedDriver(sparkCore, "led", "D7")
button := gpio.NewButtonDriver(sparkCore, "button", "D5")
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("spark",
[]gobot.Connection{sparkCore},
[]gobot.Device{button, led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
motor := gpio.NewMotorDriver(firmataAdaptor, "motor", "3")
work := func() {
speed := byte(0)
fadeAmount := byte(15)
gobot.Every(100*time.Millisecond, func() {
motor.Speed(speed)
speed = speed + fadeAmount
if speed == 0 || speed == 255 {
fadeAmount = -fadeAmount
}
})
}
robot := gobot.NewRobot("motorBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{motor},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
bebopAdaptor := bebop.NewBebopAdaptor("Drone")
drone := bebop.NewBebopDriver(bebopAdaptor, "Drone")
work := func() {
gobot.On(drone.Event("flying"), func(data interface{}) {
gobot.After(3*time.Second, func() {
drone.Land()
})
})
drone.HullProtection(true)
drone.TakeOff()
}
robot := gobot.NewRobot("drone",
[]gobot.Connection{bebopAdaptor},
[]gobot.Device{drone},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
beagleboneAdaptor := beaglebone.NewBeagleboneAdaptor("beaglebone")
led := gpio.NewDirectPinDriver(beagleboneAdaptor, "led", "P8_10")
button := gpio.NewDirectPinDriver(beagleboneAdaptor, "button", "P8_9")
work := func() {
gobot.Every(500*time.Millisecond, func() {
if button.DigitalRead() == 1 {
led.DigitalWrite(1)
} else {
led.DigitalWrite(0)
}
})
}
robot := gobot.NewRobot("pinBot",
[]gobot.Connection{beagleboneAdaptor},
[]gobot.Device{led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
board := firmata.NewFirmataAdaptor("arduino", os.Args[1])
// digital devices
button := gpio.NewButtonDriver(board, "button", "2")
blue := gpio.NewLedDriver(board, "blue", "3")
work := func() {
gobot.On(button.Event(gpio.Push), func(data interface{}) {
fmt.Println("On!")
blue.On()
})
gobot.On(button.Event(gpio.Release), func(data interface{}) {
fmt.Println("Off!")
blue.Off()
})
}
robot := gobot.NewRobot("airlock",
[]gobot.Connection{board},
[]gobot.Device{button, blue},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
red := gpio.NewLedDriver(firmataAdaptor, "red", "7")
green := gpio.NewLedDriver(firmataAdaptor, "green", "6")
blue := gpio.NewLedDriver(firmataAdaptor, "blue", "5")
work := func() {
checkTravis(gbot.Robot("travis"))
gobot.Every(10*time.Second, func() {
checkTravis(gbot.Robot("travis"))
})
}
robot := gobot.NewRobot("travis",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{red, green, blue},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("myFirmata", "/dev/ttyACM0")
pin := gpio.NewDirectPinDriver(firmataAdaptor, "pin", "13")
work := func() {
level := byte(1)
gobot.Every(1*time.Second, func() {
pin.DigitalWrite(level)
if level == 1 {
level = 0
} else {
level = 1
}
})
}
robot := gobot.NewRobot("pinBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{pin},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
e := edison.NewEdisonAdaptor("edison")
touch := gpio.NewGroveTouchDriver(e, "touch", "2")
work := func() {
gobot.On(touch.Event(gpio.Push), func(data interface{}) {
fmt.Println("On!")
})
gobot.On(touch.Event(gpio.Release), func(data interface{}) {
fmt.Println("Off!")
})
}
robot := gobot.NewRobot("blinkBot",
[]gobot.Connection{e},
[]gobot.Device{touch},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
digisparkAdaptor := digispark.NewDigisparkAdaptor("digispark")
led := gpio.NewLedDriver(digisparkAdaptor, "led", "0")
work := func() {
brightness := uint8(0)
fadeAmount := uint8(15)
gobot.Every(100*time.Millisecond, func() {
led.Brightness(brightness)
brightness = brightness + fadeAmount
if brightness == 0 || brightness == 255 {
fadeAmount = -fadeAmount
}
})
}
robot := gobot.NewRobot("pwmBot",
[]gobot.Connection{digisparkAdaptor},
[]gobot.Device{led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
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()
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()
e := edison.NewEdisonAdaptor("edison")
led := gpio.NewRgbLedDriver(e, "led", "3", "5", "6")
work := func() {
gobot.Every(1*time.Second, func() {
r := uint8(gobot.Rand(255))
g := uint8(gobot.Rand(255))
b := uint8(gobot.Rand(255))
led.SetRGB(r, g, b)
})
}
robot := gobot.NewRobot("rgbBot",
[]gobot.Connection{e},
[]gobot.Device{led},
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()
adaptor := sphero.NewSpheroAdaptor("Sphero", "/dev/rfcomm0")
spheroDriver := sphero.NewSpheroDriver(adaptor, "sphero")
work := func() {
gobot.On(spheroDriver.Event("collision"), func(data interface{}) {
fmt.Println("Collision Detected!")
})
gobot.Every(3*time.Second, func() {
spheroDriver.Roll(30, uint16(gobot.Rand(360)))
})
gobot.Every(1*time.Second, func() {
r := uint8(gobot.Rand(255))
g := uint8(gobot.Rand(255))
b := uint8(gobot.Rand(255))
spheroDriver.SetRGB(r, g, b)
})
}
robot := gobot.NewRobot("sphero",
[]gobot.Connection{adaptor},
[]gobot.Device{spheroDriver},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
edisonAdaptor := edison.NewEdisonAdaptor("edison")
blinkm := i2c.NewBlinkMDriver(edisonAdaptor, "blinkm")
sensor := gpio.NewAnalogSensorDriver(edisonAdaptor, "sensor", "2")
work := func() {
gobot.On(sensor.Event("data"), func(data interface{}) {
brightness := uint8(
gobot.ToScale(gobot.FromScale(float64(data.(int)), 0, 4096), 0, 255),
)
fmt.Println("sensor", data)
fmt.Println("brightness", brightness)
blinkm.Rgb(0, brightness, 0)
})
}
robot := gobot.NewRobot("sensorBot",
[]gobot.Connection{edisonAdaptor},
[]gobot.Device{blinkm, sensor},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
wiichuck := i2c.NewWiichuckDriver(firmataAdaptor, "wiichuck")
work := func() {
wiichuck.On(wiichuck.Event("joystick"), func(data interface{}) {
fmt.Println("joystick", data)
})
wiichuck.On(wiichuck.Event("c"), func(data interface{}) {
fmt.Println("c")
})
wiichuck.On(wiichuck.Event("z"), func(data interface{}) {
fmt.Println("z")
})
wiichuck.On(wiichuck.Event("error"), func(data interface{}) {
fmt.Println("Wiichuck error:", data)
})
}
robot := gobot.NewRobot("chuck",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{wiichuck},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
work := func() {
gobot.Every(1*time.Second, func() {
val, err := firmataAdaptor.AnalogRead("0")
if err != nil {
fmt.Println(err)
return
}
voltage := (float64(val) * 5) / 1024 // if using 3.3V replace 5 with 3.3
tempC := (voltage - 0.5) * 100
tempF := (tempC * 9 / 5) + 32
fmt.Printf("%.2f°C\n", tempC)
fmt.Printf("%.2f°F\n", tempF)
})
}
robot := gobot.NewRobot("sensorBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
m := mqtt.NewMqttAdaptor("mqtt", "tcp://192.168.0.90:1883", "drone")
digisparkAdaptor := digispark.NewDigisparkAdaptor("digispark")
servo := gpio.NewServoDriver(digisparkAdaptor, "servo", "0")
work := func() {
servo.Move(10)
m.On("drop", func(data []byte) {
servo.Move(150)
m.Publish("drone", []byte("Dropped"))
})
}
robot := gobot.NewRobot("servoBot",
[]gobot.Connection{digisparkAdaptor, m},
[]gobot.Device{servo},
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()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
sensor := gpio.NewAnalogSensorDriver(firmataAdaptor, "sensor", "0")
led := gpio.NewLedDriver(firmataAdaptor, "led", "3")
work := func() {
sensor.On(gpio.Data, func(data interface{}) {
brightness := uint8(
gobot.ToScale(gobot.FromScale(float64(data.(int)), 0, 1024), 0, 255),
)
fmt.Println("sensor", data)
fmt.Println("brightness", brightness)
led.Brightness(brightness)
})
}
robot := gobot.NewRobot("sensorBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{sensor, led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
deviceName := flag.String("device", "", "path to Sphero device")
flag.Parse()
gbot := gobot.NewGobot()
adaptor := sphero.NewSpheroAdaptor("sphero", *deviceName)
driver := sphero.NewSpheroDriver(adaptor, "sphero")
work := func() {
gobot.Every(3*time.Second, func() {
driver.Roll(30, uint16(gobot.Rand(360)))
})
}
robot := gobot.NewRobot("sphero",
[]gobot.Connection{adaptor},
[]gobot.Device{driver},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
firmataAdaptor := firmata.NewFirmataAdaptor("firmata", "/dev/ttyACM0")
blinkm := i2c.NewBlinkMDriver(firmataAdaptor, "blinkm")
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)
fmt.Println("color", blinkm.Color())
})
}
robot := gobot.NewRobot("blinkmBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{blinkm},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}
func main() {
gbot := gobot.NewGobot()
e := edison.NewEdisonAdaptor("edison")
sensor := gpio.NewAnalogSensorDriver(e, "sensor", "0")
led := gpio.NewLedDriver(e, "led", "3")
work := func() {
sensor.On(gpio.Data, func(data interface{}) {
brightness := uint8(
gobot.ToScale(gobot.FromScale(float64(data.(int)), 0, 4096), 0, 255),
)
fmt.Println("sensor", data)
fmt.Println("brightness", brightness)
led.Brightness(brightness)
})
}
robot := gobot.NewRobot("sensorBot",
[]gobot.Connection{e},
[]gobot.Device{sensor, led},
work,
)
gbot.AddRobot(robot)
gbot.Start()
}