Ständig Interrupt Probleme
Moin!
Ich hab mein Programm mal ein bisschen weiter endwickelt.
Ich hab einen Servo, der sich hin und her bewegt. Auf den ist ein GP2D12 montiert. Dann hab ich einen LDR, der über ADC "ausgelesen" wird. Und 2 H-Brücken (mit Relais) bei denen 2 Antriebsmotoren über PWM gesteuert werden und über 2 Ausgänge werden die Drehrichtungen geändert. Das alles auf einem Modellpanzer.
Mein Problem war erst das meine Scheinwerfer, die ja über den kontroller eingeschaltet werden wenn´s dunkel ist, geflakert haben, weil die Interruptroutine zu lang war. Das hab ich jetzt hinbekommen. Nur jetzt wo ich die Motorsteuerung programmiert habe, fängt plözlich mein Servo an zu rucken, oder bleibt einfach stehen und zuckt dann rum, läuft dann aber nach ner zeit wieder weiter. Dachte zuerst Hardware-Problem. Hab also ein bisschen rumgemessen und so, aber nichts gefunden. Dann hab ich meinen ganzen Motorkram aus meinem Programm genommen und das Programm wieder auf meinen Mega32 geladen. So funktioniert wieder alles ohne Problem. Mein Servo bewegt sich ganz normal und meine Helligkeitsmessung macht auch kein Problem.
Hier mal mein Programm MIT Motorkram.
Code:
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
#ifndef F_CPU
#define F_CPU 16000000
#endif
#define Scheinwerfer PD0
#define Rueckleuchten PD1
#define PWM_ServoPort PD5
#define IR_Servo OCR1A
#define Motor_Links PB3
#define Motor_Rechts PD7
#define Motor_Links_Rueck PC0
#define Motor_Rechts_Rueck PC1
//---------------------------------Globale Variablen----------------------------------
uint8_t a=0, posi=25, count=0;
//---------------------------------Interruptroutinen----------------------------------
ISR(TIMER1_COMPB_vect)
{
count++;
}
//---------------------------------Helligkeitsmessung---------------------------------
void helligkeitsmessung(void)
{
uint16_t LDR;
ADCSRA |= (1<<ADSC);
while (ADCSRA & (1<<ADSC))
{
;
}
LDR = ADCL;
LDR += (ADCH<<8);
if (LDR<150)
{
PORTD |= (1<<Scheinwerfer);
PORTD |= (1<<Rueckleuchten);
}
if (LDR>190)
{
PORTD &= ~(1<<Scheinwerfer);
PORTD &= ~(1<<Rueckleuchten);
}
}
//-------------------------------------IR_Servosteuerung---------------------------------------
int IR_Servoposition(void)
{
if ((count==2)&&(a==0))
{
count=0;
posi++;
if (posi==50)
{
a=1;
}
}
if ((count==2)&&(a==1))
{
count=0;
posi--;
if (posi==0)
{
a=0;
}
}
return ((posi)+440); //440=min, 490=max
}
//--------------------------------------Motorsteuerung-----------------------------------------
void Motorsteuerung(void)
{
OCR0=50; //255=Max (Links)
OCR2=50; //255=Max (Rechts)
}
//-------------------------------------initialisierungen---------------------------------------
void Initial_ADC0(void)
{
ADMUX |= 0x00; //AREF, resultat rechtsbündig, ADC-Eingang ADC0
ADCSRA |= ((1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)); //ADC eingeschaltet, Teilungsfaktor..
DDRD |= ((1<<Scheinwerfer) | (1<<Rueckleuchten));
}
void Initial_IR_Servo(void)
{
TCCR1A |= ((1<<WGM11)|(1<<COM1A1)|(1<<COM1A0)); //9-Bit PWM, Inverted Mode OC1A
TCCR1A |= ((1<<COM1B1)|(1<<COM1B0)); //Inverted Mode OC1B
TCCR1B |= (1<<CS12); //Prescaler 256
TIMSK |= (1<<OCIE1B);
DDRD |= (1<<PWM_ServoPort);
PORTD |= (1<<PWM_ServoPort);
OCR1B=500; //beliebige zeit (irgendwas unter ner ms)
}
void Initial_Motoren(void)
{
//Ausgang Initialisieren (OC0)
DDRB |= (1<<Motor_Links); //Setzen als Ausgang
PORTB |= (1<<Motor_Links); //Pull-Up
//Ausgang Initialisieren (OC2)
DDRD |= (1<<Motor_Rechts); //Setzen als Ausgang
PORTD |= (1<<Motor_Rechts); //Pull-Up
//Initialisierung der Ausgänge für Rückwärtsfahren
DDRC |= ((1<<Motor_Links_Rueck)|(1<<Motor_Rechts_Rueck));
//Initialisierung PWM für OC0
TCCR0 |= ((1<<WGM01)|(1<<WGM00)); //Fast PWM
TCCR0 |= (1<<COM01); //Clear Output on Compare, Set on Top
TCCR0 |= ((1<<CS02)|(1<<CS00)); //CLK/1024 (15,625kHz, 64µs/periode)
//Compare Register ist OCR0
//Initialisierung PWM für OC2
TCCR2 |= ((1<<WGM21)|(1<<WGM20)); //Fast PWM
TCCR2 |= (1<<COM21); //Clear Output on Compare, Set on Top
TCCR2 |= ((1<<CS22)|(1<<CS21)|(1<<CS20)); //CLK/1024 (15,625kHz, 64µs/periode)
//Compare Register ist OCR2
}
//---------------------------------------Hauptprogramm---------------------------------
int main(void)
{
Initial_ADC0();
Initial_IR_Servo();
Initial_Motoren();
while(1)
{
helligkeitsmessung();
sei();
IR_Servo = IR_Servoposition();
Motorsteuerung();
cli();
}
}
Ich weiß echt nicht mehr weiter. Wurde mich freuen wenn mal jemand ein Auge drauf wirft, der sich auskennt. Is auch das erste mal das ich was mit Interrupt mache. Hab also nicht wirklich erfahrung, aber denke der is schuld an meinem spinnenden Roboter.
MfG Jan
Warum sperrst Du die Interrupts
Hi Spongebob,
gleich mal vorneweg, ich habe mir das Programm nicht im Detail angeschaut und weiß auch nicht, ob alle Register richtig initialisiert werden.
Aber eines ist mir aufgefallen: Du sperrst als letztes in Deiner while(1) alle Interrupts. Dann rufst Du die Funktion helligkeitsmessung(), die auf ein Wandlerergebnis(?) wartet. Das heißt aber auch, dass wenn der Timer überläuft, während Du auf das Ergebnis wartest die ISR nicht angesprungen wird. Das passiert erst, wenn die Funktion helligkeitsmessung() beendet wurde. Je nachdem, wie schnell Dein Timer überläuft kann es passieren, dass Du einen Interrupt nicht mitbekommst (nämlich genau dann, wenn Dein Timer zweimal überläuft, während Du auf den AD-Wandler wartest).
Würde Dir folgendes empfehlen:
1. Nach der Interruptfreigabe (vor while(1)) sperre den Interrupt nicht mehr!
2. Überprüfe in der TimerISR, ob Dein Counter schon 2 ist, wenn ja, setzte ein globales Flag, das Du in der while(1) abfrägst, und nur wenn dieses gesetzt ist rufst Du die Funktion IR_Servoposition().
Hoffe mal, das hilft etwas, ansonsten schreib halt nochmal. Wie gesagt, ob Deine Initialisierungen stimmen kann ich nicht beurteilen, dafür kenne ich die AVRs zu wenig...
Viele Grüße
Liste der Anhänge anzeigen (Anzahl: 2)
@Hubert.G:
Mein Ganzer Code sieht jetzt so aus:
Code:
#include <avr/io.h>
#include <stdint.h>
#include <avr/interrupt.h>
#ifndef F_CPU
#define F_CPU 16000000
#endif
#define Scheinwerfer PD0
#define Rueckleuchten PD1
#define PWM_ServoPort PD5
#define IR_Servo OCR1A
#define Motor_Links PB3
#define Motor_Rechts PD7
#define Motor_Links_Rueck PC0
#define Motor_Rechts_Rueck PC1
//---------------------------------Globale Variablen----------------------------------
volatile uint8_t count=0;
volatile int8_t posi=25, a=1;
volatile uint16_t LDR;
//---------------------------------Interruptroutinen----------------------------------
ISR(TIMER1_COMPB_vect)
{
count++;
}
ISR(ADC_vect)
{
LDR = ADC;
}
//---------------------------------Helligkeitsmessung---------------------------------
void helligkeitsmessung(void)
{
ADCSRA |= (1<<ADSC);
if (LDR<=150)
{
PORTD |= (1<<Scheinwerfer);
PORTD |= (1<<Rueckleuchten);
}
if (LDR>=190)
{
PORTD &= ~(1<<Scheinwerfer);
PORTD &= ~(1<<Rueckleuchten);
}
}
//-------------------------------------IR_Servosteuerung---------------------------------------
int IR_Servoposition(void)
{
if ((count>=2)&&(a>=1))
{
posi++;
count=0;
if (posi>=50)
{
a=0;
}
}
if ((count>=2)&&(a<=0))
{
posi--;
count=0;
if (posi<=0)
{
a=1;
}
}
return ((posi)+440); //440=min, 490=max
}
//--------------------------------------Motorsteuerung-----------------------------------------
void Motorsteuerung(void)
{
OCR0=0; //255=Max (Links)
OCR2=0; //255=Max (Rechts)
}
//-------------------------------------initialisierungen---------------------------------------
void Initial_ADC0(void)
{
ADMUX |= 0x00; //AREF, resultat rechtsbündig, ADC-Eingang ADC0
ADCSRA |= ((1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)); //ADC eingeschaltet, Teilungsfaktor..
ADCSRA |= (1<<ADIE);
DDRD |= ((1<<Scheinwerfer) | (1<<Rueckleuchten));
}
void Initial_IR_Servo(void)
{
TCCR1A |= ((1<<WGM11)|(1<<COM1A1)|(1<<COM1A0)); //9-Bit PWM, Inverted Mode OC1A
TCCR1A |= ((1<<COM1B1)|(1<<COM1B0)); //Inverted Mode OC1B
TCCR1B |= (1<<CS12); //Prescaler 256
TIMSK |= (1<<OCIE1B);
DDRD |= (1<<PWM_ServoPort);
PORTD |= (1<<PWM_ServoPort);
OCR1B=500; //beliebige zeit (irgendwas unter ner ms)
}
void Initial_Motoren(void)
{
//Ausgang Initialisieren (OC0)
DDRB |= (1<<Motor_Links); //Setzen als Ausgang
PORTB |= (1<<Motor_Links); //Pull-Up
//Ausgang Initialisieren (OC2)
DDRD |= (1<<Motor_Rechts); //Setzen als Ausgang
PORTD |= (1<<Motor_Rechts); //Pull-Up
//Initialisierung der Ausgänge für Rückwärtsfahren
DDRC |= ((1<<Motor_Links_Rueck)|(1<<Motor_Rechts_Rueck));
//Initialisierung PWM für OC0
TCCR0 |= ((1<<WGM01)|(1<<WGM00)); //Fast PWM
TCCR0 |= (1<<COM01); //Clear Output on Compare, Set on Top
TCCR0 |= ((1<<CS02)|(1<<CS00)); //CLK/1024 (15,625kHz, 64µs/periode)
//Compare Register ist OCR0
//Initialisierung PWM für OC2
TCCR2 |= ((1<<WGM21)|(1<<WGM20)); //Fast PWM
TCCR2 |= (1<<COM21); //Clear Output on Compare, Set on Top
TCCR2 |= ((1<<CS22)|(1<<CS21)|(1<<CS20)); //CLK/1024 (15,625kHz, 64µs/periode)
//Compare Register ist OCR2
}
//---------------------------------------Hauptprogramm---------------------------------
int main(void)
{
Initial_ADC0();
Initial_IR_Servo();
Initial_Motoren();
sei(); //Globales Interrupt gesetzt
while(1)
{
helligkeitsmessung();
IR_Servo = IR_Servoposition();
Motorsteuerung();
}
return 0; //wird nie erreicht
}
Irgendwie finde ich auch komisch das man für jeden Interrupt mindestens eine Globale Variable braucht. Oder gibts ne andere Möglichkeit?
Und die Struktur gefällt mir auch nicht wirklich. Ist halt aber mein erster Roboter und das erste mal das ich mehr als die Main funktion verwende.
@oberallgeier
Die Spannungsversorgung erfolgt über einen 7805. An dessen Eingang ein Akku hängt der 9,6V Nennspannung hat. Ist alles schon auf meinem Roboter.
Hab hier von dem Roboter noch ein paar Bilder angehängt:
