Module ADS1115 16-Bit ADC – 4 Ch avec Amplificateur

Tutorial ADS1115 Arduino : caractéristiques, raccordement, et code de programmation

Caractéristiques et fonctionnement de l’ADS1115

Tout d’abord : qu’est-ce qu’un ADS1115 ? En fait, il s’agit simplement d’une puce électronique de chez TEXAS INSTRUMENT (datasheet ADS1115), permettant de faire de la conversion analogique numérique. Ainsi, par exemple, il est courant de s’en servir pour faire de la mesure de tension à intervalle régulier, et transmettre ces infos à un microcontrôleur.

Les avantages à utiliser une telle puce sont multiples : précision, rapidité, amplification au besoin, et surtout, optimisation des entrées sorties. Car en effet, seuls deux fils suffisent pour contrôler cette mini plaquette ADC, et relever jusqu’à 4 tensions différentes (ça économise donc bien des entrées sur un microcontrôleur !). Mais trêve de compliments, et voyons tout cela plus en détail

Raccordement à l’Arduino UNO

Une fois qu’on a compris comment raccorder la partie i2c (SDA, SCL, et ADDR), il n’est pas compliqué de faire le reste ! Voici d’ailleurs un exemple de branchement, sur une carte Arduino Uno :

Notez que le branchement de la broche ALRT est « optionnel », en ce sens où on peut gérer le signalement d’une tension « prête à lire » de manière logicielle. Toutefois, l’alerte physique, plutôt que logicielle, est l’idéal si l’on veut par exemple déclencher une interruption sur un Arduino, chaque fois qu’une mesure est prête à lire. Cela permet de lui donner la pleine priorité, lors de l’exécution d’un programme, à n’importe quel moment.

Notion de mesure de tension simple, ou différentielle

Concernant les mesures de tension en elles-mêmes, celles-ci peuvent se faire de 2 manières différentes :

• Lecture absolue : ici, on mesure une tension fixe, dans les limites de l’ADC, et par rapport à la masse (0 volts).
• Lecture différentielle : ici, on mesure la différence de potentiel entre 2 points distincts (par exemple, aux bornes d’une pile). Dans ce cas, c’est comme si on faisait une lecture « flottante » de tension, entre deux points donnés.

Dans le premier cas, on est limité à une résolution de 15 bits, pour la lecture d’une tension positive, par rapport au référentiel commun (zéro volt). Ici, les tensions mesurables sont au nombre de 4, via les broches A0, A1, A2, et A3. La mesure de tension se fera par rapport à la masse (GND).

Dans le deuxième cas, on a une résolution égale à 16 bits (en fait de 15 bits et un bit de signe +/-), pour la lecture de tensions flottantes, sans référentiel commun. Une des applications classiques de ce mode, est la mesure de chute de tension aux bornes d’une résistance de shunt. Ainsi, on peut calculer le courant traversant quelque chose, au travers de la différence de potentiel mesurée aux bornes de cette résistance.

Dans le cas d’une lecture différentielle (2^ème cas), les mesures se feront entre 2 entrées. Par exemple : entre A0 et A1, ou A2 et A3 (on peut faire bien d’autres combinaisons, dans les limites de ce que propose la librairie arduino utilisée).

Et pour rappel, aucune tension négative ou supérieure à la tension d’alimentation ne devra être appliquée sur les bornes d’entrées de l’ADS1115. Si l’on peut effectivement lire des « tensions négatives », c’est seulement en faisant des soustractions de tensions positives entre elles. Par exemple : « +0V » – « +5V » = – 5 volts. On voit donc bien qu’on peut mesurer une tension négative de manière différentielle, en soustrayant deux tensions positives mesurées.

Librairie pour ADS1115, avec paramètres de démarrage

Il existe bon nombre de librairies Arduino, pour communiquer avec un ADS1115. Mais celle qui me semble la plus appropriée, et la plus complète, au moment où je rédige cet article, est celle qu’on retrouve dans le gestionnaire de bibliothèques de librairie, dans l’IDE arduino. Il s’agit de la librairie « ADS1X15 » de RobTillaart (https://github.com/RobTillaart/ADS1X15), prévue pour les ADC ads1015 et ads1115 (donc parfaite pour nous !). Qui plus est, celle-ci dispose de tout un tas de réglages possibles, que d’autres n’ont pas la possibilité de faire.

Nous allons d’ailleurs voir ici tous les principaux paramètres, permettant d’interagir de manière optimale avec un ADS1115 !

Initialisation, avec définition de l’adresse i2c choisie

Comme toute librairie dont on souhaite se servir dans un projet arduino, il faut l’inclure dans le code, dès les premières lignes. Ensuite, il faut appeler cette librairie, en créant une instance de celle-ci, pour s’en servir. C’est ici d’ailleurs qu’on renseignera l’adresse i2c de la petite carte ADS1115 qu’on a raccordé à son arduino, sachant que les valeurs possibles sont : 0x48, 0x49, 0x4A, ou 0x4B (se sont des valeurs hexadécimales, oui !). Puis, il ne reste plus qu’à démarrer le tout, avec la fonction « begin » ! Au niveau du code, cela donne ceci :

#include "ADS1X15.h"
ADS1115 ADS(0x48);	// ADS1115 physiquement défini à l'adresse 0x48

void setup() {
   ADS.begin();
   // Paramètres suivants ici
}

Nota : si vous ne renseignez aucune adresse i2c, le programme considérera que votre module ADS1115 se trouve à l’adresse « 0x48 », c’est à dire avec la broche ADDR branchée sur GND.

Paramétrage du Gain souhaité

Parmi les autres paramètres principaux, que l’on peut définir juste après l’appel de la fonction « begin », on retrouve celle permettant de définir le gain (comme vu dans le paragraphe 1.3). Là, vous aurez donc le choix entre 6 valeurs possibles.

Au niveau de la programmation, cela se traduit de la manière suivante (il suffira de commenter/décommenter les lignes, en fonction de vos besoins)

ADS.setGain(0);		// ± 6.144 volt (par défaut). À noter que le gain réel ici sera de « 2/3 », et non zéro, comme le laisse croire ce paramètre !
//ADS.setGain(1);	// ± 4.096 volt
//ADS.setGain(2);	// ± 2.048 volt
//ADS.setGain(4);	// ± 1.024 volt
//ADS.setGain(8);	// ± 0.512 volt
//ADS.setGain(16);	// ± 0.256 volt

Nota : si vous ne mettez aucune valeur, ou toute autre valeur d’ailleurs, cela reviendra par défaut à exécuter la commande ADS.setGain(0).

Les 2 modes de lecture de tension : à la demande (single shot) ou en automatique (continuous)

Comme vu précédemment, il existe 2 façons de lire des tensions : de manière manuelle (à la demande), ou en automatique (de manière perpétuelle). Avec cette librairie, cela se définit avec la fonction « setMode », qu’il faut mettre à 1 pour faire des lectures ponctuelles, ou à 0, pour faire des lectures cycliques permanentes.

ADS.setMode(1);	// 0 = CONTINUOUS, 1 = SINGLE (default)

À noter que par défaut, si aucune valeur n’est renseignée, ou si cette valeur est différente de 0 ou 1, cela revient à choisir le mode « single », soit la mesure de tension « à la demande ». Petite parenthèse : ne pensez pas que le mode continu serait la meilleure façon de procéder. Car dans ce mode, la consommation sera évidemment plus élevée qu’à la normale (même si ça reste faible, je vous l’accorde !), et le niveau de bruit sera plus important (donc mesures moins précises), attention.

Réglage de la vitesse de lecture

L’ADS1115 a une vitesse de lecture paramétrable. Cette vitesse, aussi appelée « vitesse d’échantillonnage » (SPS en anglais, pour « Samples per second »), ou encore « débit de données » (« datarate », en anglais), peut prendre 8 valeurs différentes.

Au niveau du code de programmation, sous l’IDE arduino, cela se traduira de la manière suivante :

ADS.setDataRate(7);  // avec vitesse de mesure, allant de 0 à 7 (7 étant le max, soit 860 échantillons par seconde)

Nota : si vous ne définissez aucune vitesse, celle-ci sera par défaut mise à 4, lors de l’instanciation de la librairie. Cela correspond donc à une vitesse d’échantillonnage de 128 mesures de tension par seconde, que vous pouvez bien évidemment accélérer ou ralentir, avec la fonction « setDataRate », suivant vos besoins.

Demande de lecture de tension simple (par rapport à la masse)

Ici, on arrive enfin à la méthode permettant de lire des tensions simples, c’est-à-dire par rapport à la masse (0 volts). L’appel de cette fonction est vraiment facile à faire, d’ailleurs, puisqu’il suffit d’écrire qu’une seule ligne pour ce faire. Du coup, lorsqu’on veut lire les tensions des entrées A0, A1, A2, et A3, de l’ADS1115, on pourra écrire les lignes suivantes :

int16_t mesure_A0 = ADS.readADC(0);		// Valeur entre -32768 et +32767
int16_t mesure_A1 = ADS.readADC(1);
int16_t mesure_A2 = ADS.readADC(2);
int16_t mesure_A3 = ADS.readADC(3);

À noter que le résultat de cette lecture de tension sera au format « int16_t », c’est-à-dire une valeur entière située entre -32768 et +32767. Et comme on ne peut lire que des tensions strictement positives sur l’ADC, le résultat de cette fonction sera par définition un nombre compris entre 0 et 32767. On s’aperçoit là qu’on a bien une résolution de 15 bits, et non de 16, comme le fabricant le laisse entendre ????

Autre remarque : cette fonction est en faite la somme de 3 fonctions en 1. Car elle réalise les trois opérations suivantes, en arrière plan :

1. readADC demande à l’ADC de lire une tension sur la broche souhaitée
2. puis readADC attend que cette valeur soit prête (puisqu’il faut un certain temps pour qu’un ADC puisse convertir une valeur analogique présente sur l’une de ses broches, en valeur numérique)
3. et enfin, readADC récupère cette valeur, pour pouvoir nous la communiquer

Cela veut donc dire que lorsqu’on appelle la fonction « readADC », on est « sûr » de lire la dernière valeur de tension présente sur l’entrée souhaitée (car on aura « attendu » que celle-ci soit lue ET « prêt à lire »).

Enfin, à noter que cette librairie met à disposition une fonction « toVoltage », permettant de convertir la valeur retournée par readADC, en tension exprimée en volts. Ainsi :

float tension_A0 = ADS.toVoltage(mesure _0);	// Valeur exprimée en volts (dont l’amplitude sera automatiquement calculée en fonction du gain préalablement choisi
float tension_A1 = ADS.toVoltage(mesure _1);
float tension_A2 = ADS.toVoltage(mesure _2);
float tension_A3 = ADS.toVoltage(mesure _3);

Demande de lecture de tension différentielle (entre 2 des entrées analogiques, parmi les broches A0, A1, A2, ou A3 de l’ADS1115)

À l’image de la fonction précédente, il s’agit là aussi de lire une tension sur l’ADC. Mais cette fois-ci, cette mesure ne se fera pas par rapport à la masse, mais entre 2 des 4 entrées analogiques de l’ADS1115. Par exemple, si on veut lire la différence de potentiel entre les entrées A0 et A1, on appellera la fonction suivante :

int16_t difference_potentiel_A0_A1 = ADS.readADC_Differential_0_1();

Petite note : la différence de potentielle sera égale à A0 moins A1, et non l’inverse (A1-A0). Et bien sûr, en se rappelant qu’aucune tension négative ne peut être appliquée sur ces entrées. Ainsi, si vous avez par exemple 1 volt sur A0, et 4 volts sur A1, la tension différentielle sera égale à : (+1V) – (+4V), ce qui donne – 3 volts. On peut donc obtenir une mesure de tension négative, à partir de ces deux tensions positives (à l’image d’un voltmètre qu’on brancherait à l’envers).

Le résultat de cette fonction sera un entier signé à 16 bits, dont situé entre -32768 et +32767.

Au niveau des combinaisons de broches d’entrées, sur lesquelles on peut faire des lectures de tensions différentielles, on a le choix entre ces 4 possibilités :

• requestADC_Differential_0_1() // donne la tension A0 – A1 (valeur entre -32768 et +32767)
• requestADC_Differential_0_3() // donne la tension A0 – A3
• requestADC_Differential_1_3() // donne la tension A1 – A3
• requestADC_Differential_2_3() // donne la tension A2 – A3

Et là aussi, on peut facilement convertir ces valeurs en volts, avec la fonction « toVoltage », fourni avec cette librairie. Par exemple, pour connaitre la tension différentielle entre A0 et A1, il suffira d’écrire :

float tension_A0_A1 = ADS.toVoltage(difference_potentiel_A0_A1);	// Valeur exprimée en volts, fonction de la valeur mesurée par l’ADC, et du gain sélectionné.

Tuto ADS1115 : code arduino pour mesure de tension simple

Maintenant que nous avons vu la partie « théorique », passons à la pratique ! Pour ce faire, nous allons partir du schéma suivant. Dans les grandes lignes, ce montage permettra de lire la tension présente sur les 2 potentiomètres branchés en entrée, et de faire varier l’intensité lumineuse de 2 LED en conséquence. Ainsi, si le curseur d’un potentiomètre est complètement à gauche, alors la LED correspondante sera éteinte. À l’inverse, si le curseur est tourné complètement à droite, alors la LED sera pleinement allumée. Et enfin, si le curseur est quelque part entre ces deux positions extrêmes, alors on allumera la lumière de manière plus moins atténuée, suivant la position (en la pilotant en PWM, comme vous verrez !).

Donc, pour commencer, voici le montage à réaliser :

Et au niveau du code arduino, cela se traduit avec les lignes suivantes :

/*  

* Réaliser par Micro-Electroniques Générales au Maroc 
* Visite notre site megma.ma  */ #include "ADS1X15.h" const byte pinLED1 = 5; const byte pinLED2 = 6; ADS1115 ADS(0x48); // ADS1115 physiquement défini à l'adresse 0x48, avec sa broche ADDR reliée à la masse void setup() { // On définit D5 et D6 en sortie, et on les mets à l'état bas pinMode(pinLED1, OUTPUT); pinMode(pinLED2, OUTPUT); digitalWrite(pinLED1,LOW); digitalWrite(pinLED2,LOW); // ADS1115 ADS.begin(); // Initialisation du module ADS1115 ADS.setGain(0); // On prend le gain le plus bas (index 0), pour avoir la plus grande plage de mesure (6.144 volt) ADS.setMode(1); // On indique à l'ADC qu'on fera des mesures à la demande, et non en continu (0 = CONTINUOUS, 1 = SINGLE) ADS.setDataRate(7); // On spécifie la vitesse de mesure de tension qu'on souhaite, allant de 0 à 7 (7 étant le plus rapide, soit 860 échantillons par seconde) ADS.readADC(0); // Et on fait une lecture à vide, pour envoyer tous ces paramètres } void loop() { // Demande de mesure de tensions à l'ADC (résultats entre -32768 et +32767) int16_t tension_A0 = ADS.readADC(0); // Mesure de tension de la broche A0, par rapport à la masse int16_t tension_A1 = ADS.readADC(1); // Mesure de tension de la broche A1, par rapport à la masse  // Nota1 : ces valeurs seront en fait comprises entre 0 et +32767, car aucune tension négative ne peut être appliquée sur ces broches // Nota2 : on peut convertir ces valeurs en Volts, si besoin, avec la commande "float tension_volts_A0 = ADS.toVoltage(tension_A0);" // Conversion 15 bits -> 8 bits (utile pour la suite) byte val0 = map(tension_A0, 0, 32767, 0, 255); byte val1 = map(tension_A1, 0, 32767, 0, 255); // Puis on ajuste le rapport cyclique de l'alimentation de chaque LED, afin de les faire briller plus ou moins, en fonction des tensions mesurées précédentes analogWrite(pinLED1, val0); // PWM de rapport cyclique "val0" pour la LED1 analogWrite(pinLED2, val1); // PWM de rapport cyclique "val1" pour la LED1 // Nota : quelques exemples, pour mieux comprendre : // - si "tension_A0" = 0, alors val0 = 0, d'où un rapport cyclique à 0% sur la LED1 (celle-ci sera donc éteint) // - si "tension_A0" = 32767, alors val0 = 255, d'où un rapport cyclique à 100% sur la LED1 (celle-ci sera donc pleinement allumée) // - si "tension_A0" est entre ces deux valeurs, alors le rapport cyclique sera fonction de celle-ci (et donc, l'éclairement de la LED aussi en fonction) // Puis on boucle ! }

Conclusion

Voilà ! Je pense que nous avons survolé toutes les fonctionnalités principales de l’ADS1115 ! Bien sûr, il y a bien des choses que j’ai laissé de côté, à l’image de la fonction comparateur. Mais comme le but premier de cet article était avant de tout de vous familiariser avec ce convertisseur analogique numérique, je préfère me limiter à l’essentiel, sans vous noyer d’infos techniques, ou trop pointues. J’espère d’ailleurs que vous aurez pu découvrir ou apprendre un maximum de choses ici, afin de pouvoir les intégrer à vos futurs projets !

Plus d’information visite notre page Facebook.