control_logic.h

Go to the documentation of this file.

 
#pragma once
 
#include "aim_policy.h"
#include "button_classifier.h"
#include "calibration_session.h"
#include "control_status.h"
#include "remote_inbox.h"
#include "system_control_types.h"
#include "track_snapshot.h"
 
#include <cstdint>
#include <optional>
 
namespace control
{
constexpr uint32_t kJogPeriodMs = 40;
 
constexpr uint32_t kHudRecordTimeoutMs = 1000;
 
struct StickDeflection {
    int x = 0;
    int y = 0;
};
 
struct HudRequests {
    std::optional<remote::RemoteMode> mode;
    std::optional<remote::CalAction> cal;
    std::optional<remote::AimPixel> aim;
};
 
enum class LogEvent : uint8_t {
    ModeChanged,       
    CalStarted,        
    CalCancelled,      
    CalSaveFailed,     
    CalComplete,       
    CalFailed,         
    CalRestarted,      
    CalMiss,           
    CalPointRecorded,  
    HudPoseTimeout,    
    PressPoseFallback, 
};
 
struct LogRecord {
    LogEvent event = LogEvent::ModeChanged;
    ControlMode mode = ControlMode::Ai;
    int points = 0;
    const char* failure = nullptr;
};
 
class ControlPorts
{
public:
    virtual ~ControlPorts() = default;
 
    virtual StickDeflection read_stick() noexcept = 0;
 
    virtual remote::Jog read_hud_jog() noexcept = 0;
 
    virtual HudRequests take_hud_requests() noexcept = 0;
 
    virtual TrackSnapshot read_track() noexcept = 0;
 
    virtual aiming::Angles turret_pose() noexcept = 0;
 
    virtual float turret_pan_speed() noexcept = 0;
 
    virtual void turret_jog(float pan, float tilt) noexcept = 0;
 
    virtual void turret_set_target(const aiming::Angles& target) noexcept = 0;
 
    virtual void turret_home() noexcept = 0;
 
    virtual void reset_detection() noexcept = 0;
 
    virtual bool save_calibration(const aiming::AimMap& map) noexcept = 0;
 
    virtual void log(const LogRecord& record) noexcept = 0;
};
 
class ControlLogic
{
public:
    explicit ControlLogic(ControlPorts& io) : io_(io), policy_(aiming::default_map()) {}
 
    void load_calibration(const aiming::AimMap& map);
 
    void run(uint32_t now_ms, bool held);
 
    ControlStatus status(uint32_t now_ms, const aiming::Angles& pose, remote::JogSpeed speed) const;
 
    ControlMode mode() const { return mode_; }
 
private:
    void jog_from_inputs(uint32_t now_ms, bool force_stop);
    void stop_jog();
    void set_mode(ControlMode mode);
    void enter_calibration();
    void cancel_calibration();
    void record_cal_point(const aiming::Angles& pose);
    void apply_cal_request(remote::CalAction action, uint32_t now_ms);
    void service_hud_record(uint32_t now_ms);
    void on_long_press();
    void on_short_press();
 
    ControlPorts& io_;
    aiming::ButtonClassifier button_;
    aiming::AimPolicy policy_;
    aiming::CalibrationSession session_;
    ControlMode mode_ = ControlMode::Ai;
    ControlMode mode_before_cal_ = ControlMode::Ai; 
    bool calibrated_ = false;                       
    uint32_t cal_saves_ = 0;                        
    uint32_t cal_miss_ = 0;                         
    bool hud_record_pending_ = false;               
    uint32_t hud_record_since_ms_ = 0;              
    bool aim_hold_ = false;  
    bool stick_ = false;     
    uint32_t aims_ = 0;      
    bool prev_held_ = false; 
    aiming::Angles cal_pose_at_press_; 
    bool cal_pose_captured_ = false;   
    uint32_t last_jog_ms_ = 0;         
};
} // namespace control