Subversion Repositories FlightCtrl

#include <stdlib.h>

#include <avr/io.h>

#include "eeprom.h"

#include "flight.h"

#include "output.h"

// Necessary for external control and motor test

#include "uart0.h"

// for scope debugging

// #include "rc.h"

#include "timer2.h"

#include "attitude.h"

#include "controlMixer.h"

#include "commands.h"

#ifdef USE_MK3MAG

#include "gps.h"

#endif

#define CHECK_MIN_MAX(value, min, max) {if(value < min) value = min; else if(value > max) value = max;}

/*

 * These are no longer maintained, just left at 0. The original implementation just summed the acc.

 * value to them every 2 ms. No filtering or anything. Just a case for an eventual overflow?? Hey???

 */

// int16_t naviAccPitch = 0, naviAccRoll = 0, naviCntAcc = 0;

int8_t pitchPFactor, rollPFactor, yawPFactor;

int8_t pitchDFactor, rollDFactor, yawDFactor;

int32_t IPart[2] = {0,0};

/************************************************************************/

/*  Filter for motor value smoothing (necessary???)                     */

/************************************************************************/

int16_t outputFilter(int16_t newvalue, int16_t oldvalue) {

  switch (dynamicParams.UserParams[5]) {

  case 0:

    return newvalue;

  case 1:

    return (oldvalue + newvalue) / 2;

  case 2:

    if (newvalue > oldvalue)

      return (1 * (int16_t) oldvalue + newvalue) / 2; //mean of old and new

    else

      return newvalue - (oldvalue - newvalue) * 1; // 2 * new - old

  case 3:

    if (newvalue < oldvalue)

      return (1 * (int16_t) oldvalue + newvalue) / 2; //mean of old and new

    else

      return newvalue - (oldvalue - newvalue) * 1; // 2 * new - old

  default:

    return newvalue;

  }

}

/************************************************************************/

/*  Neutral Readings                                                    */

/************************************************************************/

#define CONTROL_CONFIG_SCALE 10

void flight_setNeutral() {

  MKFlags |= MKFLAG_CALIBRATE;

  // not really used here any more.

  controlMixer_initVariables();

}

void setFlightParameters

(

 uint8_t _pitchPFactor,

 uint8_t _rollPFactor,

 uint8_t _yawPFactor,

 uint8_t _pitchDFactor,

 uint8_t _rollDFactor,

 uint8_t _yawDFactor

 ) {

  pitchPFactor = _pitchPFactor;

  rollPFactor = _rollPFactor;

  yawPFactor = _yawPFactor;

  pitchDFactor = _pitchDFactor;

  rollDFactor = _rollDFactor;

  yawDFactor = _yawDFactor;

}

void setNormalFlightParameters(void) {

  setFlightParameters

    (

     dynamicParams.GyroPitchP / CONTROL_CONFIG_SCALE,     // 12 seems good

     dynamicParams.GyroRollP / CONTROL_CONFIG_SCALE,      // 9 seems good

     dynamicParams.GyroYawP / (CONTROL_CONFIG_SCALE/2),   // 24 seems too little

     dynamicParams.GyroPitchD / CONTROL_CONFIG_SCALE,

     dynamicParams.GyroRollD / CONTROL_CONFIG_SCALE,

     dynamicParams.GyroYawD / CONTROL_CONFIG_SCALE

     );

}

void setStableFlightParameters(void) {

  setFlightParameters(0, 0, 0, 0, 0, 0);

}

/************************************************************************/

/*  Main Flight Control                                                 */

/************************************************************************/

void flight_control(void) {

  // Mixer Fractions that are combined for Motor Control

  int16_t yawTerm, throttleTerm, term[2];

  // PID controller variables

  int16_t PDPart[2], PDPartYaw;

  static int8_t debugDataTimer = 1;

  // High resolution motor values for smoothing of PID motor outputs

  static int16_t outputFilters[MAX_OUTPUTS];

  uint8_t i;

  // Fire the main flight attitude calculation, including integration of angles.

  // We want that to kick as early as possible, not to delay new AD sampling further.

  calculateFlightAttitude();

  controlMixer_update();

  throttleTerm = control[CONTROL_THROTTLE];

  /************************************************************************/

  /* RC-signal is bad                                                     */

  /************************************************************************/

  if (controlMixer_getSignalQuality() <= SIGNAL_BAD) { // the rc-frame signal is not received or noisy

    RED_ON;

    beepRCAlarm();

    setStableFlightParameters();

  } else {

    commands_handleCommands();

    setNormalFlightParameters();

  }

  /************************************************************************/

  /* Calculate control feedback from angle (gyro integral)                */

  /* and angular velocity (gyro signal)                                   */

  /************************************************************************/

  PDPart[PITCH] = ((int32_t) rate_PID[PITCH] * pitchPFactor /

                  (256L / CONTROL_SCALING))

  + (differential[PITCH] * (int16_t) dynamicParams.GyroPitchD) / 16;

  PDPart[ROLL] = ((int32_t) rate_PID[ROLL] * rollPFactor /

                  (256L / CONTROL_SCALING))

  + (differential[ROLL] * (int16_t) dynamicParams.GyroRollD) / 16;

  PDPartYaw = (int32_t) (yawRate * 2 * (int32_t) yawPFactor) / (256L / CONTROL_SCALING)

  + (differential[YAW] * (int16_t) dynamicParams.GyroYawD) / 16;

  /************************************************************************/

  /* Stick signals are positive and gyros are negative...                 */

  /************************************************************************/

  IPart[PITCH] = controlIntegrals[CONTROL_ELEVATOR] - angle[PITCH];

  if (IPart[PITCH] > PITCHROLLOVER180) IPart[PITCH] -= PITCHROLLOVER360;

  else if (IPart[PITCH] <= -PITCHROLLOVER180) IPart[PITCH] += PITCHROLLOVER360;

  if (IPart[PITCH] > HH_RANGE) IPart[PITCH] = HH_RANGE;

  else if (IPart[PITCH] < -HH_RANGE) IPart[PITCH] = -HH_RANGE;

  IPart[ROLL] = controlIntegrals[CONTROL_AILERONS] - angle[ROLL];

  if (IPart[ROLL] > PITCHROLLOVER180) IPart[ROLL] -= PITCHROLLOVER360;

  else if (IPart[ROLL] <= -PITCHROLLOVER180) IPart[ROLL] += PITCHROLLOVER360;

  if (IPart[ROLL] > HH_RANGE) IPart[ROLL] = HH_RANGE;

  else if (IPart[ROLL] < -HH_RANGE) IPart[ROLL] = -HH_RANGE;

  term[PITCH] = control[CONTROL_ELEVATOR] + (staticParams.ControlSigns & 1 ? PDPart[PITCH] : -PDPart[PITCH]);

  term[ROLL] = control[CONTROL_AILERONS] + (staticParams.ControlSigns & 2 ? PDPart[ROLL] : -PDPart[ROLL]);

  yawTerm = control[CONTROL_RUDDER] + (staticParams.ControlSigns & 4 ? PDPartYaw : -PDPartYaw);

  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  // Universal Mixer

  // Each (pitch, roll, throttle, yaw) term is in the range [0..255 * CONTROL_SCALING].

  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  DebugOut.Analog[12] = term[PITCH];

  DebugOut.Analog[13] = term[ROLL];

  DebugOut.Analog[14] = throttleTerm;

  DebugOut.Analog[15] = yawTerm;

  for (i = 0; i < MAX_OUTPUTS; i++) {

    int16_t tmp;

      if (outputTestActive) {

          outputs[i].SetPoint = outputTest[i] * 4;

      } else {

        // Follow the normal order of servos: Ailerons, elevator, throttle, rudder.

        switch(i) {

        case 0: tmp = term[ROLL]; break;

        case 1: tmp = term[PITCH]; break;

        case 2: tmp = throttleTerm - 310; break;

        case 3: tmp = yawTerm; break;

        default: tmp = 0;

        }

      outputFilters[i] = outputFilter(tmp, outputFilters[i]);

      // Now we scale back down to a 0..255 range.

      tmp = outputFilters[i];

      outputs[i].SetPoint = tmp;

    }

  }

  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  // Debugging

  // +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  if (!(--debugDataTimer)) {

    debugDataTimer = 24; // update debug outputs at 488 / 24 = 20.3 Hz.

    DebugOut.Analog[0] = (10 * angle[PITCH]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg

    DebugOut.Analog[1] = (10 * angle[ROLL]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg

    DebugOut.Analog[2] = yawGyroHeading / GYRO_DEG_FACTOR_YAW;

    DebugOut.Analog[6] = pitchPFactor;

    DebugOut.Analog[7] = rollPFactor;

    DebugOut.Analog[8] = yawPFactor;

    DebugOut.Analog[9] = pitchDFactor;

    DebugOut.Analog[10] = rollDFactor;

    DebugOut.Analog[11] = yawDFactor;

    DebugOut.Analog[18] = (10 * controlIntegrals[CONTROL_ELEVATOR]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg

    DebugOut.Analog[19] = (10 * controlIntegrals[CONTROL_AILERONS]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg

    DebugOut.Analog[22] = (10 * IPart[PITCH]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg

    DebugOut.Analog[23] = (10 * IPart[ROLL]) / GYRO_DEG_FACTOR_PITCHROLL; // in 0.1 deg

  }

}