Atmega 16 PWM über Komparator unterbrechen

[Steffen H. (stef_fen)]

Hallo Zusammen,

ich möchte mittels eines Stromsensors der am Komparator Eingang AIN1 des 
Atmega 16 angeschlossen ist die PWM ausschalten und damit die Mosfets 
vor Überstrom schützen. Dazu habe ich erst mal anstatt des Stromsensors 
einen Spannungsteiler bestehend aus 10k und einem 10k Poti an den AIN1 
Eingang geschaltet. Als Referenzspannung dienen die internen 1,3 Volt. 
Zum Test schaltet der Komparator eine LED. Aber wie kann ich jetzt die 
PWM unterbrechen? Wenn ich in der ISR ANA_COMP_vect den Befehl OCR2 = 0 
reinschreibe zuckt der Motor auch mal ganz kurz aber dann läuft er ganz 
normal weiter.

Vielen Dank. Gruß Steffen

//Bibliotheken einbinden
#define F_CPU 8000000
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include "lcd-routines.h"
#include <stdlib.h>
#include <util/delay.h>

//Variablendeklaration
uint16_t eeunten EEMEM;  //fuer EEPROM
uint16_t unten;      //fuer EEPROM
uint16_t eeoben EEMEM;  //fuer EEPROM
uint16_t oben;      //fuer EEPROM
int flanke;        //fuer PWM
uint16_t flankeStart;  //fuer PWM
volatile uint16_t pwm;  //fuer PWM (volatile = Global gueltig)
char Buffer[20];    //fuer LCD
int lcdpwm;        //fuer LCD
float i;        //fuer Rechnung
float j;        //fuer Rechnung
int k;          //fuer Rechnung

ISR(TIMER1_CAPT_vect)
{
  // Initialiserung fuer PWM einlesen vom Empfänger
  if (flanke==0)
  {
    flankeStart = ICR1;
    TCCR1B &= ~(1<<ICES1); // fallende Flanke zur Auswertung des ICP
    flanke = 1;
  }
  else
  {
    pwm = ICR1 - flankeStart;
    flanke = 0;
    TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  }
  TIFR = ( 1 << ICF1 );  
}

ISR(ANA_COMP_vect)
{
  //Intialisierung fuer Strommessung
  if bit_is_clear(ACSR, ACO)
  {
    PORTB &= ~(1<<PB1);  //LED ein
    //OCR2 = 0;
  }
  else
  {
    PORTB |= (1<<PB1); //LED aus  
  }
}

void PWM_Mosfet(void)
{
  /*Initialisierung fuer PWM ausgeben an Mosfet Treiber
  PWM = Prozessorgeschwindigkeit / (Prescaler * 256)
  PWM = 8000000 / (8 * 256) = 3906,25Hz = 3,9kHz*/
  DDRD |= (1 << PD7); // Motor (OC2 => PD7) = Ausgang
  OCR2 = 0; // von 0 bis 255 einstellbar
  TCCR2 |= (1 << COM21); // normaler Modus (für invertierenden Modus | (1 << COM20))
  TCCR2 |= (1 << WGM21) | (1 << WGM20); // fast PWM
  TCCR2 |= (1 << CS21); // Prescaler Clock/8
}

void PWM_Empfaenger(void)
{
  //Initialisierung fuer PWM einlesen vom Empfänger
  TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  TCCR1B |= (1<<CS11) | (1<<CS10); //Quelle für Timer/Counter = CPU-Takt/64
  TIMSK |= (1<<TICIE1); //Capture Interrupt Enable
  DDRD &= ~(1<<PD6); // Impuls von Fernsteuerung (ICP1 => PD6) = Eingang
  PORTD |= (1<<PD6); //Pullup aktiviert
}

void Strommessung(void)
{
  //Initialisierung fuer Strommessung
  ACSR |= (0 << ACD);
  ACSR |= (1 << ACBG); //interne Referenzspannung (1,3 Volt)
  ACSR |= (1 << ACI);
  ACSR |= (1 << ACIE);
  ACSR |= (0 << ACIC);
  ACSR |= (0 << ACIS1) | (0 << ACIS0);
}

void Knueppelweg(void)
{
  //Initialisierung fuer Knueppelweg
  lcd_clear();
  lcd_string("Regler");
  lcd_setcursor( 0, 2);
  lcd_string("V2.0");
  _delay_ms(1000);

  //Werte ermitteln
  if(!(PINB & (1 << PB0)))
  {
    PORTB |= (1 << PB1);
    _delay_ms(1000);
    while(1) //fuer untere Knueppelposition
    {
      lcd_clear();
      lcd_string("down:");
      lcd_setcursor(0, 2);
      lcdpwm = pwm * 8;
      itoa(lcdpwm, Buffer, 10);
      lcd_string(Buffer);
      _delay_ms(50);
      if(!(PINB & (1 << PB0)))
      {
        unten = pwm;
        unten += 2; // Korrekturfaktor
        eeprom_write_word (&eeunten, unten); //schreiben
        lcd_clear();
        lcd_string("its:");
        lcd_setcursor(0, 2);
        itoa(unten, Buffer, 10);
        lcd_string(Buffer);
        _delay_ms(3000);
        break;
      }
    }
    _delay_ms(1000);
    while(1) //fuer obere Knueppelposition
    {
      lcd_clear();
      lcd_string("up:");
      lcd_setcursor(0, 2);
      lcdpwm = pwm * 8;
      itoa(lcdpwm, Buffer, 10);
      lcd_string(Buffer);
      _delay_ms(50);
      if(!(PINB & (1 << PB0)))
      {
        oben = pwm;
        oben -= 2; //Korrekturfaktor
        eeprom_write_word (&eeoben, oben); //schreiben
        lcd_clear();
        lcd_string("its:");
        lcd_setcursor(0, 2);
        itoa(oben, Buffer, 10);
        lcd_string(Buffer);
        _delay_ms(3000);
        PORTB &= ~(1 << PB1);
        break;
      }
    }
  }
  lcd_clear();  
}

void Knueppelstellung(void)
{
  //Kontrolliert ob der Knueppel beim ersten Start in der Nullposition ist
  while(1)
  {
    if (pwm == unten)
    {
    break;
    }
  }
  PORTC |= (1 << PC0);
}

void Ein_Ausgaenge(void)
{
  //Initialisierung fuer Ein-/Ausgaenge
  DDRB &= ~(1 << PB0); //Taster (PB0) = Eingang
  PORTB |= (1 << PB0); //Pullup
  DDRB |= (1 << PB1); //Gelbe LED (PC6) = Ausgang
  DDRC |= (1 << PC0); //SD/ Pin IR2184 Mosfet Treiber (PC0) = Ausgang
}  

void ADC_Init(void) 
{
  //Initialisierung fuer Spannungsmessung
  uint16_t result;
 
  // interne Referenzspannung als Refernz für den ADC wählen:
  ADMUX = (1<<REFS1) | (1<<REFS0);
  ADCSRA = (1<<ADPS2) | (1<<ADPS1);     // Frequenzvorteiler, Dummyreadout
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC)) {         // auf Abschluss der Konvertierung warten
  }
  result = ADCW;
}
 
uint16_t ADC_Read(uint8_t channel)
{
  // Initialisierung fuer Spannungseinzelmessung
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F); //Kanal waehlen, ohne andere Bits zu beeinflußen
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;
}
 
int main (void)
{
  lcd_init();
  lcd_clear(); 
    
  PWM_Mosfet();
  PWM_Empfaenger();
  Strommessung();
  sei(); //fuer ISR (gibt den Startschuss fuer Interrupt)
  Ein_Ausgaenge();
  Knueppelweg();
  
  unten = eeprom_read_word (&eeunten); //EEPROM lesen
  oben = eeprom_read_word (&eeoben);
  
  Knueppelstellung();
  
  j = oben - unten; //Knueppelweg Vorberechnung
  j = 255 / j;
  
  ADC_Init(); //Spannungsmessung
  uint16_t  spannung; //Spannungsmessung
  
  while(1) 
  {  
      i = pwm - unten;
      i = i * j;
      k = i;
      if(pwm >= oben)
      {
        k = 255;  
      }
      if(pwm <= unten)
      {
        k = 0;
      }
      OCR2 = k;
      spannung = ADC_Read(0);
      if (spannung <= 250)
      {
        break;
      }
  }
  while(1)
  {
    OCR2 = 0;
    lcd_init();
    lcd_clear();
    lcd_string("Akku");
    lcd_setcursor( 0, 2);
    lcd_string("leer!");
    _delay_ms(1000);
    PORTC &= ~(1 << PC0);
  }
  return 0;
}

[Karl H. (kbuchegg)]

Steffen Ha schrieb:

> PWM unterbrechen? Wenn ich in der ISR ANA_COMP_vect den Befehl OCR2 = 0
> reinschreibe zuckt der Motor auch mal ganz kurz aber dann läuft er ganz
> normal weiter.

Logisch.

Dennb nachdem die ISR abgelaufen ist, geht es ja an der unterbrechenden 
Stelle weiter, und das wird dann ja wohl die Hauptschleife in main() 
sein.

In der steht aber

  while(1) 
  {  
      i = pwm - unten;
      i = i * j;
      k = i;
      if(pwm >= oben)
      {
        k = 255;  
      }
      if(pwm <= unten)
      {
        k = 0;
      }
      OCR2 = k;

womit dein 0-setzen von OCR2 in der ISR nur noch ein Ereignis in der 
Vergangenheit war.

Deine ISR sollte
* ein globales Flag setzen, in dem vermerkt wird, dass der Motor 
abzustellen ist.
* die Hauptschleife berücksichtigt auch noch dieses Flag und entscheidet
  dann was eigentlich gilt. Der Wert, der sich aus der Knüppelposition
  ergeben hat, oder der fixe Wert 0, weil der Analogcomperator eine
  Fehlersituation festgestellt und im globalen Flag dokumentiert hat.
  Und je nachdem wird dann ein entsprechender Wert an OCR2 zugewiesen.

[Karl H. (kbuchegg)]

PS.
deine vielen Endlos-Schleifen sind .... nicht gut.
Die kann man ruhig auch so umformen, dass man sich nicht aus jeder 
Schleife rausbreaken muss.

Aus

void Knueppelstellung(void)
{
  //Kontrolliert ob der Knueppel beim ersten Start in der Nullposition ist
  while(1)
  {
    if (pwm == unten)
    {
    break;
    }
  }
  PORTC |= (1 << PC0);
}

kann man ganz leicht machen

void Knueppelstellung(void)
{
  while( pwm != unten )
    ;

  PORTC |= (1 << PC0);
}

das ist erstens kürzer und zweitens sieht man auch recht eindeutig, was 
die Schleife eigentlich macht. Da steht
  Wiederhole solange, solange pwm nicht gleich unten ist.

Bam, das kann auch der Blindenhund eines Sehbehinderten aus 15 Meter 
Entfernung begreifen, worum es da geht. Und wenn du dann die Variable 
'pwm' noch sinnvoll benennst, denn das ist ja offensichtlich die 
festgestellte Knüppelstellung und auch noch der Funktion einen 
ordentlichen Namen gibst, dann wird der Code selbst dokumentierend ohne 
dass du auch nur einen einzigen Kommentar schreiben musst.

void WaitForUserReady()
{
  while( stick != unten )
    ;

  ENGINE_PORT |= ( 1 << ENGINE_PIN );
}

Anstatt des
  ENGINE_PORT |= ( 1 << ENGINE_PIN );
noch eine Abstrahierung, die Auskunft darüber gibt, was hier eigentlich 
mit dem Motor gemacht wird und gut ists.



Und mit den anderen while Schleifen kann man ebenfalls arbeiten. Das 
kann man alles gleichzeitig kürzer UND übersichtlicher schreiben. Deine 
Funktion Knueppelweg ist ein einziger Horror für eine eigentlich 
einfache Funktionalität.

[Steffen H. (stef_fen)]

Vielen Dank. An der Übersichtlichkeit werde ich noch arbeiten.

>Deine ISR sollte
>* ein globales Flag setzen, in dem vermerkt wird, dass der Motor
>abzustellen ist.

Kann ich das über Bit 4 ACI machen? Muss ich dazu das I-Bit in SREG 
setzen oder mach das schon das sei()?

[Karl H. (kbuchegg)]

Steffen Ha schrieb:
> Vielen Dank. An der Übersichtlichkeit werde ich noch arbeiten.

Machs gleich!

Die Tatsache, dass du deinen Code nicht mehr überblickst erzählt Bände!
Die Dinge werden nicht besser, in dem du notwendige Arbeiten am Code vor 
dir herschiebst.

> Kann ich das über Bit 4 ACI machen? Muss ich dazu das I-Bit in SREG
> setzen oder mach das schon das sei()?

Wozu so kompliziert?

volatile uint8_t currentOverload;

ISR(ANA_COMP_vect)
{
  if bit_is_clear(ACSR, ACO)
  {
    currentOverload = TRUE;
  }
  else
  {
    currentOverload = FALSE;
  }
}


...


int main()
{
  ...

  currentOverload = FALSE;

  ...

  while(1)
  {
    if( currentOverload )
    {
      LED_PORT &= ~(1 << OVERLOAD_LED );
      i = 0;
    }

    else
    {
      LED_PORT |= (1 << OVERLOAD_LED );

      i = pwm - unten;
      i = i * j;

      if(pwm >= oben)
      {
        i = 255;  
      }
      if(pwm <= unten)
      {
        i = 0;
      }
    }

    OCR2 = i;

    ...

Es ist löblich, wenn du dir überall { } machst. Aber wichtiger wäre es, 
ordentliche Variablennamen zu nehmen. Dieses i hier, das hat eine 
Bedeutung und die Variable hätte sich einen besseren Namen als 'i' 
verdient. Einen Namen, der ihrer Bedeutung besser entspricht. Genauso 
wie 'pwm'. Was ist dieses pwm, was stellt es dar? Das ist die Position 
des Knüppels! Das sollte auch in der Benamung der Variablen rauskommen. 
Das du diese Knüppelposition mit dem Timer feststellst, indem du die 
Pulslänge der eingehenden PWM ausmisst, das ist an dieser Stelle 
uninteressant. Benenne die Dinge danach, was sie (im Umfeld der Aufgabe) 
darstellen und nicht nach technischen Details. Eine Knüppelposition ist 
eine Knüppelposition und keine PWM. In deinem Progamm geht es um Knüppel 
(es sind wohl die KNüppel einer Fernsteuerung gemeint) und Motoren. Aber 
abgesehen von ein paar versteckten Kommentaren kann ich in deinem COde 
diese beiden Wörter überhaupt nirgends entdecken. Dabei sind diese 
beiden Begriffe die Haupt'personen' in diesem Programm. Darum dreht sich 
alles! Stattdessen lese ich i und k und j und ....

[Steffen H. (stef_fen)]

Eben habe ich das Programm noch mal getestet. Wenn jetzt aber die 
simulierte Stromüberlast auftritt läut der Motor auf der letzen 
Geschwindigkeit weiter. Die LED geht an. Das passt ja soweit, aber der 
Motor sollte ja auch ausgehen.

 
//Bibliotheken einbinden
#define F_CPU 8000000
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <avr/io.h>
#include "lcd-routines.h"
#include <stdlib.h>
#include <util/delay.h>

//Variablendeklaration
uint16_t eeunten EEMEM;        //fuer EEPROM
uint16_t unten;            //fuer EEPROM
uint16_t eeoben EEMEM;        //fuer EEPROM
uint16_t oben;            //fuer EEPROM
int flanke;              //fuer PWM
uint16_t flankeStart;        //fuer PWM
volatile uint16_t stick;      //fuer Knueppelposition (volatile = Global gueltig)
volatile uint8_t currentOverload;  //fuer Stromsensor
char Buffer[20];          //fuer LCD
int lcdpwm;              //fuer LCD
float i;              //fuer Rechnung
float deltaStick;              //fuer Rechnung
int k;                //fuer Rechnung

ISR(TIMER1_CAPT_vect)
{
  // Initialiserung fuer PWM einlesen vom Empfänger
  if (flanke==0)
  {
    flankeStart = ICR1;
    TCCR1B &= ~(1<<ICES1); // fallende Flanke zur Auswertung des ICP
    flanke = 1;
  }
  else
  {
    stick = ICR1 - flankeStart;
    flanke = 0;
    TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  }
  TIFR = ( 1 << ICF1 );  
}

ISR(ANA_COMP_vect)
{
  //Intialisierung fuer Strommessung
  if bit_is_clear(ACSR, ACO)
  {
    currentOverload = 1;
  }
  else
  {
    currentOverload = 0;
  }
}

void PWM_Mosfet(void)
{
  /*Initialisierung fuer PWM ausgeben an Mosfet Treiber
  PWM = Prozessorgeschwindigkeit / (Prescaler * 256)
  PWM = 8000000 / (8 * 256) = 3906,25Hz = 3,9kHz*/
  DDRD |= (1 << PD7); // Motor (OC2 => PD7) = Ausgang
  OCR2 = 0; // von 0 bis 255 einstellbar
  TCCR2 |= (1 << COM21); // normaler Modus (für invertierenden Modus | (1 << COM20))
  TCCR2 |= (1 << WGM21) | (1 << WGM20); // fast PWM
  TCCR2 |= (1 << CS21); // Prescaler Clock/8
}

void PWM_Empfaenger(void)
{
  //Initialisierung fuer PWM einlesen vom Empfänger
  TCCR1B |= (1<<ICES1); // steigende Flanke zur Auswertung des ICP
  TCCR1B |= (1<<CS11) | (1<<CS10); //Quelle für Timer/Counter = CPU-Takt/64
  TIMSK |= (1<<TICIE1); //Capture Interrupt Enable
  DDRD &= ~(1<<PD6); // Impuls von Fernsteuerung (ICP1 => PD6) = Eingang
  PORTD |= (1<<PD6); //Pullup aktiviert
}

void Strommessung(void)
{
  //Initialisierung fuer Strommessung
  ACSR |= (0 << ACD);
  ACSR |= (1 << ACBG); //interne Referenzspannung (1,3 Volt)
  ACSR |= (1 << ACI);
  ACSR |= (1 << ACIE);
  ACSR |= (0 << ACIC);
  ACSR |= (0 << ACIS1) | (0 << ACIS0);
}

void Knueppelweg(void)
{
  //Initialisierung fuer Knueppelweg
  lcd_clear();
  lcd_string("Regler");
  lcd_setcursor( 0, 2);
  lcd_string("V2.0");
  _delay_ms(1000);

  //Werte ermitteln
  if(!(PINB & (1 << PB0)))
  {
    PORTB |= (1 << PB1);
    _delay_ms(1000);
    while(1) //fuer untere Knueppelposition
    {
      lcd_clear();
      lcd_string("down:");
      lcd_setcursor(0, 2);
      lcdpwm = stick * 8;
      itoa(lcdpwm, Buffer, 10);
      lcd_string(Buffer);
      _delay_ms(50);
      if(!(PINB & (1 << PB0)))
      {
        unten = stick;
        unten += 2; // Korrekturfaktor
        eeprom_write_word (&eeunten, unten); //schreiben
        lcd_clear();
        lcd_string("its:");
        lcd_setcursor(0, 2);
        itoa(unten, Buffer, 10);
        lcd_string(Buffer);
        _delay_ms(3000);
        break;
      }
    }
    _delay_ms(1000);
    while(1) //fuer obere Knueppelposition
    {
      lcd_clear();
      lcd_string("up:");
      lcd_setcursor(0, 2);
      lcdpwm = stick * 8;
      itoa(lcdpwm, Buffer, 10);
      lcd_string(Buffer);
      _delay_ms(50);
      if(!(PINB & (1 << PB0)))
      {
        oben = stick;
        oben -= 2; //Korrekturfaktor
        eeprom_write_word (&eeoben, oben); //schreiben
        lcd_clear();
        lcd_string("its:");
        lcd_setcursor(0, 2);
        itoa(oben, Buffer, 10);
        lcd_string(Buffer);
        _delay_ms(3000);
        PORTB &= ~(1 << PB1);
        break;
      }
    }
  }
  lcd_clear();  
}

void WaitForUserReady(void)
{
  //Kontrolliert ob der Knueppel beim ersten Start in der Nullposition ist
  while(stick != unten);
  PORTC |= (1 << PC0);
}

void Ein_Ausgaenge(void)
{
  //Initialisierung fuer Ein-/Ausgaenge
  DDRB &= ~(1 << PB0); //Taster (PB0) = Eingang
  PORTB |= (1 << PB0); //Pullup
  DDRB |= (1 << PB1); //Gelbe LED (PC6) = Ausgang
  DDRC |= (1 << PC0); //SD/ Pin IR2184 Mosfet Treiber (PC0) = Ausgang
}  

void ADC_Init(void) 
{
  //Initialisierung fuer Spannungsmessung
  uint16_t result;
 
  // interne Referenzspannung als Refernz für den ADC wählen:
  ADMUX = (1<<REFS1) | (1<<REFS0);
  ADCSRA = (1<<ADPS2) | (1<<ADPS1);     // Frequenzvorteiler, Dummyreadout
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC)) {         // auf Abschluss der Konvertierung warten
  }
  result = ADCW;
}
 
uint16_t ADC_Read(uint8_t channel)
{
  // Initialisierung fuer Spannungseinzelmessung
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F); //Kanal waehlen, ohne andere Bits zu beeinflußen
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;
}
 
int main (void)
{
  lcd_init();
  lcd_clear(); 
    
  PWM_Mosfet();
  PWM_Empfaenger();
  Strommessung();
  sei(); //fuer ISR (gibt den Startschuss fuer Interrupt)
  Ein_Ausgaenge();
  Knueppelweg();
  
  currentOverload = 0;

  unten = eeprom_read_word (&eeunten); //EEPROM lesen
  oben = eeprom_read_word (&eeoben);
  
  WaitForUserReady();
  
  deltaStick = oben - unten; //Knueppelweg Vorberechnung
  deltaStick = 255 / deltaStick;
  
  ADC_Init(); //Spannungsmessung
  uint16_t  spannung; //Spannungsmessung
  
  while(1) 
  {  
    if(currentOverload == 1)
    {
      PORTB |= (1 << PB1);
      k = 0;
    }
    else
    {
      PORTB &= ~(1 << PB1);
      i = stick - unten;
      i = i * deltaStick;
      k = i;
      if(stick >= oben)
      {
        k = 255;  
      }
      if(stick <= unten)
      {
        k = 0;
      }
      OCR2 = k;
      spannung = ADC_Read(0);
      if (spannung <= 250)
      {
        break;
      }
    }
  }
  while(1)
  {
    OCR2 = 0;
    lcd_init();
    lcd_clear();
    lcd_string("Akku");
    lcd_setcursor( 0, 2);
    lcd_string("leer!");
    _delay_ms(1000);
    PORTC &= ~(1 << PC0);
  }
  return 0;
}

[Steffen H. (stef_fen)]

Eben ist mir noch etwas eingefallen. Ich muss ja in der Main OCR2 = 0 
setzen anstatt k = 0 bei:

if(currentOverload == 1)
    {
      PORTB |= (1 << PB1);
      k = 0;
    }


 if(currentOverload == 1)
    {
      PORTB |= (1 << PB1);
      OCR2 = 0;
    }

[Karl H. (kbuchegg)]

Schau noch mal GENAU!

Wo ...

  while(1) 
  {  
    if(currentOverload == 1)
    {
      PORTB |= (1 << PB1);
      k = 0;
    }
    else
    {
      PORTB &= ~(1 << PB1);
      i = stick - unten;
      i = i * deltaStick;
      k = i;
      if(stick >= oben)
      {
        k = 255;  
      }
      if(stick <= unten)
      {
        k = 0;
      }
      OCR2 = k;
      spannung = ADC_Read(0);
      if (spannung <= 250)
      {
        break;
      }
    }
  }

... setzt du den OCR2 neu?

Damit der Motor stoppt, muss OCR2 auf 0 gesetzt werden. Wie genau
realisierst du das in deinem Code?
Oder anders ausgedrückt: Wenn currentOverload anspricht, wie kommt dann
OCR2 eigentlich zu seinem vorgesehenen Wert von 0?

Bei dir: gar nicht.
Du setzt zwar k auf 0, aber .....
... wenn ich mir mal die Einrückung so ansehe

    if(currentOverload == 1)
    {
      ...
      k = 0;
    }
    else
    {
      ...
      OCR2 = k;
      ...
    }

dann landet dieses k ja nie im OCR2. Das 0-setzen ist im then-Zweig und
die Zuweisung ist im else Zweig.

[Steffen H. (stef_fen)]

Perfekt. Jetzt funktioniert es. Momentan wertet ja der Timer 1 das 
Signal von der Fernsteuerung aus und der Timer 2 erzeugt das PWM Signal. 
Kann der Timer 1 eigentlich auch beide Aufgaben übernehmen?

Vielen Dank. Gruß Steffen

[Steffen H. (stef_fen)]

Habt ihr eine Idee wie das mit den Timern ist?

Gruß Steffen

[Steffen H. (stef_fen)]

Die Frage hat sich leider noch nicht geklärt. Hab ihr eine Idee wie das 
mit den Timern ist? Momentan wertet ja der Timer 1 das Signal von der 
Fernsteuerung aus und der Timer 2 erzeugt das PWM Signal. Kann der Timer 
1 eigentlich auch beide Aufgaben übernehmen?

Vielen Dank. Gruß Steffen