Fast External Interrupts XC164 Infineon

[Rogger R. (manta)]

Hallo zusammen!

Ich habe unlängst versucht die Fast External Interrupts von meinem XC164 
von Infineon zu verwenden. Allerdings funktioniert das ganze nicht so 
richtig.
Falls es hilfreich ist, ich verwende die Software Keil zum 
programmieren!

Hier mal mein anfänglicher Code:

void extISR(void) interrupt 0x18
{
  counter = counter +1;
}

void main(void){
//Pin Konfig
DP1H_P0 = 0;
DP1H_P4 = 0;
  
//Mode Register auf Capture setzen
CC2_M4 |= 0x0200;

//ConRegister auf falling edge setzen
EXICON |= 0x0002; 
  
//Interrupt LVL und GVL setzen
CC1_CC8IC = 0x0059;

//
...
//

PSW_IEN = 1;

//
...
//

}

Nach einigen Recherchen bin ich schließlich draufgekommen, dass das 
Register EXICON schreibgeschützt ist und das ich das ganze mit einem 
"unlock modul" betreiben muss...dieses sollte so aussehen:

//****************************************************************************
// @Function      void MAIN_vUnlockProtecReg(void) 
//
//----------------------------------------------------------------------------
// @Description   This function makes it possible to write one protected 
//                register. After calling of this function and write on the 
//                protected register is the security level set to low 
//                protected mode.
//
//----------------------------------------------------------------------------
// @Returnvalue   None
//
//----------------------------------------------------------------------------
// @Parameters    None
//
//----------------------------------------------------------------------------
// @Date          27.02.2009
//
//****************************************************************************
void MAIN_vUnlockProtecReg(void)
{
  uword uwPASSWORD;

  if((SCUSLS & 0x1800) == 0x0800)      // if low protected mode
  {

    uwPASSWORD = SCUSLS & 0x00FF;
    uwPASSWORD = (~uwPASSWORD) & 0x00FF;
    SCUSLC = 0x8E00 | uwPASSWORD;      // command 4

  }  // end if low protected mode

  if((SCUSLS & 0x1800) == 0x1800)      // if write protected mode
  {
    SCUSLC = 0xAAAA;                   // command 0
    SCUSLC = 0x5554;                   // command 1

    uwPASSWORD = SCUSLS & 0x00FF;
    uwPASSWORD = (~uwPASSWORD) & 0x00FF;

    SCUSLC = 0x9600 | uwPASSWORD;      // command 2
    SCUSLC = 0x0800;                   // command 3; new PASSWOR is 0x00

    uwPASSWORD = SCUSLS & 0x00FF;
    uwPASSWORD = (~uwPASSWORD) & 0x00FF;
    SCUSLC = 0x8E00 | uwPASSWORD;      // command 4

  }  // end if write protected mode

} //  End of function MAIN_vUnlockProtecReg

So das ganze ist ja gut und schön, nur wie verwende ich diese "unlock 
Routine"? Wichitg für mich ist der command 4. Nach diesem sollte ich 
Schreibzugriff haben. Aber ich komm beim besten Willen nicht drauf, wie 
ich das Ding verwende :S
Aja und ich will keine Komplettlösung! Ich steh komplett auf der 
Leitung...Ich bräuchte nur einen Schubs in die richtige Richtung!

lg + danke
Manta

[Guido (Gast)]

Ich würde das eins zu eins aus der Dokumentation übernehmen.Es macht
wohl wenig Sinn sich Gedanken darüber zu machen. Wie der Keil das
umsetzt, wissen eh nur die Götter.

Programming Examples

EXTR #4 ;Sequence to change the security level
MOV SCUSLC, #0AAAAH ;Command0
MOV SCUSLC, #05554H ;Command1
MOV SCUSLC, #096FFH ;Command2: current password = 00H
MOV SCUSLC, #008EDH ;Command3: level = 01, new password = EDH

EXTR #1 ;Access sequence in secured mode
MOV SCUSLC, #8E12H ;Command4: current password = EDH
MOV register, data ;Access enabled by the preceding Command4

[B73 (Gast)]

Hallo manta,
ich kenne nur den XC167, aber vielleicht ist es ja beim XC164 genauso. 
Wenn Du Dir eine Beispielapplikation mit DAVE2 erzeugst, dann wird die 
Unlock-Funktion unmittelbar vor jedem Zugriff (exakt eine Zeile vorher) 
auf das geschützte Register in den Quellcode geschrieben. Danach ist das 
Register für einen Schreibzugriff geöffnet. Wenn Du nochmal schreiben 
möchtest, vorher nochmal Unlock aufrufen. Hope it helps.
Gruß,
B73
P.S. CC8 ist beim XC167 an P2.8 gebunden. Willst Du den IRQ beim 
Capture-Ereignis in CC8 oder bei einem Flankenwechsel am Eingang P2.8?

[Rogger R. (manta)]

Danke mal für die Antworten!

Davor die Routine aufrufen und dann verwenden! Danke das hat gefunzt!
(Es ist immer einfacher als man probiert ^^)

B73 schrieb:
> P.S. CC8 ist beim XC167 an P2.8 gebunden. Willst Du den IRQ beim
> Capture-Ereignis in CC8 oder bei einem Flankenwechsel am Eingang P2.8?

In den User Manuals steht bei den External Interrupts, dass das 
CC1_CC8IC das entsprechende Controlregister ist -> das stimmt ;)

---

Wenn wir gleich mal dabei sind hätte ich noch eine weitere Frage die 
sich mir stellt:

Wenn ich jetzt nicht nur External Interrupts verwenden möchte, sondern 
auch Fast External Interrupts, dann muss ich diese entsprechend Keil 
deklarieren (das passt, das weiß ich wie es geht). Aber wo krieg ich die 
Adresse von den Dingern her? Machts hier ein einfacher Pointer auf die 
entsprechende Funktion?

Was ich gefunden habe, was so herumkusiert ist folgendes:

//Defines/oder eher Macros
#define SEG(func) (unsigned int)(((unsigned long)((void (far *) (void))func) >> 16))
#define SOF(func) (unsigned int)(((void (far *) (void))func))

//Globals
unsigned int counter = 0;

//ISR - zählt hier nur die globalvar counter rauf
void extISR(void) interrupt hsync=CACHED
{
  counter = counter +1;
}

//MAIN
void main(void){
  
  //Initialisiere Fast Interrupts damit sie auch "fast" sind
  //Schreibe in den Cache zu deutsch
  FINT0CSP   = SEG(extISR) | 0x8C00;
  FINT0ADDR  = SOF(extISR);
  
  //Pin Konfig
  DP1H_P0 = 0;
  
  //Schreiben erlauben
  MAIN_vUnlockProtecReg();
  //External Interrupts setzen
  EXICON |= 0x0002; // Falling edge EXI0
  
  //Interrupt Controlregister
  CC1_CC8IC = 0x0059;

  //Global IEN setzen
  PSW_IEN = 1;
  
  while(1);
}

Bei den beiden:

FINT0CSP   = SEG(extISR) | 0x8C00;
FINT0ADDR  = SOF(extISR);

muss die entsprechende ISRRoutine eingetragen werden, sprich die 
Adresse. Ich habs bereits mit einem Pointer auf die Funktion extISR 
versucht, aber da mekert Keil nur!

Mit den oben angeführten Macros (die kommen von der Keil Homepage) kann 
ich zwar ohne Fehler compilieren, aber das Ding tut nichts ...

[Rogger R. (manta)]

So ich denk ich habs selbst gelöst:

Die Macros von Keil.com sind richitg (warum auch nicht?:)
Das Problem an der Verwendung war folgendes:

Wenn man Fast External Interrupts verwenden will, dann müssen die LVL 
und GVL der Interrupts sowohl in den normalen Interrupt Registern, als 
auch bei den Fast Interrupts zusammenstimmen:

  
  FINT0CSP   = SEG(extISR) | 0x8C00;
  FINT0ADDR  = SOF(extISR);
  
  //
  ...
  //
  
  //Interrupt Controlregister
  CC1_CC8IC = 0x007C; --> Fehler lag hier...LVL und GVL muss gleich sein wie oben!