Struct PowertrainParams 

pub struct PowertrainParams {
    pub base: MotorQuadParams,
    pub motor_tau: f64,
    pub discharge_rate: f64,
    pub sag_coeff: f64,
    pub min_voltage_scale: f64,
    pub relax_build: f64,
    pub relax_recover: f64,
    pub relax_coeff: f64,
}

Powertrain parameters layered on top of the base motor model.

Fields

base: MotorQuadParams

Base rigid-body and rotor-mixing parameters.

motor_tau: f64

First-order motor spin-up time constant [s]; 0 means instant.

discharge_rate: f64

Battery discharge rate per unit load per second [1/s].

sag_coeff: f64

Instantaneous voltage droop fraction at full electrical load, in [0, 1).

min_voltage_scale: f64

Open-circuit voltage scale at an empty pack, in (0, 1].

relax_build: f64

Rate [1/s] at which the relaxation overpotential builds toward the load.

relax_recover: f64

Rate [1/s] at which the relaxation overpotential decays (recovers).

relax_coeff: f64

Voltage-scale depression per unit relaxation overpotential, in [0, 1).

Implementations

impl PowertrainParams

pub fn new( base: MotorQuadParams, motor_tau: f64, discharge_rate: f64, sag_coeff: f64, min_voltage_scale: f64, ) -> RoboticsResult<Self>

Build a powertrain with explicit lag/battery coefficients.

pub fn with_recovery(self, build: f64, recover: f64, coeff: f64) -> Self

Add a battery-recovery (relaxation-overpotential) model: the relaxation state builds toward the load at build [1/s] and decays at recover [1/s], depressing the terminal voltage by coeff per unit. Easing off therefore lets the terminal voltage — and thus the thrust ceiling — recover even though the state of charge keeps falling. All arguments are sanitized (build/recover >= 0 and finite, coeff in [0, 1)); the defaults of zero leave the pack with no recovery dynamics.

pub fn ideal(base: MotorQuadParams) -> Self

Idealized powertrain: no lag, no discharge, no sag. Reduces exactly to the base MotorQuadParams dynamics — the benchmark baseline.

pub fn load(self, rotor_thrust: [f64; 4]) -> f64

Electrical load in [0, 1]: total rotor thrust over the absolute max.

pub fn voltage_scale(self, soc: f64, load: f64) -> f64

Terminal-voltage scale in [0, 1] from state of charge and load.

Open-circuit voltage falls linearly with state of charge from 1 (full) to min_voltage_scale (empty); instantaneous sag subtracts sag_coeff * load on top of that.

pub fn terminal_voltage_scale(self, soc: f64, load: f64, relaxation: f64) -> f64

Terminal-voltage scale including the relaxation overpotential: the open-circuit-minus-sag Self::voltage_scale less relax_coeff * relaxation. This is the voltage actually available at the rotors.

pub fn effective_max_rotor(self, state: PowertrainState) -> f64

Battery-limited per-rotor thrust ceiling for the current state, including the relaxation overpotential.

pub fn step( self, state: PowertrainState, command: MotorCommand, dt: f64, ) -> PowertrainState

Advance the powertrain one step under the commanded rotor thrusts.

Trait Implementations

impl Clone for PowertrainParams

fn clone(&self) -> PowertrainParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PowertrainParams

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

Formats the value using the given formatter.

impl PartialEq for PowertrainParams

fn eq(&self, other: &PowertrainParams) -> 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 Copy for PowertrainParams

impl StructuralPartialEq for PowertrainParams