Module ADS1115 Arduino : caractéristiques, fonctionnement, et raccordement (tutorial avec exemples de code arduino)

On pourrait se dire : « Pourquoi prendre un convertisseur analogique numérique externe (cet ADS1115), alors que l’Arduino possède déjà des entrées analogiques pour ce faire ? ». Et c’est une très bonne question, d’ailleurs !

Mais vous vous en doutez : si on fait appel à un petit module extérieur tel que celui-ci, c’est certainement qu’il y a une bonne raison ! C’est d’ailleurs ce que nous allons voir ici. Toutefois, afin que les choses soient le plus compréhensible possible, je les ai simplifiées au maximum.

Ici, nous allons aborder aussi bien la partie théorique, que la mise en pratique (bien plus fun !). Nous verrons donc ensemble le fonctionnement détaillé de l’ADS1115, ainsi que son pilotage via Arduino. Vous verrez d’ailleurs qu’il existe bien des façons d’utiliser ce petit module, suivant ses besoins. On en profitera bien sûr pour survoler tous les paramétrages de base de cette carte (vitesse d’échantillonnage, ajustement du gain, sélection d’adresse i2c), et découvrir toutes les différentes méthodes de mesure possibles.

Alors sans plus attendre, commençons par découvrir les caractéristiques principales de ce convertisseur analogique numérique (CAN, ou ADC en anglais) modèle ADS1115, afin de pouvoir s’en servir de manière optimale !

Nota : si jamais vous avez des questions, ou si vous relevez des coquilles, n’hésitez pas à m’en faire part en commentaire, afin d’améliorer le présent article, et les suivants ! Merci à vous !

Module	Description	Lien
	Module ADS1115 "tout équipé" (pour pilotage I²C facilité, via Arduino ou autre)	Voir le prix

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 : grande résolution, 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 😉

Résolution de 16 bits (supérieure à l’Arduino)

Voilà bien ce qui justifie l’utilisation d’un convertisseur analogique ADS1115, plutôt que les entrées analogiques de l’Arduino. Car la résolution de mesure est sans appel :

• Avec l’arduino, la résolution n’est que de 10 bits (puisque la valeur retournée se situe entre 0 et 1023). Du coup, pour bien se représenter la chose, dites vous que, si vous alimentez un Arduino en 5 volts, alors la résolution d’un bit vaudra 5/1024 volts, soit environ 4,8 mV
• Avec l’ADS1115, la résolution est de 15 bits (allant de 0 à 32767) : ainsi, si on travaille en 5 volts, la résolution de chaque bit équivaudra à 5/32768 volts, soit environ 0,15 mV

Soit un rapport de 32 entre ces deux valeurs, signifiant que la mesure faite avec l’ADS1115 sera 32 fois plus fin que celle faite avec l’arduino. Et croyez-moi, on a plus souvent besoin qu’on croit d’une telle résolution. C’est par exemple le cas, lorsqu’on cherche à mesurer la très faible chute de tension aux bornes d’une résistance de shunt, afin de déterminer le courant qui alimente une charge !

Remarque : si vous êtes attentif, vous avez sûrement dû vous dire que j’ai commis une erreur un peu plus haut. Car je vous ai parlé d’une résolution de 15 bits dans l’exemple ci-dessus, alors que cette puce est donnée pour une résolution de 16 bits (dans le datasheet, dans les descriptifs produits, …). Mais vous verrez qu’en fait, ces fameux « 16 bits » ne sont en fait qu’un tour de passe-passe marketing, justifié par la possibilité de lecture de tensions différentielles. Sceptique ? Ne vous inquiétez pas, car vous pourrez vérifier tout cela au moment des essais !

Tension d’alimentation, et tensions maximales sur les entrées de mesure (A0, A1, A2, et A3)

Pour commencer, un mot sur la tension d’alimentation de l’ADS1115 :

• Valeur recommandée : de 2 à 5,5 volts
• Valeur maximale (à ne pas maintenir longtemps) : jusqu’à 7 volts

En bref, ce convertisseur analogique numérique peut s’alimenter jusqu’à 7 volts pendant une courte durée, mais en temps normal, il faut se limiter à 5V maximum.

Si je vous parle de cette tension d’alimentation, ce n’est pas pour rien. Car celle-ci conditionne la tension maximale qu’on peut appliquer sur les entrées de mesures. Et s’il y a une première chose à retenir, c’est celle-ci :

La tension d’entrée à mesurer devra toujours être inférieure à la tension d’alimentation de l’ADS1115 + 0.3 volts, sous peine de détruire ce convertisseur analogique numérique !

Par exemple, dans l’absolu :

• Si vous êtes alimenté en +5V, la tension à mesurer ne doit pas dépasser 5,3 volts
• Si vous êtes alimenté en +3,3V, la tension à mesurer ne doit pas excéder 3,6 volts

Bien sûr, pour ne pas risquer d’endommager l’ADC, il vaut mieux rester dans la fourchette de valeurs recommandées par le fabricant, c’est à dire ici, de ne jamais dépasser la tension d’alimentation, tout simplement.

À noter que les autres entrées du convertisseur analogique numérique ADS1115, que sont SDA, SCL, ADDR, et ALERT/RDY, peuvent quant à elles être alimentées jusqu’à 5,5 volts (quelque soit la tension d’alimentation).

Gain, plages de mesure, résolution, et précision

Là où l’ADS1115 devient plus intéressant qu’un simple convertisseur analogique numérique basique, c’est qu’il intègre un PGA (Programmable Gain Amplifier), permettant d’amplifier un signal, pour faire des lectures plus précises encore.

Voici d’ailleurs le tableau spécifiant les valeurs mesurables avec cet ADC, en fonction du gain sélectionné :

Donc grâce au PGA interne, il est possible d’amplifier le signal analogique jusqu’à 16 fois.

Deux remarques TRÈS IMPORTANTES :

• Vous avez certainement remarqué que certaines de ces plages de mesure (par exemple +/- 6.144 volts) dépasseront forcément la tension d’alimentation. Certaines de ces valeurs ne seront donc bien entendu absolument pas atteignables en pratique, car comme vu dans le paragraphe précédent, il ne faudra jamais dépasser la tension d’alimentation (au risque de griller l’ADC, à plus ou moins long terme)
• Vous avez certainement dû aussi remarquer la présence du signe « +/- ». Mais autant vous le dire tout de suite : l’ADS1115 ne permet absolument pas de lire des tensions négatives sur ses entrées, par rapport à la masse, malgré ce qu’on pourrait croire, et il ne les supporterait pas du tout d’ailleurs ! Ce signe est en fait un autre « tour de passe-passe » du fabricant, et atteignable seulement à l’occasion de lectures différentielles de tensions positives. Par exemple, si vous mesurez deux tensions sur cet ADC, avec « +1V » sur la première entrée analogique, et « +3V » sur la seconde, la tension différentielle sera de « +1V » – « +3V », soit -2 volts. On obtient donc une tension négative, à partir de la mesure de 2 tensions positives. Je pense que vous comprenez à présent qu’il ne s’agit juste d’une « façon de voir les choses », car il n’y a aucune tension négative en entrée !

Ainsi, les « vraies » plages de mesures possibles, en pratique, lorsqu’on mesure des tensions simples sur cet ADC par rapport à la masse, sont :

Comme vous le voyez, il ne faut pas mal interpréter les chiffres présentés dans les datasheets 😉

Pour autant, il ne s’agit pas là d’une publication mensongère du fabricant. Car dans l’absolu, on pourrait alimenter l’ADS1115 jusqu’à 7 volts pendant un court instant, et donc pouvoir faire des mesures jusqu’à 6.144 volts. Par ailleurs, les tensions négatives sont effectivement mesurables en mode différentielle (soustraction de mesures de tensions simples), tout en gardant bien à l’esprit qu’il ne s’agit que là d’une manière de présenter les choses. Car encore une fois, aucune tension négative de doit être appliquée aux entrées de ce convertisseur analogique numérique !

Par contre, je vous l’accorde : on ne retrouve pas forcément ce qu’on aurait pu espérer en lisant les premières lignes descriptives de l’ADS1115 ! Car si la résolution avait été de 16 bits sous 5 volts, on obtiendrait une valeur correspondant à 5/2^16 pour chaque bit, soit 0,0763 mV. Or ici, en réalité, on a environ 2 fois moins de « finesse », avec la gamme +/- 6.144V !).

Enfin, au niveau de la précision de l’ADS1115 en lui-même, il faut considérer une marge d’erreur potentielle, d’environ +/- 3 fois la résolution d’un bit. Par exemple, si on utilise l’ADC avec un gain égal à 1, on aura une marge d’erreur plus ou moins égale à environ 0.375 mV (soit 3 x 0,125mV unitaire, comme présenté dans le tableau ci-dessus).

Important : le datasheet du fabricant n’indique pas clairement quelle est la plage réelle de précision de ce convertisseur analogique-numérique (le % d’erreur de mesure, si vous préférez). Certes la résolution est grande (16 bits nous donne 1/65000ème), mais cela nous garantie pas « l’exactitude » de la mesure, d’autant plus qu’on n’a pas d’infos précises, ni retour externe, sur la référence de tension interne de cette puce (est-elle bien stable ? bien calibrée ?).

Mesures et pilotage : 4 canaux de lecture de tension, consultables via 2 fils seulement !

Autre atout du convertisseur analogique numérique ADS1115 : il permet des mesures de tensions à 4 endroits à la fois, par rapport à la masse, tout en ne prenant que 2 fils pour interagir avec un Arduino. C’est d’ailleurs toute la beauté de ce genre de puce électronique, sans parler des autres avantages (rapidité, « grande » résolution, …).

En effet, l’ADS1115 dispose de 4 entrées distinctes : A0, A1, A2, et A3. Et pour le pilotage de cet ADC, seuls 2 fils suffisent : SDA et SCL (l’interface i2c de l’arduino, donc).

Mais on peut aller bien au-delà de 4 mesures de tensions simples ! Car l’adresse i2c de l’ads1115 peut quant à elle prendre 4 valeurs différentes (selon comment est branchée la broche ADDR). Ainsi, si on utilise 4 modules ADS1115, on peut donc lire 16 tensions différentes, et piloter tout ça avec un seul arduino, sur 2 fils seulement ! Difficile de faire mieux, pour économiser au maximum les entrées/sorties de son microcontrôleur (qui sont assez limitées !).

Et pour s’adresser à un ADS1115 plutôt qu’un autre, tout se passe au niveau logiciel. Car comme chaque plaquette ADC aura une adresse i2c qui lui est propre, l’arduino pourra interroger qui il veut, quand il veut, et comme il veut !

Nota : l’ADS1115 n’a pas d’entrée type « Vref » pour avoir une tension de référence extérieure, à la fois stable et précise. En fait, il y a déjà tout ce qu’il faut dans sa puce, et donc, pas besoin de composants additionnels, à ce niveau !

Vitesse de lecture et d’échantillonnage (mesure de tension)

Sur l’ads1115, on peut sélectionner l’une des 8 vitesses d’échantillonnage possibles, notées DR (pour « Data Rate »), selon ses besoins :

• DR=0 : 8 SPS. Ici l’ADC aura un « data rate » égal à 8 lectures par seconde, ou 8 « échantillons par seconde », si vous préférez (aussi appelé « SPS » en anglais, pour « Samples per second »)
• DR=1 : 16 SPS
• DR=2 : 32 SPS
• DR=3 : 64 SPS
• DR=4 : 128 SPS. C’est la VALEUR PAR DÉFAUT (soit 128 échantillons mesurés par seconde)
• DR=5 : 250 SPS
• DR=6 : 475 SPS
• DR=7 : 860 SPS. Soit 860 lectures de tension par seconde !

Ainsi, le délai de conversion est fonction du DR choisi. Par exemple, si DR = 7 (soit 860 SPS), alors la mesure sera faite en près de 1/860 secondes, soit environ 1,16 ms.

À noter que cette vitesse d’échantillonnage a une influence sur la consommation du convertisseur analogique numérique (bien que celle-ci soit franchement ridicule, car 300 µA au maximum !), et sur le niveau de bruit (bien supérieur à 860 SPS, comparativement à 8 SPS).

À noter que la séquence de lecture d’une tension devra toujours se faire de la sorte :

1. L’arduino doit demander à l’ADS1115 de lire de la tension sur telle ou telle entrée (A0 à A3)
2. Puis l’arduino devra attendre que l’ADS1115 lui envoi un signal de confirmation en retour, lui disant que la tension a été mesurée, et que cette valeur est « prête à lire »
3. Et enfin, l’arduino pourra récupérer cette valeur, stockée en attente dans l’ADS1115

La temps de lecture d’une tension est donc la somme de toutes ces étapes : échantillonnage + délais d’émission, d’attente, et de réception. Et ce temps définit la vitesse maximale réelle de mesures de tensions par seconde.

Module	Description	Lien
	Module ADS1115 "tout équipé" (pour pilotage I²C facilité, via Arduino ou autre)	Voir le prix

Comment raccorder l’ADS1115 à l’Arduino ? (alimentation, adresse I2C, …)

Le convertisseur analogique numérique ADS1115 est clairement l’ADC de rêve, pour faire des mesures précises, et rapides. Et l’Arduino est sans conteste l’un des moyens les plus simples pour le piloter. Bien sûr, vous pourriez parfaitement vous servir d’un Raspberry Pi, ou d’un ESP32 pour ce faire. Mais je trouve qu’avec l’arduino, c’est plus simple à comprendre, et à mettre en œuvre, surtout lorsqu’on est débutant.

D’autant plus que cette mini plaquette est super facile à raccorder ! En effet, il n’y a que 10 pins présentes sur un module ADS1115 :

• Vdd : la tension d’alimentation (de 2 à 5,5 volts)
• Vss : la masse (0 volt)
• SCL et SDA : les lignes d’horloge et de données séries (i2c)
• ADDR : une pin servant à définir physiquement l’adresse i2c du module (4 adresses différentes possibles)
• ALRT : une sortie « d’alerte » (permettant par exemple à l’ADS1115 d’indiquer à un microcontrôleur qu’une tension a été mesurée, et que cette valeur est prête pour être lue)
• A0, A1, A2, et A3 : les quatre entrées analogiques, sur lesquelles pourront être lues des tensions (simples ou différentielles)

Adresse i2c : 4 choix possibles

Comme je vous disais précédemment, 2 fils suffisent pour piloter ce module : il s’agit des lignes SDA et SCL, de l’interface i2c Arduino. Mais comme tout appareil utilisant ce type de connexion, il faut que chaque carte i2c ait une adresse précise, pour pouvoir communiquer avec elle, sans erreur d’aiguillage ! Ce qui est le cas ici.

Avec ce module ADC, on peut choisir parmi 4 adresses différentes possibles, suivant où l’on raccorde la broche ADDR. Et pour être plus clair, rien de tel qu’un bon petit tableau !

À noter que ce branchement est à faire physiquement sur le module, avant de le mettre sous tension. Autre remarque : vous pouvez parfaitement utiliser 4 x ADS1115 en même temps, branchés sur les 2 fils I2C d’un Arduino. Aussi, deux fils suffisent pour piloter jusqu’à 4 modules ADS1115 à la fois, et donc, lire jusqu’à 16 tensions différentes (puisque chaque ADC possède 4 canaux !). D’ailleurs, voici le branchement que vous pourriez faire :

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)

Par ailleurs, 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é.

Module	Description	Lien
	Module ADS1115 "tout équipé" (pour pilotage I²C facilité, via Arduino ou autre)	Voir le prix

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 :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier: ads1115_mesure_simple.ino
  Description: fichier test de mesure de tensions simples
  Page projet : https://passionelectronique.fr/
  Auteur: Jérôme TOMSKI

  Créé le 21.12.2020
*/
#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 !
}

Comme vous le voyez, le code est au final assez simple ! J’en ai toutefois profité pour rajouter un maximum de commentaires, afin que la compréhension soit la plus facile possible. Mais dans tous les cas, au besoin, n’hésitez pas à poser vos questions, en zone commentaires !

Tutorial ADS1115 : code arduino pour mesure de tension différentielle

Ici, il s’agit de faire des mesures flottantes, donc sans que celles-ci ne soient reliées à la masse. Je vous propose le montage suivant, pour l’illustrer. Cela met en œuvre une simple pile (vous pouvez prendre une pile AA 1,5 volts, une piles lithium 18650 de 3.7 volts, ou ce que vous voulez, afin de faire vos essais !). La mesure de tension sera quant à elle affichée sur le moniteur série de l’interface Arduino, tout simplement.

Mais tout d’abord, voici le montage à réaliser :

Au niveau du code arduino de ce programme, voici ce qu’il contient :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier: ads1115_mesure_differentielle.ino
  Description: fichier test de mesure de tensions différentielles
  Page projet : https://passionelectronique.fr/
  Auteur: Jérôme TOMSKI

  Créé le 21.12.2020
*/
#include "ADS1X15.h"

ADS1115 ADS(0x48);  // ADS1115 physiquement défini à l'adresse 0x48, avec sa broche ADDR reliée à la masse

void setup() {
  // Initialisation de port série
  Serial.begin(9600);
  Serial.println("Lecture de tensions différentielles / ADS1115");
  Serial.println("---------------------------------------------");
  Serial.println("Mesure de différence de potentiel entre les entrées A0 et A1 de l'ADC");
  Serial.println("Nota : ADC Range: +/- 6.144V (soit 1 bit = 0.1875 mV)");
  Serial.println("");
  
  // 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() {
  // Mesure de la tension différentielle entre A0 et A1 (le résultat se situera entre -32768 et +32767, comme nous sommes sur 16 bits)
  int16_t difference_potentiel_A0_A1 = ADS.readADC_Differential_0_1();
  Serial.print("Lecture de l'ADC (A0-A1) : ");
  Serial.println(difference_potentiel_A0_A1);

  // Conversion de cette valeur en volts (le résultat sera fonction de la plage sélectionnée, fonction du gain ; ici, le résultat sera entre -6.144 et +6.144 volts)
  float tension_volts_A0_A1 = ADS.toVoltage(difference_potentiel_A0_A1);
  Serial.print("Tension différentielle = ");
  Serial.print(tension_volts_A0_A1,3);    // On limite l'affichage à 3 chiffres après la virgule
  Serial.println(" volts");

  // Puis on boucle, après une pause de 2 secondes !
  Serial.println("");
  delay(2000);
}

Et au niveau du moniteur série de votre IDE Arduino, vous devriez avoir quelque chose comme ce qui suit (là j’ai mesuré un accus li-ion 18650, que j’avais sous la main !) :

Module	Description	Lien
	Module ADS1115 "tout équipé" (pour pilotage I²C facilité, via Arduino ou autre)	Voir le prix

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 !

J’en profite pour vous glisser des liens vers les principaux composants utilisés ici, dans le cadre de ce tutorial, si vous ne savez pas où les trouver :

• Carte Arduino Uno R3 (microcontrôleur ATmega328P)
• Module plaquette ADS1115 (convertisseur analogique numérique 16 bits, à 4 canaux)

À bientôt.
Jérôme.

À découvrir : l’ensemble des articles portant sur les modules Arduino

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 18/01/2024