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 <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_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);
};