Utilisation du "Data Logging Shield" (Arduino)

Je me souviens d'une époque (pas si lointaine) où je n'achetais pratiquement jamais de shield pour Arduino, parce que les prix me semblaient inutilement élevés.  Ainsi, lors de la réalisation d'un montage destiné à compiler des mesures de températures et de luminosité, j'avais utilisé, en plus des capteurs nécessaires,  un module RTC (horloge temps réel), un lecteur de carte SD, un convertisseur de niveau logique (requis par le lecteur de carte SD), etc.

J'avais alors fait remarquer qu'un shield tout fait était vendu par Adafruit, mais au prix de 14 USD, ça me semblait un luxe inutile.

Les temps ont bien changé.  De nos jours, vous pouvez facilement trouver sur eBay des clones du Data Logging Shield conçu par Adafruit pour aussi peu que 3 USD (frais de port inclus).

Résultat:  de nos jours, même pour un radin comme moi, il n'y a aucune raison de se priver d'un data logging shield prêt à l'utilisation.

Le shield comporte un lecteur de carte SD, une horloge temps réel et un convertisseur de niveau logique, en plus de deux LEDs que vous pouvez, au besoin, lier à la pin Arduino de votre choix.  Il ne reste donc plus qu'à brancher les capteurs.

L'horloge

Pour que l'horloge temps réel DS1307 fonctionne correctement, il faut insérer une pile CR1220 (qui n'était pas fournie avec le shield que j'ai acheté).  Cette horloge utilise le protocole i2c.

Pour utiliser l'horloge, vous devez installer la bibliothèque RTClib de Jeetlabs qui n'est généralement pas incluse avec l'IDE Arduino.  Le sketch d'exemple "ds1307" fourni avec la bibliothèque vous permettra de vérifier que votre horloge fonctionne correctement (si elle n'affiche pas l'heure et la date correcte, exécutez l'exemple "ds1307" après avoir décommenté la ligne "RTC.adjust(DateTime(__DATE__, __TIME__));"

Le lecteur de cartes SD

Le lecteur de carte SD utilise quant à lui le protocole SPI.  La bibliothèque SD est déjà installée par défaut avec l'IDE Arduino.  Pour vous assurer que le lecteur fonctionne correctement, vous pouvez exécuter le sketch "CardInfo" fourni avec la bibliothèque SD...

...mais attention:  dans ce sketch, vous devez modifier la constante "chipSelect" et lui assigner la valeur "10".

Les LEDs indicatrices

Le shield comporte également deux LEDs (L1 et L2) qui peuvent être connectées à n'importe quelle sortie de l'Arduino.  Grâce à deux petits bouts de fil conducteur, j'ai relié la LED "L1" à la sortie 5 de l'Arduino, et la LED "L2" à la sortie 4 (un fer à souder est requis ici).

Ces LEDs peuvent être utilisées pour vous permettre de savoir si votre data logger fonctionne correctement lorsqu'il n'est pas connecté à un ordinateur (une LED peut s'allumer ou clignoter pendant que les mesures sont prises, une autre peut indiquer la fin de la prise de mesure, etc.).

Un exemple de sketch

Pour cet exemple de sketch, j'ai supposé la présence de deux capteurs analogiques branchés respectivement aux entrées A0 et A1 du shield.  Il ne vous restera qu'à adapter le code pour qu'il gère les capteurs qui vous conviennent, peu importe qu'ils soient analogiques ou numériques.

Des mesures sont prises toutes les 10 secondes:  il est facile de modifier cette fréquence, stockée dans la constante "DELAI_MESURES".

Chaque fois qu'une mesure est prise, elle est affichée dans le moniteur série, si ce dernier est actif (ce qui sera surtout utile pour vérifier le fonctionnement correct du dispositif).  De plus (et surtout), elle est enregistrée dans un fichier "csv" ("comma separated values") qui pourra facilement être ouvert et traité avec un tableur comme, par exemple,  Excel.  Notez que j'utilise la convention qui permettra aux fichiers d'être correctement interprétée par la version française d'Excel:  les données sont séparées par des points virgules plutôt que par des virgules.

La LED "L1" clignote pour indiquer que le data logger est en fonctionnement (si vous oubliez d'insérer une carte SD lors du démarrage du sketch, la LED ne s'allumera pas).

La LED "L2" s'allume temporairement chaque fois que le data logger effectue des mesures et les enregistre sur la carte SD.

	/************************************************************
	Saisie de données (data logging) avec un Arduino
	Matériel: Arduino Uno et Data Logging Shield (modèle mis au point par Adafruit)
	Lecteur de carte SD (10-11-12-13) avec adapteur 5/3,3 V
	Capteurs analogiques branchés à A0 et A1
	LEDs du Data Logging Shield branchées à D4 et D5
	http://electroniqueamateur.blogspot.ca/2016/10/utilisation-du-data-logging-shield.html
	*************************************************************/
	// Les bibiothèques
	#include <SD.h> // pour le lecteur de carte SD
	#include <Wire.h> // pour l'horloge temps réel et capteurs i2C
	#include <RTClib.h> // pour l'horloge temps réel
	// Nombre de secondes entres chaque prise de mesure
	#define DELAI_MESURES 10
	const int capteur1Pin = A0; // un premier capteur branché à A0
	const int capteur2Pin = A1; // un premier capteur branché à A1
	const int chipSelect = 10; // chipSelect de la carte SD à la pin 10
	const int LED1Pin = 5; // une LED branchée à D5 (clignote pendant que le DataLogger est en fonction)
	const int LED2Pin = 4; // une LED branchée à D4 (s'allume temporairement pendant la prise de mesures)
	RTC_DS1307 RTC; // objet Real Time Clock
	DateTime now;
	long tempsInitial = 0; // nombre de secondes entre le 1 jan 2000 et le début du script
	long derniereMesure = 0; // moment de la plus récente prise de mesure
	long dernierBlink = 0; // dernère fois qu'on a changé l'état de la LED clignotante
	int etatLED = 0;
	File logfile; //fichier
	void error(char *str)
	{
	Serial.print("Erreur: ");
	Serial.println(str);
	while (1);
	}
	void setup(void)
	{
	// initialisation du moniteur série
	Serial.begin(9600);
	Serial.println();
	// initialisation de la carte SD
	pinMode(10, OUTPUT);
	// initialisation de la carte SD
	if (!SD.begin(chipSelect)) {
	error("echec de l'initialisation de la carte SD");
	}
	Serial.println("Initialisation de la carte SD reussie.");
	// Création d'un fichier
	char filename[] = "Rappor00.csv";
	for (uint8_t i = 0; i < 100; i++) {
	filename[6] = i / 10 + '0';
	filename[7] = i % 10 + '0';
	if (! SD.exists(filename)) {
	logfile = SD.open(filename, FILE_WRITE);
	break;
	}
	}
	if (! logfile) {
	error("echec de la creation du fichier");
	}
	Serial.print("Nom du fichier: ");
	Serial.println(filename);
	// initialisation de l'horloge temps réel (RTC)
	Wire.begin();
	RTC.begin();
	now = RTC.now();
	tempsInitial = now.get();
	derniereMesure = now.get() - DELAI_MESURES;
	logfile.println("secondes;date;heure;mesure 1;mesure 2");
	Serial.println("secondes;date;heure;mesure 1;mesure 2");
	}
	void loop(void)
	{
	// on mesure les données pertinentes
	now = RTC.now(); // quelle heure est-il?
	long maintenant = now.get();
	//clignotement de la LED de fonctionnement normal
	if ((maintenant - dernierBlink) >= 1) { // c'est le temps de changer l'état de la LED clignotante
	etatLED = !etatLED;
	digitalWrite(LED1Pin, etatLED);
	dernierBlink = maintenant;
	}
	if ((now.get() - derniereMesure) < DELAI_MESURES) return; // on ne va pas plus loin si aucune mesure n'est nécessaire
	derniereMesure = now.get();
	// on allume la LED indicatrice de mesure
	digitalWrite(LED2Pin, HIGH);
	int mesure1 = analogRead(capteur1Pin);
	int mesure2 = analogRead(capteur2Pin);
	// Écriture du fichier
	logfile.print(now.get() - tempsInitial); // nombre de secondes depuis le début des mesures
	logfile.print("; ");
	if (now.day() < 10) logfile.print("0"); // date
	logfile.print(now.day(), DEC);
	logfile.print("-");
	if (now.month() < 10) logfile.print("0");
	logfile.print(now.month(), DEC);
	logfile.print("-");
	logfile.print(now.year(), DEC);
	logfile.print("; ");
	if (now.hour() < 10) logfile.print("0"); // heure
	logfile.print(now.hour(), DEC);
	logfile.print(":");
	if (now.minute() < 10) logfile.print("0");
	logfile.print(now.minute(), DEC);
	logfile.print(":");
	if (now.second() < 10) logfile.print("0");
	logfile.print(now.second(), DEC);
	logfile.print("; ");
	logfile.print(mesure1); // luminosite
	logfile.print("; ");
	logfile.print(mesure2);
	logfile.println();
	// Écriture du moniteur série (utile pour le débogage, pas tellement pendant
	// l'utilisation réelle.
	Serial.print(now.get() - tempsInitial); // nombre de secondes depuis le début du sketch
	Serial.print("; ");
	if (now.day() < 10) Serial.print("0");
	Serial.print(now.day(), DEC);
	Serial.print("-");
	if (now.month() < 10) Serial.print("0");
	Serial.print(now.month(), DEC);
	Serial.print("-");
	Serial.print(now.year(), DEC);
	Serial.print("; ");
	if (now.hour() < 10) Serial.print("0");
	Serial.print(now.hour(), DEC);
	Serial.print(":");
	if (now.minute() < 10) Serial.print("0");
	Serial.print(now.minute(), DEC);
	Serial.print(":");
	if (now.second() < 10) Serial.print("0");
	Serial.print(now.second(), DEC);
	Serial.print("; ");
	Serial.print(mesure1);
	Serial.print("; ");
	Serial.print(mesure2);
	Serial.println();
	logfile.flush();
	// on éteint la LED de mesure
	digitalWrite(LED2Pin, LOW);
	}

view raw Shield_data_logging.ino hosted with ❤ by GitHub

Voici ce qu'affiche le moniteur série pendant la prise de mesures:

Et voici le fichier "RAPPOR00.CSV" qui a été enregistré sur la carte SD, après ouverture dans Excel:

Les données peuvent ensuite être présentées sous forme de graphiques.

Yves Pelletier   (Twitter, Facebook)

Une première exploration de la carte µLogic16

µLogic16 est une carte d'interface mise au point en France par BS Electronics. Particularité intéressante: elle est accompagnée d'un logiciel (LogiControl) qui permet  de la piloter au moyens de représentations schématiques de circuits logiques.

Son concepteur m'en ayant gentiment expédié un exemplaire, je partage aujourd'hui mes premières expérimentations avec cette carte.

La carte µLogic16

Basée sur le microcontrôleur STM32F33, la carte mesure 4 cm X 5 cm (un peu plus que la moitié d'une carte Arduino).  Elle comporte deux ports qui peuvent être configurés en entrée ou en sortie (8 entrées/sorties par port).   Les connecteurs sont de robustes borniers à vis.

Lorsque vous branchez la carte à un ordinateur pour la première fois (par son connecteur mini usb), les pilotes nécessaires sont automatiquement installés.

Le logiciel Logicontrol

On peut télécharger le logiciel sur la page de BS Electronics.  Il s'agit ensuite d'exécuter l'application "LogiControl.exe" (Windows seulement).

Une fois dans l'application, un clic sur le bouton "Connect" crée un lien entre l'application Logicontrol et la carte µLogic 16.

Premier projet:  faire clignoter une LED

Puisque la carte comporte une LED verte qui peut être contrôlée par l'utilisateur, notre premier essai consistera à faire clignoter cette LED.

Nous allons donc créer un nouveau fichier (Menu File / New)...

On choisit une destination et un nom pour le fichier, on règle "Device" à "µLogic16", puis on clique sur le bouton "Create".

Ici, les choses deviennent intéressantes:  les entrées/sorties des deux ports apparaissent à l'écran, ainsi que la LED intégrée à la carte.  De plus, de nouveaux menus nous permettent d'ajouter des composants sur le schéma.

Dans le menu "Special", on trouve un article intitulé "Clock":

...ce menu permet de faire apparaître une horloge réglée par défaut à une fréquence de 1 Hz (cliquez là où vous voulez placer l'horloge).

En cliquant sur les deux terminaux (19 et 18), on peut relier l'horloge à la LED:

Ce schéma devrait être suffisant pour faire clignoter la LED à une fréquence de 1 Hz (si cette fréquence ne vous convient pas, un clic droit sur le schéma de l'horloge vous permettra de la modifier).

Il nous reste à transmettre l'information à la carte µLogic 16.  Pour ce faire, vous cliquez d'abord sur le bouton "Import", et vous choisissez "From Schematic":

Puis, vous cliquez sur le bouton "Program Device".

Mission accomplie:  la LED verte intégrée sur la carte se met à clignoter.

Deuxième projet:  des boutons, des LEDs et des portes logiques

Dans un deuxième temps, j'ai voulu ajouter un peu d'interactivité tout en testant les entrées et sorties de la carte.  Le but, cette fois, est de contrôler deux LEDs au moyen d'un même bouton poussoir:  une première LED qui est habituellement éteinte mais qui s'allume lorsqu'on appuie sur le bouton, et une deuxième LED qui est habituellement allumée mais qui s'éteint lorsqu'on appuie sur le bouton.

Le circuit réel construit sur breadboard consiste en un bouton poussoir qui permettra de contrôler l'entrée 0 du port A de la carte, et de deux LEDs qui seront contrôlées respectivement par les sorties 0 et 3 du port B.

Construisons maintenant le circuit virtuel, dans Logicontrol, qui déterminera le comportement de la carte µLogic16.

Après avoir créé un nouveau fichier (menu File / New)...

...je fais un clic droit sur la représentation du port B, afin de le configurer en mode "sortie" (output):

Un second clic droit sur le port B me permet de le déplacer face au port A (après avoir cliqué sur le bouton "move":

Pour que la sortie B0 prenne systématiquement le même état logique que l'entrée A0, je clique sur le connecteur de A0, et ensuite sur le connecteur de B0:

Dans le menu "Gate", je sélectionne une porte NON (Not):

... que je déplace entre A3 et B3.

Je clique entre la sortie de la porte NON et la sortie B3, afin de les relier entre elles.  Je clique également sur l'entrée de la porte NON et le câble qui relie déjà A0 et B0:

De cette façon, la sortie B3 de la carte sera systématiquement dans l'état logique contraire à celui de l'entrée A0.

Il ne reste plus qu'à essayer notre circuit:  on clique sur le bouton "Import", puis sur "From Schematic", et finalement sur "Program Device".

Résultat, tel que prévu:  une des LEDs installées sur la breadboard s'allume quand on appuie sur le bouton et s'éteint lorsqu'on relâche le bouton.  L'autre LED est allumée quand le bouton est relâchée, et éteinte quand on appuie sur le bouton.

Troisième projet:  un compteur binaire 8 bits


Dans cette troisième expérience exploratoire, j'ai utilisé le compteur binaire 8 bits offert dans le logiciel Logicontrol.


Cette fois, le circuit réel sur breadboard est constitué de 8 LEDs, chacune d'entre elle étant contrôlée par une des sorties du port B de la carte µLogic16.

Pour la construction du circuit virtuel dans le logiciel Logicontrol, il faut choisir un compteur (Counter) dans le menu "Component".

On ajoute ensuite une horloge ("Clock", dans le menu "Special") qu'on relie à l'entrée "CK" du compteur, et on relie chaque sortie du compteur à une pin du port B (qui a préalablement été configuré en sortie):

Comme c'était le cas dans les projets précédents,  on clique sur le bouton "Import", puis sur "From Schematic", et finalement sur "Program Device".

Sur la breaboard, les 8 LEDs s'allument en alternance de façon à présenter les nombres binaires de 0 jusqu'à 255.

Pour pous d'informations:  BS Electronics


Yves Pelletier   (Twitter, Facebook)

Fermeture de Codebender

Mise à jour (25 juin 2017):  Codebender a récemment annoncé sa résurrection, ayant été acquis par Codeanywhere.  Nouveauté importante: après une période d'essai gratuite d'un mois, vous devrez dorénavant payer un abonnement mensuel de $10 pour utiliser Codebender...

Il y a quelques mois, lorsque j'ai appris la création d'Arduino Create, qui permet de programmer votre Arduino en ligne à partir d'un fureteur web, j'avais mentionné que ce nouvel outil jouait beaucoup dans les plates-bandes de Codebender, qui offrait un service assez similaire.


Ce qui devait arriver vient d'arriver:  l'équipe de Codebender vient d'annoncer la fin de l'aventure. Le service était pourtant populaire (100 000 utilisateurs inscrits), mais il n'était malheureusement pas rentable.

À partir du 31 octobre, il deviendra impossible de créer un nouveau compte sur Codebender.  Le 7 novembre, la compilation sera désactivée.  Le 15 novembre, la création de projet sera désactivée, et le 31 novembre (ils ont un 31 novembre en Grèce?!?!?), les comptes d'utilisateurs existants seront désactivés.

Les projets hébergés sur le site seront accessible en lecture seule au moins jusqu'au 31 décembre, et possiblement plus longtemps si la demande le justifie.

Yves Pelletier   (Twitter, Facebook)

Appareil pour identifier les composants électroniques LCR-T3

Quand j'ai vu ce "DIY LCR-T3 graphical Digital Combo tester capacitor +inductance + resistor +SCR" offert sur eBay pour la modique somme de 9 USD, ça m'a semblé une addition très pertinente pour ma boîte à outils.

Il s'agit d'un appareil qui permet d'identifier et de mesurer les principales caractéristiques de divers composants électroniques:  résistances, condensateurs, diodes, transistors, etc.  D'après ce que j'ai compris, c'est basé sur le travail de Markus Frejek et Karl-Heinz Kübbeler.

Le dispositif est vendu sous la forme d'un kit:  avant de l'utiliser, l'acheteur devra lui-même souder 3 morceaux (fournis):  un connecteur ZIF, un bouton poussoir et un connecteur pour batterie 9 V.  20 points de soudure au total, rien de bien compliqué.

La photo ci-dessous montre le verso de la carte:  en plus du microcontrôleur (Atmega 328P, le même que l'Arduino Uno) et d'un quartz de 8 MHz, de nombreux petits composants SMD ont déjà été soudés sur la carte en usine.

Pour utiliser l'appareil, il s'agit d'insérer le composant à identifier dans le connecteur ZIF, puis d'appuyer sur le bouton.  Les caractéristiques du composant s'affichent à l'écran pendant quelques secondes (un peu plus tard, le dispositif s'éteint automatiquement).

Faisons quelques essais...

Je commence par insérer une résistance de 100 Ω dans le connecteur ZIF, puis j'appuis sur le bouton. Ça affiche une résistance de 100,8 Ω.  On peut mesurer n'importe quelle résistance jusqu'à 50 MΩ avec une résolution de 0,1 Ω.

Un potentiomètre sera 100 kΩ est correctement identifié comme un groupe de deux résistances en série:

Un condensateur de 100 nF est correctement identifié.  En prime, on indique la résistance équivalente série (ESR) et la perte de tension.

J'ai ensuite inséré un inducteur de forme toroïdale:  il a une inductance de 0,03 mH et une résistance de 0,3 Ω.

J'essaie maintenant une LED bleue.  Comme pour toutes les diodes, une illustration indique dans quel sens elle a été branchée.  On obtient également sa tension de seuil et sa capacité.

Succès mitigé pour la diode zener 1N5224 (2,8 V):  elle est identifiée comme une combinaison de 2 diodes.  Le vendeur affirmait pourtant que l'appareil pouvait identifier les diodes zener dont la tension est plus basse que 4,5 V.

Transistor bipolaire 2N3904:  on identifie la base, l'émetteur et le récepteur, on indique qu'il s'agit d'un NPN, on fournit le gain en courant et la tension base-émetteur.

Un MOSFET 2N7000:

Un triac:

Nous sommes limités à des composants comportant 2 ou 3 broches (pas question d'insérer un circuit intégré dans l'espoir qu'il soit automatiquement identifié), mais de toute évidence cet outil peut être très utile (particulièrement si vous récupérez des composants dans de vieux appareils, ou si vous achetez des composants en vrac).


Yves Pelletier   (Twitter, Facebook)

Capteur de lumière TSL2561 et Arduino

Je vous présente aujourd'hui une courte marche à suivre pour utiliser un module capteur de lumière TSL2561 avec une carte Arduino.

Lorsqu'on veut qu'un circuit électronique fasse la différence entre la lumière et l'obscurité (pour qu'une veilleuse s'allume automatiquement quand il fait noir, ou pour capter le signal pulsé d'une télécommande infrarouge, par exemple) l'utilisation d'une photorésistance ou d'un phototransistor est tout à fait appropriée.

Mais si vous désirez mesurer une intensité lumineuse, vous obtiendrez probablement de meilleurs résultats en utilisant un capteur plus sophistiqué.  Le TSL2561 est un capteur numérique (protocole I2C) qui indique l'intensité lumineuse en lux, de façon à imiter la réponse de l'oeil humain.  Pour ce faire, le TSL2561 comporte deux photodiodes: l'une d'entre elles mesure à la fois la lumière visible et l'infrarouge, alors que l'autre mesure exclusivement l'infrarouge.  Une équation empirique permet de calculer l'intensité lumineuse en lux à partir de ces deux mesures.

Le module

Le circuit intégré lui-même est liliputien:  ça vaut vraiment la peine de se procurer un module (breakout) auquel il suffira de souder une rangée de 5 pins.  Vous pouvez le trouver sur eBay pour $2 environ, à moins que vous préfériez vous procurer l'original développé par Sparkfun.

Les 5 connecteurs sont identifiés aux verso du module:

• 3V3  et GND servent pour l'alimentation du module.
• SCL et SDA servent à la communication i2C
• INT peut être utilisée pour envoyer un "interrupt" au microcontrôleur, signifiant qu'une mesure a été prise.  Je n'ai pas utilisé cette option.

Connexions à l'Arduino

Rien de très surprenant ici, si vous avez déjà utilisé un périphérique i2c auparavant:  les pins i2c de l'Arduino Uno sont A4 (SDA) et A5 (SCL) (mais elles sont différentes sur d'autres modèle comme le Mega, par exemple)­.  Le breakout doit être alimenté en 3,3 V, mais il n'est pas nécessaire de convertir le signal de communication (qui sera, lui, à 5 V).

• 3V3 du TSL2561 à 3V3 de l'Arduino Uno
• GND du TSL2561 à GND de l'Arduino Uno
• SCL du TSL2561 à A5 de l'Arduino Uno
• SDA du TSL2561 à A4 de l'Arduino Uno

Installation de la bibliothèque

Sparkfun a mis au point une bibliothèque qui nous facilitera la tâche pour la phase de codage de l'Arduino.  Après avoir téléchargé la bibliothèque sur le site github, vous devrez l'installer manuellement (le menu "Ajouter une bibliothèque .zip" de l'IDE Arduino ne fonctionne pas pour ce fichier).   Vous devez donc décompresser le fichier "TSL2561_Luminosity_Sensor.zip", renommer son dossier "Librairies" à votre convenance, puis déplacer ce dossier à l'intérieur du dossier "Librairies" de votre sketchbook Arduino.

Utilisation du sketch d'exemple

Si votre bibliothèque a été convenablement installée, vous devriez voir dans le menu "Fichier / Exemples" une nouvelle catégorie intitulée "Sparkfun TSL2561", contenant un exemple intitutlé "SparkFunTSL2561Example".

Il s'agit d'ouvrir ce fichier, de le téléverser dans votre Arduino et d'activer le moniteur série pour voir apparaître les mesures.

"data0" et "data1" représentent respectivement les données brutes mesurées par chacun des deux capteurs, alors que le 3e nombre indique l'intensité lumineuse calculée en lux.  La mention "good" indique qu'aucun des deux capteurs n'était saturé.

Modifications au sketch d'exemple

Deux variables peuvent être modifiées pour que le sketch réponde mieux à vos besoins:

La variable booléenne "gain" est réglée par défaut à "0", ce qui est approprié pour mesurer des intensité lumineuses élevées.  Si vous désirez mesurer des intensités lumineuses plus faibles, vous pouvez régler cette variable à "1", ce qui multiplie le gain par 16.

L'entier "time" permet de régler le temps d'intégration (le temps pendant lequel le capteur compile une série de mesures qui seront utilisées dans le calcul).  Par défaut, ce temps d'intégration est de 402 ms, mais vous pouvez le régler à 13,7 ms (si time = 0), 101 ms (si time = 1),  402 ms (si time = 2) ou réglage manuel (si time = 3).

Vérifiez l'état de la variable booléenne "good":  si elle devient nulle, ça indique qu'au moins un des capteurs a saturé.  Il faut alors réduire le gain, ou diminuer le temps d'intégration.

Sources:  ce tutoriel rédigé par Sparkfun m'a été très utile.

Yves Pelletier   (Twitter, Facebook)