Timer with Interrupts

Overview

In this tutorial we will improve on the Timer peripheral developed in Create a Simple Timer Peripheral. The improvement is achieved by enabling the peripheral to generate an interrupt when the timer expires. The PowerPC then processes the interrupt through an interrupt handler function which gets called whenever the interrupt occurs. In this example, the interrupt handler function will switch the state of the LEDs and reset the timer.

Figure: The Timer peripheral

The timer will use two registers, one to store the delay period and the other for starting, stopping and checking if the timer has expired. We will call the first register the delay register and the second register the control register. The delay register will be set by the software application to determine how long of a delay it requires. This value will remain in the delay register unchanged and the software application will be able to read this value if for some reason it needs to. The control register will only use the first two bits, being bit 0 and bit 1. Bit 0 will be read-only and will be used by the timer peripheral to signal to the software application that the timer has expired. Bit 1 will be read and writeable, and it will be used by the software application to make the timer “run”. When a “1” is written to this bit, the timer will start counting down from the delay value. When a “0” is written to this bit, the timer will reset.

This tutorial contains screenshots to guide you through the entire implementation process. You can click on the images to view a higher resolution when necessary.

Are you using EDK 10.1?

Try the updated version of this tutorial based on the Virtex-5 FPGA on the ML505 board: Timer with Interrupts

Create the Basic Project

Follow these steps to create the basic project:

Open XPS and from the dialog box, select “Base System Builder wizard” and OK.
Create a new folder for the project and select it using “Browse”. In “Advanced Options” tick “Use repository paths” and select the “C:\XUPV2P\lib” folder using “Browse”. Click “OK”.
Tick “I would like to create a new design” and click “Next”.
Select “Xilinx” as the board vendor. Select “XUP Virtex II Pro Development System” as the board name. Select “C” as the board revision. Click “Next”.
Tick “PowerPC” and click “Next”.
Select all clock frequencies to be 100MHz. Select “No debug”. Click “Next”.
In selecting the Additional IO Interfaces, tick RS232_Uart_1 and LEDs_4Bit. Untick everything else.
When Adding Internal Peripherals, select 64KB for the plb_bram_if_cntlr_1 and click “Next”.
Select RS232_Uart_1 for both STDIN and STDOUT. Un-tick “Memory Test” and leave “Peripheral Test” ticked. Click “Next”.
On the “Configure Peripheral Test Application” page, select plb_bram_if_cntlr_1 for the Instruction, Data, Stack and Heap memories. Click “Next”.
Click “Generate”.
Click “Finish”.
Tick “Start using Platform Studio” and click “OK”.

Create the Timer Peripheral

We now create our Timer peripheral using the Peripheral Wizard.

Select from the menu “Hardware->Create or Import Peripheral”. Click “Next”.
Select “Create templates for a new peripheral” and click “Next”.
We must now decide where to place the files for the peripheral. They can be placed within this project, or they can be made accessible to other projects. Select “To an XPS project”. Click “Next”.
Type my_timer for the peripheral name. Click “Next”.
Select “On-chip Peripheral Bus” (OPB) and click “Next”.
The Peripheral Wizard can generate our VHDL template to include many different features. Tick “User logic interrupt support” and “User logic S/W register support”. Un-tick everything else and click “Next”.
On the “Interrupt Service” page, leave the defaults and click “Next”.
Choose “2” for the number of software accessible registers. Choose 32-bits for the size of the registers, as we will use a 32-bit timer.
On the “IP Interconnect” page we can customize our connection to the OPB but we will leave everything as is for simplicity. Click “Next”.
On the “Peripheral Simulation Support” page, we can specify if we want the wizard to create a simulation platform for our peripheral. Click “Next” without ticking the option to generate.
After the “Peripheral Implementation Support” page, the wizard will generate all the template files for us. Tick “Generate ISE and XST project files” and “Generate template driver files”. Click “Next”.
Click “Finish”. Now our templates are created and we can modify them to include the code for the timer.

Modify the Timer Peripheral

Now we want to add a timer to this peripheral template and connect it up with the registers that the Peripheral Wizard created for us.

Select from the menu “File->Open” and look in the project folder.
Open the folders: pcores\my_timer_v1_00_a\hdl\vhdl. This folder contains two source files that describe our peripheral my_timer.vhd and user_logic.vhd. The first file is the main part of the peripheral and it implements the interface to the OPB. The second file is where we place our custom logic to make the peripheral do what we need it to do. This part is instantiated by the first file.
Open the file user_logic.vhd. We will need to modify this source code to include our timer code.
Find the line of code that says --USER signal declarations added here and add the following lines of code just below.

-- Timer signals and components

signal timer_count : std_logic_vector(0 to C_DWIDTH-1);
signal timer_expired : std_logic;
signal timer_run : std_logic;

Find the line of code that says --USER logic implementation added here and add the following lines of code just below.

-- Timer connections
timer_run <= slv_reg1(1);

-- Timer process - times the delay between bursts
process (Bus2IP_Clk, Bus2IP_Reset)
begin
  -- if the peripheral is told to reset, then reset the timer
  if Bus2IP_Reset = '1' then
    timer_count <= (others => '0');
    timer_expired <= '1';
  -- otherwise, if there is a clock event, run the timer
  elsif Bus2IP_Clk'event and Bus2IP_Clk = '1' then
    -- if the timer is not running, then reset the timer
    if timer_run = '0' then
      timer_count <= slv_reg0;
      timer_expired <= '0';
    -- if the timer count is not zero then decrease the count
    elsif timer_count /= 0 then
      timer_count <= timer_count - 1;
      timer_expired <= '0';
    -- otherwise, the timer has expired
    else
      timer_expired <= '1';
    end if;
  end if;
end process;

-- Interrupt connections
IP2Bus_IntrEvent(0) <= timer_expired;

Find the line of code that says “when “01” => slv_ip2bus_data <= slv_reg1” and replace it with the three lines of code below. Now, when the timer control register is read from, bit 0 will represent the timer_expired signal.

when "01" =>
  slv_ip2bus_data(1 to C_DWIDTH-1) <= slv_reg1(1 to C_DWIDTH-1);
  slv_ip2bus_data(0) <= timer_expired;

Now we need to remove the example code that generates interrupts. The peripheral wizard automatically generates some VHDL code to generate interrupts in our user_logic.vhd file. As we use the timer_expired signal to generate interrupts, we must delete the example code. Comment out or delete all the code between the line -- Example code to generate user logic interrupts and the line IP2Bus_IntrEvent <= interrupt; inclusively.
Save and close the file.

Import the Timer Peripheral

Now we will use the Peripheral Wizard again, but this time using the import function.

Select from the menu “Hardware->Create or Import Peripheral” and click “Next”.
Select “Import existing peripheral” and click “Next”.
Select “To an XPS project”, ensure that the folder chosen is the project folder, and click “Next”.
For the name of the peripheral, type my_timer. Tick “Use version” and select the same version number that we originally created. Click “Next”. It will ask if we are willing to overwrite the existing peripheral and we should answer “Yes”.
Tick “HDL source files” and click “Next”.
Select “Use existing Peripheral Analysis Order file (*.pao)” and click “Browse”. From the project folder, go to pcores\my_timer_v1_00_a\data and select the my_timer_v2_1_0.pao file. Click “Next”.
On the HDL analysis information page, click “Next”. The wizard will mention if any errors are found in the design.
On the Bus Interfaces page, tick “OPB Slave” and click “Next”.
On the “SOPB: Port” page, click “Next”.
On the “SOPB: Parameter” page, click “Next”.
On the “Identify Interrupt Signals” page, leave the defaults and click “Next”.
On the “Parameter Attributes” page, click “Next”.
On the “Port Attributes” page, click “Next”.
Click “Finish”.

The timer peripheral is now ready to use and it should be accessible through the “IP Catalog->Project Repository” in the XPS interface. Note that although we can access it through the IP Catalog, other projects will not find it there because it is only associated with our project, as we specified in the Peripheral Wizard.

Create an Instance of the Peripheral

Now we are ready to create an instance of the peripheral into our project which can then be downloaded into the FPGA and tested by using simple code running on the PowerPC.

From the “IP Catalog” find the my_timer IP core in the “Project Repository” group. Right click on the core and select “Add IP”.
From the “System Assembly View” using the “Bus Interface” filter, connect the my_timer_0 to the OPB bus.
Click on the “Ports” filter. Click on the “+” for my_timer_0 to view its ports. Click on the “Net” field for the IP2INTC_Irpt port. Type my_timer_irq in this field and press “Enter”.
Still within the “Ports” filter, click on the “+” for the ppc405_0 to view the PowerPC ports. Click on the “Net” field for the “EICC405EXTINPUTIRQ” port. Type my_timer_irq in this field and press “Enter”. This connects the timer interrupt request signal to the interrupt request input of the PowerPC.
Click on the “Addresses” filter. Change the “Size” for my_timer_0 to 64K. Then click “Generate Addresses”.

Now we have created an instance of the Timer peripheral in our design and we have connected its interrupt request signal to the external interrupt request input of the PowerPC. This completes our hardware connections for interrupt capability.

Modify the Software Application

The software application will contain the main program and the interrupt handler function to be called when an interrupt occurs. It must create the interrupt vector table which tells the PowerPC what code to run when an interrupt is generated. It also must enable the Timer peripheral to generate interrupts, and the PowerPC to respond to interrupts.

From the “Applications” tab, open “Sources” within the “Project: TestApp_Peripheral” tree. Open the TestApp_Peripheral.c source file.
Replace all the code in this file with the following source and save the file.

#include "xparameters.h"
#include "xbasic_types.h"
#include "xgpio.h"
#include "xstatus.h"
#include "my_timer.h"
#include "xexception_l.h"

#define TIMER_RESET   0x00000000
#define TIMER_RUN     0x40000000
#define TIMER_EXPIRED 0x80000000
#define TIMER_HALFSEC 0x02FAF080

XGpio GpioOutput;
Xuint32 my_timer;
unsigned int *my_timer_p =
         (unsigned int *) XPAR_MY_TIMER_0_BASEADDR;

//----------------------------------------------------
// INTERRUPT HANDLER FUNCTION
//----------------------------------------------------
void MY_TIMER_Intr_Handler(void * baseaddr_p)
{
  static Xuint32 led_data;
  Xuint32 baseaddr;
  Xuint32 IpStatus;

  baseaddr = (Xuint32) baseaddr_p;

  // Get the timer interrupt status
  IpStatus = MY_TIMER_mReadReg(baseaddr,
                      MY_TIMER_INTR_ISR_OFFSET);

  // If timer caused the interrupt then switch LEDs
  if (IpStatus){
    // If LEDs are ON then turn OFF and vice versa
    led_data = led_data ^ 0xF;
    XGpio_DiscreteWrite(&GpioOutput, 1, led_data);
    // Reset the timer and hence the interrupt
    MY_TIMER_mWriteSlaveReg1(baseaddr, TIMER_RESET);
    MY_TIMER_mWriteSlaveReg1(baseaddr, TIMER_RUN);
  }
}

//----------------------------------------------------
// MAIN FUNCTION
//----------------------------------------------------
int main (void)
{
  Xuint32 status;

  // Clear screen
  xil_printf("%c[2J",27);
  xil_printf("  Timer Project from ");
  xil_printf("http://www.fpgadeveloper.com\r\n");
  xil_printf("  --------------------------------");
  xil_printf("-----------------\r\n\r\n");

  //----------------------------------------------------
  // INITIALIZE INTERRUPT VECTOR TABLE
  //----------------------------------------------------
  xil_printf("  - Initializing interrupt vector table\r\n");
  // Initialize exception handling
  XExc_Init();
  XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT,
    (XExceptionHandler)MY_TIMER_Intr_Handler,
  (void *)XPAR_MY_TIMER_0_BASEADDR);

  //----------------------------------------------------
  // INITIALIZE THE TIMER PERIPHERAL
  //----------------------------------------------------
  xil_printf("  - Initializing the timer peripheral\r\n");
  // Check that the my_timer peripheral exists
  XASSERT_NONVOID(my_timer_p != XNULL);
  my_timer = (Xuint32) my_timer_p;
  // Load the delay register with the delay time of 0.5s
  MY_TIMER_mWriteSlaveReg0(my_timer, TIMER_HALFSEC);

  //----------------------------------------------------
  // SETUP THE LEDs
  //----------------------------------------------------
  xil_printf("  - Setting up the LEDs\r\n");
  // Initialize the GPIO driver
  status = XGpio_Initialize(&GpioOutput,
                            XPAR_LEDS_4BIT_DEVICE_ID);
  if (status != XST_SUCCESS)
    return XST_FAILURE;
  // Set the direction for all signals to be outputs
  XGpio_SetDataDirection(&GpioOutput, 1, 0x0);
  // Turn the LEDs ON
  XGpio_DiscreteWrite(&GpioOutput, 1, 0x0);

  //----------------------------------------------------
  // ENABLE INTERRUPTS
  //----------------------------------------------------
  xil_printf("  - Enabling interrupts\r\n");
  // Enable timer interrupts
  MY_TIMER_EnableInterrupt(my_timer_p);
  // Enable PowerPC non-critical interrupts
  XExc_mEnableExceptions(XEXC_NON_CRITICAL);

  // Start the timer
  xil_printf("  - Starting the timer\r\n\r\n");
  MY_TIMER_mWriteSlaveReg1(my_timer, TIMER_RUN);

  xil_printf("    SUCCESS!\r\n");
  while(1){
  }
}

Save and close the file.

Use the Default Linker Script

As mentioned earlier, the PowerPC requires an interrupt vector table to know what code to run when an interrupt occurs. The vector table resides in memory reserved by the linker script. The custom linker script for the TestApp_Peripheral application does not include a vector table, so we need to switch to the default linker script.

From the “Applications” tab and within “Project: TestApp_Peripheral”, right-click on “Compiler Options” and select “Set Compiler Options”.
Tick “Use default linker script” and click “OK”.

Download and Test the Project

Open a Hyperterminal window with the required settings. For the correct settings, see Hyperterminal Settings.
Turn on the XUPV2P board.
From the XPS software, select “Device Configuration->Download Bitstream”.

The Hyperterminal output should look as shown in the image below:

The LEDs should be flashing once every second. The timer peripheral is set for a delay period of half a second. Each call to the interrupt handler changes the state of the LEDs and resets the timer for another half a second. The result is that the LEDs remain ON for half a second and OFF for half a second.

The PowerPC has only one input for non-critical interrupt requests and in this project, we used it for our Timer peripheral. In a more complex design with multiple interrupts sources, we need to use an interrupt controller to multiplex all the interrupt request signals into one. This is the topic of the next tutorial.

The project folder for this tutorial can be downloaded in a compressed ZIP file TimerInterrupts.zip . Right-click on the link and select “Save Link As”.

interrupts timer

See also