Eine Briefwaage mit Arduino oder ESP32 erstellen

Ob eine kleine Briefwaage für geringe Gewichte, eine Hängewaage für Pakete oder Koffer, eine Standwaage für Personen, bis hin zu Objektwaagen mit Messvermögen über 100kg. All diese Messgeräte zur Bestimmung einer Masse, ist mit den aktuell erhältlichen Gewichtssensoren recht einfach, diese selbst zu bauen.

Wie in dem unten zu findenden Video erklärt, wird eine oder mehrere Wägezellen passend zu den zu wiegenden Objekten benötigt. Beim Kauf auf die maximale Gewichtsangabe beachten. Diese geben das gemessene Gewicht als analogen Wert zurück.

Damit die Wägezelle diese präzisen Werte messen kann, sind Dehnungsmessstreifen (DMS) auf dem Metallstück angebracht. Auf dem Foto leider nicht zu sehen, da unter der weißen Kleber versteckt. Leider sind die Details im Datenblatt nicht sehr informativ. Ich gehe mal davon aus, das es sich hier um eine Vollbrücken-Wägezelle (Full-Bridge Load Cell) handelt. Enthält vier DMS, verschaltet in einer kompletten Wheatstone-Brücke.

Wird nun durch das hinzukommende Gewicht, ein Druck ausgeübt, dehnt sich Metallstück und die gemessene Spannung der Dehnungsmessstreifen ändert sich.

Da diese Messwerte mit dem 10-Bit Analog-Digital-Wandler des Arduino Nano jedoch nur sehr grob interpretiert werden können, wird ein leistungsfähigerer AD-Wandler benötigt.

Somit wird dieses Verstärkerboard HX711 dazwischengeschaltet.
Der HX711 ist ein spezialisierter 24-Bit Analog-Digital-Wandler (ADC) mit integriertem Verstärker, der speziell für Wägezellen und Dehnungsmessstreifen entwickelt wurde.
Im Auslieferzustand wird es 10 Messungen pro Sekunde ausführen, kann aber optional auf 80 Messungen (80Hz) umgestellt werden.

Wer sich tiefer in das Thema Dehnungsmessstreifen einlesen möchte, dem empfehle ich auch die Wheatstone’schen Brückenschaltung genauer zu betrachten.

Hardware:
Wägezelle 1kg mit HX711
Arduino Clone Nano Board
LCD mit I2C -Board

Alternative Hardware:
Wägezelle bis 100g Hohe Präzision
Wägezelle 5kg mit HX711
Wägezelle 10kg mit HX711
Gewichtssensoren für Personenwaage
Dehnungsmessstreifen
Arduino Nano oder Arduino Uno
Kalibrierte Testgewichte

Einfache Schaltung mit Arduino Nano:

Erweiterungsschaltung: Arduino mit Wägezelle, HX711 und LCD incl. I2C Modul:

Datenblatt:
1Kg Wägezelle mit AD-HX711

Bibliothek und Quellcode:
Für Teil 1:
https://github.com/bogde/HX711

Für Teil 2:
RobTillaart –>https://github.com/RobTillaart

Für Teil 3:
https://github.com/olkal/HX711_ADC

Sketch:

#include "HX711.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

const int LOADCELL_DOUT_PIN = 4;
const int LOADCELL_SCK_PIN = 5;

HX711 scale;

void setup() {
  Serial.begin(57600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  lcd.init();                      
  lcd.init();
  lcd.backlight();
}

void loop() {

  if (scale.is_ready()) {
    long reading = ((scale.read() * (-0.01))-2217 )/8;
    Serial.print("HX711 hat folgendes gemessen: ");
    Serial.println(reading);
    lcd.setCursor(3, 0);
    lcd.print("Gewicht:");
    lcd.setCursor(3, 1);
    lcd.print(reading);

  } else {
    Serial.println("HX711 nicht gefunden");
  }

  delay(1000);
  lcd.clear();
}

Video zu Teil 1:

Zusätzliche Info:

Der Unterschied zwischen Halbbrücken- und Vollbrücken-Wägezellen liegt in der internen Verschaltung der Dehnungsmessstreifen (DMS) und damit in der Genauigkeit, Empfindlichkeit und Komplexität der Signalverarbeitung.

Die bei mir eingesetzten Arduino Nano Clones musste ich bei den Arduino Einstellungen unter Prozessor auf ATmega328P (Old Bootloader) ändern. Auch kann es vorkommen das unter Win11 der notwendige CH340 Treiber zu neu ist! Bei mir funktioniert: CH340 Treiber Version 3.7.2022.01.

ESP32-Version:

Briefwaage mit ESP32-C3 incl. Display – Variante 2:

Briefwaage mit 1kg Wägezelle an einem Mini ESP32-C3 mit 0,42″OLED Display
Angeschlossen wird dieser wie folgt:
DT an GPIO 2
SCK an GPIO 3
GND an GND
VCC an 5V

Wägezelle und HX711 Modul unverändert wie bei Arduino Nano Teil 1

Der Sketch ist inklusive Kalibrierung.

Einschalten,
Voreingestellte 5 Sekunden Wartezeit, um ein kleines bekanntes Gewicht aufzulegen, das unter const float refWeight = 100.0; // Gramm eingetragen ist. zB. eine Tafel Schokolade.
Dann berechnet der Code automatisch den Kalibrierfaktor und zeigt abschließend das gemessene Gewicht an.

Ab jetzt können weitere Artikel gemessen werden

Sketch:

#include <U8g2lib.h>
#include <Wire.h>
#include "HX711.h"

// OLED: Mini ESP32-C3 mit 0,42" Display
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, 6, 5); // SDA=6, SCL=5

// HX711 Pins
const int HX_DT = 2;   // DOUT
const int HX_SCK = 3;  // SCK
HX711 scale;

// Display-Fenster (72x40 Pixel im 128x64 Canvas)
int width = 72, height = 40;
int xOffset = 28, yOffset = 16;

// Kalibrierfaktor (wird im Schritt 2 berechnet)
float calFactor = 1.0f;

// Hilfsfunktion: zentrierter Text im OLED-Fenster
void drawCentered(const char* text, int yShift) {
  int w = u8g2.getStrWidth(text);
  int x = xOffset + (width - w)/2;
  int y = yOffset + height/2 + yShift;
  u8g2.setCursor(x, y);
  u8g2.print(text);
}

void setup() {
  // Display
  u8g2.begin();
  u8g2.setFont(u8g2_font_6x10_tr);
  u8g2.setBusClock(400000);

  // HX711
  scale.begin(HX_DT, HX_SCK);
  scale.set_gain(128);   // Kanal A, Gain 128
  delay(200);

  // Schritt 1: Nullpunkt setzen (Tare)
  scale.tare(15);        // 15 Samples mitteln

  // Hinweis auf Display
  u8g2.clearBuffer();
  drawCentered("Tare gesetzt", 0);
  drawCentered("Lege bekanntes", 10);
  drawCentered("gewicht auf", 20);
  u8g2.sendBuffer();
  delay(5000);
}

void loop() {
  // Schritt 2: Kalibrierung mit Referenzgewicht
  // Beispiel: 100 g Referenzgewicht
  static bool calibrated = false;
  const float refWeight = 100.0; // Beispiel 100 Gramm Schokolade

  if (!calibrated) {
    long raw = scale.get_value(15);   // Rohwert ohne Skalierung
    calFactor = raw / refWeight;      // Faktor berechnen
    scale.set_scale(calFactor);       // setzen
    calibrated = true;

    // Anzeige Kalibrierung
    u8g2.clearBuffer();
    drawCentered("Kalibrierung OK", -6);
    char buf[32];
    snprintf(buf, sizeof(buf), "Faktor: %.2f", calFactor);
    drawCentered(buf, 10);
    u8g2.sendBuffer();
    delay(2000);
  }

  // Danach: normale Gewichtsanzeige
  float grams = scale.get_units(10); // gemittelt
  char buf[24];
  snprintf(buf, sizeof(buf), "%.2f g", grams);

  u8g2.clearBuffer();
  drawCentered("Gewicht", 1);
  drawCentered(buf, 17);
  u8g2.sendBuffer();

  delay(500);
}

Wenn nun beim ersten Start „Lege bekanntes Gewicht auf“ erscheint,
lege ein bekanntes Gewicht auf, das in zeile const float refWeight = 100.0 eingetragen wurde. Also in diesem Fall, etwas was 100g wiegt. Wenn dann der calFactor angezeigt wird. In meinem Beispiel 902.7 dann Schokolade entnehmen und die Briefwaage ist bereit und zeigt dann 0g an.

Funktioniert – Prima.

Jedoch bei jedem neuen einschalten muss jedes Mal beim Start ein neues calFactor berechnet werden.
Wenn du möchtest, dass die Waage nicht dauerhaft kalibriert werden soll, musst du:

den Kalibrierfaktor einmalig ermitteln,
diesen festen Wert im Code eintragen,
die automatische Kalibrierung deaktivieren.

Hier die finale Variante:

Merke dir den calFactor (Bei mir 902.7)

Über Setup einfügen:

const float calFactor = 902.7;   // hier deinen gemessenen Wert eintragen

In die Setup einfügen:

void setup() {
    Serial.begin(115200);
    // Display, HX711 etc. initialisieren

    scale.begin(HX_DT, HX_SCK);
    scale.set_gain(128);
    delay(200);

    scale.tare(15);              // Nullpunkt setzen (kannst du auch weglassen)
    scale.set_scale(calFactor);  // festen Kalibrierfaktor setzen
}

In der Loop lösche:

if (!calibrated) {
    Serial.print("nimm bekanntes Gewicht wieder runter, damit Kalibrierung abgeschlossen werden kann");
    long raw = scale.get_value(15);   // Rohwert ohne Skalierung
    calFactor = raw / refWeight;      // Faktor berechnen
    scale.set_scale(calFactor);       // setzen
    calibrated = true;

    // Anzeige Kalibrierung
    u8g2.clearBuffer();
    drawCentered("Kalibrierung OK", -6);
    char buf[32];
    snprintf(buf, sizeof(buf), "Faktor: %.2f", calFactor);
    drawCentered(buf, 10);
    u8g2.sendBuffer();
    delay(2000);
  }

Damit:

wird beim Einschalten nichts mehr neu kalibriert,
die Waage nutzt immer deinen festen calFactor,
und du kannst optional scale.tare(15); auch noch entfernen, wenn selbst der Nullpunkt dauerhaft bleiben soll.

So sollte der Code aussehen, wenn nicht mehr dauernd kalibriert werden soll:

#include <Arduino.h>
#include <U8g2lib.h>
#include <Wire.h>
#include "HX711.h"

// Pins für ESP32-C3 Variante 2
#define HX_DT 2
#define HX_SCK 3

// Deinen ermittelten Kalibrierfaktor hier eintragen:
const float calFactor = 902.7;

// Display (0,42" OLED)
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, 6, 5); // SDA=6, SCL=5

// HX711
HX711 scale;

// Hilfsfunktion für zentrierten Text
void drawCentered(const char* text, int y) {
    u8g2.setFont(u8g2_font_6x12_tf);
    int w = u8g2.getStrWidth(text);
    int x = (72 - w) / 2;
    u8g2.drawStr(x, y, text);
}

void setup() {
    Serial.begin(115200);

    // Display
    u8g2.begin();
    u8g2.clearBuffer();
    drawCentered("Start...", 20);
    u8g2.sendBuffer();

    // HX711
    scale.begin(HX_DT, HX_SCK);
    scale.set_gain(128);
    delay(200);

    // Nullpunkt setzen (optional)
    scale.tare(15);

    // festen Kalibrierfaktor setzen
    scale.set_scale(calFactor);

    delay(300);
}

void loop() {
    float grams = scale.get_units(10);

    u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_logisoso16_tf);

    char buf[16];
    snprintf(buf, sizeof(buf), "%.1f g", grams);
    drawCentered(buf, 28);

    u8g2.sendBuffer();
    delay(100);
}

Personen‑ und Objektwaage mit Halbbrücken‑Wägezellen

Arduino Projekt: Bau einer Art digitalen Personenwaage