controller.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <functional>
#include <string>
 
#include "controller_input.hpp"
#include "controller_io.hpp"
#include "vendor/dylib/dylib.hpp"
 
namespace kynema_fmb::interfaces::components {
 
class Controller {
public:
    explicit Controller(const ControllerInput& input);
 
    void CallController();
 
    [[nodiscard]] double PitchAngleCommand() const { return this->pitch_angle_command_; }
 
    [[nodiscard]] std::array<double, 3> PitchAngleCommandIndividual() const {
        return {
            this->io.pitch_blade1_command, this->io.pitch_blade2_command,
            this->io.pitch_blade3_command
        };
    }
 
    [[nodiscard]] double GeneratorTorqueCommand() const { return this->generator_torque_command_; }
 
    [[nodiscard]] double YawAngleCommand() const { return this->yaw_angle_command_; }
 
    void SetStatusInit() { this->io.status = 0; }
 
    void SetStatusOperating() { this->io.status = 1; }
 
    void SetStatusWriteCheckpoint() { this->io.status = -8; }
 
    void SetStatusReadCheckpoint() { this->io.status = -9; }
 
    void SetSimulationTime(double simulation_time) { this->io.time = simulation_time; }
 
    void SetSimulationTimeStep(double simulation_time_step) { this->io.dt = simulation_time_step; }
 
    void SetYawAngle(double yaw_angle) { this->io.yaw_angle_actual = yaw_angle; }
 
    void SetRotorSpeed(double rotor_speed) { this->io.rotor_speed_actual = rotor_speed; }
 
    void SetGeneratorSpeed(double generator_speed) {
        this->io.generator_speed_actual = generator_speed;
    }
 
    void SetGeneratorTorque(double generator_torque) {
        this->io.generator_torque_actual = generator_torque;
    }
 
    void SetGeneratorPower(double generator_power) {
        this->io.generator_power_actual = generator_power;
    }
 
    void SetWindSpeed(double wind_speed) { this->io.horizontal_wind_speed = wind_speed; }
 
    void SetRotorAzimuth(double rotor_azimuth) { this->io.azimuth_angle = rotor_azimuth; }
 
    void SetBladePitch(double blade_pitch_collective) {
        this->io.pitch_blade1_actual = blade_pitch_collective;
        this->io.pitch_blade2_actual = blade_pitch_collective;
        this->io.pitch_blade3_actual = blade_pitch_collective;
    }
 
    void SetBladePitch(std::array<double, 3> blade_pitch) {
        this->io.pitch_blade1_actual = blade_pitch[0];
        this->io.pitch_blade2_actual = blade_pitch[1];
        this->io.pitch_blade3_actual = blade_pitch[2];
    }
 
    void SetOutOfPlaneRootBendingMoment(std::array<double, 3> root_moment) {
        this->io.out_of_plane_root_bending_moment_blade1 = root_moment[0];
        this->io.out_of_plane_root_bending_moment_blade2 = root_moment[1];
        this->io.out_of_plane_root_bending_moment_blade3 = root_moment[2];
    }
 
private:
    ControllerIO io;
 
    bool pitch_control_enabled_{false};   //< Flag to enable pitch control
    bool torque_control_enabled_{false};  //< Flag to enable torque control
    bool yaw_control_enabled_{false};     //< Flag to enable yaw control
 
    double generator_torque_command_{0.0};  //< Commanded torque (Nm)
    double pitch_angle_command_{0.0};       //< Commanded pitch angle (rad)
    double yaw_angle_command_{0.0};  //< Commanded yaw angle (rad) integrated from yaw rate command
 
    std::string input_file_path_;           //< Path to the input file
    std::string output_file_path_;          //< Path to the output file
    std::string shared_lib_path_;           //< Path to shared library
    std::string controller_function_name_;  //< Name of the controller function in the shared library
 
    util::dylib lib_;  //< Handle to the shared library
    std::function<void(float*, int*, const char* const, const char* const, char* const)>
        controller_function_;  //< Function pointer to the controller function
};
 
}  // namespace kynema_fmb::interfaces::components