- Matériel requis pour le Power Meter ESP32
- Compteur d'efficacité basé sur Arduino et ESP32 - Schéma de circuit
- Conception de circuits imprimés pour compteur d'efficacité basé sur Arduino et ESP32
- Compteur d'efficacité basé sur Arduino et ESP32 - Code
- Test de l'indicateur d'efficacité basé sur Arduino et ESP32
- Autres améliorations
Nous connaissons tous un voltmètre, un ampèremètre et des wattmètres de base, les trois éléments de base dont vous avez besoin pour mesurer les valeurs sur tous les projets ou circuits électroniques. Mesurer la tension et le courant à l'aide d'un multimètre peut être un bon moyen de commencer, mais l'un des plus gros problèmes auxquels je suis confronté lors du test d'un circuit est la mesure de l'efficacité énergétique. Donc, aujourd'hui, nous allons résoudre ce problème en construisant un compteur d'efficacité basé sur Arduino et ESP32 qui peut mesurer la tension d'entrée, le courant d'entrée, la tension de sortie et le courant de sortie. Par conséquent, il peut mesurer la puissance d'entrée et la puissance de sortie en même temps, et avec ces valeurs, nous pouvons mesurer l'efficacité facilement. Auparavant, nous avons également fait quelque chose de très similaire dans notre projet de wattmètre basé sur Arduino, mais ici nous mesurerons à la fois la puissance d'entrée et la puissance de sortie pour calculer l'efficacité énergétique.
Plutôt que d'acheter quatre compteurs pour le travail, nous serons en mesure de résoudre ce problème en intégrant les capacités des quatre compteurs en un seul. La construction de votre compteur numérique réduit non seulement les coûts, mais vous donne également une marge de manœuvre pour les mises à niveau et les améliorations. Comme nous utilisons un ESP32 pour construire ce projet, nous pouvons facilement activer l'IoT de ce compteur et enregistrer les données sur le Web, ce qui est le sujet du futur projet. Avec toutes les bases clarifiées, allons-y.
Remarque: ce wattmètre est conçu pour les circuits CC. Si vous cherchez à mesurer le courant alternatif en efficacité énergétique CA calculée, vous pouvez consulter les projets de compteurs d'énergie électrique et de compteurs d'énergie prépayés basés sur l'IoT.
Matériel requis pour le Power Meter ESP32
L'image ci-dessous montre les matériaux utilisés pour construire le circuit. Comme il est fait avec des composants très génériques, vous devriez être en mesure de trouver tout le matériel listé dans votre magasin de bricolage local.
J'ai également répertorié les composants ci-dessous avec la quantité requise. Si vous construisez vous-même le circuit, il est fortement recommandé d'obtenir tous les matériaux de la liste ci-dessous.
- Carte ESP32 - 1
- OLED 128 x 64 - 1
- ACS712-20 IC - 2
- DC Barrel Jack - 1
- Condensateur 100uF - 2
- 104pF - 2
- 102pF - 2
- 10 000, 1% - 4
- 68 000, 1% - 2
- 6,8 K, 1% - 2
Compteur d'efficacité basé sur Arduino et ESP32 - Schéma de circuit
Le schéma de l' indicateur d'efficacité basé sur Arduino et ESP32 est illustré ci-dessous. La création de ce circuit est très simple et utilise des composants génériques.
Le fonctionnement du circuit est très simple. Nous mesurerons la tension et le courant dans ce projet mais d'une manière unique. Nous mesurons la tension et le courant à la fois pour l'entrée et la sortie, nous pouvons donc voir l'efficacité du circuit. Ceci est très pratique pour certains projets. Un exemple pourrait être un convertisseur CC-CC où la mesure du rendement devient obligatoire. Le fonctionnement de ces circuits est décrit ci-dessous.
Le circuit intégré du capteur de courant ACS712:
Comme vous pouvez le voir dans l'image ci-dessus, nous utilisons un circuit intégré de capteur de courant ACS712 pour mesurer le courant. C'est un circuit intégré très intéressant car il utilise l' effet Hall pour mesurer le courant, il existe trois variantes de ce circuit intégré que l'on peut trouver sur le marché f (ou 5A, 20A et 30A). Nous utilisons la variante 20A de ceci et elle est étiquetée ACS712-20.
La fiche technique de l'ACS712 recommande une plage de tension de 4,5 à 5,5 pour fonctionner correctement. Et comme nous allons mesurer le courant avec un ESP32, il ne tolère que 3,3 V, c'est pourquoi j'ai utilisé un diviseur de tension avec deux résistances 10K pour faire baisser la tension de sortie du circuit intégré ACS712. Lorsqu'aucun courant ne circule dans le circuit intégré, il produit 2,5 V et lorsqu'une certaine quantité de courant traverse le circuit intégré, il abaisse la tension ou augmente la tension en fonction du sens du courant. Nous avons utilisé deux de ces circuits intégrés pour mesurer le courant d'entrée et de sortie. Consultez nos précédents projets (ci-dessous) dans lesquels nous avons utilisé ce capteur ACS712.
- Compteur d'énergie électrique basé sur l'IoT utilisant Arduino et le module Wi-Fi ESP8266
- Circuit d'ampèremètre numérique utilisant le microcontrôleur PIC et l'ACS712
Où nous avons discuté du fonctionnement de ces capteurs en détail. Vous pouvez les consulter si vous souhaitez en savoir plus sur ces capteurs.
Le diviseur de tension:
Pour mesurer la tension d'entrée et de sortie, nous avons deux diviseurs de tension sur l'entrée et le côté sortie du circuit. La tension maximale que le circuit peut mesurer est de 35 V, mais elle peut être facilement modifiée en changeant les valeurs de résistance du diviseur de tension.
Le régulateur de tension:
Un régulateur de tension générique LM7805 est utilisé pour alimenter les CI ESP32, OLED et ACS712. Comme nous l'alimentons avec une puissance assez propre, aucun condensateur de découplage n'est utilisé, mais nous avons utilisé des condensateurs de 100 uF à l'entrée et à la sortie pour stabiliser le circuit intégré.
L'ESP32 IC et l'écran OLED:
Nous avons utilisé un ESP32 comme processeur principal, qui est responsable de toutes les lectures, calculs, entrées et sorties. De plus, nous avons utilisé un écran OLED 128X64 pour connaître les valeurs.
Conception de circuits imprimés pour compteur d'efficacité basé sur Arduino et ESP32
Le circuit imprimé de notre compteur d'efficacité basé sur Arduino et ESP32 est conçu sur une carte unilatérale. J'ai utilisé Eagle pour concevoir mon PCB mais vous pouvez utiliser n'importe quel logiciel de conception de votre choix. L'image 2D de la conception de ma carte est présentée ci-dessous.
Une trace de terre suffisante est utilisée pour établir des connexions de terre appropriées entre tous les composants. De plus, nous nous sommes assurés d'utiliser des traces 5V et 3,3V appropriées pour réduire le bruit et améliorer l'efficacité.
- Télécharger les fichiers de conception de circuits imprimés et GERBER Compteur d'efficacité basé sur Arduino et ESP32
PCB à la main:
Pour plus de commodité et de test, j'ai fait ma version artisanale du PCB et c'est illustré ci-dessous. Dans la première version, j'ai commis des erreurs, que j'ai corrigées à l'aide de câbles de raccordement. Mais dans la version finale, je les ai corrigés, vous pouvez simplement télécharger les fichiers et les utiliser.
Compteur d'efficacité basé sur Arduino et ESP32 - Code
Maintenant que nous avons une bonne compréhension du côté matériel des choses, nous pouvons ouvrir l'IDE Arduino et commencer notre codage. Le but du code est de lire la tension analogique des broches 35 et 33 de la carte ESP32. En outre, nous lisons la tension de 32 et 34 broches qui est la valeur actuelle. Une fois que nous faisons cela, nous pouvons multiplier ceux-ci pour obtenir la puissance d'entrée et la puissance de sortie, et en appliquant la formule d'efficacité, nous pouvons obtenir l'efficacité.
Enfin, on l'affiche sur l'écran LCD. Le programme complet pour faire de même est donné à la fin, qui peut être utilisé comme tel pour le matériel décrit ci-dessus. De plus, le code est divisé en petits extraits et expliqué.
Comme nous utilisons un écran OLED 128X64, nous avons besoin de la bibliothèque Adafruit_GFX et de la bibliothèque Adafruit_SSD1306 pour communiquer avec l'écran. Vous pouvez télécharger les deux depuis le terminal de gestion de carte par défaut de l'Arduino; si vous rencontrez des problèmes avec la partie gestionnaire de tableau, vous pouvez également télécharger et inclure les bibliothèques à partir de son référentiel GitHub associé, qui est indiqué ci-dessous.
- Télécharger la bibliothèque Adafruit_GFX
- Télécharger la bibliothèque Adafruit_SSD1306
Comme toujours, nous commençons notre code en incluant toutes les bibliothèques requises. Ensuite, nous définissons toutes les broches et variables nécessaires qui sont toutes indiquées ci-dessous.
#comprendre
Les définitions SCREEN_WIDTH et SCREEN_HEIGHT sont utilisées pour définir la taille de l'écran. Ensuite, nous avons défini toutes les broches nécessaires, à travers lesquelles nous allons mesurer la tension et le courant. Ensuite, nous avons défini les valeurs de résistance qui sont utilisées dans le matériel comme vous pouvez le voir sur le schéma. Si vous n'avez pas ces valeurs ou si vous souhaitez modifier la plage du compteur, vous pouvez modifier ces valeurs, le code fonctionnera très bien.
Comme nous utilisons un ACS712 pour mesurer le courant, nous avons besoin de la valeur mVperAmp pour calculer le courant à partir de la tension. Comme j'utilise un module ACS712 20A, la valeur mV / A est de 100 comme indiqué dans la fiche technique. Mais parce que nous utilisons un ESP32 et un diviseur de tension, nous aurons la moitié de la valeur qui est 50, et c'est pourquoi nous avons mis la valeur mV / AMP.
ACSoffset est le décalage nécessaire pour calculer le courant à partir de la tension. Comme les circuits intégrés ACS712 sont alimentés à partir de 5 V, la tension de décalage est de 2,5 V. Mais comme nous utilisons un diviseur de tension, il descend à 1,25 V. Vous connaissez peut-être déjà l'ADC merdique de l'ESP32, j'ai donc dû utiliser une valeur de 1136. Si vous rencontrez des problèmes d'étalonnage, vous pouvez modifier les valeurs et compenser l'ADC.
Enfin, nous terminons cette section en créant un objet d' affichage de la classe Adafruit_SSD1306 et en passant la largeur de l'écran, la hauteur, la configuration I 2 C, et le dernier paramètre -1 est utilisé pour définir la fonctionnalité de réinitialisation. Si votre écran n'a pas de broche de réinitialisation externe (ce qui est certainement pour mon écran), vous devez utiliser -1 pour le dernier argument.
void setup () {Serial.begin (115200); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adresse 0x3D pour 128x64 Serial.println (F ("L'allocation SSD1306 a échoué")); pour (;;); } display.clearDisplay (); display.setRotation (2); display.setTextSize (1); retard (100); }
Ensuite, nous avons notre section setup () . Dans cette section, nous activons serial pour le débogage, nous vérifions si un affichage I 2 C est disponible ou non à l'aide de la méthode de début de l'objet d'affichage. De plus, nous définissons l' adresse I 2 C. Ensuite, nous effaçons l'affichage avec la méthode clearDisplay () . De plus, nous faisons pivoter l'affichage avec la méthode setRotation , c'est parce que j'ai gâché la conception de mon PCB. Ensuite, nous mettons un délai de 100 ms pour que les fonctions prennent effet. Une fois que cela est fait, nous pouvons maintenant passer à la fonction de boucle. Mais avant de passer à la fonction de boucle, nous devons discuter de deux autres fonctions qui sont return_voltage_value () , et return_current_value () .
double return_voltage_value (int pin_no) {double tmp = 0; double ADCVoltage = 0; double inputVoltage = 0; double moyenne = 0; pour (int i = 0; i <150; i ++) {tmp = tmp + analogRead (pin_no); } avg = tmp / 150; ADCVoltage = ((moyenne * 3,3) / (4095)) + 0,138; inputVoltage = ADCVoltage / (R2_VOLTAGE / (R1_VOLTAGE + R2_VOLTAGE)); // formule pour calculer la tension dans ie GND return inputVoltage; }
La fonction return_voltage_value () est utilisée pour mesurer la tension entrant dans l'ADC, et prend le pin_no comme argument. Dans cette fonction, nous commençons par déclarer certaines variables, qui sont tmp, ADCVoltage, inputVoltage et avg. La variable tmp est utilisée pour stocker la valeur ADC temporaire que nous obtenons de la fonction analogRead (), puis nous la moyenne 150 fois dans une boucle for, et nous stockons la valeur dans une variable appelée avg. Nous calculons ensuite la tension ADC à partir de la formule donnée, enfin, nous calculons la tension d'entrée et renvoyons les valeurs. La valeur +0.138 que vous voyez est la valeur d'étalonnage que j'ai utilisée pour étalonner le niveau de tension, jouez avec cette valeur si vous obtenez des erreurs.
double return_current_value (int pin_no) {double tmp = 0; double moyenne = 0; double ADCVoltage = 0; double ampères = 0; pour (int z = 0; z <150; z ++) {tmp = tmp + analogRead (pin_no); } avg = tmp / 150; ADCVoltage = ((moy / 4095,0) * 3300); // Obtient mV Amps = ((ADCVoltage - ACSoffset) / mVperAmp); retour ampères; }
Ensuite, nous avons la fonction return_current_value () . Cette fonction prend également pin_no comme argument. Dans cette fonction, nous avons également quatre variables à savoir. tmp, avg, ADCVoltage et ampères
Ensuite, nous lisons la broche avec la fonction analogRead () et la moyenne 150 fois, nous utilisons ensuite la formule pour calculer la tension ADC, avec laquelle nous calculons le courant et nous renvoyons la valeur. Avec cela, nous pouvons passer à la section boucle.
boucle vide () {float input_voltage = abs (return_voltage_value (INPUT_VOLTAGE_SENSE_PIN)); float input_current = abs (return_current_value (INPUT_CURRENT_SENSE_PIN)); float output_voltage = abs (return_voltage_value (OUTPUT_VOLTAGE_SENSE_PIN)); float output_current = abs ((return_current_value (OUTPUT_CURRENT_SENSE_PIN))); input_current = input_current - 0,025; Serial.print ("Tension d'entrée:"); Serial.print (input_voltage); Serial.print ("- Courant d'entrée:"); Serial.print (input_current); Serial.print ("- Tension de sortie:"); Serial.print (output_voltage); Serial.print ("- Courant de sortie:"); Serial.println (output_current); retard (300); display.clearDisplay (); display.setCursor (0, 0); display.print ("I / PV:"); display.setCursor (37, 0); display.print (tension_entrée); display.setCursor (70, 0); afficher.impression ("V"); }
Nous commençons la section boucle en déclarant et en définissant des variables flottantes, dans les quatre variables. Nous appelons les fonctions respectives, en passant pin_no comme argument, car le module ACS712 peut renvoyer des valeurs courantes en négatif. Nous utilisons la fonction abs () de la bibliothèque mathématique pour rendre la valeur négative positive. Ensuite, nous imprimons en série toutes les valeurs pour le débogage. Ensuite, nous effaçons l'affichage, définissons le curseur et imprimons les valeurs. Nous faisons cela pour tous les caractères affichés à l'écran. Ce qui marque la fin de la fonction de boucle et du programme.
Test de l'indicateur d'efficacité basé sur Arduino et ESP32
Comme vous pouvez le voir ma configuration de test dans l'image ci-dessus. J'ai mon transformateur 30 V en entrée et mon compteur est branché pour la carte de test. J'utilise un convertisseur abaisseur basé sur LM2596 et pour la charge et j'utilise trois résistances 10 Ohms, en parallèle.
Comme vous pouvez le voir dans l'image ci-dessus, je me suis connecté à des multimètres pour vérifier la tension d'entrée et de sortie. Le transformateur produit presque 32 V et la sortie du convertisseur abaisseur est de 3,95 V.
L'image ici montre le courant de sortie mesuré par mon compteur d'efficacité et le multimètre. Comme vous pouvez le voir, le multimètre affiche 0,97 ampères, et si vous zoomez un peu, il affiche 1,0A, il est légèrement éteint en raison de la non-linéarité présente dans le module ACS712, mais cela sert notre objectif. Pour une explication détaillée et des tests, vous pouvez consulter la vidéo dans notre section vidéo.
Autres améliorations
Pour cette démonstration, le circuit est réalisé sur un PCB fait à la main mais le circuit peut être facilement construit dans un PCB de bonne qualité. Dans mon expérience, la taille du PCB est vraiment grande en raison de la taille du composant, mais dans un environnement de production, elle peut être réduite en utilisant des composants SMD bon marché. Le circuit n'a pas non plus de fonction de protection intégrée, donc l'inclusion d'un circuit de protection améliorera l'aspect général de sécurité du circuit. De plus, en écrivant le code, j'ai remarqué que l'ADC de l'ESP32 n'était pas terrible. L'inclusion d'un ADC externe comme le module ADS1115 augmentera la stabilité et la précision globales.
J'espère que vous avez aimé cet article et en avez appris quelque chose de nouveau. Si vous avez le moindre doute, vous pouvez demander dans les commentaires ci-dessous ou utiliser nos forums pour une discussion détaillée.