base.hpp

浏览该文件的文档.

 
#pragma once
#include <cstddef>
#include <type_traits>
#include <stdexcept>
 
#include "core/async.hpp"
#include "core/logger.h"
#include "core/multiton.hpp"
#include "device/base.hpp"
#include "utils/controller.hpp"
#include "utils/utils.hpp"
 
namespace roboctrl::device{
 
struct motor_base : public device_base {
protected:
    float angle_ {}; //rad
    float angle_speed_ {}; //rad/s
    float torque_ {}; // Driver-defined raw current counts or torque Nm; see motor-protocols.md.
    float radius_ {}; // m
 
public:
    virtual ~motor_base() = default;
 
    virtual awaitable<void> set(fp32 target) = 0;
    virtual awaitable<void> set_angle_speed(fp32 target) { co_await set(target * radius_); }
    virtual awaitable<void> set_current(fp32) {
        throw std::logic_error("motor does not support direct current control");
        co_return;
    }
    virtual bool supports_current_control() const { return false; }
    virtual bool faulted() const { return false; }
    virtual fp32 requested_current() const { return 0.f; }
    virtual fp32 current_feedback_raw() const { return torque_; }
    virtual fp32 max_current() const { return 0.f; }
    virtual fp32 target_angle_speed() const { return 0.f; }
    virtual void set_output_scale(fp32) {}
    virtual void set_current_limit(fp32) {}
    fp32 radius() const { return radius_; }
    virtual awaitable<void> enable() = 0;
    virtual void disable() {}
    virtual void set_enabled(bool enabled) { if (!enabled) disable(); }
 
    inline fp32 angle() const { return angle_; }
    
    inline fp32 angle_speed() const { return angle_speed_; }
 
    inline fp32 rpm() const { return angle_speed_ * 60.f / (2.f * Pi_f); }
    
    inline fp32 torque() const { return torque_; }
    
    inline fp32 linear_speed() const { return angle_speed_ * radius_; }
    
    inline explicit motor_base(const std::chrono::nanoseconds offline_timeout,fp32 radius) : device_base{offline_timeout},radius_{radius}{}
};
 
template <typename T>
concept motor =
    owner<T> and
    std::derived_from<T, motor_base> and
    requires(T t) {
        { t.set(std::declval<float>()) } -> std::same_as<awaitable<void>>;
        { t.enable() } -> std::same_as<awaitable<void>>;
        { t.task() } -> std::same_as<awaitable<void>>;
    };
 
 
template<motor motor_type,utils::controller controller_type>
requires (std::is_convertible_v<float, typename controller_type::input_type> &&
    std::is_convertible_v<typename controller_type::state_type, float >)
struct controlled_motor{
    using motor_key_type = typename motor_type::info_type::key_type;
 
    controller_type controller;
    motor_key_type name;
 
    struct params_type{
        motor_key_type key;
        typename controller_type::params_type controller_params;
    };
 
    controlled_motor() = default;
 
    controlled_motor(const motor_key_type& name,const typename controller_type::params_type& controller_params):
        name{name},controller{controller_params}{}
    
    awaitable<void> set(float state){
        controller.update(state);
        co_await roboctrl::get<motor_type>(name).set(controller.state());
    }
 
    inline motor_type& motor() const {return roboctrl::get<motor_type>(name); }
 
    inline fp32 angle() const { return motor().angle(); }
 
    inline fp32 angle_speed() const { return motor().angle_speed(); }
 
    inline fp32 torque() const { return motor().torque(); }
 
    inline fp32 linear_speed() const { return motor().linear_speed(); }
};
 
template<motor motor_type>
awaitable<void> set_motor(const typename motor_type::info_type::key_type& key ,fp32 value){
    co_await roboctrl::get<motor_type>(key).set(value);
}
 
} // namespace dev
 
namespace motor {
enum class dir : int {
    forward = 1,
    reverse = -1,
};
 
}