USART_Interrupt_verlassen_funktioniert_nicht

[Alex X. (behindi)]

Hallo

ich hab nen keleines Problem und es wäre super wenn mir jemand weiter 
helfen könnte:) , danke im vorsus für jede Hilfe

ich verwende den PIC18F46K20. Der PIC soll einen Interrupt auslösen wenn 
ein Byte über die USART enpfangen wird. Das Problem ist dass der 
Interrupt in einer Endlosschleife ausgeführt wird trotz dass das Flagbit 
gelöscht wird.??
Das Byte sende ich vom PC aus. Die USART und die kommunikation mit dem 
PC funktioniert. Hat von euch jemand ne idee was ich falsch mache?
hier der code

#pragma config FOSC = INTIO67, FCMEN = OFF, IESO = OFF
#pragma config PWRT = ON, BOREN = OFF, BORV = 18
#pragma config WDTEN = OFF, WDTPS = 1
#pragma config MCLRE = ON, HFOFST = OFF, LPT1OSC = OFF, PBADEN = OFF
#pragma config CCP2MX = PORTBE, STVREN = OFF, LVP = OFF, XINST = OFF, DEBUG = OFF
#pragma config CP0 = OFF, CP1 = OFF, CP2 = OFF, CP3 = OFF
#pragma config CPB = OFF, CPD = OFF
#pragma config EBTR0 = OFF
#pragma config EBTR1 = OFF
#pragma config EBTR2 = OFF
#pragma config EBTR3 = OFF

#define USE_OR_MASKS

#include "p18f46K20.h"
#include "delays.h"
#include "usart.h"

unsigned char i,j;

#pragma code

void PORT_INIT(void);
void UART_CONFIG(void);

void ISH(void);
void ISL(void);
void INT_UART_INIT(void);

#pragma code IVH = 0x08      // Interrupt-Vektor fuer hohe Prioritaet (HP)
void IVH(void)
{
  _asm              // So werden Assembler-Befehle in C eingebettet
    goto ISH          // Interrupt Service Routine fuer HP
  _endasm
}

#pragma code IVL = 0x18      // Interrupt-Vektor fuer niedere (low) Prioritaet (LP)
void IVL(void)
{
  _asm
    goto ISL          // Interrupt Service Routine fuer LP
  _endasm
}

void main(void)
{
  PORT_INIT();
  UART_CONFIG();
    INT_UART_INIT();
    LATD=0x00;
    Delay10KTCYx(100);

  while(1);
}

void PORT_INIT(void)
  {
  OSCCONbits.IRCF2 = 1;
  OSCCONbits.IRCF1 = 0;           // 16MHz
  OSCCONbits.IRCF0 = 1;

    TRISD=0x00;
  }

void UART_CONFIG(void)
  {
  unsigned char config = 0, baudconfig = 0;
  unsigned int spbrg = 0;

    CloseUSART();

  config = USART_TX_INT_OFF | USART_RX_INT_ON | USART_ASYNCH_MODE | USART_EIGHT_BIT | USART_CONT_RX | USART_BRGH_LOW;
  spbrg =25;                      // 2400 Baud
  OpenUSART(config, spbrg);

  baudconfig = BAUD_8_BIT_RATE | BAUD_AUTO_OFF;
  baudUSART(baudconfig);
  }

void INT_UART_INIT(void)
    {
    PIE1bits.RCIE=1;                // enable USART resieve interrupts
    IPR1bits.RCIP=1;                 // high priority

    RCONbits.IPEN = 1;          // Interrupt-Prioritaeten deaktiviert
    INTCONbits.GIE = 1;          // Interrupts global aktiviert
    INTCONbits.PEIE = 1;        // Periphere Interrupts aktiviert
    }

#pragma interrupt ISH
void ISH(void)
    {
    LATD++;
    PIR1bits.RCIF = 0;                                               
    }

#pragma interruptlow ISL
void ISL(void) {}

[Conny G. (conny_g)]

> Das Problem ist dass der
> Interrupt in einer Endlosschleife ausgeführt wird trotz dass das Flagbit
> gelöscht wird.??

Also auf jeden Fall steht auf Seite 243 des Datasheet:

"The RCIF interrupt flag bit is read-only, it cannot be set or cleared 
by software."
(gleich am Anfang der Seite)

Der Code scheint momentan in der ISR nichts weiter zu machen, vielleicht 
MUSS man das Byte lesen oder den Interrupt anders resetten?
Es gibt auch einen Buffer Overrun, vielleicht schlägt der zu?

Ansonsten ist die ISH ja eine allgemeine Routine und nicht nur für den 
USART, vielleicht passiert da ja noch was anderes wie ein Timer 
Interrupt?

[B. S. (bestucki)]

Konrad hat recht, steht auch auf Seite 112:
> bit 5 RCIF: EUSART Receive Interrupt Flag bit
> 1 = The EUSART receive buffer, RCREG, is full (cleared when RCREG is
> read)
> 0 = The EUSART receive buffer is empty

Du musst RCREG lesen, dann erledigt sich die Sache von selbst. Das ist 
eines der wenigen Falgs, das man nicht manuell löschen muss.


Nachtrag:
Falls du später vor hast Daten zu senden; auch da gibts ne Falle. Dann 
löst das Interrupt immer aus, wenn der Buffer (TXREG) leer ist. Also 
auch dann, wenn du gar nichts senden willst. Daher musst du das erste 
Byte manuell in TXREG kopieren, Interrupt einschalten und den Rest 
kannst du dann im Interrupt erledigen. Hast du keine Daten zum senden 
mehr, so musst du das Interrupt wieder ausschalten.

[Alex X. (behindi)]

Danke für deine Hilfe,

habs im Datenblatt auch gelesen, aber
in einem Example von der C18 lib steht das zwar auch so:D

....
/*  66 */        */
/*  67 */       putsUSART (data[10]);
/*  68 */
/*  69 */       /* Display value received on LEDs */
/*  70 */       PORTB = c;
/*  71 */     }
/*  72 */
/*  73 */     /* Clear the interrupt flag */
/*  74 */     PIR1bits.RCIF = 0;
/*  75 */ }

naja löschen lässts sich jedenfalls nicht

Konrad G. schrieb:
> vielleicht
> MUSS man das Byte lesen

jo muss man :)

jetzt funktioniert es, danke für die Hilfe

mgf