Digitale Waage mit Wägezelle und Arduino

In diesem Beitrag lernen wir die Wägezelle auf Dehnungsmessstreifenbasis kennen. Wir werden untersuchen, was Dehnungsmessstreifen sind, was Wägezelle ist, Temperatureinfluss auf Dehnungsmessstreifen, Temperaturkompensation mit Wheatstone-Brücke und Wägezellenverstärker HX711, und schließlich lernen wir, wie man eine Arduino-basierte Waage durch Implementierung von Wägezelle als baut der Gewichtssensor.

Dieser Beitrag befasst sich mit Gewichtsmessung und Messmethoden sowie der Implementierung der Methoden in einer Arduino-basierten Waagenschaltung.

Wir alle lieben es, unser Gewicht zu sehen, unabhängig von unserem Alter. Ein kleines Kind mag es, seine Gewichtszunahme zu sehen, und Erwachsene mögen es, seinen Gewichtsverlust zu sehen. Gewicht ist seit jeher ein wichtiges Konzept, das beim Handel mit Waren, bei der Entwicklung wissenschaftlicher Geräte und bei kommerziellen Produkten hilfreich war.

In der heutigen Zeit messen wir Gewichte in Kilogramm, Milligramm oder sogar Mikrogramm für Laborzwecke. Ein Gramm ist weltweit gleich, alle Gewichtsmessgeräte müssen gleich messen. Die Massenproduktion einer Pille mit einem winzigen Unterschied von wenigen Milligramm Dosierung reicht aus, um aus einer lebensrettenden Pille eine Selbstmordpille zu machen.

Was ist Gewicht?

Gewicht ist die Kraft, die auf ein Flugzeug ausgeübt wird. Die ausgeübte Kraft ist direkt proportional zur Masse eines Objekts. Dies bedeutet, dass die ausgeübte Kraft umso höher ist, je höher die Masse des Objekts ist.

Masse ist die Menge an physischer Materie, die in einem Objekt vorhanden ist.

Das Gewicht hängt von einem weiteren Faktor ab: der Schwerkraft.

Die Schwerkraft ist weltweit konstant (Aufgrund der ungleichmäßigen Kugelform der Erde gibt es geringfügige Abweichungen in der Schwerkraft, die jedoch sehr klein ist). Das Gewicht von 1 kg auf der Erde wiegt auf dem Mond 160 Gramm mit genau der gleichen Masse, da der Mond eine viel schwächere Anziehungskraft hat.

Jetzt wissen Sie, was Gewicht ist und welche Faktoren ein Objekt schwer machen.

Was ist Dehnungsmessstreifen:

Der Dehnungsmessstreifen ist ein Wandler oder ein Sensor, der die Dehnung (Verformung) eines Objekts misst. Dies wurde vom Elektrotechniker Edward E. Simmons und dem Maschinenbauingenieur Arthur Claude Ruge erfunden.

Abbildung der Dehnungsmessstreifen:

Das Dehnungsmessstreifen ist flexibel. Es handelt sich um ein dünnes Metallfolienmuster, das zwischen zwei dünnen Kunststoffplatten angeordnet ist, und es muss mit geeignetem Klebstoff oder einem beliebigen Klebstoff auf einer Oberfläche befestigt werden.

Wenn wir Gewicht oder Kraft auf die Oberfläche ausüben, verformt sie sich und der Dehnungsmessstreifen verformt sich ebenfalls. Durch die Verformung des Dehnungsmessers ändert sich der elektrische Widerstand der Metallfolie.

Jetzt ist die Widerstandsänderung des Dehnungsmessers direkt proportional zum Gewicht oder zur auf die Oberfläche ausgeübten Kraft.

Im wirklichen Leben ist die Änderung des Widerstands des Dehnungsmessers sehr unbedeutend zu erkennen. Um winzige Änderungen des Widerstands festzustellen, verwenden wir die Wheatstone-Brücke.

Lassen Sie uns auf den Punkt bringen, was die Wheatstone-Brücke ist.

Eine Wheatstone-Brücke verstehen:

Eine Weizensteinbrücke ist eine Schaltung, mit der unbekannter Widerstand bestimmt werden kann. Die Wheatstone-Brücke wurde von Samuel Hunter Christie entworfen, später wurde die Wheatstone-Brücke von Sir Charles erweitert und verbreitet

Weizenstein.

Abbildung der Wheatstone-Brückenschaltung:

Unsere modernen Digitalmultimeter können den Widerstandswert im Bereich von Mega-Ohm, Kilo-Ohm und Ohm ablesen.

Mit der Weizensteinbrücke können wir den Widerstand im Milli-Ohm-Bereich messen.

Die Weizensteinbrücke besteht aus 4 Widerständen, von den vier sind 3 bekannte Widerstände und einer unbekannter Widerstand.

Die Potentialdifferenz (Spannung) wird an die Punkte 'A' und 'C' angelegt und von den Punkten 'B' und 'D' wird ein Voltmeter angeschlossen.

Wenn alle Widerstände gleich sind, fließt an den Punkten „B“ und „D“ kein Strom, und das Voltmeter zeigt Null an. Dies wird als ausgeglichene Brücke bezeichnet.

Wenn sich der Widerstand eines Widerstands von den anderen drei Widerständen unterscheidet, fließt zwischen den Punkten „B“ und „D“ ein Spannungsfluss, und das Voltmeter zeigt einen Wert an, der proportional zum unbekannten Widerstand ist. Dies wird als unausgeglichene Brücke bezeichnet.

Hier ist der unbekannte Widerstand der Dehnungsmessstreifen. Wenn der Widerstand geändert wird, reflektiert er das Voltmeter.

Jetzt haben wir eine Verformung oder ein Gewicht oder eine Kraft in ein Spannungssignal umgewandelt. Diese Spannung muss verstärkt werden, um einige nützliche Messwerte zu erhalten, die einem Mikrocontroller zugeführt werden, um die Messwerte in Gramm zu erhalten.

Lassen Sie uns nun diskutieren, wie sich die Temperatur auf die Leistung des Dehnungsmessstreifens auswirkt.

Temperatureffekte am Dehnungsmessstreifen:

Der Dehnungsmessstreifen ist temperaturempfindlich und kann die tatsächlichen Gewichts- / Kraftwerte beeinträchtigen. Bei einer Änderung der Umgebungstemperatur wird die Metallfolie einer Metallausdehnung ausgesetzt, die sich direkt auf den Widerstand auswirkt.

Wir können den Temperatureffekt mithilfe der Wheatstone-Brücke aufheben. Mal sehen, wie wir die Temperatur mithilfe der Wheatstone-Brücke kompensieren können.

Temperaturkompensation:

Wir können den Temperatureffekt leicht neutralisieren, indem wir alle Widerstände durch Dehnungsmessstreifen ersetzen. Jetzt wird der gesamte Widerstand des Dehnungsmessers gleichermaßen von der Temperatur beeinflusst und unerwünschte Geräusche werden durch den Charakter der Wheatstone-Brücke aufgehoben.

Was ist eine Wägezelle?

Eine Wägezelle ist ein Aluminiumprofil mit einem Dehnungsmessstreifen, der an 4 Seiten in Wheatstone-Brückenkonfiguration angebracht ist.

Abbildung der Wägezelle:

Diese Art von Wägezelle ist starr und wird üblicherweise in der Industrie verwendet. Es gibt 4 Schraubenhalterungen, eine Seite ist mit einer stationären Oberfläche verschraubt und das andere Ende ist mit einem Halter (z. B. Korb) verschraubt, um das zu messende Objekt zu halten.

Das im Datenblatt oder am Körper angegebene maximale Gewicht kann die Wägezelle beschädigen, wenn die Spezifikation überschritten wird.

Eine Vollbrückenzelle besteht aus 4 Anschlüssen, nämlich E +, E-, die Erregungsdrähte sind, über die die Versorgungsspannung angelegt wird. Die anderen beiden Drähte sind S + und S-, die Signaldrähte sind, von denen die Spannung gemessen wird.

Jetzt liegen diese Spannungen im Millivoltbereich und sind nicht stark genug, damit ein Mikrocontroller sie lesen und verarbeiten kann. Wir brauchen eine Verstärkung und winzige Veränderungen sollten für den Mikrocontroller sichtbar sein. Zu diesem Zweck gibt es ein spezielles Modul namens Wägezellenverstärker. Lassen Sie uns einen Überblick darüber geben.

Wägezellenverstärker HX711:

Abbildung des Wägezellenverstärkermoduls HX711:

Der Wägezellenverstärker basiert auf dem IC HX711, einem 24-Bit-Analog-Digital-Wandler, der speziell für Gewichtsmessungen entwickelt wurde. Es hat verschiedene wählbare Verstärkungen 32, 64 und 128 und arbeitet mit 2,6 bis 5,5 V.
Dieses Breakout-Board hilft dabei, winzige Abweichungen an der Wägezelle zu erkennen. Für dieses Modul ist die Bibliothek HX711.h erforderlich

Arduino oder andere Mikrocontroller.

Die Wägezelle wird mit dem HX711-Modul verbunden und das Modul wird mit Arduino verbunden. Die Gewichtsmessschaltung muss auf diese Weise entwickelt werden.

Zusammenfassend wissen Sie jetzt, was Dehnungsmessstreifen sind, was Wheatstone-Brücke ist, Temperatureffekte auf den Dehnungsmessstreifen, Temperaturkompensation und was Wägezellenverstärker ist.

Wir haben den theoretischen Teil des Entwurfs einer Waage aus der obigen Diskussion umfassend verstanden. Nun wollen wir sehen, wie eine Loas-Zelle zur Herstellung einer praktischen Waagenmaschine unter Verwendung von Arduino verwendet werden kann

Entwerfen einer digitalen Waagenmaschine mit Arduino

In den folgenden Diskussionen erfahren Sie, wie Sie mit Arduino eine digitale Waagenmaschine konstruieren, mit der Gewichte von wenigen Gramm bis 40 kg (abhängig von den Spezifikationen Ihrer Wägezelle) mit angemessener Genauigkeit gemessen werden können. Wir werden etwas über die Klassifizierung von Präzisions-Wägezellen lernen und die vorgeschlagene Schaltung kalibrieren und die Waagenmaschine fertigstellen.

Hinweis: Diese Schaltung entspricht möglicherweise nicht den für die kommerzielle Implementierung erforderlichen Standards.

Waagenmaschinen werden in verschiedenen Branchen und Forschungsbereichen eingesetzt, die von Milligramm bis zu mehreren Tonnen reichen. Die maximale Waage der vorgeschlagenen Waage hängt von der Spezifikation Ihrer Wägezelle ab. Es gibt Bereiche von 500 Gramm, 1 kg, 5 kg, 10 kg, 20 kg und 40 kg usw.

Es gibt verschiedene Arten von Wägezellen, sie bieten unterschiedliche Genauigkeitsbereiche und Sie sollten die für Ihr Projekt geeignete auswählen.

Klassifizierung der Wägezellen-Genauigkeitsklasse:

Die verschiedenen Genauigkeitsklassen sind für verschiedene Arten von Anwendungen definiert. Die folgende Klassifizierung reicht von der niedrigsten Genauigkeit bis zum höchsten Genauigkeitsbereich.

Die Wägezellen mit geringerer Genauigkeit (aber einigermaßen genauer) werden als D1, C1 und C2 klassifiziert. Das reicht für dieses Projekt. Diese Wägezellen dienen zur Gewichtsmessung von Sand, Zement oder Wasser.

Wägezellen der Klasse C3 werden zur Qualitätssicherung eingesetzt, z. B. zur Überprüfung des Gewichts von Kugellagern, Teilen von Maschinenkonstruktionen usw.

C4, C5, C6 sind die besten in der Klasse Genauigkeit. Diese Typen von Wägezellen werden verwendet, um in Gramm bis Mikrogramm zu messen. Diese Klassenklassen werden in Ladenthekenwaagen, Produktionsüberwachung in großem Maßstab, Lebensmittelverpackung und Laboreinsatz usw. verwendet.

Kommen wir nun zu den technischen Details des Projekts.

Schaltplan:

Wägezellenverbindung HX711 zu Arduino und Wägezelle.

Das Projekt besteht aus Arduino, Wägezellen- und HX711-Wägezellenverstärkerplatine und einem Computer. Die Ausgabe kann auf dem seriellen Monitor der Arduino IDE überwacht werden.

Das Gehirn des Projekts ist wie immer das Arduino. Sie können jedes Arduino-Board-Modell verwenden. Der HX711 ist ein 24-Bit-ADC, der aufgrund des Gewichts der Wägezelle den kleinsten Flex finden kann. Es kann von 2,7 V bis 5 V betrieben werden. Die Stromversorgung erfolgt über das Arduino-Board.

Die Wägezelle hat im Allgemeinen vier Drähte. Dies ist die Ausgabe des von der Wheatstone-Brücke konfigurierten Dehnungsmessstreifens.

Der rote Draht ist E +, der schwarze Draht ist E-, der grüne Draht ist A- und der weiße Draht ist A +. Einige HX711-Module geben den Namen der Klemmen der Wägezelle an, und einige HX711-Module geben die Farben der Drähte an. Ein solches Modell ist im Schaltplan dargestellt.

Der DATA-Pin des HX711 ist mit Pin 3 von Arduino verbunden, und der Clock-Pin des HX711 ist mit Pin 2 von Arduino verbunden.

So montieren Sie die Wägezelle:

Die Wägezelle hat vier Schraubenlöcher, zwei auf beiden Seiten. Jede Seite muss stationär sein, um die bestmögliche Genauigkeit zu erzielen. Sie kann auf ein Holz mit angemessenem Gewicht aufgeschüttet werden.

Ein dünnes Holz oder eine dünne Platte kann verwendet werden, um das Messgewicht wie oben dargestellt zu halten.

Wenn Sie also ein Gewicht platzieren, biegt sich die Wägezelle ebenso wie der Dehnungsmessstreifen und ändert seinen Widerstand, der vom HX711-Modul gemessen und Arduino zugeführt wird.

Sobald das Hardware-Setup abgeschlossen ist, laden wir den Code hoch und kalibrieren.

Schaltung kalibrieren:

Es gibt zwei Programme, eines ist das Kalibrierungsprogramm (Ermitteln des Kalibrierungsfaktors). Ein weiterer Code ist das Gewichtsmessprogramm. Der aus dem Code des Kalibrierungsprogramms ermittelte Kalibrierungsfaktor muss in das Gewichtsmessprogramm eingegeben werden.

Der Kalibrierungsfaktor bestimmt die Genauigkeit der Gewichtsmessung.

Laden Sie die HX711-Bibliothek hier herunter: github.com/bogde/HX711

Kalibrierungen Programmcode:

//-------------------- --------------------//
#include
const int out = 3
const int clck = 2
HX711 scale(out, clck)
float CalibrationFactor = -96550
char var
void setup()
{
Serial.begin(9600)
Serial.println('------------- Weight Scale Calibration --------------')
Serial.println('Press Q,W,E,R or q,w,e,r to increase calibration factor by 10,100,1000,10000 respectively')
Serial.println('Press A,S,D,F or a,s,d,f to decrease calibration factor by 10,100,1000,10000 respectively')
Serial.println('Press 'T' or 't' for tare')
scale.set_scale()
scale.tare()
long zero_factor = scale.read_average()
Serial.print('Zero factor: ')
Serial.println(zero_factor)
}
void loop()
{
scale.set_scale(CalibrationFactor)
Serial.print('Reading: ')
Serial.print(scale.get_units(), 3)
Serial.println(' Kilogram')
Serial.print('Calibration Factor is: ')
Serial.println(CalibrationFactor)
Serial.println('--------------------------------------------')
if (Serial.available())
{
var = Serial.read()
if (var == 'q')
{
CalibrationFactor = CalibrationFactor + 10
}
else if (var == 'a')
{
CalibrationFactor = CalibrationFactor - 10
}
else if (var == 'w')
{
CalibrationFactor = CalibrationFactor + 100
}
else if (var == 's')
{
CalibrationFactor = CalibrationFactor - 100
}
else if (var == 'e')
{
CalibrationFactor = CalibrationFactor + 1000
}
else if (var == 'd')
{
CalibrationFactor = CalibrationFactor - 1000
}
else if (var == 'r')
{
CalibrationFactor = CalibrationFactor + 10000
}
else if (var == 'f')
{
CalibrationFactor = CalibrationFactor - 10000
}
else if (var == 'Q')
{
CalibrationFactor = CalibrationFactor + 10
}
else if (var == 'A')
{
CalibrationFactor = CalibrationFactor - 10
}
else if (var == 'W')
{
CalibrationFactor = CalibrationFactor + 100
}
else if (var == 'S')
{
CalibrationFactor = CalibrationFactor - 100
}
else if (var == 'E')
{
CalibrationFactor = CalibrationFactor + 1000
}
else if (var == 'D')
{
CalibrationFactor = CalibrationFactor - 1000
}
else if (var == 'R')
{
CalibrationFactor = CalibrationFactor + 10000
}
else if (var == 'F')
{
CalibrationFactor = CalibrationFactor - 10000
}
else if (var == 't')
{
scale.tare()
}
else if (var == 'T')
{
scale.tare()
}
}
}
//-------------------- --------------------//

So kalibrieren Sie:

• Laden Sie nach Abschluss des Hardware-Setups den obigen Code hoch.
• Entfernen Sie die dünne Platte oder das Holz, mit dem das Gewicht gehalten wird, einschließlich der beiden Schrauben (die andere Seite der Wägezelle sollte an einer Basis befestigt sein).
• Öffnen Sie den seriellen Monitor.
• Legen Sie ein bekanntes Gewicht direkt auf die Wägezelle, 100 Gramm (sagen wir).
• Drücken Sie Q, W, E, R. um den Kalibrierungsfaktor um 10.100.1000.10000 zu erhöhen.
• Drücken Sie A, S, D, F. Kalibrierungsfaktor um 10.100.1000.10000 zu verringern.
• Drücken Sie nach jedem Inkrementieren oder Dekrementieren des Kalibrierungsfaktors die Eingabetaste.
• Erhöhen oder verringern Sie den Kalibrierungsfaktor, bis das richtige Gewicht des Materials mit bekanntem Gewicht angezeigt wird.
• Die Tara-Funktion besteht darin, die Gewichtsskala auf Null zu setzen. Dies ist nützlich, wenn Sie das Gewicht von Wasser (z. B.) ohne das Gewicht der Schüssel messen möchten. Stellen Sie die Schüssel zuerst auf, drücken Sie die Tara und gießen Sie das Wasser ein.
• Notieren Sie den Kalibrierungsfaktor und notieren Sie ihn, nachdem das bekannte Gewicht angezeigt wird.

Jetzt kann es unbekannte Gewichte messen.

Code des Gewichtsmessprogramms:

//---------------- ----------------//
#include
const int out = 3
const int clck = 2
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
void setup()
{
Serial.begin(9600)
Serial.println('Press 'T' or 't' to tare')
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
Serial.print('Weight: ')
Serial.print(scale.get_units(), 3)
Serial.println(' Kilogram')
if (Serial.available())
{
char var = Serial.read()
if (var == 't')
{
scale.tare()
}
if (var == 'T')
{
scale.tare()
}
}
}
//---------------- ----------------//

float CalibrationFactor = -12000

Ersetzen Sie -12000 durch den gefundenen Kalibrierungsfaktor. Es kann eine negative oder eine positive Zahl sein.

Laden Sie den obigen Code mit Ihrem vollständigen Hardware-Setup hoch und Ihre Waagenmaschine ist bereit.

Waage mit LCD-Display

Im obigen Artikel wurde ein Arduino-basiertes Waagensystem mit Ihrem PC erläutert. Im folgenden Abschnitt werden wir versuchen, eine praktische Version der Waagenmaschine durch Hinzufügen eines 16 x 2-LCD-Displays zu erstellen, damit wir beim Messen nicht von einem PC abhängig sind Gewichte. In diesem Beitrag werden zwei Versionen vorgeschlagen, eine mit 16 x 2-LCD „I2C“ und eine ohne 16 x 2-LCD-Display „I2C“.

Hier werden zwei Auswahlmöglichkeiten angegeben, damit die Leser das Design nach ihren Wünschen auswählen können. Der Hauptunterschied zwischen beiden besteht in der Kabelverbindung mit dem I2C-Adaptermodul. Für die Funktion des LCD-Displays sind nur 4 Drähte (Vcc, GND, SCL und SDA) erforderlich. Ohne I2C-Adapter benötigen Sie mehrere Drähte, um die Verbindung zwischen dem Arduino- und dem LCD-Display herzustellen.

Beide Funktionen sind jedoch genau gleich. Einige bevorzugen I2C gegenüber herkömmlichen Funktionen und andere bevorzugen umgekehrt. Hier sind also beide Designs.

Schauen wir uns das herkömmliche LCD-Design an:

Schaltplan:

Im obigen Schema haben wir das Arduino, ein 16 x 2 LCD-Display und ein 10K-Potentiometer zum Einstellen des LCD-Display-Kontrasts.

Zur Hintergrundbeleuchtung können 3,3 V von Arduino auf das LCD-Display eingespeist werden. Ein Druckknopf bringt den Gewichtswert auf Null. Diese Funktion wird am Ende ausführlich erläutert.

Dies ist nur eine Verbindung zwischen LCD und Arduino. Die Verbindung zwischen Wägezelle und Wägezellenverstärker zu Arduino ist im vorherigen Abschnitt dargestellt.

Code für LCD-Waage:

// -------- Program developed by R.GIRISH -------//
#include
#include
const int rs = 10
const int en = 9
const int d4 = 8
const int d5 = 7
const int d6 = 6
const int d7 = 5
LiquidCrystal lcd(rs, en, d4, d5, d6, d7)
const int out = 3
const int clck = 2
const int Tare = 4
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
void setup()
{
lcd.begin(16, 2)
pinMode(Tare, INPUT)
digitalWrite(Tare, HIGH)
lcd.setCursor(0, 0)
lcd.print(' Weight Scale')
lcd.setCursor(0, 1)
lcd.print(' Machine')
delay(2000)
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Weight:')
lcd.print(scale.get_units(), 3)
lcd.print(' Kg')
delay(200)
if (digitalRead(Tare) == LOW)
{
scale.tare()
lcd.clear()
lcd.setCursor(0, 0)
lcd.print('Tare ......')
lcd.setCursor(0, 1)
lcd.print('Setting to 0 Kg.')
delay(1000)
}
}
// -------- Program developed by R.GIRISH -------//

Lassen Sie uns nun sehen, wie Sie diese Waage mit I2C-Adapter-basiertem LCD-Display verwenden.

Schaltplan Arduino- und LCD-Display mit I2C-Adapter:

Hier haben wir nur ein Arduino- und LCD-Display mit I2C-Adapter auf der Rückseite. Jetzt sind die Kabelverbindungen vereinfacht und unkompliziert.

Abbildung des I2C-Moduls:

Dieses Modul kann direkt auf die Rückseite eines normalen 16 x 2 oder sogar 20 x 4 LCD-Displays gelötet werden und folgt dem schematischen Diagramm.

Weitere Informationen zum Anschluss von Wägezelle, Wägezellenverstärker und Arduino finden Sie im vorherigen Abschnitt.

Laden Sie die folgende Bibliothek für I2C herunter:

github.com/marcoschwartz/LiquidCrystal_I2C

github.com/PaulStoffregen/Wire

Code für I2C-basierte Gewichtswaage:

// -------- Program developed by R.GIRISH -------//
#include
#include
#include
const int out = 3
const int clck = 2
const int Tare = 4
HX711 scale(out, clck)
float CalibrationFactor = -12000 // Replace -12000 the calibration factor.
LiquidCrystal_I2C lcd(0x27, 16, 2)
void setup()
{
lcd.init()
lcd.backlight()
pinMode(Tare, INPUT)
digitalWrite(Tare, HIGH)
lcd.setCursor(0,0)
lcd.print(' Weight Scale')
lcd.setCursor(0,1)
lcd.print(' Machine')
delay(2000)
scale.set_scale(CalibrationFactor)
scale.tare()
}
void loop()
{
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Weight:')
lcd.print(scale.get_units(), 3)
lcd.print(' Kg')
delay(200)
if (digitalRead(Tare) == LOW)
{
scale.tare()
lcd.clear()
lcd.setCursor(0,0)
lcd.print('Tare ......')
lcd.setCursor(0,1)
lcd.print('Setting to 0 Kg.')
delay(1000)
}
}
// -------- Program developed by R.GIRISH -------//

HINWEIS:

Sie sollten den Kalibrierungsfaktor in den Code eingeben, bevor Sie einen der Codes auf Arduino hochladen.

float CalibrationFactor = -12000

Das Erhalten des Kalibrierungsfaktors wird in einem der vorherigen Abschnitte oben erläutert.

Tara-Funktion:

Die Tara-Funktion in einer Waage besteht darin, die Messwerte auf Null zu bringen. Wenn wir beispielsweise einen Warenkorb haben, in den die Waren geladen werden, ist das Nettogewicht das Gewicht des Warenkorbs + das Gewicht der Waren.

Wenn wir vor dem Laden der Waren die Tara-Taste mit dem Korb auf der Wägezelle drücken, wird das Gewicht des Korbs vernachlässigt und wir können das Gewicht der Waren allein messen.

Wenn Sie Fragen zu dieser auf Arduino basierenden praktischen LCD-Waage haben, geben Sie diese bitte im Kommentarbereich an. Möglicherweise erhalten Sie eine schnelle Antwort.