Wartezeit mit Match oder besser ohne?

[Merve B. (student1990)]

Hallo,

ich hab da eine kleine Frage. Ich möchte 2 Funktionen meines Timers 
ausnutzen. Einmal die Capture Funktion und einmal die Match Funktion. 
Nun will ich aber, dass bei Capture was anderes passiert und bei Match. 
Soweit ich weiß, hat jeder Timer nur eine ISR. Ich habe mir gedacht, 
dass ich in der ISR überprüfe, welches Bit denn nun gesetzt worden ist, 
sprich ich überprüfe, ob der Capture jetzt auf "1" gegangen ist oder 
Match. Habe es auch ausprobiert, aber leider bleibt der in der ISR an 
dieser Stelle hängen. Deswegen habe ich mir gedacht, ich frage direkt in 
der main() (hab also die komplette Match Funktion rausgenommen) den Wert 
des Timer Counter Registers ab (soll bei einer Minute eine Variable 
hochzählen). Doch der geht nicht mal in die Bedingung rein, obwohl mein 
Timer aufgrund des Captures schon gestartet hat. Also im TC stehen 
Werte, aber die Bedingung in meiner main() wird komischerweise nie 
erfüllt. Kann mir jemand mal einen Tipp geben?
Vielen Dank.

[Peter II (Gast)]

Merve B. schrieb:
> Kann mir jemand mal einen Tipp geben?

ohne den µC zu kennen - nein.

[Merve B. (student1990)]

Tut mir leid.
Ich benutze einen LPC2368

[Mike (Gast)]

Merve B. schrieb:
> Ich benutze einen LPC2368

Der hat doch genug Timer

[Merve B. (student1990)]

@Mike
Ja das ist mir klar, aber mein Timer startet, wenn ein Capture anliegt 
und soll dann, wenn kein 2. Capture kommt, stoppen (nach 1 Minute).

[Falk B. (falk)]

@ Merve B. (student1990)

>Ja das ist mir klar, aber mein Timer startet, wenn ein Capture anliegt

Nö. Der Timer läuft STÄNDIG. Wenn ein Capture-Ereignis erkannt wird, 
wird der aktuelle Zählerstand in das Capture-Register kopiert.

>und soll dann, wenn kein 2. Capture kommt, stoppen (nach 1 Minute).

Das ist eine leichte Übung. In fast jedem Mikrcontrollerprogramm braucht 
man so oder so eine Zeitbasis, hier reichen 100ms locker. Also muss der 
oder ein anderer Timer einen Interrupt alle 100ms erzeugen. Dort kannst 
du dann deine 1 Minute runterzählen und entsprechend reagieren. Siehe 
Interrupt, Timer und Statemachine.

[Merve B. (student1990)]

@Falk Brunner

Was ich gemeint habe, dass mein Timer erst bei einem Interrupt startet. 
Folglich läuft er davor nicht.
Danke für die Links. Ich habe es mir durchgelesen.

Habe jetzt mal was anderes ausprobiert und mit 2 Timern gearbeitet, 
wobei der eine Timer vom anderen abhängt. Hierfür habe ich dann eine 
extra ISR geschrieben, welche mit dem Match arbeitet. Das ganze habe ich 
ausprobiert. Beide Timer starten FAST zeitgleich, ABER jetzt zu meinem 
Problem. Obwohl ich den 2. Timer mit dem Match arbeiten lasse, geht er 
nicht in die entsprechende ISR rein. Ich sehe zwar, dass er den 
TC-Register wieder auf Null setzt, aber der Timer läuft ständig weiter. 
Was mir noch aufgefallen ist-der ist irgendwie ständig in der ISR von 
dem anderen Timer (der mit dem Capture arbeitet), obwohl ich eigentlich 
die Flags wieder freigebe. An was kann das liegen? Komplett Lösungen 
oder sowas möchte ich nicht keine Sorge. Will lediglich nur Tipps, die 
mir weiterhelfen könnten. Will ja was lernen und nicht ständig euch 
damit belästigen. Vielen dank im voraus.
Hier mein Code (der leider nicht so sauber programmiert ist)

/*----------------------------------------------------------------------------
 * Name:    main.c
 *----------------------------------------------------------------------------*/

#include <LPC23xx.h>           /* LPC23xx definitions */
#include "LPC2xxx_embedded.h"
#include "LCD.h"               /* LCD function prototypes */      
#include <stdio.h>

//Definition Strukturzeige

pLPC_PinConnect_TypeDef pPinsel;
pLPC_VIC_TypeDef  VIC_Controller_basis;
pLPC_TIMER_TypeDef  pTimer;
pLPC_TIMER_TypeDef pTimer2;


volatile int zeit1;
//volatile int zeit2;
static volatile int zeit2 = 0;
static volatile int personen = 0;
volatile int test;
static volatile int besetzt;
volatile int sensor1;
volatile int sensor2;
const double strecke = 3.0;
unsigned int wait;
static volatile int timeout = 0;
double v = 0.0;
int hilfe1 = 0;

//Var. für LCD
char wert1[12];
char wert2[12];

__irq void timer0_ISR (void);
__irq void timer3_ISR (void);

__irq void timer0_ISR (void)
{
  pTimer2-> TTCR = 0x0;      //Timer0 stoppen
  pTimer-> TTCR = 0x0;      //Timer3 stoppen
  besetzt = 0;
  timeout = 1;
  pTimer2->TIR |= 1;
  pTimer->TIR = 1 <<4;
  pTimer->TIR = 1 <<5;
  VIC_Controller_basis->VIC_Address = 0;  
}
__irq void timer3_ISR (void) 
  {

    /*  
    //Fehlfunktion
    if(pTimer->TIR == 0x30)
    {
      pTimer->TIR |= 1 <<4;
      pTimer->TIR |= 1 <<5;
    }
*/
//    if(pTimer->TIR == 0x10 || pTimer->TIR == 0x20)
//    {  
/*    if((pTimer->TIR) == 0x01)
    {
      hilfe1 = 1;
      timeout = 1;
      pTimer->TIR |= 1;
    }
*/    
    if(pTimer->TTCR == 0x0)
    {
      pTimer-> TTCR = 0x01;      //Timer starten
      besetzt = 1;
      if((pTimer->TIR == 0x10))
      {
      pTimer->TIR = 1 <<4;
      sensor1 = 1;
      }
      if((pTimer->TIR == 0x20))
      {
      pTimer->TIR = 1 <<5;
      sensor2 = 1;
      }    
    }

    //Timer stoppen & Zeit abspeichern
    if((sensor1 == 1) && (sensor2 == 0) && (pTimer->TIR == 0x20))
    {
       pTimer-> TTCR = 0x0;      //Timer stoppen
       zeit1 = pTimer-> TTC;  
       zeit2 = zeit1;        // Zeit abspeichern
       zeit2/= 0xDBBA00;  // 1s
       test = zeit1;
       personen++;
       zeit1 = 0;  
       besetzt = 0;
       sensor1 = 0;
       pTimer->TTC = 0x0;     //TC zurücksetzen
       pTimer->TIR = 1 <<5;

    }

     if(sensor2 == 1 && sensor1 == 0 && (pTimer->TIR == 0x10))
    {
       pTimer-> TTCR = 0x0;      //Timer stoppen
       zeit1 = pTimer-> TTC;
       zeit2 = zeit1;        // Zeit abspeichern
       zeit2/= 0xDBBA00;  // 1s
       test = zeit1;
       personen++;
       zeit1 = 0;  
       besetzt = 0;
       sensor2 = 0;
       pTimer->TTC = 0x0;
       pTimer->TIR = 1 <<4;

    }
  
      
    // Interrupt Flag löschen; TC wieder auf 0
       VIC_Controller_basis->VIC_Address = 0;  
  }

void PinConnectBlock (void)
{
    pPinsel->PIN_SEL1 |= 0x3C000;   //CAP3.0 & CAP3.1 input for Timer3
}

  //Initialize Timer
void init_Timer3(void)
{
  
  PCONP |=(1<<23);     //PONCONP Timer3 wird "geweckt"
  pTimer->TIR = 0x31; //CR0.0 und CR0.1 interrupt flag; Match register flag  -> 0x31;
  pTimer->TCCR = 0x2D; //Capture 0.0 und 0.1 rising edge; interrupt on cap0.0 und 0.1-> event will generate an interrupt
  pTimer->TMCR = 0x05; // interrupt on MR0 & Reset TC if Match
  pTimer->TMR0 = 0x337F9800; //Einstellung auf 1 min 0xDBBA00 * 60
}
void init_Timer0(void)
{
  pTimer2->TIR = 0x01; //Match Register
  pTimer2->TMCR = 0x03; // interrupt on MR0 & Reset TC if Match
  pTimer2->TMR0 = 0x337F9800; //Einstellung auf 1 min 0xDBBA00 * 60
}
void vic_init(void)
  
{
    VIC_Controller_basis->VIC_VectAddress[27] = (unsigned long)timer3_ISR;   //Vektor
    VIC_Controller_basis->VIC_VectPriority[27] = 0x0000000A;    //Priorität
    VIC_Controller_basis->VIC_IntEnable |= (1 << 27);    //Interrupt  freigeben für Timer3
  
    VIC_Controller_basis->VIC_VectAddress[4] = (unsigned long)timer3_ISR;   //Vektor
    VIC_Controller_basis->VIC_VectPriority[4] = 0x0000000B;    //Priorität
    VIC_Controller_basis->VIC_IntEnable |= (1 << 4);    //Interrupt  freigeben für Timer0
  

}

//MAIN function
int main(void)
{  
  pTimer = TIMER3_BASE;
  pTimer2 = TIMER0_BASE;
  pPinsel = PinConnectBlock_BASE;
  VIC_Controller_basis = VIC_BASE;
  PinConnectBlock();
  vic_init();
  init_Timer0();
  init_Timer3();
  
  //Initialize LCD
  lcd_init();
  lcd_clear();

  while (1)
  {
    /* if(zeit2>=60)
     {
      set_cursor(0,0);
      lcd_print("Zeitueberschreitung");
     }
     for(wait=0;wait<(1440000/2);wait++);
     lcd_clear();
     */
/*     if(pTimer->TTC == 0x337F9800)
     {  
       pTimer-> TTCR = 0x0;      //Timer stoppen
       lcd_clear();
       set_cursor(0,0);
       lcd_print("Timeout");
       timeout = 0;
     }
    */
//     for(wait=0;wait<(1440000/2);wait++);
//     lcd_clear();
/*     
     if(pTimer->TTC == 0x337F9800)
     {  
       pTimer-> TTCR = 0x0;      //Timer stoppen
       timeout = 1;
     }
*/  
     if(besetzt == 1)
     {
        pTimer2->TTCR = 0x01;
     }
     
     hilfe1 = 0;
     set_cursor(0,0);
     v = strecke/((double)zeit2);  
     sprintf(wert1, "t: %ds Pers. %d    ",zeit2,personen);
     lcd_print(wert1);
  
     set_cursor(0,1);
     sprintf(wert2, "v: %4.2f m/s",v);
     lcd_print(wert2);
    
  }
  

}

[Merve B. (student1990)]

Habe gerade einen Fehler entdeckt! Ich habe vergessen von Timer 3 die 
Einstellungen für das Match-Register raus zu nehmen. Vielleicht lag es 
daran. Ich probiere es gleich aus und werde hier dann das Verhalten 
schreiben.

[Merve B. (student1990)]

Hab es ausprobiert. Mein Problem ist, dass er nicht in die entsprechende 
ISR reinspringt. Das ist total seltsam, denn als ich ein Testprogramm 
geschrieben habe, hat das alles wunderbar funktioniert und es waren die 
selben Einstellungen für den Timer...
Kann mir wirklich keiner einen Tipp geben, warum er nicht in die ISR 
reinspringt, obwohl er ein Match erkennt?

Danke