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   508 / 840
(#) kurosaki válasza Sasmadár hozzászólására (») Jan 13, 2013 /
 
köszönöm mégegyszer.

mindenkihez szolok ezzel a problémával:
naiv módon aszittem hogy innentől meg tudom csinálni hogy eltárolom egy változóban pl:
int valami=1;
és akkor egy kapcsolót tudok készíteni de most csak villog.
mivel tudom megakadályozni hogy az érték csak is 0 és 1 között változzon?
tudom nem vagyok profi AVR es előre is bocsánat de ennek a kódnak mennie kéne de valamiért az = jelet nem veszi figyelembe a LED nél.
  1. int main(void)
  2.       {
  3.                   int online=0;
  4.               DDRB = (1<<PB4);
  5.               PORTD |= (1<<PD1);
  6.                   PORTD |= (1<<PD5); //felhúzó ellenállás bekapcsolása a D1-en
  7.               while(1)
  8.               {
  9.                       if(bit_is_set(PIND,PIND1))
  10.                       {
  11.                                   online=1;
  12.      
  13.                       }
  14.                              
  15.                           if(bit_is_set(PIND,PIND5))
  16.                            {
  17.                                        online=0;
  18.                                        
  19.                            }
  20.                            
  21.                           if(online = 1)
  22.                           {
  23.                                   LED_OFF();
  24.                           }                      
  25.                           else
  26.                           {
  27.                                   LED_ON();
  28.                           }
  29.  
  30.               }
  31.       }
(#) Sasmadár válasza kurosaki hozzászólására (») Jan 13, 2013 /
 
  1. if(online ==1)

Ahogy Te írtad értékadás.
(#) kurosaki válasza Sasmadár hozzászólására (») Jan 13, 2013 /
 
Perfect köszönöm szépen bár nem tom miért nem elég egy db egyenlőség jel.
(#) tecsa válasza kurosaki hozzászólására (») Jan 13, 2013 /
 
Az a fárnya Ritchie meg a Kerninghan
A hozzászólás módosítva: Jan 13, 2013
(#) Sasmadár válasza kurosaki hozzászólására (») Jan 13, 2013 /
 
C-ben az egyenlőség operátor: ==
(#) kurosaki hozzászólása Jan 13, 2013 /
 
AVR ben hogyan lehet megoldani az akksi szint jelzését? gondolok itt hogy 4-5 led csücsül 4-5 lábon
5LED 100%
4 led 60%
stb
vagy ehez más is kell mint egy AVR?
(#) zombee válasza kurosaki hozzászólására (») Jan 13, 2013 /
 
Hát attól függ. Azért jó ha tudod hogy egy akksi töltöttségét nem a kapocsfesz jelzi. SOHA!
Talán a belső ellenállás az, ami megbízható adat, és viszonylag könnyen mérhető.
De még ez sem teljesen, mert az akku polarizálódik, így nem mindegy hogy egy álló vagy
éppen használatban lévő akku belső ellenállását méred.
Egy AVR nem rossz választás, de a körítés és a mérési elv, na az már valami!
A hozzászólás módosítva: Jan 13, 2013
(#) kurosaki válasza zombee hozzászólására (») Jan 13, 2013 /
 
Akkor ezt még hanyagolom igazából a 12V os ellem nek használati idejét szerettem volna mérni mármint mennyi van még hátra.
Projectem egy Zenére villogo ledsor lesz több funkcioval és aza vad 5letem van hogy 12V os ellemröl hajtom meg egy 5V letranszformálással hogy az AVR ne füstöljön el.
Akkor marad más megoldás addig. Köszönöm a segitséget nagyon mindenkinek
(#) mario1111 válasza mario1111 hozzászólására (») Jan 13, 2013 /
 
Sziasztok!

Esetleg valakinek van valami tippje azzal kapcsolatban, amit korábban írtam.
Gyakorlatilag egy egysoros programot letolok a prociba, még csak fel se konfigolom az AD-t, de már eltolja a feszosztómat. Most ráforrasztottam a 4k7-re még egy 4k7-et meg az 1k-t is így, h maradjon az osztó. Az osztó bemenő, kimenő feszét megmértem és, ha nincs rákapcsolva a proci AD-jára, akkor jó, ha rákötöm akkor meg felhúzza pár mV-al. Így, hogy feleztem az ellenállásokat kicsit jobb lett, de nem gondolom,h ez normális és az 5 V-ot a végén valami 1k-val kell megterhelnem, hogy jól mérje.

Most két ötletem van még. Vagy ez a példány hibás és cserélem, vagy ha ez általános probléma, akkor jobban járok egy külső ad-vel.
Javaslat?

M
(#) huba válasza mario1111 hozzászólására (») Jan 13, 2013 /
 
Mérd meg a processzor egy másik AD lábát is. Hogyha tényleg elhúzza az osztód, a szabad lábon kell mérjél feszültséget.
Hogyha minden ad-lábon ezt csinálja, és analaog gnd jol be van kötve, és tényleg minden perfiéria jól van konfigurálva, akkor még utolsó esélyként megnézném az adalapban megadott bemeneti impedancia nagyságát.
(#) sikolymester válasza kurosaki hozzászólására (») Jan 13, 2013 /
 
Ha alkaline elemet használsz, akkor annak ~lineáris a kisülése, ami alapján simán lehet következtetni a kapacitására. Zombee kolléga azt hitte, hogy NiMh vagy Li-ion akkumulátorra gondolsz.
(#) kurosaki válasza sikolymester hozzászólására (») Jan 13, 2013 /
 
Ja értem akkor bocsánat.Igazábol majd azt is szeretnék de elöször valami egyszerübbet szeretnék.Gondolom maga az AVR nem alkalmas a mérésre vagy igen?
(#) Sick-Bastard válasza Sick-Bastard hozzászólására (») Jan 13, 2013 /
 
Az átláthatóság kedvéért összeraktam a 3 filet.
  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3.  
  4. // SPI settings
  5. #define SPI_PORT        PORTB
  6. #define SPI_DDR         DDRB
  7. #define CS1                     PB2
  8. #define CE                      PB4
  9. #define MOSI            PB5
  10. #define MISO            PB6
  11. #define SCK                     PB7
  12.  
  13. // Chip Select pin on AVR
  14. #define ROM             PB2                     // 25LC320 EEPROM chip
  15. #define SR                      PB4                     // 74HC595 chip
  16.  
  17. // INSTRUCTION SET
  18. #define READ            0b00000011      // Read data  memory array beginning at ed address
  19. #define WRITE           0b00000010      // Write data to memory array beginning at ed address
  20. #define WRDI            0b00000100      // Reset the write enable latch (disable write operations)
  21. #define WREN            0b00000110      // Set the write enable latch (enable write operations)
  22. #define RDSR            0b00000101      // Read Status register
  23. #define WRSR            0b00000001      // Write Status register
  24.  
  25. // Read Status Register
  26. #define WPEN            0b10000000      // Write-Protect Enable
  27. #define BP0                     0b00000100      // Block Protection0
  28. #define BP1                     0b00001000      // Block Protection1
  29. // address 16bit max 2^12=4096*8bit 128*32byte
  30.  
  31. unsigned char data;
  32.  
  33. void SPIWR(unsigned char data)
  34. {
  35.         SPDR = data;
  36.         while(!(SPSR & (1<<SPIF)));
  37.         _delay_us(1);
  38. }
  39.  
  40. unsigned char SPIRD(void)
  41. {
  42.         SPDR = 0x00;
  43.         while(!(SPSR & (1<<SPIF)));
  44.         _delay_us(1);
  45.         return(SPDR);
  46. }
  47.  
  48. void SPI_Init(void)
  49. {
  50.         SPI_DDR |= (1<<SCK)|(1<<MOSI)|(1<<CE)|(1<<CS1);
  51.         SPCR |= (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0);
  52.         SPCR |= (0<<DORD);
  53.         SPSR |= (0<<SPI2X);
  54. }
  55.  
  56. unsigned char ROMRDSR(void)
  57. {
  58.         SPI_PORT &= ~(1<<ROM);                  // activate eeprom
  59.         SPIWR(RDSR);                                    // 0b00000101
  60.         SPDR = 0x00;                                    // dummy data
  61.         while(!(SPSR & (1<<SPIF)));     // wait until transfer is completed
  62.         _delay_us(1);                                   // extra delay
  63.         SPI_PORT |= (1<<ROM);                   // deacivate eeprom
  64.         _delay_ms(5);
  65.         return(SPDR);                                   // returning data  SPI register to variable
  66. }
  67.  
  68. void ROMWRSR(unsigned char data)
  69. {
  70.         SPI_PORT &= ~(1<<ROM);
  71.         SPIWR(WRSR);
  72.         SPIWR(data);
  73.         SPI_PORT |= (1<<ROM);
  74.         _delay_ms(5);
  75. }
  76.  
  77. int main(void)
  78. {
  79.         SPI_Init();
  80.         SPI_PORT |= (1<<ROM);
  81.         SPI_PORT &= ~(1<<SR);
  82.        
  83.         DDRD |= (1<<PIND5);
  84.  
  85.         while(1)
  86.         {
  87.                 SPIWR(0xFF);
  88.                 SPI_PORT |= (1<<SR);
  89.                 _delay_us(1);
  90.                 SPI_PORT &= ~(1<<SR);
  91.                 _delay_ms(2000);
  92.                
  93.                 SPIWR(0x11);
  94.                 SPI_PORT |= (1<<SR);
  95.                 _delay_us(1);
  96.                 SPI_PORT &= ~(1<<SR);
  97.                 _delay_ms(2000);
  98.                
  99.                 data = ROMRDSR();
  100.                 SPIWR(data);
  101.                 SPI_PORT |= (1<<SR);
  102.                 _delay_us(1);
  103.                 SPI_PORT &= ~(1<<SR);
  104.                
  105.                 PORTD ^= (1<<PIND5);            // 0bxxxx0000
  106.                 _delay_ms(2000);
  107.                
  108.                 ROMWRSR(WREN);                          // ROM SR Write Enable
  109.                
  110.                 PORTD ^= (1<<PIND5);
  111.                 _delay_ms(2000);
  112.                
  113.                 data = ROMRDSR();
  114.                 SPIWR(data);
  115.                 SPI_PORT |= (1<<SR);
  116.                 _delay_us(1);
  117.                 SPI_PORT &= ~(1<<SR);
  118.                
  119.                 PORTD ^= (1<<PIND5);            // 0bxxxx0010
  120.                 _delay_ms(2000);
  121.                
  122.                 ROMWRSR(WRDI);                          // ROM SR Write Disable
  123.                
  124.                 PORTD ^= (1<<PIND5);
  125.                 _delay_ms(2000);
  126.                
  127.         }
  128.        
  129. }


A probléma még mindig, hogy nem tudom írni/olvasni a ROM SR-ét így a memóriáját sem...
A nagy 2mp-es késleltetések, csak a kód lassítására szolgálnak.

SB
(#) mario1111 válasza huba hozzászólására (») Jan 13, 2013 /
 
Alapból minden láb lebeg valahol fél volt körül.
Viszont itt a méréssel is lesz valami gond. A multival a portláb tövében mérve más feszt mérek mint a feszosztónál mérve. Viszont ha a portlábtól nézem a feszosztóig, akkor meg 0V-ot mérek.
Itt a kapcsolóüzemű táppal lesz nem kis gond. Megpróbáltam leárnyékolni nyákdarabbal és máris csökkent ez a feszültség. Az volt gyanús, hogy a portlábon kisebb feszt mértem mint a feszosztónál. Ha a procitól jönne vissza ez a dolog, akkor ott pont fordítva kéne lenni.
Szóval nem a proci emeli meg vsz, hanem a kapcsolóüzemű táp, ami nem túl szerencsés helyre került
Ebből sztem holnap nyáktervezés lesz és satronik, meg újrarendelem az alkatrészeket.
Viszont most már odatervezek külső AD-nek helyet...

M
(#) huba válasza mario1111 hozzászólására (») Jan 13, 2013 /
 
Ha már újratervezel, tegyél be egy 10-100pF os kondit az analog vonal hidegítésére, mielőtt belemenne a mikrovezérlőbe. Sok zajt leszűr, és alig kerül valamibe.
(#) kurosaki hozzászólása Jan 14, 2013 /
 
Sziasztok.
Egy ujjab probléma/Kérdésem lenne:
Első:Attiny 2313 hány "programot" tudna eltárolni/meghívni/kezelni?Ugyértve hogy bevan töltve 4 Program pl az AVR be és gombokkal váltok köztük.

Második:Hogyan lehet ezt megoldani? Mivel Lenne egyszerűbb? IF? vagy külön File és Includolni?
Köszönöm előre is a segitséget.
(#) sikolymester válasza kurosaki hozzászólására (») Jan 14, 2013 /
 
Egy C könyv forgatását javaslom.
Hidd el, nem fogod megbánni.
(#) zombee válasza sikolymester hozzászólására (») Jan 14, 2013 /
 
Hehe. Ravasz.

Az én válaszom, hogy csinálj X darab "taszk" függvényt, amiből futnak a dolgok.
Mivel egy AVR programja soha nem érhet véget, ezeket a függvényeket ciklusba kell megoldani.
De, és itt jön a csavar: a ciklusmag végén a vezérlés visszakerül a main függvénybe,
ami valamilyen feltétel alapján kiválasztja hogy legközelebb melyik taszk függvényét hívja meg.
Ha nem változik semmi akkor az előzőt hívja meg, kvázi ciklust valósítva meg ezzel.
A váltás a main függvény feladata(pl. a hívás előtt ellenőrzi a kapcsolók állását),
illetve interruptot is használhatsz(pl. gombnyomásra), de akkor is csak a main-nál lesz átkapcsolás.
Ügyelj arra hogy a taszkfüggvényekben létrehozott változók elvesznek, használj globális változókat!
Egyébként ezt a módszert nem-preemptív ütemezésnek hívják. Köszönöm a figyelmet.
A hozzászólás módosítva: Jan 14, 2013
(#) csabeszq válasza zombee hozzászólására (») Jan 14, 2013 /
 
A setjmp, longjmp segítségével tényleges szálakat is csinálhatsz, de mondjuk 128 byte rammal rendelkező eszközön ne próbáld. Szálanként legalább 64 byte stack legyen benne.

Régen szórakozásból megírtam, de egyébként az esetek 1%-ában lehet rá szükséged.



Egyébként az AVR nem tud programot betölteni. Felprogramozod és úgy marad. A flash 10000 írást bír ki, nem való program betöltésre.
(#) kurosaki hozzászólása Jan 15, 2013 /
 
Sziasztok
Minden klappol ugy ahogy kell köszönöm a segitséget.

Még egy kérdésem lenne AVR el gondolom nem tudom szürni a frekiket. Mármint a hangmagasságot hogy mély,magas stb? És annak megfelelően adjon ki jelet ? pl: magas ütemre a PB2 es lábon lévő dolgot hajtsa meg.

Vagy ehez már Filter kell?
(#) macsaba hozzászólása Jan 15, 2013 /
 
Sziasztok!
Lenne egy C programom ahol egy gomb lenyomására lefut egy konfiguráló rész ami ad egy jelet a hardvernek majd méri a visszaérkező jelig eltelt időt (erre azért van szükség mivel ez az idő változhat mivel a hardvere is saját fejlesztés és ha változtatok rajta akkor újra meg kéne mérni ). A feladat az hogy ezt a mért értéket elmentse az AVR mivel a főprogram használja ezt és ne kelljen újra elindítani a konfigurálást minden egyes kikapcsolás után.
(#) benjami válasza macsaba hozzászólására (») Jan 15, 2013 /
 
Ilyesmire találták ki az adat EEPROM-ot. Az adatlapban megnézhető van-e benne és mennyi.
(#) Fizikus válasza kurosaki hozzászólására (») Jan 16, 2013 /
 
Nem tudom pontosan hogy mit akarsz epiteni, de lehet hogy egy MSGEQ7 IC kellene neked...
(#) Sick-Bastard hozzászólása Jan 16, 2013 /
 
Üdv!

Kérhetnék egy kis segítséget egy 8535-ös AVR és egy 25LC320-as EEPROM kommunikációjával kapcsolatban?

A problémám, hogy nem tudok vagy/és írni/olvasni.

A bekötések 99%, hogy jók, a gond szerintem az adat küldésben és fogadásban van.

Az adatlapja szerint:
Idézet:
„2.5 Serial Clock (SCK)
The SCK is used to synchronize the communication
between a master and the 25XX320. Instructions,
addresses, or data present on the SI pin are latched on
the rising edge of the clock input, while data on the SO
pin is updated after the falling edge of the clock input.”


Szóval ha jól sejtem az írásnál és az olvasásnál más-más SPI beállítást kell használnom. Tippem szerint a CPHA bitet kell feltétlen módosítanom: írásnál 0-ra olvasásnál 1-re.
Közel járok az igazsághoz?

  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3.  
  4. // SPI settings
  5. #define SPI_PORT        PORTB
  6. #define SPI_DDR         DDRB
  7. #define MOSI            PB5
  8. #define MISO            PB6
  9. #define SCK                     PB7
  10.  
  11. // Chip Select pin on AVR
  12. #define ROM             PB2                     // 25LC320 EEPROM chip
  13. #define SR                      PB4                     // 74HC595 chip
  14.  
  15. // INSTRUCTION SET
  16. #define READ            0b00000011      // Read data  memory array beginning at ed address
  17. #define WRITE           0b00000010      // Write data to memory array beginning at ed address
  18. #define WRDI            0b00000100      // Reset the write enable latch (disable write operations)
  19. #define WREN            0b00000110      // Set the write enable latch (enable write operations)
  20. #define RDSR            0b00000101      // Read Status register
  21. #define WRSR            0b00000001      // Write Status register
  22.  
  23. // Read Status Register
  24. #define WPEN            0b10000000      // Write-Protect Enable
  25. #define BP0                     0b00000100      // Block Protection0
  26. #define BP1                     0b00001000      // Block Protection1
  27. // address 16bit max 2^12=4096*8bit 128*32byte
  28.  
  29. unsigned char data;
  30.  
  31. void SPIWR(unsigned char data)
  32. {
  33.         SPDR = data;
  34.         while(!(SPSR & (1<<SPIF)));
  35.         _delay_us(1);
  36. }
  37.  
  38. unsigned char SPIRD(void)
  39. {
  40.         SPDR = 0x00;
  41.         while(!(SPSR & (1<<SPIF)));
  42.         _delay_us(1);
  43.         return(SPDR);
  44. }
  45.  
  46. void SPI_Init(void)
  47. {
  48.         SPI_DDR |= (1<<SCK)|(1<<MOSI)|(1<<ROM)|(1<<SR);
  49.         SPCR |= (0<<SPIE)|(1<<SPE)|(0<<DORD)|(1<<MSTR)|(0<<CPOL)|(0<<CPHA)|(1<<SPR1)|(1<<SPR0);
  50.         SPSR |= (0<<SPI2X);
  51. }
  52.  
  53. void EEPROMRD_SPI_Init(void)
  54. {
  55.         SPI_DDR |= (1<<SCK)|(1<<MOSI)|(1<<ROM)|(1<<SR);
  56.         SPCR |= (0<<SPIE)|(1<<SPE)|(0<<DORD)|(1<<MSTR)|(0<<CPOL)|(1<<CPHA)|(1<<SPR1)|(1<<SPR0);
  57.         SPSR |= (0<<SPI2X);
  58. }
  59.  
  60. void EEPROMWR_SPI_Init(void)
  61. {
  62.         SPI_DDR |= (1<<SCK)|(1<<MOSI)|(1<<ROM)|(1<<SR);
  63.         SPCR |= (0<<SPIE)|(1<<SPE)|(0<<DORD)|(1<<MSTR)|(0<<CPOL)|(0<<CPHA)|(1<<SPR1)|(1<<SPR0);
  64.         SPSR |= (0<<SPI2X);
  65. }
  66.  
  67. /*unsigned char ROMRDSR(void)
  68. {
  69.         SPI_PORT &= ~(1<<ROM);                  // activate eeprom
  70.         SPIWR(RDSR);                                    // 0b00000101
  71.         SPDR = 0x00;                                    // dummy data
  72.         while(!(SPSR & (1<<SPIF)));             // wait until transfer is completed
  73.         _delay_us(1);                                   // extra delay
  74.         SPI_PORT |= (1<<ROM);                   // deacivate eeprom
  75.         _delay_ms(5);
  76.         return(SPDR);                                   // returning data  SPI register to variable
  77. }*/
  78.  
  79. void ROMRDSR(void)
  80. {
  81.         SPI_PORT &= ~(1<<ROM);                 
  82.         SPIWR(RDSR);                                   
  83. }
  84.  
  85. void ROMWRSR(unsigned char data)
  86. {
  87.         SPI_PORT &= ~(1<<ROM);
  88.         SPIWR(WRSR);
  89.         SPIWR(data);
  90.         SPI_PORT |= (1<<ROM);
  91.         _delay_ms(5);
  92. }
  93.  
  94. int main(void)
  95. {
  96.         SPI_Init();
  97.         SPI_PORT |= (1<<ROM);
  98.         SPI_PORT &= ~(1<<SR);
  99.        
  100.         DDRD |= (1<<PIND5);
  101.  
  102.         while(1)
  103.         {
  104.                 SPIWR(0xFF);
  105.                 SPI_PORT |= (1<<SR);
  106.                 _delay_us(1);
  107.                 SPI_PORT &= ~(1<<SR);
  108.                 _delay_ms(2000);
  109.                
  110.                 SPIWR(0x11);
  111.                 SPI_PORT |= (1<<SR);
  112.                 _delay_us(1);
  113.                 SPI_PORT &= ~(1<<SR);
  114.                 _delay_ms(2000);
  115.                
  116.                 ROMRDSR();
  117.                 EEPROMRD_SPI_Init();
  118.                 data = SPIRD();
  119.                 SPI_PORT |= (1<<ROM);
  120.                
  121.                 SPI_Init();
  122.                 SPIWR(data);
  123.                 SPI_PORT |= (1<<SR);
  124.                 _delay_us(1);
  125.                 SPI_PORT &= ~(1<<SR);
  126.                
  127.                 PORTD ^= (1<<PIND5);            // 0bxxxx0000
  128.                 _delay_ms(2000);
  129.                
  130.                 ROMWRSR(WREN);                          // ROM SR Write Enable
  131.                
  132.                 PORTD ^= (1<<PIND5);
  133.                 _delay_ms(2000);
  134.                
  135.                 ROMRDSR();
  136.                 EEPROMRD_SPI_Init();
  137.                 data = SPIRD();
  138.                 SPI_PORT |= (1<<ROM);
  139.                
  140.                 SPI_Init();
  141.                 SPIWR(data);
  142.                 SPI_PORT |= (1<<SR);
  143.                 _delay_us(1);
  144.                 SPI_PORT &= ~(1<<SR);
  145.                
  146.                 PORTD ^= (1<<PIND5);            // 0bxxxx0010
  147.                 _delay_ms(2000);
  148.                
  149.                 ROMWRSR(WRDI);                          // ROM SR Write Disable
  150.                
  151.                 PORTD ^= (1<<PIND5);
  152.                 _delay_ms(2000);
  153.                
  154.         }
  155.        
  156. }
(#) kurosaki válasza Fizikus hozzászólására (») Jan 16, 2013 /
 
Szia köszi a választ és hol tudok beszerezni ilyen IC et?(MSGEQ7)?

A projektem egy mély/bassus ra reagálo led/ fénycső ami megvan építve azaz vezérlés (maga a program hogy hány led vagy épp Fénycső legyen aktív) aza problémám perpill hogy ha Keverőpultal nyomom akkor van elég fesz de amint telefon/számítógépre csatlakoztatom nincs elég kakaója hogy meghajtsa szoval kell egy Előerősitő is ami fixen 50% al megemeli a bejövö jelet.plusz egy Bassus Ampfiler vagy micsoda hogy a mélyre reagáljon. remélem érthető.

ez a MSGEQ7 IC mit is tud pontosan?
(#) Sick-Bastard válasza Sick-Bastard hozzászólására (») Jan 16, 2013 /
 
Egy érdekes jelenséget tapasztaltam.

A while(1) függvényben a SPIWR(0xFF) és az utána következő SPIWR(0x11) első alkalommal szépen lefutnak, de második alkalomtól kezdve mintha el lenne csúszva 1 bit-tel az LSB irányába, tehát a 8. bitet nem jeleníti meg.

Ez mitől lehet?

Talán a gond a többszörös SPI inicializálással van?
(#) huba válasza kurosaki hozzászólására (») Jan 16, 2013 /
 
Ami neked kéne az egy FFT(gyors furier transzformáció) program az avr-be. Kell mintavételezni a bejövő hangjelet és abbol kiszámítani a frekvenciakomponeseket. Egy avr elbírja.
Én annó Ezt építettem. Itt az avr talán mega48 számolja a fouriret egy másik végzi a kijelző multiplexelést. A neten fellelhető függvénykönyvtár számára. Programot nem tudok szolgáltatni, mert azóta sajnos elveszett.
A hozzászólás módosítva: Jan 16, 2013
(#) kurosaki válasza huba hozzászólására (») Jan 16, 2013 /
 
Ezt én mint kezdö meg tudom csinálni? vagy van neten fellelhetö Bassushoz is "example"kod?
(#) huba válasza kurosaki hozzászólására (») Jan 16, 2013 /
 
Mindenképpen jelentősen bonyolultabb mint összedrótozni egy analóg szűrőt. Szét kell nézni hátha van kész megoldás. Nemtudom mennyire vagy kezdő én akkor még az voltam, sok elszántsággal és bíbelődéssel kb egy hónap alatt összehoztam.
(#) kurosaki válasza huba hozzászólására (») Jan 16, 2013 /
 
hááát nekem legegyszerübb megoldás kéne és az AVR mégjobb lenne ha megtudnám oldani de nincs kedvem sokat cseszekedni vele :// ráadásul mintavételezéshez sincs eszközöm stb. de utána nézek csak sajna nem tudom hogy az AVR nek hogyan tudom megadni hogy ne sorba csinalja a folyamatokat hanem parhuzamosan mert jelenleg 3 állás van ami közt váltok 0-1-2 enyi mást beteszek akkor nem fut le.
Ezekre szükség lehet! - HESTORE.HU

25LC320
74HC595 SMD
LIYV-1x0.14-GN-HELU
JT308-13.56M/KB
FSDA-25-20
Következő: »»   508 / 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