Kā izveidot un pārbaudīt labāku DAC, izmantojot ESP32: 5 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:52

ESP32 ir 2 8 bitu digitālie analogie pārveidotāji (DAC). Šie DAC ļauj mums radīt patvaļīgu spriegumu noteiktā diapazonā (0–3,3 V) ar 8 bitu izšķirtspēju. Šajā pamācībā es jums parādīšu, kā izveidot DAC un raksturot tā veiktspēju, kā arī salīdzināt to ar ESP32 DAC. Darbības rādītāji, kurus aplūkošu, ietver

• Skaļuma līmenis
• Joslas platums
• Integrāla nelinearitāte
• Diferenciālā nelinearitāte

Lai pārbaudītu šos indeksus, es izmantošu ADS1115.

Ir svarīgi atzīmēt, ka visu šo rādītāju novērtējums būs tikpat precīzs kā jūsu atsauces ierīce (šajā gadījumā ADS115). Piemēram, ADS115 nav 16 bitu precizitātes attiecībā uz sprieguma nobīdi un pastiprinājumu. Šīs kļūdas var būt pat 0,1%. Daudzām sistēmām šīs kļūdas var ignorēt, ja absolūtā precizitāte rada ierobežotas bažas.

Piegādes

• ADS1115
• ESP32 valde
• maizes dēlis
• džemperu vadi
• 5 kOhm rezistors
• 1 mikro-Farad keramikas kondensators

1. darbība: maizes dēļa izkārtojums

Pievienojiet vadus šādām tapām

Starp ESP32 un ADS1115

3v3 VDD

GND GND

GPIO22 SCL

GPIO21 SDA

ADS1115

ADDR GND (ADS115)

DAC izveide

Ir daudz veidu, kā izveidot DAC. Vienkāršākais ir zemas caurlaides filtrēt PWM signālu ar rezistoru un kondensatoru. Es šeit būtu varējis pievienot op-amp kā buferi, bet gribēju, lai viss būtu vienkārši. Šis dizains ir vienkāršs un lēts, lai to īstenotu ar jebkuru mikrokontrolleri, kas atbalsta PWM. Es šeit neiešu cauri dizaina teorijai (google PWM DAC).

Vienkārši pievienojiet GPIO255 KOhm rezistoru 1 microFarad Capacitor gnd

Tagad pievienojiet džempera vadu no vietas, kur rezistors saskaras ar kondensatoru, līdz AD011 A0.

2. darbība. Novērtējiet signālu līdz trokšņa līmenim

Lai novērtētu trokšņa līmeni, vienkārši palaidiet zemāk esošo skriptu. Lai to novērtētu, mēs vienkārši atstājam DAC pie fiksētas vērtības un mēra sprieguma svārstības laika gaitā.

Pateicoties DAC konstrukcijai, troksnis būs vislielākais, ja PWM signāls būs 50% darba ciklā. Tāpēc mēs to novērtēsim. Mēs arī novērtēsim ESP32 šajā pašā signāla līmenī. Mēs arī filtrēsim ESP32 DAC ar to pašu zemas caurlaidības filtru, lai mērījumi būtu salīdzināmi.

Man iznākums bija skaidrs. PWM konstrukcijai bija> 6 dB labāks SNR (tas ir 2 reizes labāk). Skaidra uzvara jaunajam DAC. Neliela neskaidrība ir tāda, ka ADC ir iebūvēti filtri, kas noteikti uzlabo SNR. Tāpēc absolūtās vērtības var būt grūti interpretēt. Ja es būtu izmantojis otrās kārtas filtru, tas tā nebūtu.

Jebkurā gadījumā kods ir norādīts zemāk

#iekļaut

#iekļaut Adafruit_ADS1115 reklāmas; // adafruit bibliotēka adc int16_t adc0; // void setup (void) {Serial.begin (115200); // Sāciet sērijas reklāmas.setGain (GAIN_TWO); // 2x pastiprinājums +/- 2.048V 1 bits = 0.0625mV ads.begin (); // sākt adc pludiņu M = 0; // sākotnējais vidējais pludiņš Mp = 0; // iepriekšējais vidējais pludiņš S = 0; // sākotnējais dispersijas pludiņš Sp = 0; // iepriekšējā dispersija const int reps = 500; // atkārtojumu skaits int n = 256; // paraugu skaits ledcSetup (0, 25000, 8); // iestatīt pwm frequecny = 25000 Hz pie 8 bitu izšķirtspējas ledcAttachPin (25, 0); // iestatīt pwm uz pin 25 ledcWrite (0, 128); // iestatiet to uz pusi darba cikla (lielākais troksnis) kavēšanos (3000); // gaidīt norēķinu laiku float snrPWM [reps]; // PWM pludiņa snrs masīvs snrDAC [reps]; // DAC snrs masīvs (int i = 0; i <reps; i ++) {// cilpa pār atkārtojumiem (int k = 1; k <(n+1); k ++) {// cilpa virs paraugiem adc0 = ads.readADC_SingleEnded (0); // iegūt lasījumu M = Mp + (adc0 - Mp) / k; // aprēķināt slīdošo vidējo Mp = M; // iestatīt iepriekšējo vidējo S = Sp + (adc0 - Mp) * (adc0 - M); // aprēķināt ritošo dispersiju Sp = S; // iestatīt iepriekšējo dispersiju} // snr dB dB snrPWM = 20 * log10 (3.3 / (sqrt (S / n) *.0625 *.001)); // atiestatīt vērtības M = 0; Mp = 0; S = 0; Sp = 0; } ledcDetachPin (25); // atvienot PWM no tapas 25 dacWrite (25, 128); // rakstīt uz DAC kavēšanos (3000); // pagaidiet, lai samierinātos ar (int i = 0; i <reps; i ++) {// tāpat kā PWM cilpa (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 / (kv. (S / n) *.0625 *.001)); M = 0; Mp = 0; S = 0; Sp = 0; } // uzzīmēt SNR vienā grafikā (int i = 1; i <reps; i ++) {Serial.print ("PWM_SNR (dB):"); Sērijas nospiedums (snrPWM ); Serial.print (","); Serial.print ("ESP32_SNR (dB):"); Sērijas.println (snrDAC ); }} void loop (void) {}

3. solis: integrālā nelinearitāte un diferenciālā nelinearitāte

Neatņemamā nelinearitāte ir aptuvens rādītājs, cik liela ir novirze starp jūsu DAC izejas spriegumu un taisni. Jo lielāks tas ir, jo sliktāk tas ir…

Diferenciālā nelinearitāte ir mērs, cik aptuveni novērotās sprieguma izmaiņas (no viena koda uz otru) atšķiras no tā, kas būtu sagaidāms no taisnes.

Rezultāti šeit bija patiešām interesanti. Pirmkārt, abiem ir mazāk nekā 0,5 lsb kļūda (ar 8 bitu izšķirtspēju), kas ir labi, bet PWM ir daudz labāka integrālā linearitāte. Abiem ir salīdzināma atšķirīga nelinearitāte, bet ESP32 DAC ir daži ļoti dīvaini tapas. Turklāt PWM metodei ir zināma kļūdu struktūra. Būtībā tas maina un pārspēj pareizo spriegumu.

Man ir aizdomas, ka tā ir dīvaina noapaļošanas kļūda, kā ESP32 tiek ģenerēts 8 bitu PWM signāls.

Viens veids, kā to labot, ir ātri pārvietoties starp diviem blakus esošiem kodiem (piemēram, 128, 129) ar PWM. Izmantojot analogo zemfrekvences filtru, iegūtās kļūdas būs vidēji līdz nullei. Es to modelēju programmatūrā, un visas kļūdas patiešām pazuda. Tagad PWM metodei ir linearitāte, kas ir precīza līdz 16 bitiem!

Tālāk ir norādīts jebkurš datu ģenerēšanas kods. Izeja seriālajā monitorā būs.csv formātā. Vienkārši nokopējiet to teksta failā turpmākai apstrādei.

#iekļaut

#iekļaut Adafruit_ADS1115 reklāmas; / * Izmantojiet to 16 bitu versijai */ int16_t adc0; void setup (void) {Serial.begin (115200); ads.setGain (GAIN_ONE); // 2x pastiprinājums +/- 2.048V 1 bits = 1mV 0.0625mV ads.begin (); ledcSetup (0, 25000, 8); ledcAttachPin (25, 0); Serial.println ("Paredzēts, novērots"); ledcWrite (0, 2); kavēšanās (3000); par (int i = 2; i <255; i ++) {ledcWrite (0, i); kavēšanās (100); adc0 = ads.readADC_SingleEnded (0); paredzamais pludiņš = (i / 256,0 * 3,3) / 4,096 * 32767; Sērijas nospiedums (paredzēts); Serial.print (","); Serial.println (adc0); }} void loop (void) {}

4. darbība: joslas platums

Es definēšu joslas platumu šeit kā frekvenci, kādā DAC izeja samazinās par 3dB. Šī ir konvencija un zināmā mērā patvaļīga. Piemēram, 6 dB punktā DAC joprojām izvadīs signālu, tā amplitūda būs tikai ~ 50%.

Lai to izmērītu, mēs vienkārši arvien biežāk dodam sinusoidālos viļņus no DAC uz ADC un mēra to standarta novirzi. Nav pārsteidzoši, ka 3dB punkts ir 30 Hz (1/(2*pi*5000*1e-6)).

ESP32 var veikt 1 mega paraugu sekundē. Šī ir praktiska ESP32 uzvara. Tās amplitūda 100 Hz joslas platuma testa reģionā nemaz nesamazinās.

Tālāk esošais kods var pārbaudīt PWM DAC joslas platumu.

#iekļaut

#iekļaut Adafruit_ADS1115 reklāmas; / * Izmantojiet to 16 bitu versijai */ int16_t adc0; int16_t adc1; void setup (void) {float M; pludiņš Mp = 0; pludiņš S = 0; pludiņš Sp = 0; Serial.begin (115200); ads.setGain (GAIN_ONE); // 1x pastiprinājums +/- 4.096V 1 bits = 2mV 0.125mV ads.begin (); ledcSetup (0, 25000, 8); ledcAttachPin (25, 0); kavēšanās (5000); Serial.println ("Frekvence, amplitūda"); par (int i = 1; i <100; i ++) {neparakstīts garš sākums = milis (); neparakstīts garais T = milis (); Sp = 0; S = 0; M = 0; Mp = 0; int k = 1; pludiņa norma; kamēr ((T - sākums) <1000) {int out = 24 * sin (2 * PI * i * (T - sākums) / 1000,0) + 128; ledcWrite (0, ārā); adc0 = ads.readADC_SingleEnded (0); M = Mp + (adc0 - Mp) / k; Mp = M; S = Sp + (adc0 - Mp) * (adc0 - M); Sp = S; T = milis (); k ++; } ja (i == 1) {norma = sqrt (S / k); } Sērijas nospiedums (i); Serial.print (","); Sērijas.println (kv. (S / k) / norma, 3); k = 0; }} void loop (void) {}

Un šis kods pārbaudīs ESP32 joslas platumu. Noteikti noņemiet kondensatoru, pretējā gadījumā abām metodēm rezultāti būs vienādi.

#iekļaut

#iekļaut Adafruit_ADS1115 reklāmas; / * Izmantojiet to 16 bitu versijai */ int16_t adc0; int16_t adc1; void setup (void) {float M; pludiņš Mp = 0; pludiņš S = 0; pludiņš Sp = 0; Serial.begin (115200); ads.setGain (GAIN_ONE); // 1x pastiprinājums +/- 4.096V 1 bits = 2mV 0.125mV ads.begin (); kavēšanās (5000); Serial.println ("Frekvence, amplitūda"); par (int i = 1; i <100; i ++) {neparakstīts garš sākums = milis (); neparakstīts garais T = milis (); Sp = 0; S = 0; M = 0; Mp = 0; int k = 1; pludiņa norma; kamēr ((T - sākums) <1000) {int out = 24 * sin (2 * PI * i * (T - sākums) / 1000,0) + 128; dacWrite (25, ārā); adc0 = ads.readADC_SingleEnded (0); M = Mp + (adc0 - Mp) / k; Mp = M; S = Sp + (adc0 - Mp) * (adc0 - M); Sp = S; T = milis (); k ++; } ja (i == 1) {norma = sqrt (S / k); } Sērijas nospiedums (i); Serial.print (","); Sērijas.println (kv. (S / k) / norma, 3); k = 0; }} void loop (void) {}

5. solis: domu slēgšana

Jaunais DAC dizains uzvar linearitāti un troksni, bet zaudē joslas platumu. Atkarībā no pielietojuma viens no šiem rādītājiem var būt svarīgāks par otru. Izmantojot šīs pārbaudes procedūras, jums vajadzētu spēt objektīvi pieņemt šo lēmumu!

Turklāt es domāju, ka šeit ir vērts norādīt, ka, tā kā PWM izeja ir zems trokšņa līmenis, ar izcilu linearitāti vajadzētu būt iespējai izveidot daudz augstākas izšķirtspējas DAC ar PWM izeju (varbūt pat 16 bitu precizitāti). Tas prasīs zināmu darbu. Līdz tam es jums atvados!