Kann nicht Interrupt auslosen mit Timer4 und Timer5

[ivan (Gast)]

Ich will eine Steuerung bauen für das Einschalten bzw Ausschalten der 
Heizung in der Wohnung, ueber MOD-GSM(also SMS Versand und 
Auswertung).Dazu  habe ich Olimex Platine mit Pi32MX220(40MHZ ->Fosc), 
programmiere in C mit Pinguino IDE version x.4. Ich habe aus der 
Dokumentation von Microchip rausgelesen, dass  die Timer4 und Timer5 
kann man zusammen schalten und daraus ein 32 Bit Timer bauen, ich will 
mit dem Timer45 ein Interrupt auslosen, das  hat schon mal nicht 
funktioniert. Keine Ahnung warum hier ist mein C Code:

/*----------------------------------------------------- 
Author:  --<Ivan>
Date: Sat Sep 14 16:12:03 2013
Description:

-----------------------------------------------------*/
#define K 7
  //First Definition
void __attribute__ ((nomips16)) ISR_wrapper_vector_20(void) __attribute__ ((section (".vector_20")));
// Put the ISR_wrapper in the good place

//Second Definition
void __attribute__ ((nomips16))  Tmr5Interrupt(void) __attribute__ ((interrupt));
// Tmr1Interrupt is declared as an interrupt routine

//Third Definition
void __attribute__ ((nomips16)) ISR_wrapper_vector_20(void) { Tmr5Interrupt(); }
// ISR_wrapper will call the Tmr1Interrupt()

// define here the code to execute when an interrupt occure
void  __attribute__ ((nomips16))  Tmr5Interrupt(void) 
   {
      
        digitalWrite(K,HIGH);
   
        init_timer45();
}
   
void init_timer45(void)
  {
    
    T4CON=0x0;      // Stop timer 4
    T5CON=0x0;      // Stop timer 5
    T4CONSET=0x0008;      // Enable  32 Bit mode pescaler 1:1,
                          // Internal clock source
                          
    TMR4=0x0;        // Clear contents of the timer 4 and timer 5
  
    PR4=0xDC3CBA00;      // Load PR4 and PR5 with 32 Bit value
  
    IPC5SET=0x00000004;    // Set priority level 1
    IPC5SET=0x00000001;    // Set sub priority level 1
    IFS0CLR=0x00100000;    // clear the timer 5 interrupt status flag
    IEC0SET=0x00100000;    // enable timer 5 interrupt
    T4CONSET=0x8000;        //Start the timer 
    
  }

void setup() {
    //run once:
    pinMode(K, OUTPUT);
    
    init_timer45();
    }

void loop() {
    //run repeatedly:
    //digitalWrite(K,HIGH);
    }

Definitiv habe ich irgendwo ein oder mehrere Fehlern, nach meinen 
Berechnungen soll Interrupt nach ca. 60 sec Portausgang K auf High 
setzen, ist aber nicht der Fall. Danke für die Hilfe.

[Thomas (Gast)]

Probiere ohne (nomips16)

[Ivan (Gast)]

Ich werde es heute nach der Arbeit probieren.
Danke

[ivan (Gast)]

@Thomas
Nein hat nicht geholfen ich glaube es ligt an der Interrupt Vector 
definition! Kennt sich jemand aus mit dem kalkulieren der Vectornummer 
für Pic32, danke

[Peter D. (peda)]

Zu einem Compiler gibt es meistens auch ein Verzeichnis mit Beispielen, 
die sollten eigentlich laufen.
Und wenn man die verstanden hat, kann man davon ausgehend seinen eigenen 
Code schreiben.
Nur planlos rumraten bringt allgemein garnichts.

Ich würde auch nicht gleich mit nem 32Bit-Boliden anfangen, sondern nem 
kleinen 8Bitter.
Die 40MHz sind für ne Heizungssteuerung etwa 1000-fach zu schnell.

[Ivan (Gast)]

@Peter
Danke für den vorschlag, ich habe leider schon die platine vom olimex 
da, mit pic32mx, gerade die neue interrupt beispiele lassen sich nicht 
mit pinguino ide übersetzen.
Um das ganze langsammer zu machen wollte ich die timer4 und timer5 
zusammen schalten, damit ich auf 2^32 - 1, also ein 8byte wert in 
timer45 setzen kann.
Leider wird die interrupt routine nicht ausgelost, led leuchtet nicht. 
Also weiss ich nicht woran es liegen kann, aber danke für die 
rückmeldung.

[Peter D. (peda)]

Ivan schrieb:
> gerade die neue interrupt beispiele lassen sich nicht
> mit pinguino ide übersetzen.

Du brauchst natürlich solche Beispiele, die zu Deiner Toolchain passen.
Ansonsten schmeiß die Toolchain weg und nimm eine passende.

[Ivan (Gast)]

@Peter
ich finde kein beispiel wo ich zwei timer 2 und 3 bzw. 4 und 5 zu einem 
schalte und dann mit timer23 bzw. timer45 interrupt auslose. In meiner 
anwendung möchte ich die zwei priorisierten interrupts laufen lassen den 
1 interrupt fürs abholen der sms und den zweiten zum steuern der 
portsausgänge und zeitberechnung. Das abholen der sms funktioniert 
bereits, aber wenn ich dazu timer45 nehme, dann geht es nicht mehr. 
Interrupt wird nicht durch timer45 ausgelost. Keine ahnung warum? Werde 
dankbar für jeden hinweis.

[Chris B. (dekatz)]

Die Initialisierung für Timer45 ist in Ordnung.

Ob die Initialisierung von der IPC, IFS und IEC Register OK ist habe ich 
nicht überprüft, wie auch die Interruptroutinen selbst - ziemlicher 
Aufwand um einen Timerinterrupt zu Händeln ( ich verwende MPLAB/MPLABX 
und dem C32/CX32 - da gibt es aussagekräftige Funktionen bzw. Macros 
dafür)
z.B.
void __ISR(_TIMER_1_VECTOR, IPL5SOFT) Timer1Handler(void)
{
    mT1ClearIntFlag();
    LATBINV = 0x00008000;       //Ausgangssignal für Testzwecke erzeugen
}
macht genau das was du machst - nur eben Timer1, Priority=5 und ein 
anderer Pin für die LED.

btw: Warum Initialisierts du in der Interruptroutine jedesmal Timer45 
aufs neue?? Das Löschen des entsprechenden Interruptflags reicht völlig.

[Peter D. (peda)]

Ivan schrieb:
> ich finde kein beispiel wo ich zwei timer 2 und 3 bzw. 4 und 5 zu einem
> schalte und dann mit timer23 bzw. timer45 interrupt auslose.

Dann nimm doch erstmal ein Beispiel für einen Timer und bring das zum 
Laufen.
Du kannst dann im Interrupt einfach eine Variable hochzählen.
Man muß nicht alle Features nehmen, nur weil sie möglich sind.

Ich bin mir aber sicher, im Datenblatt werden die Unterschiede 
beschrieben sein, so viele können das ja nicht sein.

[Ivan (Gast)]

@Chris
Hallo und danke zuerst für den hiweis, ich werde heute abend 
MPLAB/MPLABX
und den compiler C32/CX32 ausprobieren, vielleicht bringe ich es zum 
laufen mit diesem tool. Ich fand das pinguino ide ziemlich komfortabel, 
aber alles hat sein preis.
Warum ich timer45 neu initialisiere? Hm, ich war schon ziemlich 
verzweifelt, und dachte, wenn es nicht beim ersten durchlauf klappt dann 
... , also war nicht sicher ob der timer4 und timer5 laufen, habe kein 
simulator oder so was.
Ich probiere heute den neuen weg und melde mich noch mal. Danke!!!

[Chris B. (dekatz)]

Es genügt MPLABX und der XC32 weil MPLAB und C32 nicht mehr von 
MICROCHIP aktualisiert werden!!

[Ivan (Gast)]

@Chris
Gibt es auch für linux? Habe kein Windows leider :)

[Chris B. (dekatz)]

MPLABX und XC32 auch für Linux !!

[Ivan (Gast)]

@Chris
Vielen dank, ich melde mich heute abend mit dem ergebnis

[ivan (Gast)]

@Chris
Habe schon MPLAB X c32 installiert, muss noch mich einarbeiten, mal 
sehen

[Ivan (Gast)]

Habe so ein programm geschrieben bzw. angepasst und aufgespielt auf 
PIC32 MX220 mit MPLAB X

#include <plib.h>



main()
{
    mPORTCClearBits(BIT_7);           //Clear bits to ensure the LED is off.
    mPORTCSetPinsDigitalOut(BIT_7);   //Set port as output

   
 int j;

    while(1)    
    {
        j = 100000;
        mPORTCToggleBits(BIT_7);      //Toggle light status. 
        while(j--) {}                 //Kill time.
    }
}

Es funzt nicht led ist off?
Woran kann es liegen, ist die platine schon hinüber?
Danke

[Ivan (Gast)]

OK, habe fehler gefunden PGM und PGD verwechselt
Sorry!

[Ivan (Gast)]

Hier ist mein C Code:

#include <plib.h>
#include <stdio.h>


void __ISR(_TIMER_45_VECTOR, IPL5SOFT) Timer45Handler(void) //Priority=5
{
    mT45ClearIntFlag();
    mPORTCClearBits(BIT_6);
}
void init_timer45(void)
  {
    INTEnableSystemMultiVectoredInt();
    T4CON = 0x0; // Stop 16-bit Timer4 and clear control register
    T5CON = 0x0; // Stop 16-bit Timer5 and clear control register
    T4CONSET = 0x0008; // Enable 32-bit mode, prescaler at 1:1,     // internal clock source
    TMR4 = 0x0; // Clear contents of the TMR4 and TMR5
    PR4 = 0xFFFFFF00;//0xDC3CBA00; // Load PR4 and PR5 registers with 32-bit value
    IPC5SET = 0x00000006; // Set priority level = 6
    IPC5SET = 0x00000003; // Set sub-priority level = 3
    IFS0CLR = 0x00100000; // Clear the Timer5 interrupt status flag
    IEC0SET = 0x00100000; // Enable Timer5 interrupts
    T4CONSET = 0x8000; // Start timer

  }
main()
{   
    mPORTCClearBits(BIT_7);           //Clear bits to ensure the LED is off.
    mPORTCSetPinsDigitalOut(BIT_7);   //Set port as output
    mPORTCClearBits(BIT_6);           //Clear bits to ensure the LED is off.
    mPORTCSetPinsDigitalOut(BIT_6);   //Set port as output
    PORTCbits.RC6 = 1;
    //mPORTCClearBits(BIT_6);
    
    init_timer45();
 int j;

    while(1)
    {
        j = 100000;
        mPORTCToggleBits(BIT_7);      //Toggle light status.
        while(j--) {}                 //Kill time.
    }
}

Warum wird Interrupt nicht ausgelost? Kann jemand helfen, danke?

[Chris B. (dekatz)]

.....PR4 = 0xFFFFFF00;
Keine Ahnung wie der Controller konfiguriert ist, aber wenn der mit FRC 
8MHz Takt läuft PBCLK 1:1 ist, dann dauert es 4294967040 * 0,125µs bis 
der Interrupt ausgelöst wird..das sind 536 Sekunden bzw. 9 Minuten

Und das hier:

void __ISR(_TIMER_45_VECTOR, IPL5SOFT) Timer45Handler(void) //Priority=5
....
IPC5SET = 0x00000006; // Set priority level = 6

passt auch nicht so recht zusammen - entweder 5 oder 6 !

[Ivan (Gast)]

@Chris
Danke für die antwort, war schon zu spät wo ich das ganze zusammen 
geschrieben habe, konzentration war ganz unten. Ja, den fehler sehe ich 
auch, kann erst heute abend neu ausprobieren.
Habe noch eine frage Chris, da mein englisch nicht so gut ist, wie muss 
man richtig den IPLX für irgendein timer wählen, bin mit der tabelle von 
microchip nicht klar gekommen. Wenn du mir das kurz erklären kannst wäre 
schön.
Danke.

[Chris B. (dekatz)]

IPLx{mode} legt fest auf welche Weise die Register bei Einsprung in die 
Interruptroutine gesichert werden.

IPLxSOFT: Sichert/Wiederherstellung die Register mit PUSH/POP Befehle 
auf den Stack - langsamste Methode

IPLxSRS: Sicher die Register in ein "Shadow Register Set" mit einem 
einzigen Befehl - schnellste Methode, da es aber nur 1 solches 
Registerset gibt (ev. gibt es mehrere, aber da müsste ich erst 
nachsehen!?) kann darüber nicht x-beliebig verfügt werden.

IPLxAUTO: erzeugt zusätzlichen Code welcher vor der Registersicherung 
testet, ob SOFT oder SRS verwendet werden kann/muss.

IPLx{mode} kann man auch weglassen, dann wird AUTO angenommen.

(nur so im Groben, wies exakt funkteoniert habe ich auch nicht im 
Kopf..ist im XC32-Compiler manual genauer beschrieben)

Das "x" in IPLx{mode}...musst du selbst entscheiden wie wichtig, 
dringlich, etc.  dein Timerinterrupt gegüber anderen Interruptquellen 
ist.
Muss dann aber mit den Einstellungen in den IPCx Registern 
übereinstimmen!

[Ivan (Gast)]

@Chris
Danke, ich werde es heute abend ausprobieren.

[Ivan (Gast)]

Also mit interrupts bin ich klar gekommen.
Habe aber ein problem mit UART schnittstelle, hier ist mein programm in 
C,

#include <stdio.h>
#include <string.h>
#include <p32xxxx.h>
#include <plib.h>


// Config Bits
#pragma config FNOSC = FRCPLL       // Internal Fast RC oscillator (8 MHz) w/ PLL
#pragma config FPLLIDIV = DIV_2     // Divide FRC before PLL (now 4 MHz)
#pragma config FPLLMUL = MUL_20     // PLL Multiply (now 80 MHz)
#pragma config FPLLODIV = DIV_2     // Divide After PLL (now 40 MHz)
                                    // see figure 8.1 in datasheet for more info
#pragma config FWDTEN = OFF         // Watchdog Timer Disabled
#pragma config ICESEL = ICS_PGx1    // ICE/ICD Comm Channel Select (pins 4,5)
#pragma config JTAGEN = OFF         // Disable JTAG
#pragma config FSOSCEN = OFF        // Disable Secondary Oscillator


 // Defines
#define SYSCLK 40000000L


 #define DESIRED_BAUDRATE     115200


 void WriteString(const char *string);
 int x = 1000000;
 char buffer[100];

int main(void)
 {
                 mPORTCClearBits(BIT_7);                            // Turn off RA7 on startup.
                 mPORTCSetPinsDigitalOut(BIT_7);           // Make RA7 as output.

 UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
     UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
     UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
     UARTSetDataRate(UART2, SYSCLK, DESIRED_BAUDRATE);
     UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));

// Turn ECHO OFF
WriteString("ATE0\r\n");
     WriteString("ATE0\r\n");
     WriteString("ATE0\r\n");
     
     
                // Time delay
                while(x--) {}
               
     
     WriteString("AT+CMGF=1\r\n");
     WriteString("AT+CMGDA=\"DEL ALL\"\r\n");

                 
                 while (1){
                     //REQUEST THE NEW SMS MESSAGE
                     WriteString("AT+CMGR=1\r\n");
                     
                     // Wait until the SMS indicator string is received
                     x=1000000;
                     while(x--) {}
                     
                   
                     
                      char f = 0;
                      char c;
                     
                      x = 1000000;

                        do{
                            

                            PORTCbits.RC7 = 1;
                            //PORTCbits.RC7 = 0;
                            if(f<2){
                            c = UARTGetDataByte(UART2);//ReadUART2();
                    // Skip the <CR><LF> characters at the beginning of the string
                            if(!(c== 0x0d || c== 0x0a)){buffer[f] = c; f++;}

                            c = UARTGetDataByte(UART2);//ReadUART2() ;
                            if(!(c== 0x0d || c== 0x0a)){buffer[f] = c; f++;}
                            
                            }else{
                                c = UARTGetDataByte(UART2);//ReadUART2() ;
                                buffer[f] = c; f++;
                            }
                      
                        }while( c != 'K' );
                        buffer[f] = '\0';
PORTCbits.RC7 = 0;

  


    WriteString("AT+CMGDA=\"DEL ALL\"\r\n");
         }
                 return 0;
 }
 

 // helper functions
 void WriteString(const char *string)
 {
     while(*string != '\0')
     {
         while(!UARTTransmitterIsReady(UART2))
             ;

         UARTSendDataByte(UART2, *string);
         //putsUART2(*string);
         string++;

         while(!UARTTransmissionHasCompleted(UART2))
             ;
     }
 }

Nach meiner überlegung, wenn ich ein SMS mit inhalt 'K' sende muss die 
led off sein, ist aber nicht der fall, wenn jemand helfen könnte würde 
ich sehr dankbar

[Chris B. (dekatz)]

Tut sich gar nichts auf den UART Pins?
Das ist doch ein PIC32MX220xxxxx - oder??
Da sind die Pins für UART, SPI, I2C nur über PPS (Peripheral Pin select) 
zugänglich.
Die Beschreibung dafür findet sich im PIC32MX1xx/2xx Manual (DS61168) ab 
Seite 143.
Ich habe hier einen PIC32MX220F032B auf Lochraster mit MAX3232 aufgebaut 
und die Zuordnung von RX/TX findet so statt:

// Zugriff auf PPS must erst freigeschaltet werden!!
  SYSKEY = 0;                   // locked durch sinnlosen Wert
  SYSKEY = 0xAA996655;          // Key1 für unlock
  SYSKEY = 0x556699AA;          // Key2 für unlock
  CFGCONbits.IOLOCK = 0;
  // Peripheral pin select:
  PPSInput(3,U1RX,RPB2);        // RX auf RB2
  PPSOutput(1,RPB3,U1TX);       // TX auf RB3
  // PPS-Zugriff wieder sperren
  CFGCONbits.IOLOCK = 1;
  SYSKEY = 0;                   // locked

Für dein Board musst du dir die entsprechenden PPSInput/PPSOutput 
entsprechend abändern.

[Ivan (Gast)]

@Chris
Danke dir für info, ich werde mich zuerst einlesen, brauche paar minuten 
zeit
Vielen vielen dank :)

[Ivan (Gast)]

@Chris

Habe mein code so angepasst:

#include <stdio.h>
#include <string.h>
#include <p32xxxx.h>
#include <plib.h>

// Config Bits
#pragma config FNOSC = FRCPLL       // Internal Fast RC oscillator (8 MHz) w/ PLL
#pragma config FPLLIDIV = DIV_2     // Divide FRC before PLL (now 4 MHz)
#pragma config FPLLMUL = MUL_20     // PLL Multiply (now 80 MHz)
#pragma config FPLLODIV = DIV_2     // Divide After PLL (now 40 MHz)
                                    // see figure 8.1 in datasheet for more info
#pragma config FWDTEN = OFF         // Watchdog Timer Disabled
#pragma config ICESEL = ICS_PGx1    // ICE/ICD Comm Channel Select (pins 4,5)
#pragma config JTAGEN = OFF         // Disable JTAG
#pragma config FSOSCEN = OFF        // Disable Secondary Oscillator


 // Defines
#define SYSCLK 40000000L


 #define DESIRED_BAUDRATE     115200


 void WriteString(const char *string);
 int x = 1000000;
 char buffer[100];

 int main(void)
 {                

  
                
                   
                 mPORTCClearBits(BIT_8);                            // Turn off RA7 on startup.
                 mPORTCSetPinsDigitalIn(BIT_8);           // Make RA7 as output.
                 mPORTCClearBits(BIT_9);                            // Turn off RA7 on startup.
                 mPORTCSetPinsDigitalOut(BIT_9);           // Make RA7 as output.
                 mPORTCClearBits(BIT_7);                            // Turn off RA7 on startup.
                 mPORTCSetPinsDigitalOut(BIT_7);           // Make RA7 as output.
                 mPORTCClearBits(BIT_6);                            // Turn off RA7 on startup.
                 mPORTCSetPinsDigitalOut(BIT_6);           // Make RA7 as output.
                 mPORTCClearBits(BIT_5);                            // Turn off RA7 on startup.
                 mPORTCSetPinsDigitalOut(BIT_5);           // Make RA7 as output.
  SYSKEY = 0;                   // locked durch sinnlosen Wert
  SYSKEY = 0xAA996655;          // Key1 für unlock
  SYSKEY = 0x556699AA;          // Key2 für unlock
  CFGCONbits.IOLOCK = 0;
  // Peripheral pin select:
  //PPSUnLock;
  PPSInput(2,U2RX,RPC8);        // RX auf RB2
  PPSOutput(4,RPC9,U2TX);       // TX auf RB3
  //PPSLock;
  CFGCONbits.IOLOCK = 1;
  SYSKEY = 0;                   // locked
     UARTConfigure(UART2, UART_ENABLE_PINS_TX_RX_ONLY);
     UARTSetFifoMode(UART2, UART_INTERRUPT_ON_TX_NOT_FULL | UART_INTERRUPT_ON_RX_NOT_EMPTY);
     UARTSetLineControl(UART2, UART_DATA_SIZE_8_BITS | UART_PARITY_NONE | UART_STOP_BITS_1);
     UARTSetDataRate(UART2, SYSCLK, DESIRED_BAUDRATE);
     UARTEnable(UART2, UART_ENABLE_FLAGS(UART_PERIPHERAL | UART_RX | UART_TX));

 WriteString("ATE0\r\n");
     WriteString("ATE0\r\n");
     WriteString("ATE0\r\n");
     
     
                // Time delay
                while(x--) {}
               
     
     WriteString("AT+CMGF=1\r\n");
     WriteString("AT+CMGDA=\"DEL ALL\"\r\n");

                 
                 while (1){
  
                     //REQUEST THE NEW SMS MESSAGE
                     WriteString("AT+CMGR=1\r\n");
                     
                     // Wait until the SMS indicator string is received
                     x=1000000;
                     while(x--) {}
                     
                   
                     
                      char f = 0;
                      char c;
                     
                      x = 1000000;

                        do{
                            

                            PORTCbits.RC7 = 1;
                            //PORTCbits.RC7 = 0;
                            if(f<2){
                            c = UARTGetDataByte(UART2);//ReadUART2();
                    // Skip the <CR><LF> characters at the beginning of the string
                            if(!(c== 0x0d || c== 0x0a)){buffer[f] = c; f++;}

                            c = UARTGetDataByte(UART2);//ReadUART2() ;
                            if(!(c== 0x0d || c== 0x0a)){buffer[f] = c; f++;}
                            
                            }else{
                                c = UARTGetDataByte(UART2);//ReadUART2() ;
                                buffer[f] = c; f++;
                            }
                      
                        }while( c != 'K' );
                        buffer[f] = '\0';
 PORTCbits.RC7 = 0;
 x=1000000;
 while(x--) {}
  


    WriteString("AT+CMGDA=\"DEL ALL\"\r\n");
                // PPS-Zugriff wieder sperren
  
         }
                 return 0;
 }
 

 // helper functions
 void WriteString(const char *string)
 {
     while(*string != '\0')
     {
         while(!UARTTransmitterIsReady(UART2))
             ;

         UARTSendDataByte(UART2, *string);
         //putsUART2(*string);
         string++;

         while(!UARTTransmissionHasCompleted(UART2))
             ;
     }
 }
 /*
 void PutCharacter(const char character)
 {
         while(!UARTTransmitterIsReady(UART2))
             ;

         UARTSendDataByte(UART2, character);


         while(!UARTTransmissionHasCompleted(UART2))
             ;
 }*/
 // UART 2 interrupt handler
 // it is set at priority level 2
void __ISR(_UART2_VECTOR, ipl2) IntUart2Handler(void)
 {
                 int c;

               // Is this an RX interrupt?
                 if(INTGetFlag(INT_SOURCE_UART_RX(UART2)))
                 {
                      c= UARTGetDataByte(UART2);

                      // Clear the RX interrupt Flag
                     INTClearFlag(INT_SOURCE_UART_RX(UART2));

                     // Echo what we just received.
                     //PutCharacter(c);

                    // Toggle LED to indicate UART activity
                    mPORTCToggleBits(BIT_7);
                 }

}

Trotzdem geht es nicht, die led an port RC7 ist konstant an, es liegt 
bestimmt an der auswertung von character, oder die while schleife ist 
nicht richtig oraniesiert. Ich habe übrigens :PIC32MX220F032D an dem 
olimex board. Habe noch zusätzlich an dem Tx ausgang led angelegt(nicht 
während der datenübertragung), die flimmert leicht, also tut sich da 
was, hm ??

[Chris B. (dekatz)]

Hmmmm...der _UART2_VECTOR bedient 3 Interruptquellen, u.a. auch den 
TX-Interrupt (was nr.3 ist weiss ich jetzt nicht auswendig, habe ich bei 
mir aber auchnicht berücksichtigt...). Versuch einfach mal das TX-Int 
Flag zurückzusetzen, also nach dem

if(INTGetFlag(INT_SOURCE_UART_RX(UART2)))
  {
   ......
   ......
  }

fügst du noch:

// TX Interrupt ohne Funktion
  if ( INTGetFlag(INT_SOURCE_UART_TX(UART1)) )
    {
      INTClearFlag(INT_SOURCE_UART_TX(UART1));
    }

ein.

[Ivan (Gast)]

@Chris
Leider hat nicht geholfen.

[Ivan (Gast)]

@Chris
Ich checke noch mal hardware wegen drahtbruch u.s.w, villeicht habe ich 
da meht glück, wünsche dir schönen abend

[Ivan (Gast)]

@Chris
Also HW ist in ordnung, ich habe probiert noch ein gleichen board 
(olimex pi32-pinguino-mx220) mit pinguino ide zu programmieren, das 
programm nutzt nicht uart2 wie ich sonder uart1 und es funktioniert, µC 
signaliesiert, dass die sms empfangen werden, ich werde probieren mein 
mplab programm auf uart1 umzustellen, wieso geht es nicht über uart2?

[Chris B. (dekatz)]

Keine Ahnung auf die Schnelle.
Die beiden von mir geposteten Zeilen
......
// TX Interrupt ohne Funktion
  if ( INTGetFlag(INT_SOURCE_UART_TX(UART1)) )
    {
      INTClearFlag(INT_SOURCE_UART_TX(UART1));
    }
.....
hast du hofffentlich auf UART2 angepasst??

[Ivan (Gast)]

ja habe geändert gehabt weil bei mir im programm nutze ich uart2