Balance électronique avec la carte ESP32 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 ESP32
Présentation du projet
Objectif du projet
L’objectif de ce projet est de réaliser une balance électronique numérique capable de mesurer le poids d’un objet avec précision en utilisant une carte ESP32, un module HX711, une cellule de charge et un afficheur LCD I2C.
Ce système permet de convertir la force appliquée sur la cellule de charge en une valeur de poids lisible et affichée en temps réel sur l’écran LCD.
Ce projet permet également d’apprendre à :
- utiliser une cellule de charge pour mesurer une force ou un poids
- lire les données du module HX711 avec l’ESP32
- afficher des informations sur un écran LCD I2C
- concevoir un système de mesure électronique précis
- réaliser des projets de pesage pour des applications réelles
Fonctionnement du projet
Le fonctionnement de la balance électronique repose sur plusieurs étapes :
1- Application du poids
Lorsqu’un objet est placé sur la cellule de charge, celle-ci se déforme légèrement. Cette déformation génère un très faible signal électrique analogique.
2- Amplification et conversion du signal
Le module HX711 amplifie ce signal très faible et le convertit en un signal numérique exploitable par l’ESP32.
3- Lecture des données par l’ESP32
La carte ESP32 lit les données numériques envoyées par le module HX711, puis applique un facteur de calibration pour convertir ces données en une valeur de poids réelle (en grammes ou kilogrammes).
4- Affichage du poids
L’ESP32 envoie ensuite la valeur calculée vers l’afficheur LCD I2C, qui affiche le poids mesuré en temps réel.
5- Actualisation continue
Le système répète ce processus en continu afin d’afficher le poids instantanément dès qu’un objet est ajouté, retiré ou modifié.
Matériel nécessaire
1- Carte ESP32
La carte ESP32 est le microcontrôleur principal du projet. Elle permet de lire les données envoyées par le module HX711, de traiter ces données et de calculer le poids correspondant. Ensuite, elle envoie le résultat vers l’afficheur LCD I2C pour l’affichage.
2. Capteur HX711
Le capteur HX711 est un module spécialisé conçu pour les systèmes de pesage. Il amplifie les faibles signaux électriques provenant de la cellule de poids et les convertit en données numériques lisibles par la carte ESP32.
4. Cellule de poids (Load Cell)
La cellule de poids est un capteur qui mesure la force ou le poids appliqué. Elle contient des jauges de contrainte qui changent de résistance lorsqu’une force est appliquée.
5. Afficheur LCD I2C
L’afficheur LCD I2C permet d’afficher le poids mesuré de manière claire et lisible.
6. Câbles de Connexion (Jumper Wires)
Les fils de connexion permettent de relier les différents composants entre eux.
7- Breadboard (Plaque d'essai) :
Une breadboard est utile pour créer un circuit temporaire et connecter facilement les composants entre eux.
Schéma de câblage de la balance
1- Connexion du capteur HX711 à la carte ESP32
| Capteur HX711 | Carte ESP32 |
|---|---|
| VCC | 3V |
| GND | GND |
| DT | GPIO 19 |
| SCK | GPIO 18 |
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 ESP32
| Afficheur LCD I2C | Carte ESP32 |
|---|---|
| VCC | 5V |
| GND | GND |
| SDA | GPIO 21 |
| SCL | GPIO 22 |
Programmation de la carte ESP32
Ce programme MicroPython permet de réaliser une balance électronique numérique en utilisant la carte ESP32, le module HX711, une cellule de charge et un afficheur LCD I2C. Il mesure le poids d’un objet et l’affiche en temps réel sur l’écran LCD.
On commence par l’importation de ces bibliothèques:
i2c_lcd et lcd_api → pour afficher les informations sur l’écran LCD I2C
hx711.py → pour contrôler le module HX711
Voici le code en Micropython 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 |
# Importer la classe Pin pour contrôler les broches GPIO de l'ESP32 # Importer la classe I2C pour la communication avec les périphériques I2C from machine import Pin, I2C # Importer la bibliothèque pour contrôler l'afficheur LCD I2C from i2c_lcd import I2cLcd # Importer le module time pour utiliser les temporisations import time # Importer la bibliothèque du module HX711 pour lire la cellule de charge from hx711 import HX711 # ===================================== # CONFIGURATION DE L'AFFICHEUR LCD I2C # ===================================== # Adresse I2C de l'afficheur LCD (souvent 0x27 ou 0x3F) I2C_ADDR = 0x27 # Initialisation du bus I2C # I2C(0) -> utiliser le bus I2C numéro 0 de l'ESP32 # scl=Pin(22) -> connecter la broche SCL du LCD à GPIO 22 # sda=Pin(21) -> connecter la broche SDA du LCD à GPIO 21 # 4, 20 -> LCD avec 4 lignes et 20 colonnes lcd = I2cLcd(I2C(0, scl=Pin(22), sda=Pin(21)), I2C_ADDR, 4, 20) # Effacer l'écran LCD lcd.clear() # Afficher un message de démarrage sur la première ligne lcd.putstr("ESP32 Balance") # ===================================== # CONFIGURATION DU MODULE HX711 # ===================================== # Initialiser le module HX711 # d_out=19 -> broche DT connectée à GPIO 19 # pd_sck=18 -> broche SCK connectée à GPIO 18 driver = HX711(d_out=19, pd_sck=18) # ===================================== # BOUCLE PRINCIPALE # ===================================== while True: # Lire la valeur brute envoyée par le module HX711 # Appliquer une formule de calibration pour convertir la valeur en poids (grammes) # 183200 -> valeur offset (tare) # 238 -> facteur de calibration # -47 -> correction pour améliorer la précision # abs() -> permet d'obtenir une valeur positive poids = abs(183200 - driver.read()) / 238 - 47 # Placer le curseur au début de la deuxième ligne (colonne 0, ligne 1) lcd.move_to(0, 1) # Effacer la deuxième ligne en écrivant des espaces lcd.putstr(" ") # Replacer le curseur au début de la deuxième ligne lcd.move_to(0, 1) # Afficher le poids avec 2 chiffres après la virgule lcd.putstr("Poids= " + str(round(poids, 2)) + " g") # Attendre 1 seconde avant la prochaine mesure time.sleep(1) |
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
