gobot

package module
v0.0.0-...-61b36ed Latest Latest
Warning

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

 Go to latest Published: Sep 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/)

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
    • Digital Sensor
    • Direct Pin
    • LED
    • 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
    • Wii Nunchuck Controller

More platforms and drivers are coming soon...

Getting Started

Install Gobot with: go get -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 is the main point of entry in your Gobot application. A Gobot is typically composed of one or more robots that makes up a project.

Commands are a way to expose your robots functionality with the external world. A Gobot can be configured to expose a restful HTTP interface using the api package. You can define custom commands on your Gobot and interact with your application as a web service.

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

Web Enabled? You bet! 

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

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

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func After 

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

After triggers the passed function after `t` duration.

func Assert 

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

func Every 

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

Every triggers f every `t` time until the end of days.

func FromScale 

func FromScale(input, min, max float64) float64

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

func Once 

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

func Publish 

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

func Rand 

func Rand(max int) int

func Refute 

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

func ToScale 

func ToScale(input, min, max float64) float64

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

func (*Adaptor) Connected 

func (a *Adaptor) Connected() bool

func (*Adaptor) Name 

func (a *Adaptor) Name() string

func (*Adaptor) Port 

func (a *Adaptor) Port() string

func (*Adaptor) SetConnected 

func (a *Adaptor) SetConnected(b bool)

func (*Adaptor) SetName 

func (a *Adaptor) SetName(s string)

func (*Adaptor) SetPort 

func (a *Adaptor) SetPort(s string)

func (*Adaptor) ToJSON 

func (a *Adaptor) ToJSON() *JSONConnection

func (*Adaptor) Type 

func (a *Adaptor) Type() string

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
}

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

func (*Driver) Adaptor 

func (d *Driver) Adaptor() AdaptorInterface

func (*Driver) AddCommand 

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

func (*Driver) AddEvent 

func (d *Driver) AddEvent(name string)

func (*Driver) Command 

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

func (*Driver) Commands 

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

func (*Driver) Event 

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

func (*Driver) Events 

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

func (*Driver) Interval 

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

func (*Driver) Name 

func (d *Driver) Name() string

func (*Driver) Pin 

func (d *Driver) Pin() string

func (*Driver) SetInterval 

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

func (*Driver) SetName 

func (d *Driver) SetName(s string)

func (*Driver) SetPin 

func (d *Driver) SetPin(pin string)

func (*Driver) ToJSON 

func (d *Driver) ToJSON() *JSONDevice

func (*Driver) Type 

func (d *Driver) Type() string

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
}

type Event 

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

func NewEvent 

func NewEvent() *Event

func (*Event) Read 

func (e *Event) Read()

func (*Event) Write 

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

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 instantiates 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 our Gobot instance.

func (*Gobot) Command 

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

Command fetch the associated command using the given command name

func (*Gobot) Commands 

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

Commands lists all available commands on this Gobot instance.

func (*Gobot) Robot 

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

Robot find a robot with a given name.

func (*Gobot) Robots 

func (g *Gobot) Robots() *robots

Robots fetch all robots associated with this Gobot instance.

func (*Gobot) Start 

func (g *Gobot) Start()

Start runs the main Gobot event loop

func (*Gobot) ToJSON 

func (g *Gobot) ToJSON() *JSONGobot

ToJSON retrieves a JSON representation of this Gobot.

type JSONConnection 

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

type JSONDevice 

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

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 software representation of a physical board. A robot is a named entitity that manages multiple IO devices using a set of adaptors. Additionally a user can specificy custom commands to control a robot remotely.

func NewRobot 

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

NewRobot constructs a new named robot. Though a robot's name will be generated, we recommend that user take care of naming a robot for later access.

func NewTestRobot 

func NewTestRobot(name string) *Robot

func (*Robot) AddCommand 

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

AddCommand setup a new command that we be made available via the REST api.

func (*Robot) AddConnection 

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

AddConnection add a new connection on this robot.

func (*Robot) AddDevice 

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

AddDevice adds a new device on this robot.

func (*Robot) Command 

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

Command fetch a named command on this robot.

func (*Robot) Commands 

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

Commands lists out all available commands on this robot.

func (*Robot) Connection 

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

Connection finds a connection by name.

func (*Robot) Connections 

func (r *Robot) Connections() *connections

Connections retrieves all connections on this robot.

func (*Robot) Device 

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

Device finds a device by name.

func (*Robot) Devices 

func (r *Robot) Devices() *devices

Devices retrieves all devices associated with this robot.

func (*Robot) Start 

func (r *Robot) Start()

Start a robot instance and runs it's work function if any. You should not need to manually start a robot if already part of a Gobot application as the robot will be automatically started for you.

func (*Robot) ToJSON 

func (r *Robot) ToJSON() *JSONRobot

ToJSON returns a JSON representation of the master robot.

Source Files

View all Source files

Directories

Path Synopsis
api
robeaux
Use Gobot to control BeagleBone's digital pins directly
 Use Gobot to control BeagleBone's digital pins directly
platforms
ardrone
beaglebone
digispark
firmata
gpio
i2c
joystick
leap
mavlink
mavlink/common
neurosky
opencv
pebble
spark
sphero

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.