Heute werden wir eine DIY-Gewichtsmesswaage mit ESP8266 bauen. Die Entwicklung im Bereich eingebetteter Systeme hat es zu einem Kinderspiel gemacht, mit minimalem Zeit- und Kostenaufwand eine präzise und genaue Waage zu bauen. Selbst wenn du nur wenig oder gar kein Verständnis für Mikrocontroller wie die ESP8266-Entwicklungsboards oder NodeMCU hast, wirst du es ohne Schwierigkeiten schaffen. Wir werden eine Waage zur Gewichtsmessung mit einer Wägezelle, einem HX711 und einem ESP8266 Entwicklungsboard bauen.
Benötigte Komponenten
Wir benötigen die folgenden Dinge:
- ESP8266
- Arduino IDE
- USB-Kabel
- Wägezelle (10 kg oder je nach Wunsch)
- HX711 ADC für Wägezelle
- Breadboard
- Überbrückungsdrähte
- I2C LCD (HD44780)
Schaltungsaufbau
Schritt 1: Verbinde das HX711 mit der Wägezelle. Die Wägezelle hat vier Drähte mit den Farben rot, schwarz, grün und weiß. Schließe diese gemäß dem folgenden Schaubild an:
Schritt 2: Verbinde nun den HX711 mit dem ESP8266. Der HX711 hat vier Pins, darunter Vcc, Masse, Daten und Takt. Verbinde die Pins Data und Clock mit D5 und D6 des ESP8266. Masse und Vcc werden einfach mit den Vin und Ground Pins verbunden.
Schritt 3: Schließe den ESP8266 und die I2C-LED an, um die Gewichtswerte anzuzeigen. Die I2C-LED hat vier Pins, darunter Masse, Vcc, SDA und SCL. Schließe sie gemäß der folgenden Tabelle an:
Endgültige Schaltung: Achte beim Anschließen des Stromkreises auf die losen Verbindungen und die richtigen Anschlüsse gemäß der Tabelle und den oben gezeigten Verbindungen. Nachdem alle Kabel angeschlossen sind, sieht der endgültige Stromkreis wie folgt aus:
Code des ersten Teils des Schaltkreises
Zunächst müssen wir unseren HX711-Sensor und die Wägezelle kalibrieren. Durch die einmalige Kalibrierung erhalten wir genaue und präzise Werte, da wir sonst falsche Werte für die Dinge erhalten, die wir auf die Waage legen. Wir benötigen zwei Bibliotheken für den Code, die Folgendes umfassen:
Kalibrierung
Die Kalibrierung des HX711 erfolgt nach der „Hit and Trial“-Methode, d.h. wir messen den Wert des Gewichts auf der Wägezelle viele Male, um den Wert des Kalibrierungsfaktors einzustellen. Sobald unser Messwert dem bekannten Wert unseres Gewichts entspricht, können wir unsere Waage problemlos zur Messung jedes anderen Gewichts verwenden.
Im ersten Teil des Kalibrierungscodes haben wir ein Objekt der Klasse HX711 erstellt und eine Funktion scale.begin() verwendet, um die Daten- und Taktpins zuzuweisen. Danach setzen wir einfach den Anfangswert unseres HX711 zurück.
Im zweiten Teil der Kalibrierung wiederholen wir einfach eine Schleife, um den genauen Wert des Kalibrierungsfaktors zu ermitteln. Wir kalibrieren unser HX711 durch Erhöhen oder Verringern des Faktors je nach Bedarf, indem wir den richtigen Wert in den seriellen Monitor eingeben.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#include "HX711.h" //Install this library from library manager #include <Wire.h> #include <LiquidCrystal_I2C.h> //Including I2C LCD library LiquidCrystal_I2C lcd(0x27, 16, 2); //Creating an object of LCD_I2C #define Clock D5 #define Data D6 //Defining Clock and Data Pins HX711 scale; //Making an object of HX711 class //Assume a random conversion factor and then this is changed according to the calibration float calibration_factor = -109000; //Assuming a calibration_factor float weight; void setup() { //Setup Function scale.begin(Data, Clock); //Using Hx711 function scale to begin the connection Serial.begin(9600); Serial.println("HX711 Calibration"); Serial.println("First Remove all the weight"); Serial.println("PLace your weight after the readings start"); Serial.println("Calibration is increased when you press a,b,c,d by the factor of 10,100,1000,10000"); Serial.println("Calibration is increased when you press e,f,g,h by the factor of 10,100,1000,10000"); Serial.println("Press t for reset"); //Printing necessary instructions scale.set_scale(); scale.tare(); //Reset the scale to 0 long zero_factor = scale.read_average(); //Get a baseline reading Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects. Serial.println(zero_factor); Wire.begin(D7,D8); //Starting Connection of LCD lcd.begin(); lcd.setCursor(1,1); //Setting the LCD cursor to display value at a particular spot lcd.print("Weighing Scale"); delay(3000); lcd.clear(); //Clearing the LCD after the delaying } |
Wir lesen die Werte weiter ab und finden den Kalibrierungsfaktor, bis unsere Wägezellen den genauen Wert des Gewichts ablesen, mit dem wir sie kalibrieren wollen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
void loop() { scale.set_scale(calibration_factor); //We are adjusting the calibration factor Serial.print("Reading Values "); Serial.print(scale.get_units(), 3); Serial.print(" kg"); //Changing this unit to KG to follow SI units Serial.print(" calibration_factor: "); Serial.print(calibration_factor); Serial.println(); if(Serial.available()) //Applying the condition to check if something is entered on the serial or not { char temp = Serial.read(); //Reading the value entered on the serial monitor if(temp == '+' || temp == 'a') calibration_factor += 10; //Applying if statements to increase or decrease the calibration factor according to requirement else if(temp =='-' || temp == 'e') calibration_factor -= 10; else if(temp == 'b') calibration_factor += 100; else if(temp == 'f') calibration_factor -= 100; else if(temp == 'c') calibration_factor += 1000; else if(temp == 'g') calibration_factor -= 1000; else if(temp == 'd') calibration_factor += 10000; //Calibration factor will increase or decrease according to the key pressed else if(temp == 'h') calibration_factor -= 10000; //Once we get right value of the weight placed we simplyset that thing as calibration factor else if(temp == 't') scale.tare(); } } |
Endgültiger Kode
Im endgültigen Code richten wir zunächst unser LCD und den HX711 ein und setzen sie auf Null zurück. Im Setup beginnen wir die Verbindung mit dem I2C LCD und stellen die Cursorposition so ein, dass eine Zeile mit einer Verzögerung von 3 Sekunden angezeigt wird.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#include "HX711.h" //Install this library from library manager #include <Wire.h> #include <LiquidCrystal_I2C.h> //Inluding I2C LCD library LiquidCrystal_I2C lcd(0x27, 16, 2); //Creating object of LCD #define Clock D5 #define Data D6 HX711 scale; //Assume a random conversion factor and then this is changed according to the calibration float calibration_factor = -109000; //Assuming a calibration factor float weight; void setup() { Serial.begin(115200); //Starting serial connection scale.begin(Data, Clock); //Starting Connection of Hx711 scale.set_scale(); scale.tare(); //Reset the scale to 0 long zero_factor = scale.read_average(); //Get a baseline reading Serial.print("Zero factor: "); //This can be used to remove the need to tare the scale. Useful in permanent scale projects. Serial.println(zero_factor); Wire.begin(D7,D8); //Starting LCD connection lcd.begin(); lcd.setCursor(1,1); //Displaying a value at a particular spot on LCD lcd.print("Weighing Scale"); delay(3000); lcd.clear(); //Clearing LCD } |
Im zweiten Teil haben wir den erhaltenen Kalibrierungsfaktor verwendet, um den Maßstab unseres HX711 einzustellen. Wir erhalten die Gewichtswerte mit der Funktion get_units(). Dann wird einfach dieser Gewichtswert auf dem LCD angezeigt, indem der Cursor gesetzt wird und auch auf dem seriellen Monitor angezeigt wird.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
void loop() { scale.set_scale(calibration_factor); //Adjust to this calibration factor weight = scale.get_units(5); //Getting the weight using HX711 lcd.setCursor(0, 0); lcd.print("Measured Weight"); lcd.setCursor(0, 1); lcd.print(weight); //Displaying different values on LCD lcd.print(" KG "); delay(3000); lcd.clear(); Serial.print("Weight: "); Serial.print(weight); Serial.println(" KG"); //Also printing the weights on the serial monitor } |
Funktionsweise der verschiedenen Komponenten
HX711
HX711 enthält einen HX711-Chip mit der Fähigkeit zur Analog-Digital-Wandlung mit einer Genauigkeit von bis zu 24 Bit. Er verstärkt die von den Wägezellen gelieferten Millivolt-Werte und macht sie für den ESP8266 nutzbar, der schließlich das Gewicht aus den abgerufenen Daten berechnet.
Er hat vier Stifte. Die Pins VCC und Ground dienen der Stromversorgung des HX711. Der Daten-Pin dient dazu, die Daten von der Wägezelle abzuholen. Das Taktsignal ist ebenfalls mit dem Pin verbunden, um das Signal von einem der Pins des ESP8266 zu übernehmen.
Wägezelle
Eine Wägezelle ist ein Kraftaufnehmer. Er wandelt die Kraft wie Zug, Druck oder Kompression in ein elektrisches Signal um, das gemessen oder standardisiert werden kann. Wenn die auf die Last ausgeübte Kraft zunimmt, ändert sich das elektrische Signal proportional dazu. Grundsätzlich funktioniert eine Wägezelle nach dem Prinzip einer Wheatstone-Brücke
Die Erregerspannung VEX ist konstant, und die Spannung Vo ist die variable Spannung, die von der Form der Dehnungsmessstreifen abhängt. Wenn die Widerstände ausgeglichen sind, ist Vo gleich Null. Wenn ein Widerstand geändert wird, ändert sich Vo relativ, und diese Änderung wird erkannt.
In der Wägezelle sind die Widerstände mit den Dehnungsmessstreifen ausgetauscht und abwechselnd mit Zug- und Druckbildung angeordnet. Wenn eine Kraft auf die Wägezelle ausgeübt wird, ändern sich die Struktur und der Widerstand der Dehnungsmessstreifen, wodurch sich Vo ändert. Diese Änderung kann gemessen werden.
ESP8266/NodeMCU
Der ESP8266 ist der zentrale Teil unserer Schaltung und ist für das Abrufen der Daten von der Wägezelle und der Anzeige verantwortlich. Der ESP8266 ist ein kostengünstiger Wi-Fi-Mikrochip mit integrierter TCP/Networking-Software und Mikrocontroller-Fähigkeit. Seine geringen Kosten und seine hohe Funktionalität machen ihn zu einem idealen Chip für den Einsatz in Gewichtsmesswaagen.
I2C-LCD
I2C ist eine Abkürzung für Inter-IC. Es ist ein paketvermittelter Multi-Master-, Multi-Slave- und einseitiger serieller Bus, d.h. mehrere Chips können an denselben angeschlossen werden. I2C verwendet zwei bidirektionale Kommunikationswege. Der I2C-Adapter wird verwendet, um eine direkte Verbindung mit dem LCD herzustellen, und dieser Adapter ist mit dem ESP8266 verbunden. Wir werden die I2C LCD-Bibliothek verwenden, um unseren LCD mit unserem Mikrocontroller zu integrieren. I2C ist ein sehr leistungsfähiges Kommunikationsprotokoll zum Austausch von Daten zwischen nahe beieinander liegenden Mikrocontrollern oder Sensoren.
Vorteile der Gewichtsmesswaage
Die mit ESP8266 hergestellte Waage ist sehr nützlich und vorteilhaft, da sie eine Genauigkeit von etwa +/-0,03 aufweist. Außerdem kann sie durch die Verwendung einer größeren Anzahl von Wägezellen modifiziert werden, um Gewicht bis zu Hunderten von Kilogramm zu messen. Darüber hinaus können wir eine geeignete Leiterplatte für diese Schaltung entwickeln und einen Kunststoffkörper mit einem 3D-Drucker herstellen, um eine genauere und intuitivere Messwaage zu erhalten. Wir können auch das Internet der Dinge und ESP8266 verwenden, um die gemessenen Gewichtswerte aus der Ferne an jeden beliebigen Ort zu senden. Wir können diese Messwaage auch auf andere Einheiten wie Pfund oder eine andere lokale Einheit kalibrieren.
Übrigens: Auch mit dem Raspberry Pi können wir einfach eine Waage bauen.
Ein Kommentar
Super Tutorial! Es ist wirklich super verständlich erklärt.
Kennst du inzwischen eine kleine Küchenwaage die neben der Wägezelle auch einen HX711 Wandler verbaut hat den man verwenden kann?