API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 21st, 2014
157
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.15 KB | None | 0 0
raw download clone embed print report
  1. #include "HD44780.h"
  2. #include "derivative.h"
  3.  
  4. char buffer1[21]; // buffer 1 wiersza
  5. char buffer2[21]; // buffer 2 wiersza
  6. char buffer3[21]; //buffer 3 wiersza
  7. char buffer4[21]; // buffer 4 wiersza
  8. volatile unsigned char LCD_refresh,start,tick,flagaPID;
  9. static volatile unsigned char i;
  10.  
  11.  
  12.  
  13. void delay_ms(int liczba)
  14. {
  15. /*
  16. * FUNKCJA POMOCNICZA KTORA PRZY POMOCY ODLICZANIA CZASU ZA POMOCA SYSTICK
  17. * REALIZUJE OPOZNIENIA POTRZEBNE PRZY INICJALIZACJI LCD
  18. */
  19. unsigned char i=0;
  20. start = 1;
  21. for(i=0;i<=liczba;i++)
  22. {
  23. do {}
  24. while(start);
  25. }
  26.  
  27. }
  28.  
  29.  
  30.  
  31. void WRITE_TO_LCD (unsigned char x,unsigned char op)
  32. {
  33. unsigned char busy;
  34.  
  35. LCD;
  36. asm("nop");
  37. asm("nop");
  38. if(x&0x10) SET_D4; else CLR_D4;
  39. if(x&0x20) SET_D5; else CLR_D5;
  40. if(x&0x40) SET_D6; else CLR_D6;
  41. if(x&0x80) SET_D7; else CLR_D7;
  42. asm("nop");
  43. asm("nop");
  44. CLR_E;
  45. asm("nop");
  46. asm("nop");
  47. if(op) SET_RS;else CLR_RS;
  48. asm("nop");
  49. asm("nop");
  50. CLR_RW;
  51. asm("nop");
  52. asm("nop");
  53.  
  54. SET_E;
  55. asm("nop");
  56. asm("nop");
  57. CLR_E;
  58. asm("nop");
  59. asm("nop");
  60.  
  61. if(x&0x01) SET_D4; else CLR_D4;
  62. if(x&0x02) SET_D5; else CLR_D5;
  63. if(x&0x04) SET_D6; else CLR_D6;
  64. if(x&0x08) SET_D7; else CLR_D7;
  65.  
  66.  
  67.  
  68.  
  69. asm("nop");
  70. asm("nop");
  71.  
  72. SET_E;
  73. asm("nop");
  74. asm("nop");
  75. CLR_E;
  76. asm("nop");
  77. asm("nop");
  78.  
  79.  
  80. IN_D4;
  81. IN_D5;
  82. IN_D6;
  83. IN_D7;
  84. asm("nop");
  85. asm("nop");
  86. CLR_RS;
  87. asm("nop");
  88. asm("nop");
  89. SET_RW;
  90. asm("nop");
  91. asm("nop");
  92.  
  93.  
  94. do
  95. {
  96. asm("nop");
  97. asm("nop");
  98.  
  99. SET_E;
  100. asm("nop");
  101. asm("nop");
  102.  
  103. busy = IF_D7;
  104. CLR_E;
  105. asm("nop");
  106. asm("nop");
  107. SET_E;
  108. asm("nop");
  109. asm("nop");
  110. CLR_E;
  111.  
  112. }while(busy);
  113.  
  114. }
  115.  
  116. void WRITE_TEXT( char *s)
  117. {
  118. unsigned char licznik=wiersze;
  119. while(licznik)
  120. {
  121. WRITE_TO_LCD(*s++,data) ;
  122. licznik--;
  123. }
  124.  
  125. }
  126.  
  127. void LCD_XY(unsigned char x , unsigned char y) // pierwszy argument to X drugi to Y
  128. {
  129.  
  130.  
  131. //WRITE_TO_LCD((y*0x40+x)|0x80,comm); wzór dobry dla lcd 2x16
  132.  
  133. /*
  134. * PONIZEJ PODANE SA ADRESY POCZATKÓW KAZDEJ Z CZTERECH LINII WYWIETLACZA
  135. */
  136. switch( y )
  137. {
  138. case 1:
  139. WRITE_TO_LCD(0x80+x,comm );
  140. break;
  141. case 2:
  142. WRITE_TO_LCD(x+0xC0,comm );
  143. break;
  144. case 3:
  145. WRITE_TO_LCD(x+0x94 ,comm );
  146. break;
  147. case 4:
  148. WRITE_TO_LCD(x+0xD4,comm );
  149. break;
  150. }
  151.  
  152. }
  153.  
  154.  
  155. void LCD_INIT (void)
  156. {
  157. /*
  158. * FUNKCJA INICJALIZUJĄCA WYSWIETLACZ LCD
  159. */
  160. delay_ms(160);
  161. LCD;
  162. STER;
  163.  
  164. CLR_E;
  165. CLR_RS;
  166. CLR_RW;
  167. SET_D4;
  168. SET_D5;
  169. CLR_D6;
  170. CLR_D7;
  171.  
  172. unsigned char i;
  173.  
  174. for( i=0; i<3; i++)
  175. {
  176. asm("nop");
  177. asm("nop");
  178. SET_E;
  179. asm("nop");
  180. asm("nop");
  181. CLR_E;
  182. asm("nop");
  183. asm("nop");
  184. delay_ms(5);
  185. }
  186.  
  187. CLR_D4;
  188. asm("nop");
  189. asm("nop");
  190. SET_E;
  191. asm("nop");
  192. asm("nop");
  193. CLR_E;
  194. asm("nop");
  195. asm("nop");
  196. delay_ms(1);
  197.  
  198. WRITE_TO_LCD(0x28,comm);
  199. WRITE_TO_LCD(0x08,comm);
  200. WRITE_TO_LCD(0x01,comm);
  201. WRITE_TO_LCD(0x06,comm);
  202. WRITE_TO_LCD(0x0C,comm);
  203. delay_ms(100);
  204.  
  205. bCLR(all);
  206. }
  207.  
  208. void bCLR (unsigned char mode)
  209. {
  210. /*
  211. * FUNKCJA OBSŁUGI CZYSZCZENIA EKRANU LCD
  212. * RODZAJ CZYSZCZENIA ZALEZNY OD MODE, MOZNA CZYSCIC JEDNA LINIA, DRUGA LUB CAŁOSC
  213. * '1'->PIERWSZA LINIA
  214. * '2'->DRUGA LINIA
  215. * 'all'-> CALOSC
  216. */
  217. unsigned char i;
  218.  
  219. switch (mode)
  220. {
  221. case 1:
  222. {
  223.  
  224. for(i=0;i<20;i++)
  225. {
  226. buffer1[i] = 32;
  227. }
  228. buffer1[20] = 0;
  229.  
  230. }
  231. break;
  232. case 2:
  233. {
  234. for(i=0;i<20;i++)
  235. {
  236. buffer2[i] = 32;
  237.  
  238. }
  239. buffer2[20] = 0;
  240. }
  241. break;
  242. case 3:
  243. {
  244. for(i=0;i<20;i++)
  245. {
  246. buffer3[i] = 32;
  247. }
  248. buffer3[20] = 0;
  249. }
  250. break;
  251. case 4:
  252. {
  253. for(i=0;i<20;i++)
  254. {
  255. buffer4[i] = 32;
  256. }
  257. buffer4[20] = 0;
  258. }
  259. break;
  260.  
  261.  
  262. case 5:
  263. {
  264. for(i=0;i<20;i++)
  265. {
  266. buffer1[i] = 32;
  267. buffer2[i] = 32;
  268. buffer3[i] = 32;
  269. buffer4[i] = 32;
  270. }
  271. buffer1[21] = 0;
  272. buffer2[21] = 0;
  273. buffer3[21] = 0;
  274. buffer4[21] = 0;
  275. }
  276. break;
  277. }
  278. }
  279.  
  280.  
  281.  
  282. void bRAM (char *txt, unsigned char Px,unsigned char Py,obiektLCD *obiekt)
  283. {
  284. /*
  285. * GŁÓWNA FUNKCJA - BUFFER ZAPISUJĄCA CIĄGI ZNAKÓW W BUFFERACH 1 I 2 KTÓRE NASTĘPNIE
  286. * WYSWIETLANE SA PRZEZ FUNKCJE LCD_DISP
  287. * Px ZAWIERA SIE W ZAKRESIE OD (0-15)
  288. * Py MOZE BYC ROWNE:
  289. * 1 DLA PIERWSZEJ LINII
  290. * 2 DLA DRUGIEJ LINII
  291. */
  292. unsigned char i,j;
  293.  
  294.  
  295.  
  296. if(obiekt->Y ==1)
  297. {
  298. for(j=obiekt->X;j<((obiekt->X)+obiekt->pozkonc);j++) buffer1[j]=32;
  299.  
  300. }
  301.  
  302. obiekt->X = Px;
  303. obiekt->Y = Py;
  304.  
  305. if(obiekt->Y ==2)
  306. {
  307. for(j=obiekt->X;j<((obiekt->X)+obiekt->pozkonc);j++) buffer2[j]=32;
  308. }
  309.  
  310.  
  311. obiekt->X = Px;
  312. obiekt->Y = Py;
  313.  
  314. if(obiekt->Y ==3)
  315. {
  316. for(j=obiekt->X;j<((obiekt->X)+obiekt->pozkonc);j++) buffer3[j]=32;
  317. }
  318.  
  319.  
  320. obiekt->X = Px;
  321. obiekt->Y = Py;
  322.  
  323. if(obiekt->Y ==4)
  324. {
  325. for(j=obiekt->X;j<((obiekt->X)+obiekt->pozkonc);j++) buffer4[j]=32;
  326. }
  327.  
  328.  
  329. obiekt->X = Px;
  330. obiekt->Y = Py;
  331.  
  332. while(*txt&&(Px<20))
  333. {
  334.  
  335. if (Py==1)
  336. {
  337. buffer1[Px++]=*txt++;
  338. i++;
  339.  
  340. }
  341. if (Py==2)
  342. {
  343. buffer2[Px++]=*txt++;
  344. i++;
  345. }
  346.  
  347. if (Py==3)
  348. {
  349. buffer3[Px++]=*txt++;
  350. i++;
  351. }
  352.  
  353. if (Py==4)
  354. {
  355. buffer4[Px++]=*txt++;
  356. i++;
  357. }
  358.  
  359. }
  360. obiekt->pozkonc = i;
  361. }
  362.  
  363. void LCD_disp (void)
  364. {
  365. /*
  366. * FUNKCJA STEROWANA PRZEZ SYSTICK ZA POMOCA SYSTEMU FLAG LCD_REFRESH
  367. * EKRAN LCD ODSWIEZANY JEST CO 100ms
  368. */
  369. if(LCD_refresh)
  370. {
  371. LCD_refresh = 0 ;
  372. LCD_XY(0,1);
  373. WRITE_TEXT(buffer1);
  374. LCD_XY(0,2);
  375. WRITE_TEXT(buffer2);
  376. LCD_XY(0,3);
  377. WRITE_TEXT(buffer3);
  378. LCD_XY(0,4);
  379. WRITE_TEXT(buffer4);
  380.  
  381. }
  382.  
  383.  
  384.  
  385.  
  386. }
  387.  
  388. void SysTick_init(void)
  389. {
  390. SYST_RVR = clock; //wartosc od ktorej zlicza systick
  391. SYST_CVR = 0; // skasowanie wartosci licznika
  392. SYST_CSR |= SysTick_CSR_CLKSOURCE_MASK | SysTick_CSR_TICKINT_MASK | SysTick_CSR_ENABLE_MASK ; //zrodlo zegara-> procesor, wlaczenie systick,
  393. //pozwolenie na odliczanie
  394. /*
  395. * FUNKCJA ODLICZA W AKTUALNYM USTAWIENIU W PRZERWANIU 1ms.TAKTOWANIE SYGNAŁEM 48MHZ
  396. */
  397. }
  398. void SysTick_Handler()
  399. {
  400. if(start) start=0;
  401.  
  402. /*
  403. * INICJALIZACJA FLAG ODMIERZAJACYCH 1MS
  404. */
  405.  
  406. tick = 1;
  407. flagaPID=1;
  408.  
  409.  
  410.  
  411.  
  412. i++;
  413. if(i==100)
  414. {
  415. i=0;
  416. LCD_refresh = 1;
  417. }
  418.  
  419. }
  420.  
  421. void LCD_GPIO_INIT(void)
  422. {
  423. /*
  424. * FUNKCJA INICJALIZUJACA SYGNAŁY I MULTIPLEKSOWANIE PINOW PTORZEBNYCH
  425. * DO OBSLUGI WYSWIETLACZA LCD HD44780, TRYB PRACY 4 BITOWY Z OBSŁUGĄ BUSY FLAG
  426. * DO OBSŁUGI BUSY FLAG WYMAGANY JEST PIN R/W
  427. */
  428. SIM_SCGC5 |= SIM_SCGC5_PORTE_MASK; //ustawienie sygnału zegarowego na port E
  429.  
  430. PORTE_PCR20 = PORT_PCR_MUX(1) | PORT_PCR_PE_MASK | PORT_PCR_PS_MASK; // włączenie multipleksowania dla wybranych pinów RW,RS,RE
  431. PORTE_PCR21 = PORT_PCR_MUX(1); // dodatkowo włączenie internal resistor(PE) i podciągniecie pull-up(PS)
  432. PORTE_PCR22 = PORT_PCR_MUX(1);
  433.  
  434. PORTE_PCR2 = PORT_PCR_MUX(1); // włączenie multipleksowania dla pinów D4,D5,D6,D7
  435. PORTE_PCR3 = PORT_PCR_MUX(1);
  436. PORTE_PCR4 = PORT_PCR_MUX(1);
  437. PORTE_PCR5 = PORT_PCR_MUX(1);
  438. }
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!