Subversion Repositories FlightCtrl

Rev

Rev 1908 | Rev 1955 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1868 - 1
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1612 dongfang 2
// + Copyright (c) 04.2007 Holger Buss
1870 - 3
// + Nur für den privaten Gebrauch
1612 dongfang 4
// + www.MikroKopter.com
5
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1870 - 6
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
7
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
1612 dongfang 8
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
9
// + bzgl. der Nutzungsbedingungen aufzunehmen.
1870 - 10
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
1612 dongfang 11
// + Verkauf von Luftbildaufnahmen, usw.
12
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1870 - 13
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
14
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
1612 dongfang 15
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
16
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
1870 - 17
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
18
// + eindeutig als Ursprung verlinkt werden
1612 dongfang 19
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1870 - 20
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
1612 dongfang 21
// + Benutzung auf eigene Gefahr
1870 - 22
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
1612 dongfang 23
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
24
// + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
1870 - 25
// + mit unserer Zustimmung zulässig
1612 dongfang 26
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
27
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
28
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
29
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
30
// + this list of conditions and the following disclaimer.
31
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
32
// +     from this software without specific prior written permission.
33
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
34
// +     for non-commercial use (directly or indirectly)
1868 - 35
// +     Commercial use (for example: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
1612 dongfang 36
// +     with our written permission
37
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
38
// +     clearly linked as origin
39
// +   * porting to systems other than hardware from www.mikrokopter.de is not allowed
40
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
41
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
44
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
45
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
46
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1870 - 47
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1612 dongfang 48
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
49
// +  POSSIBILITY OF SUCH DAMAGE.
50
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
51
 
52
#include <stdlib.h>
53
#include <avr/io.h>
54
#include "eeprom.h"
55
#include "flight.h"
1845 - 56
#include "output.h"
1612 dongfang 57
 
58
// Only for debug. Remove.
1645 - 59
//#include "analog.h"
60
//#include "rc.h"
1612 dongfang 61
 
62
// Necessary for external control and motor test
63
#include "uart0.h"
1775 - 64
 
65
// for scope debugging
66
// #include "rc.h"
67
 
1612 dongfang 68
#include "twimaster.h"
69
#include "attitude.h"
70
#include "controlMixer.h"
1775 - 71
#include "commands.h"
1612 dongfang 72
#ifdef USE_MK3MAG
73
#include "gps.h"
74
#endif
75
 
76
#define CHECK_MIN_MAX(value, min, max) {if(value < min) value = min; else if(value > max) value = max;}
77
 
78
/*
79
 * These are no longer maintained, just left at 0. The original implementation just summed the acc.
80
 * value to them every 2 ms. No filtering or anything. Just a case for an eventual overflow?? Hey???
81
 */
1645 - 82
// int16_t naviAccPitch = 0, naviAccRoll = 0, naviCntAcc = 0;
1612 dongfang 83
 
1872 - 84
uint8_t gyroPFactor, gyroIFactor; // the PD factors for the attitude control
1612 dongfang 85
uint8_t yawPFactor, yawIFactor; // the PD factors for the yaw control
86
 
87
// Some integral weight constant...
88
uint16_t Ki = 10300 / 33;
89
uint8_t RequiredMotors = 0;
90
 
91
/************************************************************************/
92
/*  Filter for motor value smoothing (necessary???)                     */
93
/************************************************************************/
94
int16_t motorFilter(int16_t newvalue, int16_t oldvalue) {
1872 - 95
  switch (dynamicParams.UserParams[5]) {
1841 - 96
  case 0:
97
    return newvalue;
98
  case 1:
1872 - 99
    return (oldvalue + newvalue) / 2;
1841 - 100
  case 2:
1872 - 101
    if (newvalue > oldvalue)
102
      return (1 * (int16_t) oldvalue + newvalue) / 2; //mean of old and new
103
    else
1841 - 104
      return newvalue - (oldvalue - newvalue) * 1; // 2 * new - old
105
  case 3:
1872 - 106
    if (newvalue < oldvalue)
107
      return (1 * (int16_t) oldvalue + newvalue) / 2; //mean of old and new
108
    else
1841 - 109
      return newvalue - (oldvalue - newvalue) * 1; // 2 * new - old
1872 - 110
  default:
111
    return newvalue;
1841 - 112
  }
1612 dongfang 113
}
114
 
115
/************************************************************************/
116
/*  Neutral Readings                                                    */
117
/************************************************************************/
118
void flight_setNeutral() {
1841 - 119
  MKFlags |= MKFLAG_CALIBRATE;
120
  // not really used here any more.
121
  dynamicParams.KalmanK = -1;
122
  dynamicParams.KalmanMaxDrift = 0;
123
  dynamicParams.KalmanMaxFusion = 32;
124
  controlMixer_initVariables();
1612 dongfang 125
}
126
 
1872 - 127
void setFlightParameters(uint8_t _Ki, uint8_t _gyroPFactor,
128
    uint8_t _gyroIFactor, uint8_t _yawPFactor, uint8_t _yawIFactor) {
1841 - 129
  Ki = 10300 / _Ki;
130
  gyroPFactor = _gyroPFactor;
131
  gyroIFactor = _gyroIFactor;
132
  yawPFactor = _yawPFactor;
133
  yawIFactor = _yawIFactor;
1612 dongfang 134
}
135
 
136
void setNormalFlightParameters(void) {
1946 - 137
  setFlightParameters(dynamicParams.IFactor, dynamicParams.GyroP,
1872 - 138
      staticParams.GlobalConfig & CFG_HEADING_HOLD ? 0 : dynamicParams.GyroI,
1946 - 139
      dynamicParams.GyroP, dynamicParams.UserParams[6]);
1612 dongfang 140
}
141
 
142
void setStableFlightParameters(void) {
1841 - 143
  setFlightParameters(33, 90, 120, 90, 120);
1612 dongfang 144
}
145
 
146
/************************************************************************/
147
/*  Main Flight Control                                                 */
148
/************************************************************************/
149
void flight_control(void) {
1841 - 150
  int16_t tmp_int;
1872 - 151
  // Mixer Fractions that are combined for Motor Control
1841 - 152
  int16_t yawTerm, throttleTerm, term[2];
1612 dongfang 153
 
1841 - 154
  // PID controller variables
155
  int16_t PDPart[2], PDPartYaw, PPart[2];
1872 - 156
  static int32_t IPart[2] = { 0, 0 };
1841 - 157
  //  static int32_t yawControlRate = 0;
1612 dongfang 158
 
1841 - 159
  // Removed. Too complicated, and apparently not necessary with MEMS gyros anyway.
160
  // static int32_t IntegralGyroPitchError = 0, IntegralGyroRollError = 0;
161
  // static int32_t CorrectionPitch, CorrectionRoll;
1612 dongfang 162
 
1841 - 163
  static uint16_t emergencyFlightTime;
164
  static int8_t debugDataTimer = 1;
1612 dongfang 165
 
1841 - 166
  // High resolution motor values for smoothing of PID motor outputs
167
  static int16_t motorFilters[MAX_MOTORS];
1612 dongfang 168
 
1841 - 169
  uint8_t i, axis;
1612 dongfang 170
 
1841 - 171
  // Fire the main flight attitude calculation, including integration of angles.
1870 - 172
  // We want that to kick as early as possible, not to delay new AD sampling further.
1841 - 173
  calculateFlightAttitude();
1870 - 174
  controlMixer_update();
1908 - 175
  throttleTerm = controls[CONTROL_THROTTLE];
1870 - 176
 
1841 - 177
  // This check removed. Is done on a per-motor basis, after output matrix multiplication.
1872 - 178
  if (throttleTerm < staticParams.MinThrottle + 10)
179
    throttleTerm = staticParams.MinThrottle + 10;
180
  else if (throttleTerm > staticParams.MaxThrottle - 20)
181
    throttleTerm = (staticParams.MaxThrottle - 20);
1612 dongfang 182
 
1841 - 183
  /************************************************************************/
184
  /* RC-signal is bad                                                     */
185
  /* This part could be abstracted, as having yet another control input   */
186
  /* to the control mixer: An emergency autopilot control.                */
187
  /************************************************************************/
1775 - 188
 
1872 - 189
  if (controlMixer_getSignalQuality() <= SIGNAL_BAD) { // the rc-frame signal is not reveived or noisy
1841 - 190
    RED_ON;
191
    beepRCAlarm();
1872 - 192
 
193
    if (emergencyFlightTime) {
1841 - 194
      // continue emergency flight
1872 - 195
      emergencyFlightTime--;
196
      if (isFlying > 256) {
197
        // We're probably still flying. Descend slowly.
198
        throttleTerm = staticParams.EmergencyGas; // Set emergency throttle
199
        MKFlags |= (MKFLAG_EMERGENCY_LANDING); // Set flag for emergency landing
200
        setStableFlightParameters();
1841 - 201
      } else {
1872 - 202
        MKFlags &= ~(MKFLAG_MOTOR_RUN); // Probably not flying, and bad R/C signal. Kill motors.
1841 - 203
      }
204
    } else {
205
      // end emergency flight (just cut the motors???)
206
      MKFlags &= ~(MKFLAG_MOTOR_RUN | MKFLAG_EMERGENCY_LANDING);
207
    }
1872 - 208
  } else {
1841 - 209
    // signal is acceptable
1872 - 210
    if (controlMixer_getSignalQuality() > SIGNAL_BAD) {
1841 - 211
      // Reset emergency landing control variables.
1872 - 212
      MKFlags &= ~(MKFLAG_EMERGENCY_LANDING); // clear flag for emergency landing
1841 - 213
      // The time is in whole seconds.
1872 - 214
      emergencyFlightTime = (uint16_t) staticParams.EmergencyGasDuration * 488;
1841 - 215
    }
1612 dongfang 216
 
1841 - 217
    // If some throttle is given, and the motor-run flag is on, increase the probability that we are flying.
1872 - 218
    if (throttleTerm > 40 && (MKFlags & MKFLAG_MOTOR_RUN)) {
1841 - 219
      // increment flight-time counter until overflow.
1872 - 220
      if (isFlying != 0xFFFF)
221
        isFlying++;
222
    } else
223
    /*
224
     * When standing on the ground, do not apply I controls and zero the yaw stick.
225
     * Probably to avoid integration effects that will cause the copter to spin
226
     * or flip when taking off.
227
     */
228
    if (isFlying < 256) {
229
      IPart[PITCH] = IPart[ROLL] = 0;
230
      // TODO: Don't stomp on other modules' variables!!!
231
      // controlYaw = 0;
232
      PDPartYaw = 0; // instead.
233
      if (isFlying == 250) {
234
        // HC_setGround();
235
        updateCompassCourse = 1;
236
        yawAngleDiff = 0;
1841 - 237
      }
1872 - 238
    } else {
239
      // Set fly flag. TODO: Hmmm what can we trust - the isFlying counter or the flag?
240
      // Answer: The counter. The flag is not read from anywhere anyway... except the NC maybe.
241
      MKFlags |= (MKFLAG_FLY);
242
    }
1612 dongfang 243
 
1872 - 244
    commands_handleCommands();
1612 dongfang 245
 
1841 - 246
    // if(controlMixer_getSignalQuality() >= SIGNAL_GOOD) {
247
    setNormalFlightParameters();
248
    // }
249
  } // end else (not bad signal case)
250
  // end part1a: 750-800 usec.
251
  /*
252
   * Looping the H&I way basically is just a matter of turning off attitude angle measurement
253
   * by integration (because 300 deg/s gyros are too slow) and turning down the throttle.
254
   * This is the throttle part.
255
   */
1872 - 256
  if (looping) {
257
    if (throttleTerm > staticParams.LoopGasLimit)
258
      throttleTerm = staticParams.LoopGasLimit;
1841 - 259
  }
1867 - 260
 
1841 - 261
  /************************************************************************/
262
  /*  Yawing                                                              */
263
  /************************************************************************/
1908 - 264
  if (abs(controls[CONTROL_YAW]) > 4 * staticParams.StickYawP) { // yaw stick is activated
1841 - 265
    ignoreCompassTimer = 1000;
1872 - 266
    if (!(staticParams.GlobalConfig & CFG_COMPASS_FIX)) {
1841 - 267
      updateCompassCourse = 1;
268
    }
269
  }
1872 - 270
 
1841 - 271
  //  yawControlRate = controlYaw;
1612 dongfang 272
 
1841 - 273
  // Trim drift of yawAngleDiff with controlYaw.
274
  // TODO: We want NO feedback of control related stuff to the attitude related stuff.
275
  // This seems to be used as: Difference desired <--> real heading.
1908 - 276
  yawAngleDiff -= controls[CONTROL_YAW];
1872 - 277
 
1841 - 278
  // limit the effect
279
  CHECK_MIN_MAX(yawAngleDiff, -50000, 50000);
1872 - 280
 
1841 - 281
  /************************************************************************/
282
  /* Compass is currently not supported.                                  */
283
  /************************************************************************/
1872 - 284
  if (staticParams.GlobalConfig & (CFG_COMPASS_ACTIVE | CFG_GPS_ACTIVE)) {
1841 - 285
    updateCompass();
286
  }
1872 - 287
 
1805 - 288
#if defined (USE_NAVICTRL)
1841 - 289
  /************************************************************************/
290
  /* GPS is currently not supported.                                      */
291
  /************************************************************************/
292
  if(staticParams.GlobalConfig & CFG_GPS_ACTIVE) {
293
    GPS_Main();
294
    MKFlags &= ~(MKFLAG_CALIBRATE | MKFLAG_START);
295
  } else {
296
  }
1612 dongfang 297
#endif
1841 - 298
  // end part 1: 750-800 usec.
299
  // start part 3: 350 - 400 usec.
1645 - 300
#define SENSOR_LIMIT  (4096 * 4)
1872 - 301
  /************************************************************************/
1775 - 302
 
1872 - 303
  /* Calculate control feedback from angle (gyro integral)                */
304
  /* and angular velocity (gyro signal)                                   */
305
  /************************************************************************/
306
  // The P-part is the P of the PID controller. That's the angle integrals (not rates).
1868 - 307
 
1872 - 308
  for (axis = PITCH; axis <= ROLL; axis++) {
309
    if (looping & ((1 << 4) << axis)) {
1841 - 310
      PPart[axis] = 0;
311
    } else { // TODO: Where do the 44000 come from???
312
      PPart[axis] = angle[axis] * gyroIFactor / (44000 / CONTROL_SCALING); // P-Part - Proportional to Integral
313
    }
1645 - 314
 
1841 - 315
    /*
316
     * Now blend in the D-part - proportional to the Differential of the integral = the rate.
317
     * Read this as: PDPart = PPart + rate_PID * pfactor * CONTROL_SCALING
318
     * where pfactor is in [0..1].
319
     */
1872 - 320
    PDPart[axis] = PPart[axis] + (int32_t) ((int32_t) rate_PID[axis]
321
        * gyroPFactor / (256L / CONTROL_SCALING)) + (differential[axis]
322
        * (int16_t) dynamicParams.GyroD) / 16;
1645 - 323
 
1841 - 324
    CHECK_MIN_MAX(PDPart[axis], -SENSOR_LIMIT, SENSOR_LIMIT);
325
  }
1775 - 326
 
1872 - 327
  PDPartYaw = (int32_t) (yawRate * 2 * (int32_t) yawPFactor) / (256L
328
      / CONTROL_SCALING) + (int32_t) (yawAngleDiff * yawIFactor) / (2 * (44000
329
      / CONTROL_SCALING));
330
 
1841 - 331
  // limit control feedback
332
  CHECK_MIN_MAX(PDPartYaw, -SENSOR_LIMIT, SENSOR_LIMIT);
1872 - 333
 
1841 - 334
  /*
335
   * Compose throttle term.
336
   * If a Bl-Ctrl is missing, prevent takeoff.
337
   */
1872 - 338
  if (missingMotor) {
1841 - 339
    // if we are in the lift off condition. Hmmmmmm when is throttleTerm == 0 anyway???
1872 - 340
    if (isFlying > 1 && isFlying < 50 && throttleTerm > 0)
1841 - 341
      isFlying = 1; // keep within lift off condition
342
    throttleTerm = staticParams.MinThrottle; // reduce gas to min to avoid lift of
343
  }
1612 dongfang 344
 
1841 - 345
  // Scale up to higher resolution. Hmm why is it not (from controlMixer and down) scaled already?
346
  throttleTerm *= CONTROL_SCALING;
1612 dongfang 347
 
1841 - 348
  /*
349
   * Compose yaw term.
350
   * The yaw term is limited: Absolute value is max. = the throttle term / 2.
351
   * However, at low throttle the yaw term is limited to a fixed value,
352
   * and at high throttle it is limited by the throttle reserve (the difference
353
   * between current throttle and maximum throttle).
354
   */
1645 - 355
#define MIN_YAWGAS (40 * CONTROL_SCALING)  // yaw also below this gas value
1908 - 356
  yawTerm = PDPartYaw - controls[CONTROL_YAW] * CONTROL_SCALING;
1841 - 357
  // Limit yawTerm
358
  DebugOut.Digital[0] &= ~DEBUG_CLIP;
1872 - 359
  if (throttleTerm > MIN_YAWGAS) {
360
    if (yawTerm < -throttleTerm / 2) {
1841 - 361
      DebugOut.Digital[0] |= DEBUG_CLIP;
1872 - 362
      yawTerm = -throttleTerm / 2;
363
    } else if (yawTerm > throttleTerm / 2) {
1841 - 364
      DebugOut.Digital[0] |= DEBUG_CLIP;
1872 - 365
      yawTerm = throttleTerm / 2;
1841 - 366
    }
367
    //CHECK_MIN_MAX(yawTerm, - (throttleTerm / 2), (throttleTerm / 2));
368
  } else {
1872 - 369
    if (yawTerm < -MIN_YAWGAS / 2) {
1841 - 370
      DebugOut.Digital[0] |= DEBUG_CLIP;
1872 - 371
      yawTerm = -MIN_YAWGAS / 2;
372
    } else if (yawTerm > MIN_YAWGAS / 2) {
1841 - 373
      DebugOut.Digital[0] |= DEBUG_CLIP;
1872 - 374
      yawTerm = MIN_YAWGAS / 2;
1841 - 375
    }
376
    //CHECK_MIN_MAX(yawTerm, - (MIN_YAWGAS / 2), (MIN_YAWGAS / 2));
377
  }
1775 - 378
 
1841 - 379
  // FIXME: Throttle may exceed maxThrottle (there is no check no more).
380
  tmp_int = staticParams.MaxThrottle * CONTROL_SCALING;
1845 - 381
  if (yawTerm < -(tmp_int - throttleTerm)) {
382
    yawTerm = -(tmp_int - throttleTerm);
1841 - 383
    DebugOut.Digital[0] |= DEBUG_CLIP;
1845 - 384
  } else if (yawTerm > (tmp_int - throttleTerm)) {
385
    yawTerm = (tmp_int - throttleTerm);
1841 - 386
    DebugOut.Digital[0] |= DEBUG_CLIP;
387
  }
1867 - 388
 
1841 - 389
  // CHECK_MIN_MAX(yawTerm, -(tmp_int - throttleTerm), (tmp_int - throttleTerm));
390
  DebugOut.Digital[1] &= ~DEBUG_CLIP;
1872 - 391
  for (axis = PITCH; axis <= ROLL; axis++) {
1841 - 392
    /*
393
     * Compose pitch and roll terms. This is finally where the sticks come into play.
394
     */
1872 - 395
    if (gyroIFactor) {
1841 - 396
      // Integration mode: Integrate (angle - stick) = the difference between angle and stick pos.
397
      // That means: Holding the stick a little forward will, at constant flight attitude, cause this to grow (decline??) over time.
398
      // TODO: Find out why this seems to be proportional to stick position - not integrating it at all.
1908 - 399
      IPart[axis] += PPart[axis] - controls[axis]; // Integrate difference between P part (the angle) and the stick pos.
1841 - 400
    } else {
401
      // "HH" mode: Integrate (rate - stick) = the difference between rotation rate and stick pos.
402
      // To keep up with a full stick PDPart should be about 156...
1908 - 403
      IPart[axis] += PDPart[axis] - controls[axis]; // With gyroIFactor == 0, PDPart is really just a D-part. Integrate D-part (the rot. rate) and the stick pos.
1841 - 404
    }
1612 dongfang 405
 
1872 - 406
    tmp_int = (int32_t) ((int32_t) dynamicParams.DynamicStability
407
        * (int32_t) (throttleTerm + abs(yawTerm) / 2)) / 64;
1612 dongfang 408
 
1841 - 409
    // TODO: From which planet comes the 16000?
410
    CHECK_MIN_MAX(IPart[axis], -(CONTROL_SCALING * 16000L), (CONTROL_SCALING * 16000L));
411
    // Add (P, D) parts minus stick pos. to the scaled-down I part.
1908 - 412
    term[axis] = PDPart[axis] - controls[axis] + IPart[axis] / Ki; // PID-controller for pitch
1775 - 413
 
1841 - 414
    /*
415
     * Apply "dynamic stability" - that is: Limit pitch and roll terms to a growing function of throttle and yaw(!).
416
     * The higher the dynamic stability parameter, the wider the bounds. 64 seems to be a kind of unity
417
     * (max. pitch or roll term is the throttle value).
418
     * TODO: Why a growing function of yaw?
419
     */
420
    if (term[axis] < -tmp_int) {
421
      DebugOut.Digital[1] |= DEBUG_CLIP;
422
    } else if (term[axis] > tmp_int) {
423
      DebugOut.Digital[1] |= DEBUG_CLIP;
424
    }
425
    CHECK_MIN_MAX(term[axis], -tmp_int, tmp_int);
426
  }
1775 - 427
 
1841 - 428
  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
429
  // Universal Mixer
430
  // Each (pitch, roll, throttle, yaw) term is in the range [0..255 * CONTROL_SCALING].
431
  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1612 dongfang 432
 
1841 - 433
  DebugOut.Analog[12] = term[PITCH];
434
  DebugOut.Analog[13] = term[ROLL];
1908 - 435
  //DebugOut.Analog[14] = yawTerm;
1841 - 436
  DebugOut.Analog[15] = throttleTerm;
1775 - 437
 
1872 - 438
  for (i = 0; i < MAX_MOTORS; i++) {
1874 - 439
    int32_t tmp;
1908 - 440
    uint8_t throttle;
441
 
442
    tmp = (int32_t)throttleTerm * Mixer.Motor[i][MIX_THROTTLE];
443
    tmp += (int32_t)term[PITCH] * Mixer.Motor[i][MIX_PITCH];
444
    tmp += (int32_t)term[ROLL] * Mixer.Motor[i][MIX_ROLL];
445
    tmp += (int32_t)yawTerm * Mixer.Motor[i][MIX_YAW];
446
    tmp = tmp >> 6;
447
    motorFilters[i] = motorFilter(tmp, motorFilters[i]);
448
    // Now we scale back down to a 0..255 range.
449
    tmp = motorFilters[i] / MOTOR_SCALING;
450
 
451
    // So this was the THIRD time a throttle was limited. But should the limitation
452
    // apply to the common throttle signal (the one used for setting the "power" of
453
    // all motors together) or should it limit the throttle set for each motor,
454
    // including mix components of pitch, roll and yaw? I think only the common
455
    // throttle should be limited.
456
    // --> WRONG. This caused motors to stall completely in tight maneuvers.
457
    // Apply to individual signals instead.
458
    CHECK_MIN_MAX(tmp, 1, 255);
459
    throttle = tmp;
460
 
461
    if (i < 4) DebugOut.Analog[22 + i] = throttle;
462
 
1841 - 463
    if (MKFlags & MKFLAG_MOTOR_RUN && Mixer.Motor[i][MIX_THROTTLE] > 0) {
1908 - 464
      motor[i].SetPoint = throttle;
1872 - 465
    } else if (motorTestActive) {
1841 - 466
      motor[i].SetPoint = motorTest[i];
467
    } else {
468
      motor[i].SetPoint = 0;
469
    }
470
  }
1872 - 471
 
1841 - 472
  I2C_Start(TWI_STATE_MOTOR_TX);
1872 - 473
 
1841 - 474
  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
475
  // Debugging
476
  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1872 - 477
  if (!(--debugDataTimer)) {
1841 - 478
    debugDataTimer = 24; // update debug outputs at 488 / 24 = 20.3 Hz.
1872 - 479
    DebugOut.Analog[0] = (10 * angle[PITCH]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg
480
    DebugOut.Analog[1] = (10 * angle[ROLL]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg
481
    DebugOut.Analog[2] = yawGyroHeading / GYRO_DEG_FACTOR_YAW;
1612 dongfang 482
 
1874 - 483
    DebugOut.Analog[6] = 64 >> 4;
484
    DebugOut.Analog[7] = -64 >> 4;
485
 
1841 - 486
    /*
1872 - 487
     DebugOut.Analog[23] = (yawRate * 2 * (int32_t)yawPFactor) / (256L / CONTROL_SCALING);
488
     DebugOut.Analog[24] = controlYaw;
489
     DebugOut.Analog[25] = yawAngleDiff / 100L;
490
     DebugOut.Analog[26] = accNoisePeak[PITCH];
491
     DebugOut.Analog[27] = accNoisePeak[ROLL];
492
     DebugOut.Analog[30] = gyroNoisePeak[PITCH];
493
     DebugOut.Analog[31] = gyroNoisePeak[ROLL];
494
     */
1841 - 495
  }
1612 dongfang 496
}