139 lines
3.6 KiB
Go
139 lines
3.6 KiB
Go
package i2c
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"gobot.io/x/gobot"
|
|
)
|
|
|
|
const blinkmAddress = 0x09
|
|
|
|
// BlinkMDriver is a Gobot Driver for a BlinkM LED
|
|
type BlinkMDriver struct {
|
|
name string
|
|
connector Connector
|
|
connection Connection
|
|
Config
|
|
gobot.Commander
|
|
}
|
|
|
|
// NewBlinkMDriver creates a new BlinkMDriver.
|
|
//
|
|
// Params:
|
|
// conn Connector - the Adaptor to use with this Driver
|
|
//
|
|
// Optional params:
|
|
// i2c.WithBus(int): bus to use with this driver
|
|
// i2c.WithAddress(int): address to use with this driver
|
|
//
|
|
func NewBlinkMDriver(a Connector, options ...func(Config)) *BlinkMDriver {
|
|
b := &BlinkMDriver{
|
|
name: gobot.DefaultName("BlinkM"),
|
|
Commander: gobot.NewCommander(),
|
|
connector: a,
|
|
Config: NewConfig(),
|
|
}
|
|
|
|
for _, option := range options {
|
|
option(b)
|
|
}
|
|
|
|
b.AddCommand("Rgb", func(params map[string]interface{}) interface{} {
|
|
red := byte(params["red"].(float64))
|
|
green := byte(params["green"].(float64))
|
|
blue := byte(params["blue"].(float64))
|
|
return b.Rgb(red, green, blue)
|
|
})
|
|
|
|
b.AddCommand("Fade", func(params map[string]interface{}) interface{} {
|
|
red := byte(params["red"].(float64))
|
|
green := byte(params["green"].(float64))
|
|
blue := byte(params["blue"].(float64))
|
|
return b.Fade(red, green, blue)
|
|
})
|
|
|
|
b.AddCommand("FirmwareVersion", func(params map[string]interface{}) interface{} {
|
|
version, err := b.FirmwareVersion()
|
|
return map[string]interface{}{"version": version, "err": err}
|
|
})
|
|
|
|
b.AddCommand("Color", func(params map[string]interface{}) interface{} {
|
|
color, err := b.Color()
|
|
return map[string]interface{}{"color": color, "err": err}
|
|
})
|
|
|
|
return b
|
|
}
|
|
|
|
// Name returns the Name for the Driver
|
|
func (b *BlinkMDriver) Name() string { return b.name }
|
|
|
|
// SetName sets the Name for the Driver
|
|
func (b *BlinkMDriver) SetName(n string) { b.name = n }
|
|
|
|
// Connection returns the connection for the Driver
|
|
func (b *BlinkMDriver) Connection() gobot.Connection { return b.connection.(gobot.Connection) }
|
|
|
|
// Start starts the Driver up, and writes start command
|
|
func (b *BlinkMDriver) Start() (err error) {
|
|
bus := b.GetBusOrDefault(b.connector.GetDefaultBus())
|
|
address := b.GetAddressOrDefault(blinkmAddress)
|
|
|
|
b.connection, err = b.connector.GetConnection(address, bus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if _, err := b.connection.Write([]byte("o")); err != nil {
|
|
return err
|
|
}
|
|
return
|
|
}
|
|
|
|
// Halt returns true if device is halted successfully
|
|
func (b *BlinkMDriver) Halt() (err error) { return }
|
|
|
|
// Rgb sets color using r,g,b params
|
|
func (b *BlinkMDriver) Rgb(red byte, green byte, blue byte) (err error) {
|
|
if _, err = b.connection.Write([]byte("n")); err != nil {
|
|
return
|
|
}
|
|
_, err = b.connection.Write([]byte{red, green, blue})
|
|
return
|
|
}
|
|
|
|
// Fade removes color using r,g,b params
|
|
func (b *BlinkMDriver) Fade(red byte, green byte, blue byte) (err error) {
|
|
if _, err = b.connection.Write([]byte("c")); err != nil {
|
|
return
|
|
}
|
|
_, err = b.connection.Write([]byte{red, green, blue})
|
|
return
|
|
}
|
|
|
|
// FirmwareVersion returns version with MAYOR.minor format
|
|
func (b *BlinkMDriver) FirmwareVersion() (version string, err error) {
|
|
if _, err = b.connection.Write([]byte("Z")); err != nil {
|
|
return
|
|
}
|
|
data := []byte{0, 0}
|
|
read, err := b.connection.Read(data)
|
|
if read != 2 || err != nil {
|
|
return
|
|
}
|
|
return fmt.Sprintf("%v.%v", data[0], data[1]), nil
|
|
}
|
|
|
|
// Color returns an array with current rgb color
|
|
func (b *BlinkMDriver) Color() (color []byte, err error) {
|
|
if _, err = b.connection.Write([]byte("g")); err != nil {
|
|
return
|
|
}
|
|
data := []byte{0, 0, 0}
|
|
read, err := b.connection.Read(data)
|
|
if read != 3 || err != nil {
|
|
return []byte{}, err
|
|
}
|
|
return []byte{data[0], data[1], data[2]}, nil
|
|
}
|