Arduino Datenlogger mit Stockwaage für Imker

http://www.layadcircuits.com/tutorial.php?p=4


Liebe Bienenhalter,
stetig wächst das Interesse, über den Zustand unserer Bienenvölker und deren Ertrag, überall und umfassend informiert zu sein.
Der Handel zieht hier natürlich nach und so kann man leicht dreistellige Beträge für vernetzte Stockwaagen mit Temperatursensoren und einer Vielzahl weiterer elektronischer Helfer ausgeben.
Es ist aber auch mit kleinem Geldbeutel und entsprechendem Engagement möglich, einen Datenlogger mit Stockwaage, Bienenzähler, Temperatursensoren, Luftfeuchtesensoren, Luxmeter und einem Schwarmalarm zu realisieren und die Daten beispielsweise über das Internet zu speichern und grafisch darzustellen.
Die Seite beelogger.de bietet Euch Schritt für Schritt Anleitungen für Euren Arduino Datenlogger mit ausführlichen Programmierbeispielen bis hin zum fertigen Komplettsystem, Einkaufstipps, Bezugsquellen, Preisen, Schaltplänen, Platinen und vieles mehr.
Für den einfachen und schnellen Aufbau wurde speziell für dieses Projekt die Platine ‘beelogger-EasyPlug’ von uns entwickelt, um Sensoren und Module ohne zusätzliche Leitungen und passend zum Programmcode auf einer Platine miteinander zu verbinden.
Zusätzlich steht unser solar- und akkubetriebenes System ‘beelogger-Solar‘ als Platine mit ausführlichen Anleitungen zum Nachbau zur Verfügung.
Besonders energieeffiziente Bauteile und eine intelligente Schaltung ermöglichen einen unkomplizierten und kostengünstigen Betrieb unabhängig vom Stromnetz.
Als Erweiterung kann das solarbetriebene System mit einem GSM-Modul zur Datenübertragung über das Mobilfunknetz ausgestattet werden.
Sogar eine Android-App für eine schnelle Kontrolle steht kostenlos zum Download bereit.

Viel Spaß und Erfolg wünschen
Thorsten & Raimund

Programmcodes

Schaltungen

Platinen

Android-App

• 
  
• 
  
• 
  

Quelle:
https://beelogger.de/

Stockwaage (Bosche H30A & HX711)

YZC-161E 50kg menschliche Körper Skala Wägesensor

Wägezelle Generic YZC-161E 50kg Body Scale Sensor Human Scale Load Cell Weighing Sensor (Pack of 4)

BQLZR Aluminium Legierung YZC-161E 50kg

Körperwaage - Wiegen Sensor 

Wägezelle
Lotoclub 50KG 110lb Single Point Aluminium Weighing Load Cell Sensor Pressure Transducer For Industry And Machinery… $22.99
Viele Wochen ausführlicher Tests haben allerdings gezeigt, dass die Abweichungen dieser Elemente (im Testzeitraum mit fixem Gewicht  über +/- 400 g) zu hoch sind und auch Strategien der Kompensation nicht greifen.
Deshalb haben wir uns für den Arduino Datenlogger für eine Bosche-Wägezelle H30A entschieden, da wir selbst seit Mitte 2014 gute Erfahrungen im Dauereinsatz hiermit sammeln konnten.
Zur Auswertung der Wägezelle wird der 24bit A/D-Wandler  HX711 verwendet, welcher speziell für Wägezellen mit Wheatstone-Brücke konzipiert wurde.

Er bietet eine einstellbare Verstärkung und integrierte Stromversorgung für die Wägezelle.
Bezug:
Eine Bosche-Wägezelle kann direkt über den Shop von Bosche bezogen werden.
Optimal für eine Stockwaage geeignet, scheint die BOSCH Wägezelle  H30A  mit einer Nennlast von 150 kg zu sein:
Nennlast 150 kg
Schutzklasse IP65
Kompensierte Eckenlastfehler
Für Dauereinsatz geeignet

Platinen mit HX711 Chip
werden mit unterschiedlichen Layouts angeboten. Im Referenzdesign, welches vom Hersteller des Chips empfohlenen wird, ist E- bzw. BLK mit GND verbunden.
Leider weichen einige der erhältlichen Boards hiervon ab.
Eine interessante Diskussion hierzu ist unter http://www.mikrocontroller.net/topic/326445 zu finden.
Plantinen ohne diese Verschaltung neigen generell zu einer größeren Tolleranz der Messwerte, haben eine höhere Temperaturempfindlichkeit und und weisen größere Abweichungen auch über längere Zeit auf, wenn das Board zuvor stromlos bzw. im Power-Down-Modus gewesen ist.
Eine generelle Aussage über die Verschaltung des Boards kann optisch nicht getroffen werden.
Man kann sich jedoch am Aufbau der Platine orientieren, um mit relativ hoher Wahrscheinlichkeit ein korrekt beschaltetes Board zu erwerben.
Weitere Informationen sind unter Kalibrierung und Test zu finden.

HX711      24-bit A/D-Wandler für DMS

HX711 Modul Wiegen Sensor Drucksensor 24bit AD-Modul

Der HX711 Wägezellenverstärker wurde dafür gebaut, die Wiederstandsänderungen einer Messbrücke zu messen und in eine Spannung umzuwandeln.

Das HX711-Modul kommuniziert mit dem Mikrocontrollerboard über TTL 232.

• Eingangsspannungsbereich: 40mV
• Auflösung: 24 bit (24 bit A / D Wandler)
• Aktualisierungsfrequenz: 80 Hz
• Versorgungsspannung: 5V DC
• Stromaufnahme: <10 mA
• Größe: 38mm*21mm*10mm

HX711 - Wägezellenverstärker

 Mit hoher Wahrscheinlichkeit korrekt beschaltetes Board

Stockwaage – Beschaltung & Aufbau

Beschaltung

Um die Stockwaage korrekt zu beschalten, muss zunächst der Arduino mit dem HX711 verbunden werden. 

Die Leitungen der Bosche Wägezelle sind farblich markiert. Die Verbindung mit dem HX711 ist wie folgt vorzunehmen.

Die Abschirmung der Wägezelle ist mit GND zu verbinden.

Aufbau
Zum Aufbau der Wägekonstruktion wird eine Plattform als Träger der Beute benötigt, die auf das Wägeelement geschraubt wird.
Die Plattform sollte für einen sicheren Aufbau so groß wie die Grundfläche der Beute sein, darf jedoch die Maße 500x600mm für Wägeelemente mit einer Nennlast von 100 bis 300 kg nicht überschreiten.
Bei der Montage ist darauf zu achten, dass das Wägeelement mittig unter der Plattform montiert ist.

Um eine gewisse Auslenkung zu gewährleisten, ist zusätzlich ein Distanzstück zwischen Plattform und Wägeelement in Größe der Montagefläche zu verwenden.
Als ‘Standfuss’ wird eine weitere Platte benötigt.
Diese wird entsprechend der oberen Plattform an der unteren Montagefläche des Wägeelementes befestigt.
Gut verfügbar und einfach zu bearbeiten ist Holz, welches mit entsprechender Beschichtung (Siebdruckplatte), Lackierung (ungiftig!) oder einer dicken Folie vor dem Wetter geschützt wird.
Auch ein Überstand bietet Schutz gegen direkte Witterunseinflüsse und hat den weiteren Vorteil, dass Messwerte, beispielsweise durch eine Schneedecke, nicht verfälscht werden.

Für das beelogger-Referenzsystem haben wir uns für eine ‘H-Konstruktion’ entschieden.

Nach dem Aufbau kann mit der Kalibrierung und dem Test der Stockwaage begonnen werden.

Stockwaage – Kalibrierung & Test

Prüfung und Modifikation HX711

Libraries   <HX711.h> – https://github.com/bogde/HX711

Kalibrierung-Programmcode
Vor der Kalibrierung sollte die Wägekonstruktion mehrmals stark belastet und wieder entlastet werden (z.B. kurz auf die Wägeplattform stellen), damit sich die gesamte Konstruktion setzen kann.
Bei vielen Wägeelementen gibt es eine gewisse Trägheit bei hohen Gewichtsdifferenzen in kurzer Zeit. In der Praxis kommen diese nicht vor, weshalb hierdurch keine Fehlmessungen entstehen.
In diesem Fall sollte allerdings eine ausreichende Zeit gewartet werden, bevor mit der Kalibrierung begonnen wird.
Im Praxistest konnte zudem festgestellt werden, dass die gemessenen Werte kurz nach Inbetriebnahme von denen im Dauerbetrieb abweichen.
Der Programmcode zur Kalibrierung ist interaktiv und erfordert manuelle Eingabe über den seriellen Monitor, welcher schließlich auch die erforderlichen Werte ausgibt:

1. “Waage ohne Gewicht – Kalibrierung mit ‘1’ und ‘Enter’ starten!” – Hiermit wird das Taragewicht ermittelt. Soll die Beute selbst bei den Messungen keine Berücksichtigung finden, muss diese vor diesem Schritt auf der Wägekonstruktion platziert werden.
2. “Waage mit genau 1 Kg beschweren – Kalibrierung mit ‘2’ und ‘Enter’ starten!” – Mit diesem Schritt wird die Skalierung ermittelt. Als Gewicht eignet sich beispielsweise eine Wasserflasche, die zuvor mit einer Referenzwaage (z.B. Küchenwaage) auf genau 1Kg gewogen wurde.
3. “Pruefe Gewicht:” – Hiermit wird geprüft, ob die Kalibrierung erfolgreich war. Der angezeigte Wert ist das Gewicht des eingewogenen Referenzgewichtes und sollte ca. 1000 Gramm entsprechen. Sollte dies nicht der Fall sein, muss die Prozedur erneut, durch einen Reset des Arduinos, durchgeführt werden.
4. Zum Schluß werden Taragewicht und Skalierung ausgegeben. Diese Werte sind im Test-Programmcode bzw. dem kompletten Programmcode entsprechend einzusetzen.

Programmcode downloaden 

Test-Programmcode
In diesem Test-Programmcode sind die über den Kalibrierung-Programmcode ermittelten Werte für Taragewicht und Skalierung einzugeben.
Um Messfehler oder kurzzeitige Gewichtsabweichungen durch externe Einflüsse abzufangen, wird bei jeder Messung das letzte ermittelte Gewicht mit dem aktuellen Messwert verglichen.
Ist die Differenz größer als 500g, wird die Messung wiederholt.

Im Test-Programmcode sind bis zu 2 Wiederholungen mit einer Wartezeit von 3 Sekunden zwischen den Messungen festgelegt.
Werden die Sensorwerte später an einen Webserver übertragen, wird das Skript zum Speichern der Datensätze, den Messwert auch mit einer entsprechend großen Abweichung speichern.
Damit gehen keine Messwerte verloren, auch wenn beispielsweise ein heruntergefallener Ast längere Zeit auf der Beute liegt.

Sketch

Programmcode downloaden

Stockwaage – Temperaturkompensation

Absolutwert der Differenz von Referenzgewicht und aktuellem Gewicht

——————————————————————————————–

Absolutwert der Differenz von Temperatur zum Zeitpunkt der Kalibrierung (Kalibriertemperatur) und aktueller Temperatur

Aus den auf diese Weise berechneten Korrekturwerten wird nach Entfernung möglicher Ausreißer der Median (kein Durchschnitt) ermittelt.
Das Ergebnis wird als Wert der Variable ‘KorrekturwertGrammproGrad’ zusammen mit der ‘Kalibriertemperatur’ in der Konfiguration des Programmcodes eingetragen.
Alternativ zu dieser Methode kann der Korrekturwert auch grafisch über die Webserverskripte ermittelt werden.
Hierzu müssen lediglich in der Datei ‘beelogger_log-php’ ein paar Zeilen ergänzt werden und der jeweilige Korrekturwert des aktuellen Datenpaares wird parallel, beispielsweise anstatt ‘Bienen In-Out’, eingetragen.

Vor dem Code zum Speichern der Messwerte

werden hierzu folgende Zeilen in der Datei ‘beelogger_log-php’ mit eigenen Werten für ‘Kalibriertemperatur’ und ‘Referenzgewicht’ eingefügt:

HX711 (24 bit Analog to Digital Converter)

HX711 (24 bit Analog to Digital Converter)

HX 711 is a precision 24-bit analog to digital converter (ADC) specially designed for Weigh scales and industrial control applications to interface directly with a bridge sensor.

https://www.sparkfun.com/products/13230

http://www.theorycircuit.com/interfacing-load-cell-arduino-using-hx711/

#include "HX711.h"// HX711 circuit wiringconst int LOADCELL_DOUT_PIN = 2;const int LOADCELL_SCK_PIN = 3;HX711 scale;void setup() {  Serial.begin(57600);  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);}void loop() {  if (scale.is_ready()) {long reading = scale.read();Serial.print("HX711 reading: ");Serial.println(reading);  } else {Serial.println("HX711 not found.");  }  delay(1000);


https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide/all
https://arduino.stackexchange.com/questions/71548/hx711-inconsistent-readings

Arduino Example

/* Example using the SparkFun HX711 breakout board with a scale By: Nathan Seidle SparkFun Electronics Date: November 19th, 2014 License: This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license). This is the calibration sketch. Use it to determine the calibration_factor that the main example uses. It also outputs the zero_factor useful for projects that have a permanent mass on the scale in between power cycles. Setup your scale and start the sketch WITHOUT a weight on the scale Once readings are displayed place the weight on the scale Press +/- or a/z to adjust the calibration_factor until the output readings match the known weight Use this calibration_factor on the example sketch This example assumes pounds (lbs). If you prefer kilograms, change the Serial.print(" lbs"); line to kg. The calibration factor will be significantly different but it will be linearly related to lbs (1 lbs = 0.453592 kg). Your calibration factor may be very positive or very negative. It all depends on the setup of your scale system and the direction the sensors deflect from zero state This example code uses bogde's excellent library: https://github.com/bogde/HX711 bogde's library is released under a GNU GENERAL PUBLIC LICENSE Arduino pin 2 -> HX711 CLK 3 -> DOUT 5V -> VCC GND -> GND Most any pin on the Arduino Uno will be compatible with DOUT/CLK. The HX711 board can be powered from 2.7V to 5V so the Arduino 5V power should be fine.*/#include "HX711.h"#define DOUT  3#define CLK  2HX711 scale;float calibration_factor = -7050; //-7050 worked for my 440lb max scale setupvoid setup() {  Serial.begin(9600);  Serial.println("HX711 calibration sketch");  Serial.println("Remove all weight from scale");  Serial.println("After readings begin, place known weight on scale");  Serial.println("Press + or a to increase calibration factor");  Serial.println("Press - or z to decrease calibration factor");  scale.begin(DOUT, CLK);  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);}void loop() {  scale.set_scale(calibration_factor); //Adjust to this calibration factor  Serial.print("Reading: ");  Serial.print(scale.get_units(), 1);  Serial.print(" lbs"); //Change this to kg and re-adjust the calibration factor if you follow SI units like a sane person  Serial.print(" calibration_factor: ");  Serial.print(calibration_factor);  Serial.println();  if(Serial.available())  {    char temp = Serial.read();    if(temp == '+' || temp == 'a')      calibration_factor += 10;    else if(temp == '-' || temp == 'z')      calibration_factor -= 10;  }}

https://www.robotshop.com/community/forum/t/hx711-and-a-single-strain-gauge/48600

/*
 * Hauptsketch - Wiegesketch
*/
 



#include <LiquidCrystal_I2C.h>
//#include <Wire.h>  
#include <HX711.h> //eventuell fehlt hier das entsprechende Library

LiquidCrystal_I2C lcd(0x27,20,4);  // set the LCD address to 0x27 for a 16 chars and 2 line display
HX711 scale1(4, 5);
HX711 scale2(6, 7);

long TaragewichtA = 62963; // Hier ist der Wert aus der Kalibrierung für Waage F1 einzutragen 
float SkalierungA = 394.45; // Hier ist der Wert aus der Kalibrierung für Waage F1 einzutragen 
 
long TaragewichtB = -50213; // Hier ist der Wert aus der Kalibrierung für Waage F2 einzutragen 
float SkalierungB = 391.35; // Hier ist der Wert aus der Kalibrierung für Waage F2 einzutragen
 
long GewichtA = 999999;
long GewichtB = 999999;  

                  
 
 
void setup() { 

  
  Serial.begin(9600); 
    
  lcd.init();
  lcd.init();
  lcd.backlight();
  
  int a= (GewichtA);
  int b= (GewichtB);
  int c = a + b;
  int d = 250;//das ist die Entfernung der beiden Auflagepunkte-eventuell ändern
  int cog = ((GewichtB)*(250))/(c);//wenn "d" abgeändert wurde, dann muss der Wert (250) ebenfalls geändert werden!
}
 
 
void loop() {
 

  scale1.set_gain(128); 
  scale1.set_offset(TaragewichtA);  
  scale1.set_scale(SkalierungA); 
  GewichtA= scale1.get_units(10); 
 
  scale2.set_gain(128); 
  scale2.set_offset(TaragewichtB);  
  scale2.set_scale(SkalierungB); 
  GewichtB= scale2.get_units(10); 
 
  Serial.print("Waage F1=  ");
  Serial.print(GewichtA);
  Serial.print("g  ");
 
  Serial.print("Waage F2=  ");
  Serial.print(GewichtB);
  Serial.print("g  ");

  Serial.println("D=250 mm");//diese Zeile kann man auch weglassen
  
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Waage F1 = ");
  if (GewichtA<10) {(GewichtA)=0;}
  lcd.print(GewichtA);
  lcd.print(" g");
  
  lcd.setCursor(0,1);
  lcd.print("Waage F2 = ");
  if (GewichtB<10) {(GewichtB)=0;}
  lcd.print(GewichtB);
  lcd.print(" g");
  
  lcd.setCursor(0,2);
  //lcd.print("D = 250 mm");

 

  int c =  (GewichtA) + (GewichtB);
  Serial.print("Gesamtgewicht  ");
  Serial.print(c);
  Serial.print("g  ");

  int cog = ((GewichtB)*(250))/(c);
  Serial.print("CoG = ");
  if (GewichtB<10) {(cog)=125;}
  Serial.print(cog);
  Serial.print("mm  ");
  
  lcd.setCursor(0,2);
  lcd.print("Gesamtgewicht= ");
  lcd.print(c);
  lcd.print(" g");

  //delay(3000);
  
  
  lcd.setCursor(0,3);
  lcd.print("CoG = ");
  lcd.print(cog);
  lcd.print(" mm");
 
 
  
  delay(3000);
} [7code]

 hauptsketch.doc
30 KB
downloaded 23 times

 kalibrierungssketch.doc
27.5 KB
downloaded 19 times

#include "HX711.h"HX711 loadcell;// 1. HX711 circuit wiringconst int LOADCELL_DOUT_PIN = 2;const int LOADCELL_SCK_PIN = 3;// 2. Adjustment settingsconst long LOADCELL_OFFSET = 50682624;const long LOADCELL_DIVIDER = 5895655;// 3. Initialize libraryloadcell.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);loadcell.set_scale(LOADCELL_DIVIDER);loadcell.set_offset(LOADCELL_OFFSET);// 4. Acquire readingSerial.print("Weight: ");Serial.println(loadcell.get_units(10), 2);

// 4. Acquire reading without blockingif (loadcell.wait_ready_timeout(1000)) {    long reading = loadcell.get_units(10);    Serial.print("Weight: ");    Serial.println(reading, 2);} else {    Serial.println("HX711 not found.");}

Software für den Arduino

Das Kalibrierungs-Programm

1. Das Programm gibt den Text "Waage ohne Gewicht – Kalibrierung mit '1' und 'Enter' starten!"aus.
   
2. Nach der Eingabe wird der aktuelle Messwert der Brücke (= Taragewicht) ermittelt.
3. Nun folgt die Ausgabe "Waage mit genau 1 kg belasten – Kalibrierung mit '2' und 'Enter' starten!"
   
4. Anhand der Gewichtszunahme wird die Skalierung ermittelt. Das Referenzgewicht von 1 kg kann man mit einer Küchenwaage etc. ermitteln.
   
5. Wichtig ist, dass es wirklich genau1 kg sind, sonst sind später alle Messwerte falsch.
6. Es erfolgt die Ausgabe "Kalibriere" und danach "Pruefe Gewicht:"
   
7. Bei erfolgreicher Kalibrierungsollte der angezeigte Wert fast genau 1000 Gramm betragen.
   
8. Sollte dies nicht der Fall sein, muss die Kalibrierung wiederholt werden.
9. Abschließend werden Taragewicht und Skalierung ausgegeben. Diese Werte sind im Programmcodeder Messprogramms zu hinterlegen.

Das Messprogramm

Das Messprogramm kann bis zu acht Waagen abfragen.
Die ermittelten Gewichtsdaten werden über die serielle Schnittstelle ausgegeben.
Beim Testen kann die Daten mit dem seriellen Monitor der Arduino-IDE ansehen.
Im Betrieb ist der USB-Anschluss des Arduino mit dem USB-Anschluss eines Raspberry Pi verbunden (oder dem USB-Anschluss eines beliebigen Linux-PCs).
Über die USB-Verbindung werden der Arduino und die HX711-Bausteine auch mit Energie versorgt, wobei jeder HX711 gerade mal ca. 1,5 mA Strom benötigt.
Das Messprogramm ist für die Arduino-Modelle "Uno" und "Nano" sowie für ein Arduino-kompatibles Board "Pro Mini 5V/16MHz" konzipiert.
Die Unterscheidung wird über eine Konstante BOARD getroffen, die für "Uno" und "Nano" den Wert 1 besitzt und für "Pro Mini 5V/16MHz" den Wert 2.
Prinzipiell ist eine Erweiterung auf andere Boards der Arduino-Familie möglich.
Für den Anschluss der acht Waagen ergibt sich dann die folgende Pin-Zuordnung der HX711-Bausteine zum Arduino UNO/NANO.
Im Programm ist alternativ noch die Zuordnung für ein Clone-Board "Pro Mini 5V/16MHz" vorgesehen.


Es werden zuerst die Digital-Ports D2, D3 usw. genommen und dann die Analog-Ports A0, A1 usw., die als Digital-Ports eingesetzt werden.


Die Digital-Ports 12 und 13 sind ausgespart wg. der am Port 13 angeschlossenen On-Board-LED.

................................usw. usw. usw.

http://www.netzmafia.de/skripten/hardware/Arduino/Waage/index.html

Links

• Kalibrierprogramm
• Messprogramm
• HX711-Bibliothek für den Arduino
• Sparkfun: Beispielprogramme zum HX711
• Sparkfun: Breakout-Board
• Sparkfun: Grundlagen-Tutorial
• Sparkfun: Anschluss Wägezelle
• Datenbaltt HX711
• Bosche Wägetechnik Plattform-Wägezellen

Links HX711 Arduino Library:

/* * (C) 2015 Thorsten Gurzan - beelogger.de * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * beelogger.de - Arduino Datenlogger fuer Imker * Erlaeuterungen dieses Programmcodes unter http://beelogger.de*/// Kalibrierung auf Kanal 0#include <HX711.h>HX711 scale(2, 3);char c;long Tara;float Scale;void setup()  {  Serial.begin(9600);  delay(5000);  Serial.println(F("Zur Kalibrierung der Stockwaage bitte den Anweisungen folgen!"));  Serial.println();  Serial.println(F("Waage ohne Gewicht - Kalibrierung mit '1' und 'Enter' starten!"));  Serial.println();  while (c != '1') {c = Serial.read();};  c = 'x';  Serial.println(F("Kalibriere ... "));  Serial.println();  scale.set_scale();  scale.read_average(10);  Tara = scale.read_average(10);  Serial.println(F("Waage mit genau 1 kg belasten - Kalibrierung mit '2' und 'Enter' starten!"));  Serial.println();  while (c != '2') {c = Serial.read();};  Serial.println(F("Kalibriere ... "));  Serial.println();  scale.set_offset(Tara);  scale.get_units(10);  Scale = ((scale.get_units(10)) / 1000);  scale.set_scale(Scale);  Serial.print(F("Pruefe Gewicht: "));  Serial.println(scale.get_units(10), 1);  Serial.println();  Serial.print(F("Taragewicht: "));  Serial.println(Tara);  Serial.println();  Serial.print(F("Skalierung: "));  Serial.println(Scale);  Serial.println();  }void loop()  {}

Plattform Wägezellen von BOSCHE Wägetechnik