WebSVN - FlightCtrl - Diff - Rev 2119 and 2125 - /branches/dongfang_FC


#include <avr/io.h>
#include <avr/interrupt.h>
#include "eeprom.h"
#include "output.h"
#include "flight.h"
#include "attitude.h"
#include "timer2.h"
 
// #define COARSERESOLUTION 1
 
#ifdef COARSERESOLUTION
#define NEUTRAL_PULSELENGTH 938
#define STABILIZATION_LOG_DIVIDER 6
#define SERVOLIMIT 500
#define SCALE_FACTOR 4
#define CS2 ((1<<CS21)|(1<<CS20))
 
#else
#define NEUTRAL_PULSELENGTH 3750
#define STABILIZATION_LOG_DIVIDER 4
#define SERVOLIMIT 2000
#define SCALE_FACTOR 16
#define CS2 (1<<CS21)
#endif
 
#define FRAMELEN ((NEUTRAL_PULSELENGTH + SERVOLIMIT) * staticParams.servoCount + 128)
#define MIN_PULSELENGTH (NEUTRAL_PULSELENGTH - SERVOLIMIT)
#define MAX_PULSELENGTH (NEUTRAL_PULSELENGTH + SERVOLIMIT)
 
volatile uint8_t recalculateServoTimes = 0;
volatile uint16_t servoValues[MAX_SERVOS];
volatile uint16_t previousManualValues[2];
 
#define HEF4017R_ON     PORTC |=  (1<<PORTC6)
#define HEF4017R_OFF    PORTC &= ~(1<<PORTC6)
 
//#define HEF4017R_ON ;
//#define HEF4017R_OFF ;
 
/*****************************************************
 *              Initialize Timer 2
 *****************************************************/
void timer2_init(void) {
    uint8_t sreg = SREG;
 
    // disable all interrupts before reconfiguration
    cli();
 
    // set PD7 as output of the PWM for pitch servo
    DDRD |= (1 << DDD7);
    PORTD &= ~(1 << PORTD7); // set PD7 to low
 
    DDRC |= (1 << DDC6); // set PC6 as output (Reset for HEF4017)
    HEF4017R_ON; // reset
 
    // Timer/Counter 2 Control Register A
    // Timer Mode is CTC (Bits: WGM22 = 0, WGM21 = 1, WGM20 = 0)
    // PD7: Output OCR2 match, (Bits: COM2A1 = 1, COM2A0 = 0)
    // PD6: Normal port operation, OC2B disconnected, (Bits: COM2B1 = 0, COM2B0 = 0)
    TCCR2A &= ~((1 << COM2A0) | (1 << COM2B1) | (1 << COM2B0) | (1 << WGM20) | (1 << WGM22));
    TCCR2A |= (1 << COM2A1) | (1 << WGM21);
 
    // Timer/Counter 2 Control Register B
 
    // Set clock divider for timer 2 to 20MHz / 8 = 2.5 MHz
    // The timer increments from 0x00 to 0xFF with an update rate of 2.5 kHz or 0.4 us
    // hence the timer overflow interrupt frequency is 625 kHz / 256 = 9.765 kHz or 0.1024ms
 
    TCCR2B &= ~((1 << FOC2A) | (1 << FOC2B) | (1 << CS20) | (1 << CS21) | (1 << CS22));
    TCCR2B |= CS2;
 
    // Initialize the Timer/Counter 2 Register
    TCNT2 = 0;
 
    // Initialize the Output Compare Register A used for signal generation on port PD7.
    OCR2A = 255;
 
    // Timer/Counter 2 Interrupt Mask Register
    // Enable timer output compare match A Interrupt only
    TIMSK2 &= ~((1 << OCIE2B) | (1 << TOIE2));
    TIMSK2 |= (1 << OCIE2A);
 
    for (uint8_t axis=0; axis<2; axis++)
      previousManualValues[axis] = dynamicParams.gimbalServoManualControl[axis] * SCALE_FACTOR;
 
    SREG = sreg;
}
 
/*****************************************************
 * Control (camera gimbal etc.) servos
 *****************************************************/
int16_t calculateStabilizedServoAxis(uint8_t axis) {
  int32_t value = attitude[axis] >> STABILIZATION_LOG_DIVIDER; // between -500000 to 500000 extreme limits. Just about
  // With full blast on stabilization gain (255) we want to convert a delta of, say, 125000 to 2000.
  // That is a divisor of about 1<<14. Same conclusion as H&I.
  value *= staticParams.gimbalServoConfigurations[axis].stabilizationFactor;
  value = value >> 8;
  if (staticParams.gimbalServoConfigurations[axis].flags & SERVO_STABILIZATION_REVERSE)
    return -value;
  return value;
}
 
// With constant-speed limitation.
uint16_t calculateManualServoAxis(uint8_t axis, uint16_t manualValue) {
  int16_t diff = manualValue - previousManualValues[axis];
  uint8_t maxSpeed = staticParams.gimbalServoMaxManualSpeed;
  if (diff > maxSpeed) diff = maxSpeed;
  else if (diff < -maxSpeed) diff = -maxSpeed;
  manualValue = previousManualValues[axis] + diff;
  previousManualValues[axis] = manualValue;
  return manualValue;
}
 
// add stabilization and manual, apply soft position limits.
// All in a [0..255*SCALE_FACTOR] space (despite signed types used internally)
int16_t featuredServoValue(uint8_t axis) {
  int16_t value = calculateManualServoAxis(axis, dynamicParams.gimbalServoManualControl[axis] * SCALE_FACTOR);
  value += calculateStabilizedServoAxis(axis);
  int16_t limit = staticParams.gimbalServoConfigurations[axis].minValue * SCALE_FACTOR;
  if (value < limit) value = limit;
  limit = staticParams.gimbalServoConfigurations[axis].maxValue * SCALE_FACTOR;
  if (value > limit) value = limit;
  value -= (128 * SCALE_FACTOR);
  if (value < -SERVOLIMIT) value = -SERVOLIMIT;
  else if (value > SERVOLIMIT) value = SERVOLIMIT;
  // Shift into the [NEUTRAL_PULSELENGTH-SERVOLIMIT..NEUTRAL_PULSELENGTH+SERVOLIMIT] space.
  return value + NEUTRAL_PULSELENGTH;
}
 
void calculateControlServoValues(void) {
  int16_t value;
  //int16_t minLimit = staticParams.controlServoMinValue * SCALE_FACTOR;
  //int16_t maxLimit = staticParams.controlServoMaxValue * SCALE_FACTOR;
  for (uint8_t axis=0; axis<4; axis++) {
        value = controlServos[axis];
        if (value < -SERVOLIMIT) value = -SERVOLIMIT;
    else if (value > SERVOLIMIT) value = SERVOLIMIT;
        servoValues[axis] = value + NEUTRAL_PULSELENGTH;
  }
 
 
 
 
}
 
void calculateFeaturedServoValues(void) {
  int16_t value;
  uint8_t axis;
 
  // Save the computation cost of computing a new value before the old one is used.
  if (!recalculateServoTimes) return;
 
  for (axis= MAX_CONTROL_SERVOS; axis<MAX_CONTROL_SERVOS+2; axis++) {
        value = featuredServoValue(axis-MAX_CONTROL_SERVOS);
        servoValues[axis] = value;
  }
  for (axis=MAX_CONTROL_SERVOS+2; axis<MAX_SERVOS; axis++) {
        value = 128 * SCALE_FACTOR;
        servoValues[axis] = value;
  }
 
  recalculateServoTimes = 0;
}
 
ISR(TIMER2_COMPA_vect) {
  static uint16_t remainingPulseTime;
  static uint8_t servoIndex = 0;
  static uint16_t sumOfPulseTimes = 0;
 
  if (!remainingPulseTime) {
    // Pulse is over, and the next pulse has already just started. Calculate length of next pulse.
    if (servoIndex < staticParams.servoCount) {
      // There are more signals to output.
      sumOfPulseTimes += (remainingPulseTime = servoValues[servoIndex]);
      servoIndex++;
    } else {
      // There are no more signals. Reset the counter and make this pulse cover the missing frame time.
      remainingPulseTime = FRAMELEN - sumOfPulseTimes;
      sumOfPulseTimes = servoIndex = 0;
      recalculateServoTimes = 1;
      HEF4017R_ON;
    }
  }
 
  // Schedule the next OCR2A event. The counter is already reset at this time.
  if (remainingPulseTime > 256+128) {
    // Set output to reset to zero at next OCR match. It does not really matter when the output is set low again,
    // as long as it happens once per pulse. This will, because all pulses are > 255+128 long.
    OCR2A = 255;
    TCCR2A &= ~(1<<COM2A0);
    remainingPulseTime-=256;
  } else if (remainingPulseTime > 256) {
    // Remaining pulse lengths in the range [256..256+128] might cause trouble if handled the standard
    // way, which is in chunks of 256. The remainder would be very small, possibly causing an interrupt on interrupt
    // condition. Instead we now make a chunk of 128. The remaining chunk will then be in [128..255] which is OK.
    remainingPulseTime-=128;
    OCR2A=127;
  } else {
    // Set output to high at next OCR match. This is when the 4017 counter will advance by one. Also set reset low
    TCCR2A |= (1<<COM2A0);
    OCR2A = remainingPulseTime-1;
    remainingPulseTime=0;
    HEF4017R_OFF; // implement servo-disable here, by only removing the reset signal if ServoEnabled!=0.
  }
}
 

Subversion Repositories FlightCtrl

(root)/branches/dongfang_FC_fixedwing/timer2.c - Rev 2119 → 2125

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