Banc de Mesure de Consommation
Cet article décrit un banc de mesure de consommation. Il est réalisé autour d'une carte ARDUINO MEGA et possède deux modules INA226 et un afficheur OLED.
1. La théorie
La tension maximale aux bornes du shunt de l'INA226 est de 81.92mV, ce qui correspond pour un shunt de 100mΩ à un courant maximal mesurable arrondi de 820mA ou pour un shunt de 10Ω à un courant maximal mesurable arrondi de 8,20mA.Pour le shunt de 100mΩ La résolution est donc de 820 / 32768 = 25µA.
Pour le shunt de 10Ω La résolution est donc de 8,20 / 32768 = 0.25µA.
Pourquoi 32768 alors que l'ADC de l'INA226 est un 16bits ? Parce qu'il est capable de mesurer des courants négatifs, donc 16 bits moins le bit de signe cela fait 15, et 2 à la puissance 15 = 32768.
Dans tous les cas, la chute de tension maximale aux bornes du shunt sera celle de l'INA226 : 81.92mV, ce qui est très acceptable.
2. Les fonctionnalités
Cette carte permet de mesurer la consommation de montages électroniques, en particulier de circuits à base de micro-contrôleurs à faible consommation comme décrit ICI.Il est capable de mesurer des courants de 0.5µA à 0.8A.
Deux shunts sont utilisés :
- un shunt 0.1Ω high-side
- un shunt 10Ω low-side
Le shunt de 10Ω est activé uniquement pour la mesure de courant inférieurs à 5mA.
La tension appliquée à la charge est également mesurée. Celle-ci peut être au maximum de 33V.
Un transil 33V et un fusible protègent le banc.
Ce banc permet donc d'alimenter des cartes à micro-contrôleur en 1.8V, 3.3V, 5V et plus. Il peut par exemple mesurer le courant sur le JACK d'alimentation d'un ARDUINO UNO en 7.5V ou 12V. Il n'est pas limité à la mesure de tensions faibles comme certains :
Exemple: ST microelectronics, limité à 1.8V - 3.3V.
Deux modes de fonctionnement sont possibles. Le choix se fait par un petit inverseur.
2.1. Mode autonome
Un petit afficheur OLED permet de visualiser la tension et le courant instantanés.2.2. Mode connecté
Les données sont remontées vers un PC par le câble USB de l'ARDUINO MEGA.
Un logiciel sur le PC récolte les données et effectue les calculs :
- tension minimale
- tension maximale
- tension moyenne
- courant minimal
- courant maximal
- courant moyen
Il est développé en PYTHON + MATPLOTLIB.
2.3. Calibration
En l'absence de charge, l'appui sur un micro-switch permet de calibrer le zéro du banc.Débrancher et brancher la câble USB. Appuyer sur le switch une vingtaine de secondes, relâcher. Appuyer à nouveau pour démarrer.
La calibration est sauvegardée en EEPROM.
2.4. Shield
La carte est développée sous forme de shield enfichable directement sur la carte ARDUINO MEGA. La carte MEGA est équipée de quatre pieds plastique.3. Le matériel
Pour réaliser ce banc, il vous faudra réunir :
- un ARDUINO MEGA
- deux modules INA226
- un shunt 10Ω CMS 2010
- un shunt 100mΩ CMS 2010
- un afficheur SSD1306 0.96 pouces
- 1 condensateur de 100nF
- un transistor MOSFET IRLZ44N
- 1 résistance de 110Ω
- 1 résistance de 9.1KΩ
- deux connecteurs 2 broches mâles au pas de 2.54
- trois connecteurs 8 broches mâles au pas de 2.54
- un connecteur 10 broches mâles au pas de 2.54
- un micro-switch pur PCB
- un inverseur pour PCB
- un porte-fusible 20mm
- un transil 33V
- une broche de test
- quatre pieds plastique pour la MEGA
Ils doivent être remplacés. Il s'agit de résistance CMS 2010, maximum 2512.
Les valeurs des résistances de 110Ω et 9.1KΩ ne sont pas critiques. 100Ω et 10KΩ conviennent.
Le transil n'est pas obligatoire si vous êtes sûr de limiter la tension d'alimentation à 33V.
4. Le schéma
Sur ce diagramme de l'INA226 on peut voir que l'on peut faire la mesure de courant en low-side (côté GND) ou high-side (côté positif).
- un INA226 est utilisé en milliampèremètre (shunt de 100mΩ) et voltmètre en high-side
- un INA226 est utilisé en microampèremètre (shunt de 10Ω) en low-side
- un MOSFET canal N permet de court-circuiter le micro-ampèremètre lorsque la mesure est effectuée par le milliampèremètre
Le micro-ampèremètre est situé côté low-side car pour commander le MOSFET canal N il faut que sa source soit au GND, et que sa grille soit commandée par une tension positive suffisamment élevée (5V).
Le MOSFET est saturé en permanence, ce qui court-circuite le shunt de 10Ω du microampèremètre et permet d'éviter une chute de tension trop importante pendant la mesure des courants importants.Quand le courant mesuré sur le milliampèremètre est inférieur à 5mA, une tension de 0V est appliquée sur la grille du MOSFET afin de mettre en service le shunt de 10Ω. Une mesure est alors réalisée par le microampèremètre.
Le schéma est réalisé à l'aide de KICAD.
Pour récupérer le projet voir plus bas : 8. Téléchargements
Vous pouvez aisément essayer ce montage sur une breadboard.
5. IDE ARDUINO
Il vous faudra installer les bibliothèques ARDUINO suivantes :
Librairie Bounce2 : https://github.com/thomasfredericks/Bounce2
Librairie INA226 : https://github.com/jarzebski/Arduino-INA226
Librairie GFX : https://github.com/adafruit/Adafruit-GFX-Library
Librairie SSD1306 : https://github.com/adafruit/Adafruit_SSD1306
Dans
votre IDE (arduino-cc 1.8.5 par exemple), dans le menu "Outils/Type de
Carte" choisir "Arduino MEGA".
6. Le code
Pour récupérer le projet voir plus bas : 8. Téléchargements
7. Photos
Voici quelques photos du montage réalisé :
La MEGA avec quatre pieds plastique.
La charge mesurée (à gauche) est une carte d'expérimentation MYSENSORS, montée en thermomètre basse consommation.
Elle est équipée d'un ARDUINO MINI, d'un module NRF24L01 et passe la plupart de son temps en mode sommeil profond. Toutes les 10 secondes elle se réveille pour effectuer une mesure de température et envoyer celle-ci via le module NRV24L01 à une passerelle MYSENSORS reliée à un serveur DOMOTICZ.
La carte est alimentée en 3.7V, et possède un régulateur 3.3V consommant à lui tout seul 14µA.
Cet exemple illustre parfaitement l'utilisation du banc. Le but est de connaître avec précision la consommation moyenne de la carte afin de dimensionner correctement la batterie LITHIUM-ION qui l'alimente.
Comme on le voit sur le graphe en 1.2, la carte consomme 15.5µA en mode sommeil, 33mA lors de l'émission des données, ce qui donne une moyenne de 75µA.
Avec une batterie de 600mAH, l'autonomie serait donc de 8000 heures, soit 333 jours.
La période de 10 secondes a été choisie à titre d'exemple pour cet essai. Une période de mesure de plusieurs minutes serait plus adaptée pour un thermomètre, et la consommation moyenne serait encore plus basse.
Mon thermomètre sur batterie effectue une mesure toutes les 15 minutes. Il est en service depuis décembre et affiche encore une capacité batterie de 92%.
Mon détecteur de mouvement consomme 65µA. Il est en service depuis fin avril et affiche une capacité batterie de 77%.
8. Téléchargements
Le projet est disponible ici : https://bitbucket.org/henri_bachetti/ina226-usb-power-bench.git
Le logiciel PYTHON est fourni : INA226_powerbench.py
Cette page vous donne toutes les informations nécessaires :
https://riton-duino.blogspot.com/p/migration-sous-bitbucket.html
9. Bibliographie
Le sujet sur le forum ARDUINO :https://forum.arduino.cc/index.php?topic=545217.0
Le projet sur le forum ARDUINO :
https://forum.arduino.cc/index.php?topic=561033.0
10. Mises à jour
01/08/2018 : améliorations du code.02/11/2018 : ajout du paragraphe 1. La théorie
12/01/2019 : ajout de photos
22/03/2019 : déménagement du projet vers BitBucket.org
08/09/2019 : 4. Le schéma (synoptique)
Salut,
RépondreSupprimerJ'ai un montage qui en veille consomme 9,32��A.
J'ai la chance d'avoir un Fluke 287 qui permet d'enregistrer à une fréquence programmable. J'ai choisi hier "toutes les secondes".
Quelle différence j'aurai entre ce montage et le Fluke ?
Si j'ai bien compris la valeur par défaut de la période d'échantillonnage est de 2 secondes dans le code.
Pour mon Fluke, j'ai écrit un code Python qui me permet de récupérer les données sur mon pc. Le gros inconvénient est que ça me consomme beaucoup de courant (6 piles LR6) ☹️
De plus je n'ai pas écrit de code pour afficher les courbes. J'utilise l'affichage des tendances (courbes) sur le multimètre.
Je pose cette question avant de ma lancer dans la réalisation. En gros est-ce que ça m'apportera un plus (en dehors du plaisir de la réalisation) ?
Autre question, pourquoi un Arduino MEGA ?
L'affichage après publication est bizarre.
SupprimerLes deux points d'interrogation, c'était le symbole "micro".
Il fallait donc lire 9,32 microampères
Salut,
SupprimerJ'ai compris pour le MEGA. J'ai retrouvé l'historique du projet sur le forum arduino.
Ça me fait beaucoup de lecture...
Avec mon Fluke, et mes mesures toutes les secondes, je manque beaucoup trop de choses.
Quel est ton échantillonnage final ?
L'échantillonnage final est celui de l'ADS1115 (860 samples/seconde), si l'affichage sur le mini-écran n'est pas activé bien sûr.
SupprimerLes deux secondes dont tu parles encadrées par une directive de compilation :
#if DEBUG & DEBUG_INA226
Bonjour,
RépondreSupprimerJe vais finalement me lancer dans le montage. J'ai commandé les composants.
Je n'ai pas de MEGA, et n'ai pas trop envie d'en acheter une. Elle ne me servirait pas beaucoup, et est un peu chère.
J'ai par contre des stm32F103 (bluepill).
J'ai compilé ton programme pour cette plateforme, et ça passe.
Il a fallu que j'utilise les cartes ST. Sinon j'avais des problèmes avec la classe EEPROM. "get" et "put" n'y étaient pas définies. Et je voulais éviter de modifier le code pendant le portage en utilisant "read" et "write".
Je voudrais ton avis. Si j'ai bien compris, je n'ai qu'à adapter quelques broches pour que tout fonctionne. Il s'agirait de: GUI_SWITCH, MOSFET_GATE, BUTTON, et éventuellement LED. C'est bien ça ?
Merci d'avance.
La BluePill est un bon choix, bien plus puissante qu'une MEGA.
SupprimerEn faisant rapidement le tour, oui cela devrait être tout, à moins d'adopter les pins correspondantes à D5 D6 D13 D8, PB4 PB3 PB_15 PA_12.
Il vaudrait mieux faire un petit essai sur breadboard pour valider tout ça quand même.
Super. Merci infiniment.
SupprimerJe te tiendrai au courant ici du résultat quand j'aurai reçu le matériel.
Oui, je ferai ça sur breadboard.
En fait le plus compliqué, c'est ce que tu as fait. Là, c'est de la simple adaptation.
Salut,
RépondreSupprimerJ'ai quelques remarques, et quelques questions. J'espère que tu auras le temps de répondre à ces quelques points.
En fait, comme j'attends les composants, je me suis plongé dans la lecture du code, et l'examen du schéma.
Certaines choses peuvent te sembler évidentes, elles le sont moins pour moi (et probablement pour d'autres).
Voici pour les remarques:
1 - La led est allumée dès le début (setup). Elle est reliée au +5V et à D13. Comme elle est initialisée à LOW sur D13, elle est donc allumée. Est-ce voulu ?
2 - Du fait du point précédent, la led s'éteint quand il y a transfert de données. C'est voulu ? Habituellement on fonctionne de manière inverse.
3 - La led est connectée à D13 dans le programme, et à D4 sur dans le schéma sur git
4 - La led ne figure pas sur le schéma de la page web actuelle
5 - Dans la loop, on a un test sur GUI_SWITCH à High. Dans ce cas, on déclare la variable "started", et on l'initialise à "HIGH". Du coup le test "! started" sera toujours vrai, et le "started=true" ne sert pas. C'est ça où je me trompe ?
J'ai également quelques questions:
1 - On ne peut calibrer que quand GUI_SWITCH est relié à GND, c'est bien ça ?
2 - les deux modules INA226 sont alimentés en 5V. C'est voulu ? Ce n'est pas possible, ou pas recommandé en 3,3V ?
3 - Autre point relatif à mon ignorance:
Quand je mesure une intensité avec mon multimètre, je l'intercale entre l'alim et la charge.
Ici, je vois un "input" et un "output". Pourrais-tu stp expliquer comment se fait le branchement du banc par rapport à la charge et son alimentation.
Je n'ai pas tout vu donc pas tout compris. J'espère que tu permettras que je te pose plus tard quelques questions complémentaires si besoin était.
Merci d'avance
1-4) Oui je sais. Le dernier schéma comporte une LED en D4 qui n'est pas exploitée dans le code. Je n'ai pas encore eu le temps de tester cette version. Il faudrait que j'ajoute cette LED sur mon proto.
SupprimerCe n'est pas très grave, il suffit d'inverser la logique de commande de la LED dans le code, ou laisser le code tel quel et utiliser la LED D13.
5) cela sert simplement à afficher le message "SENDING DATA TO SERIAL LINE" une seule fois.
1) Oui.
2) On peut alimenter en 6V maxi. Je n'ai pas vu de minimum dans la datasheet. Je n'ai pas essayé en 3.3V.
3) Le courant entre par la borne 1 de P1, traverse U3, sort par la borne 1 de P2, passe dans la charge, revient par la borne 2 de P2, traverse U4 (ou le MOSFET) et va à la masse.
U3 est en high-side, u4 en low-side. Cela fait 2 ampèremètres, et non pas un seul.
Brancher une alim sur P1 (33V maxi), brancher la charge sur P2, c'est tout.
Bonjour Henri,
RépondreSupprimerMerci pour tes réponses.
Je comprends mieux comment ça fonctionne pour le courant, c'est bien plus clair.
Pourrais-tu s.t.p expliquer comment ça fonctionne pour la tension.
J'ai vu dans le code qu'elle est calculée sur U3. J'aurais compris que ça se fasse sur U4 qui est connecté à la charge. Ce ne serait donc pas la tension aux bornes de la charge qui serait déterminée ?
Par ailleurs comment est utilisé VBUS ?
J'ai consulté pas mal de sites et la datasheet de l'UNA226. Il faut être du métier pour comprendre. Et comme tu es plutôt pédagogue...
Si tu as de bonnes docs compréhensibles par un novice, je suis preneur.
Merci encore
J'ai ajouté un synoptique en paragraphe 4.
SupprimerVBUS est l'entrée de mesure de tension.
On pourrait mesurer VBUS sur U3 ou U4, cela ne fait pas une grosse différence. Entre l'entrée V+ de U3 et l'entrée V+ de U4 il y a seulement le shunt de 0.1 ohm de U3. La chute de tension serait minime.
Salut,
RépondreSupprimerMerci beaucoup pour ces explications. Les choses sont plus claires maintenant.
Il ne me reste plus qu'à expérimenter (Aliexpress n'est pas si express que ça).
Juste par curiosité, est-ce que ça aurait un sens de déplacer U4 et le MOSFET vers le high-side, après U3 ?
Ceci dit, je ne souhaite pas créer un débat interminable.
Une nouvelle fois, merci pour ces explications, et ce super article.
Déplacer U4 et le MOSFET vers le high-side, après U3 :
SupprimerJ'ai déjà expérimenté. Il faut un MOSFET canal P, moins courant.
De plus, il ne pourra être commandé directement par l'ARDUINO, à moins d'ajouter un transistor (sauf si l'on se limite à une tension VBUS de 5V).
Cela augmente la complexité, sans aucun avantage.
Voir https://forum.arduino.cc/index.php?topic=545217.0
Salut,
RépondreSupprimerJ'ai pratiquement tout reçu, il me manque juste la résistance de 10 ohms. Je ferai x1000 dans le code en attendant, pour pouvoir commencer les tests.
J'ai réalisé le montage sur breadboard.
J'ai comme indiqué précédemment, utilisé un STM32 (une BluePill, STM32F103C8T6)
J'ai utilisé les même I/O, mais j'ai augmenté la taille du buffer : 1000 au lieu de 400, car j'ai plus de RAM.
J'ai également augmenté la vitesse de communication entre le banc de mesure et le PC. Je suis passé à 2000000 baud.
Je n'utilise plus Python 2 car il va être abandonné. J'ai donc porté le code en Python 3.
Le sketch fonctionne parfaitement. J'ai dû très légèrement modifier le code Python, car la boucle sur le compteur ne coincidait pas avec avec les valeurs stockées dedans (temps). Je ne sais pas si c'est bien la dernière version qu'il y a sur le git.
On peut donc dire que tout est OK.
Il me reste une question. Dans le sketch, quand le courant est inférieur à 5mA, on active l'INA226 low-side, et là il y a une attente de 2 secondes (delay 2000). À quoi elle sert ?
Le risque est de louper des parties importantes de début de phases de réveil si on analyse un montage qui est la plupart du temps en veille, et qui n'est vraiment actif que durant quelques secondes. Dans le cas d'un Arduino avec une boucle sur des veilles de 8 secondes, on risque même de ne pas en voir plusieurs.
Cette attente est-elle indispensable (ex stabilisation de l'INA ou du MOSFET) ?
Merci par ailleurs pour les explications concernant l'éventuel déplacement de U4.
Effectivement c'est une boulette.
RépondreSupprimerDans une autre version j'ai un temps de stabilisation de 20µS, et 2s en DEBUG.
J'ai fait un commit.
merci et bravo pour la réalisation.
Bonjour Henri
RépondreSupprimerJ'aurais besoin de ton avis.
J'ai utilisé le banc avec un montage à base de STM32 sans aucun problème.
J'essaye de l'utiliser avec un autre montage à base d'ESP8266.
Ce montage fonctionne bien sans passer par le banc.
Quand j'utilise le banc, tout va bien durant la phase de repos. Mais dès qu'un réveil se produit ça ne va plus.
Au réveil, j'envoie des données à un serveur web en wifi. L'ESP8266 consomme beaucoup durant ces phases. J'ai donc une alimentation externe suffisante.
Curieusement l'ESP8266 se met à consommer du courant sans arrêt, et n'envoie rien. J'ai l'impression que c'est la variation brutale d'intensité. On passe de 100 uA à environ 110 mA, avec des pics à 450 mA. Le tout sous 3,3V.
Si je démarre en phase de marche, tout va bien. Je passe ensuite en phase de repos normalement. Puis à la phase de marche suivante, ça bug. C'est vraiment le passage du repos à la marche qui ne va pas.
Je ne sais pas si c'est important, mais l'ESP8266 passe de repos à marche par un reset.
Est-ce que le banc peut supporter ces variations ?
Sinon, aurais-tu une idée de ce qui se passe ?
Ce phénomène est reproductible.
Merci d'avance.
Information complémentaire importante, si j'arrête le sketch (avec un exit(0) dans la loop), la charge se met à fonctionner correctement. Il faut toutefois un redémarrage de celle-ci.
RépondreSupprimerJe m'arrache les cheveux...
Effectivement l'ESP8266 consomme bien 450mA pendant la phase de connexion WIFI. A travers un shunt de 100mΩ cela devrait occasionner une chute de tension de 45mV. Est-ce gênant ?
SupprimerIl faudrait mesurer la tension d'alimentation sur la carte ESP.
Salut Henri,
RépondreSupprimer45mV de chute, ça ne devrait pas gêner.
Je pense que c'est la partie low-side qui me pose problème.
Voici ce qui me fait dire ça:
J'ai modifié la charge pour qu'il y ait juste un esp8266 nu, et une led.
J'y ai mis un sketch minimal (blink)
Quand j'alimente directement la charge, ça fonctionne normalement.
Quand je passe par le banc, ça ne fonctionne plus. Le sketch ne s'exécute pas.
Je suis alors passé par le high-side seul. C'est à dire que j'ai branché le + de la charge à la borne (1) de out, et le - directement à la masse. Et là, ça fonctionnait bien. C'est donc bien le low-side qui pose problème, non ?
Je soupçonne le shunt. J'ai effectivement mis une résistance de type 1206, et non 2010, comme tu le demandes. Est-ce que ce ne serait pas là qu'il y aurait une limitation du courant ?
Je ne vois que ça comme explication.
Non. Il y a une autre explication. Si le MOSFET n'est pas commandé le shunt low-side reste en série. A vérifier.
SupprimerBonjour Henri,
RépondreSupprimerDésolé d'avoir tardé à répondre. Je voulais vérifier un maximum de choses.
Tout à l'air d'être correct, y compris le MOSFET qui est bien commandé.
J'ai fait de nouveaux tests avec un ESP32, et là tout va bien.
Il n'y a donc que l'ESP8266 qui pose problème.
J'ai commandé une nouvelle alimentation pour le cas où l'actuelle serait insuffisante. J'avoue que je tâtonne un peu...
En tout cas, le souci ne paraît pas avoir pour origine le banc.
Autre chose, j'ai modifié un peu le sketch.
Comme j'ai maintenant un très gros buffer, j'ai augmenté la fréquence d'échantillonnage, et le SEND_DATA_DELAY. Malgré tout, le script python peut se terminer sans avoir reçu toutes les données. J'ai donc ajouté une fonction de "flush" du buffer. En effet, le bouton ne sert pas en mode "sending serial data".
Si on appuie sur le bouton à ce moment-là, on force le "flush" du buffer. Du coup, je mets "duration" à une valeur très élevée dans le script Python, et quand je veux terminer la relève, j'appuie sur le bouton. Un message de fin est envoyé avec les données, et le script Python s'arrête.
Je n'ai jamais essayé le banc avec un ESP8266. Pour mes projets basse consommation je préfère ARDUINO PRO MINI + NRF24L01.
SupprimerToutes modifications du sketch sont les bienvenues.
Bonnes mesures.
Salut Henri,
RépondreSupprimerBonne nouvelle. J'ai refait le montage avec un ESP32. Tout fonctionne bien.
J'ai juste été obligé de modifier les broches. Celles du montage original ne convenaient pas pour un ESP32.
À noter qu'avec ce nouveau banc, j'ai le même souci en mesurant un ESP8266.
J'ai pourtant utilisé de nouveaux composants. Par contre question RAM, j'ai 9000 entrées dans le buffer...
J'avoue que c'est surpuissant pour le besoin.
Sinon, pour un autre montage sur batterie, j'ai également utilisé un Arduino Pro Mini, mais avec un boitier Sigfox (concurrent français de Lora).
Bonjour Henri,
RépondreSupprimerJ'ai continué à travailler sur mon problème lié à l'utilisation d'un montage à base d'ESP8266.
Je pense avoir trouvé ce qui n'allait pas dans mon montage, mais je souhaiterais avoir ton avis.
Tu avais raison. C'est bien un problème de commande du MOSFET. Je pense que je ne l'avais pas vu, car tout semblait bien aller.
Sur mon dernier montage du banc à base d'ESP32, tout comme sur le STM32, je suis en full 3,3V.
J'avais bien vu que tu utilisais du 5V, mais je pensais que c'était du fait de l'utilisation d'une MEGA.
J'ai relu et décortiqué ton billet, et j'ai fini par lire "et que sa grille soit commandée par une tension positive suffisamment élevée (5V)".
Du coup, j'ai été voir comment fonctionnaient les MOSFET. Bref, comme mon dernier banc est basé sur une carte Wemos LOLIN32, alimenté par l'USB, j'ai du 5V en entrée. J'ai donc ajouté un transistor (BC548) et deux résistances en "level shifter". Le signal est inversé, mais la pin GATE du MOSFET fonctionne en 5V.
J'ai également inversé la logique dans le code (enableLowPowerShunt et disableLowPowerShunt). Ça fonctionne mieux avec la charge à base d'ESP8266. Pas dans 100% des cas, mais c'est nettement mieux.
J'ai compris que ça passait pour les charges plus faibles, mais pas pour l'ESP8266 qui ne démarrait pas vraiment. L'alim elle, débitait beaucoup et chauffait.
Je vais maintenant soit ajouter un deuxième transistor pour remettre la logique à l'endroit, soit remplacer le MOSFET. Si tu connais un modèle qui irait avec un fonctionnement en 3,3V pour avoir un interrupteur fermé, je serais preneur.
Pour le STM32, j'utilise une alim externe en 3,3V
Rappelle-toi que je ne suis pas électronicien, juste un bricoleur, et que je peux me tromper dans cette conclusion.
J'attends ton avis, et t'en remercie d'avance.
J'espère que tu as bien utilisé un IRLZ44N et non pas un IRFZ44N.
SupprimerSinon, il faudrait utiliser un MOSFET ayant une tension VGSth plus faible, et une résistance RDSon faible. En TO220 ça va être dur.
J'en connais un : AO3400, AO4400 (CMS SOT23)
Bonjour Henri. Merci pour ta réponse.
RépondreSupprimerOui, j'ai bien utilisé un IRLZ44N.
J'ai commandé des AO3400, en SOT23 donc. Je vais les souder sur des adaptateurs SOT23-SIP3, car c'est pour une breadboard.
Je te dirai le résultat, mais j'ai bon espoir.
Bonjour et merci pour ce bel outil! Je viens de terminer la réalisation. J'ai juste ajouté des connecteurs USB types B et A pour, respectivement, l'entrée et la charge. Cela fonctionne parfaitement!
RépondreSupprimerPar contre, j'ai un problème avec le programme en python. N'étant pas programmeur, je galère un peu. J'ai eu plusieurs erreurs indiquant qu'il manquait des parenthèses dans les lignes "print". Je les ai ajoutées. J'ai également installé les lirairies et fixé le n° de port série. J'ai maintenant l'erreur suivante : line 37, in
if not s.startswith('INA226 POWER BENCH') and not s.startswith('read current offset from EEPROM'):
TypeError: startswith first arg must be bytes or a tuple of bytes, not str
J'utilise python 3.9.2 sous windows.
Une piste serait la bienvenue ;-)
Cordialement
PYTHON 3 est probablement la source des problèmes.
SupprimerPersonnellement j'ai utilisé PYTHON 2.7
J'ai constaté que le type de la variable "s" obtenue par readline() était "byte". Je l'ai donc convertie en string. Premier problème réglé. Le test startswith ne fonctionnait pas. Un print(s) me donnais b'INA226 POWERBENCH\r\n' . Pour ne pas trop chercher, j'ai changé la méthode de test par find. Il m'a fallu également spécifier le départ de la recherche dans la chaîne: if not s.find("INA226",0) and not s.find('read',0):.
RépondreSupprimerJ'ai également spécifié le début de la recherche dans find('V') et find('I') : if s.find('V',0) != -1: et if s.find('I',0) != -1:
Le programme se lance sans erreur et après le temps écoulé, une fenêtre graphique s'ouvre. Par contre, les valeurs affichées sont nulles et le graphique est vide. Je poursuivrai les recherches dès que possible.
Modifications à partir de la ligne 36
RépondreSupprimers = str(line.readline())
s=s[2:-5] pour enlever les caractères indésirables de s
if s.find("INA226",0) == -1 and s.find('read',0) == -1:
if s.find('V',0) != -1:
...
if s.find('I',0) != -1:
J'obtiens bien l'affichage des valeurs ainsi que le récapitulatif.
Par contre, le graphique est toujours vide:-(
Une idée??
Au temps pour moi, le graphique vide était dû au manque de variations du courant ;-) Tout est en ordre sous python 3.9.2.Encore merci.
RépondreSupprimerPour être complet, j'ai également modifié la ligne 34 comme suit :
RépondreSupprimerline = serial.Serial(port=sys.argv[1], baudrate=230400, timeout=1000, parity=serial.PARITY_NONE)
Désolé de m'être un peu étalé mais je ne suis pas trop programmation ;-)
OK. Bonnes mesures.
SupprimerPar contre, concernant la protection, si le fusible grille, l'entrée de l'INA est toujours alimentée. Ne faudrait-il pas connecter l'entrée de l'INA de l'autre côté du fusible ?
RépondreSupprimerOui, effectivement. Bonne remarque. Il faut que je corrige cela.
SupprimerBonjour, j'ai une question concernant votre code :
RépondreSupprimer"long shuntVoltage = ina226_H.readRegister16(INA226_REG_SHUNTVOLTAGE) * 25L;"
Que signifie le "*25L" à la fin ?
Bonjour.
SupprimerCela signifie 25 en version long.
Sans cela l'opération se ferait sur un int16_t, le type retourné par readRegister16(), et cela risquerait de déborder.
Merci pour la réponse rapide ! J'ai une autre question concernant la fonction SendDatas(void), elle envoie les données de où vers où ?
SupprimerJ'en profite pour faire une autre demande. Dans le code suivant :
SupprimerWire.beginTransmission(addr);
Wire.requestFrom(addr, 2);
while (!Wire.available()) {};
uint8_t vha = Wire.read();
uint8_t vla = Wire.read();
Wire.endTransmission();
J'ai du mal à comprendre ce que représentent les variables vha et vla et en quoi elles sont utiles dans le programme.
La fonction SendDatas() envoie les données sur la ligne série, vers un PC par exemple.
Supprimervha et vla sont les valeurs lues dans deux registres de l'INA226. Elles sont ensuite combinées pour former un entier : value = vha << 8 | vla;
SupprimerBonjour, merci je comprends mieux maintenant. J'ai une dernière question qui concerne plus le fonctionnement global. J'ai du mal à comprendre par où passe le courant lorsque l'INA avec le shunt de 10 ohm est utilisé. L'entrée V+ de l'INA avec le shunt de 10 ohm est connectée au OUT et le V- au ground. Est ce que vous pouvez juste dire par où passe le courant dans ce cas de figure ? Merci d'avance !
SupprimerLe courant entre dans U3 V+, ressort par U3 V-, passe par la charge (OUT), entre dans U4 V+, ressort par U4 V-, et GND.
SupprimerComment se justifie le choix du high side / low side pour chacun des INA (de ce que j'ai compris, pour l'INA de droite c'est lié au MOSFET mais il y a t'il d'autres raisons ?)
SupprimerLe premier INA226 mesure également la tension, donc il doit être HIGH-SIDE. L'autre peut être LOW-SIDE, car il ne mesure que le courant.
SupprimerBonjour et merci pour vos articles qui m'accompagnent souvent dans mes montages. Si je souhaite mesurer des courants de 4 A en 5 V, il faut que je change la valeur de la charge (20 mΩ)! Et quand est-il de la puissance de celle-ci ? Je dois mettre une résistance de 20 W ?
RépondreSupprimer20W ? non pas du tout. Il suffit d'appliquer la formule :
SupprimerP = R * I² = 0.020 * 4² = 0.32W
Les shunts que j'ai utilisé sont des CMS 2010, 1W, qui se soudent facilement.
Bonjour et un grand merci pour la clarté de vos article. Dans ce dernier, je n'ai pas su voir quelles adresses vous affectiez à chaque périphérique I2C (INA226 et Afficheur SSD1306). serait il possible de préciser cette information ou de m'indiquer ou cette dernière est "cachée". Merci
RépondreSupprimerDans le code : https://bitbucket.org/henri_bachetti/ina226-usb-power-bench/src/master/arduino/INA226_powerbench/INA226_powerbench.ino
SupprimerINA226_ADDRESS (adresse par défaut INA226)
0x3C pour l'écran
Merci, mais il y a 2 INA226 et il faut bien leur donner une adresse physique en I2C différente. Quelle adresse pour chaque INA226 ?
RépondreSupprimerTout est dans le code. Il suffit de savoir lire :
Supprimerina226_H.begin(0x41);
ina226_L.begin(0x40);
Merci
SupprimerBonjour Henri,
SupprimerTout d’abord un grand merci a toutes les infos que tu donnes sur ton blog. C’est un puit de sciences pour moi.
Une question sur ce banc de test, est-il possible d’utiliser un Arduino Uno pour le réaliser ou la mémoire flash et la Sram du Méga sont indispensable ?
Je te remercie.
Bien à toi
Thomas
Non, une UNO n'a pas suffisamment de mémoire RAM.
SupprimerMerci de ton retour. Effectivement en lisant le forum, j'ai vu que ce n'est pas possible l'Arduino UNO. Du coup je vais essayer avec un esp32. Vu que les sorties GPIO sont en 3.3V, penses tu qu'il est possible de commander le MOSFET IRLZ44N avec du 3.3v ?
SupprimerJe te remercie,
Thomas
Tu peux t'inspirer de ceci :
Supprimerhttps://riton-duino.blogspot.com/2020/01/un-logger-analogique-et-digital-version.html
Il n'y a qu'un seul INA226 mais on peut en ajouter un deuxième.
L'IRLZ44N est OK pour une commande en 3.3V (éviter l'IRFZ44). Un AO3400 (CMS) est encore meilleur si le courant à mesurer est inférieur à 5.6A.
https://riton-duino.blogspot.com/2019/01/mosfets-de-puissance.html
Super. Merci de ton retour. Je vais étudier tout ça. Je suis en train de réaliser une alarme moto autonome (non connecté à la batterie de la moto) et je souhaite diminuer au maximum la consommation. Pour cela il faut un petit banc de test pour mesurer la consommation.
SupprimerJe te remercie en tout cas.
Bien à toi
Thomas
Bonjour Henri,
SupprimerJe suis de nouveau sur ce sujet 3 ans après.
J'essaye de porter l'appli sur un ESP-32-S2 (après l'avoir fait avec succès sur un stm32 puis un ESP32 ancienne génération). Je rencontre un souci et voudrais savoir si tu as une idée. Le programme "bloque" dans readShuntCurrent juste au moment d'exécuter "long shuntVoltage = ina226_H.readRegister16(INA226_REG_SHUNTVOLTAGE) * 25L;".
Je me doute bien que diagnostiquer ça de cette manière ne dot pas être évident. Mais aurais-tu une idée de ce qu'il se passe, et éventuellement où chercher. C'est tout simplement bloqué sur cette instruction, ça ne va pas plus loin.
Merci d'avance
nbenm
Encore plus précis, c'est dans readRegister16 sur la ligne Wire.requestFrom(addr, 2); que ça bloque. Là, je sèche.
RépondreSupprimerJ'avance. J'ai trouvé un post dans lequel on disait que pour l'ESP32 (l'ancien), pour les accès i2c, il fallait enlever le beginTransmission qui précède un Wire.requestFrom. Je l'ai commenté, et ça va mieux. Ceci dit il y a d'autres soucis. la pin GUI_SWITCH est en INPUT PILLUP. J'ai l'impression que ce n'ai pas le cas sur le S2. J'ai systématiquement sending serial. J'ai branché un fil sur le +, et là, j'ai voltage et current. Bon, je continue, ça a l'air de se débloquer progressivement. Je vais arrêter de polluer ce fil, je ferai juste un récap à la fin (si ça fonctionne).
RépondreSupprimerTout fonctionne. Il y a juste le beginTransmission à commenter. Pour le reste c'était une erreur de câblage sur breadboard. Test effectué sur un module ESP32-S2-DevKitM-1 équipé d'un ESP32-S2-MINI-1 en fait un FN4R2 (4M de flash, et 2M de PSRAM). Je suis vraiment content de ce montage qui me rend bien des services. J'en ai profité pour remplacer la bibliothèque EEPROM par "Preferences". C'est ce qui est recommandé actuellement. Merci pour tout.
RépondreSupprimerSalut.
SupprimerQu'est ce qui t'a poussé à porter sur S2 ?
Le module que j'utilisais était à base de Wrover sans PSRAM. Quand j'ai voulu passer au Wrover, toutes les docs espressif disaient qu'il était obsolète, et qu'il fallait utiliser les nouvelles série. Le S3 était trop gros (dual core). J'ai également commandé un C3, mais le S2 est arrivé plus vite...
SupprimerJe voulais surtout de la PSRAM car je fais des relevés sur de longues périodes. La petite taille du buffer (8000 entrées sur l'ESP32) me faisait perdre des données au moment du "flush". Là je suis passé à 150000, et je peux aller jusqu'à 175000 environ.
OK je vois. En tous cas, je suis content que ce projet te rende service.
SupprimerBonjour Henri,
SupprimerJ'avais une limitation à environ 1000 échantillons par seconde, soit 1KHz.
Ça me gênait dans les montées brusques de tension, et par conséquent d'intensités.
Je voulais augmenter cette fréquence.
J'ai cherché, et je me suis plongé en particulier dans la lecture de la datasheet de l'INA226.
J'ai trouvé cette phrase:
"The INA226 supports the transmission protocol for fast mode (1 kHz to 400 kHz) and high-speed mode (1 kHz to 2.94 MHz)."
J'ai donc essayé de me renseigner sur ce mode high-speed.
J'ai fait un petit montage avec un seul INA et un code minimaliste dans lequel il y a une itération sur 100000 appels à la fonction readShuntCurrent.
En ajoutant la ligne "Wire.setClock(1000000);" après "Wire.begin();", le traitement est 4 fois plus rapide.
J'avais auparavant supprimé le delay(1) qui était présent (à tort) dans readRegister16.
J'ai essayé d'autres valeurs comme 4000 ou 2940000, ce n'est pas mieux.
Je n'arrive pas à atteindre le MHz.
Pour résumer: dans readRegister16, j'ai enlevé delay (1),
le begin transmission, et le end transmission (il y a des "issues" à ce sujet sur le github).
J'ai également enlevé le while available inutile lui aussi. Voilà pour readRegister16.
Dans begin de MyINA226, j'ai donc ajouté le fameux "Wire.setClock(1000000);"
Et enfin, dans le setup, j'ai remplacé le millis par micros, vu qu'on dépasse 1KHz.
J'aurais voulu aller encore plus vite...
J'aimerais savoir ce que tu penses de ça.
nb
Je pense que le problème avec l'INA226 se situe plus au niveau du nombre d'échantillons possibles par seconde (SPS) qu'au niveau I2C.
SupprimerAvec un capteur analogique, je pense que la vitesse serait bien supérieure :
https://riton-duino.blogspot.com/2020/07/lina138-current-monitor.html
Salut Henri,
RépondreSupprimerCe petit post juste pour te dire que la bibliothèque de jarzebski est en jachère. Le développeur est aux abonnés absents. Il ne répond à aucune "issue".
Il existe une autre bibliothèque tenue par RobTillaart. C'est un Hollandais extrêmement dynamique. J'ai eu des contacts avec au sujet d'une lib FRAM. Il réagit très vite et est vraiment pointu, voire perfectionniste. C'est un vrai plaisir.
Je te recommande vraiment de voir ce qu'il a fait pour l'INA226. Même si ce sujet semble un peu remplacé par le projet INA138.
Merci pour tes articles. Je suis comme toi informaticien. Et en ce qui me concerne électronicien du dimanche. C'est un plaisir de les lire, (tes articles) ce que je fais depuis 2019.
Merci du conseil. En effet RobTillaart est très connu dans le monde ARDUiNO, et très actif.
SupprimerL'INA138 est analogique, ce qui pourrait être une bonne chose d'un point de vue rapidité, allié à un µcontrôleur musclé du genre STM32, ou même ESP32.