Connaissez-vous le réglage ESP32 ADC ? : 29 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Aujourd'hui, je vais parler d'un problème plus technique, mais que tous ceux qui travaillent avec ESP32 devraient connaître: le problème du réglage de la lecture ADC (convertisseur analogique-numérique). Je trouve cela important car lorsque vous effectuez une "mesure", en particulier avec un instrument qui a une sortie analogique, vous devez être absolument certain que la lecture est effectuée correctement.

Dans la vidéo d'aujourd'hui, nous allons donc effectuer des mesures à l'aide du "convertisseur analogique-numérique" de l'ESP32, observer les écarts de conversion et appliquer une méthode de réglage/étalonnage ADC.

Étape 1: Qu'est-ce qu'un convertisseur AD ?

Un convertisseur AN est un circuit capable de traduire une quantité analogique (continue) en valeurs numériques (discrètes). Qu'est-ce que ça veut dire? Cela signifie que tandis que les valeurs numériques ne peuvent prendre que des valeurs discrètes formées par la combinaison de zéros et de uns, une quantité analogique peut prendre n'importe quelle valeur dans une plage. Par exemple, si nous mesurions la tension d'une pile AA idéale, nous pourrions trouver n'importe quelle valeur entre 0V et 1,5V, puisqu'il s'agit d'une quantité analogique. L'état de sortie d'une lampe idéale ne doit prendre que deux états (éteint ou allumé), ce qui est une grandeur discrète. Étant donné que les microcontrôleurs fonctionnent en utilisant cette logique discrète, nous avons besoin d'un circuit capable de traduire une quantité analogique en numérique (ou discret).

Étape 2: Ressources utilisées

• Une carte Lolin32 Lite v1.0.0

• Un oscilloscope Tektronix TDS1001C pour la capture

• Un câble USB pour l'ESP32

• Un oscilloscope Hantek DSO4102C comme générateur de signaux

Étape 3: ESP32 ADC

Selon les données Espressif, les puces ESP32 peuvent présenter une différence de +/- 6% d'une puce à l'autre dans les résultats mesurés.

De plus, la conversion n'a PAS de réponse linéaire pour chaque plage disponible pour la lecture. Espressif propose une méthode d'étalonnage et suggère aux utilisateurs de mettre en œuvre d'autres méthodes s'ils le jugent nécessaire pour atteindre la précision souhaitée.

Nous allons effectuer une acquisition de données, et à partir de là, nous montrerons les réponses ADC et un exemple d'application d'un processus mathématique pour lire l'ajustement.

Il existe plusieurs manières (plus simples ou plus complexes) d'effectuer ces corrections. A vous d'évaluer la plus adaptée à votre projet.

Celui présenté ici aura un but illustratif et tentera d'aborder des points intéressants que l'on pourra observer lors des réglages.

Étape 4: Circuit utilisé

J'ai utilisé un oscilloscope avec un générateur de signal qui monte jusqu'à 25 MHz, le Hantek DSO4102C. Nous avons généré une onde qui a été lue par l'ESP A/D et l'oscilloscope. Les données collectées ont été enregistrées en csv et dans un tableur, que je laisserai à la fin de l'article en téléchargement.

Étape 5: Signe utilisé

Nous avons choisi un signal trapézoïdal basse fréquence qui permet d'accéder aux rampes qui parcourent toute la plage de conversion. Cela permet un grand nombre d'échantillons sur ces rampes.

Étape 6: Données obtenues par l'oscilloscope

L'image de la capture a été réalisée par l'oscilloscope. Les données ont été stockées dans un fichier csv. Notez la légère courbure sur les rampes montantes et descendantes du signal.

Étape 7: Données obtenues par l'oscilloscope (fichier csv dans Excel)

Nous avons les échantillons ici.

Étape 8: Données obtenues par l'ADC

En modifiant le taux de transfert de la série, nous pouvons afficher les données capturées par l'ADC. Observer la déformation du signal trapézoïdal.

Données observées sur le traceur série Arduino IDE

Étape 9: Données obtenues par ADC - Excel

En utilisant un taux plus élevé et le terminal série, nous pouvons capturer les valeurs et les appliquer dans Excel pour nos comparaisons.

Étape 10: Comparaison des rampes d'escalade

Nous comparons les deux rampes d'escalade des deux prises.

Notez la courbure qui se produit sur les deux rampes.

A noter également que pour une même rampe, nous avons beaucoup plus d'échantillons de l'ESP32 que de l'oscilloscope.

Étape 11: Égaliser le nombre d'échantillons

Parce que l'ESP32 a fourni un plus grand nombre d'échantillons que l'oscilloscope, nous devons assimiler ces valeurs, car elles serviront d'indice pour comparer les deux courbes.

Pour cela, nous allons faire une comparaison directe.

Nous avons 305 échantillons pour la rampe de l'oscilloscope et 2365 échantillons pour la rampe ADC.

Étant donné que les rampes sont de la même plage, nous pouvons dire que nous avons environ 7,75 échantillons de l'ADC pour chaque oscilloscope.

La multiplication de l'indice de chaque échantillon d'oscilloscope a la même courbe, mais avec des indices équivalents à l'ADC et aux données redistribuées.

Pour combler les données manquantes pour les nouvelles positions, nous appliquerons une courbe qui correspond statistiquement aux données connues.

Étape 12: Combler les lacunes - Ligne de tendance

En sélectionnant les données connues (points bleus), en cliquant puis en cliquant avec le bouton droit, on sélectionne: « Ajouter une ligne de tendance… »

Dans la fenêtre qui apparaît, nous sélectionnons le type Polynomial (l'ordre 2 suffira).

Nous avons également coché les options "Afficher l'équation dans le graphique" et "Afficher la valeur R au carré dans le graphique".

Nous cliquons sur "Fermer".

Étape 13: Combler les lacunes - Courbe polynomiale de grade 2

Excel nous donne deux nouvelles informations; l'équation du second ordre qui correspond le mieux aux données et l'équation R au carré qui quantifie cette adéquation.

N'oubliez pas que plus l'équation est proche de 1, plus l'équation est appropriée.

Ne nous plongeons pas dans les mathématiques impliquées, utilisons-les simplement comme un outil.

Étape 14: Combler les lacunes - Évaluer la fonction

Comblons les lacunes d'échantillonnage avec les données générées par l'équation. Et ensuite, comparez-les point par point.

y = -9E-08x2 + 0, 0014x + 0, 1505

R² = 0,9999

Tension oscilloscope = -9E-08 * indice2 + 0, 0014 * indice + 0, 1505

Étape 15: Conversion de la tension de l'oscilloscope en une valeur équivalente à comparer avec l'ADC

Profitons-en pour transformer également la valeur de la tension de l'oscilloscope en une valeur ADC équivalente.

Comme la valeur la plus élevée obtenue dans l'ADP de l'ESP32 était de 4095, ce qui équivaut à la lecture de 2.958V pour le même indice, on peut dire que:

Chaque volt dans les mesures de l'oscilloscope équivaut à environ 1384,4 unités de l'AD. Par conséquent, nous pouvons multiplier toutes les mesures de l'oscilloscope par cette valeur.

Étape 16: Comparer les deux rampes obtenues

Visualisation des différences obtenues dans les deux lectures.

Étape 17: Comportement de la différence de lecture ADC (ERREUR)

La courbe ci-dessous montre comment se comporte la différence de lecture ADC en fonction de la mesure. Cette collecte de données va nous permettre de trouver une fonction de correction.

Pour trouver cette courbe, il suffit de tracer la différence trouvée dans chaque mesure en fonction de chaque position AD possible (0 à 4095).

Étape 18: Comportement de différence de lecture ADC - Recherche d'une fonction de correction

Nous pouvons déterminer dans Excel une fonction de correction en ajoutant une ligne de tendance, maintenant d'un degré plus élevé, jusqu'à ce qu'elle corresponde suffisamment à nos données.

Étape 19: Utilisation d'un autre logiciel

Un autre logiciel intéressant pour déterminer les courbes est PolySolve, qui peut être utilisé directement sur le lien: https://arachnoid.com/polysolve/ ou téléchargé en tant qu'application Java.

Il permet l'application de régressions polynomiales de degré supérieur et la livraison de la fonction formatée, ainsi que d'autres fonctionnalités.

Pour l'utiliser, entrez simplement les données dans la première zone de texte. Les données doivent suivre l'ordre X, Y séparés par une virgule ou une tabulation. Soyez prudent lorsque vous utilisez correctement le point comme point décimal.

Un graphique apparaîtra dans la case suivante si les données saisies sont correctement formatées.

Voici comment s'est déroulée notre courbe d'erreur ADC.

Cette fenêtre présentera le résultat de la régression, y compris les données d'adéquation de la fonction, qui à leur tour peuvent avoir leur sortie formatée de plusieurs manières: comme une fonction C/C++, une liste de coefficients, une fonction écrite en Java, etc.

Remarque: faites attention aux séparateurs décimaux

Étape 20: Constantes et configuration ()

Je rappelle ici le GPIO utilisé pour la capture analogique. J'initialise le port série, ainsi que la broche déterminée pour la capture analogique.

const int pin_leitura = 36; //GPIO utilisé pour la capture analogique void setup() { Serial.begin(1000000); //Iniciciando a porta serial somente para debug pinMode(pin_leitura, INPUT); //Pino utilizado para captura analógica }

Étape 21: Boucle () et la fonction de correction

Nous faisons la capture de la tension ajustée, et nous imprimons les valeurs avec ou sans les bonnes corrections.

boucle vide() { int valor_analogico = analogRead(pin_leitura); //Réaliser une capture d'une tension ajustée //Serial.print(valor_analogico + f(valor_analogico)); //Imprimer les valeurs pour le débogage (COM CORREÇÃO) Serial.print(valor_analogico); //imprime les valeurs pour le débogage (SEM CORREÇÃO) Serial.print(", "); Serial.print (4095); // cria uma linha para marcar o valor máximo de 4095 Serial.print(", "); Serial.println(0); //cria uma linha para marcar o valor minimo de 0 }

Notez à la ligne 12 que nous avons la possibilité d'imprimer les données avec l'ajout de la fonction de différence f (analog_value).

Étape 22: Utilisation de la fonction de correction PolySolve

Ici, nous utilisons la fonction PolySolve dans l'IDE Arduino.

/* Mode: normal Degré polynomial 6, 2365 paires de données x, y Coefficient de corrélation (r^2) = 9, 907187626418e-01 Erreur standard = 1, 353761109831e+01 Forme de sortie: Fonction C/C++: Copyright © 2012, P. Lutus -- https://www.arachnoid.com. Tous les droits sont réservés. */ double f(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x + 1.276218788985e-04 * pow(x, 2) + -3.470360275448e-07 * pow(x, 3) + 2.082790802069e- 10 * pow(x, 4) + -5.306931174991e-14 * pow(x, 5) + 4.787659214703e-18 * pow(x, 6); }

Notez le changement virgule par point comme séparateur décimal.

Étape 23: Capture avec correction - Série du traceur

Étape 24: Coût de calcul

Pour effectuer des calculs polynomiaux, il est nécessaire que le processeur gère cette tâche. Cela peut entraîner des retards d'exécution, selon le code source et la puissance de calcul disponible.

Ici, nous voyons un tableau de résultats d'un test utilisant des polynômes à plusieurs degrés. Notez la différence entre les moments où la fonction pow () a été utilisée et quand elle ne l'a pas été.

Étape 25: Code de test - Configuration () et démarrage de la boucle ()

Ici, nous avons le code utilisé dans notre test.

void setup() { Serial.begin(1000000); //Iniciando a porta serial somente para debug } void loop() { float valor_analogico = 500.0; //um valor arbtrario float quantidade = 10000.0; //quantidade de chamadas float contador = 0.0; //contador de chamadas

Étape 26: Code de test - Boucle () et traitement

J'ai utilisé la fonction micros () pour obtenir la valeur en microsecondes.

//============= inicia o processo float agora = micros(); //marca o instante inicial while (contador < quantidade) { //v(valor_analogico); //função vazia //r(valor_analogico); //Função com retorno //f0(valor_analogico); //grau 0 //f1(valor_analogico); //grau 1 //f2(valor_analogico); //grau 2 //f3(valor_analogico); //grau 3 //f4(valor_analogico); //grau 4 //f5(valor_analogico); //grau 5 //f6(valor_analogico); //grau 6 //f13_semPow(valor_analogico); //grau 13º SEM a função POW //f13_comPow(valor_analogico); //grau 13º COM a função POW contador++; } agora = (micros() - agora) / quantidade; //determina o intervalo que se passou para cada iteração //============= finaliza o processo

Étape 27: Code de test - Boucle () - Résultats

Nous imprimons la valeur renvoyée par la fonction de grade 13 avec et sans POW pour comparaison, ainsi que l'intervalle de traitement.

//Imprime o valor retornado da função de grau 13 come e sem POW para comparação Serial.print(f13_semPow(valor_analogico)); //grau 13º SEM une fonction POW Serial.print(" - "); Serial.print(f13_comPow(valor_analogico)); //grau 13º COM une fonction POW Serial.print(" - "); //Imprime o intervalo do processamento Serial.println(agora, 6); }

Étape 28: Code de test - Fonctions utilisées

Fonctions vides (uniquement avec retour) de degré 0 et 1.

//FUNÇÃO VAZIAdouble v(double x) { } //FUNÇÃO SOMENTE COM RETORNO double r(double x) { return x; } //FUNÇÃO DE GRAU 0 double f0(double x) { return 2.202196968876e+02; } //FUNÇÃO DE GRAU 1 double f1(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x; }

Fonctions de niveau 2, 3 et 4.

//FUNÇÃO DE GRAU 2double f2(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x + 1.276218788985e-04 * pow(x, 2); } //FUNÇÃO DE GRAU 3 double f3(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x + 1.276218788985e-04 * pow(x, 2) + -3.470360275448e-07 * pow(x, 3); } //FUNÇÃO DE GRAU 4 double f4(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x + 1.276218788985e-04 * pow(x, 2) + -3.470360275448e-07 * pow(x, 3) + 2.082790802069e-10 * pow(x, 4); }

Fonctions de 5e et 6e années.

//FUNÇÃO DE GRAU 5double f5(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x + 1.276218788985e-04 * pow(x, 2) + -3.470360275448e-07 * pow(x, 3) + 2.082790802069e-10 * pow(x, 4) + -5.306931174991e-14 * pow(x, 5); } //FUNÇÃO DE GRAU 6 double f6(double x) { return 2.202196968876e+02 + 3.561383996027e-01 * x + 1.276218788985e-04 * pow(x, 2) + -3.470360275448e-07 * pow(x, 3) + 2.082790802069e-10 * pow(x, 4) + -5.306931174991e-14 * pow(x, 5) + 4.787659214703e-18 * pow(x, 6); }

Fonction de la 13e année en utilisant le prisonnier de guerre.

//FUNÇÃO DE GRAU 13 USANDO O POWdouble f13_comPow(double x) { return 2, 161282383460e+02 + 3, 944594843419e-01 * x + 5, 395439724295e-04 * pow(x, 2) + -3, 968558178426e-06 * pow(x, 3) + 1, 047910519933e-08 * pow(x, 4) + -1, 479271312313e-11 * pow(x, 5) + 1, 220894795714e-14 * pow(x, 6) + -6, 136200785076e-18 * pow(x, 7) + 1, 910015248179e-21 * pow(x, 8) + -3, 566607830903e-25 * pow(x, 9) + 5, 000280815521e-30 * pow(x, 10) + 3, 434515045670e-32 * pow(x, 11) + -1, 407635444704e-35 * pow(x, 12) + 9, 871816383223e-40 * pow(x, 13); }

Fonction de niveau 13 sans utiliser de prisonnier de guerre.

//FUNÇÃO DE GRAU SEM USAR O POWdouble f13_semPow(double x) { return 2, 161282383460e+02 + 3, 944594843419e-01 * x + 5, 395439724295e-04 * x * x + -3, 968558178426e-06 * x * x * x + 1, 047910519933e-08 * x * x * x * x + -1, 479271312313e-11 * x * x * x * x * x + 1, 220894795714e-14 * x * x * x * x * x * x + -6, 136200785076e-18 * x * x * x * x * x * x * x + 1, 910015248179e-21 * x * x * x * x * x * x * x * x + -3, 566607830903e- 25 * x * x * x * x * x * x * x * x * x + 5, 000280815521e-30 * x * x * x * x * x * x * x * x * x * x + 3, 434515045670e- 32 * x * x * x * x * x * x * x * x * x * x * x + -1, 407635444704e-35 * x * x * x * x * x * x * x * x * x * x * x * x + 9, 871816383223e-40 * x * x * x * x * x * x * x * x * x * x * x * x * x; }

Étape 29: Fichiers

Téléchargez les fichiers:

PDF

INO

Tableur