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

 volatile uint8_t GYROS_ATT_FILTER;
 volatile uint8_t GYROS_D_FILTER;
 volatile uint8_t ACC_FILTER;
 /*
- * Air pressure measurement.
+ * Air pressure
  */
+volatile uint8_t rangewidth = 106;
-#define MIN_RAWPRESSURE 200
-#define MAX_RAWPRESSURE (1023-MIN_RAWPRESSURE)
+// Direct from sensor, irrespective of range.
+// volatile uint16_t rawAirPressure;
-volatile uint8_t rangewidth = 53;
+// Value of 2 samples, with range.
+volatile uint16_t simpleAirPressure;
-volatile uint16_t rawAirPressure;
+// Value of AIRPRESSURE_SUMMATION_FACTOR samples, with range, filtered.
+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 uint16_t filteredAirPressure;
+volatile uint8_t pressureMeasurementCount;
 /*
  * Battery voltage, in units of: 1k/11k / 3V * 1024 = 31.03 per volt.
   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
   } 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 uint16_t sensorInputs[8] = {0,0,0,0,0,0,0,0};
+  static uint16_t pressureAutorangingWait = 25;
-  static uint8_t pressure_wait = 10;
+  uint16_t rawAirPressure;
   uint8_t i, axis;
-  int16_t range;
+  int16_t newrange;
   /*
    * 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) {
-      // A range switch was done recently. Wait for steadying.
+    if (pressureAutorangingWait) {
-      pressure_wait--;
+      //A range switch was done recently. Wait for steadying.
-      break;
+      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.
+      newrange = OCR0A - (MAX_RAWPRESSURE - rawAirPressure) / rangewidth - 1;
+      if (newrange > MIN_RANGES_EXTRAPOLATION) {
+        pressureAutorangingWait = (OCR0A - newrange) * AUTORANGE_WAIT_FACTOR;
+        OCR0A = newrange;
+      } else {
-      // value is too low, so decrease voltage on the op amp minus input, making the value higher.
+        if (OCR0A) {
-      range -= (MAX_RAWPRESSURE - rawAirPressure) / rangewidth - 1;
+          OCR0A--;
+          pressureAutorangingWait = AUTORANGE_WAIT_FACTOR;
-      if (range < 0) range = 0;
+        }
-      pressure_wait = (OCR0A - range) * 4;
+      }
-      OCR0A = range;
+    } else if (rawAirPressure > MAX_RAWPRESSURE) {
-    } 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
+      newrange = OCR0A + (rawAirPressure - MIN_RAWPRESSURE) / rangewidth - 1;
+      if (newrange < MAX_RANGES_EXTRAPOLATION) {
+      pressureAutorangingWait = (newrange - OCR0A) * AUTORANGE_WAIT_FACTOR;
+      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.
-      // value is too high, so increase voltage on the op amp minus input, making the value lower.
+      airPressureSum += (int16_t)MIN_RANGES_EXTRAPOLATION * rangewidth + (simpleAirPressure - (int32_t)MIN_RANGES_EXTRAPOLATION * rangewidth) * PRESSURE_EXTRAPOLATION_COEFF;
+    } else if (simpleAirPressure > MAX_RANGES_EXTRAPOLATION * rangewidth) {
-      range += (rawAirPressure - MIN_RAWPRESSURE) / rangewidth - 1;
+      // Danger: pressure near upper end of range. If the measurement saturates, the
-      if (range > 254) range = 254;
+      // 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.
+      airPressureSum += simpleAirPressure;
+    }
+    // 2 samples were added.
-      pressure_wait = (range - OCR0A) * 4;
+    pressureMeasurementCount += 2;
-      OCR0A = range;
+    if (pressureMeasurementCount == AIRPRESSURE_SUMMATION_FACTOR) {
-    } else {
+      filteredAirPressure = (filteredAirPressure * (AIRPRESSURE_FILTER-1) + airPressureSum + AIRPRESSURE_FILTER/2) / AIRPRESSURE_FILTER;
+      pressureMeasurementCount = airPressureSum = 0;
       filteredAirPressure = filterAirPressure(getAbsPressure(rawAirPressure));
-    }
+    // DebugOut.Analog[14] = OCR0A;
-    DebugOut.Analog[13] = range;
+    // DebugOut.Analog[15] = simpleAirPressure;
-    DebugOut.Analog[14] = rawAirPressure;
+    DebugOut.Analog[11] = UBat;
-    DebugOut.Analog[15] = filteredAirPressure;
+    DebugOut.Analog[27] = acc[Z];
     break;
-  case 14:
+  case 15:
     // 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++;
 void analog_calibrate(void) {
 #define GYRO_OFFSET_CYCLES 32
   uint8_t i, axis;
-  int32_t deltaOffsets[3] = {0,0,0};
-  int16_t filteredDelta;
+  int32_t deltaOffsets[3] = {0,0,0};
   // Set the filters... to be removed again, once some good settings are found.
   GYROS_PID_FILTER = (dynamicParams.UserParams[4]   & 0b00000011)       + 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.
-  gyroNoisePeak[PITCH] = gyroNoisePeak[ROLL] = 0;
+  // airPressureSum = simpleAirPressure * (AIRPRESSURE_SUMMATION_FACTOR/2);
   // pressureMeasurementCount = 0;
   accOffset[PITCH] = GetParamWord(PID_ACC_PITCH);
-  accOffset[ROLL]  = GetParamWord(PID_ACC_ROLL);
+  // Experiment!
   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;
   // 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++) {
     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 - Rev 1646 → 1775