Microblaze Interrupt

[Monika (Gast)]

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 ! ! !

#include "xparameters.h"
#include "xgpio.h"
#include "xintc_l.h"
#include "mb_interface.h"

void InterruptHandler (void);


int value;
XGpio Led;
XGpio Sw;
 
int main(void)
{
  
  XGpio_Initialize(&Led, XPAR_LEDS_8BIT_DEVICE_ID);
  XGpio_Initialize(&Sw , XPAR_DIP_SWITCHES_8BIT_DEVICE_ID);
  
  XGpio_SetDataDirection(&Led,1,0);
    XGpio_SetDataDirection(&Sw,1,0xFFFFFFFF);

  XIntc_RegisterHandler(XPAR_XPS_INTC_0_BASEADDR, XPAR_DIP_SWITCHES_8BIT_DEVICE_ID,
                          (XInterruptHandler)InterruptHandler,
                          (void *)0);
    XIntc_Out32(XPAR_XPS_INTC_0_BASEADDR + XIN_MER_OFFSET, XIN_INT_MASTER_ENABLE_MASK);
    XIntc_mEnableIntr(XPAR_XPS_INTC_0_BASEADDR, XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
    XIntc_mMasterEnable( XPAR_XPS_INTC_0_BASEADDR );
    XGpio_InterruptEnable(&Sw, XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
  
  value = 0xAAAAAAAA;
  XGpio_DiscreteWrite(&Led, 1, value);
  microblaze_enable_interrupts(); 
  
  //XIntc_Out32(XPAR_XPS_INTC_0_BASEADDR + XIN_ISR_OFFSET, XPAR_DIP_SWITCHES_8BIT_IP2INTC_IRPT_MASK);
  
  while(1);
}

void InterruptHandler(void)
{
  
  microblaze_disable_interrupts();
  value = 0xFFFFFFFF;
  XGpio_mSetDataReg(XPAR_LEDS_8BIT_BASEADDR, 1, value);
  microblaze_enable_interrupts();
}

[Valko Z. (hydravliska)]

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

[Monika (Gast)]

Hab alles neu gemacht. Ohne Interrupt Controller.

#include "xparameters.h"
#include "xgpio_l.h"
#include "mb_interface.h"

void InterruptHandler (void);


int value;

 
int main(void)
{
  

  
  XGpio_mSetDataDirection(XPAR_LEDS_8BIT_BASEADDR,1,0);
  XGpio_mSetDataDirection(XPAR_PUSH_BUTTONS_5BIT_BASEADDR,1,1);
  microblaze_register_handler((XInterruptHandler) InterruptHandler, (void *)0); 
  microblaze_enable_interrupts();
  
  value = 0xAAAAAAAA;
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);

  
  while(1);
}

void InterruptHandler(void)
{
  
  microblaze_disable_interrupts();
  value = 0xFFFFFFFF;
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);
  microblaze_enable_interrupts();
}

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  ! ! ! !

[rudel (Gast)]

du musts noch die interrupts für XGPio anschalten

[rudel (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 ) ;

[Monika (Gast)]

DANKE!

wo finde ich (&GpioInput)? Ich verwende GPIO_l.h

[Monika (Gast)]

Ich habs mit

#include "xparameters.h"
#include "xgpio_l.h"
#include "xgpio.h"
#include "mb_interface.h"

void InterruptHandler (void);


int value;
XGpio led;
 
int main(void)
{
  

  XGpio_Initialize(&led, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
  XGpio_mSetDataDirection(XPAR_LEDS_8BIT_BASEADDR,1,0);
  XGpio_mSetDataDirection(XPAR_PUSH_BUTTONS_5BIT_BASEADDR,1,1);
  microblaze_register_handler((XInterruptHandler) InterruptHandler, (void *)0); 
  XGpio_InterruptGlobalEnable(&led) ;
  microblaze_enable_interrupts();
  
  value = 0xAAAAAAAA;
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);

  
  while(1);
}

void InterruptHandler(void)
{
  
  microblaze_disable_interrupts();
  value = 0xFFFFFFFF;
  XGpio_mWriteReg(XPAR_LEDS_8BIT_BASEADDR, XGPIO_DATA_OFFSET, value);
  microblaze_enable_interrupts();
}

versucht. Geht immer noch nicht.

[rudel (Gast)]

du initialisierst die led Gpio instance gar nicht mehr

[Monika (Gast)]

DANKE!

Werde es sofort ausprobieren!

[Monika (Gast)]

Irgendwas stimmt mit dem Exception Handler nicht (benutze Microblaze).

Ich lande immer in  bri=0 hängen.

MB_ExceptionVectorTable:
    .long XNullHandler
    .long 0                                 /* --          FSL Exception         -- */
    .long XNullHandler
    .long 1                                 /* -- Unaligned Access Exception     -- */
    .long XNullHandler
    .long 2                                 /* --   Illegal Opcode Exception     -- */
    .long XNullHandler
    .long 3                                 /* --         IOPB Exception         -- */
    .long XNullHandler
    .long 4                                 /* --         DOPB Exception         -- */
    .long XNullHandler
    .long 5                                 /* --       Div-by-0 Exception       -- */
    .long XNullHandler
    .long 6                                 /* --         FPU  Exception         -- */
    .long XNullHandler
    .long 7                                 /* --         MMU  Exceptions        -- */    

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

.global _hw_exception_handler                               
.section .text                                          
.align 2
.ent _hw_exception_handler
_hw_exception_handler:
        bri     0; // DA BLEIBT DAS PROGRAMM HÄNGEN
.end _hw_exception_handler        
                                
#endif  /* MICROBLAZE_EXCEPTIONS_ENABLED */

[rudel (Gast)]

hast du das mit der exception aus der anleitung übernommen ? das ist für 
powerpc440 das darf man so nicht übernehmen.

vll hilft dir der link noch weiter

https://wiki.ittc.ku.edu/ittc/images/d/df/Edk_interrupts.pdf

[Monika (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

[rudel (Gast)]

häng mal nochmal dein aktuelles programm an vll find ich noch was

[Monika (Gast)]

#include "xintc.h"
#include "xparameters.h"
#include "xgpio.h"
#include "mb_interface.h"



#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID

void SetupInterruptSystem();
void ButtonInterrupt (void * CallbackRef);

XGpio GpioInput;
XGpio led;

static XIntc InterruptController;

int main (void)
{
  
  microblaze_enable_interrupts();
  
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);
  XGpio_SetDataDirection(&led, 1, 0x0);
  XGpio_InterruptGlobalEnable(&GpioInput);
  XGpio_InterruptEnable(&GpioInput, 0x00000001);
  
  XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
  
  XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
  XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
  
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
  
  while(1);
}

void ButtonInterrupt (void* CallbackRef)
{
  XGpio_InterruptClear(&GpioInput, 0x00000001);
  XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
}

DANKE, dass DU dir so viel Mühe machst!!!

[rudel (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?

[Monika (Gast)]

Nein, ich arbeite erst seit gestern mit SDK.

[rudel (Gast)]

probier mal statt

XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);

XIntc_Connect(&Interruptcontroller, INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);

[Monika (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!

[Valko Z. (hydravliska)]

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

[Monika (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 ?

#include "xintc.h"
#include "xparameters.h"
#include "xgpio.h"
#include "mb_interface.h"



#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID

void SetupInterruptSystem();
void ButtonInterrupt (void * CallbackRef);

XGpio GpioInput;
XGpio led;
XIntc intc;

static XIntc InterruptController;
int main (void)
{

  
  
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
  XIntc_Initialize(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);
  XGpio_SetDataDirection(&led, 1, 0x0);
  XGpio_InterruptGlobalEnable(&GpioInput);
  XGpio_InterruptEnable(&GpioInput, XGPIO_IR_CH1_MASK);
  
  XIntc_Start(&intc, XIN_REAL_MODE);
  
  //XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
  XIntc_Connect(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR, (XInterruptHandler)ButtonInterrupt, NULL);
  XIntc_Enable(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR);
  
  microblaze_enable_interrupts();
  
  //XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
  //XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
  
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
  
  while(1);
}

void ButtonInterrupt (void* CallbackRef)
{
  XGpio_InterruptClear(&GpioInput, XGPIO_IR_CH1_MASK);
  XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
}

LG
Monika

[Duke Scarring (Gast)]

Monika schrieb:
> Geht leider immer noch nicht.

Wie stellst Du das eigentlich fest? Im Simulator oder auf echter 
Hardware?

Duke

[Monika (Gast)]

echte Hardware

Design via Impact in den FPGA gespielt und mit SDK debuged.
Ich habe einen Breakpoint in der ISR und die Leds sollten was anderes 
anzeigen.

[rudel (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

[Monika (Gast)]

schon da

[Duke Scarring (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

[rudel (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

[Valko Z. (hydravliska)]

Hi,

kannst du vielleicht die aktuelle xparameters.h sowie dein .ucf datei 
hochladen? Sind die Buttons auf die richtige Pins?

Gruss,
Valentin

[Monika (Gast)]

gerne

[Valko Z. (hydravliska)]

Hi,

versuch mal ohne die folgende Zeile:
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);

Im Datenblatt steht das die Register per Default als Eingang 
initialisiert sind. Du schreibt da ein 4 Bit Wert in einem 32Bit breit 
Register.

Gruss,
Valentin

[Monika (Gast)]

Habs probiert. Bleibe immer noch in der while hängen.
Das gibts doch nicht. Ich weis, Frauen und Technik aber so dumm kann ich 
doch nicht sein.

[Valko Z. (hydravliska)]

Hi,

lies die Buttons dann in der while(1) Schleife und gib die auf die LEDs.
Dann solltest du mindestens sehen, wenn du die Buttons druckst

Gruss

[Monika (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!

#include "xintc.h"
#include "xparameters.h"
#include "xgpio.h"
#include "mb_interface.h"



#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID

void SetupInterruptSystem();
void ButtonInterrupt (void * CallbackRef);

XGpio GpioInput;
XGpio led;
XIntc intc;

static XIntc InterruptController;
int main (void)
{
  
  int test;
  
  
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
  XIntc_Initialize(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
  //XGpio_SetDataDirection(&GpioInput, 1, 0xF);
  XGpio_SetDataDirection(&led, 1, 0x0);
  XGpio_InterruptGlobalEnable(&GpioInput);
  XGpio_InterruptEnable(&GpioInput, XGPIO_IR_CH1_MASK);
  
  XIntc_Start(&intc, XIN_REAL_MODE);
  
  //XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,NULL);
  XIntc_Connect(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR, (XInterruptHandler)ButtonInterrupt, NULL);
  XIntc_Enable(&intc, XPAR_XPS_INTC_0_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_INTR);
  
  microblaze_enable_interrupts();
  
  XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
  //XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
  
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
  
  while(1)
{
  test=XGpio_DiscreteRead(&GpioInput, 1);
  XGpio_DiscreteWrite(&led, 1, test);
}

}

void ButtonInterrupt (void* CallbackRef)
{
  XGpio_InterruptClear(&GpioInput, XGPIO_IR_CH1_MASK);
  XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
}

[Valko Z. (hydravliska)]

Kannst du auch eine Foto von die "Addresses" Menu in System Assembly 
View hochladen. Sind alle IPs mit einer gültigen Addresse ?

[Monika (Gast)]

Adressen

[Valko Z. (hydravliska)]

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?

[Monika (Gast)]

Hi,

Ja, den hatte ich nicht zur Auswahl.

Linker Script? Nein. Wusste nicht, dass ich so etwas schreiben muss.

[rudel (Gast)]

das linker script erstellst du in SDK unter Xilinx tools --> Generate 
Linker Script

[Monika (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

[Valko Z. (hydravliska)]

Hi,

ich bin verwirrt, weil dein INTC Memory Map fängt bei Addresse 
0x00000000 an. Hast schon mal mit automatische Generierung die Addresse 
probiert.

[Monika (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

[rudel (Gast)]

funktioniert denn

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?

[Monika (Gast)]

JA, 0xAA... geht.

Nein, das in der While geht gar nicht. Ich hab mir die Values angesehen. 
Egal welchen Knopf ich drücke es tut sich nichts.

[Valko Z. (hydravliska)]

Kannst du mal dein Projekt hochladen, oder ist das Verzeichnis sehr 
gross?

[rudel (Gast)]

also entweder hackt es dann an den buttons odfer es wird ein interruppt 
ausgelöst udn er bleibt dann da irgendwo hängen

[Monika (Gast)]

Gerne.

Danke, dass Ihr euch so viel Mühe mit mir gebt!!!

Das ist super-lieb!!!!

[rudel (Gast)]

include "xintc.h"
#include "xparameters.h"
#include "xgpio.h"
#include "mb_interface.h"


/*
#define INTC_BASEADDR     XPAR_XPS_INTC_0_BASEADDR
#define INTC_DEVICE_ID    XPAR_XPS_INTC_0_DEVICE_ID
#define INTC_DEVICE_INTR_ID  XPAR_INTC_0_GPIO_1_VEC_ID

void SetupInterruptSystem();
void ButtonInterrupt (void * CallbackRef);
*/
XGpio GpioInput;
XGpio led;

static XIntc InterruptController;

int main (void)
{
  
  //microblaze_enable_interrupts();
  
  XGpio_Initialize(&GpioInput, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
  XGpio_Initialize(&led, XPAR_LEDS_8BIT_DEVICE_ID);
  XGpio_SetDataDirection(&GpioInput, 1, 0xF);
  XGpio_SetDataDirection(&led, 1, 0x0);
  /*XGpio_InterruptGlobalEnable(&GpioInput);
  XGpio_InterruptEnable(&GpioInput, 0x00000001);
  
  //XIntc_Connect(&InterruptController, INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);
   XIntc_RegisterHandler(INTC_BASEADDR,INTC_DEVICE_INTR_ID,(XInterruptHandler)ButtonInterrupt,(void *)0);  
  
  XIntc_Out32(INTC_BASEADDR + XIN_MER_OFFSET, 0x00000003);
  XIntc_Out32(INTC_BASEADDR + XIN_SIE_OFFSET, XPAR_PUSH_BUTTONS_5BIT_IP2INTC_IRPT_MASK);
  */
  XGpio_DiscreteWrite(&led, 1, 0xAAAAAAAA);
  
  while(1)
  {
  if(XGpio_DiscreteRead(&GpioInput!=0)){
                                          XGpio_DiscreteWrite(&led, 1, 0xFFFFFFFF);
                                          }
  }
  ;
}
/*
void ButtonInterrupt (void* CallbackRef)
{
  XGpio_InterruptClear(&GpioInput, 0x00000001);
  XGpio_DiscreteWrite(&led, 1, 0x66666666);
}*/

ändert sich hier bei tastendruck die LED anzeige?

[rudel (Gast)]

XGpio_DiscreteRead(&GpioInput!=0,1)

sry die abfrage ist falsch

[rudel (Gast)]

ohh gott ^^

XGpio_DiscreteRead(&GpioInput,1)!=0

[Valko Z. (hydravliska)]

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

[rudel (Gast)]

dann ist das prob ja bestimmt jetzt geöst :D

[Monika (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.

[Monika (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

[Valko Z. (hydravliska)]

Klasse