dm
/
school
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Activity
Contains the source code from the course work throughout my undergraduate Computer Engineering degree at Brigham Young University. There is a mixture of Go, Python, C, C++, Java, VHDL, Verilog, Matlab, Bash, Assembly, etc..
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
11 Commits
1 Branch
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
school/ecen427/vdma.c

873 lines
31KB
Raw Permalink Blame History 

  1. #include <stdio.h>

  2. #include "platform.h"

  3. #include "xparameters.h"

  4. #include "xaxivdma.h"

  5. #include "xio.h"

  6. #include "time.h"

  7. #include "unistd.h"

  8. #include "xgpio.h"          // Provides access to PB GPIO driver.

  9. #include "mb_interface.h"   // provides the microblaze interrupt enables, etc.

  10. #include "xintc_l.h"        // Provides handy macros for the interrupt controller.

  11. #include "xac97_l.h"

  12. #include "nes.h"

  13. #include "global.h"

  14. #include <xuartlite_l.h>

  15. 

  16. XGpio gpLED;  // This is a handle for the LED GPIO block.

  17. XGpio gpPB;   // This is a handle for the push-button GPIO block.

  18. 

  19. 

  20. #define DEBUG

  21. #define FRAME_BUFFER_0_ADDR 0xC5000000  // Starting location in DDR where we will store the images that we display.

  22. #define VOL_ATTN_MIN 0x0

  23. #define VOL_ATTN_MAX 0x1f

  24. 

  25. Xuint32 vol_attn = 0x10;

  26. 

  27. int mytimer = 0;

  28. int mycounter = 0;

  29. 

  30. int onesec;

  31. int fifteenms;

  32. int fivems;

  33. int tenms;

  34. int buttonValid;

  35. int currentButtonState;

  36. int speed = 30;

  37. 

  38. int holding;

  39. 

  40. int gameState = 1;

  41. 

  42. 

  43. void increaseVolume() {

  44.   if((int)vol_attn > VOL_ATTN_MIN) {

  45. 	vol_attn = vol_attn - 0x1;

  46. 	XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, vol_attn | (vol_attn << 8));

  47. 	XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_AuxOutVol, vol_attn | (vol_attn << 8));

  48.   }

  49. }

  50. void decreaseVolume() {

  51.   if((int)vol_attn < VOL_ATTN_MAX) {

  52. 	vol_attn = vol_attn + 0x1;

  53. 	XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, vol_attn | (vol_attn << 8));

  54. 	XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_AuxOutVol, vol_attn | (vol_attn << 8));

  55.   }

  56. }

  57. void delayDying() {

  58. 	int counter = 0;

  59. 	while(counter < 500000){

  60. 		counter++;

  61. 	}

  62. }

  63. 

  64. void setGameState(int mystate){

  65. 	gameState = mystate;

  66. }

  67. 

  68. unsigned int * framePointer = (unsigned int *) FRAME_BUFFER_0_ADDR;

  69. 

  70. void pb_interrupt_handler();

  71. 

  72. int isBottom(int value) {

  73. 	short* aliens = getAliens();

  74. 

  75. 	if(value > 43) {

  76. 		return 1;

  77. 	}

  78. 	if(value < 44 && value > 32) {

  79. 		if(aliens[value+11] == 0) {

  80. 			return 1;

  81. 		}

  82. 		else {

  83. 			return 0;

  84. 		}

  85. 	}

  86. 	if(value < 33 && value > 21) {

  87. 		if(aliens[value+11] == 0 && aliens[value+22] == 0) {

  88. 			return 1;

  89. 		}

  90. 		else {

  91. 			return 0;

  92. 		}

  93. 	}

  94. 	if(value < 22 && value > 10) {

  95. 		if(aliens[value+11] == 0 && aliens[value+22] == 0 && aliens[value+33] == 0) {

  96. 			return 1;

  97. 		}

  98. 		else {

  99. 			return 0;

  100. 		}

  101. 	}

  102. 	if(value < 11) {

  103. 		if(aliens[value+11] == 0 && aliens[value+22] == 0 && aliens[value+33] == 0 && aliens[value+44] == 0) {

  104. 			return 1;

  105. 		}

  106. 		else {

  107. 			return 0;

  108. 		}

  109. 	}

  110. }

  111. 

  112. int whatRow(int position) {

  113. 	if(position > 43) {

  114. 		return 120;

  115. 	}

  116. 	if(position < 44 && position > 32) {

  117. 		return 94;

  118. 	}

  119. 	if(position < 33 && position > 21) {

  120. 		return 68;

  121. 	}

  122. 	if(position < 22 && position > 10) {

  123. 		return 42;

  124. 	}

  125. 	if(position < 11) {

  126. 		return 16;

  127. 	}

  128. 

  129. }

  130. 

  131. void collisionCleanUp(int x, int y) {

  132. 	setHaveAlienDeathSound(1);

  133. 	blankTankBullet(framePointer);

  134. 	setTankBulletPositionY(0);

  135. 	setTankBulletState(0);

  136. 	delayDying();

  137. 	dyingAlienHelper(framePointer, x, y);

  138. 	int guise = getGuise();

  139. 	if(guise == 0) {

  140. 		renderAlien2(framePointer);

  141. 	}

  142. 	else {

  143. 		renderAlien1(framePointer);

  144. 	}

  145. 	alienSpeed();

  146. }

  147. 

  148. void alienCollision() {

  149. 	int curTankY = ((getTankBulletPositionY()-2)*640);

  150. 	int curTankX = getTankBulletPositionX()+3;

  151. 	int curAlienX = getAlienBlockPositionX();

  152. 	int curAlienY = getAlienBlockPositionY();

  153. 	int ufoscore = 0;

  154. 	int updatescore = 0;

  155. 

  156. 	if(framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()+3] == 0x00FF0000) {

  157. 		setHaveSpaceShipDeathSound(1);

  158. 		blankUfo(framePointer, getUfoPositionX(), getUfoPositionY());

  159. 		setUfoState(0);

  160. 		blankTankBullet(framePointer);

  161. 		setTankBulletPositionY(0);

  162. 		setTankBulletState(0);

  163. 		// ufo score operation

  164. 		ufoscore = rand()%7;

  165. 		updatescore = selectingUfoscore(framePointer, ufoscore);

  166. 		updateMyscore(updatescore);

  167. 		updateNumber(framePointer);

  168. 	}

  169. 	if(framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()+3] == 0x00FFFFFF || \

  170. 			framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()+5] == 0x00FFFFFF ||\

  171. 			framePointer[((getTankBulletPositionY()-2)*640) + getTankBulletPositionX()] == 0x00FFFFFF){

  172. 		curTankY = curTankY/640;

  173. 		if(curAlienX > 1000) {

  174. 			curAlienX -= 65535;

  175. 		}

  176. 		xil_printf("curX: %d\r\n", curAlienX);

  177. 		if(curAlienY < curTankY && curTankY < curAlienY + 16 ) {

  178. 			if(curAlienX < curTankX && curTankX < (curAlienX + 32)) {

  179. 				dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()));

  180. 				setAliens(0, 0);

  181. 				collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()));

  182. 			}

  183. 			if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) {

  184. 				dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()));

  185. 				setAliens(0, 1);

  186. 				collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()));

  187. 			}

  188. 			if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) {

  189. 				dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()));

  190. 				setAliens(0, 2);

  191. 				collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()));

  192. 			}

  193. 			if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) {

  194. 				dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()));

  195. 				setAliens(0, 3);

  196. 				collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()));

  197. 			}

  198. 			if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) {

  199. 				dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()));

  200. 				setAliens(0, 4);

  201. 				collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()));

  202. 			}

  203. 			if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) {

  204. 				dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()));

  205. 				setAliens(0, 5);

  206. 				collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()));

  207. 			}

  208. 			if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) {

  209. 				dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()));

  210. 				setAliens(0, 6);

  211. 				collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()));

  212. 			}

  213. 			if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) {

  214. 				dyingAlien(framePointer, (getAlienBlockPositionX()+ 224), (getAlienBlockPositionY()));

  215. 				setAliens(0, 7);

  216. 				collisionCleanUp((getAlienBlockPositionX()+ 224), (getAlienBlockPositionY()));

  217. 			}

  218. 			if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) {

  219. 				dyingAlien(framePointer, (getAlienBlockPositionX()+ 256), (getAlienBlockPositionY()));

  220. 				setAliens(0, 8);

  221. 				collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()));

  222. 			}

  223. 			if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) {

  224. 				dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()));

  225. 				setAliens(0, 9);

  226. 				collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()));

  227. 			}

  228. 			if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) {

  229. 				dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()));

  230. 				setAliens(0, 10);

  231. 				collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()));

  232. 			}

  233. 			updateMyscore(40);

  234. 			updateNumber(framePointer);

  235. 

  236. 		}

  237. 		if(curAlienY + 26 < curTankY && curTankY < curAlienY + 42) {

  238. 			if(curAlienX < curTankX && curTankX < (curAlienX + 32)) {

  239. 				dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+26));

  240. 				setAliens(0, 11);

  241. 				collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+26));

  242. 			}

  243. 			if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) {

  244. 				dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+26));

  245. 				setAliens(0, 12);

  246. 				collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+26));

  247. 			}

  248. 			if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) {

  249. 				dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+26));

  250. 				setAliens(0, 13);

  251. 				collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+26));

  252. 			}

  253. 			if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) {

  254. 				dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+26));

  255. 				setAliens(0, 14);

  256. 				collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+26));

  257. 			}

  258. 			if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) {

  259. 				dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+26));

  260. 				setAliens(0, 15);

  261. 				collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+26));

  262. 			}

  263. 			if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) {

  264. 				dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+26));

  265. 				setAliens(0, 16);

  266. 				collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+26));

  267. 			}

  268. 			if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) {

  269. 				dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+26));

  270. 				setAliens(0, 17);

  271. 				collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+26));

  272. 			}

  273. 			if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) {

  274. 				dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+26));

  275. 				setAliens(0, 18);

  276. 				collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+26));

  277. 			}

  278. 			if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) {

  279. 				dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+26));

  280. 				setAliens(0, 19);

  281. 				collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+26));

  282. 			}

  283. 			if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) {

  284. 				dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+26));

  285. 				setAliens(0, 20);

  286. 				collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+26));

  287. 			}

  288. 			if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) {

  289. 				dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+26));

  290. 				setAliens(0, 21);

  291. 				collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+26));

  292. 			}

  293. 			updateMyscore(20);

  294. 			updateNumber(framePointer);

  295. 		}

  296. 		if(curAlienY + 52 < curTankY && curTankY < curAlienY + 68) {

  297. 			if(curAlienX < curTankX && curTankX < (curAlienX + 32)) {

  298. 				dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+52));

  299. 				setAliens(0, 22);

  300. 				collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+52));

  301. 			}

  302. 			if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) {

  303. 				dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+52));

  304. 				setAliens(0, 23);

  305. 				collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+52));

  306. 			}

  307. 			if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) {

  308. 				dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+52));

  309. 				setAliens(0, 24);

  310. 				collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+52));

  311. 			}

  312. 			if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) {

  313. 				dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+52));

  314. 				setAliens(0, 25);

  315. 				collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+52));

  316. 			}

  317. 			if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) {

  318. 				dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+52));

  319. 				setAliens(0, 26);

  320. 				collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+52));

  321. 			}

  322. 			if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) {

  323. 				dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+52));

  324. 				setAliens(0, 27);

  325. 				collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+52));

  326. 			}

  327. 			if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) {

  328. 				dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+52));

  329. 				setAliens(0, 28);

  330. 				collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+52));

  331. 			}

  332. 			if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) {

  333. 				dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+52));

  334. 				setAliens(0, 29);

  335. 				collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+52));

  336. 			}

  337. 			if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) {

  338. 				dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+52));

  339. 				setAliens(0, 30);

  340. 				collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+52));

  341. 			}

  342. 			if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) {

  343. 				dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+52));

  344. 				setAliens(0, 31);

  345. 				collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+52));

  346. 			}

  347. 			if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) {

  348. 				dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+52));

  349. 				setAliens(0, 32);

  350. 				collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+52));

  351. 			}

  352. 			updateMyscore(20);

  353. 			updateNumber(framePointer);

  354. 		}

  355. 		if(curAlienY + 78 < curTankY && curTankY < curAlienY + 94) {

  356. 			if(curAlienX < curTankX && curTankX < (curAlienX + 32)) {

  357. 				dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+78));

  358. 				setAliens(0, 33);

  359. 				collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+78));

  360. 			}

  361. 			if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) {

  362. 				dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+78));

  363. 				setAliens(0, 34);

  364. 				collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+78));

  365. 			}

  366. 			if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) {

  367. 				dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+78));

  368. 				setAliens(0, 35);

  369. 				collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+78));

  370. 			}

  371. 			if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) {

  372. 				dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+78));

  373. 				setAliens(0, 36);

  374. 				collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+78));

  375. 			}

  376. 			if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) {

  377. 				dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+78));

  378. 				setAliens(0, 37);

  379. 				collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+78));

  380. 			}

  381. 			if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) {

  382. 				dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+78));

  383. 				setAliens(0, 38);

  384. 				collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+78));

  385. 			}

  386. 			if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) {

  387. 				dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+78));

  388. 				setAliens(0, 39);

  389. 				collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+78));

  390. 			}

  391. 			if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) {

  392. 				dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+78));

  393. 				setAliens(0, 40);

  394. 				collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+78));

  395. 			}

  396. 			if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) {

  397. 				dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+78));

  398. 				setAliens(0, 41);

  399. 				collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+78));

  400. 			}

  401. 			if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) {

  402. 				dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+78));

  403. 				setAliens(0, 42);

  404. 				collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+78));

  405. 			}

  406. 			if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) {

  407. 				dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+78));

  408. 				setAliens(0, 43);

  409. 				collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+78));

  410. 			}

  411. 			updateMyscore(10);

  412. 			updateNumber(framePointer);

  413. 		}

  414. 		if(curAlienY + 104 < curTankY && curTankY < curAlienY +120){

  415. 			if(curAlienX < curTankX && curTankX < (curAlienX + 32)) {

  416. 				dyingAlien(framePointer, (getAlienBlockPositionX()), (getAlienBlockPositionY()+104));

  417. 				setAliens(0, 44);

  418. 				collisionCleanUp((getAlienBlockPositionX()), (getAlienBlockPositionY()+104));

  419. 			}

  420. 			if(curAlienX + 32 < curTankX && curTankX < curAlienX + 64) {

  421. 				dyingAlien(framePointer, (getAlienBlockPositionX()+32), (getAlienBlockPositionY()+104));

  422. 				setAliens(0,45);

  423. 				collisionCleanUp((getAlienBlockPositionX()+32), (getAlienBlockPositionY()+104));

  424. 			}

  425. 			if(curAlienX + 64 < curTankX && curTankX < curAlienX + 96) {

  426. 				dyingAlien(framePointer, (getAlienBlockPositionX()+64), (getAlienBlockPositionY()+104));

  427. 				setAliens(0, 46);

  428. 				collisionCleanUp((getAlienBlockPositionX()+64), (getAlienBlockPositionY()+104));

  429. 			}

  430. 			if(curAlienX + 96 < curTankX && curTankX < curAlienX + 128) {

  431. 				dyingAlien(framePointer, (getAlienBlockPositionX()+96), (getAlienBlockPositionY()+104));

  432. 				setAliens(0, 47);

  433. 				collisionCleanUp((getAlienBlockPositionX()+96), (getAlienBlockPositionY()+104));

  434. 			}

  435. 			if(curAlienX + 128 < curTankX && curTankX < curAlienX + 160) {

  436. 				dyingAlien(framePointer, (getAlienBlockPositionX()+128), (getAlienBlockPositionY()+104));

  437. 				setAliens(0, 48);

  438. 				collisionCleanUp((getAlienBlockPositionX()+128), (getAlienBlockPositionY()+104));

  439. 			}

  440. 			if(curAlienX + 160 < curTankX && curTankX < curAlienX + 192) {

  441. 				dyingAlien(framePointer, (getAlienBlockPositionX()+160), (getAlienBlockPositionY()+104));

  442. 				setAliens(0, 49);

  443. 				collisionCleanUp((getAlienBlockPositionX()+160), (getAlienBlockPositionY()+104));

  444. 			}

  445. 			if(curAlienX + 192 < curTankX && curTankX < curAlienX + 224) {

  446. 				dyingAlien(framePointer, (getAlienBlockPositionX()+192), (getAlienBlockPositionY()+104));

  447. 				setAliens(0, 50);

  448. 				collisionCleanUp((getAlienBlockPositionX()+192), (getAlienBlockPositionY()+104));

  449. 			}

  450. 			if(curAlienX + 224 < curTankX && curTankX < curAlienX + 256) {

  451. 				dyingAlien(framePointer, (getAlienBlockPositionX()+224), (getAlienBlockPositionY()+104));

  452. 				setAliens(0, 51);

  453. 				collisionCleanUp((getAlienBlockPositionX()+224), (getAlienBlockPositionY()+104));

  454. 			}

  455. 			if(curAlienX + 256 < curTankX && curTankX < curAlienX + 288) {

  456. 				dyingAlien(framePointer, (getAlienBlockPositionX()+256), (getAlienBlockPositionY()+104));

  457. 				setAliens(0, 52);

  458. 				collisionCleanUp((getAlienBlockPositionX()+256), (getAlienBlockPositionY()+104));

  459. 			}

  460. 			if(curAlienX + 288 < curTankX && curTankX < curAlienX + 320) {

  461. 				dyingAlien(framePointer, (getAlienBlockPositionX()+288), (getAlienBlockPositionY()+104));

  462. 				setAliens(0, 53);

  463. 				collisionCleanUp((getAlienBlockPositionX()+288), (getAlienBlockPositionY()+104));

  464. 			}

  465. 			if(curAlienX + 320 < curTankX && curTankX < curAlienX + 352) {

  466. 				dyingAlien(framePointer, (getAlienBlockPositionX()+320), (getAlienBlockPositionY()+104));

  467. 				setAliens(0, 54);

  468. 				collisionCleanUp((getAlienBlockPositionX()+320), (getAlienBlockPositionY()+104));

  469. 			}

  470. 			updateMyscore(10);

  471. 			updateNumber(framePointer);

  472. 		}

  473. 	}

  474. }

  475. 

  476. void alienSpeed() {

  477. 	short* aliens = getAliens();

  478. 	int i;

  479. 	int total = 0;

  480. 	for(i = 0; i < 55; i++) {

  481. 		if(aliens[i] == 1) {

  482. 			total++;

  483. 		}

  484. 	}

  485. 	if(total < 55) {

  486. 		speed = 30;

  487. 	}

  488. 	if(total < 44) {

  489. 		speed = 28;

  490. 	}

  491. 	if(total < 33) {

  492. 		speed = 26;

  493. 	}

  494. 	if(total < 22) {

  495. 		speed = 24;

  496. 	}

  497. 	if(total < 11) {

  498. 		speed = 20;

  499. 	}

  500. 	if(total == 0) {

  501. 		gameOver(framePointer);

  502. 	}

  503. }

  504. 

  505. void timer_interrupt_handler() {

  506. 	onesec++;

  507. 	fifteenms++;

  508. 	fivems++;

  509. 	tenms++;

  510. 	mytimer++;

  511. 

  512. 	if(mytimer == 5000){

  513. 		mytimer = 0;

  514. 		xil_printf("my counter value: %d\r\n", mycounter);

  515. 	}

  516. 

  517. 	if(onesec == 100) {

  518. 		onesec = 0;

  519. 	}

  520. 	if(fifteenms == speed) {

  521. 		fifteenms = 0;

  522. 		incrementAlienSoundCadence();

  523. 		moveAlien(framePointer);

  524. 		renderAlien(framePointer);

  525. 		if(getAlienBlockPositionY() > 240){

  526. 			int col;

  527. 			for(col=0; col<640; col++) {

  528. 				if(framePointer[360*640 + col] == 0x00FFFFFF) {

  529. 					gameOver(framePointer);

  530. 				}

  531. 

  532. 			}

  533. 		}

  534. 

  535. 	}

  536. 	if(tenms == 2){

  537. 		tenms = 0;

  538. 		if(getUfoState() == 1){

  539. 			moveUfo(framePointer, getUfoDirection());

  540. 			renderUfo(framePointer);

  541. 

  542. 		}

  543. 

  544. 	}

  545. 	if(fivems == 1) {

  546. 		fivems = 0;

  547. 		if(getTankBulletState() == 1 || getAlien1BulletState() == 1 || getAlien2BulletState() == 1 || \

  548. 				getAlien3BulletState() == 1 || getAlien4BulletState() == 1) {

  549. 			int i;

  550. 			for(i = 0; i < 3; i++) {

  551. 				moveBullets(framePointer);

  552. 				renderBullet(framePointer);

  553. 			}

  554. 			if(getAlien1BulletState()){

  555. 				selectBlock(framePointer, 1);

  556. 			}

  557. 			if(getAlien2BulletState()){

  558. 				selectBlock(framePointer, 2);

  559. 			}

  560. 			if(getAlien3BulletState()){

  561. 				selectBlock(framePointer, 3);

  562. 			}

  563. 			if(getAlien4BulletState()){

  564. 				selectBlock(framePointer, 4);

  565. 			}

  566. 			if(getTankBulletState()){

  567. 				selectBlock(framePointer, 5);

  568. 			}

  569. 		}

  570. 	}

  571. }

  572. 

  573. // This is invoked each time there is a change in the button state (result of a push or a bounce).

  574. void pb_interrupt_handler() {

  575. 	// Clear the GPIO interrupt.

  576. 	XGpio_InterruptGlobalDisable(&gpPB);                // Turn off all PB interrupts for now.

  577. 	currentButtonState = XGpio_DiscreteRead(&gpPB, 1);  // Get the current state of the buttons.

  578. 	if(currentButtonState == 16) {

  579. 		increaseVolume();

  580. 	}

  581. 	if(currentButtonState == 4) {

  582. 		decreaseVolume();

  583. 	}

  584. 	XGpio_InterruptClear(&gpPB, 0xFFFFFFFF);            // Ack the PB interrupt.

  585. 	XGpio_InterruptGlobalEnable(&gpPB);                 // Re-enable PB interrupts.

  586. }

  587. 

  588. // Main interrupt handler

  589. void interrupt_handler_dispatcher(void* ptr) {

  590. 	int intc_status = XIntc_GetIntrStatus(XPAR_INTC_0_BASEADDR);

  591. 

  592. 	// Check the AC97. Just one method - no need for a separate handler

  593. 	if (intc_status & XPAR_AXI_AC97_0_INTERRUPT_MASK) {

  594. 		XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_AXI_AC97_0_INTERRUPT_MASK);

  595. 		fillSound();

  596. 	}

  597. 	// Check the FIT interrupt first.

  598. 	if (intc_status & XPAR_FIT_TIMER_0_INTERRUPT_MASK){

  599. 		XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_FIT_TIMER_0_INTERRUPT_MASK);

  600. 		timer_interrupt_handler();

  601. 	}

  602. 	// Check the push buttons.

  603. 	if (intc_status & XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK){

  604. 		XIntc_AckIntr(XPAR_INTC_0_BASEADDR, XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK);

  605. 		pb_interrupt_handler();

  606. 	}

  607. }

  608. 

  609. int main() {

  610. 	init_platform();                   // Necessary for all programs.

  611. 	// Initialize the GPIO peripherals.

  612. 	 XAC97_HardReset(XPAR_AXI_AC97_0_BASEADDR);  //Reset XAC97

  613. 	 XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, AC97_VOL_ATTN_23_5_DB);  // Set default volume

  614. 

  615. 	 XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_ExtendedAudioStat, 1);

  616. 	 XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR,AC97_PCM_DAC_Rate,AC97_PCM_RATE_11025_HZ);

  617. 

  618. 	 XAC97_mSetControl(XPAR_AXI_AC97_0_BASEADDR, AC97_ENABLE_IN_FIFO_INTERRUPT);   //Enable AC97 Interrupts

  619. 

  620. 	//interrupt code from clock lab

  621. 	int success;

  622. 	success = XGpio_Initialize(&gpPB, XPAR_PUSH_BUTTONS_5BITS_DEVICE_ID);

  623. 	// Set the push button peripheral to be inputs.

  624. 	XGpio_SetDataDirection(&gpPB, 1, 0x0000001F);

  625. 	// Enable the global GPIO interrupt for push buttons.

  626. 	XGpio_InterruptGlobalEnable(&gpPB);

  627. 	// Enable all interrupts in the push button peripheral.

  628. 	XGpio_InterruptEnable(&gpPB, 0xFFFFFFFF);

  629. 

  630. 	microblaze_register_handler(interrupt_handler_dispatcher, NULL);

  631. 	XIntc_EnableIntr(XPAR_INTC_0_BASEADDR,

  632. 			(XPAR_FIT_TIMER_0_INTERRUPT_MASK | XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK |XPAR_AXI_AC97_0_INTERRUPT_MASK ));

  633. 	XIntc_MasterEnable(XPAR_INTC_0_BASEADDR);

  634. 	microblaze_enable_interrupts();

  635. 	//end of interrupt code from clock lab

  636. 

  637. 

  638. 	int Status;                        // Keep track of success/failure of system function calls.

  639. 	XAxiVdma videoDMAController;

  640. 	// There are 3 steps to initializing the vdma driver and IP.

  641. 	// Step 1: lookup the memory structure that is used to access the vdma driver.

  642.     XAxiVdma_Config * VideoDMAConfig = XAxiVdma_LookupConfig(XPAR_AXI_VDMA_0_DEVICE_ID);

  643.     // Step 2: Initialize the memory structure and the hardware.

  644.     if(XST_FAILURE == XAxiVdma_CfgInitialize(&videoDMAController, VideoDMAConfig,	XPAR_AXI_VDMA_0_BASEADDR)) {

  645.     	xil_printf("VideoDMA Did not initialize.\r\n");

  646.     }

  647.     // Step 3: (optional) set the frame store number.

  648.     if(XST_FAILURE ==  XAxiVdma_SetFrmStore(&videoDMAController, 2, XAXIVDMA_READ)) {

  649.     	xil_printf("Set Frame Store Failed.");

  650.     }

  651.     // Initialization is complete at this point.

  652. 

  653.     // Setup the frame counter. We want two read frames. We don't need any write frames but the

  654.     // function generates an error if you set the write frame count to 0. We set it to 2

  655.     // but ignore it because we don't need a write channel at all.

  656.     XAxiVdma_FrameCounter myFrameConfig;

  657.     myFrameConfig.ReadFrameCount = 2;

  658.     myFrameConfig.ReadDelayTimerCount = 10;

  659.     myFrameConfig.WriteFrameCount =2;

  660.     myFrameConfig.WriteDelayTimerCount = 10;

  661.     Status = XAxiVdma_SetFrameCounter(&videoDMAController, &myFrameConfig);

  662.     if (Status != XST_SUCCESS) {

  663. 	   xil_printf("Set frame counter failed %d\r\n", Status);

  664. 	   if(Status == XST_VDMA_MISMATCH_ERROR)

  665. 		   xil_printf("DMA Mismatch Error\r\n");

  666.     }

  667.     // Now we tell the driver about the geometry of our frame buffer and a few other things.

  668.     // Our image is 480 x 640.

  669.     XAxiVdma_DmaSetup myFrameBuffer;

  670.     myFrameBuffer.VertSizeInput = 480;    // 480 vertical pixels.

  671.     myFrameBuffer.HoriSizeInput = 640*4;  // 640 horizontal (32-bit pixels).

  672.     myFrameBuffer.Stride = 640*4;         // Dont' worry about the rest of the values.

  673.     myFrameBuffer.FrameDelay = 0;

  674.     myFrameBuffer.EnableCircularBuf=1;

  675.     myFrameBuffer.EnableSync = 0;

  676.     myFrameBuffer.PointNum = 0;

  677.     myFrameBuffer.EnableFrameCounter = 0;

  678.     myFrameBuffer.FixedFrameStoreAddr = 0;

  679.     if(XST_FAILURE == XAxiVdma_DmaConfig(&videoDMAController, XAXIVDMA_READ, &myFrameBuffer)) {

  680.     	xil_printf("DMA Config Failed\r\n");

  681.      }

  682.     // We need to give the frame buffer pointers to the memory that it will use. This memory

  683.     // is where you will write your video data. The vdma IP/driver then streams it to the HDMI

  684.     // IP.

  685.      myFrameBuffer.FrameStoreStartAddr[0] = FRAME_BUFFER_0_ADDR;

  686. 

  687.      if(XST_FAILURE == XAxiVdma_DmaSetBufferAddr(&videoDMAController, XAXIVDMA_READ,

  688.     		               myFrameBuffer.FrameStoreStartAddr)) {

  689.     	 xil_printf("DMA Set Address Failed Failed\r\n");

  690.      }

  691.      // Print a sanity message if you get this far.

  692.      xil_printf("Woohoo! I made it through initialization.\n\r");

  693.      // Now, let's get ready to start displaying some stuff on the screen.

  694.      // The variables framePointer and framePointer1 are just pointers to the base address

  695.      // of frame 0 and frame 1.

  696.      //unsigned int * framePointer = (unsigned int *) FRAME_BUFFER_0_ADDR;

  697.      int row = 0;

  698.      int col = 0;

  699.      for(row=0; row<480; row++) {

  700.     	 for(col=0; col<640; col++) {

  701.     		 if(row > 460 && row < 464) {

  702.     			 framePointer[row*640 + col] = 0x0000FF00;

  703.     		 }

  704.     		 else {

  705.     			 framePointer[row*640 + col] = 0x00000000;

  706.     		 }

  707.     	 }

  708.      }

  709. 

  710.      // This tells the HDMI controller the resolution of your display (there must be a better way to do this).

  711.      XIo_Out32(XPAR_AXI_HDMI_0_BASEADDR, 640*480);

  712. 

  713.      // Start the DMA for the read channel only.

  714.      if(XST_FAILURE == XAxiVdma_DmaStart(&videoDMAController, XAXIVDMA_READ)){

  715.     	 xil_printf("DMA START FAILED\r\n");

  716.      }

  717.      int frameIndex = 0;

  718.      // We have two frames, let's park on frame 0. Use frameIndex to index them.

  719.      // Note that you have to start the DMA process before parking on a frame.

  720.      if (XST_FAILURE == XAxiVdma_StartParking(&videoDMAController, frameIndex,  XAXIVDMA_READ)) {

  721.     	 xil_printf("vdma parking failed\n\r");

  722.      }

  723. 

  724.      setAlienBlockPosition(0, 120);

  725. 	 setTankPosition(300, 420);

  726. 	 renderTank(framePointer);

  727. 	 renderAlien(framePointer);

  728. 	 renderBunker(framePointer);

  729. 	 renderScore(framePointer);

  730. 	 renderNumber(framePointer);

  731. 	 renderTanks(framePointer);

  732. 	 alienSpeed();

  733. 

  734. 	 while (gameState) {

  735. 

  736. 		 mycounter++;

  737. 

  738. 		 alienCollision();

  739. 		 int nesButtonState = NES_mReadReg(XPAR_NES_0_BASEADDR, 0);

  740. 		 if(nesButtonState == 2) {

  741. 			xil_printf("we are in left\r\n");

  742. 			 moveTankL(framePointer);

  743. 			 renderTank(framePointer);

  744. 		 }

  745. 		 if(nesButtonState == 1) {

  746. 			 xil_printf("we are in right\r\n");

  747. 			 moveTankR(framePointer);

  748. 			 renderTank(framePointer);

  749. 		 }

  750. 		 if(nesButtonState == 4) {

  751. 			 xil_printf("we are in mid\r\n");

  752. 			 if(getTankBulletState() == 1) {

  753. 				 continue;

  754. 			 }

  755. 			 else {

  756. 				 setHaveTankBulletSound(1);

  757. 				 setTankBulletState(1);

  758. 				 initialTankBulletPosition();

  759. 				 renderBullet(framePointer);

  760. 			 }

  761. 		 }

  762. 		 if(nesButtonState == 6) {

  763. 			 xil_printf("we are in mid\r\n");

  764. 			 moveTankL(framePointer);

  765. 			 renderTank(framePointer);

  766. 			 if(getTankBulletState() == 1) {

  767. 				 continue;

  768. 			 }

  769. 			 else {

  770. 				 setHaveTankBulletSound(1);

  771. 				 setTankBulletState(1);

  772. 				 initialTankBulletPosition();

  773. 				 renderBullet(framePointer);

  774. 			 }

  775. 		 }

  776. 		 if(nesButtonState == 5) {

  777. 			 xil_printf("we are in mid\r\n");

  778. 			 moveTankR(framePointer);

  779. 			 renderTank(framePointer);

  780. 			 if(getTankBulletState() == 1) {

  781. 				 continue;

  782. 			 }

  783. 			 else {

  784. 				 setHaveTankBulletSound(1);

  785. 				 setTankBulletState(1);

  786. 				 initialTankBulletPosition();

  787. 				 renderBullet(framePointer);

  788. 			 }

  789. 		 }

  790. 

  791. 		 int ufo_show = rand() % 3000;

  792. 		 if(ufo_show == 100){

  793. 			 if(getUfoState() == 0){

  794. 				 setHaveSpaceShipSound(1);

  795. 				 setUfoState(1);

  796. 				 setUfoDirection();

  797. 				 if(getUfoDirection()){		// getUfoDirection = 1 means ufo going left

  798. 					 setUfoPositionX(610);

  799. 					 setUfoPositionY(45);

  800. 					 renderUfo(framePointer);

  801. 				 }

  802. 				 else{				   	    // getUfoDirection = 0 means ufo going right

  803. 					 setUfoPositionX(0);

  804. 					 setUfoPositionY(45);

  805. 					 renderUfo(framePointer);

  806. 				 }

  807. 			 }

  808. 		 }

  809. 

  810. 		 int alienShot = rand() % 100000;	// this controls how frequent bullets are fired by aliens

  811. 		 if(alienShot == 50) {	//key 3

  812. 			 int i = 0;

  813. 			 int j = rand() % 4;

  814. 			 int k[4] = {getAlien1BulletState(), getAlien2BulletState(), getAlien3BulletState(), getAlien4BulletState()};

  815. 			 for(i = 0; i < 16; i ++) {

  816. 				 if(k[j] == 0) {

  817. 					 break;

  818. 				 }

  819. 				 else {

  820. 					 j = rand()%4;

  821. 				 }

  822. 			 }

  823. 			 int bottomAlien = 0;

  824. 			 short* aliens = getAliens();

  825. 			 int a;

  826. 			 while(bottomAlien == 0) {

  827. 				 a = rand () % 54;

  828. 				 if(aliens[a] == 1 && isBottom(a)) {

  829. 					 bottomAlien = 1;

  830. 				 }

  831. 			 }

  832. 			 int position = whatRow(a);

  833. 			 int x = a % 11;

  834. 

  835. 			 switch(j){

  836. 			 case 0:

  837. 				 if(getAlien1BulletState() == 0) {

  838. 					 setAlien1BulletState(1);

  839. 					 setAlien1BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position);

  840. 					 renderBullet(framePointer);

  841. 				 }

  842. 				 break;

  843. 			 case 1:

  844. 				 if(getAlien2BulletState() == 0) {

  845. 					 setAlien2BulletState(1);

  846. 					 setAlien2BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position);

  847. 					 renderBullet(framePointer);

  848. 				 }

  849. 				 break;

  850. 			 case 2:

  851. 				 if(getAlien3BulletState() == 0) {

  852. 					 setAlien3BulletState(1);

  853. 					 setAlien3BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position);

  854. 					 renderBullet(framePointer);

  855. 				 }

  856. 				 break;

  857. 			 case 3:

  858. 				 if(getAlien4BulletState() == 0) {

  859. 					 setAlien4BulletState(1);

  860. 					 setAlien4BulletPosition(((getAlienBlockPositionX()+10) + 32 * x), getAlienBlockPositionY()+position);

  861. 					 renderBullet(framePointer);

  862. 				 }

  863. 				 break;

  864. 			 default :

  865. 				 break;

  866. 			 }

  867. 		 }

  868. 	 }

  869. 	 cleanup_platform();

  870. 

  871. 	 return 0;

  872. }