fixedWingPilotController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1999-2000 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfobjcore/platformLocalObjectFacade.h"
#include <matrix/LibMatrix.h>
#include "vrfutil/rwAirSpeedType.h"

class DtString;
class DtSimulationServices;
class DtConstrainedAnalogOutputPort;
class DtConstrainedDualAxisAnalogOutputPort;
class DtBooleanOutputPort;
class DtFixedWingEntityStateRepository;
class DtTaskMessage;
class DtFixedWingFlightPSR;
class DtAirspeedCalculator;

const double DtTurningSpeedTol = 0.0556;

const double DtLandingTolerance = 2.5;

#include "vrfmodel/vrfmodelDefines.h"
class DT_DLL_vrfmodel DtFixedWingPilotController : public DtSingleTaskControllerComponent
{

public:

   DtFixedWingPilotController(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtFixedWingPilotController() override;

   virtual bool init() override;

   virtual void tick() override;

   virtual const char* type() const override;

   virtual void clearTask() override;

   virtual void registerAttributeFunctions() override;

   static DtReaderWriter* provideMaxThrustAcceleration(void* controller);


   virtual void taxiTo(const DtVector& destination, double speed);

   virtual void taxi(double speed, double turnRate);

   virtual double calculateSteering(double turnAngle) const;

   virtual double approximateThrottle(double speed);
   
   virtual double calculateCurrentBrakingDistance() const;


   virtual void flyTo(const DtVector& destination, double speed, double maxTerrainAvoidanceLookaheadDist = -1);

   virtual void flyToDirect(const DtVector& destination, double speed, double maxTerrainAvoidanceLookaheadDist = -1);

   virtual void fly(double speed, double turnRate, double climbRate, double maxTerrainAvoidanceLookaheadDist = -1);

   virtual void flyFixedPitch(double speed, double turnRate, double desiredPitch, double maxTerrainAvoidanceLookaheadDist = -1);

   virtual double terrainAvoidancePitch(double speed, double desiredPitch, double maxTerrainAvoidanceLookaheadDist);

   virtual bool clearPathTo(const DtVector& localPosition, bool& dataAvailable, double minAltitude);

   virtual void circle(const DtVector& center, double radius, double speed, 
      double altitude, bool clockwise = true);

   virtual double calcControlForRoll(double rollRate);

   virtual double calcControlForThrottle(double speed, bool& deployFlaps);

   virtual double decelerationLimitedClimbRate(double altitudeError, 
      double desiredSpeed, double finalClimbRate = 0.0);

   virtual void calcControlForTurnAndClimb(double turnRate, double climbRate, 
       double& stickX, double& pedal);

   virtual void calcControlForTurnAndPitch(double turnRate, double desiredPitch, 
      double& stickX, double& pedal, double rollRate = 0.0);

   virtual double calculateClimbRate(double altitude, double climbTime) const;

   // turn rate = (heading change / max-turnrate-cutoff-angle) *
   //    max-pitch-rate
   virtual double calculateTurnRate(double turnAngle, double additionalTurnRate = 0) const;

   // roll angle = ATAN((speed * turn rate * 0.5)  /  9.8)
   virtual double calculateRollAngle(double turnRate, double speed)
       const;

   virtual double calculateRollRate(double rollAngle, double turnRate);


   virtual void calculateNormalizedBodyVelocity();

   virtual void calculateLocalAngularVelocity();

   //     mySpeedRatioSquared
   virtual void calculateSpeedRatioSquared();

   virtual void initializeControllerForTick();

   virtual bool createFixedWingControlPortGroup();
   virtual bool createThrottlePort();
   virtual bool createStickPort();
   virtual bool createPedalPort();
   virtual bool createBrakePort();

   virtual bool createFlapsDeployedPort();

   virtual DtConstrainedAnalogOutputPort* throttlePort();
   virtual DtConstrainedDualAxisAnalogOutputPort*  stickPort();
   virtual DtConstrainedAnalogOutputPort* pedalPort();
   virtual DtConstrainedAnalogOutputPort* brakePort();
   virtual DtBooleanOutputPort* flapsDeployedPort();

   virtual void setMaxThrustAcceleration(double maxThrustAcceleration);

   virtual void setTakeOffDir(const DtVector& takeOffDir);
   virtual const DtVector& takeOffDir() const;

   virtual DtReal maxTurningGsForTask() const;
   virtual DtReal maxTurnRateCutoffAngle() const;
   virtual DtReal maxTaxiingTurnSpeed() const;
   virtual DtReal taxiingNearDistance() const;
   virtual DtReal taxiingAtDistance() const;
   virtual DtReal taxiingApproachSpeed() const;
   virtual DtReal maxPitchAngle() const;
   virtual DtReal timeToTargetAltitude() const;

   virtual double maxTurningGs() const;

   virtual bool terrainAvoidanceEnabled() const;
   virtual double terrainAvoidanceLookaheadTime();

   static DtSimComponent * creator(const DtString& name, 
      DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

protected:
   virtual DtReaderWriter* processProvideMaxThrustAcceleration();

   virtual bool createPorts() override;

   virtual bool createPortGroups() override;

   virtual void lookupAndCacheProcessSR();

   virtual bool postAddComponentsInit() override;

   virtual bool decideToGiveUpTask() const override;

   virtual void updateCurrentState();

   virtual void processEstimatedTotCalculation();

   virtual double calculateCollisionLookAhead(const double climbRate,
      const double speed,
      const double desiredAltitude);

   virtual void updateTaskVisualizations() override;

   virtual double convertSpeedtoGroundSpeed(double speed, double currentAlt, DtAirSpeedType speedType);

protected:
   
   DtFixedWingPilotController();

   DtFixedWingPilotController(const DtFixedWingPilotController & 
      orig);

   const DtFixedWingPilotController & operator=(const 
      DtFixedWingPilotController & orig);

protected:

   DtFixedWingEntityStateRepository* myFixedWingEntityState;


   DtOutputPortGroup* myFixedWingControlPortGroup;
   
   DtConstrainedAnalogOutputPort* myThrottlePort;
   
   DtConstrainedDualAxisAnalogOutputPort* myStickPort;
   
   DtConstrainedAnalogOutputPort* myPedalPort;
   
   DtConstrainedAnalogOutputPort* myBrakePort;
   
   DtBooleanOutputPort* myFlapsDeployedPort;
   

   DtFixedWingFlightPSR*              myProcessState;

   DtAirspeedCalculator* myAirSpeedCalculator;

   DtVector myCurrentLocalPosition;
   DtVector myCurrentLocalVelocity;
   double myCurrentSpeed;
   DtDcm myCurrentOrientationMatrix;
   double myCurrentHeading;
   double myCurrentTopoPitch;
   double myCurrentTopoRoll;
   DtDcm myLocalToTopoDcm;

   const double DtEstimatedTotCalcInterval = 5.0;

   bool myEstimatedTotCalcEnabled;
   double myEstimatedTotValue;
   double myEstimatedTotLastCalcTime;
   DtVector myEstimatedTotTextPos;
   DtPlatformLocalObjectFacade myPlatformLocalObjectFacade;
};