Subversion Repositories FlightCtrl

Rev

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

Rev Author Line No. Line
1910 - 1
#include <avr/io.h>
2
#include <avr/interrupt.h>
3
#include "eeprom.h"
2102 - 4
#include "output.h"
5
#include "flight.h"
1910 - 6
#include "attitude.h"
2104 - 7
#include "timer2.h"
1910 - 8
 
2102 - 9
// #define COARSERESOLUTION 1
1910 - 10
 
2099 - 11
#ifdef COARSERESOLUTION
12
#define NEUTRAL_PULSELENGTH 938
13
#define STABILIZATION_LOG_DIVIDER 6
14
#define SERVOLIMIT 500
15
#define SCALE_FACTOR 4
16
#define CS2 ((1<<CS21)|(1<<CS20))
1910 - 17
 
2099 - 18
#else
19
#define NEUTRAL_PULSELENGTH 3750
20
#define STABILIZATION_LOG_DIVIDER 4
21
#define SERVOLIMIT 2000
22
#define SCALE_FACTOR 16
23
#define CS2 (1<<CS21)
24
#endif
1910 - 25
 
2099 - 26
#define FRAMELEN ((NEUTRAL_PULSELENGTH + SERVOLIMIT) * staticParams.servoCount + 128)
27
#define MIN_PULSELENGTH (NEUTRAL_PULSELENGTH - SERVOLIMIT)
28
#define MAX_PULSELENGTH (NEUTRAL_PULSELENGTH + SERVOLIMIT)
29
 
30
volatile uint8_t recalculateServoTimes = 0;
31
volatile uint16_t servoValues[MAX_SERVOS];
32
volatile uint16_t previousManualValues[2];
33
 
34
#define HEF4017R_ON     PORTC |=  (1<<PORTC6)
35
#define HEF4017R_OFF    PORTC &= ~(1<<PORTC6)
36
 
2109 - 37
//#define HEF4017R_ON ;
38
//#define HEF4017R_OFF ;
39
 
1910 - 40
/*****************************************************
2099 - 41
 *              Initialize Timer 2
1910 - 42
 *****************************************************/
43
void timer2_init(void) {
2099 - 44
    uint8_t sreg = SREG;
1910 - 45
 
2099 - 46
    // disable all interrupts before reconfiguration
47
    cli();
48
 
49
    // set PD7 as output of the PWM for pitch servo
50
    DDRD |= (1 << DDD7);
51
    PORTD &= ~(1 << PORTD7); // set PD7 to low
52
 
53
    DDRC |= (1 << DDC6); // set PC6 as output (Reset for HEF4017)
2109 - 54
    HEF4017R_ON; // reset
2099 - 55
 
56
    // Timer/Counter 2 Control Register A
57
    // Timer Mode is CTC (Bits: WGM22 = 0, WGM21 = 1, WGM20 = 0)
58
    // PD7: Output OCR2 match, (Bits: COM2A1 = 1, COM2A0 = 0)
59
    // PD6: Normal port operation, OC2B disconnected, (Bits: COM2B1 = 0, COM2B0 = 0)
60
    TCCR2A &= ~((1 << COM2A0) | (1 << COM2B1) | (1 << COM2B0) | (1 << WGM20) | (1 << WGM22));
61
    TCCR2A |= (1 << COM2A1) | (1 << WGM21);
62
 
63
    // Timer/Counter 2 Control Register B
64
 
65
    // Set clock divider for timer 2 to 20MHz / 8 = 2.5 MHz
66
    // The timer increments from 0x00 to 0xFF with an update rate of 2.5 kHz or 0.4 us
67
    // hence the timer overflow interrupt frequency is 625 kHz / 256 = 9.765 kHz or 0.1024ms
68
 
69
    TCCR2B &= ~((1 << FOC2A) | (1 << FOC2B) | (1 << CS20) | (1 << CS21) | (1 << CS22));
70
    TCCR2B |= CS2;
71
 
72
    // Initialize the Timer/Counter 2 Register
73
    TCNT2 = 0;
74
 
75
    // Initialize the Output Compare Register A used for signal generation on port PD7.
76
    OCR2A = 255;
77
 
78
    // Timer/Counter 2 Interrupt Mask Register
79
    // Enable timer output compare match A Interrupt only
80
    TIMSK2 &= ~((1 << OCIE2B) | (1 << TOIE2));
81
    TIMSK2 |= (1 << OCIE2A);
82
 
83
    for (uint8_t axis=0; axis<2; axis++)
2119 - 84
      previousManualValues[axis] = dynamicParams.gimbalServoManualControl[axis] * SCALE_FACTOR;
2099 - 85
 
86
    SREG = sreg;
1910 - 87
}
88
 
89
/*****************************************************
2102 - 90
 * Control (camera gimbal etc.) servos
1910 - 91
 *****************************************************/
2099 - 92
int16_t calculateStabilizedServoAxis(uint8_t axis) {
93
  int32_t value = attitude[axis] >> STABILIZATION_LOG_DIVIDER; // between -500000 to 500000 extreme limits. Just about
94
  // With full blast on stabilization gain (255) we want to convert a delta of, say, 125000 to 2000.
95
  // That is a divisor of about 1<<14. Same conclusion as H&I.
2119 - 96
  value *= staticParams.gimbalServoConfigurations[axis].stabilizationFactor;
2099 - 97
  value = value >> 8;
2119 - 98
  if (staticParams.gimbalServoConfigurations[axis].flags & SERVO_STABILIZATION_REVERSE)
2099 - 99
    return -value;
100
  return value;
101
}
102
 
103
// With constant-speed limitation.
104
uint16_t calculateManualServoAxis(uint8_t axis, uint16_t manualValue) {
105
  int16_t diff = manualValue - previousManualValues[axis];
2119 - 106
  uint8_t maxSpeed = staticParams.gimbalServoMaxManualSpeed;
2099 - 107
  if (diff > maxSpeed) diff = maxSpeed;
108
  else if (diff < -maxSpeed) diff = -maxSpeed;
109
  manualValue = previousManualValues[axis] + diff;
110
  previousManualValues[axis] = manualValue;
111
  return manualValue;
112
}
113
 
114
// add stabilization and manual, apply soft position limits.
115
// All in a [0..255*SCALE_FACTOR] space (despite signed types used internally)
116
int16_t featuredServoValue(uint8_t axis) {
2119 - 117
  int16_t value = calculateManualServoAxis(axis, dynamicParams.gimbalServoManualControl[axis] * SCALE_FACTOR);
2099 - 118
  value += calculateStabilizedServoAxis(axis);
2119 - 119
  int16_t limit = staticParams.gimbalServoConfigurations[axis].minValue * SCALE_FACTOR;
2099 - 120
  if (value < limit) value = limit;
2119 - 121
  limit = staticParams.gimbalServoConfigurations[axis].maxValue * SCALE_FACTOR;
2099 - 122
  if (value > limit) value = limit;
123
  value -= (128 * SCALE_FACTOR);
124
  if (value < -SERVOLIMIT) value = -SERVOLIMIT;
125
  else if (value > SERVOLIMIT) value = SERVOLIMIT;
126
  // Shift into the [NEUTRAL_PULSELENGTH-SERVOLIMIT..NEUTRAL_PULSELENGTH+SERVOLIMIT] space.
127
  return value + NEUTRAL_PULSELENGTH;
128
}
129
 
2102 - 130
void calculateControlServoValues(void) {
131
  int16_t value;
2119 - 132
  //int16_t minLimit = staticParams.controlServoMinValue * SCALE_FACTOR;
133
  //int16_t maxLimit = staticParams.controlServoMaxValue * SCALE_FACTOR;
2103 - 134
  for (uint8_t axis=0; axis<4; axis++) {
2102 - 135
        value = controlServos[axis];
2119 - 136
        if (value < -SERVOLIMIT) value = -SERVOLIMIT;
137
    else if (value > SERVOLIMIT) value = SERVOLIMIT;
2102 - 138
        servoValues[axis] = value + NEUTRAL_PULSELENGTH;
139
  }
140
}
141
 
142
void calculateFeaturedServoValues(void) {
143
  int16_t value;
144
  uint8_t axis;
145
 
146
  // Save the computation cost of computing a new value before the old one is used.
2099 - 147
  if (!recalculateServoTimes) return;
2102 - 148
 
2104 - 149
  for (axis= MAX_CONTROL_SERVOS; axis<MAX_CONTROL_SERVOS+2; axis++) {
150
        value = featuredServoValue(axis-MAX_CONTROL_SERVOS);
151
        servoValues[axis] = value;
2099 - 152
  }
2104 - 153
  for (axis=MAX_CONTROL_SERVOS+2; axis<MAX_SERVOS; axis++) {
2102 - 154
        value = 128 * SCALE_FACTOR;
2104 - 155
        servoValues[axis] = value;
2102 - 156
  }
157
 
2099 - 158
  recalculateServoTimes = 0;
159
}
160
 
1910 - 161
ISR(TIMER2_COMPA_vect) {
2099 - 162
  static uint16_t remainingPulseTime;
1910 - 163
  static uint8_t servoIndex = 0;
164
  static uint16_t sumOfPulseTimes = 0;
165
 
166
  if (!remainingPulseTime) {
167
    // Pulse is over, and the next pulse has already just started. Calculate length of next pulse.
2099 - 168
    if (servoIndex < staticParams.servoCount) {
1910 - 169
      // There are more signals to output.
2099 - 170
      sumOfPulseTimes += (remainingPulseTime = servoValues[servoIndex]);
1910 - 171
      servoIndex++;
172
    } else {
173
      // There are no more signals. Reset the counter and make this pulse cover the missing frame time.
174
      remainingPulseTime = FRAMELEN - sumOfPulseTimes;
175
      sumOfPulseTimes = servoIndex = 0;
2099 - 176
      recalculateServoTimes = 1;
177
      HEF4017R_ON;
1910 - 178
    }
179
  }
180
 
181
  // Schedule the next OCR2A event. The counter is already reset at this time.
2099 - 182
  if (remainingPulseTime > 256+128) {
183
    // Set output to reset to zero at next OCR match. It does not really matter when the output is set low again,
1910 - 184
    // as long as it happens once per pulse. This will, because all pulses are > 255+128 long.
2099 - 185
    OCR2A = 255;
1910 - 186
    TCCR2A &= ~(1<<COM2A0);
2099 - 187
    remainingPulseTime-=256;
188
  } else if (remainingPulseTime > 256) {
189
    // Remaining pulse lengths in the range [256..256+128] might cause trouble if handled the standard
190
    // way, which is in chunks of 256. The remainder would be very small, possibly causing an interrupt on interrupt
1910 - 191
    // condition. Instead we now make a chunk of 128. The remaining chunk will then be in [128..255] which is OK.
2099 - 192
    remainingPulseTime-=128;
193
    OCR2A=127;
1910 - 194
  } else {
195
    // Set output to high at next OCR match. This is when the 4017 counter will advance by one. Also set reset low
196
    TCCR2A |= (1<<COM2A0);
2099 - 197
    OCR2A = remainingPulseTime-1;
198
    remainingPulseTime=0;
199
    HEF4017R_OFF; // implement servo-disable here, by only removing the reset signal if ServoEnabled!=0.
1910 - 200
  }
201
}