xil GPIO 2x Interrupt

[olpo (Gast)]

Halli hallo,

ich benutze xGPIO um mit den Druckknöpfen an meinem FPGA-Board einen 
Interrupt in C zu generieren.

Das klappt auch.

Jetzt möchte ich jedoch für alle vier Druckknöpfe unterschiedliche 
Interrupts erzeugen, und das funktioniert noch nicht.

Ich habe versucht, alle vier Druckknöpfe über einen GPIO-Core 
anzusprechen.
Die Frage ist jetzt, geht das so, oder brauche ich für jeden Druckknopf 
einen eigenen GPIO?

Hier ist mal der .mhs und .ucf Code.

#system.mhs

PORT Push_Buttons_GPIO_0_IO_pin = Push_Buttons_GPIO_0_IO, DIR = IO, VEC = [0:1]
PORT Push_Buttons_GPIO_1_IO_pin = Push_Buttons_GPIO_1_IO, DIR = IO, VEC = [0:1]

BEGIN xps_gpio
 PARAMETER INSTANCE = Push_Buttons
 PARAMETER HW_VER = 2.00.a
 PARAMETER C_INTERRUPT_PRESENT = 1
 PARAMETER C_BASEADDR = 0x00040000
 PARAMETER C_HIGHADDR = 0x000401FF
 PARAMETER C_GPIO_WIDTH = 2
 PARAMETER C_IS_DUAL = 1
 PARAMETER C_GPIO2_WIDTH = 2
 BUS_INTERFACE SPLB = mb_plb
 PORT GPIO_0_IO = Push_Buttons_GPIO_0_IO
 PORT IP2INTC_Irpt = Push_Buttons_IP2INTC_Irpt
 PORT GPIO_1_IO = Push_Buttons_GPIO_1_IO
END

# West
Net Push_Buttons_GPIO_0_IO_pin<0> LOC = AJ7  |  IOSTANDARD=LVCMOS33  |  PULLDOWN  |  SLEW=SLOW  |  DRIVE=2;
# East
Net Push_Buttons_GPIO_0_IO_pin<1> LOC = AK7  |  IOSTANDARD=LVCMOS33  |  PULLDOWN  |  SLEW=SLOW  |  DRIVE=2;
# South
Net Push_Buttons_GPIO_1_IO_pin<0> LOC = V8  |  IOSTANDARD=LVCMOS33  |  PULLDOWN  |  SLEW=SLOW  |  DRIVE=2;
# North
Net Push_Buttons_GPIO_1_IO_pin<1> LOC = U8  |  IOSTANDARD=LVCMOS33  |  PULLDOWN  |  SLEW=SLOW  |  DRIVE=2;

Ich kann im C-Code aber immer nur Knopf "West" ansprechen.
Bzw. ich weiß schlicht und einfach nicht wie ich die anderen ansprechen 
soll.

Die xparameters.h liefert diese Parameter:

/* Definitions for driver GPIO */
#define XPAR_XGPIO_NUM_INSTANCES 1

/* Definitions for peripheral PUSH_BUTTONS */
#define XPAR_PUSH_BUTTONS_BASEADDR 0x00040000
#define XPAR_PUSH_BUTTONS_HIGHADDR 0x000401FF
#define XPAR_PUSH_BUTTONS_DEVICE_ID 0
#define XPAR_PUSH_BUTTONS_INTERRUPT_PRESENT 1
#define XPAR_PUSH_BUTTONS_IS_DUAL 1

#define XPAR_INTC_0_GPIO_0_VEC_ID XPAR_XPS_INTC_PUSH_BUTTONS_IP2INTC_IRPT_INTR

Es sind also keine Parameter für die einzelnen Druckknöpfe gegeben.

Und hier ist der C-Code für den einen Druckknopf.
Auch hier sehe ich nicht, wie ich andere Knöpfe ansprechen soll.

XGpio gpio_PUSH;

void meine_Routine(){
...
}

/**
 *  Initialize GPIO Interrupt
 */
int GpioSetupIntrSystem (XIntc *IntcInstancePtr, XGpio *InstancePtr,
    u16 DeviceId, u16 IntrId, u16 IntrMask) {

  int Status;

  /* Hook up interrupt service routine */
  Status = XIntc_Connect(IntcInstancePtr, IntrId,
      (XInterruptHandler) meine_Routine, InstancePtr);
  if (Status != XST_SUCCESS) {
    return XST_FAILURE;
  }

  /* Enable the interrupt vector at the interrupt controller */
  XIntc_Enable(IntcInstancePtr, IntrId);

  /*
   * Enable the GPIO channel interrupts so that push button can be
   * detected and enable interrupts for the GPIO device
   */
  XGpio_InterruptEnable(InstancePtr, IntrMask);
  XGpio_InterruptGlobalEnable(InstancePtr);

  return XST_SUCCESS;
}


int main() 
{
   int Status;
   static XIntc InterruptController;

   XGpio_Initialize(&gpio_PUSH, XPAR_PUSH_BUTTONS_DEVICE_ID);

   /*
    * Initialize the interrupt controller driver so that it's ready to use.
    * specify the device ID that was generated in xparameters.h
    */
   Status = XIntc_Initialize( &InterruptController,
XPAR_XPS_INTC_DEVICE_ID);
  if (Status != XST_SUCCESS) {
    return XST_FAILURE;
  }
   /* set Push-Button Interrupt */
   Status = GpioSetupIntrSystem(&InterruptController, &gpio_PUSH, XPAR_PUSH_BUTTONS_DEVICE_ID,
      XPAR_INTC_0_GPIO_1_VEC_ID, 1);

  /*
   * Start the interrupt controller such that interrupts are recognized
   * and handled by the processor
   */
  Status = XIntc_Start( &InterruptController, XIN_REAL_MODE);
  if (Status != XST_SUCCESS) {
    return XST_FAILURE;
  }

      /* enable Interrups on Microblaze */
      microblaze_enable_interrupts();

    while(1);
   return 0;
}

Also, geht das so, mit nur einem GPIO, oder muss ich für jeden 
Druckknopf einen eigenen GPIO nehmen und für jeden einzelne Interrupts 
verlegen?

[Duke Scarring (Gast)]

olpo schrieb:
>Druckknöpfe
Die werden gepollt. Auch bei FPGAs.
Die Entprellung erfolgt dann meinetwegen in Software.

Tss. Soweit kommt es noch, pro Taster einen Interrupt zu verschwenden...
kopfschüttel

Duke

[Zonk (Gast)]

schau mal, wie atmel das bei den pinchange interrupts macht...