SHARE
TWEET

Untitled

a guest Oct 16th, 2014 398 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2.  * Copyright (c) 2009 Xilinx, Inc.  All rights reserved.
  3.  *
  4.  * Xilinx, Inc.
  5.  * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
  6.  * COURTESY TO YOU.  BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
  7.  * ONE POSSIBLE   IMPLEMENTATION OF THIS FEATURE, APPLICATION OR
  8.  * STANDARD, XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION
  9.  * IS FREE FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE
  10.  * FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
  11.  * XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
  12.  * THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO
  13.  * ANY WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE
  14.  * FROM CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY
  15.  * AND FITNESS FOR A PARTICULAR PURPOSE.
  16.  *
  17.  */
  18.  
  19. /*
  20.  * helloworld.c: simple test application
  21.  */
  22. #include "xgpio.h"          // Provides access to PB GPIO driver.
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include "mb_interface.h"   // provides the microblaze interrupt enables, etc.
  26. #include "xintc_l.h"        // Provides handy macros for the interrupt controller.
  27. #include "platform.h"
  28. #include "xparameters.h"
  29. #include "xaxivdma.h"
  30. #include "xio.h"
  31. #include "time.h"
  32. #include "unistd.h"
  33. #include "bitmask.h"
  34. #include "globals.h"
  35. XGpio gpLED; // This is a handle for the LED GPIO block.
  36. XGpio gpPB; // This is a handle for the push-button GPIO block.
  37.  
  38. #define DEBUG
  39. void print(char *str);
  40.  
  41. #define FRAME_BUFFER_0_ADDR 0xC1000000  // Starting location in DDR where we will store the images that we display.
  42. direction tank_direction = RIGHT;
  43. int move_alien_right = 1;
  44. u32 currentButtonState;
  45. u16 debounce = 0;
  46. u32 LEFTSBTNPRESS = 0x8;
  47. u32 MIDDLESBTNPRESS = 0x1;
  48. u32 RIGHTBTNPRESS = 0x2;
  49. u32 UPBTNPRESS = 0x10;
  50. u32 DOWNBTNPRESS = 0x4;
  51. u16 button_delay = 0;
  52. u32 update_screen_delay = 0;
  53. u32 second_delay = 0;
  54. int alien_delay_speed = 100;
  55. int random = 0;
  56. int * tankDeath_symbol;
  57. int tank_dead_count;
  58. int gameOver = 0;
  59. int gameOverCount;
  60. int UFO_speed = 0;
  61. int bulletShotCount = 0;
  62. UFO ufo;
  63. unsigned int * framePointer;
  64.  
  65. void timer_interrupt_handler() {
  66.  
  67.         if (!gameOver) {
  68.                 UFO_speed++;
  69.                 button_delay++;
  70.                 update_screen_delay++;
  71.                 second_delay++;
  72.  
  73.                 if (button_delay == 2) {
  74.                         button_delay = 0;
  75.  
  76.                         if ((currentButtonState & LEFTSBTNPRESS) && !tank_hit) {
  77.                                 //Move Tank Left
  78.  
  79.                                 tank_direction = LEFT;
  80.                                 move_tank();
  81.  
  82.                         }
  83.  
  84.                         if ((currentButtonState & RIGHTBTNPRESS) && !tank_hit) {
  85.                                 //Move Tank Right
  86.  
  87.                                 tank_direction = RIGHT;
  88.                                 move_tank();
  89.                         }
  90.  
  91.                         if (currentButtonState & MIDDLESBTNPRESS) {
  92.                                 //Shoot Tank Bullet
  93.                                 shootTankBullet();
  94.                         }
  95.  
  96.                         if (currentButtonState & DOWNBTNPRESS) {
  97.                                 //Make UFO
  98.                                 spawnUFO();
  99.                         }
  100.  
  101.                         if(currentButtonState & UPBTNPRESS)
  102.                                 init(framePointer);
  103.                 }
  104.                 if (UFO_speed == 3) {
  105.                         UFO_speed = 0;
  106.  
  107.                                 moveUFO();
  108.  
  109.                 }
  110.  
  111.                 if (update_screen_delay % 128) {
  112.                         moveBullets();
  113.                         random++;
  114.                         if (random > 256) {
  115.                                 shootAlienBullet();
  116.                                 random = 0;
  117.                                 random = rand() % 256;
  118.  
  119.                                 bulletShotCount++;
  120.                         }
  121.                         if(bulletShotCount == 20){
  122.                                 spawnUFO();
  123.                                 bulletShotCount = 0;
  124.                         }
  125.                 }
  126.                 if (second_delay == 10) {
  127.                         //updateScore(5);
  128.                         second_delay = 0;
  129.                         if (ufoDie){
  130.                                 draw(ufo.pos.x, ufo.pos.y, blankAlienSymbol, ALIEN_WIDTH, ALIEN_HEIGHT,
  131.                                                                                 0x0000000);
  132.                                 ufoDie = 0;
  133.                                 if(ufo.ufo_direction == RIGHT){
  134.                                         ufo.ufo_direction = LEFT;
  135.                                 }
  136.                                 else{
  137.                                         ufo.ufo_direction = RIGHT;
  138.                                 }
  139.                                 //add score stuff
  140.                                 updateScore(69);
  141.                         }
  142.                         if (tank_hit) {
  143.                                 draw(tank.x, tank.y, blankAlienSymbol, TANK_WIDTH, TANK_HEIGHT,
  144.                                                 0x00000000); //clear
  145.                                 draw(tank.x, tank.y, tankDeath_symbol, TANK_WIDTH, TANK_HEIGHT,
  146.                                                 0x0000FF00); //draw 1
  147.                                 tank_dead_count++;
  148.                         }
  149.                         if (tankDeath_symbol == tankDeath_1) {
  150.                                 tankDeath_symbol = tankDeath_2;
  151.                         } else {
  152.                                 tankDeath_symbol = tankDeath_1;
  153.                         }
  154.                         if (tank_dead_count == 15) {
  155.                                 tank_hit = 0;
  156.                                 tank_dead_count = 0;
  157.                                 lives--;
  158.                                 updateLives();
  159.  
  160.                                 draw(tank.x, tank.y, blankAlienSymbol, TANK_WIDTH, TANK_HEIGHT,
  161.                                                 0x00000000); //clear
  162.                                 draw(tank.x, tank.y, tankSymbol, TANK_WIDTH, TANK_HEIGHT,
  163.                                                 0x000FF000); //clear
  164.                         }
  165.  
  166.                         if (lives == 0) {
  167.  
  168.                                 int row, column;
  169.                                 for (row = 0; row < 480; row++) {
  170.                                         for (column = 0; column < 640; column++) {
  171.  
  172.                                                 framePointer[row * 640 + column] = 0x00000000;
  173.  
  174.                                         }
  175.                                 }
  176.  
  177.                                 int x = 175;
  178.                                 int i = 0;
  179.                                 int * symbol;
  180.                                 for (i = 0; i < 9; i++) {
  181.  
  182.                                         switch (i) {
  183.                                         case 0:
  184.                                                 symbol = GO_G;
  185.                                                 break;
  186.                                         case 1:
  187.                                                 symbol = GO_A;
  188.                                                 break;
  189.                                         case 2:
  190.                                                 symbol = GO_M;
  191.                                                 break;
  192.                                         case 3:
  193.                                                 symbol = GO_E;
  194.                                                 break;
  195.                                         case 4:
  196.                                                 symbol = GO_Blank;
  197.                                                 break;
  198.                                         case 5:
  199.                                                 symbol = GO_O;
  200.                                                 break;
  201.                                         case 6:
  202.                                                 symbol = GO_V;
  203.                                                 break;
  204.                                         case 7:
  205.                                                 symbol = GO_E;
  206.                                                 break;
  207.                                         case 8:
  208.                                                 symbol = GO_R;
  209.                                                 break;
  210.                                         default:
  211.                                                 symbol = GO_G;
  212.  
  213.                                         }
  214.  
  215.                                         draw(x, 200, symbol, 32, 32, 0xFFFFFFF);
  216.                                         x += 35;
  217.                                 }
  218.  
  219.                                 gameOver = 1;
  220.  
  221.                                 //      XGpio_InterruptClear(&gpPB, 0xFFFFFFFF); // Ack the PB interrupt.
  222.                                 //XGpio_InterruptGlobalEnable(&gpPB); // Re-enable PB interrupts.
  223.                                 //init(framePointer);
  224.                         }
  225.  
  226.                 }
  227.  
  228.                 if (update_screen_delay >= alien_delay_speed) {
  229.                         move_aliens();
  230.                         update_screen_delay = 0;
  231.                 }
  232.         } else {
  233.                 gameOverCount++;
  234.  
  235.                 if (gameOverCount == 500) {
  236.                         gameOverCount = 0;
  237.                         gameOver = 0;
  238.                         init(framePointer);
  239.                 }
  240.  
  241.         }
  242. }
  243.  
  244. void pb_interrupt_handler() {
  245.  
  246.         // Clear the GPIO interrupt.
  247.         XGpio_InterruptGlobalDisable(&gpPB); // Turn off all PB interrupts for now.
  248.         currentButtonState = XGpio_DiscreteRead(&gpPB, 1); // Get the current state of the buttons.
  249.         // You need to do something here.
  250.  
  251.         //xil_printf("%x\n",currentButtonState);
  252.  
  253.  
  254.         XGpio_InterruptClear(&gpPB, 0xFFFFFFFF); // Ack the PB interrupt.
  255.         XGpio_InterruptGlobalEnable(&gpPB); // Re-enable PB interrupts.
  256. }
  257.  
  258. void interrupt_handler_dispatcher(void* ptr) {
  259.         int intc_status = XIntc_GetIntrStatus(XPAR_INTC_0_BASEADDR);
  260.         // Check the FIT interrupt first.
  261.         if (intc_status & XPAR_FIT_TIMER_0_INTERRUPT_MASK) {
  262.                 XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_FIT_TIMER_0_INTERRUPT_MASK);
  263.                 timer_interrupt_handler();
  264.         }
  265.         // Check the push buttons.
  266.         if (intc_status & XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK) {
  267.                 XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK);
  268.                 pb_interrupt_handler();
  269.         }
  270. }
  271.  
  272. int main() {
  273.  
  274.         srand(time(NULL));
  275.         init_platform(); // Necessary for all programs.
  276.         int Status; // Keep track of success/failure of system function calls.
  277.  
  278.         //VDMA SETUP
  279.         XAxiVdma videoDMAController;
  280.         // There are 3 steps to initializing the vdma driver and IP.
  281.         // Step 1: lookup the memory structure that is used to access the vdma driver.
  282.         XAxiVdma_Config * VideoDMAConfig = XAxiVdma_LookupConfig(
  283.                         XPAR_AXI_VDMA_0_DEVICE_ID);
  284.         // Step 2: Initialize the memory structure and the hardware.
  285.         if (XST_FAILURE == XAxiVdma_CfgInitialize(&videoDMAController,
  286.                         VideoDMAConfig, XPAR_AXI_VDMA_0_BASEADDR)) {
  287.                 xil_printf("VideoDMA Did not initialize.\r\n");
  288.         }
  289.         // Step 3: (optional) set the frame store number.
  290.         if (XST_FAILURE == XAxiVdma_SetFrmStore(&videoDMAController, 2,
  291.                         XAXIVDMA_READ)) {
  292.                 xil_printf("Set Frame Store Failed.");
  293.         }
  294.         // Initialization is complete at this point.
  295.  
  296.         // Setup the frame counter. We want two read frames. We don't need any write frames but the
  297.         // function generates an error if you set the write frame count to 0. We set it to 2
  298.         // but ignore it because we don't need a write channel at all.
  299.         XAxiVdma_FrameCounter myFrameConfig;
  300.         myFrameConfig.ReadFrameCount = 2;
  301.         myFrameConfig.ReadDelayTimerCount = 10;
  302.         myFrameConfig.WriteFrameCount = 2;
  303.         myFrameConfig.WriteDelayTimerCount = 10;
  304.         Status = XAxiVdma_SetFrameCounter(&videoDMAController, &myFrameConfig);
  305.         if (Status != XST_SUCCESS) {
  306.                 xil_printf("Set frame counter failed %d\r\n", Status);
  307.                 if (Status == XST_VDMA_MISMATCH_ERROR)
  308.                         xil_printf("DMA Mismatch Error\r\n");
  309.         }
  310.         // Now we tell the driver about the geometry of our frame buffer and a few other things.
  311.         // Our image is 480 x 640.
  312.         XAxiVdma_DmaSetup myFrameBuffer;
  313.         myFrameBuffer.VertSizeInput = 480; // 480 vertical pixels.
  314.         myFrameBuffer.HoriSizeInput = 640 * 4; // 640 horizontal (32-bit pixels).
  315.         myFrameBuffer.Stride = 640 * 4; // Dont' worry about the rest of the values.
  316.         myFrameBuffer.FrameDelay = 0;
  317.         myFrameBuffer.EnableCircularBuf = 1;
  318.         myFrameBuffer.EnableSync = 0;
  319.         myFrameBuffer.PointNum = 0;
  320.         myFrameBuffer.EnableFrameCounter = 0;
  321.         myFrameBuffer.FixedFrameStoreAddr = 0;
  322.         if (XST_FAILURE == XAxiVdma_DmaConfig(&videoDMAController, XAXIVDMA_READ,
  323.                         &myFrameBuffer)) {
  324.                 xil_printf("DMA Config Failed\r\n");
  325.         }
  326.         // We need to give the frame buffer pointers to the memory that it will use. This memory
  327.         // is where you will write your video data. The vdma IP/driver then streams it to the HDMI
  328.         // IP.
  329.         myFrameBuffer.FrameStoreStartAddr[0] = FRAME_BUFFER_0_ADDR;
  330.         myFrameBuffer.FrameStoreStartAddr[1] = FRAME_BUFFER_0_ADDR + 4 * 640 * 480;
  331.  
  332.         if (XST_FAILURE == XAxiVdma_DmaSetBufferAddr(&videoDMAController,
  333.                         XAXIVDMA_READ, myFrameBuffer.FrameStoreStartAddr)) {
  334.                 xil_printf("DMA Set Address Failed Failed\r\n");
  335.         }
  336.         // Print a sanity message if you get this far.
  337.         xil_printf("Woohoo! I made it through initialization.\n\r");
  338.         // Now, let's get ready to start displaying some stuff on the screen.
  339.         // The variables framePointer and framePointer1 are just pointers to the base address
  340.         // of frame 0 and frame 1.
  341.  
  342.         //unsigned int * framePointer = (unsigned int *) FRAME_BUFFER_0_ADDR;
  343.         framePointer = (unsigned int *) FRAME_BUFFER_0_ADDR;
  344.  
  345.         // Just paint some large red, green, blue, and white squares in different
  346.         // positions of the image for each frame in the buffer (framePointer0 and framePointer1).
  347.  
  348.  
  349.         init(framePointer);
  350.  
  351.         // This tells the HDMI controller the resolution of your display (there must be a better way to do this).
  352.         XIo_Out32(XPAR_AXI_HDMI_0_BASEADDR, 640*480);
  353.  
  354.         // Start the DMA for the read channel only.
  355.         if (XST_FAILURE == XAxiVdma_DmaStart(&videoDMAController, XAXIVDMA_READ)) {
  356.                 xil_printf("DMA START FAILED\r\n");
  357.         }
  358.         int frameIndex = 0;
  359.         // We have two frames, let's park on frame 0. Use frameIndex to index them.
  360.         // Note that you have to start the DMA process before parking on a frame.
  361.         if (XST_FAILURE == XAxiVdma_StartParking(&videoDMAController, frameIndex,
  362.                         XAXIVDMA_READ)) {
  363.                 xil_printf("vdma parking failed\n\r");
  364.         }
  365.         // Oscillate between frame 0 and frame 1.
  366.         //   int sillyTimer = MAX_SILLY_TIMER;  // Just a cheap delay between frames.
  367.  
  368.         //GPIO SETUP
  369.         int success;
  370.         success = XGpio_Initialize(&gpPB, XPAR_PUSH_BUTTONS_5BITS_DEVICE_ID);
  371.         // Set the push button peripheral to be inputs.
  372.         XGpio_SetDataDirection(&gpPB, 1, 0x0000001F);
  373.         // Enable the global GPIO interrupt for push buttons.
  374.         XGpio_InterruptGlobalEnable(&gpPB);
  375.         // Enable all interrupts in the push button peripheral.
  376.         XGpio_InterruptEnable(&gpPB, 0xFFFFFFFF);
  377.  
  378.         microblaze_register_handler(interrupt_handler_dispatcher, NULL);
  379.         XIntc_EnableIntr(XPAR_INTC_0_BASEADDR,
  380.                         (XPAR_FIT_TIMER_0_INTERRUPT_MASK | XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK));
  381.         XIntc_MasterEnable(XPAR_INTC_0_BASEADDR);
  382.         microblaze_enable_interrupts();
  383.  
  384.         while (1) {
  385.                 //char key_input = getKeyChar();
  386.                 //xil_printf("%c ", key_input);
  387.                 //processKeyPress(key_input);
  388.  
  389.                 if (XST_FAILURE == XAxiVdma_StartParking(&videoDMAController, 0,
  390.                                 XAXIVDMA_READ)) {
  391.                         xil_printf("vdma parking failed\n\r");
  392.                 }
  393.         }
  394.         cleanup_platform();
  395.  
  396.         return 0;
  397. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top