AVR32: USART Empfangproblem mit DMA/PDCA

[optimax (Gast)]

Hallo zusammen,

also  direkt zum Problem:

Ich empfange mit dem USART1 einen Frame
der wird mit dem RXRDY-Interrupt behandelt

0x7e Delimiter
0xnn Länge des Frames
     speichern in einer Array
     wenn die Länge bekannt ist, PDCA initialisieren
     und restliche Bytes ebenfalls in die Array schaufeln

klappt wunderbar, d.h. solange ich die Frames manuell mit Hterm eintippe

Tippe ich 0x7e 0x05 PAUSE 0x01 0x02 0x03 ein läuft alles problemlos.
Sende ich dagegen 0x7e 0x05 0x01 0x02 0x03 an einem Stück werden 2 
Zeichen verschluckt!? Das ganze ist reproduzierbar und habe es auch 
schom mit verschiedenen Baudraten probiert. Getaktet ist der 
AT32UC3B0512 mit 12Mhz.
Habe ich irgendwas vergessen zu initialisieren? Ich habe keine Ahnung, 
wo ich weiter suchen kann/soll.

Ergebins im Array: 0x00 0x00 0x03 sonst 0x00

Ich bin ein bisschen ratlos. Eigentlich stammen die Funktionen von einem 
8bitter. Da klappt das ganze - natürlich ohne DMA - ganz gut, und wollte 
jetzt, wo schon ein PDCA vorhanden ist, den auch benutzen.


Init-Routine vor Endlosschleife

sysclk_init();  
   
   //Oscillator konfigurieren
   osc_enable(OSC_ID_OSC0);   
   osc_wait_ready(OSC_ID_OSC0);
   sysclk_set_source(SYSCLK_SRC_OSC0);

   static const usart_options_t USART_OPTIONS =
   {
     .baudrate     = 57600,
     .charlength   = 8,
     .paritytype   = USART_NO_PARITY,
     .stopbits     = USART_1_STOPBIT,
     .channelmode  = USART_NORMAL_CHMODE
   };
    
  gpio_enable_module(USART_GPIO_MAP, sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));
  usart_init_rs232((&AVR32_USART1), &USART_OPTIONS, 12000000L);

  INTC_init_interrupts();
  INTC_register_interrupt(&pdca_recieve_complete, AVR32_PDCA_IRQ_1 , AVR32_INTC_INT1);
  INTC_register_interrupt(&usart1_int_handler, AVR32_USART1_IRQ, AVR32_INTC_INT3);
   (&AVR32_USART1)->ier = AVR32_USART_IER_RXRDY_MASK;
     
   Enable_global_interrupt();

Hier wird der Wechsel von Interrupt-Steuerung nach DMA vollzogen:

__attribute__((__interrupt__)) static void usart1_int_handler(void)
{
gpio_tgl_gpio_pin(AVR32_PIN_PA08);

int c = 0;
usart_read_char((&AVR32_USART1), &c );

unsigned char tmp_UDR = (unsigned char) c ;
unsigned char tmp_ES = EmpfangsSeite;
unsigned char tmp_Position = Seite[tmp_ES].position;

switch(frameError)
{
  case FALSE:
    if(tmp_Position == 0x00)
    {
      if(tmp_UDR != 0x7e)
      {
        usart_write_line((&AVR32_USART1),"no Delimiter\r\n");
        frameError = TRUE;
        return;  
      }
      usart_write_line((&AVR32_USART1),"Delimiter\r\n");
      tmp_Position++;
      Seite[tmp_ES].position=tmp_Position;
      return;      
    }
    
    if(tmp_Position == 0x01)
    {
      
      
      usart_write_line((&AVR32_USART1),"Laenge\r\n");
      usart_putchar((&AVR32_USART1),tmp_UDR);
      Seite[tmp_ES].framelaenge = tmp_UDR;
    
      if(tmp_UDR > MAX_FRAME_LENGTH)
      {
        usart_write_line((&AVR32_USART1),"!max Laenge\r\n");
        frameError = TRUE;
        return;
      }
      
            
      //empfangenes Byte speichern
      Seite[tmp_ES].frame[tmp_Position] = tmp_UDR;

      //Position in der Bank erhöhen
      tmp_Position++;
      Seite[tmp_ES].position=tmp_Position;
    
//Hier ist möglicherweise der Fehler versteckt, wenn man die Daten in einem Rutsch ankommen
      //Disable USART1 Empfangsroutine: usart1_int_handler()
      usart_write_line((&AVR32_USART1),"DMA active\r\n");
  
      (&AVR32_USART1)->idr = AVR32_USART_IDR_RXRDY_MASK;

      //DMA: Ziel und Quelle wählen
      pdca_channel_options_t PDCA_USART1_OPTIONS_RX;
      PDCA_USART1_OPTIONS_RX.pid = AVR32_PDCA_PID_USART1_RX;          // Quelle
      PDCA_USART1_OPTIONS_RX.addr = &Seite[tmp_ES].frame[2];          // Zieladresse
      PDCA_USART1_OPTIONS_RX.size = (unsigned int)tmp_UDR-2;  
      PDCA_USART1_OPTIONS_RX.transfer_size = PDCA_TRANSFER_SIZE_BYTE;
      PDCA_USART1_OPTIONS_RX.r_addr = 0;                    //ungenutzt
      PDCA_USART1_OPTIONS_RX.r_size = 0;                    //ungenutzt
          
      pdca_init_channel(1,&PDCA_USART1_OPTIONS_RX);
      
      //mit DMA Transfer beginnen
      
      pdca_enable(1);
      pdca_enable_interrupt_transfer_complete(1);
      
    }

Bei Transferende wieder auf Interrupt-Behandlung wechseln:

__attribute__((__interrupt__)) static void pdca_recieve_complete(void)
{  
    
    usart_write_line((&AVR32_USART1),"DMA beendet\r\n");
    
    //PDCA: Kanal&Interrupt deaktivieren
    pdca_disable_interrupt_transfer_complete(1);
    pdca_disable(1);
    
    //USART1_RX Int einschalten
    (&AVR32_USART1)->ier = AVR32_USART_IER_RXRDY_MASK;
    
    //Bankwechsel
      Seite[EmpfangsSeite].status = AUSWERTEN;

      //leere Bank suchen
      unsigned char i = 0;
      for(; i<MAXSEITEN; i++)
      {
        if(Seite[i].status == UNBENUTZT)
        {
          EmpfangsSeite = i;
          Seite[i].status = EMPFANGEN;
          usart_write_line((&AVR32_USART1),"Neue Seite");
          
          usart_putchar((&AVR32_USART1), EmpfangsSeite);
        
          return;
        }
      }
      
      // wird nur bei nicht-vorzeitigem verlassen ausgeführt
      
        usart_write_line((&AVR32_USART1),"!Bank");
        pageError =  TRUE;
        frameError = TRUE;
}