Struct ConstantGetter 

pub struct ConstantGetter<T: Clone, TG: TimeGetter<E> + ?Sized, E: Copy + Debug> { /* private fields */ }

Getter for returning a constant value.

Implementations

impl<T: Clone, TG: TimeGetter<E> + ?Sized, E: Copy + Debug> ConstantGetter<T, TG, E>

pub const fn new(time_getter: Reference<TG>, value: T) -> Self

Constructor for ConstantGetter.

Examples found in repository

examples/pid.rs (line 38)

    pub fn new(
        input: Reference<dyn Getter<Quantity, ()>>,
        setpoint: Quantity,
        kp: Quantity,
        ki: Quantity,
        kd: Quantity,
    ) -> Self {
        let time_getter = rc_ref_cell_reference(TimeGetterFromGetter::new(input.clone()));
        let setpoint = rc_ref_cell_reference(ConstantGetter::new(time_getter.clone(), setpoint));
        let kp = rc_ref_cell_reference(ConstantGetter::new(time_getter.clone(), kp));
        let ki = rc_ref_cell_reference(ConstantGetter::new(time_getter.clone(), ki));
        let kd = rc_ref_cell_reference(ConstantGetter::new(time_getter.clone(), kd));
        let error = rc_ref_cell_reference(DifferenceStream::new(setpoint.clone(), input.clone()));
        let int = rc_ref_cell_reference(IntegralStream::new(error.clone()));
        let drv = rc_ref_cell_reference(DerivativeStream::new(error.clone()));
        //`ProductStream`'s behavior is to treat all `None` values as 1.0 so that it's as if they
        //were not included. However, this is not what we want with the coefficient. `NoneToValue`
        //is used to convert all `None` values to `Some(0.0)` to effectively exlude them from the
        //final sum.
        let int_zeroer = rc_ref_cell_reference(NoneToValue::new(
            int.clone(),
            time_getter.clone(),
            Quantity::new(0.0, MILLIMETER),
        ));
        let drv_zeroer = rc_ref_cell_reference(NoneToValue::new(
            drv.clone(),
            time_getter.clone(),
            Quantity::new(0.0, MILLIMETER),
        ));
        let kp_mul = rc_ref_cell_reference(ProductStream::new([
            to_dyn!(Getter<Quantity, ()>, kp.clone()),
            to_dyn!(Getter<Quantity, ()>, error.clone()),
        ]));
        //The way a PID controller works necessitates that it adds quantities of different units.
        //Thus, QuantityToFloat streams are required to keep the dimensional analysis system from
        //stopping this.
        let pro_float_maker = rc_ref_cell_reference(QuantityToFloat::new(kp_mul));
        let ki_mul = rc_ref_cell_reference(ProductStream::new([
            to_dyn!(Getter<Quantity, ()>, ki.clone()),
            to_dyn!(Getter<Quantity, ()>, int_zeroer.clone()),
        ]));
        let int_float_maker = rc_ref_cell_reference(QuantityToFloat::new(ki_mul));
        let kd_mul = rc_ref_cell_reference(ProductStream::new([
            to_dyn!(Getter<Quantity, ()>, kd.clone()),
            to_dyn!(Getter<Quantity, ()>, drv_zeroer.clone()),
        ]));
        let drv_float_maker = rc_ref_cell_reference(QuantityToFloat::new(kd_mul));
        let output = SumStream::new([
            to_dyn!(Getter<f32, ()>, pro_float_maker.clone()),
            to_dyn!(Getter<f32, ()>, int_float_maker.clone()),
            to_dyn!(Getter<f32, ()>, drv_float_maker.clone()),
        ]);
        Self {
            int: to_dyn!(Getter<Quantity, ()>, int),
            drv: to_dyn!(Getter<Quantity, ()>, drv),
            pro_float_maker: to_dyn!(Getter<f32, ()>, pro_float_maker),
            int_float_maker: to_dyn!(Getter<f32, ()>, int_float_maker),
            drv_float_maker: to_dyn!(Getter<f32, ()>, drv_float_maker),
            output: output,
        }
    }

Trait Implementations

impl<T: Clone, TG: TimeGetter<E> + ?Sized, E: Copy + Debug> Getter<T, E> for ConstantGetter<T, TG, E>

fn get(&self) -> Output<T, E>

Get something.

impl<T: Clone, TG: TimeGetter<E> + ?Sized, E: Copy + Debug> Settable<T, E> for ConstantGetter<T, TG, E>

fn get_settable_data_ref(&self) -> &SettableData<T, E>

As traits cannot have fields, get functions and separate types are required. All you have to do is make a field for a corresponding SettableData, make this return an immutable reference to it, and make get_settable_data_mut return a mutable reference to it.

fn get_settable_data_mut(&mut self) -> &mut SettableData<T, E>

As traits cannot have fields, get functions and separate types are required. All you have to do is make a field for a corresponding SettableData, make this return a mutable reference to it, and make get_settable_data_ref return an immutable reference to it.

fn impl_set(&mut self, value: T) -> NothingOrError<E>

Set something, not updating the internal SettableData. Due to current limitations of the language, you must implement this but call set. Do not call this directly as it will make get_last_request work incorrectly.

fn set(&mut self, value: S) -> NothingOrError<E>

Set something to a value. For example, this could set a motor to a voltage. You should call this and not impl_set.

fn follow(&mut self, getter: Reference<dyn Getter<S, E>>)

Begin following a Getter of the same type. For this to work, you must have update_following_data in your Updatable implementation.

fn stop_following(&mut self)

Stop following the Getter.

fn update_following_data(&mut self) -> NothingOrError<E>

Get a new value from the Getter we’re following, if there is one, and call set accordingly. You must add this to your Updatable implementation if you are following Getters. This is a current limitation of the Rust language. If specialization is ever stabilized, this will hopefully be done in a better way.

fn get_last_request(&self) -> Option<S>

Get the argument from the last time set was called.

impl<T: Clone, TG: TimeGetter<E> + ?Sized, E: Copy + Debug> Updatable<E> for ConstantGetter<T, TG, E>

fn update(&mut self) -> NothingOrError<E>

This does not need to be called.