Balance numérique avec ESP8266 NodeMCU et module HX711

ESP8266 05-03-26

25 0

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 ESP8266 NodeMCU

Présentation du projet

Objectif du projet

L’objectif de ce projet est de réaliser une balance numérique électronique en utilisant la carte ESP8266 NodeMCU, le module amplificateur HX711, un capteur de force (load cell) et un LCD 16x2 I2C. Cette balance permet de mesurer avec précision le poids d’un objet et d’afficher la valeur directement sur l’écran LCD. Le projet a aussi pour but de montrer comment interfacer un capteur analogique très sensible avec un microcontrôleur et comment afficher les données mesurées sur un afficheur I2C en temps réel.

Fonctionnement du projet :

Le fonctionnement de la balance repose sur le capteur de charge (load cell) qui détecte la force exercée par l’objet placé sur la plateforme. Cette force est convertie en un très faible signal électrique. Le module HX711 amplifie ce signal et le convertit en données numériques exploitables par la carte ESP8266 NodeMCU. Le microcontrôleur lit ensuite ces données, applique un facteur de calibration pour convertir la valeur en poids (grammes), puis envoie le résultat vers l’afficheur LCD I2C. L’écran affiche alors le poids mesuré en temps réel, généralement en grammes (g), permettant à l’utilisateur de lire facilement la mesure.

Matériel nécessaire

1- Carte ESP32

La carte ESP8266 NodeMCU est une carte de développement basée sur le microcontrôleur ESP8266. Elle sert de cerveau du système. Elle lit les données envoyées par le module HX711, effectue les calculs nécessaires pour déterminer le poids et envoie le résultat à l’afficheur LCD.

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 ESP8266 NodeMCU.

3. 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.

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)

Fils de connexion

Les fils de connexion permettent de relier les différents composants entre eux.

6- Breadboard (Plaque d'essai) :

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 ESP8266

Capteur HX711	Carte ESP8266
VCC	3V
GND	GND
DT	D6 (GPIO 12)
SCK	D5 (GPIO 14)

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 ESP8266

Afficheur LCD I2C	Carte ESP8266
VCC	5V
GND	GND
SDA	D2 (GPIO 4)
SCL	D1 (GPIO 5)

Programmation de la carte ESP8266 NodeMCU

Ce programme MicroPython permet de réaliser une balance électronique numérique en utilisant la carte ESP8266 NodeMCU, 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 :

# Importation des classes nécessaires pour utiliser les broches et la communication I2C
from machine import Pin, I2C , SoftI2C

# Importation de la bibliothèque pour contrôler l'afficheur LCD I2C
from i2c_lcd import I2cLcd

# Importation du module time pour les temporisations
import time 

# Importation de la bibliothèque du module HX711 (utilisé avec la cellule de charge)
from hx711 import HX711


# Adresse I2C du module LCD (souvent 0x27 ou 0x3F)
I2C_ADDR = 0x27

# Nombre de lignes et de colonnes de l'afficheur LCD
totalRows = 4
totalColumns = 20


# === Initialisation du LCD I2C ===
# Création du bus I2C logiciel pour la carte ESP8266
# SCL connecté à la broche GPIO5
# SDA connecté à la broche GPIO4
i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=10000)

# Création de l'objet LCD avec l'adresse I2C et la taille de l'écran
lcd = I2cLcd(i2c, I2C_ADDR, totalRows, totalColumns)


# Effacer l'écran LCD au démarrage
lcd.clear()

# Afficher un message de démarrage sur la première ligne
lcd.putstr("ESP8266 Balance")


# Initialisation du module HX711
# d_out connecté à la broche GPIO12
# pd_sck connecté à la broche GPIO14
driver = HX711(d_out=12, pd_sck=14)


# Boucle principale (fonctionne en continu)
while True:
    
   # Lecture de la valeur brute du capteur HX711
   # Conversion en poids avec un facteur de calibration
   poids = abs(183200 - driver.read()) / 238 - 45
   
   # Positionner le curseur au début de la deuxième ligne
   lcd.move_to(0, 1)
   
   # Effacer la ligne pour éviter les anciens caractères
   lcd.putstr("                    ")
   
   # Replacer le curseur au début de la deuxième ligne
   lcd.move_to(0, 1)
   
   # Afficher le poids mesuré arrondi à deux chiffres après la virgule
   lcd.putstr("Poids= " + str(round(poids, 2)) + " g")