HX711 Arduino Waage: Wägezelle anschließen und kalibrieren

Das Duo HX711 und Arduino ist der verbreitetste und günstigste Weg, das Signal einer Wägezelle (Load Cell) im Mikrovoltbereich zu lesen und in ein Gewicht in Gramm umzurechnen. Küchenwaage, Personenwaage, Bienenstockwaage, Futternapf-Überwachung oder Schubmessung eines Motors: Alle diese Projekte beruhen auf demselben Prinzip. Die Wägezelle verbiegt sich unter Last unsichtbar wenig, der HX711 wandelt diese winzige Änderung in eine 24-Bit-Zahl um, und der Arduino rechnet diese Zahl mit einem Kalibrierfaktor in Gramm um.

In dieser Anleitung lernst du, wie die Wheatstonesche Brücke in einer Wägezelle funktioniert, was die Kabelfarben bedeuten (E+, E-, A+, A-), wie man vier 50-kg-Halbbrücken-Zellen aus einer Personenwaage verdrahtet und wie du mit der HX711-Bibliothek Schritt für Schritt die Tara setzt und den Kalibrierfaktor bestimmst. Danach baust du eine digitale Waage mit LCD und Tara-Taster, siehst, warum die Messwerte zappeln und wie du sie beruhigst, und machst zum Schluss dasselbe mit einem ESP32 samt OLED-Display und mit dem Raspberry Pi Pico (MicroPython).

Was ist eine Wägezelle und wie funktioniert sie?

Eine Wägezelle ist ein Stück Aluminium oder Stahl, auf das Dehnungsmessstreifen (DMS) geklebt sind. Ein DMS ist ein Widerstand, der als Zickzackbahn auf eine dünne Folie geätzt ist: Wird das Metall gedehnt, wird die Bahn länger und dünner und ihr Widerstand steigt; wird es gestaucht, sinkt er. Die Änderung ist unglaublich klein. Ein DMS mit einem k-Faktor von etwa 2 ändert seinen Widerstand bei einer Dehnung von einem Promille nur um 0,2 Prozent; bei einem 1000-Ω-Streifen sind das 2 Ω, die ein normales analogRead() niemals erkennen kann.

Damit diese winzige Änderung messbar wird, werden vier DMS als Wheatstonesche Brücke verschaltet. Die Brücke besteht einfach aus zwei nebeneinanderliegenden Spannungsteilern: Zwischen E+ und E- liegt die Versorgung, A+ und A- sind die Mittelpunkte der beiden Teiler. Ohne Last sind alle vier Widerstände gleich, beide Mittelpunkte liegen auf derselben Spannung und der Ausgang ist null. Unter Last werden zwei DMS gedehnt und zwei gestaucht; ein Mittelpunkt steigt, der andere fällt. Nennt man den oberen und unteren Widerstand des linken Teilers R1 und R2 und die des rechten R3 und R4, ergibt sich Vaus = Vspeis × (R4/(R3+R4) − R2/(R1+R2)), und diese Spannung wächst proportional zum Gewicht. Das Teilerprinzip kannst du mit dem Spannungsteiler-Rechner ausprobieren.

Ein Wert wie 1 mV/V auf dem Etikett einer Wägezelle ist ihre Empfindlichkeit: Bei Nennlast liefert die Zelle pro Volt Speisespannung 1 mV Ausgangsspannung. Da das HX711-Modul die Brücke mit etwa 4,3 V speist, erzeugt eine 5-kg-Zelle bei 5 kg nur 4,3 mV und pro Gramm gerade einmal 0,86 µV. Genau deshalb braucht man einen speziellen 24-Bit-ADC mit 128-facher Verstärkung.

In der Tabelle fällt ein Detail auf: Der Rohwert hängt nicht von der Versorgungsspannung ab. Der HX711 nutzt die Spannung, die die Brücke speist (AVDD), gleichzeitig als Messreferenz; sinkt die Versorgung etwas, sinkt der Brückenausgang im selben Verhältnis, und das Ergebnis bleibt gleich. Das nennt man ratiometrische Messung. Als Faustregel entspricht die Nennlast einer 1-mV/V-Zelle etwa 2.147.000 Zählwerten. Teilst du das durch die Kapazität der Zelle in Gramm, erhältst du einen ungefähren Kalibrierfaktor: ≈ 2150 für 1 kg, ≈ 430 für 5 kg und ≈ 107 für 20 kg.

Was ist das HX711-Modul? Technische Daten

Der HX711 ist ein 24-Bit-Sigma-Delta-ADC von Avia Semiconductor für Wägeanwendungen. Er enthält einen programmierbaren Verstärker (PGA), einen Regler zur Speisung der Brücke und einen internen Oszillator und kommuniziert über nur zwei Leitungen mit einem eigenen, einfachen seriellen Protokoll. Dieses Protokoll ist kein I2C: Geht die Leitung DT (DOUT) auf LOW, liegen Daten bereit, und der Arduino liest die 24 Bit nacheinander, indem er 25 bis 27 Takte auf SCK sendet. Die Zahl der Takte wählt Kanal und Verstärkung für die nächste Messung: 25 Takte bedeuten Kanal A mit Verstärkung 128, 26 Takte Kanal B mit 32 und 27 Takte Kanal A mit 64.

Bei den meisten günstigen grünen Modulen ist der RATE-Pin auf der Platine fest mit GND verbunden, das Modul misst also 10-mal pro Sekunde. 10 SPS rauschen weniger und unterdrücken zusätzlich 50/60-Hz-Netzstörungen, daher ist das zum Wiegen meist die beste Wahl. Bleibt SCK länger als 60 µs auf HIGH, geht der HX711 in den Power-down-Modus und schaltet auch die Brückenspeisung ab. In batteriebetriebenen Projekten nutzt du das bequem über power_down() und power_up().

Wägezellen-Typen: Welche Kapazität solltest du wählen?

Wähle eine Kapazität von etwa dem 1,5-Fachen der schwersten Last, die du messen willst. Eine zu große Zelle verringert die Auflösung: Mit einer 20-kg-Zelle kannst du einen 50-g-Brief wiegen, aber die Anzeige ist viermal gröber als mit einer 5-kg-Zelle. Schlimmer ist es, eine kleine Zelle zu überlasten; Biegebalken vertragen meist rund 120 Prozent ihrer Nennlast sicher, oberhalb von 150 Prozent kann sich das Metall dauerhaft verbiegen, und die Zelle kehrt nie wieder auf null zurück. Die Gesamtkapazität hängt auch davon ab, auf wie viele Zellen sich das Gewicht verteilt: Vier 50-kg-Zellen in den Ecken tragen zusammen 200 kg.

Kabelfarben und HX711-Anschluss

Die Farben können je nach Hersteller abweichen; manche Zellen nutzen Gelb statt Schwarz oder Blau statt Grün, oder Weiß und Grün sind vertauscht. Um sicherzugehen, stellst du dein Multimeter auf Ohm: Das Speisepaar (E+, E-) und das Signalpaar (A+, A-) zeigen meist um die 1000 Ω, die Kreuzpaare etwa drei Viertel davon. Vertauschte Signaladern beschädigen nichts, der Wert sinkt dann nur, wenn du Gewicht auflegst. Du behebst das, indem du die Adern tauschst oder den Kalibrierfaktor negativ machst. B+ und B- gehören zum zweiten Kanal und bleiben bei Projekten mit einer Zelle frei.

Vier 50-kg-Halbbrücken-Wägezellen anschließen (Personenwaage)

Die 50-kg-Zellen aus Personenwaagen, deren Mitte wie ein E aussieht, enthalten nur zwei DMS und 3 Adern; jede ist also eine halbe Brücke. Die Adern sind meist rot, weiß und schwarz, aber den Mittelabgriff solltest du immer durch Messen bestimmen: Zwischen den beiden äußeren Adern misst du etwa 2 kΩ, zwischen der mittleren und jeder äußeren etwa 1 kΩ. Bei den meisten Zellen ist der Mittelabgriff rot. Verbindest du vier Zellen ringförmig miteinander, entsteht eine vollständige Wheatstonesche Brücke.

1. Setze die Zellen in die vier Ecken der Plattform und nummeriere die Ecken 1 (vorne links), 2 (vorne rechts), 3 (hinten rechts) und 4 (hinten links).
2. Verbinde die gleichfarbigen äußeren Adern benachbarter Zellen: die weißen von 1 und 2, die schwarzen von 2 und 3, die weißen von 3 und 4 und die schwarzen von 4 und 1.
3. Schließe die roten Adern der diagonal liegenden Zellen 1 und 3 an E+ und E- an.
4. Schließe die roten Adern der anderen Diagonale, Zellen 2 und 4, an A+ und A- an.
5. Vor dem Löten messen: E+ zu E- und A+ zu A- sollten jeweils etwa 2 kΩ zeigen. Weicht der Wert stark ab, ist eine Verbindung falsch.
6. Sinkt der Wert beim Auflegen von Gewicht, tausche A+ und A- oder verwende einen negativen Faktor.

Die HX711-Bibliothek installieren

1. Öffne in der Arduino IDE Werkzeuge > Bibliotheken verwalten und gib HX711 ins Suchfeld ein.
2. Installiere die HX711 Arduino Library von Bogdan Necula. Wenn du zum ersten Mal eine Bibliothek installierst, wirf einen Blick in die Anleitung Arduino-Bibliotheken hinzufügen.
3. Nach der Installation findest du unter Datei > Beispiele > HX711 Arduino Library die Sketche HX711_basic_example und HX711_full_example; der Code unten nutzt dieselben Funktionen.

Wie setzt man die Tara und bestimmt den Kalibrierfaktor?

Der HX711 liefert dir keine Gramm, sondern eine Rohzahl. Um sie in ein Gewicht umzurechnen, brauchst du zwei Werte: den Offset (Tara), den die leere Waage anzeigt, und die Zählwerte pro Gramm, also den Kalibrierfaktor. Die Formel ist einfach: Gewicht = (Rohwert − Offset) / Faktor. Die Funktion tare() ermittelt den Offset; den Faktor berechnest du einmalig mit einem Gegenstand, dessen Gewicht du kennst. Zeigt die leere Waage zum Beispiel 84.120 und nach dem Auflegen eines 500-g-Gewichts 298.870, beträgt die Differenz 214.750 und der Faktor 214.750 / 500 = 429,5.

1. Montiere die Zelle fest auf der Plattform; kalibriert wird im endgültigen Aufbau der Waage.
2. Lade den Code unten hoch, öffne den seriellen Monitor mit 9600 Baud und warte bei leerer Waage auf die Tarierung.
3. Lege einen Gegenstand mit bekanntem Gewicht in die Mitte. Eine auf einer anderen Waage gewogene Wasserflasche reicht völlig; ein Gewicht um die halbe Kapazität liefert das beste Ergebnis.
4. Tippe das Gewicht des Gegenstands in Gramm in den seriellen Monitor (z. B. 500) und drücke Enter. Der Code berechnet und gibt den Faktor aus und macht sofort eine Kontrollmessung.
5. Notiere den Faktor und trage ihn in deinen Waagen-Code ein. Mehrmals mit verschiedenen Gewichten wiederholen und mitteln erhöht die Genauigkeit.

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}

Der Code nimmt mit tare(20) den Mittelwert von 20 Messungen als Null; bei 10 SPS dauert das etwa 2 Sekunden. Liegt das Gewicht auf, liefert get_value(20) die tarierte Rohdifferenz, und geteilt durch die bekannten Gramm ergibt sich der Faktor. Keine Sorge, wenn der Faktor negativ ist: Dann sind nur die Signaladern vertauscht, und die Waage misst mit negativem Faktor trotzdem richtig. Damit du den Faktor nicht bei jedem Start neu eingeben musst, kannst du ihn mit EEPROM.put() im dauerhaften Speicher des Arduino ablegen und mit EEPROM.get() wieder lesen; Details findest du im Artikel Arduino EEPROM.

Digitale Waage mit Arduino: Gramm auf dem LCD und Tara-Taster

Jetzt bauen wir mit deinem Faktor eine echte Waage. Das Gewicht erscheint auf einem 16x2-I2C-LCD, und ein Taster an D4 tariert jederzeit; so stellst du erst das Gefäß auf, tarierst und wiegst dann nur den Inhalt. Das LCD kommt an A4 (SDA) und A5 (SCL); Details stehen im Artikel I2C-LCD-Display, und wie du den Taster mit internem Pull-up anschließt, im Artikel Taster anschließen.

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}

Der Code nutzt drei kleine Tricks. Erstens einen exponentiellen gleitenden Mittelwert (EMA): Jede neue Messung fließt nur zu 30 Prozent ins Ergebnis ein, dadurch wird das Zappeln geglättet. Zweitens wird der Filter übersprungen, wenn sich das Gewicht plötzlich um mehr als 5 g ändert, sodass die Anzeige sofort auf den neuen Wert springt; der Filter greift nur bei ruhender Last. Drittens ein Totband: Werte unter ±0,5 g werden als 0 angezeigt, damit tanzende Ziffern wie 0.3, -0.2, 0.1 bei leerer Waage verschwinden. Weil get_units(4) bei jedem Aufruf auf vier Messungen wartet, wird die Anzeige bei 10 SPS etwa 2,5-mal pro Sekunde aktualisiert.

Schwankende Werte: Zappeln, Drift und Lösungen

Die meisten Probleme in HX711-Projekten kommen von der Mechanik, nicht vom Code. Ein Biegebalken arbeitet wie ein Kragträger: Ein Ende wird an die Grundplatte, das andere an die Wiegeplatte geschraubt, und an beiden Enden sitzt ein Abstandshalter von einigen Millimetern (Unterlegscheiben oder ein 3D-gedruckter Block). So steht die Zelle in Z-Form, und ihre Mitte kann sich frei verbiegen. Berührt die Mitte der Zelle die Grund- oder Wiegeplatte, sind die Schrauben zu fest angezogen oder biegt sich die Platte durch, driften die Werte ständig. Achte darauf, dass der Pfeil auf der Zelle in Kraftrichtung (nach unten) zeigt, und lass nichts den mittleren Bereich mit den DMS berühren.

• Steife Grundplatte: Grund- und Wiegeplatte dürfen sich nicht biegen; nimm dickes Sperrholz, MDF oder ein Aluminiumblech. Auch Erschütterungen des Tisches zeigen sich im Messwert.
• Kurze, fixierte Kabel: Halte die Adern der Zelle kurz, verdrille sie und befestige sie. Ein baumelndes Kabel drückt auf die Zelle und verändert den Wert.
• Saubere Versorgung: Der USB-Anschluss eines Laptops kann verrauscht sein. Kondensatoren mit 100 nF und 10 µF zwischen VCC und GND des Moduls sowie Abstand zu Motoren, Relais und WLAN-Antenne helfen.
• Aufwärmzeit: In den ersten Minuten nach dem Einschalten, während Zelle und Modul warm werden, kann der Nullpunkt um einige Gramm wandern; warte vor genauen Messungen und tariere dann.
• Mitteln: get_units(10) senkt das Rauschen etwa um den Faktor drei, dauert bei 10 SPS aber 1 Sekunde. Finde die Balance zwischen Tempo und Stabilität; weitere Filtermethoden findest du im Artikel Sensordaten filtern.
• Kriechen: Unter einer lange aufliegenden Last kann sich der Wert innerhalb von Minuten um einige Gramm ändern. Das liegt in der Natur der Zelle und ist bei billigen Zellen stärker ausgeprägt.
• Realistische Erwartung: 0,5–1 g Stabilität mit einer gut montierten 5-kg-Zelle und 50–100 g bei einer Personenwaage aus vier 50-kg-Zellen sind gute Ergebnisse.

Waage mit dem ESP32: OLED-Display und dauerhafte Kalibrierung

Auf dem ESP32 läuft dieselbe Bibliothek unverändert. Das Beispiel unten zeigt das Gewicht in großen Ziffern auf einem 0,96-Zoll-SSD1306-OLED, tariert mit einem Taster an GPIO 27 und speichert den Kalibrierfaktor mit der Bibliothek Preferences im Flash. Tippe einfach das bekannte Gewicht in Gramm in den seriellen Monitor, und der neue Faktor wird berechnet und dauerhaft gespeichert. Anschluss (SDA GPIO 21, SCL GPIO 22) und Bibliotheken des OLED findest du im Artikel OLED-Display.

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}

Versorgst du den HX711 aus dem 3V3-Pin des ESP32, kann der Regler des Moduls keine 4,3 V erreichen, und die Brücke läuft mit knapp unter 3,3 V. Da die Messung ratiometrisch ist, ändert sich der Faktor kaum; nur das Rauschen nimmt etwas zu. Der ESP32 ist außerdem bereit für WLAN: Das Gewicht auf einer Webseite anzeigen oder eine Benachrichtigung aufs Handy schicken, wenn der Futternapf leer ist, kostet nur ein paar zusätzliche Zeilen. Für den Einstieg lies Was ist der ESP32?. Bei einer batteriebetriebenen Bienenstockwaage schickst du den HX711 zwischen den Messungen mit scale.power_down() schlafen und den ESP32 mit Deep Sleep. Damit SCK während des Schlafs auf HIGH bleibt, hältst du den Pin mit gpio_hold_en() fest; sonst floatet er, und der HX711 kann von selbst aufwachen. Verwirf außerdem nach dem Aufwachen die Messwerte der ersten 400 ms.

HX711 mit dem Raspberry Pi Pico (MicroPython)

MicroPython bringt kein HX711-Modul mit, aber das Protokoll ist so einfach, dass du den Treiber in wenigen Zeilen selbst schreiben kannst. Die Klasse unten wartet, bis DT auf LOW geht, liest die Daten mit 24 Takten auf SCK, sendet 1–3 zusätzliche Takte zur Wahl der Verstärkung und wandelt das Ergebnis vom Zweierkomplement in eine vorzeichenbehaftete Zahl um. Während des Lesens werden Interrupts kurz gesperrt, damit SCK nie länger als 60 µs auf HIGH bleibt und der HX711 nicht versehentlich einschläft. Zur Einrichtung von MicroPython siehe Was ist der 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)

Die Kalibrierung funktioniert wie beim Arduino: Setze hx.scale = 1.0, lege das bekannte Gewicht auf und teile das Ergebnis von get_units() durch dessen Gewicht in Gramm, dann hast du den Faktor. Auch am Pico versorgst du den HX711 aus dem Pin 3V3(OUT). Willst du das Gewicht auf einem Display zeigen, ergänze ein OLED mit dem Treiber ssd1306.py und gib den Wert mit oled.text() aus.

Projektideen mit HX711 und Wägezelle

• Küchenwaage: 5-kg-Zelle, Tara-Taster und OLED-Display für eine Waage mit 1 g Auflösung.
• Personenwaage: Die vier Zellen einer alten Personenwaage, ein HX711 und ein I2C-LCD mit Anzeige in Kilogramm.
• Smarter Futternapf: Fällt das Gewicht des Napfs unter einen Grenzwert, schickt der ESP32 eine Benachrichtigung und ein Servomotor öffnet eine Klappe für Futter.
• Blumentopfwaage: Berechne den Wasserbedarf, während der Topf leichter wird, und vergleiche das Ergebnis mit einem Bodenfeuchtesensor.
• Bienenstockwaage: Stelle 4 Zellen unter den Stock, verfolge die Tracht über die tägliche Gewichtszunahme und speichere die Daten per WLAN.
• Teilezähler: Bring ihm das Gewicht einer einzelnen Schraube bei und berechne aus dem Gesamtgewicht, wie viele Schrauben in der Kiste sind.
• Datenlogger: Schicke die Messwerte über die serielle Schnittstelle an den PC und mach daraus Diagramme mit der Methode Daten nach Excel übertragen.

Häufige Fehler und Lösungen

Ist eine Wägezelle mit HX711 einmal richtig montiert und kalibriert, hast du mit günstigen Teilen ein grammgenaues Messgerät. Speichere deinen Kalibrierfaktor, baue eine solide Mechanik und stimme den Filter auf das Tempo deines Projekts ab; der Rest liegt an deiner Fantasie. Einen breiteren Blick aufs Messen bietet der Ratgeber zu Arduino-Sensoren. In der BlueGrays-App findest du Projekte zum Auslesen von Sensoren, zur Anzeige von Werten auf LCD und OLED und zum Datenloggen mit dem ESP32, jeweils mit Schaltplan und Code Schritt für Schritt, und kannst deine Waage damit kombinieren.