API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 17th, 2019
143
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 8.48 KB | None | 0 0
raw download clone embed print report
  1. /* main.c
  2. * Created on: 17 lis 2019
  3. * Author: Student */
  4.  
  5.  
  6. //1.jedna dioda
  7. /*
  8. #include <avr/io.h>
  9. #include <util/delay.h>
  10.  
  11. #define LED_PIN ( 1 << PB0 )
  12. #define LED_TOG PORTB ^= LED_PIN //zmiana stanu
  13.  
  14. int main (void) {
  15. DDRB |= LED_PIN; //ustawienie portu jako wyjsciowy
  16.  
  17. while(1) {
  18. LED_TOG;
  19. _delay_ms(1000);
  20. }
  21. }
  22. */
  23.  
  24. //2.dwie diody
  25. /*
  26. #include <avr/io.h>
  27. #include <util/delay.h>
  28.  
  29. #define LED_PIN1 ( 1 << PB0 )
  30. #define LED_ON1 PORTB &= ~LED_PIN1 //włączenie
  31. #define LED_OFF1 PORTB |= LED_PIN1 //wyłączenie
  32. #define LED_TOG1 PORTB ^= LED_PIN1 //zmiana stanu
  33.  
  34. #define LED_PIN2 ( 1 << PB1 )
  35. #define LED_ON2 PORTB &= ~LED_PIN2 //włączenie
  36. #define LED_OFF2 PORTB |= LED_PIN2 //wyłączenie
  37. #define LED_TOG2 PORTB ^= LED_PIN2 //zmiana stanu
  38.  
  39. int main (void) {
  40. DDRB |= LED_PIN1;
  41. DDRB |= LED_PIN2;
  42.  
  43. while(1) {
  44. LED_OFF2;
  45. LED_ON1;
  46. _delay_ms(1000);
  47. LED_OFF1;
  48. LED_ON2;
  49. _delay_ms(1000);
  50. }
  51. }
  52. */
  53.  
  54. //3.Diody zapalają się od lewej do prawej
  55. /*
  56. #include <avr/io.h>
  57. #include <util/delay.h>
  58.  
  59. int main (void) {
  60. DDRB = 0xff; //do calego rejestru ustawiamy 1
  61. PORTB = 0xff; //dla calego portu ustawiamy 1 czyli gasimy diody bo diody podlaczone katoda
  62.  
  63. while(1) {
  64. for(uint8_t i=0; i<8; i++) {
  65. PORTB =~ ( 1 << i);
  66. _delay_ms(200);
  67. }
  68. }
  69. }
  70. */
  71.  
  72. //4.Diody zapalają się od lewej do prawej i potem od prawej do lewej
  73. /*
  74. #include <avr/io.h>
  75. #include <util/delay.h>
  76.  
  77. int main(void) {
  78. DDRB = 0xff;
  79. PORTB = 0xff;
  80.  
  81. while(1) {
  82. for(uint8_t i=0; i<8; i++) {
  83. PORTB =~ ( 1 << i);
  84. _delay_ms(200);
  85. }
  86. for(uint8_t i=6; i>0; i--) {
  87. PORTB =~ ( 1 << i);
  88. _delay_ms(200);
  89. }
  90. }
  91. }
  92. */
  93.  
  94. //5.Diody gasna od prawej do lewej i potem od lewej do prawej
  95. /*
  96. #include <avr/io.h>
  97. #include <util/delay.h>
  98.  
  99. int main(void) {
  100. DDRB = 0xff;
  101. PORTB = 0xff;
  102.  
  103. while(1) {
  104. for(uint8_t i=0; i<8; i++) {
  105. PORTB = ( 1 << i);
  106. _delay_ms(200);
  107. }
  108. for(uint8_t i=6; i>0; i--) {
  109. PORTB = ( 1 << i);
  110. _delay_ms(200);
  111. }
  112. }
  113. }
  114. */
  115.  
  116. //6. Dioda zapalana z przycisku
  117. /*
  118. #include <avr/io.h>
  119. #include <util/delay.h>
  120. #define LED_PIN ( 1 << PB0 )
  121. #define LED_TOG PORTB ^=LED_PIN
  122. #define LED_OFF PORTB |=LED_PIN
  123. #define KEY_PIN (1<<PC5)
  124. #define KEY_DOWN ! (PINC & KEY_PIN)
  125. int main(void){
  126. DDRB |= LED_PIN;
  127. PORTB |= LED_PIN;
  128. DDRC &= ~KEY_PIN;
  129. PORTC |= KEY_PIN;
  130.  
  131. while(1)
  132. {
  133. if(KEY_DOWN){
  134. _delay_ms(80);
  135. if(KEY_DOWN){
  136.  
  137.  
  138. LED_TOG;
  139. _delay_ms(500);
  140. }
  141. }else LED_OFF;
  142. }
  143.  
  144. }*/
  145. // 7.Przycisk i dioda ale inaczej
  146.  
  147.  
  148. /*
  149. #include <avr/io.h>
  150. #include <util/delay.h>
  151.  
  152.  
  153.  
  154. #define LED_PIN ( 1 << PB0 )
  155. #define LED_TOG PORTB ^=LED_PIN
  156. #define LED_OFF PORTB |=LED_PIN
  157. #define KEY_PIN (1<<PC5)
  158. #define KEY_DOWN ! (PINC & KEY_PIN)
  159.  
  160.  
  161. uint8_t Button_On(void);
  162.  
  163. int main(void) {
  164. DDRB |= LED_PIN;
  165. PORTB |= LED_PIN;
  166. DDRC &= ~KEY_PIN;
  167. PORTC |= KEY_PIN;
  168.  
  169. while(1) {
  170. if(Button_On()) {
  171. LED_TOG;
  172. _delay_ms(500);
  173. } else LED_OFF;
  174. }
  175. }
  176.  
  177. uint8_t Button_On(void) {
  178. if(KEY_DOWN) {
  179. _delay_ms(80);
  180. if(KEY_DOWN) { return 1; }
  181. }
  182. return 0;
  183. }
  184. */
  185.  
  186. //8.Jeden klawisz wlacza miganie diody, drugi wylacza. Oba wcisniete jednoczesnie
  187. /*
  188. #include <avr/io.h>
  189. #include <util/delay.h>
  190.  
  191. #define LED_PIN (1<<PB0)
  192. #define LED_TOG PORTB ^= LED_PIN
  193. #define LED_OFF PORTB |= LED_PIN //wyłączenie
  194. #define KEY_PIN (1<<PC5)
  195. #define KEY_DOWN ! (PINC & KEY_PIN)
  196. #define KEY_PIN1 (1<<PC4)
  197. #define KEY_DOWN1 ! (PINC & KEY_PIN1)
  198.  
  199. uint8_t Button_On(void);
  200. uint8_t Button_Off(void);
  201. void mk_delay_ms( uint16_t ms ) {
  202. while(ms--) { _delay_ms(1); }
  203. }
  204.  
  205. int main(void) {
  206. DDRB |= LED_PIN;
  207. PORTB |= LED_PIN;
  208. DDRC &= ~KEY_PIN;
  209. PORTC |= KEY_PIN;
  210. DDRC &= ~KEY_PIN1;
  211. PORTC |= KEY_PIN1;
  212.  
  213. while(1) {
  214. if( Button_On() == 1 && Button_Off() == 0 ) {
  215. LED_TOG;
  216. mk_delay_ms(500);
  217. }
  218. if( Button_On() == 1 && Button_Off() == 1 ) { LED_OFF; }
  219. if( Button_On() == 0 && Button_Off() == 0 ) { LED_OFF; }
  220. }
  221. }
  222.  
  223. uint8_t Button_On(void) {
  224. if(KEY_DOWN) {
  225. mk_delay_ms(80);
  226. if(KEY_DOWN) return 1;
  227. }
  228. return 0;
  229. }
  230.  
  231. uint8_t Button_Off(void) {
  232. if(KEY_DOWN1) {
  233. mk_delay_ms(80);
  234. if(KEY_DOWN1) return 1;
  235. }
  236. return 0;
  237. }
  238. */
  239.  
  240. //9.Cztery klawisze wszystkie diody
  241.  
  242. #include <avr/io.h>
  243. #include <avr/interrupt.h>
  244. #include <util/delay.h>
  245.  
  246. #define KEY_PIN (1<<PC5) //Def. pinu do ktorego podlaczony przycisk
  247. #define KEY_DOWN ! (PINC & KEY_PIN) //makro sprawdzajace czy jest stan 0
  248. #define KEY_PIN1 (1<<PC4) //Def. pinu do ktorego podlaczony przycisk
  249. #define KEY_DOWN1 ! (PINC & KEY_PIN1) //makro sprawdzajace czy jest stan 0
  250. #define KEY_PIN2 (1<<PC6) //Def. pinu do ktorego podlaczony przycisk
  251. #define KEY_DOWN2 ! (PINC & KEY_PIN2) //makro sprawdzajace czy jest stan 0
  252.  
  253. void mk_delay_ms( uint16_t ms ) {
  254. while(ms--) { _delay_ms(1); }
  255. }
  256. /*void mk_delay_ms( uint16_t ms ) {
  257. while(ms--) { _delay_ms(1); }
  258. }*/
  259.  
  260. volatile uint8_t licznik; //zmienna do do zliczania taktow
  261. uint8_t Lewo_Prawo(void), Flag_Lewo_Prawo = 0, StanBefore = 0, StanNow = 0;
  262. uint8_t Prawo_Lewo(void), Flag_Prawo_Lewo = 0, StanBefore1 = 0, StanNow1 = 0;
  263. uint8_t Wygas(void), Flag_Wygas = 0, StanBefore2 = 0, StanNow2 = 0;
  264.  
  265.  
  266. int main(void) {
  267. DDRB = 0xff; //do calego rejestru D ustawiamy 1
  268. PORTB = 0xff; //dla calego portu D ustawiamy 1 czyli gasimy diody bo diody podlaczone katoda
  269. DDRC &= ~KEY_PIN; //kierunek pinu jako wejsciowy
  270. PORTC |= KEY_PIN; //podciagniecie pinu do VCC (wew. rezystor)
  271. DDRC &= ~KEY_PIN1; //kierunek pinu jako wejsciowy
  272. PORTC |= KEY_PIN1; //podciagniecie pinu do VCC (wew. rezystor)
  273. DDRC &= ~KEY_PIN2; //kierunek pinu jako wejsciowy
  274. PORTC |= KEY_PIN2; //podciagniecie pinu do VCC (wew. rezystor)
  275. //timer///////////////////////////////////////////////////
  276. //TCCR0 |= (1<<CS02); //preskaler = 256 czyli 1 takt przy 8MHz 31250 timer zlicza impulsy z 8MHz/256= 31250 Hz czyli 0,032 ms
  277. TCCR0 |= (1<<CS02) | (1<<CS00); //1024 czyli 8Mhz/1024= 7812,5 Hz czyli 0,128 ms
  278. TIMSK |= (1<<TOIE0); //Zezwolenie na przerwanie Compare Match
  279. sei();
  280. //timer///////////////////////////////////////////////////
  281. while(1){
  282. StanNow = KEY_DOWN; //obsl. przycisk
  283. if(StanNow != StanBefore) { //wykr. zmiany stanu
  284. mk_delay_ms(80);
  285. if(StanNow != StanBefore) {
  286. if(StanNow == 0) { //zb opadaj. przycisk wcisniety
  287. Flag_Lewo_Prawo = !Flag_Lewo_Prawo;
  288. Flag_Prawo_Lewo = 0;
  289. }
  290. StanBefore = StanNow;
  291. }
  292. }
  293. if(Flag_Lewo_Prawo == 1) { Lewo_Prawo(); }
  294.  
  295. StanNow1 = KEY_DOWN1; //obsl. przycisk
  296. if(StanNow1 != StanBefore1) { //wykr. zmiany stanu
  297. mk_delay_ms(80);
  298. if(StanNow1 != StanBefore1) {
  299. if(StanNow1 == 0) { //zb opadaj. przycisk wcisniety
  300. Flag_Prawo_Lewo = !Flag_Prawo_Lewo;
  301. Flag_Lewo_Prawo = 0;
  302. }
  303. StanBefore1 = StanNow1;
  304. }
  305. }
  306. if(Flag_Prawo_Lewo == 1) { Prawo_Lewo(); }
  307.  
  308. StanNow2 = KEY_DOWN2; //obsl. przycisk
  309. if(StanNow2 != StanBefore2) { //wykr. zmiany stanu
  310. mk_delay_ms(80);
  311. if(StanNow2 != StanBefore2) {
  312. if(StanNow1 == 0) { //zb opadaj. przycisk wcisniety
  313. Flag_Wygas = !Flag_Wygas;
  314. Flag_Wygas = 0;
  315. }
  316. StanBefore2 = StanNow2;
  317. }
  318. }
  319. if(Flag_Wygas == 1) { Wygas(); }
  320.  
  321. if(KEY_DOWN2) {
  322. mk_delay_ms(80);
  323. if(KEY_DOWN2) PORTB = 0xFF;
  324. }
  325.  
  326. }
  327. }
  328.  
  329. ISR(TIMER0_OVF_vect) { ++licznik; }
  330.  
  331. uint8_t Lewo_Prawo(void) {
  332. static volatile uint8_t step = 0;
  333. if ( licznik >= 10){
  334. if(++step == 8) step = 0;
  335.  
  336. PORTB = ~(1<<(7-step));
  337. licznik=0;
  338. }
  339. }
  340.  
  341. uint8_t Prawo_Lewo(void) {
  342. static volatile uint8_t step = 0;
  343. if ( licznik >= 10){
  344. if(++step == 8) step = 0;
  345.  
  346. PORTB = ~(1<<step);
  347. licznik=0;
  348. }
  349. }
  350. /*uint8_t Wygas(void) {
  351. static volatile uint8_t step = 0;
  352. if ( licznik >= 10){
  353. ku+as=10;
  354. licznik=0;
  355. }
  356. }
  357. */
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!