API tools faq
paste
CodeCodeCode

code that works

CodeCodeCode
Dec 9th, 2012
64
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 93.57 KB | None | 0 0
raw download clone embed print report
  1. /*********************************************************************************
  2. * ECE 362 - Mini-Project C Source File - Fall 2012
  3. **********************************************************************************
  4. **********************************************************************************
  5. *
  6. * Team ID: 16
  7. *
  8. * Project Name: < chess >
  9. *
  10. * Team Members:
  11. * Name: Mark Luzarowski Signature:________________________________
  12. * Mail: [email protected]
  13. * Name: Micheal Standiford Signature:________________________________
  14. * Mail: [email protected]
  15. * Name: Mark Sears Signature:________________________________
  16. * Mail: [email protected]
  17. * Name: That other guy Signature:________________________________
  18. * Mail: [email protected]
  19. *
  20. * Team Positions:
  21. *
  22. * Team/Doc Leader: < Mark Luzarowski > Signature: ______________________
  23. *
  24. * Software Leader: < Mark Luzarowski > Signature: ______________________
  25. *
  26. * Interface Leader: < Micheal Standiford > Signature: ______________________
  27. *
  28. * Peripheral Leader: < Micheal Standiford > Signature: ______________________
  29. *
  30. *
  31. * Academic Honesty Statement: In signing above, we hereby certify that we
  32. * are the individuals who created this HC(S)12 source file and that we have
  33. * not copied the work of any other student (past or present) while completing
  34. * it. We understand that if we fail to honor this agreement, we will receive
  35. * a grade of ZERO and be subject to possible disciplinary action.
  36. *
  37. **********************************************************************************
  38. * Project Purpose
  39. **********************************************************************************
  40. * The objective of this Mini-Project is to create a game board the can as a multi-
  41. * game base; games planned so far are chess and checkers. The board itself will
  42. * function as a "learning board" of sorts for any game programmed into it.
  43. *
  44. **********************************************************************************
  45. * Project-specific Success Criteria
  46. **********************************************************************************
  47. * 1. Piece tracking & movement analysis
  48. *
  49. * 2. Time & turn tracking
  50. *
  51. * 3. User-side game editing
  52. *
  53. **********************************************************************************
  54. * Change Log
  55. **********************************************************************************
  56. * Date code started: November 13, 2012
  57. *
  58. * Update history:
  59. *
  60. * Date: November 13, 2012
  61. * Name: Mark Luzarowski
  62. * Update: Added generalized functions for LCD communications.
  63. * Added initializations skeleton.
  64. * -------------------------------------------------------------------------------
  65. * Date:
  66. * Name:
  67. * Update:
  68. *
  69. ***********************************************************************************
  70. **********************************************************************************/
  71. #include <hidef.h> // common defines and macros
  72. #include "derivative.h" // derivative-specific definitions
  73. #include <mc9s12c32.h> // 9S12 register & port defines
  74.  
  75. //Dictionary defines
  76. #define LCD_RS PTT_PTT2
  77. #define LCD_CLK PTT_PTT4
  78. #define RPG_A PTT_PTT5
  79. #define RPG_B PTT_PTT6
  80. #define RPG_BTN PTT_PTT7
  81. #define enable PTAD_PTAD7
  82. #define enable2 PTAD_PTAD6
  83. #define output PTM_PTM3
  84. #define output2 PTM_PTM2
  85. #define output3 PTM_PTM1
  86. #define output4 PTM_PTM0
  87. #define output5 PTT_PTT3
  88.  
  89. //All funtions after main should be initialized here
  90. char inchar(void);
  91. void outchar(char);
  92. void LCD_Delay(int);
  93. void LCD_Cursor_Position(int);
  94. void LCD_Send_Byte(char, int);
  95. void LCD_Display(int Msgtype);
  96. void bco(char);
  97. void LCD_Timer(void);
  98. void LED_Out(void);
  99. void LED_Convert(void);
  100. void Chess_Locations(int);
  101. void LCD_Piece_Select(int);
  102. void Play_Sound(int);
  103. void HALL_Input(void);
  104. void LED_Test(void);
  105.  
  106. //James' Functions
  107. //dec 1st
  108. void currpccnt(void);
  109. void pickedup(int row, int col, int piece);
  110. void pawnled(int row,int col,int team,int mode);
  111. void bishopled(int row,int col,int team);
  112. void rookled(int row,int col, int team);
  113. void knightled(int row,int col,int team);
  114. int bcheck(int row,int col);
  115. void ledcopy(int mode);
  116. void queenled(int row,int col,int team);
  117. void ischeck(int team);
  118. int blackcheckflag = 0;
  119. int whitecheckflag = 0;
  120. void kingledout(int row,int col,int team);
  121. void kingled(int row,int col,int team);
  122. void ledcopy(int mode);
  123. void checkmatrix(int team);
  124. //dec 3rd
  125. void scanline(void);\
  126. void movecnt(void);
  127. int nummoves = 0;
  128. //void bco(void);
  129. void addchar(char a);
  130. char CR = 0x0D;//Return
  131. char LF = 0x0A; //line feed
  132. void sevenchar(int mode);
  133. void sci_outline(int mode);
  134. void sci_datafetch(int mode, int line);
  135. void outtype(int type);
  136. void outteam(int team);
  137. void nowpccnt(void);
  138. void hpccnt(void);
  139.  
  140. // James' variables
  141. //dec 1st
  142. int nowpc; //how many pieces are currently on the board
  143. int currpc; //how many pieces are currently in the game (not taken yet)
  144. int switchflag = 0; //flag that determines whether a switch is being currently made
  145. int ldata[8][8];
  146. int ltemp[8][8];
  147. int hlatch[8][8];
  148. //dec 3rd
  149. int sciset = 0;
  150. int boardset = 0;
  151. int sciline = 0;
  152. int boardline = 0;
  153. int scioff_flag = 0;
  154. //dec 5th
  155. int scicountflag = 0;
  156. int scicount = 0;
  157. void sciscan(void);
  158. //dec 6th
  159. int movenumber = 2;
  160. int whitescore = 0;
  161. int blackscore = 0;
  162. int scoreline = 0;
  163. int ledoutmode = 0;
  164. unsigned char MOVEOutData[8];
  165. int uprow; //variables for keeping track of pieces
  166. int upcol;
  167. int downrow;
  168. int downcol;
  169. int nextrow;
  170. int nextcol;
  171. int sameflag;
  172. int pickedupflag = 0;
  173. int hpc = 0;
  174. int cndiff = 0;
  175. int hndiff = 0;
  176. int rtarget;
  177. int ctarget;
  178. int nowpclatch;
  179. void hallvlatch(void);
  180. void hallvchess(void);
  181. void setdown(int row, int col, int piece);
  182. void puteverythingback(void);
  183.  
  184. //Global Declarations Begin Here
  185. //------------------------------------
  186. //------------------------------------
  187. //SCI Variables
  188. int tin = 0; //SCI transmit display buffer IN pointer
  189. int tout = 0; //SCI transmit display buffer OUT pointer
  190. int tsize = 70; //SCI size of transmit buffer
  191. char tbuf[70]; //SCI transmit display buffer
  192. int tdata; // how much data is in the buffer
  193. //TIM Variables
  194. int P1mins = 20; //White player minutes remaining on chess clock
  195. int P1secs = 0; //White player seconds remaining on chess clock
  196. int P2mins = 20; //Black player minutes remaining on chess clock
  197. int P2secs = 0; //Black player seconds remaining on chess clock
  198. int TimerCounter = 0; //Chess timer 10ms collector
  199. int timeExpired = 0; //Timer has reached 00:00 for either player
  200. //LCD Variables
  201. char LineOffset = 0x00; //In use to calculate position of LCD write cursor
  202. //RPG Variables
  203. int RPGRightTurns = 0; //Number of pulses for right detected
  204. int RPGLeftTurns = 0; //Number of pulses for left detected
  205. int RPGRight = 0; //Movement to the right detected
  206. int RPGLeft = 0; //Movement to the left detected
  207. int prevRPGbutton = 0; //Status of RPG button (previous)
  208. int newRPGbutton = 0; //Status of RPG button (current)
  209. //Menu Variables
  210. int OutOfSplashScreen = 0; //Sees if the game has left the welcome splash
  211. //0 = Still on splash screen
  212. //1 = Left the splash screen
  213. int MenuPosition = 1; //Current Screen of the menu
  214. //0 = Game Start
  215. //1 = Edit Timer
  216. int TimerEditing = 0; //Are we editing the timer?
  217. //Gameplay (human) Variables
  218. int PlayerToggle = 0; //The current player toggle
  219. //0 = White
  220. //1 = Black
  221. int TimerRunning = 0; //Sees if the timer is up
  222. int TimerExpired = 0; //Sees if the timer has expired for either player
  223. int TimerRefresh = 0; //Refresh the timer on the LCD
  224. int GameRunning = 0; //Sees if game is currently running
  225.  
  226. int HallMatrix[8][8]; //Magnet sensor input matrix
  227. int ChessMatrix[8][8];//Chess piece memory map
  228. unsigned char LEDOutData[8]; //Set of LED shiftout variables; one for each row of LEDs.
  229. int en1 = 0;
  230. int en2 = 0;
  231. int RefreshHall = 0;
  232.  
  233.  
  234. //------------------------------------
  235. //------------------------------------
  236.  
  237. //ASCII character constants
  238. char ASCII_CR = 0x0D; //Return
  239. char ASCII_LF = 0x0A; //Linefeed
  240.  
  241. //LCD specific constants
  242. char LCD_LINE1 = 0x80; //LCD line #1
  243. char LCD_LINE2 = 0xC0; //LCD line #2
  244. char LCD_ON = 0x0F; //LCD turn on instruction
  245. char LCD_CLEAR = 0x01; //LCD clear instruction
  246. char LCD_2LINE = 0x38; //LCD use both lines instruction
  247. char LCD_CURSOR = 0xFE; //LCD cursor move instruction
  248.  
  249. /*********************************************************************************
  250. Initializations
  251. **********************************************************************************/
  252. void initializations(void) {
  253.  
  254.  
  255. // Set the PLL speed (bus clock = 24 MHz)
  256. CLKSEL = CLKSEL & 0x80; // disengage PLL from system
  257. PLLCTL = PLLCTL | 0x40; // turn on PLL
  258. SYNR = 0x02; // set PLL multiplier
  259. REFDV = 0; // set PLL divider
  260. while (!(CRGFLG & 0x08)){ }
  261. CLKSEL = CLKSEL | 0x80; // engage PLL
  262.  
  263. // Disable watchdog timer (COPCTL register)
  264. COPCTL = 0x40; // COP off; RTI and COP stopped in BDM-mode
  265.  
  266. // Initialize asynchronous serial port (SCI) for 9600 baud, no interrupts
  267. SCIBDH = 0x00; // set baud rate to 9600
  268. SCIBDL = 0x9C; // 24,000,000 / 16 / 156 = 9600 (approx) dec=26
  269. SCICR1 = 0x00; // $9C = 156
  270. SCICR2 = 0x0C; // initialize SCI for program-driven operation
  271. SCICR2 = SCICR2 & 0x7F;
  272. DDRB = 0x10; // set PB4 for output mode
  273. PORTB = 0x10; // assert DTR pin on COM port
  274.  
  275. //RTI Initialization (2.048ms)
  276. CRGINT = CRGINT | 0x80; //RTI enabled
  277. RTICTL = 0x1F; //
  278.  
  279.  
  280. //SPI Initialization (6MHz)
  281. SPICR1 = 0x52; //SPI control register #1
  282. //[Bit 7] SPIE = 0 | SPI interrupts disabled
  283. //[Bit 6] SPE = 1 | SPI enabled
  284. //[Bit 5] SPTIE = 0 | SPI transmit empty interrupt disabled
  285. //[Bit 4] MSTR = 1 | Master mode
  286. //[Bit 3] CPOL = 0 | Active low clock (SCK) - idles low
  287. //[Bit 2] CPHA = 0 | Data sampled at odd edges of SCK
  288. //[Bit 1] SSOE = 1 | Slave select output enable
  289. //[Bit 0] LSBFE = 0 | Data transferred most significant bit first
  290. SPICR2 = 0x00;
  291. SPIBR = 0x08; //Baud rate register
  292. //[Bit 6-4] SPPRx = 000 | Baud rate pre-selection bits
  293. //[Bit 2-0] SPRx = 001 | Baud rate selection bits
  294. //SPI rate = BusClock / [(SPPR + 1) * 2^(SPR + 1)]
  295.  
  296. //TIM Initialization (10ms)
  297. TSCR1_TEN = 1; //TIM enable
  298. TIOS_IOS7 = 1; //Output compare on ch7
  299. TSCR2_TCRE = 1; //TCNT reset when OC7 occurs
  300. TSCR2_PR2 = 1; //24MHz / 16 = 1.5MHz
  301. TSCR2_PR1 = 0;
  302. TSCR2_PR0 = 0;
  303. TC7 = 15000; //15000 / 1.5MHz = 10ms
  304. TIE_C7I = 0; //TIM interrupts disabled
  305.  
  306. //PWM Initialization (1470.5Hz)
  307. PWME = 0x01; //PMW enable
  308. PWMPOL = 0x01; //PWM polarity select (active high)
  309. PWMPER0 = 0xFF; //period
  310. PWMDTY0 = 0x00; //duty
  311. PWMPRCLK = 0x04; //24MHz/16 = 1.5MHz
  312. PWMCLK = 0x01; //use clock SA
  313. PWMSCLA = 2; //1.5MHz/(2*2) = 375KHz
  314. PWMSCLB = 0; //375KHz/255 = 1470.5Hz final output
  315. MODRR = 0x01; //Reroute pwm to PT pins
  316. PWMCAE = 0;
  317.  
  318. //Port Initializations
  319. ATDDIEN = 0xFF;
  320. DDRT = 0x17; // 00010111 T5, T6, T7 are inputs from the shiny button
  321. PTT = 0;
  322. DDRAD = 0xE0;//DDRAD = 0xFF;
  323.  
  324. //LCD Initializations
  325. LCD_CLK = 1;
  326. LCD_Send_Byte(LCD_ON, 1);
  327. LCD_Send_Byte(LCD_2LINE, 1);
  328. LCD_Send_Byte(LCD_CLEAR, 1);
  329. LCD_Delay(1);
  330. LCD_Display(0);
  331.  
  332. enable = 0;
  333. asm {
  334. nop
  335. }
  336. }
  337.  
  338. /*********************************************************************************
  339. Main
  340. **********************************************************************************/
  341. void main(void) {
  342. DisableInterrupts;
  343. initializations();
  344. EnableInterrupts;
  345.  
  346.  
  347.  
  348. for(;;) {
  349. //RPG turned to the right
  350. if (RPGRight == 1) {
  351. RPGRight = 0;
  352.  
  353. //Not on welcome splash
  354. if (OutOfSplashScreen == 1) {
  355. //Not editing the game timer
  356. if (TimerEditing == 0) {
  357. MenuPosition++; //Next menu object
  358.  
  359. //Scroller cannot pass maximum menu objects
  360. if (MenuPosition > 3) {
  361. MenuPosition = 3;
  362. } else {
  363. //Display menu object on LCD
  364. LCD_Display(MenuPosition);
  365. }
  366. //Editing the game timer
  367. } else {
  368. P1mins++;
  369. P2mins++;
  370.  
  371. //Timer cannout go over 60 minutes
  372. if (P1mins > 60) {
  373. P1mins = 60;
  374. P2mins = 60;
  375. }
  376.  
  377. LCD_Timer();
  378. }
  379. }
  380. }
  381.  
  382. //RPG turned to the left
  383. if (RPGLeft == 1) {
  384. RPGLeft = 0;
  385.  
  386. //Not on welcome splash
  387. if (OutOfSplashScreen == 1) {
  388. //Not editing the game timer
  389. if (TimerEditing == 0) {
  390. MenuPosition--; //Next menu object
  391.  
  392. //Scroller cannot pass maximum menu objects
  393. if (MenuPosition < 1) {
  394. MenuPosition = 1;
  395. } else {
  396. //Display menu object on LCD
  397. LCD_Display(MenuPosition);
  398. }
  399. //Editing game timer
  400. } else {
  401. P1mins--;
  402. P2mins--;
  403.  
  404. //Timer cannout go below 1 minute
  405. if (P1mins < 1) {
  406. P1mins = 1;
  407. P2mins = 1;
  408. }
  409.  
  410. LCD_Timer();
  411. }
  412. }
  413. }
  414.  
  415. //RPG button pressed
  416. if (newRPGbutton == 1) {
  417. newRPGbutton = 0;
  418.  
  419. //Check if on splash
  420. if (OutOfSplashScreen == 0) {
  421. OutOfSplashScreen = 1;
  422. LCD_Display(MenuPosition);
  423. } else {
  424. //Start game, bring up timer
  425. if (MenuPosition == 1) {
  426. GameRunning = 1;
  427.  
  428. //If timer not running, start it and game initializations
  429. if (TimerRunning == 0) {
  430. TIE_C7I = 1;
  431. TimerRunning = 1;
  432.  
  433. //Chess_Locations(0); //Initialize new game piece locations
  434. enable = 1;
  435. LED_Test();
  436. enable = 0;
  437. //LED_Convert(); //Set up LED backlighting
  438. //enable = 1;
  439. //LED_Out();
  440. //enable = 0;
  441.  
  442. //SCICR2 = SCICR2 | 0x80;
  443. //LED_Convert(); //Set up LED backlighting
  444. //enable = 1;
  445. //LED_Out();
  446. //enable = 0;
  447. //enable2 = 1;
  448. //HALL_Input();
  449. //enable2 = 0;
  450. //If timer is running, toggle player
  451. } else if (TimerRunning == 1){
  452. PlayerToggle = !PlayerToggle;
  453.  
  454. }
  455. //Editing the game timer
  456. } else if (MenuPosition == 2) {
  457. LCD_Timer();
  458.  
  459. //Already brought the screen up
  460. if (TimerEditing == 1) {
  461. LCD_Display(MenuPosition);
  462. TimerEditing = 0;
  463. } else {
  464. TimerEditing = 1;
  465. }
  466.  
  467. } else if (MenuPosition == 3) {
  468. //load game
  469. }
  470. }
  471. }
  472.  
  473. //gameflow
  474. /* if(GameRunning == 1 && TimerRunning == 1){
  475. if(pickedupflag == 0){
  476. nowpccnt();
  477. hpccnt();
  478. currpccnt();
  479. if(nowpc > currpc){
  480. puteverythingback();
  481. } else {
  482.  
  483. nowpclatch = nowpc;
  484. cndiff = currpc - nowpc;
  485. if(cndiff == 1){
  486. hallvchess();
  487. if((ChessMatrix[uprow][upcol] / 10) == PlayerToggle){
  488. if(sameflag == 0){
  489. pickedup(uprow,upcol,ChessMatrix[uprow][upcol]);
  490. pickedupflag = 1;
  491. }
  492. LCD_Display(6);
  493. } else {
  494. puteverythingback();
  495. }
  496.  
  497.  
  498. }
  499. }
  500.  
  501.  
  502. } else if (pickedupflag == 1){
  503. currpccnt();
  504. nowpccnt();
  505. hpccnt();
  506. if(nowpc < hpc - 1 || nowpc > hpc + 1){
  507. puteverythingback();
  508. } else {
  509. if(nowpc = hpc + 1){ //setting it back down
  510. hallvlatch();
  511. if(ldata[nextrow][nextcol] && sameflag == 0){
  512. setdown(nextrow,nextcol,ChessMatrix[uprow][upcol]);
  513. }
  514. } else if (nowpc = hpc - 1){ //picking another up
  515. hallvlatch();
  516. if(ldata[nextrow][nextcol] && sameflag == 0){
  517. setdown(nextrow,nextcol,ChessMatrix[uprow][upcol]);
  518. }
  519. }
  520. }
  521. }
  522. }*/
  523.  
  524.  
  525. //If timer is running and it needs a refresh, refresh it.
  526. if ((TimerRunning == 1) && (TimerRefresh == 1)) {
  527. TimerRefresh = 0;
  528.  
  529. LCD_Timer();
  530. }
  531.  
  532. if (RefreshHall == 1) {
  533. enable2 = 1;
  534. HALL_Input();
  535. enable2 = 0;
  536. RefreshHall = 0;
  537. }
  538.  
  539.  
  540.  
  541. _FEED_COP(); /* feeds the dog */
  542. } /* loop forever */
  543. /* please make sure that you never leave main */
  544. }
  545.  
  546. /*********************************************************************************
  547. * Name: Chess_Locations
  548. * Description: Manages vitual piece location map.
  549. * [->] (global): ChessMatrix: Map of the board.
  550. * 00 = empty space
  551. * X1 = pawn
  552. * X2 = rook
  553. * X3 = knight
  554. * X4 = bishop
  555. * X5 = Queen
  556. * X6 = King
  557. * 1X = White piece
  558. * 2X = Black piece
  559. * (int): Mode: Mode of map.
  560. * 0 = Initialization for new game.
  561. * 1 = Standard
  562. * [<-] (void): [void]
  563. *********************************************************************************/
  564. void Chess_Locations(int Mode) {
  565.  
  566. if (Mode == 0) {
  567. ChessMatrix[0][0] = 2;
  568. ChessMatrix[0][1] = 3;
  569. ChessMatrix[0][2] = 4;
  570. ChessMatrix[0][3] = 5;
  571. ChessMatrix[0][4] = 6;
  572. ChessMatrix[0][5] = 4;
  573. ChessMatrix[0][6] = 3;
  574. ChessMatrix[0][7] = 2;
  575. ChessMatrix[1][0] = 1;
  576. ChessMatrix[1][1] = 1;
  577. ChessMatrix[1][2] = 1;
  578. ChessMatrix[1][3] = 1;
  579. ChessMatrix[1][4] = 1;
  580. ChessMatrix[1][5] = 1;
  581. ChessMatrix[1][6] = 1;
  582. ChessMatrix[1][7] = 1;
  583. ChessMatrix[2][0] = 0;
  584. ChessMatrix[2][1] = 0;
  585. ChessMatrix[2][2] = 0;
  586. ChessMatrix[2][3] = 0;
  587. ChessMatrix[2][4] = 0;
  588. ChessMatrix[2][5] = 0;
  589. ChessMatrix[2][6] = 0;
  590. ChessMatrix[2][7] = 0;
  591. ChessMatrix[3][0] = 0;
  592. ChessMatrix[3][1] = 0;
  593. ChessMatrix[3][2] = 0;
  594. ChessMatrix[3][3] = 0;
  595. ChessMatrix[3][4] = 0;
  596. ChessMatrix[3][5] = 0;
  597. ChessMatrix[3][6] = 0;
  598. ChessMatrix[3][7] = 0;
  599. ChessMatrix[4][0] = 0;
  600. ChessMatrix[4][1] = 0;
  601. ChessMatrix[4][2] = 0;
  602. ChessMatrix[4][3] = 0;
  603. ChessMatrix[4][4] = 0;
  604. ChessMatrix[4][5] = 0;
  605. ChessMatrix[4][6] = 0;
  606. ChessMatrix[4][7] = 0;
  607. ChessMatrix[5][0] = 0;
  608. ChessMatrix[5][1] = 0;
  609. ChessMatrix[5][2] = 0;
  610. ChessMatrix[5][3] = 0;
  611. ChessMatrix[5][4] = 0;
  612. ChessMatrix[5][5] = 0;
  613. ChessMatrix[5][6] = 0;
  614. ChessMatrix[5][7] = 0;
  615. ChessMatrix[6][0] = 11;
  616. ChessMatrix[6][1] = 11;
  617. ChessMatrix[6][2] = 11;
  618. ChessMatrix[6][3] = 11;
  619. ChessMatrix[6][4] = 11;
  620. ChessMatrix[6][5] = 11;
  621. ChessMatrix[6][6] = 11;
  622. ChessMatrix[6][7] = 11;
  623. ChessMatrix[7][0] = 12;
  624. ChessMatrix[7][1] = 13;
  625. ChessMatrix[7][2] = 14;
  626. ChessMatrix[7][3] = 16;
  627. ChessMatrix[7][4] = 15;
  628. ChessMatrix[7][5] = 14;
  629. ChessMatrix[7][6] = 13;
  630. ChessMatrix[7][7] = 12;
  631. }
  632.  
  633. if (Mode == 1) { //Update locations map
  634.  
  635. }
  636. return;
  637. }
  638. /***********************************************************************
  639. BOARD ANALYSIS
  640. ***********************************************************************/
  641. //hall vs chessmatrix
  642. //up = 1 down = 0
  643. //updates hlatch
  644. void hallvchess(void){
  645. int i;
  646. int j;
  647. int differ = 0;
  648. int rtemp;
  649. int ctemp;
  650.  
  651. for (i = 0; i < 8; i++) { //Chess row loop
  652. for (j = 0; j < 8; j++) { //Chess column loop
  653.  
  654. if(ChessMatrix[i][j] > 0){
  655. hlatch[i][j] = 1;
  656. } else {
  657. hlatch[i][j] = 0;
  658. }
  659.  
  660. if (hlatch[i][j] != HallMatrix[i][j]) { //both aren't the same
  661. differ += 1;
  662. rtemp = i;
  663. ctemp = j;
  664. }
  665. }
  666. }
  667. //if(dir == 1){
  668. uprow = rtemp;
  669. upcol = ctemp;
  670. hlatch[uprow][upcol] = 0;
  671. // } else if(dir == 0){
  672. // downrow = rtemp;
  673. // downcol = ctemp;
  674. // }
  675. if(differ == 0){
  676. sameflag = 1;
  677. } else {
  678. sameflag = 0;
  679. }
  680. }
  681.  
  682.  
  683. void hallvlatch(void){
  684. int i;
  685. int j;
  686. int differ = 0;
  687. int rtemp;
  688. int ctemp;
  689.  
  690. for (i = 0; i < 8; i++) { //Chess row loop
  691. for (j = 0; j < 8; j++) { //Chess column loop
  692.  
  693. if (hlatch[i][j] != HallMatrix[i][j]) { //both aren't the same
  694. differ += 1;
  695. rtemp = i;
  696. ctemp = j;
  697. }
  698. }
  699. }
  700. //if(dir == 1){
  701. nextrow = rtemp;
  702. nextcol = ctemp;
  703. hlatch[uprow][upcol] = 0;
  704. // } else if(dir == 0){
  705. // downrow = rtemp;
  706. // downcol = ctemp;
  707. // }
  708. if(differ == 0){
  709. sameflag = 1;
  710. } else {
  711. sameflag = 0;
  712. }
  713. }
  714.  
  715.  
  716. //updates currpc
  717. void currpccnt(void){
  718. int pcnum = 0;
  719. int i;
  720. int j;
  721.  
  722. for (i = 0; i < 8; i++) { //Chess column loop
  723. for (j = 0; j < 8; j++) { //Chess row loop
  724. if (ChessMatrix[i][j] != 0) { //if piece exists on tile
  725. pcnum += 1;
  726. }
  727. }
  728. }
  729.  
  730. currpc = pcnum;
  731.  
  732. }
  733. //updates nowpc
  734. void nowpccnt(void){
  735. int pcnum = 0;
  736. int i;
  737. int j;
  738.  
  739. for (i = 0; i < 8; i++) { //Hall column loop
  740. for (j = 0; j < 8; j++) { //Hall row loop
  741. if (HallMatrix[i][j] != 0) { //if piece exists on tile
  742. pcnum += 1;
  743. }
  744. }
  745. }
  746.  
  747. nowpc = pcnum;
  748.  
  749. }
  750.  
  751. void hpccnt(void){
  752. int pcnum = 0;
  753. int i;
  754. int j;
  755.  
  756. for (i = 0; i < 8; i++) { //Hall column loop
  757. for (j = 0; j < 8; j++) { //Hall row loop
  758. if (hlatch[i][j] != 0) { //if piece exists on tile
  759. pcnum += 1;
  760. }
  761. }
  762. }
  763.  
  764. hpc = pcnum;
  765.  
  766. }
  767.  
  768. //counts how many moves avail
  769. void movecnt(void){
  770. int pcnum = 0;
  771. int i;
  772. int j;
  773.  
  774. for (i = 0; i < 8; i++) { //Hall column loop
  775. for (j = 0; j < 8; j++) { //Hall row loop
  776. if (ldata[i][j] != 0) { //if piece exists on tile
  777. pcnum += 1;
  778. }
  779. }
  780. }
  781.  
  782. nummoves = pcnum;
  783.  
  784. }
  785.  
  786.  
  787. void puteverythingback(void){
  788.  
  789. int i;
  790. int j;
  791. int differ = 0;
  792. int temp = 0;
  793. int check = 1;
  794. ledoutmode = 0;
  795. LCD_Display(6);
  796. while(check == 1){
  797. differ = 0;
  798. for (i = 0; i < 8; i++) { //Chess row loop
  799. for (j = 0; j < 8; j++) { //Chess column loop
  800.  
  801. if(ChessMatrix[i][j] > 0){
  802. temp = 1;
  803. } else {
  804. temp = 0;
  805. }
  806. if (temp != HallMatrix[i][j]) { //both aren't the same
  807. differ += 1;
  808. }
  809. }
  810. }
  811. if(differ == 0){
  812. check = 0;
  813. }
  814.  
  815. }
  816.  
  817. pickedupflag = 0;
  818. }
  819.  
  820.  
  821. /*********************************************************************************
  822. * Name: pickedup
  823. * Description: What is done when one piece is currently picked up
  824. * [->] (int i, int j): the coordinates of the piece being picked up
  825. * [<-] (void): [pcnum]
  826. *********************************************************************************/
  827.  
  828. void pickedup(int row, int col, int piece){
  829. int type = piece % 10; // 1=pawn 2=rook 3=knight 4=bishop 5=queen 6=king
  830. int team = piece / 10; //0=white 1=black
  831.  
  832. if(type == 1){
  833. pawnled(row,col,team,0);
  834. }
  835. else if(type == 2){
  836. rookled(row,col,team);
  837. }
  838. else if(type == 3){
  839. knightled(row,col,team);
  840. }
  841. else if(type == 4){
  842. bishopled(row,col,team);
  843. }
  844. else if(type == 5){
  845. queenled(row,col,team);
  846. }
  847. else if(type == 6){
  848. kingled(row,col,team);
  849. }
  850. //movecnt();
  851. //ledcopy(5);
  852. ledoutmode = 1;
  853. }
  854.  
  855.  
  856. void setdown(int row, int col, int piece){
  857. int epiece = ChessMatrix[row][col];
  858. int type = epiece % 10; // 1=pawn 2=rook 3=knight 4=bishop 5=queen 6=king
  859. int team = piece / 10; //0=white 1=black
  860. int score;
  861.  
  862.  
  863. if(type == 1){
  864. score = 1;
  865. }
  866. else if(type == 2){
  867. score = 5;
  868. }
  869. else if(type == 3){
  870. score = 3;
  871. }
  872. else if(type == 4){
  873. score = 3;
  874. }
  875. else if(type == 5){
  876. score = 9;
  877. } else {
  878. score = 0;
  879. }
  880. if(team == 0){
  881. whitescore += score;
  882. } else if(team == 1){
  883. blackscore += score;
  884. }
  885.  
  886. ChessMatrix[row][col] = piece;
  887. ChessMatrix[uprow][upcol] = 0;
  888. ledoutmode = 0;
  889. currpccnt();
  890. nowpccnt();
  891. if(currpc != nowpc){
  892. puteverythingback();
  893. }
  894. PlayerToggle = !PlayerToggle;
  895. //movecnt();
  896. //ledcopy(5);
  897. }
  898.  
  899.  
  900.  
  901. /***********************************************************************
  902. LED/ VALID MOVE MATRIX GENERATION
  903. ***********************************************************************/
  904. //mode 0 regular //mode 1 only piece captures
  905. void pawnled(int row,int col,int team,int mode){
  906. int dir;
  907. if (team == 1){
  908. dir = -1;
  909. } else {
  910. dir = 1;
  911. }
  912.  
  913. if(mode == 0){
  914. if(ChessMatrix[row+dir][col] == 0){ //check 1 space
  915. ldata[row+dir][col] = 1;
  916. if(team == 1){ //check 2 spaces
  917. if(row == 6 && ChessMatrix[row+dir+dir][col] == 0){
  918. ldata[row+dir+dir][col] = 1;
  919. }
  920. } else {
  921. if(row == 1 && ChessMatrix[row+dir+dir][col] == 0){
  922. ldata[row+dir+dir][col] = 1;
  923. }
  924. }
  925. }
  926. }
  927.  
  928. if(col != 7 && ChessMatrix[row+dir][col+1] != 0 && (ChessMatrix[row+dir][col+1] / 10) != team){ //check right capture
  929. ldata[row+dir][col+1] = 1;
  930.  
  931. }
  932. if(col != 0 && ChessMatrix[row+dir][col-1] != 0 && (ChessMatrix[row+dir][col-1] / 10) != team){ //check left capture
  933. ldata[row+dir][col-1] = 1;
  934.  
  935. }
  936.  
  937. //pick up piece message
  938. }
  939.  
  940. void rookled(int row,int col, int team){
  941. int cscan = col;
  942. int rscan = row;
  943. int dir = 1;
  944.  
  945. while(rscan < 7){ //scan up positive row
  946. if(ChessMatrix[rscan+dir][col] == 0){
  947. ldata[rscan+dir][col] = 1;
  948. rscan += dir;
  949. } else if((ChessMatrix[rscan+dir][col] / 10) != team){
  950. ldata[rscan+dir][col] = 1;
  951. rscan = 8;
  952. } else {
  953. rscan = 8;
  954. }
  955. }
  956.  
  957. dir = -1; //reset scan parameters
  958. rscan = row;
  959.  
  960. while(rscan > 0){ //scan up negative row
  961. if(ChessMatrix[rscan+dir][col] == 0){
  962. ldata[rscan+dir][col] = 1;
  963. rscan += dir;
  964. } else if((ChessMatrix[rscan+dir][col] / 10) != team){
  965. ldata[rscan+dir][col] = 1;
  966. rscan = -1;
  967. } else {
  968. rscan = -1;
  969. }
  970. }
  971.  
  972. dir = 1;
  973.  
  974.  
  975. while(cscan < 7){ //scan up positive column
  976. if(ChessMatrix[row][cscan+dir] == 0){
  977. ldata[row][cscan+dir] = 1;
  978. cscan += dir;
  979. } else if((ChessMatrix[row][cscan+dir] / 10) != team){
  980. ldata[row][cscan+dir] = 1;
  981. cscan = 8;
  982. } else {
  983. cscan = 8;
  984. }
  985. }
  986.  
  987. dir = -1; //reset scan parameters
  988. cscan = col;
  989.  
  990. while(cscan > 0){ //
  991. if(ChessMatrix[row][cscan+dir] == 0){ //scan up negative column
  992. ldata[row][cscan+dir] = 1;
  993. cscan += dir;
  994. } else if((ChessMatrix[row][cscan+dir] / 10) != team){
  995. ldata[row][cscan+dir] = 1;
  996. cscan = -1;
  997. } else {
  998. cscan = -1;
  999. }
  1000. }
  1001. }
  1002.  
  1003. void bishopled(int row,int col,int team){
  1004. int cscan = col;
  1005. int rscan = row;
  1006. int cdir = 1;
  1007. int rdir = 1;
  1008.  
  1009. //+ + dir
  1010. while(rscan < 7 && cscan < 7){ //scan up positive row
  1011. if(ChessMatrix[rscan+rdir][cscan+cdir] == 0){
  1012. ldata[rscan+rdir][cscan+cdir] = 1;
  1013. rscan += rdir;
  1014. cscan += cdir;
  1015. } else if((ChessMatrix[rscan+rdir][cscan+cdir] / 10) != team){
  1016. ldata[rscan+rdir][cscan+cdir] = 1;
  1017. rscan = 8;
  1018. cscan = 8;
  1019. } else {
  1020. rscan = 8;
  1021. cscan = 8;
  1022. }
  1023. }
  1024.  
  1025. rscan = row;
  1026. cscan = col;
  1027. cdir = -1;
  1028.  
  1029. //- + dir
  1030. while(rscan < 7 && cscan > 0){ //scan up positive row
  1031. if(ChessMatrix[rscan+rdir][cscan+cdir] == 0){
  1032. ldata[rscan+rdir][cscan+cdir] = 1;
  1033. rscan += rdir;
  1034. cscan += cdir;
  1035. } else if((ChessMatrix[rscan+rdir][cscan+cdir] / 10) != team){
  1036. ldata[rscan+rdir][cscan+cdir] = 1;
  1037. rscan = 8;
  1038. cscan = -1;
  1039. } else {
  1040. rscan = 8;
  1041. cscan = -1;
  1042. }
  1043. }
  1044.  
  1045. rscan = row;
  1046. cscan = col;
  1047. cdir = 1;
  1048. rdir = -1;
  1049.  
  1050. //+ - dir
  1051. while(rscan > 0 && cscan < 7){ //scan up positive row
  1052. if(ChessMatrix[rscan+rdir][cscan+cdir] == 0){
  1053. ldata[rscan+rdir][cscan+cdir] = 1;
  1054. rscan += rdir;
  1055. cscan += cdir;
  1056. } else if((ChessMatrix[rscan+rdir][cscan+cdir] / 10) != team){
  1057. ldata[rscan+rdir][cscan+cdir] = 1;
  1058. rscan = -1;
  1059. cscan = 8;
  1060. } else {
  1061. rscan = -1;
  1062. cscan = 8;
  1063. }
  1064. }
  1065.  
  1066. rscan = row;
  1067. cscan = col;
  1068. cdir = -1;
  1069.  
  1070.  
  1071. //- - dir
  1072. while(rscan > 0 && cscan > 0){ //scan up positive row
  1073. if(ChessMatrix[rscan+rdir][cscan+cdir] == 0){
  1074. ldata[rscan+rdir][cscan+cdir] = 1;
  1075. rscan += rdir;
  1076. cscan += cdir;
  1077. } else if((ChessMatrix[rscan+rdir][cscan+cdir] / 10) != team){
  1078. ldata[rscan+rdir][cscan+cdir] = 1;
  1079. rscan = -1;
  1080. cscan = -1;
  1081. } else {
  1082. rscan = -1;
  1083. cscan = -1;
  1084. }
  1085. }
  1086.  
  1087. }
  1088.  
  1089. //0 good -1 not
  1090. int bcheck(int row,int col){
  1091. if(row > 7){
  1092. return -1;
  1093. } else if(col > 7){
  1094. return -1;
  1095. } else if(row < 0){
  1096. return -1;
  1097. } else if(col < 0){
  1098. return -1;
  1099. } else {
  1100. return 0;
  1101. }
  1102. }
  1103.  
  1104. void knightled(int row,int col,int team){
  1105. int cchk = col;
  1106. int rchk = row;
  1107.  
  1108. rchk += 2;
  1109. cchk += 1;
  1110.  
  1111. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1112. ldata[rchk][cchk] = 1;
  1113. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1114. ldata[rchk][cchk] = 1;
  1115. }
  1116.  
  1117. rchk = row;
  1118. cchk = col;
  1119.  
  1120. rchk += 1;
  1121. cchk += 2;
  1122.  
  1123. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1124. ldata[rchk][cchk] = 1;
  1125. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1126. ldata[rchk][cchk] = 1;
  1127. }
  1128.  
  1129. rchk = row;
  1130. cchk = col;
  1131.  
  1132. rchk += -1;
  1133. cchk += 2;
  1134.  
  1135. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1136. ldata[rchk][cchk] = 1;
  1137. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1138. ldata[rchk][cchk] = 1;
  1139. }
  1140.  
  1141. rchk = row;
  1142. cchk = col;
  1143.  
  1144. rchk += 1;
  1145. cchk += -2;
  1146.  
  1147. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1148. ldata[rchk][cchk] = 1;
  1149. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1150. ldata[rchk][cchk] = 1;
  1151. }
  1152.  
  1153. rchk = row;
  1154. cchk = col;
  1155.  
  1156. rchk += 2;
  1157. cchk += -1;
  1158.  
  1159. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1160. ldata[rchk][cchk] = 1;
  1161. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1162. ldata[rchk][cchk] = 1;
  1163. }
  1164.  
  1165. rchk = row;
  1166. cchk = col;
  1167.  
  1168. rchk += -2;
  1169. cchk += 1;
  1170.  
  1171. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1172. ldata[rchk][cchk] = 1;
  1173. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1174. ldata[rchk][cchk] = 1;
  1175. }
  1176.  
  1177. rchk = row;
  1178. cchk = col;
  1179.  
  1180. rchk += -1;
  1181. cchk += -2;
  1182.  
  1183. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1184. ldata[rchk][cchk] = 1;
  1185. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1186. ldata[rchk][cchk] = 1;
  1187. }
  1188.  
  1189. rchk = row;
  1190. cchk = col;
  1191.  
  1192. rchk += -2;
  1193. cchk += 1;
  1194.  
  1195. if (bcheck(rchk,cchk) == 0 && ChessMatrix[rchk][cchk] == 0){
  1196. ldata[rchk][cchk] = 1;
  1197. } else if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1198. ldata[rchk][cchk] = 1;
  1199. }
  1200.  
  1201. }
  1202.  
  1203. void queenled(int row,int col,int team){
  1204. bishopled(row,col,team);
  1205. rookled(row,col,team);
  1206. }
  1207.  
  1208. //mode 1 = data to temp
  1209. //mode 2 = temp back to data
  1210. //cleans the one it moved from
  1211. //mode 3 = switch data
  1212. //mode 4 = switch and filter
  1213. //mode 5 (debugging) ldata to chessmatrix
  1214. //mode 6 get rid of all 27
  1215. void ledcopy(int mode){
  1216.  
  1217. int r;
  1218. int c;
  1219. int temp;
  1220.  
  1221. for (r = 0; r < 8; r++) {
  1222. for (c = 0; c < 8; c++) {
  1223. if(mode == 1){
  1224. ltemp[r][c] = ldata[r][c];
  1225. ldata[r][c] = 0;
  1226. } else if(mode == 2) {
  1227. ldata[r][c] = ltemp[r][c];
  1228. ltemp[r][c] = 0;
  1229. } else if(mode == 3) {
  1230. temp = ltemp[r][c];
  1231. ltemp[r][c] = ldata[r][c];
  1232. ldata[r][c] = temp;
  1233. } else if(mode == 5) {
  1234. if(ldata[r][c] == 1){
  1235. ChessMatrix[r][c] = 27;
  1236. }
  1237. } else if(mode == 6) {
  1238. if(ChessMatrix[r][c] == 27){
  1239. ChessMatrix[r][c] = 0;
  1240. }
  1241. } else {
  1242. temp = ltemp[r][c];
  1243. ltemp[r][c] = ldata[r][c];
  1244. ldata[r][c] = temp;
  1245. if((ltemp[r][c] + ldata[r][c]) == 2){
  1246. ldata[r][c] = 0;
  1247. }
  1248. }
  1249. }
  1250. }
  1251. }
  1252.  
  1253. void kingledout(int row,int col,int team){
  1254. int rchk = row;
  1255. int cchk = col;
  1256.  
  1257. rchk += 1;
  1258.  
  1259. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1260. ldata[rchk][cchk] = 1;
  1261. }
  1262.  
  1263. rchk = row;
  1264. rchk += -1;
  1265.  
  1266. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1267. ldata[rchk][cchk] = 1;
  1268. }
  1269.  
  1270. rchk = row;
  1271. cchk += 1;
  1272.  
  1273. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1274. ldata[rchk][cchk] = 1;
  1275. }
  1276.  
  1277. cchk = col;
  1278. cchk += -1;
  1279.  
  1280. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1281. ldata[rchk][cchk] = 1;
  1282. }
  1283.  
  1284. cchk = col;
  1285. cchk += 1;
  1286. rchk += 1;
  1287.  
  1288. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1289. ldata[rchk][cchk] = 1;
  1290. }
  1291.  
  1292. cchk = col;
  1293. rchk = row;
  1294. cchk += -1;
  1295. rchk += 1;
  1296.  
  1297. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1298. ldata[rchk][cchk] = 1;
  1299. }
  1300.  
  1301. cchk = col;
  1302. rchk = row;
  1303. cchk += 1;
  1304. rchk += -1;
  1305.  
  1306. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1307. ldata[rchk][cchk] = 1;
  1308. }
  1309.  
  1310. cchk = col;
  1311. rchk = row;
  1312. cchk += -1;
  1313. rchk += -1;
  1314.  
  1315. if(bcheck(rchk,cchk) == 0 && (ChessMatrix[rchk][cchk] / 10) != team){
  1316. ldata[rchk][cchk] = 1;
  1317. }
  1318. }
  1319.  
  1320.  
  1321. void checkmatrix(int team){
  1322.  
  1323. int r;
  1324. int c;
  1325.  
  1326. for (r = 0; r < 8; r++) {
  1327. for (c = 0; c < 8; c++) {
  1328. if((ChessMatrix[r][c] / 10) != team){
  1329. if((ChessMatrix[r][c] % 10) == 1){
  1330. pawnled(r,c,1-team,1);
  1331. }
  1332. else if((ChessMatrix[r][c] % 10) == 2){
  1333. rookled(r,c,1-team);
  1334. }
  1335. else if((ChessMatrix[r][c] % 10) == 3){
  1336. knightled(r,c,1-team);
  1337. }
  1338. else if((ChessMatrix[r][c] % 10) == 4){
  1339. bishopled(r,c,1-team);
  1340. }
  1341. else if((ChessMatrix[r][c] % 10) == 5){
  1342. queenled(r,c,1-team);
  1343. }
  1344. else if((ChessMatrix[r][c] % 10) == 6){
  1345. kingledout(r,c,1-team);
  1346. }
  1347. }
  1348. }
  1349. }
  1350. }
  1351.  
  1352.  
  1353. void kingled(int row,int col,int team){
  1354. kingledout(row,col,team); //show possible moves without checking for check
  1355. ledcopy(1); //store in temp matrix
  1356. checkmatrix(team); //create a matrix of enemy moves
  1357. ledcopy(4); //filter the temp matrix with enemy move matrix
  1358. }
  1359.  
  1360. void ischeck(int team){
  1361. int piece;
  1362. int r;
  1363. int c;
  1364. int tempr;
  1365. int tempc;
  1366.  
  1367. if(team == 0){
  1368. piece = 6;
  1369. } else if(team == 1){
  1370. piece = 16;
  1371. }
  1372.  
  1373. for (r = 0; r < 8; r++) {
  1374. for (c = 0; c < 8; c++) {
  1375. if(ChessMatrix[r][c] == piece){
  1376. tempr = r;
  1377. tempc = c;
  1378. }
  1379. }
  1380. }
  1381.  
  1382. //checkmatrix(team);
  1383. if(ldata[tempr][tempc] == 1){
  1384. if(team == 0){
  1385. whitecheckflag = 1;
  1386. } else if (team == 1){
  1387. blackcheckflag = 1;
  1388. }
  1389. }
  1390.  
  1391.  
  1392. }
  1393.  
  1394.  
  1395.  
  1396.  
  1397.  
  1398.  
  1399.  
  1400.  
  1401. /*********************************************************************************
  1402. * SCI Functions
  1403. **********************************************************************************/
  1404.  
  1405.  
  1406. //0='*', 1=' '
  1407. void sevenchar(int mode){
  1408. int i = 0;
  1409. char a;
  1410. if(mode == 1){
  1411. a = '*';
  1412. } else {
  1413. a = ' ';
  1414. }
  1415. for (i = 0; i < 7; i++) {
  1416. addchar(a);
  1417. }
  1418.  
  1419. }
  1420.  
  1421. //2=solid line, 1=whiteblackwhiteblack, 0=blackwhiteblackwhite
  1422. void sci_outline(int mode){
  1423. int i = 0;
  1424. int j = 0;
  1425.  
  1426. if(mode == 2){
  1427. addchar('*');
  1428. for (i = 0; i < 8; i++) {
  1429. sevenchar(1);
  1430. addchar('*');
  1431. }
  1432. addchar(LF);
  1433. addchar(CR);
  1434. } else if(mode == 1){
  1435. addchar('*');
  1436. j = 0;
  1437. for (i = 0; i < 8; i++) {
  1438. j = 1 - j;
  1439. sevenchar(j);
  1440. addchar('*');
  1441. }
  1442. addchar(LF);
  1443. addchar(CR);
  1444. } else if(mode == 0){
  1445. addchar('*');
  1446. j = 1;
  1447. for (i = 0; i < 8; i++) {
  1448. j = 1 - j;
  1449. sevenchar(j);
  1450. addchar('*');
  1451. }
  1452. addchar(LF);
  1453. addchar(CR);
  1454.  
  1455. }
  1456.  
  1457. }
  1458.  
  1459.  
  1460.  
  1461. void addchar(char a){
  1462. tbuf[tin] = a;
  1463. tdata += 1;
  1464. tin += 1;
  1465. tin = tin % tsize;
  1466. }
  1467.  
  1468. void outtype(int type){
  1469. char x;
  1470. //sciset = 1 - sciset;
  1471. if(boardset == 0){
  1472. x = '*';
  1473. } else {
  1474. x = ' ';
  1475. }
  1476. if(type == 1){
  1477. addchar(x);
  1478. addchar('P');
  1479. addchar('a');
  1480. addchar('w');
  1481. addchar('n');
  1482. addchar(x);
  1483. addchar(x);
  1484. } else if(type == 2){
  1485. addchar(x);
  1486. addchar('R');
  1487. addchar('o');
  1488. addchar('o');
  1489. addchar('k');
  1490. addchar(x);
  1491. addchar(x);
  1492. } else if(type == 3){
  1493. addchar(x);
  1494. addchar('K');
  1495. addchar('n');
  1496. addchar('i');
  1497. addchar('g');
  1498. addchar('h');
  1499. addchar('t');
  1500. } else if(type == 4){
  1501. addchar(x);
  1502. addchar('B');
  1503. addchar('i');
  1504. addchar('s');
  1505. addchar('h');
  1506. addchar('o');
  1507. addchar('p');
  1508. } else if(type == 5){
  1509. addchar(x);
  1510. addchar('Q');
  1511. addchar('u');
  1512. addchar('e');
  1513. addchar('e');
  1514. addchar('n');
  1515. addchar(x);
  1516. } else if(type == 6){
  1517. addchar(x);
  1518. addchar('K');
  1519. addchar('i');
  1520. addchar('n');
  1521. addchar('g');
  1522. addchar(x);
  1523. addchar(x);
  1524. }
  1525. addchar('*');
  1526. }
  1527.  
  1528. void outteam(int team){
  1529. char x;
  1530. //boardset = 1 - sciset;
  1531. if(boardset == 1){
  1532. x = '*';
  1533. } else {
  1534. x = ' ';
  1535. }
  1536. if(team == 0){
  1537. addchar(x);
  1538. addchar('W');
  1539. addchar('h');
  1540. addchar('i');
  1541. addchar('t');
  1542. addchar('e');
  1543. addchar(x);
  1544. } else if(team == 1){
  1545. addchar(x);
  1546. addchar('B');
  1547. addchar('l');
  1548. addchar('a');
  1549. addchar('c');
  1550. addchar('k');
  1551. addchar(x);
  1552. }
  1553. addchar('*');
  1554. }
  1555. //0=team, 1=type
  1556. void sci_datafetch(int mode, int line){
  1557. int i = 0;
  1558.  
  1559.  
  1560. if(mode == 0){
  1561. for (i = 0; i < 8; i++) {
  1562. //if(ChessMatrix[line][i] == 0){
  1563. boardset = 1 - boardset;
  1564. if(HallMatrix[line][i] == 0){
  1565. sevenchar(boardset);
  1566. addchar('*');
  1567. } else {
  1568. //outteam(ChessMatrix[line][i] / 10);
  1569. outteam(HallMatrix[line][i] / 10);
  1570. }
  1571.  
  1572. }
  1573. } else {
  1574. for (i = 0; i < 8; i++) {
  1575. //if(ChessMatrix[line][i] == 0){
  1576. boardset = 1 - boardset;
  1577. if(HallMatrix[line][i] == 0){
  1578. sevenchar(1-boardset);
  1579. addchar('*');
  1580. } else {
  1581. //outtype(ChessMatrix[line][i] % 10);
  1582. outtype(HallMatrix[line][i] % 10);
  1583. }
  1584. }
  1585. //boardset = 1 - boardset;
  1586. }
  1587. //addchar('*');
  1588. addchar(LF);
  1589. addchar(CR);
  1590.  
  1591. }
  1592.  
  1593. void sciscan(void){
  1594. int i = 0;
  1595. int j = 0;
  1596. if(scioff_flag > 0){
  1597. if(scioff_flag == 3){
  1598. SCICR2 = SCICR2 & 0x7F;
  1599. //for (j = 0; j < 2; j++) {
  1600. //addchar(LF);
  1601. //addchar(CR);
  1602. //}
  1603. scioff_flag = 0;
  1604. scicountflag = 1;
  1605. }
  1606. else if(scioff_flag == 2){
  1607. scoreline += 1;
  1608. if(scoreline == 1){
  1609. addchar(LF);
  1610. addchar(CR);
  1611. addchar(LF);
  1612. addchar(CR);
  1613. for (i = 0; i < 15; i++) {
  1614. addchar(' ');
  1615. }
  1616. i = 0;
  1617. for (i = 0; i < 34; i++) {
  1618. addchar('*');
  1619. }
  1620. addchar(LF);
  1621. addchar(CR);
  1622. }
  1623. else if(scoreline == 2){
  1624. for (i = 0; i < 15; i++) {
  1625. addchar(' ');
  1626. }
  1627. addchar('*');
  1628. addchar('W');
  1629. addchar('h');
  1630. addchar('i');
  1631. addchar('t');
  1632. addchar('e');
  1633. addchar(' ');
  1634. addchar('S');
  1635. addchar('c');
  1636. addchar('o');
  1637. addchar('r');\
  1638. addchar('e');
  1639. addchar(':');
  1640. addchar(' ');
  1641. if((whitescore / 10) == 0){
  1642. addchar('0');
  1643. addchar(whitescore + 0x30);
  1644. }
  1645. else {
  1646. addchar((whitescore / 10) + 0x30);
  1647. addchar((whitescore % 10) + 0x30);
  1648. }
  1649. addchar(' ');
  1650. addchar(' ');
  1651. addchar('B');
  1652. addchar('l');
  1653. addchar('a');
  1654. addchar('c');
  1655. addchar('k');
  1656. addchar(' ');
  1657. addchar('S');
  1658. addchar('c');
  1659. addchar('o');
  1660. addchar('r');\
  1661. addchar('e');
  1662. addchar(':');
  1663. addchar(' ');
  1664.  
  1665. if((blackscore / 10) == 0){
  1666. addchar('0');
  1667. addchar(blackscore + 0x30);
  1668. }
  1669. else {
  1670. addchar((blackscore / 10) + 0x30);
  1671. addchar((blackscore % 10) + 0x30);
  1672. }
  1673. addchar('*');
  1674. addchar(LF);
  1675. addchar(CR);
  1676. }
  1677. else if(scoreline == 3){
  1678. for (i = 0; i < 15; i++) {
  1679. addchar(' ');
  1680. }
  1681. i = 0;
  1682.  
  1683. addchar('*');
  1684. for (i = 0; i < 9; i++) {
  1685. addchar(' ');
  1686. }
  1687. j = PlayerToggle + 1;
  1688.  
  1689. if(movenumber % 2){
  1690. addchar('B');
  1691. addchar('l');
  1692. addchar('a');
  1693. addchar('c');
  1694. addchar('k');
  1695. addchar(' ');
  1696. }
  1697. else {
  1698. addchar('W');
  1699. addchar('h');
  1700. addchar('i');
  1701. addchar('t');
  1702. addchar('e');
  1703. addchar(' ');
  1704. }
  1705.  
  1706. addchar('T');
  1707. addchar('u');
  1708. addchar('r');
  1709. addchar('n');
  1710. addchar(' ');
  1711. if((j / 100) == 0){
  1712. if((j / 10) == 0){
  1713. addchar('0');
  1714. addchar('0');
  1715. addchar(j + 0x30);
  1716. }
  1717. else {
  1718. addchar('0');
  1719. addchar((j / 10) + 0x30);
  1720. addchar((j % 10) + 0x30);
  1721. }
  1722. } else {
  1723. addchar((j / 100) + 0x30);
  1724. addchar(((j % 100) / 10) + 0x30);
  1725. addchar((j % 10) + 0x30);
  1726. }
  1727. i = 0;
  1728. for (i = 0; i < 9; i++) {
  1729. addchar(' ');
  1730. }
  1731. addchar('*');
  1732. addchar(LF);
  1733. addchar(CR);
  1734.  
  1735.  
  1736. }
  1737. else if(scoreline == 4){
  1738.  
  1739. for (i = 0; i < 15; i++) {
  1740. addchar(' ');
  1741. }
  1742. i = 0;
  1743. for (i = 0; i < 34; i++) {
  1744. addchar('*');
  1745. }
  1746. addchar(LF);
  1747. addchar(CR);
  1748. }
  1749. else {
  1750. scoreline = 0;
  1751. scioff_flag += 1;
  1752. //tdata -= 1;
  1753. }
  1754. }
  1755. else {
  1756. addchar('*');
  1757. sci_outline(2);
  1758.  
  1759. scioff_flag += 1;
  1760. }
  1761. }
  1762. else {
  1763. scanline();
  1764. }
  1765. }
  1766.  
  1767. void scanline(void){
  1768. int i = 0;
  1769. addchar('*');
  1770.  
  1771. sciset = 1 - sciset;
  1772. boardset = sciset;
  1773.  
  1774. if(sciline == 0){
  1775. sci_outline(2);
  1776. } else if(sciline == 1){
  1777. sci_outline(boardline % 2);
  1778. } else if(sciline == 2){
  1779. sci_datafetch(0,boardline);
  1780. } else if(sciline == 3){
  1781. sci_datafetch(1,boardline);
  1782. } else if(sciline == 4){
  1783. sci_outline(boardline % 2);
  1784. }
  1785.  
  1786. sciline += 1;
  1787. if(sciline > 4){
  1788. boardline += 1;
  1789. sciline = 0;
  1790. }
  1791.  
  1792. if(boardline > 7){
  1793. scioff_flag = 1;
  1794. boardline = 0;
  1795. }
  1796.  
  1797. }
  1798.  
  1799. /**********************************************************************************
  1800. * Name: SCI_ISR
  1801. * Description: SCI RTI for character data transfer to radial buffer.
  1802. * [->] (*): (*)
  1803. * [<-] (void): [void]
  1804. **********************************************************************************/
  1805. interrupt 20 void SCI_ISR( void)
  1806. {
  1807.  
  1808.  
  1809. int j;
  1810.  
  1811. SCISR1_TDRE; //Read status flag to ready data register
  1812.  
  1813. if(scioff_flag == 3){
  1814. scicountflag = 1;
  1815. SCICR2 = SCICR2 & 0x7F;
  1816. //tin += 1;
  1817. //tin = 0;
  1818.  
  1819. for (j = 0; j < 2; j++) {
  1820. addchar(LF);
  1821. addchar(CR);
  1822. }
  1823. scioff_flag = 0;
  1824. }
  1825.  
  1826.  
  1827. if(tdata == 0){
  1828. sciscan();
  1829. }
  1830.  
  1831. if(SCISR1 & 0x80){
  1832. SCIDRL = tbuf[tout];
  1833. tout += 1;
  1834. tout = tout % tsize;
  1835. tdata -= 1;
  1836. }
  1837.  
  1838.  
  1839.  
  1840. }
  1841.  
  1842. /*********************************************************************************
  1843. * LED Matrix Functions
  1844. **********************************************************************************
  1845. **********************************************************************************
  1846. * Name: LED_Out
  1847. * Description: Shifts out the updated LED matrix data.
  1848. * [->] (global): LEDOutData: LED lighting data, one for each row.
  1849. * [<-] (void): [void]
  1850. *********************************************************************************/
  1851. void LED_Out(void) {
  1852. int i = 0;
  1853.  
  1854. for (i = 0; i < 8; i++) {
  1855. while (SPISR_SPTEF == 0) {
  1856. //Loop until SPISR data register is empty
  1857. }
  1858.  
  1859. if(ledoutmode == 0){
  1860. SPIDR = LEDOutData[i]; //Put data into SPISR data register
  1861. } else if(ledoutmode == 1){
  1862. SPIDR = MOVEOutData[i]; //Put data into SPISR data register
  1863. }
  1864. LCD_Delay(0); //Call a delay for shifting out
  1865.  
  1866. //enable daisy chain, disable LCD
  1867. }
  1868. return;
  1869. }
  1870.  
  1871. /*********************************************************************************
  1872. * Name: LED_Test
  1873. * Description: Outs a spiral to test the matrix
  1874. * [->] (global): LEDOutData
  1875. * [<-] (void): [void]
  1876. *********************************************************************************/
  1877. void LED_Test(void) {
  1878. int i = 0;
  1879. int j = 0;
  1880. unsigned char a = 0x00;
  1881. unsigned char b = 0x00;
  1882. unsigned char c = 0x00;
  1883. int counter = 0;
  1884. int row = 0;
  1885. int k = 0;
  1886. //TIE_C7I = 0;
  1887.  
  1888. for (k = 0; k < 3; k++) {
  1889. for (j = 0; j < 9; j++) {//refreshs
  1890. for (i = 0; i < 8; i++) {//rows
  1891.  
  1892. while (SPISR_SPTEF == 0) {
  1893. //Loop until SPISR data register is empty
  1894. }
  1895.  
  1896. if (k == 0) {
  1897. if (i == 0) {
  1898. if (j == 0) { //1000 0000
  1899. counter = 0x80;
  1900. } else if (j == 1) {//1100 0000
  1901. counter = 0xC0;
  1902. } else if (j == 2) {//1110 0000
  1903. counter = 0xE0;
  1904. } else if (j == 3) {//1111 0000
  1905. counter = 0xF0;
  1906. } else if (j == 4) {//1111 1000
  1907. counter = 0xF8;
  1908. } else if (j == 5) {//1111 1100
  1909. counter = 0xFC;
  1910. } else if (j == 6) {//1111 1110
  1911. counter = 0xFE;
  1912. } else if (j == 7) {//1111 1111
  1913. counter = 0xFF;
  1914. } //else if (j == 8) {//++
  1915. //row = 1;
  1916. //}
  1917. } else if ((i != 0) && (k == 0)) {
  1918. counter = 0x00;
  1919. }
  1920.  
  1921. if ((k == 0) && (j != 8)) {
  1922. SPIDR = counter;
  1923. }
  1924.  
  1925. } else if (k == 1) {
  1926. if (i == 0) {
  1927. counter = 0xFF;
  1928. } else if (i == 1) {
  1929.  
  1930. if (j == 0) { //1111 1111 FF
  1931. counter = 0x80;
  1932. } else if (j == 1) {//0111 1111 7F
  1933. counter = 0xC0;
  1934. } else if (j == 2) {//0011 1111 3F
  1935. counter = 0xE0;
  1936. } else if (j == 3) {//0001 1111 1F
  1937. counter = 0xF0;
  1938. } else if (j == 4) {//0000 1111 0F
  1939. counter = 0xF8;
  1940. } else if (j == 5) {//0000 0111 07
  1941. counter = 0xFC;
  1942. } else if (j == 6) {//0000 0011 03
  1943. counter = 0xFE;
  1944. } else if (j == 7) {//0000 0001 01
  1945. counter = 0xFF;
  1946. } //else if (j == 8) {
  1947. //row = 2;
  1948. //}
  1949. } else if ((i != 1) && (k == 1)){
  1950. counter = 0x00;
  1951. }
  1952.  
  1953. if ((k == 1) && (j != 8)) {
  1954. SPIDR = counter;
  1955. }
  1956. } else if (k == 2) {
  1957. if ((i == 0) || (i == 1)) {
  1958. counter = 0xFF;
  1959. } else if (i == 2) {
  1960. if (j == 0) { //1111 1111 FF
  1961. counter = 0x80;
  1962. } else if (j == 1) {//0111 1111 7F
  1963. counter = 0xC0;
  1964. } else if (j == 2) {//0011 1111 3F
  1965. counter = 0xE0;
  1966. } else if (j == 3) {//0001 1111 1F
  1967. counter = 0xF0;
  1968. } else if (j == 4) {//0000 1111 0F
  1969. counter = 0xF8;
  1970. } else if (j == 5) {//0000 0111 07
  1971. counter = 0xFC;
  1972. } else if (j == 6) {//0000 0011 03
  1973. counter = 0xFE;
  1974. } else if (j == 7) {//0000 0001 01
  1975. counter = 0xFF;
  1976. }
  1977. } else if ((i != 2) && (k == 2)) {
  1978. counter = 0x00;
  1979. }
  1980.  
  1981. if ((k == 2) && (j != 8)) {
  1982. SPIDR = counter;
  1983. }
  1984. } else if (k == 3) {
  1985. if ((i == 0) || (i == 1) || (i == 2)) {
  1986. counter = 0xFF;
  1987. } else if (i == 3) {
  1988. if (j == 0) { //1111 1111 FF
  1989. counter = 0x80;
  1990. } else if (j == 1) {//0111 1111 7F
  1991. counter = 0xC0;
  1992. } else if (j == 2) {//0011 1111 3F
  1993. counter = 0xE0;
  1994. } else if (j == 3) {//0001 1111 1F
  1995. counter = 0xF0;
  1996. } else if (j == 4) {//0000 1111 0F
  1997. counter = 0xF8;
  1998. } else if (j == 5) {//0000 0111 07
  1999. counter = 0xFC;
  2000. } else if (j == 6) {//0000 0011 03
  2001. counter = 0xFE;
  2002. } else if (j == 7) {//0000 0001 01
  2003. counter = 0xFF;
  2004. }
  2005. } else {
  2006. counter = 0x00;
  2007. }
  2008.  
  2009. if ((k == 3) && (j != 8)) {
  2010. SPIDR = counter;
  2011. }
  2012. }// row if end
  2013. }//i for end
  2014.  
  2015. for (a = 0x00; a < 0xFE; a++) {
  2016. for (b = 0x00; b < 0xFE; b++) {
  2017. for (c = 0x00; c < 0x3F; c++) {
  2018. //do nothing
  2019. }
  2020. }
  2021. }
  2022. }//j for end
  2023. }//k for end
  2024. //while (SPISR_SPTEF == 0) {
  2025. //Loop until SPISR data register is empty
  2026. //}
  2027.  
  2028. //counter = 0x00;
  2029.  
  2030. }
  2031.  
  2032. /*********************************************************************************
  2033. * Name: LED_Convert
  2034. * Description: Converts chess data to LED data.
  2035. * [->] (global): LEDOutData
  2036. * ChessMatrix
  2037. * [<-] (void): [void]
  2038. *********************************************************************************/
  2039. void LED_Convert(void) {
  2040. int i = 0;
  2041. int j = 0;
  2042. int k = 0;
  2043. int temp = 1;
  2044. int temp2 = 1;
  2045. for (i = 0; i < 8; i++) { //Chess column loop
  2046. LEDOutData[i] = 0; //Clear of former data.
  2047. MOVEOutData[i] = 0;
  2048.  
  2049. for (j = 0; j < 8; j++) { //Chess row loop
  2050. if (ChessMatrix[i][j] != 0) { //if piece exists on tile
  2051. temp = 1;
  2052.  
  2053. for (k = 0; k < j; k++) { //shifting data calculation
  2054. temp = temp * 2;
  2055.  
  2056. }
  2057. LEDOutData[i] += temp;
  2058. }
  2059. if (ldata[i][j] != 0) { //if light exists in ldata
  2060. temp2 = 1;
  2061.  
  2062. for (k = 0; k < j; k++) { //shifting data calculation
  2063. temp2 = temp2 * 2;
  2064.  
  2065. }
  2066. MOVEOutData[i] += temp2;
  2067. }
  2068. }
  2069. }
  2070.  
  2071. return;
  2072. }
  2073.  
  2074. /*********************************************************************************
  2075. * Hall Sensor Functions
  2076. **********************************************************************************
  2077. **********************************************************************************
  2078. * Name: HALL_Input
  2079. * Description: Collects magnet connection data.
  2080. * [->] (global): datas
  2081. * [<-] (void): [void]
  2082. *********************************************************************************/
  2083. void HALL_Input(void) {
  2084. int i = 0;
  2085. int j = 0;
  2086. char Selector = 0x00;
  2087. int LinVal = 0;
  2088. int Temp[64];
  2089. int MatVal = 0;
  2090.  
  2091. Selector = 0x0B; //Multiplexer data slector set to highest for chip 5 (12)
  2092. for (j = 0; j < 12; j++) {//Multiplexer inputs on chip 5
  2093. while (SPISR_SPTEF == 0) {
  2094. //Loop until SPISR data register is empty
  2095. }
  2096.  
  2097. SPIDR = Selector; //Put data into SPISR data register
  2098. LCD_Delay(0);
  2099.  
  2100. //if (j == 1) {
  2101. // LineVal == 0;
  2102. //}
  2103. Temp[LinVal] = output5;
  2104. Selector -= 0x01;
  2105. LinVal++;
  2106. }
  2107.  
  2108.  
  2109. Selector = 0x0C; //Multiplexer data slector set to highest for chip 4 (13)
  2110. for (j = 0; j < 13; j++) {//Multiplexer inputs on chip 4
  2111. while (SPISR_SPTEF == 0) {
  2112. //Loop until SPISR data register is empty
  2113. }
  2114.  
  2115. SPIDR = Selector; //Put data into SPISR data register
  2116. LCD_Delay(0);
  2117.  
  2118. Temp[LinVal] = output4;
  2119. Selector -= 0x01;
  2120. LinVal++;
  2121. }
  2122.  
  2123. Selector = 0x0C; //Multiplexer data slector set to highest for chip 3 (13)
  2124. for (j = 0; j < 13; j++) {//Multiplexer inputs on chip 3
  2125. while (SPISR_SPTEF == 0) {
  2126. //Loop until SPISR data register is empty
  2127. }
  2128.  
  2129. SPIDR = Selector; //Put data into SPISR data register
  2130. LCD_Delay(0);
  2131.  
  2132. Temp[LinVal] = output3;
  2133. Selector -= 0x01;
  2134. LinVal++;
  2135. }
  2136.  
  2137. Selector = 0x0C; //Multiplexer data slector set to highest for chip 2 (13)
  2138. for (j = 0; j < 13; j++) {//Multiplexer inputs on chip 2
  2139. while (SPISR_SPTEF == 0) {
  2140. //Loop until SPISR data register is empty
  2141. }
  2142.  
  2143. SPIDR = Selector; //Put data into SPISR data register
  2144. LCD_Delay(0);
  2145.  
  2146. Temp[LinVal] = output2;
  2147. Selector -= 0x01;
  2148. LinVal++;
  2149. }
  2150.  
  2151. Selector = 0x0C; //Multiplexer data slector set to highest for chip 1 (13)
  2152. for (j = 0; j < 13; j++) {//Multiplexer inputs on chip 1
  2153. while (SPISR_SPTEF == 0) {
  2154. //Loop until SPISR data register is empty
  2155. }
  2156.  
  2157. SPIDR = Selector; //Put data into SPISR data register
  2158. LCD_Delay(0);
  2159.  
  2160. Temp[LinVal] = output;
  2161. Selector -= 0x01;
  2162. LinVal++;
  2163. }
  2164.  
  2165. for (i = 0; i < 8; i++) {
  2166. for (j = 0; j < 8; j++) {
  2167.  
  2168. HallMatrix[i][j] = Temp[MatVal];
  2169. MatVal++;
  2170. }
  2171.  
  2172. }
  2173. return;
  2174. }
  2175.  
  2176. /*********************************************************************************
  2177. * LCD Specific Functions
  2178. **********************************************************************************
  2179. **********************************************************************************
  2180. * Name: LCD_Timer
  2181. * Description: Refreshes the chess timer.
  2182. * [->] (global): P1mins: Player 1 minutes remaining
  2183. * P1secs: Player 1 seconds remaining
  2184. * P2mins: Player 2 minutes remaining
  2185. * P2secs: Player 2 seconds remaining
  2186. * [<-] (void): [void]
  2187. *********************************************************************************/
  2188. void LCD_Timer(void) {
  2189. int t1 = 0;
  2190. int t2 = 0;
  2191.  
  2192. LineOffset = 0x00;
  2193. LCD_Send_Byte(LCD_CLEAR, 1); //Instruction mode
  2194.  
  2195. LCD_Cursor_Position(1); //"White: "
  2196. LCD_Send_Byte('W',0);
  2197. LCD_Cursor_Position(1);
  2198. LCD_Send_Byte('h',0);
  2199. LCD_Cursor_Position(1);
  2200. LCD_Send_Byte('i',0);
  2201. LCD_Cursor_Position(1);
  2202. LCD_Send_Byte('t',0);
  2203. LCD_Cursor_Position(1);
  2204. LCD_Send_Byte('e',0);
  2205. LCD_Cursor_Position(1);
  2206. LCD_Send_Byte(':',0);
  2207. LCD_Cursor_Position(1);
  2208. LCD_Send_Byte(' ',0);
  2209. LCD_Cursor_Position(1);
  2210. LCD_Send_Byte(' ',0);
  2211. LCD_Cursor_Position(1);
  2212. LCD_Send_Byte(' ',0);
  2213. LCD_Cursor_Position(1);
  2214. LCD_Send_Byte(' ',0);
  2215.  
  2216.  
  2217.  
  2218. t2 = P1mins % 10; //mins:secs,
  2219. t1 = P1mins / 10;
  2220.  
  2221. LCD_Cursor_Position(1);
  2222. LCD_Send_Byte(t1 + 0x30,0);
  2223. LCD_Cursor_Position(1);
  2224. LCD_Send_Byte(t2 + 0x30,0);
  2225.  
  2226. LCD_Cursor_Position(1);
  2227. LCD_Send_Byte(':',0);
  2228.  
  2229. t2 = P1secs % 10;
  2230. t1 = P1secs / 10;
  2231.  
  2232. LCD_Cursor_Position(1);
  2233. LCD_Send_Byte(t1 + 0x30,0);
  2234. LCD_Cursor_Position(1);
  2235. LCD_Send_Byte(t2 + 0x30,0);
  2236. //----------------------- line two begins
  2237. LineOffset = 0x00;
  2238. LCD_Cursor_Position(2);
  2239. LCD_Send_Byte('B',0);
  2240. LCD_Cursor_Position(2);
  2241. LCD_Send_Byte('l',0);
  2242. LCD_Cursor_Position(2);
  2243. LCD_Send_Byte('a',0);
  2244. LCD_Cursor_Position(2);
  2245. LCD_Send_Byte('c',0);
  2246. LCD_Cursor_Position(2);
  2247. LCD_Send_Byte('k',0);
  2248. LCD_Cursor_Position(2);
  2249. LCD_Send_Byte(':',0);
  2250. LCD_Cursor_Position(2);
  2251. LCD_Send_Byte(' ',0);
  2252. LCD_Cursor_Position(2);
  2253. LCD_Send_Byte(' ',0);
  2254. LCD_Cursor_Position(2);
  2255. LCD_Send_Byte(' ',0);
  2256. LCD_Cursor_Position(2);
  2257. LCD_Send_Byte(' ',0);
  2258.  
  2259. t2 = P2mins % 10;
  2260. t1 = P2mins / 10;
  2261.  
  2262. LCD_Cursor_Position(2);
  2263. LCD_Send_Byte(t1 + 0x30,0);
  2264. LCD_Cursor_Position(2);
  2265. LCD_Send_Byte(t2 + 0x30,0);
  2266.  
  2267. LCD_Cursor_Position(2);
  2268. LCD_Send_Byte(':',0);
  2269.  
  2270. t2 = P2secs % 10;
  2271. t1 = P2secs / 10;
  2272.  
  2273. LCD_Cursor_Position(2);
  2274. LCD_Send_Byte(t1 + 0x30,0);
  2275. LCD_Cursor_Position(2);
  2276. LCD_Send_Byte(t2 + 0x30,0);
  2277.  
  2278. LCD_Cursor_Position(2);
  2279. LCD_Send_Byte(' ',0);
  2280. return;
  2281. }
  2282.  
  2283.  
  2284.  
  2285.  
  2286.  
  2287. /*********************************************************************************
  2288. * Name: LCD_Delay
  2289. * Description: Creates a delay of ~2ms or ~30cy using ASM NOPs.
  2290. * [->] (int): mode: Operational mode of the function.
  2291. * 0 = Short wait mode (~30cy)
  2292. * 1 = Long wait mode (~25,000cy) = (~2ms)
  2293. * [<-] (void): [void]
  2294. *********************************************************************************/
  2295. void LCD_Delay(int mode) {
  2296. int i = 0; //Wait loop counter
  2297.  
  2298. //Mode check
  2299. if (mode == 0) {
  2300. mode = 3;
  2301. } else if (mode == 1) {
  2302. mode = 2500;
  2303. } else {
  2304. mode = 250000000;
  2305.  
  2306. }
  2307.  
  2308. //Wait generation loop
  2309. for (i = 0; i <= mode; i++) {
  2310. asm {
  2311. nop
  2312. nop
  2313. nop
  2314. nop
  2315. nop
  2316. nop
  2317. nop
  2318. nop
  2319. nop
  2320. nop
  2321. }
  2322. }
  2323.  
  2324. return;
  2325. }
  2326.  
  2327. /*********************************************************************************
  2328. * Name: LCD_Cursor_Position
  2329. * Description: Moves the LCD Cursor vertically and horizontally.
  2330. * [->] (int): LineNumber: Declares the line number the cursor is to be moved to
  2331. * 1 = Cursor to be moved to line #1
  2332. * 2 = Cursor to be moved to line #2
  2333. * [<-] (void): [void]
  2334. *********************************************************************************/
  2335. void LCD_Cursor_Position(int LineNumber) {
  2336. LCD_Send_Byte(LCD_CURSOR, 1);
  2337.  
  2338. if (LineNumber == 1) {
  2339. LCD_Send_Byte((LCD_LINE1 + LineOffset), 1); //Instruction mode
  2340. } else {
  2341. LCD_Send_Byte((LCD_LINE2 + LineOffset), 1); //Instruction mode
  2342. }
  2343.  
  2344. LineOffset = LineOffset + 0x01;
  2345.  
  2346. return;
  2347. }
  2348.  
  2349. /*********************************************************************************
  2350. * Name: LCD_Send_Byte
  2351. * Description: Sends character or instruction through respective shift register.
  2352. * [->] (uchar): data: The byte of data to be sent through the shift register
  2353. * (int): mode: Operational mode of the function,
  2354. * 0 = Normal sending mode
  2355. * 1 = Instruction sending mode
  2356. * [<-] (void): [void]
  2357. *********************************************************************************/
  2358. void LCD_Send_Byte(char data, int mode) {
  2359.  
  2360. if (mode == 1) {
  2361. LCD_RS = 0; //Register select line low
  2362. }
  2363.  
  2364. while (SPISR_SPTEF == 0) {
  2365. //Loop until SPISR data register is empty
  2366. }
  2367.  
  2368. SPIDR = data; //Put data into SPISR data register
  2369.  
  2370. LCD_Delay(0); //Call a 30cy delay so that data can shift out
  2371.  
  2372. LCD_CLK = 0; //this may be some other clock i don't know
  2373. LCD_CLK = 1;
  2374.  
  2375. LCD_Delay(1); //Call a 2ms delay so LCD can respond
  2376.  
  2377. if (mode == 1) {
  2378. LCD_RS = 1; //Register select line high. This is the default.
  2379. }
  2380.  
  2381. return;
  2382. }
  2383.  
  2384. /*********************************************************************************
  2385. * Name: LCD_Piece_Select
  2386. * Description: Displays some text on the LCD to select a kind of piece.
  2387. * [->] (int): MsgType: The pre-rendered message to print to the LCD.
  2388. *
  2389. *
  2390. * X1 = pawn
  2391. * X2 = rook
  2392. * X3 = knight
  2393. * X4 = bishop
  2394. * X5 = Queen
  2395. *
  2396. * [<-] (void): [void]
  2397. *********************************************************************************/
  2398. void LCD_Piece_Select(int PieceType) {
  2399. LineOffset = 0x00;
  2400.  
  2401. LCD_Send_Byte(LCD_CLEAR, 1); //Instruction mode
  2402.  
  2403.  
  2404. LCD_Cursor_Position(1);
  2405. LCD_Send_Byte('S',0);
  2406. LCD_Cursor_Position(1);
  2407. LCD_Send_Byte('e',0);
  2408. LCD_Cursor_Position(1);
  2409. LCD_Send_Byte('l',0);
  2410. LCD_Cursor_Position(1);
  2411. LCD_Send_Byte('e',0);
  2412. LCD_Cursor_Position(1);
  2413. LCD_Send_Byte('c',0);
  2414. LCD_Cursor_Position(1);
  2415. LCD_Send_Byte('t',0);
  2416. LCD_Cursor_Position(1);
  2417. LCD_Send_Byte(' ',0);
  2418. LCD_Cursor_Position(1);
  2419. LCD_Send_Byte('p',0);
  2420. LCD_Cursor_Position(1);
  2421. LCD_Send_Byte('i',0);
  2422. LCD_Cursor_Position(1);
  2423. LCD_Send_Byte('e',0);
  2424. LCD_Cursor_Position(1);
  2425. LCD_Send_Byte('c',0);
  2426. LCD_Cursor_Position(1);
  2427. LCD_Send_Byte('e',0);
  2428. LCD_Cursor_Position(1);
  2429. LCD_Send_Byte(' ',0);
  2430. LCD_Cursor_Position(1);
  2431. LCD_Send_Byte(' ',0);
  2432. LCD_Cursor_Position(1);
  2433. LCD_Send_Byte(' ',0);
  2434. LineOffset = 0x00;
  2435.  
  2436. /* options for pawn to become:
  2437. * X2 = rook
  2438. * X3 = knight
  2439. * X4 = bishop
  2440. * X5 = Queen
  2441. *
  2442. */
  2443. if (PieceType == 2) {
  2444. LCD_Cursor_Position(2);
  2445. LCD_Send_Byte(' ',0);
  2446. LCD_Cursor_Position(2);
  2447. LCD_Send_Byte(' ',0);
  2448. LCD_Cursor_Position(2);
  2449. LCD_Send_Byte(' ',0);
  2450. LCD_Cursor_Position(2);
  2451. LCD_Send_Byte(' ',0);
  2452. LCD_Cursor_Position(2);
  2453. LCD_Send_Byte(' ',0);
  2454. LCD_Cursor_Position(2);
  2455. LCD_Send_Byte(' ',0);
  2456. LCD_Cursor_Position(2);
  2457. LCD_Send_Byte('R',0);
  2458. LCD_Cursor_Position(2);
  2459. LCD_Send_Byte('o',0);
  2460. LCD_Cursor_Position(2);
  2461. LCD_Send_Byte('o',0);
  2462. LCD_Cursor_Position(2);
  2463. LCD_Send_Byte('k',0);
  2464. LCD_Cursor_Position(2);
  2465. LCD_Send_Byte(' ',0);
  2466. LCD_Cursor_Position(2);
  2467. LCD_Send_Byte(' ',0);
  2468. LCD_Cursor_Position(2);
  2469. LCD_Send_Byte(' ',0);
  2470. LCD_Cursor_Position(2);
  2471. LCD_Send_Byte(' ',0);
  2472. LCD_Cursor_Position(2);
  2473. LCD_Send_Byte(' ',0);
  2474. LCD_Cursor_Position(2);
  2475. LCD_Send_Byte(' ',0);
  2476. }
  2477. if (PieceType == 3) {
  2478. LCD_Cursor_Position(2);
  2479. LCD_Send_Byte(' ',0);
  2480. LCD_Cursor_Position(2);
  2481. LCD_Send_Byte(' ',0);
  2482. LCD_Cursor_Position(2);
  2483. LCD_Send_Byte(' ',0);
  2484. LCD_Cursor_Position(2);
  2485. LCD_Send_Byte(' ',0);
  2486. LCD_Cursor_Position(2);
  2487. LCD_Send_Byte(' ',0);
  2488. LCD_Cursor_Position(2);
  2489. LCD_Send_Byte(' ',0);
  2490. LCD_Cursor_Position(2);
  2491. LCD_Send_Byte('K',0);
  2492. LCD_Cursor_Position(2);
  2493. LCD_Send_Byte('n',0);
  2494. LCD_Cursor_Position(2);
  2495. LCD_Send_Byte('i',0);
  2496. LCD_Cursor_Position(2);
  2497. LCD_Send_Byte('g',0);
  2498. LCD_Cursor_Position(2);
  2499. LCD_Send_Byte('h',0);
  2500. LCD_Cursor_Position(2);
  2501. LCD_Send_Byte('t',0);
  2502. LCD_Cursor_Position(2);
  2503. LCD_Send_Byte(' ',0);
  2504. LCD_Cursor_Position(2);
  2505. LCD_Send_Byte(' ',0);
  2506. LCD_Cursor_Position(2);
  2507. LCD_Send_Byte(' ',0);
  2508. LCD_Cursor_Position(2);
  2509. LCD_Send_Byte(' ',0);
  2510. }
  2511. if (PieceType == 4) {
  2512. LCD_Cursor_Position(2);
  2513. LCD_Send_Byte(' ',0);
  2514. LCD_Cursor_Position(2);
  2515. LCD_Send_Byte(' ',0);
  2516. LCD_Cursor_Position(2);
  2517. LCD_Send_Byte(' ',0);
  2518. LCD_Cursor_Position(2);
  2519. LCD_Send_Byte(' ',0);
  2520. LCD_Cursor_Position(2);
  2521. LCD_Send_Byte(' ',0);
  2522. LCD_Cursor_Position(2);
  2523. LCD_Send_Byte(' ',0);
  2524. LCD_Cursor_Position(2);
  2525. LCD_Send_Byte('B',0);
  2526. LCD_Cursor_Position(2);
  2527. LCD_Send_Byte('i',0);
  2528. LCD_Cursor_Position(2);
  2529. LCD_Send_Byte('s',0);
  2530. LCD_Cursor_Position(2);
  2531. LCD_Send_Byte('h',0);
  2532. LCD_Cursor_Position(2);
  2533. LCD_Send_Byte('o',0);
  2534. LCD_Cursor_Position(2);
  2535. LCD_Send_Byte('p',0);
  2536. LCD_Cursor_Position(2);
  2537. LCD_Send_Byte(' ',0);
  2538. LCD_Cursor_Position(2);
  2539. LCD_Send_Byte(' ',0);
  2540. LCD_Cursor_Position(2);
  2541. LCD_Send_Byte(' ',0);
  2542. LCD_Cursor_Position(2);
  2543. LCD_Send_Byte(' ',0);
  2544. }
  2545. if (PieceType == 5) {
  2546. LCD_Cursor_Position(2);
  2547. LCD_Send_Byte(' ',0);
  2548. LCD_Cursor_Position(2);
  2549. LCD_Send_Byte(' ',0);
  2550. LCD_Cursor_Position(2);
  2551. LCD_Send_Byte(' ',0);
  2552. LCD_Cursor_Position(2);
  2553. LCD_Send_Byte(' ',0);
  2554. LCD_Cursor_Position(2);
  2555. LCD_Send_Byte(' ',0);
  2556. LCD_Cursor_Position(2);
  2557. LCD_Send_Byte(' ',0);
  2558. LCD_Cursor_Position(2);
  2559. LCD_Send_Byte('Q',0);
  2560. LCD_Cursor_Position(2);
  2561. LCD_Send_Byte('u',0);
  2562. LCD_Cursor_Position(2);
  2563. LCD_Send_Byte('e',0);
  2564. LCD_Cursor_Position(2);
  2565. LCD_Send_Byte('e',0);
  2566. LCD_Cursor_Position(2);
  2567. LCD_Send_Byte('n',0);
  2568. LCD_Cursor_Position(2);
  2569. LCD_Send_Byte(' ',0);
  2570. LCD_Cursor_Position(2);
  2571. LCD_Send_Byte(' ',0);
  2572. LCD_Cursor_Position(2);
  2573. LCD_Send_Byte(' ',0);
  2574. LCD_Cursor_Position(2);
  2575. LCD_Send_Byte(' ',0);
  2576. LCD_Cursor_Position(2);
  2577. LCD_Send_Byte(' ',0);
  2578. }
  2579. }
  2580.  
  2581. /*********************************************************************************
  2582. * Name: LCD_Display
  2583. * Description: Displays some text on the chosen LCD.
  2584. * [->] (int): MsgType: The pre-rendered message to print to the LCD.
  2585. * 0 = "Press the shiny|button to start!"
  2586. * 1 = " --OPTION-- | >Start chess "
  2587. * 2 = " --OPTION-- | Edit timer "
  2588. * 3 = " --OPTION-- | Load Game "
  2589. * 4 = " --OPTION-- |< Save Game "
  2590. * 5 = " --PAUSED-- |Press to resume"
  2591. * [<-] (void): [void]
  2592. *********************************************************************************/
  2593. void LCD_Display(int MsgType) {
  2594. LineOffset = 0x00;
  2595.  
  2596. LCD_Send_Byte(LCD_CLEAR, 1); //Instruction mode
  2597.  
  2598. if (MsgType == 0) {
  2599. LCD_Cursor_Position(1);
  2600. LCD_Send_Byte('P',0);
  2601. LCD_Cursor_Position(1);
  2602. LCD_Send_Byte('r',0);
  2603. LCD_Cursor_Position(1);
  2604. LCD_Send_Byte('e',0);
  2605. LCD_Cursor_Position(1);
  2606. LCD_Send_Byte('s',0);
  2607. LCD_Cursor_Position(1);
  2608. LCD_Send_Byte('s',0);
  2609. LCD_Cursor_Position(1);
  2610. LCD_Send_Byte(' ',0);
  2611. LCD_Cursor_Position(1);
  2612. LCD_Send_Byte('t',0);
  2613. LCD_Cursor_Position(1);
  2614. LCD_Send_Byte('h',0);
  2615. LCD_Cursor_Position(1);
  2616. LCD_Send_Byte('e',0);
  2617. LCD_Cursor_Position(1);
  2618. LCD_Send_Byte(' ',0);
  2619. LCD_Cursor_Position(1);
  2620. LCD_Send_Byte('s',0);
  2621. LCD_Cursor_Position(1);
  2622. LCD_Send_Byte('h',0);
  2623. LCD_Cursor_Position(1);
  2624. LCD_Send_Byte('i',0);
  2625. LCD_Cursor_Position(1);
  2626. LCD_Send_Byte('n',0);
  2627. LCD_Cursor_Position(1);
  2628. LCD_Send_Byte('y',0);
  2629. LineOffset = 0x00;
  2630. LCD_Cursor_Position(2);
  2631. LCD_Send_Byte('b',0);
  2632. LCD_Cursor_Position(2);
  2633. LCD_Send_Byte('u',0);
  2634. LCD_Cursor_Position(2);
  2635. LCD_Send_Byte('t',0);
  2636. LCD_Cursor_Position(2);
  2637. LCD_Send_Byte('t',0);
  2638. LCD_Cursor_Position(2);
  2639. LCD_Send_Byte('o',0);
  2640. LCD_Cursor_Position(2);
  2641. LCD_Send_Byte('n',0);
  2642. LCD_Cursor_Position(2);
  2643. LCD_Send_Byte(' ',0);
  2644. LCD_Cursor_Position(2);
  2645. LCD_Send_Byte('t',0);
  2646. LCD_Cursor_Position(2);
  2647. LCD_Send_Byte('o',0);
  2648. LCD_Cursor_Position(2);
  2649. LCD_Send_Byte(' ',0);
  2650. LCD_Cursor_Position(2);
  2651. LCD_Send_Byte('s',0);
  2652. LCD_Cursor_Position(2);
  2653. LCD_Send_Byte('t',0);
  2654. LCD_Cursor_Position(2);
  2655. LCD_Send_Byte('a',0);
  2656. LCD_Cursor_Position(2);
  2657. LCD_Send_Byte('r',0);
  2658. LCD_Cursor_Position(2);
  2659. LCD_Send_Byte('t',0);
  2660. LCD_Cursor_Position(2);
  2661. LCD_Send_Byte('!',0);
  2662. } else if (MsgType == 1) {
  2663. LCD_Cursor_Position(1);
  2664. LCD_Send_Byte(' ',0);
  2665. LCD_Cursor_Position(1);
  2666. LCD_Send_Byte(' ',0);
  2667. LCD_Cursor_Position(1);
  2668. LCD_Send_Byte(' ',0);
  2669. LCD_Cursor_Position(1);
  2670. LCD_Send_Byte('-',0);
  2671. LCD_Cursor_Position(1);
  2672. LCD_Send_Byte('-',0);
  2673. LCD_Cursor_Position(1);
  2674. LCD_Send_Byte('O',0);
  2675. LCD_Cursor_Position(1);
  2676. LCD_Send_Byte('P',0);
  2677. LCD_Cursor_Position(1);
  2678. LCD_Send_Byte('T',0);
  2679. LCD_Cursor_Position(1);
  2680. LCD_Send_Byte('I',0);
  2681. LCD_Cursor_Position(1);
  2682. LCD_Send_Byte('O',0);
  2683. LCD_Cursor_Position(1);
  2684. LCD_Send_Byte('N',0);
  2685. LCD_Cursor_Position(1);
  2686. LCD_Send_Byte('-',0);
  2687. LCD_Cursor_Position(1);
  2688. LCD_Send_Byte('-',0);
  2689. LineOffset = 0x00;
  2690. LCD_Cursor_Position(2);
  2691. LCD_Send_Byte(' ',0);
  2692. LCD_Cursor_Position(2);
  2693. LCD_Send_Byte(0x7E,0);
  2694. LCD_Cursor_Position(2);
  2695. LCD_Send_Byte('S',0);
  2696. LCD_Cursor_Position(2);
  2697. LCD_Send_Byte('t',0);
  2698. LCD_Cursor_Position(2);
  2699. LCD_Send_Byte('a',0);
  2700. LCD_Cursor_Position(2);
  2701. LCD_Send_Byte('r',0);
  2702. LCD_Cursor_Position(2);
  2703. LCD_Send_Byte('t',0);
  2704. LCD_Cursor_Position(2);
  2705. LCD_Send_Byte(' ',0);
  2706. LCD_Cursor_Position(2);
  2707. LCD_Send_Byte('c',0);
  2708. LCD_Cursor_Position(2);
  2709. LCD_Send_Byte('h',0);
  2710. LCD_Cursor_Position(2);
  2711. LCD_Send_Byte('e',0);
  2712. LCD_Cursor_Position(2);
  2713. LCD_Send_Byte('s',0);
  2714. LCD_Cursor_Position(2);
  2715. LCD_Send_Byte('s',0);
  2716. LCD_Cursor_Position(2);
  2717. LCD_Send_Byte(' ',0);
  2718. LCD_Cursor_Position(2);
  2719. LCD_Send_Byte(' ',0);
  2720. LCD_Cursor_Position(2);
  2721. LCD_Send_Byte(' ',0);
  2722. } else if (MsgType == 2) {
  2723. LCD_Cursor_Position(1);
  2724. LCD_Send_Byte(' ',0);
  2725. LCD_Cursor_Position(1);
  2726. LCD_Send_Byte(' ',0);
  2727. LCD_Cursor_Position(1);
  2728. LCD_Send_Byte(' ',0);
  2729. LCD_Cursor_Position(1);
  2730. LCD_Send_Byte('-',0);
  2731. LCD_Cursor_Position(1);
  2732. LCD_Send_Byte('-',0);
  2733. LCD_Cursor_Position(1);
  2734. LCD_Send_Byte('O',0);
  2735. LCD_Cursor_Position(1);
  2736. LCD_Send_Byte('P',0);
  2737. LCD_Cursor_Position(1);
  2738. LCD_Send_Byte('T',0);
  2739. LCD_Cursor_Position(1);
  2740. LCD_Send_Byte('I',0);
  2741. LCD_Cursor_Position(1);
  2742. LCD_Send_Byte('O',0);
  2743. LCD_Cursor_Position(1);
  2744. LCD_Send_Byte('N',0);
  2745. LCD_Cursor_Position(1);
  2746. LCD_Send_Byte('-',0);
  2747. LCD_Cursor_Position(1);
  2748. LCD_Send_Byte('-',0);
  2749. LineOffset = 0x00;
  2750. LCD_Cursor_Position(2);
  2751. LCD_Send_Byte(' ',0);
  2752. LCD_Cursor_Position(2);
  2753. LCD_Send_Byte(' ',0);
  2754. LCD_Cursor_Position(2);
  2755. LCD_Send_Byte('E',0);
  2756. LCD_Cursor_Position(2);
  2757. LCD_Send_Byte('d',0);
  2758. LCD_Cursor_Position(2);
  2759. LCD_Send_Byte('i',0);
  2760. LCD_Cursor_Position(2);
  2761. LCD_Send_Byte('t',0);
  2762. LCD_Cursor_Position(2);
  2763. LCD_Send_Byte(' ',0);
  2764. LCD_Cursor_Position(2);
  2765. LCD_Send_Byte('T',0);
  2766. LCD_Cursor_Position(2);
  2767. LCD_Send_Byte('i',0);
  2768. LCD_Cursor_Position(2);
  2769. LCD_Send_Byte('m',0);
  2770. LCD_Cursor_Position(2);
  2771. LCD_Send_Byte('e',0);
  2772. LCD_Cursor_Position(2);
  2773. LCD_Send_Byte('r',0);
  2774. LCD_Cursor_Position(2);
  2775. LCD_Send_Byte(' ',0);
  2776. LCD_Cursor_Position(2);
  2777. LCD_Send_Byte(' ',0);
  2778. LCD_Cursor_Position(2);
  2779. LCD_Send_Byte(' ',0);
  2780. LCD_Cursor_Position(2);
  2781. LCD_Send_Byte(' ',0);
  2782. } else if (MsgType == 3) {
  2783. LCD_Cursor_Position(1);
  2784. LCD_Send_Byte(' ',0);
  2785. LCD_Cursor_Position(1);
  2786. LCD_Send_Byte(' ',0);
  2787. LCD_Cursor_Position(1);
  2788. LCD_Send_Byte(' ',0);
  2789. LCD_Cursor_Position(1);
  2790. LCD_Send_Byte('-',0);
  2791. LCD_Cursor_Position(1);
  2792. LCD_Send_Byte('-',0);
  2793. LCD_Cursor_Position(1);
  2794. LCD_Send_Byte('O',0);
  2795. LCD_Cursor_Position(1);
  2796. LCD_Send_Byte('P',0);
  2797. LCD_Cursor_Position(1);
  2798. LCD_Send_Byte('T',0);
  2799. LCD_Cursor_Position(1);
  2800. LCD_Send_Byte('I',0);
  2801. LCD_Cursor_Position(1);
  2802. LCD_Send_Byte('O',0);
  2803. LCD_Cursor_Position(1);
  2804. LCD_Send_Byte('N',0);
  2805. LCD_Cursor_Position(1);
  2806. LCD_Send_Byte('-',0);
  2807. LCD_Cursor_Position(1);
  2808. LCD_Send_Byte('-',0);
  2809. LineOffset = 0x00;
  2810. LCD_Cursor_Position(2);
  2811. LCD_Send_Byte(' ',0);
  2812. LCD_Cursor_Position(2);
  2813. LCD_Send_Byte(' ',0);
  2814. LCD_Cursor_Position(2);
  2815. LCD_Send_Byte('L',0);
  2816. LCD_Cursor_Position(2);
  2817. LCD_Send_Byte('o',0);
  2818. LCD_Cursor_Position(2);
  2819. LCD_Send_Byte('a',0);
  2820. LCD_Cursor_Position(2);
  2821. LCD_Send_Byte('d',0);
  2822. LCD_Cursor_Position(2);
  2823. LCD_Send_Byte(' ',0);
  2824. LCD_Cursor_Position(2);
  2825. LCD_Send_Byte('G',0);
  2826. LCD_Cursor_Position(2);
  2827. LCD_Send_Byte('a',0);
  2828. LCD_Cursor_Position(2);
  2829. LCD_Send_Byte('m',0);
  2830. LCD_Cursor_Position(2);
  2831. LCD_Send_Byte('e',0);
  2832. LCD_Cursor_Position(2);
  2833. LCD_Send_Byte(' ',0);
  2834. LCD_Cursor_Position(2);
  2835. LCD_Send_Byte(' ',0);
  2836. LCD_Cursor_Position(2);
  2837. LCD_Send_Byte(' ',0);
  2838. LCD_Cursor_Position(2);
  2839. LCD_Send_Byte(' ',0);
  2840. LCD_Cursor_Position(2);
  2841. LCD_Send_Byte(' ',0);
  2842. } else if (MsgType == 4) {
  2843. LCD_Cursor_Position(1);
  2844. LCD_Send_Byte(' ',0);
  2845. LCD_Cursor_Position(1);
  2846. LCD_Send_Byte(' ',0);
  2847. LCD_Cursor_Position(1);
  2848. LCD_Send_Byte(' ',0);
  2849. LCD_Cursor_Position(1);
  2850. LCD_Send_Byte('-',0);
  2851. LCD_Cursor_Position(1);
  2852. LCD_Send_Byte('-',0);
  2853. LCD_Cursor_Position(1);
  2854. LCD_Send_Byte('O',0);
  2855. LCD_Cursor_Position(1);
  2856. LCD_Send_Byte('P',0);
  2857. LCD_Cursor_Position(1);
  2858. LCD_Send_Byte('T',0);
  2859. LCD_Cursor_Position(1);
  2860. LCD_Send_Byte('I',0);
  2861. LCD_Cursor_Position(1);
  2862. LCD_Send_Byte('O',0);
  2863. LCD_Cursor_Position(1);
  2864. LCD_Send_Byte('N',0);
  2865. LCD_Cursor_Position(1);
  2866. LCD_Send_Byte('-',0);
  2867. LCD_Cursor_Position(1);
  2868. LCD_Send_Byte('-',0);
  2869. LineOffset = 0x00;
  2870. LCD_Cursor_Position(2);
  2871. LCD_Send_Byte(0x7F,0);
  2872. LCD_Cursor_Position(2);
  2873. LCD_Send_Byte(' ',0);
  2874. LCD_Cursor_Position(2);
  2875. LCD_Send_Byte('S',0);
  2876. LCD_Cursor_Position(2);
  2877. LCD_Send_Byte('a',0);
  2878. LCD_Cursor_Position(2);
  2879. LCD_Send_Byte('v',0);
  2880. LCD_Cursor_Position(2);
  2881. LCD_Send_Byte('e',0);
  2882. LCD_Cursor_Position(2);
  2883. LCD_Send_Byte(' ',0);
  2884. LCD_Cursor_Position(2);
  2885. LCD_Send_Byte('G',0);
  2886. LCD_Cursor_Position(2);
  2887. LCD_Send_Byte('a',0);
  2888. LCD_Cursor_Position(2);
  2889. LCD_Send_Byte('m',0);
  2890. LCD_Cursor_Position(2);
  2891. LCD_Send_Byte('e',0);
  2892. LCD_Cursor_Position(2);
  2893. LCD_Send_Byte(' ',0);
  2894. LCD_Cursor_Position(2);
  2895. LCD_Send_Byte(' ',0);
  2896. LCD_Cursor_Position(2);
  2897. LCD_Send_Byte(' ',0);
  2898. LCD_Cursor_Position(2);
  2899. LCD_Send_Byte(' ',0);
  2900. LCD_Cursor_Position(2);
  2901. LCD_Send_Byte(' ',0);
  2902. } else if (MsgType == 5) {
  2903. LCD_Cursor_Position(1);
  2904. LCD_Send_Byte('P',0);
  2905. LCD_Cursor_Position(1);
  2906. LCD_Send_Byte('u',0);
  2907. LCD_Cursor_Position(1);
  2908. LCD_Send_Byte('t',0);
  2909. LCD_Cursor_Position(1);
  2910. LCD_Send_Byte(' ',0);
  2911. LCD_Cursor_Position(1);
  2912. LCD_Send_Byte('E',0);
  2913. LCD_Cursor_Position(1);
  2914. LCD_Send_Byte('v',0);
  2915. LCD_Cursor_Position(1);
  2916. LCD_Send_Byte('e',0);
  2917. LCD_Cursor_Position(1);
  2918. LCD_Send_Byte('r',0);
  2919. LCD_Cursor_Position(1);
  2920. LCD_Send_Byte('y',0);
  2921. LCD_Cursor_Position(1);
  2922. LCD_Send_Byte(' ',0);
  2923. LCD_Cursor_Position(1);
  2924. LCD_Send_Byte(' ',0);
  2925. LCD_Cursor_Position(1);
  2926. LCD_Send_Byte(' ',0);
  2927. LCD_Cursor_Position(1);
  2928. LCD_Send_Byte(' ',0);
  2929. LineOffset = 0x00;
  2930. LCD_Cursor_Position(2);
  2931. LCD_Send_Byte(0x7F,0);
  2932. LCD_Cursor_Position(2);
  2933. LCD_Send_Byte('T',0);
  2934. LCD_Cursor_Position(2);
  2935. LCD_Send_Byte('h',0);
  2936. LCD_Cursor_Position(2);
  2937. LCD_Send_Byte('i',0);
  2938. LCD_Cursor_Position(2);
  2939. LCD_Send_Byte('n',0);
  2940. LCD_Cursor_Position(2);
  2941. LCD_Send_Byte('g',0);
  2942. LCD_Cursor_Position(2);
  2943. LCD_Send_Byte(' ',0);
  2944. LCD_Cursor_Position(2);
  2945. LCD_Send_Byte('B',0);
  2946. LCD_Cursor_Position(2);
  2947. LCD_Send_Byte('a',0);
  2948. LCD_Cursor_Position(2);
  2949. LCD_Send_Byte('c',0);
  2950. LCD_Cursor_Position(2);
  2951. LCD_Send_Byte('k',0);
  2952. LCD_Cursor_Position(2);
  2953. LCD_Send_Byte('!',0);
  2954. LCD_Cursor_Position(2);
  2955. LCD_Send_Byte(' ',0);
  2956. LCD_Cursor_Position(2);
  2957. LCD_Send_Byte(' ',0);
  2958. LCD_Cursor_Position(2);
  2959. LCD_Send_Byte(' ',0);
  2960. LCD_Cursor_Position(2);
  2961. LCD_Send_Byte(' ',0);
  2962. } else if (MsgType == 6) {
  2963. LCD_Cursor_Position(1);
  2964. LCD_Send_Byte('S',0);
  2965. LCD_Cursor_Position(1);
  2966. LCD_Send_Byte('e',0);
  2967. LCD_Cursor_Position(1);
  2968. LCD_Send_Byte('t',0);
  2969. LCD_Cursor_Position(1);
  2970. LCD_Send_Byte(' ',0);
  2971. LCD_Cursor_Position(1);
  2972. LCD_Send_Byte('d',0);
  2973. LCD_Cursor_Position(1);
  2974. LCD_Send_Byte('o',0);
  2975. LCD_Cursor_Position(1);
  2976. LCD_Send_Byte('w',0);
  2977. LCD_Cursor_Position(1);
  2978. LCD_Send_Byte('n',0);
  2979. LCD_Cursor_Position(1);
  2980. LCD_Send_Byte(' ',0);
  2981. LCD_Cursor_Position(1);
  2982. LCD_Send_Byte('o',0);
  2983. LCD_Cursor_Position(1);
  2984. LCD_Send_Byte('r',0);
  2985. LCD_Cursor_Position(1);
  2986. LCD_Send_Byte(' ',0);
  2987. LCD_Cursor_Position(1);
  2988. LCD_Send_Byte(' ',0);
  2989. LineOffset = 0x00;
  2990. LCD_Cursor_Position(2);
  2991. LCD_Send_Byte(0x7F,0);
  2992. LCD_Cursor_Position(2);
  2993. LCD_Send_Byte('p',0);
  2994. LCD_Cursor_Position(2);
  2995. LCD_Send_Byte('i',0);
  2996. LCD_Cursor_Position(2);
  2997. LCD_Send_Byte('c',0);
  2998. LCD_Cursor_Position(2);
  2999. LCD_Send_Byte('k',0);
  3000. LCD_Cursor_Position(2);
  3001. LCD_Send_Byte('.',0);
  3002. LCD_Cursor_Position(2);
  3003. LCD_Send_Byte('u',0);
  3004. LCD_Cursor_Position(2);
  3005. LCD_Send_Byte('p',0);
  3006. LCD_Cursor_Position(2);
  3007. LCD_Send_Byte(' ',0);
  3008. LCD_Cursor_Position(2);
  3009. LCD_Send_Byte('o',0);
  3010. LCD_Cursor_Position(2);
  3011. LCD_Send_Byte('t',0);
  3012. LCD_Cursor_Position(2);
  3013. LCD_Send_Byte('h',0);
  3014. LCD_Cursor_Position(2);
  3015. LCD_Send_Byte('e',0);
  3016. LCD_Cursor_Position(2);
  3017. LCD_Send_Byte('r',0);
  3018. LCD_Cursor_Position(2);
  3019. LCD_Send_Byte('.',0);
  3020. LCD_Cursor_Position(2);
  3021. LCD_Send_Byte(' ',0);
  3022.  
  3023. }
  3024.  
  3025. }
  3026.  
  3027.  
  3028. /*********************************************************************************
  3029. * Interrupt Functions
  3030. **********************************************************************************
  3031. **********************************************************************************
  3032. * Name: RTI_ISR
  3033. * Description: Interrupt at 2.048ms intervals. Checks pushbutton states.
  3034. * [->] (*): (*)
  3035. * [<-] (void): [void]
  3036. *********************************************************************************/
  3037. interrupt 7 void RTI_ISR(void)
  3038. {
  3039. CRGFLG = CRGFLG | 0x80; //Enable
  3040.  
  3041. //debug pushbuttons on docking board
  3042. /*if ((TOP_BTN == 0) && (new_TOP_BTN == 0)) {
  3043. new_TOP_BTN = 1;
  3044. }
  3045. if ((BTM_BTN == 0) && (new_BTM_BTN == 0)) {
  3046. new_BTM_BTN = 1;
  3047. }*/
  3048.  
  3049. if((RPG_BTN == 1) && (prevRPGbutton ==0)) {
  3050. newRPGbutton = 1;
  3051. }
  3052. prevRPGbutton = RPG_BTN;
  3053.  
  3054. if(RPG_A == 1) {
  3055. RPGRightTurns++;
  3056.  
  3057. if(RPGLeftTurns > 3) {
  3058. RPGLeft = 1;
  3059. }
  3060.  
  3061. RPGLeftTurns = 0;
  3062. }
  3063.  
  3064.  
  3065. if(RPG_B == 1) {
  3066. RPGLeftTurns++;
  3067.  
  3068. if(RPGRightTurns > 3) {
  3069. RPGRight = 1;
  3070. }
  3071.  
  3072. RPGRightTurns = 0;
  3073. }
  3074. }
  3075.  
  3076. /**********************************************************************************
  3077. * Name: TIM_ISR
  3078. * Description: TIM RTI at 10ms for 100 packets. Updates timer.
  3079. * [->] (*): (*)
  3080. * [<-] (void): [void]
  3081. **********************************************************************************/
  3082. interrupt 15 void TIM_ISR( void)
  3083. {
  3084. TFLG1 = TFLG1 | 0x80; //Enable
  3085.  
  3086. TimerCounter++; //Another 10ms have passed
  3087.  
  3088. if (TimerCounter == 100) { //100 10ms interrupts accumulated
  3089. //enable2 = 1;
  3090. //HALL_Input();
  3091. //enable2 = 0;
  3092.  
  3093. RefreshHall = 1;
  3094. if (PlayerToggle == 0) { //player is white
  3095. if (P1secs == 0) { //XX:00 is white timer
  3096. P1mins--;
  3097. P1secs = 59;
  3098.  
  3099. if(P1mins <= 0 && P1secs <= 0) { //timer lock at 00:00
  3100. P1mins = 0;
  3101. P1secs = 0;
  3102. TimerExpired = 1;
  3103. TimerRunning = 0;
  3104. TIE_C7I = 0;
  3105. }
  3106. } else { //XX:XX is white timer
  3107. P1secs--;
  3108. }
  3109. } else { //player is black
  3110. if (P2secs == 0) { //XX:00 is black timer
  3111. P2mins--;
  3112. P2secs = 59;
  3113.  
  3114. if(P2mins <= 0 && P2secs <= 0) { //timer lock at 00:00
  3115. P2mins = 0;
  3116. P2secs = 0;
  3117. TimerExpired = 1;
  3118. TimerRunning = 0;
  3119. TIE_C7I = 0;
  3120. }
  3121. } else { //XX:XX is black timer
  3122. P2secs--;
  3123. }
  3124. }
  3125. TimerRefresh = 1;
  3126. TimerCounter = 0;
  3127. }
  3128.  
  3129. if(scicountflag = 1){
  3130. scicount += 1;
  3131. if(scicount == 200){
  3132. //10 seconds have passed
  3133. scicount = 0;
  3134. SCICR2 = SCICR2 | 0x80;
  3135. scicountflag = 0;
  3136. }
  3137. }
  3138. }
  3139.  
  3140.  
  3141.  
  3142. /*********************************************************************************
  3143. * Sound Generation Functions
  3144. **********************************************************************************
  3145. **********************************************************************************
  3146. * Name: Play_Sound
  3147. * Description: Generates sounds based on what is current required.
  3148. * [->] (int): Mode: The type of sound that will be output.
  3149. * 0 = "Error" sound (buzz)
  3150. * 1 = "White's turn" sound (boop beep)
  3151. * 2 = "Black's turn" sound (beep boop)
  3152. * 3 = "Mystery" sound (whoop)
  3153. * [<-] (void): [void]
  3154. *********************************************************************************/
  3155. void Play_Sound(int mode) {
  3156. unsigned char a = 0; //Looping variables
  3157. unsigned char b = 0;
  3158. unsigned char c = 0;
  3159. unsigned char d = 0;
  3160. unsigned char e = 0;
  3161.  
  3162. if (mode == 0) {
  3163. for (a = 0; a <= 4; a++) {
  3164. for (b = 0xFF; b >= 0x01; b--) {
  3165. PWMPER0 = 0xFF;
  3166.  
  3167. for (c = 0x00; c <= 0xFE; c++) {
  3168. PWMDTY0 = c;
  3169.  
  3170. for (d = 0; d < 1; d++) {
  3171. for (e = 0; e < 1; e++) {
  3172. }
  3173. }
  3174. }
  3175.  
  3176. for (c = 0xFF; c >= 0x01; c--) {
  3177. PWMDTY0 = c;
  3178. for (d = 0; d < 1; d++) {
  3179. for (e = 0; e < 1; e++) {
  3180. }
  3181. }
  3182. }
  3183. }
  3184. for (d = 0; d < 1; d++) {
  3185. for (e = 0; e < 100; e++) {
  3186. }
  3187. }
  3188. }
  3189. PWMDTY0 = 0x00;
  3190.  
  3191. } else if (mode == 1) {
  3192. PWMDTY0 = 175;
  3193.  
  3194.  
  3195. for (a = 0; a < 0xFF; a++) {
  3196. for (b = 0; b < 0xFF; b++) {
  3197. for (c = 0; c < 0x0F; c++) {
  3198. //do nothing
  3199. }
  3200. }
  3201. }
  3202.  
  3203. PWMDTY0 = 225;
  3204.  
  3205. for (a = 0; a < 0xFF; a++) {
  3206. for (b = 0; b < 0xFF; b++) {
  3207. for (c = 0; c < 0x0F; c++) {
  3208. //do nothing
  3209. }
  3210. }
  3211. }
  3212.  
  3213. PWMDTY0 = 0x00;
  3214.  
  3215. } else if (mode == 2) {
  3216. PWMPER0 = 0xFF;
  3217. PWMDTY0 = 225;
  3218.  
  3219.  
  3220. for (a = 0; a < 0xFF; a++) {
  3221. for (b = 0; b < 0xFF; b++) {
  3222. for (c = 0; c < 0x0F; c++) {
  3223. //do nothing
  3224. }
  3225. }
  3226. }
  3227.  
  3228. PWMDTY0 = 175;
  3229.  
  3230. for (a = 0; a < 0xFF; a++) {
  3231. for (b = 0; b < 0xFF; b++) {
  3232. for (c = 0; c < 0x0F; c++) {
  3233. //do nothing
  3234. }
  3235. }
  3236. }
  3237.  
  3238. PWMDTY0 = 0x00;
  3239. } else if (mode == 3) {
  3240. for (a = 0; a < 0xFE; a++) {
  3241. PWMDTY0 = a;
  3242. for (b = 0; b < 0xFF; b++) {
  3243. for (c = 0; c < 0x0F; c++) {
  3244. //do nothing
  3245. }
  3246. }
  3247. }
  3248. for (a = 0; a < 0xFE; a++) {
  3249. PWMDTY0 = 0xFE - a;
  3250.  
  3251. for (b = 0; b < 0xFF; b++) {
  3252. for (c = 0; c < 0x0F; c++) {
  3253. //do nothing
  3254. }
  3255. }
  3256. }
  3257. PWMDTY0 = 0;
  3258. }
  3259.  
  3260. return;
  3261. }
  3262.  
  3263. /*********************************************************************************
  3264. * Character I/O Library Routines
  3265. **********************************************************************************
  3266. **********************************************************************************
  3267. * Name: inchar
  3268. * Description: Inputs ASCII character from SCI serial port and returns it.
  3269. * [->] (void): [void]
  3270. * [<-] (char): ASCII value from Teraterm .
  3271. *********************************************************************************/
  3272. char inchar(void) {
  3273. /* receives character from the terminal channel */
  3274. while (!(SCISR1 & 0x20)); /* wait for input */
  3275. return SCIDRL;
  3276. }
  3277.  
  3278. /*********************************************************************************
  3279. * Name: outchar
  3280. * Description: Outputs ASCII character to the SCI serial port.
  3281. * [->] (char): ASCII value.
  3282. * [<-] (void): [void]
  3283. *********************************************************************************/
  3284. void outchar(char ch) {
  3285. /* sends a character to the terminal channel */
  3286. while (!(SCISR1 & 0x80)); /* wait for output buffer empty */
  3287. SCIDRL = ch;
  3288. }
  3289.  
  3290. /**********************************************************************************
  3291. * Name: bco
  3292. * Description: Outputs character data in radial buffer to serial.
  3293. * [->] (*): (*)
  3294. * [<-] (void): [void]
  3295. **********************************************************************************/
  3296. void bco(char input)
  3297. {
  3298. while(((tin + 1) % tsize) == tout) {}
  3299. tbuf[tin] = input;
  3300. tin = (tin + 1) % tsize;
  3301.  
  3302. SCICR2 = SCICR2 | 0x80;
  3303. }
  3304.  
  3305. /*********************************************************************************
  3306. * ECE 362 - Mini-Project C Source File - Fall 2012
  3307. *********************************************************************************/
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!