vreRotaryWingActuatorDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreRotaryWingActuatorDescriptor.h
//! \ingroup vreVrfobjparam
//! \brief Rotary wing actuator descriptor for VREngage
//!
//! This file defines the DtVreRotaryWingActuatorDescriptor class, which configures
//! rotary wing actuator components in VREngage. It extends the base rotary wing actuator
//! descriptor to add stability control, PID parameters, and other helicopter-specific settings.
 
#pragma once
 
#include <vreVrfobjparam/export.h>
 
#include <vrfobjparam/rotaryWingActuatorDescriptor.h>
 
#include <readerWriter/rwInt.h>
 
namespace makVre
{
//! \brief Type identifier string for the rotary wing actuator descriptor
const char DtVreRotaryWingActuatorDescriptorType[] = "vre-rotary-wing-actuator-descriptor";
 
//! \brief Rotary wing actuator descriptor for VREngage
//!
//! This class extends the base rotary wing actuator descriptor to add configuration for
//! stability control, PID parameters, crash behavior, and collective control settings.
//! It provides detailed controls for helicopter flight dynamics and handling characteristics
//! in VREngage simulations.
class VREVRFOBJPARAM_DLL DtVreRotaryWingActuatorDescriptor : public DtRotaryWingActuatorDescriptor
{
public:
   //! \brief Constructor with component name
   //! \param name The name of this component
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new rotary wing actuator descriptor with the specified name.
   DtVreRotaryWingActuatorDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig The source descriptor to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new rotary wing actuator descriptor as a copy of the provided original.
   DtVreRotaryWingActuatorDescriptor(
      const DtVreRotaryWingActuatorDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Assignment operator
   //! \param orig The source descriptor to copy from
   //! \return Reference to this descriptor after assignment
   //!
   //! Assigns the contents of the provided descriptor to this one.
   DtVreRotaryWingActuatorDescriptor& operator=(const DtVreRotaryWingActuatorDescriptor& orig);
 
   //! \brief Creates a clone of this descriptor
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //! \return Pointer to a new descriptor that is a clone of this one
   //!
   //! Creates a new rotary wing actuator descriptor as a deep copy of this one.
   virtual DtComponentDescriptor* clone(DtReaderWriterRegistry* parentRegistry = 0) const override;
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the descriptor.
   virtual ~DtVreRotaryWingActuatorDescriptor() override;
 
   //! \brief Gets the type identifier for this descriptor
   //! \return String identifying this descriptor type
   //!
   //! Returns a unique type identifier string for this descriptor type.
   //! Will return DtVreRotaryWingActuatorDescriptorType.
   virtual DtString type() const override;
 
   //! \brief Gets the stability augmentation mode
   //! \return The stability augmentation mode value
   //!
   //! Returns the current stability augmentation mode for the rotary wing aircraft.
   //! Different modes provide different levels of automated stability assistance.
   virtual int stabilityAugmentationMode() const;
 
   //! \brief Sets the stability augmentation mode
   //! \param value The stability augmentation mode value
   //!
   //! Sets the stability augmentation mode for the rotary wing aircraft.
   //! Different modes provide different levels of automated stability assistance.
   virtual void setStabilityAugmentationMode(int value);
 
   //! \brief Checks if vertical hold is enabled in stability augmentation
   //! \return True if vertical hold is enabled, false otherwise
   //!
   //! Returns whether the vertical hold feature is enabled in stability augmentation.
   //! When enabled, the aircraft will attempt to maintain a constant altitude.
   virtual bool stabilityAugmentationVerticalHold() const;
 
   //! \brief Sets if vertical hold is enabled in stability augmentation
   //! \param value True to enable vertical hold, false to disable
   //!
   //! Sets whether the vertical hold feature is enabled in stability augmentation.
   //! When enabled, the aircraft will attempt to maintain a constant altitude.
   virtual void setStabilityAugmentationVerticalHold(bool value);
 
   //! \brief Checks if detonation on crash is enabled
   //! \return True if detonation on crash is enabled, false otherwise
   //!
   //! Returns whether the aircraft will detonate when it crashes.
   virtual double detonateOnCrash() const { return myDetonateOnCrash; };
 
   //! \brief Sets if detonation on crash is enabled
   //! \param val True to enable detonation on crash, false to disable
   //!
   //! Sets whether the aircraft will detonate when it crashes.
   virtual void setDetonateOnCrash(double val) { myDetonateOnCrash = val; };
 
   //! \brief Gets the proportional gain for the PID controller
   //! \return The proportional gain value
   //!
   //! Returns the proportional gain value used in the PID controller for flight stability.
   virtual double pGain() const { return myPGain; };
 
   //! \brief Sets the proportional gain for the PID controller
   //! \param val The proportional gain value
   //!
   //! Sets the proportional gain value used in the PID controller for flight stability.
   virtual void setPGain(double val) { myPGain = val; };
 
   //! \brief Gets the integral gain for the PID controller
   //! \return The integral gain value
   //!
   //! Returns the integral gain value used in the PID controller for flight stability.
   virtual double iGain() const { return myIGain; };
 
   //! \brief Sets the integral gain for the PID controller
   //! \param val The integral gain value
   //!
   //! Sets the integral gain value used in the PID controller for flight stability.
   virtual void setIGain(double val) { myIGain = val; };
 
   //! \brief Gets the derivative gain for the PID controller
   //! \return The derivative gain value
   //!
   //! Returns the derivative gain value used in the PID controller for flight stability.
   virtual double dGain() const { return myDGain; };
 
   //! \brief Sets the derivative gain for the PID controller
   //! \param val The derivative gain value
   //!
   //! Sets the derivative gain value used in the PID controller for flight stability.
   virtual void setDGain(double val) { myDGain = val; };
 
   //! \brief Gets the feed-forward gain for the PID controller
   //! \return The feed-forward gain value
   //!
   //! Returns the feed-forward gain value used in the PID controller for flight stability.
   virtual double fGain() const { return myFGain; };
 
   //! \brief Sets the feed-forward gain for the PID controller
   //! \param val The feed-forward gain value
   //!
   //! Sets the feed-forward gain value used in the PID controller for flight stability.
   virtual void setFGain(double val) { myFGain = val; };
 
   //! \brief Gets the PID output filter value
   //! \return The PID output filter value
   //!
   //! Returns the filter value applied to the PID controller output
   //! to smooth the control response.
   virtual double pidOutputFilter() const { return myPidOutputFilter; };
 
   //! \brief Sets the PID output filter value
   //! \param val The PID output filter value
   //!
   //! Sets the filter value applied to the PID controller output
   //! to smooth the control response.
   virtual void setPidOutputFilter(double val) { myPidOutputFilter = val; };
 
   //! \brief Gets the PID output ramp rate
   //! \return The PID output ramp rate value
   //!
   //! Returns the ramp rate applied to the PID controller output
   //! to limit how quickly control outputs can change.
   virtual double pidOutputRampRate() const { return myPidOutputRampRate; };
 
   //! \brief Sets the PID output ramp rate
   //! \param val The PID output ramp rate value
   //!
   //! Sets the ramp rate applied to the PID controller output
   //! to limit how quickly control outputs can change.
   virtual void setPidOutputRampRate(double val) { myPidOutputRampRate = val; };
 
   //! \brief Gets the maximum integral output for the PID controller
   //! \return The maximum integral output value
   //!
   //! Returns the maximum value for the integral term output in the PID controller.
   //! This prevents integral windup by clamping the integral term contribution.
   virtual double pidMaxIOutput() const { return myPidMaxIOutput; };
 
   //! \brief Sets the maximum integral output for the PID controller
   //! \param val The maximum integral output value
   //!
   //! Sets the maximum value for the integral term output in the PID controller.
   //! This prevents integral windup by clamping the integral term contribution.
   virtual void setPidMaxIOutput(double val) { myPidMaxIOutput = val; };
 
   //! \brief Checks if collective control is reversed
   //! \return True if collective control is reversed, false otherwise
   //!
   //! Returns whether the collective control inputs are reversed.
   //! This affects how the helicopter responds to collective stick movements.
   virtual bool reverseCollective() const { return myReverseCollective; };
 
   //! \brief Sets if collective control is reversed
   //! \param val True to reverse collective control, false for normal operation
   //!
   //! Sets whether the collective control inputs are reversed.
   //! This affects how the helicopter responds to collective stick movements.
   virtual void setReverseCollective(bool val) { myReverseCollective = val; };
 
   //! \brief Factory function to create a new instance of this descriptor
   //! \return Pointer to a newly created descriptor
   //!
   //! Static factory function used by the descriptor creation system to instantiate
   //! new instances of this descriptor type.
   static DtComponentDescriptor* creator();
 
protected:
   //! \brief Stability augmentation mode
   //!
   //! Defines the level of automated stability assistance provided to the aircraft.
   //! Different modes provide different levels of control assistance.
   DtRwInt myStabilityAugmentationMode;
 
   //! \brief Vertical hold flag for stability augmentation
   //!
   //! When true, the stability augmentation system will attempt to maintain
   //! a constant altitude during flight.
   DtRwBoolean myStabilityAugmentationVerticalHold;
 
   //! \brief Flag for detonation on crash
   //!
   //! When true, the aircraft will detonate when it crashes.
   DtRwBoolean myDetonateOnCrash;
 
   //! \brief Proportional gain for the PID controller
   //!
   //! The proportional gain value used in the PID controller for flight stability.
   DtRwReal myPGain;
 
   //! \brief Integral gain for the PID controller
   //!
   //! The integral gain value used in the PID controller for flight stability.
   DtRwReal myIGain;
 
   //! \brief Derivative gain for the PID controller
   //!
   //! The derivative gain value used in the PID controller for flight stability.
   DtRwReal myDGain;
 
   //! \brief Feed-forward gain for the PID controller
   //!
   //! The feed-forward gain value used in the PID controller for flight stability.
   DtRwReal myFGain;
 
   //! \brief Filter value for PID controller output
   //!
   //! Filter value applied to the PID controller output to smooth the control response.
   DtRwReal myPidOutputFilter;
 
   //! \brief Ramp rate for PID controller output
   //!
   //! Ramp rate applied to the PID controller output to limit how quickly control outputs can change.
   DtRwReal myPidOutputRampRate;
 
   //! \brief Maximum integral output value for the PID controller
   //!
   //! Maximum value for the integral term output in the PID controller.
   //! This prevents integral windup by clamping the integral term contribution.
   DtRwReal myPidMaxIOutput;
 
   //! \brief Flag for reversing collective control
   //!
   //! When true, the collective control inputs are reversed, affecting
   //! how the helicopter responds to collective stick movements.
   DtRwBoolean myReverseCollective;
};
} // namespace makVre