tmc51x0_config_builder.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstdint>
#include "../tmc51x0_types.hpp"
 
namespace tmc51x0 {
 
class ConfigBuilder {
private:
    DriverConfig config_;
 
public:
    ConfigBuilder() = default;
 
    explicit ConfigBuilder(const DriverConfig& cfg) : config_(cfg) {}
 
    // ========== MOTOR SPECIFICATION ==========
 
    ConfigBuilder& WithMotorMa(uint16_t steps_per_rev, uint16_t rated_current_ma) {
        config_.motor_spec.steps_per_rev = steps_per_rev;
        config_.motor_spec.rated_current_ma = rated_current_ma;
        return *this;
    }
 
    ConfigBuilder& WithRunCurrentMa(uint16_t run_current_ma) {
        config_.motor_spec.run_current_ma = run_current_ma;
        return *this;
    }
 
    ConfigBuilder& WithHoldCurrentMa(uint16_t hold_current_ma) {
        config_.motor_spec.hold_current_ma = hold_current_ma;
        return *this;
    }
 
    ConfigBuilder& WithSupplyVoltageMv(uint32_t voltage_mv) {
        config_.motor_spec.supply_voltage_mv = voltage_mv;
        return *this;
    }
 
    ConfigBuilder& WithSenseResistorMohm(uint32_t resistance_mohm) {
        config_.motor_spec.sense_resistor_mohm = resistance_mohm;
        return *this;
    }
 
    ConfigBuilder& WithWindingResistanceMohm(uint32_t resistance_mohm) {
        config_.motor_spec.winding_resistance_mohm = resistance_mohm;
        return *this;
    }
 
    ConfigBuilder& WithWindingInductanceMh(float inductance_mh) {
        config_.motor_spec.winding_inductance_mh = inductance_mh;
        return *this;
    }
 
    ConfigBuilder& WithMotorPowerDownDelayMs(float delay_ms) {
        config_.motor_spec.iholddelay_ms = delay_ms;
        return *this;
    }
 
    ConfigBuilder& WithStepsPerRevolution(uint16_t steps) {
        config_.motor_spec.steps_per_rev = steps;
        return *this;
    }
 
    // ========== BOARD CONFIGURATION (Power Stage) ==========
 
    ConfigBuilder& WithMosfetMillerChargeNc(float charge_nc) {
        config_.power_stage.mosfet_miller_charge_nc = charge_nc;
        return *this;
    }
 
    ConfigBuilder& WithBbmTimeNs(uint32_t time_ns) {
        config_.power_stage.bbm_time_ns = time_ns;
        return *this;
    }
 
    ConfigBuilder& WithSenseFilter(SenseFilterTime filter_time) {
        config_.power_stage.sense_filter = filter_time;
        return *this;
    }
 
    ConfigBuilder& WithOverTempProtection(OverTempProtection protection) {
        config_.power_stage.over_temp_protection = protection;
        return *this;
    }
 
    ConfigBuilder& WithS2vsVoltageMv(uint16_t voltage_mv) {
        config_.power_stage.s2vs_voltage_mv = voltage_mv;
        return *this;
    }
 
    ConfigBuilder& WithS2gVoltageMv(uint16_t voltage_mv) {
        config_.power_stage.s2g_voltage_mv = voltage_mv;
        return *this;
    }
 
    ConfigBuilder& WithShortFilter(uint8_t filter) {
        config_.power_stage.shortfilter = filter;
        return *this;
    }
 
    ConfigBuilder& WithShortDetectionDelayUsX10(uint8_t delay_us_x10) {
        config_.power_stage.short_detection_delay_us_x10 = delay_us_x10;
        return *this;
    }
 
    // ========== CHOPPER CONFIGURATION ==========
 
    ConfigBuilder& WithChopperMode(ChopperMode mode) {
        config_.chopper.mode = mode;
        return *this;
    }
 
    ConfigBuilder& WithChopperToff(uint8_t toff) {
        config_.chopper.toff = toff;
        return *this;
    }
 
    ConfigBuilder& WithChopperBlankTime(ChopperBlankTime blank_time) {
        config_.chopper.tbl = static_cast<uint8_t>(blank_time);
        return *this;
    }
 
    ConfigBuilder& WithHysteresisStart(uint8_t hstrt) {
        config_.chopper.hstrt = hstrt;
        return *this;
    }
 
    ConfigBuilder& WithHysteresisEnd(uint8_t hend) {
        config_.chopper.hend = hend;
        return *this;
    }
 
    ConfigBuilder& WithFastDecayTime(uint8_t tfd) {
        config_.chopper.tfd = tfd;
        return *this;
    }
 
    ConfigBuilder& WithPassiveFastDecayTime(uint8_t tpfd) {
        config_.chopper.tpfd = tpfd;
        return *this;
    }
 
    ConfigBuilder& WithMicrostepResolution(MicrostepResolution mres) {
        config_.chopper.mres = mres;
        return *this;
    }
 
    ConfigBuilder& WithInterpolation(bool enable) {
        config_.chopper.intpol = enable;
        return *this;
    }
 
    // ========== STEALTHCHOP CONFIGURATION ==========
 
    ConfigBuilder& WithStealthChop(bool enable) {
        config_.global_config.en_stealthchop_mode = enable;
        return *this;
    }
 
    ConfigBuilder& WithStealthChopThreshold(const VelocityValue& velocity) {
        config_.stealthchop.velocity_threshold = velocity.value;
        config_.stealthchop.velocity_threshold_unit = velocity.unit;
        return *this;
    }
 
    ConfigBuilder& WithStealthChopPwmFreq(uint8_t freq) {
        config_.stealthchop.pwm_freq = freq;
        return *this;
    }
 
    ConfigBuilder& WithStealthChopPwmOfs(uint8_t ofs) {
        config_.stealthchop.pwm_ofs = ofs;
        return *this;
    }
 
    ConfigBuilder& WithStealthChopAutoscale(bool enable) {
        config_.stealthchop.pwm_autoscale = enable;
        return *this;
    }
 
    ConfigBuilder& WithStealthChopAutograd(bool enable) {
        config_.stealthchop.pwm_autograd = enable;
        return *this;
    }
 
    // ========== STALLGUARD CONFIGURATION ==========
 
    ConfigBuilder& WithStallGuardThreshold(int8_t threshold) {
        config_.stallguard.threshold = threshold;
        return *this;
    }
 
    ConfigBuilder& WithStallGuardFilter(bool enable) {
        config_.stallguard.enable_filter = enable;
        return *this;
    }
 
    ConfigBuilder& WithStallGuardMinVelocity(float velocity, Unit unit = Unit::RPM) {
        config_.stallguard.min_velocity = velocity;
        config_.stallguard.velocity_unit = unit;
        return *this;
    }
 
    ConfigBuilder& WithStallGuardMaxVelocity(float velocity, Unit unit = Unit::RPM) {
        config_.stallguard.max_velocity = velocity;
        config_.stallguard.velocity_unit = unit;
        return *this;
    }
 
    ConfigBuilder& WithStallGuard(const StallGuardConfig& sg_config) {
        config_.stallguard = sg_config;
        return *this;
    }
 
    // ========== GLOBAL CONFIGURATION ==========
 
    ConfigBuilder& WithRecalibration(bool enable) {
        config_.global_config.recalibrate = enable;
        return *this;
    }
 
    ConfigBuilder& WithShortStandstillTimeout(bool enable) {
        config_.global_config.en_short_standstill_timeout = enable;
        return *this;
    }
 
    ConfigBuilder& WithStealthChopStepFilter(bool enable) {
        config_.global_config.en_stealthchop_step_filter = enable;
        return *this;
    }
 
    // ========== MOTION CONFIGURATION (Ramp) ==========
 
    ConfigBuilder& WithMaxSpeed(const VelocityValue& velocity) {
        config_.ramp_config.vmax = velocity;
        return *this;
    }
 
    ConfigBuilder& WithAcceleration(const AccelerationValue& acceleration) {
        config_.ramp_config.amax = acceleration;
        return *this;
    }
 
    ConfigBuilder& WithDeceleration(const AccelerationValue& deceleration) {
        config_.ramp_config.dmax = deceleration;
        return *this;
    }
 
    ConfigBuilder& WithStartSpeed(const VelocityValue& velocity) {
        config_.ramp_config.vstart = velocity;
        return *this;
    }
 
    ConfigBuilder& WithStopSpeed(const VelocityValue& velocity) {
        config_.ramp_config.vstop = velocity;
        return *this;
    }
 
    ConfigBuilder& WithVelocityThreshold(const VelocityValue& velocity) {
        config_.ramp_config.v1 = velocity;
        return *this;
    }
 
    ConfigBuilder& WithFirstAcceleration(const AccelerationValue& acceleration) {
        config_.ramp_config.a1 = acceleration;
        return *this;
    }
 
    ConfigBuilder& WithFirstDeceleration(const AccelerationValue& deceleration) {
        config_.ramp_config.d1 = deceleration;
        return *this;
    }
 
    ConfigBuilder& WithRampPowerDownDelayMs(float delay_ms) {
        config_.ramp_config.tpowerdown_ms = delay_ms;
        return *this;
    }
 
    ConfigBuilder& WithZeroWaitTimeMs(float wait_ms) {
        config_.ramp_config.tzerowait_ms = wait_ms;
        return *this;
    }
 
    // ========== CLOCK CONFIGURATION ==========
 
    ConfigBuilder& WithInternalClock() {
        config_.external_clk_config.frequency_hz = 0;
        return *this;
    }
 
    ConfigBuilder& WithExternalClockHz(uint32_t frequency_hz) {
        config_.external_clk_config.frequency_hz = frequency_hz;
        return *this;
    }
 
    // ========== MECHANICAL SYSTEM ==========
 
    ConfigBuilder& WithDirectDrive() {
        config_.mechanical.system_type = MechanicalSystemType::DirectDrive;
        config_.mechanical.gear_ratio = 1.0f;
        config_.mechanical.lead_screw_pitch_mm = 0.0f;
        config_.mechanical.belt_pulley_teeth = 0;
        config_.mechanical.belt_pitch_mm = 0.0f;
        return *this;
    }
 
    ConfigBuilder& WithGearbox(float gear_ratio) {
        config_.mechanical.system_type = MechanicalSystemType::Gearbox;
        config_.mechanical.gear_ratio = gear_ratio;
        config_.mechanical.lead_screw_pitch_mm = 0.0f;
        config_.mechanical.belt_pulley_teeth = 0;
        config_.mechanical.belt_pitch_mm = 0.0f;
        return *this;
    }
 
    ConfigBuilder& WithLeadScrew(float pitch_mm) {
        config_.mechanical.system_type = MechanicalSystemType::LeadScrew;
        config_.mechanical.lead_screw_pitch_mm = pitch_mm;
        config_.mechanical.gear_ratio = 1.0f;
        config_.mechanical.belt_pulley_teeth = 0;
        config_.mechanical.belt_pitch_mm = 0.0f;
        return *this;
    }
 
    ConfigBuilder& WithBeltDrive(uint16_t pulley_teeth, float belt_pitch_mm) {
        config_.mechanical.system_type = MechanicalSystemType::BeltDrive;
        config_.mechanical.belt_pulley_teeth = pulley_teeth;
        config_.mechanical.belt_pitch_mm = belt_pitch_mm;
        config_.mechanical.gear_ratio = 1.0f;
        config_.mechanical.lead_screw_pitch_mm = 0.0f;
        return *this;
    }
 
    // ========== DIRECTION ==========
 
    ConfigBuilder& WithDirection(MotorDirection direction) {
        config_.direction = direction;
        return *this;
    }
 
    // ========== BUILD ==========
 
    DriverConfig Build() const {
        return config_;
    }
 
    DriverConfig& Config() {
        return config_;
    }
 
    const DriverConfig& Config() const {
        return config_;
    }
};
 
} // namespace tmc51x0