gobot

package module
v0.0.0-...-1595f01 Latest Latest
Warning

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

 Go to latest Published: Nov 18, 2014 License: Apache-2.0 Imports: 13 Imported by: 0

README

Gobot

http://gobot.io/

Gobot 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 Ruby or Javascript on robots? Check out our sister projects Artoo (http://artoo.io) and Cylon.js (http://cylonjs.com/)

GoDoc Build Status Coverage Status

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 cylon-gpio module:

  • GPIO <=> Drivers
    • Analog Sensor
    • Button
    • Direct Pin
    • Digital Sensor
    • Direct Pin
    • LED
    • MakeyButton
    • Motor
    • Servo

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

  • I2C <=> Drivers
    • BlinkM
    • HMC6352
    • MPL1150A2
    • MPU6050
    • Wii Nunchuck Controller

More platforms and drivers are coming soon...

Getting Started

Install Gobot with: go get -d -u github.com/hybridgroup/gobot/...

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.Username = "Gort"
  server.Password = "klaatu"
  server.Start()

You may access the robeaux AngularJS 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!

Contributing

  • All active development is in the dev branch. New or updated features must be added to the dev branch. Hotfixes will be considered on the master branch in situations where it does not alter behaviour or features, only fixes a bug.
  • All patches must be provided under the Apache 2.0 License
  • Please use the -s option in git to "sign off" that the commit is your work and you are providing it under the Apache 2.0 License
  • Submit a Github Pull Request to the appropriate branch and ideally discuss the changes with us in IRC.
  • We will look at the patch, test it out, and give you feedback.
  • Avoid doing minor whitespace changes, renamings, etc. along with merged content. These will be done by the maintainers from time to time but they can complicate merges and should be done seperately.
  • Take care to maintain the existing coding style.
  • golint and go fmt your code.
  • Add unit tests for any new or changed functionality.
  • All pull requests should be "fast forward"
    • If there are commits after yours use “git rebase -i <new_head_branch>”
    • If you have local changes you may need to use “git stash”
    • For git help see progit which is an awesome (and free) book on git

License

Copyright (c) 2013-2014 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

This section is empty.

Functions

func After 

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

After triggers f after t duration.

Example 
package main

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

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

Output:

func Assert 

func Assert(t *testing.T, a interface{}, b interface{})

Assert ensures a and b are equal and of the same type, or else it causes a t.Error

Example 
package main

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

func main() {
	t := &testing.T{}
	var a int = 100
	var b int = 100
	gobot.Assert(t, a, b)
}

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"
	"github.com/hybridgroup/gobot"
	"time"
)

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 NewLoopbackAdaptor 

func NewLoopbackAdaptor(name string) *loopbackAdaptor

func NewPingDriver 

func NewPingDriver(adaptor *loopbackAdaptor, name string) *pingDriver

func NewTestAdaptor 

func NewTestAdaptor(name string) *testAdaptor

func NewTestDriver 

func NewTestDriver(name string, adaptor *testAdaptor) *testDriver

func NewTestStruct 

func NewTestStruct() *testStruct

func On 

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

On executes f when e is Published to.

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

Once is similar to On except that it only executes f one time.

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

Publish emits val to all subscribers of e.

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 Refute 

func Refute(t *testing.T, a interface{}, b interface{})

Refute ensures a and b are not equal, causes a t.Error if they are equal

Example 
package main

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

func main() {
	t := &testing.T{}
	var a int = 100
	var b int = 200
	gobot.Refute(t, a, b)
}

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

Types

type Adaptor 

type Adaptor struct {
	// contains filtered or unexported fields
}

func NewAdaptor 

func NewAdaptor(name string, adaptorType string, v ...interface{}) *Adaptor

NewAdaptor returns a new Adaptor given a name, adaptorType and optionally accepts: 

string: Port the adaptor connects to

adaptorType is a label used for identification in the api

func (*Adaptor) Connected 

func (a *Adaptor) Connected() bool

Connected returns true if the adaptor is connected

func (*Adaptor) Name 

func (a *Adaptor) Name() string

Name returns adaptor name

func (*Adaptor) Port 

func (a *Adaptor) Port() string

Port returns adaptor port

func (*Adaptor) SetConnected 

func (a *Adaptor) SetConnected(b bool)

SetConnected sets adaptor as connected/disconnected

func (*Adaptor) SetName 

func (a *Adaptor) SetName(s string)

SetName sets adaptor name

func (*Adaptor) SetPort 

func (a *Adaptor) SetPort(s string)

SetPort sets adaptor port

func (*Adaptor) ToJSON 

func (a *Adaptor) ToJSON() *JSONConnection

ToJSON returns a json representation of an adaptor

func (*Adaptor) Type 

func (a *Adaptor) Type() string

Type returns adaptor type

type AdaptorInterface 

type AdaptorInterface interface {
	Finalize() bool
	Connect() bool
	Port() string
	Name() string
	Type() string
	Connected() bool
	SetConnected(bool)
	SetName(string)
	SetPort(string)
	ToJSON() *JSONConnection
}

AdaptorInterface defines behaviour expected for a Gobot Adaptor

type Connection 

type Connection AdaptorInterface

type Device 

type Device DriverInterface

type Driver 

type Driver struct {
	// contains filtered or unexported fields
}

func NewDriver 

func NewDriver(name string, driverType string, v ...interface{}) *Driver

NewDriver returns a new Driver given a name, driverType and optionally accepts: 

string: Pin the driver connects to
AdaptorInterface: Adaptor the driver connects to
time.Duration: Interval used internally for polling where applicable

driverType is a label used for identification in the api

func (*Driver) Adaptor 

func (d *Driver) Adaptor() AdaptorInterface

Adaptor returns driver adaptor

func (*Driver) AddCommand 

func (d *Driver) AddCommand(name string, f func(map[string]interface{}) interface{})

AddCommand links specified command name to `f`

func (*Driver) AddEvent 

func (d *Driver) AddEvent(name string)

AddEvents adds a new event by name

func (*Driver) Command 

func (d *Driver) Command(name string) func(map[string]interface{}) interface{}

Command retrieves a command by name

func (*Driver) Commands 

func (d *Driver) Commands() map[string]func(map[string]interface{}) interface{}

Commands returns a map of driver commands

func (*Driver) Event 

func (d *Driver) Event(name string) *Event

Event returns an event by name if exists

func (*Driver) Events 

func (d *Driver) Events() map[string]*Event

Events returns driver events map

func (*Driver) Interval 

func (d *Driver) Interval() time.Duration

Interval current driver interval duration

func (*Driver) Name 

func (d *Driver) Name() string

Name returns driver name.

func (*Driver) Pin 

func (d *Driver) Pin() string

Pin returns driver pin

func (*Driver) SetInterval 

func (d *Driver) SetInterval(t time.Duration)

SetInterval defines driver interval duration.

func (*Driver) SetName 

func (d *Driver) SetName(s string)

SetName sets driver name.

func (*Driver) SetPin 

func (d *Driver) SetPin(pin string)

SetPin defines driver pin

func (*Driver) ToJSON 

func (d *Driver) ToJSON() *JSONDevice

ToJSON returns JSON Driver represnentation including adaptor and commands

func (*Driver) Type 

func (d *Driver) Type() string

Type returns driver type

type DriverInterface 

type DriverInterface interface {
	Start() bool
	Halt() bool
	Adaptor() AdaptorInterface
	SetInterval(time.Duration)
	Interval() time.Duration
	SetName(string)
	Name() string
	Pin() string
	SetPin(string)
	Command(string) func(map[string]interface{}) interface{}
	Commands() map[string]func(map[string]interface{}) interface{}
	AddCommand(string, func(map[string]interface{}) interface{})
	Events() map[string]*Event
	Event(string) *Event
	AddEvent(string)
	Type() string
	ToJSON() *JSONDevice
}

DriverInterface defines Driver expected behaviour

type Event 

type Event struct {
	Chan      chan interface{}
	Callbacks []callback
}

func NewEvent 

func NewEvent() *Event

NewEvent returns a new event which is then ready for publishing and subscribing.

func (*Event) Read 

func (e *Event) Read()

Read publishes to all subscribers of e if there is any new data

func (*Event) Write 

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

Write writes data to the Event

type Gobot 

type Gobot struct {
	// contains filtered or unexported fields
}

Gobot is a container composed of one or more robots

func NewGobot 

func NewGobot() *Gobot

NewGobot returns a new Gobot

func (*Gobot) AddCommand 

func (g *Gobot) AddCommand(name string, f func(map[string]interface{}) interface{})

AddCommand creates a new command and adds it to the Gobot. This command will be available via HTTP using '/commands/name'

Example: 

gbot.AddCommand( 'rollover', func( params map[string]interface{}) interface{} {
	fmt.Println( "Rolling over - Stand by...")
})

With the api package setup, you can now get your Gobot to rollover using: http://localhost:3000/commands/rollover

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) Command 

func (g *Gobot) Command(name string) func(map[string]interface{}) interface{}

Command reutnrs a command given a name.

func (*Gobot) Commands 

func (g *Gobot) Commands() map[string]func(map[string]interface{}) interface{}

Commands returns all available commands on this Gobot.

func (*Gobot) Robot 

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

Robot returns a robot given name. Returns nil on no robot.

func (*Gobot) Robots 

func (g *Gobot) Robots() *robots

Robots returns all robots associated with this Gobot instance.

func (*Gobot) Start 

func (g *Gobot) Start()

Start calls the Start method on each robot in it's collection of robots, and stops all robots on reception of a SIGINT. Start will block the execution of your main function until it receives the SIGINT.

func (*Gobot) ToJSON 

func (g *Gobot) ToJSON() *JSONGobot

ToJSON returns a JSON representation of this Gobot.

type JSONConnection 

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

JSONConnection holds a JSON representation of 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 Gobot Device.

type JSONGobot 

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

JSONGobot holds a JSON representation of 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.

type NullReadWriteCloser 

type NullReadWriteCloser struct{}

func (NullReadWriteCloser) Close 

func (NullReadWriteCloser) Close() error

func (NullReadWriteCloser) Read 

func (NullReadWriteCloser) Read(b []byte) (int, error)

func (NullReadWriteCloser) Write 

func (NullReadWriteCloser) Write(p []byte) (int, error)

type Robot 

type Robot struct {
	Name string

	Work func()
	// 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

func NewTestRobot 

func NewTestRobot(name string) *Robot

func (*Robot) AddCommand 

func (r *Robot) AddCommand(name string, f func(map[string]interface{}) interface{})

AddCommand adds a new command to the robot's collection of commands

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) Command 

func (r *Robot) Command(name string) func(map[string]interface{}) interface{}

Command returns the command given a name.

func (*Robot) Commands 

func (r *Robot) Commands() map[string]func(map[string]interface{}) interface{}

Commands returns all available commands on the robot.

func (*Robot) Connection 

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

Connection returns a connection given a name. Returns nil on no connection.

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 on no device.

func (*Robot) Devices 

func (r *Robot) Devices() *devices

Devices returns all devices associated with this robot.

func (*Robot) Start 

func (r *Robot) Start()

Start starts all the robot's connections and drivers and runs it's work function.

func (*Robot) ToJSON 

func (r *Robot) ToJSON() *JSONRobot

ToJSON returns a JSON representation of the robot.

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.
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.
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.
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.