Zeichen im Interrupt empfangen, an alle Interupt Liebhabe

[ARM LPC (Gast)]

Hallo,

ich programmiere gerade auf dem ARM LPC und will ein Zeichen per 
Interrupt empfangen:

Im main wird eine Funktion aufgerufen. Die ein Zeichen an UART1 
versendet.

Jetzt will ich eine Funktion schreiben die ein Zeichen per Interrupt 
empfängt.

Dazu habe ich schon mal folgende Pins aktiviert:

uart1_interrupt_enable()
{
   U1IER = 0x01;  /*UART1 Interrupt Enable*/ 
  //RBR IE
  //Rx Line Status IE
  //Modem Status IE
 
    /*Vectored Interrrupt Controller (VIC) UART1*/
    VICIntSelect = 0x00000000;
    VICIntEnClr  = 0xFFFFFFFF;    //clear all interrupts
    VICIntEnable = 0xFFFFFFFF;    //enable UART1 interrupt  
   //VICVectAddr0 = 0x00000000; //abhänig vom IRQ Slot 
   //VICRawIntr   = 0x00001008
   //VICIRQStatus = 0x00000000;
   //VICFIQStatus = 0x00000000;
   //VICSoftInt    = 0x00000000;
   //VICSoftIntClear = 0x00000000; 

   /* Receiver & Transmitter Register */
   //U1RBR/THR

   /* Scatch Pad Register */
   //U1SCR  
}

Kennt sich einer mit Interupts aus?
Welche PINS soll ich noch zusätzlich aktivieren?

Jetzt will eine Empfangsroutine schreiben:
ISR (Interrupt Service Routine).

Wie sieht diese ungefähr aus?
und von wo statet man die?

[ARM LPC (Gast)]

Kann mir den keiner ein Tipp geben?

[Peter D. (peda)]

ARM LPC schrieb:
> Kann mir den keiner ein Tipp geben?

Du bist Dir absolut sicher, daß in Deiner Compilerinstallation kein 
Interruptbeispiel drin ist?
Glaub ich nicht.

Und es könnte in keinem Fall schaden, erstmal die Compilerinstallation 
zu nennen.


Peter

[... (Gast)]

Muuuaaahhhhh. Gleich mit einem ARM  zu beginnen ist doch etwas heftig. 
Naja, Weshalb auch Zeit mit einfachen Dingen verplempern ...

[Sergey S. (Firma: ARM LPC2134, uVision3, in C) (serik00)]

Danke für den Hinweiß

#include <LPC21xx.H>    // Philips Peripheral Registers

/*
 * software interrupt function accept parameters and run in
 * supervisor mode (interrupt protected).
 */
int myfunc1 (int i1, long i2) __swi (8)  {
  return (i1 / i2);
}

int myfunc2 (int i1) __swi (9)  {
  return (i1<<4);
}

/*
 * standard interrupt function saves only R0 - R12 and returns with 
 */
void DefaultIRQ (void) __irq {
  ;
}

/*
 * fast interrupt function saves only R0 - R7 and returns with 
 */
void FIQ_Handler (void)  __fiq  {
  IOSET1 = 0x00010000;          // Set pin P1.16
  EXTINT = 0x00000002;          // Clear the peripheral interrupt flag
}

/*
 * task functions have no register save/restore and no return.
 */
void tsk (void) __task {
  while (1);
}



/*
 * Sample 'main' function
 */
int res;

void main (void)  {
  IODIR1         = 0x00FF0000;    // Set the LED pins as outputs
  PINSEL0        = 0x20000000;    // Enable the EXTINT1 interrupt
  VICIntSelect   = 0x00008000;    // Enable a Vic Channel as FIQ
  VICIntEnable   = 0x00008000;    
                                  // Set Default interrupt vector
  VICDefVectAddr = (unsigned long) DefaultIRQ;

  res = myfunc1 (10, 2);          // call SWI functions
  res += myfunc2 (res);

  while (1);                      // endless loop
}

allerdings verstehe ich das nicht so ganz.


Also es gibt:
externe Interrupts, mein uController hat 4 davon EINT[3:0]

In der VIC stehen dann auch noch weitere Interrupts wie UART1,SSP + 
Externe Interrupts usw.

dann gibt es noch Software-Interrupts

dann kann mann die Interrupts als IRQ oder FIQ definieren

Kann mir jemand was dazu sagen.
Wozu braucht man Externe wenn in der VIC alle möglichen vorhanden sind?
usw.

[Sergey S. (Firma: ARM LPC2134, uVision3, in C) (serik00)]

Gut, schwer ist das schon.
Ich dachte schon ich bin doof:)

[let (Gast)]

Alle Interrupts werden über den VIC abgearbeitet. Die IRQ
und FIQ Eingänge des ARM7 sind nicht herausgeführt sondern
mit dem VIC verbunden.

Auch wenn du das wahrscheinlich nicht hören willst aber
nach deinem Programm und den Fragen zu urteilen scheinen
dir die Grundlagen des ARM7/VIC zu fehlen.
Da hilft nur eins: Lesen, probieren, nochmal lesen, probieren,
weiterlesen, probieren....
Das ist nicht sonderlich schwierig aber durch den Umfang dauert
das eine Weile. Eine Antwort darauf wie du die Aufgabe lösen
kannst würde dir nicht viel bringen.

Mein Vorschlag: Vergiss den UART und beschäftige dich erstmal
mit den Beispielprogrammen. Doch vielleicht nicht gerade mit
diesem hier. SWI ist eine Spezialität um die man sich auch
später kümmern kann. Einfacher und praxistauglicher sind da
die Timer.
Mit welcher Entwicklungsumgebung du arbeitest darf anscheinend
keiner wissen. Dadurch wird es schwierig dir ein passenderes
Beispiel zu nennen. Aber schau mal nach ob es ein 'blinky'
Projekt gibt das einen Timer verwendet.

Für die Grundlagen des LPC21xx kann ich dir das 'Insider Guide'
von Hitex empfehlen. Google doch mal nach 'hitex insider guide'.
Du mußt dich da registrieren. Die EMail Adresse wird aber nicht
überprüft.

[Sergey S. (Firma: ARM LPC2134, uVision3, in C) (serik00)]

Vielen Dank für den tollen Link.
Das Dokument ist sehr informativ! Wird mir große Hilfe sein.

Ich programmiere mit uVision vom KEIL.

Ich weiß das mir die Grundlagen fehlen.
Das muss nachgeholt werden;)

[let (Gast)]

http://www.keil.com/download/docs/232.asp

Habs mir aber nicht angesehen.