282 lines
6.5 KiB
Go
282 lines
6.5 KiB
Go
package gpio
|
|
|
|
import (
|
|
"errors"
|
|
"strconv"
|
|
"time"
|
|
|
|
"gobot.io/x/gobot"
|
|
)
|
|
|
|
// EasyDriver object
|
|
type EasyDriver struct {
|
|
gobot.Commander
|
|
|
|
name string
|
|
connection DigitalWriter
|
|
stepPin string
|
|
dirPin string
|
|
enPin string
|
|
sleepPin string
|
|
|
|
angle float32
|
|
rpm uint
|
|
dir int8
|
|
moving bool
|
|
stepNum int
|
|
enabled bool
|
|
sleeping bool
|
|
}
|
|
|
|
// 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 NewEasyDriver(a DigitalWriter, angle float32, stepPin string, dirPin string, enPin string, sleepPin string) *EasyDriver {
|
|
d := &EasyDriver{
|
|
Commander: gobot.NewCommander(),
|
|
name: gobot.DefaultName("EasyDriver"),
|
|
connection: a,
|
|
stepPin: stepPin,
|
|
dirPin: dirPin,
|
|
enPin: enPin,
|
|
sleepPin: sleepPin,
|
|
|
|
angle: angle,
|
|
rpm: 1,
|
|
dir: 1,
|
|
enabled: true,
|
|
sleeping: false,
|
|
}
|
|
|
|
// panic if step pin isn't set
|
|
if stepPin == "" {
|
|
panic("Step pin is not set")
|
|
}
|
|
|
|
// 1/4 of max speed. Not too fast, not too slow
|
|
d.rpm = d.GetMaxSpeed() / 4
|
|
|
|
d.AddCommand("Move", func(params map[string]interface{}) interface{} {
|
|
degs, _ := strconv.Atoi(params["degs"].(string))
|
|
return d.Move(degs)
|
|
})
|
|
d.AddCommand("Step", func(params map[string]interface{}) interface{} {
|
|
return d.Step()
|
|
})
|
|
d.AddCommand("Run", func(params map[string]interface{}) interface{} {
|
|
return d.Run()
|
|
})
|
|
d.AddCommand("Stop", func(params map[string]interface{}) interface{} {
|
|
return d.Stop()
|
|
})
|
|
|
|
return d
|
|
}
|
|
|
|
// Name of EasyDriver
|
|
func (d *EasyDriver) Name() string { return d.name }
|
|
|
|
// SetName sets name for EasyDriver
|
|
func (d *EasyDriver) SetName(n string) { d.name = n }
|
|
|
|
// Connection returns EasyDriver's connection
|
|
func (d *EasyDriver) Connection() gobot.Connection { return d.connection.(gobot.Connection) }
|
|
|
|
// Start implements the Driver interface
|
|
func (d *EasyDriver) Start() (err error) { return }
|
|
|
|
// Halt implements the Driver interface; stops running the stepper
|
|
func (d *EasyDriver) Halt() (err error) {
|
|
d.Stop()
|
|
return
|
|
}
|
|
|
|
// Move the motor given number of degrees at current speed.
|
|
func (d *EasyDriver) Move(degs int) (err error) {
|
|
if d.moving {
|
|
// don't do anything if already moving
|
|
return
|
|
}
|
|
|
|
d.moving = true
|
|
|
|
steps := int(float32(degs) / d.angle)
|
|
for i := 0; i < steps; i++ {
|
|
if !d.moving {
|
|
// don't continue to step if driver is stopped
|
|
break
|
|
}
|
|
|
|
d.Step()
|
|
}
|
|
|
|
d.moving = false
|
|
|
|
return
|
|
}
|
|
|
|
// Step the stepper 1 step
|
|
func (d *EasyDriver) Step() (err error) {
|
|
stepsPerRev := d.GetMaxSpeed()
|
|
|
|
// a valid steps occurs for a low to high transition
|
|
d.connection.DigitalWrite(d.stepPin, 0)
|
|
// 1 minute / steps per revolution / revolutions per minute
|
|
// let's keep it as Microseconds so we only have to do integer math
|
|
time.Sleep(time.Duration(60*1000*1000/stepsPerRev/d.rpm) * time.Microsecond)
|
|
d.connection.DigitalWrite(d.stepPin, 1)
|
|
|
|
// increment or decrement the number of steps by 1
|
|
d.stepNum += int(d.dir)
|
|
|
|
return
|
|
}
|
|
|
|
// Run the stepper continuously
|
|
func (d *EasyDriver) Run() (err error) {
|
|
if d.moving {
|
|
// don't do anything if already moving
|
|
return
|
|
}
|
|
|
|
d.moving = true
|
|
|
|
go func() {
|
|
for d.moving {
|
|
d.Step()
|
|
}
|
|
}()
|
|
|
|
return
|
|
}
|
|
|
|
// Stop running the stepper
|
|
func (d *EasyDriver) Stop() (err error) {
|
|
d.moving = false
|
|
return
|
|
}
|
|
|
|
// SetDirection sets the direction to be moving. Valid directions are "cw" or "ccw"
|
|
func (d *EasyDriver) SetDirection(dir string) (err error) {
|
|
// can't change direct if dirPin isn't set
|
|
if d.dirPin == "" {
|
|
return errors.New("dirPin is not set")
|
|
}
|
|
|
|
if dir == "ccw" {
|
|
d.dir = -1
|
|
d.connection.DigitalWrite(d.dirPin, 1) // high is ccw
|
|
} else { // default to cw, even if user specified wrong value
|
|
d.dir = 1
|
|
d.connection.DigitalWrite(d.dirPin, 0) // low is cw
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// SetSpeed sets the speed of the motor in RPMs. 1 is the lowest and GetMaxSpeed is the highest
|
|
func (d *EasyDriver) SetSpeed(rpm uint) (err error) {
|
|
if rpm < 1 {
|
|
d.rpm = 1
|
|
} else if rpm > d.GetMaxSpeed() {
|
|
d.rpm = d.GetMaxSpeed()
|
|
} else {
|
|
d.rpm = rpm
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// GetMaxSpeed returns the max speed of the stepper
|
|
func (d *EasyDriver) GetMaxSpeed() uint {
|
|
return uint(360 / d.angle)
|
|
}
|
|
|
|
// GetCurrentStep returns current step number
|
|
func (d *EasyDriver) GetCurrentStep() int {
|
|
return d.stepNum
|
|
}
|
|
|
|
// IsMoving returns a bool stating whether motor is currently in motion
|
|
func (d *EasyDriver) IsMoving() bool {
|
|
return d.moving
|
|
}
|
|
|
|
// Enable enables all motor output
|
|
func (d *EasyDriver) Enable() (err error) {
|
|
// can't enable if enPin isn't set. This is fine normally since it will be enabled by default
|
|
if d.enPin == "" {
|
|
return errors.New("enPin is not set. Board is enabled by default")
|
|
}
|
|
|
|
d.enabled = true
|
|
d.connection.DigitalWrite(d.enPin, 0) // enPin is active low
|
|
|
|
return
|
|
}
|
|
|
|
// Disable disables all motor output
|
|
func (d *EasyDriver) Disable() (err error) {
|
|
// can't disable if enPin isn't set
|
|
if d.enPin == "" {
|
|
return errors.New("enPin is not set")
|
|
}
|
|
|
|
// let's stop the motor first
|
|
d.Stop()
|
|
|
|
d.enabled = false
|
|
d.connection.DigitalWrite(d.enPin, 1) // enPin is active low
|
|
|
|
return
|
|
}
|
|
|
|
// IsEnabled returns a bool stating whether motor is enabled
|
|
func (d *EasyDriver) IsEnabled() bool {
|
|
return d.enabled
|
|
}
|
|
|
|
// Sleep puts the driver to sleep and disables all motor output. Low power mode.
|
|
func (d *EasyDriver) Sleep() (err error) {
|
|
// can't sleep if sleepPin isn't set
|
|
if d.sleepPin == "" {
|
|
return errors.New("sleepPin is not set")
|
|
}
|
|
|
|
// let's stop the motor first
|
|
d.Stop()
|
|
|
|
d.sleeping = true
|
|
d.connection.DigitalWrite(d.sleepPin, 0) // sleepPin is active low
|
|
|
|
return
|
|
}
|
|
|
|
// Wake wakes up the driver
|
|
func (d *EasyDriver) Wake() (err error) {
|
|
// can't wake if sleepPin isn't set
|
|
if d.sleepPin == "" {
|
|
return errors.New("sleepPin is not set")
|
|
}
|
|
|
|
d.sleeping = false
|
|
d.connection.DigitalWrite(d.sleepPin, 1) // sleepPin is active low
|
|
|
|
// we need to wait 1ms after sleeping before doing a step to charge the step pump (according to data sheet)
|
|
// this will ensure that happens
|
|
time.Sleep(1 * time.Millisecond)
|
|
|
|
return
|
|
}
|
|
|
|
// IsSleeping returns a bool stating whether motor is enabled
|
|
func (d *EasyDriver) IsSleeping() bool {
|
|
return d.sleeping
|
|
}
|