Microblaze Interrupt

Gast #1854545
Liebe Kollegen!

Ich versuche (inzwischen verzweifelt) eine ISR zu machen. Der Microblaze 
soll in die ISR springen wenn einer der DIP Schalter betätigt wird. 
Leider kann ich machen was ich will er springt nicht.
Wenn ich die ISR forciere (XIntc_Out32(X...) dann geht es.

H I L F E ! ! !
1
#include "xparameters.h"
2
#include "xgpio.h"
3
#include "xintc_l.h"
4
#include "mb_interface.h"
5

6
void InterruptHandler (void);
7

8

9
int value;
10
XGpio Led;
11
XGpio Sw;
12
 
13
int main(void)
14
{
15
  
16
  XGpio_Initialize(&Led, XPAR_LEDS_8BIT_DEVICE_ID);
17
  XGpio_Initialize(&Sw , XPAR_DIP_SWITCHES_8BIT_DEVICE_ID);
18
  
19
  XGpio_SetDataDirection(&Led,1,0);
20
    XGpio_SetDataDirection(&Sw,1,0xFFFFFFFF);
21

22
  XIntc_RegisterHandler(XPAR_XPS_INTC_0_BASEADDR, XPAR_DIP_SWITCHES_8BIT_DEVICE_ID,
23
                          (XInterruptHandler)InterruptHandler,
24
                          (void *)0);
25
    XIntc_Out32(XPAR_XPS_INTC_0_BASEADDR + XIN_MER_OFFSET, XIN_INT_MASTER_ENABLE_MASK);
26
    XIntc_mEnableIntr(XPAR_XPS_INTC_0_BASEADDR, XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
27
    XIntc_mMasterEnable( XPAR_XPS_INTC_0_BASEADDR );
28
    XGpio_InterruptEnable(&Sw, XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
29
  
30
  value = 0xAAAAAAAA;
31
  XGpio_DiscreteWrite(&Led, 1, value);
32
  microblaze_enable_interrupts(); 
33
  
34
  //XIntc_Out32(XPAR_XPS_INTC_0_BASEADDR + XIN_ISR_OFFSET, XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
35
  
36
  while(1);
37
}
38

39
void InterruptHandler(void)
40
{
41
  
42
  microblaze_disable_interrupts();
43
  value = 0xFFFFFFFF;
44
  XGpio_mSetDataReg(XPAR_LEDS_8BIT_BASEADDR, 1, value);
45
  microblaze_enable_interrupts();
46
}
Angehängte Dateien:
Die "xparameters.h" wird sehr hilfreich sein. Eigentlich sollte man vor 
dem
    XGpio_InterruptEnable(&Sw, 
XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
ein "XGpio_InterruptGlobalEnable" machen.

Ausserdem bei:

XIntc_RegisterHandler(XPAR_XPS_INTC_0_BASEADDR, 
XPAR_DIP_SWITCHES_8BIT_DEVICE_ID,
                     (XInterruptHandler)InterruptHandler,
                     (void *)0);

ich glaube das is die falsche DEVICE_ID, bin aber nich 100% sicher. 
Alles steht in die "xparameters.h"

Gruss
Valentin
Gast
Hab alles neu gemacht. Ohne Interrupt Controller.
1
#include "xparameters.h"
2
#include "xgpio_l.h"
3
#include "mb_interface.h"
4

5
void InterruptHandler (void);
6

7

8
int value;
9

10
 
11
int main(void)
12
{
13
  
14

15
  
16
  XGpio_mSetDataDirection(XPAR_LEDS_8BIT_BASEADDR,1,0);
17
  XGpio_mSetDataDirection(XPAR_PUSH_BUTTONS_5BIT_BASEADDR,1,1);
18
  microblaze_register_handler((XInterruptHandler) InterruptHandler, (void *)0); 
19
  microblaze_enable_interrupts();
20
  
21
  value = 0xAAAAAAAA;
22
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);
23

24
  
25
  while(1);
26
}
27

28
void InterruptHandler(void)
29
{
30
  
31
  microblaze_disable_interrupts();
32
  value = 0xFFFFFFFF;
33
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);
34
  microblaze_enable_interrupts();
35
}

Ich hab die Befehlsfolge aus einem Tutorial. Ich dachte mir vielleicht 
wird es einfacher ohne InterruptController. Leider geht immer noch 
nichts.

H E L P  ! ! ! !
Angehängte Dateien:
Gast
/* Global Enable I n t e r r u p t s Gpio Pushbuttons (GIE Re g s i t e 
r ) */
XGpio Inter ruptGlobalEnable (&GpioInput ) ;
89
/* Enable I n t e r r u p t s f o r Channel 1 IER Re g s i t e r */
91 XGpio Inter ruptEnable (&GpioInput , 0 x00000001 ) ;
Gast
Ich habs mit
1
#include "xparameters.h"
2
#include "xgpio_l.h"
3
#include "xgpio.h"
4
#include "mb_interface.h"
5

6
void InterruptHandler (void);
7

8

9
int value;
10
XGpio led;
11
 
12
int main(void)
13
{
14
  
15

16
  XGpio_Initialize(&led, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
17
  XGpio_mSetDataDirection(XPAR_LEDS_8BIT_BASEADDR,1,0);
18
  XGpio_mSetDataDirection(XPAR_PUSH_BUTTONS_5BIT_BASEADDR,1,1);
19
  microblaze_register_handler((XInterruptHandler) InterruptHandler, (void *)0); 
20
  XGpio_InterruptGlobalEnable(&led) ;
21
  microblaze_enable_interrupts();
22
  
23
  value = 0xAAAAAAAA;
24
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);
25

26
  
27
  while(1);
28
}
29

30
void InterruptHandler(void)
31
{
32
  
33
  microblaze_disable_interrupts();
34
  value = 0xFFFFFFFF;
35
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);
36
  microblaze_enable_interrupts();
37
}

versucht. Geht immer noch nicht.
Gast
Irgendwas stimmt mit dem Exception Handler nicht (benutze Microblaze).

Ich lande immer in  bri=0 hängen.
1
MB_ExceptionVectorTable:
2
    .long XNullHandler
3
    .long 0                                 /* --          FSL Exception         -- */
4
    .long XNullHandler
5
    .long 1                                 /* -- Unaligned Access Exception     -- */
6
    .long XNullHandler
7
    .long 2                                 /* --   Illegal Opcode Exception     -- */
8
    .long XNullHandler
9
    .long 3                                 /* --         IOPB Exception         -- */
10
    .long XNullHandler
11
    .long 4                                 /* --         DOPB Exception         -- */
12
    .long XNullHandler
13
    .long 5                                 /* --       Div-by-0 Exception       -- */
14
    .long XNullHandler
15
    .long 6                                 /* --         FPU  Exception         -- */
16
    .long XNullHandler
17
    .long 7                                 /* --         MMU  Exceptions        -- */    
18

19
#else                                       /* Dummy exception handler, in case exceptions are not present in the processor */
20

21
.global _hw_exception_handler                               
22
.section .text                                          
23
.align 2
24
.ent _hw_exception_handler
25
_hw_exception_handler:
26
        bri     0; // DA BLEIBT DAS PROGRAMM HÄNGEN
27
.end _hw_exception_handler        
28
                                
29
#endif  /* MICROBLAZE_EXCEPTIONS_ENABLED */
Gast
Das kenne ich schon. Ich hab den Part mit Exception.... durch ein 
enable_interrupt austetauscht. Das Programm bleibt aber im Exception 
Table hängen.
Immerhin bin ich mit Deiner Anleitung weiter. Bis jetzt bin ich über die 
while(1) nicht hinausgekommen (kein Interrupt).

Fällt Dir vielleicht sonst was ein?

LG
Monika
Gast
1
#include "xintc.h"
2
#include "xparameters.h"
3
#include "xgpio.h"
4
#include "mb_interface.h"
5

6

7

8
#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
9
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
10
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID
11

12
void SetupInterruptSystem();
13
void ButtonInterrupt (void * CallbackRef);
14

15
XGpio GpioInput;
16
XGpio led;
17

18
static XIntc InterruptController;
19

20
int main (void)
21
{
22
  
23
  microblaze_enable_interrupts();
24
  
25
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
26
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
27
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);
28
  XGpio_SetDataDirection(&led, 1, 0x0);
29
  XGpio_InterruptGlobalEnable(&GpioInput);
30
  XGpio_InterruptEnable(&GpioInput, 0x00000001);
31
  
32
  XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
33
  
34
  XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
35
  XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
36
  
37
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
38
  
39
  while(1);
40
}
41

42
void ButtonInterrupt (void* CallbackRef)
43
{
44
  XGpio_InterruptClear(&GpioInput, 0x00000001);
45
  XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
46
}

DANKE, dass DU dir so viel Mühe machst!!!
Gast
also ein fehler kann ich nicht mehr entdecken hast du mal die register 
während des programmablaufs ausgelesen ob überhaupt ein interrupt 
ausgelöst wird?
Gast
probier mal statt
1
XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);

1
XIntc_Connect(&Interruptcontroller, INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
Gast
Jetzt geht gar nichts mehr. Die XMD schreibt
Error: Debug Memory Access Check Failed

Keine Ahnung. Ich werde morgen noch einmal versuchen den Interrupt zu 
machen. Vielleicht habe ich dann mehr Glück

Natürlich versuche ich dann auch den XIntc_Connect...

DANKE!!!

Vielleicht "lesen" wir uns ja morgen wieder!
So haben wir das mit meinem Kollege damals im Labor gemacht:

GPIO Initialisierung
GPIO Interrupt enable
INTC Initialisierung
Interrupt verbinden
Interrupt in INTC enable

int main(void){
...
  XGpio_Initialize(&BUTTONS, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
...
  //von Buttons erzeugte Interrupts enablen
  XGpio_InterruptGlobalEnable(&BUTTONS);
  XGpio_InterruptEnable(&BUTTONS, XGPIO_IR_CH1_MASK);
...
  //Interrupt-Controller init.
  XIntc_Initialize(&intc, XPAR_XPS_INTC_0_DEVICE_ID);

  //Ausgang des Interrupt-Controllers zum Prozessor enablen
  XIntc_Start(&intc, XIN_REAL_MODE);

  //Button-ISR bekannt geben
  XIntc_Connect(&intc,XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR, 
(XInterruptHandler)Buttons_ISR, NULL);

  //Button-Interruptquelle enablen
  XIntc_Enable(&intc, 
XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR);

...

  microblaze_enable_interrupts();
...
}// end of main

void ISR(){
...
  //Interrupt-Status zurücksetzen
  XGpio_InterruptClear(&BUTTONS, XGPIO_IR_CH1_MASK);
...
}

Du muss natürlich die MAKROs aus deinem xparameters.h verwenden.
Hoffentlich hilft dir das weiter

Gruss,
Valentin
Gast
Hab das so gemacht. Geht leider immer noch nicht.
Ich habe die PushButtons als External definiert. Ist das ev. der Fehler?

Fällt Dir noch was ein ?
1
#include "xintc.h"
2
#include "xparameters.h"
3
#include "xgpio.h"
4
#include "mb_interface.h"
5

6

7

8
#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
9
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
10
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID
11

12
void SetupInterruptSystem();
13
void ButtonInterrupt (void * CallbackRef);
14

15
XGpio GpioInput;
16
XGpio led;
17
XIntc intc;
18

19
static XIntc InterruptController;
20
int main (void)
21
{
22

23
  
24
  
25
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
26
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
27
  XIntc_Initialize(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
28
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);
29
  XGpio_SetDataDirection(&led, 1, 0x0);
30
  XGpio_InterruptGlobalEnable(&GpioInput);
31
  XGpio_InterruptEnable(&GpioInput, XGPIO_IR_CH1_MASK);
32
  
33
  XIntc_Start(&intc, XIN_REAL_MODE);
34
  
35
  //XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
36
  XIntc_Connect(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR, (XInterruptHandler)ButtonInterrupt, NULL);
37
  XIntc_Enable(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR);
38
  
39
  microblaze_enable_interrupts();
40
  
41
  //XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
42
  //XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
43
  
44
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
45
  
46
  while(1);
47
}
48

49
void ButtonInterrupt (void* CallbackRef)
50
{
51
  XGpio_InterruptClear(&GpioInput, XGPIO_IR_CH1_MASK);
52
  XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
53
}

LG
Monika
Gast
am besten du hängst die mhs datei nochmal an ansonsten müsste man mal 
das entsprechende register des IntC auslesen und per UART ans Hterm 
ausgeben um zu gucken ob der interrupt überhaupt da ankommt
Gast
Hmm. Wie wäre es denn mal mit simulieren?
Da kann man gucken, ob die Interrupt-Leitung wackelt, wo der program 
counter steht und welcher Befehl als nächstes dran ist. Am besten ohne 
D- und I-Cache.
Nebenbei bekommt man noch einen Eindruck, wie langsam auf Interrupts 
reagiert wird...

Duke
Gast
also für mich sieht das programm und die mhs gut aus

denke belibt nur noch simulieren oder halt per uart die registerwerte 
ausgeben und gucken ob das stimmt mehr fällt mir auch nicht mehr ein
Gast
Geht nicht. Wiso? Ich hab das selbe ohne Interrupt gemacht und da ist es 
gegangen. Warum dreht mir der Interrupt alles ab?

Anbei mein EDK!
1
#include "xintc.h"
2
#include "xparameters.h"
3
#include "xgpio.h"
4
#include "mb_interface.h"
5

6

7

8
#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
9
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
10
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID
11

12
void SetupInterruptSystem();
13
void ButtonInterrupt (void * CallbackRef);
14

15
XGpio GpioInput;
16
XGpio led;
17
XIntc intc;
18

19
static XIntc InterruptController;
20
int main (void)
21
{
22
  
23
  int test;
24
  
25
  
26
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
27
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
28
  XIntc_Initialize(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
29
  //XGpio_SetDataDirection(&GpioInput, 1, 0xF);
30
  XGpio_SetDataDirection(&led, 1, 0x0);
31
  XGpio_InterruptGlobalEnable(&GpioInput);
32
  XGpio_InterruptEnable(&GpioInput, XGPIO_IR_CH1_MASK);
33
  
34
  XIntc_Start(&intc, XIN_REAL_MODE);
35
  
36
  //XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,NULL);
37
  XIntc_Connect(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR, (XInterruptHandler)ButtonInterrupt, NULL);
38
  XIntc_Enable(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR);
39
  
40
  microblaze_enable_interrupts();
41
  
42
  XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
43
  //XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
44
  
45
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
46
  
47
  while(1)
48
{
49
  test=XGpio_DiscreteRead(&GpioInput, 1);
50
  XGpio_DiscreteWrite(&led, 1, test);
51
}
52

53
}
54

55
void ButtonInterrupt (void* CallbackRef)
56
{
57
  XGpio_InterruptClear(&GpioInput, XGPIO_IR_CH1_MASK);
58
  XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
59
}
Angehängte Dateien:
Hi,

hast du das Interrupt Controller selber eingebaut? Normaleweise kannst 
du das direkt beim Projekterstellung machen, so sollten solche Probleme 
nicht auftretten.

Kriegst du Warnings bei der Synthese? Falls ein Pins nicht verbunden ist 
kommt normaleweise ein Warning.

Hast du auch ein Linker Script, wo werden Interrupt ausgelagert?
Gast
Hi,

hab das Linker Script erzeugt. Jetzt kann ich das Programm nicht mehr 
debugen. Unter Thread steht (Suspended: Signal 'SIGTRAP' received. 
Description: Trace/breakpoint trap.)

Hab aber keine Breakpoints mehr drinnen.

Falls das linker script interessant ist => als Beilage
Angehängte Dateien:
Gast
Hi

das war von der Generate Addresses. Ich hab die INTC ganz hinten 
angehängt. Geht aber immer noch nicht. Weder der Interrupt noch die 
Buttons=>Leds
Gast
funktioniert denn
1
XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
 das jede 2 led leuchtet?

und es geht nicht das du in der while(1) einfach immer den Buttonstatus 
abfragst und dann z.b. die LEDanzeige wechselt?
Gast
1
include "xintc.h"
2
#include "xparameters.h"
3
#include "xgpio.h"
4
#include "mb_interface.h"
5

6

7
/*
8
#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
9
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
10
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID
11

12
void SetupInterruptSystem();
13
void ButtonInterrupt (void * CallbackRef);
14
*/
15
XGpio GpioInput;
16
XGpio led;
17

18
static XIntc InterruptController;
19

20
int main (void)
21
{
22
  
23
  //microblaze_enable_interrupts();
24
  
25
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
26
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
27
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);
28
  XGpio_SetDataDirection(&led, 1, 0x0);
29
  /*XGpio_InterruptGlobalEnable(&GpioInput);
30
  XGpio_InterruptEnable(&GpioInput, 0x00000001);
31
  
32
  //XIntc_Connect(&InterruptController, INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
33
   XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);  
34
  
35
  XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
36
  XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
37
  */
38
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
39
  
40
  while(1)
41
  {
42
  if(XGpio_DiscreteRead(&GpioInput!=0)){
43
                                          XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
44
                                          }
45
  }
46
  ;
47
}
48
/*
49
void ButtonInterrupt (void* CallbackRef)
50
{
51
  XGpio_InterruptClear(&GpioInput, 0x00000001);
52
  XGpio_DiscreteWrite(&led, 1, 0x66666666);
53
}*/


ändert sich hier bei tastendruck die LED anzeige?
in deinem UCF datei verwendest du:

fpga_0_Push_Buttons_5Bit_GPIO_IO_pin

in deinem MHS datei aber:
Push_Buttons_5Bit_GPIO_IO_I_pin

es gibt keine Verbindung zwischen UCF und MHS.

Solche Fehler kannst du vermeiden, in dem du ein neues Projekt 
erstellst. Dann kannst du direkt die Interrupts eingeben und EDK 
verbindet alles für dich. So bist du sicher das die HW Seite in Ordnung 
ist. Dann kannst du die SW debuggen.

Ich persönlich würde die mir ein Projekt direkt im EDK erzeugen, da 
sonst bei jede Synthese die "hw" Verzeichnis im SDK überschrieben werden 
soll.

Für diese Test reicht auch ein kleine Anwendung im EDK.

Gruss
Gast
Hi,

Ich hab die ISE noch mal laufen lassen und alle Bez. kontrolliert.

Die Buttons rühren sich immer noch nicht.

Ich werde die EDK noch einmal machen. Vielleicht hilft das etwas.
Gast
Der Interrupt funktioniert!!!!!!

Ich hab alles noch einmal gemacht und genau wie Ihr gesagt habt die 
Interrupts bleich beim BSB eingestellt. JUHU!!!

D A N K E für Eure Geduld.

Dickes Bussi
Monika

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 16 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]
  • [vhdl]VHDL-Code[/vhdl]
  • [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.