WebSVN - FlightCtrl - Diff - Rev 1646 and 1775 - /branches/dongfang_FC

 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Copyright (c) 04.2007 Holger Buss
 // + Nur für den privaten Gebrauch
 // + www.MikroKopter.com
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
 // + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
 // + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
 // + bzgl. der Nutzungsbedingungen aufzunehmen.
 // + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
 // + Verkauf von Luftbildaufnahmen, usw.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
 // + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
 // + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
 // + eindeutig als Ursprung verlinkt werden
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
 // + Benutzung auf eigene Gefahr
 // + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Die Portierung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
 // + mit unserer Zustimmung zulässig
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // + Redistributions of source code (with or without modifications) must retain the above copyright notice,
 // + this list of conditions and the following disclaimer.
 // +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
 // +     from this software without specific prior written permission.
 // +   * The use of this project (hardware, software, binary files, sources and documentation) is only permittet
 // +     for non-commercial use (directly or indirectly)
 // +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
 // +     with our written permission
 // +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
 // +     clearly linked as origin
 // +   * porting to systems other than hardware from www.mikrokopter.de is not allowed
 // +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 // +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 // +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 // +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 // +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 // +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include <avr/pgmspace.h>
 #include "analog.h"
 #include "sensors.h"
 // for Delay functions
 #include "timer0.h"
 // For DebugOut
 #include "uart0.h"
 // For reading and writing acc. meter offsets.
 #include "eeprom.h"
 /*
  * For each A/D conversion cycle, each analog channel is sampled a number of times
  * (see array channelsForStates), and the results for each channel are summed.
  * Here are those for the gyros and the acc. meters. They are not zero-offset.
  * They are exported in the analog.h file - but please do not use them! The only
  * reason for the export is that the ENC-03_FC1.3 modules needs them for calibrating
  * the offsets with the DAC.
  */
 volatile int16_t rawGyroSum[3];
 volatile int16_t acc[3];
 volatile int16_t filteredAcc[2]={0,0};
 /*
  * These 4 exported variables are zero-offset. The "PID" ones are used
  * in the attitude control as rotation rates. The "ATT" ones are for
  * integration to angles.
  */
 volatile int16_t gyro_PID[2];
 volatile int16_t gyro_ATT[2];
 volatile int16_t gyroD[2];
 volatile int16_t yawGyro;
 /*
  * Offset values. These are the raw gyro and acc. meter sums when the copter is
  * standing still. They are used for adjusting the gyro and acc. meter values
  * to be centered on zero.
  */
 volatile int16_t gyroOffset[3] = {
 * GYRO_SUMMATION_FACTOR_PITCHROLL,
 * GYRO_SUMMATION_FACTOR_PITCHROLL,
 * GYRO_SUMMATION_FACTOR_YAW
 };
 volatile int16_t accOffset[3] = {
 * ACC_SUMMATION_FACTOR_PITCHROLL,
 * ACC_SUMMATION_FACTOR_PITCHROLL,
 * ACC_SUMMATION_FACTOR_Z
 };
 /*
  * This allows some experimentation with the gyro filters.
  * Should be replaced by #define's later on...
  */
 volatile uint8_t GYROS_PID_FILTER;
 volatile uint8_t GYROS_ATT_FILTER;
 volatile uint8_t GYROS_D_FILTER;
 volatile uint8_t ACC_FILTER;
 /*
- * Air pressure measurement.
+ * Air pressure
  */
-#define MIN_RAWPRESSURE 200
+volatile uint8_t rangewidth = 106;
-#define MAX_RAWPRESSURE (1023-MIN_RAWPRESSURE)
+// Direct from sensor, irrespective of range.
-volatile uint8_t rangewidth = 53;
+// volatile uint16_t rawAirPressure;
+// Value of 2 samples, with range.
-volatile uint16_t rawAirPressure;
+volatile uint16_t simpleAirPressure;
+// Value of AIRPRESSURE_SUMMATION_FACTOR samples, with range, filtered.
-volatile uint16_t filteredAirPressure;
+volatile int32_t filteredAirPressure;
+// Partial sum of AIRPRESSURE_SUMMATION_FACTOR samples.
+volatile int32_t airPressureSum;
+// The number of samples summed into airPressureSum so far.
+volatile uint8_t pressureMeasurementCount;
 /*
  * Battery voltage, in units of: 1k/11k / 3V * 1024 = 31.03 per volt.
  * That is divided by 3 below, for a final 10.34 per volt.
  * So the initial value of 100 is for 9.7 volts.
  */
 volatile int16_t UBat = 100;
 /*
  * Control and status.
  */
 volatile uint16_t ADCycleCount = 0;
 volatile uint8_t analogDataReady = 1;
 /*
  * Experiment: Measuring vibration-induced sensor noise.
  */
 volatile uint16_t gyroNoisePeak[2];
 volatile uint16_t accNoisePeak[2];
 // ADC channels
 #define AD_GYRO_YAW       0
 #define AD_GYRO_ROLL      1
 #define AD_GYRO_PITCH     2
 #define AD_AIRPRESSURE    3
 #define AD_UBAT           4
 #define AD_ACC_Z          5
 #define AD_ACC_ROLL       6
 #define AD_ACC_PITCH      7
 /*
  * Table of AD converter inputs for each state.
  * The number of samples summed for each channel is equal to
  * the number of times the channel appears in the array.
  * The max. number of samples that can be taken in 2 ms is:
  * 20e6 / 128 / 13 / (1/2e-3) = 24. Since the main control
  * loop needs a little time between reading AD values and
  * re-enabling ADC, the real limit is (how much?) lower.
  * The acc. sensor is sampled even if not used - or installed
  * at all. The cost is not significant.
  */
 const uint8_t channelsForStates[] PROGMEM = {
   AD_GYRO_PITCH,
   AD_GYRO_ROLL,
   AD_GYRO_YAW,
   AD_ACC_PITCH,
   AD_ACC_ROLL,
-  // AD_AIRPRESSURE,
+  AD_AIRPRESSURE,
   AD_GYRO_PITCH,
   AD_GYRO_ROLL,
-  AD_ACC_Z,       // at 7, measure Z acc.
+  AD_ACC_Z,       // at 8, measure Z acc.
   AD_GYRO_PITCH,
   AD_GYRO_ROLL,
-  AD_GYRO_YAW,    // at 10, finish yaw gyro
+  AD_GYRO_YAW,    // at 11, finish yaw gyro
-  AD_ACC_PITCH,   // at 11, finish pitch axis acc.
+  AD_ACC_PITCH,   // at 12, finish pitch axis acc.
-  AD_ACC_ROLL,    // at 12, finish roll axis acc.
+  AD_ACC_ROLL,    // at 13, finish roll axis acc.
-  AD_AIRPRESSURE, // at 13, finish air pressure.
+  AD_AIRPRESSURE, // at 14, finish air pressure.
-  AD_GYRO_PITCH,  // at 14, finish pitch gyro
+  AD_GYRO_PITCH,  // at 15, finish pitch gyro
-  AD_GYRO_ROLL,   // at 15, finish roll gyro
+  AD_GYRO_ROLL,   // at 16, finish roll gyro
-  AD_UBAT         // at 16, measure battery.
+  AD_UBAT         // at 17, measure battery.
 };
 // Feature removed. Could be reintroduced later - but should work for all gyro types then.
 // uint8_t GyroDefectPitch = 0, GyroDefectRoll = 0, GyroDefectYaw = 0;
 void analog_init(void) {
   uint8_t sreg = SREG;
   // disable all interrupts before reconfiguration
   cli();
   //ADC0 ... ADC7 is connected to PortA pin 0 ... 7
   DDRA = 0x00;
   PORTA = 0x00;
   // Digital Input Disable Register 0
   // Disable digital input buffer for analog adc_channel pins
   DIDR0 = 0xFF;
   // external reference, adjust data to the right
   ADMUX &= ~((1 << REFS1)|(1 << REFS0)|(1 << ADLAR));
   // set muxer to ADC adc_channel 0 (0 to 7 is a valid choice)
   ADMUX = (ADMUX & 0xE0) | AD_GYRO_PITCH;
   //Set ADC Control and Status Register A
   //Auto Trigger Enable, Prescaler Select Bits to Division Factor 128, i.e. ADC clock = SYSCKL/128 = 156.25 kHz
   ADCSRA = (0<<ADEN)|(0<<ADSC)|(0<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(0<<ADIE);
   //Set ADC Control and Status Register B
   //Trigger Source to Free Running Mode
   ADCSRB &= ~((1 << ADTS2)|(1 << ADTS1)|(1 << ADTS0));
   // Start AD conversion
   analog_start();
   // restore global interrupt flags
   SREG = sreg;
+}
 void measureNoise(const int16_t sensor, volatile uint16_t* const noiseMeasurement, const uint8_t damping) {
   if (sensor > (int16_t)(*noiseMeasurement)) {
     *noiseMeasurement = sensor;
   } else if (-sensor > (int16_t)(*noiseMeasurement)) {
     *noiseMeasurement = -sensor;
   } else if (*noiseMeasurement > damping) {
     *noiseMeasurement -= damping;
   } else {
     *noiseMeasurement = 0;
+  }
+}
-uint16_t getAbsPressure(int advalue) {
+uint16_t getSimplePressure(int advalue) {
   return (uint16_t)OCR0A * (uint16_t)rangewidth + advalue;
+}
-uint16_t filterAirPressure(uint16_t rawpressure) {
-  return rawpressure;
-}
 /*****************************************************
  * Interrupt Service Routine for ADC
  * Runs at 312.5 kHz or 3.2 µs. When all states are
  * processed the interrupt is disabled and further
  * AD conversions are stopped.
  *****************************************************/
 ISR(ADC_vect) {
   static uint8_t ad_channel = AD_GYRO_PITCH, state = 0;
   static uint16_t sensorInputs[8] = {0,0,0,0,0,0,0,0};
-  static uint8_t pressure_wait = 10;
+  static uint16_t pressureAutorangingWait = 25;
+  uint16_t rawAirPressure;
   uint8_t i, axis;
-  int16_t range;
+  int16_t newrange;
   // for various filters...
   int16_t tempOffsetGyro, tempGyro;
   sensorInputs[ad_channel] += ADC;
   /*
    * Actually we don't need this "switch". We could do all the sampling into the
    * sensorInputs array first, and all the processing after the last sample.
    */
   switch(state++) {
-  case 7: // Z acc
+  case 8: // Z acc
   if (ACC_REVERSED[Z])
     acc[Z] = accOffset[Z] - sensorInputs[AD_ACC_Z];
   else
     acc[Z] = sensorInputs[AD_ACC_Z] - accOffset[Z];
   break;
-  case 10: // yaw gyro
+  case 11: // yaw gyro
     rawGyroSum[YAW] = sensorInputs[AD_GYRO_YAW];
     if (GYRO_REVERSED[YAW])
       yawGyro = gyroOffset[YAW] - sensorInputs[AD_GYRO_YAW];
     else
       yawGyro = sensorInputs[AD_GYRO_YAW] - gyroOffset[YAW];
     break;
-  case 11: // pitch axis acc.
+  case 12: // pitch axis acc.
     if (ACC_REVERSED[PITCH])
       acc[PITCH] = accOffset[PITCH] - sensorInputs[AD_ACC_PITCH];
     else
       acc[PITCH] = sensorInputs[AD_ACC_PITCH] - accOffset[PITCH];
     filteredAcc[PITCH] = (filteredAcc[PITCH] * (ACC_FILTER-1) + acc[PITCH]) / ACC_FILTER;
     measureNoise(acc[PITCH], &accNoisePeak[PITCH], 1);
     break;
-  case 12: // roll axis acc.
+  case 13: // roll axis acc.
     if (ACC_REVERSED[ROLL])
       acc[ROLL] = accOffset[ROLL] - sensorInputs[AD_ACC_ROLL];
     else
       acc[ROLL] = sensorInputs[AD_ACC_ROLL] - accOffset[ROLL];
     filteredAcc[ROLL] = (filteredAcc[ROLL] * (ACC_FILTER-1) + acc[ROLL]) / ACC_FILTER;
     measureNoise(acc[ROLL], &accNoisePeak[ROLL], 1);
     break;
-  case 13: // air pressure
+  case 14: // air pressure
-    if (pressure_wait) {
+    if (pressureAutorangingWait) {
-      // A range switch was done recently. Wait for steadying.
+      //A range switch was done recently. Wait for steadying.
-      pressure_wait--;
+      pressureAutorangingWait--;
       break;
-    }
     range = OCR0A;
     rawAirPressure = sensorInputs[AD_AIRPRESSURE];
     if (rawAirPressure < MIN_RAWPRESSURE) {
       // value is too low, so decrease voltage on the op amp minus input, making the value higher.
-      range -= (MAX_RAWPRESSURE - rawAirPressure) / rangewidth - 1;
+      newrange = OCR0A - (MAX_RAWPRESSURE - rawAirPressure) / rangewidth - 1;
-      if (range < 0) range = 0;
+      if (newrange > MIN_RANGES_EXTRAPOLATION) {
-      pressure_wait = (OCR0A - range) * 4;
+        pressureAutorangingWait = (OCR0A - newrange) * AUTORANGE_WAIT_FACTOR;
-      OCR0A = range;
+        OCR0A = newrange;
+      } else {
+        if (OCR0A) {
+          OCR0A--;
+          pressureAutorangingWait = AUTORANGE_WAIT_FACTOR;
+        }
+      }
     } else if (rawAirPressure > MAX_RAWPRESSURE) {
       // value is too high, so increase voltage on the op amp minus input, making the value lower.
+      // If near the end, make a limited increase
-      range += (rawAirPressure - MIN_RAWPRESSURE) / rangewidth - 1;
+      newrange = OCR0A + (rawAirPressure - MIN_RAWPRESSURE) / rangewidth - 1;
-      if (range > 254) range = 254;
+      if (newrange < MAX_RANGES_EXTRAPOLATION) {
-      pressure_wait = (range - OCR0A) * 4;
+      pressureAutorangingWait = (newrange - OCR0A) * AUTORANGE_WAIT_FACTOR;
-      OCR0A = range;
+      OCR0A = newrange;
+      } else {
+        if (OCR0A<254) {
+          OCR0A++;
+          pressureAutorangingWait = AUTORANGE_WAIT_FACTOR;
+        }
+      }
+    }
+    // Even if the sample is off-range, use it.
+    simpleAirPressure = getSimplePressure(rawAirPressure);
+    if (simpleAirPressure < MIN_RANGES_EXTRAPOLATION * rangewidth) {
+      // Danger: pressure near lower end of range. If the measurement saturates, the
+      // copter may climb uncontrolled... Simulate a drastic reduction in pressure.
+      airPressureSum += (int16_t)MIN_RANGES_EXTRAPOLATION * rangewidth + (simpleAirPressure - (int32_t)MIN_RANGES_EXTRAPOLATION * rangewidth) * PRESSURE_EXTRAPOLATION_COEFF;
+    } else if (simpleAirPressure > MAX_RANGES_EXTRAPOLATION * rangewidth) {
+      // Danger: pressure near upper end of range. If the measurement saturates, the
+      // copter may fall uncontrolled... Simulate a drastic increase in pressure.
+      airPressureSum += (int16_t)MAX_RANGES_EXTRAPOLATION * rangewidth + (simpleAirPressure - (int32_t)MAX_RANGES_EXTRAPOLATION * rangewidth) * PRESSURE_EXTRAPOLATION_COEFF;
     } else {
+      // normal case.
-      filteredAirPressure = filterAirPressure(getAbsPressure(rawAirPressure));
+      airPressureSum += simpleAirPressure;
+    }
+    // 2 samples were added.
+    pressureMeasurementCount += 2;
+    if (pressureMeasurementCount == AIRPRESSURE_SUMMATION_FACTOR) {
+      filteredAirPressure = (filteredAirPressure * (AIRPRESSURE_FILTER-1) + airPressureSum + AIRPRESSURE_FILTER/2) / AIRPRESSURE_FILTER;
+      pressureMeasurementCount = airPressureSum = 0;
+    }
-    DebugOut.Analog[13] = range;
+    // DebugOut.Analog[14] = OCR0A;
-    DebugOut.Analog[14] = rawAirPressure;
+    // DebugOut.Analog[15] = simpleAirPressure;
+    DebugOut.Analog[11] = UBat;
-    DebugOut.Analog[15] = filteredAirPressure;
+    DebugOut.Analog[27] = acc[Z];
     break;
-  case 14:
+  case 15:
-  case 15: // pitch or roll gyro.
+  case 16: // pitch or roll gyro.
-    axis = state - 15;
+    axis = state - 16;
     tempGyro = rawGyroSum[axis] = sensorInputs[AD_GYRO_PITCH - axis];
         // DebugOut.Analog[6 + 3 * axis ] = tempGyro;
     /*
      * Process the gyro data for the PID controller.
      */
     // 1) Extrapolate: Near the ends of the range, we boost the input significantly. This simulates a
     //    gyro with a wider range, and helps counter saturation at full control.
     if (staticParams.GlobalConfig & CFG_ROTARY_RATE_LIMITER) {
       if (tempGyro < SENSOR_MIN_PITCHROLL) {
         tempGyro = tempGyro * EXTRAPOLATION_SLOPE - EXTRAPOLATION_LIMIT;
+      }
       else if (tempGyro > SENSOR_MAX_PITCHROLL) {
         tempGyro = (tempGyro - SENSOR_MAX_PITCHROLL) * EXTRAPOLATION_SLOPE + SENSOR_MAX_PITCHROLL;
+      }
+    }
     // 2) Apply sign and offset, scale before filtering.
     if (GYRO_REVERSED[axis]) {
       tempOffsetGyro = (gyroOffset[axis] - tempGyro) * GYRO_FACTOR_PITCHROLL;
     } else {
       tempOffsetGyro = (tempGyro - gyroOffset[axis]) * GYRO_FACTOR_PITCHROLL;
+    }
     // 3) Scale and filter.
     tempOffsetGyro = (gyro_PID[axis] * (GYROS_PID_FILTER-1) + tempOffsetGyro) / GYROS_PID_FILTER;
     // 4) Measure noise.
     measureNoise(tempOffsetGyro, &gyroNoisePeak[axis], GYRO_NOISE_MEASUREMENT_DAMPING);
     // 5) Differential measurement.
     gyroD[axis] = (gyroD[axis] * (GYROS_D_FILTER-1) + (tempOffsetGyro - gyro_PID[axis])) / GYROS_D_FILTER;
     // 6) Done.
     gyro_PID[axis] = tempOffsetGyro;
     /*
      * Now process the data for attitude angles.
      */
     tempGyro = rawGyroSum[axis];
     // 1) Apply sign and offset, scale before filtering.
     if (GYRO_REVERSED[axis]) {
       tempOffsetGyro = (gyroOffset[axis] - tempGyro) * GYRO_FACTOR_PITCHROLL;
     } else {
       tempOffsetGyro = (tempGyro - gyroOffset[axis]) * GYRO_FACTOR_PITCHROLL;
+    }
     // 2) Filter.
     gyro_ATT[axis] = (gyro_ATT[axis] * (GYROS_ATT_FILTER-1) + tempOffsetGyro) / GYROS_ATT_FILTER;
     break;
+  case 17:
-  case 16:
+    // Battery. The measured value is: (V * 1k/11k)/3v * 1024 = 31.03 counts per volt (max. measurable is 33v).
-    // battery
+    // This is divided by 3 --> 10.34 counts per volt.
     UBat = (3 * UBat + sensorInputs[AD_UBAT] / 3) / 4;
     analogDataReady = 1; // mark
     ADCycleCount++;
     // Stop the sampling. Cycle is over.
     state = 0;
     for (i=0; i<8; i++) {
       sensorInputs[i] = 0;
+    }
     break;
   default: {} // do nothing.
+  }
   // set up for next state.
   ad_channel = pgm_read_byte(&channelsForStates[state]);
   // ad_channel = channelsForStates[state];
   // set adc muxer to next ad_channel
   ADMUX = (ADMUX & 0xE0) | ad_channel;
   // after full cycle stop further interrupts
   if(state) analog_start();
+}
 void analog_calibrate(void) {
 #define GYRO_OFFSET_CYCLES 32
   uint8_t i, axis;
   int32_t deltaOffsets[3] = {0,0,0};
-  int16_t filteredDelta;
   // Set the filters... to be removed again, once some good settings are found.
   GYROS_PID_FILTER = (dynamicParams.UserParams[4]   & 0b00000011)       + 1;
   GYROS_ATT_FILTER = ((dynamicParams.UserParams[4]  & 0b00001100) >> 2) + 1;
   GYROS_D_FILTER = ((dynamicParams.UserParams[4]    & 0b00110000) >> 4) + 1;
   ACC_FILTER = ((dynamicParams.UserParams[4]        & 0b11000000) >> 6) + 1;
   gyro_calibrate();
   // determine gyro bias by averaging (requires that the copter does not rotate around any axis!)
   for(i=0; i < GYRO_OFFSET_CYCLES; i++) {
-    Delay_ms_Mess(10);
+    Delay_ms_Mess(20);
-    for (axis=0; axis<=YAW; axis++) {
+    for (axis=PITCH; axis<=YAW; axis++) {
-      deltaOffsets[axis] += rawGyroSum[axis] - gyroOffset[axis];
+      deltaOffsets[axis] += rawGyroSum[axis];
+    }
+  }
-  for (axis=0; axis<=YAW; axis++) {
+  for (axis=PITCH; axis<=YAW; axis++) {
-    filteredDelta = (deltaOffsets[axis] + GYRO_OFFSET_CYCLES / 2) / GYRO_OFFSET_CYCLES;
+    gyroOffset[axis] =  (deltaOffsets[axis] + GYRO_OFFSET_CYCLES/2) / GYRO_OFFSET_CYCLES;
-    gyroOffset[axis] += filteredDelta;
+    DebugOut.Analog[20+axis] = gyroOffset[axis];
+  }
   // Noise is relative to offset. So, reset noise measurements when changing offsets.
   gyroNoisePeak[PITCH] = gyroNoisePeak[ROLL] = 0;
   accOffset[PITCH] = GetParamWord(PID_ACC_PITCH);
   accOffset[ROLL]  = GetParamWord(PID_ACC_ROLL);
   accOffset[Z]     = GetParamWord(PID_ACC_Z);
+  // Rough estimate. Hmm no nothing happens at calibration anyway.
+  // airPressureSum = simpleAirPressure * (AIRPRESSURE_SUMMATION_FACTOR/2);
+  // pressureMeasurementCount = 0;
+  // Experiment!
+  // filteredAirPressureOffset = filteredAirPressure - 1000L;
   Delay_ms_Mess(100);
+}
 /*
  * Find acc. offsets for a neutral reading, and write them to EEPROM.
  * Does not (!} update the local variables. This must be done with a
  * call to analog_calibrate() - this always (?) is done by the caller
  * anyway. There would be nothing wrong with updating the variables
  * directly from here, though.
  */
 void analog_calibrateAcc(void) {
 #define ACC_OFFSET_CYCLES 10
   uint8_t i, axis;
   int32_t deltaOffset[3] = {0,0,0};
   int16_t filteredDelta;
   // int16_t pressureDiff, savedRawAirPressure;
   for(i=0; i < ACC_OFFSET_CYCLES; i++) {
     Delay_ms_Mess(10);
-    for (axis=0; axis<=YAW; axis++) {
+    for (axis=PITCH; axis<=YAW; axis++) {
-          deltaOffset[axis] += acc[axis];
+      deltaOffset[axis] += acc[axis];
-        }
+    }
+  }
-  for (axis=0; axis<=YAW; axis++) {
+  for (axis=PITCH; axis<=YAW; axis++) {
     filteredDelta = (deltaOffset[axis] + ACC_OFFSET_CYCLES / 2) / ACC_OFFSET_CYCLES;
     accOffset[axis] += ACC_REVERSED[axis] ? -filteredDelta : filteredDelta;
+  }
   // Save ACC neutral settings to eeprom
   SetParamWord(PID_ACC_PITCH, accOffset[PITCH]);
   SetParamWord(PID_ACC_ROLL,  accOffset[ROLL]);
   SetParamWord(PID_ACC_Z,     accOffset[Z]);
   // Noise is relative to offset. So, reset noise measurements when
   // changing offsets.
   accNoisePeak[PITCH] = accNoisePeak[ROLL] = 0;
   // Setting offset values has an influence in the analog.c ISR
   // Therefore run measurement for 100ms to achive stable readings
   Delay_ms_Mess(100);
   // Set the feedback so that air pressure ends up in the middle of the range.
   // (raw pressure high --> OCR0A also high...)
   // OCR0A += (rawAirPressure - 512) / rangewidth;
   // Delay_ms_Mess(500);
   /*
     pressureDiff = 0;
-    DebugOut.Analog[16] = rawAirPressure;
+    // DebugOut.Analog[16] = rawAirPressure;
     #define PRESSURE_CAL_CYCLE_COUNT 2
     for (i=0; i<PRESSURE_CAL_CYCLE_COUNT; i++) {
     savedRawAirPressure = rawAirPressure;
     OCR0A++;
     Delay_ms_Mess(200);
     // raw pressure will decrease.
     pressureDiff += (savedRawAirPressure - rawAirPressure);
     savedRawAirPressure = rawAirPressure;
     OCR0A--;
     Delay_ms_Mess(200);
     // raw pressure will increase.
     pressureDiff += (rawAirPressure - savedRawAirPressure);
+    }
-    DebugOut.Analog[16] = rangewidth =
+    // DebugOut.Analog[16] =
-    (pressureDiff + PRESSURE_CAL_CYCLE_COUNT * 2 - 1) / (PRESSURE_CAL_CYCLE_COUNT * 2);
+    rangewidth = (pressureDiff + PRESSURE_CAL_CYCLE_COUNT * 2 - 1) / (PRESSURE_CAL_CYCLE_COUNT * 2);
   */
+}

Subversion Repositories FlightCtrl

(root)/branches/dongfang_FC_rewrite/analog.c @ 1845 - Rev 1646 → 1775