gobot

package module
v0.12.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 13, 2016 License: Apache-2.0 Imports: 11 Imported by: 0

README

Gobot

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

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

Want to use Javascript robotics? Check out our sister project Cylon.js (http://cylonjs.com/)

Want to use Ruby on robots? Check out our sister project Artoo (http://artoo.io)

GoDoc Build Status Coverage Status

Getting Started

Get the Gobot source with: go get -d -u github.com/hybridgroup/gobot/...

Examples

Gobot with Arduino
package main

import (
	"time"

	"github.com/hybridgroup/gobot"
	"github.com/hybridgroup/gobot/platforms/firmata"
	"github.com/hybridgroup/gobot/platforms/gpio"
)

func main() {
	gbot := gobot.NewGobot()

	firmataAdaptor := firmata.NewFirmataAdaptor("arduino", "/dev/ttyACM0")
	led := gpio.NewLedDriver(firmataAdaptor, "led", "13")

	work := func() {
		gobot.Every(1*time.Second, func() {
			led.Toggle()
		})
	}

	robot := gobot.NewRobot("bot",
		[]gobot.Connection{firmataAdaptor},
		[]gobot.Device{led},
		work,
	)

	gbot.AddRobot(robot)

	gbot.Start()
}
Gobot with Sphero
package main

import (
	"fmt"
	"time"

	"github.com/hybridgroup/gobot"
	"github.com/hybridgroup/gobot/platforms/sphero"
)

func main() {
	gbot := gobot.NewGobot()

	adaptor := sphero.NewSpheroAdaptor("sphero", "/dev/rfcomm0")
	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()
}

Hardware Support

Gobot has a extensible system for connecting to hardware devices. The following robotics and physical computing platforms are currently supported:

Support for many devices that use General Purpose Input/Output (GPIO) have a shared set of drivers provided using the gobot/platforms/gpio package:

  • GPIO <=> Drivers
    • Analog Sensor
    • Button
    • Direct Pin
    • Digital Sensor
    • Direct Pin
    • Grove Button
    • Grove Buzzer
    • Grove LED
    • Grove Light Sensor
    • Grove Piezo Vibration Sensor
    • Grove Relay
    • Grove Rotary Dial
    • Grove Sound Sensor
    • Grove Touch Sensor
    • LED
    • Makey Button
    • Motor
    • Servo

Support for devices that use Inter-Integrated Circuit (I2C) have a shared set of drivers provided using the gobot/platforms/i2c package:

  • I2C <=> Drivers
    • BlinkM
    • Grove Digital Accelerometer
    • Grove RGB LCD
    • HMC6352 Compass
    • JHD1313M1 RGB LCD Display
    • LIDAR-Lite
    • MCP23017 Port Expander
    • MMA7660 3-Axis Accelerometer
    • MPL115A2 Barometer
    • MPU6050 Accelerometer/Gyroscope
    • Wii Nunchuck Controller

More platforms and drivers are coming soon...

API:

Gobot includes a RESTful API to query the status of any robot running within a group, including the connection and device status, and execute device commands.

To activate the API, require the github.com/hybridgroup/gobot/api package and instantiate the API like this:

  gbot := gobot.NewGobot()
  api.NewAPI(gbot).Start()

You can also specify the api host and port, and turn on authentication:

  gbot := gobot.NewGobot()
  server := api.NewAPI(gbot)
  server.Port = "4000"
  server.AddHandler(api.BasicAuth("gort", "klatuu"))
  server.Start()

You may access the robeaux React.js interface with Gobot by navigating to http://localhost:3000/index.html.

Documentation

We're busy adding documentation to our web site at http://gobot.io/ please check there as we continue to work on Gobot

Thank you!

Need help?

Contributing

For our contribution guidelines, please go to https://github.com/hybridgroup/gobot/blob/master/CONTRIBUTING.md .

License

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

Documentation

Overview

Package gobot provides a framework for robotics, physical computing and the internet of things. It is the main point of entry for your Gobot application. A Gobot program is typically composed of one or more robots that makes up a project.

Basic Setup 

package main

import (
  "fmt"
  "time"

  "github.com/hybridgroup/gobot"
)

func main() {
  gbot  := gobot.NewGobot()

  robot := gobot.NewRobot("Eve", func() {
    gobot.Every(500*time.Millisecond, func() {
      fmt.Println("Greeting Human")
    })
  })

  gbot.AddRobot(robot)

  gbot.Start()
}

Blinking an LED (Hello Eve!) 

package main

import (
	"time"

	"github.com/hybridgroup/gobot"
	"github.com/hybridgroup/gobot/platforms/firmata"
	"github.com/hybridgroup/gobot/platforms/gpio"
)

func main() {
	gbot := gobot.NewGobot()

	firmataAdaptor := firmata.NewFirmataAdaptor("arduino", "/dev/ttyACM0")
	led := gpio.NewLedDriver(firmataAdaptor, "led", "13")

	work := func() {
		gobot.Every(1*time.Second, func() {
			led.Toggle()
		})
	}

	robot := gobot.NewRobot("Eve",
		[]gobot.Connection{firmataAdaptor},
		[]gobot.Device{led},
		work,
	)

	gbot.AddRobot(robot)

	gbot.Start()
}

Web Enabled? You bet! Gobot can be configured to expose a restful HTTP interface using the api package. You can define custom commands on your robots, in addition to the built-in device driver commands, and interact with your application as a web service. 

package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
	"github.com/hybridgroup/gobot/api"
)

func main() {
	gbot := gobot.NewGobot()

  // Starts the API server on default port 3000
	api.NewAPI(gbot).Start()

  // Accessible via http://localhost:3000/api/commands/say_hello
	gbot.AddCommand("say_hello", func(params map[string]interface{}) interface{} {
		return "Master says hello!"
	})

	hello := gbot.AddRobot(gobot.NewRobot("Eve"))

  // Accessible via http://localhost:3000/robots/Eve/commands/say_hello
	hello.AddCommand("say_hello", func(params map[string]interface{}) interface{} {
		return fmt.Sprintf("%v says hello!", hello.Name)
	})

	gbot.Start()
}

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	// ErrUnknownEvent is the error resulting if the specified Event does not exist
	ErrUnknownEvent = errors.New("Event does not exist")
)

Functions

func After 

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

After triggers f after t duration.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/hybridgroup/gobot"
)

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

Output:

func Every 

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

Every triggers f every t time until the end of days. It does not wait for the previous execution of f to finish before it fires the next f.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/hybridgroup/gobot"
)

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

Output:

func FromScale 

func FromScale(input, min, max float64) float64

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

Example 
package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
)

func main() {
	fmt.Println(gobot.FromScale(5, 0, 10))
}

Output:

0.5

func On 

func On(e *Event, f func(s interface{})) (err error)

On executes f when e is Published to. Returns ErrUnknownEvent if Event does not exist.

Example 
package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
)

func main() {
	e := gobot.NewEvent()
	gobot.On(e, func(s interface{}) {
		fmt.Println(s)
	})
	gobot.Publish(e, 100)
	gobot.Publish(e, 200)
}

Output:

func Once 

func Once(e *Event, f func(s interface{})) (err error)

Once is similar to On except that it only executes f one time. Returns ErrUnknownEvent if Event does not exist.

Example 
package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
)

func main() {
	e := gobot.NewEvent()
	gobot.Once(e, func(s interface{}) {
		fmt.Println(s)
		fmt.Println("I will no longer respond to events")
	})
	gobot.Publish(e, 100)
	gobot.Publish(e, 200)
}

Output:

func Publish 

func Publish(e *Event, val interface{}) (err error)

Publish emits val to all subscribers of e. Returns ErrUnknownEvent if Event does not exist.

Example 
package main

import (
	"github.com/hybridgroup/gobot"
)

func main() {
	e := gobot.NewEvent()
	gobot.Publish(e, 100)
}

Output:

func Rand 

func Rand(max int) int

Rand returns a positive random int up to max

Example 
package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
)

func main() {
	i := gobot.Rand(100)
	fmt.Sprintln("%v is > 0 && < 100", i)
}

Output:

func ToScale 

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

Example 
package main

import (
	"fmt"

	"github.com/hybridgroup/gobot"
)

func main() {
	fmt.Println(gobot.ToScale(500, 0, 10))
}

Output:

10

func Version 

func Version() string

Version returns the current Gobot version

Types

type Adaptor 

type Adaptor interface {
	// Name returns the label for the Adaptor
	Name() 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 

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 

func NewCommander() Commander

NewCommander returns a new Commander.

type Connection 

type Connection Adaptor

A Connection is an instance of an Adaptor

type Connections 

type Connections []Connection

Connections represents a collection of Connection

func (*Connections) Each 

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

Each enumerates through the Connections and calls specified callback function.

func (*Connections) Finalize 

func (c *Connections) Finalize() (errs []error)

Finalize calls Finalize on each Connection in c

func (*Connections) Len 

func (c *Connections) Len() int

Len returns connections length

func (*Connections) Start 

func (c *Connections) Start() (errs []error)

Start calls Connect on each Connection in c

type Device 

type Device Driver

A Device is an instnace of a Driver

type Devices 

type Devices []Device

Devices represents a collection of Device

func (*Devices) Each 

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

Each enumerates through the Devices and calls specified callback function.

func (*Devices) Halt 

func (d *Devices) Halt() (errs []error)

Halt calls Halt on each Device in d

func (*Devices) Len 

func (d *Devices) Len() int

Len returns devices length

func (*Devices) Start 

func (d *Devices) Start() (errs []error)

Start calls Start on each Device in d

type Driver 

type Driver interface {
	// Name returns the label for the Driver
	Name() string
	// Start initiates the Driver
	Start() []error
	// Halt terminates the Driver
	Halt() []error
	// Connection returns the Connection assiciated with the Driver
	Connection() Connection
}

Driver is the interface that describes a driver in gobot

type Event 

type Event struct {
	sync.Mutex
	Callbacks []callback
}

Event executes the list of Callbacks when Chan is written to.

func NewEvent 

func NewEvent() *Event

NewEvent returns a new Event which is now listening for data.

func (*Event) Write 

func (e *Event) Write(data interface{})

Write writes data to the Event, it will not block and will not buffer if there are no active subscribers to the Event.

type Eventer 

type Eventer interface {
	// Events returns the Event map.
	Events() (events map[string]*Event)
	// Event returns an Event by name. Returns nil if the Event is not found.
	Event(name string) (event *Event)
	// AddEvent adds a new Event given a name.
	AddEvent(name string)
}

Eventer is the interface which describes behaviour for a Driver or Adaptor which uses events.

func NewEventer 

func NewEventer() Eventer

NewEventer returns a new Eventer.

type Gobot 

type Gobot struct {
	AutoStop bool
	Commander
	Eventer
	// contains filtered or unexported fields
}

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

func NewGobot 

func NewGobot() *Gobot

NewGobot returns a new Gobot

func (*Gobot) AddRobot 

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

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

func (*Gobot) Robot 

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

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

func (*Gobot) Robots 

func (g *Gobot) Robots() *Robots

Robots returns all robots associated with this Gobot.

func (*Gobot) Start 

func (g *Gobot) Start() (errs []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 (*Gobot) Stop 

func (g *Gobot) Stop() (errs []error)

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

type JSONConnection 

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

JSONConnection is a JSON representation of a Connection.

func NewJSONConnection 

func NewJSONConnection(connection Connection) *JSONConnection

NewJSONConnection returns a JSONConnection given a Connection.

type JSONDevice 

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 

func NewJSONDevice(device Device) *JSONDevice

NewJSONDevice returns a JSONDevice given a Device.

type JSONGobot 

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

JSONGobot is a JSON representation of a Gobot.

func NewJSONGobot 

func NewJSONGobot(gobot *Gobot) *JSONGobot

NewJSONGobot returns a JSONGobt given a Gobot.

type JSONRobot 

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 

func NewJSONRobot(robot *Robot) *JSONRobot

NewJSONRobot returns a JSONRobot given a Robot.

type Pinner 

type Pinner interface {
	Pin() string
}

Pinner is the interface that describes a driver's pin

type Porter 

type Porter interface {
	Port() string
}

Porter is the interface that describes an adaptor's port

type Robot 

type Robot struct {
	Name string
	Work func()

	Commander
	Eventer
	// contains filtered or unexported fields
}

Robot is a named entitity that manages a collection of connections and devices. It containes it's own work routine and a collection of custom commands to control a robot remotely via the Gobot api.

func NewRobot 

func NewRobot(name string, v ...interface{}) *Robot

NewRobot returns a new Robot given a name and optionally accepts: 

[]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

A name will be automaically generated if no name is supplied.

func (*Robot) AddConnection 

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 

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 

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 

func (r *Robot) Connections() *Connections

Connections returns all connections associated with this robot.

func (*Robot) Device 

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 

func (r *Robot) Devices() *Devices

Devices returns all devices associated with this Robot.

func (*Robot) Start 

func (r *Robot) Start() (errs []error)

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

func (*Robot) Stop 

func (r *Robot) Stop() (errs []error)

Stop stops a Robot's connections and Devices

type Robots 

type Robots []*Robot

Robots is a collection of Robot

func (*Robots) Each 

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

Each enumerates through the Robots and calls specified callback function.

func (*Robots) Len 

func (r *Robots) Len() int

Len returns the amount of Robots in the collection.

func (*Robots) Start 

func (r *Robots) Start() (errs []error)

Start calls the Start method of each Robot in the collection

func (*Robots) Stop 

func (r *Robots) Stop() (errs []error)

Stop calls the Stop method of each Robot in the collection

Source Files

View all Source files

Directories

Path Synopsis
api
Package api provides a webserver to interact with your Gobot program over the network.
 Package api provides a webserver to interact with your Gobot program over the network.
robeaux
CLI tool for generating new Gobot projects.
 CLI tool for generating new Gobot projects.
platforms
ardrone
Package ardrone provides the Gobot adaptor and driver for the Parrot Ardrone.
 Package ardrone provides the Gobot adaptor and driver for the Parrot Ardrone.
beaglebone
Package beaglebone provides the Gobot adaptor for the Beaglebone Black.
 Package beaglebone provides the Gobot adaptor for the Beaglebone Black.
bebop
Package bebop provides the Gobot adaptor and driver for the Parrot Bebop.
 Package bebop provides the Gobot adaptor and driver for the Parrot Bebop.
bebop/client
bebop/client/examples
This example will connect to the Bebop and stream it's video to a webpage via ffserver.
 This example will connect to the Bebop and stream it's video to a webpage via ffserver.
chip
Package chip contains the Gobot adaptor for the CHIP For further information refer to the chip README: https://github.com/hybridgroup/gobot/blob/master/platforms/chip/README.md
 Package chip contains the Gobot adaptor for the CHIP For further information refer to the chip README: https://github.com/hybridgroup/gobot/blob/master/platforms/chip/README.md
digispark
Package digispark provides the Gobot adaptor for the Digispark ATTiny-based USB development board.
 Package digispark provides the Gobot adaptor for the Digispark ATTiny-based USB development board.
firmata
Package firmata provides the Gobot adaptor for microcontrollers that support the Firmata protocol.
 Package firmata provides the Gobot adaptor for microcontrollers that support the Firmata protocol.
firmata/client
Package client provies a client for interacting with microcontrollers using the Firmata protocol https://github.com/firmata/protocol.
 Package client provies a client for interacting with microcontrollers using the Firmata protocol https://github.com/firmata/protocol.
firmata/client/examples
gpio
Package gpio provides Gobot drivers for General Purpose Input/Output devices.
 Package gpio provides Gobot drivers for General Purpose Input/Output devices.
i2c
Package i2c provides Gobot drivers for i2c devices.
 Package i2c provides Gobot drivers for i2c devices.
intel-iot
Package inteliot contains Gobot adaptors for the Intel IoT platforms.
 Package inteliot contains Gobot adaptors for the Intel IoT platforms.
intel-iot/edison
Package edison contains the Gobot adaptor for the Intel Edison.
 Package edison contains the Gobot adaptor for the Intel Edison.
joystick
Package joystick provides the Gobot adaptor and drivers for game controllers that are compatible with SDL.
 Package joystick provides the Gobot adaptor and drivers for game controllers that are compatible with SDL.
keyboard
Packge keyboard contains the Gobot drivers for keyboard support.
 Packge keyboard contains the Gobot drivers for keyboard support.
leap
Package leap provides the Gobot adaptor and driver for the Leap Motion.
 Package leap provides the Gobot adaptor and driver for the Leap Motion.
mavlink
Package mavlink contains the Gobot adaptor and driver for the MAVlink Communication Protocol.
 Package mavlink contains the Gobot adaptor and driver for the MAVlink Communication Protocol.
mavlink/common
mqtt
Package mqtt provides Gobot adaptor for the mqtt message service.
 Package mqtt provides Gobot adaptor for the mqtt message service.
neurosky
opencv
Packge opencv contains the Gobot drivers for opencv.
 Packge opencv contains the Gobot drivers for opencv.
pebble
Package pebble contains the Gobot adaptor and driver for Pebble smart watch.
 Package pebble contains the Gobot adaptor and driver for Pebble smart watch.
raspi
Package raspi contains the Gobot adaptor for the Raspberry Pi.
 Package raspi contains the Gobot adaptor for the Raspberry Pi.
spark
Package spark provides the Gobot adaptor for the Spark Core.
 Package spark provides the Gobot adaptor for the Spark Core.
sphero
Package sphero provides the Gobot adaptor and driver for the Sphero.
 Package sphero provides the Gobot adaptor and driver for the Sphero.
Package sysfs provides generic access to linux gpio.
 Package sysfs provides generic access to linux gpio.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.