pynq interrumpir las interrupciones (EMIO) GPIO prueba

Plataforma PYNQ-Z2

Realizar la función

Aquí lograr interrupciones de acceso Botón de IRQ EMIO con pynq

Hardware EMIO 54 de recogida btn0, a través de entrada, provoca una interrupción # 52, a GIC

Por SPI, operación de interrupción y otros registros de la CPU de activación especificado IRQ

Diseño de hardware

Un EMIO de clientes potenciales de disciplina GPIO_0_0_tri_io a btn0

restricción

set_property -dict { PACKAGE_PIN D19   IOSTANDARD LVCMOS33 } [get_ports { GPIO_0_0_tri_io }]; #IO_L4P_T0_35 Sch=btn[0]

Diseño de software

#include <stdio.h>
#include "platform.h"



#include "xgpiops.h"
#include "xgpiops_hw.h"

#include "XSCUGIC.H"
#include "XSCUGIC_HW.H"

#include "sleep.h"



#define ICCPMR   *(volatile unsigned int *) 0xf8f00104
//printf(" ICCPMR = %0X  @ line = %d \n", ICCPMR ,__LINE__  );
//(__FILE__, __LINE__);

#define GPIO_NO 54

static void GpioHandler(void *CallBackRef, int Bank, u32 Status)
{

	static int  i = 0;

	if (Status ==0 ) return ;
    XGpioPs* pGpioPs=(XGpioPs*)CallBackRef;

    XGpioPs_IntrDisablePin(pGpioPs,GPIO_NO);

    printf("Gpio Handler %d...\n\r",i++);

  //  while (1 == XGpioPs_ReadPin( pGpioPs  ,  GPIO_NO )) ;

    usleep(100*1000);
    XGpioPs_IntrClearPin(pGpioPs,GPIO_NO);
    XGpioPs_IntrEnablePin(pGpioPs,GPIO_NO);



}

int main()

{

    XGpioPs Gpio;

    XGpioPs_Config *ConfigPtr;

    printf(" ICCPMR = %0X  @ line = %d \n", ICCPMR ,__LINE__  );


    ConfigPtr = XGpioPs_LookupConfig(0);
    XGpioPs_CfgInitialize(&Gpio, ConfigPtr, ConfigPtr->BaseAddr);
 //初始化GPIO的输入以及中断。

    XGpioPs_SetDirectionPin(&Gpio,GPIO_NO,0x0);


     XGpioPs_SetIntrTypePin(&Gpio,GPIO_NO,XGPIOPS_IRQ_TYPE_EDGE_RISING);
     XGpioPs_SetCallbackHandler(&Gpio, (void *)&Gpio, GpioHandler);
     XGpioPs_IntrEnablePin(&Gpio,GPIO_NO);


     XScuGic ScuGic;
     XScuGic_Config* pScuGicCfg;
     pScuGicCfg=XScuGic_LookupConfig(XPAR_SCUGIC_SINGLE_DEVICE_ID);
     XScuGic_CfgInitialize(&ScuGic,pScuGicCfg,pScuGicCfg->CpuBaseAddress);

     XScuGic_Connect(&ScuGic, 52,
                    (Xil_ExceptionHandler)XGpioPs_IntrHandler,
                    (void *)&Gpio);

     XScuGic_SetPriorityTriggerType(&ScuGic,52,0xa0,0x01);//优先级阈值f0
     XScuGic_Enable(&ScuGic,52);


     Xil_ExceptionInit();
     Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,(Xil_ExceptionHandler)XScuGic_InterruptHandler,&ScuGic);
     Xil_ExceptionEnable();

    printf("Intr test: \n\r");

    while(1)
    {

    }

}

resultado

botón

ICCICR (IC CPU IC REG) ->
ICDDC R (UC distribuidor C REG) ->

biblioteca de análisis de la función de interrupción GPIO

void XGpioPs_SetCallbackHandler(XGpioPs *InstancePtr, void *CallBackRef,
				 XGpioPs_Handler FuncPointer)

 XGpioPs_SetCallbackHandler(&Gpio, (void *)&Gpio, GpioHandler);

puntero de función XGpioPs_Handler

interrupción

La velocidad del procesador con la velocidad de los dispositivos de hardware periféricos con frecuencia no están en un orden de magnitud, por lo que si se toma el procesador central para enviar una petición al hardware, y luego esperar a que de una manera especial para responder, al parecer para reducir la eficiencia del núcleo.

Por lo tanto, depende de nosotros para proporcionar un mecanismo para el kernel de hardware nuevo enviar una señal (iniciativa activa para cambiar el hardware del kernel) cuando sea necesario, este es el mecanismo de ruptura.

Diferentes dispositivos correspondientes a diferentes interrupciones, cada interrupción a través de una identidad digital única.
Por ejemplo, es diferente desde el teclado de interrupción interrupciones desde el disco duro, por lo que el sistema operativo es capaz de distinguir entre la interrupción y saber qué hardware dispositivos que generaron la interrupción. De esta manera, el sistema operativo con el fin de proporcionar diferentes diferente de interrupción controlador de interrupción.

Cuando se ejecuta un programa, si hay otro evento ocurre (como el usuario ha abierto un programa) de modo que por el tiempo que necesita para el mecanismo de interrupción de un sistema informático de tratar.

Incluyendo hardware de interrupción mecanismomedios de interrupciónY el sistema operativorutina de servicio de interrupción.

Deje que el kernel de hardware nuevo señala cuando sea necesario.

interrupciones del sistema de ordenador Early generado por el código de identificación de hardware (identificación de la fuente de interrupción, se pueden usar para formar el correspondiente rutina de servicio de interrupción dirección o de almacenamiento de entrada de dirección de la primera rutina de servicio de interrupción) se llamavector de interrupcióndirección de interrupción Variable

tabla de vectores de interrupción: interrupción de la conexión entre el número de la tabla y el tipo de dirección de entrada de fuente de interrupción correspondiente controlador de interrupción;

_vector_table:
	B	_boot
	B	Undefined
	B	SVCHandler
	B	PrefetchAbortHandler
	B	DataAbortHandler
	NOP	/* Placeholder for address exception vector*/
	B	IRQHandler
	B	FIQHandler

rutina de servicio de interrupción: romper el código que se ejecuta cuando la interrupción de recepción

compilación

IRQHandler:					/* IRQ vector handler */

	stmdb	sp!,{r0-r3,r12,lr}		/* state save from compiled code*/
#if FPU_HARD_FLOAT_ABI_ENABLED
	vpush {d0-d7}
	vpush {d16-d31}
	vmrs r1, FPSCR
	push {r1}
	vmrs r1, FPEXC
	push {r1}
#endif

#ifdef PROFILING
	ldr	r2, =prof_pc
	subs	r3, lr, #0
	str	r3, [r2]
#endif

	bl	IRQInterrupt			/* IRQ vector */

C

/*****************************************************************************/
/**
*
* This is the C level wrapper for the IRQ interrupt called from the vectors.s
* file.
*
* @param	None.
*
* @return	None.
*
* @note		None.
*
******************************************************************************/
void IRQInterrupt(void)
{
	XExc_VectorTable[XIL_EXCEPTION_ID_IRQ_INT].Handler(XExc_VectorTable[
					XIL_EXCEPTION_ID_IRQ_INT].Data);
}

#if !defined (__aarch64__)

ref
https://blog.csdn.net/qq_18077275/article/details/89304215?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

ruptura Zynq

Fuentes dividen en tres categorías SPI, PPI, SGI total de 96 el número de identificación de interrupción

Después de un descanso de ejecutar múltiples controlador de lanzador de interrupción de interrupción, los siguientes pasos

• PASO 1, el primero en saltar al vector de interrupción para activar la rutina de servicio de IRQ. Corresponde a la función

• PASO 2, hay docenas de maneras de generar IRQ (ID No. 96) docenas, por lo que necesitamos saber específicamente lo que pasó, pasó interrupciones IRQ número de interrupción. La convocatoria correspondiente al manejador apropiado si se encuentra.

• PASO 3, que encuentran particular, el número de identificación de interrupción, que corresponde a los pasos es re-proceso puede tener que ser subdividido
  (por ejemplo, a 118, 52 GPIO puede generar interrupciones para determinar el específico de los cuales). Así como otro proceso apropiado.