axisunit.h

Go to the documentation of this file.

#pragma once
#include "../config/axis.h"
#include "pulse_gen.h"
 
namespace modules {
namespace motion {
 
// Import required types
using config::Axis;
using config::Idler;
using config::Pulley;
using config::Selector;
 
using config::Accel;
using config::Lenght;
using config::Speed;
 
using pulse_gen::pos_t;
using pulse_gen::steps_t;
 
template <typename T, Axis A, config::UnitType U>
struct AxisUnit {
    T v;
 
    static constexpr Axis axis = A;
    static constexpr config::UnitType unit = U;
 
    typedef T type_t;
    typedef AxisUnit<T, A, U> self_t;
 
    // same-type operations
    constexpr self_t operator+(const self_t r) const { return { v + r.v }; }
    constexpr self_t operator-(const self_t r) const { return { v - r.v }; }
    constexpr self_t operator-() const { return { -v }; }
    constexpr self_t operator*(const self_t r) const { return { v * r.v }; }
    constexpr self_t operator/(const self_t r) const { return { v / r.v }; }
 
    // allow an unitless multiplier to scale the quantity: AU * f => AU
    constexpr self_t operator*(const long double f) const { return { (T)(v * f) }; }
    constexpr self_t operator/(const long double f) const { return { (T)(v / f) }; }
};
 
// complementary f * AU => AU * f
template <typename T, Axis A, config::UnitType U>
constexpr AxisUnit<T, A, U> operator*(const long double f, const AxisUnit<T, A, U> u) { return u * f; }
 
struct AxisScale {
    unit::UnitBase base;
    long double stepsPerUnit;
};
 
static constexpr AxisScale axisScale[config::NUM_AXIS] = {
    { config::pulleyLimits.base, config::pulley.stepsPerUnit },
    { config::selectorLimits.base, config::selector.stepsPerUnit },
    { config::idlerLimits.base, config::idler.stepsPerUnit },
};
 
template <typename AU, typename U>
static constexpr AU unitToAxisUnit(U v) {
    static_assert(AU::unit == U::unit, "incorrect unit type conversion");
    static_assert(U::base == axisScale[AU::axis].base, "incorrect unit base conversion");
    return { (typename AU::type_t)(v.v * axisScale[AU::axis].stepsPerUnit) };
}
 
template <typename U, typename AU, typename T = int32_t>
static constexpr T axisUnitToTruncatedUnit(AU v, long double mul = 1.) {
    static_assert(AU::unit == U::unit, "incorrect unit type conversion");
    static_assert(U::base == axisScale[AU::axis].base, "incorrect unit base conversion");
    return { ((T)v.v / (T)(axisScale[AU::axis].stepsPerUnit / mul)) };
}
 
template <typename U, typename T = int32_t>
static constexpr T truncatedUnit(U v, long double mul = 1.) {
    return (T)(v.v * mul);
}
 
template <typename AU, typename U>
static constexpr typename AU::type_t unitToSteps(U v) {
    return unitToAxisUnit<AU>(v).v;
}
 
// Pulley
typedef AxisUnit<pos_t, Pulley, Lenght> P_pos_t; 
typedef AxisUnit<steps_t, Pulley, Speed> P_speed_t; 
typedef AxisUnit<steps_t, Pulley, Accel> P_accel_t; 
 
static constexpr P_pos_t operator"" _P_mm(long double mm) {
    return { unitToAxisUnit<P_pos_t>(config::U_mm { mm }) };
}
 
static constexpr P_speed_t operator"" _P_mm_s(long double mm_s) {
    return { unitToAxisUnit<P_speed_t>(config::U_mm_s { mm_s }) };
}
 
static constexpr P_accel_t operator"" _P_mm_s2(long double mm_s2) {
    return { unitToAxisUnit<P_accel_t>(config::U_mm_s2 { mm_s2 }) };
}
 
// Selector
typedef AxisUnit<pos_t, Selector, Lenght> S_pos_t; 
typedef AxisUnit<steps_t, Selector, Speed> S_speed_t; 
typedef AxisUnit<steps_t, Selector, Accel> S_accel_t; 
 
static constexpr S_pos_t operator"" _S_mm(long double mm) {
    return { unitToAxisUnit<S_pos_t>(config::U_mm { mm }) };
}
 
static constexpr S_speed_t operator"" _S_mm_s(long double mm_s) {
    return { unitToAxisUnit<S_speed_t>(config::U_mm_s { mm_s }) };
}
 
static constexpr S_accel_t operator"" _S_mm_s2(long double mm_s2) {
    return { unitToAxisUnit<S_accel_t>(config::U_mm_s2 { mm_s2 }) };
}
 
// Idler
typedef AxisUnit<pos_t, Idler, Lenght> I_pos_t; 
typedef AxisUnit<steps_t, Idler, Speed> I_speed_t; 
typedef AxisUnit<steps_t, Idler, Accel> I_accel_t; 
 
static constexpr I_pos_t operator"" _I_deg(long double deg) {
    return { unitToAxisUnit<I_pos_t>(config::U_deg { deg }) };
}
 
static constexpr I_speed_t operator"" _I_deg_s(long double deg_s) {
    return { unitToAxisUnit<I_speed_t>(config::U_deg_s { deg_s }) };
}
 
static constexpr I_accel_t operator"" _I_deg_s2(long double deg_s2) {
    return { unitToAxisUnit<I_accel_t>(config::U_deg_s2 { deg_s2 }) };
}
 
} // namespace motion
} // namespace modules
 
// Inject literal operators into the global namespace for convenience
using modules::motion::operator"" _P_mm;
using modules::motion::operator"" _P_mm_s;
using modules::motion::operator"" _P_mm_s2;
using modules::motion::operator"" _S_mm;
using modules::motion::operator"" _S_mm_s;
using modules::motion::operator"" _S_mm_s2;
using modules::motion::operator"" _I_deg;
using modules::motion::operator"" _I_deg_s;
using modules::motion::operator"" _I_deg_s2;