README

GPIO

This package provides drivers for General Purpose Input/Output (GPIO) devices. It is normally used by connecting an adaptor such as firmata that supports the needed interfaces for GPIO devices.

Getting Started

Installing

go get -d -u gobot.io/x/gobot/...

Hardware Support

Gobot has a extensible system for connecting to hardware devices. The following GPIO devices are currently supported: - Button - Buzzer - Direct Pin - Grove Button - Grove Buzzer - Grove LED - Grove Magnetic Switch - Grove Relay - Grove Touch Sensor - LED - Makey Button - Motor - Proximity Infra Red (PIR) Motion Sensor - Relay - RGB LED - Servo - Stepper Motor - TM1638 LED Controller

More drivers are coming soon...

Expand ▾ Collapse ▴

Documentation

Overview

    Package gpio provides Gobot drivers for General Purpose Input/Output devices.

    Installing:

    go get -d -u gobot.io/x/gobot
    

    For further information refer to gpio README: https://github.com/hybridgroup/gobot/blob/master/platforms/gpio/README.md

    Index

    Constants

    View Source
    const (
    	AIP1640DataCmd  = 0x40
    	AIP1640DispCtrl = 0x88
    	AIP1640AddrCmd  = 0xC0
    
    	AIP1640FixedAddr = 0x04
    )
    View Source
    const (
    	Whole   = 4
    	Half    = 2
    	Quarter = 1
    	Eighth  = 0.500
    )
    View Source
    const (
    	Rest = 0
    	C0   = 16.35
    	Db0  = 17.32
    	D0   = 18.35
    	Eb0  = 19.45
    	E0   = 20.60
    	F0   = 21.83
    	Gb0  = 23.12
    	G0   = 24.50
    	Ab0  = 25.96
    	A0   = 27.50
    	Bb0  = 29.14
    	B0   = 30.87
    	C1   = 32.70
    	Db1  = 34.65
    	D1   = 36.71
    	Eb1  = 38.89
    	E1   = 41.20
    	F1   = 43.65
    	Gb1  = 46.25
    	G1   = 49.00
    	Ab1  = 51.91
    	A1   = 55.00
    	Bb1  = 58.27
    	B1   = 61.74
    	C2   = 65.41
    	Db2  = 69.30
    	D2   = 73.42
    	Eb2  = 77.78
    	E2   = 82.41
    	F2   = 87.31
    	Gb2  = 92.50
    	G2   = 98.00
    	Ab2  = 103.83
    	A2   = 110.00
    	Bb2  = 116.54
    	B2   = 123.47
    	C3   = 130.81
    	Db3  = 138.59
    	D3   = 146.83
    	Eb3  = 155.56
    	E3   = 164.81
    	F3   = 174.61
    	Gb3  = 185.00
    	G3   = 196.00
    	Ab3  = 207.65
    	A3   = 220.00
    	Bb3  = 233.08
    	B3   = 246.94
    	C4   = 261.63
    	Db4  = 277.18
    	D4   = 293.66
    	Eb4  = 311.13
    	E4   = 329.63
    	F4   = 349.23
    	Gb4  = 369.99
    	G4   = 392.00
    	Ab4  = 415.30
    	A4   = 440.00
    	Bb4  = 466.16
    	B4   = 493.88
    	C5   = 523.25
    	Db5  = 554.37
    	D5   = 587.33
    	Eb5  = 622.25
    	E5   = 659.25
    	F5   = 698.46
    	Gb5  = 739.99
    	G5   = 783.99
    	Ab5  = 830.61
    	A5   = 880.00
    	Bb5  = 932.33
    	B5   = 987.77
    	C6   = 1046.50
    	Db6  = 1108.73
    	D6   = 1174.66
    	Eb6  = 1244.51
    	E6   = 1318.51
    	F6   = 1396.91
    	Gb6  = 1479.98
    	G6   = 1567.98
    	Ab6  = 1661.22
    	A6   = 1760.00
    	Bb6  = 1864.66
    	B6   = 1975.53
    	C7   = 2093.00
    	Db7  = 2217.46
    	D7   = 2349.32
    	Eb7  = 2489.02
    	E7   = 2637.02
    	F7   = 2793.83
    	Gb7  = 2959.96
    	G7   = 3135.96
    	Ab7  = 3322.44
    	A7   = 3520.00
    	Bb7  = 3729.31
    	B7   = 3951.07
    	C8   = 4186.01
    	Db8  = 4434.92
    	D8   = 4698.63
    	Eb8  = 4978.03
    	E8   = 5274.04
    	F8   = 5587.65
    	Gb8  = 5919.91
    	G8   = 6271.93
    	Ab8  = 6644.88
    	A8   = 7040.00
    	Bb8  = 7458.62
    	B8   = 7902.13
    )
    View Source
    const (
    	// Error event
    	Error = "error"
    	// ButtonRelease event
    	ButtonRelease = "release"
    	// ButtonPush event
    	ButtonPush = "push"
    	// Data event
    	Data = "data"
    	// Vibration event
    	Vibration = "vibration"
    	// MotionDetected event
    	MotionDetected = "motion-detected"
    	// MotionStopped event
    	MotionStopped = "motion-stopped"
    )
    View Source
    const (
    	HD44780_CLEARDISPLAY        = 0x01
    	HD44780_RETURNHOME          = 0x02
    	HD44780_ENTRYMODESET        = 0x04
    	HD44780_DISPLAYCONTROL      = 0x08
    	HD44780_CURSORSHIFT         = 0x10
    	HD44780_FUNCTIONSET         = 0x20
    	HD44780_SETCGRAMADDR        = 0x40
    	HD44780_SETDDRAMADDR        = 0x80
    	HD44780_ENTRYRIGHT          = 0x00
    	HD44780_ENTRYLEFT           = 0x02
    	HD44780_ENTRYSHIFTINCREMENT = 0x01
    	HD44780_ENTRYSHIFTDECREMENT = 0x00
    	HD44780_DISPLAYON           = 0x04
    	HD44780_DISPLAYOFF          = 0x00
    	HD44780_CURSORON            = 0x02
    	HD44780_CURSOROFF           = 0x00
    	HD44780_BLINKON             = 0x01
    	HD44780_BLINKOFF            = 0x00
    	HD44780_DISPLAYMOVE         = 0x08
    	HD44780_CURSORMOVE          = 0x00
    	HD44780_MOVERIGHT           = 0x04
    	HD44780_MOVELEFT            = 0x00
    	HD44780_1LINE               = 0x00
    	HD44780_2LINE               = 0x08
    	HD44780_5x8DOTS             = 0x00
    	HD44780_5x10DOTS            = 0x04
    	HD44780_4BITBUS             = 0x00
    	HD44780_8BITBUS             = 0x10
    )
    View Source
    const (
    	MAX7219Digit0 = 0x01
    	MAX7219Digit1 = 0x02
    	MAX7219Digit2 = 0x03
    	MAX7219Digit3 = 0x04
    	MAX7219Digit4 = 0x05
    	MAX7219Digit5 = 0x06
    	MAX7219Digit6 = 0x07
    	MAX7219Digit7 = 0x08
    
    	MAX7219DecodeMode  = 0x09
    	MAX7219Intensity   = 0x0a
    	MAX7219ScanLimit   = 0x0b
    	MAX7219Shutdown    = 0x0c
    	MAX7219DisplayTest = 0x0f
    )
    View Source
    const (
    	TM1638None = iota
    	TM1638Red
    	TM1638Green
    )
    View Source
    const (
    	TM1638DataCmd  = 0x40
    	TM1638DispCtrl = 0x80
    	TM1638AddrCmd  = 0xC0
    
    	TM1638WriteDisp = 0x00
    	TM1638ReadKeys  = 0x02
    	TM1638FixedAddr = 0x04
    )
    View Source
    const (
    	HD44780_2NDLINEOFFSET = 0x40
    )

    Variables

    View Source
    var (
    	// ErrServoWriteUnsupported is the error resulting when a driver attempts to use
    	// hardware capabilities which a connection does not support
    	ErrServoWriteUnsupported = errors.New("ServoWrite is not supported by this platform")
    	// ErrPwmWriteUnsupported is the error resulting when a driver attempts to use
    	// hardware capabilities which a connection does not support
    	ErrPwmWriteUnsupported = errors.New("PwmWrite is not supported by this platform")
    	// ErrAnalogReadUnsupported is error resulting when a driver attempts to use
    	// hardware capabilities which a connection does not support
    	ErrAnalogReadUnsupported = errors.New("AnalogRead is not supported by this platform")
    	// ErrDigitalWriteUnsupported is the error resulting when a driver attempts to use
    	// hardware capabilities which a connection does not support
    	ErrDigitalWriteUnsupported = errors.New("DigitalWrite is not supported by this platform")
    	// ErrDigitalReadUnsupported is the error resulting when a driver attempts to use
    	// hardware capabilities which a connection does not support
    	ErrDigitalReadUnsupported = errors.New("DigitalRead is not supported by this platform")
    	// ErrServoOutOfRange is the error resulting when a driver attempts to use
    	// hardware capabilities which a connection does not support
    	ErrServoOutOfRange = errors.New("servo angle must be between 0-180")
    )
    View Source
    var StepperModes = struct {
    	SinglePhaseStepping [][4]byte
    	DualPhaseStepping   [][4]byte
    	HalfStepping        [][4]byte
    }{
    
    	SinglePhaseStepping: [][4]byte{
    		{1, 0, 0, 0},
    		{0, 1, 0, 0},
    		{0, 0, 1, 0},
    		{0, 0, 0, 1},
    	},
    
    	DualPhaseStepping: [][4]byte{
    		{1, 0, 0, 1},
    		{1, 1, 0, 0},
    		{0, 1, 1, 0},
    		{0, 0, 1, 1},
    	},
    
    	HalfStepping: [][4]byte{
    		{1, 0, 0, 1},
    		{1, 0, 0, 0},
    		{1, 1, 0, 0},
    		{0, 1, 0, 0},
    		{0, 1, 1, 0},
    		{0, 0, 1, 0},
    		{0, 0, 1, 1},
    		{0, 0, 0, 1},
    	},
    }

      StepperModes to decide on Phase and Stepping

      Functions

      func NewTM1638Fonts

      func NewTM1638Fonts() map[string]byte

        NewTM1638Fonts returns a map with fonts and their corresponding byte for proper representation on the 7-segment LCD

        Types

        type AIP1640Driver

        type AIP1640Driver struct {
        	gobot.Commander
        	// contains filtered or unexported fields
        }

          AIP1640Driver is the gobot driver for the AIP1640 LED driver used in the WEMOS D1 mini Matrix LED Shield. It has some similarities with the TM16xx LED drivers

          Datasheet CN: https://datasheet.lcsc.com/szlcsc/AiP1640_C82650.pdf

          Library ported from: https://github.com/wemos/WEMOS_Matrix_LED_Shield_Arduino_Library

          func NewAIP1640Driver

          func NewAIP1640Driver(a gobot.Connection, clockPin string, dataPin string) *AIP1640Driver

            NewAIP1640Driver return a new AIP1640Driver given a gobot.Connection and the clock, data and strobe pins

            func (*AIP1640Driver) Clear

            func (a *AIP1640Driver) Clear()

              Clear empties the buffer (turns off all the LEDs)

              func (*AIP1640Driver) Connection

              func (a *AIP1640Driver) Connection() gobot.Connection

                Connection returns the AIP1640Driver Connection

                func (*AIP1640Driver) Display

                func (a *AIP1640Driver) Display()

                  Display sends the buffer to the display (ie. turns on/off the corresponding LEDs)

                  func (*AIP1640Driver) DrawMatrix

                  func (a *AIP1640Driver) DrawMatrix(data [8]byte)

                    DrawMatrix sets the whole buffer

                    func (*AIP1640Driver) DrawPixel

                    func (a *AIP1640Driver) DrawPixel(x, y byte, enabled bool)

                      DrawPixel turns on or off a specific in the buffer

                      func (*AIP1640Driver) DrawRow

                      func (a *AIP1640Driver) DrawRow(row, data byte)

                        DrawRow sets any given row of LEDs in the buffer

                        func (*AIP1640Driver) Halt

                        func (a *AIP1640Driver) Halt() (err error)

                          Halt implements the Driver interface

                          func (*AIP1640Driver) Name

                          func (a *AIP1640Driver) Name() string

                            Name returns the AIP1640Drivers name

                            func (*AIP1640Driver) SetIntensity

                            func (a *AIP1640Driver) SetIntensity(level byte)

                              SetIntensity changes the intensity (from 1 to 7) of the display

                              func (*AIP1640Driver) SetName

                              func (a *AIP1640Driver) SetName(n string)

                                SetName sets the AIP1640Drivers name

                                func (*AIP1640Driver) Start

                                func (a *AIP1640Driver) Start() (err error)

                                  Start initializes the tm1638, it uses a SPI-like communication protocol

                                  type ButtonDriver

                                  type ButtonDriver struct {
                                  	Active       bool
                                  	DefaultState int
                                  
                                  	gobot.Eventer
                                  	// contains filtered or unexported fields
                                  }

                                    ButtonDriver Represents a digital Button

                                    func NewButtonDriver

                                    func NewButtonDriver(a DigitalReader, pin string, v ...time.Duration) *ButtonDriver

                                      NewButtonDriver returns a new ButtonDriver with a polling interval of 10 Milliseconds given a DigitalReader and pin.

                                      Optionally accepts:

                                      time.Duration: Interval at which the ButtonDriver is polled for new information
                                      

                                      func (*ButtonDriver) Connection

                                      func (b *ButtonDriver) Connection() gobot.Connection

                                        Connection returns the ButtonDrivers Connection

                                        func (*ButtonDriver) Halt

                                        func (b *ButtonDriver) Halt() (err error)

                                          Halt stops polling the button for new information

                                          func (*ButtonDriver) Name

                                          func (b *ButtonDriver) Name() string

                                            Name returns the ButtonDrivers name

                                            func (*ButtonDriver) Pin

                                            func (b *ButtonDriver) Pin() string

                                              Pin returns the ButtonDrivers pin

                                              func (*ButtonDriver) SetName

                                              func (b *ButtonDriver) SetName(n string)

                                                SetName sets the ButtonDrivers name

                                                func (*ButtonDriver) Start

                                                func (b *ButtonDriver) Start() (err error)

                                                  Start starts the ButtonDriver and polls the state of the button at the given interval.

                                                  Emits the Events:

                                                  Push int - On button push
                                                  Release int - On button release
                                                  Error error - On button error
                                                  

                                                  type BuzzerDriver

                                                  type BuzzerDriver struct {
                                                  	BPM float64
                                                  	// contains filtered or unexported fields
                                                  }

                                                    BuzzerDriver represents a digital buzzer

                                                    func NewBuzzerDriver

                                                    func NewBuzzerDriver(a DigitalWriter, pin string) *BuzzerDriver

                                                      NewBuzzerDriver return a new BuzzerDriver given a DigitalWriter and pin.

                                                      func (*BuzzerDriver) Connection

                                                      func (l *BuzzerDriver) Connection() gobot.Connection

                                                        Connection returns the BuzzerDrivers Connection

                                                        func (*BuzzerDriver) Halt

                                                        func (l *BuzzerDriver) Halt() (err error)

                                                          Halt implements the Driver interface

                                                          func (*BuzzerDriver) Name

                                                          func (l *BuzzerDriver) Name() string

                                                            Name returns the BuzzerDrivers name

                                                            func (*BuzzerDriver) Off

                                                            func (l *BuzzerDriver) Off() (err error)

                                                              Off sets the buzzer to a low state.

                                                              func (*BuzzerDriver) On

                                                              func (l *BuzzerDriver) On() (err error)

                                                                On sets the buzzer to a high state.

                                                                func (*BuzzerDriver) Pin

                                                                func (l *BuzzerDriver) Pin() string

                                                                  Pin returns the BuzzerDrivers name

                                                                  func (*BuzzerDriver) SetName

                                                                  func (l *BuzzerDriver) SetName(n string)

                                                                    SetName sets the BuzzerDrivers name

                                                                    func (*BuzzerDriver) Start

                                                                    func (l *BuzzerDriver) Start() (err error)

                                                                      Start implements the Driver interface

                                                                      func (*BuzzerDriver) State

                                                                      func (l *BuzzerDriver) State() bool

                                                                        State return true if the buzzer is On and false if the led is Off

                                                                        func (*BuzzerDriver) Toggle

                                                                        func (l *BuzzerDriver) Toggle() (err error)

                                                                          Toggle sets the buzzer to the opposite of it's current state

                                                                          func (*BuzzerDriver) Tone

                                                                          func (l *BuzzerDriver) Tone(hz, duration float64) (err error)

                                                                          type DigitalReader

                                                                          type DigitalReader interface {
                                                                          	DigitalRead(string) (val int, err error)
                                                                          }

                                                                            DigitalReader interface represents an Adaptor which has DigitalRead capabilities

                                                                            type DigitalWriter

                                                                            type DigitalWriter interface {
                                                                            	DigitalWrite(string, byte) (err error)
                                                                            }

                                                                              DigitalWriter interface represents an Adaptor which has DigitalWrite capabilities

                                                                              type DirectPinDriver

                                                                              type DirectPinDriver struct {
                                                                              	gobot.Commander
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                DirectPinDriver represents a GPIO pin

                                                                                func NewDirectPinDriver

                                                                                func NewDirectPinDriver(a gobot.Connection, pin string) *DirectPinDriver

                                                                                  NewDirectPinDriver return a new DirectPinDriver given a Connection and pin.

                                                                                  Adds the following API Commands:

                                                                                  "DigitalRead" - See DirectPinDriver.DigitalRead
                                                                                  "DigitalWrite" - See DirectPinDriver.DigitalWrite
                                                                                  "AnalogWrite" - See DirectPinDriver.AnalogWrite
                                                                                  "PwmWrite" - See DirectPinDriver.PwmWrite
                                                                                  "ServoWrite" - See DirectPinDriver.ServoWrite
                                                                                  

                                                                                  func (*DirectPinDriver) Connection

                                                                                  func (d *DirectPinDriver) Connection() gobot.Connection

                                                                                    Connection returns the DirectPinDrivers Connection

                                                                                    func (*DirectPinDriver) DigitalRead

                                                                                    func (d *DirectPinDriver) DigitalRead() (val int, err error)

                                                                                      DigitalRead returns the current digital state of the pin

                                                                                      func (*DirectPinDriver) DigitalWrite

                                                                                      func (d *DirectPinDriver) DigitalWrite(level byte) (err error)

                                                                                        DigitalWrite writes to the pin. Acceptable values are 1 or 0

                                                                                        func (*DirectPinDriver) Halt

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

                                                                                          Halt implements the Driver interface

                                                                                          func (*DirectPinDriver) Name

                                                                                          func (d *DirectPinDriver) Name() string

                                                                                            Name returns the DirectPinDrivers name

                                                                                            func (*DirectPinDriver) Off

                                                                                            func (d *DirectPinDriver) Off() (err error)

                                                                                              Turn Off pin

                                                                                              func (*DirectPinDriver) On

                                                                                              func (d *DirectPinDriver) On() (err error)

                                                                                                Turn On pin

                                                                                                func (*DirectPinDriver) Pin

                                                                                                func (d *DirectPinDriver) Pin() string

                                                                                                  Pin returns the DirectPinDrivers pin

                                                                                                  func (*DirectPinDriver) PwmWrite

                                                                                                  func (d *DirectPinDriver) PwmWrite(level byte) (err error)

                                                                                                    PwmWrite writes the 0-254 value to the specified pin

                                                                                                    func (*DirectPinDriver) ServoWrite

                                                                                                    func (d *DirectPinDriver) ServoWrite(level byte) (err error)

                                                                                                      ServoWrite writes value to the specified pin

                                                                                                      func (*DirectPinDriver) SetName

                                                                                                      func (d *DirectPinDriver) SetName(n string)

                                                                                                        SetName sets the DirectPinDrivers name

                                                                                                        func (*DirectPinDriver) Start

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

                                                                                                          Start implements the Driver interface

                                                                                                          type EasyDriver

                                                                                                          type EasyDriver struct {
                                                                                                          	gobot.Commander
                                                                                                          	// contains filtered or unexported fields
                                                                                                          }

                                                                                                            EasyDriver object

                                                                                                            func NewEasyDriver

                                                                                                            func NewEasyDriver(a DigitalWriter, angle float32, stepPin string, dirPin string, enPin string, sleepPin string) *EasyDriver

                                                                                                              NewEasyDriver returns a new EasyDriver from SparkFun (https://www.sparkfun.com/products/12779) TODO: Support selecting phase input instead of hard-wiring MS1 and MS2 to board truth table This should also work for the BigEasyDriver (untested) A - DigitalWriter stepPin - Pin corresponding to step input on EasyDriver dirPin - Pin corresponding to dir input on EasyDriver. Optional enPin - Pin corresponding to enabled input on EasyDriver. Optional sleepPin - Pin corresponding to sleep input on EasyDriver. Optional angle - Step angle of motor

                                                                                                              func (*EasyDriver) Connection

                                                                                                              func (d *EasyDriver) Connection() gobot.Connection

                                                                                                                Connection returns EasyDriver's connection

                                                                                                                func (*EasyDriver) Disable

                                                                                                                func (d *EasyDriver) Disable() (err error)

                                                                                                                  Disable disables all motor output

                                                                                                                  func (*EasyDriver) Enable

                                                                                                                  func (d *EasyDriver) Enable() (err error)

                                                                                                                    Enable enables all motor output

                                                                                                                    func (*EasyDriver) GetCurrentStep

                                                                                                                    func (d *EasyDriver) GetCurrentStep() int

                                                                                                                      GetCurrentStep returns current step number

                                                                                                                      func (*EasyDriver) GetMaxSpeed

                                                                                                                      func (d *EasyDriver) GetMaxSpeed() uint

                                                                                                                        GetMaxSpeed returns the max speed of the stepper

                                                                                                                        func (*EasyDriver) Halt

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

                                                                                                                          Halt implements the Driver interface; stops running the stepper

                                                                                                                          func (*EasyDriver) IsEnabled

                                                                                                                          func (d *EasyDriver) IsEnabled() bool

                                                                                                                            IsEnabled returns a bool stating whether motor is enabled

                                                                                                                            func (*EasyDriver) IsMoving

                                                                                                                            func (d *EasyDriver) IsMoving() bool

                                                                                                                              IsMoving returns a bool stating whether motor is currently in motion

                                                                                                                              func (*EasyDriver) IsSleeping

                                                                                                                              func (d *EasyDriver) IsSleeping() bool

                                                                                                                                IsSleeping returns a bool stating whether motor is enabled

                                                                                                                                func (*EasyDriver) Move

                                                                                                                                func (d *EasyDriver) Move(degs int) (err error)

                                                                                                                                  Move the motor given number of degrees at current speed.

                                                                                                                                  func (*EasyDriver) Name

                                                                                                                                  func (d *EasyDriver) Name() string

                                                                                                                                    Name of EasyDriver

                                                                                                                                    func (*EasyDriver) Run

                                                                                                                                    func (d *EasyDriver) Run() (err error)

                                                                                                                                      Run the stepper continuously

                                                                                                                                      func (*EasyDriver) SetDirection

                                                                                                                                      func (d *EasyDriver) SetDirection(dir string) (err error)

                                                                                                                                        SetDirection sets the direction to be moving. Valid directions are "cw" or "ccw"

                                                                                                                                        func (*EasyDriver) SetName

                                                                                                                                        func (d *EasyDriver) SetName(n string)

                                                                                                                                          SetName sets name for EasyDriver

                                                                                                                                          func (*EasyDriver) SetSpeed

                                                                                                                                          func (d *EasyDriver) SetSpeed(rpm uint) (err error)

                                                                                                                                            SetSpeed sets the speed of the motor in RPMs. 1 is the lowest and GetMaxSpeed is the highest

                                                                                                                                            func (*EasyDriver) Sleep

                                                                                                                                            func (d *EasyDriver) Sleep() (err error)

                                                                                                                                              Sleep puts the driver to sleep and disables all motor output. Low power mode.

                                                                                                                                              func (*EasyDriver) Start

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

                                                                                                                                                Start implements the Driver interface

                                                                                                                                                func (*EasyDriver) Step

                                                                                                                                                func (d *EasyDriver) Step() (err error)

                                                                                                                                                  Step the stepper 1 step

                                                                                                                                                  func (*EasyDriver) Stop

                                                                                                                                                  func (d *EasyDriver) Stop() (err error)

                                                                                                                                                    Stop running the stepper

                                                                                                                                                    func (*EasyDriver) Wake

                                                                                                                                                    func (d *EasyDriver) Wake() (err error)

                                                                                                                                                      Wake wakes up the driver

                                                                                                                                                      type GroveButtonDriver

                                                                                                                                                      type GroveButtonDriver struct {
                                                                                                                                                      	*ButtonDriver
                                                                                                                                                      }

                                                                                                                                                        GroveButtonDriver represents a button sensor with a Grove connector

                                                                                                                                                        func NewGroveButtonDriver

                                                                                                                                                        func NewGroveButtonDriver(a DigitalReader, pin string, v ...time.Duration) *GroveButtonDriver

                                                                                                                                                          NewGroveButtonDriver returns a new GroveButtonDriver with a polling interval of 10 Milliseconds given a DigitalReader and pin.

                                                                                                                                                          Optionally accepts:

                                                                                                                                                          time.Duration: Interval at which the ButtonDriver is polled for new information
                                                                                                                                                          

                                                                                                                                                          type GroveBuzzerDriver

                                                                                                                                                          type GroveBuzzerDriver struct {
                                                                                                                                                          	*BuzzerDriver
                                                                                                                                                          }

                                                                                                                                                            GroveBuzzerDriver represents a buzzer with a Grove connector

                                                                                                                                                            func NewGroveBuzzerDriver

                                                                                                                                                            func NewGroveBuzzerDriver(a DigitalWriter, pin string) *GroveBuzzerDriver

                                                                                                                                                              NewGroveBuzzerDriver return a new GroveBuzzerDriver given a DigitalWriter and pin.

                                                                                                                                                              type GroveLedDriver

                                                                                                                                                              type GroveLedDriver struct {
                                                                                                                                                              	*LedDriver
                                                                                                                                                              }

                                                                                                                                                                GroveLedDriver represents an LED with a Grove connector

                                                                                                                                                                func NewGroveLedDriver

                                                                                                                                                                func NewGroveLedDriver(a DigitalWriter, pin string) *GroveLedDriver

                                                                                                                                                                  NewGroveLedDriver return a new GroveLedDriver given a DigitalWriter and pin.

                                                                                                                                                                  Adds the following API Commands:

                                                                                                                                                                  "Brightness" - See LedDriver.Brightness
                                                                                                                                                                  "Toggle" - See LedDriver.Toggle
                                                                                                                                                                  "On" - See LedDriver.On
                                                                                                                                                                  "Off" - See LedDriver.Off
                                                                                                                                                                  

                                                                                                                                                                  type GroveMagneticSwitchDriver

                                                                                                                                                                  type GroveMagneticSwitchDriver struct {
                                                                                                                                                                  	*ButtonDriver
                                                                                                                                                                  }

                                                                                                                                                                    GroveMagneticSwitchDriver represent a magnetic switch sensor with a Grove connector

                                                                                                                                                                    func NewGroveMagneticSwitchDriver

                                                                                                                                                                    func NewGroveMagneticSwitchDriver(a DigitalReader, pin string, v ...time.Duration) *GroveMagneticSwitchDriver

                                                                                                                                                                      NewGroveMagneticSwitchDriver returns a new GroveMagneticSwitchDriver with a polling interval of 10 Milliseconds given a DigitalReader, name and pin.

                                                                                                                                                                      Optionally accepts:

                                                                                                                                                                      time.Duration: Interval at which the ButtonDriver is polled for new information
                                                                                                                                                                      

                                                                                                                                                                      type GroveRelayDriver

                                                                                                                                                                      type GroveRelayDriver struct {
                                                                                                                                                                      	*RelayDriver
                                                                                                                                                                      }

                                                                                                                                                                        GroveRelayDriver represents a Relay with a Grove connector

                                                                                                                                                                        func NewGroveRelayDriver

                                                                                                                                                                        func NewGroveRelayDriver(a DigitalWriter, pin string) *GroveRelayDriver

                                                                                                                                                                          NewGroveRelayDriver return a new GroveRelayDriver given a DigitalWriter and pin.

                                                                                                                                                                          Adds the following API Commands:

                                                                                                                                                                          "Toggle" - See RelayDriver.Toggle
                                                                                                                                                                          "On" - See RelayDriver.On
                                                                                                                                                                          "Off" - See RelayDriver.Off
                                                                                                                                                                          

                                                                                                                                                                          type GroveTouchDriver

                                                                                                                                                                          type GroveTouchDriver struct {
                                                                                                                                                                          	*ButtonDriver
                                                                                                                                                                          }

                                                                                                                                                                            GroveTouchDriver represents a touch button sensor with a Grove connector

                                                                                                                                                                            func NewGroveTouchDriver

                                                                                                                                                                            func NewGroveTouchDriver(a DigitalReader, pin string, v ...time.Duration) *GroveTouchDriver

                                                                                                                                                                              NewGroveTouchDriver returns a new GroveTouchDriver with a polling interval of 10 Milliseconds given a DigitalReader and pin.

                                                                                                                                                                              Optionally accepts:

                                                                                                                                                                              time.Duration: Interval at which the ButtonDriver is polled for new information
                                                                                                                                                                              

                                                                                                                                                                              type HD44780BusMode

                                                                                                                                                                              type HD44780BusMode int

                                                                                                                                                                                data bus mode

                                                                                                                                                                                const (
                                                                                                                                                                                	HD44780_4BITMODE HD44780BusMode = iota + 1
                                                                                                                                                                                	HD44780_8BITMODE
                                                                                                                                                                                )

                                                                                                                                                                                type HD44780DataPin

                                                                                                                                                                                type HD44780DataPin struct {
                                                                                                                                                                                	D0 string // not used if 4bit mode
                                                                                                                                                                                	D1 string // not used if 4bit mode
                                                                                                                                                                                	D2 string // not used if 4bit mode
                                                                                                                                                                                	D3 string // not used if 4bit mode
                                                                                                                                                                                	D4 string
                                                                                                                                                                                	D5 string
                                                                                                                                                                                	D6 string
                                                                                                                                                                                	D7 string
                                                                                                                                                                                }

                                                                                                                                                                                  databit pins

                                                                                                                                                                                  type HD44780Driver

                                                                                                                                                                                  type HD44780Driver struct {
                                                                                                                                                                                  	gobot.Commander
                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                  }

                                                                                                                                                                                    HD44780Driver is the gobot driver for the HD44780 LCD controller Datasheet: https://www.sparkfun.com/datasheets/LCD/HD44780.pdf

                                                                                                                                                                                    func NewHD44780Driver

                                                                                                                                                                                    func NewHD44780Driver(a gobot.Connection, cols int, rows int, busMode HD44780BusMode, pinRS string, pinEN string, pinDataBits HD44780DataPin) *HD44780Driver

                                                                                                                                                                                      NewHD44780Driver return a new HD44780Driver a: gobot.Conenction cols: lcd columns rows: lcd rows busMode: 4Bit or 8Bit pinRS: register select pin pinEN: clock enable pin pinDataBits: databit pins

                                                                                                                                                                                      func (h *HD44780Driver) Blink(on bool) (err error)

                                                                                                                                                                                        Blink turn the blink on and off

                                                                                                                                                                                        func (*HD44780Driver) Clear

                                                                                                                                                                                        func (h *HD44780Driver) Clear() (err error)

                                                                                                                                                                                          Clear clear the display

                                                                                                                                                                                          func (*HD44780Driver) Connection

                                                                                                                                                                                          func (h *HD44780Driver) Connection() gobot.Connection

                                                                                                                                                                                            Connecton returns the HD44780Driver Connection

                                                                                                                                                                                            func (*HD44780Driver) CreateChar

                                                                                                                                                                                            func (h *HD44780Driver) CreateChar(pos int, charMap [8]byte) (err error)

                                                                                                                                                                                              CreateChar create custom character

                                                                                                                                                                                              func (*HD44780Driver) Cursor

                                                                                                                                                                                              func (h *HD44780Driver) Cursor(on bool) (err error)

                                                                                                                                                                                                Cursor turn the cursor on and off

                                                                                                                                                                                                func (*HD44780Driver) Display

                                                                                                                                                                                                func (h *HD44780Driver) Display(on bool) (err error)

                                                                                                                                                                                                  Display turn the display on and off

                                                                                                                                                                                                  func (*HD44780Driver) Halt

                                                                                                                                                                                                  func (h *HD44780Driver) Halt() error

                                                                                                                                                                                                    Halt implements the Driver interface

                                                                                                                                                                                                    func (*HD44780Driver) Home

                                                                                                                                                                                                    func (h *HD44780Driver) Home() (err error)

                                                                                                                                                                                                      Home return cursor to home

                                                                                                                                                                                                      func (*HD44780Driver) LeftToRight

                                                                                                                                                                                                      func (h *HD44780Driver) LeftToRight() (err error)

                                                                                                                                                                                                        LeftToRight display text from left to right

                                                                                                                                                                                                        func (*HD44780Driver) Name

                                                                                                                                                                                                        func (h *HD44780Driver) Name() string

                                                                                                                                                                                                          Name returns the HD44780Driver name

                                                                                                                                                                                                          func (*HD44780Driver) RightToLeft

                                                                                                                                                                                                          func (h *HD44780Driver) RightToLeft() (err error)

                                                                                                                                                                                                            RightToLeft display text from right to left

                                                                                                                                                                                                            func (*HD44780Driver) ScrollLeft

                                                                                                                                                                                                            func (h *HD44780Driver) ScrollLeft() (err error)

                                                                                                                                                                                                              ScrollLeft scroll text left

                                                                                                                                                                                                              func (*HD44780Driver) ScrollRight

                                                                                                                                                                                                              func (h *HD44780Driver) ScrollRight() (err error)

                                                                                                                                                                                                                ScrollRight scroll text right

                                                                                                                                                                                                                func (*HD44780Driver) SendCommand

                                                                                                                                                                                                                func (h *HD44780Driver) SendCommand(data int) (err error)

                                                                                                                                                                                                                  SendCommand send control command

                                                                                                                                                                                                                  func (*HD44780Driver) SetCursor

                                                                                                                                                                                                                  func (h *HD44780Driver) SetCursor(col int, row int) (err error)

                                                                                                                                                                                                                    SetCursor move the cursor to the specified position

                                                                                                                                                                                                                    func (*HD44780Driver) SetName

                                                                                                                                                                                                                    func (h *HD44780Driver) SetName(n string)

                                                                                                                                                                                                                      SetName sets the HD44780Driver name

                                                                                                                                                                                                                      func (*HD44780Driver) Start

                                                                                                                                                                                                                      func (h *HD44780Driver) Start() (err error)

                                                                                                                                                                                                                        Start initializes the HD44780 LCD controller refer to page 45/46 of hitachi HD44780 datasheet

                                                                                                                                                                                                                        func (*HD44780Driver) Write

                                                                                                                                                                                                                        func (h *HD44780Driver) Write(message string) (err error)

                                                                                                                                                                                                                          Write output text to the display

                                                                                                                                                                                                                          func (*HD44780Driver) WriteChar

                                                                                                                                                                                                                          func (h *HD44780Driver) WriteChar(data int) (err error)

                                                                                                                                                                                                                            WriteChar output a character to the display

                                                                                                                                                                                                                            type LedDriver

                                                                                                                                                                                                                            type LedDriver struct {
                                                                                                                                                                                                                            	gobot.Commander
                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              LedDriver represents a digital Led

                                                                                                                                                                                                                              func NewLedDriver

                                                                                                                                                                                                                              func NewLedDriver(a DigitalWriter, pin string) *LedDriver

                                                                                                                                                                                                                                NewLedDriver return a new LedDriver given a DigitalWriter and pin.

                                                                                                                                                                                                                                Adds the following API Commands:

                                                                                                                                                                                                                                "Brightness" - See LedDriver.Brightness
                                                                                                                                                                                                                                "Toggle" - See LedDriver.Toggle
                                                                                                                                                                                                                                "On" - See LedDriver.On
                                                                                                                                                                                                                                "Off" - See LedDriver.Off
                                                                                                                                                                                                                                

                                                                                                                                                                                                                                func (*LedDriver) Brightness

                                                                                                                                                                                                                                func (l *LedDriver) Brightness(level byte) (err error)

                                                                                                                                                                                                                                  Brightness sets the led to the specified level of brightness

                                                                                                                                                                                                                                  func (*LedDriver) Connection

                                                                                                                                                                                                                                  func (l *LedDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                    Connection returns the LedDrivers Connection

                                                                                                                                                                                                                                    func (*LedDriver) Halt

                                                                                                                                                                                                                                    func (l *LedDriver) Halt() (err error)

                                                                                                                                                                                                                                      Halt implements the Driver interface

                                                                                                                                                                                                                                      func (*LedDriver) Name

                                                                                                                                                                                                                                      func (l *LedDriver) Name() string

                                                                                                                                                                                                                                        Name returns the LedDrivers name

                                                                                                                                                                                                                                        func (*LedDriver) Off

                                                                                                                                                                                                                                        func (l *LedDriver) Off() (err error)

                                                                                                                                                                                                                                          Off sets the led to a low state.

                                                                                                                                                                                                                                          func (*LedDriver) On

                                                                                                                                                                                                                                          func (l *LedDriver) On() (err error)

                                                                                                                                                                                                                                            On sets the led to a high state.

                                                                                                                                                                                                                                            func (*LedDriver) Pin

                                                                                                                                                                                                                                            func (l *LedDriver) Pin() string

                                                                                                                                                                                                                                              Pin returns the LedDrivers name

                                                                                                                                                                                                                                              func (*LedDriver) SetName

                                                                                                                                                                                                                                              func (l *LedDriver) SetName(n string)

                                                                                                                                                                                                                                                SetName sets the LedDrivers name

                                                                                                                                                                                                                                                func (*LedDriver) Start

                                                                                                                                                                                                                                                func (l *LedDriver) Start() (err error)

                                                                                                                                                                                                                                                  Start implements the Driver interface

                                                                                                                                                                                                                                                  func (*LedDriver) State

                                                                                                                                                                                                                                                  func (l *LedDriver) State() bool

                                                                                                                                                                                                                                                    State return true if the led is On and false if the led is Off

                                                                                                                                                                                                                                                    func (*LedDriver) Toggle

                                                                                                                                                                                                                                                    func (l *LedDriver) Toggle() (err error)

                                                                                                                                                                                                                                                      Toggle sets the led to the opposite of it's current state

                                                                                                                                                                                                                                                      type MAX7219Driver

                                                                                                                                                                                                                                                      type MAX7219Driver struct {
                                                                                                                                                                                                                                                      	gobot.Commander
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        MAX7219Driver is the gobot driver for the MAX7219 LED driver

                                                                                                                                                                                                                                                        Datasheet: https://datasheets.maximintegrated.com/en/ds/MAX7219-MAX7221.pdf

                                                                                                                                                                                                                                                        func NewMAX7219Driver

                                                                                                                                                                                                                                                        func NewMAX7219Driver(a gobot.Connection, clockPin string, dataPin string, csPin string, count uint) *MAX7219Driver

                                                                                                                                                                                                                                                          NewMAX7219Driver return a new MAX7219Driver given a gobot.Connection, pins and how many chips are chained

                                                                                                                                                                                                                                                          func (*MAX7219Driver) All

                                                                                                                                                                                                                                                          func (a *MAX7219Driver) All(address byte, data byte)

                                                                                                                                                                                                                                                            All sends the same data to all the modules

                                                                                                                                                                                                                                                            func (*MAX7219Driver) ClearAll

                                                                                                                                                                                                                                                            func (a *MAX7219Driver) ClearAll()

                                                                                                                                                                                                                                                              ClearAll turns off all LEDs of all modules

                                                                                                                                                                                                                                                              func (*MAX7219Driver) ClearOne

                                                                                                                                                                                                                                                              func (a *MAX7219Driver) ClearOne(which uint)

                                                                                                                                                                                                                                                                ClearAll turns off all LEDs of the given module

                                                                                                                                                                                                                                                                func (*MAX7219Driver) Connection

                                                                                                                                                                                                                                                                func (a *MAX7219Driver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                  Connection returns the MAX7219Driver Connection

                                                                                                                                                                                                                                                                  func (*MAX7219Driver) Halt

                                                                                                                                                                                                                                                                  func (a *MAX7219Driver) Halt() (err error)

                                                                                                                                                                                                                                                                    Halt implements the Driver interface

                                                                                                                                                                                                                                                                    func (*MAX7219Driver) Name

                                                                                                                                                                                                                                                                    func (a *MAX7219Driver) Name() string

                                                                                                                                                                                                                                                                      Name returns the MAX7219Drivers name

                                                                                                                                                                                                                                                                      func (*MAX7219Driver) One

                                                                                                                                                                                                                                                                      func (a *MAX7219Driver) One(which uint, address byte, data byte)

                                                                                                                                                                                                                                                                        One sends data to a specific module

                                                                                                                                                                                                                                                                        func (*MAX7219Driver) SetIntensity

                                                                                                                                                                                                                                                                        func (a *MAX7219Driver) SetIntensity(level byte)

                                                                                                                                                                                                                                                                          SetIntensity changes the intensity (from 1 to 7) of the display

                                                                                                                                                                                                                                                                          func (*MAX7219Driver) SetName

                                                                                                                                                                                                                                                                          func (a *MAX7219Driver) SetName(n string)

                                                                                                                                                                                                                                                                            SetName sets the MAX7219Drivers name

                                                                                                                                                                                                                                                                            func (*MAX7219Driver) Start

                                                                                                                                                                                                                                                                            func (a *MAX7219Driver) Start() (err error)

                                                                                                                                                                                                                                                                              Start initializes the max7219, it uses a SPI-like communication protocol

                                                                                                                                                                                                                                                                              type MakeyButtonDriver

                                                                                                                                                                                                                                                                              type MakeyButtonDriver struct {
                                                                                                                                                                                                                                                                              	Active bool
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	gobot.Eventer
                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                MakeyButtonDriver Represents a Makey Button

                                                                                                                                                                                                                                                                                func NewMakeyButtonDriver

                                                                                                                                                                                                                                                                                func NewMakeyButtonDriver(a DigitalReader, pin string, v ...time.Duration) *MakeyButtonDriver

                                                                                                                                                                                                                                                                                  NewMakeyButtonDriver returns a new MakeyButtonDriver with a polling interval of 10 Milliseconds given a DigitalReader and pin.

                                                                                                                                                                                                                                                                                  Optionally accepts:

                                                                                                                                                                                                                                                                                  time.Duration: Interval at which the ButtonDriver is polled for new information
                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                  func (*MakeyButtonDriver) Connection

                                                                                                                                                                                                                                                                                  func (b *MakeyButtonDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                    Connection returns the MakeyButtonDrivers Connection

                                                                                                                                                                                                                                                                                    func (*MakeyButtonDriver) Halt

                                                                                                                                                                                                                                                                                    func (b *MakeyButtonDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                      Halt stops polling the makey button for new information

                                                                                                                                                                                                                                                                                      func (*MakeyButtonDriver) Name

                                                                                                                                                                                                                                                                                      func (b *MakeyButtonDriver) Name() string

                                                                                                                                                                                                                                                                                        Name returns the MakeyButtonDrivers name

                                                                                                                                                                                                                                                                                        func (*MakeyButtonDriver) Pin

                                                                                                                                                                                                                                                                                        func (b *MakeyButtonDriver) Pin() string

                                                                                                                                                                                                                                                                                          Pin returns the MakeyButtonDrivers pin

                                                                                                                                                                                                                                                                                          func (*MakeyButtonDriver) SetName

                                                                                                                                                                                                                                                                                          func (b *MakeyButtonDriver) SetName(n string)

                                                                                                                                                                                                                                                                                            SetName sets the MakeyButtonDrivers name

                                                                                                                                                                                                                                                                                            func (*MakeyButtonDriver) Start

                                                                                                                                                                                                                                                                                            func (b *MakeyButtonDriver) Start() (err error)

                                                                                                                                                                                                                                                                                              Start starts the MakeyButtonDriver and polls the state of the button at the given interval.

                                                                                                                                                                                                                                                                                              Emits the Events:

                                                                                                                                                                                                                                                                                              Push int - On button push
                                                                                                                                                                                                                                                                                              Release int - On button release
                                                                                                                                                                                                                                                                                              Error error - On button error
                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                              type MotorDriver

                                                                                                                                                                                                                                                                                              type MotorDriver struct {
                                                                                                                                                                                                                                                                                              	SpeedPin         string
                                                                                                                                                                                                                                                                                              	SwitchPin        string
                                                                                                                                                                                                                                                                                              	DirectionPin     string
                                                                                                                                                                                                                                                                                              	ForwardPin       string
                                                                                                                                                                                                                                                                                              	BackwardPin      string
                                                                                                                                                                                                                                                                                              	CurrentState     byte
                                                                                                                                                                                                                                                                                              	CurrentSpeed     byte
                                                                                                                                                                                                                                                                                              	CurrentMode      string
                                                                                                                                                                                                                                                                                              	CurrentDirection string
                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                MotorDriver Represents a Motor

                                                                                                                                                                                                                                                                                                func NewMotorDriver

                                                                                                                                                                                                                                                                                                func NewMotorDriver(a DigitalWriter, speedPin string) *MotorDriver

                                                                                                                                                                                                                                                                                                  NewMotorDriver return a new MotorDriver given a DigitalWriter and pin

                                                                                                                                                                                                                                                                                                  func (*MotorDriver) Backward

                                                                                                                                                                                                                                                                                                  func (m *MotorDriver) Backward(speed byte) (err error)

                                                                                                                                                                                                                                                                                                    Backward sets the backward pin to the specified speed

                                                                                                                                                                                                                                                                                                    func (*MotorDriver) Connection

                                                                                                                                                                                                                                                                                                    func (m *MotorDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                      Connection returns the MotorDrivers Connection

                                                                                                                                                                                                                                                                                                      func (*MotorDriver) Direction

                                                                                                                                                                                                                                                                                                      func (m *MotorDriver) Direction(direction string) (err error)

                                                                                                                                                                                                                                                                                                        Direction sets the direction pin to the specified speed

                                                                                                                                                                                                                                                                                                        func (*MotorDriver) Forward

                                                                                                                                                                                                                                                                                                        func (m *MotorDriver) Forward(speed byte) (err error)

                                                                                                                                                                                                                                                                                                          Forward sets the forward pin to the specified speed

                                                                                                                                                                                                                                                                                                          func (*MotorDriver) Halt

                                                                                                                                                                                                                                                                                                          func (m *MotorDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                                            Halt implements the Driver interface

                                                                                                                                                                                                                                                                                                            func (*MotorDriver) IsOff

                                                                                                                                                                                                                                                                                                            func (m *MotorDriver) IsOff() bool

                                                                                                                                                                                                                                                                                                              IsOff returns true if the motor is off

                                                                                                                                                                                                                                                                                                              func (*MotorDriver) IsOn

                                                                                                                                                                                                                                                                                                              func (m *MotorDriver) IsOn() bool

                                                                                                                                                                                                                                                                                                                IsOn returns true if the motor is on

                                                                                                                                                                                                                                                                                                                func (*MotorDriver) Max

                                                                                                                                                                                                                                                                                                                func (m *MotorDriver) Max() (err error)

                                                                                                                                                                                                                                                                                                                  Max sets the motor to the maximum speed

                                                                                                                                                                                                                                                                                                                  func (*MotorDriver) Min

                                                                                                                                                                                                                                                                                                                  func (m *MotorDriver) Min() (err error)

                                                                                                                                                                                                                                                                                                                    Min sets the motor to the minimum speed

                                                                                                                                                                                                                                                                                                                    func (*MotorDriver) Name

                                                                                                                                                                                                                                                                                                                    func (m *MotorDriver) Name() string

                                                                                                                                                                                                                                                                                                                      Name returns the MotorDrivers name

                                                                                                                                                                                                                                                                                                                      func (*MotorDriver) Off

                                                                                                                                                                                                                                                                                                                      func (m *MotorDriver) Off() (err error)

                                                                                                                                                                                                                                                                                                                        Off turns the motor off or sets the motor to a 0 speed

                                                                                                                                                                                                                                                                                                                        func (*MotorDriver) On

                                                                                                                                                                                                                                                                                                                        func (m *MotorDriver) On() (err error)

                                                                                                                                                                                                                                                                                                                          On turns the motor on or sets the motor to a maximum speed

                                                                                                                                                                                                                                                                                                                          func (*MotorDriver) SetName

                                                                                                                                                                                                                                                                                                                          func (m *MotorDriver) SetName(n string)

                                                                                                                                                                                                                                                                                                                            SetName sets the MotorDrivers name

                                                                                                                                                                                                                                                                                                                            func (*MotorDriver) Speed

                                                                                                                                                                                                                                                                                                                            func (m *MotorDriver) Speed(value byte) (err error)

                                                                                                                                                                                                                                                                                                                              Speed sets the speed of the motor

                                                                                                                                                                                                                                                                                                                              func (*MotorDriver) Start

                                                                                                                                                                                                                                                                                                                              func (m *MotorDriver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                Start implements the Driver interface

                                                                                                                                                                                                                                                                                                                                func (*MotorDriver) Toggle

                                                                                                                                                                                                                                                                                                                                func (m *MotorDriver) Toggle() (err error)

                                                                                                                                                                                                                                                                                                                                  Toggle sets the motor to the opposite of it's current state

                                                                                                                                                                                                                                                                                                                                  type PIRMotionDriver

                                                                                                                                                                                                                                                                                                                                  type PIRMotionDriver struct {
                                                                                                                                                                                                                                                                                                                                  	Active bool
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	gobot.Eventer
                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    PIRMotionDriver represents a digital Proximity Infra Red (PIR) motion detecter

                                                                                                                                                                                                                                                                                                                                    func NewPIRMotionDriver

                                                                                                                                                                                                                                                                                                                                    func NewPIRMotionDriver(a DigitalReader, pin string, v ...time.Duration) *PIRMotionDriver

                                                                                                                                                                                                                                                                                                                                      NewPIRMotionDriver returns a new PIRMotionDriver with a polling interval of 10 Milliseconds given a DigitalReader and pin.

                                                                                                                                                                                                                                                                                                                                      Optionally accepts:

                                                                                                                                                                                                                                                                                                                                      time.Duration: Interval at which the PIRMotionDriver is polled for new information
                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                      func (*PIRMotionDriver) Connection

                                                                                                                                                                                                                                                                                                                                      func (p *PIRMotionDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                                                        Connection returns the PIRMotionDriver Connection

                                                                                                                                                                                                                                                                                                                                        func (*PIRMotionDriver) Halt

                                                                                                                                                                                                                                                                                                                                        func (p *PIRMotionDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                                                                          Halt stops polling the button for new information

                                                                                                                                                                                                                                                                                                                                          func (*PIRMotionDriver) Name

                                                                                                                                                                                                                                                                                                                                          func (p *PIRMotionDriver) Name() string

                                                                                                                                                                                                                                                                                                                                            Name returns the PIRMotionDriver name

                                                                                                                                                                                                                                                                                                                                            func (*PIRMotionDriver) Pin

                                                                                                                                                                                                                                                                                                                                            func (p *PIRMotionDriver) Pin() string

                                                                                                                                                                                                                                                                                                                                              Pin returns the PIRMotionDriver pin

                                                                                                                                                                                                                                                                                                                                              func (*PIRMotionDriver) SetName

                                                                                                                                                                                                                                                                                                                                              func (p *PIRMotionDriver) SetName(n string)

                                                                                                                                                                                                                                                                                                                                                SetName sets the PIRMotionDriver name

                                                                                                                                                                                                                                                                                                                                                func (*PIRMotionDriver) Start

                                                                                                                                                                                                                                                                                                                                                func (p *PIRMotionDriver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                                  Start starts the PIRMotionDriver and polls the state of the sensor at the given interval.

                                                                                                                                                                                                                                                                                                                                                  Emits the Events:

                                                                                                                                                                                                                                                                                                                                                  MotionDetected - On motion detected
                                                                                                                                                                                                                                                                                                                                                  MotionStopped int - On motion stopped
                                                                                                                                                                                                                                                                                                                                                  Error error - On button error
                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                  The PIRMotionDriver will send the MotionDetected event over and over, just as long as motion is still being detected. It will only send the MotionStopped event once, however, until motion starts being detected again

                                                                                                                                                                                                                                                                                                                                                  type PwmWriter

                                                                                                                                                                                                                                                                                                                                                  type PwmWriter interface {
                                                                                                                                                                                                                                                                                                                                                  	PwmWrite(string, byte) (err error)
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    PwmWriter interface represents an Adaptor which has Pwm capabilities

                                                                                                                                                                                                                                                                                                                                                    type RelayDriver

                                                                                                                                                                                                                                                                                                                                                    type RelayDriver struct {
                                                                                                                                                                                                                                                                                                                                                    	Inverted bool
                                                                                                                                                                                                                                                                                                                                                    	gobot.Commander
                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      RelayDriver represents a digital relay

                                                                                                                                                                                                                                                                                                                                                      func NewRelayDriver

                                                                                                                                                                                                                                                                                                                                                      func NewRelayDriver(a DigitalWriter, pin string) *RelayDriver

                                                                                                                                                                                                                                                                                                                                                        NewRelayDriver return a new RelayDriver given a DigitalWriter and pin.

                                                                                                                                                                                                                                                                                                                                                        Adds the following API Commands:

                                                                                                                                                                                                                                                                                                                                                        "Toggle" - See RelayDriver.Toggle
                                                                                                                                                                                                                                                                                                                                                        "On" - See RelayDriver.On
                                                                                                                                                                                                                                                                                                                                                        "Off" - See RelayDriver.Off
                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                        func (*RelayDriver) Connection

                                                                                                                                                                                                                                                                                                                                                        func (l *RelayDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                                                                          Connection returns the RelayDrivers Connection

                                                                                                                                                                                                                                                                                                                                                          func (*RelayDriver) Halt

                                                                                                                                                                                                                                                                                                                                                          func (l *RelayDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                                                                                            Halt implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                            func (*RelayDriver) Name

                                                                                                                                                                                                                                                                                                                                                            func (l *RelayDriver) Name() string

                                                                                                                                                                                                                                                                                                                                                              Name returns the RelayDrivers name

                                                                                                                                                                                                                                                                                                                                                              func (*RelayDriver) Off

                                                                                                                                                                                                                                                                                                                                                              func (l *RelayDriver) Off() (err error)

                                                                                                                                                                                                                                                                                                                                                                Off sets the relay to a low state.

                                                                                                                                                                                                                                                                                                                                                                func (*RelayDriver) On

                                                                                                                                                                                                                                                                                                                                                                func (l *RelayDriver) On() (err error)

                                                                                                                                                                                                                                                                                                                                                                  On sets the relay to a high state.

                                                                                                                                                                                                                                                                                                                                                                  func (*RelayDriver) Pin

                                                                                                                                                                                                                                                                                                                                                                  func (l *RelayDriver) Pin() string

                                                                                                                                                                                                                                                                                                                                                                    Pin returns the RelayDrivers name

                                                                                                                                                                                                                                                                                                                                                                    func (*RelayDriver) SetName

                                                                                                                                                                                                                                                                                                                                                                    func (l *RelayDriver) SetName(n string)

                                                                                                                                                                                                                                                                                                                                                                      SetName sets the RelayDrivers name

                                                                                                                                                                                                                                                                                                                                                                      func (*RelayDriver) Start

                                                                                                                                                                                                                                                                                                                                                                      func (l *RelayDriver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                                                        Start implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                                        func (*RelayDriver) State

                                                                                                                                                                                                                                                                                                                                                                        func (l *RelayDriver) State() bool

                                                                                                                                                                                                                                                                                                                                                                          State return true if the relay is On and false if the relay is Off

                                                                                                                                                                                                                                                                                                                                                                          func (*RelayDriver) Toggle

                                                                                                                                                                                                                                                                                                                                                                          func (l *RelayDriver) Toggle() (err error)

                                                                                                                                                                                                                                                                                                                                                                            Toggle sets the relay to the opposite of it's current state

                                                                                                                                                                                                                                                                                                                                                                            type RgbLedDriver

                                                                                                                                                                                                                                                                                                                                                                            type RgbLedDriver struct {
                                                                                                                                                                                                                                                                                                                                                                            	gobot.Commander
                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              RgbLedDriver represents a digital RGB Led

                                                                                                                                                                                                                                                                                                                                                                              func NewRgbLedDriver

                                                                                                                                                                                                                                                                                                                                                                              func NewRgbLedDriver(a DigitalWriter, redPin string, greenPin string, bluePin string) *RgbLedDriver

                                                                                                                                                                                                                                                                                                                                                                                NewRgbLedDriver return a new RgbLedDriver given a DigitalWriter and 3 pins: redPin, greenPin, and bluePin

                                                                                                                                                                                                                                                                                                                                                                                Adds the following API Commands:

                                                                                                                                                                                                                                                                                                                                                                                "SetRGB" - See RgbLedDriver.SetRGB
                                                                                                                                                                                                                                                                                                                                                                                "Toggle" - See RgbLedDriver.Toggle
                                                                                                                                                                                                                                                                                                                                                                                "On" - See RgbLedDriver.On
                                                                                                                                                                                                                                                                                                                                                                                "Off" - See RgbLedDriver.Off
                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                func (*RgbLedDriver) BluePin

                                                                                                                                                                                                                                                                                                                                                                                func (l *RgbLedDriver) BluePin() string

                                                                                                                                                                                                                                                                                                                                                                                  BluePin returns the RgbLedDrivers bluePin

                                                                                                                                                                                                                                                                                                                                                                                  func (*RgbLedDriver) Connection

                                                                                                                                                                                                                                                                                                                                                                                  func (l *RgbLedDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                                                                                                    Connection returns the RgbLedDriver Connection

                                                                                                                                                                                                                                                                                                                                                                                    func (*RgbLedDriver) GreenPin

                                                                                                                                                                                                                                                                                                                                                                                    func (l *RgbLedDriver) GreenPin() string

                                                                                                                                                                                                                                                                                                                                                                                      GreenPin returns the RgbLedDrivers redPin

                                                                                                                                                                                                                                                                                                                                                                                      func (*RgbLedDriver) Halt

                                                                                                                                                                                                                                                                                                                                                                                      func (l *RgbLedDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                                                                                                                        Halt implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                                                        func (*RgbLedDriver) Name

                                                                                                                                                                                                                                                                                                                                                                                        func (l *RgbLedDriver) Name() string

                                                                                                                                                                                                                                                                                                                                                                                          Name returns the RGBLEDDrivers name

                                                                                                                                                                                                                                                                                                                                                                                          func (*RgbLedDriver) Off

                                                                                                                                                                                                                                                                                                                                                                                          func (l *RgbLedDriver) Off() (err error)

                                                                                                                                                                                                                                                                                                                                                                                            Off sets the led to black.

                                                                                                                                                                                                                                                                                                                                                                                            func (*RgbLedDriver) On

                                                                                                                                                                                                                                                                                                                                                                                            func (l *RgbLedDriver) On() (err error)

                                                                                                                                                                                                                                                                                                                                                                                              On sets the led's pins to their various states

                                                                                                                                                                                                                                                                                                                                                                                              func (*RgbLedDriver) Pin

                                                                                                                                                                                                                                                                                                                                                                                              func (l *RgbLedDriver) Pin() string

                                                                                                                                                                                                                                                                                                                                                                                                Pin returns the RgbLedDrivers pins

                                                                                                                                                                                                                                                                                                                                                                                                func (*RgbLedDriver) RedPin

                                                                                                                                                                                                                                                                                                                                                                                                func (l *RgbLedDriver) RedPin() string

                                                                                                                                                                                                                                                                                                                                                                                                  RedPin returns the RgbLedDrivers redPin

                                                                                                                                                                                                                                                                                                                                                                                                  func (*RgbLedDriver) SetLevel

                                                                                                                                                                                                                                                                                                                                                                                                  func (l *RgbLedDriver) SetLevel(pin string, level byte) (err error)

                                                                                                                                                                                                                                                                                                                                                                                                    SetLevel sets the led to the specified color level

                                                                                                                                                                                                                                                                                                                                                                                                    func (*RgbLedDriver) SetName

                                                                                                                                                                                                                                                                                                                                                                                                    func (l *RgbLedDriver) SetName(n string)

                                                                                                                                                                                                                                                                                                                                                                                                      SetName sets the RGBLEDDrivers name

                                                                                                                                                                                                                                                                                                                                                                                                      func (*RgbLedDriver) SetRGB

                                                                                                                                                                                                                                                                                                                                                                                                      func (l *RgbLedDriver) SetRGB(r, g, b byte) error

                                                                                                                                                                                                                                                                                                                                                                                                        SetRGB sets the Red Green Blue value of the LED.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*RgbLedDriver) Start

                                                                                                                                                                                                                                                                                                                                                                                                        func (l *RgbLedDriver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                          Start implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                                                                          func (*RgbLedDriver) State

                                                                                                                                                                                                                                                                                                                                                                                                          func (l *RgbLedDriver) State() bool

                                                                                                                                                                                                                                                                                                                                                                                                            State return true if the led is On and false if the led is Off

                                                                                                                                                                                                                                                                                                                                                                                                            func (*RgbLedDriver) Toggle

                                                                                                                                                                                                                                                                                                                                                                                                            func (l *RgbLedDriver) Toggle() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                              Toggle sets the led to the opposite of it's current state

                                                                                                                                                                                                                                                                                                                                                                                                              type ServoDriver

                                                                                                                                                                                                                                                                                                                                                                                                              type ServoDriver struct {
                                                                                                                                                                                                                                                                                                                                                                                                              	gobot.Commander
                                                                                                                                                                                                                                                                                                                                                                                                              	CurrentAngle byte
                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                ServoDriver Represents a Servo

                                                                                                                                                                                                                                                                                                                                                                                                                func NewServoDriver

                                                                                                                                                                                                                                                                                                                                                                                                                func NewServoDriver(a ServoWriter, pin string) *ServoDriver

                                                                                                                                                                                                                                                                                                                                                                                                                  NewServoDriver returns a new ServoDriver given a ServoWriter and pin.

                                                                                                                                                                                                                                                                                                                                                                                                                  Adds the following API Commands:

                                                                                                                                                                                                                                                                                                                                                                                                                  "Move" - See ServoDriver.Move
                                                                                                                                                                                                                                                                                                                                                                                                                  	"Min" - See ServoDriver.Min
                                                                                                                                                                                                                                                                                                                                                                                                                  	"Center" - See ServoDriver.Center
                                                                                                                                                                                                                                                                                                                                                                                                                  	"Max" - See ServoDriver.Max
                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ServoDriver) Center

                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *ServoDriver) Center() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                    Center sets the servo to it's center position

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ServoDriver) Connection

                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *ServoDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                                                                                                                                      Connection returns the ServoDrivers connection

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ServoDriver) Halt

                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *ServoDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                        Halt implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ServoDriver) Max

                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *ServoDriver) Max() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                          Max sets the servo to its maximum position

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*ServoDriver) Min

                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *ServoDriver) Min() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                            Min sets the servo to it's minimum position

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*ServoDriver) Move

                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *ServoDriver) Move(angle uint8) (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                              Move sets the servo to the specified angle. Acceptable angles are 0-180

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*ServoDriver) Name

                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *ServoDriver) Name() string

                                                                                                                                                                                                                                                                                                                                                                                                                                Name returns the ServoDrivers name

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*ServoDriver) Pin

                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *ServoDriver) Pin() string

                                                                                                                                                                                                                                                                                                                                                                                                                                  Pin returns the ServoDrivers pin

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ServoDriver) SetName

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *ServoDriver) SetName(n string)

                                                                                                                                                                                                                                                                                                                                                                                                                                    SetName sets the ServoDrivers name

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ServoDriver) Start

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *ServoDriver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                      Start implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                                                                                                      type ServoWriter

                                                                                                                                                                                                                                                                                                                                                                                                                                      type ServoWriter interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                      	ServoWrite(string, byte) (err error)
                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                        ServoWriter interface represents an Adaptor which has Servo capabilities

                                                                                                                                                                                                                                                                                                                                                                                                                                        type StepperDriver

                                                                                                                                                                                                                                                                                                                                                                                                                                        type StepperDriver struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                        	gobot.Commander
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                          StepperDriver object

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewStepperDriver

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewStepperDriver(a DigitalWriter, pins [4]string, phase phase, stepsPerRev uint) *StepperDriver

                                                                                                                                                                                                                                                                                                                                                                                                                                            NewStepperDriver returns a new StepperDriver given a DigitalWriter Pins - To which the stepper is connected Phase - Defined by StepperModes {SinglePhaseStepping, DualPhaseStepping, HalfStepping} Steps - No of steps per revolution of Stepper motor

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*StepperDriver) Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *StepperDriver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                              Connection returns StepperDriver's connection

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*StepperDriver) GetCurrentStep

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *StepperDriver) GetCurrentStep() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                GetCurrentStep gives the current step of motor

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*StepperDriver) GetMaxSpeed

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *StepperDriver) GetMaxSpeed() uint

                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetMaxSpeed gives the max RPM of motor

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*StepperDriver) Halt

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *StepperDriver) Halt() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Halt implements the Driver interface and halts the motion of the Stepper

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*StepperDriver) IsMoving

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *StepperDriver) IsMoving() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                      IsMoving returns a bool stating whether motor is currently in motion

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*StepperDriver) Move

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *StepperDriver) Move(stepsToMove int) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Move moves the motor for given number of steps

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*StepperDriver) Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *StepperDriver) Name() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Name of StepperDriver

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*StepperDriver) Run

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *StepperDriver) Run() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Run continuously runs the stepper

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*StepperDriver) SetDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *StepperDriver) SetDirection(direction string) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetDirection sets the direction in which motor should be moving, Default is forward

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*StepperDriver) SetName

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *StepperDriver) SetName(n string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetName sets name for StepperDriver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*StepperDriver) SetSpeed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *StepperDriver) SetSpeed(rpm uint) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSpeed sets the rpm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*StepperDriver) Start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *StepperDriver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Start implements the Driver interface and keeps running the stepper till halt is called

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TM1638Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TM1638Driver struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	gobot.Commander
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewTM1638Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewTM1638Driver(a gobot.Connection, clockPin string, dataPin string, strobePin string) *TM1638Driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewTM1638Driver return a new TM1638Driver given a gobot.Connection and the clock, data and strobe pins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TM1638Driver) AddFonts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TM1638Driver) AddFonts(fonts map[string]byte)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AddFonts adds new custom fonts or modify the representation of existing ones

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TM1638Driver) ClearFonts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TM1638Driver) ClearFonts()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ClearFonts removes all the fonts from the driver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TM1638Driver) Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TM1638Driver) Connection() gobot.Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Connection returns the TM1638Driver Connection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TM1638Driver) Halt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TM1638Driver) Halt() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Halt implements the Driver interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TM1638Driver) Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TM1638Driver) Name() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Name returns the TM1638Drivers name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TM1638Driver) SendChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TM1638Driver) SendChar(pos byte, data byte, dot bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SendChar sends one byte to the specific position in the display

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TM1638Driver) SetDisplay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TM1638Driver) SetDisplay(data []byte)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetDisplay cuts and sends a byte array to the display (without dots)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TM1638Driver) SetDisplayText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TM1638Driver) SetDisplayText(text string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetDisplayText cuts and sends a string to the display (without dots)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TM1638Driver) SetLED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TM1638Driver) SetLED(color byte, pos byte)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetLED changes the color (TM1638None, TM1638Red, TM1638Green) of the specific LED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TM1638Driver) SetName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TM1638Driver) SetName(n string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetName sets the TM1638Drivers name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TM1638Driver) Start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TM1638Driver) Start() (err error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Start initializes the tm1638, it uses a SPI-like communication protocol