Odrive内部存在一些非常好的设计，为了通篇掌握Odrive的设计理念和算法，对项目中采用的设计模式，数据结构和算法必须了解，本文梳理下Odrive中涉及到的一些重要的数据结构。

1. ComponentBase

所有支持update回调的类基类,支持传入一个时间戳用于实时更新对象内部状态。

class ComponentBase {
public:
    virtual void update(uint32_t timestamp) = 0;
};

子类有:

开环控制器类：OpenLoopController

FOC控制器类：FieldOrientedController

2. InputPort和OutputPort模板类

这两个类非常重要，是Odrive为了解耦各对象之间交互的桥梁，可以简化理解为两个对象之间通讯的中间件(只是类比)，有了这个设计，模块可以很方便的连接外部输入源，还能管理输入源的生命周期。

template<typename T>
class OutputPort {
public:
    OutputPort(T val) : content_(val) {}
    void operator=(T value) {
        //关联数据
        content_ = value;
        age_ = 0;
    }
    void reset() {
        //强制让数据过期
        age_++;
    }
    std::optional<T> present() {
        //正值"壮年",数据是刚刚更新有效
        if (age_ == 0) {
            return content_;
        } else {
            return std::nullopt;
        }
    }
    std::optional<T> previous() {
        //上一个周期的数据
        if (age_ == 1) {
            return content_;
        } else {
            return std::nullopt;
        }
    }
    std::optional<T> any() {
        return content_;
    }
    
private:
    uint32_t age_ = 2; 
    T content_;
};

template<typename T>
class InputPort {
public:
    //将输入关联到特定的输入源--模板包装
    void connect_to(OutputPort<T>* input_port) {
        content_ = input_port;
    }
    //将输入关联到特定的输入源-原始指针
    void connect_to(T* input_ptr) {
        content_ = input_ptr;
    }
    //断开数据源
    void disconnect() {
        content_ = (OutputPort<T>*)nullptr;
    }
    //更新数据,实际上是获取的输入源数据
    std::optional<T> present() {
        if (content_.index() == 2) {
            OutputPort<T>* ptr = std::get<2>(content_);
            return ptr ? ptr->present() : std::nullopt;
        } else if (content_.index() == 1) {
            T* ptr = std::get<1>(content_);
            return ptr ? std::make_optional(*ptr) : std::nullopt;
        } else {
            return std::get<0>(content_);
        }
    }
    
    std::optional<T> any() {
        if (content_.index() == 2) {
            OutputPort<T>* ptr = std::get<2>(content_);
            return ptr ? ptr->any() : std::nullopt;
        } else if (content_.index() == 1) {
            T* ptr = std::get<1>(content_);
            return ptr ? std::make_optional(*ptr) : std::nullopt;
        } else {
            return std::get<0>(content_);
        }
    }
    
private:
    std::variant<T, T*, OutputPort<T>*> content_;
};

这两个类在很对地方都有用到，比如下面的代码就是把FOC控制的输入源关联到开关控制器的输出中：

axis_->motor_.current_control_.enable_current_control_src_ = (axis_->motor_.config_.motor_type != Motor::MOTOR_TYPE_GIMBAL);
axis_>motor_.current_control_.Idq_setpoint_src_.connect_to(&axis_>open_loop_controller_.Idq_setpoint_);
axis_->motor_.current_control_.Vdq_setpoint_src_.connect_to(&axis_->open_loop_controller_.Vdq_setpoint_);
     
axis_->motor_.current_control_.phase_src_.connect_to(&axis_->open_loop_controller_.phase_);
axis_->acim_estimator_.rotor_phase_src_.connect_to(&axis_->open_loop_controller_.phase_);

axis_->motor_.phase_vel_src_.connect_to(&axis_->open_loop_controller_.phase_vel_);
axis_->motor_.current_control_.phase_vel_src_.connect_to(&axis_->open_loop_controller_.phase_vel_);
axis_->acim_estimator_.rotor_phase_vel_src_.connect_to(&axis_->open_loop_controller_.phase_vel_);

再比如下面代码将编码器的输出关联到控制器的相关输入上

controller_.pos_estimate_circular_src_.connect_to(&ax->encoder_.pos_circular_);
controller_.pos_estimate_linear_src_.connect_to(&ax->encoder_.pos_estimate_);
controller_.vel_estimate_src_.connect_to(&ax->encoder_.vel_estimate_);

3. Timer类，用于做相关计时

template <class T>
class Timer {
   public:
    void setTimeout(const T timeout) {
        timeout_ = timeout;
    }

    void setIncrement(const T increment) {
        increment_ = increment;
    }

    void start() {
        running_ = true;
    }

    void stop() {
        running_ = false;
    }

    // If the timer is started, increment the timer
    void update() {
        if (running_)
            timer_ = std::min<T>(timer_ + increment_, timeout_);
    }

    void reset() {
        timer_ = static_cast<T>(0);
    }

    bool expired() {
        return timer_ >= timeout_;
    }

   private:
    T timer_ = static_cast<T>(0);     // Current state
    T timeout_ = static_cast<T>(0);   // Time to count
    T increment_ = static_cast<T>(0);  // Amount to increment each time update() is called
    bool running_ = false;            // update() only increments if runing_ is true
};

这个类配合下面的类和宏可以测量任意代码块的执行时间：

struct TaskTimerContext {
    TaskTimerContext(const TaskTimerContext&) = delete;
    TaskTimerContext(const TaskTimerContext&&) = delete;
    void operator=(const TaskTimerContext&) = delete;
    void operator=(const TaskTimerContext&&) = delete;
    TaskTimerContext(TaskTimer& timer) : timer_(timer), start_time(timer.start()) {}
    ~TaskTimerContext() { timer_.stop(start_time); }
    
    TaskTimer& timer_;
    uint32_t start_time;
    bool exit_ = false;
};

#define MEASURE_TIME(timer) for (TaskTimerContext __task_timer_ctx{timer}; !__task_timer_ctx.exit_; __task_timer_ctx.exit_ = true)

比如下面的代码就是测量热敏电阻算法更新的耗时：

MEASURE_TIME(axis.task_times_.thermistor_update) {
    axis.motor_.fet_thermistor_.update();
    axis.motor_.motor_thermistor_.update();
}

4. Endpoint。用于对输入信号的极性检测进行封装

该类处理GPIO的输入状态进行拦截，同时考虑抖动的处理。

class Endstop {
   public:
    struct Config_t {
        float offset = 0;
        uint32_t debounce_ms = 50;
        uint16_t gpio_num = 0;
        bool enabled = false;
        bool is_active_high = false;

        // custom setters
        Endstop* parent = nullptr;
        void set_gpio_num(uint16_t value) { gpio_num = value; parent->apply_config(); }
        void set_enabled(uint32_t value) { enabled = value; parent->apply_config(); }
        void set_debounce_ms(uint32_t value) { debounce_ms = value; parent->apply_config(); }
    };


    Endstop::Config_t config_;
    Axis* axis_ = nullptr;

    bool apply_config();

    void update();
    constexpr bool get_state(){
        return endstop_state_;
    }

    constexpr bool rose(){
        return (endstop_state_ != last_state_) && endstop_state_;
    }

    constexpr bool fell(){
        return (endstop_state_ != last_state_) && !endstop_state_;
    }

    bool endstop_state_ = false;

   private:
    bool last_state_ = false;
    bool pin_state_ = false;
    float pos_when_pressed_ = 0.0f;
    Timer<float> debounceTimer_;
};