Microblaze Interrupt

Monika Gast #1854545
Lesenswert?
• ▲
▼ 
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:
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Valko Z. #1854799
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1855455
Lesenswert?
• ▲
▼ 
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:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
rudel Gast #1855472
Lesenswert?
• ▲
▼ 
/* 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 ) ;
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1855505
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1855875
Lesenswert?
• ▲
▼ 
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 */
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1855963
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1855973
Lesenswert?
• ▲
▼ 
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!!!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
rudel Gast #1856001
Lesenswert?
• ▲
▼ 
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);
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1856030
Lesenswert?
• ▲
▼ 
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!
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Valko Z. #1856039
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1856947
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
rudel Gast #1856977
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Duke Scarring Gast #1857016
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1857331
Lesenswert?
• ▲
▼ 
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:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Valko Z. #1857377
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Monika Gast #1857416
Lesenswert?
• ▲
▼ 
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:
Antwort Zitieren Bearbeiten Löschen Beitrag melden
rudel Gast #1857475
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
rudel Gast #1857516
Lesenswert?
• ▲
▼ 
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?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Valko Z. #1857524
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren