plant_identification.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstdint>
#include <expected>
#include <functional>
#include <nlohmann/json.hpp>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include "node/somanet_drive.h"
 
 
namespace mm::node {
 
struct PlantMeasurement {
  std::vector<double> torquesNm;               
  std::vector<double> velocitiesRadPerSecond;  
};
 
struct PlantModelFit {
  std::vector<double> numerator;    
  std::vector<double> denominator;  
  nlohmann::json bode;
};
 
using PlantModelFitFn = std::function<std::expected<PlantModelFit, std::string>(
    const PlantMeasurement& measurement, double startFrequencyHz, double endFrequencyHz)>;
 
inline constexpr std::string_view kPlantModelFile = "plant_model.csv";
 
inline constexpr std::chrono::milliseconds kChirpPaddingMs{200};
 
inline constexpr double kMinMeanAbsTorquePermil = 10.0;
 
inline constexpr double kMinMeanAbsVelocityRadPerSecond = 0.5;
 
inline constexpr double kLowMeanAbsVelocityRadPerSecond = 6.0;
 
struct PlantModelChirp {
  double startFrequencyHz = 0.0;  
  double endFrequencyHz = 0.0;    
  uint32_t amplitudePermil = 0;   
  uint32_t durationMs = 0;        
  somanet::ChirpSignalType signalType{somanet::ChirpSignalType::kLogarithmic};
};
void to_json(nlohmann::json& j, const PlantModelChirp& chirp);
 
struct PlantModel {
  std::vector<double> numerator;    
  std::vector<double> denominator;  
  PlantModelChirp chirp;            
 
  std::optional<double> inertia() const;
 
  std::optional<double> friction() const;
};
void to_json(nlohmann::json& j, const PlantModel& model);
 
std::expected<std::chrono::milliseconds, std::string> plantIdentificationStreamDuration(
    std::chrono::milliseconds transitionTime);
 
PlantMeasurement convertPlantMeasurement(std::span<const HrdSystemIdentificationSample> samples,
                                         uint32_t ratedTorqueMilliNm);
 
std::expected<std::optional<std::string>, std::string> checkPlantMeasurementAmplitudes(
    const PlantMeasurement& measurement, uint32_t ratedTorqueMilliNm);
 
bool isStablePlantModel(std::span<const double> denominator);
 
std::string plantModelCsv(const PlantModel& model);
 
std::expected<PlantModel, std::string> parsePlantModelCsv(std::string_view text);
 
}  // namespace mm::node