Kraftmesser mit Wägezelle Teil 1: Aufbau - AZ-Delivery

0 Kommentare

In der aktuellen Beitragsfolge wende ich mich an meine Kollegen von der physikalischen Fraktion. In den nächsten Episoden wird es um einen Kraftmesser ohne Schraubenfeder gehen, natürlich nicht ohne den Einsatz eines elastischen Sensors. Allerdings sieht man von dessen Elastizität enorm wenig. Jedoch wird die Auflösung durch den kaum wahrnehmbaren visuellen Aspekt nicht herabgesetzt, sondern eher gefördert. Wie das möglich ist, das verrate ich Ihnen in den neuen Folgen aus der Reihe

MicroPython auf dem ESP32, ESP8266 und Raspberry Pi Pico

heute

Ein Kraftmesser unter MicroPython – Teil 1

1. Im ersten Teil beschäftigen wir uns mit dem Messprinzip und dem Aufbau der Hardware.

2. Im zweiten Teil fügen wir eine Großanzeige auf dem Laptop hinzu, die über USB gesteuert wird.

3. In Teil 3 ersetzen wir die USB-Datenleitung durch Funkübertragung

4. Teil 4 bringt eine Anzeigeeinheit mit 8 LED-Panelen, die ebenfalls über WLAN angebunden wird.

5. Ein Android-Tablet als Anzeige-Einheit wird in Teil 5 vorgestellt.

Der Kraftsensor

Vor einiger Zeit habe ich ein Bauteil, aus dessen Familie auch jetzt wieder eines in Anwendung kommt, bereits anderweitig in einer Waage verbaut. Hier wie dort geht es letztlich um die Messung von Kräften. Das heißt, auch bei der Massenbestimmung mit der Waage ging es um die Messung einer Kraft, nämlich der Gravitationskraft F_g. Diese ist über den Ortsfaktor g = 9,81N/kg mit der Masse m von Wägestücken verknüpft: F_g = g • m. Damit war es möglich, die Waage mit Massestücken zu calibrieren. Abbildung 1 zeigt so einen Wägbalken. Bei der Waage wird die rechte Seite fest mit dem Untergrund verschraubt, links wird die Waagschale befestigt.

Abbildung 1: Wägezelle von der Seite

Im aktuellen Fall gilt es, direkt Kräfte zu messen. Möglich wird das durch die elastische Verformung eines Wägbalkens aus Aluminium, an dem Dehnungsmesstreifen angebracht sind. Diese Bauteile bestehen aus hauchdünnen Leiterschleifen, die durch die Verbiegung der ausgedünnten Stellen des Balkens je nach ihrer Lage gestreckt oder gestaucht werden und dadurch ihren elektrischen Widerstand verändern.

Abbildung 2: Dehnungsmessstreifen schematisch

Durch Strecken werden die Leiter länger und dünner, durch Stauchen passiert das Gegenteil. Leiterlänge und Querschnittsfläche gehen beide in die Berechnung des elektrischen Widerstands eines Leiters ein. Sowohl die Verlängerung, als auch die Verringerung des Querschnitts bewirken beide eine Steigerung des Widerstandswerts. ρ ist der spezifische Widerstand, eine Materialkonstante.

Abbildung 3: Widerstandsformel

Damit auch kleinste Veränderungen des Widerstandswerts zu einem reproduzierbaren Messergebnis mit hoher Auflösung führen, sind die Messstreifen zu einer Brückenschaltung zusammengefasst, deren Ausgangsspannung einem Präzisionsverstärker zugeführt wird. Dessen Ausgangsspannung muss für die Verarbeitung in einem Microcontroller nun nur noch digitalisiert werden.

Abbildung 4: Dehnungsmessstreifen am HX711

Der Baustein HX711 beinhaltet beide Komponenten und erlaubt ferner die Wahl der Verstärkung, 128-fach oder 64-fach am Differenzeingang A, sowie 32-fach am Eingang B. Die Übertragung des 24-Bit-ADC-Werts (ADC = Analog Digital Converter) zum Microcontroller erfolgt über die Data-Leitung, die durch 24 Pulse an Clock getaktet wird. Bis zu drei weitere Pulse beeinflussen die Verstärkungseinstellung des PGAs (Programmable Gain Amplifier) für die nächste Messung. Der hier verwendete Wägbalken kann bis 5kg belastet werden, was einer maximalen Kraft von ca. 50N entspricht. Zusammen mit dem Eingang A und Gain=128 erreichen wir eine Auflösung von 1mN entsprechend ca. 0,1 Gramm Masse. Weil das bereits die unsichere Stelle ist, begnügen wir uns mit 10mN als kleinste Messgröße und bekommen dafür eine stabile Messwertanzeige. 0,01N ist ja auch weit mehr, als man mit Kraftmessern mit Schraubenfedern erreichen kann.

Abbildung 5: Verstärkungseinstellung über zusätzliche Takt-Impulse

Das Software-Interface zum HX711 ist die Klasse HX711 aus dem MicroPython-Modul hx711.py. Dazu kommen wir später.

Hardware

Als Controller eignen sich sowohl beliebige ESP8266- wie auch ESP32-Modelle mit mindestens vier freien GPIOs. Die Anzeige des Messwerts erfolgt zunächst über ein OLED-Display. Als Wägezelle kann natürlich auch ein anderes Modell dienen. Es gibt sie ab 100g aufwärts bis zu 100kg Wägevolumen und mehr.

Aus Platzgründen habe ich mich in diesem Projekt für ein D1 Mini NodeMcu mit ESP8266-12F WLAN Modul entschieden. Die Spannungsversorgung der Messelektronik erfolgt fürs Erste über den USB.

1	D1 Mini NodeMcu mit ESP8266-12F WLAN Modul oder D1 Mini V3 NodeMCU mit ESP8266-12F oder NodeMCU Lua Amica Modul V2 ESP8266 ESP-12F WIFI oder NodeMCU Lua Lolin V3 Module ESP8266 ESP-12F WIFI oder ESP32 Dev Kit C unverlötet oder ESP32 Dev Kit C V4 unverlötet oder ESP32 NodeMCU Module WLAN WiFi Development Board mit CP2102 oder NodeMCU-ESP-32S-Kit oder ESP32 Lolin LOLIN32 WiFi Bluetooth Dev Kit
1	0,91 Zoll OLED I2C Display 128 x 32 Pixel
1	NeoPixel-Led vom Streifen WS2812B 30 LEDs/m 30 Pixels/m LED Strip RGB adressierbarer LED Streifen mit 5050 SMD LEDs IP20 Schwarz nicht Wasserdicht
1	Wägezelle
1	HX711 AD-Wandler für Wägezellen
1	MB-102 Breadboard Steckbrett mit 830 Kontakten
2	Taste aus dem Sortiment Mikroschalter Taster Set - 180 Stück, Verschiedene Größen, Vielseitige Taster für Elektronik
diverse	Jumper Wire Kabel 3 x 40 STK. je 20 cm M2M/ F2M / F2F evtl. auch 65Stk. Jumper Wire Kabel Steckbrücken für Breadboard
1	Mini Breadboard 400 Pin mit 4 Stromschienen für Jumper Kabel
4	Schraube M4 x 25
4	Schraube M3 x 7
4	Schraube M3 x 10
2	Schrauböse M4 x 40
2	Abstandsbleche 21mm x 12mm x 2,5mm
2	Aluprofil 12mm x 12mm x 75mm
2	Alu-Uschiene 15mm x 13mm x 75mm; t = 1,5mm
4	Plexiglasscheibe 12mm x 10mm x 2mm
optional	Logic Analyzer

Die Schaltung für den ESP8266 D1 Mini

Abbildung 6: Kraftmesser - Schaltung

Die Software

Fürs Flashen und die Programmierung des ESP32:

Thonny oder

µPyCraft

Herstellung eigener Zeichensätze

zeichensatz.rar Arbeitsumgebung zum Erzeugen eigener Zeichensätze

Die MicroPython-Programme zum Projekt:

ssd1306.py Hardwaretreiber für das OLED-Display

oled.py API für das OLED-Display

geometer_30.py großer Zeichensatz für die Ziffernanzeige

hx711.py API für den AX711

newtonmeter.py Das Betriebsprogramm

MicroPython - Sprache - Module und Programme

Zur Installation von Thonny finden Sie hier eine ausführliche Anleitung (english version). Darin gibt es auch eine Beschreibung, wie die Micropython-Firmware (Stand 25.01.2024) auf den ESP-Chip gebrannt wird. Wie Sie den Raspberry Pi Pico einsatzbereit kriegen, finden Sie hier.

MicroPython ist eine Interpretersprache. Der Hauptunterschied zur Arduino-IDE, wo Sie stets und ausschließlich ganze Programme flashen, ist der, dass Sie die MicroPython-Firmware nur einmal zu Beginn auf den ESP32 flashen müssen, damit der Controller MicroPython-Anweisungen versteht. Sie können dazu Thonny, µPyCraft oder esptool.py benutzen. Für Thonny habe ich den Vorgang hier beschrieben.

Sobald die Firmware geflasht ist, können Sie sich zwanglos mit Ihrem Controller im Zwiegespräch unterhalten, einzelne Befehle testen und sofort die Antwort sehen, ohne vorher ein ganzes Programm kompilieren und übertragen zu müssen. Genau das stört mich nämlich an der Arduino-IDE. Man spart einfach enorm Zeit, wenn man einfache Tests der Syntax und der Hardware bis hin zum Ausprobieren und Verfeinern von Funktionen und ganzen Programmteilen über die Kommandozeile vorab prüfen kann, bevor man ein Programm daraus strickt. Zu diesem Zweck erstelle ich auch gerne immer wieder kleine Testprogramme. Als eine Art Makro fassen sie wiederkehrende Befehle zusammen. Aus solchen Programmfragmenten entwickeln sich dann mitunter ganze Anwendungen.

Autostart

Soll das Programm autonom mit dem Einschalten des Controllers starten, kopieren Sie den Programmtext in eine neu angelegte Blankodatei. Speichern Sie diese Datei unter main.py im Workspace ab und laden Sie sie zum ESP-Chip hoch. Beim nächsten Reset oder Einschalten startet das Programm automatisch.

Programme testen

Manuell werden Programme aus dem aktuellen Editorfenster in der Thonny-IDE über die Taste F5 gestartet. Das geht schneller als der Mausklick auf den Startbutton, oder über das Menü Run. Lediglich die im Programm verwendeten Module müssen sich im Flash des ESP32 befinden.

Zwischendurch doch mal wieder Arduino-IDE?

Sollten Sie den Controller später wieder zusammen mit der Arduino-IDE verwenden wollen, flashen Sie das Programm einfach in gewohnter Weise. Allerdings hat der ESP32/ESP8266 dann vergessen, dass er jemals MicroPython gesprochen hat. Umgekehrt kann jeder Espressif-Chip, der ein kompiliertes Programm aus der Arduino-IDE oder die AT-Firmware oder LUA oder … enthält, problemlos mit der MicroPython-Firmware versehen werden. Der Vorgang ist immer so, wie hier beschrieben.

Aufbau der Messeinrichtung

Für die Aufhängung des Wägbalkens mit 12mm x 12mm x 75mm benötigen wir zwei weitere Aluminium-Profile mit denselben Abmessungen, ferner zwei Alubleche mit 21mm x 12mm x 2,5mm als Abstandshalter. Zwei Aluminium-U-Schienen werden für die Aufnahme der Platinen gebraucht, auf welche der Controller und der HX711 gesteckt werden. Hier ist die Teileskizze, die auch als PDF-Dokument heruntergeladen werden kann. Darin sind das Layout der Platinen und deren Bestückungsplan enthalten.

Die Aluprofile habe ich im Baumarkt bekommen. In das obere Profil müssen M3-Gewinde für die Befestigung der U-Schienen geschnitten werden. Auch die Befestigung der Platinen in den U-Schienen erfolgt über M3-Gewinde und Abstandshalter aus Plexiglas (12mm x 10mm x 2mm). 3mm-Gewinde an den Außenseiten der U-Schienen dienen der Befestigung einer optionalen Abdeckung.

Abbildung 7: Mechanischer Aufbau des Kraftmessers

Abbildung 8: Sensoreinheit von oben

Abbildung 9: Kraftmesser im Einsatz

Abbildung 8 zeigt die Montage der Elektronik. Als Träger dienen zwei Platinen, die mit Buchsenleisten für die Aufnahme von Microcontroller und HX711 bestückt sind. Hier sind Layout und Bestückungsplan. Drei Kabelverbindungen sind in grün eingetragen.

Abbildung 10: Layout der beiden Platinen

Für das erste Beschnuppern habe ich einen Testaufbau mit einem NodeMCU Lua Lolin V3 Module ESP8266, das gerade zur Hand war, realisiert. Den Wägbalken habe ich mit meinen Testkabeln fliegend mit der Schaltung verbunden.

Abbildung 11: Testaufbau mit einem ESP8266 Node MCU-Board

Diese Testkabel lassen sich leicht aus einem hochflexiblen Siliconkabel und einer Testklemme in beliebiger Länge herstellen. Eine einpolige Steckleiste ermöglicht den Anschluss auf dem Breadboard. Einem Kabelbruch am Stecker wirkt ein Stück Schrumpfschlauch entgegen.

Abbildung 12: Praktische Testklemme mit Siliconkabel

Ein großer Zeichensatz für das OLED-Display

Große Ziffern erleichtern die Ablesung der Messung erheblich. Statt der üblichen acht Pixel, verwenden wir 30 Pixel als Zeichenhöhe. Die Datei geometer_30.py enthält die entsprechenden Informationen dazu.

Um selbst einen eigenen Zeichensatz für das OLED-Display herzustellen, brauchen wir ein paar Zutaten.

1. Python für Windows

2. freetype-py

3. zeichensatz.rar

Falls Python noch nicht auf Ihrem PC installiert ist, müssen Sie das jetzt tun. Laden Sie Sie das aktuelle Paket Python 3.13.3 herunter und installieren sie es, indem Sie die Datei python-3.13.3-amd64.exe im Downloadordner starten und dem Assistenten folgen.

freetype-py ist ein Tool, welches bei der Umwandlung eines TTF-Zeichensatzes von Windows benötigt wird. Mit Python wurde auch ein Werkzeug mit dem Namen pip3 installiert. Das benutzen wir, um freetype-py zu installieren.

Öffnen sie die Eingabeaufforderung und geben Sie am Prompt folgende Zeile ein.

pip3 install freetype-py

Und so stellen Sie sich einen eigenen Zeichensatz aus dem TTF-Vorrat von Windows her.

Laden Sie das Archiv zeichensatz.rar herunter und entpacken Sie den Inhalt in ein beliebiges Verzeichnis. Um Tipparbeit zu sparen, empfehle ich ein Verzeichnis mit einem kurzen Namen im Root-Pfad der Festplatte oder eines Sticks. Bei mir ist es F:\fonts.

Öffnen Sie aus dem Explorer heraus ein Powershell-Fenster in diesem Verzeichnis, indem Sie mit gedrückter Shift-Taste einen Rechtsklick auf das Verzeichnis machen. Dann Linksklick auf PowerShell-Fenster hier öffnen.

Abbildung 13: Powershell-Fenster öffnen

Geben Sie am Prompt folgende Zeile ein und drücken Sie Enter.

.\makecharset.bat geometer 30 """0123456789,-+N""" "F:\fonts\quellen\"

Abbildung 14: Der Zeichensatz ist fertig

Im Verzeichnis befindet sich jetzt eine Datei geometer_30.py mit den Pixeldaten des neuen Zeichensatzauszugs. Umgesetzt wurden nur die Zeichen in """0123456789,-+N""", das spart Speicherplatz. Weitere Zeichensätze können Sie aus dem fonts-Verzeichnis von Windows in das Verzeichnis quellen kopieren und wie oben angegeben umwandeln. Beachten Sie bitte, dass der Dateiname ohne die Ergänzung .TTF angegeben wird.

Den erzeugten Zeichensatz kopieren wir nun in das Arbeitsverzeichnis unseres neuen MicroPython-Projekts.

Erste Tests

Die Signal-LED

Dann können wir damit beginnen ein paar erste Tests zu starten. Als Voraussetzung dafür können wir die Testschaltung von Abbildung 11 verwenden, an die der Wägbalken wie im Schaltbild, Abbildung 6, angeklemmt wird.

Als Signal-LED habe ich eine Neopixel-LED von einem LED-Streifen hergenommen, die beim Bau der Abakus-Uhr übriggeblieben ist. Das hat den Vorteil, dass mit einer LED über eine einige Steuerleitung jede beliebige Farbe dargestellt werden kann.

Abbildung 15: Neopixel-LED

Weil der NodeMCU Lua Lolin V3 Module ESP8266 am Pin Vin die 5V vom USB nicht herausführt, habe ich +5V des Steifens am 3,3 V-Ausgang der Controllerboards angeschlossen, das geht mit einer LED problemlos. Der ESP8266 D1 Mini, den wir im Kraftsensor verbauen, liefert am 5V-Pin tatsächlich die 5V vom USB. Din schließen wir an D4 = GPIO2 an.

Im Folgenden werden Eingaben in REPL fett formatiert, Ausgaben kursiv.

>>> from neopixel import NeoPixel

Das Neopixel-Objekt besteht aus einer LED an GPIO2

>>> led=Pin(2, Pin.OUT, value=0) # D4

>>> np=NeoPixel(led,1)

Wir definieren einige Farben…

>>> red=(4,0,0)

>>> blue=(0,0,4)

>>> yellow=(16,8,0)

>>> off=(0,0,0)

Und überprüfen deren Wirkung.

>>> np[0]=red

>>> np.write()

>>> np[0]=off

>>> np.write()

Farbwahl und Schreiben zur LED fassen wir in der Funktion signal() zusammen.

>>> def signal(col):

np[0]=col

np.write()

>>> signal(yellow)

>>> signal(off)

Messung von Kräften

Für die Bedienung des HX711 gibt es eine Klasse, die im Modul hx711.py wohnt. Startet man hx711.py in einem Editorfenster von Thonny, dann erzeugt der if-Block am Ende des Listings ein HX711-Objekt mit dem Bezeichner hx.

if __name__ == "__main__":

from machine import Pin

hx=HX711(Pin(14),Pin(12,Pin.IN)) # D5, D6

Damit können wir erste Gehversuche mit dem Kraftsensor unternehmen. Wir holen einen Messwert, so wie ihn der HX711 bestimmt hat, über die serielle Leitung ab. Gemäß dessen Beschaltung bekommen wir 10 Werte pro Sekunde (Anschluss Rate = GND).

>>> %Run -c $EDITOR_CONTENT

HX711 bereit auf Kanal A mit Gain 128

>>> hx.getRaw()

-502747

Dieser Wert ergibt sich für den unbelasteten Wägbalken. Bezugspunkt ist in unserem Fall nicht die untere Halterung des Wägbalkens, sondern der Haken im oberen Teil. Im hängenden Zustand der Messeinheit zählen zu den belastenden Teilen des Sensors auch die Profilteile, die unterhalb des Wägbalkens montiert sind. Diesen Wert müssen wir für spätere Messungen als Tara berücksichtigen. Den Tarawert bestimmen wir aus mehreren Messungen als Mittelwert. Die Anzahl der Messungen geben wir beim Aufruf vor, hier 2.

>>> hx.tara(2)

-502631

Abbildung 16: Tara erfassen

Als nächstes muss der Sensor calibriert werden. Das heißt, dass der rohe Messwert für eine bestimmte Kraft, korrigiert um den Tara-Wert, in eine Kraftangabe in Newton umgerechnet werden muss. Wir spannen den Wägbalken also fest ein oder hängen unsere Messeinheit auf, starten hx711.py und rufen hx.tara(2) auf. Der Tara-Wert wird dadurch im Attribut hx.tare gespeichert und zurückgegeben.

Nun müssen wir den Calibrierfaktor für die Umrechnung in Newton bestimmen. Das erledigt die Methode hx.calibrateF(), der wir die Masse von 102g übergeben. Im Schwerefeld der Erde wirkt auf diese Masse, abhängig vom Messort, eine Gewichtskraft von ca. 1 Newton.

Abbildung 17: Mit einer Masse von 102g auf 1N calibrieren

Auch dieser Wert wird als Attribut hx.fcal des HX711-Objekts gespeichert. Ab sofort können wir nun Kräfte direkt messen, indem wir die Methode hx.kraft(n) aufrufen. Der Parameter n gibt wieder die Anzahl durchzuführender Messungen an, aus denen der Mittelwert berechnet wird. Jede Einzelmessung dauert circa 100ms.

>>> hx.calibrateF(102)

44098.7

>>> hx.kraft(2)

1.00366

Den Calibrierfaktor können wir jederzeit abrufen und gegebenenfalls händisch nachjustieren. Für ein einfacheres Prozedere, ist es empfehlenswert, den gefundenen Calibrierfaktor in der Klasse HX711 beim Klassenattribut KFaktorKraft einzutragen. Alternativ könnten wir den Wert auch in eine Datei schreiben die wir jedes Mal beim Booten auslesen.

>>> hx.fcalFaktor(44098.1)

>>> hx.kraft(2)

1.00045

>>> hx.kraft(2)

1.00288

Wir erkennen, dass ein brauchbares Ergebnis nur mit zwei Nachkommastellen angegeben werden kann, weil die dritte Nachkommastelle bereits deutlich wackelt. Das reicht aber auch, denn kein herkömmlicher Kraftmesser mit Schraubenfeder kann auf 0,01N auflösen. Wir werden unsere Messergebnisse also künftig für die Anzeige auf sechs Positionen mit zwei Nachkommastellen trimmen und rechtsbündig (>) mit einem "N" als Benennung ausgeben.

>>> "{:>6.2f} N".format(hx.kraft(2))

' 1.00 N'

Größere Zeichen im OLED-Display

Das Modul geometer_30.py hat den folgenden Aufbau. Nach einem Header, in welchem die enthaltenen Zeichen, die Höhe und die maximale Breite der Zeichen aufgeführt sind, folgen in der Liste number Tupel, deren erste Komponente die aktuelle Zeichenbreite angibt. Danach folgt das Pixelmuster des Zeichens in Form von bytes-Objekten in binärer Darstellung. Über die Position des Zeichens im String chars erhalten wir Zugriff auf den Eintrag in number. Eigene Zeichen können generiert werden, indem wir das Bitmuster händisch erzeugen und ein Pointer-Zeichen in chars eintragen.

Das Modul muss in den Flash des Controllers hochgeladen werden, damit es angesprochen werden kann.

>>> import geometer_30 as cs

Auf diese Weise importiert, können wie das Modul statt mit dem Präfix geometer_30 ganz kurz mit dem Präfix cs ansprechen.

chars="0123456789,-"

height=31

width=29

number=[

(17, # Zeichen: 0

0b00000000000000000,

0b00000011111000000,

0b00001111111110000,

0b00011111111111000,

0b00111110001111100,

0b01111100000111110,

0b00111110001111100,

0b00011111111111000,

0b00001111111110000,

0b00000011111000000,

0b00000000000000000,

Zur Darstellung müssen wir nun einfach im Display ab der Startposition (= linke obere Ecke der Zeichenmatrix) überall dort ein Pixel setzen, wo im Muster eine 1 steht. Das macht die Funktion putNumber(). Die Nummer des Musters in der Liste erhalten wir durch folgende Zeile. z ist das darzustellende Zeichen, die Methode index() bestimmt die Position in chars.

>>> n=cs.chars.index(z)

def putNumber(n,xpos,ypos,show=True):

breite=cs.number[n][0]

for row in range(1,cs.height):

for col in range(breite-1,-1,-1):

c=cs.number[n][row] & 1<<col

d.setPixel(xpos+breite+3-col,ypos+row,c,False)

if show:

d.show()

return xpos+breite+2

Wir holen die Zeichenbreite und klappern Zeile für Zeile und Spalte für Spalte das Muster ab. Wir lesen den Farbcode c aus, 0 oder 1, und setzen verdeckt (False) entsprechend das Pixel auf Hinter- oder Vordergrundfarbe, 0 oder 1. Dabei sind zwei Pixel als Zeichenabstand vorgesehen. Die Funktion gibt die x-Position für das nächste Zeichen zurück, so dass Zeichen im Proportionalmodus dargestellt werden können.

Für die nächsten Tests müssen die Dateien oled.py und ssh1306.py in den Flash des Controllers hochgeladen werden.

>>> import geometer_30 as cs

>>> from machine import Pin,freq,SoftI2C

>>> from oled import OLED

>>> import geometer_30 as cs

>>> def putNumber(n,xpos,ypos,show=True):

breite=cs.number[n][0]

for row in range(1,cs.height):

for col in range(breite-1,-1,-1):

c=cs.number[n][row] & 1<<col

d.setPixel(xpos+breite+3-col,ypos+row,c,False)

if show: