ATmega 644 Timer und Motorsteuerung, Problem mit PWM

[Marc H. (martrixmarc)]

Guten Tag.
Ich habe derzeit ein Problem bei meiner Diplomarbeit. Ziel ist es einen 
Quadcopter zu bauen. Steuerung für Links Rechts Vor Zurück funktioniert 
schon alles. Allerdings habe ich das Problem das bei einem der Timer das 
PWM Signal nicht ganz stimmt.

Timer1: _|--|_|--|_|--|_|--|_|--|_

Timer2: _|--|_|--|______|--|_|--|_

In dieser kleinen GRafik habe ich versucht das Problem wiederzuegeben. 
Die beiden PWM Signale sollten eigentlich genau gleich sein. Allerdings 
fehlt bei Timer2 ein Teil.

Im Anhang habe ich den C Code angehängt.
Ich hoffe hier kann mir wer helfen. Ich glaube ja das der Fehler dadurch 
zustande kommt, weil ich die Timer auch verwende um das Signal der 
Fernsteuerung auszuwerten. Dies funktioniert durch Interrupts.

mfg Marc

#define F_CPU 2000000UL  // CPU Frequenz deklarieren

#include <avr/io.h>    //IO Pins einbinden
#include <avr/interrupt.h>  //Interrupts einbinden
#include <util/delay.h>    //Delay Funktion einbinden


volatile int flanke=0;
volatile int flanke1=0;
volatile int flanke2=0;

volatile int aktuell_pwm=0;
volatile int aktuell_pwm1=0;
volatile int aktuell_pwm2=0;

volatile int vornerechts=0;
volatile int vornelinks=0;
volatile int hintenrechts=0;
volatile int hintenlinks=0;

volatile int vornerechts2=0;
volatile int vornelinks2=0;
volatile int hintenrechts2=0;
volatile int hintenlinks2=0;

volatile int count = 0;


ISR(PCINT0_vect)
{
  if(flanke==0)
  {           
      TCNT1L = 0; //Timer auf null zurück

       //TCCR1B&= ~(1<<ICES1); //INT0-Pin auf fallende Flanke einstellen
       flanke=1;
  }
  else
  {
       flanke=0;
       //TCCR1B|=(1<<ICES1);    //INT0 auf steigende Flanke wieder aktivieren
       aktuell_pwm=TCNT1L;      //Zählerstand speichern
  }

}
ISR(PCINT1_vect)
{
    if(flanke1==0)
      {           
        TCNT2 = 0; //Timer auf null zurück
        flanke1=1;
      }
      else
      {
        flanke1=0;
        aktuell_pwm1=TCNT2;      //Zählerstand speichern
      count=1;
      }
}
ISR(PCINT2_vect)
{
    if(flanke2==0)
      {           
        TCNT1L = 0; //Timer auf null zurück
        flanke2=1;
      }
      else
      {
        flanke2=0;
        aktuell_pwm2=TCNT1L;      //Zählerstand speichern
      count=0;
    }
}

int abs(int z) 
{ 
  if (z>=0) 
  { 
    return z; 
  } 
  return -z; 
}

int main (void)
{
  //char my_buffer[120]; //Buffer einlesen
  //setup_uart(); // RS232 einrichten



  DDRA = 0x00;     //PINA0 als eingang deklarieren
    //PORTA = 0xff;    //PUllup Widerstand aktivieren


    PCICR |= (1 << PCIE0) | (1 << PCIE1) | (1 << PCIE2) | (1 << PCIE3);    // set PCIE0 to enable PCMSK0 scan
    PCMSK0 |= (1 << PCINT0);
  PCMSK1 |= (1 << PCINT8);
  PCMSK2 |= (1 << PCINT16);
  PCMSK3 |= (1 << PCINT27);  // set PCINT0 to trigger an interrupt on state change 
  // set PCINT0 to trigger an interrupt on state change 
    //EIMSK |= (1 << INT1) | (1 << INT2);    // set PCIE0 to enable PCMSK0 scan
    
    sei();                    //Interrupts anschalten


  DDRD |= (1 << PIND0) | (1 << PIND1);
  //DDRD &= ~(1 << PIND5);
    
  DDRD |= (1 << PIND4) | (1 << PIND5);
     DDRD |= (1 << PIND6) | (1 << PIND7); // PIN 6 & 7 auf Output setzen (PWM)
    DDRB = (1 << PINB4) | (1 << PINB3); // PIN 3 & 4 auf Output setzen (PWM)


  //Timer 2 PWM Settings
  TCCR2A = (1<<COM2B1) | (1<<COM2A1) | (1<<WGM20);
  TCCR2B = (1<<CS20) | (1<<CS21);


  //Timer 1 Prescaler setzen
  TCCR1B = (1<<CS10) | (1<<CS11);


  //Timer 0 PWM Settings
  TCCR0A = (1<<COM0B1) | (1<<COM0A1) | (1<<WGM00) | (1<<WGM01); //Fast PWM OCRA TOP TOP
  TCCR0B = (1<<CS00) | (1<<CS01);


  while(1)
    {
    if (aktuell_pwm >= 0 && aktuell_pwm < 100)
      {  

      OCR0A = 10;
      OCR0B = 10;

      OCR2A = 10;
      OCR2B = 10;
      }  
    else if (aktuell_pwm >= 100)
      {
      //LINKS - RECHTS
      if (aktuell_pwm1 < 96 && aktuell_pwm1 > 10)
        {  
        hintenrechts = abs(aktuell_pwm1-110)/3; //rechts hinten
        vornerechts = abs(aktuell_pwm1-110)/3;
        }
    
      else if(aktuell_pwm1 > 150)
        {
        hintenlinks = abs(aktuell_pwm1-110)/3;
        vornelinks = abs(aktuell_pwm1-110)/3;
        }  
      else if(aktuell_pwm1 < 150 && aktuell_pwm1 > 96)
        {
        hintenrechts = 0;
        vornelinks = 0;
        hintenlinks = 0;
        vornerechts = 0;
        } 

      //VOR - ZURÜCK
      if (aktuell_pwm2 < 96 && aktuell_pwm2 > 10)
        {  
        vornelinks2 = abs(aktuell_pwm2-110)/3; //rechts hinten
        vornerechts2 = abs(aktuell_pwm2-110)/3;
        }
    
      else if(aktuell_pwm2 > 150)
        {
        hintenlinks2 = abs(aktuell_pwm2-110)/3;
        hintenrechts2 = abs(aktuell_pwm2-110)/3;
        }  
      else if(aktuell_pwm2 < 150 && aktuell_pwm2 > 96)
        {
        hintenrechts2 = 0;
        vornelinks2 = 0;
        hintenlinks2 = 0;
        vornerechts2 = 0;
        }       


      OCR0A = aktuell_pwm-hintenrechts-hintenrechts2; //rechts hinten
      OCR0B = aktuell_pwm-hintenlinks-hintenlinks2; // links hinten
        
      OCR2A = aktuell_pwm-vornelinks-vornelinks2; //links vorne
      OCR2B = aktuell_pwm-vornerechts-vornerechts2; //rechts vorne

      } 
  
    }
}

[Marc H. (martrixmarc)]

little thumb up :)

[Marc H. (martrixmarc)]

weiß denn keiner woran das liegen kann?

[Karl H. (kbuchegg)]

Wenn du dich in den ISR am Timer vergreifst und dessen Zählerstand 
mutwillig veränderst, darfst du dich nicht wundern, wenn die 
Hardware-PWM durcheinander kommt.

Wenn ein Timer eine PWM eigenständig generieren soll, dann musst du den 
in Ruhe arbeiten lassen! Jede Einmischung von aussen am Zählerstand ist 
verboten und führt unweigerlich zum Schluckauf in der generierten PWM.

[Karl H. (kbuchegg)]

Um ein Signal auszuwerten, muss man auch nicht den zuständigen Timer auf 
0 zurücksetzen. Oder stellst du dauernd deine Armbanduhr um, wenn du für 
eine Aktion eine Zeit stoppen sollst? Du merkst dir, wann das 
'Startereignis' eingetreten ist, zum Beispiel als der Sekundenzeiger auf 
48 stand, und wann das Endereignis eingetreten ist, zum Beispiel steht 
der Sekudenzeiger dann auf 12, und aus der Differenz und dem Wissen, 
dass der Sekundenzeiger bei 60 konzeptionell wieder bei 0 beginnt 
errechnest du die Zeitdauer: 12 + 60 - 48 = 24 (in diesem Fall, da 12 - 
48 ein negatives Ergebnis bringen würde, was aber offensichtlich nicht 
richtig sein kann. Ein von einem Hochhaus fallender Ziegelstein kann 
dazu nicht eine negative Zeit benötigen). Die Aktion hat also 24 
Sekunden gedauert. Und das hast du festgestellt, ohne dass du deine 
Armbanduhr manipulieren musstest oder irgendetwas zurücksetzen musstest.

[Oliver S. (oliverso)]

Marc Hiedl schrieb:
> //Timer 1 Prescaler setzen
>   TCCR1B = (1<<CS10) | (1<<CS11);

Laut deinem Programm läuft Timer 1 im Normal-Modus ohne PWM. Also ist 
das entweder nicht das echte Programm, oder das falsche Diagramm.

Ansonsten pfuschst du ja lustig in den Zählerständen rum. Was da wann 
warum und wie passiert, kann dir so keiner sagen.

Schmeiß alles raus, was nicht mit dem Problem zu tun hat, und wenn das 
Problem dann noch da ist, zeig das hier mit einem compilierbaren !!! 
Programm als Anhang !!!.

Oliver

[Marc H. (martrixmarc)]

Sorry ich meinte natürlich Timer0

Das mit dem wert merken und dann einfach abziehen und so die 
Zeitdifferenz berechnen werde ich mal ausprobeiren :)