Xilinx ZYNQ 7000+Vivado2015.2系列（十三）私有定时器中断

私有定时器属于PS部分，定时器可以帮我们计数、计时，有效的控制模块的时序。

这一次实验我们认识定时器并使用定时器产生中断。

CPU的私有中断(PPI)

CPU的私有中断(PPI)，5个：全局定时器，私有看门狗定时器，私有定时器以及来自 PL 的 FIQ/IRQ。

20180115094042330

它们的触发类型都是固定不变的，并且来自 PL 的快速中断信号 FIQ 和中断信号 IRQ 反向，

然后送到中断控制器因此尽管在ICDICFR1 寄存器内反映的他们是低电平触发，但是 PS-PL 接口中为高电平触发。

CPU的私有定时器

CPU的私有定时器：每个CPU都有自己的私有定时器：

20180115093827047

私有定时器的工作频率是CPU的一半（频率仅供参考，主要看频率分配比率）：

20180115094250721

插曲：zc702的时钟源有三个：

20180115094902762

PS Clock经过倍频以后供给PS各个模块使用：

20180115095428511

PL时钟产生：

20180115095643112

在ZYNQ核里，CPU默认的时钟比率是6：2：1，CPU时钟频率666.666M：

20180115100024128

这样定时器工作频率就是333.333MHz。

私有定时器的特性：

（1） 32 位计数器，达到零时产生一个中断
（2） 8 位预分频计数器，可以更好的控制中断周期
（3）可配置一次性或者自动重加载模式
（4）定时器时间可以通过下式计算：
定时时间 = 1/定时器频率*（预加载值+1），粗略一点预加载值=定时时间*定时器频率。

私有定时器中断硬件系统

硬件系统十分简单，因为是PS部分的，所以只需要添加ZYNQ核就可以了，DDR正确配置，需要打印信息，所以把uart1勾选上：

20180115101217031

也没有什么引脚约束，我们就观察计时信息，这样就搭建好了要用的硬件。

软件部分

重点在软件部分。

首先我们通过一个例子，用极简的方式熟悉私有定时器的使用：

#include <stdio.h>
#include "xscutimer.h"
#include "xparameters.h"
 
int main()
{
	int Status;
	int timer_value;
	int counter = 0;
//----------------------------------------------------------------------------------------
	XScuTimer my_Timer;  //定时器实例
	XScuTimer_Config *Timer_Config;//定时器配置信息
//----------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------
	Timer_Config = XScuTimer_LookupConfig(XPAR_PS7_SCUTIMER_0_DEVICE_ID);//查找配置信息
	Status = XScuTimer_CfgInitialize(&my_Timer, Timer_Config, Timer_Config->BaseAddr);//初始化定时器
	XScuTimer_LoadTimer(&my_Timer, XPAR_PS7_CORTEXA9_0_CPU_CLK_FREQ_HZ / 2);//设置计数值，也就是设置时间，这里设为1s
	XScuTimer_Start(&my_Timer);//开启定时器
//-----------------------------------------------------------------------------------------
	while(1)
	{
		timer_value = XScuTimer_GetCounterValue(&my_Timer);//得到当前计数值
		if (timer_value == 0)//计完一个周期
		{
			XScuTimer_RestartTimer(&my_Timer);//装载初始值重新开始计数
			printf("Timer has reached zero %d times\n\r", counter++);
		}
//		else
//		{
//			printf("Timer is still running (Timer value = %d)\n\r", timer_value);//打印出当前计数值
//		}
	}
	return 0;
}

从main函数开始：

首先定义需要用到的两个实例：

XScuTimer //定时器实例  

XScuTimer\_Config //定时器配置  

XScuTimer\_LookupConfig //查找定时器的配置信息  

XScuTimer\_CfgInitialize //定时器的初始化  

XScuTimer\_LoadTimer //设置加载值，也就是设置时间，这里设为1s

我们可以进入xparameters.h文件得到CPU的工作频率，取其一般为计数值，即为定时1s:

20180115104456395

XScuTimer\_Start //开启定时器

while循环里，相当于检测定时器定时是否准确：

XScuTimer\_GetCounterValue //得到当前计数值

如果计数值重新回到0则

XScuTimer\_RestartTimer //装载初始值重新开始计数

串口打印信息：

20180115104757343

接下来看一个私有定时器请求中断的例子：

#include <stdio.h>
#include "xscutimer.h"
#include "xparameters.h"
#include "xscugic.h"
 
 
#define INTERRUPT_COUNT_TIMEOUT_VALUE 50
 
// ------------------------函数原型---------------------------
static void my_timer_interrupt_handler(void *CallBackRef);
//---------------------------------------------------------
 
int InterruptCounter = 0;
 
int main()
{
	int Status;
 
	//-----------私有定时器需要的两个结构体--------------------
	XScuTimer my_Timer;
	XScuTimer_Config *Timer_Config;
	//-------------------------------------------------
 
	//-----------中断控制器需要的两个结构体--------------------
	XScuGic my_Gic;
	XScuGic_Config *Gic_Config;
	//-------------------------------------------------
 
	Gic_Config = XScuGic_LookupConfig(XPAR_PS7_SCUGIC_0_DEVICE_ID);//查找GIC的配置信息
	Status = XScuGic_CfgInitialize(&my_Gic, Gic_Config, Gic_Config->CpuBaseAddress);//使用配置信息初始化GIC
 
	Timer_Config = XScuTimer_LookupConfig(XPAR_PS7_SCUTIMER_0_DEVICE_ID);//查找定时器的配置信息
	Status = XScuTimer_CfgInitialize(&my_Timer, Timer_Config, Timer_Config->BaseAddr);//使用配置信息初始化定时器
 
	Xil_ExceptionInit();//初始化ARM处理器的异常处理
 
	//连接到Xilinx提供的通用中断处理程序XScuGic_InterruptHandler，
	//所有产生的中断都要经过GIC，GIC负责使能中断，废弃中断，赋予优先级，发送到CPU，
	//中断发生时ARM处理器会先询问中断控制器哪一个外设产生的中断，第三个参数是传递给处理程序的
	Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT, (Xil_ExceptionHandler)XScuGic_InterruptHandler, &my_Gic);
 
	// 连接到我们自己设计的定时器的中断处理程序
	Status = XScuGic_Connect(&my_Gic, XPAR_SCUTIMER_INTR, (Xil_ExceptionHandler)my_timer_interrupt_handler, (void *)&my_Timer);
 
	// 在GIC上使能定时器中断（Input）
	XScuGic_Enable(&my_Gic, XPAR_SCUTIMER_INTR);
 
	// 使能定时器中断（Output）
	XScuTimer_EnableInterrupt(&my_Timer);
 
	// 在ARM处理器上使能中断
	Xil_ExceptionEnable();
 
	XScuTimer_LoadTimer(&my_Timer, XPAR_PS7_CORTEXA9_0_CPU_CLK_FREQ_HZ / 2);//设置定时器计数值
 
	XScuTimer_EnableAutoReload(&my_Timer);//自动reload
 
	XScuTimer_Start(&my_Timer);//开启定时器
 
	while(1)
	{
		if (InterruptCounter >= INTERRUPT_COUNT_TIMEOUT_VALUE)
		{
			break;//计数50次跳出
		}
	}
 
	printf("If we see this message, then we've broken out of the while loop\n\r");
	Xil_ExceptionDisable();//通知处理器废弃这个中断
	XScuGic_Disconnect(&my_Gic, XPAR_SCUTIMER_INTR);//通知GIC废弃这个定时器中断
	return 0;
}
 
 
static void my_timer_interrupt_handler(void *CallBackRef)
{
	XScuTimer *my_Timer_LOCAL = (XScuTimer *) CallBackRef;//Xilinx的驱动会自动传入外设的实例进来
 
	if (XScuTimer_IsExpired(my_Timer_LOCAL))
	{
		// Clear the interrupt flag in the timer, so we don't service
		// the same interrupt twice.
		XScuTimer_ClearInterruptStatus(my_Timer_LOCAL);
		printf("count %d times\n\r",InterruptCounter++);
 
		if (InterruptCounter >= INTERRUPT_COUNT_TIMEOUT_VALUE)
		{
			XScuTimer_DisableAutoReload(my_Timer_LOCAL);//必须有CallBackRef我们才能完成这件事
		}
	}
}

从main函数进入：

私有定时器需要的两个结构体：XScuTimer  XScuTimer_Config

中断控制器需要的两个结构体：XScuGic  XScuGic_Config

私有定时器的初始化：XScuTimer_LookupConfig  XScuTimer_CfgInitialize

中断控制器的初始化：XScuGic_LookupConfig XScuGic_CfgInitialize

Xil\_ExceptionInit  //ARM异常处理初始化  
Xil\_ExceptionRegisterHandler  //连接到Xilinx提供的通用中断处理程序，
                               //中断发生时ARM处理器会先询问中断控制器哪一个外设产生的中断，
                               //第三个参数是传递给处理程序的
XScuGic\_Connect  //连接到我们自己设计的定时器的中断处理程序
XScuGic\_Enable  //在GIC上使能定时器中断（Input）  
XScuTimer\_EnableInterrupt //使能定时器中断（Output）  
Xil\_ExceptionEnable  //在ARM处理器上使能中断  
XScuTimer\_LoadTimer  //设置定时器计数值  
XScuTimer\_EnableAutoReload  //自动reload  
XScuTimer\_Start  //开启定时器  
while循环，循环到一定次数退出
Xil\_ExceptionDisable  //通知处理器废弃这个定时器中断  
XScuGic\_Disconnect  //通知GIC废弃这个定时器中断

异常处理程序：

最后看一下我们设计的异常处理程序：

static void my_timer_interrupt_handler(void *CallBackRef)
{
	XScuTimer *my_Timer_LOCAL = (XScuTimer *) CallBackRef;//Xilinx的驱动会自动传入外设的实例进来
	if (XScuTimer_IsExpired(my_Timer_LOCAL))
	{
		// Clear the interrupt flag in the timer, so we don't service
		// the same interrupt twice.
		XScuTimer_ClearInterruptStatus(my_Timer_LOCAL);
		printf("count %d times\n\r",InterruptCounter++);
 
		if (InterruptCounter >= INTERRUPT_COUNT_TIMEOUT_VALUE)
		{
			XScuTimer_DisableAutoReload(my_Timer_LOCAL);//必须有CallBackRef我们才能完成这件事
		}
	}
}

回调中断实例，定时器每计满一次会触发中断，

然后进入我们的中断处理程序，将计数次数加1并打印出来，计满一定次数以后不再计数。

打印的信息：

20180115112136537

中断系统的建立单独封装

另外，可以将中断系统的建立单独封装，看起来结构更清晰：

#include <stdio.h>
#include "xscugic.h"
#include "xscutimer.h"
#include "xparameters.h"
//timer info
#define TIMER_DEVICE_ID XPAR_XSCUTIMER_0_DEVICE_ID
#define INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
#define TIMER_IRPT_INTR XPAR_SCUTIMER_INTR
#define TIMER_LOAD_VALUE XPAR_PS7_CORTEXA9_0_CPU_CLK_FREQ_HZ / 2
static XScuGic Intc; //GIC
static XScuTimer Timer;//timer
 
static void TimerIntrHandler(void *CallBackRef)
{
	static int time = 0; //计数
	XScuTimer *TimerInstancePtr = (XScuTimer *) CallBackRef;
	XScuTimer_ClearInterruptStatus(TimerInstancePtr);
	time++;
	printf("count %d times\n\r",time); //每秒打印输出一次
}
 
void SetupInterruptSystem(XScuGic *GicInstancePtr,XScuTimer *TimerInstancePtr, u16 TimerIntrId)
{
	XScuGic_Config *IntcConfig; //GIC config
	Xil_ExceptionInit();
	//initialise the GIC
	IntcConfig = XScuGic_LookupConfig(INTC_DEVICE_ID);
	XScuGic_CfgInitialize(GicInstancePtr, IntcConfig, IntcConfig->CpuBaseAddress);
 
	Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
	(Xil_ExceptionHandler)XScuGic_InterruptHandler,//connect to the hardware
	GicInstancePtr);
	XScuGic_Connect(GicInstancePtr, TimerIntrId,
	(Xil_ExceptionHandler)TimerIntrHandler,//set up the timer interrupt
	(void *)TimerInstancePtr);
 
	XScuGic_Enable(GicInstancePtr, TimerIntrId);//enable the interrupt for the Timer at GIC
	XScuTimer_EnableInterrupt(TimerInstancePtr);//enable interrupt on the timer
	//Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ); //Enable interrupts in the Processor.
	Xil_ExceptionEnable();
}
 
int main()
{
	XScuTimer_Config *TMRConfigPtr; //timer config
	printf("------------START-------------\n");
	//私有定时器初始化
	TMRConfigPtr = XScuTimer_LookupConfig(TIMER_DEVICE_ID);
	XScuTimer_CfgInitialize(&Timer, TMRConfigPtr,TMRConfigPtr->BaseAddr);
	//set up the interrupts
	SetupInterruptSystem(&Intc,&Timer,TIMER_IRPT_INTR);
	//加载计数周期， 私有定时器的时钟为 CPU 的一般， 为 333MHZ,
    //如果计数 1S,加载值为1sx(333x1000x1000)(1/s)-1=0x13D92D3F
	XScuTimer_LoadTimer(&Timer, TIMER_LOAD_VALUE);
	//自动装载
	XScuTimer_EnableAutoReload(&Timer);
	//启动定时器
	XScuTimer_Start(&Timer);
	while(1);
	return 0;
}

posted @ 2024-03-28 17:22 L707 阅读(278) 评论(0) 编辑收藏举报

刷新页面返回顶部

柒月的风