standalone_autotuning.h

Go to the documentation of this file.

#pragma once
 
#ifdef _WIN32
// <windows.h> pulls in the original WinSock.h unless this is defined first,
// which then collides with the WinSock2.h that Boost.Asio needs: including this
// header before Boost.Asio in the same translation unit fails to compile with
// "WinSock.h has already been included". The library target defines the macro
// as well, for a consumer that reaches <windows.h> by some other route first.
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#endif
#ifdef __linux__
#include <sys/types.h>
#endif
 
#include <cstdint>
#include <string>
#include <vector>
 
#include <nlohmann/json.hpp>

class StandaloneAutotuningError {
 public:
  std::string message;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(StandaloneAutotuningError, message)
 

class PIDGains {
 public:
  double kp;

  double ki;

  double kd;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(PIDGains, kp, ki, kd)
 

class ControllerGains {
 public:
  PIDGains position;

  PIDGains velocity;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(ControllerGains, position, velocity)
 

class AutoTuningGainsResult {
 public:
  ControllerGains gains;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(AutoTuningGainsResult, gains)
 

class VelocityAutoTuningState {
 public:
  double gm;

  double pm;

  double msens;

  double act_bw;

  double vel_cl;

  double noise_resp;

  double max_KS;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(VelocityAutoTuningState, gm, pm, msens,
                                   act_bw, vel_cl, noise_resp, max_KS)
 

class PositionAutoTuningState {
 public:
  double gm_p;

  double pm_p;

  double msens_p;

  double gm_v;

  double pm_v;

  double msens_v;

  double noise_resp;

  double max_KS;

  double bw_p;

  double bw_v;

  double act_st;

  double pos_cl;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(PositionAutoTuningState, gm_p, pm_p, msens_p,
                                   gm_v, pm_v, msens_v, noise_resp, max_KS,
                                   bw_p, bw_v, act_st, pos_cl)
 

class FullVelocityAutoTuningResult {
 public:
  ControllerGains gains;

  double demanded_bw;

  double demanded_zeta;

  VelocityAutoTuningState state;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(FullVelocityAutoTuningResult, gains,
                                   demanded_bw, demanded_zeta, state)
 

class FullPositionAutoTuningResult {
 public:
  ControllerGains gains;

  double demanded_st;

  double demanded_zeta;

  PositionAutoTuningState state;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(FullPositionAutoTuningResult, gains,
                                   demanded_st, demanded_zeta, state)
 

class PlantModelResult {
 public:
  std::vector<double> numerators;

  std::vector<double> denominators;

  std::string bode_file_content;
};

class GeneratePlantBodeFileResult {
 public:
  std::string bode_file_content;
};

class StandaloneAutotuning {
 private:
  std::string programPath;

  std::string host;

  uint16_t port;
 
#ifdef _WIN32
  PROCESS_INFORMATION pi;
#endif
#ifdef __linux__
  pid_t pid;
#endif

  nlohmann::json request(const std::string& method, const std::string& target,
                         const std::string& body,
                         unsigned int timeoutMilliseconds);

  bool isProcessRunning();
 
 public:
  static constexpr uint16_t kDefaultPort = 63528;

  static constexpr unsigned int kRequestTimeoutMilliseconds = 120000;

  static constexpr unsigned int kFitRequestTimeoutMilliseconds = 900000;

  static constexpr unsigned int kHealthTimeoutMilliseconds = 1000;

  static constexpr unsigned int kReadyTimeoutMilliseconds = 30000;

  explicit StandaloneAutotuning(const std::string& programPath,
                                const std::string& host = "127.0.0.1");

  ~StandaloneAutotuning();

  bool start(uint16_t port = kDefaultPort);

  void stop();

  bool isHealthy(unsigned int timeoutMilliseconds = kHealthTimeoutMilliseconds);

  nlohmann::json exchange(
      const nlohmann::json& jsonObj,
      unsigned int timeoutMilliseconds = kRequestTimeoutMilliseconds);

  ControllerGains auto_tune_velocity_controller(const nlohmann::json& data);

  ControllerGains auto_tune_position_controller(const nlohmann::json& data);

  FullVelocityAutoTuningResult full_auto_tune_velocity_controller(
      const nlohmann::json& data);

  FullPositionAutoTuningResult full_auto_tune_position_controller(
      const nlohmann::json& data);

  ControllerGains compute_position_controller_gains(const nlohmann::json& data);

  PlantModelResult identify_plant_model(const nlohmann::json& data);

  GeneratePlantBodeFileResult generate_plant_bode_file(
      const nlohmann::json& data);
};