Bar
SpaceWire UK
Specialist providers of VHDL Intellectual Property & Design Services
BarBarBarBar
Tutorial
Missing Image!
Part 9 - Create & build 3rd software project

Introduction

This tutorial details the steps required for using Vitis to create & deploy a very simple ARM Cortex-A9 based bare metal software application to access the LED's and slide switches on the ZedBoard hardware.

Aims

The aims of this tutorial are as follows :-
  1. Setup environment
  2. Create project area
  3. Launch Vitis
  4. Create project
  5. Build platform
  6. Create new source file
  7. Build project
  8. Archive project

1. Setup environment

Setup Xilinx design environment for the 2020.2 toolset.
steve@Linux-Steve:/home/steve$ source xilinx.sh
Xilinx tools available tools at /opt/Xilinx :-
1) 2020.2 - Vivado - SDK - Vitis - PetaLinux
0) Exit
Please select tools required or exit : 1

Tools are as follows :-
vivado @ /opt/Xilinx/Vivado/2020.2/bin/vivado
vitis @ /opt/Xilinx/Vitis/2020.2/bin/vitis
petalinux-build @ /opt/Xilinx/PetaLinux/2020.2/tool/tools/common/petalinux/bin/petalinux-build

2. Create project area

Create the project directory along with a subdirectory for the software.
steve@Linux-Steve:/home/steve$ mkdir -p /home/steve/projects/leds_buttons/sw

3. Launch Vitis

Launch Vitis IDE and specify the new Workspace to use.
steve@Linux-Steve:/home/steve$ vitis -workspace /home/steve/projects/leds_buttons/sw &

4. Create project

The Vitis IDE : Welcome window will now appear. Create a project by clicking on Create Application Project under the Project heading. Missing Image! The New Application : Project Create a New Project window will now appear. Review the information provided and then click Next. Missing Image! The New Application Project : Platform window will now appear. Select the exported hardware platform from Vivado by entering the Create a new platform form hardware (XSA) tab and setting the XSA File to /home/steve/projects/leds_buttons/fw/system_wrapper.xsa. Click Next to continue. Missing Image! The New Application Project : Application Project Details window will now appear. Set the Application project name to leds_buttons and then click Next. Missing Image! The New Application Project : Domain window will now appear. The default settings as shown are fine for this project. Click Next to contune. Missing Image! The New Application Project : Templates window will now appear. Create an empty application by selecting Empty Application from the Available Templates section. Click Finish to contune. Missing Image! The Vitis IDE cockpit window will now appear. This is the window where all the action happens. Missing Image!

5. Build platform

Build the platform by right clicking on system_wrapper inside the Explorer tab and selecting Build Project. Missing Image!

6. Create new source file

Create a new source file inside the leds_buttons application project. Right click on src then select New » File. Missing Image! In the Create New File dialog set the File name to leds_buttons.c and click Finish to continue. Missing Image! The new source file is automatically opened in the Vitis IDE for editing. Missing Image! Copy the code below into the newly created leds_buttons.c and save it by selecting File » Save from the main menu.

leds_buttons.c

  1. //
  2. // Includes
  3. //
  4. #include "xparameters.h"
  5. #include "xgpio.h"
  6. #include "xscugic.h"
  7. #include "xil_exception.h"
  8. #include <stdio.h>


  11. //
  12. // Defines
  13. //
  14. #define CHANNEL_LEDS 1
  15. #define CHANNEL_BTNS 2

  17. #define BUTTON_CENTER 0x01
  18. #define BUTTON_DOWN   0x02
  19. #define BUTTON_LEFT   0x04
  20. #define BUTTON_RIGHT  0x08
  21. #define BUTTON_UP     0x10

  23. //
  24. // Global Variables
  25. //
  26. static XScuGic Intc;


  29. //
  30. // Instances
  31. //
  32. XGpio Gpio;


  35. //
  36. // Rotate right
  37. //
  38. u8 ror(u8 num) {
  39.   return (num >> 1) | (num << 7);
  40. }


  43. //
  44. // Rotate left
  45. //
  46. u8 rol(u8 num) {
  47.   return (num << 1) | (num >> 7);
  48. }


  51. //
  52. // Interrupt service routine
  53. //
  54. void GpioIsr(void *InstancePtr)
  55. {
  56.   u32 btns;
  57.   u32 leds;
  58.   u8 width = 0;

  60.   XGpio *GpioPtr = (XGpio *)InstancePtr;

  62.   // Disable button interrupts
  63.   XGpio_InterruptDisable(GpioPtr, XGPIO_IR_CH2_MASK);

  65.   // Only deal with button interrupts
  66.   if ((XGpio_InterruptGetStatus(GpioPtr) & XGPIO_IR_CH2_MASK) != XGPIO_IR_CH2_MASK) {
  67.     return;
  68.   }

  70.   // Obtain register values for LED's & buttons
  71.   leds = XGpio_DiscreteRead(&Gpio, CHANNEL_LEDS);
  72.   btns = XGpio_DiscreteRead(&Gpio, CHANNEL_BTNS);

  74.   // Print button status
  75.   xil_printf("ISR called, button register = 0x%x\n\r", btns);

  77.   // Determine LED bar width
  78.   for (u8 i=0; i<=7; i++) {
  79.     if ((0b00000001 << i) & leds) {
  80.       width++;
  81.     }
  82.   }

  84.   // Handle button functionality
  85.   switch (btns) {

  87.     // Set LED bar width to 4
  88.     case BUTTON_CENTER :
  89.       leds = 0b00111100;
  90.       break;

  92.     // Rotate LED's left
  93.     case BUTTON_LEFT :
  94.       if (width == 0) {
  95.         leds = 0b00000001;
  96.       } else {
  97.         leds = (u8)rol(leds);
  98.       }
  99.       break;

  101.     // Rotate LED's right
  102.     case BUTTON_RIGHT :
  103.       if (width == 0) {
  104.         leds = 0b10000000;
  105.       } else {
  106.         leds = (u8)ror(leds);
  107.       }
  108.       break;

  110.     // Increase illuminated LED's
  111.     case BUTTON_UP :
  112.       if (width == 0) {
  113.      leds = 0b00001000;
  114.       } else if (width & 1) {
  115.         leds = leds | rol(leds);
  116.       } else {
  117.         leds = leds | ror(leds);
  118.       }
  119.       break;

  121.     // Decrease illuminated LED's
  122.     case BUTTON_DOWN :
  123.       if (width == 8) {
  124.      leds = 0b01111111;
  125.       } else if (width & 1) {
  126.         leds = leds & rol(leds);
  127.       } else {
  128.         leds = leds & ror(leds);
  129.       }
  130.       break;

  132.     // Do nothing
  133.     default:
  134.       break;
  135.   }

  137.   // Update LED's
  138.   XGpio_DiscreteWrite(&Gpio, CHANNEL_LEDS, leds);

  140.   // Clear pending interrupts
  141.   XGpio_InterruptClear(GpioPtr, XGPIO_IR_CH2_MASK);

  143.   // Enable button interrupts
  144.   XGpio_InterruptEnable(GpioPtr, XGPIO_IR_CH2_MASK);
  145. }


  148. //
  149. // Setup interrupt system
  150. //
  151. int SetupInterruptSystem()
  152. {
  153.   int Result;
  154.   XScuGic *IntcInstancePtr = &Intc;

  156.   XScuGic_Config *IntcConfig;

  158.   // Initialise interrupt controller
  159.   IntcConfig = XScuGic_LookupConfig(XPAR_PS7_SCUGIC_0_DEVICE_ID);
  160.   if (NULL == IntcConfig) {
  161.     return XST_FAILURE;
  162.   }

  164.   // Comment
  165.   Result = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig, IntcConfig->CpuBaseAddress);
  166.   if (Result != XST_SUCCESS) {
  167.     return XST_FAILURE;
  168.   }

  170.   // Comment
  171.   XScuGic_SetPriorityTriggerType(IntcInstancePtr, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR, 0xA0, 0x3);

  173.   // Connect interrupt handler
  174.   Result = XScuGic_Connect(IntcInstancePtr, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR, (Xil_ExceptionHandler)GpioIsr, &Gpio);
  175.   if (Result != XST_SUCCESS) {
  176.     return Result;
  177.   }

  179.   // Enable GPIO interrupt
  180.   XScuGic_Enable(IntcInstancePtr, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR);

  182.   // Enable button interrupts
  183.   XGpio_InterruptEnable(&Gpio, XGPIO_IR_CH2_MASK);

  185.   // Enable GPIO interrupts
  186.   XGpio_InterruptGlobalEnable(&Gpio);

  188.   // Initialise the exception table
  189.   Xil_ExceptionInit();

  191.   // Register interrupt controller handle with exception table
  192.   Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XScuGic_InterruptHandler, IntcInstancePtr);

  194.   // Enable non-critical exceptions
  195.   Xil_ExceptionEnable();

  197.   return XST_SUCCESS;
  198. }


  201. //
  202. // Main function
  203. //
  204. int main(void)
  205. {
  206.   int Status;

  208.   // Initialise GPIO driver
  209.   Status = XGpio_Initialize(&Gpio, XPAR_AXI_GPIO_0_DEVICE_ID);
  210.   if (Status != XST_SUCCESS) {
  211.     return XST_FAILURE;
  212.   }

  214.   // Clear LED's
  215.   XGpio_DiscreteWrite(&Gpio, CHANNEL_LEDS, 0);

  217.   // Setup interrupt system
  218.   Status = SetupInterruptSystem();
  219.   if (Status != XST_SUCCESS) {
  220.     return XST_FAILURE;
  221.   }

  223.   // Print header
  224.   print("--== LED & Push Buttons interrupt example ==--\n\n\r");
  225.   print("Use the buttons to control the LED's :-\n\n\r");
  226.   print("Centre - Reset LED's to 00111100\n\r");
  227.   print("Left   - Rotate LED's left\n\r");
  228.   print("Right  - Rotate LED's right\n\r");
  229.   print("Up     - Increase illuminated LED's\n\r");
  230.   print("Down   - Decrease illuminated LED's\n\n\r");
  231.   print("Press enter key to quit application\n\r");

  233.   // Wait for user input
  234.   getc(stdin);

  236.   // Clear LED's
  237.   XGpio_DiscreteWrite(&Gpio, CHANNEL_LEDS, 0);

  239.   // Print footer
  240.   print("All done!\n\n\r");

  242.   return XST_SUCCESS;
  243. }

7. Build project

Build the project by right clicking on leds_buttons under leds_buttons_system inside the Explorer tab and selecting Build Project. Missing Image!

8. Archive project

Create an archive so the project can be regenerated and revision controlled (optional). Select File » Export... from the main menu. In the Export Vitis Projects dialog set Archive File to vitis_export_archive.ide.zip, set Directory to /home/steve/projects/leds_buttons and tick System Projects & Platform Projects. Click OK to continue. Missing Image! In the Export Vitis Projects status dialog click OK to continue. Missing Image! Add the file /home/steve/projects/leds_buttons/vitis_export_archive.ide.zip to the revision control system & commit (optional).
Copyright © 2004-2021 SpaceWire UK. All rights reserved.