Balance électronique avec Arduino UNO et module HX711
Plan de tutoriel
1- Présentation du projet
2- Matériel nécessaire
3- Schéma de câblage de la balance
4- Programmation de la carte Arduino UNO
Présentation du projet
L’objectif de ce projet est de réaliser une balance électronique numérique capable de mesurer le poids d’un objet et d’afficher la valeur mesurée sur un écran. Le système est basé sur la carte Arduino Uno, qui assure le traitement des données, le module HX711 utilisé pour amplifier et convertir le signal provenant de la cellule de charge, et un afficheur LCD 16x2 qui permet de visualiser le poids mesuré. Ce projet constitue une bonne introduction aux systèmes de mesure électroniques et à l’utilisation des capteurs avec Arduino.
Le fonctionnement du système repose sur la cellule de charge, qui agit comme un capteur de force. Lorsqu’un objet est placé sur la plateforme de la balance, la cellule de charge se déforme légèrement. Cette déformation modifie la résistance des jauges de contrainte intégrées dans le capteur et génère un signal électrique très faible proportionnel au poids appliqué.
Ce signal étant très faible, il ne peut pas être lu directement par la carte Arduino. Le module HX711 est donc utilisé pour amplifier ce signal et le convertir en données numériques. Ces données sont ensuite envoyées à la carte Arduino, qui les traite à l’aide d’un programme afin de calculer le poids réel en appliquant un facteur de calibration.
Enfin, la valeur du poids calculée est envoyée vers l’afficheur LCD I2C. L’écran affiche le poids de l’objet placé sur la balance en temps réel, ce qui permet à l’utilisateur de lire facilement la mesure. Grâce à la communication I2C, seulement deux fils de données sont nécessaires pour connecter l’écran à la carte Arduino, ce qui simplifie le câblage du montage.
Matériel nécessaire
1- Carte Arduino UNO
La carte Arduino Uno est le cerveau du système. C’est une carte microcontrôleur qui exécute le programme chargé par l’utilisateur. Elle reçoit les données du module HX711, effectue les calculs nécessaires (conversion et calibration) puis envoie le résultat vers l’afficheur LCD.
2. Module HX711
Le module HX711 est un module amplificateur et convertisseur analogique-numérique (ADC). La cellule de charge produit un signal électrique très faible, impossible à lire directement par l’Arduino. Le HX711 amplifie ce signal et le convertit en données numériques exploitables.
3. Cellule de poids (Load Cell)
La cellule de charge (load cell) est le capteur de poids. Elle fonctionne grâce à des jauges de contrainte internes qui se déforment légèrement lorsqu’un objet est placé dessus. Cette déformation provoque une variation de tension proportionnelle au poids appliqué.
4. Afficheur LCD I2C
L’afficheur LCD I2C permet d’afficher le poids mesuré de manière claire et lisible.
5. Câbles de Connexion (Jumper Wires)
Les fils de connexion permettent de relier les différents composants entre eux.
Schéma de câblage de la balance
1- Connexion du capteur HX711 à la carte Arduino UNO
| Capteur HX711 | Arduino UNO |
|---|---|
| VCC | 3V |
| GND | GND |
| DT | Pin 3 |
| SCK | Pin 2 |
2- Connexion du cellule de poids au capteur HX711
| Cellule de poids | capteur HX711 |
|---|---|
| Rouge | E+ |
| Noir | E- |
| Blanc | A- |
| Vert | A+ |
3- Connexion de l’afficheur LCD I2C à la carte Arduino UNO
| Afficheur LCD I2C | Arduino UNO |
|---|---|
| VCC | 5V |
| GND | GND |
| SDA | Pin A4 |
| SCL | Pin A5 |
Programmation de la carte Arduino UNO
Ce programme Arduino permet de mesurer un poids à l’aide d’une cellule de charge et du module HX711, puis d’afficher la valeur mesurée sur un écran LCD I2C, tout en l’envoyant également vers le moniteur série.
On commence par l’importation de ces bibliothèques:
LiquidCrystal_I2C → pour afficher les informations sur l’écran LCD I2C
HX711-master.zip → pour contrôler le module HX711
Voici le code en Arduino qui implémente le fonctionnement du système :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 |
// =============================== // Lecture du poids avec HX711 // Affichage sur LCD I2C // =============================== // Inclusion de la bibliothèque pour le module HX711 #include "HX711.h" // Inclusion de la bibliothèque pour l'afficheur LCD I2C #include <LiquidCrystal_I2C.h> // =============================== // Configuration HX711 // =============================== // Définition des broches utilisées pour connecter le HX711 à l'Arduino #define DT 3 // Broche DT (Data) du HX711 connectée à la broche 3 #define SCK 2 // Broche SCK (Clock) du HX711 connectée à la broche 2 // Création d'un objet scale pour manipuler le HX711 HX711 scale; // =============================== // Configuration LCD I2C // =============================== // Création de l'objet lcd // 0x27 = adresse I2C de l'écran // 20 = nombre de colonnes // 4 = nombre de lignes LiquidCrystal_I2C lcd(0x27, 20, 4); // =============================== // Facteur de calibration // =============================== // Facteur permettant de convertir la valeur brute en grammes // Cette valeur doit être ajustée selon votre cellule de charge float calibration_factor = 235; void setup() { // Initialisation de la communication série (pour affichage dans le moniteur série) Serial.begin(9600); // =============================== // Initialisation du LCD // =============================== lcd.init(); // Initialiser l'écran LCD lcd.backlight(); // Activer le rétroéclairage lcd.setCursor(0, 0); // Positionner le curseur colonne 0, ligne 0 lcd.print("Arduino Balance"); // Afficher un message de démarrage // =============================== // Initialisation du HX711 // =============================== scale.begin(DT, SCK); // Démarrer le HX711 avec les broches définies scale.set_scale(calibration_factor); // Appliquer le facteur de calibration scale.tare(); // Mettre la balance à zéro (sans charge) delay(2000); // Attendre 2 secondes avant de commencer les mesures //lcd.clear(); // Effacer l'écran (optionnel) } void loop() { // Lire le poids en faisant la moyenne de 10 mesures float poids = scale.get_units(10); // Positionner le curseur sur la deuxième ligne lcd.setCursor(0, 1); lcd.print("Poids : "); // Afficher le texte fixe // Positionner le curseur après le texte lcd.setCursor(9, 1); // Afficher le poids avec 2 chiffres après la virgule lcd.print(poids, 2); lcd.print(" g "); // Ajouter des espaces pour effacer les anciens chiffres // Affichage également dans le moniteur série Serial.print("Poids: "); Serial.print(poids, 2); Serial.println(" g"); // Petite pause avant la prochaine lecture delay(500); } |
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
