standalone_autotuning.h

Go to the documentation of this file.

#pragma once
 
#ifdef _WIN32
#include <windows.h>
#endif
#ifdef __linux__
#include <sys/types.h>
#endif
 
#include <nlohmann/json.hpp>
#include <string>
 
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_path;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(PlantModelResult, numerators, denominators,
                                   bode_file_path);
 
class GeneratePlantBodeFileResult {
 public:
  std::string bode_file_path;
};
 
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GeneratePlantBodeFileResult, bode_file_path);
 
class StandaloneAutotuning {
 private:
  std::string programPath;
 
  std::string pipeAddress;
#ifdef _WIN32
  HANDLE hPipe;
 
  PROCESS_INFORMATION pi;
#endif
#ifdef __linux__
  pid_t pid;
 
  int sock;
#endif
 
  bool connected;
 
 public:
  static const int BUFFER_SIZE = 4096;
 
  StandaloneAutotuning(const std::string& programPath,
                       const std::string& pipeAddress);
 
  ~StandaloneAutotuning();
 
  bool start();
 
  void stop();
 
  bool connect();
 
  void disconnect();
 
  bool send(const nlohmann::json& jsonObj);
 
  nlohmann::json receive(unsigned int timeoutMilliseconds = 5000);
 
  nlohmann::json exchange(const nlohmann::json& jsonObj,
                          unsigned int timeoutMilliseconds = 5000);
 
  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);
};