HX711 Arduino: cella di carico, taratura e bilancia digitale

La coppia HX711 e Arduino è il modo più diffuso ed economico per leggere il segnale di pochi microvolt di una cella di carico (load cell) e trasformarlo in un peso in grammi. Bilancia da cucina, pesapersone, bilancia per arnie, controllo della ciotola del cane o banco prova per la spinta di un motore: tutti questi progetti si basano sulla stessa idea. La cella di carico si piega di una quantità invisibile sotto il peso, l'HX711 converte questa minuscola variazione in un numero a 24 bit e Arduino lo trasforma in grammi con un fattore di calibrazione.

In questa guida imparerai come funziona il ponte di Wheatstone dentro una cella di carico, cosa significano i colori dei fili (E+, E-, A+, A-), come collegare quattro celle a mezzo ponte da 50 kg recuperate da un pesapersone e come fare la tara e trovare il fattore di calibrazione passo dopo passo con la libreria HX711. Poi costruirai una bilancia digitale con display LCD e pulsante di tara, vedrai perché le letture tremolano e come stabilizzarle, e infine farai lo stesso con un ESP32 con display OLED e con un Raspberry Pi Pico (MicroPython).

Cos'è una cella di carico e come funziona?

Una cella di carico è un pezzo di alluminio o acciaio su cui sono incollati degli estensimetri (strain gauge). Un estensimetro è una resistenza incisa a zigzag su una sottile pellicola: quando il metallo si allunga, la pista diventa più lunga e sottile e la sua resistenza aumenta; quando si comprime, diminuisce. La variazione è incredibilmente piccola. Un estensimetro con un fattore di sensibilità (gauge factor) di circa 2 cambia la sua resistenza solo dello 0,2 per cento con una deformazione di un millesimo; per un estensimetro da 1000 Ω sono 2 Ω, che un normale analogRead() non potrebbe mai rilevare.

Per rendere misurabile questa minuscola variazione, quattro estensimetri vengono collegati a ponte di Wheatstone. Il ponte è semplicemente formato da due partitori di tensione affiancati: l'alimentazione va tra E+ ed E-, mentre A+ e A- sono i punti centrali dei due partitori. Senza carico, le quattro resistenze sono uguali, i due punti centrali hanno la stessa tensione e l'uscita è zero. Sotto carico, due estensimetri si allungano e due si comprimono; un punto centrale sale mentre l'altro scende. Se chiamiamo R1 e R2 le resistenze superiore e inferiore del partitore di sinistra e R3 e R4 quelle di destra, l'uscita è Vout = Vecc × (R4/(R3+R4) − R2/(R1+R2)) e cresce in proporzione al peso. Puoi provare l'idea del partitore con il calcolatore del partitore di tensione.

Un valore come 1 mV/V sull'etichetta di una cella di carico è la sua sensibilità: a pieno carico la cella fornisce 1 mV per ogni volt di alimentazione. Dato che il modulo HX711 alimenta il ponte con circa 4,3 V, una cella da 5 kg produce solo 4,3 mV a 5 kg e appena 0,86 µV per grammo. Ecco perché serve un ADC dedicato a 24 bit con guadagno 128.

Nella tabella c'è un dettaglio interessante: il valore grezzo non dipende dalla tensione di alimentazione. L'HX711 usa la tensione che alimenta il ponte (AVDD) anche come riferimento di misura; se l'alimentazione cala un po', l'uscita del ponte cala nella stessa proporzione e il risultato non cambia. Si chiama misura raziometrica. Come regola indicativa, il pieno carico di una cella da 1 mV/V corrisponde a circa 2.147.000 conteggi. Dividendo per la portata della cella in grammi ottieni un fattore di calibrazione approssimativo: ≈ 2150 per 1 kg, ≈ 430 per 5 kg e ≈ 107 per 20 kg.

Cos'è il modulo HX711? Caratteristiche tecniche

L'HX711 è un ADC sigma-delta a 24 bit prodotto da Avia Semiconductor per applicazioni di pesatura. Contiene un amplificatore a guadagno programmabile (PGA), un regolatore che alimenta il ponte e un oscillatore interno, e comunica con l'esterno su soli due fili tramite un protocollo seriale semplice e tutto suo. Questo protocollo non è I2C: quando la linea DT (DOUT) va a LOW il dato è pronto, e Arduino legge i 24 bit uno alla volta inviando da 25 a 27 impulsi sulla linea SCK. Il numero di impulsi sceglie canale e guadagno della lettura successiva: 25 impulsi significano canale A con guadagno 128, 26 impulsi canale B con 32 e 27 impulsi canale A con 64.

Sulla maggior parte dei moduli verdi economici il pin RATE è collegato a GND sulla scheda, quindi il modulo fa 10 letture al secondo. 10 SPS significa meno rumore e una buona reiezione dei disturbi di rete a 50/60 Hz, per cui di solito è la scelta migliore per pesare. Se la linea SCK resta HIGH per più di 60 µs, l'HX711 entra in power-down e toglie anche l'alimentazione al ponte. Nei progetti a batteria questa funzione è comoda con power_down() e power_up().

Tipi di cella di carico: quale portata scegliere?

Scegli una portata di circa 1,5 volte il carico più pesante che misurerai. Una cella sovradimensionata riduce la risoluzione: con una cella da 20 kg puoi pesare una lettera da 50 g, ma la lettura sarà quattro volte più grossolana che con una da 5 kg. Sovraccaricare una cella piccola è peggio; le celle a barra di solito reggono in sicurezza circa il 120 per cento della loro portata, ma oltre il 150 per cento il metallo può piegarsi in modo permanente e la cella non tornerà mai più a zero. La portata totale dipende anche da quante celle si dividono il peso: quattro celle da 50 kg agli angoli reggono insieme 200 kg.

Colori dei fili e collegamento dell'HX711

I colori possono variare da un produttore all'altro; alcune celle usano il giallo al posto del nero o il blu al posto del verde, oppure scambiano il ruolo di bianco e verde. Per essere sicuro, imposta il multimetro sugli ohm: la coppia di alimentazione (E+, E-) e la coppia di segnale (A+, A-) misurano di solito circa 1000 Ω, le coppie incrociate circa tre quarti di quel valore. Invertire i fili di segnale non danneggia nulla; semplicemente il valore scende quando aggiungi peso. Lo correggi scambiando i fili o rendendo negativo il fattore di calibrazione. B+ e B- appartengono al secondo canale e restano liberi nei progetti con una sola cella.

Collegare quattro celle di carico da 50 kg a mezzo ponte (pesapersone)

Le celle da 50 kg dei pesapersone, quelle con il centro a forma di E, contengono solo due estensimetri e 3 fili: ognuna è quindi mezzo ponte. I fili di solito sono rosso, bianco e nero, ma individua sempre il punto centrale misurando: tra i due fili esterni leggi circa 2 kΩ, tra il filo centrale e ciascun filo esterno circa 1 kΩ. Nella maggior parte delle celle il punto centrale è il rosso. Collegando le quattro celle ad anello ottieni un ponte di Wheatstone completo.

1. Metti le celle ai quattro angoli della pedana e numera gli angoli 1 (davanti a sinistra), 2 (davanti a destra), 3 (dietro a destra) e 4 (dietro a sinistra).
2. Unisci i fili esterni dello stesso colore delle celle vicine: i bianchi di 1 e 2, i neri di 2 e 3, i bianchi di 3 e 4 e i neri di 4 e 1.
3. Collega i fili rossi delle celle in diagonale 1 e 3 a E+ ed E-.
4. Collega i fili rossi dell'altra diagonale, celle 2 e 4, ad A+ e A-.
5. Misura prima di saldare: tra E+ ed E- e tra A+ e A- devi leggere circa 2 kΩ. Se il valore è molto diverso, una giunzione è sbagliata.
6. Se il valore scende quando aggiungi peso, scambia i fili A+ e A- o usa un fattore negativo.

Installare la libreria HX711

1. Nell'Arduino IDE apri Strumenti > Gestisci librerie e scrivi HX711 nella casella di ricerca.
2. Installa HX711 Arduino Library di Bogdan Necula. Se è la prima volta che installi una libreria, dai un'occhiata alla guida aggiungere librerie ad Arduino.
3. Dopo l'installazione trovi gli esempi HX711_basic_example e HX711_full_example in File > Esempi > HX711 Arduino Library; il codice qui sotto usa le stesse funzioni.

Come fare la tara e trovare il fattore di calibrazione?

L'HX711 non ti dà grammi, ti dà un numero grezzo. Per trasformarlo in peso servono due valori: l'offset (tara) letto dalla bilancia vuota e i conteggi per grammo, cioè il fattore di calibrazione. La formula è semplice: peso = (valore grezzo − offset) / fattore. La funzione tare() trova l'offset; il fattore lo calcoli una volta sola con un oggetto di cui conosci il peso. Per esempio, se la bilancia vuota legge 84.120 e con un peso da 500 g il valore diventa 298.870, la differenza è 214.750 e il fattore è 214.750 / 500 = 429,5.

1. Fissa bene la cella alla pedana; la calibrazione va fatta con la bilancia nella sua forma definitiva.
2. Carica il codice qui sotto, apri il Monitor seriale a 9600 baud e attendi la tara con la bilancia vuota.
3. Metti al centro un oggetto di peso noto. Va benissimo una bottiglia d'acqua pesata su un'altra bilancia; un peso vicino alla metà della portata dà il risultato migliore.
4. Scrivi nel Monitor seriale il peso dell'oggetto in grammi (ad es. 500) e premi Invio. Il codice calcola e stampa il fattore e fa subito una misura di controllo.
5. Annota il fattore e inseriscilo nel codice della bilancia. Ripetere più volte con pesi diversi e fare la media migliora la precisione.

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}

Il codice considera zero la media di 20 letture con tare(20); a 10 SPS ci vogliono circa 2 secondi. Con il peso sopra, get_value(20) restituisce la differenza grezza dopo la tara, e dividendola per i grammi noti si ottiene il fattore. Non preoccuparti se il fattore esce negativo: significa solo che i fili di segnale sono invertiti, e la bilancia misura comunque correttamente con un fattore negativo. Per non dover reinserire il fattore a ogni avvio, puoi scriverlo nella memoria permanente di Arduino con EEPROM.put() e rileggerlo con EEPROM.get(); trovi i dettagli nell'articolo EEPROM di Arduino.

Bilancia digitale con Arduino: grammi sul display LCD e pulsante di tara

Ora costruiamo una vera bilancia con il tuo fattore. Il peso compare su un display LCD I2C 16x2 e un pulsante su D4 fa la tara in qualsiasi momento: così appoggi prima il contenitore, fai la tara e poi pesi solo il contenuto. Il display LCD si collega ad A4 (SDA) e A5 (SCL); per i dettagli vedi l'articolo display LCD I2C e, per collegare il pulsante con il pull-up interno, l'articolo collegare un pulsante.

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}

Il codice usa tre piccoli trucchi. Il primo è una media mobile esponenziale (EMA): ogni nuova lettura pesa solo per il 30 per cento sul risultato, così il tremolio si attenua. Il secondo: se il peso cambia di colpo di più di 5 g, il filtro viene saltato e il display passa subito al nuovo valore; il filtro interviene solo con carico stabile. Il terzo è una banda morta: i valori sotto ±0,5 g vengono mostrati come 0, così spariscono le cifre ballerine come 0.3, -0.2, 0.1 a bilancia vuota. Poiché get_units(4) aspetta quattro letture a ogni chiamata, a 10 SPS il display si aggiorna circa 2,5 volte al secondo.

Letture instabili: tremolio, deriva e soluzioni

La maggior parte dei problemi nei progetti con HX711 nasce dalla meccanica, non dal codice. Una cella a barra lavora come una trave a sbalzo: un'estremità è avvitata alla base e l'altra al piatto superiore, con un distanziale di qualche millimetro (rondelle o un blocchetto stampato in 3D) a ciascuna estremità. Così la cella sta a forma di Z e il suo centro può flettersi liberamente. Se il centro della cella tocca la base o il piatto, se le viti sono troppo strette o se il piatto si flette, le letture continueranno a derivare. Assicurati che la freccia sulla cella punti nella direzione della forza (verso il basso) e non lasciare che nulla tocchi la zona centrale dove si trovano gli estensimetri.

• Base rigida: base e piatto non devono flettersi; usa compensato spesso, MDF o una lastra di alluminio. Anche le vibrazioni del tavolo finiscono nella lettura.
• Fili corti e fissati: tieni corti i fili della cella, intrecciali e fissali. Un cavo che penzola spinge sulla cella e cambia il valore.
• Alimentazione pulita: la porta USB di un portatile può essere rumorosa. Aggiungere condensatori da 100 nF e 10 µF tra VCC e GND del modulo e tenerlo lontano da motori, relè e antenna Wi-Fi aiuta.
• Tempo di riscaldamento: nei primi minuti dopo l'accensione, mentre cella e modulo si scaldano, lo zero può spostarsi di qualche grammo; aspetta prima delle misure precise e poi fai la tara.
• Fai la media: get_units(10) riduce il rumore di circa tre volte, ma a 10 SPS richiede 1 secondo. Trova l'equilibrio tra velocità e stabilità; per altri metodi di filtraggio vedi l'articolo filtrare i dati dei sensori.
• Creep (scorrimento): con un carico che resta a lungo, il valore può cambiare di qualche grammo nel giro di minuti. È nella natura della cella ed è più evidente in quelle economiche.
• Aspettative realistiche: 0,5–1 g di stabilità con una cella da 5 kg ben montata e 50–100 g su un pesapersone con quattro celle da 50 kg sono buoni risultati.

Bilancia con ESP32: display OLED e calibrazione permanente

Sull'ESP32 la stessa libreria funziona senza modifiche. L'esempio qui sotto mostra il peso con cifre grandi su un display OLED SSD1306 da 0,96 pollici, fa la tara con un pulsante su GPIO 27 e salva il fattore di calibrazione nella flash con la libreria Preferences. Basta scrivere nel Monitor seriale il peso noto in grammi perché il nuovo fattore venga calcolato e salvato in modo permanente. Per il collegamento dell'OLED (SDA GPIO 21, SCL GPIO 22) e le sue librerie, vedi l'articolo display 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}

Se alimenti l'HX711 dal pin 3V3 dell'ESP32, il regolatore del modulo non riesce ad arrivare a 4,3 V e il ponte lavora con poco meno di 3,3 V. Poiché la misura è raziometrica, il fattore cambia appena; aumenta solo un po' il rumore. L'ESP32 è anche pronto per il Wi-Fi: mostrare il peso su una pagina web o mandare una notifica al telefono quando la ciotola è vuota richiede solo poche righe in più. Per iniziare leggi Cos'è l'ESP32?. In una bilancia per arnie a batteria, tra una misura e l'altra metti in stand-by l'HX711 con scale.power_down() e l'ESP32 con il deep sleep. Per tenere SCK a HIGH mentre l'ESP32 dorme, blocca il pin con gpio_hold_en(); altrimenti resta flottante e l'HX711 può risvegliarsi da solo. Ricordati anche di scartare le letture dei primi 400 ms dopo il risveglio.

HX711 con il Raspberry Pi Pico (MicroPython)

MicroPython non include un modulo per l'HX711, ma il protocollo è così semplice che puoi scrivere il driver da solo in poche righe. La classe qui sotto aspetta che DT vada a LOW, legge i dati inviando 24 impulsi su SCK, manda da 1 a 3 impulsi extra per scegliere il guadagno e converte il risultato dal complemento a due in un numero con segno. Durante la lettura gli interrupt vengono disattivati per un attimo, così SCK non resta mai HIGH per più di 60 µs e l'HX711 non va in stand-by per errore. Per installare MicroPython vedi Cos'è il 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)

La logica di calibrazione è la stessa di Arduino: con hx.scale = 1.0 appoggia il peso noto e dividi il risultato di get_units() per il suo peso in grammi per ottenere il fattore. Anche sul Pico alimenta l'HX711 dal pin 3V3(OUT). Se vuoi mostrare il peso su un display, aggiungi un OLED con il driver ssd1306.py e scrivi il valore con oled.text().

Idee di progetto con HX711 e cella di carico

• Bilancia da cucina: cella da 5 kg, pulsante di tara e display OLED per pesare al grammo.
• Pesapersone: le quattro celle di un vecchio pesapersone, un HX711 e un LCD I2C che mostra i chili.
• Ciotola intelligente: quando il peso della ciotola scende sotto una soglia, l'ESP32 manda una notifica e un servomotore apre uno sportello per far scendere il cibo.
• Bilancia per vasi: calcola quanta acqua serve alla pianta man mano che il vaso diventa più leggero e confronta il risultato con un sensore di umidità del terreno.
• Monitoraggio dell'arnia: metti 4 celle sotto l'arnia, segui il raccolto di nettare dall'aumento di peso giornaliero e registra i dati via Wi-Fi.
• Contapezzi: insegnagli il peso di una sola vite e calcola quante viti ci sono nella scatola dal peso totale.
• Registrazione dati: invia le letture al computer tramite la porta seriale e trasformale in grafici con il metodo per trasferire dati su Excel.

Errori comuni e soluzioni

Una volta montata e calibrata correttamente, una cella di carico con HX711 ti dà uno strumento che misura al grammo con componenti economici. Salva il fattore di calibrazione, costruisci una meccanica solida e regola il filtro sulla velocità del tuo progetto; il resto dipende dalla tua fantasia. Per una visione più ampia sulle misure, dai un'occhiata alla guida ai sensori per Arduino. Nell'app BlueGrays trovi progetti per leggere sensori, mostrare valori su display LCD e OLED e registrare dati con l'ESP32, con schema elettrico e codice passo dopo passo, da combinare con la tua bilancia.