როგორ გააკეთოთ და გამოსცადოთ უკეთესი DAC ESP32– ით: 5 ნაბიჯი

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

ESP32– ს აქვს 2 8 ბიტიანი ციფრული ანალოგური გადამყვანი (DAC). ეს DAC- ები გვაძლევს საშუალებას წარმოქმნათ თვითნებური ძაბვები გარკვეულ დიაპაზონში (0-3.3V) 8 ბიტიანი გარჩევადობით. ამ ინსტრუქციაში, მე გაჩვენებთ თუ როგორ უნდა ავაშენოთ DAC და დავახასიათოთ მისი შესრულება, ასევე შევადარო ESP32 DAC– ს. შესრულების მაჩვენებლები მე შევხედავ მოიცავს

• Ხმაურის დონე
• გამტარუნარიანობა
• ინტეგრალური არაწრფილობა
• დიფერენციალური არაწრფილობა

ამ მაჩვენებლების შესამოწმებლად გამოვიყენებ ADS1115.

მნიშვნელოვანია აღინიშნოს, რომ ყველა ამ ინდიკატორის შეფასება იქნება ისეთივე ზუსტი, როგორც თქვენი საცნობარო მოწყობილობა (ამ შემთხვევაში ADS115). მაგალითად, ADS115– ს არ აქვს 16 ბიტიანი სიზუსტე, როდესაც საქმე ეხება ძაბვის გადატვირთვას და მომატებას. ეს შეცდომები შეიძლება იყოს 0.1%-მდე. მრავალი სისტემისთვის, ეს შეცდომები შეიძლება იგნორირებული იყოს, როდესაც აბსოლუტური სიზუსტე შეზღუდულია.

მარაგები

• ADS1115
• ESP32 დაფა
• პურის დაფა
• ჯუმბერის მავთულები
• 5 kOhm რეზისტორი
• 1 მიკრო-ფარადის კერამიკული კონდენსატორი

ნაბიჯი 1: პურის დაფის დაგება

მიამაგრეთ შემდეგი ქინძისთავები

ESP32- სა და ADS1115- ს შორის

3v3 VDD

GND GND

GPIO22 SCL

GPIO21 SDA

ADS1115– ზე

ADDR GND (ADS115)

DAC- ის დამზადება

DAC– ის შექმნის მრავალი გზა არსებობს. უმარტივესი არის დაბალი გამავლობის გაფილტვრა PWM სიგნალით რეზისტორით და კონდენსატორით. შემეძლო აქ დაემატა op-amp როგორც ბუფერი, მაგრამ მინდოდა ყველაფერი მარტივი ყოფილიყო. ეს დიზაინი მარტივი და იაფია ნებისმიერი მიკროკონტროლერის გამოყენებით, რომელიც მხარს უჭერს PWM. მე არ ვაპირებ დიზაინის თეორიის გავლას აქ (google PWM DAC).

უბრალოდ დააკავშირეთ GPIO255 KOhm რეზისტორი 1 microFarad Capacitor gnd

ახლა დააკავშირეთ ჯუმბერის მავთული იმ წერტილიდან, სადაც რეზისტორი ხვდება კონდენსატორს A011– ზე ADS115– ზე.

ნაბიჯი 2: შეაფასეთ სიგნალი ხმაურის დონეზე

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

DAC- ის დიზაინის გამო, ხმაური იქნება ყველაზე დიდი, როდესაც PWM სიგნალი იქნება 50% სამუშაო ციკლზე. ამიტომ, ეს არის ის, სადაც ჩვენ შევაფასებთ მას. ჩვენ ასევე შევაფასებთ ESP32 სიგნალის იმავე დონეზე. ჩვენ ასევე გავფილტროთ ESP32 DAC იგივე დაბალი გამავლობის ფილტრით, რათა გავზომოთ შესადარებელი.

ჩემთვის გამომავალი ნათელია. PWM დიზაინს ჰქონდა> 6dB უკეთესი SNR (ეს 2 -ჯერ უკეთესი). აშკარა გამარჯვება ახალი DAC– სთვის. ერთი უმნიშვნელო დაბნეულობა ის არის, რომ არის ADC- ში ჩაშენებული ფილტრები, რომლებიც უდავოდ აძლიერებენ SNR- ს. ასე რომ, აბსოლუტური მნიშვნელობების ინტერპრეტაცია შეიძლება რთული იყოს. მე რომ გამოვიყენო მეორე რიგის ფილტრი, ეს ასე არ იქნება.

ყოველ შემთხვევაში კოდი არის ქვემოთ

#ჩართეთ

#ჩართეთ Adafruit_ADS1115 რეკლამა; // adafruit ბიბლიოთეკა adc int16_t adc0; // void setup (void) {Serial.begin (115200); // სერიული რეკლამების დაწყება. SetGain (GAIN_TWO); // 2x მომატება +/- 2.048V 1 ბიტი = 0.0625mV რეკლამა. დაწყება (); // დაიწყოს adc float M = 0; // საწყისი საშუალო float Mp = 0; // previouos ნიშნავს float S = 0; // საწყისი Variance float Sp = 0; // წინა ვარიაცია const int reps = 500; // გამეორებების რაოდენობა int n = 256; // ნიმუშების რაოდენობა ledcSetup (0, 25000, 8); // დააყენეთ pwm frequecny = 25000 Hz 8 ბიტიანი გარჩევადობით ledcAttachPin (25, 0); // დააყენეთ pwm პინზე 25 ledcWrite (0, 128); // დააყენეთ ნახევარი სამუშაო ციკლის (ყველაზე დიდი ხმაური) დაყოვნება (3000); // დაელოდეთ დასახლების დროს float snrPWM [გამეორება]; // მასივი snrs PWM float snrDAC [reps]; // მასივის snrs DAC for (int i = 0; i <reps; i ++) {// loope over repititions for (int k = 1; k <(n+1); k ++) {// loope over samples adc0 = ads.readADC_SingleEnded (0); // მიიღეთ კითხვა M = Mp + (adc0 - Mp) / k; // გამოთვალეთ მოძრავი საშუალო Mp = M; // დააყენეთ წინა საშუალო S = Sp + (adc0 - Mp) * (adc0 - M); // გამოთვალეთ მოძრავი ვარიაცია Sp = S; // დააყენეთ წინა ვარიაცია} // snr dB snrPWM = 20 * log10 (3.3 / (sqrt (S / n) *.0625 *.001)); // მნიშვნელობების გადატვირთვა M = 0; Mp = 0; S = 0; Sp = 0; } ledcDetachPin (25); // გათიშეთ PWM პინიდან 25 dacWrite (25, 128); // ჩაწერეთ DAC დაგვიანებით (3000); // დაელოდეთ მოგვარებას (int i = 0; i <reps; i ++) {// იგივე PWM მარყუჟისთვის (int k = 1; k <(n+1); k ++) {adc0 = ads.readADC_SingleEnded (0); M = Mp + (adc0 - Mp) / k; Mp = M; S = Sp + (adc0 - Mp) * (adc0 - M); Sp = S; } snrDAC = 20 * log10 (3.3 / (sqrt (S / n) *.0625 *.001)); M = 0; Mp = 0; S = 0; Sp = 0; } // ჩაწერეთ SNRs ერთ გრაფაზე (int i = 1; i <reps; i ++) {Serial.print ("PWM_SNR (dB):"); Serial.print (snrPWM ); Serial.print (","); Serial.print ("ESP32_SNR (dB):"); Serial.println (snrDAC ); }} void loop (void) {}

ნაბიჯი 3: ინტეგრალური არაწრფილობა და დიფერენციალური არაწრფილობა

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

დიფერენციალური არაწრფივობა არის საზომი იმისა, თუ რამდენად განსხვავდება ძაბვის (ერთი კოდიდან მეორეზე) დაკვირვებული ცვლილება იმაზე, რაც მოსალოდნელია სწორი ხაზისგან.

აქ შედეგები მართლაც საინტერესო იყო. უპირველეს ყოვლისა, ორივეს აქვს 0.5lsb- ზე ნაკლები შეცდომა (8 ბიტიანი გარჩევადობით) რაც კარგია, მაგრამ PWM– ს აქვს ბევრად უკეთესი ინტეგრალური ხაზოვანი. ორივეს აქვს შესადარებელი დიფერენციალური არაწრფივობა, მაგრამ ESP32 DAC– ს აქვს ძალიან უცნაური ნაპერწკლები. უფრო მეტიც, PWM მეთოდს აქვს შეცდომების გარკვეული სტრუქტურა. არსებითად ის გადააჭარბებს და აქვეითებს სწორ ძაბვას მონაცვლეობით.

მე ეჭვი მაქვს, რომ ეს არის რაღაც უცნაური დამრგვალების შეცდომა, თუ როგორ იქმნება 8 ბიტიანი PWM სიგნალი ESP32– ზე.

ამის გამოსწორების ერთ -ერთი გზაა სწრაფი გადაადგილება ორ მიმდებარე კოდს შორის (მაგ. 128, 129) PWM– ით. ანალოგური დაბალგამტარი ფილტრით, შედეგად მიღებული შეცდომები საშუალოდ ნულამდე იქნება. მე ამის სიმულაცია გავაკეთე პროგრამულ უზრუნველყოფაში და მართლაც ყველა შეცდომა გაქრა. ახლა PWM მეთოდს აქვს წრფივი ხაზი, რომელიც ზუსტია 16 ბიტზე!

ვინც მონაცემთა გენერირების კოდია ქვემოთ. გამომავალი იქნება სერიულ მონიტორზე.csv ფორმატში. უბრალოდ დააკოპირეთ იგი ტექსტურ ფაილში შემდგომი დამუშავებისთვის.

#ჩართეთ

#მოიცავს Adafruit_ADS1115 რეკლამას; / * გამოიყენეთ ეს 16 ბიტიანი ვერსიისთვის */ int16_t adc0; void setup (void) {Serial.begin (115200); ads.setGain (GAIN_ONE); // 2x მომატება +/- 2.048V 1 ბიტი = 1mV 0.0625mV რეკლამა. დაწყება (); ledcSetup (0, 25000, 8); ledcAttachPin (25, 0); Serial.println ("მოსალოდნელი, დაკვირვებული"); ledcWrite (0, 2); დაგვიანება (3000); for (int i = 2; i <255; i ++) {ledcWrite (0, i); დაგვიანება (100); adc0 = ads.readADC_SingleEnded (0); float მოსალოდნელი = (i / 256.0 * 3.3) / 4.096 * 32767; სერიული. ბეჭდვა (მოსალოდნელი); Serial.print (","); Serial.println (adc0); }} void loop (void) {}

ნაბიჯი 4: გამტარუნარიანობა

მე ვაპირებ განვსაზღვრო გამტარუნარიანობა, როგორც სიხშირე, რომლის დროსაც DAC- ის გამომუშავება მცირდება 3dB– ით. ეს არის კონვენცია და, გარკვეულწილად, თვითნებური. მაგალითად, 6dB წერტილში, DAC კვლავ გამოსცემს სიგნალს, ის იქნება ~ 50% ამპლიტუდა.

ამის გასაზომად ჩვენ უბრალოდ გავდივართ სინუსის ტალღებს DAC– დან ADC– მდე მზარდი სიხშირით და ვზომავთ მათ სტანდარტულ გადახრას. გასაკვირი არ არის, რომ 3dB წერტილი არის 30Hz (1/(2*pi*5000*1e-6)).

ESP32– ს შეუძლია გააკეთოს 1 მეგა ნიმუში წამში. ეს არის პრაქტიკული გამარჯვება ESP32– ისთვის. მისი ამპლიტუდა საერთოდ არ იშლება 100 ჰც -იანი გამტარობის ტესტის რეგიონში.

ქვემოთ მოყვანილ კოდს შეუძლია შეამოწმოთ PWM DAC გამტარობა.

#ჩართეთ

#ჩართეთ Adafruit_ADS1115 რეკლამა; / * გამოიყენეთ ეს 16 ბიტიანი ვერსიისთვის */ int16_t adc0; int16_t adc1; void setup (void) {float M; float Mp = 0; float S = 0; float Sp = 0; Serial.begin (115200); ads.setGain (GAIN_ONE); // 1x მომატება +/- 4.096V 1 ბიტი = 2mV 0.125mV რეკლამა. დაწყება (); ledcSetup (0, 25000, 8); ledcAttachPin (25, 0); დაგვიანება (5000); Serial.println ("სიხშირე, ამპლიტუდა"); for (int i = 1; i <100; i ++) {unsigned long start = millis (); ხელმოუწერელი გრძელი T = მილი (); Sp = 0; S = 0; M = 0; Mp = 0; int k = 1; float ნორმა; ხოლო ((T - დაწყება) <1000) {int out = 24 * sin (2 * PI * i * (T - დაწყება) / 1000.0) + 128; ledcWrite (0, გარეთ); adc0 = ads.readADC_SingleEnded (0); M = Mp + (adc0 - Mp) / k; Mp = M; S = Sp + (adc0 - Mp) * (adc0 - M); Sp = S; T = მილი (); k ++; } if (i == 1) {norm = sqrt (S / k); } Serial.print (i); Serial.print (","); Serial.println (sqrt (S / k) / ნორმა, 3); k = 0; }} void loop (void) {}

და ეს კოდი შეამოწმებს ESP32 გამტარობას. დარწმუნდით, რომ ამოიღეთ კონდენსატორი, წინააღმდეგ შემთხვევაში ორივე მეთოდი ერთნაირი იქნება.

#ჩართეთ

#ჩართეთ Adafruit_ADS1115 რეკლამა; / * გამოიყენეთ ეს 16 ბიტიანი ვერსიისთვის */ int16_t adc0; int16_t adc1; void setup (void) {float M; float Mp = 0; float S = 0; float Sp = 0; Serial.begin (115200); ads.setGain (GAIN_ONE); // 1x მომატება +/- 4.096V 1 ბიტი = 2mV 0.125mV რეკლამა. დაწყება (); დაგვიანება (5000); Serial.println ("სიხშირე, ამპლიტუდა"); for (int i = 1; i <100; i ++) {unsigned long start = millis (); ხელმოუწერელი გრძელი T = millis (); Sp = 0; S = 0; M = 0; Mp = 0; int k = 1; float ნორმა; ხოლო ((T - დაწყება) <1000) {int out = 24 * sin (2 * PI * i * (T - დაწყება) / 1000.0) + 128; dacWrite (25, გარეთ); adc0 = ads.readADC_SingleEnded (0); M = Mp + (adc0 - Mp) / k; Mp = M; S = Sp + (adc0 - Mp) * (adc0 - M); Sp = S; T = მილი (); k ++; } if (i == 1) {norm = sqrt (S / k); } Serial.print (i); Serial.print (","); Serial.println (sqrt (S / k) / ნორმა, 3); k = 0; }} void loop (void) {}

ნაბიჯი 5: ფიქრების დახურვა

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

ასევე, მე ვფიქრობ, რომ აქ ღირს აღვნიშნო, რომ რადგანაც PWM გამომავალი ხმაური დაბალია, განსაკუთრებული ხაზგარეშეობით შესაძლებელი უნდა იყოს ბევრად მაღალი გარჩევადობის DAC- ის აგება PWM გამომავალით (შესაძლოა 16 ბიტიანი სიზუსტითაც კი). ამას გარკვეული სამუშაო დასჭირდება. მანამდე კი, გილოცავ!