Modules de mesures de tension, courant et puissance

1.1.1        L’INA219

1.1.1.1       La théorie

Le module INA219 permet de mesurer la tension, le courant et la puissance électrique dans un circuit. Il se contrôle en I2C et permet de récupérer les mesures via ces registres internes. Il peut mesurer la  tension jusqu’à 32V et le courant jusqu’à 3.2A, soit une puissance de plus de 100W.

Le datasheet se trouve à l’URL http://www.ti.com/lit/ds/symlink/ina219.pdf


 

1.1.1.2       L’électronique

Le module se connecte très simplement sur un Raspberry via les 4 broches VCC, GND, SCL et SDA. La tension d’alimentation sera plutôt en 3.3V pour éviter les problèmes de tension sur le bus I2C.

INA219

Raspberry

VCC

3.3V : Pin 1 ou 17 (Il peut également être alimenté en 5V, mais dans ce cas, il faut faire attention à ce que la broche SDA du Raspberry ne reçoivent pas plus de 3.3V)

GND

Masse : Pin 6, 9, 14, 30, 34 ou 39

SDA

SDA : Pin 3

SCL

SCL : Pin 5

 

Par contre, la connexion de l’appareil à mesurer demande plus d’attention.

-          La tension positive de l’alimentation de l’appareil à mesurer doit être branchée au Vin+

-          La broche positive de l’appareil à mesurer doit être branchée au Vin-

-          Les masses de l’alimentation de l’appareil à mesurer, de l’INA219 et du Raspberry doivent absolument être connectées entre elles.

La mesure se fait à travers une résistance de 0.1Ω que l’on voit très bien sur le module  . Cette résistance est en série entre l’alimentation et le circuit à mesurer et occasionnera une très faible chute de tension dans l’alimentation de ce circuit.

Sur un schéma, cela donne quelque chose comme ceci.


 

1.1.1.3       Les logiciels

1.1.1.3.1      Bases communes

L’adresse du module est par défaut à l’adresse 0x40 (attention : c’est la même adresse que l’adresse de base du PCA9685).

L’adresse peut être normalement paramétrée pour prendre une valeur entre 0x40 et 0x47, mais dans le module, seul les adresses 0x40, 0x41, 0x44 et 0x45 peuvent être utilisé en soudant les deux broches A0 et A1 sur le module.

Toutes les adresses possibles avec le circuit seul:


 

Les adresses possibles sur le module :

J’ai positionné mon module en 0x45

Le module stocke les mesures dans différents registres

-          Le registre 00 de configuration permet de sélectionner les échelles de mesure, et les temps de mesure. Il sert également au Reset du module.

-          Le registre 01 donne la tension aux bornes du Shunt (La grosse résistance sur le module). Le shunt fait normalement 0.1Ω (si vous êtes soigneux, vous pouvez toujours le changer pour avoir une autre échelle de mesure) et la tension à ces bornes peut aller jusqu’à ±320mV. C’est la tension entre les bornes Vin+ et Vin-

-          Le registre 02 donne la tension du bus, c’est-à-dire la tension entre la sortie du shunt (Borne Vin-) qui est également l’entrée de l’appareil à mesurer et la masse

-          Le registre 03 donne la puissance. La puissance est fonction du registre de configuration. Si le registre configuration est à 0, le registre puissance sera à 0.

-          Le registre 04 donne le courant. Le courant est fonction du registre de configuration. Si le registre configuration est à 0, le registre courant sera à 0.

-          Valeur permettant au module le calcul de la puissance et du courant en fonction de la configuration. Cette valeur demande un calcul assez complexe.

A chaque demande de la tension de Bus ou de Shunt, une conversion est faite qui prendra le temps paramétré dans le registre de configuration. Par contre, les demandes de puissance et de courant ne prennent pas de temps.

Calcul de la calibration :

Le registre de calibration doit recevoir une valeur qui lui permettra de calculer la puissance et le courant. La procédure pour trouver cette valeur est la suivante :

-          Courant Max Possible = Tension de Shunt Max / Résistance Shunt

-          Pas minimum pour 15 bits = Courant Max Possible / 32767

-          On prend une valeur ronde très proche de cette valeur

-          Calibration = trunc(0.04096 / (Valeur arrondie * ResistanceShunt))

Soit par exemple

-          On choisit un gain / 4 (PG0 et PG1 du registre de configuration), donc Tension de Shunt max = 160mV

-          Courant Max Possible = 160mV / 0.1Ω = 1.6A

-          Pas minimum pour 15 bits = 1.6 / 32767 = 0.0000488296, soit environ 49µA par bit

-          On prend 50µA comme valeur ronde la plus proche

-          Calibration = trunc(0.04096 / (50*10-6 * 0.1)) = 8192

Fonctionnement sans calibration :

On peut également s’affranchir de cette valeur de calibration en faisant le calcul du courant et de la puissance dans le programme lui-même. Cela prendra par contre du temps machine.

-          Courant = Registre 01 / 0.1, soit VShunt / résistance de Shunt.

-          Puissance dans le montage à mesurer = Registre 02 * Courant, soit Tension de Bus * Courant

-          Puissance totale = (Registre 01 + Registre 02) * courant, soit (Tension de Shunt + Tension de Bus) * Courant

Attention : Comme je l’ai déjà dit, la résistance de Shunt est en série sur l’alimentation, elle occasionnera donc une légère chute de tension dans l’alimentation de l’appareil à mesurer. Dans le pire des cas, avec un courant de 3.2 Ampères, on aura une perte de 0.32V, ce qui peut être problématique par exemple avec un appareil alimenté en 3.3V qui ne recevrait plus que 2.98V. C’est bien sur un fonctionnement aux limites, mais il faut en être conscient

Le temps de mesure et la résolution des tensions seront fonction du paramétrage indiqué dans le registre de configuration par les bits BADC pour le Bus et SADC pour le Shunt. Il peut varier de 84µs à 68.1ms pour le temps et de 9 (512 pas) à 12 bits (4096 pas) pour la résolution. Le temps et la résolution minimum pourront être par exemple utilisés pour un petit oscilloscope où on recherche le nombre maximum de mesure par seconde.  Le temps et la résolution maximum étant utilisables pour un simple mesureur.


 

1.1.1.3.2      Construction

Le logiciel sera comme d’habitude constitué d’une librairie gérant le module et de différents logiciels pour tester le fonctionnement. Pour le PilotageMoteur, il réutilisera les librairies de gestion des GPIO.

Nom du fichier

Utilité

GestionI2C.h

L’entête de la librairie de gestion de l’I2C

GestionI2C.cpp

Librairie de gestion de l’I2C. Elle permet la lecture et l’écriture en 8 et 16 bits sur un appareil I2C avec ou sans adresse. Deux méthodes y ont été ajoutées depuis la version précédente afin de gérer la lecture en 16 bits avec inversion des deux octets.

GestionINA219.h

L’entête de la librairie de gestion de l’INA219

GestionINA219.cpp

Librairie de gestion de l’INA219. Elle permet de paramétrer le module, de calculer les valeurs de calibration et d’effectuer les mesures. Fourni aussi quelques méthodes pour le fonctionnement.

GestionPin.h 

L’entête de la classe de base de gestion des GPIO

GestionPin.cpp

La  classe de base de gestion des GPIO

GestionPinGPIO.h 

L’entête de la classe de gestion des GPIO

GestionPinGPIO.cpp

La classe de gestion des GPIO

Makefile

Le fichier permettant de compiler le programme grâce à la commande make

MesureurSimple.cpp

Mesureur donnant les tensions, le courant et la puissance consommé

Oscillo.cpp

Permet de constituer le plus rapidement possible un fichier avec 10000 mesures de tension pour faire une courbe du signal sur un tableur ou un logiciel spécifique.

PilotageMoteur.cpp

Permet de protéger un moteur ou un circuit quelconque d’un blocage ou d’un court-circuit

 

La compilation par un simple make


 

1.1.1.3.3      Mesureur simple

Ce logiciel mesure en boucle toutes les valeurs disponibles sur l’INA219 ainsi que le courant et la puissance à partir des valeurs de tension.

Le montage pour le test sera le suivant :

Et le fonctionnement

Par contre, attention, j’ai paramétré le temps de mesure au maximum, soit 68.1ms. Il mettra donc 68.1ms pour mesurer la tension de bus et encore 68.1ms pour mesurer la tension de shunt. Pendant chaque 68.1ms, il effectuera 128 mesures et en fera la moyenne. Ce programme est donc utilisable sur des tensions continues ou à évolution très lente. Si vous l’utilisez sur une tension alternative il donnera la tension moyenne.


 

1.1.1.3.4      Oscilloscope

Le but de ce programme sera de suivre une tension alternative. On va voir jusqu’à quelle fréquence on peut avoir une bonne idée du signal. Le programme enverra ses mesures sur l’écran et pourra être redirigé dans un fichier afin d’être traité ou visualisé sur un tableur ou un logiciel dédié.

Le schéma est extrêmement simple, il suffit de faire passer le signal que l’on veut mesurer entre le Vin+ et le Vin-.

Si vous voulez mesurer une sortie GPIO comme ici, n’oubliez surtout pas de mettre une résistance, car si vous mettez directement le Vin- à la masse, la GPIO ne verra que la résistance de shunt soit 0,1 et essayera donc de fournir 3.3 / 0.1 soit 33A, ce qui signera son arrêt de mort et peut être même celle du Raspberry.N

Le programme sera très simple et ne fera que mesurer la tension et l’envoyer à l’écran pour une possible redirection vers un fichier

#include <iostream>

#include <wiringPi.h>

 

#include "GestionINA219.h"

#include <chrono>     // Chronometre

#include <stdint.h>

 

using namespace std;

using namespace std::chrono;

 

GestionINA219 ina219;

 

int main() {

       ina219.init(ADDR_45);

       ina219.reset();

       ina219.setCalibration_3_2A(_32V, B_9Bits_1S_84US, S_9Bits_1S_84US, BusVoltageContinuous);

       cout << "temps;Bus voltage V" << endl;

       uint32_t initTime = static_cast<long int>(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());

       for(int compteur = 0; compteur != 10000; compteur++) {

             uint32_t time = static_cast<long int>(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());

             cout << time - initTime << ";" << ina219.getBusVoltage_V() * 1000 << endl;

       }

}

Attention, le programme ne fait que la mesure, si vous voulez mesurer ce qui se passe sur l’une des broches (pour moi la GPIO18 qui est le générateur PWM), il faut programmer cette broche dans un autre programme et le lancer dans une autre console ou en tache de font avant l’oscilloscope.

L’exécution du programme

Le programme met plus de 8s pour effectuer ses 10000 mesures, ce qui donne donc environ 865µs par mesure. En ayant mis un temps de conversion à 84µs, je m’attendais à beaucoup moins. Toutefois, le bus I2C et surtout sa commande via un fichier n’est malheureusement pas très rapide. Un temps de mesure comme celui-là donne 1155 mesures par seconde, ce qui fait qu’on peut avoir une bonne idée du signal pour une fréquence de 115Hz maximum.

Par exemple ici, après redirection du résultat dans un fichier et lecture de ce fichier par Excel, une courbe d’un signal pour un servo à 50Hz

Vu le temps de traitement, il est possible de positionner le temps de mesure à 532µs et 12 bits au lieu de 9bits et 84µs, cela ne changera rien à la vitesse de traitement globale et permettra une sensibilité plus grande.

 


 

1.1.1.3.5      Sauvegarde d’un moteur

Ce programme permettra de couper l’alimentation d’un moteur si celui-ci consomme trop de courant, suite à un blocage par exemple.

Le schéma sera le suivant :

La sortie GPIO commandera le moteur via un transistor 2N7000, l’INA219 mesurera le courant et permettra au programme de couper le moteur si celui-ci consomme trop de courant. Il faudra au préalable mesurer le courant consommé par le moteur en fonctionnement normal (avec le programme de mesure simple par exemple) afin de couper en cas de dépassement trop important de cette valeur. Le moteur pourra par exemple être relancé au bout d’un certain temps et coupé définitivement au bout de trois dépassements consécutifs.

Le transistor 2N7000 (https://www.onsemi.com/pub/Collateral/2N7000-D.PDF) accepte une tension de 60V (ne pas dépasser 32V sur l’INA219) et 200mA. Si vous voulez tester un moteur dépassant ces valeurs, il faut prévoir un autre circuit de commande. Personnellement, j’utilise un moteur MDN3 (http://radio-hobby.org/uploads/datasheets/mdn/mdn3.pdf) récupéré sur un lecteur DVD trouvé à la poubelle. Ce moteur peut être alimenté entre 0.7 et 6V et consomme une vingtaine de mA à vide.

Le programme devra être paramétré dans les lignes define au début du programme en fonction du moteur utilisé.

Il faut lui indiquer :

-          La consommation d’alerte, on peut par exemple prendre le courant de fonctionnement plus 20%

-          Le nombre d’erreurs consécutives et d’essais de redémarrage avant un arrêt complet

-          Le temps d’arrêt après une erreur

-          Le temps de démarrage du moteur (Un moteur consomme beaucoup plus au démarrage qu’en fonctionnement établi. Si on ne met pas cette temporisation, le moteur sera tout de suite en erreur)

Le fonctionnement

Le montage


 

1.1.1.4       Liste des programmes

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionI2C.cpp

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionI2C.h

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionINA219.cpp

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionINA219.h

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionPin.cpp

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionPin.h

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionPinGPIO.cpp

https://github.com/montotof123/raspberry/blob/master/295_INA219/GestionPinGPIO.h

https://github.com/montotof123/raspberry/blob/master/295_INA219/Makefile

https://github.com/montotof123/raspberry/blob/master/295_INA219/MesureurSimple.cpp

https://github.com/montotof123/raspberry/blob/master/295_INA219/Oscillo.cpp

https://github.com/montotof123/raspberry/blob/master/295_INA219/PilotageMoteur.cpp


1.1.2        L’INA3221

1.1.2.1       La théorie

Le circuit INA3221 en lui-même est sensé remplacer trois INA219. Toutefois, la logique de cablage de ce module (un CJMCU-3221) est complètement différente. L’alimentation général se fait par les broches POW et GND situé sur le haut du module et les appareils à alimenter le sont via les broches CHx et GND situées sur le coté. Il n’est plus question ici de VIN+ et VIN-. Ce module peut donc mesurer trois canaux à condition qu’ils soient alimentés par la même source.

Les différences par rapport à l’INA219 sont les suivantes :

-          Trois canaux de mesure au lieu d’un, avec bien sur tous les registres pour les contrôler et les lire. Tous les canaux sont par contre alimentés par la même source.

-          Pas de registre de courant et de puissance et donc pas de paramétrage complexe de la calibration pour le calcul de ces valeurs.

-          Plusieurs registres et broches permettant des alertes ou des mises en garde sur les tensions.

-          Maximum 26V et 1.6A par canal.

Image associée

Le datasheet se trouve à l’URL http://www.ti.com/lit/ds/symlink/ina3221.pdf


 

1.1.2.2       L’électronique

Le module est par contre plus complexe à brancher qu’un INA219

INA3221

Utilisation

Raspberry

VS

Alimentation logique

3.3V : Pin 1 ou 17 (Il peut également être alimenté en 5V, mais dans ce cas, il faut faire attention à ce que la broche SDA du Raspberry ne reçoivent pas plus de 3.3V)

GND

Masse logique

Masse : Pin 6, 9, 14, 30, 34 ou 39

SDA

I2C

SDA : Pin 3

SCL

I2C

SCL : Pin 5

PV

Alerte moniteur d’alimentation général

GPIO pour lecture ou interruption

CRI

Alerte critique sur un canal

GPIO pour lecture ou interruption

WAR

Alerte warning sur un canal

GPIO pour lecture ou interruption

TC

Alerte tension minimum trop basse

GPIO pour lecture ou interruption

VPU

Moniteur d’alimentation général

 

POW

Alimentation générale

 

GND

Masse de l’alimentation générale

 

CH1

Alimentation canal 1

 

GND

Masse canal 1

 

CH2

Alimentation canal 2

 

GND

Masse canal 2

 

CH3

Alimentation canal 3

 

GND

Masse canal 3

 

 

Attention : Les borniers ne sont pas fournis, il va falloir les acheter à part ou faire un cablage différent.


 

Le montage pour le test sera le suivant :


1.1.2.3       Le logiciel

Avant toute utilisation, il faut positionner l’adresse du module en soudant l’un des ponts nommés A0

Les adresses possibles vont de 0x40 à 0x43. Là encore nous sommes dans les mêmes plages d’adresses que les INA219 et PCA9685, donc prudence avant de positionner l’adresse du module.

Pont

Adresse

GND

0x40

VS

0x41

SDA

0x42

SCL

0x43

 

J’ai positionné le miens à l’adresse 0x42


 

Le module comporte beaucoup plus de registres que l’INA219. En plus des registres de configuration, de lecture des tensions de shunt et de bus, il y a de nombreux registres permettant de positionner des niveaux d’alerte pour indiquer des tensions à ne pas dépasser.  La liste des registres est la suivante (Leur description complète est dans le datasheet) :


 

Coté programme, comme d’habitude, une librairie pour gérer le module et toutes ses fonctionnalités ainsi que les librairies déjà connue pour l’I2C et les GPIO plus un makefile et un programme de test.

Nom du fichier

Utilité

GestionI2C.h

L’entête de la librairie de gestion de l’I2C

GestionI2C.cpp

Librairie de gestion de l’I2C. Elle permet la lecture et l’écriture en 8 et 16 bits sur un appareil I2C avec ou sans adresse. Deux méthodes y ont été ajoutées depuis la version précédente afin de gérer la lecture en 16 bits avec inversion des deux octets. Ainsi qu’une lecture en bloc de plusieurs registres afin de faire des mesures cohérentes si tout doit être lu en même temps.

GestionINA3221.h

L’entête de la librairie de gestion de l’INA3221

GestionINA3221.cpp

Librairie de gestion de l’INA3221. Elle permet de paramétrer le module, d’effectuer les mesures, de vérifier les dépassements. Fourni aussi quelques méthodes pour le fonctionnement.

GestionPin.h 

L’entête de la classe de base de gestion des GPIO

GestionPin.cpp

La  classe de base de gestion des GPIO

GestionPinGPIO.h 

L’entête de la classe de gestion des GPIO

GestionPinGPIO.cpp

La classe de gestion des GPIO

Makefile

Le fichier permettant de compiler le programme grâce à la commande make

MesureurSimple.cpp

Mesureur donnant les tensions, le courant et la puissance sur les canaux ainsi que le contrôle des flags de dépassement

 

La compilation par un simple make :


 

L’exécution du programme de test:

Explication du fonctionnement :

Dans un premier temps, le programme initialise les GPIO permettant de lire les broches d’alerte ainsi que le module lui-même. Il test si le module est bien un INA3221 (manufacturer TI et modèle 3220). Puis, il initialise les mesures ainsi que les alertes sur les différentes tensions, somme de tension et tension de bus (bizarrement nommé puissance dans le datasheet).

Le programme va ensuite boucler en effectuant des mesures de tension, courant et puissance sur chacun des canaux ainsi que des tests afin de vérifier si les valeurs de mise en garde ou critique ne sont pas atteintes.

Le programme boucle indéfiniment et s’arrête par un CTRL-C.


 

1.1.2.4     Liste des programmes

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionI2C.cpp

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionI2C.h

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionINA3221.cpp

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionINA3221.h

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionPin.cpp

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionPin.h

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionPinGPIO.cpp

https://github.com/montotof123/raspberry/blob/master/297_INA3221/GestionPinGPIO.h

https://github.com/montotof123/raspberry/blob/master/297_INA3221/Makefile

https://github.com/montotof123/raspberry/blob/master/297_INA3221/MesureurSimple.cpp