API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 29th, 2016
119
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.05 KB | None | 0 0
raw download clone embed print report
  1. #include "Uart1.h"
  2. //#include "DS18B20.h"
  3. #include "HD44780.h"
  4. #include "uart.h"
  5.  
  6. #define UART_BAUD_RATE      9600      //powoli, mi sie nie spieszy :P
  7.  
  8.  
  9. char linia1[16], linia2[16], linia3[16], linia4[16];
  10. uint8_t sekunda=0;
  11. uint8_t Ssekundy=0;
  12. volatile int szklarnia=-1;
  13. uint8_t odbierz=0;
  14. int ekran=0;
  15. int TEST[10]; // do testow
  16. int czas_p1=0, czas_p2=0, czas_p3=0, czas_p4=0, czas_p5=0;
  17. char tmp[5];
  18. char tmp2[5];
  19. uint8_t nastawianie=0;
  20.  
  21. char temp1[5]="0000";
  22. char temp2[5]="0000";
  23. char temp3[5]="0000";
  24. char temp4[5]="0000";
  25. char temp5[5]="0000";
  26. char temp6[5]="0000";
  27. char temp7[5]="0000";
  28. char temp8[5]="0000";
  29. char temp9[5]="0000";
  30.  
  31.  struct alarm { //struktora pamietajaca ostatnie 10 probek oraz prog ponizej ktorego wlaczy sie alarm
  32.     int prog;
  33.     int pamiec[10];
  34.     } * tab_alarmow[10];
  35.  
  36. void odczytaj (char tab[]); //odebranie z uartu 4bajtów temperatury.
  37. void dopisz (alarm &ktory, char tab[]); // przesuniecie tablicy probek w prawo o 1 i dopisanie nowej probki
  38. uint8_t spr_alarm(alarm **tab); // sprawdzanie czy spelniony jest warunek alarmu (zwraca numer obiektu alarmujacego)
  39. uint8_t spr_poprawnosc(char tab[]); //sprawdza czy z transmisjii otrzymano 3bajty z ktorych kazdy jest cyfra
  40. char* dodaj_przecinek (char tab[]);
  41. char* alarm_do_string (int &wartosc);
  42. void nastaw_alarm();
  43.  
  44.  
  45.  
  46. int main(void)
  47. {
  48.    
  49.      //tablica wskaźników na strukturę alarmów
  50.     alarm pierwszy, drugi, trzeci, czwarty, piaty, szosty,
  51.     siodmy, osmy, dziewiaty, dziesiaty; //struktury alarmow
  52.     /* PROGI ALARMOWE! */
  53.     pierwszy.prog=0;
  54.     drugi.prog=0;
  55.     trzeci.prog=200;
  56.     czwarty.prog=0;
  57.     piaty.prog=0;
  58.     szosty.prog=0;
  59.     siodmy.prog=0;
  60.     osmy.prog=0;
  61.     dziewiaty.prog=0;
  62.     dziesiaty.prog=0;
  63.     /* KONIEC PROGOW ALARMOWYCH */
  64.    
  65.     /* PRZYPISANIE ADRESOW ALARMOW DO TABLICY WSKAZNIKOW */
  66.     tab_alarmow[0] = &pierwszy;
  67.     tab_alarmow[1] = &drugi;
  68.     tab_alarmow[2] = &trzeci;
  69.     tab_alarmow[3] = &czwarty;
  70.     tab_alarmow[4] = &piaty;
  71.     tab_alarmow[5] = &szosty;
  72.     tab_alarmow[6] = &siodmy;
  73.     tab_alarmow[7] = &osmy;
  74.     tab_alarmow[8] = &dziewiaty;
  75.     tab_alarmow[9] = &dziesiaty;
  76.    
  77.     DDRB=0x00;
  78.     PORTB=0xFF;
  79.    
  80.     DDRD |= _BV(6);
  81.     DDRD |= _BV(5);
  82.     PORTD |= _BV(6);
  83.     PORTD |= _BV(5);
  84.         DDRD |= _BV(4);
  85.         PORTD |= _BV(4);
  86.        /*
  87.      *  Initialize UART library, pass baudrate and AVR cpu clock
  88.      *  with the macro
  89.      *  UART_BAUD_SELECT() (normal speed mode )
  90.      *  or
  91.      *  UART_BAUD_SELECT_DOUBLE_SPEED() ( double speed mode)
  92.      */
  93.     uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) );
  94.    
  95.  
  96.     sei(); // Zezwolenie globalne na przerwania
  97.    
  98.     //8-bit timer dla wyswietlacza
  99.    
  100.     TCCR0 |= (1 << CS00) | (1 << CS02); // preskaler /1024 (do 255 zliczy w 32ms przy 8MHz)
  101.     TIMSK |= (1 << TOIE0); // przerwanie od przepelnienia
  102.    
  103. /*
  104.     ADMUX |=(1<<REFS0)|(1<<REFS1); // odniesienie wewnetrzne 2.56V
  105.     ADMUX |= (1<<MUX1)|(1<<MUX2);
  106.     ADCSRA |=(1<<ADPS0)|(1<<ADPS1)|(1<<ADPS2);
  107.     ADCSRA |=(1<<ADEN)|(1<<ADSC)|(1<<ADATE);
  108. */
  109.  
  110.     //do testow
  111.     for(int i=0; i<10; i++)
  112.     {
  113.     trzeci.pamiec[i]=190;      
  114.     }
  115.    
  116.    
  117.     LCD_Initalize(); // uruchomienie LCD 4x16 (zmodyfikowana biblioteka!)
  118.  
  119.  
  120. uint8_t tmp_sek=0;
  121. tmp_sek=Ssekundy; //poprzednia wartosc zmiennej Ssekundy -> (co 3 sekundy jest inkrementowana)
  122. for(;;)
  123.     {
  124.        
  125.         //do testow
  126.         for(int i=0; i<10;i++)
  127.         {
  128.             TEST[i]=trzeci.pamiec[i];
  129.         }
  130.        
  131.        
  132.     if(odbierz==0 && tmp_sek!=Ssekundy)
  133.             {
  134.                 tmp_sek=Ssekundy;
  135.                 switch (szklarnia) // sekwencja nadania prawa do nadawania, odczyt, sprawdzenie poprawnosci, dopisanie do pamieci
  136.                 {
  137.                     case 0:
  138.                             odbierz=1;
  139.                             uart_putc('a');
  140.                             _delay_ms(50);
  141.                             odczytaj(temp1);
  142.                             if(spr_poprawnosc(temp1)==1)
  143.                             dopisz(pierwszy, temp1);
  144.                             PORTD &=~_BV(5);
  145.                             break;
  146.                
  147.                     case 1:
  148.                             odbierz=2;
  149.                             uart_putc('b');
  150.                             _delay_ms(50);
  151.                             odczytaj(temp2);
  152.                             if(spr_poprawnosc(temp2)==1)
  153.                             dopisz(drugi, temp2);
  154.                             PORTD |=_BV(5);
  155.                             break;
  156.            
  157.                     case 2:
  158.                             odbierz=3;
  159.                             uart_putc('c');
  160.                             _delay_ms(50);
  161.                             odczytaj(temp3);
  162.                             if(spr_poprawnosc(temp3)==1)
  163.                             dopisz(trzeci, temp3);
  164.                             break;
  165.            
  166.                     case 3:
  167.                             odbierz=4;
  168.                             uart_putc('d');
  169.                             _delay_ms(50);
  170.                             odczytaj(temp4);
  171.                             if(spr_poprawnosc(temp4)==1)
  172.                             dopisz(czwarty, temp4);
  173.                             break;
  174.            
  175.                     case 4:
  176.                             odbierz=5;
  177.                             uart_putc('e');
  178.                             _delay_ms(50);
  179.                             odczytaj(temp5);
  180.                             if(spr_poprawnosc(temp5)==1)
  181.                             dopisz(piaty, temp5);
  182.                             break;
  183.            
  184.                     case 5:
  185.                             odbierz=6;
  186.                             uart_putc('f');
  187.                             _delay_ms(50);
  188.                             odczytaj(temp6);
  189.                             if(spr_poprawnosc(temp6)==1)
  190.                             dopisz(szosty, temp6);
  191.                             break;
  192.            
  193.                     case 6:
  194.                             odbierz=7;
  195.                             uart_putc('g');
  196.                             _delay_ms(50);
  197.                             odczytaj(temp7);
  198.                             if(spr_poprawnosc(temp7)==1)
  199.                             dopisz(siodmy, temp7);
  200.                             break;
  201.                    
  202.                     case 7:
  203.                             odbierz=8;
  204.                             uart_putc('h');
  205.                             _delay_ms(50);
  206.                             odczytaj(temp8);
  207.                             if(spr_poprawnosc(temp8)==1)
  208.                             dopisz(osmy, temp8);
  209.                             break;
  210.                     case 8:
  211.                             odbierz=9;
  212.                             uart_putc('i');
  213.                             _delay_ms(50);
  214.                             odczytaj(temp9);
  215.                             if(spr_poprawnosc(temp9)==1)
  216.                             dopisz(dziewiaty, temp9);
  217.                             break;
  218.                 }//koniec switcha
  219.             }//koniec ifa
  220.            
  221.             if(spr_alarm(tab_alarmow)!=0) //zwraca nr obiektu z alarmem
  222.             {
  223.             PORTD &=~_BV(6);
  224.             }
  225.             else
  226.             PORTD |=_BV(6);        
  227.     }//koniec petli glownej
  228. }//koniec maiana
  229.  
  230. ISR (TIMER0_OVF_vect)
  231. {
  232.     //PRZYCISKI DO PRZESUWANIA EKRANU RECZNIE 1
  233.     if(bit_is_set(PINB,2))
  234.     czas_p1=0;
  235.     if(bit_is_clear(PINB,2)) // przesuwanie w gore
  236.     {
  237.         czas_p1++;
  238.         if(czas_p1>8)
  239.         {
  240.             ekran++;
  241.             if(ekran>8)
  242.             ekran=0;
  243.             Ssekundy=0;
  244.             czas_p1=0;
  245.         }
  246.     }
  247.    
  248.     //PRZYCISKI DO PRZESUWANIA EKRANU RECZNIE 2
  249.     if(bit_is_set(PINB,1))
  250.     czas_p2=0;
  251.     if(bit_is_clear(PINB,1)) // przesuwanie w dol
  252.     {
  253.         czas_p2++;
  254.         if(czas_p2>8)
  255.         {
  256.             ekran--;
  257.             if(ekran<0)
  258.             ekran=8;
  259.             Ssekundy=0;
  260.             czas_p2=0;
  261.         }
  262.     }
  263.    
  264.     // SRODKOWY PRZYCISK DO USTAWIANIA ALARMOW
  265.         if(bit_is_set(PINB,3))
  266.         czas_p3=0;
  267.         if(bit_is_clear(PINB,3)) // przesuwanie w dol
  268.         {
  269.             czas_p3++;
  270.             if(czas_p3>8)
  271.             {
  272.                 czas_p3=0;
  273.             }
  274.         }
  275.    
  276.     sekunda++;
  277.     if(sekunda==32)
  278.     {
  279.         sekunda=0;
  280.         Ssekundy++;
  281.         szklarnia++;
  282.         if(szklarnia==9)
  283.         szklarnia=0;
  284.         if(Ssekundy==3)
  285.         {
  286.             Ssekundy=0;
  287.             ekran++; // ma byc ++
  288.             if(ekran>8)
  289.             ekran=0;
  290.         }
  291.     }
  292.    
  293. if(nastawianie==0)
  294.     {
  295.         switch (ekran)
  296.         {
  297.         case 0:
  298.         LCD_Clear();
  299.         LCD_GoTo(0,0);
  300.         sprintf(linia1,"dom: %s",dodaj_przecinek(temp1));
  301.         LCD_WriteText(linia1);
  302.         LCD_GoTo(0,1);
  303.         sprintf(linia2,"mnozarka: %s",dodaj_przecinek(temp2));
  304.         LCD_WriteText(linia2);
  305.         LCD_GoTo(0,2);
  306.         sprintf(linia3,"dmuchana: %s",dodaj_przecinek(temp3));
  307.         LCD_WriteText(linia3);
  308.         LCD_GoTo(0,3);
  309.         sprintf(linia4,"pierwsza 6: %s",dodaj_przecinek(temp4));
  310.         //sprintf(linia4, "t: %d %d %d %d",TEST[0],TEST[1],TEST[2],TEST[3]);
  311.         LCD_WriteText(linia4);
  312.         break;
  313.        
  314.         case 1:
  315.         LCD_Clear();
  316.         LCD_GoTo(0,0);
  317.         sprintf(linia1,"mnozarka: %s",dodaj_przecinek(temp2));
  318.         LCD_WriteText(linia1);
  319.         LCD_GoTo(0,1);
  320.         sprintf(linia2,"dmuchana: %s",dodaj_przecinek(temp3));
  321.         LCD_WriteText(linia2);
  322.         LCD_GoTo(0,2);
  323.         sprintf(linia3,"pierwsza 6: %s",dodaj_przecinek(temp4));
  324.         LCD_WriteText(linia3);
  325.         LCD_GoTo(0,3);
  326.         sprintf(linia4,"druga 6: %s",dodaj_przecinek(temp5));
  327.         LCD_WriteText(linia4);
  328.         break;
  329.        
  330.         case 2:
  331.         LCD_Clear();
  332.         LCD_GoTo(0,0);
  333.         sprintf(linia1,"dmuchana: %s",dodaj_przecinek(temp3));
  334.         LCD_WriteText(linia1);
  335.         LCD_GoTo(0,1);
  336.         sprintf(linia2,"pierwsza 6: %s",dodaj_przecinek(temp4));
  337.         LCD_WriteText(linia2);
  338.         LCD_GoTo(0,2);
  339.         sprintf(linia3,"druga 6: %s",dodaj_przecinek(temp5));
  340.         LCD_WriteText(linia3);
  341.         LCD_GoTo(0,3);
  342.         sprintf(linia4,"dziewiatka: %s",dodaj_przecinek(temp6));
  343.         LCD_WriteText(linia4);
  344.         break;
  345.        
  346.         case 3:
  347.         LCD_Clear();
  348.         LCD_GoTo(0,0);
  349.         sprintf(linia1,"pierwsza 6: %s",dodaj_przecinek(temp4));
  350.         LCD_WriteText(linia1);
  351.         LCD_GoTo(0,1);
  352.         sprintf(linia2,"druga 6: %s",dodaj_przecinek(temp5));
  353.         LCD_WriteText(linia2);
  354.         LCD_GoTo(0,2);
  355.         sprintf(linia3,"dziewiatka: %s",dodaj_przecinek(temp6));
  356.         LCD_WriteText(linia3);
  357.         LCD_GoTo(0,3);
  358.         sprintf(linia4,"sliwka: %s",dodaj_przecinek(temp7));
  359.         LCD_WriteText(linia4);
  360.         break;
  361.        
  362.         case 4:
  363.         LCD_Clear();
  364.         LCD_GoTo(0,0);
  365.         sprintf(linia1,"druga 6: %s",dodaj_przecinek(temp5));
  366.         LCD_WriteText(linia1);
  367.         LCD_GoTo(0,1);
  368.         sprintf(linia2,"dziewiatka: %s",dodaj_przecinek(temp6));
  369.         LCD_WriteText(linia2);
  370.         LCD_GoTo(0,2);
  371.         sprintf(linia3,"sliwka: %s",dodaj_przecinek(temp7));
  372.         LCD_WriteText(linia3);
  373.         LCD_GoTo(0,3);
  374.         sprintf(linia4,"dol: %s",dodaj_przecinek(temp8));
  375.         LCD_WriteText(linia4);
  376.         break;
  377.        
  378.         case 5:
  379.         LCD_Clear();
  380.         LCD_GoTo(0,0);
  381.         sprintf(linia1,"dziewiatka: %s",dodaj_przecinek(temp6));
  382.         LCD_WriteText(linia1);
  383.         LCD_GoTo(0,1);
  384.         sprintf(linia2,"sliwka: %s",dodaj_przecinek(temp7));
  385.         LCD_WriteText(linia2);
  386.         LCD_GoTo(0,2);
  387.         sprintf(linia3,"dol: %s",dodaj_przecinek(temp8));
  388.         LCD_WriteText(linia3);
  389.         LCD_GoTo(0,3);
  390.         sprintf(linia4,"piec: %s",dodaj_przecinek(temp9));
  391.         LCD_WriteText(linia4);
  392.         break;
  393.        
  394.         case 6:
  395.         LCD_Clear();
  396.         LCD_GoTo(0,0);
  397.         sprintf(linia1,"sliwka: %s",dodaj_przecinek(temp7));
  398.         LCD_WriteText(linia1);
  399.         LCD_GoTo(0,1);
  400.         sprintf(linia2,"dol: %s",dodaj_przecinek(temp8));
  401.         LCD_WriteText(linia2);
  402.         LCD_GoTo(0,2);
  403.         sprintf(linia3,"piec: %s",dodaj_przecinek(temp9));
  404.         LCD_WriteText(linia3);
  405.         LCD_GoTo(0,3);
  406.         sprintf(linia4,"dom: %s",dodaj_przecinek(temp1));
  407.         LCD_WriteText(linia4);
  408.         break;
  409.        
  410.         case 7:
  411.         LCD_Clear();
  412.         LCD_GoTo(0,0);
  413.         sprintf(linia1,"dol: %s",dodaj_przecinek(temp8));
  414.         LCD_WriteText(linia1);
  415.         LCD_GoTo(0,1);
  416.         sprintf(linia2,"piec: %s",dodaj_przecinek(temp9));
  417.         LCD_WriteText(linia2);
  418.         LCD_GoTo(0,2);
  419.         sprintf(linia3,"dom: %s",dodaj_przecinek(temp1));
  420.         LCD_WriteText(linia3);
  421.         LCD_GoTo(0,3);
  422.         sprintf(linia4,"mnozarka: %s",dodaj_przecinek(temp2));
  423.         LCD_WriteText(linia4);
  424.         break;
  425.        
  426.         case 8:
  427.         LCD_Clear();
  428.         LCD_GoTo(0,0);
  429.         sprintf(linia1,"piec: %s",dodaj_przecinek(temp9));
  430.         LCD_WriteText(linia1);
  431.         LCD_GoTo(0,1);
  432.         sprintf(linia2,"dom: %s",dodaj_przecinek(temp1));
  433.         LCD_WriteText(linia2);
  434.         LCD_GoTo(0,2);
  435.         sprintf(linia3,"mnozarka: %s",dodaj_przecinek(temp2));
  436.         LCD_WriteText(linia3);
  437.         LCD_GoTo(0,3);
  438.         sprintf(linia4,"dmuchana: %s",dodaj_przecinek(temp3));
  439.         LCD_WriteText(linia4);
  440.         break;
  441.         }
  442.     }
  443.     else
  444.     {
  445.         char chuj[5];
  446.         strcpy(chuj, alarm_do_string(tab_alarmow[1]->prog));
  447.         //tu wyswietlanie nastawiania.
  448.     }
  449. }
  450.  
  451. uint8_t spr_poprawnosc(char tab[])
  452. {
  453.     if(isdigit(tab[0])&&isdigit(tab[1])&&isdigit(tab[2]))
  454.     {
  455.     return 1;
  456.     }
  457.     else
  458.     return 0;
  459. }
  460.  
  461.  
  462. void odczytaj (char tab[])
  463. {
  464. unsigned int c=0;
  465.     for(int i=0; i<4; i++)
  466.         {
  467.             c = uart_getc();   
  468.             tab[i]=c;
  469.             if(i==3)
  470.                 {
  471.                     tab[4]='\0';
  472.                     odbierz=0;
  473.                     break;
  474.                 }
  475.         }
  476. }
  477.  
  478. void dopisz (alarm &ktory, char tab[])
  479. {
  480.     int pom=atoi(tab);
  481.     for(int i=8; i>=0; i--)
  482.         {
  483.             ktory.pamiec[i+1]=ktory.pamiec[i];// przesuniecie tablicy w prawo o 1
  484.         }
  485.     ktory.pamiec[0]=pom; // wpisnie na miejsce 0 nowej temperatury
  486.  
  487. }
  488.  
  489. uint8_t spr_alarm(alarm **tab)
  490. {
  491.     PORTD |=_BV(4);
  492.     uint8_t wynik=0;
  493.     uint8_t pom=0;
  494.     for(int i=2; i<3; i++)// tu popraw po testach
  495.     {
  496.         for(int j=0; j<10; j++)
  497.         {
  498.             if(tab[i]->pamiec[j]<tab[i]->prog)
  499.             {
  500.             pom++;
  501.             PORTD &=~_BV(4);
  502.             }
  503.         }
  504.         if(pom>8)
  505.         {
  506.             wynik=i+1;
  507.         }
  508.         pom=0;
  509.     }
  510.     return wynik;
  511. }
  512.  
  513. char* dodaj_przecinek(char tab[])
  514. {
  515.     char pom;
  516.     for(int i=0; i<5; i++)
  517.     {
  518.         tmp[i]=tab[i];
  519.     }
  520.    
  521.     if(tab[0]!='0')
  522.     {
  523.         pom=tab[2];
  524.         tmp[2]='.';
  525.         tmp[3]=pom;
  526.         tmp[4]='\0';
  527.         return tmp; //tmp jest globalne, zwracamy adres tej tablicy
  528.     }
  529.     else
  530.     {
  531.         tmp[0]=tmp[1];
  532.         tmp[1]=tmp[2];
  533.         tmp[2]='.';
  534.         return tmp;
  535.     }
  536. }
  537. char* alarm_do_string (int &wartosc)
  538. {
  539.     char aaa[5]="abcd";
  540.     strcpy(tmp2, aaa);
  541.     return tmp2;
  542. }
  543.  
  544. /*
  545.         if(bit_is_set(PINB,2))
  546.         czas2=0;
  547.         if(bit_is_clear(PINB,2))
  548.         {
  549.             czas2++;
  550.             if(czas2>1000)
  551.             {
  552.                 uart_putc('b');
  553.                 sprintf(linia2,"Wyslano b");
  554.                 odbierz=1;
  555.                 czas2=0;
  556.             }
  557.         }*/
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!