API tools faq
paste
Advertisement
Guest User

Genstart

a guest
Jan 16th, 2018
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.30 KB | None | 0 0
raw download clone embed print report
  1. #include "../../Crazy-driver/src/video_demo.h"
  2.  
  3. #include <stdio.h>
  4. #include "xuartps.h"
  5. #include "math.h"
  6. #include <ctype.h>
  7. #include <stdlib.h>
  8. #include "xil_types.h"
  9. #include "xil_cache.h"
  10. #include "xparameters.h"
  11. #include <stdio.h>
  12. #include "xtime_l.h"
  13. #include "xgpio.h"
  14. #include "xscugic.h"
  15. #include <unistd.h>
  16.  
  17. #include "../../Crazy-driver/src/display_ctrl/display_ctrl.h"
  18. #include "../../Crazy-driver/src/intc/intc.h"
  19. #include "../../Crazy-driver/src/timer_ps/timer_ps.h"
  20. #include "../../Crazy-driver/src/video_capture/video_capture.h"
  21. #include "xtmrctr.h"
  22.  
  23. Farve red={255,0,0};
  24. Farve sort = {192,192,192};
  25.  
  26. /*
  27. * XPAR redefines
  28. */
  29. #define DYNCLK_BASEADDR XPAR_AXI_DYNCLK_0_BASEADDR
  30. #define VGA_VDMA_ID XPAR_AXIVDMA_0_DEVICE_ID
  31. #define DISP_VTC_ID XPAR_VTC_0_DEVICE_ID
  32. #define VID_VTC_ID XPAR_VTC_1_DEVICE_ID
  33. #define VID_GPIO_ID XPAR_AXI_GPIO_VIDEO_DEVICE_ID
  34. #define VID_VTC_IRPT_ID XPS_FPGA3_INT_ID
  35. #define VID_GPIO_IRPT_ID XPS_FPGA4_INT_ID
  36. #define SCU_TIMER_ID XPAR_SCUTIMER_DEVICE_ID
  37. #define UART_BASEADDR XPAR_PS7_UART_1_BASEADDR
  38.  
  39. #define BTNS_DEVICE_ID XPAR_AXI_GPIO_BTN_DEVICE_ID
  40. #define LEDS_DEVICE_ID XPAR_AXI_GPIO_LED_DEVICE_ID
  41. #define INTC_GPIO_INTERRUPT_ID XPAR_FABRIC_AXI_GPIO_BTN_IP2INTC_IRPT_INTR
  42. #define INTC_TMR_INTERRUPT_ID XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR
  43. #define BTN_INT XGPIO_IR_CH1_MASK
  44.  
  45. /* ------------------------------------------------------------ */
  46. /* Global Variables */
  47. /* ------------------------------------------------------------ */
  48. char userInput = 0;
  49. int playeNewPos;
  50. int player_pos = 220;
  51.  
  52.  
  53. int GameStartet = 0;
  54.  
  55.  
  56. int score = 0;
  57. int highScore = 0;
  58.  
  59.  
  60. int ra1;
  61. int ra2;
  62. int ra3;
  63. int ra4;
  64.  
  65. int r1 = 5;
  66. int r2 = 8;
  67. int r3 = 10;
  68. int r4 = 5;
  69.  
  70.  
  71. int enemySpeedCounter1;
  72. int enemySpeedCounter2;
  73. int enemySpeedCounter3;
  74. int enemySpeedCounter4;
  75.  
  76.  
  77.  
  78. int speedUp = 0;
  79. int speed1 = 5;
  80. int speed2 = 8;
  81. int speed3 = 11;
  82.  
  83.  
  84. int Enemy_X4 = 800;
  85. int Enemy4_wGreen = 0;
  86. int Enemy4_wRed = 255;
  87. int Enemy4_wBlue = 0;
  88. int enemy_y4 = 300;
  89.  
  90.  
  91. int Enemy_X3 = 800;
  92. int Enemy3_wGreen = 0;
  93. int Enemy3_wRed = 255;
  94. int Enemy3_wBlue = 0;
  95. int enemy_y3 = 260;
  96.  
  97.  
  98. int Enemy_X2 = 1200;
  99. int Enemy2_wGreen = 0;
  100. int Enemy2_wRed = 255;
  101. int Enemy2_wBlue = 0;
  102. int enemy_y2 = 220;
  103.  
  104.  
  105. int Enemy_wGreen = 0;
  106. int Enemy_wRed = 255;
  107. int Enemy_wBlue = 0;
  108. int enemy_y = 180;
  109. int Enemy_X = 1200;
  110.  
  111. int Enemy_y_size = 10;
  112. int Enemy_x_size = 40;
  113.  
  114. int value = 1;
  115.  
  116.  
  117. XGpio LEDInst, BTNInst;
  118. XScuGic INTCInst;
  119. int SpilStartet;
  120. int r;
  121. int r2;
  122. int x=5;
  123. int led_data;
  124. int btn_value;
  125.  
  126. /*
  127. * Display and Video Driver structs
  128. */
  129. DisplayCtrl dispCtrl;
  130. XAxiVdma vdma;
  131. VideoCapture videoCapt;
  132. INTC intc;
  133. char fRefresh; //flag used to trigger a refresh of the Menu on video detect
  134.  
  135.  
  136.  
  137.  
  138. int randomCount;
  139. int count;
  140.  
  141. /* ------------------------------------------------------------ */
  142. /* PROTOTYPE Definitions */
  143. /* ------------------------------------------------------------ */
  144. void Int_Handler(void *InstancePtr);
  145. void BTN_Intr_Handler(void *baseaddr_p);
  146. void TMR_Intr_Handler(void *InstancePtr, u8 TmrCtrNumber);
  147. int InterruptSystemSetup(XScuGic *XScuGicInstancePtr);
  148. int IntcInitFunction(u16 DeviceId, XGpio *GpioInstancePtr);
  149.  
  150. /*
  151. * Framebuffers for video data
  152. */
  153. u8 frameBuf[DISPLAY_NUM_FRAMES][DEMO_MAX_FRAME];
  154. u8 *pFrames[DISPLAY_NUM_FRAMES]; //array of pointers to the frame buffers
  155.  
  156. /*
  157. * Interrupt vector table
  158. */
  159. const ivt_t ivt[] = {
  160. videoGpioIvt(VID_GPIO_IRPT_ID, &videoCapt),
  161. videoVtcIvt(VID_VTC_IRPT_ID, &(videoCapt.vtc)),
  162. {66, (XInterruptHandler)Int_Handler, NULL, 0xA0, 0x3}
  163. };
  164.  
  165. void XTmrCtr_ClearInterruptFlag(XTmrCtr * InstancePtr, u8 TmrCtrNumber)
  166. {
  167. u32 CounterControlReg;
  168.  
  169. Xil_AssertVoid(InstancePtr != NULL);
  170. Xil_AssertVoid(TmrCtrNumber < XTC_DEVICE_TIMER_COUNT);
  171. Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
  172.  
  173. /*
  174. * Read current contents of the CSR register so it won't be destroyed
  175. */
  176. CounterControlReg = XTmrCtr_ReadReg(InstancePtr->BaseAddress,
  177. TmrCtrNumber, XTC_TCSR_OFFSET);
  178. /*
  179. * Reset the interrupt flag
  180. */
  181. XTmrCtr_WriteReg(InstancePtr->BaseAddress, TmrCtrNumber,
  182. XTC_TCSR_OFFSET,
  183. CounterControlReg | XTC_CSR_INT_OCCURED_MASK);
  184. }
  185.  
  186.  
  187. void BTN_Intr_Handler(void *InstancePtr)
  188. {
  189.  
  190. // Disable GPIO interrupts
  191. XGpio_InterruptDisable(&BTNInst, BTN_INT);
  192. // Ignore additional button presses
  193. if ((XGpio_InterruptGetStatus(&BTNInst) & BTN_INT) !=
  194. BTN_INT)
  195. { return;
  196. }
  197.  
  198. btn_value = XGpio_DiscreteRead(&BTNInst, 1);
  199.  
  200. if ( btn_value == 8) {
  201. value = 1;
  202. userInput = '1';
  203.  
  204. }
  205.  
  206.  
  207.  
  208. XGpio_DiscreteWrite(&LEDInst, 1, led_data);
  209. (void)XGpio_InterruptClear(&BTNInst, BTN_INT);
  210. // Enable GPIO interrupts
  211. XGpio_InterruptEnable(&BTNInst, BTN_INT);
  212. }
  213.  
  214.  
  215.  
  216.  
  217. /* ------------------------------------------------------------ */
  218. /* Procedure Definitions */
  219. /* ------------------------------------------------------------ */
  220. int a=1;
  221. int main(void)
  222. {
  223.  
  224.  
  225. int status;
  226. XTmrCtr TMRInst;
  227. //----------------------------------------------------
  228. // INITIALIZE THE PERIPHERALS & SET DIRECTIONS OF GPIO
  229. //----------------------------------------------------
  230. // Initialise LEDs
  231. status = XGpio_Initialize(&LEDInst, LEDS_DEVICE_ID);
  232. if(status != XST_SUCCESS) return XST_FAILURE;
  233. // Initialise Push Buttons
  234. status = XGpio_Initialize(&BTNInst, BTNS_DEVICE_ID);
  235. if(status != XST_SUCCESS) return XST_FAILURE;
  236. // Set LEDs direction to outputs
  237. XGpio_SetDataDirection(&LEDInst, 1, 0x00);
  238. // Set all buttons direction to inputs
  239. XGpio_SetDataDirection(&BTNInst, 1, 0xFF);
  240. status = IntcInitFunction(INTC_DEVICE_ID, &BTNInst);
  241. if (status != XST_SUCCESS) return XST_FAILURE;
  242.  
  243.  
  244.  
  245. DemoInitialize();
  246. u8* frame = &frameBuf[0];
  247. PlayerBox(frame,50,220,40,10,1);
  248. DisplayChangeFrame(&dispCtrl, 0);
  249.  
  250.  
  251.  
  252. while(1){
  253. switch (value)
  254. {
  255. case 1:
  256. xil_printf("\n\rVelkommen til Crazy Driver!");
  257. xil_printf("\n\rTryk på button 8 for at starte.");
  258. xil_printf("\n\rTryk på button 1 for at bevæge dig op.");
  259. xil_printf("\n\rTryk på button 2 for at bevæge dig ned.");
  260. xil_printf("\n\rHeld og lykke!");
  261. userInput = 0;
  262. GameStartet = 0;
  263. GenstartEnemy();
  264. score=0;
  265.  
  266. StartSpil();
  267.  
  268. PlayerBox(frame,50,220,40,10,1);
  269. Input();
  270.  
  271.  
  272.  
  273.  
  274. while(userInput != '2') {
  275.  
  276.  
  277.  
  278. Input();
  279.  
  280.  
  281. if(GameStartet == 1) {
  282.  
  283. CompareAdjustSpeed();
  284.  
  285. EnemySpeed1();
  286. tegn_box(frame,Enemy_X,enemy_y,40,10,sort);
  287. MoveEnemy1();
  288. tegn_box(frame,Enemy_X,enemy_y,40,10,red);
  289.  
  290. EnemySpeed2();
  291. tegn_box(frame,Enemy_X2,enemy_y2,40,10,sort);
  292. MoveEnemy2();
  293. tegn_box(frame,Enemy_X2,enemy_y2,40,10,red);
  294.  
  295. EnemySpeed3();
  296. tegn_box(frame,Enemy_X3,enemy_y3,40,10,sort);
  297. MoveEnemy3();
  298. tegn_box(frame,Enemy_X3,enemy_y3,40,10,red);
  299.  
  300. EnemySpeed4();
  301. tegn_box(frame,Enemy_X4,enemy_y4,40,10,sort);
  302. MoveEnemy4();
  303. tegn_box(frame,Enemy_X4,enemy_y4,40,10,red);
  304.  
  305.  
  306. HitDetection();
  307.  
  308. speedUp++;
  309. score++;
  310. xil_printf("\n\rScore: %d", score);
  311.  
  312. if(score > highScore) {
  313. highScore = score;
  314. }
  315.  
  316. }
  317. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  318.  
  319.  
  320.  
  321.  
  322. //xil_printf("test\n\r");
  323. usleep(16000);
  324.  
  325. }
  326. break;
  327.  
  328. case 2:
  329. xil_printf("\n\rVelkommen til Crazy Driver!");
  330. xil_printf("\n\rTryk på button 8 for at starte.");
  331. xil_printf("\n\rTryk på button 1 for at bevæge dig op.");
  332. xil_printf("\n\rTryk på button 2 for at bevæge dig ned.");
  333. xil_printf("\n\rHeld og lykke!");
  334. userInput = 0;
  335. GameStartet = 0;
  336. score=0;
  337.  
  338.  
  339. GenstartEnemy();
  340.  
  341. StartSpil();
  342. player_pos = 220;
  343. PlayerBox(frame,50,220,40,10,1);
  344. Input();
  345.  
  346.  
  347. while(userInput != '2') {
  348.  
  349.  
  350.  
  351. Input();
  352.  
  353.  
  354. if(GameStartet == 1) {
  355.  
  356. CompareAdjustSpeed();
  357.  
  358. EnemySpeed1();
  359. tegn_box(frame,Enemy_X,enemy_y,40,10,sort);
  360. MoveEnemy1();
  361. tegn_box(frame,Enemy_X,enemy_y,40,10,red);
  362.  
  363. EnemySpeed2();
  364. tegn_box(frame,Enemy_X2,enemy_y2,40,10,sort);
  365. MoveEnemy2();
  366. tegn_box(frame,Enemy_X2,enemy_y2,40,10,red);
  367.  
  368. EnemySpeed3();
  369. tegn_box(frame,Enemy_X3,enemy_y3,40,10,sort);
  370. MoveEnemy3();
  371. tegn_box(frame,Enemy_X3,enemy_y3,40,10,red);
  372.  
  373. EnemySpeed4();
  374. tegn_box(frame,Enemy_X4,enemy_y4,40,10,sort);
  375. MoveEnemy4();
  376. tegn_box(frame,Enemy_X4,enemy_y4,40,10,red);
  377.  
  378.  
  379. HitDetection2();
  380.  
  381. speedUp++;
  382. score++;
  383. xil_printf("\n\rScore: %d", score);
  384.  
  385. if(score > highScore) {
  386. highScore = score;
  387. }
  388.  
  389. }
  390. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  391.  
  392. //xil_printf("test\n\r");
  393. usleep(16000);
  394. }
  395.  
  396. break;
  397.  
  398. default :
  399. xil_printf("\n\rInvalid Selection");
  400. TimerDelay(500000);
  401.  
  402. break;
  403.  
  404. }
  405.  
  406.  
  407.  
  408. }
  409. }
  410.  
  411.  
  412.  
  413. void Int_Handler(void *InstancePtr){
  414.  
  415. enemySpeedCounter1++;
  416. enemySpeedCounter2++;
  417. enemySpeedCounter3++;
  418. enemySpeedCounter4++;
  419.  
  420.  
  421. //xil_printf("%d\n\r", enemySpeedCounter3);
  422.  
  423.  
  424. }
  425.  
  426.  
  427.  
  428.  
  429.  
  430. void DemoInitialize()
  431. {
  432. int Status;
  433. XAxiVdma_Config *vdmaConfig;
  434. int i;
  435.  
  436. /*
  437. * Initialize an array of pointers to the 3 frame buffers
  438. */
  439. for (i = 0; i < DISPLAY_NUM_FRAMES; i++)
  440. {
  441. pFrames[i] = frameBuf[i];
  442. }
  443.  
  444. /*
  445. * Initialize a timer used for a simple delay
  446. */
  447. TimerInitialize(SCU_TIMER_ID);
  448.  
  449. /*
  450. * Initialize VDMA driver
  451. */
  452. vdmaConfig = XAxiVdma_LookupConfig(VGA_VDMA_ID);
  453. if (!vdmaConfig)
  454. {
  455. xil_printf("No video DMA found for ID %d\r\n", VGA_VDMA_ID);
  456. return;
  457. }
  458. Status = XAxiVdma_CfgInitialize(&vdma, vdmaConfig, vdmaConfig->BaseAddress);
  459. if (Status != XST_SUCCESS)
  460. {
  461. xil_printf("VDMA Configuration Initialization failed %d\r\n", Status);
  462. return;
  463. }
  464.  
  465. /*
  466. * Initialize the Display controller and start it
  467. */
  468. Status = DisplayInitialize(&dispCtrl, &vdma, DISP_VTC_ID, DYNCLK_BASEADDR, pFrames, DEMO_STRIDE);
  469. if (Status != XST_SUCCESS)
  470. {
  471. xil_printf("Display Ctrl initialization failed during demo initialization%d\r\n", Status);
  472. return;
  473. }
  474. Status = DisplayStart(&dispCtrl);
  475. if (Status != XST_SUCCESS)
  476. {
  477. xil_printf("Couldn't start display during demo initialization%d\r\n", Status);
  478. return;
  479. }
  480.  
  481.  
  482. /*
  483. * Initialize the Video Capture device
  484. */
  485. Status = VideoInitialize(&videoCapt, &intc, &vdma, VID_GPIO_ID, VID_VTC_ID, VID_VTC_IRPT_ID, pFrames, DEMO_STRIDE, DEMO_START_ON_DET);
  486. if (Status != XST_SUCCESS)
  487. {
  488. xil_printf("Video Ctrl initialization failed during demo initialization%d\r\n", Status);
  489. return;
  490. }
  491.  
  492. /*
  493. * Set the Video Detect callback to trigger the menu to reset, displaying the new detected resolution
  494. */
  495.  
  496. VideoSetCallback(&videoCapt, DemoISR, &fRefresh);
  497.  
  498.  
  499. StartSpil();
  500.  
  501. return;
  502.  
  503.  
  504. }
  505.  
  506.  
  507.  
  508.  
  509. void DemoInvertFrame(u8 *srcFrame, u8 *destFrame, u32 width, u32 height, u32 stride)
  510. {
  511. u32 xcoi, ycoi;
  512. u32 lineStart = 0;
  513. for(ycoi = 0; ycoi < height; ycoi++)
  514. {
  515. for(xcoi = 0; xcoi < (width * 3); xcoi+=3)
  516. {
  517. destFrame[xcoi + lineStart] = ~srcFrame[xcoi + lineStart]; //Red
  518. destFrame[xcoi + lineStart + 1] = ~srcFrame[xcoi + lineStart + 1]; //Blue
  519. destFrame[xcoi + lineStart + 2] = ~srcFrame[xcoi + lineStart + 2]; //Green
  520. }
  521. lineStart += stride;
  522. }
  523. /*
  524. * Flush the framebuffer memory range to ensure changes are written to the
  525. * actual memory, and therefore accessible by the VDMA.
  526. */
  527. Xil_DCacheFlushRange((unsigned int) destFrame, DEMO_MAX_FRAME);
  528. }
  529.  
  530.  
  531. /*
  532. * Bilinear interpolation algorithm. Assumes both frames have the same stride.
  533. */
  534. void DemoScaleFrame(u8 *srcFrame, u8 *destFrame, u32 srcWidth, u32 srcHeight, u32 destWidth, u32 destHeight, u32 stride)
  535. {
  536. float xInc, yInc; // Width/height of a destination frame pixel in the source frame coordinate system
  537. float xcoSrc, ycoSrc; // Location of the destination pixel being operated on in the source frame coordinate system
  538. float x1y1, x2y1, x1y2, x2y2; //Used to store the color data of the four nearest source pixels to the destination pixel
  539. int ix1y1, ix2y1, ix1y2, ix2y2; //indexes into the source frame for the four nearest source pixels to the destination pixel
  540. float xDist, yDist; //distances between destination pixel and x1y1 source pixels in source frame coordinate system
  541.  
  542. int xcoDest, ycoDest; // Location of the destination pixel being operated on in the destination coordinate system
  543. int iy1; //Used to store the index of the first source pixel in the line with y1
  544. int iDest; //index of the pixel data in the destination frame being operated on
  545.  
  546. int i;
  547.  
  548. xInc = ((float) srcWidth - 1.0) / ((float) destWidth);
  549. yInc = ((float) srcHeight - 1.0) / ((float) destHeight);
  550.  
  551. ycoSrc = 0.0;
  552. for (ycoDest = 0; ycoDest < destHeight; ycoDest++)
  553. {
  554. iy1 = ((int) ycoSrc) * stride;
  555. yDist = ycoSrc - ((float) ((int) ycoSrc));
  556.  
  557. /*
  558. * Save some cycles in the loop below by presetting the destination
  559. * index to the first pixel in the current line
  560. */
  561. iDest = ycoDest * stride;
  562.  
  563. xcoSrc = 0.0;
  564. for (xcoDest = 0; xcoDest < destWidth; xcoDest++)
  565. {
  566. ix1y1 = iy1 + ((int) xcoSrc) * 3;
  567. ix2y1 = ix1y1 + 3;
  568. ix1y2 = ix1y1 + stride;
  569. ix2y2 = ix1y1 + stride + 3;
  570.  
  571. xDist = xcoSrc - ((float) ((int) xcoSrc));
  572.  
  573. /*
  574. * For loop handles all three colors
  575. */
  576. for (i = 0; i < 3; i++)
  577. {
  578. x1y1 = (float) srcFrame[ix1y1 + i];
  579. x2y1 = (float) srcFrame[ix2y1 + i];
  580. x1y2 = (float) srcFrame[ix1y2 + i];
  581. x2y2 = (float) srcFrame[ix2y2 + i];
  582.  
  583. /*
  584. * Bilinear interpolation function
  585. */
  586. destFrame[iDest] = (u8) ((1.0-yDist)*((1.0-xDist)*x1y1+xDist*x2y1) + yDist*((1.0-xDist)*x1y2+xDist*x2y2));
  587. iDest++;
  588. }
  589. xcoSrc += xInc;
  590. }
  591. ycoSrc += yInc;
  592. }
  593.  
  594. /*
  595. * Flush the framebuffer memory range to ensure changes are written to the
  596. * actual memory, and therefore accessible by the VDMA.
  597. */
  598. Xil_DCacheFlushRange((unsigned int) destFrame, DEMO_MAX_FRAME);
  599.  
  600. return;
  601. }
  602.  
  603.  
  604. void Input(){
  605.  
  606. fRefresh = 0;
  607.  
  608. /* Store the first character in the UART receive FIFO and echo it */
  609. if (XUartPs_IsReceiveData(UART_BASEADDR))
  610. {
  611. btn_value = XUartPs_ReadReg(UART_BASEADDR, XUARTPS_FIFO_OFFSET);
  612. xil_printf("%c", userInput);
  613. }
  614. else //Refresh triggered by video detect interrupt
  615. {
  616. userInput = 'r';
  617. }
  618.  
  619.  
  620.  
  621.  
  622. if(btn_value == 1){
  623. PlayerMove(1);
  624. btn_value = 0;
  625.  
  626.  
  627. }
  628.  
  629.  
  630. if(btn_value == 2){
  631. PlayerMove(2);
  632. btn_value = 0;
  633.  
  634. }
  635.  
  636. /*
  637.  
  638. if(btn_value == 1 && btn_last_value!= 1){
  639. PlayerMove(1);
  640. btn_value = 0;
  641. btn_last_value = 1;
  642.  
  643.  
  644. }
  645.  
  646.  
  647. if(btn_value == 2 && btn_last_value2 != 1){
  648. PlayerMove(2);
  649. btn_value = 0;
  650.  
  651. btn_last_value2 = 1;
  652.  
  653.  
  654. }
  655.  
  656. */
  657.  
  658. if(btn_value == 8) {
  659. GameStartet = 1;
  660.  
  661.  
  662. }
  663.  
  664.  
  665.  
  666.  
  667.  
  668. }
  669.  
  670. void GenstartEnemy(){
  671. Enemy_X4 = 800;
  672. Enemy4_wGreen = 0;
  673. Enemy4_wRed = 255;
  674. Enemy4_wBlue = 0;
  675. enemy_y4 = 300;
  676. player_pos = 220;
  677.  
  678.  
  679. speedUp = 0;
  680. speed1 = 5;
  681. speed2 = 8;
  682. speed3 = 11;
  683.  
  684. Enemy_X3 = 800;
  685. Enemy3_wGreen = 0;
  686. Enemy3_wRed = 255;
  687. Enemy3_wBlue = 0;
  688. enemy_y3 = 260;
  689.  
  690.  
  691. Enemy_X2 = 1200;
  692. Enemy2_wGreen = 0;
  693. Enemy2_wRed = 255;
  694. Enemy2_wBlue = 0;
  695. enemy_y2 = 220;
  696.  
  697.  
  698. Enemy_wGreen = 0;
  699. Enemy_wRed = 255;
  700. Enemy_wBlue = 0;
  701. enemy_y = 180;
  702. Enemy_X = 1200;
  703.  
  704. Enemy_y_size = 10;
  705. Enemy_x_size = 40;
  706.  
  707. }
  708.  
  709. void MoveEnemy1(){
  710.  
  711.  
  712.  
  713. Enemy_X = Enemy_X - r1;
  714.  
  715. if (Enemy_X <= 0) {
  716. Enemy_X = 1200;
  717. }
  718.  
  719. }
  720.  
  721. void MoveEnemy2(){
  722.  
  723.  
  724. Enemy_X2 = Enemy_X2 - r2;
  725.  
  726. if (Enemy_X2 <= 0) {
  727. Enemy_X2 = 600;
  728. }
  729.  
  730. }
  731.  
  732. void MoveEnemy3(){
  733.  
  734. Enemy_X3 = Enemy_X3 - r3;
  735.  
  736.  
  737. if (Enemy_X3 <= 0) {
  738. Enemy_X3 = 800;
  739. }
  740.  
  741. }
  742.  
  743. void MoveEnemy4(){
  744.  
  745. Enemy_X4 = Enemy_X4 - r4;
  746.  
  747.  
  748. if (Enemy_X4 <= 0) {
  749. Enemy_X4 = 800;
  750. }
  751.  
  752. }
  753.  
  754.  
  755.  
  756.  
  757. void CompareAdjustSpeed() {
  758.  
  759. if(speedUp == 200){
  760. speed1 += 2;
  761. speed2 += 2;
  762. speed3 += 2;
  763.  
  764. speedUp = 0;
  765. }
  766.  
  767.  
  768. if(r1 == r2) {
  769. r2 = r3;
  770. }
  771.  
  772. if(r2 == r3){
  773. r3 = r4;
  774. }
  775.  
  776. if(r3 == r4){
  777. r4 = r1;
  778. }
  779.  
  780.  
  781. }
  782.  
  783.  
  784.  
  785.  
  786.  
  787. void EnemySpeed1(){
  788.  
  789. if(enemySpeedCounter1 >= 100 && Enemy_X >= 580){
  790. ra1=rand()%3;
  791.  
  792. if(ra1 == 0){
  793. r1 = speed1;
  794. }
  795.  
  796.  
  797. if(ra1 == 1) {
  798. r1 = speed2;
  799.  
  800. }
  801.  
  802. if(ra1 == 2) {
  803. r1 = speed3;
  804.  
  805. }
  806. enemySpeedCounter1 = 0;
  807. }
  808. }
  809.  
  810.  
  811.  
  812. void EnemySpeed2(){
  813.  
  814. if(enemySpeedCounter2 >= 100 && Enemy_X2 >= 580){
  815. ra2=rand()%3;
  816.  
  817. if(ra2 == 0){
  818. r2 = speed1;
  819. }
  820.  
  821.  
  822. if(ra2 == 1) {
  823. r2 = speed2;
  824.  
  825. }
  826.  
  827. if(ra2 == 2) {
  828. r2 = speed3;
  829.  
  830. }
  831. enemySpeedCounter2 = 0;
  832. }
  833. }
  834.  
  835.  
  836.  
  837.  
  838. void EnemySpeed3(){
  839.  
  840. if(enemySpeedCounter3 >= 100 && Enemy_X3 >= 580){
  841. ra3=rand()%3;
  842.  
  843. if(ra3 == 0){
  844. r3 = speed1;
  845. }
  846.  
  847.  
  848. if(ra3 == 1) {
  849. r3 = speed2;
  850.  
  851. }
  852.  
  853. if(ra3 == 2) {
  854. r3 = speed3;
  855.  
  856. }
  857. enemySpeedCounter3 = 0;
  858. }
  859. }
  860.  
  861.  
  862. void EnemySpeed4(){
  863.  
  864. if(enemySpeedCounter4 >= 100 && Enemy_X4 >= 580){
  865. ra4=rand()%3;
  866.  
  867. if(ra4 == 0){
  868. r4 = speed1;
  869. }
  870.  
  871.  
  872. if(ra4 == 1) {
  873. r4 = speed2;
  874.  
  875. }
  876.  
  877. if(ra4 == 2) {
  878. r4 = speed3;
  879.  
  880. }
  881. enemySpeedCounter4 = 0;
  882. }
  883. }
  884.  
  885.  
  886.  
  887. void HitDetection() {
  888. if (player_pos == enemy_y && Enemy_X <= 90 && Enemy_X >= 10) {
  889.  
  890. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  891. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  892. TimerDelay(2000000);
  893.  
  894. userInput = '2';
  895. value = 2;
  896. }
  897.  
  898. if (player_pos == enemy_y2 && Enemy_X2 <= 90 && Enemy_X2 >= 10 ) {
  899.  
  900. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  901. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  902. TimerDelay(2000000);
  903.  
  904. userInput = '2';
  905. value = 2;
  906.  
  907. }
  908.  
  909. if (player_pos == enemy_y3 && Enemy_X3 <= 90 && Enemy_X3 >= 10 ) {
  910.  
  911. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  912. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  913. TimerDelay(2000000);
  914.  
  915. userInput = '2';
  916. value = 2;
  917.  
  918. }
  919.  
  920. if (player_pos == enemy_y4 && Enemy_X4 <= 90 && Enemy_X4 >= 10 ) {
  921.  
  922. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  923. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  924. TimerDelay(2000000);
  925.  
  926. userInput = '2';
  927. value = 2;
  928.  
  929. }
  930.  
  931.  
  932. }
  933.  
  934.  
  935. void HitDetection2() {
  936. if (player_pos == enemy_y && Enemy_X <= 90 && Enemy_X >= 10) {
  937.  
  938. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  939. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  940.  
  941. TimerDelay(2000000);
  942.  
  943. userInput = '2';
  944. value = 1;
  945. }
  946.  
  947. if (player_pos == enemy_y2 && Enemy_X2 <= 90 && Enemy_X2 >= 10 ) {
  948.  
  949. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  950. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  951.  
  952. TimerDelay(2000000);
  953. userInput = '2';
  954. value = 1;
  955.  
  956. }
  957.  
  958. if (player_pos == enemy_y3 && Enemy_X3 <= 90 && Enemy_X3 >= 10 ) {
  959.  
  960. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  961. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  962.  
  963. TimerDelay(2000000);
  964.  
  965. userInput = '2';
  966. value = 1;
  967.  
  968. }
  969.  
  970. if (player_pos == enemy_y4 && Enemy_X4 <= 90 && Enemy_X4 >= 10 ) {
  971.  
  972. GameOver(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  973. GameOverTitle(pFrames[dispCtrl.curFrame],120,220,10, DEMO_STRIDE);
  974.  
  975. TimerDelay(4000000);
  976. userInput = '2';
  977. value = 1;
  978.  
  979. }
  980.  
  981.  
  982. }
  983.  
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993.  
  994.  
  995.  
  996.  
  997.  
  998.  
  999.  
  1000.  
  1001.  
  1002.  
  1003.  
  1004.  
  1005.  
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012.  
  1013. void tegn_box(u8* frame, u32 x, u32 y, u32 dx, u32 dy, Farve f){
  1014. u32 x_tmp, y_tmp;
  1015. u32 iPixelAddr;
  1016.  
  1017.  
  1018.  
  1019.  
  1020. for(x_tmp = x ; x_tmp < x+dx; x_tmp++)
  1021. {
  1022. for(y_tmp=y; y_tmp < y+dy; y_tmp++)
  1023. {
  1024. iPixelAddr = 3*x_tmp + y_tmp*DEMO_STRIDE;
  1025.  
  1026. frame[iPixelAddr] = f.g;
  1027. frame[iPixelAddr + 1] = f.b;
  1028. frame[iPixelAddr + 2] = f.r;
  1029.  
  1030. }
  1031. }
  1032. }
  1033.  
  1034.  
  1035.  
  1036. void PlayerBox(u8 *frame, u32 x, u32 y, u32 x_size, u32 y_size, u32 color) {
  1037.  
  1038. u32 iPixelAddr;
  1039. u8 wRed, wBlue, wGreen;
  1040. u32 x_tmp, y_tmp;
  1041.  
  1042.  
  1043. //Sort farve
  1044. if(color == 1) {
  1045.  
  1046. wGreen = 0;
  1047. wRed = 0;
  1048. wBlue = 0;
  1049. }
  1050.  
  1051. //Grå farve
  1052. else {
  1053. wGreen = 192;
  1054. wRed = 192;
  1055. wBlue = 192;
  1056. }
  1057.  
  1058.  
  1059. //Tegner boxen
  1060. for(x_tmp=x; x_tmp < x+x_size; x_tmp++)
  1061. {
  1062. for(y_tmp=y; y_tmp < y+y_size; y_tmp++)
  1063. {
  1064. iPixelAddr = 3*x_tmp + y_tmp*DEMO_STRIDE;
  1065.  
  1066. frame[iPixelAddr] = wGreen;
  1067. frame[iPixelAddr + 1] = wBlue;
  1068. frame[iPixelAddr + 2] = wRed;
  1069.  
  1070. }
  1071. }
  1072.  
  1073. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1074.  
  1075. }
  1076.  
  1077.  
  1078. void PlayerMove(u32 playerNewPos){
  1079.  
  1080.  
  1081. int y;
  1082.  
  1083. y = player_pos;
  1084.  
  1085.  
  1086. // Flytter player op
  1087. if(playerNewPos == 1 && player_pos == 260 ){
  1088. PlayerBox(frameBuf[0],50,y,40,10,2);
  1089.  
  1090. y = y-40;
  1091. PlayerBox(frameBuf[0],50,y,40,10,1);
  1092. //PlayerBox(frameBuf[0],50,y,40,10,0);
  1093.  
  1094. }
  1095.  
  1096.  
  1097. if(playerNewPos == 1 && player_pos == 220 ){
  1098. PlayerBox(frameBuf[0],50,y,40,10,2);
  1099.  
  1100. y = y-40;
  1101. PlayerBox(frameBuf[0],50,y,40,10,1);
  1102. //PlayerBox(frameBuf[0],50,y,40,10,0);
  1103.  
  1104.  
  1105. }
  1106.  
  1107. // Flytter player op
  1108. if(playerNewPos == 1 && player_pos == 300 ){
  1109. PlayerBox(frameBuf[0],50,y,40,10,2);
  1110.  
  1111. y = y-40;
  1112. PlayerBox(frameBuf[0],50,y,40,10,1);
  1113. //PlayerBox(frameBuf[0],50,y,40,10,0);
  1114.  
  1115. }
  1116.  
  1117.  
  1118.  
  1119.  
  1120.  
  1121. // Flytter player ned
  1122. if(playerNewPos == 2 && player_pos == 180 ){
  1123. PlayerBox(frameBuf[0],50,y,40,10,2);
  1124.  
  1125. y = y+40;
  1126. PlayerBox(frameBuf[0],50,y,40,10,1);
  1127. //PlayerBox(frameBuf[0],50,y,40,10,0);
  1128.  
  1129. }
  1130.  
  1131. // Flytter player ned
  1132. if(playerNewPos == 2 && player_pos == 220 ){
  1133. PlayerBox(frameBuf[0],50,y,40,10,2);
  1134.  
  1135. y = y+40;
  1136. PlayerBox(frameBuf[0],50,y,40,10,1);
  1137. //PlayerBox(frameBuf[0],50,y,40,10,0);
  1138.  
  1139. }
  1140.  
  1141.  
  1142. // Flytter player ned
  1143. if(playerNewPos == 2 && player_pos == 260 ){
  1144. PlayerBox(frameBuf[0],50,y,40,10,2);
  1145.  
  1146. y = y+40;
  1147. PlayerBox(frameBuf[0],50,y,40,10,1);
  1148. //PlayerBox(frameBuf[0],50,y,40,10,0);
  1149.  
  1150. }
  1151.  
  1152.  
  1153.  
  1154.  
  1155.  
  1156. player_pos=y;
  1157.  
  1158. }
  1159.  
  1160.  
  1161.  
  1162. void StartSpil(){
  1163. SpilStartet = 1;
  1164.  
  1165. Background(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  1166.  
  1167. Platform2(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  1168. Platform(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  1169. OpStribe(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  1170. NedStribe(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  1171. NederstStribe(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  1172. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 100, 1700);
  1173. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 400, 1400);
  1174. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 700, 1100);
  1175. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 1000, 800);
  1176. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 1300, 500);
  1177. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 1600, 200);
  1178. GreyBox(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE, 1900, 0);
  1179. Title(pFrames[dispCtrl.curFrame],150,60,6, DEMO_STRIDE);
  1180. //Score(pFrames[dispCtrl.curFrame],30,400,6, DEMO_STRIDE);
  1181.  
  1182.  
  1183. }
  1184.  
  1185.  
  1186.  
  1187. void Platform2(u8 *frame, u32 width, u32 height, u32 stride){
  1188. u32 xcoi, ycoi;
  1189. u32 iPixelAddr;
  1190. u8 wRed, wBlue, wGreen;
  1191.  
  1192. wGreen = 255;
  1193. wRed = 255;
  1194. wBlue = 255;
  1195.  
  1196. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  1197. {
  1198. iPixelAddr = xcoi + 315*stride;
  1199. for(ycoi = 270; ycoi < height-200; ycoi++)
  1200. {
  1201. frame[iPixelAddr] = wGreen;
  1202. frame[iPixelAddr + 1] = wBlue;
  1203. frame[iPixelAddr + 2] = wRed;
  1204.  
  1205. iPixelAddr += stride;
  1206.  
  1207. }
  1208. }
  1209. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1210. }
  1211.  
  1212.  
  1213.  
  1214. void Platform(u8 *frame, u32 width, u32 height, u32 stride){
  1215.  
  1216. u32 xcoi, ycoi;
  1217. u32 iPixelAddr;
  1218. u8 wRed, wBlue, wGreen;
  1219.  
  1220. wGreen = 255;
  1221. wRed = 255;
  1222. wBlue = 255;
  1223.  
  1224. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  1225. {
  1226. iPixelAddr = xcoi + 158*stride;
  1227. for(ycoi = 270; ycoi < height-200; ycoi++)
  1228. {
  1229. frame[iPixelAddr] = wGreen;
  1230. frame[iPixelAddr + 1] = wBlue;
  1231. frame[iPixelAddr + 2] = wRed;
  1232.  
  1233. iPixelAddr += stride;
  1234.  
  1235. }
  1236. }
  1237. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1238. }
  1239.  
  1240.  
  1241.  
  1242. void Background(u8 *frame, u32 width, u32 height, u32 stride)
  1243. {
  1244. u32 xcoi, ycoi;
  1245. u32 iPixelAddr;
  1246. u8 wRed, wBlue, wGreen;
  1247.  
  1248. wGreen = 192;
  1249. wRed = 192;
  1250. wBlue = 192;
  1251.  
  1252.  
  1253.  
  1254. for(xcoi = 0; xcoi < (width*3)-1; xcoi+=3)
  1255. {
  1256. iPixelAddr = xcoi + 165*stride;
  1257. for(ycoi = 0; ycoi < height-320; ycoi++)
  1258. {
  1259. frame[iPixelAddr] = wGreen;
  1260. frame[iPixelAddr +1] = wBlue;
  1261. frame[iPixelAddr + 2] = wRed;
  1262. iPixelAddr += stride;
  1263. }
  1264. }
  1265.  
  1266. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1267. }
  1268.  
  1269.  
  1270. void OpStribe(u8 *frame, u32 width, u32 height, u32 stride){
  1271.  
  1272. u32 xcoi, ycoi;
  1273. u32 iPixelAddr;
  1274. u8 wRed, wBlue, wGreen;
  1275.  
  1276. wGreen = 255;
  1277. wRed = 255;
  1278. wBlue = 255;
  1279.  
  1280. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  1281. {
  1282. iPixelAddr = xcoi + 200*stride;
  1283. for(ycoi = 276; ycoi < height-200; ycoi++)
  1284. {
  1285. frame[iPixelAddr] = wGreen;
  1286. frame[iPixelAddr + 1] = wBlue;
  1287. frame[iPixelAddr + 2] = wRed;
  1288.  
  1289. iPixelAddr += stride;
  1290.  
  1291. }
  1292. }
  1293. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1294. }
  1295.  
  1296.  
  1297.  
  1298. void NedStribe(u8 *frame, u32 width, u32 height, u32 stride){
  1299.  
  1300. u32 xcoi, ycoi;
  1301. u32 iPixelAddr;
  1302. u8 wRed, wBlue, wGreen;
  1303.  
  1304. wGreen = 255;
  1305. wRed = 255;
  1306. wBlue = 255;
  1307.  
  1308. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  1309. {
  1310. iPixelAddr = xcoi + 240*stride;
  1311. for(ycoi = 276; ycoi < height-200; ycoi++)
  1312. {
  1313. frame[iPixelAddr] = wGreen;
  1314. frame[iPixelAddr + 1] = wBlue;
  1315. frame[iPixelAddr + 2] = wRed;
  1316.  
  1317. iPixelAddr += stride;
  1318.  
  1319. }
  1320. }
  1321. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1322. }
  1323.  
  1324.  
  1325. void NederstStribe(u8 *frame, u32 width, u32 height, u32 stride){
  1326.  
  1327. u32 xcoi, ycoi;
  1328. u32 iPixelAddr;
  1329. u8 wRed, wBlue, wGreen;
  1330.  
  1331. wGreen = 255;
  1332. wRed = 255;
  1333. wBlue = 255;
  1334.  
  1335. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  1336. {
  1337. iPixelAddr = xcoi + 280*stride;
  1338. for(ycoi = 276; ycoi < height-200; ycoi++)
  1339. {
  1340. frame[iPixelAddr] = wGreen;
  1341. frame[iPixelAddr + 1] = wBlue;
  1342. frame[iPixelAddr + 2] = wRed;
  1343.  
  1344. iPixelAddr += stride;
  1345.  
  1346. }
  1347. }
  1348. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1349. }
  1350.  
  1351.  
  1352.  
  1353.  
  1354.  
  1355.  
  1356. void GameOver(u8 *frame, u32 width, u32 height, u32 stride){
  1357.  
  1358. u32 xcoi, ycoi;
  1359. u32 iPixelAddr;
  1360. u8 wRed, wBlue, wGreen;
  1361.  
  1362. wGreen = 0;
  1363. wRed = 0;
  1364. wBlue = 0;
  1365.  
  1366. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  1367. {
  1368. iPixelAddr = xcoi + 150*stride;
  1369. for(ycoi = 276; ycoi < height-20; ycoi++)
  1370. {
  1371. frame[iPixelAddr] = wGreen;
  1372. frame[iPixelAddr + 1] = wBlue;
  1373. frame[iPixelAddr + 2] = wRed;
  1374.  
  1375. iPixelAddr += stride;
  1376.  
  1377. }
  1378. }
  1379.  
  1380. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1381. }
  1382.  
  1383.  
  1384.  
  1385.  
  1386.  
  1387. void GreyBox(u8 *frame, u32 width, u32 height, u32 stride, int x1, int x2)
  1388. {
  1389. u32 xcoi, ycoi;
  1390. u32 iPixelAddr;
  1391. u8 wRed, wBlue, wGreen;
  1392.  
  1393. wGreen = 192;
  1394. wRed = 192;
  1395. wBlue = 192;
  1396.  
  1397. for(xcoi = x1; xcoi < (width*3)-x2; xcoi+=3)
  1398. {
  1399. iPixelAddr = xcoi + 170*stride;
  1400. for(ycoi = 0; ycoi < height-345; ycoi++)
  1401. {
  1402. frame[iPixelAddr] = wGreen;
  1403. frame[iPixelAddr +1] = wBlue;
  1404. frame[iPixelAddr + 2] = wRed;
  1405. iPixelAddr += stride;
  1406. }
  1407. }
  1408.  
  1409. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1410. }
  1411.  
  1412.  
  1413. void DemoISR(void *callBackRef, void *pVideo)
  1414. {
  1415. char *data = (char *) callBackRef;
  1416. *data = 1; //set fRefresh to 1
  1417. }
  1418.  
  1419.  
  1420.  
  1421. void Title(u8 *frame, u32 xcor, u32 ycor, u32 size, u32 stride){
  1422. int aer[5][56] = {
  1423. {0,2,2,2,0,2,2,2,0,0,0,2,2,0,0,2,2,2,2,2,0,2,0,0,0,2,0,0,0,0,2,2,2,0,0,2,2,2,0,0,2,0,2,0,0,0,2,0,2,2,2,0,2,2,2,0,},
  1424. {2,0,0,0,0,2,0,0,2,0,2,0,0,2,0,0,0,0,2,0,0,0,2,0,2,0,0,0,0,0,2,0,0,2,0,2,0,0,2,0,2,0,2,0,0,0,2,0,2,0,0,0,2,0,0,2,},
  1425. {2,0,0,0,0,2,2,2,2,0,2,2,2,2,0,0,0,2,0,0,0,0,0,2,0,0,0,0,0,0,2,0,0,2,0,2,2,2,2,0,2,0,2,0,0,0,2,0,2,2,2,0,2,2,2,2,},
  1426. {2,0,0,0,0,2,0,2,0,0,2,0,0,2,0,0,2,0,0,0,0,0,0,2,0,0,0,0,0,0,2,0,0,2,0,2,0,2,0,0,2,0,0,2,0,2,0,0,2,0,0,0,2,0,2,0,},
  1427. {0,2,2,2,0,2,0,0,2,0,2,0,0,2,0,2,2,2,2,2,0,0,0,2,0,0,0,0,0,0,2,2,2,0,0,2,0,0,2,0,2,0,0,0,2,0,0,0,2,2,2,0,2,0,0,2,}
  1428. };
  1429. for(int j = 0; j<5; j++){
  1430. for(int i = 0; i<56; i++){
  1431. int x =aer[j][i];
  1432. switch(x){
  1433. case 0 :
  1434. xcor += size;
  1435. break;
  1436. case 2 :
  1437. DrawTitle(frame, xcor, ycor, size,stride, 255, 255, 255);
  1438. xcor += size;
  1439. break;
  1440. }
  1441. }
  1442. ycor += size;
  1443. xcor -= 56*size;
  1444. }
  1445. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1446. }
  1447.  
  1448. void DrawTitle(u8 *frame, u32 xcor, u32 ycor, u32 size, u32 stride, double fRed, double fBlue, double fGreen){
  1449. xcor = xcor*3;
  1450. u32 iPixelAddr;
  1451. for(int x = 0; x < (size*3); x+=3){
  1452. iPixelAddr = xcor+(stride*ycor)+x;
  1453. for(int y = 0; y < size; y++){
  1454. frame[iPixelAddr] = fRed;
  1455. frame[iPixelAddr + 1] = fBlue;
  1456. frame[iPixelAddr + 2] = fGreen;
  1457. /*
  1458. * This pattern is printed one vertical line at a time, so the address must be incremented
  1459. * by the stride instead of just 1.
  1460. */
  1461. iPixelAddr += stride;
  1462. }
  1463. }
  1464. }
  1465.  
  1466.  
  1467.  
  1468.  
  1469. void Score(u8 *frame, u32 xcor, u32 ycor, u32 size, u32 stride){
  1470. int aer[5][56] = {
  1471. {0,2,2,2,0,0,2,2,2,0,0,2,2,0,0,2,2,2,0,0,2,2,2,0,0,0,0,0,0,0,0,2,2,0,0,0,2,2,0,0,0,2,2,0,0,0,2,2,0,0,0,0,0,0,0,},
  1472. {2,0,0,0,0,2,0,0,0,0,2,0,0,2,0,2,0,0,2,0,2,0,0,0,0,2,2,2,0,0,2,0,0,2,0,2,0,0,2,0,2,0,0,2,0,2,0,0,2,0,0,0,0,0,0,},
  1473. {2,2,2,2,0,2,0,0,0,0,2,0,0,2,0,2,2,2,2,0,2,2,2,0,0,0,0,0,0,0,2,0,0,2,0,2,0,0,2,0,2,0,0,2,0,2,0,0,2,0,0,0,0,0,0,},
  1474. {0,0,0,2,0,2,0,0,0,0,2,0,0,2,0,2,0,2,0,0,2,0,0,0,0,2,2,2,0,0,2,0,0,2,0,2,0,0,2,0,2,0,0,2,0,2,0,0,2,0,0,0,0,0,0,},
  1475. {2,2,2,0,0,0,2,2,2,0,0,2,2,0,0,2,0,0,2,0,2,2,2,0,0,0,0,0,0,0,0,2,2,0,0,0,2,2,0,0,0,2,2,0,0,0,2,2,0,0,0,0,0,0,0,}
  1476. };
  1477. for(int j = 0; j<5; j++){
  1478. for(int i = 0; i<56; i++){
  1479. int x =aer[j][i];
  1480. switch(x){
  1481. case 0 :
  1482. xcor += size;
  1483. break;
  1484. case 2 :
  1485. DrawScore(frame, xcor, ycor, size,stride, 255, 255, 255);
  1486. xcor += size;
  1487. break;
  1488. }
  1489. }
  1490. ycor += size;
  1491. xcor -= 56*size;
  1492. }
  1493. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1494. }
  1495.  
  1496. void DrawScore(u8 *frame, u32 xcor, u32 ycor, u32 size, u32 stride, double fRed, double fBlue, double fGreen){
  1497. xcor = xcor*3;
  1498. u32 iPixelAddr;
  1499. for(int x = 0; x < (size*3); x+=3){
  1500. iPixelAddr = xcor+(stride*ycor)+x;
  1501. for(int y = 0; y < size; y++){
  1502. frame[iPixelAddr] = fRed;
  1503. frame[iPixelAddr + 1] = fBlue;
  1504. frame[iPixelAddr + 2] = fGreen;
  1505. /*
  1506. * This pattern is printed one vertical line at a time, so the address must be incremented
  1507. * by the stride instead of just 1.
  1508. */
  1509. iPixelAddr += stride;
  1510. }
  1511. }
  1512. }
  1513.  
  1514.  
  1515. void GameOverTitle(u8 *frame, u32 xcor, u32 ycor, u32 size, u32 stride){
  1516. int aer[5][56] = {
  1517. {2,2,2,2,0,0,2,2,0,0,2,0,0,0,2,0,2,2,2,0,0,0,0,0,2,2,0,0,2,0,0,0,2,0,2,2,2,0,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
  1518. {2,0,0,0,0,2,0,0,2,0,2,2,0,2,2,0,2,0,0,0,0,0,0,2,0,0,2,0,2,0,0,0,2,0,2,0,0,0,2,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
  1519. {2,0,2,2,0,2,2,2,2,0,2,0,2,0,2,0,2,2,2,0,0,0,0,2,0,0,2,0,2,0,0,0,2,0,2,2,2,0,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
  1520. {2,0,0,2,0,2,0,0,2,0,2,0,0,0,2,0,2,0,0,0,0,0,0,2,0,0,2,0,0,2,0,2,0,0,2,0,0,0,2,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
  1521. {2,2,2,2,0,2,0,0,2,0,2,0,0,0,2,0,2,2,2,0,0,0,0,0,2,2,0,0,0,0,2,0,0,0,2,2,2,0,2,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,}
  1522. };
  1523. for(int j = 0; j<5; j++){
  1524. for(int i = 0; i<56; i++){
  1525. int x =aer[j][i];
  1526. switch(x){
  1527. case 0 :
  1528. xcor += size;
  1529. break;
  1530. case 2 :
  1531. DrawGameOverTitle(frame, xcor, ycor, size,stride, 255, 255, 255);
  1532. xcor += size;
  1533. break;
  1534. }
  1535. }
  1536. ycor += size;
  1537. xcor -= 56*size;
  1538. }
  1539. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  1540. }
  1541.  
  1542. void DrawGameOverTitle(u8 *frame, u32 xcor, u32 ycor, u32 size, u32 stride, double fRed, double fBlue, double fGreen){
  1543. xcor = xcor*3;
  1544. u32 iPixelAddr;
  1545. for(int x = 0; x < (size*3); x+=3){
  1546. iPixelAddr = xcor+(stride*ycor)+x;
  1547. for(int y = 0; y < size; y++){
  1548. frame[iPixelAddr] = fRed;
  1549. frame[iPixelAddr + 1] = fBlue;
  1550. frame[iPixelAddr + 2] = fGreen;
  1551. /*
  1552. * This pattern is printed one vertical line at a time, so the address must be incremented
  1553. * by the stride instead of just 1.
  1554. */
  1555. iPixelAddr += stride;
  1556. }
  1557. }
  1558. }
  1559.  
  1560.  
  1561.  
  1562.  
  1563.  
  1564.  
  1565.  
  1566.  
  1567.  
  1568.  
  1569.  
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.  
  1588.  
  1589.  
  1590. //----------------------------------------------------
  1591. // INITIAL SETUP FUNCTIONS
  1592. //----------------------------------------------------
  1593.  
  1594. int InterruptSystemSetup(XScuGic *XScuGicInstancePtr)
  1595. {
  1596. // Enable interrupt
  1597. XGpio_InterruptEnable(&BTNInst, BTN_INT);
  1598. XGpio_InterruptGlobalEnable(&BTNInst);
  1599.  
  1600. Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
  1601. (Xil_ExceptionHandler)XScuGic_InterruptHandler,
  1602. XScuGicInstancePtr);
  1603. Xil_ExceptionEnable();
  1604.  
  1605.  
  1606. return XST_SUCCESS;
  1607.  
  1608. }
  1609.  
  1610.  
  1611.  
  1612. int IntcInitFunction(u16 DeviceId, XGpio *GpioInstancePtr)
  1613. {
  1614. XScuGic_Config *IntcConfig;
  1615. int status;
  1616. u8 pri, trig;
  1617.  
  1618. // Interrupt controller initialisation
  1619. IntcConfig = XScuGic_LookupConfig(DeviceId);
  1620. status = XScuGic_CfgInitialize(&INTCInst, IntcConfig, IntcConfig->CpuBaseAddress);
  1621. if(status != XST_SUCCESS) return XST_FAILURE;
  1622.  
  1623. /*
  1624. * Initialize the Interrupt controller and start it.
  1625. */
  1626. status = fnInitInterruptController(&intc);
  1627. if(status != XST_SUCCESS) {
  1628. xil_printf("Error initializing interrupts");
  1629. return;
  1630. }
  1631. fnEnableInterrupts(&intc, &ivt[0], sizeof(ivt)/sizeof(ivt[0]));
  1632.  
  1633.  
  1634. // Call to interrupt setup
  1635. status = InterruptSystemSetup(&INTCInst);
  1636. if(status != XST_SUCCESS) return XST_FAILURE;
  1637.  
  1638.  
  1639. // Connect GPIO interrupt to handler
  1640. status = XScuGic_Connect(&INTCInst,
  1641. INTC_GPIO_INTERRUPT_ID,
  1642. (Xil_ExceptionHandler)BTN_Intr_Handler,
  1643. (void *)GpioInstancePtr);
  1644. if(status != XST_SUCCESS) return XST_FAILURE;
  1645.  
  1646.  
  1647.  
  1648. // Enable GPIO interrupts interrupt
  1649. XGpio_InterruptEnable(GpioInstancePtr, 1);
  1650. XGpio_InterruptGlobalEnable(GpioInstancePtr);
  1651.  
  1652. // Enable GPIO and timer interrupts in the controller
  1653. XScuGic_Enable(&INTCInst, INTC_GPIO_INTERRUPT_ID);
  1654. //XScuGic_Enable(&INTCInst, INTC_TMR_INTERRUPT_ID);
  1655.  
  1656. xil_printf("Getting the Timer interrupt info\n\r");
  1657. XScuGic_GetPriTrigTypeByDistAddr(INTCInst.Config->DistBaseAddress, INTC_TMR_INTERRUPT_ID, &pri, &trig);
  1658. xil_printf("GPIO Interrupt-> Priority:%d, Trigger:%x\n\r", pri, trig);
  1659.  
  1660.  
  1661. //Set the timer interrupt as edge triggered
  1662. //XScuGic_SetPriorityTriggerType(&INTCInst, INTC_TMR_INTERRUPT_ID, )
  1663.  
  1664. return XST_SUCCESS;
  1665. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!