Fórum témák

» Több friss téma
Fórum » AVR - Miértek hogyanok
 
Témaindító: pakibec, idő: Márc 11, 2006
Témakörök:
WinAVR / GCC alapszabályok:
1. Ha ISR-ben használsz globális változót, az legyen "volatile"
2. Soha ne érjen véget a main() függvény
3. UART/USART hibák 99,9% a rossz órajel miatt van
4. Kerüld el a -O0 optimalizációs beállítást minden áron
5. Ha nem jó a _delay időzítése, akkor túllépted a 65ms-et, vagy rossz az optimalizációs beállítás
6. Ha a PORTC-n nem működik valami, kapcsold ki a JTAG-et
Bővebben: AVR-libc FAQ
Lapozás: OK   571 / 840
(#) Szabi1 válasza benjami hozzászólására (») Okt 26, 2013 /
 
igen ezt észrevettem, de csak nem működik...
(#) matheattila válasza Szabi1 hozzászólására (») Okt 26, 2013 /
 
Szia, nem tudom, hogy mekkora frekin járatod a procit, de az lcd.h-ban egy 20MHz-es kvarc van definiálva, így a függvények időzítései ahhoz vannak igazítva, esetleg írd át a te kvarcod értékére. A másik amit észre vettem, hogy szép nagy LCD-t használsz (legalább 14 soros és 9 oszlopos ) arra alapozva, hogy biztos vagy abban ahogy az lcd_gotoxy függvényt használod. A viccet férre téve, az x jelenti az oszlopok pozícióját és az y a sorok pozícióját. Tehát ha a második sor 10. oszlopához akarod tenni a kurzort akkor ezt kell beírd: lcd_gotoxy(9,1).
Szerintem az ADC-t sem kell állandóan inicializálni. Nem tudom mit akarsz azzal a '\037'-el de szerintem sokkal egyszerűbb lenne '%'-ot, vagy 0x25-öt írni helyette.
Ellenőrizd a bekötéseket, vagyis, hogy az lcd.c és lcd.h-ban használt PORT és pin-ek megegyeznek a valós bekötéseknke. Esetleg tegyél be minden lcd-re iratás után egy néhány ms-os delay-t, vagy ami a legbiztosabb, kommentálj ki mindent és csak az lcd-vel kapcsolatos dolgokat hagyd meg, és ott is a legalapvatőbb dolgokat próbáld ki:
  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3. #include <stdlib.h>
  4. #include "lcd.h"
  5. #include "lcd.c"
  6.  
  7. int main(void)
  8. {
  9.     lcd_init(LCD_DISP_ON);
  10.     lcd_home();
  11.     lcd_clrscr();
  12.  
  13.     lcd_puts("Hello World!");
  14.  
  15.     while(1){};
  16. }

Ha ez működik akkor az lcd rendben van, valami egyébbel lehet gond, amitől nem úgy működik a program ahogy elvárod.
(#) Fizikus válasza palomatE hozzászólására (») Okt 27, 2013 /
 
I2C (TWI) hasznalata AVR-rel:
Bővebben: Link
Ebben Peter Fleury TWI (I2C) konyvtarat hasznaltam.
(#) killbill válasza matheattila hozzászólására (») Okt 27, 2013 /
 
Idézet:
„Nem tudom mit akarsz azzal a '\037'-el de szerintem sokkal egyszerűbb lenne '%'-ot, vagy 0x25-öt írni helyette”

Igzad van, mert lathatolag szazalekjelet akart irni. Bár, ha szazalekjelet akarsz irni, akkor irjal azt, es ne 0x25-ot. Ugyanaz a ketto, de a '%' egyertelmubb. De a lenyeg, hogy mondjuk el az igazsagot ezzel kapcsolatban: A \037 az oktalis 37, ami decimalisan 31.

A \szamjegy es max. tovabbi ket szamjegy formaban leirt karakterkonstans oktalisan ertelmezodik, azaz nyolcas szamrendszerben. A \3 az 3, a \33 az decimalis 27 (ESC), a \101 az pedig decimalis 65, ami az 'A' betu. A \033 az ugyanaz, mint a \33, itt nincs kulonbseg, mindig oktalisnak tekinti.

A mai C szabvany karakterkonstans helyen mar megengedi a \xn vagy \xnn formatumot is, ahol n (nn) egy hexadecimalis szam. Tehat a '\x41' az megfelel az elobbi 'A'-nak, vagy a '\x25' a szazalekjelnek.

A C-ben sima konstansoknal, ha a szam 0-val kezdodik, akkor azt oktalisan ertelmezi a fordito, igy a 12 es a 012 egeszen mast jelent. Az egyik decimalis 12, a masik oktalis 12, ami decimalis 9. tehat az
a = 9;
a = 012;
pontosan ugyanaz.
A hozzászólás módosítva: Okt 27, 2013
(#) Szabi1 válasza matheattila hozzászólására (») Okt 27, 2013 /
 
Nincs külső kvarc használva, másik dolog, van egy kapcsoló beépítve hogy ha megnyomom akkor az egyik relét leoldja az AVR, és azon a relén keresztül kap áramot. Csak sajnos eddig az AVR nem vette észre ha megnyomtam, de azt hiszem megtaláltam a problémát!
  1. DDRD|=(1<<PB0); // Portb0 input
helyett
  1. DDRB|=(0<<PB0); // Portb0 input


Nem akarom megszakításként kezelni mert jobb ha pár másodpercet várva oldná csak le a relét.

Viszont van egy másik nyomógomb beépítve amivel újra el lehet inditani az AVR-t.

Ahoz hogy 0x25-öt használjak kellene deklarálni egy új karakter változót, és annak megadni érttékként és azt kiirni, másképp számként kezeli ha ki akarom írni.
A hozzászólás módosítva: Okt 27, 2013

main.c
    
(#) killbill válasza Szabi1 hozzászólására (») Okt 27, 2013 /
 
Az itt felmerulo kerdesek nem AVR dolgok, hanem C nyelv alapjai, elso fejezet.
A << operator a baloldalan allo szamot shifteli, igy a 0-t felesleges shiftelni, az eredmeny mindig nulla lesz. Szoval az altalad irt sornak semmi ertelme. Amit te szeretnel az:

  1. DDRB &= ~(1 << PB0);     // bemenet


De ehhez tudni kellene, hogy mit csinalnak az |, |= , &= , ~ es a << operatorok.

Azon felul, ha egy fuggvenynek atadsz egy erteket, az TELJESEN mindegy, hogy milyen formaban irod le: 0x25, '%', '\45', 045 vagy eppen 37; ez mind pontosan ugyanazt fogja jelenteni. Es a meghivott fuggvenynek fogalma sincs rola, hogy ezt az erteket egy konstanskent kapta vagy egy valtozobol. A fuggveny csak az erteket kapja meg. A putc(char c) kiirja a kapott karaktert, soha nem ir szamot. Javaslom, hogy olvass utana a C nyelvnek.
(#) palomatE válasza Fizikus hozzászólására (») Okt 27, 2013 /
 
Köszönöm a részletes leírást, sokat segít!
Minden jót!
(#) fifadani hozzászólása Okt 27, 2013 /
 
Sziasztok!
ADC-vel próbálkozok. Sikerült is megcsinálni az oldalon található infók alapján.
8 bites ADC-t használok, balra rendezve.
ADC mérés eredményét szeretném feszültséggé varázsolni az LCD-mre.
Hogy tudom ezt megoldani?

Köfi
(#) fifadani válasza fifadani hozzászólására (») Okt 27, 2013 /
 
Illetve az LCD-m meghajtója byte-os kijelzésű... 255-nél nagyobb értéknél nullázza a kiírt számot, majd kezdi előlről...
Hmm, hogy kellene megoldani?
A hozzászólás módosítva: Okt 27, 2013
(#) fapuma68 hozzászólása Okt 27, 2013 /
 
Sziasztok!
Ahogy a címben is említettem egy attiny45-öt szeretnék programozni egy AVR Doperrel 3.3v-os környezetben,de nem megy.
A deviceID avrdudenál 0x0ffffff,5V-on simán megy próbapanelon összerakva és a neki épített nyákon is.Kipróbáltam ezzel a programozóval egy másik IC-t atmega48 és atmega88 azok mennek gond nélkül 5 és 3.3 volton is.
Esetleg ötlet hogy mi a gond hogy a t45 miért nem működik 3.3 voltról?
(#) fifadani hozzászólása Okt 27, 2013 /
 
Akarom mondani, hogy byte hosszúságú adatot képes csak megjeleníteni. Pl. 999-et már nem képes megjeleníteni..
Próbálkoztam sokat, de nem sikerül..
(#) zombee válasza fifadani hozzászólására (») Okt 27, 2013 /
 
Az ADC-vel milyen hosszúságú adatot kapsz? Véletlenül nem 10 bitest? Akkor nem bájt,
hanem integer típusú az adat amit ki kell jelezni. Ez megint csak alap C, nem AVR.
(#) fifadani hozzászólása Okt 27, 2013 /
 
Megmutatom...


  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3. #include <avr/interrupt.h>
  4. #include "debugserial.c"
  5. #define F_CPU 16000000UL
  6.  
  7. void m_delay_10ms(unsigned int val)
  8.         {
  9.                 unsigned int i;
  10.  
  11.                 for(i=0;i<val;i++)
  12.                 {
  13.                 _delay_ms(10);
  14.                 }
  15. //hozzá tartozó m_delay_10ms(10) //10*10ms
  16. //Késleltetés bővítés
  17. //a _delay_ms max 65.535 ms-et képes sleepelni,
  18. // tehát nagyobb idozítést többol lehet "összerakni"  
  19.         }
  20.  
  21. void inits(void) //alapvető beállítások
  22. {  
  23.         DDRB  = (1<<PB0); //PB0 ki
  24.         DDRD = (1<<PD0); //PD0 ki
  25.         DDRC &= ~(1<<PC5); //PC5 be
  26.         PORTC = 0b00000000;
  27. }
  28.  
  29. void ADCkonfig8bit()
  30. {
  31.         ADMUX |= (1<<REFS0) | (1<<ADLAR);       // Vcc mint referencia, balra rendezett
  32.     ADCSRA = (1<<ADEN) | (1<<ADPS1) | (1<<ADPS0);      
  33.         // ADC engedelyezese, ADC eloosztas = 128 (125 KHz)
  34. }
  35.  
  36. unsigned char ADCbeolvas8bit(unsigned char csatorna)
  37. {
  38.         ADMUX = (ADMUX & 0b11110000) | csatorna;   // ADC csatorna kivalasztasa
  39.         ADCSRA |= (1<<ADSC);    // ADC konverzio elinditasa
  40.         while (ADCSRA & (1<<ADSC));    // varas az atalakitasra
  41.         ADCSRA |= (1<<ADSC);         // konverzió elindítás
  42.         while (ADCSRA & (1<<ADSC));    // varas az atalakitasra
  43.         return (ADCH);
  44.         // ADC ertek visszaadasa (csak a felso 8 bit (ADCH), az also 2 zajos bit elhagyasa)
  45. }
  46.  
  47. volatile int ADCmeres1;
  48.  
  49. int main()
  50. {
  51.        
  52.         inits();
  53.         ADCkonfig8bit();
  54.  
  55.         while(1)
  56.         {
  57.         ADCmeres1 = ADCbeolvas8bit(5);
  58.         DebugInit();
  59.         DebugClear();
  60.         DebugSendStr("Fesz.:");
  61.         DebugNL();
  62.         DebugSendU8(ADCmeres1);
  63.  
  64.         DebugNL();
  65.     if(ADCmeres1>177)
  66.                 {
  67.                 PORTB &= ~(1<<PB0);
  68.                 }
  69.                 else
  70.                 {
  71.                 PORTB = (1<<PB0);
  72.                 }
  73.        
  74.         m_delay_10ms(10);
  75.         }
  76.  
  77. return 0;
  78. }


Az LCD meghajtónál lévő kódrészlet ami ehhez tartozik:

  1. //-------------------------------------
  2. void DebugSendByte(unsigned char data) {
  3. //-------------------------------------
  4.         DebugSendBit(0);        //startbit
  5.         DebugSendBit(data&1);
  6.         DebugSendBit(data&2);
  7.         DebugSendBit(data&4);
  8.         DebugSendBit(data&8);
  9.         DebugSendBit(data&16);
  10.         DebugSendBit(data&32);
  11.         DebugSendBit(data&64);
  12.         DebugSendBit(data&128);
  13.         DebugSendBit(1);        //stop bit
  14. }
  15.  
  16.  
  17. //-------------------------------------
  18. void DebugSendU8(unsigned char data) {
  19. //-------------------------------------
  20.         DebugSendByte('0'+data/100);data%=100;
  21.         DebugSendByte('0'+data/10);     data%=10;
  22.         DebugSendByte('0'+data);
  23. }
A hozzászólás módosítva: Okt 27, 2013
(#) fifadani hozzászólása Okt 28, 2013 /
 
Sziasztok!
Csináltam egy ilyet:
  1. volatile int ADCmeres1;
  2. float osztas,ADCfesz,aref;
  3.  
  4. int main()
  5. {
  6.         inits();
  7.         ADCkonfig8bit();
  8.         ADCmeres1 = 0;
  9.               ADCfesz = 0;
  10.         aref=4.69;
  11.         osztas=aref/255;
  12.  
  13.         while(1)
  14.         {
  15.         ADCmeres1 = ADCbeolvas8bit(5);
  16.         ADCfesz = ADCmeres1*osztas;
  17.         DebugInit();
  18.         DebugClear();
  19.         DebugSendStr("Feszultseg:");
  20.         DebugNL();
  21.         DebugSendU8_1(ADCfesz*10);
  22.         DebugNL();
  23.     if(ADCmeres1>250)
  24.                 {
  25.                 PORTB &= ~(1<<PB0);
  26.                 }
  27.                 else
  28.                 {
  29.                 PORTB = (1<<PB0);
  30.                 }


Most ott tartok, hogy multival ellenőrzöm a potin lévő feszt.
0,1V-os pontossággal mér.. Vélemény?
Illetve, hogy tudnám összehozni, hogy a század-ot is kiküldje az LCD-re?
(#) Szabi1 válasza killbill hozzászólására (») Okt 28, 2013 /
 
Az jutott eszembe az LCD-vel kapcsolatosan eszembe, hogy én ezt a kapcsolást építettem meg, (pár nyomógomb és relével kiegészítve)Bővebben: Link, de nem találtam az lcd-t kezelő fájlokat, ezért letöltöttem innen: Bővebben: Link
Az lehetséges hogy ahonan letöltöttem, nem oda voltak deklarálva az LCD lábjai?
És alapból ha nem állítok át egy portbitet akkor az alaból bemenet nemde?
A hozzászólás módosítva: Okt 28, 2013
(#) killbill válasza Szabi1 hozzászólására (») Okt 28, 2013 /
 
Minden lehetseges. A portok alapbol bemenetek, igen.
Ha elfogadsz egy jotanacsot, akkor nem az LCD kezelo file-okat kellene letolteni, hanem a C programozas konyvet, az AVR adatlapjat es a kijelzo adatlapjat. Ennek a haromnak a birtokaban magad is meg tudod oldani a feladatot. De, amig nem erted, hogy a DDRD |= (1 << PD2); pontosan mit csinal, addig nem erdemes tovabblepni.
A hozzászólás módosítva: Okt 28, 2013
(#) univerzum hozzászólása Okt 28, 2013 /
 
Üdv! Belekezdtem egy olyan projektbe, hogy mikrokontrollerell hangot kibocsájtani.
Találtam is kezdésnek egy forráskódot. Elősször pic-el akartam, mert az bejáratottabb.
Végül avr nyert.
  1. // musicbox1.c
  2. // for NerdKits with ATtiny26L
  3. // mrobbins@mit.edu
  4.  
  5. // F_CPU defined for delay.c
  6. #define F_CPU 8000000UL // 8MHz
  7.  
  8. #include <avr/io.h>
  9. #include <avr/interrupt.h>
  10. #include <avr/pgmspace.h>
  11. #include <util/delay.h>
  12. #include <inttypes.h>
  13. #include <stdlib.h>
  14.  
  15. #include "delay.h"
  16. #include "lcd.h"
  17.  
  18. // PIN DEFINITIONS:
  19. //
  20. // PA0 -- temperature sensor analog input
  21. // PA1 -- piezo buzzer
  22. // PA4 -- LCD RS (pin 4)
  23. // PA5 -- LCD E (pin 6)
  24. // PA7 -- button (pullup high)
  25. // PB3-6 -- LCD DB4-7 (pins 11-14)
  26.  
  27. void lcd_blank_line() {
  28.   lcd_write_string(PSTR("                        "));
  29. }
  30.  
  31. void lcd_quick_clear_and_home() {
  32.     lcd_home();
  33.     lcd_blank_line();
  34.     lcd_line_two();
  35.     lcd_blank_line();
  36.     lcd_home();
  37. }
  38.  
  39. void play_tone(uint16_t delay, uint8_t duration) {
  40.   // delay is half-period in microseconds
  41.   // duration is in 10ms increments
  42.  
  43.   // example: 440Hz --> delay=1136
  44.  
  45.  
  46.   // duration = 2*delay * cycles (all in same units)
  47.   // cycles = 10000 * duration / delay / 2
  48.   // cycles = 100 * duration / (delay/50)
  49.   uint16_t tmp = 100 * duration;
  50.   uint16_t delaysm = delay / 50;
  51.   uint16_t cycles = tmp / delaysm;
  52.  
  53.   while(cycles > 0) {
  54.     PORTA |= (1<<PA1);
  55.     delay_us(delay);
  56.     PORTA &= ~(1<<PA1);
  57.     delay_us(delay);
  58.     cycles--;
  59.   }
  60. }
  61.  
  62. // define some notes
  63. // converted to half-periods (us) by calculating
  64. //      1000000/2/frequency
  65. // where frequency is in Hz
  66. #define D5 851
  67. #define E5 758
  68. #define Fsh5 675
  69. #define G5 637
  70. #define A5 568
  71. #define B5 506
  72. #define C6 477
  73. #define D6 425
  74. #define DUR 40
  75.  
  76. int main() {
  77.   // internal RC oscillator calibration for 8MHz.
  78.   OSCCAL = 176;
  79.  
  80.   // enable the piezo as output
  81.   DDRA |= (1<<PA1);
  82.  
  83.   // enable internal pullup on PA7 (the button)
  84.   PORTA |= (1<<PA7);
  85.  
  86.   // fire up the LCD
  87.   lcd_init();
  88.   lcd_home();
  89.  
  90.   // loop forever!
  91.   while(1) {
  92.     lcd_quick_clear_and_home();
  93.     lcd_write_string(PSTR("Press to play a song..."));
  94.  
  95.     // wait for button press...
  96.     while(PINA & (1<<PA7)) {
  97.       // do nothing
  98.     }
  99.  
  100.     lcd_quick_clear_and_home();
  101.     lcd_write_string(PSTR("  Happy ")); play_tone(D5, DUR);
  102.     lcd_write_string(PSTR("birth"));    play_tone(E5, DUR);
  103.     lcd_write_string(PSTR("day "));     play_tone(D5, DUR);
  104.     lcd_write_string(PSTR("to "));      play_tone(G5, DUR);
  105.     lcd_write_string(PSTR("you "));     play_tone(Fsh5, 2*DUR);
  106.  
  107.     lcd_line_two();
  108.     lcd_write_string(PSTR("  Happy ")); play_tone(D5, DUR);
  109.     lcd_write_string(PSTR("birth"));    play_tone(E5, DUR);
  110.     lcd_write_string(PSTR("day "));     play_tone(D5, DUR);
  111.     lcd_write_string(PSTR("to "));      play_tone(A5, DUR);
  112.     lcd_write_string(PSTR("you "));     play_tone(G5, 2*DUR);
  113.  
  114.     lcd_quick_clear_and_home();
  115.  
  116.     lcd_write_string(PSTR("Happy "));   play_tone(D5, DUR);
  117.     lcd_write_string(PSTR("birth"));    play_tone(D6, DUR);
  118.     lcd_write_string(PSTR("day "));     play_tone(B5, DUR);
  119.     lcd_write_string(PSTR("dear "));    play_tone(G5, DUR);
  120.     lcd_write_string(PSTR("__"));       play_tone(Fsh5, DUR);
  121.     lcd_write_string(PSTR("__"));       play_tone(E5, DUR);
  122.    
  123.     lcd_line_two();
  124.     lcd_write_string(PSTR(" Happy "));  play_tone(C6, DUR);
  125.     lcd_write_string(PSTR("birth"));    play_tone(B5, DUR);
  126.     lcd_write_string(PSTR("day "));     play_tone(G5, DUR);
  127.     lcd_write_string(PSTR("to "));      play_tone(A5, DUR);
  128.     lcd_write_string(PSTR("you! "));    play_tone(G5, 2*DUR);
  129.  
  130.     // delay a bit
  131.     delay_ms(500);
  132.   }
  133.  
  134.   return 0;
  135. }

Első körben annyit szeretnék megtudni, ha én 3szöget vagy szinuszt szeretnék hallani akkor mit csináljak?
Igen szoftveresen akarok mindent megcsinálni.
(#) univerzum válasza (Felhasználó 15355) hozzászólására (») Okt 28, 2013 /
 
Pont nem pcm lejátszás a célom. PWM okés, csak akkor hogy programozok be PWM jelalakba egy szinuszt?
PCM mintavétel alapú hanggenerátort csinálnék akkor fognék egy eepromot és abba égetném be a hangot. Amúgy nem dallamcsengőt akarok, röviden egy szintetizátort akarok csinálni, csak így még több lehetőségem van, mert véletlen szám generálás-t random frekvencia gnereálást stb is be tudok iktatni...
(#) csabeszq hozzászólása Okt 28, 2013 /
 
Az AVR lábára NA5W-K 5V-os relét kötöttem és meglepődtem, mert nem ment. A fülemhez tartva nagyon halkan kattogott, az interneten utánaolvastam és rájöttem, hogy fordítva kötöttem be. A pólusokat megfordítva védődiódával az IC is simán elkapcsolgatta a relét tranzisztoros áramerősítés nélkül.

A kérdésem az: ha kattog, akkor elektromágneses a relé, de mitől polaritásos? Idáig abban a hiszemben éltem, hogy az elektromágnes nem válogat az irányok között. Mindenesetre az adatlap egyértelműen megjelöli, hogy melyik a [+] és a [-], csak nem értem.
A hozzászólás módosítva: Okt 28, 2013
(#) univerzum válasza csabeszq hozzászólására (») Okt 28, 2013 /
 
Nincs benne dióda? Nem ír rólla az adatlap?
(#) csabeszq válasza univerzum hozzászólására (») Okt 28, 2013 /
 
Nem ír védődiódáról az adatlap, kimérni meg nem tudtam a soros ellenállás miatt.
(#) Szabi1 hozzászólása Okt 29, 2013 /
 
Sziasztok! Ha winavr ben írok egy programot és kompilálom akor ugye létrejön egy .hex file, de a haveremnek kell a program, de neki nincs csak arduino programozója, akkor ő direktbe felteheti a kompilált fájlt vagy újra kell forditani a forráskódot?
(#) gtk válasza Szabi1 hozzászólására (») Okt 29, 2013 / 1
 
A havered felteheti a hex filet, ha nem akarja modositani a programot.
(#) lajos1969 hozzászólása Okt 29, 2013 /
 
Sziasztok!
Lenne egy olyan problémám, hogy a CodeVisionAvr-t használom Atmega programozáshoz Pickit2-vel. Eddig gond nélkül működött de most olyat csinál, hogy felismeri az controllert ki is olvassa, de ha törölni akarom akkor hibát ír ki meg ha programozni akarom akkor is. Valaki találkozott már ilyen jelenséggel? Valami a géppel vagy a beállításokkal lehet mert ugyanazt az avr-t a haveromnál ugyan ilyen módszerrel gond nélkül beprogramoztuk.
Előre is köszönöm a tanácsokat!!
(#) Robi98 hozzászólása Okt 30, 2013 /
 
Üdv!
Ép az előbb azzal kínlódtam, hogy miként tudnék szoftveres PWM-et létrehozni. Ez éppen sikerült is, de az a kódrészlet nem akar sikerülni:
  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3. #include <avr/interrupt.h>
  4.  
  5. unsigned int ertek=0; // ez lesz a PWM értéke
  6.  
  7. ISR(TIMER2_OVF_vect)// ez a megszakítás akkor jön létre amikor a timer eléri a csúcsot
  8. {
  9. PORTB|=1<<PB0;//
  10. }
  11. //++++++++++++++++++++++++++
  12. int komparator(void)
  13. {
  14. if(TCNT2>=ertek)
  15.            {
  16.            PORTB&=~1<<PB0;
  17.            }
  18. }
  19.  
  20. //+++++++++++++++++++++++++
  21.  
  22. int main(void)
  23. {
  24. DDRB|=1<<PB0; // PB0 kimenet ide jön a LED
  25. TCCR2|=1<<CS21;// 8 bites timer elindítása 8-as előosztás
  26. TIMSK|=1<<TOIE2; // amikor a timer eléri a csúcsot, egy megszakítást generál
  27. sei();// interrupt engedélyezése
  28.  
  29.     while(1)
  30.         {  
  31.         komparator();
  32.          ertek=ertek+125;
  33.          komparator();
  34.          _delay_ms(1000);
  35.          ertek=ertek+125;
  36.          komparator();
  37.          _delay_ms(1000);
  38.          
  39.          ertek=ertek-125;
  40.          komparator();
  41.          _delay_ms(1000);
  42.          ertek=ertek-125;
  43.          komparator();
  44.          _delay_ms(1000);
  45.         }
  46. }

Ennek az lenne a lényege, hogy a led fényerejét a felére, majd fullra, aztán megint a felére, és végül nullára emelje.
(#) Szabi1 válasza Robi98 hozzászólására (») Okt 30, 2013 /
 
Igy kell:
  1. #include <avr/io.h>
  2.     #include <util/delay.h>
  3.     #include <avr/interrupt.h>
  4.      
  5.     unsigned int ertek=0; // ez lesz a PWM értéke
  6.      
  7.     ISR(TIMER2_OVF_vect)// ez a megszakítás akkor jön létre amikor a timer eléri a csúcsot
  8.     {
  9.     PORTB|=1<<PB0;//
  10.     }
  11.     //++++++++++++++++++++++++++
  12.     void komparator(void)
  13.     {
  14.     if(TCNT2>=ertek)
  15.                {
  16.                PORTB&=~1<<PB0;
  17.                }
  18.     }
  19.      
  20.     //+++++++++++++++++++++++++
  21.      
  22.          
  23.          
  24.          
  25.     int main(void)
  26.     {
  27.     DDRB|=1<<PB0; // PB0 kimenet ide jön a LED
  28.     TCCR2|=1<<CS21;// 8 bites timer elindítása 8-as eloosztás
  29.     TIMSK|=1<<TOIE2; // amikor a timer eléri a csúcsot, egy megszakítást generál
  30.     sei();// interrupt engedélyezése
  31.      
  32.         while(1)
  33.             {
  34.             komparator();
  35.              ertek=ertek+125;
  36.              komparator();
  37.              _delay_ms(1000);
  38.              ertek=ertek+125;
  39.              komparator();
  40.              _delay_ms(1000);
  41.            
  42.              ertek=ertek-125;
  43.              komparator();
  44.              _delay_ms(1000);
  45.              ertek=ertek-125;
  46.              komparator();
  47.              _delay_ms(1000);
  48.         }
  49.                 return 0;
  50.         }

Tehát az int fuggvénynek kell legyen egy viszatérési értéke ha rendben lefut;
  1. int fuggveny1()
  2. {
  3.     //kod;
  4.    return 0;
  5.  
  6. }

Ekkor le lehet kérdezni egy változó segítségével a függvény lefutási állapotát:
  1. int uj;
  2. uj=fuggveny1();
  3. if (uj==0)// a fuggveny lefutott;

Amugy a kód helyességét nem néztem meg....
A hozzászólás módosítva: Okt 30, 2013
(#) zombee válasza Robi98 hozzászólására (») Okt 30, 2013 /
 
mivaaaaaan?
Így nem lesz semmilyen PWM-ed...
A hozzászólás módosítva: Okt 30, 2013
(#) csabeszq válasza Robi98 hozzászólására (») Okt 30, 2013 /
 
Kicsit bonyolultul oldottad meg.

  1. for(i=0; i<200; i++) // 0-100 novekszik, 100-200 csokken
  2.   {
  3.      uint16_t on_delay = (i > 100) ? 200 - i : i;
  4.      PORTB |= (1<<PB0); // LED be
  5.      _delay_ms(on_delay);
  6.      PORTB &= ~(1<<PB0); // LED ki
  7.      _delay_ms(100-on_delay);
  8.   }


A delay hosszát változtatod a for ciklusban. Sem timer, sem interrupt, sem semmi nem kell hozzá.
A hozzászólás módosítva: Okt 30, 2013
(#) lajos1969 hozzászólása Okt 30, 2013 /
 
Bocs, hogy közbeszólok de nekem tudnátok valami tanácsot adni???
Köszönöm.
(#) killbill válasza Szabi1 hozzászólására (») Okt 30, 2013 /
 
Hamar megtanultad! Tegnap még kerdeztel, ma mar tanitod. Csak ne beszelj butasagokat!Minden fuggvenynek, ami nem void, kell legyen visszateresi erteke. De mindig, nem csak akkor ha 'rendben lefut'. Kulonben is, mi az, hogy rendben?
Azon felul teljesen felesleges valtozo ahhoz, hogy egy fuggveny visszateresi erteket vizsgald. A C nyelvben ez ennel sokkal altalanosabb. Minden kifejezesnek van erteke. Egy kifejezes lehet egy valtozo, egy konstans, tetszoleges muvelet, vagy akar fuggveny, vagy ezekbol osszerakott kifejezes. Tehat egesz nyugodtan irhatod azt is, hogy if(fuggveny() == 0) de ezzel megegyezo az if(! fuggveny()). Azt is leirhatod, hogy a = fuggveny() + 2; es ennek az egesznek is van erteke, tehat az is elfogadott, hogy:

int a;

switch(a = fuggveny() * 2){
case 8:
...
}
Következő: »»   571 / 840
Bejelentkezés

Belépés

Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem