OK Mégsem
Fórum témák

» Több friss téma
Fórum » AVR - Miértek hogyanok
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   570 / 840
(#) Massawa válasza blackdog hozzászólására (») Okt 21, 2013 /
 
Nézd meg pl. a DCC szabványt, ott 16-24V-t kapcsolnak, méghozzá ugy, hogy a kod energiája minden pillanatban elegendö a fogyaszto áramellátására is.
De sok ilyen van pl. a telefontechnikában is. Az informáciot a 0 átmenet hordozza maga kod meg az áramellátást végzi.
(#) matheattila válasza fifadani hozzászólására (») Okt 21, 2013 /
 
Szivesen! Timer 0-át is használhatod, csak akkor kicsit más lesz a dolog, mert a megszakítást kisebb intervallumokban tudod megoldani. Pl minden 10ms-ben generálódik csak megszakítás és egy változót minden ciklusban növelsz és mikor eléri a 100-at akkor változik a 'sec' változó egyet...
Kicsit utána kell számolni a dolgoknak és akkor meglátod, hogy neked melyik a legmegfelelőbb
(#) zombee válasza blackdog hozzászólására (») Okt 21, 2013 /
 
Pl. azért kell protokoll, mert a -legtöbb- rendszer nem "csak úgy" kapja meg a digitális jelsorozatot. Ha mégis "csak" egy sorozatot adnál ki, tudom ajánlani az SPI egységet. Látom szkópod is van, így hamar meg fogod látni hogy miért nem jó, és miért is kell a protokollt ismerni.
(#) fifadani válasza matheattila hozzászólására (») Okt 21, 2013 /
 
Szia!
Most próbálom átlátni azt, hogyha timer0-val csinálom meg, akkor mivan.
16bit-es timer-el okés a dolog. 16Mhz/1024-1=15624. Mivel a timer1 65535-ig számol, a 15624 simán belefér. Ha ezt az értéket eléri, jön a megszakítás.
Ha timer0-át akarom használni akkor, hogy kell osztanom a cpu frekijét, hogy 254-nél legyen a megszakítás?

Köszi!
A hozzászólás módosítva: Okt 21, 2013
(#) matheattila válasza fifadani hozzászólására (») Okt 21, 2013 /
 
Mint már korábban is írtam, Timer 0-ával is meg lehet oldani, de ott csak overflow (tulcsordulás) megszakítást generál (azaz mikor eléri a 255-öt és vált 0-ra), nem tudsz te megadni egy értéket, hogy addig számoljon majd generáljon megszakítást. Ennek az a hátránya, hogy nem tudsz pontos időzítéseket létrehozni, vagyis 16000000/1024/256 = 61.035... ez azt jelenti, hogy egy másodperc alatt 61-szer fog túlcsordulni, minden túlcsordulásnál növelsz egy változót és mikor eléri a 61-et akkor növeled a másodperc változódat!
Mivel az osztás eredménye nem egész szám lett ezért minden 28.44-ik másodpercben lesz egy 62-ik túlcsordulás is, de mivel te 61-nél már növeled a másodperceket és nullázod ezt a változót, ezzel gyakorlatilag hamarabb váltasz mint ahogy kellene, ezért ezek a kis hibák lassan mind összegyűlnek és kb minden 29-ik percben sietni fog 1 másodpercet
Ezért azt javaslom, hogy inkább használd a Timer1-et ha van rá lehetőséged, mert ott nagyon pontos megszakításokat tudsz beállítani.
Egy másik megoldás a Timer2 Aszinkrón üzemmódban, de ehhez kell egy 32768Hz-es óra kvarc de mivel a mega8 csak egyetlen külső kvarcot tud kezelni, ezért a 16MHz-es helyett kell betedd, így akkor a proci órajelét a belső RC oszcillátorról kell meghajtani, ami szintén nem pontos, viszon a timer2 nagyon pontos 1 másodperces megszakításokat tud ezzel generálni overflow üzemmódban, 128-as előosztóval
Remélem, hogy ezek közül egyikkel csak meg tudod oldani
(#) Fizikus válasza matheattila hozzászólására (») Okt 22, 2013 /
 
Timer0-val is megoldhato a pontos idozites, csak trukkozni kell.
Pl: (16MHz-es kvarcot feltetelezve)
a) 1-es timer eloosztas eseten masodpercenkent 16.000.000/256=62500-szor csordul tul. A megszakitason belul novelsz egy szamlalot, ha eleri a 62500-at, akkor nullazod a szamlalot es noveled a masodperc erteket 1-el. (nem tudom hogy mit kell meg csinalnia az AVR-nek, de ebben az esetben ele sokat foglalkozik a megszakitassal)
b) 8-as timer eloosztas eseten masodpercenkent 16.000.000/(8*256)=7812.5-szer csordul tul, ezert kell trukkozni. A megszakitas kiszolgalo rutinba kell azt megoldani hogy a szamlalo eloszor ha eleri a 7812-et akkor novelje a masodperc erteket 1-el, ezutan a nullazas utan masodjara meg csak akkor novelje a masodpercet, ha a szamlalo eleri a 7813-at. Igy az elso masodperc 1/15625-od masodperccel rovidebb, a masodik pedig ugyanennyivel hosszabb lesz, ezaltal a hibak kiegyenlitik egymast...
A hozzászólás módosítva: Okt 22, 2013
(#) palomatE hozzászólása Okt 22, 2013 /
 
Sziasztok!
Adott egy atmega128, és hozzá egy PCF8563 RTC chip (SCL és SDA lábak). Hogyan tudok program szinten kommunikálni a chippel (írni olvasni az időt-dátumot)?
Köszönöm!
(#) Fizikus válasza palomatE hozzászólására (») Okt 22, 2013 /
 
Ezek alapjan mar meg tudod erteni a lenyeget es at tudod irni a kodot...
Arduino + PCF8563
Hack A Day
(#) benjami válasza fifadani hozzászólására (») Okt 22, 2013 /
 
Timer0 - val, komparátor nélkül is lehet pontos időt létrehozni. Az alábbi példa pont 1Hz-el villogtat két ledet:
  1. // Atmega8 timer0 időzítővel pontos óra
  2. // led lábak definiálása
  3. #define  LED1ON     PORTB |=  (1 << 2)
  4. #define  LED2ON     PORTB |=  (1 << 3)
  5. #define  LED1OFF    PORTB &= ~(1 << 2)
  6. #define  LED2OFF    PORTB &= ~(1 << 3)
  7. #define  LED1IO     DDRB |=  (1 << 2)
  8. #define  LED2IO     DDRB |=  (1 << 3)
  9. #define  LED1       (PORTB & (1 << 2))
  10. #define  LED2       (PORTB & (1 << 3))
  11.  
  12. // órajel forrás frekvencia
  13. #define  TimerSrcClock (16000000UL)
  14.  
  15. // 1000 megszakítás/sec
  16. #define  TIMECLK    1000
  17.  
  18. #include <avr/io.h>
  19. #include <avr/interrupt.h>
  20. #include <string.h>
  21. #include <stdlib.h>
  22.  
  23. // reset óta eltelt idő másodpercben
  24. volatile unsigned long masodperc = 0;
  25.  
  26. //******************************************************************************
  27. void init(void)
  28. {
  29.   // időzítő inicializálása
  30.   #define  TIMEDIV ((TimerSrcClock+TIMECLK/2)/TIMECLK-1)
  31.   #if TIMEDIV < 256
  32.   #define TMCLKDIV         1
  33.   #define TMCLKSEL         1
  34.   #elif TIMEDIV < (256*8)
  35.   #define TMCLKDIV         8
  36.   #define TMCLKSEL         2
  37.   #elif TIMEDIV < (256*64)
  38.   #define TMCLKDIV        64
  39.   #define TMCLKSEL         3
  40.   #elif TIMEDIV < (256*256)
  41.   #define TMCLKDIV       256
  42.   #define TMCLKSEL         4
  43.   #elif TIMEDIV < (256*1024)
  44.   #define TMCLKDIV      1024
  45.   #define TMCLKSEL         5
  46.   #endif // TIMEDIV
  47.   #define TMCOMP (((TimerSrcClock/TMCLKDIV)+TIMECLK/2)/TIMECLK-1)
  48.  
  49.   TCNT0 = 255 - TMCOMP;
  50.   TCCR0 = TMCLKSEL<<CS00;  // előosztó
  51.   TIMSK |= (1<<TOIE0);
  52.   sei();
  53.  
  54.   // ledek beállítása
  55.   LED1OFF; LED2OFF; LED1IO; LED2IO;
  56. }
  57.  
  58. int main(void)
  59. {
  60.   unsigned long lastsec = 0xFFFFFFFF;
  61.  
  62.   init();
  63.   while(1)
  64.   {
  65.     if(lastsec != masodperc)
  66.     {
  67.       // 2 led másodpercenkéánt felváltva villogjon
  68.       if(LED1)
  69.         {LED1OFF; LED2ON;}
  70.       else
  71.         {LED1ON; LED2OFF;}
  72.       lastsec = masodperc;
  73.     }
  74.   }
  75. }
  76.  
  77. //******************************************************************************
  78. // AVR megszakítás kiszolgálás
  79. ISR (TIMER0_OVF_vect)
  80. {
  81.   static unsigned int msec = 0;
  82.   TCNT0 += (255 - TMCOMP);
  83.   msec++;
  84.   if(msec == 1000)
  85.   {
  86.     masodperc++;
  87.     msec = 0;
  88.   }
  89. }
(#) zombee válasza benjami hozzászólására (») Okt 22, 2013 /
 
Bocs, de valamit nem értek a kódodban. Miért birizgálod a TCNT0 regisztert abban az
interruptban, amit pont a TCNT0 állapotváltozása(túlcsordulás) váltott ki?
A CTC módot szoftveresen csinálod? Miért? A CTC a legtöbb AVR-ben hardveresen elérhető.
Ehhez csak ennyit kell csinálni:
- komparátor: OCR0(A) regiszter beállítása, mint nálad a "TCOMP"
- TCCR0(A/B) regiszterekben CTC módot adsz meg
- TIMSK regiszterben a TCIE0(A) flaget állítod be
- ISR hívásnál "TIMER0 capture (A)" nevet használsz
(#) benjami válasza zombee hozzászólására (») Okt 22, 2013 /
 
Oké, de ezt próbáld meg Atmega8-on is megcsinálni. Annak elég buta a timer0-ja (nincs benne komparátor), és pont ez volt a kérdés. Komparátorral könnyű.
(#) zombee válasza benjami hozzászólására (») Okt 23, 2013 /
 
Ok, értem, akkor csak demonstráció volt. Amire azért nagyon ügyelni kell(ene), nehogy meglepetések érjenek: ha az interruptban állítod a TCNT0-t, akkor nem szabad hogy közben lépjen a számláló. Gondolom érzed hogy az 1-es és 8-as előosztó esetéről beszélek. Utóbbi ráadásul bosszantóbb hibákat generál, mert kiszámíthatatlan, mikor lesz jó és mikor nem.
Ha az 1-es timer foglalt, ott a 2-es, igaz hogy ez is 8 bites, de tud CTC módot és ez jó.
A hozzászólás módosítva: Okt 23, 2013
(#) zolek hozzászólása Okt 23, 2013 /
 
Sziasztok! Valaki megnézné hogy jól csináltam-e? Itt a c fájl, nekem a hex 3kb.
MaSTeRFoXX Hanglejátszós ajtócsengő szeretném meg építeni.
A hozzászólás módosítva: Okt 23, 2013

1 main.c
Makefile.rtf		   
(#) zolek hozzászólása Okt 23, 2013 /
 
Hanglejátszós ajtócsengő

Makefile.rtf		    
(#) GPeti1977 hozzászólása Okt 23, 2013 /
 
Az AVR Studio4 -en nem jelenik meg a programozó kiválasztó menüsor, a Jumbo is telepítve van, de nem tudom miért.

hianyzik.JPG		    
(#) zombee válasza GPeti1977 hozzászólására (») Okt 23, 2013 /
 
Ha pedig így se jelenik meg (pl. jobbegérnél az "STK500" nincs a listában), akkor Tools menü,
és majdnem legalul Program AVR. Újratelepítés végleg megoldja ezt is. Volt már ilyenem...
(#) fifadani hozzászólása Okt 23, 2013 /
 
Sziasztok!
Újabb problémám lenne.
Van 4 db 7 szegmenses kijelzőm. Órát szeretnék majd belőlük.
Korábban beszéltük, hogy a timer1 megszakításában növelgetem a változók értékét stbstb.
Van egy sn7447-es IC-m amivel vezérlem a kijelzőket.
Itt a bibi, hogy csinálom meg azt hogy a perc két helyiértékét, majd az óra két helyiértékét küldjem külön külön BCD-ben a 7447-nek?
(kapcsoló tranzisztorok kapcsolgatják a kijelzőket)

  1. volatile unsigned char sec,min,hour; //globális változók
  2.  
  3. void inits(void) //alapvető beállítások
  4. {
  5.    DDRB = (1<<PB0); //PB0 kimenet
  6.    DDRD = (1<<PD1) | (1<<PD7) | (1<<PD6) | (1<PD5); //PD1 kimenet, LCD-hez TXD, LCD-n RXD
  7.    DDRC = (1<<PC2) | (1<<PC3) | (1<<PC4) | (1<<PC5);
  8.  
  9.  
  10.    OCR1A   = 15624;  //  F_CPU/előosztó/1sec - 1;  16000000/1024/1 - 1
  11.    TCNT1 = 0;
  12.    TCCR1B |= (1 << WGM12);              // Mód 4, CTC -> OCR1A
  13.    TIMSK  |= (1 << OCIE1A);             // Interrupt ha komparátor 1
  14.    TCCR1B |= (1 << CS12) | (1 << CS10); // Előosztó 1024 , timer indítás
  15.    sei();
  16. }
  17.  
  18. ISR (TIMER1_COMPA_vect) //megszakítás rutin, timer1
  19. {
  20.  if(sec >= 60)
  21.  {
  22.  sec = 0;
  23.  min++;
  24.  }
  25.  if(min >= 60)
  26.  {
  27.  min = 0;
  28.  hour++;
  29.  }
  30.  if(hour >= 24)
  31.  {
  32.  hour = 0;
  33.  }
  34.  
  35.  
  36. }
  37.  
  38. int main ()
  39. {
  40.  
  41.   inits();
  42.        
  43.   while(1)
  44.    {
  45.  
  46.    }
  47.  
  48. return 0;
  49. }


Köszi szépen!
(#) matheattila válasza fifadani hozzászólására (») Okt 23, 2013 /
 
Ezt multiplexeléssel tudod megoldani, ami azt jelenti, hogy egy időpillanatban csak egyetlen kijelző aktív (egyszerre csak egy szám látszik a 4-ből), tiltod az összes kijelzőt, kiküldöd az első számjegy adatait a BCD sínre (mivel minden kijelző a,b,...g és dp kivezetéseit párhuzamosan kell kötni) majd engedélyezed az elsőt, vársz, majd megint tiltod az őket, kiküldöd a második számjegyet, aktíválod a második számjegyet és így tovább...
Hogy ez a folyamatos kapcsolgatás ne zavarja az emberi szemet, legalább 24-szer kellene ezt végig játszodd egy másodperc alatt, de biztos ami biztos alapon a legjobb ha 1kHz-en kapcsolgatod őket, így mindegyik csak 1ms-ot aktív és 3ms-ot inaktív, ami 250Hz-es villogást eredményez de ezt már az emberi szem nem képes észlelni és egy folyamatos számsornak látja az órádat
Elsőre kicsit bonyolultnak tűnhet, de ezzel a módszerrel nagyon sok kivezetést meg lehet spórolni egynél több kijelző esetén
Az hogy egy számot hogy osztol vel számjegyeire az egyszerű, mert az első számjegyre az szám/10-el tudsz hivatkozni míg a másodikra szám%10-el (hour/10, hour%10, min/10 és min%10 -et kell felváltva kiküldözgeteni a megfelelő pillanatban).
A legjobb megoldás ha a multiplexeléshez szükséges időintervallumokat is megszakítással hozod létre, ha nem szeretnéd azzal akkor egyszerű 1ms-os delay-eket teszel be egy végtelen ciklusba, csak ekkor nem nagyon tudsz az idő alatt egyébbel foglalkozni, mert a proci mindig a várakozással lesz elfoglalva
(#) fifadani válasza matheattila hozzászólására (») Okt 23, 2013 /
 
Tanulásnak bőven elég ez is..
Köszi szépen!
(#) fifadani válasza matheattila hozzászólására (») Okt 23, 2013 /
 
Megcsináltam.
Műkszik a dolog, de valami nem okés.
  1. while(1)
  2.    {
  3.    PORTD = 0b00000000;
  4.    PORTB = 0b00000000;
  5.    min1=min/10;
  6.    min2=min%10;
  7.    hour1=hour/10;
  8.    hour2=hour%10;
  9.    PORTB = 0b00000001;
  10.    PORTC = (min2<<PC2);
  11.    _delay_ms(5);
  12.    PORTD = 0b10000000;
  13.    PORTC = (min1<<PC2);
  14.    _delay_ms(5);
  15.    PORTD = 0b01000000;
  16.    PORTC = (hour2<<PC2);
  17.    _delay_ms(5);
  18.    PORTD = 0b00100000;
  19.    PORTC = (hour1<<PC2);
  20.    _delay_ms(5);
  21.    }

Az a baj vele, hogy az utolsó szám, azaz a hour 1 értéke átcsúszik a min1-re..
(#) matheattila válasza fifadani hozzászólására (») Okt 23, 2013 /
 
A programod alapján a PB0, PD7, PD6, és PD5 a négy kijelző közös anódja, és a PC5, PC4, PC3 és PC2 a 7447-es D,C,B és A bemenetei. Ha igen akkor a gond az, hogy neked csak minden ciklus után nullázza az összes kijelzőt, és mivel az egyik kijelző (a min2) a B porton van és a többi a D-n és nem kapcsolod ki MINDEGYIKET akkor ha jobban megnézed láthatod, hogy a PB0 mindvégig 1 marad, azaz minden utána következő számot ábrázolni fog az is.
A delay-t is csökkentheted 1ms-re (gyorsabb a multiplexelés és nem zavarja a szemet, a mostani programod 50Hz-en villog.
A másik észrevétel az a min1,min2... változók használata, szerintem fölösleges, elég lehhe ott helyben behelyettesíteni. Tudom, van még hely bőven a memóriában, csak jó hogy ha úgy szokod meg már az elejétől, hogy a lehető legkevesebb memóriát próbálod felhasználni, ennek akkor veszed majd hasznát ha nagyobb programokat kell majd írj, mert lehet, hogy ott minden byte-ra szükséged lesz majd
Jobban átláthatóbb lenne a program ha használnál makrókat is, ez jelen esetben majdnem lényegtelen, de később (hónapok múlva) megint előveszed, hogy egy másik programnál felhasználd akkor majd pillanatok alatt látni fogod, hogy hogyan is működik, mi van abban a programban és könnyebben tudod majd felhasználni abban a projektben

pl így:
  1. ...
  2. #define H1_ON()  PORTD |= (1<<PD5)
  3. #define H1_OFF() PORTD &= ~(1<<PD5)
  4. #define H2_ON()  PORTD |= (1<<PD6)
  5. #define H2_OFF() PORTD &= ~(1<<PD6)
  6. #define M1_ON()  PORTD |= (1<<PD7)
  7. #define M1_OFF() PORTD &= ~(1<<PD7)
  8. #define M2_ON()  PORTB |= (1<<PB0)
  9. #define M2_OFF() PORTB &= ~(1<<PB0)
  10.  
  11. ISR(...)
  12. {
  13.     ...
  14. }
  15.  
  16. H1_OFF();
  17. H2_OFF();
  18. M1_OFF();
  19. M2_OFF();
  20. PORTC = 0x00;
  21.  
  22.     while(1)
  23.     {
  24.        M2_OFF();
  25.        PORTC = ((hour/10)<<PC2);
  26.        H1_ON();
  27.  
  28.        _delay_ms(1);
  29.  
  30.        H1_OFF();
  31.        PORTC = ((hour%10)<<PC2);
  32.        H2_ON();
  33.  
  34.        _delay_ms(1);
  35.  
  36.        H2_OFF();
  37.        PORTC = ((min/10)<<PC2);
  38.        M1_ON();
  39.  
  40.        _delay_ms(1);
  41.  
  42.        M1_OFF();
  43.        PORTC = ((min%10)<<PC2);
  44.        M2_ON();
  45.  
  46.        _delay_ms(1);
  47.     }
(#) csabeszq hozzászólása Okt 24, 2013 /
 
AVR-es C-s exception implementációt keresnék, ha valaki tud ilyet. Technikailag nem nehéz, mert lementjük a registereket, exception-nél meg átállítjuk a stack-et és visszatöltjük a regisztereket.

Nagyon gyors méréshez kellene, ahol nem szeretném megvárni az interrupt >20 órajeles késleltetését (interrupt meghívása, regiszterek mentése, reti,...). A program végtelen ciklusban várakozna az analóg komparátor interrupt jelzővezetékén. Amikor timeout van, akkor interruptból dobnék egy exception-t, ami kiugrana a végtelen ciklusos mérésből.

A kérdés, hogy valaki írt-e már C-s exception-handlert?
A hozzászólás módosítva: Okt 24, 2013
(#) matheattila válasza csabeszq hozzászólására (») Okt 24, 2013 /
 
Hát a hozzászólásodban több helyen is ellentmondás van:
exception:
Idézet:
„...lementjük a registereket, exception-nél meg átállítjuk a stack-et és visszatöltjük a regisztereket.”

interrupt:
Idézet:
„interrupt meghívása, regiszterek mentése, reti,...”

ez a kettő egy és ugyanaz de te nem szeretnéd
Idézet:
„megvárni az interrupt >20 órajeles késleltetését”
.
A másik
Idézet:
„Amikor timeout van, akkor interruptból dobnék egy exception-t, ami kiugrana a végtelen ciklusos mérésből”
és itt is az interruptot használod fel az exceptionhoz, akkor hogy is van pontosan? Nem tetszik a megszakítás mert sokat kell várni, viszont az exceptionnal pont azt használod!

Szerintem kicsit gondold át a dolgot, mert itt valami nincs rendben, amúgy meg nem tudom mi lehet olyan gyors hogy egy 16MHz-es órajelen járó proci ne tudná lekezelni ezt megszaktításból...
(#) zombee válasza matheattila hozzászólására (») Okt 24, 2013 /
 
Szerintem félreérted azt, hogy mit szeretne. Mivel voltam már hasonló helyzetben, nagyjából
sejtem mit szeretne. Szeretne egy pontos időmérést a komparátorral, gondolom 1us vagy
még pontosabb felbontásban. Ha ezalatt figyeli a timert is, az a pontosság rovására megy.
Ezért kell egy "kiugrás", ha a dolog túl sokáig várakozik.

Legegyszerűbb megoldás:
Nem kell semmilyen try/catch szerkezet, az analóg komparátor és a Timer1 között lóg egy
"input capture" nevű szerkezet. Csak be kell állítani a timert, és ha vált a komparátor,
csak ki kell olvasni az ICR1 regiszterből az értéket.

Hardveres megoldás:
Az AVR 0-s vagy 2-es timerének segítségével előállítasz egy F_CPU/2 órajelet. Az órajel egy
külső logikai áramkörre megy(néhány kapuból megépíthető), ami csak egyszer engedi
a komparátort váltani. Ja igen: a komparátor is külső kell hogy legyen, pl. LM393.
Ha vált a komparátor, a logikai rész tiltja az órajelet(ami a T1 lábra megy be az AVR-en).
És csak a TCNT1-et kell kiolvasni. A TCNT1-re beállíthatsz egy felső határt, és akkor interrupt
is megszakíthatja a számlálást(ha akarod). Amikor indítod a számlálást, csak egy regisztert
kell beállítani a timer0 vagy 2-n (fast PWM mód vagy hasonló) és a TCNT1-t lenullázni.
Bonyolultnak hangzik, de ez adja a lehető legpontosabb mérést.

Amit te szeretnél (try/catch blokk) arra nem tudok pontos választ adni. Mindenesetre próbáld
a lehető legegyszerűbben megoldani, ez nem JAVA meg C#, itt mindent neked kell lekódolni.
A hozzászólás módosítva: Okt 24, 2013
(#) csabeszq válasza zombee hozzászólására (») Okt 24, 2013 /
 
Végülis sikerült összebarkácsolnom az exception-kezelést és a kód is tök egyszerű lett, a lefordított méret sem tragikus. Ez kiugrik mindenhonnan és az interrupt flag-et is helyrerakja (csatolva).

Szépen végigugrált az exception-ökön a következő teszt kódon:
  1. void meth2()
  2. {
  3.   TRY(
  4.     THROW(4);
  5.   );
  6.   CATCH(4,
  7.     THROW(3);
  8.   )
  9. }
  10.  
  11. void meth1()
  12. {
  13.   meth2();
  14. }
  15.  
  16. int main()
  17. {
  18.   TRY(
  19.     meth1();
  20.   );
  21.   CATCH(3,
  22.     PORTD = 0;
  23.   );
  24. }
A hozzászólás módosítva: Okt 24, 2013

AVRException.zip		    
(#) zombee válasza csabeszq hozzászólására (») Okt 24, 2013 /
 
éééérdekes!
(#) gacserus hozzászólása Okt 26, 2013 /
 
Sziasztok,

SoftPWM-et próbálok megvalósítani. A jel meg is jelenik rendben. A kitöltési tényezőt egy változóval szeretném vezérelni (threshold). A változtatást pedig egy külső interrupt (INT0) kezdeményezi. Az interrupt rutin lefut de a threshold nem változik meg. Betettem az ISR rutinba ellenőrzésként egy LEDet felkapcsoló utasítást. Az is csak egy pillanatra változik meg majd kikapcsolt állapotba visszakerül.
MIÉRT?
gacserus

PWMTest.c		    
(#) Szabi1 hozzászólása Okt 26, 2013 /
 
Sziasztok!
Most programoztam egy ATMEGA 8 at de sajnos az LCD re nem ír ki semmit, ha a kontrasztot állítom akkor az első sor sárga lesz azután a második is.

lcd.c
lcd.h
main.c		  
(#) palomatE válasza Fizikus hozzászólására (») Okt 26, 2013 /
 
Köszönöm a linkeket, azonban az alapvető problémám az I2C (vagyis TWI) interface használata az Atmega128 chipen. Gondolom van már készen erre a feladatra függvénykészlet (feltételezem az első példában a Wire.h header tartalmazza ezeket), amelyeket tanulmányozhatnék, de eddig sajnos nem találtam megfelelő változatot.
A hozzászólás módosítva: Okt 26, 2013
(#) benjami válasza Szabi1 hozzászólására (») Okt 26, 2013 /
 
Az lcd_init és az lcd_clrscr hívását tedd a while(1) elé. Ha állandóan inicializálod és törlöd a kijelzőt nem csoda ha nem megy.
Ezekre szükség lehet! - HESTORE.HU

ATMEGA128-16AU
ATMEGA8-16AU
LED21-MR16-WH
PCF8563T SMD
SN7447AN
Következő: »»   570 / 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