When we built the MicroBlaze system we included the ability to handle interrupts by the inclusion of an AXI Interrupt controller. This is connected to the interrupt input on the MicroBlaze controller each AXI interrupt controller is capable of supporting up to 32 interrupts. However, we can cascade the interrupt controllers to support up to 96 interrupts for each MicroBlaze instantiation.
Within the system we created in our first blog , we had two interrupts one from the AXI UART lite and a second from the AXI Timer.
The interrupt signal from both the timer and UART are concatenated into a bus using the concatenate block as can be seen above. The intr input on the AXI interrupt shown above as intr[1:0] will scale automatically depending upon the size of the buss connected to it. To use all 32 interrupts use a 32 input bit concatenate block, when you next click on validate you will see the intr input width on the AXI Interrupt block update automatically to the correct width.
The AXI controller is very simple then containing a number of 32 bit registers such as interrupt status, pending, enable and clear registers along with interrupt vector addresses to manage the 32 interrupts.
Within the AXI interrupt block we can customise its behaviour, most importantly we can select if we want the interrupts to be level triggered and active high or low.
Once we have configured the hardware as we desire we can build the hardware and export the hardware to SDK if we have not already done this previously.
Within SDK we can create a simple programme which enable us to configure and initialise the AXI interrupt controller and simulate a timer interrupt occurring. Taking this approach allows us to verify in stages our use of interrupts, this stage allows us to demonstrate that we have correctly configured the interrupt controller. Satisfied that this is working OK we can then configure the timer to function and generate interrupts later on.
The first thing we need to do within our software application is include the correct libraries for this example we will need the following
- stdio.h – Contains the standard input and output functions
- platform.h – Defines the initialisation and tidy up routines for the MicroBlaze
- xparameters.h – Contains the address and configurations of need for the system
- xstatus.h – Contains the status definitions used
- xintc.h – Contains the API for using the AI interrupt controller
- xil_exception.h – Contains the API for MicroBlaze exceptions
With the correct libraries included the next stage is to write three functions
- Interrupt Example – This one is called from the main() function and controls the demonstration
- Interrupt set up – A standalone function which configures the AXI interrupt controller and the microblaze exceptions
- Interrupt Service Routine (ISR) – This is the function called when the interrupt occurs
As this is a simulated interrupt the ISR simply terminates the programme after printing a message out over the UART when I ran this I got the following output on my terminal.
I have added the software application I wrote to my GIT Hub repository for download if you want it. The next blog on the ARTY will look at the using the AXI timer and the determining the interrupt latency.