HX711 Arduino : capteur de poids, étalonnage et balance numérique

Le duo HX711 et Arduino est la solution la plus répandue et la moins chère pour lire le signal de quelques microvolts d'un capteur de poids (cellule de charge, ou load cell) et le convertir en grammes. Balance de cuisine, pèse-personne, balance de ruche, surveillance d'une gamelle ou banc de mesure de poussée d'un moteur : tous ces projets reposent sur le même principe. La cellule se déforme d'une quantité invisible sous la charge, le HX711 transforme ce minuscule changement en un nombre de 24 bits, et l'Arduino le convertit en grammes grâce à un facteur d'étalonnage.

Dans ce guide, tu vas découvrir comment fonctionne le pont de Wheatstone à l'intérieur d'une cellule de charge, ce que signifient les couleurs des fils (E+, E-, A+, A-), comment câbler quatre demi-ponts de 50 kg récupérés dans un pèse-personne, et comment faire la tare et trouver le facteur d'étalonnage pas à pas avec la bibliothèque HX711. Ensuite, tu construiras une balance numérique avec écran LCD et bouton de tare, tu verras pourquoi les mesures tremblent et comment les stabiliser, puis tu feras la même chose avec un ESP32 et un écran OLED, et avec un Raspberry Pi Pico (MicroPython).

Qu'est-ce qu'une cellule de charge et comment fonctionne-t-elle ?

Une cellule de charge est une pièce en aluminium ou en acier sur laquelle sont collées des jauges de contrainte (strain gauges). Une jauge est une résistance gravée en zigzag sur un film mince : quand le métal s'étire, la piste s'allonge et s'amincit, et sa résistance augmente ; quand il est comprimé, elle diminue. La variation est incroyablement faible. Une jauge dont le facteur de jauge vaut environ 2 ne change sa résistance que de 0,2 pour cent pour une déformation d'un millième ; pour une jauge de 1000 Ω, cela fait 2 Ω, qu'un simple analogRead() ne pourrait jamais voir.

Pour rendre ce minuscule changement mesurable, quatre jauges sont câblées en pont de Wheatstone. Un pont, ce sont simplement deux diviseurs de tension côte à côte : l'alimentation est appliquée entre E+ et E-, tandis que A+ et A- sont les points milieux des deux diviseurs. Sans charge, les quatre résistances sont égales, les deux points milieux sont au même potentiel et la sortie vaut zéro. Sous charge, deux jauges s'étirent et deux se compriment ; un point milieu monte pendant que l'autre descend. Si l'on appelle R1 et R2 les résistances haute et basse du diviseur gauche, et R3 et R4 celles du diviseur droit, la sortie vaut Vsortie = Vexc × (R4/(R3+R4) − R2/(R1+R2)) et elle augmente proportionnellement au poids. Tu peux tester le principe du diviseur avec le calculateur de pont diviseur.

Une valeur comme 1 mV/V sur l'étiquette d'une cellule de charge indique sa sensibilité : à pleine charge, la cellule fournit 1 mV par volt d'alimentation. Comme le module HX711 alimente le pont avec environ 4,3 V, une cellule de 5 kg ne produit que 4,3 mV à 5 kg et à peine 0,86 µV par gramme. C'est pourquoi il faut un CAN 24 bits dédié avec un gain de 128.

Un détail mérite d'être remarqué dans ce tableau : la valeur brute ne dépend pas de la tension d'alimentation. Le HX711 utilise la tension qui alimente le pont (AVDD) aussi comme référence de mesure ; si l'alimentation baisse un peu, la sortie du pont baisse dans la même proportion et le résultat ne change pas. On parle de mesure ratiométrique. En règle approximative, la pleine charge d'une cellule de 1 mV/V correspond à environ 2 147 000 points. En divisant par la capacité de la cellule en grammes, tu obtiens un facteur d'étalonnage approximatif : ≈ 2150 pour 1 kg, ≈ 430 pour 5 kg et ≈ 107 pour 20 kg.

Qu'est-ce que le module HX711 ? Caractéristiques

Le HX711 est un CAN sigma-delta 24 bits fabriqué par Avia Semiconductor pour les applications de pesage. Il intègre un amplificateur à gain programmable (PGA), un régulateur qui alimente le pont et un oscillateur interne, et il communique sur seulement deux fils avec un protocole série simple qui lui est propre. Ce protocole n'est pas de l'I2C : quand la ligne DT (DOUT) passe à LOW, une donnée est prête, et l'Arduino lit les 24 bits un par un en envoyant 25 à 27 impulsions sur la ligne SCK. Le nombre d'impulsions choisit le canal et le gain de la mesure suivante : 25 impulsions pour le canal A avec un gain de 128, 26 pour le canal B avec 32, et 27 pour le canal A avec 64.

Sur la plupart des modules verts bon marché, la broche RATE est reliée à GND sur la carte : le module effectue donc 10 mesures par seconde. 10 SPS, c'est moins de bruit et un bon rejet des parasites secteur à 50/60 Hz, ce qui en fait en général le meilleur choix pour peser. Si la ligne SCK reste à HIGH plus de 60 µs, le HX711 passe en veille et coupe aussi l'alimentation du pont. Dans les projets sur batterie, c'est pratique grâce aux fonctions power_down() et power_up().

Types de cellules de charge : quelle capacité choisir ?

Choisis une capacité d'environ 1,5 fois la charge la plus lourde que tu veux mesurer. Une cellule surdimensionnée réduit la résolution : tu peux peser une lettre de 50 g avec une cellule de 20 kg, mais la mesure sera quatre fois plus grossière qu'avec une cellule de 5 kg. Surcharger une petite cellule est pire encore ; les cellules en barre supportent en général 120 pour cent de leur capacité sans risque, mais au-delà de 150 pour cent le métal peut se déformer définitivement et la cellule ne reviendra plus jamais à zéro. La capacité totale dépend aussi du nombre de cellules qui se partagent le poids : quatre cellules de 50 kg aux coins supportent ensemble 200 kg.

Couleurs des fils et câblage du HX711

Les couleurs peuvent varier selon le fabricant ; certaines cellules utilisent du jaune au lieu du noir ou du bleu au lieu du vert, ou inversent le rôle du blanc et du vert. Pour en être sûr, mets ton multimètre en ohmmètre : la paire d'alimentation (E+, E-) et la paire de signal (A+, A-) affichent en général autour de 1000 Ω, et les paires croisées environ les trois quarts de cette valeur. Inverser les fils de signal n'abîme rien ; la valeur diminue simplement quand tu ajoutes du poids. Tu corriges cela en inversant les fils ou en rendant le facteur d'étalonnage négatif. B+ et B- appartiennent au second canal et restent libres dans les projets à une seule cellule.

Câblage de quatre cellules demi-pont de 50 kg (pèse-personne)

Les cellules de 50 kg des pèse-personnes, celles dont le centre ressemble à un E, ne contiennent que deux jauges et 3 fils : chacune est donc un demi-pont. Les fils sont généralement rouge, blanc et noir, mais identifie toujours le point milieu en mesurant : entre les deux fils extérieurs tu mesures environ 2 kΩ, et entre le fil du milieu et chaque fil extérieur environ 1 kΩ. Sur la plupart des cellules, le point milieu est le rouge. En reliant les quatre cellules en anneau, tu obtiens un pont de Wheatstone complet.

1. Place les cellules aux quatre coins du plateau et numérote les coins 1 (avant gauche), 2 (avant droit), 3 (arrière droit) et 4 (arrière gauche).
2. Relie les fils extérieurs de même couleur des cellules voisines : les blancs de 1 et 2, les noirs de 2 et 3, les blancs de 3 et 4, et les noirs de 4 et 1.
3. Branche les fils rouges des cellules en diagonale 1 et 3 sur E+ et E-.
4. Branche les fils rouges de l'autre diagonale, cellules 2 et 4, sur A+ et A-.
5. Mesure avant de souder : entre E+ et E- et entre A+ et A-, tu dois lire environ 2 kΩ. Si la valeur est très différente, une jonction est fausse.
6. Si la valeur diminue quand tu ajoutes du poids, inverse les fils A+ et A- ou utilise un facteur négatif.

Installer la bibliothèque HX711

1. Dans l'Arduino IDE, ouvre Outils > Gérer les bibliothèques et tape HX711 dans la zone de recherche.
2. Installe HX711 Arduino Library de Bogdan Necula. Si c'est la première fois que tu installes une bibliothèque, jette un œil au guide ajouter une bibliothèque Arduino.
3. Après l'installation, tu trouveras les exemples HX711_basic_example et HX711_full_example dans Fichier > Exemples > HX711 Arduino Library ; le code ci-dessous utilise les mêmes fonctions.

Comment faire la tare et trouver le facteur d'étalonnage ?

Le HX711 ne te donne pas des grammes, mais un nombre brut. Pour le convertir en poids, il faut deux valeurs : l'offset (la tare), c'est-à-dire ce que lit la balance vide, et le nombre de points par gramme, le facteur d'étalonnage. La formule est simple : poids = (valeur brute − offset) / facteur. La fonction tare() trouve l'offset ; le facteur, tu le calcules une seule fois avec un objet dont tu connais le poids. Par exemple, si la balance vide lit 84 120 et que la valeur passe à 298 870 avec un poids de 500 g, la différence vaut 214 750 et le facteur 214 750 / 500 = 429,5.

1. Fixe solidement la cellule sur le plateau ; l'étalonnage doit se faire avec la balance dans sa forme définitive.
2. Téléverse le code ci-dessous, ouvre le moniteur série à 9600 bauds et attends la tare, balance vide.
3. Pose au centre un objet de poids connu. Une bouteille d'eau pesée sur une autre balance fait très bien l'affaire ; un poids proche de la moitié de la capacité donne le meilleur résultat.
4. Tape le poids de l'objet en grammes dans le moniteur série (par ex. 500) et appuie sur Entrée. Le code calcule et affiche le facteur, puis fait aussitôt une mesure de contrôle.
5. Note le facteur et reporte-le dans le code de ta balance. Répéter plusieurs fois avec des poids différents et faire la moyenne améliore la précision.

1#include "HX711.h"
2
3const int DT_PIN = 2;                      // HX711 DT (DOUT)
4const int SCK_PIN = 3;                     // HX711 SCK (PD_SCK)
5
6HX711 scale;
7
8void setup() {
9  Serial.begin(9600);
10  scale.begin(DT_PIN, SCK_PIN);            // kanal A, kazanç 128 / channel A, gain 128
11  if (!scale.wait_ready_timeout(1000)) {   // modül cevap vermiyor / module not answering
12    Serial.println("HX711 bulunamadi / HX711 not found");
13    while (true) {}
14  }
15  scale.set_scale();                       // faktör 1: ham sayı / factor 1: raw counts
16  Serial.println("Tarti bos olsun, dara aliniyor... / Keep it empty, taring...");
17  delay(2000);
18  scale.tare(20);                          // 20 ölçümün ortalaması sıfır / average of 20 readings = zero
19  Serial.println("Bilinen agirligi koy, gramini yaz (or. 500) / Place a known weight, type its grams (e.g. 500)");
20}
21
22void loop() {
23  if (Serial.available()) {
24    float bilinen = Serial.parseFloat();   // Seri Monitör'den gram / grams from Serial Monitor
25    if (bilinen > 0) {
26      double fark = scale.get_value(20);   // dara düşülmüş ham fark / tared raw difference
27      float faktor = fark / bilinen;
28      Serial.print("Ham fark / raw difference: ");
29      Serial.println(fark, 0);
30      Serial.print("Kalibrasyon faktoru / calibration factor: ");
31      Serial.println(faktor, 2);
32      scale.set_scale(faktor);             // hemen kontrol et / check right away
33      Serial.print("Kontrol / check: ");
34      Serial.print(scale.get_units(10), 1);
35      Serial.println(" g");
36    }
37  }
38}

Le code prend comme zéro la moyenne de 20 mesures avec tare(20) ; à 10 SPS, cela prend environ 2 secondes. Une fois le poids posé, get_value(20) renvoie la différence brute après la tare, et en la divisant par les grammes connus on obtient le facteur. Pas d'inquiétude si le facteur est négatif : cela veut seulement dire que les fils de signal sont inversés, et la balance mesure quand même correctement avec un facteur négatif. Pour ne pas ressaisir le facteur à chaque démarrage, tu peux l'écrire dans la mémoire permanente de l'Arduino avec EEPROM.put() et le relire avec EEPROM.get() ; les détails sont dans l'article EEPROM Arduino.

Balance numérique Arduino : grammes sur l'écran LCD et bouton de tare

Construisons maintenant une vraie balance avec ton facteur. Le poids s'affiche sur un écran LCD I2C 16x2, et un bouton sur D4 fait la tare à tout moment : tu poses d'abord le récipient, tu fais la tare, puis tu ne pèses que le contenu. L'écran LCD se branche sur A4 (SDA) et A5 (SCL) ; pour les détails, consulte l'article écran LCD I2C, et pour brancher le bouton avec le pull-up interne, l'article brancher un bouton.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include "HX711.h"
4
5const int DT_PIN = 2;                      // HX711 DT
6const int SCK_PIN = 3;                     // HX711 SCK
7const int DARA_BUTON = 4;                  // dara butonu, diğer ucu GND / tare button, other leg to GND
8const float FAKTOR = 429.5;                // kendi faktörünü yaz / use your own factor
9
10HX711 scale;
11LiquidCrystal_I2C lcd(0x27, 16, 2);       // adres, sütun, satır / address, columns, rows
12float filtreli = 0;                        // filtrelenmiş ağırlık / filtered weight
13
14void setup() {
15  pinMode(DARA_BUTON, INPUT_PULLUP);
16  lcd.init();
17  lcd.backlight();
18  lcd.print("Dara aliniyor...");
19  scale.begin(DT_PIN, SCK_PIN);
20  scale.set_scale(FAKTOR);
21  scale.tare(20);                          // açılışta terazi boş olmalı / scale must be empty at start
22  lcd.clear();
23  lcd.print("Agirlik:");
24}
25
26void loop() {
27  if (digitalRead(DARA_BUTON) == LOW) {    // butona basıldı / button pressed
28    lcd.setCursor(0, 1);
29    lcd.print("Dara...         ");
30    scale.tare(20);
31    filtreli = 0;
32    while (digitalRead(DARA_BUTON) == LOW) {}   // bırakılmasını bekle / wait for release
33    delay(50);                             // kontak sıçramasını atla / skip contact bounce
34  }
35
36  if (scale.is_ready()) {
37    float w = scale.get_units(4);          // 4 ölçümün ortalaması / average of 4 readings
38    if (fabs(w - filtreli) > 5.0) {
39      filtreli = w;                        // büyük değişim: filtreyi atla / big change: skip the filter
40    } else {
41      filtreli = 0.7 * filtreli + 0.3 * w; // üstel ortalama (EMA) / exponential moving average
42    }
43    float goster = filtreli;
44    if (fabs(goster) < 0.5) goster = 0;    // sıfırdaki titremeyi gizle / hide jitter around zero
45
46    char yazi[12];
47    dtostrf(goster, 8, 1, yazi);           // 8 karakter, 1 ondalık / 8 chars, 1 decimal
48    lcd.setCursor(0, 1);
49    lcd.print(yazi);
50    lcd.print(" g");
51  }
52}

Le code utilise trois petites astuces. La première est une moyenne mobile exponentielle (EMA) : chaque nouvelle mesure ne compte que pour 30 pour cent du résultat, ce qui lisse les tremblements. Deuxième astuce : si le poids change brusquement de plus de 5 g, le filtre est ignoré et l'affichage passe tout de suite à la nouvelle valeur ; le filtre n'agit qu'avec une charge stable. Troisième astuce, une zone morte : les valeurs inférieures à ±0,5 g s'affichent 0, ce qui fait disparaître les chiffres qui dansent, comme 0.3, -0.2, 0.1, sur une balance vide. Comme get_units(4) attend quatre mesures à chaque appel, l'affichage se rafraîchit environ 2,5 fois par seconde à 10 SPS.

Mesures instables : tremblements, dérive et solutions

La plupart des problèmes des projets HX711 viennent de la mécanique, pas du code. Une cellule en barre fonctionne comme une poutre en porte-à-faux : une extrémité est vissée sur la base, l'autre sur le plateau supérieur, avec une entretoise de quelques millimètres (rondelles ou bloc imprimé en 3D) à chaque bout. La cellule forme ainsi un Z et son centre peut fléchir librement. Si le centre de la cellule touche la base ou le plateau, si les vis sont trop serrées ou si le plateau fléchit, les mesures dérivent sans cesse. Vérifie que la flèche de la cellule pointe dans le sens de la force (vers le bas), et ne laisse rien toucher la zone centrale où se trouvent les jauges.

• Base rigide : la base et le plateau ne doivent pas fléchir ; utilise du contreplaqué épais, du MDF ou une plaque d'aluminium. Les vibrations de la table se retrouvent aussi dans la mesure.
• Fils courts et fixés : garde les fils de la cellule courts, torsade-les et fixe-les. Un câble qui pend appuie sur la cellule et modifie la valeur.
• Alimentation propre : le port USB d'un ordinateur portable peut être bruité. Ajouter des condensateurs de 100 nF et 10 µF entre VCC et GND du module et l'éloigner des moteurs, relais et de l'antenne Wi-Fi aide beaucoup.
• Temps de chauffe : pendant les premières minutes après la mise sous tension, le temps que la cellule et le module chauffent, le zéro peut dériver de quelques grammes ; attends avant les mesures précises, puis fais la tare.
• Moyenne : get_units(10) divise le bruit par trois environ, mais prend 1 seconde à 10 SPS. Trouve le bon équilibre entre vitesse et stabilité ; pour d'autres méthodes de filtrage, consulte l'article filtrer les données d'un capteur.
• Fluage (creep) : sous une charge qui reste longtemps, la valeur peut varier de quelques grammes en quelques minutes. C'est dans la nature de la cellule, et c'est plus marqué sur les modèles bon marché.
• Attentes réalistes : une stabilité de 0,5 à 1 g avec une cellule de 5 kg bien montée, et de 50 à 100 g sur un pèse-personne à quatre cellules de 50 kg, ce sont de bons résultats.

Balance avec l'ESP32 : écran OLED et étalonnage permanent

La même bibliothèque fonctionne sans modification sur l'ESP32. L'exemple ci-dessous affiche le poids en grands chiffres sur un écran OLED SSD1306 de 0,96 pouce, fait la tare avec un bouton sur le GPIO 27 et enregistre le facteur d'étalonnage dans la flash avec la bibliothèque Preferences. Il suffit de taper le poids connu en grammes dans le moniteur série pour que le nouveau facteur soit calculé et sauvegardé de façon permanente. Pour le câblage de l'OLED (SDA GPIO 21, SCL GPIO 22) et ses bibliothèques, consulte l'article écran OLED.

1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Preferences.h>
5#include "HX711.h"
6
7const int DT_PIN = 25;                     // HX711 DT
8const int SCK_PIN = 26;                    // HX711 SCK
9const int DARA_BUTON = 27;                 // dara butonu, diğer ucu GND / tare button, other leg to GND
10
11HX711 scale;
12Adafruit_SSD1306 display(128, 64, &Wire, -1);
13Preferences ayar;
14float faktor;
15
16void agirlikGoster(float g) {
17  display.clearDisplay();
18  display.setTextSize(1);
19  display.setCursor(0, 0);
20  display.print(F("BlueGrays Terazi"));
21  display.setTextSize(2);                  // büyük rakamlar / big digits
22  display.setCursor(0, 28);
23  if (fabs(g) < 1000) {
24    display.print(g, 1);
25    display.print(F(" g"));
26  } else {
27    display.print(g / 1000.0, 3);          // 1 kg üstü kilogram / kilograms above 1 kg
28    display.print(F(" kg"));
29  }
30  display.display();
31}
32
33void setup() {
34  Serial.begin(115200);
35  pinMode(DARA_BUTON, INPUT_PULLUP);
36  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);   // SDA 21, SCL 22
37  display.setTextColor(SSD1306_WHITE);
38
39  ayar.begin("terazi", false);             // flash'ta ayar alanı / settings namespace in flash
40  faktor = ayar.getFloat("faktor", 429.5); // kayıt yoksa varsayılan / default if nothing saved
41
42  scale.begin(DT_PIN, SCK_PIN);
43  scale.set_scale(faktor);
44  scale.tare(20);
45  Serial.println("Kalibrasyon: agirligi koy, gramini yaz / Calibrate: place a weight, type its grams");
46}
47
48void loop() {
49  if (digitalRead(DARA_BUTON) == LOW) {
50    scale.tare(20);
51    while (digitalRead(DARA_BUTON) == LOW) delay(10);   // bırakılmasını bekle / wait for release
52    delay(50);                             // kontak sıçramasını atla / skip contact bounce
53  }
54
55  if (Serial.available()) {
56    float bilinen = Serial.parseFloat();
57    if (bilinen > 0) {
58      faktor = scale.get_value(20) / bilinen;  // yeni faktör / new factor
59      scale.set_scale(faktor);
60      ayar.putFloat("faktor", faktor);     // elektrik kesilse de kalır / survives power loss
61      Serial.printf("Yeni faktor / new factor: %.2f\n", faktor);
62    }
63  }
64
65  if (scale.wait_ready_timeout(200)) {
66    agirlikGoster(scale.get_units(5));
67  }
68}

Si tu alimentes le HX711 par la broche 3V3 de l'ESP32, le régulateur du module ne peut pas atteindre 4,3 V et le pont fonctionne avec un peu moins de 3,3 V. Comme la mesure est ratiométrique, le facteur change à peine ; seul le bruit augmente légèrement. L'ESP32 est en plus prêt pour le Wi-Fi : afficher le poids sur une page web ou envoyer une notification sur ton téléphone quand la gamelle est vide ne demande que quelques lignes de plus. Pour débuter, lis Qu'est-ce que l'ESP32 ?. Sur une balance de ruche alimentée par batterie, tu mets le HX711 en veille entre deux mesures avec scale.power_down() et l'ESP32 avec le deep sleep. Pour que SCK reste à HIGH pendant le sommeil de l'ESP32, verrouille la broche avec gpio_hold_en() ; sinon elle devient flottante et le HX711 peut se réveiller tout seul. Pense aussi à ignorer les mesures des 400 premières ms après le réveil.

HX711 avec le Raspberry Pi Pico (MicroPython)

MicroPython ne fournit pas de module pour le HX711, mais le protocole est si simple que tu peux écrire le pilote toi-même en quelques lignes. La classe ci-dessous attend que DT passe à LOW, lit les données en envoyant 24 impulsions sur SCK, envoie 1 à 3 impulsions supplémentaires pour choisir le gain et convertit le résultat du complément à deux en nombre signé. Les interruptions sont brièvement désactivées pendant la lecture, ainsi SCK ne reste jamais à HIGH plus de 60 µs et le HX711 ne se met pas en veille par erreur. Pour installer MicroPython, consulte Qu'est-ce que le Raspberry Pi Pico ?.

1from machine import Pin
2import machine
3import time
4
5class HX711:
6    def __init__(self, dt, sck, gain=128):
7        self.dt = Pin(dt, Pin.IN)
8        self.sck = Pin(sck, Pin.OUT, value=0)
9        self.extra = {128: 1, 64: 3, 32: 2}[gain]   # toplam 25, 27, 26 darbe / 25, 27, 26 pulses in total
10        self.offset = 0
11        self.scale = 1.0
12        self.read()                                 # kazancı ayarla / set the gain
13
14    def read(self, timeout_ms=1000):
15        start = time.ticks_ms()
16        while self.dt.value() == 1:                 # DT LOW ise veri hazır / data ready when DT is LOW
17            if time.ticks_diff(time.ticks_ms(), start) > timeout_ms:
18                raise OSError("HX711 yanit vermiyor / not responding")
19        irq = machine.disable_irq()                 # SCK 60 µs'den uzun HIGH kalmasın / keep SCK HIGH under 60 µs
20        value = 0
21        for _ in range(24):
22            self.sck.value(1)
23            value = (value << 1) | self.dt.value()
24            self.sck.value(0)
25        for _ in range(self.extra):                 # sonraki ölçümün kanalı ve kazancı / next channel and gain
26            self.sck.value(1)
27            self.sck.value(0)
28        machine.enable_irq(irq)
29        if value & 0x800000:                        # ikiye tümleyen / two's complement
30            value -= 0x1000000
31        return value
32
33    def read_average(self, times=10):
34        return sum(self.read() for _ in range(times)) / times
35
36    def tare(self, times=15):
37        self.offset = self.read_average(times)
38
39    def get_units(self, times=5):
40        return (self.read_average(times) - self.offset) / self.scale
41
42
43hx = HX711(dt=15, sck=14)                           # DT -> GP15, SCK -> GP14
44print("Tarti bos, dara aliniyor... / Scale empty, taring...")
45hx.tare()
46hx.scale = 429.5                                    # kendi faktörün / your own factor
47
48while True:
49    print("{:.1f} g".format(hx.get_units()))
50    time.sleep_ms(200)

L'étalonnage suit la même logique que sur Arduino : avec hx.scale = 1.0, pose le poids connu et divise le résultat de get_units() par son poids en grammes pour obtenir le facteur. Sur le Pico aussi, alimente le HX711 par la broche 3V3(OUT). Si tu veux afficher le poids sur un écran, ajoute un OLED avec le pilote ssd1306.py et écris la valeur avec oled.text().

Idées de projets avec le HX711 et une cellule de charge

• Balance de cuisine : une cellule de 5 kg, un bouton de tare et un écran OLED pour peser au gramme près.
• Pèse-personne : les quatre cellules d'un vieux pèse-personne, un HX711 et un écran LCD I2C qui affiche les kilos.
• Gamelle connectée : quand le poids de la gamelle passe sous un seuil, l'ESP32 envoie une notification et un servomoteur ouvre une trappe pour distribuer des croquettes.
• Balance pour plante : calcule le besoin en eau à mesure que le pot s'allège, et compare le résultat avec un capteur d'humidité du sol.
• Suivi de ruche : place 4 cellules sous la ruche, suis la miellée grâce à la prise de poids quotidienne et enregistre les données en Wi-Fi.
• Compteur de pièces : apprends-lui le poids d'une seule vis et calcule combien de vis contient la boîte à partir du poids total.
• Enregistrement de données : envoie les mesures à l'ordinateur par le port série et trace des graphiques avec la méthode envoyer des données vers Excel.

Erreurs fréquentes et solutions

Une fois correctement montée et étalonnée, une cellule de charge avec un HX711 te donne un instrument précis au gramme avec des composants bon marché. Sauvegarde ton facteur d'étalonnage, soigne la mécanique et règle le filtre selon la vitesse de ton projet ; le reste ne dépend que de ton imagination. Pour une vue plus large de la mesure, jette un œil au guide des capteurs Arduino. Dans l'application BlueGrays, tu trouveras des projets pour lire des capteurs, afficher des valeurs sur écran LCD et OLED et enregistrer des données avec l'ESP32, avec schéma et code pas à pas, à combiner avec ta balance.