Maszi

Untitled

May 12th, 2021
585
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #include <util/delay.h>
  3. #include <avr/io.h>
  4. #include <avr/interrupt.h>
  5. #include <stdlib.h>
  6.  
  7.  
  8.  
  9. #define LCD_RS 0
  10. #define LCD_EN 1
  11. #define LCD_RW 2
  12. #define LCD_DATA PORTA
  13.  
  14. #define LCD_CLEAR                   0x01
  15. #define LCD_HOME                    0x02
  16. #define LCDC_ENTRY_MODE             0x04
  17. #define LCD_EM_SHIFT_CURSOR         0x00
  18. #define LCD_EM_SHIFT_DISPLAY        0x01
  19. #define LCD_EM_LEFT                 0x00
  20. #define LCD_EM_RIGHT                0x02
  21. #define LCD_ONOFF                   0x08
  22. #define LCD_DISP_ON                 0x04
  23. #define LCD_CURSOR_ON               0x02
  24. #define LCDC_CURSOR_OFF             0x00
  25. #define LCDC_BLINK_ON               0x01
  26. #define LCDC_BLINK_OFF              0x00
  27. #define LCD_SHIFT                   0x10
  28. #define LCDC_SHIFT_DISP             0x08
  29. #define LCDC_SHIFT_CURSOR           0x00
  30. #define LCDC_SHIFT_RIGHT            0x04
  31. #define LCDC_SHIFT_LEFT             0x00
  32. #define LCD_FUNC                    0x20
  33. #define LCD_8_BIT                   0x10
  34. #define LCD_4_BIT                   0x00
  35. #define LCDC_TWO_LINE               0x08
  36. #define LCDC_FONT_5x10              0x04
  37. #define LCDC_FONT_5x8               0x00
  38. #define LCDC_SET_CGRAM              0x40
  39. #define LCDC_SET_DDRAM              0x80
  40.  
  41. #define LCD_LINE1                   0x00
  42. #define LCD_LINE2                   0x40
  43.  
  44.  
  45. //sta³e
  46. char buffer_1[9] = "Wojciech";
  47. char buffer_2[12] = "Serodzinski";
  48.  
  49.  
  50. char tab_trans[17] = {0x31,0x32,0x33,0x2B,0x34,0x35,0x36,0x2D,0x37,0x38,0x39,0x2A,0x43,0x30,0x3D,0x2F};
  51.  
  52. char cyfra_1[8];
  53. char cyfra_2[8];
  54.  
  55. int cyfra1_licznik = 0;
  56. int cyfra2_licznik = 0;
  57.  
  58.  
  59. int delay;
  60. int compare;
  61. int compare_0;
  62. char cyfra;
  63. int licznik = 0;
  64. volatile unsigned char del_500_ms = 0;
  65. volatile int flaga_znak = 0;
  66. int blad = 0;
  67. int zly_klawisz = 0;
  68. int czas = 0;
  69. int dzialanie = 0;
  70. float liczba1 = 0;
  71. float liczba2 = 0;
  72. float wynik_obl = 0;
  73. int czytaj_cyfre(int a, char *cyfra_tab);
  74. float oblicz_liczbe(char * cyferka, int rozmiar);
  75. // + 2B, - 2D, / 2F, * 2A, = 3D, C 43
  76.  
  77. //deklaracje funkcji
  78. void SET_LCD(void);
  79. void lcd_write_cmd(int cmd);
  80. void lcd_char(char data);
  81. void lcd_write_byte(int data);
  82. void wypisz(void);
  83. void send_half(int dana);
  84. void czytaj_klawisz(void);
  85. void system_reset(void);
  86. void pierwsza_liczba(void);
  87. void druga_liczba(void);
  88. float wynik(void);
  89. void zeruj_wszystko(void);
  90. void reset_timer_1(void);
  91. void przepisz(void);
  92. void wypisz_wynik(void);
  93.  
  94. SIGNAL (SIG_INTERRUPT0) // INT0 - PD2
  95.     {
  96.     zeruj_wszystko();
  97.     wypisz_wynik();
  98.     PORTD =  0x01;
  99.     TCNT1 = 0;
  100.     del_500_ms = 0;
  101.     }
  102.  
  103.  
  104. SIGNAL (SIG_INTERRUPT1) // INT1 - PD3
  105.     {
  106.     SET_LCD();                      // inicjalizacja LCD
  107.     wypisz();                       // wypisuje nazwisko i imie
  108.     flaga_znak = 0;
  109.     }
  110.  
  111.  
  112.  
  113. SIGNAL (SIG_OUTPUT_COMPARE1A)       // przerwanie od przepe³nienia
  114.     {
  115.         TCNT1 = 0;      // prze³aduj TIMER1
  116.         del_500_ms = del_500_ms + 1;
  117.         if (del_500_ms >= 2)
  118.         {
  119.         PORTD = 0B00000000;;
  120.         }
  121.     }
  122.  
  123. SIGNAL (SIG_OUTPUT_COMPARE0)        // przerwanie od przepe³nienia
  124.     {
  125.         TCNT0 = delay;      // prze³aduj TIMER0
  126.         czytaj_klawisz();
  127.     }
  128.  
  129. // funkcja glowna
  130. int main(void)
  131. {
  132.     SET_LCD();                      // inicjalizacja LCD
  133.     wypisz();                       // wypisuje nazwisko i imie
  134.     del_500_ms = 0;
  135.  
  136.     PORTD = 0x0C;                   // podciaganie bitów 3 i 4 PortD  INT0 INT1
  137.     GIMSK |= _BV(INT0);             // w³acz obs³uge przerwan Int0
  138.     GIMSK |= _BV(INT1);             // w³acz obs³uge przerwan Int1
  139.  
  140.     MCUCR |= _BV(ISC01);            // w³acz generowanie przerwan przez opadajace zbocze na Int0
  141.     MCUCR |= _BV(ISC11);            // w³acz generowanie przerwan przez opadajace zbocze na Int1
  142.  
  143.  
  144.     delay = 0x0000;                 // domyslna wartosc dla TIMERA1 TIMER0
  145.     compare = 488;                  // 500 ms
  146.  
  147.     OCR1A = compare;
  148.     TIMSK = _BV(OCIE1A);            // w³acz przerwania od przepe³nienia i porównania TIMERA1
  149.     TCNT1 = delay;                  // zainicjuj TIMER1
  150.     TCCR1A = 0x00;                  // czasomierz 1 bez dodatków
  151.     TCCR1B = 0b00000101;            // taktowany F_CPU  preskaler clk / 1024
  152.  
  153.  
  154.     compare_0 = 30;                 // 50x1024us = 30ms
  155.     OCR0    = compare_0;
  156.     TIMSK   |= _BV(OCIE0);          // w³acz przerwania od przepe³nienia i porównania TIMERA0
  157.     TCNT0   = delay;                // zainicjuj TIMER0
  158.     TCCR0   = 0b00000101;           // taktowany F_CPU preskalera clk/1024
  159.  
  160.  
  161.  
  162.     flaga_znak =0;                  // flsagas ustawiana przez procedure obslugi klawiszy
  163.     sei();                          // w³acz obs³uge przerwan
  164.  
  165.     czas = 4;                       // czas  = 4 !!!!!
  166.     while (del_500_ms < czas)       // opoznienie 40x50ms = 2s
  167.     {  
  168.     asm("nop");
  169.     asm("nop");
  170.     }
  171.     system_reset();                 // czyszczenie LCD
  172.  
  173.     PORTA &= ~(1<<LCD_EN);
  174.     PORTA &= ~(1<<LCD_RS);
  175.     lcd_write_cmd( 0xC0 ); // czyszczenie LCD i kursor na pozycji 0 drugirej linii
  176.     _delay_ms(5);
  177.  
  178.     while (1)
  179.     {  
  180.     asm("nop");
  181.     if(flaga_znak)
  182.     {
  183.         zeruj_wszystko();
  184.         zly_klawisz = 0;
  185.  
  186.         zeruj_wszystko();
  187.  
  188.         pierwsza_liczba();
  189.         druga_liczba();
  190.         wynik();
  191.  
  192.         flaga_znak = 0;
  193.     }
  194.     asm("nop");
  195.     }
  196.  
  197. }
  198.  
  199. void system_reset(void)
  200. {
  201.         PORTA &= ~(1<<LCD_EN);
  202.         PORTA &= ~(1<<LCD_RS);
  203.         lcd_write_cmd( LCD_CLEAR ); // czyszczenie LCD i kursor na pozycji 0
  204.         _delay_ms(5);  
  205.         //licznik = 0;
  206. }
  207.  
  208.  
  209. void czytaj_klawisz(void)
  210. {
  211.     DDRB  = 0xF0;
  212.     PORTB = 0xFF;
  213. int kolumna;
  214. int wiersz = 5;
  215. int klawisz = 0;
  216.  
  217.     for (kolumna = 0; kolumna < 4; kolumna++)
  218.     {
  219.     PORTB &= ~(1<<(kolumna+4));
  220.  
  221.          if (bit_is_clear(PINB,0))
  222.          {
  223.          TCCR1B =0 ;
  224.          wiersz = 0;
  225.          loop_until_bit_is_set ( PINB, 0);
  226.          TCCR1B = 5;
  227.          }
  228.     else if (bit_is_clear(PINB,1))
  229.          {
  230.          TCCR1B =0 ;
  231.          wiersz = 1;
  232.          loop_until_bit_is_set ( PINB, 1);
  233.          TCCR1B = 5;
  234.          }
  235.     else if (bit_is_clear(PINB,2))
  236.          {
  237.          TCCR1B =0 ;
  238.          wiersz = 2;
  239.          loop_until_bit_is_set ( PINB, 2);
  240.          TCCR1B = 5;
  241.          }
  242.     else if (bit_is_clear(PINB,3))
  243.          {
  244.          TCCR1B =0 ;
  245.          wiersz = 3;
  246.          loop_until_bit_is_set ( PINB, 3);
  247.          TCCR1B = 5;
  248.          }
  249.  
  250.      //if ((wiersz != 5)&&(licznik<16))
  251.      if (wiersz != 5)
  252.      {
  253.         klawisz = kolumna + (wiersz * 4);
  254.         cyfra = tab_trans[klawisz];
  255.         //lcd_char(cyfra);
  256.         //licznik++;
  257.         flaga_znak = 1;
  258.         break;
  259.      }
  260.    
  261.     }
  262. }
  263.  
  264.  
  265. void SET_LCD(void)
  266. {
  267.     DDRA = 0xFF; //PORTA jako wyjscie
  268.  
  269.     DDRA |=(1<<LCD_RS);
  270.     DDRA |=(1<<LCD_EN);
  271.     DDRB |=(1<<LCD_RW);
  272.  
  273.     PORTA &= ~(1<<LCD_EN);
  274.     PORTA &= ~(1<<LCD_RS);
  275.  
  276.     _delay_ms(40);
  277.  
  278.     send_half( 0x30 );
  279.     _delay_ms(4);
  280.     _delay_us(100);
  281.  
  282.     send_half( 0x30 );
  283.     _delay_us(100);
  284.  
  285.     send_half( 0x30 );
  286.     _delay_us(100);
  287.  
  288.     send_half( 0x20 );
  289.     _delay_us(100);
  290.  
  291.  
  292.     lcd_write_cmd( LCD_FUNC | LCD_4_BIT | LCDC_TWO_LINE | LCDC_FONT_5x8 );
  293.     lcd_write_cmd( LCD_ONOFF | LCD_DISP_ON );
  294.     lcd_write_cmd( LCD_CLEAR );
  295.     _delay_ms(5);
  296.     lcd_write_cmd( LCDC_ENTRY_MODE | LCD_EM_SHIFT_CURSOR | LCD_EM_RIGHT );
  297. }
  298.  
  299. void lcd_write_cmd(int cmd)
  300. {
  301.     PORTA &= ~(1<<LCD_RS);
  302.     lcd_write_byte(cmd);
  303. }
  304.  
  305.  
  306. void lcd_char(char data)
  307. {
  308.     PORTA |=(1<<LCD_RS);
  309.     lcd_write_byte(data);
  310. }
  311.  
  312. void lcd_write_byte(int data)
  313. {
  314. int bajt = data;
  315.     send_half(bajt);
  316.     bajt = __builtin_avr_swap(bajt);
  317.     send_half(bajt);
  318. }
  319.  
  320.  
  321. void send_half(int dana)
  322. {
  323. int temp_lcd_data;
  324.     temp_lcd_data = LCD_DATA;
  325.     temp_lcd_data &= 0x0F;
  326.     dana &= 0xF0;
  327.     temp_lcd_data |= dana;
  328.     LCD_DATA = temp_lcd_data;
  329.     PORTA |=(1<<LCD_EN);
  330.     _delay_us(60);
  331.     PORTA &= ~(1<<LCD_EN);
  332.     _delay_us(10);
  333. }
  334.  
  335. void wypisz(void)
  336. {
  337.            
  338. for (int i = 0; i<8; i++)
  339.     {
  340.         lcd_char(buffer_1[i]);
  341.     }
  342.  
  343.         PORTA &= ~(1<<LCD_EN);
  344.         PORTA &= ~(1<<LCD_RS);
  345.         lcd_write_cmd( 0xC0 ); // czyszczenie LCD i kursor na pozycji 0 drugirej linii
  346.         _delay_ms(5);
  347.  
  348. for (int i = 0; i<11; i++)
  349.     {
  350.         lcd_char(buffer_2[i]);
  351.     }  
  352. }
  353.  
  354. void pierwsza_liczba(void)
  355. {
  356. czas = 1;           // czas = 1 !!!! = opoznienie 0,5 sekundy
  357. flaga_znak = 0;
  358. int klawisz_ok;
  359.  
  360.     if ((cyfra >= 0x30) && (cyfra <= 0x39))
  361.         {
  362.             lcd_char(cyfra);
  363.             cyfra_1[0] = (cyfra - 0x30);
  364.         }
  365.         else
  366.         {
  367.         goto zly_klawisz_koniec;
  368.         }
  369.  
  370.  
  371.     for (cyfra1_licznik = 1; cyfra1_licznik < 7; cyfra1_licznik++)
  372.         {
  373.         klawisz_ok = czytaj_cyfre(cyfra1_licznik, cyfra_1);
  374.         if (!klawisz_ok) {break;}
  375.         }
  376.  
  377.         if (klawisz_ok == 2) {goto zly_klawisz_koniec;}
  378.        
  379.  
  380.         reset_timer_1();
  381.         if (cyfra1_licznik == 7)
  382.         {
  383.  
  384.             flaga_znak = 0;
  385.             while ((del_500_ms < czas) && !flaga_znak)         
  386.                 {  
  387.                     asm("nop");
  388.                     asm("nop");
  389.                 }      
  390.         }
  391.  
  392.         flaga_znak = 0;
  393.         if (del_500_ms >= czas) { goto zly_klawisz_koniec;}
  394.         if ((cyfra == 0x2B) || (cyfra == 0x2D)|| (cyfra == 0x2A) || (cyfra == 0x2F))
  395.         {
  396.                     lcd_char(cyfra);
  397.                     dzialanie = cyfra;
  398.                     goto koniec;
  399.         }
  400.  
  401.         else
  402.         {
  403.             goto zly_klawisz_koniec;
  404.         }
  405.  
  406.  
  407.  
  408. zly_klawisz_koniec:
  409.         zeruj_wszystko();
  410.         zly_klawisz = 1;
  411. koniec:
  412.         asm("nop");
  413.  
  414. }
  415.  
  416.  
  417. void druga_liczba(void)
  418. {
  419. if (zly_klawisz) {goto koniec;}
  420. int klawisz_ok;
  421. czas = 1;           // czas = 1 !!!! = opoznienie 0,5 sekundy
  422. flaga_znak = 0;
  423.  
  424.     for (cyfra2_licznik = 0; cyfra2_licznik < 7; cyfra2_licznik++)
  425.         {
  426.         klawisz_ok = czytaj_cyfre(cyfra2_licznik, cyfra_2);
  427.         if (!klawisz_ok) {break;}
  428.         }
  429.  
  430.         if (klawisz_ok == 2) {goto zly_klawisz_koniec;}
  431.  
  432.  
  433.         reset_timer_1();
  434.         if (cyfra2_licznik == 7)
  435.         {
  436.  
  437.             flaga_znak = 0;
  438.             while ((del_500_ms < czas) && !flaga_znak)         
  439.                 {  
  440.                     asm("nop");
  441.                     asm("nop");
  442.                 }      
  443.         }
  444.  
  445.         flaga_znak = 0;
  446.         if (del_500_ms >= czas) { goto zly_klawisz_koniec;}
  447.         if (cyfra == 0x3D)
  448.         {
  449.                     lcd_char(cyfra);
  450.                     goto koniec;
  451.         }
  452.  
  453.         else
  454.         {
  455.             goto zly_klawisz_koniec;
  456.         }
  457.  
  458.  
  459.  
  460. zly_klawisz_koniec:
  461.         zeruj_wszystko();
  462.         zly_klawisz = 1;
  463. koniec:
  464.         asm("nop");
  465.  
  466. }
  467.  
  468.  
  469.  
  470. int czytaj_cyfre(int a, char *cyfra_tab)
  471. {
  472. czas = 1;
  473.  
  474. int klawisz_ok = 1;
  475.  
  476.     reset_timer_1();
  477.     while ((del_500_ms < czas) && !flaga_znak)         
  478.         {  
  479.             asm("nop");
  480.             asm("nop");
  481.         }
  482.  
  483.     flaga_znak = 0;
  484.     if (del_500_ms >= czas)
  485.         {
  486.             klawisz_ok = 2;
  487.             goto zly_klawisz_out;
  488.         }
  489.  
  490.     if ((cyfra >= 0x30) && (cyfra <= 0x39))
  491.         {
  492.             lcd_char(cyfra);
  493.             cyfra_tab[a] = (cyfra - 0x30);
  494.         }
  495.  
  496.         else
  497.         {
  498.             klawisz_ok = 0;
  499.         }
  500.  
  501.     zly_klawisz_out:
  502.  
  503.     return klawisz_ok;
  504.  
  505. }
  506.  
  507. float wynik(void)
  508. {
  509. if (zly_klawisz) {goto koniec;}
  510.  
  511.     liczba1 = oblicz_liczbe(cyfra_1, cyfra1_licznik);
  512.     liczba2 = oblicz_liczbe(cyfra_2, cyfra2_licznik);
  513.  
  514. switch (dzialanie)
  515.     {
  516.         case 0x2B : // +
  517.             {
  518.                 wynik_obl = liczba1 + liczba2;
  519.                 break;
  520.             }
  521.  
  522.         case 0x2D : // -
  523.             {
  524.                 wynik_obl = liczba1 - liczba2;
  525.                 break;
  526.             }
  527.  
  528.  
  529.         case 0x2A : // *
  530.             {
  531.                 wynik_obl = liczba1 * liczba2;
  532.                 break;
  533.             }
  534.  
  535.  
  536.         case 0x2F : // /
  537.             {
  538.                 wynik_obl = liczba1 / liczba2;
  539.                 break;
  540.             }
  541.  
  542.  
  543.     }
  544.  
  545.         PORTA &= ~(1<<LCD_EN);
  546.         PORTA &= ~(1<<LCD_RS);
  547.         lcd_write_cmd( LCD_CLEAR ); // czyszczenie LCD i kursor na pozycji 0
  548.         _delay_ms(5);
  549.         przepisz();
  550.         lcd_char(0x3D);
  551.  
  552.         PORTA &= ~(1<<LCD_EN);
  553.         PORTA &= ~(1<<LCD_RS);
  554.         lcd_write_cmd( 0xC0 );       // czyszczenie LCD i kursor na pozycji 0
  555.         _delay_ms(5);
  556.         wypisz_wynik();
  557.  
  558. koniec:
  559. return wynik_obl;
  560.  
  561. }
  562.  
  563. void przepisz(void)
  564. {
  565.  
  566.  
  567.     for (int dl = 0; dl < cyfra1_licznik; dl++)
  568.         {
  569.             lcd_char(cyfra_1[dl] + 0x30);
  570.         }
  571.        
  572.         lcd_char(dzialanie);
  573.  
  574.     for (int pl = 0; pl < cyfra2_licznik; pl++)
  575.         {
  576.             lcd_char(cyfra_2[pl] + 0x30);
  577.         }
  578.  
  579. }
  580.  
  581.  
  582. float oblicz_liczbe(char * cyferka, int rozmiar)
  583. {
  584. float multi = 1;
  585. float liczba = 0;
  586.  
  587.     for (int dl = (rozmiar - 1); dl >= 0; dl--)
  588.         {
  589.             liczba = liczba + (cyferka[dl] * multi);
  590.             multi = multi * 10;
  591.         }
  592. return liczba;
  593. }
  594.  
  595.  
  596. void wypisz_wynik(void)
  597. {
  598.         char wyniczek[17];
  599.         for (int z = 0; z<17; z++)
  600.             {
  601.                 wyniczek[z] = 0;
  602.             }      
  603.        
  604.         ltoa(wynik_obl, wyniczek, 10);
  605.  
  606.         for (int k = 0; k<16; k++)
  607.             {
  608.                 if (wyniczek[k] > 0)
  609.                     {
  610.                         lcd_char(wyniczek[k]);
  611.                     }
  612.                 else
  613.                 {
  614.                 break;
  615.                 }
  616.  
  617.             }
  618. }
  619.  
  620. void zeruj_wszystko(void)
  621. {
  622.         PORTA &= ~(1<<LCD_EN);
  623.         PORTA &= ~(1<<LCD_RS);
  624.         lcd_write_cmd( LCD_CLEAR ); // czyszczenie LCD i kursor na pozycji 0
  625.         _delay_ms(5);      
  626.        
  627.         PORTA &= ~(1<<LCD_EN);
  628.         PORTA &= ~(1<<LCD_RS);
  629.         lcd_write_cmd( 0xC0 ); // czyszczenie LCD i kursor na pozycji 0
  630.         _delay_ms(5);
  631. }
  632.  
  633. void reset_timer_1(void)
  634. {
  635. TCNT1 = 0;
  636. del_500_ms = 0;
  637. }
  638.  
  639.  
  640.  
RAW Paste Data