func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
led1 := gpio.NewLedDriver(firmataAdaptor, "3")
led2 := gpio.NewLedDriver(firmataAdaptor, "4")
button := gpio.NewButtonDriver(firmataAdaptor, "2")
sensor := gpio.NewAnalogSensorDriver(firmataAdaptor, "0")
work := func() {
gobot.Every(1*time.Second, func() {
led1.Toggle()
})
gobot.Every(2*time.Second, func() {
led2.Toggle()
})
button.On(gpio.ButtonPush, func(data interface{}) {
led2.On()
})
button.On(gpio.ButtonRelease, func(data interface{}) {
led2.Off()
})
sensor.On(gpio.Data, func(data interface{}) {
fmt.Println("sensor", data)
})
}
robot := gobot.NewRobot("bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{led1, led2, button, sensor},
work,
)
robot.Start()
}
func main() {
master := gobot.NewMaster()
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
red := gpio.NewLedDriver(firmataAdaptor, "7")
red.SetName("red")
green := gpio.NewLedDriver(firmataAdaptor, "6")
green.SetName("green")
blue := gpio.NewLedDriver(firmataAdaptor, "5")
blue.SetName("blue")
work := func() {
checkTravis(master.Robot("travis"))
gobot.Every(10*time.Second, func() {
checkTravis(master.Robot("travis"))
})
}
robot := gobot.NewRobot("travis",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{red, green, blue},
work,
)
master.AddRobot(robot)
master.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
wiichuck := i2c.NewWiichuckDriver(firmataAdaptor)
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,
)
robot.Start()
}
func main() {
mqttAdaptor := mqtt.NewAdaptor("tcp://test.mosquitto.org:1883", "blinker")
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
led := gpio.NewLedDriver(firmataAdaptor, "13")
work := func() {
mqttAdaptor.On("lights/on", func(data []byte) {
led.On()
})
mqttAdaptor.On("lights/off", func(data []byte) {
led.Off()
})
data := []byte("")
gobot.Every(1*time.Second, func() {
mqttAdaptor.Publish("lights/on", data)
})
gobot.Every(2*time.Second, func() {
mqttAdaptor.Publish("lights/off", data)
})
}
robot := gobot.NewRobot("mqttBot",
[]gobot.Connection{mqttAdaptor, firmataAdaptor},
[]gobot.Device{led},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
sensor := gpio.NewPIRMotionDriver(firmataAdaptor, "5")
led := gpio.NewLedDriver(firmataAdaptor, "13")
work := func() {
sensor.On(gpio.MotionDetected, func(data interface{}) {
fmt.Println(gpio.MotionDetected)
led.On()
})
sensor.On(gpio.MotionStopped, func(data interface{}) {
fmt.Println(gpio.MotionStopped)
led.Off()
})
}
robot := gobot.NewRobot("motionBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{sensor, led},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/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,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
pin := gpio.NewDirectPinDriver(firmataAdaptor, "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,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
servo1 := gpio.NewServoDriver(firmataAdaptor, "5")
servo2 := gpio.NewServoDriver(firmataAdaptor, "3")
leapAdaptor := leap.NewAdaptor("127.0.0.1:6437")
leapDriver := leap.NewDriver(leapAdaptor)
work := func() {
x := 90.0
z := 90.0
leapDriver.On(leap.MessageEvent, 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(10*time.Millisecond, func() {
servo1.Move(uint8(x))
servo2.Move(uint8(z))
fmt.Println("Current Angle: ", servo1.CurrentAngle, ",", servo2.CurrentAngle)
})
}
robot := gobot.NewRobot("pwmBot",
[]gobot.Connection{firmataAdaptor, leapAdaptor},
[]gobot.Device{servo1, servo2, leapDriver},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
motor := gpio.NewMotorDriver(firmataAdaptor, "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,
)
robot.Start()
}
// Example of a simple led toggle without the initialization of
// the entire gobot framework.
// This might be useful if you want to use gobot as another
// golang library to interact with sensors and other devices.
func main() {
f := firmata.NewAdaptor("/dev/ttyACM0")
f.Connect()
led := gpio.NewLedDriver(f, "13")
led.Start()
for {
led.Toggle()
time.Sleep(1000 * time.Millisecond)
}
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
led := gpio.NewLedDriver(firmataAdaptor, "13")
work := func() {
gobot.Every(1*time.Second, func() {
led.Toggle()
})
}
robot := gobot.NewRobot("bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{led},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
mpl115a2 := i2c.NewMPL115A2Driver(firmataAdaptor)
work := func() {
gobot.Every(1*time.Second, func() {
fmt.Println("Pressure", mpl115a2.Pressure)
fmt.Println("Temperature", mpl115a2.Temperature)
})
}
robot := gobot.NewRobot("mpl115a2Bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{mpl115a2},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
lidar := i2c.NewLIDARLiteDriver(firmataAdaptor)
work := func() {
gobot.Every(100*time.Millisecond, func() {
distance, _ := lidar.Distance()
fmt.Println("Distance", distance)
})
}
robot := gobot.NewRobot("lidarbot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{lidar},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
hmc6352 := i2c.NewHMC6352Driver(firmataAdaptor)
work := func() {
gobot.Every(100*time.Millisecond, func() {
heading, _ := hmc6352.Heading()
fmt.Println("Heading", heading)
})
}
robot := gobot.NewRobot("hmc6352Bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{hmc6352},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
servo := gpio.NewServoDriver(firmataAdaptor, "3")
work := func() {
gobot.Every(1*time.Second, func() {
i := uint8(gobot.Rand(180))
fmt.Println("Turning", i)
servo.Move(i)
})
}
robot := gobot.NewRobot("servoBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{servo},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
mpu6050 := i2c.NewMPU6050Driver(firmataAdaptor)
work := func() {
gobot.Every(100*time.Millisecond, func() {
fmt.Println("Accelerometer", mpu6050.Accelerometer)
fmt.Println("Gyroscope", mpu6050.Gyroscope)
fmt.Println("Temperature", mpu6050.Temperature)
})
}
robot := gobot.NewRobot("mpu6050Bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{mpu6050},
work,
)
robot.Start()
}
// Video: https://www.youtube.com/watch?v=ayNMyUfdAqc
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/tty.usbmodem1451")
servo1 := gpio.NewServoDriver(firmataAdaptor, "3")
servo2 := gpio.NewServoDriver(firmataAdaptor, "4")
servo3 := gpio.NewServoDriver(firmataAdaptor, "5")
servo4 := gpio.NewServoDriver(firmataAdaptor, "6")
servo5 := gpio.NewServoDriver(firmataAdaptor, "7")
leapMotionAdaptor := leap.NewAdaptor("127.0.0.1:6437")
l := leap.NewDriver(leapMotionAdaptor)
work := func() {
fist := false
l.On(leap.MessageEvent, func(data interface{}) {
handIsOpen := len(data.(leap.Frame).Pointables) > 0
if handIsOpen && fist {
servo1.Move(0)
servo2.Move(0)
servo3.Move(0)
servo4.Move(0)
servo5.Move(0)
fist = false
} else if !handIsOpen && !fist {
servo1.Move(120)
servo2.Move(120)
servo3.Move(120)
servo4.Move(120)
servo5.Move(120)
fist = true
}
})
}
robot := gobot.NewRobot("servoBot",
[]gobot.Connection{firmataAdaptor, leapMotionAdaptor},
[]gobot.Device{servo1, servo2, servo3, servo4, servo5, l},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
buzzer := gpio.NewBuzzerDriver(firmataAdaptor, "3")
work := func() {
type note struct {
tone float64
duration float64
}
song := []note{
{gpio.C4, gpio.Quarter},
{gpio.C4, gpio.Quarter},
{gpio.G4, gpio.Quarter},
{gpio.G4, gpio.Quarter},
{gpio.A4, gpio.Quarter},
{gpio.A4, gpio.Quarter},
{gpio.G4, gpio.Half},
{gpio.F4, gpio.Quarter},
{gpio.F4, gpio.Quarter},
{gpio.E4, gpio.Quarter},
{gpio.E4, gpio.Quarter},
{gpio.D4, gpio.Quarter},
{gpio.D4, gpio.Quarter},
{gpio.C4, gpio.Half},
}
for _, val := range song {
buzzer.Tone(val.tone, val.duration)
time.Sleep(10 * time.Millisecond)
}
}
robot := gobot.NewRobot("bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{buzzer},
work,
)
robot.Start()
}
func main() {
board := firmata.NewAdaptor("/dev/ttyACM0")
led := gpio.NewRgbLedDriver(board, "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{board},
[]gobot.Device{led},
work,
)
robot.Start()
}
func main() {
f := firmata.NewAdaptor("/dev/ttyACM0")
f.Connect()
led := gpio.NewLedDriver(f, "13")
led.Start()
led.Off()
button := gpio.NewButtonDriver(f, "5")
button.Start()
buttonEvents := button.Subscribe()
for {
select {
case event := <-buttonEvents:
fmt.Println("Event:", event.Name, event.Data)
if event.Name == gpio.ButtonPush {
led.Toggle()
}
}
}
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
mma7660 := i2c.NewMMA7660Driver(firmataAdaptor)
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,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
button := gpio.NewButtonDriver(firmataAdaptor, "5")
led := gpio.NewLedDriver(firmataAdaptor, "13")
work := func() {
button.On(gpio.ButtonPush, func(data interface{}) {
led.On()
})
button.On(gpio.ButtonRelease, func(data interface{}) {
led.Off()
})
}
robot := gobot.NewRobot("buttonBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{button, led},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
blinkm := i2c.NewBlinkMDriver(firmataAdaptor)
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)
color, _ := blinkm.Color()
fmt.Println("color", color)
})
}
robot := gobot.NewRobot("blinkmBot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{blinkm},
work,
)
robot.Start()
}
func main() {
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
sensor := gpio.NewAnalogSensorDriver(firmataAdaptor, "0")
led := gpio.NewLedDriver(firmataAdaptor, "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,
)
robot.Start()
}
func main() {
master := gobot.NewMaster()
a := api.NewAPI(master)
a.Start()
firmataAdaptor := firmata.NewAdaptor("/dev/ttyACM0")
led := gpio.NewLedDriver(firmataAdaptor, "13")
work := func() {
gobot.Every(1*time.Second, func() {
led.Toggle()
})
}
robot := gobot.NewRobot("bot",
[]gobot.Connection{firmataAdaptor},
[]gobot.Device{led},
work,
)
master.AddRobot(robot)
master.Start()
}