Advertisement
Guest User

Untitled

a guest
Jun 24th, 2019
57
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 5.84 KB | None | 0 0
  1. /*
  2.  * pwm.c
  3.  *
  4.  * Created: 30.05.2019 14:28:36
  5.  * Author : sala204
  6.  */
  7. /*
  8.  * USART.c
  9.  *
  10.  * Created: 25.04.2019 16:19:11
  11.  * Author : sala204
  12.  */
  13. #define F_CPU 16000000UL
  14. #include <avr/io.h>
  15. #include <avr/interrupt.h>
  16. #include <util/atomic.h>
  17. #include <util/delay.h>
  18. #include <string.h>
  19. #include <stdio.h>
  20. #define FOSC 1843200// Clock Speed
  21. #define BAUD 9600
  22. #define MYUBRR FOSC/16/BAUD-1
  23.  
  24. volatile char przerwanie;
  25. volatile unsigned char przetwornik;
  26. //volatile unsigned char przetwornik2;
  27.  
  28. void sterowanie(unsigned char ster);
  29. void USART_Init(){
  30.    
  31.     UBRR0H = (unsigned char)0;
  32.     UBRR0L = (unsigned char)16;
  33.    
  34.     UCSR0B  = (1<<TXEN0) | (1<<RXEN0) | (1<<RXCIE0);
  35.     UCSR0C |= (3<<UCSZ00);
  36.     UCSR0A |= (1 << U2X0);
  37. }
  38.  
  39. void USART_Transmit( unsigned char data )
  40. {
  41.     while( !( UCSR0A & (1<<UDRE0)) );  
  42.         UDR0 = data;
  43. }
  44.  
  45. void USART_Transmit_String(char* stringToSend)
  46. {
  47.     for(int i = 0; stringToSend[i] != '\0'; i++)
  48.     {
  49.         USART_Transmit(stringToSend[i]);
  50.     }
  51. }
  52.  
  53. unsigned char USART_Receive( void )
  54. {
  55.    
  56.     while ( !(UCSR0A & (1<<RXC0)) ) ;
  57.    
  58.     return UDR0;
  59. }
  60.  
  61. ISR(USART0_RX_vect)
  62. {
  63.     przerwanie = USART_Receive();
  64.     sterowanie(przerwanie);
  65. }
  66.  
  67.  void ADC_Init()
  68. {
  69.     ADMUX= (0<<REFS1) | (1<<REFS0) | (1<<ADLAR);
  70.     DIDR0 = (1<<ADC0D);
  71.     ADCSRA = (1<<ADEN) | (1<<ADATE) | (1<<ADIE) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0) | (1<<ADSC);
  72. }
  73. /*
  74. ISR(ADC_vect)
  75. {
  76.     przetwornik = USART_Receive(przerwanie);
  77.     sterowanie();
  78. }*/
  79.  
  80. void na_char(int liczba, unsigned char* tab)
  81. {
  82.     int setki, dziesiatki, jednosci;
  83.     if(liczba >= 100)
  84.     {
  85.         jednosci = liczba % 10;
  86.         liczba = liczba / 10;
  87.        
  88.         dziesiatki = liczba % 10;
  89.         liczba = liczba / 10;
  90.        
  91.         setki = liczba;
  92.         tab[2] = jednosci + 48;
  93.         tab[1] = dziesiatki + 48;
  94.         tab[0] = setki + 48;
  95.     }
  96.     else if(liczba >= 10)
  97.     {
  98.         jednosci = liczba % 10;
  99.         liczba = liczba / 10;
  100.        
  101.         dziesiatki = liczba % 10;
  102.         liczba = liczba / 10;
  103.         tab[2] = jednosci + 48;
  104.         tab[1] = dziesiatki + 48;
  105.         tab[0] = ' ';
  106.     }
  107.     else
  108.     {
  109.         tab[2] = liczba + 48;
  110.         tab[1] = ' ';
  111.         tab[0] = ' ';      
  112.     }
  113. }
  114. int czujnik_przod()
  115. {
  116.     if(((PINJ & (1<<PJ0)) == 0) || ((PINJ & (1<<PJ1))==0))
  117.         return 1;
  118.     else return 0;
  119. }
  120.  
  121. int czujnik_tyl()
  122. {
  123.        
  124. }
  125.  
  126.  
  127. void lewy_kierunek()
  128. {
  129.     PORTG |= (1<<PG5);  //zapal
  130.     _delay_ms(1000);    //poczekaj sekunde
  131.     PORTG &= ~(1<<PG5); //zgas
  132. }
  133.  
  134. void prawy_kierunek()
  135. {
  136.     PORTB |= (1<<PB6);  //zapal
  137.     _delay_ms(1000);    //poczekaj sekunde
  138.     PORTB &= ~(1<<PB6); //zgas
  139. }
  140. void sterowanie(unsigned char ster)
  141. {
  142.     DDRE |= (1 << PE4); //PH LEFT  - sterowanie silnikiem lewym
  143.     DDRE |= (1 << PE5); //PH RGHT - sterowanie silnikiem prawym
  144.     DDRH |= (1 << PH6); //EN RGHT  -  wlaczenie silnika prawego
  145.     DDRB |= (1 << PB4); //EN LEFT - wlaczanie silnika lewego
  146.     DDRE |= (1 << PE3); //swiatla tyl
  147.     DDRH |= (1 << PH3); //swiatla przod
  148.     TCCR2A |= (0 << WGM22) | (1 << WGM21) | (1 << WGM20) | (1 << COM2A1) | (0 << COM2A0) | (1 << COM2B1) | (0 << COM2B0); // wlaczenie PWM
  149.     TCCR2B |= (1 << CS22) | (0 << CS21) | (0 << CS20);  // prescaler clk/64
  150.     int lewy, prawy;
  151.     unsigned char wiadomosc[4];
  152.     wiadomosc[3] = 0;   //ostatni bit wiadomosci ustawiony na 0
  153.     DDRB |= (1<<PB6);
  154.     DDRG |= (1<<PG5);
  155.     DDRH |= (1 << PH3);
  156.     DDRE |= (1 << PE3);
  157.     DDRJ &= (3<<PJ0);  
  158.  
  159.     switch(ster)
  160.     {
  161.         case 'F':
  162.         if(czujnik_przod()==1)
  163.         {
  164.             OCR2A = 0;
  165.             OCR2B = 0;
  166.         }
  167.         else
  168.         {
  169.             PORTE |= (1 << PE4);
  170.             PORTE |= (1 << PE5);
  171.             PORTH |= (1 << PH3);    //swiatla przod
  172.             PORTE &= ~(1 << PE3);   //gaszenie swiatel tyl
  173.             OCR2A = 100;
  174.             OCR2B = 100;
  175.         }
  176.         break;
  177.         case 'S':                       //stop pojazdu
  178.             OCR2A = 0;
  179.             OCR2B = 0;
  180.             break;
  181.         case 'B':                       //jazda do tyłu
  182.             PORTE &= ~(1 << PE4);
  183.             PORTE &= ~(1 << PE5);
  184.             PORTH &= ~(1 << PH3);   //gaszenie swiatla przod
  185.             PORTE |= (1 << PE3);    //zapalanie swiatel tyl
  186.             OCR2A = 100;
  187.             OCR2B = 100;
  188.             break;
  189.         case 'L':                   //jazda w lewo
  190.             //lewy_kierunek();
  191.             lewy = OCR2A;
  192.             prawy = OCR2B;
  193.             if(lewy > prawy)
  194.             {
  195.                 lewy = prawy;
  196.                 prawy = prawy + 50;
  197.                 OCR2B = prawy;
  198.             }
  199.             else
  200.             {
  201.                 prawy = prawy + 50;
  202.                 OCR2B = prawy;
  203.             }
  204.             break;
  205.         case 'R':                   //jazda w prawo
  206.             //prawy_kierunek();
  207.             lewy = OCR2A;
  208.             prawy = OCR2B;
  209.             if(prawy > lewy)
  210.             {
  211.                 prawy = lewy;
  212.                 lewy = lewy + 50;
  213.                 OCR2A = lewy;
  214.             }
  215.             else
  216.             {
  217.                 lewy = lewy + 50;
  218.                 OCR2A = lewy;
  219.             }
  220.             break;
  221.         case 'U':                   //zwieksz predkosc
  222.             if((OCR2A>245) || (OCR2B>245))
  223.             {
  224.                 OCR2A = 255;
  225.                 OCR2B = 255;
  226.             }
  227.             else
  228.             {
  229.                 OCR2A = OCR2A + 10;
  230.                 OCR2B = OCR2B + 10;
  231.             }
  232.             break;
  233.         case 'D':                   //zmniejsz predkosc
  234.             if((OCR2A>=10) && (OCR2B>=10))
  235.             {
  236.                 OCR2A = OCR2A - 10;
  237.                 OCR2B = OCR2B - 10;
  238.                 na_char(OCR2A, wiadomosc);
  239.                 USART_Transmit_String(wiadomosc);
  240.                 USART_Transmit(13);
  241.             }
  242.         break;
  243.     }
  244. }
  245.  
  246. int main(void)
  247. {
  248.     USART_Init ( MYUBRR );
  249.     ADC_Init();
  250.     sei();
  251.    
  252.     sterowanie(przerwanie);
  253.     while (1)
  254.     {
  255.        
  256.     }
  257. }
  258.  
  259. /*
  260. #include <avr/io.h>
  261.  
  262.  
  263. int main(void)
  264. {
  265.     DDRE |= (1 << PE4); //PH LEFT  - sterowanie silnikiem lewym
  266.     DDRE |= (1 << PE5); //PH RGHT - sterowanie silnikiem prawym
  267.     DDRH |= (1 << PH6); //EN RGHT  -  wlaczenie silnika prawego
  268.     DDRB |= (1 << PB4); //EN LEFT - wlaczanie silnika lewego
  269.    
  270.     TCCR2A |= (0 << WGM22) | (1 << WGM21) | (1 << WGM20) | (1 << COM2A1) | (0 << COM2A0) | (1 << COM2B1) | (0 << COM2B0); // wlaczenie PWM
  271.     TCCR2B |= (1 << CS22) | (0 << CS21) | (0 << CS20);  // prescaler clk/64
  272.     OCR2A = 250;
  273.     OCR2B = 50;
  274.     while (1)
  275.     {
  276.        
  277.     }
  278. }
  279.  
  280. */
  281.  
  282.         //ADC
  283.         /*
  284.         ADC_TMP = przetwornik;
  285.         roznica = abs(ADC_TMP - ADC_TMP2);
  286.         if(roznica >= 10)
  287.         {
  288.                 na_char(przetwornik, wiadomosc);
  289.                 USART_Transmit_String(tekst);
  290.                 USART_Transmit_String(wiadomosc);
  291.                 USART_Transmit(13);
  292.                 ADC_TMP2 = ADC_TMP;
  293.                 OCR2A = ADC_TMP;
  294.                 OCR2B = ADC_TMP;
  295.         }   */
  296.         //przerwanie = USART_Receive();
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement