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   758 / 840
(#) uedit hozzászólása Jan 15, 2017 /
 
Szia mindenkinek!
Eléggé kezdő vagyok. Kérdésem: az *.ASM file-ből hogy lehet HEX filé-t készíteni az AtmelStudió, vagy a CodeVision programban. Köszönöm!
(#) ThompsoN hozzászólása Jan 15, 2017 /
 
Sziasztok!

ATMega48PA-PU-val szeretnék egy akkumulátoros fúrógépből kiszerelt motort (12V-os) vezérelni. Ehhez egy IRLZ34N MOSFET-et használnék. A probléma az, hogy ha a PWM kitöltési tényezője kevesebb, mint 100%, akkor a motor megmozdul, de nem pörög föl.

  1. TCCR0A = (1 << COM0A1) | (1 << COM0B1) | (1 << WGM00);
  2. TCCR0B = (1 << CS01) | (1 << CS00);

Ha minden igaz, akkor így fázishelyes módban, 64-es előosztással megy az időzítő. A CPU 8MHz. A MOSFET-hez csatlakozó láb kimenet. Ha a kitöltés 100% (vagy sima I/O lábként próbálom, PWM nélkül), akkor gond nélkül megy a motor, a MOSFET nem melegszik egyáltalán.

A kapcsolás valahogy így néz ki. Lehet, hogy a 270 Ohmos ellenállás túl nagy, és ezért a MOSFET nem kapcsol be elég gyorsan?
A hozzászólás módosítva: Jan 15, 2017

DSC_0222.JPG		    
(#) Robi98 hozzászólása Jan 15, 2017 /
 
Sziasztok!

Építettem egy 7X8 RGB led mátrixot egy ATmega8-al és terveztem rá egy animációt.
Videó : ITT.
A probléma az, hogy az első piros sor(a kódban red[0]) értéke végig nulla marad. Pedig annak is fel kéne töltödnie 1-255-ig.

Akárhogy törtem a fejem nem találtam meg a hibát. A legmegdöbbentőbb az, hogy ha csak az animáció felét(mármint csak a feltöltődés efektust) rakom a végtelen ciklusba, akkor működik az első sor is.
A multiplexezés a 8 bites Timer2 interruptjában fut, azzal nincs gond, tökéletesen működik. Valahol a végtelen ciklusban lehet a hiba.
  1. while(1)
  2.         {
  3.  
  4.                         unsigned char s=1;
  5.  
  6.                         while(s)
  7.                         {
  8.                         red[0]=s;
  9.                         if(s>=7)
  10.                                 {
  11.                                 if(s==7) green[1]=(1);
  12.                                 if(s>7)
  13.                                         {
  14.                                         if(green[1]<255) green[1]=(2*green[1]+1);
  15.                                                 if(green[1]==7) blue[2]=1;
  16.                                                 if(green[1]>7)
  17.                                                         {
  18.                                                         if(blue[2]<255) blue[2]=(2*blue[2]+1);
  19.                                                                 if(blue[2]==7) red[3]=1;
  20.                                                                 if(blue[2]>7)  
  21.                                                                         {
  22.                                                                         if(red[3]<255) red[3]=(2*red[3]+1);
  23.                                                                                 if(red[3]==7) green[4]=1;
  24.                                                                                 if(red[3]>7)
  25.                                                                                         {
  26.                                                                                         if(green[4]<255) green[4]=(2*green[4]+1);
  27.                                                                                                 if(green[4]==7) blue[5]=1;
  28.                                                                                                 if(green[4]>7)  
  29.                                                                                                         {
  30.                                                                                                         if(blue[5]<255) blue[5]=(2*blue[5]+1);
  31.                                                                                                                 if(blue[5]==7) red[6]=1;
  32.                                                                                                                 if(blue[5]>7)
  33.                                                                                                                         {
  34.                                                                                                                         red[6]=(2*red[6]+1);
  35.                                                                                                                         }
  36.                                                                                                         }
  37.                                                                                         }
  38.                                                                         }
  39.                                                         }
  40.                                         }
  41.                                 }
  42.                         _delay_ms(100);
  43.                         if(s<255) s=(2*s+1);
  44.                         if(red[6]==255)
  45.                                 {
  46.                                         _delay_ms(100);
  47.                                         break;
  48.                                 }
  49.                         }
  50.  
  51. //**************************************************************************
  52.                 s=127;
  53.                         while(1)
  54.                         {
  55.                         red[0]=s;
  56.                         if(s<=63)
  57.                                 {
  58.                                 if(s==63) green[1]=127;
  59.                                 if(s<63)
  60.                                         {
  61.                                          green[1]=((green[1]-1)/2);
  62.                                          if(green[1]==63) blue[2]=127;
  63.                                          if(green[1]<63)
  64.                                                         {
  65.                                                         blue[2]=((blue[2]-1)/2);
  66.                                                                 if(blue[2]==63) red[3]=127;
  67.                                                                 if(blue[2]<63)  
  68.                                                                         {
  69.                                                                         red[3]=((red[3]-1)/2);
  70.                                                                                 if(red[3]==63) green[4]=127;
  71.                                                                                 if(red[3]<63)
  72.                                                                                         {
  73.                                                                                         green[4]=((green[4]-1)/2);
  74.                                                                                                 if(green[4]==63) blue[5]=127;
  75.                                                                                                 if(green[4]<63)  
  76.                                                                                                         {
  77.                                                                                                         blue[5]=((blue[5]-1)/2);
  78.                                                                                                                 if(blue[5]==63) red[6]=127;
  79.                                                                                                                 if(blue[5]<63)
  80.                                                                                                                         {
  81.                                                                                                                         red[6]=((red[6]-1)/2);
  82.                                                                                                                         }
  83.                                                                                                         }
  84.                                                                                         }
  85.                                                                         }
  86.                                                         }
  87.                                         }
  88.  
  89.                                 }
  90.                         _delay_ms(100);
  91.                         if(s>0) s=((s-1)/2);
  92.                         if(red[6]==0)
  93.                         {
  94.                         _delay_ms(100);
  95.                         break;
  96.                         }
  97.                  
  98.                         }
  99.                        
  100.         }


Szinte biztos vagyok benne, hogy a nálam tapasztaltabbak százszor egyszerűbben is meg tudnák írni az animációt, de én csak erre jutottam

Esetleg valami ötlet, hogy mi lehet a hiba?
(#) Robi98 hozzászólása Jan 15, 2017 /
 
Elnézést, az előző kód miatt, elég rosszul sikerült a beillesztése. Itt az új:
  1. while(1)
  2. {
  3.  
  4. unsigned char s=1;
  5.  
  6. while(s)
  7. {
  8. red[0]=s;
  9.  
  10. if(s>=7)
  11. {
  12. if(s==7) green[1]=(1);
  13. if(s>7)
  14.         {
  15.         if(green[1]<255) green[1]=(2*green[1]+1);
  16.         if(green[1]==7) blue[2]=1;
  17.         if(green[1]>7)
  18.                 {
  19.                 if(blue[2]<255) blue[2]=(2*blue[2]+1);
  20.                 if(blue[2]==7) red[3]=1;
  21.                 if(blue[2]>7)  
  22.                         {
  23.                         if(red[3]<255) red[3]=(2*red[3]+1);
  24.                         if(red[3]==7) green[4]=1;
  25.                         if(red[3]>7)
  26.                                 {
  27.                                 if(green[4]<255) green[4]=(2*green[4]+1);
  28.                                 if(green[4]==7) blue[5]=1;
  29.                                 if(green[4]>7)  
  30.                                         {
  31.                                         if(blue[5]<255) blue[5]=(2*blue[5]+1);
  32.                                         if(blue[5]==7) red[6]=1;
  33.                                         if(blue[5]>7)
  34.                                                 {
  35.                                                 red[6]=(2*red[6]+1);
  36.                                                 }
  37.                                         }
  38.                                 }
  39.                         }
  40.         }
  41. }
  42. }
  43. _delay_ms(100);
  44. if(s<255) s=(2*s+1);
  45. if(red[6]==255)
  46.         {
  47.         _delay_ms(100);
  48.         break;
  49.         }
  50. }
  51.  
  52. //***************************************************************************
  53. s=127;
  54. while(1)
  55. {
  56. red[0]=s;
  57. if(s<=63)
  58. {
  59. if(s==63) green[1]=127;
  60. if(s<63)
  61. {
  62. green[1]=((green[1]-1)/2);
  63. if(green[1]==63) blue[2]=127;
  64. if(green[1]<63)
  65.                 {
  66.                 blue[2]=((blue[2]-1)/2);
  67.                 if(blue[2]==63) red[3]=127;
  68.                 if(blue[2]<63)  
  69.                         {
  70.                         red[3]=((red[3]-1)/2);
  71.                         if(red[3]==63) green[4]=127;
  72.                         if(red[3]<63)
  73.                                 {
  74.                                 green[4]=((green[4]-1)/2);
  75.                                 if(green[4]==63) blue[5]=127;
  76.                                 if(green[4]<63)  
  77.                                                 {
  78.                                                 blue[5]=((blue[5]-1)/2);
  79.                                                 if(blue[5]==63) red[6]=127;
  80.                                                 if(blue[5]<63)
  81.                                                         {
  82.                                                         red[6]=((red[6]-1)/2);
  83.                                                         }
  84.                                         }
  85.                                 }
  86.                         }
  87.                 }
  88. }
  89.  
  90. }
  91. _delay_ms(100);
  92. if(s>0) s=((s-1)/2);
  93. if(red[6]==0)
  94.         {
  95.         _delay_ms(100);
  96.         break;
  97.         }
  98.                  
  99. }
  100.                        
  101. }
(#) toma3757 válasza Sick-Bastard hozzászólására (») Jan 15, 2017 /
 
Köszönöm a segítségeteket!

Paritás,stop bitek rendben voltak, de az órajel nem..
Nem módosítottam fuse biteket, nem használok külső oszcillátort.
Most működik, de még kellett egy kis módosítás az általad említetteken kívül:
  1. #define UBRR_ERTEK ((F_CPU / (USART_BAUDRATE * 8UL)) - 1) // UBRR


A 8-as osztást ki lehet kapcsolni fuse bitek módosításával?
Persze akkor F_CPU-t is át kell írni gondolom.
(#) Sick-Bastard válasza toma3757 hozzászólására (») Jan 15, 2017 /
 
Igen ki lehet kapcsolni a fuse bitekkel.
Másik megoldás, hogy a kódba irod be a kikapcsolást.

  1. CLKPR = 0x80;
  2. CLKPR = 0;


Ezt beirod a kódod legelejére és igy 8Mhzen fog menni.
(#) Sick-Bastard válasza Robi98 hozzászólására (») Jan 15, 2017 /
 
Egy debug javaslat, ezt:
  1. if(s>=7)
  2. ...

cseréld le erre:
  1. if(red[0]>=7)
  2. ...


Ha egyik fény sem fut, akkor valóban a red[0] változóval van a baj. Ha mégis lefut, akkor valahol máshol a megjelenitésben.
(#) rascal válasza toma3757 hozzászólására (») Jan 15, 2017 /
 
Igen jól gondolod, viszont ezt a cikket olvasd el mielőtt belevágsz: Bővebben: Link. Másik hasznos dolog a fusebit doctor, néhány oldallal korábban adtam rá linket.
(#) Robi98 válasza Sick-Bastard hozzászólására (») Jan 15, 2017 /
 
Köszi, a javaslatot. Kipróbáltam és semmi változás. Tehát az már biztos, hogy a red[0] értéke az folyamatosan növelődik. Valahol máshol lehet a hiba. Kipróbáltam, hogy a csökkenő részt kivettem az animációból: ha az összes feltöltődött, akkor lenullázódnak és újra kezdődik a feltöltődés. Na ott működik mindegyik oszlop. Fogalmam sincs, mi lehet a hiba.
(#) bandi777 hozzászólása Jan 16, 2017 /
 
Üdv!

Open-suse alatt próbálkozok az avr-gcc -vel de sikertelenül.
A követketző hibát kapom mindíg:
  1. > avr-gcc -o thb.elf -mmcu=atmega128 main.o  serial.o  ...
  2. /usr/bin/avr-ld: warning: -z relro ignored.
  3. /usr/bin/avr-ld: cannot find -lm
  4. /usr/bin/avr-ld: cannot find -lc
  5. collect2: error: ld returned 1 exit status
  6. >


Valaki tud esetleg megoldást erre?
Illetve ha valaki tud küldeni egy AVR C forrásfájlokat HEX-re fordító minta makefile-t ami működőképes, azt örömmel fogadnám! (Lehet abban van a hiba?)
Előre is köszönettel!

B.
(#) Sick-Bastard válasza Robi98 hozzászólására (») Jan 16, 2017 /
 
Összedobtam két másik megközelítést a ciklusodhoz, hátha némi inspirációval szolgálnak.

7x8led_matri...c		    
(#) dc001 válasza bandi777 hozzászólására (») Jan 16, 2017 /
 
MCU után kell megadni az avr tipusát
F_CPU után az órajelet (érdemes ezt használni kódban is, pl.: c=8000000/8; helyett c=F_CPU/8; )
MODULES után ha a főprogramon kívül használsz modulokat
LIBS után ha használsz lib-eket
AVRDUDE, PORT és PROGRAMMER-t beállíthatod, ha make-el akarsz írni is (persze a programozódhoz)
CFLAGS és LDFLAGS bővítheted, ha szükséges

A HEADER alá bele teszi az összes könyvtárban lévő fejléc file-okat.
Azt feltételezi, hogy a főprogram a main.c-ben van.


használat

fordítás:
  1. make


takarít:
  1. make clean


kiírja a programod és az eeprom méretét (hasznos lehet, ha épp belefér/nem fér bele méret körül vagy)
  1. make size


felprogramozza az MCU-t
  1. make writeflash


eeprom-ot felprogramozza (ha használsz):
  1. make writeeeprom


Makefile:
  1. ## avr tipusa
  2. MCU = atmega8
  3. ## avr orajele
  4. F_CPU = 8000000
  5. ## modulok
  6. MODULES = serial.o
  7. ## libek
  8. LIBS=-lm
  9.  
  10. ## programozo
  11. AVRDUDE = avrdude
  12. ## programozo portja
  13. PORT = avrdoper
  14. ## porgramozo tipusa
  15. PROGRAMMER = stk500v2
  16.  
  17. ## c fordito
  18. CC=avr-gcc
  19. ## c linker
  20. LD=avr-gcc
  21. ## ihex
  22. GENHEX=avr-objcopy
  23.  
  24. ## fordito kapcsoloi
  25. CFLAGS = -mmcu=$(MCU) -DF_CPU=$(F_CPU)
  26. CFLAGS += -I.
  27. CFLAGS += -Wall -Os
  28. LDFLAGS =
  29. LDFLAGS += $(LIBS)
  30. HEXFLAGS=-j .text -O ihex
  31. EEPFLAGS=-j .eeprom --change-section-lma .eeprom=0 -O ihex
  32.  
  33. HEX = main.hex
  34. EEP = main.eep
  35. OBJS = main.o $(MODULES)
  36. HEADERS = $(wildcard *.h)
  37.  
  38. ALL = $(HEX) $(EEP)
  39.  
  40. all: $(ALL)
  41.  
  42. clean:
  43.         @rm -f $(OBJS) $(ALL)
  44.  
  45. %.o: %.c Makefile $(HEADERS)
  46.         $(CC) -c $< -o $@ $(CFLAGS)
  47.  
  48. %.bin: $(OBJS)
  49.         $(LD) -o $@ $(OBJS) $(LDFLAGS)
  50.  
  51. %.hex: %.bin
  52.         $(GENHEX) $(HEXFLAGS) $< $@
  53.  
  54. %.eep: %.bin
  55.         $(GENHEX) $(EEPFLAGS) $< $@
  56.  
  57.  
  58. writeflash: $(HEX)
  59.         $(AVRDUDE) -p $(MCU) -F -c $(PROGRAMMER) -P $(PORT) -U flash:w:$(HEX)
  60.  
  61. writeeeprom: $(EEP)
  62.         $(AVRDUDE) -p $(MCU) -F -c $(PROGRAMMER) -P $(PORT) -U eeprom:w:$(EEP)
  63.  
  64. size:
  65.         avr-size -d $(HEX) $(EEP)
A hozzászólás módosítva: Jan 16, 2017
(#) Robi98 válasza Sick-Bastard hozzászólására (») Jan 16, 2017 /
 
Köszönöm szépen a kód javaslatokat Amint lesz egy kis időm, ki is próbálom. A második kód hasonlított ahhoz amivel én próbálkoztam, ezért ugye könnyebb volt megérteni számomra. Az első viszont nagyon elegáns, mivel rövid és teljesen automatizált.

Eléggé kezdő vagyok még a programozásban, sokat kell még tanulnom Ez a sor például nem jutott volna eszembe, pedig teljesen logikus:
  1. sorok[0] += (sorok[0] + 1)
(#) kapu48 válasza Robi98 hozzászólására (») Jan 17, 2017 /
 
A hiba valószínűleg az elején levő értékadás: unsigned char s=1;
Amit a programod végén indokoltam.

  1. while(1)
  2. {
  3.  
  4.         unsigned char s=1;
  5.  
  6.         while(s)
  7.         {
  8.                 red[0]=s;
  9.  
  10.                 if(s>=7)
  11.                 {
  12.                         if(s==7) green[1]=(1);
  13.                         if(s>7)
  14.                         {
  15.         if(green[1]<255) green[1]=(2*green[1]+1);
  16.         if(green[1]==7) blue[2]=1;
  17.         if(green[1]>7)
  18.                 {
  19.                 if(blue[2]<255) blue[2]=(2*blue[2]+1);
  20.                 if(blue[2]==7) red[3]=1;
  21.                 if(blue[2]>7)
  22.                         {
  23.                         if(red[3]<255) red[3]=(2*red[3]+1);
  24.                         if(red[3]==7) green[4]=1;
  25.                         if(red[3]>7)
  26.                                 {
  27.                                 if(green[4]<255) green[4]=(2*green[4]+1);
  28.                                 if(green[4]==7) blue[5]=1;
  29.                                 if(green[4]>7)
  30.                                         {
  31.                                         if(blue[5]<255) blue[5]=(2*blue[5]+1);
  32.                                         if(blue[5]==7) red[6]=1;
  33.                                         if(blue[5]>7)
  34.                                                 {
  35.                                                 red[6]=(2*red[6]+1);
  36.                                                 }
  37.                                         }
  38.                                 }
  39.                         }
  40.         }
  41.                         }      
  42.                 }
  43.                 _delay_ms(100);
  44.                 if(s<255) s=(2*s+1);
  45.                 if(red[6]==255)
  46.                 {
  47.                         _delay_ms(100);
  48.                         break;
  49.                 }
  50.         }
  51.  
  52. //***************************************************************************
  53.         s=127;
  54.         while(1)
  55.         {
  56.                 red[0]=s;
  57.                 if(s<=63)
  58.                 {
  59.                         if(s==63) green[1]=127;
  60.                         if(s<63)
  61.                         {
  62.                                 green[1]=((green[1]-1)/2);
  63.                                 if(green[1]==63) blue[2]=127;
  64.                                 if(green[1]<63)
  65.         {
  66.                 blue[2]=((blue[2]-1)/2);
  67.                 if(blue[2]==63) red[3]=127;
  68.                 if(blue[2]<63)
  69.                         {
  70.                         red[3]=((red[3]-1)/2);
  71.                         if(red[3]==63) green[4]=127;
  72.                         if(red[3]<63)
  73.                                 {
  74.                                 green[4]=((green[4]-1)/2);
  75.                                 if(green[4]==63) blue[5]=127;
  76.                                 if(green[4]<63)
  77.                                                 {
  78.                                                 blue[5]=((blue[5]-1)/2);
  79.                                                 if(blue[5]==63) red[6]=127;
  80.                                                 if(blue[5]<63)
  81.                                                         {
  82.                                                         red[6]=((red[6]-1)/2);
  83.                                                         }
  84.                                         }
  85.                                 }
  86.                         }
  87.          }
  88.                         }
  89.  
  90.                 }
  91.                 _delay_ms(100);
  92.                 if(s>0) s=((s-1)/2);
  93.                 if(red[6]==0)
  94.     {
  95.         _delay_ms(100);
  96.         break;                                                  // mikor itt kilépsz a while böl! A ciklus elején s = 1 Lesz!
  97.     }
  98.                
  99.         }
  100.                        
  101. }
A hozzászólás módosítva: Jan 17, 2017
(#) janikukac hozzászólása Jan 17, 2017 /
 
Sziasztok!
Ha postán feladnék egy ATMega kontrollert válaszborítékkal, postaköltséggel együtt, akkor megtenné nekem valaki, hogy felprogramozza? A segítség csak abban a formában jó, ha nem Arduino ISP-s programozással van megoldva.
Segítségeiteket előre is köszönöm, privátban üzenetben jelezzetek, ha tudtok. Köszönöm!
(#) bandi777 válasza dc001 hozzászólására (») Jan 17, 2017 /
 
MŰKÖDIK! Köszönöm segítségedet! Plusz öröm, hogy ennek segítségével sikerült megtalálni azt is, hogy amivel eddig próbálkoztam, az miért könyökölt ki mindig a gépházból.
(#) Pethical válasza janikukac hozzászólására (») Jan 17, 2017 /
 
Csak kíváncsi vagyok, hogy az ArduinoISP miért nem jó?
(#) csatti2 válasza Pethical hozzászólására (») Jan 17, 2017 /
 
Arra én is. Az IC-t ugyan nem érdekli mi programozta fel.
(#) Robi98 válasza kapu48 hozzászólására (») Jan 18, 2017 /
 
Bocsi, de ezt nem értem. Miért baj az, hogy miután kilépek a második while-ból, akkor egy lesz a változó értéke? Ez miben befolyásolja azt, hogy az első oszlop egyáltalán nem világít? Hiszen amikor kilépek a második while ciklusból, egy lesz az értéke a változónak és indul az elejéről a feltöltődésért felelős ciklus (első while) aminek úgy kéne kezdődnie, hogy az első oszlop első ledje világít (red[0]=1).
A hozzászólás módosítva: Jan 18, 2017
(#) kapu48 válasza Robi98 hozzászólására (») Jan 18, 2017 /
 
„első oszlop első ledje világít (red[0]=1).”

Az nem elég, hogy a változóknak adsz értékeket!
Ezeket az értékeket még ki kellene küldeni a megfelelő portokra is!
Hogy vezéreljed a LED-eket.
És előtte kimenetre állítottad a portjaidat?
  1. //to make all pins of port A as output pins :
  2. DDRA = 0b11111111;
  3. ...
  4. // A porton levő LED kapcsolása
  5. PORTA = s;


ATMEL AVR Tutorial 2 : How to access Input / Output Ports ?
A hozzászólás módosítva: Jan 18, 2017
(#) kapu48 válasza Robi98 hozzászólására (») Jan 18, 2017 /
 
„első oszlop első ledje világít (red[0]=1).”

Az nem elég, hogy a változóknak adsz értékeket!
Ezeket az értékeket még ki kellene küldeni a megfelelő portokra is!
Hogy vezéreljed a LED-eket.
És előtte kimenetre állítottad a portjaidat?
  1. //to make all pins of port A as output pins :
  2. DDRA = 0b11111111;
  3. ...
  4. // A porton levő LED kapcsolása
  5. PORTA = s;


AVR programozás
(#) Sick-Bastard válasza kapu48 hozzászólására (») Jan 18, 2017 /
 
Robi98 írta:
Idézet:
„Akárhogy törtem a fejem nem találtam meg a hibát. A legmegdöbbentőbb az, hogy ha csak az animáció felét(mármint csak a feltöltődés efektust) rakom a végtelen ciklusba, akkor működik az első sor is.
A multiplexezés a 8 bites Timer2 interruptjában fut, azzal nincs gond, tökéletesen működik. Valahol a végtelen ciklusban lehet a hiba.”


Itt mellékelte a videót is, ahol látszik az animáció.

Az valóban furcsa, hogy csak akkor nem jelenik meg az első sor, ha harmadik while() ciklus is benne van a kódban.

Nekem az az elképzelésem, hogy olyan helyen van a hiba a kódban amit nem osztott meg. Pl.: az adatok kiírása a mátrixra.

Robi98:
Hogy segíthessünk légyszíves oszd meg az egész kódot, megszakítással mindennel.
(#) futlac válasza vzoole hozzászólására (») Jan 19, 2017 /
 
Segítséget kérnék, nekem van AtTiny13A amivel akku töltőt szeretnék csinálni, de nem tudom beprogramozni.A program megvan.Ha valaki nekem beprogramozna két példányt, adnék két darabot neki.
(#) futlac válasza trudnai hozzászólására (») Jan 19, 2017 /
 
Nekem Tőletek lenne kérdésem .Tudna valaki sagíteni ? AtTiny13A -al akku töltőt szeretnék csinálni, de nem tudom beprogramozni.A program megvan.Ha valaki nekem beprogramozna két példányt, adnék két darabot neki.
(#) Robi98 válasza Sick-Bastard hozzászólására (») Jan 20, 2017 /
 
Nos, először adok egy kis hardveres betekintést:
Ugye a mátrix közös katódos RGB ledekből áll és úgy vannak összekötözgetve, hogy oszloponként vannak a közös katódok, soronként pedig a megfelelő színekhez tartozó anódok.
Összesen 4 darab 74hc595 shift regiszter vezérli a ledeket: piros sorok, kék sorok, zöld sorok, és ugye az oszlopok tehát a közös katódok. A közös katódokat a shift regiszter egy tranzisztormezőn keresztül hajtja meg mert ugye itt sok áramot kell elnyelni. És ugye emiatt egy sor bekapcsolásánál nem 0-t kell elküldeni a shift regiszternek, hanem 1-et mert ugye az kapcsolja be a megfelelő tranzisztort.
A shift regisztereket SPI buszon vezérli az ATmega8. A három színért felelős shift regiszter OE lábai össze vannak kötve és a mikrovezérlő vezérli a PB0-ás lábon. Erre azért van szükség, hogy egyszerre le lehessen tiltani őket és olyankor biztosan sötét az összes led, mert nem jelenik meg rajtuk az előző adat. A reset lábak is össze vannak kötve, hogy egyszerre törölhessem a beléjük írt adatot. Ennek külön oka van, hogy így csináltam.

A multiplexezésről: Ugye a timer2 interruptjában fut, ahogyan előzőleg írtam, hogy a főprogramtól független legyen. A vezérlő órajele:8MHz >> 64-es előosztás >> 125000Hz >> ocr2=124 >> 1ms-ként van interrupt (plusz még az a kicsi idő még végigfut.) Azaz 1ms-ig van bekapcsolva 1 oszlop, aztán a következő és így tovább.
Megpróbáltam az egyes részeket jól felkommentelni.

  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3. #include <avr/interrupt.h>
  4.  
  5. #define redport PORTD
  6. #define greenport PORTD
  7. #define blueport PORTB
  8. #define negativeport PORTB
  9. #define OEport PORTB
  10.  
  11. #define OE PB0
  12. #define red_select PD0
  13. #define green_select PD1
  14. #define blue_select PB1
  15. #define negative_select PB2
  16.  
  17. unsigned char t=0;
  18.  
  19. unsigned char red[7];
  20. unsigned char green[7];
  21. unsigned char blue[7];
  22.  
  23.  
  24. void resetSPI(void) // a shift regisztereknek elküldött adat törlése
  25. {
  26. PORTD&=~(1<<PD7);
  27. _delay_us(1);
  28. PORTD|=(1<<PD7);
  29. }
  30.  
  31.  
  32. void konfigTIMER(void) 
  33. {
  34. TCCR2|=(1<<WGM21);//CTC mód TIMER2
  35. TIMSK|=(1<<OCIE2);//interrupt bekapcsolása
  36. OCR2=124; //125-re csordul túl
  37. TCNT2=0;
  38. TCCR2|=(1<<CS22);//64-es előosztás, számláló indítása
  39. }
  40.  
  41.  
  42. void konfigSPI(void)
  43. {
  44. SPCR=(1<<MSTR)|(1<<SPE);
  45. SPSR|=(1<<SPI2X);// 2-es előosztás
  46. PORTD|=(1<<PD7); // összes shift regiszter engedélyezve
  47. }
  48.  
  49.  
  50. void red_send(unsigned char red) // a piros sorokat vezérlő shift regiszternek küldi az adatot...
  51. {
  52. redport&=~(1<<red_select);
  53. _delay_us(1);
  54. SPDR=red;
  55. while(!(SPSR & (1<<SPIF)));
  56. redport|=(1<<red_select);
  57. }
  58.  
  59. void green_send(unsigned char green)//ugyanígy a zöldnek....
  60. {
  61. greenport&=~(1<<green_select);
  62. _delay_us(1);
  63. SPDR=green;
  64. while(!(SPSR & (1<<SPIF)));
  65. greenport|=(1<<green_select);
  66. }
  67.  
  68. void blue_send(unsigned char blue)//...és a kéknek...
  69. {
  70. blueport&=~(1<<blue_select);
  71. _delay_us(1);
  72. SPDR=blue;
  73. while(!(SPSR & (1<<SPIF)));
  74. blueport|=(1<<blue_select);
  75. }
  76.  
  77. void negative_send(unsigned char negative)// az oszlopokat bekapcsoló shift regiszternek
  78. {
  79. negativeport&=~(1<<negative_select);
  80. _delay_us(1);
  81. SPDR=negative;
  82. while(!(SPSR & (1<<SPIF)));
  83. negativeport|=(1<<negative_select);
  84. }
  85.  
  86.  
  87. //***********************************************************
  88. /////////////////////////////////////////////////////////////
  89. //***********************************************************
  90.  
  91. ISR(TIMER2_COMP_vect) // itt történik a multiplexezés, tehát a megjelenítés.
  92. {
  93. OEport|=(1<<OE);// letiltjuk az összes shift regiszter kimenetét.
  94. resetSPI();//töröljük a shift regiszterekben lévő előző adatot
  95. negative_send(128>>t);//bekapcsoljuk az egyik oszlopot (elsőként a 0b10000000 mert forrasztás szempontjából így volt a legegyszerűbb megoldani)                 
  96. red_send(red[t]);// PIROS adat elküldése
  97. green_send(green[t]); //zöld adat elküldése
  98. blue_send(blue[t]); //kék adat elküldése
  99. OEport&=~(1<<OE);//kimenetek engedélyezése
  100. t++;
  101. if(t==7) t=0;// mivel hét oszlop van, 0-tól 7-ig megy
  102. }
  103.  
  104.  
  105. ///////////////////////////////////////////
  106.  
  107.  
  108. int main (void)
  109. {
  110. OEport|=(1<<OE);//letiltjuk a kimeneteket (az interruptban úgy is engedélyeződni fognak)
  111. DDRD=0xFF;
  112. DDRB=(1<<blue_select)|(1<<negative_select)|(1<<PB3)|(1<<PB5)|(1<<OE);
  113. // MOSI SCK kék és negatív választó kimenet
  114.  
  115. konfigSPI();
  116. konfigTIMER();
  117. sei();
  118.  
  119. while(1)
  120. {
  121.  
  122. unsigned char s=1;
  123.  
  124. while(s) //feltöltődés animáció
  125. {
  126. red[0]=s;
  127. if(s>=7)
  128.         {
  129.         if(s==7) green[1]=(1);
  130.         if(s>7)
  131.                 {
  132.                 if(green[1]<255) green[1]=(2*green[1]+1);
  133.                 if(green[1]==7) blue[2]=1;
  134.                 if(green[1]>7)
  135.                                 {
  136.                                 if(blue[2]<255) blue[2]=(2*blue[2]+1);
  137.                                 if(blue[2]==7) red[3]=1;
  138.                                 if(blue[2]>7)  
  139.                                         {
  140.                                         if(red[3]<255) red[3]=(2*red[3]+1);
  141.                                         if(red[3]==7) green[4]=1;
  142.                                         if(red[3]>7)
  143.                                                 {
  144.                                                 if(green[4]<255) green[4]=(2*green[4]+1);
  145.                                                 if(green[4]==7) blue[5]=1;
  146.                                                 if(green[4]>7)  
  147.                                                         {
  148.                                                         if(blue[5]<255) blue[5]=(2*blue[5]+1);
  149.                                                         if(blue[5]==7) red[6]=1;
  150.                                                         if(blue[5]>7)
  151.                                                                 {
  152.                                                                 red[6]=(2*red[6]+1);
  153.                                                                 }
  154.                                                         }
  155.                                                 }
  156.                                         }
  157.                                 }
  158.                         }
  159.                 }
  160. _delay_ms(100);
  161. if(s<255) s=(2*s+1);
  162. if(red[6]==255)
  163.         {
  164.         _delay_ms(100);
  165.         break;
  166.         }
  167. }
  168.  
  169. //*************************************************************************************
  170. //*************************************************************************************
  171. //*************************************************************************************
  172. s=127;
  173. while(1) // csökkenő animáció
  174. {
  175. red[0]=s;
  176. if(s<=63)
  177. {
  178. if(s==63) green[1]=127;
  179. if(s<63)
  180.         {
  181.         green[1]=((green[1]-1)/2);
  182.         if(green[1]==63) blue[2]=127;
  183.         if(green[1]<63)
  184.                 {
  185.                 blue[2]=((blue[2]-1)/2);
  186.                 if(blue[2]==63) red[3]=127;
  187.                 if(blue[2]<63)  
  188.                         {
  189.                         red[3]=((red[3]-1)/2);
  190.                         if(red[3]==63) green[4]=127;
  191.                         if(red[3]<63)
  192.                                 {
  193.                                 green[4]=((green[4]-1)/2);
  194.                                 if(green[4]==63) blue[5]=127;
  195.                                 if(green[4]<63)  
  196.                                         {
  197.                                         blue[5]=((blue[5]-1)/2);
  198.                                         if(blue[5]==63) red[6]=127;
  199.                                         if(blue[5]<63)
  200.                                                 {
  201.                                                 red[6]=((red[6]-1)/2);
  202.                                                 }
  203.                                         }
  204.                                 }
  205.                         }
  206.                 }
  207.         }
  208.  
  209. }
  210. _delay_ms(100);
  211. if(s>0) s=((s-1)/2);
  212. if(red[6]==0)
  213.         {
  214.         _delay_ms(100);
  215.         break;
  216.         }
  217.                  
  218. }
  219.                        
  220. }
  221. }
A hozzászólás módosítva: Jan 20, 2017
(#) kapu48 válasza Robi98 hozzászólására (») Jan 20, 2017 /
 
Már próbáltam felhivni a figyelmedet rá!
  1. while(1)
  2. {
  3.  
  4. unsigned char s=1;   s miért itt lessz = 1 ????
  5.  
  6. while(s) //feltöltődés animáció
  7. {
  8. red[0]=s;
  9. if(s>=7)      s=1!!! ,  s < 7 ???? ezért ---
  10. {
  11. ...  erre a részre nem kerül a vezérlés
  12.  
  13. }
(#) Sick-Bastard válasza kapu48 hozzászólására (») Jan 20, 2017 /
 
Kipróbáltam a main while() ciklusát, ami nálam jól megy... szimulációban.

  1. int main(void)
  2. // Inicializálások....
  3. while(1)
  4. {
  5.         unsigned char s=1;
  6.         while(s)
  7.         {
  8.                 red[0]=s;
  9.                 if(s>=7)
  10.                 {
  11.                 ....
  12.                 }
  13.                 _delay_ms(100);
  14.                 if(s<255) s=(2*s+1); // itt növeli "s" változót
  15.                 if(red[6]==255)
  16.                 {
  17.                         _delay_ms(100);
  18.                         break;
  19.                 }
  20.         }
  21. ...


Robi98 szerintem azért adja meg az "s" értékét a while(1) ciklusban, mivel a harmadik while() vége után s = 0 lesz. Igy amikor main while() ciklusa másodjára futna le, akkor nem lépne be a while(s) ciklusba.

Megoldási javaslatom:
while(s) helyett while(red[6]<255)
Igy kikerülhet az "s" az első while()-ból.

az én megközelitésem
(#) Istvanpisti válasza Robi98 hozzászólására (») Jan 20, 2017 /
 
Esetleg
  1. unsigned char t=0;

helyett,
  1. volatile unsigned char t=0;


Lásd, a lap tetején lévő sárga négyszög 1. pontját.
A hozzászólás módosítva: Jan 20, 2017
(#) killbill válasza Istvanpisti hozzászólására (») Jan 20, 2017 /
 
Felesleges volatile-nak deklaralni, mert csak a megszakitas hasznalja azt a valtozot. Igazsag szerint a megszakitas fuggvenyben kellene deklaralni igy:
  1. ISR(TIMER2_COMP_vect) // itt történik a multiplexezés, tehát a megjelenítés.
  2. {
  3. static unsigned char t;
  4.  
  5. ...
  6.  
  7.  ++t;
  8.  t &= 7;
  9. }
A hozzászólás módosítva: Jan 20, 2017
(#) uedit hozzászólása Jan 21, 2017 /
 
Szia!
Kérdésem lenne?
A legtöbb AVR-es projektben, csak a HEX file van megadva, viszont az (STK500) programozóban vannak Fuses és Lock bitek. Ha ezek nincsenek megadva honnan tudom meg, hogy mit kell odaírnom? Előre is köszönöm a segítséget, a választ.

Felvétel.jpg		    
Ezekre szükség lehet! - HESTORE.HU

ATMEGA128-16AU
ATMEGA8-16AU
ATTINY13-20SU
74HC595 SMD
IRLZ34N
Következő: »»   758 / 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