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   _configMaxDecel = 11; // ft-sec-sec
  43   _configRTODecel = 11; // ft-sec-sec
  44   _configRTOSpeed = 85; // kts
  45 }
  46
  47 FGAutoBrake::~FGAutoBrake()
  48 {
  49 }
  50
  51 void FGAutoBrake::init()
  52 {
  53   _root = fgGetNode("/autopilot/autobrake", true);
  54
  55   _root->tie("armed", SGRawValueMethods<FGAutoBrake, bool>
  56     (*this, &FGAutoBrake::getArmed, &FGAutoBrake::setArmed));
  57
  58   _root->tie("step", SGRawValueMethods<FGAutoBrake, int>
  59     (*this, &FGAutoBrake::getStep, &FGAutoBrake::setStep));
  60
  61   _root->tie("rto", SGRawValueMethods<FGAutoBrake, bool>
  62     (*this, &FGAutoBrake::getRTO, &FGAutoBrake::setRTO));
  63
  64   _engineControlsNode = fgGetNode("/controls/engines");
  65   _groundspeedNode = fgGetNode("/velocities/groundspeed-kt");
  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("rto-decel-fts-sec", SGRawValuePointer<double>(&_configRTODecel));
  78   config->tie("max-decel-fts-sec", SGRawValuePointer<double>(&_configMaxDecel));
  79   config->tie("rto-engage-kts", SGRawValuePointer<double>(&_configRTOSpeed));
  80
  81   // outputs
  82   _root->tie("target-decel-fts-sec",
  83     SGRawValueMethods<FGAutoBrake,double>(*this, &FGAutoBrake::getTargetDecel));
  84   _root->tie("actual-decel-fts-sec",
  85     SGRawValueMethods<FGAutoBrake,double>(*this, &FGAutoBrake::getActualDecel));
  86   _root->tie("fcs-brake", SGRawValuePointer<double>(&_fcsBrakeControl));
  87   _root->tie("brake-left-output", SGRawValuePointer<double>(&_leftBrakeOutput));
  88   _root->tie("brake-right-output", SGRawValuePointer<double>(&_rightBrakeOutput));
  89
  90   _root->tie("engaged", SGRawValueMethods<FGAutoBrake, bool>(*this, &FGAutoBrake::getEngaged));
  91 }
  92
  93 void FGAutoBrake::postinit()
  94 {
  95   _weightOnWheelsNode = fgGetNode("/gear/gear/wow");
  96   _lastWoW = _weightOnWheelsNode->getBoolValue();
  97 }
  98
  99
 100 void FGAutoBrake::bind()
 101 {
 102 }
 103
 104 void FGAutoBrake::unbind()
 105 {
 106 }
 107
 108 void FGAutoBrake::update(double dt)
 109 {
 110   if (dt <= 0.0) {
 111     return; // paused
 112   }
 113
 114   double gs = _groundspeedNode->getDoubleValue();
 115   _actualDecel = (_lastGroundspeedKts - gs) / dt;
 116   _lastGroundspeedKts = gs;
 117
 118   _leftBrakeInput = SGMiscd::max(_brakeInputs[0]->getDoubleValue(),
 119       _brakeInputs[2]->getDoubleValue());
 120   _rightBrakeInput = SGMiscd::max(_brakeInputs[1]->getDoubleValue(),
 121       _brakeInputs[3]->getDoubleValue());
 122
 123   if (!_armed || (_step == 0)) {
 124     // even if we're off or disarmed, the physical valve system must pass
 125     // pilot control values through.
 126     _leftBrakeOutput = _leftBrakeInput;
 127     _rightBrakeOutput = _rightBrakeInput;
 128     return;
 129   }
 130
 131   if (_engaged) {
 132     updateEngaged(dt);
 133   } else {
 134     bool e = shouldEngage();
 135     if (e) {
 136       engage();
 137       updateEngaged(dt);
 138     }
 139   }
 140
 141   // sum pilot inpiuts with auto-brake FCS input
 142   _leftBrakeOutput = SGMiscd::max(_leftBrakeInput, _fcsBrakeControl);
 143   _rightBrakeOutput = SGMiscd::max(_rightBrakeInput, _fcsBrakeControl);
 144
 145   _lastWoW = _weightOnWheelsNode->getBoolValue();
 146 }
 147
 148 void FGAutoBrake::engage()
 149 {
 150   SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: engaging");
 151   _engaged = true;
 152 }
 153
 154 void FGAutoBrake::updateEngaged(double dt)
 155 {
 156   // check for pilot braking input cancelling engage
 157   const double BRAKE_INPUT_THRESHOLD = 0.02; // 2% application triggers
 158   if ((_leftBrakeInput > BRAKE_INPUT_THRESHOLD) || (_rightBrakeInput > BRAKE_INPUT_THRESHOLD)) {
 159     SG_LOG(SG_AUTOPILOT, SG_INFO, "auto-brake, detected pilot brake input, disengaing");
 160     disengage();
 161     return;
 162   }
 163
 164   // update the target deceleration; note step can be changed while engaged
 165   if (_rto) {
 166     _targetDecel = _configRTODecel;
 167   } else {
 168     double f = (double) _step / _configNumSteps;
 169     _targetDecel = _configMaxDecel * f;
 170   }
 171 }
 172
 173 bool FGAutoBrake::shouldEngage()
 174 {
 175   if (_rto) {
 176     return shouldEngageRTO();
 177   }
 178
 179   if (_lastWoW || !_weightOnWheelsNode->getBoolValue()) {
 180     return false;
 181   }
 182
 183   SG_LOG(SG_AUTOPILOT, SG_INFO, "Autobrake, should enage");
 184   return true;
 185 }
 186
 187 bool FGAutoBrake::shouldEngageRTO()
 188 {
 189   double speed = _groundspeedNode->getDoubleValue();
 190
 191   if (_rtoArmed) {
 192     if (speed < _configRTOSpeed) {
 193       SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: RTO armed, but speed is now below arming speed");
 194       _rtoArmed = false;
 195       return false;
 196     }
 197
 198     if (!_weightOnWheelsNode->getBoolValue()) {
 199       return false;
 200     }
 201
 202     return throttlesAtIdle();
 203   } else {
 204     // RTO arming case
 205     if (speed > _configRTOSpeed) {
 206       SG_LOG(SG_AUTOPILOT, SG_INFO, "Autobrake RTO: passed " << _configRTOSpeed << " knots, arming RTO mode");
 207       _rtoArmed = true;
 208     }
 209   }
 210
 211   return false;
 212 }
 213
 214 void FGAutoBrake::disengage()
 215 {
 216   if (!_engaged) {
 217     return;
 218   }
 219
 220   SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: disengage");
 221   _engaged = false;
 222   _armed = false;
 223   _rtoArmed = false;
 224   _targetDecel = 0.0;
 225 }
 226
 227 bool FGAutoBrake::throttlesAtIdle()
 228 {
 229   SGPropertyNode_ptr e;
 230   const double IDLE_THROTTLE = 0.05; // 5% margin for idle setting
 231
 232   for (int index=0; (e = _engineControlsNode->getChild("engine", index)) != NULL; ++index) {
 233     if ((e->getDoubleValue("throttle") > IDLE_THROTTLE) && !e->getBoolValue("reverser")) {
 234       return false;
 235     }
 236   } // of engines iteration
 237
 238   SG_LOG(SG_AUTOPILOT, SG_INFO, "FGAutoBrake: throttles at idle");
 239   return true;
 240 }
 241
 242 void FGAutoBrake::setArmed(bool aArmed)
 243 {
 244   if (aArmed == _armed) {
 245     return;
 246   }
 247
 248   disengage();
 249   _armed = aArmed;
 250 }
 251
 252 void FGAutoBrake::setRTO(bool aRTO)
 253 {
 254   if (aRTO) {
 255     // ensure we meet RTO selection criteria:
 256     if (!_weightOnWheelsNode->getBoolValue()) {
 257       SG_LOG(SG_AUTOPILOT, SG_WARN, "auto-brake: cannot select RTO mode, no weight on wheels");
 258       return;
 259     }
 260
 261     _rtoArmed = false;
 262     _rto = true;
 263     _step = _configRTOStep;
 264     setArmed(true);
 265     SG_LOG(SG_AUTOPILOT, SG_INFO, "RTO mode set");
 266   } else {
 267     _rto = false;
 268     _rtoArmed = false;
 269     // and if we're enaged?
 270     disengage();
 271   }
 272 }
 273
 274 void FGAutoBrake::setStep(int aStep)
 275 {
 276   if (aStep == _step) {
 277     return;
 278   }
 279
 280   SG_LOG(SG_AUTOPILOT, SG_INFO, "Autobrake step now=" << aStep);
 281   _step = aStep;
 282   bool validStep = false;
 283
 284   if (aStep == _configRTOStep) {
 285     setRTO(true);
 286     validStep = true;
 287   } else {
 288     _rto = false;
 289     validStep = (_step > 0) && (_step <= _configNumSteps);
 290   }
 291
 292   setArmed(validStep); // selecting a valid step arms the system
 293 }
 294
 295