base.hpp

浏览该文件的文档.

 
#pragma once
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
#include "core/async.hpp"
#include "core/logger.h"
#include "core/multiton.hpp"
#include "device/base.hpp"
#include "utils/controller.hpp"
#include "utils/utils.hpp"
#include "io/base.hpp"
 
namespace roboctrl::device{
 
namespace details{
 
    //通用电机测量数据。
struct motor_measure{
    uint16_t ecd = 0;
    int16_t speed_rpm = 0;
    int16_t given_current = 0;
    uint8_t temperate = 0;
};
 
struct motor_upload_pkg {
    uint8_t angle_h     : 1;
    uint8_t angle_l     : 1;
    uint8_t speed_h     : 1;
    uint8_t speed_l     : 1;
    uint8_t current_h   : 1;
    uint8_t current_l   : 1;
    uint8_t temperature : 1;
    uint8_t unused      : 1;
} __attribute__((packed));
 
inline motor_measure parse_motor_upload_pkg(io::byte_span data)
{
    motor_upload_pkg pkg = utils::from_bytes<motor_upload_pkg>(data);
    return {
        .ecd = utils::make_u16(pkg.angle_h, pkg.angle_l),
        .speed_rpm = utils::make_i16(pkg.speed_h, pkg.speed_l),
        .given_current = utils::make_i16(pkg.current_h, pkg.current_l),
        .temperate = static_cast<uint8_t>(pkg.temperature)
    };
}
 
}
 
struct motor_base : public device_base {
protected:
    float angle_ {}; //rad
    float angle_speed_ {}; //rad/s
    float torque_ {}; // A
    float radius_ {}; // m
 
public:
    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,
};
 
}