ZYNQ. Interrupt(2)SPI.AXI TIMER

Shared Peripheral Interrupts (SPI)

SPI 可以接收来自PL的中断，这里使用PL模块 AXI Timer 的中断模式，并连接到CPU。

AXI TIMER

定时器，内部有两个完全相同的TIMER模块。

特性：

在手册里可以找到详细的参数和寄存器信息。

硬件系统

需要zynq核和一个AXI Timer，PL的clock可以在zynq核内部设置。

软件部分

这里会使用到xilinx提供的函数库

• 中断       xscugic.h
• 定时器　xtmrctr.h

因为使用了PS端的GPIO，所以还需要另一个库

• GPIO      xgpiops.h

大致流程与私有定时器相似：

1. 定义定时器、中断控制器和GPIO的结构体
2. 初始化定时器、终端控制器和GPIO，以及私有定时器自检
3. ARM异常处理初始化，连接系统中断处理程序
4. 连接定时器中断程序
5. 使能GIC、使能定时器中断、使能ARM中断
6. 配置重载、计数器初值，然后开始定时器，等中断
7. 废弃这个定时器，通知处理器、通知GIC废弃

code:

//*****************2018/11/27 封装******************

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

 #include "xparameters.h"
 #include "xgpiops.h"

 #include "sleep.h"

 #include "xtmrctr.h"
 #include "xil_exception.h"
 #include "xscugic.h"

 #define GpioPsDeviceId         XPAR_PS7_GPIO_0_DEVICE_ID
 #define AxiTmrCtrDeviceId     XPAR_TMRCTR_0_DEVICE_ID
 #define XScuGic_DEVICE_ID      XPAR_PS7_SCUGIC_0_DEVICE_ID
 #define TMRCTR_INTERRUPT_ID    XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR

 #define pinLed1 0
 #define pinLed2 9

 #define TIMER_CNTR_0         0
 #define RESET_VALUE             0xFFFFFFFF-(0x5F5E100-1) //1s

 int XGpioPsInit(XGpioPs *XGpioPsPtr);
 int XIntrSysInit(XTmrCtr *XTmrCtrInstancePtr,
         XScuGic *IntcInstancePtr,
         u16 DeviceId,
         u16 IntrId);
 void XTmrCtrIntrHandler(void *CallBackRef, u8 TmrCtrNumber);
 void TmrCtrDisableIntr(XScuGic *IntcInstancePtr, u16 IntrId);

 static XGpioPs GpioPs;
 static XTmrCtr XTmrCtrInstance;
 static XScuGic IntcInstance;

 int valueWriteLed2 = 0x01;
 int valueWriteLed1 = 0x00;

 int main()
 {
     int Status;

     xil_printf("\n\r Hello,world! \n\r"
             "AXI Timer Test\n\r");

     /* Initialize the Gpio driver */
     Status = XGpioPsInit(&GpioPs);
     if (Status != XST_SUCCESS) {
         xil_printf("GPIOPS Initial Failed\r\n");
         return XST_FAILURE;
     }

     /* initialize & connect & enable interrupt system  */
     Status = XIntrSysInit(&XTmrCtrInstance,
                 &IntcInstance,
                 AxiTmrCtrDeviceId,
                 TMRCTR_INTERRUPT_ID);
     if (Status != XST_SUCCESS) {
         xil_printf("Interrupt System Initial Failed\r\n");
         return XST_FAILURE;
     }

     /* set interrupt handler */
     XTmrCtr_SetHandler(&XTmrCtrInstance,
             XTmrCtrIntrHandler,&XTmrCtrInstance);

     /* Setting the timer counter option
      * interrupt Mode and Auto Reload And Up Counter*/
     XTmrCtr_SetOptions(&XTmrCtrInstance, TIMER_CNTR_0,
             XTC_INT_MODE_OPTION );//| XTC_AUTO_RELOAD_OPTION);

     /* Set a reset value */
     XTmrCtr_SetResetValue(&XTmrCtrInstance,
             TIMER_CNTR_0, //
             RESET_VALUE); //

     /* Start the timer counter */
     XTmrCtr_Start(&XTmrCtrInstance, TIMER_CNTR_0);

     while(){
         XGpioPs_WritePin(&GpioPs, pinLed1, valueWriteLed1);
 //        XGpioPs_WritePin(&Gpio, pinLed2, valueWriteLed2);
         sleep();
         xil_printf("--Write Led1: %d--\n",valueWriteLed1);
 //        xil_printf("--Write Led2: %d--\n",valueWriteLed2);
         valueWriteLed1 = valueWriteLed1 & (0x01) ?
                 0x00 :0x01;//~valueWriteLed1;
 //        valueWriteLed2 = valueWriteLed2 & (0x01) ?
 //                0x00 :0x01;//~valueWriteLed2;

         xil_printf("\n-- Do Again --\n");
     }

     /* never reached */
     xil_printf("\n test end\n\r");

     /* Disconnect the interrupt */
     TmrCtrDisableIntr(&IntcInstance, TMRCTR_INTERRUPT_ID);

     return ;
 }

 /* Initialize the timer And GIC device driver ,
  * Connect the Interrupt to GIC And Enable the Interrupt */
 int XIntrSysInit(XTmrCtr *XTmrCtrInstancePtr,XScuGic *IntcInstancePtr,
         u16 DeviceId, u16 IntrId)
 {
     XScuGic_Config *IntcConfig;
     int Status;

     /* Initialize the timer counter*/
     Status = XTmrCtr_Initialize(XTmrCtrInstancePtr, DeviceId);
     if (Status != XST_SUCCESS) {
         xil_printf("AXI TIMER INITIAL FAILED! \n\r");
         return XST_FAILURE;
     }

     /* Initialize the interrupt controller driver */
     IntcConfig = XScuGic_LookupConfig(XScuGic_DEVICE_ID);
     if (NULL == IntcConfig) {
         return XST_FAILURE;
     }
     Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
                     IntcConfig->CpuBaseAddress);
     if (Status != XST_SUCCESS) {
         return XST_FAILURE;
     }

     /* Sets the interrupt priority & trigger type
      * for the specified IRQ source */
     XScuGic_SetPriorityTriggerType(IntcInstancePtr, IntrId,
                         0xA0, 0x3);

     /* Initialize the exception table. */
     Xil_ExceptionInit();

     /* Register the interrupt controller handler with the exception table.     */
     Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
                     (Xil_ExceptionHandler)
                     XScuGic_InterruptHandler,
                     IntcInstancePtr);

     /* Connect the interrupt handler  */
     Status = XScuGic_Connect(&IntcInstance, IntrId,
                  (Xil_ExceptionHandler)XTmrCtr_InterruptHandler,
                  XTmrCtrInstancePtr);
     if (Status != XST_SUCCESS) {
         return Status;
     }

     /* Enable the interrupt for the Timer device. */
     XScuGic_Enable(IntcInstancePtr, IntrId);

     /* Enable non-critical exceptions. */
     Xil_ExceptionEnable();

     return XST_SUCCESS;
 }

 void XTmrCtrIntrHandler(void *CallBackRef, u8 TmrCtrNumber)
 {
 //    XTmrCtr *InstancePtr = (XTmrCtr *)CallBackRef;

     XGpioPs_WritePin(&GpioPs, pinLed2, valueWriteLed2);
     xil_printf("--Write Led2: %d--\n",valueWriteLed2);
     valueWriteLed2 = valueWriteLed2 & (0x01) ?
             0x00 :0x01;//~valueWriteLed2;
     return;
 }

 int XGpioPsInit(XGpioPs *GpioPsPtr)
 {
     XGpioPs_Config *ConfigPtr;

     int Status;
     /* Initialize the Gpio driver. */
     ConfigPtr = XGpioPs_LookupConfig(GpioPsDeviceId);
     if (ConfigPtr == NULL) {
         xil_printf("ERROR\n");
         return XST_FAILURE;
     }
     Status = XGpioPs_CfgInitialize(GpioPsPtr,ConfigPtr,
                                     ConfigPtr->BaseAddr);
     if (Status != XST_SUCCESS) {
             print("cfg init err\n");
             return XST_FAILURE;
     }

     //set pin direction
     //value 0 -> input  1 -> output
     XGpioPs_SetDirectionPin(GpioPsPtr, pinLed1, );
     XGpioPs_SetDirectionPin(GpioPsPtr, pinLed2, );
     //value 0 -> disable   1 -> enable
     XGpioPs_SetOutputEnablePin(GpioPsPtr, pinLed1, );
     XGpioPs_SetOutputEnablePin(GpioPsPtr, pinLed2, );

     return XST_SUCCESS;
 }
 void TmrCtrDisableIntr(XScuGic* IntcInstancePtr, u16 IntrId)
 {
     /* Disconnect the interrupt */
     XScuGic_Disable(IntcInstancePtr, IntrId);
     XScuGic_Disconnect(IntcInstancePtr, IntrId);

     return;
 }

 via

https://blog.csdn.net/u014485485/article/details/79069445