Struct MapCommand 

pub struct MapCommand<A, F, C> { /* private fields */ }

An actuator whose commands are converted before they reach the part.

Created by Actuator::map_command. The function runs on every command, so a part that takes a pulse width or a duty can be driven by a bool, an angle, or a percentage, whichever the caller has.

Examples

use pamoja_core::{Actuator, Result};

struct Pump {
    duty: u8,
}
impl Actuator for Pump {
    type Command = u8;
    async fn apply(&mut self, duty: u8) -> Result<()> {
        self.duty = duty;
        Ok(())
    }
}

// A profile drives the pump as on or off; on means full speed.
let mut switch = Pump { duty: 0 }.map_command(|on: bool| if on { 100 } else { 0 });
switch.apply(true).await?;
assert_eq!(switch.inner().duty, 100);

Implementations

impl<A, F, C> MapCommand<A, F, C>

pub fn new(inner: A, convert: F) -> MapCommand<A, F, C>

Wraps inner so each command passes through convert first.

Arguments

• inner - the actuator being adapted.
• convert - the function turning the caller’s command into the part’s.

Returns

The adapted actuator.

pub fn inner(&self) -> &A

Borrows the wrapped actuator.

Returns

The actuator underneath the adapter.

pub fn inner_mut(&mut self) -> &mut A

Mutably borrows the wrapped actuator.

Returns

The actuator underneath the adapter.

pub fn into_inner(self) -> A

Unwraps the actuator, discarding the adapter.

Returns

The actuator underneath the adapter.

Trait Implementations

impl<A, F, C> Actuator for MapCommand<A, F, C>

where A: Actuator + Send, F: FnMut(C) -> A::Command + Send, C: Send,

type Command = C

The command accepted by a single application, for example a setpoint.

async fn apply(&mut self, command: C) -> Result<()>

Applies a command to the actuator.

fn map_command<F, C>(self, convert: F) -> MapCommand<Self, F, C>

where Self: Sized, F: FnMut(C) -> Self::Command,

Wraps this actuator so every command passes through convert first.