shoot.h

浏览该文件的文档.

 
#pragma once
#include "utils/ramp.hpp"
#include "utils/singleton.hpp"
#include "core/async.hpp"
#include "core/logger.h"
#include "device/motor/base.hpp"
#include <chrono>
#include <string>
 
namespace roboctrl::ctrl{
using namespace std::chrono_literals;
 
class shoot : public utils::singleton_base<shoot>,public logable<shoot> {
public:
    shoot() = default;
    struct info_type{
        using owner_type = shoot;
 
        utils::ramp_f::params_type friction_params;
        float friction_max_speed {};
        float trigger_speed {}; // Output shaft rad/s, matching legacy trigger PID feedback.
        float friction_ready_speed {1.5f};
        float jam_current {4000.0f};
        float jam_speed {1.0f};
        std::chrono::steady_clock::duration jam_release_time {50ms};
        std::chrono::steady_clock::duration control_time {1ms};
        std::string left_friction_motor {"left_friction"};
        std::string right_friction_motor {"right_friction"};
        std::string trigger_motor {"trigger"};
        bool enforce_referee {false};
        unsigned int bullet_caliber {17}; // 17 mm normally, 42 mm Hero.
    };
 
    inline std::string desc()const{return "shoot";}
 
    roboctrl::awaitable<void> task();
 
    bool init(const info_type& info);
    bool init(const info_type& info, device::motor_base& left,
        device::motor_base& right, device::motor_base& trigger);
    void start();
    roboctrl::awaitable<void> update(fp32 dt);
    void set_enabled(bool enabled);
    void set_fire_permitted(bool permitted) { fire_permitted_ = permitted; }
    [[nodiscard]] bool fire_allowed() const;
 
    void set_firing(bool state);
    inline bool firing()const{return firing_;}
    void set_friction_enabled(bool state);
    inline bool friction_enabled() const{return friction_enabled_;}
    [[nodiscard]] bool friction_ready() const;
 
private:
    info_type info_;
    utils::ramp_f friction_ramp_;
 
    bool enabled_ {false};
    bool fire_permitted_ {false};
    bool initialized_ {false};
    bool started_ {false};
    bool firing_ {false};
    bool friction_enabled_ {false};
    std::chrono::steady_clock::time_point jam_release_at_ {};
    device::motor_base* left_friction_motor_ {nullptr};
    device::motor_base* right_friction_motor_ {nullptr};
    device::motor_base* trigger_motor_ {nullptr};
 
};
 
static_assert(utils::singleton<shoot>);
}