API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 27th, 2020
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.33 KB | None | 0 0
raw download clone embed print report
  1. #include<msp430x14x.h>
  2. #include "lcd.h"
  3. #include "portyLcd.h"
  4. #include "uart.h"
  5. #include "portyUart.h"
  6. #include <time.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #define STATUS_ON P2OUT&=~BIT1
  10. #define STATUS_OFF P2OUT|=BIT1
  11. #define BUZ1_HI P4OUT|=BIT2
  12. #define BUZ1_LOW P4OUT&=~BIT2
  13. #define BUZ2_HI P4OUT|=BIT3
  14. #define BUZ2_LOW P4OUT&=~BIT3
  15. #define FREQ_BUZ 2000
  16. #define LIGHT 2
  17. #define BUZZER 2
  18. #define IloscZyc 4
  19. #define B1 P4IN&BIT4
  20. #define B2 P4IN&BIT5
  21. #define B3 P4IN&BIT6
  22. #define B4 P4IN&BIT7
  23. #include "portyUart.h"
  24. #include "uart.h"
  25. char poziomy_trudnosci1[] = { 'D', 'i', 'f', 'f', 'i', 'c', 'u', 'l', 't', 'y', ':' };
  26. char opis_gry[] = { 'D', 'i', 'f', 'f', 'i', 'c', 'u', 'l', 't', 'y', ':' };
  27.  
  28. char macierz[][16] = {
  29. { 'G','a','m','e',' ','d','e','s','c','r','i','p','t','i','o','n'},
  30. { 'T','h','e',' ','g','a','m','e',' ','i','s',' ','t','o',' ',' ' },
  31. { 'r','e','p','e','a','t',' ','a',' ','s','e','q','u','e','n','-' },
  32. { 'c','e','s',' ','o','f',' ','n','u','m','b','e','r',' ',' ',' ' },
  33. { 'u','s','i','n','g',' ','b','u','t','t','o','n','s','.',' ',' ' },
  34. { ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ' },
  35. };
  36.  
  37. int goToDraw = 1;
  38. char Bufor[30]; // bufor odczytywanych danych
  39. int low = 0; // znacznik począteku danych w buforze
  40. int high = 0;
  41. //---------------- zmienne globalne -------------
  42. char napis[] = { 'P', ':', 'H', ':' };
  43. unsigned int i = 0;
  44. unsigned int sekundy = 0;
  45. unsigned int licznik = 0;
  46. int Punkty = 0;
  47. int przycisniety_przycisk = 0;
  48. int iteracja = 0;
  49. int wynik[4];
  50. int czas = 1, zycia = IloscZyc, StanGry = 1;
  51. int czy_chcemy_wyswietlac = 1;
  52. char GameOver[] = { 'G', 'a', 'm', 'e', ' ', 'O', 'v', 'e', 'r' };
  53. char opisgry[] = { 'P', 'l', 'a', 'y', ' ', '1', ' ', 'S', 'c', 'o', 'r', 'e', 's', ' ', '2' };
  54. char opisgry1[] = { 'D', 'e', 's', 'c', 'r', 'i', 'p', ' ', '3', ' ', 'L', 'e', 'v', 'e', 'l', '4' };
  55. int max1 = 0;
  56. int max2 = 0;
  57. int max3 = 0;
  58. void initPortyUart(void)
  59. {
  60. P3SEL |= Tx + Rx;
  61. P3DIR |= Tx;
  62. P3DIR &= ~Rx;
  63. }
  64. void initUart(int Speed)
  65. {
  66. int i;
  67. BCSCTL1 |= XTS; // ACLK = LFXT1 = HF XTAL 8MHz
  68. do
  69. {
  70. IFG1 &= ~OFIFG; // Czyszczenie flgi OSCFault
  71. for (i = 0xFF; i > 0; i--) ; // odczekanie
  72. }
  73. while ((IFG1 & OFIFG)); // dopóki OSCFault jest ci1gle ustawiona
  74. BCSCTL2 |= SELM1 + SELM0; // MCLK =LFXT1
  75.  
  76. switch (Speed)
  77. {
  78. case 1200:
  79. {
  80. ME1 |= UTXE0 + URXE0; // W31czenie USART0 TXD/RXD
  81. UCTL0 |= CHAR; // 8-bitów
  82. UTCTL0 |= SSEL0; // UCLK = ACLK
  83. UBR00 = 0x0A; // 8MHz/Speed in Bauds
  84. UBR10 = 0x1A; //
  85. UMCTL0 = 0x5B; // Modulation
  86. UCTL0 &= ~SWRST; // Inicjalizacja UARTA
  87. IE1 |= URXIE0; // W31czenie przerwan od RX
  88. break;
  89. }
  90. }
  91. }
  92.  
  93. //---------------- wysy3anie znaku ---------
  94. void UartCharTransmit(unsigned char znak)
  95. {
  96. while ((IFG1 & UTXIFG0) == 0) ; // gdy uk31d nie jest zajety
  97. TXBUF0 = znak; // wysy3amy znak
  98. }
  99.  
  100. //---------------- wysy3anie napisu ----------
  101. void UartStringTransmit(char* napis)
  102. {
  103. while (*napis)
  104. UartCharTransmit(*napis++);
  105. }
  106. void Clock(void);
  107. void delay(unsigned int n)
  108. {
  109. unsigned int i;
  110. for (i = 0; i < n; i++) { };
  111. }
  112. void draw()
  113. {
  114. for (int i = 0; i < 4; i++)
  115. {
  116.  
  117. Delayx100us(5); Delayx100us(5); Delayx100us(5); Delayx100us(5); Delayx100us(5); Delayx100us(5);
  118. wynik[i] = (rand() % 4) + 1;
  119. Delayx100us(5);
  120. }
  121. for (int p = 0; p < 200; p++)
  122. {
  123. Delayx100us(5);
  124. }
  125. for (int i = 0; i < 4; i++)
  126. {
  127. SEND_CMD(CUR_SHIFT_LEFT);
  128. }
  129. SEND_CMD(DD_RAM_ADDR);
  130. }
  131. void gameDescription()
  132. {
  133. clearDisplay();
  134. SEND_CMD(DD_RAM_ADDR);
  135. for (int o = 0; o < 6; o++)
  136. {
  137. SEND_CMD(DD_RAM_ADDR);
  138. for (int j = 0; j < 16; j++)
  139. SEND_CHAR(macierz[o][j]);
  140. SEND_CMD(DD_RAM_ADDR2);
  141. o++;
  142. for (int j = 0; j < 16; j++)
  143. SEND_CHAR(macierz[o][j]);
  144. for (int o = 0; o < 60; o++)
  145. Delay(40000);
  146. clearDisplay();
  147. }
  148. }
  149. void wypisz()
  150. {
  151. for (int o = 0; o < 3; o++)
  152. SEND_CHAR(' ');
  153. for (int o = 0; o < 2; o++)
  154. SEND_CHAR(napis[o]);
  155. printDecDigit(Punkty / 10);
  156. printDecDigit(Punkty % 10);
  157. SEND_CHAR(' ');
  158. for (int o = 2; o < 4; o++)
  159. SEND_CHAR(napis[o]);
  160. printDecDigit(zycia);
  161. }
  162. void inscriptionLevelsOfDifficulty()
  163. {
  164. SEND_CMD(DD_RAM_ADDR);
  165. for (int o = 0; o < 11; o++)
  166. SEND_CHAR(poziomy_trudnosci1[o]);
  167. SEND_CMD(DD_RAM_ADDR2);
  168. SEND_CHAR(' ');
  169. printDecDigit(1);
  170. for (int o = 0; o < 3; o++)
  171. SEND_CHAR(' ');
  172. printDecDigit(2);
  173. for (int o = 0; o < 3; o++)
  174. SEND_CHAR(' ');
  175. printDecDigit(3);
  176. for (int o = 0; o < 3; o++)
  177. SEND_CHAR(' ');
  178. printDecDigit(4);
  179. for (int o = 0; o < 3; o++)
  180. SEND_CHAR(' ');
  181. for (int o = 0; o < 60; o++)
  182. Delay(4000);
  183. }
  184. void theBestResults()
  185. {
  186. clearDisplay();
  187. SEND_CMD(DD_RAM_ADDR);
  188. printDecDigit(max3 / 10);
  189. printDecDigit(max3 % 10);
  190. SEND_CHAR(' ');
  191. for (int o = 0; o < 30; o++)
  192. Delay(40000);
  193. printDecDigit(max2 / 10);
  194. printDecDigit(max2 % 10);
  195. SEND_CHAR(' ');
  196. for (int o = 0; o < 30; o++)
  197. Delay(40000);
  198. printDecDigit(max1 / 10);
  199. printDecDigit(max1 % 10);
  200. SEND_CHAR(' ');
  201. for (int o = 0; o < 60; o++)
  202. Delay(40000);
  203. clearDisplay();
  204. }
  205. void buzz()
  206. {
  207. P2DIR |= 0x02; // ustawienie P2.1 jako wyjocie
  208. P4DIR |= BIT2 | BIT3; // P4.2 i P4.3 wyjocia
  209. BUZ1_LOW;
  210. BUZ2_LOW;
  211. int k = 0;
  212. for (;;)
  213. {
  214. for (i = 0; i < BUZZER; i++) //uruchomienie brzeczyka
  215. {
  216. BUZ1_LOW;
  217. BUZ2_HI;
  218. delay(FREQ_BUZ);
  219. BUZ1_HI;
  220. BUZ2_LOW;
  221. delay(FREQ_BUZ);
  222. }
  223. BUZ1_LOW;
  224. k++;
  225. if (k == 50)
  226. break;
  227. }
  228. }
  229. //----------------- main program -------------------
  230. void main(void )
  231. {
  232.  
  233. P2DIR |= BIT1;
  234. P4DIR &= ~BIT4;
  235. P4DIR &= ~BIT5;
  236. P4DIR &= ~BIT6;
  237. P4DIR &= ~BIT7;
  238.  
  239.  
  240. WDTCTL = WDTPW + WDTHOLD; // wyłączenie WDT
  241.  
  242. InitPortsLcd(); // inicjalizacja portów LCD
  243. InitLCD(); // czyszczenie wyświetlacza
  244. initPortyUart(); // inicjalizacja LCD
  245. clearDisplay(); // czyszczenie wyświetlacza
  246. srand(time(NULL));
  247.  
  248. // Basic Clock Module ustawiamy na ACLK(zegar 8 MHz ) i dzielimy częstotliwość przez 2 (4 MHz)
  249. BCSCTL1 |= XTS; // ACLK = LFXT1 = HF XTAL 8MHz
  250.  
  251. do
  252. {
  253. IFG1 &= ~OFIFG; // Czyszczenie flgi OSCFault
  254. for (int i = 0xFF; i > 0; i--) ; // odczekanie
  255. }
  256. while ((IFG1 & OFIFG) == OFIFG); // dopóki OSCFault jest ciągle ustawiona
  257.  
  258. //BCSCTL1 |= DIVA_1; // ACLK=8 MHz/2=4 MHz
  259. BCSCTL2 |= SELM0 | SELM1; // MCLK= LFTX1 =ACLK
  260.  
  261. // Timer_A ustawiamy na 500 kHz
  262. // a przerwanie generujemy co 100 ms
  263. TACTL = TASSEL_1 + MC_1 + ID_3; // Wybieram ACLK, ACLK/8=500kHz,tryb Up
  264. CCTL0 = CCIE; // włączenie przerwań od CCR0
  265. CCR0 = 50000; // podzielnik 50000: przerwanie co 100 ms
  266. ME1 |= UTXE0 + URXE0; // W31czenie USART0 TXD/RXD
  267. UCTL0 |= CHAR; // 8-bitów
  268. UTCTL0 |= SSEL0; // UCLK = ACLK
  269. UBR00 = 0x0A; // 8MHz/Speed in Bauds
  270. UBR10 = 0x1A; //
  271. UMCTL0 = 0x5B; // Modulation
  272. UCTL0 &= ~SWRST; // Inicjalizacja UARTA
  273. IE1 |= URXIE0;
  274.  
  275. _EINT();
  276.  
  277.  
  278.  
  279. clearDisplay();
  280. P2OUT |= BIT1;
  281. while (1)
  282. {
  283. while (1)
  284. {
  285.  
  286. if ((B1) && (B2) && (B3) && (B4))
  287. {
  288. SEND_CMD(DD_RAM_ADDR);
  289. for (int p = 0; p < 15; p++)
  290. SEND_CHAR(opisgry[p]);
  291. SEND_CMD(DD_RAM_ADDR2);
  292. for (int p = 0; p < 16; p++)
  293. SEND_CHAR(opisgry1[p]);
  294.  
  295. }
  296. else if (!(B1))
  297. {
  298. clearDisplay();
  299. break;
  300. }
  301. else if (!(B2))
  302. {
  303. theBestResults();
  304. }
  305. else if (!(B3))
  306. {
  307. gameDescription();
  308. }
  309. else if (!(B4))
  310. {
  311. clearDisplay();
  312. inscriptionLevelsOfDifficulty();
  313.  
  314. while (1)
  315. {
  316. if (!(B1))
  317. {
  318. czas = 8;
  319. for (int o = 0; o < 60; o++)
  320. {
  321. Delay(4000);
  322. }
  323. break;
  324. //goto start;
  325. }
  326. if (!(B2))
  327. {
  328. czas = 4;
  329. for (int o = 0; o < 60; o++)
  330. {
  331. Delay(4000);
  332. }
  333. break;
  334. //goto start;
  335. }
  336. if (!(B3))
  337. {
  338. for (int o = 0; o < 60; o++)
  339. {
  340. Delay(4000);
  341. }
  342. czas = 2;
  343. break;
  344. //goto start;
  345. }
  346. if (!(B4))
  347. {
  348. for (int o = 0; o < 60; o++)
  349. {
  350. Delay(4000);
  351. }
  352. czas = 1;
  353. break;
  354. //goto start;
  355. }
  356. }
  357.  
  358. }
  359. }
  360.  
  361. for (int o = 0; o < 5; o++)
  362. Delay(40000);
  363. for (int p = 0; p < 200; p++)
  364. {
  365. Delayx100us(5);
  366. }
  367. for (; ; )
  368. {
  369. if (goToDraw == 1)
  370. {
  371. draw();
  372. goToDraw = 0;
  373. }
  374.  
  375. _BIS_SR(LPM3_bits); // przejscie do trybu LPM3
  376. if (czy_chcemy_wyswietlac == 1)
  377. Clock();
  378. if (czy_chcemy_wyswietlac == 0)
  379. {
  380. SEND_CMD(DD_RAM_ADDR);
  381. if (!(B1) && wynik[iteracja] == 1)
  382. {
  383. for (int o = 0; o < 5; o++)
  384. Delay(40000);
  385. printDecDigit(wynik[iteracja]);
  386. UartStringTransmit("1");
  387. wypisz();
  388. iteracja++;
  389. P2OUT &= ~BIT1;
  390. Delayx100us(500);
  391. P2OUT |= BIT1;
  392. SEND_CMD(CUR_SHIFT_RIGHT);
  393. }
  394. else if (!(B1) && wynik[iteracja] != 1)
  395. {
  396. for (int o = 0; o < 5; o++)
  397. Delay(40000);
  398. if (zycia != 0)
  399. zycia--;
  400. SEND_CHAR(' ');
  401. wypisz();
  402. buzz();
  403. }
  404.  
  405. if (!(B2) && wynik[iteracja] == 2)
  406. {
  407. for (int o = 0; o < 5; o++)
  408. Delay(40000);
  409. printDecDigit(wynik[iteracja]);
  410. UartStringTransmit("2");
  411. wypisz();
  412.  
  413. iteracja++;
  414. SEND_CMD(CUR_SHIFT_RIGHT);
  415. P2OUT &= ~BIT1;
  416. Delayx100us(500);
  417. P2OUT |= BIT1;
  418. }
  419. else if (!(B2) && wynik[iteracja] != 2)
  420. {
  421. for (int o = 0; o < 5; o++)
  422. Delay(40000);
  423. if (zycia != 0)
  424. zycia--;
  425. SEND_CHAR(' ');
  426. wypisz();
  427. buzz();
  428. }
  429.  
  430. if (!(B3) && wynik[iteracja] == 3)
  431. {
  432. for (int o = 0; o < 5; o++)
  433. Delay(40000);
  434. printDecDigit(wynik[iteracja]);
  435. UartCharTransmit('3');
  436. wypisz();
  437.  
  438. iteracja++;
  439. SEND_CMD(CUR_SHIFT_RIGHT);
  440. P2OUT &= ~BIT1;
  441. Delayx100us(500);
  442. P2OUT |= BIT1;
  443. }
  444. else if (!(B3) && wynik[iteracja] != 3)
  445. {
  446. for (int o = 0; o < 5; o++)
  447. Delay(40000);
  448. if (zycia != 0)
  449. zycia--;
  450. SEND_CHAR(' ');
  451. wypisz();
  452. buzz();
  453.  
  454. }
  455. if (!(B4) && wynik[iteracja] == 4)
  456. {
  457. for (int o = 0; o < 5; o++)
  458. Delay(40000);
  459. printDecDigit(wynik[iteracja]);
  460. UartStringTransmit("4");
  461. wypisz();
  462.  
  463. iteracja++;
  464. SEND_CMD(CUR_SHIFT_RIGHT);
  465. P2OUT &= ~BIT1;
  466. Delayx100us(500);
  467. P2OUT |= BIT1;
  468.  
  469. }
  470. else if (!(B4) && wynik[iteracja] != 4)
  471. {
  472. for (int o = 0; o < 5; o++)
  473. Delay(40000);
  474. if (zycia != 0)
  475. zycia--;
  476. SEND_CHAR(' ');
  477. wypisz();
  478. buzz();
  479. }
  480. while (high != low) // gdy odebrano dane
  481. {
  482. putc(Bufor[low]); // wypisanie danych na wyświetlaczu
  483. low = (++low) % 30; // inkrementowanie znaczika początka danych
  484. }
  485. if (iteracja == 4)
  486. {
  487. czy_chcemy_wyswietlac = 1;
  488. iteracja = 0;
  489. UartStringTransmit(" ");
  490. Punkty++;
  491. clearDisplay();
  492. goToDraw = 1;
  493. //goto nowe_losowanie;
  494.  
  495. }
  496. if (zycia <= 0)
  497. {
  498. clearDisplay();
  499. for (int j = 0; j < 9; j++)
  500. {
  501.  
  502. SEND_CHAR(GameOver[j]);
  503.  
  504. StanGry = 0;
  505. }
  506. UartCharTransmit('\n');
  507. if (Punkty > max3) { max3 = Punkty; }
  508. else if (Punkty <= max3 || Punkty > max2) { max2 = Punkty; }
  509. else if (Punkty <= max2 || Punkty > max1) { max1 = Punkty; }
  510. for (int o = 0; o < 40; o++)
  511. Delay(40000);
  512. StanGry = 1;
  513. czy_chcemy_wyswietlac = 1;
  514. zycia = IloscZyc;
  515. Punkty = 0;
  516. break;
  517. }
  518.  
  519. //SEND_CMD(CUR_SHIFT_RIGHT );
  520. }
  521.  
  522.  
  523. }
  524. }
  525. }
  526. void Clock(void)
  527. {
  528. if (licznik % 10 == 0 && czy_chcemy_wyswietlac == 1) // jesli minie sek
  529. {
  530. licznik = 0; //zapal diodę
  531. // licz sekundy
  532. if (sekundy == czas) //jesli skonczy sie czas od zycia
  533. {
  534.  
  535. clearDisplay();
  536. czy_chcemy_wyswietlac = 0;
  537. sekundy = 0;
  538. return;
  539. }
  540.  
  541. sekundy = sekundy % czas;
  542. for (int i = 0; i < 4; i++)
  543. printDecDigit(wynik[i]); //wyswietl liczbe sekund
  544. ++sekundy;
  545. SEND_CMD(CUR_SHIFT_LEFT); // wróć kursorem na początek
  546. SEND_CMD(CUR_SHIFT_LEFT);
  547. SEND_CMD(CUR_SHIFT_LEFT);
  548. SEND_CMD(CUR_SHIFT_LEFT);
  549. }
  550.  
  551.  
  552.  
  553. }
  554. // procedura obsługi przerwania od TimerA
  555.  
  556. #pragma vector=TIMERA0_VECTOR
  557. __interrupt void Timer_A(void)
  558. {
  559. ++licznik;
  560. _BIC_SR_IRQ(LPM3_bits);
  561.  
  562. // wyjście z trybu LPM3
  563. }
  564.  
  565. // procedura obsługi przerwania UART
  566. #pragma vector=UART0RX_VECTOR
  567. __interrupt void usart0_rx(void)
  568. {
  569. Bufor[high] = RXBUF0; // wpisanie odebranych danych do bufora
  570. high = (++high) % 30; // inkrementowanie znacznika końca danych
  571. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!