API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 25th, 2016
80
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 15.82 KB | None | 0 0
raw download clone embed print report
  1. #define F_CPU 14745600UL
  2. #define rozmiar_tablicy_z_probkami 200
  3.  
  4. #include <avr/io.h> //biblioteka wejscia - wyjscia
  5. #include <avr/interrupt.h> // przerwania
  6. #include <util/delay.h> // delaye
  7. #include <avr/pgmspace.h> // zapis w pamięci FLASH
  8. #include "uart/uart.h" // biblioteka Antystatycznego do obsługi transmisji UART
  9. #include <stdlib.h> //biblioteka potrzebna do zamiana stringow na inty
  10. #include "flash2/SPI.h"
  11. #include "flash2/AT45DB011.h"
  12.  
  13.  
  14. void start_timer_0(void);
  15. void start_timer_1(uint8_t prescaler);
  16. void stop_timer_1(void);
  17.  
  18.  
  19.  
  20. volatile uint8_t timer0_ovf;
  21. volatile uint8_t liczba_zboczy;
  22. volatile uint8_t buffer_count;
  23. volatile uint8_t error_lvl; // 1-przepelnienie licznikow
  24. volatile uint32_t timer_overflow;
  25. volatile uint32_t total_ticks;
  26. volatile uint32_t wyniki[rozmiar_tablicy_z_probkami];
  27. volatile uint8_t zadany_preskaler=0;
  28. char char_buffer[10];
  29. int page_number=0;
  30.  
  31.  
  32. void setup(void)
  33. {
  34. MCUCR =0xc0; // Eneble external SRAM with wait state
  35. SPI_init(); // Initialize SPI
  36. AT45DB011_init(); // Initialize DataFlash
  37. }
  38.  
  39.  
  40. // Funckja odpowiedzialana za wyswietlenie napisu powitalnego
  41. void napis_powitalny(void)
  42. {
  43.  
  44. uart_put_string_P(0, (PSTR("\r\nLicznik \r\nWykonanie: Mariusz Karasek i Mateusz Warowny\r\nData: Czerwiec 2016")));
  45. _delay_ms(100);
  46. }// koniec funckji ekran powitalny
  47.  
  48.  
  49. //funkcja przyjmuje liczbe probek do pomiaru
  50. long int przyjmij_liczbe_probek()
  51. {
  52. //zeruje nam tablice z probkami dla nowego pomiaru
  53. //for(int x=0; x<liczba_zlapanych_zboczy; x++)
  54. //wyniki[x]=0;
  55.  
  56. //zeruje liczbe zboczy dla nowego pomiaru
  57. //liczba_zboczy=0;
  58.  
  59.  
  60. //wskaznik_przepelnienia=0;
  61. //wskaznik_przepelnienia1=0;
  62.  
  63. char tablica[20]; //tworzymy tablice na znaki odczytane z UART
  64. uart_put_string_P(0, (PSTR("\r\n\r\nPodaj liczbe probek:")));
  65. //petla ktora nieskonczenie bedzie powtarzac proszenie o probki w przypadku podania niepoprawnej wartosci
  66. while(1)
  67. {
  68. //zerujemy pierwszy znak - jesli sie zmieni (podano liczbe probek) to wyjdziemy z petli
  69. tablica[0]=0;
  70.  
  71. long int liczba_probek=0;
  72. int wylacznik=1;
  73.  
  74. //petla oczekujaca danych nadeslanych z komputera
  75. while(wylacznik)
  76. {
  77. uart_get_string(0,tablica); // odebrane dane zapisujemy w tablica
  78.  
  79. //jesli odebrano wartosc (zmieni się 1 znak)
  80. if(tablica[0]!=0)
  81. {
  82. //zmieniamy stringa na int i sprawdzamy czy >0 (dla liter =0, dla cyfr>0)
  83. liczba_probek = atol(tablica);//zamienia stringa na long int i zapisujemy w liczba_probek
  84. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  85. }
  86.  
  87. _delay_ms(55);
  88. }//koniec while do pobierania danych z komputera
  89.  
  90. //jesli liczba probek jest liczba >0 (dla tekstu tez daje 0)
  91. if(liczba_probek>0)
  92. return liczba_probek; //wymuszamy zwracanie long inta bo normalnie zwraca inta
  93. else
  94. {
  95. uart_put_string_P(0, (PSTR("\r\nZła liczba próbek, sprobuj ponownie:\r\n\r\n Podaj liczbę próbek")));
  96. }//koniec else
  97. }//koniec while
  98. }// koniec funkcji do pryzjmowania liczby probek
  99.  
  100.  
  101.  
  102. unsigned int wybierz_preskaler()
  103. {
  104.  
  105. _delay_ms(50);
  106. char tablica[20]; //tworzymy tablice na znaki odczytane z UART
  107. uart_put_string_P(0, (PSTR("\r\n\r\nWybierz preskaler:")));
  108. uart_put_string_P(0, (PSTR("\r\n1): 1")));
  109. uart_put_string_P(0, (PSTR("\r\n2): 8")));
  110. uart_put_string_P(0, (PSTR("\r\n3): 64")));
  111. uart_put_string_P(0, (PSTR("\r\n4): 256")));
  112. uart_put_string_P(0, (PSTR("\r\n5): 1024")));
  113.  
  114.  
  115. //petla ktora nieskonczenie bedzie powtarzac proszenie o preskaler w przypadku podania niepoprawnej wartosci
  116. while(1)
  117. {
  118. //zerujemy pierwszy znak - jesli sie zmieni (podano liczbe probek) to wyjdziemy z petli
  119. tablica[0]=0;
  120.  
  121. int preskaler=0;
  122.  
  123. int wylacznik=1;
  124.  
  125. //petla oczekujaca danych nadeslanych z komputera
  126. while(wylacznik)
  127. {
  128. uart_get_string(0,tablica); // odebrane dane zapisujemy w tablica
  129.  
  130. //jesli odebrano wartosc (zmieni się 1 znak)
  131. if(tablica[0]!=0)
  132. {
  133. //zmieniamy stringa na int i sprawdzamy czy >0 (dla liter =0, dla cyfr>0)
  134. preskaler = atoi(tablica);//zamienia stringa na int i zapisujemy w liczba_probek
  135. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  136. }
  137.  
  138. //1, 8, 64, 256, 1024
  139. if(preskaler==1)
  140. {
  141. uart_put_string_P(0, (PSTR("\r\n\r\nWybrano preskaler 1 (1x)")));
  142. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  143.  
  144. }
  145.  
  146. else if(preskaler==2)
  147. {
  148. uart_put_string_P(0, (PSTR("\r\n\r\n Wybrano preskaler 2 (8x)")));
  149. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  150.  
  151. }
  152.  
  153. else if(preskaler==3)
  154. {
  155. uart_put_string_P(0, (PSTR("\r\n\r\n Wybrano preskaler 3 (64x)")));
  156.  
  157. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  158.  
  159. }
  160.  
  161. else if(preskaler==4)
  162. {
  163. uart_put_string_P(0, (PSTR("\r\n\r\n Wybrano preskaler 4 (256x)")));
  164. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  165.  
  166. }
  167.  
  168. else if(preskaler==5)
  169. {
  170. uart_put_string_P(0, (PSTR("\r\n\r\n Wybrano preskaler 5 (1024x)")));
  171. wylacznik = 0; //ustawiamy na 0 by wyskoczyc z petli
  172.  
  173. }
  174.  
  175. _delay_ms(40);
  176. }//koniec while do pobierania danych z komputera
  177.  
  178. //jesli liczba probek jest liczba >0 (dla tekstu tez daje 0) oraz mieści się do 5
  179. if(preskaler>0 && preskaler<6)
  180. return preskaler; //wymuszamy zwracanie long inta bo normalnie zwraca inta
  181. else
  182. {
  183. uart_put_string_P(0, (PSTR("\r\n Zły preskaler [wyslij cyfre od 1 do 5]:\r\n")));
  184. uart_put_string_P(0, (PSTR("\r\n\r\nWybierz preskaler:")));
  185. uart_put_string_P(0, (PSTR("\r\n1): 1")));
  186. uart_put_string_P(0, (PSTR("\r\n2): 8")));
  187. uart_put_string_P(0, (PSTR("\r\n3): 64")));
  188. uart_put_string_P(0, (PSTR("\r\n4): 256")));
  189. uart_put_string_P(0, (PSTR("\r\n5): 1024")));
  190. }//koniec else
  191. }//koniec while
  192. }// koniec funkcji wybierz preskaler
  193.  
  194.  
  195.  
  196.  
  197. // funkcja czeka na napisanie komunikatu start do mikrokontrolera
  198. int oczekuj_startu(void)
  199. {
  200. uart_put_string_P(0, (PSTR("\r\n\r\nwyslij 'start' aby rozpoczac"))); char tablica[20]; //tworzymy tablice na znaki odczytane z RS232
  201.  
  202.  
  203. char wzorzec[20]; //tworzymy tablice z wzorem naszego napisu
  204. //zapelniamy tablice 0 - bo funkcja get string zapelnia puste miejsca zerami
  205. for(int i=0; i<19; i++)
  206. {
  207. tablica[i]=0;
  208. wzorzec[i]=0;
  209. }
  210.  
  211. // tworzymy napis w tablicy na ktory ma reagowac nasz program
  212. wzorzec[0]='s';
  213. wzorzec[1]='t';
  214. wzorzec[2]='a';
  215. wzorzec[3]='r';
  216. wzorzec[4]='t';
  217.  
  218. //do czasu otrzymania napisu start nie wyjdziemy z petli
  219. while(1)
  220. {
  221.  
  222. tablica[0]=0; //na pierwszt znak dajemy 0 - swiadczy to o braku odczytania napisu
  223. uart_get_string(0,tablica);
  224. _delay_ms(50);
  225.  
  226. //jesli odczytano cos z komputera - zmieni sie pierwszy znak
  227. if (tablica[0] != 0)
  228. {
  229. int poprawnosc_wpisu=1;
  230.  
  231. //porownuje literka po literce czy litery sa zgodne - jesli jeden znak sie nie zgadza to calosc sie nie zgadza
  232. for(int i=0; i<19; i++)
  233. {
  234. if(tablica[i]==wzorzec[i])
  235. poprawnosc_wpisu=poprawnosc_wpisu*1; //iloczyn wszystkich pomiarow bedzie ktorykolwiek znak sie nie zgodzi
  236. else
  237. poprawnosc_wpisu=poprawnosc_wpisu*0;
  238. }//koniec for
  239.  
  240. if(poprawnosc_wpisu)
  241. return 1;
  242. else
  243. return 0;
  244.  
  245. _delay_ms(100);
  246.  
  247. }//koniec if'a
  248. }//koniec while
  249.  
  250. }//koniec funkcji czekania na start
  251.  
  252.  
  253. //funkcja identyczna jak start, tylko tym razem oczekuje napisu pobierz
  254. int oczekuj_odbioru(void)
  255. {
  256. uart_put_string_P(0, (PSTR("\r\n\r\nAby pobrac dane wyslij 'pobierz'")));
  257. char tablica[20]; //tworzymy tablice na znaki odczytane z RS232
  258. char wzorzec[20]; //tworzymy tablice z wzorem naszego napisu
  259.  
  260. //zapelniamy tablice 0 - bo funkcja get string zapelnia puste miejsca zerami
  261.  
  262. for(int i=0; i<20; i++)
  263. {
  264. tablica[i]=0;
  265. wzorzec[i]=0;
  266. }//koniec for
  267.  
  268. wzorzec[0]='p';
  269. wzorzec[1]='o';
  270. wzorzec[2]='b';
  271. wzorzec[3]='i';
  272. wzorzec[4]='e';
  273. wzorzec[5]='r';
  274. wzorzec[6]='z';
  275.  
  276. while(1)
  277. {
  278.  
  279. tablica[0]=0; //na 1 znak dajemy zero - swiadczy to o braku odczytania napisu
  280. uart_get_string(0,tablica);
  281. _delay_ms(80);
  282.  
  283. if (tablica[0] != 0)
  284. {
  285. int poprawnosc_wpisu=1;
  286.  
  287. //porownuje literka po literce czy litery sa zgodne
  288. for(int i=0; i<19; i++)
  289. {
  290. if(tablica[i]==wzorzec[i])
  291. poprawnosc_wpisu=poprawnosc_wpisu*1;
  292. else
  293. poprawnosc_wpisu=poprawnosc_wpisu*0;
  294. }//koniec for
  295.  
  296. if(poprawnosc_wpisu)
  297. return 1;
  298. else
  299. return 0;
  300. _delay_ms(100);
  301. }//koniec if'a
  302. }//koniec while
  303.  
  304. }//koniec funkcji czekania na zadanie odbior danych
  305.  
  306.  
  307.  
  308. // funkcja przyjmuje liczbe probek, dokounje pomiaru i wyswietla podsumowanie
  309. void pomiar_i_wyslanie(long int liczba_probek, unsigned int wybor_preskalera){
  310.  
  311.  
  312. uart_put_string_P(0, (PSTR("\r\n\r\nrobie pomiar dla ")));
  313.  
  314. char str[16];
  315. ltoa(liczba_probek,str,10); //zamienia long int int na tablice znakow by wyslac jako string
  316. uart_put_string(0, str);
  317. uart_put_string_P(0, (PSTR(" probek...")));
  318.  
  319. buffer_count=0;
  320. liczba_zboczy=0;
  321. unsigned int wylacznik=1;
  322.  
  323. //tutaj jako argument preskaler
  324. start_timer_1(wybor_preskalera);
  325.  
  326. while (wylacznik) {
  327. //_delay_ms(50);
  328. total_ticks = timer_overflow;
  329. total_ticks<<=16;
  330. total_ticks+=TCNT1;
  331.  
  332. //tutaj w warunku ilosc obrotow
  333. if(total_ticks>liczba_probek){
  334. stop_timer_1();
  335.  
  336. ltoa(total_ticks,char_buffer,10);
  337. uart_put_string_P(0, (PSTR("\r\nLiczba obrotow: ")));
  338. uart_put_string(0,char_buffer);
  339. wylacznik=0;
  340.  
  341. if(buffer_count>=264){
  342. DATAFLASH_write_mem_buffer_to_page(page_number);
  343. while (!(DATAFLASH_read_mem_stat() & 0x80)); // wait for DataFlash ready flag
  344. buffer_count=0;
  345. page_number++;
  346. }
  347. // while(1);
  348. }
  349. }
  350.  
  351. //DODAC INFORMACJE O PRZEPELNIENIU LICZNIKA CZY TAM ZMIENNEJ?
  352.  
  353.  
  354.  
  355.  
  356. wylacznik=1;
  357.  
  358. //petla pozwala wyslac po raz drugi poprawny napis start jakby nie wyszlo
  359. while(wylacznik){
  360. if(oczekuj_odbioru())
  361. {
  362.  
  363. //kod wyslania pomiaru
  364.  
  365.  
  366. uart_put_string_P(0, (PSTR("\r\n\r\nZebrano nastepujace wyniki pomiaru:")));
  367. uart_put_string_P(0, (PSTR("\r\nCzestotliwosc zegara: ")));
  368. str[16];
  369. ltoa(F_CPU,str,10); //zamienia long int int na tablice znakow
  370. uart_put_string(0, str);
  371. uart_put_string_P(0, (PSTR("Hz\r\nPreskaler: ")));
  372.  
  373.  
  374.  
  375.  
  376. unsigned int rodzaje_preskalera[6]={0,1,8,64,256,1024};
  377. uart_put_int(0, rodzaje_preskalera[wybor_preskalera]);
  378. uart_put_string_P(0, (PSTR("x")));
  379.  
  380. uart_put_string_P(0, (PSTR("\r\nzadana liczba impulsow: ")));
  381.  
  382. str[16];
  383. ltoa(liczba_probek,str,10); //zamienia long int int na tablice znakow
  384. uart_put_string(0, str);
  385. uart_put_string_P(0, (PSTR(" probek\r\n\r\nZebrane zbocza \r\n\r\n")));
  386.  
  387.  
  388.  
  389. int p=0; // zmienna sterujaca kolejnych elementwo w tablicy
  390. char str[16]; //tabelica dla znakow ktorymi beda wysylane liczby po UART
  391.  
  392. //wysyla wszyskie kroki pomiarowe
  393.  
  394. if(zadany_preskaler==1||zadany_preskaler==2)
  395. {
  396. uart_put_string_P(0, (PSTR("(wyniki z tablicy)\r\n\r\n")));
  397. _delay_ms(70);
  398.  
  399. for(int x=1; x<liczba_zboczy; x++)
  400. {
  401. if(wyniki[x]>0)
  402. {
  403.  
  404. ltoa(wyniki[x],str,10); //zamienia wynik pomiaru z long int na string i zapisuje w str
  405. uart_put_string(0, str); //wysyla moment pomiaru
  406. uart_put_string_P(0, (PSTR("\r\n"))); //nowa linia
  407. _delay_ms(20);
  408. p=x;
  409. }
  410.  
  411. }//koniec while dla wysylania zarejestrowanych pomiarow
  412. }
  413. else
  414. {
  415.  
  416. uart_put_string_P(0, (PSTR("(wyniki z FLASHA)\r\n\r\n")));
  417. _delay_ms(50);
  418.  
  419.  
  420. //!!!!! POTEM USUNAC podgladamy page number
  421.  
  422. uart_put_string_P(0, (PSTR("PAGE NUMBER: ")));
  423. ltoa(page_number,str,10); //zamienia wynik pomiaru z long int na string i zapisuje w str
  424. uart_put_string(0, str); //wysyla moment pomiaru
  425. uart_put_string_P(0, (PSTR("\r\n\r\n\r\n"))); //nowa linia
  426. _delay_ms(50);
  427.  
  428.  
  429. //!!!!! POTEM USUNAC page bufer na sztywno 10
  430.  
  431. page_number=10;
  432. for(int x=0; x<=page_number; x++)
  433. {
  434.  
  435. uint32_t wynik=0;
  436. for (int y=0; y<=264; y++)
  437. {
  438. uint32_t data1, data2, data3, data4;
  439.  
  440. data1=DATAFLASH_read_mem_main(x,y);
  441. y++;
  442. data2=DATAFLASH_read_mem_main(x,y);
  443. y++;
  444. data3=DATAFLASH_read_mem_main(x,y);
  445. y++;
  446. data4=DATAFLASH_read_mem_main(x,y);
  447. y++;
  448.  
  449. wynik=data1+data2*256+data3*65535;
  450.  
  451. //jesli wynik nie jest 0 albo wynik nie osiaga max
  452. if(wynik>0 && wynik<16776960){
  453. ltoa(wynik,str,10); //zamienia wynik pomiaru z long int na string i zapisuje w str
  454. uart_put_string(0, str); //wysyla moment pomiaru
  455. uart_put_string_P(0, (PSTR("\r\n"))); //nowa linia
  456. _delay_ms(30);
  457. }//koniec if dla wyniku >0
  458.  
  459. }// for dla przegladania strony
  460.  
  461. } //for dla zmiany stron
  462.  
  463.  
  464. }//koniec while dla wysylania zarejestrowanych pomiarow
  465.  
  466.  
  467. uart_put_string_P(0, (PSTR("RAZEM: ")));
  468. uart_put_int(0,p); //wysla liczbe pomiarow zapisana w zmiennej
  469.  
  470. uart_put_string_P(0, (PSTR("\r\n\r\nPomiar zakończony. Dziekujemy")));
  471. uart_put_string_P(0, (PSTR("\r\n\r\n##################################################")));// margines od kolejnego pomiaru
  472.  
  473. _delay_ms(100);
  474.  
  475. wylacznik=0;
  476. }//koniec ifa
  477.  
  478. else
  479. {
  480. uart_put_string_P(0, (PSTR("\r\n\r\n Niepoprawna komenda, sprobuj ponownie:")));
  481. _delay_ms(100);
  482. }//koniec else niepoprawnej komendy
  483. }//koniec while
  484. }//koniec funkcji pomiar
  485.  
  486.  
  487.  
  488.  
  489. //MAIN
  490. int main(void)
  491. {
  492.  
  493. //aktywacja uart
  494. uart_init(0,__UBRR0);
  495.  
  496. //aktywacja przerwan
  497. sei();
  498.  
  499. setup();
  500.  
  501.  
  502.  
  503.  
  504. //wyswietlenie ekeranu powitalnego
  505. napis_powitalny();
  506.  
  507. //funkcja while zapewniajaca ciaglosc programu - robi pomiar po pomiarze
  508.  
  509.  
  510.  
  511. // while(1){
  512.  
  513. uint32_t ilosc_probek = przyjmij_liczbe_probek();
  514.  
  515.  
  516. char str[16];
  517.  
  518. ltoa(ilosc_probek,str,10); //zamienia long int na tablice znakow
  519.  
  520. uart_put_string_P(0, (PSTR("\r\nZadana liczba probek to: ")));
  521. uart_put_string(0, str);
  522. _delay_ms(100);
  523.  
  524. zadany_preskaler = wybierz_preskaler();
  525.  
  526.  
  527. unsigned int wylacznik=1;
  528.  
  529. //petla pozwala wyslac po raz drugi poprawny napis start jakby nie wyszlo
  530.  
  531. while(wylacznik)
  532. {
  533. if(oczekuj_startu())
  534. {
  535. pomiar_i_wyslanie(ilosc_probek,zadany_preskaler);
  536. wylacznik=0;
  537. }
  538. else
  539. {
  540. uart_put_string_P(0, (PSTR("\r\n\r\n Niepoprawna komenda, sprobuj ponownie:")));
  541. _delay_ms(100);
  542. }//koniec else niepoprawnej komendy
  543.  
  544. }//koniec while
  545.  
  546.  
  547.  
  548. // }//koniec nieskocznonego while do powielania pomiarow
  549.  
  550.  
  551.  
  552. }//koniec main
  553.  
  554.  
  555.  
  556.  
  557. void start_timer_0(void){
  558. TCNT0 = 0;
  559. TIMSK = (1<<TOIE0);
  560. //TCCR0B =(1<<CS00);
  561.  
  562. }
  563.  
  564.  
  565.  
  566. void start_timer_1(uint8_t prescaler){
  567.  
  568. uint8_t prescaler_values[] = {
  569. 0, // stop timer
  570. (1<<CS10), // 1
  571. (1<<CS11), // 8
  572. (1<<CS10)|(1<<CS11), // 64
  573. (1<<CS12), // 256
  574. (1<<CS12)|(1<<CS10) // 1024
  575. };
  576.  
  577. TCNT1H = 0;
  578. TCNT1L = 0; // wyzerowanie timera
  579. TIMSK |= (1<<TOIE1)|(1<<TICIE1); // przerwanie przy przepelnieniu
  580. //TCCR1B = (1<<ICES1);
  581. // TCCR1B = prescaler_values[prescaler]; // wystarrowanie timera
  582.  
  583. TCCR1B |= (1<<ICES1)|prescaler_values[prescaler];
  584.  
  585. }
  586.  
  587.  
  588. void stop_timer_1(void){
  589. start_timer_1(0);
  590. }
  591.  
  592.  
  593. ISR(TIMER1_OVF_vect){
  594. timer_overflow++; // dodaj jedno przepelnienie
  595. }
  596.  
  597. ISR(TIMER1_CAPT_vect){
  598. if(zadany_preskaler==1||zadany_preskaler==2)
  599. {
  600. if(liczba_zboczy<=rozmiar_tablicy_z_probkami)
  601. {
  602. wyniki[liczba_zboczy]= (timer_overflow<<16);
  603. wyniki[liczba_zboczy]+=ICR1;
  604. liczba_zboczy++;
  605. }
  606. }
  607. else
  608. {
  609. DATAFLASH_write_mem_buf(buffer_count,ICR1H);
  610. buffer_count++;
  611. DATAFLASH_write_mem_buf(buffer_count,ICR1L);
  612. buffer_count++;
  613. DATAFLASH_write_mem_buf(buffer_count,timer_overflow);
  614. buffer_count++;
  615. DATAFLASH_write_mem_buf(buffer_count,/*przepełnienia*/0);
  616. buffer_count++;
  617. }
  618. }
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!