Usart + Timer Interrupt Problem

[Hannes A. (m4f1)]

Hallo,
ich komme direkt zu meinem Problem: Es ist mir nicht möglich Zeichen 
über die USART Schnittstelle einzulesen und im Anschluss einen Timer 
laufen zu lassen.
Es handelt sich dabei um einen XMEGA128A3.
Ich lese via USART Schnittstelle Zeichen wie folgt ein

char usart_getc(void)
{
  char c;
  while (!( USARTF0.STATUS & USART_RXCIF_bm));
  c=USARTF0.DATA;

  return(c);
}

Lese ich nun ein oder mehrere Zeichen ein, so wird mein Timer overflow 
Interrupt im Anschluss nicht mehr ausgelöst.

Hat jemand eine Idee worran es liegen oder wie ich das Problem umgehen 
könnte?

[holger (Gast)]

>Hat jemand eine Idee worran es liegen oder wie ich das Problem umgehen
>könnte?

Mit dem popeligen Stück Quellcode hat da sicher niemand eine Idee.

[Hannes A. (m4f1)]

Die USART Schnittstelle initialisiere ich wie folgt

void USART_Init_intern(void) 
{
  // BSEL ausrechnen, Berechnung siehe Datenblatt Seite 238 (bscale = -5)
  // Berechnung für internen Oszillator f=32 MHz, RS232 Geschwindigkeit 256K0
  USARTF0.BAUDCTRLA = 218&0xff;          // siehe Seite 254 Datenblatt
  USARTF0.BAUDCTRLB = (-5<<4)|(218>>8);       // siehe Seite 254 Datenblatt
  USARTF0.CTRLA = 0x30;                 // USART_RXCINTLVL_HI_gc;   //RX interrupt high level
    USARTF0.CTRLB = 0x18;              // RX und TX enable, siehe Seite 251
    USARTF0.CTRLC = 0x03;              // Datenformat einstellen, ansynchron, keine Parity, 1 Stop-Bit, 8 Daten-Bits siehe Seite 252 ff
  PORTF.DIR |= (1<<PIN3); 
  PORTF.DIR &= ~(1<<PIN2); 
  PMIC.CTRL |= 0x04;              //set PMIC high level enable
}

Den Timer wie folgt

TCC0_INTCTRLA = TC_OVFINTLVL_HI_gc;  // enable interrupt

Routine

void move(uint16_t step)
.
.
.
  // start counter
  TCC0_CTRLA = TIMER_PRESCALE_gc;

  // acceleration phase
  accel_function = accelerate;
  while ( steps > threshold_2 )
  {
    TCC0_PER = accel_function();  // set new timer value
    while ( !timer_ovf );  // wait for timer
    CHOPPER_STEP();
  }

Timer Interrupt

ISR( TCC0_OVF_vect )
{
  timer_ovf = TRUE;
}

Meine main sieht wie folgt aus:

        Verschiedene Variablien Deklarationen
        .
        .
  clock_intern_32(); //Interner 32Mhz Oszillator
  USART_Init_intern();
  inputs_Init();  //Input Ports
  outputs_Init(); //Output Ports
        SPI_INIT_E();   //ADC Schnitstelle
  STEPPERMODE();  //Motor
  pullup();  //Pullup Widerstand
  init_move();    //Timer Initialisierung
  sei();
        while(1)
        {  
                switch((int)usartgetc())
                {
                  case '1':
        
                    CW();
                    move(15000);
                    CCW();
                    move(15000);
                }    
        }

Rufe ich usartgetc vorher nicht auf, funktioniert alles wunderbar, 
leider aber bin ich auf Benutzereingaben angewiesen.
Mit usart... hängt meine Routine move()... an

while ( !timer_ovf );

 da es nicht mehr zum Timer Interrupt kommt.

Ich hoffe ich konnte euch das Problem damit näher bringen

[Karl H. (kbuchegg)]

Slawa Kabanovic schrieb:


> Mit usart... hängt meine Routine move()... an

while ( !timer_ovf
> );

 da es nicht mehr zum Timer Interrupt kommt.

bist du sicher, dass das programm an dieser stelle hängt un nicht 
einfach nur hier drinnen?

char usart_getc(void)
{
  char c;
  while (!( USARTF0.STATUS & USART_RXCIF_bm));
  c=USARTF0.DATA;

  return(c);
}

Sprich: Hast du kontrolliert, ob du von der USART ein Zeichen bekommst 
und wenn ja, welches das ist?

[Karl H. (kbuchegg)]

timer_ovf ist hoffentlich volatile definiert?

[Hannes A. (m4f1)]

Karl Heinz Buchegger schrieb:
> Sprich: Hast du kontrolliert, ob du von der USART ein Zeichen bekommst
> und wenn ja, welches das ist?

Ich bin mir sogar sehr sicher, da bei richtiger Eingabe in die 
Switch-Case Anweisung/Schleife gesprungen wird und ich per Ausgabe via 
USART getestet habe an welcher Stelle das Programm hängt.

Karl Heinz Buchegger schrieb:
> timer_ovf ist hoffentlich volatile definiert?

Kann ich leider erst morgen genauer sagen, weil ich gerade wieder zu 
hause bin. Wenn es daran scheitern sollte, warum hat das Ganze dann aber 
ohne USART so wunderbar geklappt?

[Hannes A. (m4f1)]

Ich werde gleich weiter an meinem Problem Arbeiten und timer_ovf auf 
volatile prüfen, auch wenn nicht denke das es daran liegt.
Ich kann mir im Grunde nur vorstellen, dass
> while (!( USARTF0.STATUS & USART_RXCIF_bm));
irgendwie im Konflikt mit dem Timerinterrupt steht, kann das sein? Lasse 
ich nämlich die USART-Funktion weg, klappt das ganze wunderbar.

[Hannes A. (m4f1)]

So, ich habs. Es liegt an

USARTF0.STATUS

 und der Timer vertragen sich nicht :( wie aber kann diese Abfrage 
umgehen?

[Hannes A. (m4f1)]

Ich habe den Fehler inzwischen gefunden es lag an der Initialisierung 
der USART Schnittstelle

USARTF0.CTRLA = 0x30;  // USART_RXCINTLVL_HI_gc;   //RX interrupt high level

Da ich auf den Interrupt nicht angewiesen war/bin, habe ich auch nicht 
daran gedacht ihn zu definieren, hätte also entweder eine leere 
Interruptroutine erstellen müssen oder aber den Interrupt ausstellen mit

USARTF0.CTRLA = USART_RXCINTLVL_OFF_gc;

Ich bedanke mich bei den Helfern, der Thread kann geschlossen werden 
/closed

[Stefan (Gast)]

etwas spät die Antwort aber durch scharfes hinsehen:

 ISR( TCC0_OVF_vect )
 {
    ...
 }

entspricht nicht der Konfiguration

 USARTF0.xxx = yyy;