ATtiny2313 ISR wirft mein Timing durcheinander

[Gareth]

Ja, so kriegt man zwar nicht ohne Weiteres die perfekten Zeitabstände hin (bei delayms gibt mans ja direkt an), aber das auch nicht besonders schlimm.
Kann es sein, dass wenn man bei einem 0..255-Timer, bei dem man sowohl die OCR-Compare-Match ISR, als auch die Overflow-ISR verwenden will und man einen PRescaler von 0 oder 8 nimmt, die Compare-Match ISR gar nicht mehr zum Zug kommt?

Ich hab nämlich versucht eine Hardware-PWM und und eine Software-PWM gleichzeitig am selben Timer zu benutzen. Wenn ich den 64er Prescaler benutze (damit fadet die LED an der Hardware-PWM optimal) und die selbst gemachte Counter-Variable der Software-PWM immer von der Overflow-ISR weiterzählen lasse, läuft selbiges natürlich 256mal langsamer ab, als alles an der Hardware-PWM; aber es läuft.
Als ich die Software-PWM dann aber beschleunigen wollte, indem ich den Prescaler runtersetzte (egal, dass die LED an der Hardware-PWM dann nur noch flackert), hat sich an der Software-PWM-LED gar nichts mehr getan.
Ist es vielleicht so, dass die OCR-Compare-Match-ISR eine höhere Priorität hat, als die Overflow-ISR und sich die Overflow-ISR dann schon jedesmal anstellt, aber dass die Compare-Match-ISR selber so lange läuft, dass die nächste schon ansteht, sobald eine fertig ist und sich somit immer die Compare-Match-ISRs vordrängeln?

So siehts bei mir aus:

#define F_CPU 1000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h> 

volatile  uint8_t OCR0Adirection=0, OCR0Avalue=1; 
			 //0->OCR0A raufzählen 1-> OCR0A runterzählen

	ISR(TIMER0_COMPA_vect){

		if(OCR0Adirection==0){
			OCR0Avalue += 1;
			if(OCR0Avalue==254) OCR0Adirection=1;
		}else

		//if(OCR0Adirection==1){ //kann eingespart werden
		{
			OCR0Avalue -= 1;
			if(OCR0Avalue==1) OCR0Adirection=0;
		}
		OCR0A = OCR0Avalue; //nur einmal schreiben, statt zweimal lesen und einmal schreiben
	}


/*	Erstmal mit nur einer LED, nämlich PB4.Nachgebildet werden soll eine Fast PWM. Bei jedem
	Overflow des Timers wird die Funktion einmal ausgeführt und erhöht den Counter (softTCNT).
	Trifft dieser den OCR-Wert der LED, wird diese angeschaltet. Erreicht der Counter sein max.
	und wird wieder auf 0 gesetzt, wird die LED wieder ausgeschaltet.
	Bei der Hardware-PWM kann man wählen, ob man den OCR-Wert in der Hauptschleife mit im Abstand
	von z.B. 12ms um einen bestimmten Wert heraufsetzt oder das (besser) in einer ISR macht.
	In letzterem Fall muss darauf geachtet werden, dass die den OCR verändernde ISR nicht zu
	schnell hintereinander aufgerufen wird, da man sonst wesentlich weniger als 12ms zwischen
	den LED-Helligkeiten haben kann und sie somit viel zu schnell fadet. Deshalb sollte der
	Prescaler so hoch eingestellt werden, dass die LED gerade noch nicht-flackernd aussieht
	und der Wert um den der OCR jedes Mal verändert wird, sollte möglichst klein sein.
	Bei gleichzeitiger Verwendung einer Hardware- und einer Software-PWM kann dieser hohe
	Prescaler zum Problem werden. Denn während die Hardware-PWM ihren Counter 256 mal erhöht, tut
	dies die Software-PWM (bei Verwendung des selben Timers) nur einmal.
*/
volatile uint8_t softLED1direction=0, softLED1OCR=0, softTCNT=0;
	ISR(TIMER0_OVF_vect){ //software PWM
		softTCNT++;//counter bei jedem aufruf weiterzählen
		if(softTCNT==255){//einmal pro counter-runde, also am ende, bei 255
			softTCNT=0;//wird der counter auf anfang gesetzt
			PORTB &= ~(1<<PB4);//die led geht aus
			if(softLED1direction==0){//und es wird der OCR-wert der LED weitergezählt
				softLED1OCR++;//und zwar entweder rauf
				if(softLED1OCR==255) softLED1direction=1;
			} else{//oder runter, je nach direction
				softLED1OCR--;
				if(softLED1OCR==0) softLED1direction=0;
			}
		}

		if(softTCNT == softLED1OCR){//sobald der counter in einer runde (0..255) den OCR der
			PORTB |= (1<<PB4);//LED erreicht, wird diese angeschaltet
		}
		

	}/*	Theoretisch sollte diese soft-PWM genauso schnell faden wie die Hardware-PWM (oben)
		denn auch hier wird der OCR einmal pro Counter-Zyklus verändert. Jedoch läuft das Ganze
		255 mal langsamer ab, sofern man nichts am Prescaler ändert oder nicht einen Timer 
		verwendet, mit einem Modus, dessen obere Zählgrenze kleiner (in OCR gesetzt) ist
		und der diese Overflow-ISR somit ofter, als alle 255 Takte ausführt.
		*/


/* //zum Testen von Hard- und Software-PWM gleichzeitig, erstmal diese Funktion rausnehmen
uint8_t CurrentLED=0;

void LEDleuchten(){

	if(OCR0Avalue==1 || OCR0Avalue==64 || OCR0Avalue==128 
					|| OCR0Avalue==192 || OCR0Avalue==254){//wenn timer0 am endpunkt

		switch(CurrentLED){//erst die betroffene LED aus
			case 0: PORTB &= ~(1<<PB4); break;
			case 1: PORTD &= ~(1<<PD5); break; 
			case 2: PORTA &= ~(1<<PA0); 
		}

		CurrentLED++;//dann zur nächsten wechseln
		if(CurrentLED==3)CurrentLED=0;
		
		switch(CurrentLED){//und diese anschalten
			case 0: PORTB |= (1<<PB4); break; 
			case 1: PORTD |= (1<<PD5); break; 
			case 2: PORTA |= (1<<PA0); 
		}	

		while(OCR0Avalue==1 || OCR0Avalue==64 || OCR0Avalue==128 
		   || OCR0Avalue==192 || OCR0Avalue==254){}//weil sonst sofort weitergeschaltet wird		
	}	
}*/

int main (void)
{
        
               
                TCCR0A = (1 << COM0A1) | (1 << COM0A0) | (1 << WGM00) | (1 << WGM01);
                

				//TCCR0B = (1 << CS00);//no Prescaler
                TCCR0B = (1 << CS01);//Prescaler CPU/8 
				//TCCR0B = (1 << CS00) | (1 << CS01);//Prescaler CPU/64 
				//TCCR0B = (1 << CS02);//Prescaler CPU/256
				//TCCR0B = (1 << CS00) | (1 << CS02);//Prescaler CPU/1024

                OCR0A = 1; //Startwert, pendelt dann zwischen 0..255

                DDRB = (1 << PB2); //pin PB2 auf Ausgang (das ist OC0A)
				
				//blinkende led PB4, PD5, PA0
               	DDRD |= (1 << PD5);
				DDRB |= (1 << PB4);
				DDRA |= (1 << PA0);

				//ISRs für OCR0A Compare Match und für Timer Overflow aktivieren
				TIMSK = (1 << OCIE0A) | (1 << TOIE0);
			   	
				sei();

                while(1){

					//LEDleuchten();
                       
					
               		

          
                }

}