API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 21st, 2019
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.55 KB | None | 0 0
raw download clone embed print report
  1. #include <avr/io.h>
  2. #include <avr/interrupt.h>
  3. #define F_CPU 16000000
  4. #include <util/delay.h>
  5. #include <string.h>
  6. #include <stdio.h>
  7.  
  8. void Inicjalizacja(void); //deklaracja funkcji inicjalizacji LCD
  9. void Wyswietlanie(char*, uint8_t len);
  10. void Wyswietlanie_nizej(char*, uint8_t len);
  11. void Przesuwanie(int8_t);
  12. void Zapis(int8_t); //deklaracja funkcji zapisu na wyswietlaczu LCD
  13. void Znak(const char*, int8_t);
  14.  
  15. void Clear() {
  16. PORTA &= ~(1<<PA4); //slowa sterujace
  17. PORTA &= ~(1<<PA6); //E <- 0
  18. _delay_ms(40);
  19. PORTA |= (1<<PA6); //E<-1
  20. PORTB = 0b00110000; //1-sza sekwencja 0011****
  21. PORTA &= ~(1<<PA6); //E <-0
  22. _delay_ms(4.1);
  23. PORTA |= (1<<PA6); //E<- 1
  24. //2 sekwencja 0011****
  25. PORTA &= ~(1<<PA6); //E<-0
  26. _delay_ms(100);
  27. PORTA |= (1<<PA6); // E<-1
  28. //3 sekwencja 0011****
  29.  
  30. PORTA &= ~(1<<PA6); // E<-0
  31. _delay_ms(100);
  32.  
  33. PORTA |= (1<<PA6);
  34. PORTB &= ~(1<<PB4);
  35. PORTA &= ~(1<<PA6);
  36.  
  37. Zapis(0b00101000); //dla 4bitowego
  38. //Zapis(0b00111100); //wywolanie funkcji zapis do LCD
  39. //8 bitowe slowo, 2 wiersze, matryca 5x10
  40. Zapis(0b00001100); //wlaczanie wyswietlacza, kursor aktywny i miga
  41.  
  42. Zapis(1); //czyszczenie wyswietlacza
  43. _delay_ms(1.64);
  44. Zapis(0b00000110);
  45. }
  46.  
  47. volatile uint8_t STOP = 0; //KEY STATE STOP
  48. volatile uint8_t STOPPED = 0;
  49. volatile uint8_t K_R = 0; //KEY STATE RIGHT
  50. volatile uint8_t K_L = 0; //KEY STATE LEFT
  51. volatile uint16_t SEKUNDY = 0;
  52. volatile uint8_t W_L = 0;
  53. volatile uint8_t W_R = 0;
  54. volatile uint8_t BUZKA_L = 0;
  55. volatile uint8_t BUZKA_R = 0;
  56.  
  57. char napis[4] = ""; // napis do wyswietlenia
  58. char napiss[5]= { 'S', 'u', 'p', 0, 0 };
  59.  
  60. const char kod[8] = {
  61. 0b00000,
  62. 0b01010,
  63. 0b00000,
  64. 0b00100,
  65. 0b00100,
  66. 0b10001,
  67. 0b01110,
  68. 0b00000
  69. };
  70.  
  71. int main(void)
  72. {
  73. // Timer
  74. TCCR0 |= (1 << WGM01) | (0 << WGM00);
  75. TCCR0 |= (1 << CS02) | (0 << CS01) | (1 << CS00);
  76. OCR0 = 50;
  77. TIMSK |=(1 << OCIE0);
  78. sei();
  79.  
  80. /* WERJŚCIE PORT C: */
  81. DDRC = 0x00;
  82. PORTC = 0xFF;
  83.  
  84. Inicjalizacja();
  85.  
  86.  
  87. Znak(kod, 0);
  88. //Wyswietlanie(napis, 4);
  89. //Wyswietlanie_nizej(napiss, 5);
  90.  
  91. while(1) {
  92. if(STOP == 2)
  93. {
  94. STOPPED = (!STOPPED) & 0x01;
  95. STOP = 3;
  96. }
  97.  
  98. if(K_L == 2)
  99. {
  100. W_L++;
  101. K_L = 3;
  102.  
  103. BUZKA_L = 10;
  104. }
  105.  
  106. if(K_R == 2)
  107. {
  108. W_R++;
  109. K_R = 3;
  110.  
  111. BUZKA_R = 10;
  112. }
  113. }
  114. return 0;
  115. }
  116.  
  117. void Inicjalizacja() //definicja funkcji inicjalizacji
  118. {
  119. DDRB=0xff; //wyjscie do lcd
  120. DDRA |= (1<<PA4)|(1<<PA6); //wyjscie do sterowania
  121.  
  122. PORTB = (PORTB & 0x0F); //dla 4bitowego
  123. //PORTB = 0; //PB7..0 <-0
  124.  
  125. PORTA &= ~(1<<PA4); //slowa sterujace
  126. PORTA &= ~(1<<PA6); //E <- 0
  127. _delay_ms(40);
  128. PORTA |= (1<<PA6); //E<-1
  129. PORTB = 0b00110000; //1-sza sekwencja 0011****
  130. PORTA &= ~(1<<PA6); //E <-0
  131. _delay_ms(4.1);
  132. PORTA |= (1<<PA6); //E<- 1
  133. //2 sekwencja 0011****
  134. PORTA &= ~(1<<PA6); //E<-0
  135. _delay_ms(100);
  136. PORTA |= (1<<PA6); // E<-1
  137. //3 sekwencja 0011****
  138.  
  139. PORTA &= ~(1<<PA6); // E<-0
  140. _delay_ms(100);
  141.  
  142. PORTA |= (1<<PA6);
  143. PORTB &= ~(1<<PB4);
  144. PORTA &= ~(1<<PA6);
  145.  
  146. Zapis(0b00101000); //dla 4bitowego
  147. //Zapis(0b00111100); //wywolanie funkcji zapis do LCD
  148. //8 bitowe slowo, 2 wiersze, matryca 5x10
  149. Zapis(0b00001100); //wlaczanie wyswietlacza, kursor aktywny i miga
  150.  
  151. Zapis(1); //czyszczenie wyswietlacza
  152. _delay_ms(1.64);
  153. Zapis(0b00000110); //adres inkrementowany, przesuwanie kursora
  154. }
  155.  
  156. void Znak(const char* kod, int8_t AAA)
  157. {
  158. int8_t k;
  159. PORTA &= ~(1<<PA4); // RS <- 0
  160. Zapis((0x40)|(AAA<<3)); // Rozkaz wejscia do CGRAM
  161. PORTA |=(1<<PA4); // RS <- 1
  162.  
  163. _delay_us(40);
  164.  
  165. for(k=0;k<8;k++)
  166. {
  167. Zapis(kod[k]);
  168. }
  169.  
  170. PORTA &= ~(1<<PA4); // RS <- 0 Teraz slowa sterujace
  171. Zapis(0x80); // Powrot do pamieci DDRAM
  172. PORTA |= (1<<PA4); // RS <- 1 Teraz znaki
  173.  
  174. _delay_us(40);
  175.  
  176. }
  177.  
  178. void Wyswietlanie(char* co, uint8_t len)
  179. {
  180. uint8_t ile = len;
  181. int8_t k = 0;
  182. PORTA |= (1<<PA4); //RS <-1 teraz znaki
  183.  
  184. while(k<ile)
  185. {
  186. Zapis(napis[k]); //wyslanie znakow "Fajnie?" na wyswietlacz
  187. k++;
  188. }
  189. }
  190.  
  191. void Wyswietlanie_nizej(char* co, uint8_t len)
  192. {
  193. uint8_t ile = len;
  194. int8_t k = 0;
  195.  
  196. PORTA &= ~(1<<PA4);
  197. Zapis(0b11000000);
  198. PORTA |= (1<<PA4);
  199.  
  200. while(k<ile)
  201. {
  202. Zapis(napiss[k]);
  203. k++;
  204. }
  205. }
  206.  
  207. void Przesuwanie(int8_t ile)
  208. {
  209. int8_t i = 0;
  210. int8_t k = 0;
  211.  
  212. PORTA &= ~(1<<PA4);
  213.  
  214. while(i<ile)
  215. {
  216. Zapis(0b00011100);
  217. _delay_ms(330);
  218. i++;
  219. }
  220. while(k<ile)
  221. {
  222. Zapis(0b00011000);
  223. _delay_ms(330);
  224. k++;
  225. }
  226.  
  227. PORTA |= (1<<PA4);
  228. }
  229.  
  230. void Zapis(int8_t bajt) //definicja funkcji zapisu
  231. {
  232. /*PORTA |=(1<<PA6); //E<-1
  233. PORTB = bajt;
  234. asm volatile("nop"); //male opoznienie
  235. PORTA &= ~_BV(PA6); //E<-0 zapis opadajacym zboczem
  236. _delay_us(40);*/
  237.  
  238. //dla 4bitowego
  239.  
  240. PORTA |=(1<<PA6);
  241. PORTB = (bajt & 0xF0)|(PORTB &0x0F);
  242. PORTA &= ~(1<<PA6);
  243. asm volatile("nop");
  244.  
  245. PORTA |=(1<<PA6);
  246. PORTB = ((bajt & 0x0F)<<4)|(PORTB &0x0F);
  247. PORTA &= ~(1<<PA6);
  248.  
  249. _delay_us(40);
  250.  
  251. }
  252.  
  253. volatile uint16_t licznik = 0;
  254.  
  255. ISR(TIMER0_COMP_vect)
  256. {
  257. licznik++;
  258.  
  259. switch(STOP)
  260. {
  261. case 0: if ((PINC & 0x01) == 0) STOP = 1;
  262. break;
  263.  
  264. case 1: if ((PINC & 0x01) == 0) STOP = 2;
  265. else STOP = 0;
  266. break;
  267.  
  268. case 2: break;
  269.  
  270. case 3: if ((PINC & 0x01) != 0) STOP = 4;
  271. break;
  272.  
  273. case 4: if ((PINC & 0x01) != 0) STOP = 0;
  274. else STOP = 3;
  275. break;
  276.  
  277. default: STOP = 0;
  278. }
  279.  
  280. switch(K_R)
  281. {
  282. // Jesli klikniety
  283. case 0: if ((PINC & 0x02) == 0) K_R = 1;
  284. break;
  285.  
  286. // Jesli dalej klikniety
  287. case 1: if ((PINC & 0x02) == 0) K_R = 2;
  288. else K_R = 0;
  289. break;
  290.  
  291. // Obsluga kolegi w main
  292. case 2: break;
  293.  
  294. // Zostal klikniety RAZ
  295. case 3: if ((PINC & 0x02) != 0) K_R = 4;
  296. break;
  297.  
  298. // Zostal odklikniety LUB nie to czeka
  299. case 4: if ((PINC & 0x02) != 0) K_R = 0;
  300. else K_R = 3;
  301. break;
  302.  
  303. default: K_R = 0;
  304. }
  305.  
  306. switch(K_L)
  307. {
  308. // Jesli klikniety
  309. case 0: if ((PINC & 0x04) == 0) K_L = 1;
  310. break;
  311.  
  312. // Jesli dalej klikniety
  313. case 1: if ((PINC & 0x04) == 0) K_L = 2;
  314. else K_L = 0;
  315. break;
  316.  
  317. // Obsluga kolegi w main
  318. case 2: break;
  319.  
  320. // Zostal klikniety RAZ
  321. case 3: if ((PINC & 0x04) != 0) K_L = 4;
  322. break;
  323.  
  324. // Zostal odklikniety LUB nie to czeka
  325. case 4: if ((PINC & 0x04) != 0) K_L = 0;
  326. else K_L = 3;
  327. break;
  328.  
  329. default: K_L = 0;
  330. }
  331. if(STOPPED == 0 && licznik > 270)
  332. {
  333. SEKUNDY++;
  334. licznik = 0;
  335. }
  336.  
  337. if(licznik % 270 == 0)
  338. {
  339. Clear();
  340.  
  341. PORTA &= ~(1<<PA4);
  342. PORTA |= (1<<PA4);
  343.  
  344. uint8_t ile = 5;
  345. uint8_t k = 0;
  346.  
  347. char t[5] = {'0', '0', ':', '0', '0'};
  348. t[4] = (char)((SEKUNDY % 10) + 48);
  349. t[3] = (char)(((SEKUNDY % 60) / 10) + 48);
  350. t[1] = (char)(((SEKUNDY / 60) % 10) + 48);
  351. t[0] = (char)(((SEKUNDY / 600) % 10) + 48);
  352.  
  353. while(k<ile)
  354. {
  355. Zapis(t[k]);
  356. k++;
  357. }
  358.  
  359. PORTA &= ~(1<<PA4);
  360. Zapis(0b11000000);
  361. PORTA |= (1<<PA4);
  362.  
  363. char w[5] = {'0', '0', ':', '0', '0'};
  364.  
  365. w[1] = (W_R % 10) + 48;
  366. w[0] = ((W_R / 10) % 10) + 48;
  367.  
  368. w[4] = (W_L % 10) + 48;
  369. w[3] = ((W_L / 10) % 10) + 48;
  370.  
  371. Zapis(w[0]);
  372. Zapis(w[1]);
  373.  
  374.  
  375. if(BUZKA_R > 0) {
  376. if(BUZKA_R % 4 > 1)
  377. Zapis(0);
  378. else Zapis(' ');
  379. BUZKA_R--;
  380. }
  381. else {
  382. Zapis(' ');
  383. }
  384.  
  385. for(uint8_t i = 0; i < 5; i++){
  386. Zapis(' ');
  387. }
  388.  
  389. for(uint8_t i = 0; i < 5; i++){
  390. Zapis(' ');
  391. }
  392.  
  393. if(BUZKA_L > 0) {
  394. if(BUZKA_L % 4 > 1)
  395. Zapis(0);
  396. else Zapis(' ');
  397. BUZKA_L--;
  398. }
  399. else {
  400. Zapis(' ');
  401. }
  402.  
  403. Zapis(w[3]);
  404. Zapis(w[4]);
  405. }
  406. }
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!