1024 ნიმუში FFT სპექტრის ანალიზატორი Atmega– ის გამოყენებით 1284: 9 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

ეს შედარებით მარტივი გაკვეთილი (ამ საკითხის სირთულის გათვალისწინებით) გაჩვენებთ თუ როგორ შეგიძლიათ გააკეთოთ ძალიან მარტივი 1024 ნიმუშის სპექტრის ანალიზატორი არდუინოს ტიპის დაფის (1284 ვიწრო) და სერიული პლოტერის გამოყენებით. ნებისმიერი სახის Arduino თავსებადი დაფა გააკეთებს, მაგრამ რაც უფრო მეტი RAM აქვს, საუკეთესო სიხშირის გარჩევადობას მიიღებთ. მას დასჭირდება 8 კბ -ზე მეტი ოპერატიული მეხსიერება, რომ გამოთვალოს FFT 1024 ნიმუშით.

სპექტრის ანალიზი გამოიყენება სიგნალის ძირითადი სიხშირის კომპონენტების დასადგენად. ბევრი ბგერა (ისევე როგორც მუსიკალური ინსტრუმენტის მიერ წარმოქმნილი) შედგება ფუნდამენტური სიხშირისა და ზოგიერთი ჰარმონიკისგან, რომელსაც აქვს სიხშირე, რომელიც არის ფუნდამენტური სიხშირის მთელი რიცხვი. სპექტრის ანალიზატორი გაჩვენებთ ყველა ამ სპექტრულ კომპონენტს.

შეიძლება დაგჭირდეთ გამოიყენოთ ეს კონფიგურაცია, როგორც სიხშირის მრიცხველი ან ნებისმიერი სახის სიგნალის შესამოწმებლად, რომლითაც ეჭვი გაქვთ, რომ თქვენს ელექტრონულ წრეში რაღაც ხმაური შემოდის.

აქ ჩვენ ყურადღებას გავამახვილებთ პროგრამული უზრუნველყოფის ნაწილზე. თუ გსურთ მუდმივი მიკროსქემის გაკეთება კონკრეტული პროგრამისთვის, დაგჭირდებათ სიგნალის გაძლიერება და გაფილტვრა. ეს წინასწარი განპირობება მთლიანად დამოკიდებულია იმ სიგნალზე, რომლის შესწავლაც გსურთ, მისი ამპლიტუდის, წინაღობის, მაქსიმალური სიხშირის და ა.შ. მიხედვით … შეგიძლიათ შეამოწმოთ

ნაბიჯი 1: ბიბლიოთეკის დაყენება

ჩვენ ვიყენებთ ენდრიკე კონდესის მიერ დაწერილ ArduinoFFT ბიბლიოთეკას. ვინაიდან ჩვენ გვსურს მაქსიმალურად დავზოგოთ ოპერატიული მეხსიერება, ჩვენ გამოვიყენებთ ამ საცავის განავითარებელ ფილიალს, რომელიც საშუალებას გვაძლევს float მონაცემთა ტიპი (ორმაგი ნაცვლად) გამოვიყენოთ შერჩეული და გამოთვლილი მონაცემების შესანახად. ასე რომ, ჩვენ ხელით უნდა დავაინსტალიროთ. არ ინერვიულოთ, უბრალოდ გადმოწერეთ არქივი და გააუქმეთ იგი თქვენს Arduino ბიბლიოთეკის საქაღალდეში (მაგალითად, Windows 10 -ის ნაგულისხმევი კონფიგურაციით: C: / Users / _your_user_name_ / Documents / Arduino / ბიბლიოთეკები)

თქვენ შეგიძლიათ შეამოწმოთ, რომ ბიბლიოთეკა სწორად არის დაინსტალირებული მოწოდებული ერთ -ერთი მაგალითის შედგენით, როგორიცაა "FFT_01.ino".

ნაბიჯი 2: ფურიეს ტრანსფორმაცია და FFT კონცეფციები

გაფრთხილება: თუ ვერ იტანთ რაიმე მათემატიკურ აღნიშვნას, შეიძლება გინდათ გამოტოვოთ ნაბიჯი 3.

სიხშირის სპექტრი მიიღება სწრაფი ფურიეს ტრანსფორმაციის ალგორითმის საშუალებით. FFT არის ციფრული განხორციელება, რომელიც აახლოებს ფურიეს ტრანსფორმაციის მათემატიკურ კონცეფციას. ამ კონცეფციის შემდეგ, როდესაც მიიღებთ სიგნალის ევოლუციას დროის ღერძის შემდეგ, შეგიძლიათ იცოდეთ მისი წარმოდგენა სიხშირის დომენში, რომელიც შედგება რთული (რეალური + წარმოსახვითი) მნიშვნელობებისაგან. კონცეფცია ორმხრივია, ასე რომ, როდესაც იცით სიხშირის დომენის წარმოდგენა, შეგიძლიათ გადააკეთოთ იგი დროის დომენში და მიიღოთ სიგნალი ზუსტად ისე, როგორც გარდაქმნის წინ.

მაგრამ რას ვაპირებთ გამოთვლილი კომპლექსური მნიშვნელობების ნაკრებთან დროის დომენში? ისე, უმეტესობა ინჟინრებს დარჩება. ჩვენთვის ჩვენ მოვუწოდებთ სხვა ალგორითმს, რომელიც გარდაქმნის ამ კომპლექსურ მნიშვნელობებს სპექტრული სიმკვრივის მონაცემებად: ეს არის სიდიდის (= ინტენსივობის) მნიშვნელობა, რომელიც დაკავშირებულია სიხშირის თითოეულ ჯგუფთან. სიხშირული დიაპაზონის რაოდენობა იგივე იქნება, რაც ნიმუშების რაოდენობა.

თქვენ რა თქმა უნდა იცნობთ ექვალაიზერის კონცეფციას, როგორიც ეს არის 1980 – იან წლებში Graphic EQ– ით. ჩვენ მივიღებთ იგივე შედეგებს, მაგრამ 1024 ზოლით 16 -ის ნაცვლად და ბევრად უფრო ინტენსივობის გარჩევადობით. როდესაც ექვალაიზერი იძლევა მუსიკის გლობალურ ხედვას, შესანიშნავი სპექტრალური ანალიზი საშუალებას იძლევა ზუსტად გამოვთვალოთ თითოეული 1024 ჯგუფის ინტენსივობა.

იდეალური იდეაა, მაგრამ:

1. ვინაიდან FFT არის ფურიეს გარდაქმნის ციფრული ვერსია, ის უახლოვდება ციფრულ სიგნალს და კარგავს ინფორმაციას. ასე რომ, მკაცრად რომ ვთქვათ, FFT– ის შედეგი, თუ გადაკეთდება უკან შემობრუნებული FFT ალგორითმით, არ მისცემს ზუსტად თავდაპირველ სიგნალს.
2. ასევე თეორია ითვალისწინებს სიგნალს, რომელიც არ არის სასრული, მაგრამ ეს არის მუდმივი მუდმივი სიგნალი. ვინაიდან ჩვენ მას მხოლოდ გარკვეული პერიოდის განმავლობაში გავაანალიზებთ (ანუ ნიმუშები), კიდევ რამდენიმე შეცდომა დაინერგება.
3. დაბოლოს, ანალოგურ ციფრულ კონვერსიაზე რეზოლუცია გავლენას მოახდენს გამოთვლილი ღირებულებების ხარისხზე.

პრაქტიკაში

1) შერჩევის სიხშირე (აღინიშნება fs)

ჩვენ ვიღებთ სიგნალს, ანუ გავზომოთ მისი ამპლიტუდა, ყოველ 1/წმ წამში. fs არის შერჩევის სიხშირე. მაგალითად, თუ ჩვენ ვიღებთ ნიმუშს 8 KHz– ზე, ADC (ანალოგი ციფრული გადამყვანი), რომელიც ჩიპზეა, უზრუნველყოფს გაზომვას ყოველ 1/8000 წამში.

2) ნიმუშების რაოდენობა (აღნიშნულია N ან ნიმუშები კოდში)

ვინაიდან ჩვენ უნდა მივიღოთ ყველა მნიშვნელობა FFT– ის გაშვებამდე, ჩვენ მოგვიწევს მათი შენახვა და, შესაბამისად, ჩვენ შევზღუდავთ ნიმუშების რაოდენობას. FFT ალგორითმს სჭირდება რიგი ნიმუშები, რომელთა სიმძლავრეა 2. რაც უფრო მეტი ნიმუში გვაქვს, მით უკეთესი, მაგრამ ამას ბევრი მეხსიერება სჭირდება, მით უფრო, რომ ჩვენ ასევე დაგვჭირდება გარდაქმნილი მონაცემების შესანახად, ეს არის კომპლექსური მნიშვნელობები. Arduino FFT ბიბლიოთეკა ზოგავს ადგილს მისი გამოყენებით

• ერთი მასივი სახელად "vReal" შენახული შერჩეული მონაცემების შესანახად და შემდგომ ტრანსფორმირებული მონაცემების რეალური ნაწილის შესანახად
• ერთი მასივი სახელად "vImag" შეინახავს გარდაქმნილი მონაცემების წარმოსახვით ნაწილს

ოპერატიული მეხსიერების საჭირო რაოდენობა არის 2 (მასივები) * 32 (ბიტი) * N (ნიმუშები).

ასე რომ, ჩვენს Atmega1284– ში, რომელსაც აქვს 16 კბ ოპერატიული მეხსიერება, ჩვენ შევინახავთ მაქსიმუმ N = 16000*8 /64 = 2000 მნიშვნელობას. ვინაიდან მნიშვნელობების რაოდენობა უნდა იყოს ძალა 2, ჩვენ შევინახავთ მაქსიმუმ 1024 მნიშვნელობას.

3) სიხშირის გარჩევადობა

FFT გამოითვლის ღირებულებებს იმდენი სიხშირის დიაპაზონისთვის, რამდენიც ნიმუშების რაოდენობა. ეს ზოლები იქნება 0 HZ– დან შერჩევის სიხშირემდე (fs). ამრიგად, სიხშირის გარჩევადობაა:

Fresolution = fs / N

რეზოლუცია უკეთესია, როდესაც დაბალია. ასე რომ უკეთესი რეზოლუციისთვის (ქვედა) ჩვენ გვინდა:

• მეტი ნიმუში და/ან
• ქვედა ფს

მაგრამ…

4) მინიმალური ფს

ვინაიდან ჩვენ გვინდა ვნახოთ ბევრი სიხშირე, ზოგი მათგანი ბევრად აღემატება "ფუნდამენტურ სიხშირეს", ჩვენ არ შეგვიძლია fs ძალიან დაბალ დონეზე დავაყენოთ. ფაქტობრივად, არსებობს ნიკვისტ -შენონის შერჩევის თეორემა, რომელიც გვაიძულებს აღების სიხშირე ორჯერ აღემატებოდეს მაქსიმალურ სიხშირეს, რომლის შემოწმებაც ჩვენ გვსურს.

მაგალითად, თუ გვსურს გავაანალიზოთ 0 Hz– დან ყველა სპექტრი და ვთქვათ 15 KHz, რაც არის მაქსიმალური სიხშირე, რაც ადამიანებს შეუძლიათ ნათლად მოისმინონ, ჩვენ უნდა დავნიშნოთ შერჩევის სიხშირე 30 KHz– ზე. სინამდვილეში ელექტრონიკოსები ხშირად ადგენენ მას 2.5 (ან თუნდაც 2.52) * მაქსიმალური სიხშირით. ამ მაგალითში ეს იქნება 2.5 * 15 KHz = 37.5 KHz. პროფესიონალურ აუდიოში შერჩევის ჩვეულებრივი სიხშირეებია 44.1 KHz (აუდიო CD ჩაწერა), 48 KHz და სხვა.

დასკვნა:

1 -დან 4 პუნქტამდე მივყავართ: ჩვენ გვსურს რაც შეიძლება მეტი ნიმუშის გამოყენება. ჩვენს შემთხვევაში 16 კბ ოპერატიული მეხსიერების მოწყობილობით ჩვენ განვიხილავთ 1024 ნიმუშს. ჩვენ გვსურს რაც შეიძლება დაბალი შერჩევის სიხშირის აღება, რამდენადაც ის საკმარისად მაღალია იმისათვის, რომ გავაანალიზოთ ყველაზე მაღალი სიხშირე, რომელსაც ჩვენ ველოდებით ჩვენს სიგნალში (2.5 * ეს სიხშირე, სულ მცირე).

ნაბიჯი 3: სიგნალის სიმულაცია

ჩვენი პირველი მცდელობისას, ჩვენ ოდნავ შევცვლით ბიბლიოთეკაში მოცემულ TFT_01.ino მაგალითს, რათა გავაანალიზოთ სიგნალი

• ფუნდამენტური სიხშირე, 440 Hz (მუსიკალური A)
• მე -3 ჰარმონია ფუნდამენტური ძალის ნახევარზე ("-3 დბ")
• მე -5 ჰარმონიული ფუნდამენტური ძალის 1/4-ზე ("-6 დბ)

თქვენ ხედავთ სურათზე ზემოთ სიგნალს. ის მართლაც ძალიან ჰგავს ნამდვილ სიგნალს, რომლის ხილვაც ზოგჯერ შეიძლება ოსცილოსკოპზე (მე მას "ბეტმენს" ვუწოდებ) იმ სიტუაციაში, როდესაც ხდება სინუსოიდალური სიგნალის დაჭრა.

ნაბიჯი 4: სიმულაციური სიგნალის ანალიზი - კოდირება

0) ჩართეთ ბიბლიოთეკა

#მოიცავს "arduinoFFT.h"

1) განმარტებები

დეკლარაციების განყოფილებებში ჩვენ გვაქვს

const byte adcPin = 0; // A0

const uint16_t ნიმუშები = 1024; // ეს მნიშვნელობა ყოველთვის უნდა იყოს სიმძლავრე 2 const uint16_t samplingFrequency = 8000; // იმოქმედებს ტაიმერის მაქსიმალურ მნიშვნელობაზე timer_setup () SYSCLOCK/8/sampling სიხშირე უნდა იყოს მთელი რიცხვი

ვინაიდან სიგნალს აქვს მე -5 ჰარმონიკა (ამ ჰარმონიის სიხშირე = 5 * 440 = 2200 ჰერცი) ჩვენ უნდა დავაყენოთ შერჩევის სიხშირე 2.5 * 2200 = 5500 ჰერცზე მაღლა. აქ ავირჩიე 8000 ჰერცი.

ჩვენ ასევე ვაცხადებთ მასივებს, სადაც ჩვენ ვინახავთ ნედლ და გამოთვლილ მონაცემებს

float vReal [ნიმუშები];

float vImag [ნიმუშები];

2) ინსტალაცია

ჩვენ ვქმნით ArduinoFFT ობიექტს. ArduinoFFT- ის dev ვერსია იყენებს შაბლონს, ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ float ან ორმაგი მონაცემთა ტიპი. Float (32 ბიტი) საკმარისია ჩვენი პროგრამის საერთო სიზუსტის გათვალისწინებით.

ArduinoFFT FFT = ArduinoFFT (vReal, vImag, ნიმუშები, შერჩევის სიხშირე);

3) სიგნალის სიმულაცია vReal მასივის შევსებით, იმის ნაცვლად, რომ ის ADC მნიშვნელობებით იყოს დასახლებული.

მარყუჟის დასაწყისში ჩვენ ვავსებთ vReal მასივს:

float cycles = ((((ნიმუშები) * სიგნალის სიხშირე) / შერჩევის სიხშირე); // სიგნალის ციკლის რაოდენობა, რომელსაც წაიკითხავს შერჩევა

for (uint16_t i = 0; i <ნიმუშები; i ++) {vReal = float ((ამპლიტუდა * (ცოდვა ((i * (TWO_PI * ციკლები)) / ნიმუშები)))); / * მონაცემების აგება დადებითი და უარყოფითი მნიშვნელობები */ v რეალური += float ((ამპლიტუდა * (ცოდვა ((3 * i * (TWO_PI * ციკლები))/ ნიმუშები)))/ 2.0);/ * მონაცემების შექმნა დადებითი და უარყოფითი მნიშვნელობებით */ vReal += float ((ამპლიტუდა * (ცოდვა ((5 * i * (TWO_PI * ციკლები)) / ნიმუშები))) / 4.0); / * მონაცემების შექმნა დადებითი და უარყოფითი მნიშვნელობებით * / vImag = 0.0; // წარმოსახვითი ნაწილი უნდა იყოს ნულოვანი მარყუჟის შემთხვევაში, რათა თავიდან ავიცილოთ არასწორი გათვლები და გადავსება}

ჩვენ დავამატებთ ფუნდამენტური ტალღის და ორი ჰარმონიკის ციფრულ გაფორმებას ნაკლები ამპლიტუდით. ვიდრე ჩვენ წარმოვადგინეთ წარმოსახვითი მასივი ნულებით. ვინაიდან ეს მასივი დასახლებულია FFT ალგორითმით, ჩვენ უნდა გავწმინდოთ იგი ყოველ ახალ გამოთვლამდე.

4) FFT გამოთვლა

შემდეგ ჩვენ გამოვთვლით FFT და სპექტრულ სიმკვრივეს

FFT.windowing (FFTWindow:: Hamming, FFTDirection:: Forward);

FFT.compute (FFTD მიმართულება:: წინ); / * გამოთვალეთ FFT */ FFT.complexToMagnitude (); / * გამოთვალეთ სიდიდეები */

FFT.windowing (…) ოპერაცია ცვლის ნედლეულ მონაცემებს, რადგან ჩვენ FFT- ს ვუშვებთ შეზღუდული რაოდენობის ნიმუშებზე. პირველი და ბოლო ნიმუშები წარმოადგენენ უწყვეტობას (მათ მხარეს „არაფერია“). ეს არის შეცდომის წყარო. ოპერაცია "ფანჯარა" ამცირებს ამ შეცდომას.

FFT.compute (…) მიმართულებით "წინ" ითვლის ტრანსფორმაციას დროის დომენიდან სიხშირის დომენში.

შემდეგ ჩვენ გამოვთვლით სიდიდის (ანუ ინტენსივობის) მნიშვნელობებს სიხშირის თითოეული ზოლისთვის. VReal მასივი ახლა სავსეა სიდიდის მნიშვნელობებით.

5) სერიული პლოტერის ნახაზი

მოდით დავბეჭდოთ მნიშვნელობები სერიულ პლოტერზე ფუნქციის გამოძახებით printVector (…)

PrintVector (vReal, (ნიმუშები >> 1), SCL_FREQUENCY);

ეს არის ზოგადი ფუნქცია, რომელიც საშუალებას იძლევა მონაცემების დაბეჭდვა დროის ღერძით ან სიხშირის ღერძით.

ჩვენ ასევე ვბეჭდავთ იმ ჯგუფის სიხშირეს, რომელსაც აქვს უმაღლესი სიდიდის მნიშვნელობა

float x = FFT.majorPeak ();

Serial.print ("f0 ="); სერიული. ბეჭდვა (x, 6); Serial.println ("Hz");

ნაბიჯი 5: სიმულაციური სიგნალის ანალიზი - შედეგები

ჩვენ ვხედავთ ფუნდამენტური სიხშირის (f0), მე -3 და მე -5 ჰარმონიკის შესაბამის 3 პიკს, f0 სიდიდის ნახევარი და 1/4, როგორც მოსალოდნელი იყო. ჩვენ შეგვიძლია წავიკითხოთ ფანჯრის ზედა ნაწილში f0 = 440.430114 Hz. ეს მნიშვნელობა არ არის ზუსტად 440 ჰერცი, ყველა ზემოთ ჩამოთვლილი მიზეზის გამო, მაგრამ ის ძალიან ახლოს არის რეალურ მნიშვნელობასთან. ნამდვილად არ იყო საჭირო ამდენი უმნიშვნელო ათწილადის ჩვენება.

ნაბიჯი 6: რეალური სიგნალის ანალიზი - ADC- ის გაყვანილობა

ვინაიდან ჩვენ ვიცით როგორ გავაგრძელოთ თეორიულად, ჩვენ გვსურს გავაანალიზოთ რეალური სიგნალი.

გაყვანილობა ძალიან მარტივია. შეაერთეთ საფუძველი ერთმანეთთან და სიგნალის ხაზი თქვენი დაფის A0 პინთან სერიული რეზისტორის საშუალებით, 1 KOhm– დან 10 KOhm– ის ღირებულებით.

ეს სერიის რეზისტორი დაიცავს ანალოგურ შეყვანას და თავიდან აიცილებს ზარს. ის მაქსიმალურად მაღალი უნდა იყოს ზარის თავიდან ასაცილებლად და რაც შეიძლება დაბალი, რათა უზრუნველყოს საკმარისი დენი ADC– ის სწრაფად დასატენად. მიმართეთ MCU მონაცემთა ცხრილს, რომ იცოდეთ ADC შეყვანისას სიგნალის სავარაუდო წინაღობა.

ამ დემოზე მე გამოვიყენე ფუნქციის გენერატორი 440 ჰც სიხშირის და ამპლიტუდის დაახლოებით 5 ვოლტის სინუსოიალური სიგნალის შესანახად (უმჯობესია, თუ ამპლიტუდა 3 -დან 5 ვოლტამდეა, ასე რომ ADC გამოიყენება სრული მასშტაბით), 1.2 KOhm რეზისტორის საშუალებით. რა

ნაბიჯი 7: რეალური სიგნალის ანალიზი - კოდირება

0) ჩართეთ ბიბლიოთეკა

#მოიცავს "arduinoFFT.h"

1) დეკლარაციები და ინსტანციაცია

დეკლარაციის განყოფილებაში ჩვენ განვსაზღვრავთ ADC შეყვანის (A0), ნიმუშების რაოდენობას და შერჩევის სიხშირეს, წინა მაგალითის მსგავსად.

const byte adcPin = 0; // A0

const uint16_t ნიმუშები = 1024; // ეს მნიშვნელობა ყოველთვის უნდა იყოს სიმძლავრე 2 const uint16_t samplingFrequency = 8000; // იმოქმედებს ტაიმერის მაქსიმალურ მნიშვნელობაზე timer_setup () SYSCLOCK/8/sampling სიხშირე უნდა იყოს მთელი რიცხვი

ჩვენ ვქმნით ArduinoFFT ობიექტს

ArduinoFFT FFT = ArduinoFFT (vReal, vImag, ნიმუშები, შერჩევის სიხშირე);

2) ტაიმერი და ADC კონფიგურაცია

ჩვენ ვაყენებთ ტაიმერს 1 ისე, რომ ის ციკლდება შერჩევის სიხშირეზე (8 KHz) და ზრდის შეფერხებას გამომავალი შედარებისას.

void timer_setup () {

// გადატვირთეთ ტაიმერი 1 TCCR1A = 0; TCCR1B = 0; TCNT1 = 0; TCCR1B = ბიტი (CS11) | ბიტი (WGM12); // CTC, წინასწარი გადამცემი 8 TIMSK1 = ბიტი (OCIE1B); OCR1A = ((16000000 /8) / შერჩევის სიხშირე) -1; }

და დააყენეთ ADC ასე

• იყენებს A0 შეყვანის სახით
• ავტომატურად იწყებს თითოეულ ტაიმერს 1 გამომავალი შეადარეთ მატჩი B
• წარმოქმნის შეფერხებას კონვერტაციის დასრულების შემდეგ

ADC საათი დაყენებულია 1 MHz– ზე, სისტემის საათის (16 MHz) 16 – ით გამოაქვეყნებით, ვინაიდან ყოველი კონვერტაციისთვის საჭიროა დაახლოებით 13 საათი სრული მასშტაბით, გარდაქმნის მიღწევა შესაძლებელია 1/13 = 0.076 MHz = 76 KHz სიხშირით. შერჩევის სიხშირე უნდა იყოს 76 კჰც -ზე მნიშვნელოვნად დაბალი, რათა ADC- ს ჰქონდეს დრო მონაცემების აღებისათვის. (ჩვენ ავირჩიეთ fs = 8 KHz).

void adc_setup () {

ADCSRA = ბიტი (ADEN) | ბიტი (ADIE) | ბიტი (ADIF); // ჩართეთ ADC, გსურთ შეწყვიტოთ დასრულების შემდეგ ADCSRA | = ბიტი (ADPS2); // გადამცემი 16 ADMUX = ბიტი (REFS0) | (adcPin & 7); // ADC შეყვანის დაყენება ADCSRB = ბიტი (ADTS0) | ბიტი (ADTS2); // ტაიმერი/მრიცხველი 1 შეადარეთ მატჩი B გამომწვევი წყარო ADCSRA | = ბიტი (ADATE); // ჩართეთ ავტომატური ჩართვა}

ჩვენ ვაცხადებთ შეწყვეტის დამმუშავებელს, რომელიც დარეკილი იქნება ყოველი ADC კონვერტაციის შემდეგ vReal მასივში კონვერტირებული მონაცემების შესანახად და შეწყვეტის გასასუფთავებლად

// ADC სრული ISR

ISR (ADC_vect) {vReal [resultNumber ++] = ADC; თუ (resultNumber == ნიმუშები) {ADCSRA = 0; // გამორთეთ ADC}} EMPTY_INTERRUPT (TIMER1_COMPB_vect);

თქვენ შეგიძლიათ გქონდეთ ამომწურავი ახსნა ADC კონვერტაციის შესახებ Arduino– ზე (analogRead).

3) დაყენება

დაყენების ფუნქციაში ჩვენ ვასუფთავებთ წარმოსახვითი მონაცემების ცხრილს და ვიძახებთ ტაიმერს და ADC დაყენების ფუნქციებს

ნულოვანი I (); // ფუნქცია, რომელიც ადგენს 0 ყველა წარმოსახვით მონაცემს - განმარტებულია წინა ნაწილში

timer_setup (); adc_setup ();

3) მარყუჟი

FFT.dcRemoval (); // ამოიღეთ ამ სიგნალის DC კომპონენტი, რადგან ADC მითითებულია მიწაზე

FFT.windowing (FFTWindow:: Hamming, FFTDirection:: Forward); // მონაცემების აწონვა FFT.compute (FFTDirection:: Forward); // გამოთვალეთ FFT FFT.complexToMagnitude (); // გამოთვალეთ სიდიდეები // დაბეჭდეთ სპექტრი და ფუნდამენტური სიხშირე f0 PrintVector (vReal, (ნიმუშები >> 1), SCL_FREQUENCY); float x = FFT.majorPeak (); Serial.print ("f0 ="); სერიული. ბეჭდვა (x, 6); Serial.println ("Hz");

ჩვენ ვშლით DC კომპონენტს, რადგან ADC მითითებულია მიწაზე და სიგნალი კონცენტრირებულია დაახლოებით 2.5 ვოლტზე დაახლოებით.

შემდეგ ჩვენ ვიანგარიშებთ მონაცემებს, როგორც ეს განმარტებულია წინა მაგალითში.

ნაბიჯი 8: რეალური სიგნალის ანალიზი - შედეგები

მართლაც, ჩვენ ვხედავთ მხოლოდ ერთ სიხშირეს ამ უბრალო სიგნალში. გამოთვლილი ფუნდამენტური სიხშირეა 440.118194 ჰერცი. აქ კვლავ მნიშვნელობა არის რეალური სიხშირის ძალიან ახლო მიახლოება.

ნაბიჯი 9: რაც შეეხება მოწყვეტილ სინუსოიდულ სიგნალს?

ახლა მოდით ოდნავ გადავიტანოთ ADC სიგნალის ამპლიტუდის გაზრდით 5 ვოლტზე მაღლა, ასე რომ ის მოწყვეტილია. ძალიან ნუ აწვალებთ, რომ არ გაანადგუროთ ADC შეყვანა!

ჩვენ ვხედავთ რაღაც ჰარმონიის გამოჩენას. სიგნალის დაჭერა ქმნის მაღალი სიხშირის კომპონენტებს.

თქვენ ნახეთ FFT ანალიზის საფუძვლები არდუინოს დაფაზე. ახლა თქვენ შეგიძლიათ სცადოთ შეცვალოთ შერჩევის სიხშირე, ნიმუშების რაოდენობა და ფანჯრის პარამეტრი. ბიბლიოთეკა ასევე ამატებს ზოგიერთ პარამეტრს, რათა გამოვთვალოთ FFT უფრო სწრაფად და ნაკლები სიზუსტით. თქვენ შეამჩნევთ, რომ თუ შერჩევის სიხშირეს ძალიან დაბალს დააყენებთ, გამოთვლილი სიდიდეები სპექტრალური დაკეცილების გამო სრულიად მცდარი გამოჩნდება.