SHARE
TWEET

Untitled

a guest Apr 21st, 2014 130 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
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
 
Top