src/Autopilot/autobrake.cxx

   1 // autobrake.cxx - generic, configurable autobrake system
   2 //
   3 // Written by James Turner, started September 2009.
   4 //
   5 // Copyright (C) 2009  Curtis L. Olson
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 //
  21 // $Id$
  22
  23 #include "autobrake.hxx"
  24
  25 #include <Main/fg_props.hxx>
  26
  27 FGAutoBrake::FGAutoBrake() :
  28   _lastGroundspeedKts(0.0),
  29   _step(0),
  30   _rto(false),
  31   _armed(false),
  32   _rtoArmed(false),
  33   _engaged(false),
  34   _targetDecel(0.0),
  35   _fcsBrakeControl(0.0),
  36   _leftBrakeOutput(0.0),
  37   _rightBrakeOutput(0.0)
  38 {
  39   // default config, close to Boeing 747-400 / 777 values
  40   _configNumSteps = 4;
  41   _configRTOStep = -1;
  42   _configDisengageStep = 0;
  43   _configMaxDecel = 11; // ft-sec-sec
  44   _configRTODecel = 11; // ft-sec-sec
  45   _configRTOSpeed = 85; // kts
  46 }
  47
  48 FGAutoBrake::~FGAutoBrake()
  49 {
  50 }
  51
  52 void FGAutoBrake::init()
  53 {
  54   _root = fgGetNode("/autopilot/autobrake", true);
  55
  56   _root->tie("armed", SGRawValueMethods<FGAutoBrake, bool>
  57     (*this, &FGAutoBrake::getArmed, &FGAutoBrake::setArmed));
  58
  59   _root->tie("step", SGRawValueMethods<FGAutoBrake, int>
  60     (*this, &FGAutoBrake::getStep, &FGAutoBrake::setStep));
  61
  62   _root->tie("rto", SGRawValueMethods<FGAutoBrake, bool>
  63     (*this, &FGAutoBrake::getRTO, &FGAutoBrake::setRTO));
  64
  65   _engineControlsNode = fgGetNode("/controls/engines");
  66
  67   // brake position nodes
  68   _brakeInputs[0] = fgGetNode("/controls/gear/brake-left");
  69   _brakeInputs[1] = fgGetNode("/controls/gear/brake-right");
  70   _brakeInputs[2] = fgGetNode("/controls/gear/copilot-brake-left");
  71   _brakeInputs[3] = fgGetNode("/controls/gear/copilot-brake-right");
  72
  73     // config
  74   SGPropertyNode_ptr config = _root->getChild("config", 0, true);
  75   config->tie("num-steps", SGRawValuePointer<int>(&_configNumSteps));
  76   config->tie("rto-step", SGRawValuePointer<int>(&_configRTOStep));
  77   config->tie("disengage-step", SGRawValuePointer<int>(&_configDisengageStep));
  78   config->tie("rto-decel-fts-sec", SGRawValuePointer<double>(&_configRTODecel));
  79   config->tie("max-decel-fts-sec", SGRawValuePointer<double>(&_configMaxDecel));
  80   config->tie("rto-engage-kts", SGRawValuePointer<double>(&_configRTOSpeed));
  81
  82
  83   // outputs
  84   _root->tie("target-decel-fts-sec",
  85     SGRawValueMethods<FGAutoBrake,double>(*this, &FGAutoBrake::getTargetDecel));
  86   _root->tie("actual-decel-fts-sec",
  87     SGRawValueMethods<FGAutoBrake,double>(*this, &FGAutoBrake::getActualDecel));
  88   _root->tie("fcs-brake", SGRawValuePointer<double>(&_fcsBrakeControl));
  89   _root->tie("brake-left-output", SGRawValuePointer<double>(&_leftBrakeOutput));
  90   _root->tie("brake-right-output", SGRawValuePointer<double>(&_rightBrakeOutput));
  91
  92   _root->tie("engaged", SGRawValueMethods<FGAutoBrake, bool>(*this, &FGAutoBrake::getEngaged));
  93 }
  94
  95 void FGAutoBrake::postinit()
  96 {
  97   _weightOnWheelsNode = fgGetNode("/gear/gear/wow");
  98   _groundspeedNode = fgGetNode("/velocities/groundspeed-kt");
  99   _lastWoW = _weightOnWheelsNode->getBoolValue();
 100 }
 101
 102
 103 void FGAutoBrake::bind()
 104 {
 105 }
 106
 107 void FGAutoBrake::unbind()
 108 {
 109 }
 110
 111 void FGAutoBrake::update(double dt)
 112 {
 113   _leftBrakeInput = SGMiscd::max(_brakeInputs[0]->getDoubleValue(),
 114       _brakeInputs[2]->getDoubleValue());
 115   _rightBrakeInput = SGMiscd::max(_brakeInputs[1]->getDoubleValue(),
 116       _brakeInputs[3]->getDoubleValue());
 117
 118   // various FDMs don't supply sufficent information for us to work,
 119   // so just be passive in those cases.
 120   if (!_weightOnWheelsNode || !_groundspeedNode || !_engineControlsNode) {
 121     // pass the values straight through
 122     _leftBrakeOutput = _leftBrakeInput;
 123     _rightBrakeOutput = _rightBrakeInput;
 124     return;
 125   }
 126
 127   if (dt <= 0.0) {
 128     return; // paused
 129   }
 130
 131   double gs = _groundspeedNode->getDoubleValue();
 132   _actualDecel = (_lastGroundspeedKts - gs) / dt;
 133   _lastGroundspeedKts = gs;
 134
 135   if (!_armed || (_step == 0)) {
 136     // even if we're off or disarmed, the physical valve system must pass
 137     // pilot control values through.
 138     _leftBrakeOutput = _leftBrakeInput;
 139     _rightBrakeOutput = _rightBrakeInput;
 140     return;
 141   }
 142
 143   if (_engaged) {
 144     updateEngaged(dt);
 145   } else {
 146     bool e = shouldEngage();
 147     if (e) {
 148       engage();
 149       updateEngaged(dt);
 150     }
 151   }
 152
 153   // sum pilot inpiuts with auto-brake FCS input
 154   _leftBrakeOutput = SGMiscd::max(_leftBrakeInput, _fcsBrakeControl);
 155   _rightBrakeOutput = SGMiscd::max(_rightBrakeInput, _fcsBrakeControl);
 156
 157   _lastWoW = _weightOnWheelsNode->getBoolValue();
 158 }
 159
 160 void FGAutoBrake::engage()
 161 {
 162   SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: engaging");
 163   _engaged = true;
 164 }
 165
 166 void FGAutoBrake::updateEngaged(double dt)
 167 {
 168   // check for pilot braking input cancelling engage
 169   const double BRAKE_INPUT_THRESHOLD = 0.02; // 2% application triggers
 170   if ((_leftBrakeInput > BRAKE_INPUT_THRESHOLD) || (_rightBrakeInput > BRAKE_INPUT_THRESHOLD)) {
 171     SG_LOG(SG_AUTOPILOT, SG_INFO, "auto-brake, detected pilot brake input, disengaing");
 172     disengage();
 173     return;
 174   }
 175
 176   if (!throttlesAtIdle()) {
 177     SG_LOG(SG_AUTOPILOT, SG_INFO, "auto-brake, throttles not at idle, disengaing");
 178     disengage();
 179     return;
 180   }
 181
 182   // update the target deceleration; note step can be changed while engaged
 183   if (_rto) {
 184     _targetDecel = _configRTODecel;
 185   } else {
 186     double f = (double) _step / _configNumSteps;
 187     _targetDecel = _configMaxDecel * f;
 188   }
 189 }
 190
 191 bool FGAutoBrake::shouldEngage()
 192 {
 193   if (_rto) {
 194     return shouldEngageRTO();
 195   }
 196
 197   if (_lastWoW || !_weightOnWheelsNode->getBoolValue()) {
 198     return false;
 199   }
 200
 201
 202   if (!throttlesAtIdle()) {
 203     return false;
 204   }
 205
 206   SG_LOG(SG_AUTOPILOT, SG_INFO, "Autobrake, should enage");
 207   return true;
 208 }
 209
 210 bool FGAutoBrake::shouldEngageRTO()
 211 {
 212   double speed = _groundspeedNode->getDoubleValue();
 213
 214   if (_rtoArmed) {
 215     if (speed < _configRTOSpeed) {
 216       SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: RTO armed, but speed is now below arming speed");
 217       _rtoArmed = false;
 218       return false;
 219     }
 220
 221     if (!_weightOnWheelsNode->getBoolValue()) {
 222       if (airborne()) {
 223         SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: RTO, airbone, disengaging");
 224         _rtoArmed = false;
 225         _armed = false;
 226         _step = _configDisengageStep;
 227       }
 228
 229       return false;
 230     }
 231
 232     if (throttlesAtIdle()) {
 233       SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: RTO, throttles at idle, will engage");
 234       return true;
 235     } else {
 236       return false;
 237     }
 238   } else {
 239     // RTO arming case
 240     if (speed > _configRTOSpeed) {
 241       SG_LOG(SG_AUTOPILOT, SG_INFO, "Autobrake RTO: passed " << _configRTOSpeed << " knots, arming RTO mode");
 242       _rtoArmed = true;
 243     }
 244   }
 245
 246   return false;
 247 }
 248
 249 void FGAutoBrake::disengage()
 250 {
 251   if (!_engaged) {
 252     return;
 253   }
 254
 255   SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: disengage");
 256   _engaged = false;
 257   _fcsBrakeControl = 0.0;
 258   _armed = false;
 259   _rtoArmed = false;
 260   _targetDecel = 0.0;
 261   _step = _configDisengageStep;
 262 }
 263
 264 bool FGAutoBrake::airborne() const
 265 {
 266   return !_weightOnWheelsNode->getBoolValue();
 267 }
 268
 269 bool FGAutoBrake::throttlesAtIdle() const
 270 {
 271   SGPropertyNode_ptr e;
 272   const double IDLE_THROTTLE = 0.05; // 5% margin for idle setting
 273
 274   for (int index=0; (e = _engineControlsNode->getChild("engine", index)) != NULL; ++index) {
 275     if ((e->getDoubleValue("throttle") > IDLE_THROTTLE) && !e->getBoolValue("reverser")) {
 276       return false;
 277     }
 278   } // of engines iteration
 279
 280   return true;
 281 }
 282
 283 void FGAutoBrake::setArmed(bool aArmed)
 284 {
 285   if (aArmed == _armed) {
 286     return;
 287   }
 288
 289   disengage();
 290   _armed = aArmed;
 291 }
 292
 293 void FGAutoBrake::setRTO(bool aRTO)
 294 {
 295   if (aRTO) {
 296     // ensure we meet RTO selection criteria:
 297     if (!_weightOnWheelsNode->getBoolValue()) {
 298       // some systems combine RTO with a standard step, selecting RTO if on
 299       // the ground. Handle that case by setting _rto = false, and letting
 300       // setStep() do the rest of the work as normal.
 301       if ((_configRTOStep > 0) && (_configRTOStep <= _configNumSteps)) {
 302         // RTO is combined with a normal step, select that
 303       } else {
 304         SG_LOG(SG_AUTOPILOT, SG_WARN, "auto-brake: cannot select RTO mode, no weight on wheels");
 305       }
 306
 307       _rto = false;
 308       return;
 309     }
 310
 311     _rtoArmed = false;
 312     _rto = true;
 313     _step = _configRTOStep;
 314     setArmed(true);
 315     SG_LOG(SG_AUTOPILOT, SG_INFO, "RTO mode set");
 316   } else {
 317     _rto = false;
 318     _rtoArmed = false;
 319     // and if we're enaged?
 320     disengage();
 321   }
 322 }
 323
 324 void FGAutoBrake::setStep(int aStep)
 325 {
 326   if (aStep == _step) {
 327     return;
 328   }
 329
 330   SG_LOG(SG_AUTOPILOT, SG_INFO, "Autobrake step now=" << aStep);
 331   _step = aStep;
 332   bool validStep = false;
 333
 334   if (aStep == _configRTOStep) {
 335     setRTO(true);
 336     validStep = true;
 337   } else {
 338     _rto = false;
 339     validStep = (_step > 0) && (_step <= _configNumSteps);
 340   }
 341
 342   setArmed(validStep); // selecting a valid step arms the system
 343 }
 344
 345