Struct Sequencer 

pub struct Sequencer { /* private fields */ }

A position in a drive sequence, walked one step at a time.

Holding the index into the pattern, a sequencer turns each step into the next coil pattern to apply, wrapping around the cycle so it can run indefinitely in either direction.

Examples

use pamoja_actuators::stepper::{Direction, Drive, Sequencer};

let mut sequencer = Sequencer::new(Drive::HalfStep);
assert_eq!(sequencer.coils(), 0b1000);
assert_eq!(sequencer.step(Direction::Forward), 0b1100);

// One full electrical cycle returns to the start.
for _ in 1..Drive::HalfStep.step_count() {
    sequencer.step(Direction::Forward);
}
assert_eq!(sequencer.coils(), 0b1000);

Implementations

impl Sequencer

pub fn new(drive: Drive) -> Sequencer

Creates a sequencer at the start of a drive pattern.

Arguments

• drive - the drive pattern to walk.

Returns

A sequencer whose current pattern is the first in the drive.

pub fn coils(&self) -> u8

Returns the coil pattern at the current position.

Returns

The four-bit coil pattern to apply now.

pub fn step(&mut self, direction: Direction) -> u8

Advances one step in direction and returns the new coil pattern.

The index wraps around the cycle, so stepping forever in either direction is well defined.

Arguments

• direction - which way to step.

Returns

The coil pattern to apply after the step.

pub fn drive(&self) -> Drive

Returns the drive pattern this sequencer walks.

Trait Implementations

impl Clone for Sequencer

fn clone(&self) -> Sequencer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Sequencer

impl Debug for Sequencer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Sequencer

impl PartialEq for Sequencer

fn eq(&self, other: &Sequencer) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Sequencer