gobot: gobot.io/x/gobot Index | Examples | Files | Directories

package gobot

import "gobot.io/x/gobot"

Package gobot is the primary entrypoint for Gobot (http://gobot.io), a framework for robotics, physical computing, and the Internet of Things written using the Go programming language .

It provides a simple, yet powerful way to create solutions that incorporate multiple, different hardware devices at the same time.

Classic Gobot

Here is a "Classic Gobot" program that blinks an LED using an Arduino:

package main

import (
	"time"

	"gobot.io/x/gobot"
	"gobot.io/x/gobot/drivers/gpio"
	"gobot.io/x/gobot/platforms/firmata"
)

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()
}

Metal Gobot

You can also use Metal Gobot and pick and choose from the various Gobot packages to control hardware with nothing but pure idiomatic Golang code. For example:

package main

import (
	"gobot.io/x/gobot/drivers/gpio"
	"gobot.io/x/gobot/platforms/intel-iot/edison"
	"time"
)

func main() {
	e := edison.NewAdaptor()
	e.Connect()

	led := gpio.NewLedDriver(e, "13")
	led.Start()

	for {
		led.Toggle()
		time.Sleep(1000 * time.Millisecond)
	}
}

Master Gobot

Finally, you can use Master Gobot to add the complete Gobot API or control swarms of Robots:

package main

import (
	"fmt"
	"time"

	"gobot.io/x/gobot"
	"gobot.io/x/gobot/api"
	"gobot.io/x/gobot/platforms/sphero"
)

func NewSwarmBot(port string) *gobot.Robot {
	spheroAdaptor := sphero.NewAdaptor(port)
	spheroDriver := sphero.NewSpheroDriver(spheroAdaptor)
	spheroDriver.SetName("Sphero" + port)

	work := func() {
		spheroDriver.Stop()

		spheroDriver.On(sphero.Collision, func(data interface{}) {
			fmt.Println("Collision Detected!")
		})

		gobot.Every(1*time.Second, func() {
			spheroDriver.Roll(100, uint16(gobot.Rand(360)))
		})
		gobot.Every(3*time.Second, func() {
			spheroDriver.SetRGB(uint8(gobot.Rand(255)),
				uint8(gobot.Rand(255)),
				uint8(gobot.Rand(255)),
			)
		})
	}

	robot := gobot.NewRobot("sphero",
		[]gobot.Connection{spheroAdaptor},
		[]gobot.Device{spheroDriver},
		work,
	)

	return robot
}

func main() {
	master := gobot.NewMaster()
	api.NewAPI(master).Start()

	spheros := []string{
		"/dev/rfcomm0",
		"/dev/rfcomm1",
		"/dev/rfcomm2",
		"/dev/rfcomm3",
	}

	for _, port := range spheros {
		master.AddRobot(NewSwarmBot(port))
	}

	master.Start()
}

Copyright (c) 2013-2017 The Hybrid Group. Licensed under the Apache 2.0 license.

Index

Examples

Package Files

adaptor.go commander.go connection.go device.go doc.go driver.go event.go eventer.go master.go robot.go utils.go version.go

func After Uses

func After(t time.Duration, f func())

After triggers f after t duration.

Code:

gobot.After(1*time.Second, func() {
    fmt.Println("Hello")
})

func DefaultName Uses

func DefaultName(name string) string

DefaultName returns a sensible random default name for a robot, adaptor or driver

func Every Uses

func Every(t time.Duration, f func()) *time.Ticker

Every triggers f every t time.Duration until the end of days, or when a Stop() is called on the Ticker that is returned by the Every function. It does not wait for the previous execution of f to finish before it fires the next f.

Code:

gobot.Every(1*time.Second, func() {
    fmt.Println("Hello")
})

func FromScale Uses

func FromScale(input, min, max float64) float64

FromScale returns a converted input from min, max to 0.0...1.0.

Code:

fmt.Println(gobot.FromScale(5, 0, 10))

Output:

0.5

func Rand Uses

func Rand(max int) int

Rand returns a positive random int up to max

Code:

i := gobot.Rand(100)
fmt.Printf("%v is > 0 && < 100", i)

func ToScale Uses

func ToScale(input, min, max float64) float64

ToScale returns a converted input from 0...1 to min...max scale. If input is less than min then ToScale returns min. If input is greater than max then ToScale returns max

Code:

fmt.Println(gobot.ToScale(500, 0, 10))

Output:

10

func Version Uses

func Version() string

Version returns the current Gobot version

type Adaptor Uses

type Adaptor interface {
    // Name returns the label for the Adaptor
    Name() string
    // SetName sets the label for the Adaptor
    SetName(n string)
    // Connect initiates the Adaptor
    Connect() error
    // Finalize terminates the Adaptor
    Finalize() error
}

Adaptor is the interface that describes an adaptor in gobot

type Commander Uses

type Commander interface {
    // Command returns a command given a name. Returns nil if the command is not found.
    Command(string) (command func(map[string]interface{}) interface{})
    // Commands returns a map of commands.
    Commands() (commands map[string]func(map[string]interface{}) interface{})
    // AddCommand adds a command given a name.
    AddCommand(name string, command func(map[string]interface{}) interface{})
}

Commander is the interface which describes the behaviour for a Driver or Adaptor which exposes API commands.

func NewCommander Uses

func NewCommander() Commander

NewCommander returns a new Commander.

type Connection Uses

type Connection Adaptor

A Connection is an instance of an Adaptor

type Connections Uses

type Connections []Connection

Connections represents a collection of Connection

func (*Connections) Each Uses

func (c *Connections) Each(f func(Connection))

Each enumerates through the Connections and calls specified callback function.

func (*Connections) Finalize Uses

func (c *Connections) Finalize() (err error)

Finalize calls Finalize on each Connection in c

func (*Connections) Len Uses

func (c *Connections) Len() int

Len returns connections length

func (*Connections) Start Uses

func (c *Connections) Start() (err error)

Start calls Connect on each Connection in c

type Device Uses

type Device Driver

A Device is an instnace of a Driver

type Devices Uses

type Devices []Device

Devices represents a collection of Device

func (*Devices) Each Uses

func (d *Devices) Each(f func(Device))

Each enumerates through the Devices and calls specified callback function.

func (*Devices) Halt Uses

func (d *Devices) Halt() (err error)

Halt calls Halt on each Device in d

func (*Devices) Len Uses

func (d *Devices) Len() int

Len returns devices length

func (*Devices) Start Uses

func (d *Devices) Start() (err error)

Start calls Start on each Device in d

type Driver Uses

type Driver interface {
    // Name returns the label for the Driver
    Name() string
    // SetName sets the label for the Driver
    SetName(s string)
    // Start initiates the Driver
    Start() error
    // Halt terminates the Driver
    Halt() error
    // Connection returns the Connection associated with the Driver
    Connection() Connection
}

Driver is the interface that describes a driver in gobot

type Event Uses

type Event struct {
    Name string
    Data interface{}
}

Event represents when something asyncronous happens in a Driver or Adaptor

func NewEvent Uses

func NewEvent(name string, data interface{}) *Event

NewEvent returns a new Event and its associated data.

type Eventer Uses

type Eventer interface {
    // Events returns the map of valid Event names.
    Events() (eventnames map[string]string)

    // Event returns an Event string from map of valid Event names.
    // Mostly used to validate that an Event name is valid.
    Event(name string) string

    // AddEvent registers a new Event name.
    AddEvent(name string)

    // DeleteEvent removes a previously registered Event name.
    DeleteEvent(name string)

    // Publish new events to any subscriber
    Publish(name string, data interface{})

    // Subscribe to events
    Subscribe() (events eventChannel)

    // Unsubscribe from an event channel
    Unsubscribe(events eventChannel)

    // Event handler
    On(name string, f func(s interface{})) (err error)

    // Event handler, only executes one time
    Once(name string, f func(s interface{})) (err error)
}

Eventer is the interface which describes how a Driver or Adaptor handles events.

func NewEventer Uses

func NewEventer() Eventer

NewEventer returns a new Eventer.

type JSONConnection Uses

type JSONConnection struct {
    Name    string `json:"name"`
    Adaptor string `json:"adaptor"`
}

JSONConnection is a JSON representation of a Connection.

func NewJSONConnection Uses

func NewJSONConnection(connection Connection) *JSONConnection

NewJSONConnection returns a JSONConnection given a Connection.

type JSONDevice Uses

type JSONDevice struct {
    Name       string   `json:"name"`
    Driver     string   `json:"driver"`
    Connection string   `json:"connection"`
    Commands   []string `json:"commands"`
}

JSONDevice is a JSON representation of a Device.

func NewJSONDevice Uses

func NewJSONDevice(device Device) *JSONDevice

NewJSONDevice returns a JSONDevice given a Device.

type JSONMaster Uses

type JSONMaster struct {
    Robots   []*JSONRobot `json:"robots"`
    Commands []string     `json:"commands"`
}

JSONMaster is a JSON representation of a Gobot Master.

func NewJSONMaster Uses

func NewJSONMaster(gobot *Master) *JSONMaster

NewJSONMaster returns a JSONMaster given a Gobot Master.

type JSONRobot Uses

type JSONRobot struct {
    Name        string            `json:"name"`
    Commands    []string          `json:"commands"`
    Connections []*JSONConnection `json:"connections"`
    Devices     []*JSONDevice     `json:"devices"`
}

JSONRobot a JSON representation of a Robot.

func NewJSONRobot Uses

func NewJSONRobot(robot *Robot) *JSONRobot

NewJSONRobot returns a JSONRobot given a Robot.

type Master Uses

type Master struct {
    AutoRun bool

    Commander
    Eventer
    // contains filtered or unexported fields
}

Master is the main type of your Gobot application and contains a collection of Robots, API commands that apply to the Master, and Events that apply to the Master.

func NewMaster Uses

func NewMaster() *Master

NewMaster returns a new Gobot Master

func (*Master) AddRobot Uses

func (g *Master) AddRobot(r *Robot) *Robot

AddRobot adds a new robot to the internal collection of robots. Returns the added robot

func (*Master) Robot Uses

func (g *Master) Robot(name string) *Robot

Robot returns a robot given name. Returns nil if the Robot does not exist.

func (*Master) Robots Uses

func (g *Master) Robots() *Robots

Robots returns all robots associated with this Gobot Master.

func (*Master) Running Uses

func (g *Master) Running() bool

Running returns if the Master is currently started or not

func (*Master) Start Uses

func (g *Master) Start() (err error)

Start calls the Start method on each robot in its collection of robots. On error, call Stop to ensure that all robots are returned to a sane, stopped state.

func (*Master) Stop Uses

func (g *Master) Stop() (err error)

Stop calls the Stop method on each robot in its collection of robots.

type Pinner Uses

type Pinner interface {
    Pin() string
}

Pinner is the interface that describes a driver's pin

type Porter Uses

type Porter interface {
    Port() string
}

Porter is the interface that describes an adaptor's port

type Robot Uses

type Robot struct {
    Name string
    Work func()

    AutoRun bool

    Commander
    Eventer
    // contains filtered or unexported fields
}

Robot is a named entity that manages a collection of connections and devices. It contains its own work routine and a collection of custom commands to control a robot remotely via the Gobot api.

func NewRobot Uses

func NewRobot(v ...interface{}) *Robot

NewRobot returns a new Robot. It supports the following optional params:

	name:	string with the name of the Robot. A name will be automatically generated if no name is supplied.
[]Connection: Connections which are automatically started and stopped with the robot
	[]Device: Devices which are automatically started and stopped with the robot
	func(): The work routine the robot will execute once all devices and connections have been initialized and started

func (*Robot) AddConnection Uses

func (r *Robot) AddConnection(c Connection) Connection

AddConnection adds a new connection to the robots collection of connections. Returns the added connection.

func (*Robot) AddDevice Uses

func (r *Robot) AddDevice(d Device) Device

AddDevice adds a new Device to the robots collection of devices. Returns the added device.

func (*Robot) Connection Uses

func (r *Robot) Connection(name string) Connection

Connection returns a connection given a name. Returns nil if the Connection does not exist.

func (*Robot) Connections Uses

func (r *Robot) Connections() *Connections

Connections returns all connections associated with this robot.

func (*Robot) Device Uses

func (r *Robot) Device(name string) Device

Device returns a device given a name. Returns nil if the Device does not exist.

func (*Robot) Devices Uses

func (r *Robot) Devices() *Devices

Devices returns all devices associated with this Robot.

func (*Robot) Running Uses

func (r *Robot) Running() bool

Running returns if the Robot is currently started or not

func (*Robot) Start Uses

func (r *Robot) Start(args ...interface{}) (err error)

Start a Robot's Connections, Devices, and work.

func (*Robot) Stop Uses

func (r *Robot) Stop() error

Stop stops a Robot's connections and Devices

type Robots Uses

type Robots []*Robot

Robots is a collection of Robot

func (*Robots) Each Uses

func (r *Robots) Each(f func(*Robot))

Each enumerates through the Robots and calls specified callback function.

func (*Robots) Len Uses

func (r *Robots) Len() int

Len returns the amount of Robots in the collection.

func (*Robots) Start Uses

func (r *Robots) Start(args ...interface{}) (err error)

Start calls the Start method of each Robot in the collection

func (*Robots) Stop Uses

func (r *Robots) Stop() (err error)

Stop calls the Stop method of each Robot in the collection

Directories

PathSynopsis
drivers/aioPackage aio provides Gobot drivers for Analog Input/Output devices.
drivers/gpioPackage gpio provides Gobot drivers for General Purpose Input/Output devices.
drivers/i2cPackage i2c provides Gobot drivers for i2c devices.
platforms/audioPackage audio is based on aplay audio adaptor written by @colemanserious (https://github.com/colemanserious)
platforms/beaglebonePackage beaglebone provides the Gobot adaptor for the Beaglebone Black.
platforms/blePackage ble provides the Gobot adaptor for Bluetooth LE.
platforms/chipPackage chip contains the Gobot adaptor for the CHIP and CHIP Pro
platforms/digisparkPackage digispark provides the Gobot adaptor for the Digispark ATTiny-based USB development board.
platforms/dragonboardPackage dragonboard contains the Gobot adaptor for the DragonBoard 410c
platforms/firmataPackage firmata provides the Gobot adaptor for microcontrollers that support the Firmata protocol.
platforms/firmata/clientPackage client provies a client for interacting with microcontrollers using the Firmata protocol https://github.com/firmata/protocol.
platforms/intel-iotPackage inteliot contains Gobot adaptors for the Intel IoT platforms.
platforms/intel-iot/edisonPackage edison contains the Gobot adaptor for the Intel Edison.
platforms/intel-iot/joulePackage joule contains the Gobot adaptor for the Intel Joule.
platforms/joystickPackage joystick provides the Gobot adaptor and drivers for game controllers that are compatible with SDL.
platforms/keyboardPackage keyboard contains the Gobot drivers for keyboard support.
platforms/leapPackage leap provides the Gobot adaptor and driver for the Leap Motion.
platforms/mavlinkPackage mavlink contains the Gobot adaptor and driver for the MAVlink Communication Protocol.
platforms/megapiPackage megapi provides the Gobot adaptor for MegaPi.
platforms/microbitPackage microbit contains the Gobot drivers for the Microbit.
platforms/mqttPackage mqtt provides Gobot adaptor for the mqtt message service.
platforms/natsPackage nats provides Gobot adaptor for the nats message service.
platforms/neuroskyPackage neurosky contains the Gobot adaptor and driver for the Neurosky Mindwave Mobile EEG.
platforms/opencvPackage opencv contains the Gobot drivers for opencv.
platforms/parrotPackage parrot contains Gobot adaptors and drivers for the Parrot drones
platforms/parrot/ardronePackage ardrone provides the Gobot adaptor and driver for the Parrot Ardrone.
platforms/parrot/bebopPackage bebop provides the Gobot adaptor and driver for the Parrot Bebop.
platforms/parrot/minidronePackage minidrone contains the Gobot driver for the Parrot Minidrone.
platforms/particlePackage particle provides the Gobot adaptor for the Particle Photon and Electron.
platforms/pebblePackage pebble contains the Gobot adaptor and driver for Pebble smart watch.
platforms/raspiPackage raspi contains the Gobot adaptor for the Raspberry Pi.
platforms/spheroPackage sphero provides the Gobot adaptor and driver for the Sphero.
platforms/sphero/bb8Package bb8 contains the Gobot driver for the Sphero BB-8.
platforms/sphero/olliePackage ollie contains the Gobot driver for the Sphero Ollie.
platforms/tinkerboardPackage tinkerboard contains the Gobot adaptor for the ASUS Tinker Board.
sysfsPackage sysfs provides generic access to linux gpio.

Package gobot imports 12 packages (graph) and is imported by 39 packages. Updated 2017-05-10. Refresh now. Tools for package owners.