motor

Documentation

Overview

Package motor contains a gRPC bases motor client

Package motor contains an enum representing optional motor features

Package motor contains a gRPC based motor service server

Index

• Constants
• Variables
• func CreateStatus(ctx context.Context, resource interface{}) (*pb.Status, error)
• func DependencyTypeError(name, actual interface{}) error
• func FeatureMapToProtoResponse(featureMap map[Feature]bool) (*pb.GetPropertiesResponse, error)
• func Named(name string) resource.Name
• func NamesFromRobot(r robot.Robot) []string
• func NewFeatureUnsupportedError(feature Feature, motorName string) error
• func NewGoTillStopUnsupportedError(motorName string) error
• func NewResetZeroPositionUnsupportedError(motorName string) error
• func NewServer(service subtype.Service) pb.MotorServiceServer
• func NewUnimplementedInterfaceError(actual interface{}) error
• func NewUnimplementedLocalInterfaceError(actual interface{}) error
• func NewZeroRPMError() error
• func ProtoFeaturesToMap(resp *pb.GetPropertiesResponse) map[Feature]bool
• func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error)
• type Feature
• type LocalMotor
• type Motor
  • func FromDependencies(deps registry.Dependencies, name string) (Motor, error)
  • func FromRobot(r robot.Robot, name string) (Motor, error)
  • func NewClientFromConn(ctx context.Context, conn rpc.ClientConn, name string, logger golog.Logger) Motor
• type Position
• type Powered

Constants

const SubtypeName = resource.SubtypeName("motor")

SubtypeName is a constant that identifies the component resource subtype string "motor".

Variables

var Subtype = resource.NewSubtype(
	resource.ResourceNamespaceRDK,
	resource.ResourceTypeComponent,
	SubtypeName,
)

Subtype is a constant that identifies the component resource subtype.

Functions

func CreateStatus

func CreateStatus(ctx context.Context, resource interface{}) (*pb.Status, error)

CreateStatus creates a status from the motor.

func DependencyTypeError

func DependencyTypeError(name, actual interface{}) error

DependencyTypeError is used when a resource doesn't implement the expected interface.

func FeatureMapToProtoResponse

func FeatureMapToProtoResponse(
	featureMap map[Feature]bool,
) (*pb.GetPropertiesResponse, error)

FeatureMapToProtoResponse takes a map of features to booleans (indicating whether the feature is supported) and converts it to a GetPropertiesResponse.

func Named

func Named(name string) resource.Name

Named is a helper for getting the named Motor's typed resource name.

func NamesFromRobot

func NamesFromRobot(r robot.Robot) []string

NamesFromRobot is a helper for getting all motor names from the given Robot.

func NewFeatureUnsupportedError

func NewFeatureUnsupportedError(feature Feature, motorName string) error

NewFeatureUnsupportedError returns an error representing the need for a motor to support a particular feature.

func NewGoTillStopUnsupportedError

func NewGoTillStopUnsupportedError(motorName string) error

NewGoTillStopUnsupportedError returns a standard error for when a motor is required to support the GoTillStop feature.

func NewResetZeroPositionUnsupportedError

func NewResetZeroPositionUnsupportedError(motorName string) error

NewResetZeroPositionUnsupportedError returns a standard error for when a motor is required to support reseting the zero position.

func NewServer

func NewServer(service subtype.Service) pb.MotorServiceServer

NewServer constructs a motor gRPC service server.

func NewUnimplementedInterfaceError

func NewUnimplementedInterfaceError(actual interface{}) error

NewUnimplementedInterfaceError is used when there is a failed interface check.

func NewUnimplementedLocalInterfaceError

func NewUnimplementedLocalInterfaceError(actual interface{}) error

NewUnimplementedLocalInterfaceError is used when there is a failed interface check.

func NewZeroRPMError

func NewZeroRPMError() error

NewZeroRPMError returns an error representing a request to move a motor at zero speed (i.e., moving the motor without moving the motor).

func ProtoFeaturesToMap

func ProtoFeaturesToMap(resp *pb.GetPropertiesResponse) map[Feature]bool

ProtoFeaturesToMap takes a GetPropertiesResponse and returns an equivalent Feature-to-boolean map.

func WrapWithReconfigurable

func WrapWithReconfigurable(r interface{}) (resource.Reconfigurable, error)

WrapWithReconfigurable converts a regular Motor implementation to a reconfigurableMotor. If motor is already a reconfigurableMotor, then nothing is done.

Types

type Feature

type Feature string

Feature is an enum representing an optional motor feature.

const PositionReporting Feature = "PositionReporting"

PositionReporting represesnts the feature of a motor being able to report its own position.

type LocalMotor

type LocalMotor interface {
	Motor
	// GoTillStop moves a motor until stopped. The "stop" mechanism is up to the underlying motor implementation.
	// Ex: EncodedMotor goes until physically stopped/stalled (detected by change in position being very small over a fixed time.)
	// Ex: TMCStepperMotor has "StallGuard" which detects the current increase when obstructed and stops when that reaches a threshold.
	// Ex: Other motors may use an endstop switch (such as via a DigitalInterrupt) or be configured with other sensors.
	GoTillStop(ctx context.Context, rpm float64, stopFunc func(ctx context.Context) bool) error

	resource.MovingCheckable
}

A LocalMotor is a motor that supports additional features provided by RDK (e.g. GoTillStop).

type Motor

type Motor interface {
	// SetPower sets the percentage of power the motor should employ between -1 and 1.
	// Negative power implies a backward directional rotational
	SetPower(ctx context.Context, powerPct float64, extra map[string]interface{}) error

	// GoFor instructs the motor to go in a specific direction for a specific amount of
	// revolutions at a given speed in revolutions per minute. Both the RPM and the revolutions
	// can be assigned negative values to move in a backwards direction. Note: if both are
	// negative the motor will spin in the forward direction.
	// If revolutions is 0, this will run the motor at rpm indefinitely
	// If revolutions != 0, this will block until the number of revolutions has been completed or another operation comes in.
	GoFor(ctx context.Context, rpm, revolutions float64, extra map[string]interface{}) error

	// GoTo instructs the motor to go to a specific position (provided in revolutions from home/zero),
	// at a specific speed. Regardless of the directionality of the RPM this function will move the motor
	// towards the specified target/position
	// This will block until the position has been reached
	GoTo(ctx context.Context, rpm, positionRevolutions float64, extra map[string]interface{}) error

	// Set the current position (+/- offset) to be the new zero (home) position.
	ResetZeroPosition(ctx context.Context, offset float64, extra map[string]interface{}) error

	// Position reports the position of the motor based on its encoder. If it's not supported, the returned
	// data is undefined. The unit returned is the number of revolutions which is intended to be fed
	// back into calls of GoFor.
	Position(ctx context.Context, extra map[string]interface{}) (float64, error)

	// Properties returns whether or not the motor supports certain optional features.
	Properties(ctx context.Context, extra map[string]interface{}) (map[Feature]bool, error)

	// Stop turns the power to the motor off immediately, without any gradual step down.
	Stop(ctx context.Context, extra map[string]interface{}) error

	// IsPowered returns whether or not the motor is currently on, and the percent power (between 0
	// and 1, if the motor is off then the percent power will be 0).
	IsPowered(ctx context.Context, extra map[string]interface{}) (bool, float64, error)

	generic.Generic
}

A Motor represents a physical motor connected to a board.

func FromDependencies

func FromDependencies(deps registry.Dependencies, name string) (Motor, error)

FromDependencies is a helper for getting the named motor from a collection of dependencies.

func FromRobot

func FromRobot(r robot.Robot, name string) (Motor, error)

FromRobot is a helper for getting the named motor from the given Robot.

func NewClientFromConn

func NewClientFromConn(ctx context.Context, conn rpc.ClientConn, name string, logger golog.Logger) Motor

NewClientFromConn constructs a new Client from connection passed in.

type Position

type Position struct {
	Position float64
}

Position wraps the returned position value.

type Powered

type Powered struct {
	IsPowered bool
	PowerPct  float64
}

Powered wraps the returned IsPowered value.