Zeichen im Interrupt empfangen, an alle Interupt Liebhabe

Gast #1257728
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:
1
uart1_interrupt_enable()
2
{
3
   U1IER = 0x01;  /*UART1 Interrupt Enable*/ 
4
  //RBR IE
5
  //Rx Line Status IE
6
  //Modem Status IE
7
 
8
    /*Vectored Interrrupt Controller (VIC) UART1*/
9
    VICIntSelect = 0x00000000;
10
    VICIntEnClr  = 0xFFFFFFFF;    //clear all interrupts
11
    VICIntEnable = 0xFFFFFFFF;    //enable UART1 interrupt  
12
   //VICVectAddr0 = 0x00000000; //abhänig vom IRQ Slot 
13
   //VICRawIntr   = 0x00001008
14
   //VICIRQStatus = 0x00000000;
15
   //VICFIQStatus = 0x00000000;
16
   //VICSoftInt    = 0x00000000;
17
   //VICSoftIntClear = 0x00000000; 
18

19
   /* Receiver & Transmitter Register */
20
   //U1RBR/THR
21

22
   /* Scatch Pad Register */
23
   //U1SCR  
24
}
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?
#1257839
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
(Firma: ARM LPC2134, uVision3, in C) #1257866
Danke für den Hinweiß
1
#include <LPC21xx.H>    // Philips Peripheral Registers
2

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

11
int myfunc2 (int i1) __swi (9)  {
12
  return (i1<<4);
13
}
14

15
/*
16
 * standard interrupt function saves only R0 - R12 and returns with 
17
 */
18
void DefaultIRQ (void) __irq {
19
  ;
20
}
21

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

30
/*
31
 * task functions have no register save/restore and no return.
32
 */
33
void tsk (void) __task {
34
  while (1);
35
}
36

37

38

39
/*
40
 * Sample 'main' function
41
 */
42
int res;
43

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

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

55
  while (1);                      // endless loop
56
}

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.
Gast #1257974
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.
(Firma: ARM LPC2134, uVision3, in C) #1258008
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;)

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 17 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.