Waage mit DMS

http://sites.prenninger.com/arduino-uno-r3/waage-mit-dms

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2017-02-08

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-waage.mit.dms (xx Seiten)_1a.pdf fehlt



Untergeordnete Seiten (1): HX711 A-D-Wandler



HX711 AD Converter Breakout Module & 5kg Portable Elecztronic Kitchen Scalev

Digitaler Wägezellen-Gewichtssensor HX711 AD Wandler Breakout Modul

Tragbare elektronische Küchenwaage 5kg mit HX711 Arduino

und Biegebalken HT SENSOR  TAL220B

Das HX711-Modul verwendet einen 24-bit A/D-Wandler-Chip HX711.
Speziell für die hochpräzise elektronische Waage Desigt, mit 2 analogen Eingangskanal entwickelt die interne Integration von 128-fachen des programmierbaren Gain-Verstärker.
WÄGEZELLE - Stabile Konstruktion aus Aluminiumlegierung mit Dehnungsmeßstreifen, die mit zugentlasteten Drähten vormontiert sind.
Wiegebereich von 0,01 bis 5kg.
Aktiv rauscharmer PGA auf dem Chip mit einstellbarer Verstärkung von 32, 64 und 128-fach.
HX711 ist auf Breakout-Board montiert, enthält abbrechbare Header für den Anschluss, Löten erforderlich
On-Chip-Spannungsregler für analoge Wägezellen- und ADC-Stromversorgung,
On-Chip-Oszillator, der keine externe Komponente benötigt, optional mit externem Quarz.
Einfache digitale Steuerung und serielle Schnittstelle:
Pin-gesteuerte Steuerungen, keine Programmierung des ICs erforderlich, wählbare 10SPS- oder 80SPS-Ausgangsdatenrate.



Produktbeschreibungen

HX711 AD+elektronische Küchenwaage 5kg
Eigenschaften:
2 wählbare differentielle Eingangskanäle.
Aktiv rauscharmer PGA auf dem Chip mit einstellbarer Verstärkung von 32, 64 und 128-fach.
On-Chip-Spannungsregler für analoge Wägezellen- und ADC-Stromversorgung.
On-Chip-Oszillator, der keine externe Komponente mit optionalem externem Quarz benötigt.
On-Chip Power-On-Reset.
Einfache digitale Steuerung und serielle Schnittstelle:
Pin-gesteuerte Steuerungen, keine Programmierung erforderlich.
Wählbare 10SPS oder 80SPS Ausgangsdatenrate.
Gleichzeitige 50Hz und 60Hz Versorgungsunterdrückung.
Stromaufnahme mit integriertem Analogstromregler:
normaler Betrieb  Strom 1,5 mA nach Abschaltung Abschaltung 1uA.
Betriebsversorgungsspannungsbereich: 3,3V bis 5,0V.
Betriebstemperaturbereich: -20 °C  bis +85 °C

Parameter:

Durchmesser: 10cm
Betriebsspannung: 3,3V bis 5,0V (empfohlen 5V)
Max. Gewicht: 5kg
Aussehen Höhe: 3,5 cm (einschließlich Säule)
AD-Modul: HX711 (24-bit-Hochpräzisions-A/D-Wandler-Chip HX711)
Genauigkeit nach der Kalibrierung: innerhalb 1g
Betriebsstrom:  Normalbetrieb 1,5 mA

Verbindung:
Rot          zu   E +
Schwarz  zu   E-
Grün        zu   A +  (auch gelb möglich)
Weiß       zu   A-

Hinweis:
Achten Sie darauf, nicht direkt auf die weiße Abdeckung zu drücken, um Schäden am Sensor zu vermeiden.

https://www.amazon.de/Digitaler-Wägezellen-Gewichtssensor-elektronische-Küchenwaage-Arduino-Skala-HX711-AD-5KG/dp/...


ILS = I Love Shopping

Nuovo - ILS - HX711 24bit AD Module https://www.sparkfun.com/products/13879
+
1kg Aluminium Alloy Scale Weighing Sens or Load Cell Kit for Arduino
1 kg Aluminiumbalken-Waage oder 1kg Wägezelle Kit für Arduino vorh.


Länge:       ca. 80 mm
Breite:       ca. 13 mm, an der Stelle mit der Vergussmasse ca. 15 mm
Höhe:        ca. 13 mm, an der Stelle mit der Vergussmasse ca. 16 mm
Gewicht:    ca 50g

Ich wurde heute auf folgendes Fehlverhalten des HX711 Modul aufmerksam gemacht:
Das hier
http://www.4bees.at/wiki?p_p_id=1_WAR_wikinavigationportlet_INSTANCE_lRouUBtgM7oK&p_p_lifecycle=0&p_p_state=normal&p_p_mode=view&p_p_col_id=column-1&p_p_col_count=2&p_r_p_185834411_nodeId=2096367&p_r_p_185834411_title=HX711+-+W%C3%A4gezellenverst%C3%A4rker

Modul mit dem HX711 weist bei vielen Herstellern einen Designfehler auf.
Der GND-Pin von der Versorgungsseite ist nicht mit der Ausgangsseite (AGND) verbunden.
Das führt zu einer ungenauen Regelung von AVDD.
Damit oft zu unstabilen Messwerten.
Bei höheren Last durch die Wägezelle auch zu einer Temperaturempfindlichkeit der Messanordnung.
Ursache:
Der Strom der Wägezelle nimmt einen unkontrollierten Weg durch den HX711.
Festzustellen ist der Fehler durch Messen von E+ gegen GND.
Bei 5 Volt Eingang ist der Sollwert ca. 4,3 Volt, bei Werten über 4,7 Volt fehlt die GND Verbindung.
Eine Drahtbrücke von GND nach E- löst das Problem.
Danach ist eine Neukalibrierung der Messanordnung (Scale/Offset) notwendig.
Ich habe auch den SparkFun Load Cell Amplifier - HX711 ausprobiert.
Der hat ohne Probleme funktioniert.

ILS - HX711 24bit AD Module + 1kg Aluminum Alloy Scale Weighing Sensor Load Cell Kit for Arduino

Ein Vergleich mit der Schaltung auf Sparkfun oder dem Referenzdesign des Chipherstellers AVIA bestätigt die Aussagen.
https://www.sparkfun.com/products/13879
https://cdn.sparkfun.com/datasheets/Sensors/ForceFlex/hx711_english.pdf


Eine korrekte Platine findet sich auch auf
http://www.sunrom.com/p/loadcell-sensor-24-bit-adc-hx711 
https://www.amazon.de/Ils-Module-Aluminum-Weighing-Arduino/dp/B0769FZ7NB


  Waage
Bienenstockwaage ARDUINO
https://create.arduino.cc/projecthub/team-arduinotronics/arduino-scale-b821ae

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

beelogger logo

Programmcode

Programmcodes

Schaltungen

Schaltungen

Platinen

Platinen

Android App

Android-App




Quelle:
https://beelogger.de/



Als Stockwaage, Bienenstockwaage oder Bienenwaage wird im Imkereiwesen und der Bienenzucht eine Wägevorrichtung bezeichnet, mit der die Gewichtsveränderungen eines Bienenvolkes ermittelt und überwacht werden können.
Sie besteht aus einer meist speziellen Waage, auf die ein einzelner Bienenstock, der sogenannte Waagstock, aufgesetzt wird.
Der Begriff Waagstock wird teils auch synonym für die gesamte Bienen-Wägevorrichtung mitsamt Waage, Bienenstock und etwaigem Schutzhäuschen gebraucht.
Während bislang analoge (mechanische) Stockwaagen eingesetzt wurden, kommen heute zunehmend digitale (elektronische) Stockwaagen in Gebrauch.
Elektronische Stockwaagen ermöglichen unter Einsatz spezieller Messtechnik und Datenfernübertragung
– insbesondere bei automatisierter Erfassung von weiteren Faktoren wie beispielsweise Stocktemperatur und einer standortbezogenen Wetterbeobachtung
– sehr detaillierte Trachtbeobachtung sowie Fernüberwachung von Bienenvölkern.
Dieses teils sogenannte Trachtmonitoring kann inzwischen auch für viele Standorte im Web abgerufen werden

https://de.wikipedia.org/wiki/Stockwaage



- Wägeplatte 50x50 cm (also auch für Dadant-Blatt geeignet)
- max. 150kg, 20g Schritte



Stockwaage (Bosche H30A & HX711)

Für den Arduino Datenlogger mit Stockwaage für Imker wurde zunächst nach einer günstigen Alternative zu den häufig für Stockwaagen verwendeten
Bosche-Wägezellen H30A gesucht.
Getestet wurden hierfür exemplarisch Wägezellen mit der Typenbezeichnung YZC-161E welche zu einem Preis von € 8,- für 4 Stück zu erstehen waren.
In ähnlicher Bauweise sind eine Vielzahl an Wägeelementen im Internet zu finden, die vermutlich die gleichen Eigenschaften aufweisen.


beelogger gewichtssensor

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

Nennlast                   : 50kg
Nennleistung             : 1.0 ± 0.1 mV / V
Nichtlinearität            : 0.08% F.S
Hysterese                 : 0.1% F.S
Wiederholbarkeit        : 0.05% F.S
Creep (5min)              : 0.05% F.S
Temperatureinfluss     : 0.02% F.S / ° C
Nullabgleich               : ± 0.1000 mV / V
Eingangswiderstand   : 1000 ± 20% Ohm
Ausgangsimpedanz    : 1000 ± 10% Ohm
Isolationswiderstand    : 2000 MOhm
Sichere Überlast          : 120% F.S
Grenzlast                    : 150% F.S
Betriebstemperaturbereich       : -20 ~ 65 ° C
Empfohlene Erregerspannung   : 5 Vdc
Maximale Betriebsspannung     : 8 Vdc
Schutzgrad                             : IP65
Material                                  : Aluminiumlegierung
Kabel                                     : 0,8×460 mm
Gewicht                                  : 80g

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



beelogger hx711 Korrekt

 Mit hoher Wahrscheinlichkeit korrekt beschaltetes Board

Viele ältere Boards mit diesem Aufbauweisen eine inkorrekte Beschaltung auf
beelogger HX711








300_d_AVIA-x_HX711 24-bit A-D-Wandler für DMS Brückenschaltungen - Datenblatt_1a.pdf


Viele ältere Boards mit diesem Aufbau weisen eine inkorrekte Beschaltung auf
Der HX711 ist kompatibel mit    beelogger-EasyPlug und  beelogger-Solar !
https://www.mikrocontroller.net/topic/326445



BOSCH DMS Wägezelle H30A  Nennlast 150kg  € 49,90
http://www.bosche.eu

BQLZR
https://beelogger.de/?page_id=26

Stockwaage – Beschaltung & Aufbau

Beschaltung

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

Arduino Uno, Nano, usw. HX711
5V VCC
A0 CLK / SCK
A1 DT / DATA
GND GND

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

H30A HX711
Rot E+ / RED
Schwarz E- / BLK
Grün A+ / GRN
Weiß A- / WHT

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.

beelogger_Stockwaage_H30A

Alternativ zur Plattform kann auch eine “H-Konstruktion” aus Vierkantrohren verwendet werden.
Hierbei wird das Wägeelement mittig zwischen zwei H-Profilen für Plattform und Standfuss montiert.
Auch bei dieser Konstruktion sind die maximalen Maße der Plattform zu berücksichtigen.

beelogger_Stockwaage_H30A_H

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

beelogger_Stockwaage_H30A_Aufbau

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

https://beelogger.de/?page_id=833


Stockwaage – Kalibrierung & Test

Nach erfolgreichem Aufbau der Wägekonstruktion der Stockwaage, kann diese nun kalibriert werden. Bei der Kalibrierung werden zwei Werte ermittelt:
Taragewicht
Skalierung
Mit dem Taragewicht wird das Anzeigegewicht auf Null gesetzt, um beispielsweise das Gewicht der Wägekonstruktion oder Beute unberücksichtigt zu lassen.
Durch die Skalierung werden die Messwerte des HX711 in Einheiten umgerechnet, im Fall des Arduino Datenloggers mit Stockwaage für Imker in Gramm.
Die mit dem Programmcode zur Kalibrierung ermittelten Werte, werden später im Test-Programmcode bzw. dem kompletten Programmcode des beelogger unter Programmcode eingegeben.

Prüfung und Modifikation HX711

Wie unter Stockwaage (Bosche H30A & HX711) bereits beschrieben, gibt es Boards, die in ihrer Beschaltung durch eine nicht vorhandene Verbindung von E- bzw. BLK mit GND vom Referenzdesign abweichen.
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.
Gewissheit, wie der Chip beschaltet ist, bringt nur die Messung des Widerstandes zwischen E- und GND.
Dieser sollte bei einer korrekt beschalteten Platine praktisch Null sein. Ist der Widerstand wesentlich höher, kann die fehlende Verbindung selbst hergestellt werden.
Hierzu sollte mit einem möglichst kurzen Kabel direkt auf dem Board zwischen E- und GND gearbeitet werden, um Stromschleifen zu vermeiden.

beelogger hx711 korrektur

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.

beelogger solar stromswitch dauerstrom

Zum Test des Sensors mit dem beelogger-Solar, ist dieser über den entsprechenden Jumper mit Dauerstrom zu versorgen.
Die Markierung (senkrechter Strich) gibt hierbei den Pin mit Dauerstrom an.

Sketch

/*
* (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 für Imker
// Erläuterungen dieses Programmcodes unter http://beelogger.de
 
#include <HX711.h>  
HX711 scale(A1, A0);
 
char c;
 
long Tara;
float Scale;
 
void setup(){
  Serial.begin(115200);
  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 beschweren - 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(){
 
}



Ausgabe des seriellen Monitors (115200 baud):
Waage ohne Gewicht - Kalibrierung mit '1' und 'Enter' starten!
Kalibriere ...
Waage mit genau 1 Kg beschweren - Kalibrierung mit '2' und 'Enter' starten!
Kalibriere ...
Prüfe Gewicht: 1000
Tara-Gewicht: 10552283
Skalierung: 19.12


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

/*
* (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 für Imker
// Erläuterungen dieses Programmcodes unter http://beelogger.de
 
#include <HX711.h>
HX711 scale(A1, A0);
 
byte Anzahl_Sensoren_Gewicht = 1; // Mögliche Werte: '0','1'
 
long Taragewicht = 1;  // Hier ist der Wert aus der Kalibrierung einzutragen
float Skalierung = 1;  // Hier ist der Wert aus der Kalibrierung einzutragen
 
long Gewicht = 999999;                      
long LetztesGewicht = 0;
 
void setup() {
  Serial.begin(115200);
  
  if (Anzahl_Sensoren_Gewicht == 1) {
    scale.set_offset(Taragewicht);  
    scale.set_scale(Skalierung);
  }
}
 
 
void loop() {
  if (Anzahl_Sensoren_Gewicht == 1) {
    delay(100);
    for(byte j=0 ;j < 3; j++) { // Anzahl der Widerholungen, wenn Abweichung zum letzten Gewicht zu hoch
      Gewicht= scale.get_units(10);
      if ((Gewicht-LetztesGewicht < 500) and (Gewicht-LetztesGewicht > -500)) j=10;  // Abweichung für Fehlererkennung
      if (j < 3) delay(3000); // Wartezeit zwischen Wiederholungen
    }
    LetztesGewicht = Gewicht;
    Serial.print("Gewicht: ");
    Serial.print(Gewicht);
    Serial.println(" g");
  }
}



Ausgabe des seriellen Monitors (115200 baud):
Gewicht: -1 g
Gewicht: -2 g
Gewicht: 0 g
Gewicht: 0 g
Gewicht: 0 g
Gewicht: -2 g
Gewicht: -2 g
Gewicht: -1 g
Gewicht: -1 g
Gewicht: 0 g
Gewicht: 0 g

Programmcode downloaden
Der komplette Programmcode für den Arduino Datenlogger mit Stockwaage für Imker ist unter Programmcode zu finden.
Nach der Kalibrierung kann mit der Temperaturkompensation begonnen werden.

https://beelogger.de/?page_id=835





Stockwaage – Temperaturkompensation

Auch beim Einsatz hochwertiger Wägeelemente, wie das beim Arduino Datenlogger mit Stockwaage für Imker verwendeten H30A von Bosche, sind Abweichungen des Gewichtes aufgrund von Temperaturschwankungen, die auf das Gesamtsystem von Wägeelement, Kabel, Verbindungen, HX711, Arduino und der Trägerkonstruktion einwirken, zu verzeichnen.
Grade der HX771 ist relativ temperaturempfindlich.
Wichtig ist es, zunächst die korrekte Beschaltung des HX711-Boards zu prüfen und diese ggf. zu korrigieren.
Eine Anleitung hierzu findet sich unter Kalibrierung & Test – Prüfung und Modifikation HX711.
Zudem sollte die Elektronik inkl. HX711 mit einem Gehäuse gegen kurzfristige Temperaturschwankungen geschützt werden.
Um den generellen Einfluss der Temperatur zu verringern, kann mit einem temperaturabhängigen Korrekturwert gearbeitet werden.
Für unseren Einsatz ermöglicht dies eine ausreichende Genauigkeit.
In unseren Tests konnten wir mit Hilfe der Temperaturkompensation innerhalb einer Temperaturdifferenz von 25 Grad eine maximale Abweichung von 45g erreichen (vereinzelte Ausreißer ausgenommen).
Voraussetzung für die Nutzung der Temperaturkompensation, ist die Verwendung eines Temperatursensors zur Ermittlung der Außentemperatur.
Für eine noch genauere Kompensation kann die Temperatur des Wägeelementes auch direkt durch Verbindung des Sensors über einen thermischen Leiter gemessen werden.
Dadurch entstehen keine Abweichungen durch den Nachlauf der Temperatur des Wägeelementes zur Außentemperatur.

In allen Programmcodes wird die Temperaturkompensation unterstützt. Zur Konfiguration werden lediglich die Werte für 2 Variablen benötigt, die Temperatur zum Zeitpunkt der Kalibrierung (‘Kalibriertemperatur’) sowie der Korrekturwert (‘KorrekturwertGrammproGrad’).

float Kalibriertemperatur = 0;       // Temperatur zum Zeitpunkt der Kalibrierung
float KorrekturwertGrammproGrad = 0; // Korrekturwert zur Temperaturkompensation - '0' für Deaktivierung


Zur Ermittlung des Wertes für ‘KorrekturwertGrammproGrad‘ wird die kalibrierte Stockwaage zunächst mit einem fixen Referenzgewicht belastet.
Über einen längeren Zeitraum wird nun das gemessene Gewicht sowie die Außentemperatur aufgezeichnet.
Hierbei sollte möglichst ein Ort mit entsprechenden Temperaturschwankungen gewählt werden.
Ein Wohnraum mit konstanter Temperatur wird keine verwertbaren Daten liefern. Hierfür können der Programmcode und die Webserverskripte verwendet werden, wobei darauf zu achten ist, dass ‘KorrekturwertGrammproGrad‘ den Wert ‘0’ hat.
Liegen ausreichend Daten vor, kann die über die Webserverskripte erstellte CSV-Datei vom Webserver geladen und mit einem Tabellen-Kalkulationsprogramm mit ‘Komma’ als Trennoption geöffnet werden.
Für jedes Datenpaar aus Gewicht und Temperatur wird nun ein individueller Korrekturwert mit folgender Formel ermittelt:

 

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

$datensatz = $zeit.$trennzeichen.$ext_TempIn.$trennzeichen.$ext_TempOut.$trennzeichen.$ext_FeuchteIn.$trennzeichen.$ext_FeuchteOut.$trennzeichen.$ext_Licht.$trennzeichen.$ext_Gewicht.$trennzeichen.$ext_BienenIn.$trennzeichen.$ext_BienenOut.$trennzeichen.$BienenDifferenz.$trennzeichen.$timestamp.$umbruch;
 
$aktion = fOpen("beelogger.csv", "a+");
fWrite($aktion , $datensatz);
fClose($aktion);

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

$Kalibriertemperatur = 0; // Temperatur zum Zeitpunkt der Kalibrierung
$Referenzgewicht = 0;
 
$BienenDifferenz = (abs($Referenzgewicht-$ext_Gewicht)/(abs($Kalibriertemperatur-$ext_TempIn)));


Über den hiermit erzeugten Graphen unter ‘Bienen In-Out’ kann der ‘KorrekturwertGrammproGrad’ abgeschätzt werden.
Danach müssen die obigen Zeilen aus der Datei ‘beelogger_log-php’ wieder entfernt werden, um den Bienenzähler komplett nutzen zu können.
Der Programmcode des beeloggers ist so konfiguriert, dass bei Unterschreiten der Kalibriertemperatur das Produkt aus Korrekturwert und Temperaturdifferenz zum Gewicht addiert wird.
Bei Überschreiten der Kalibriertemperatur wird dieses Produkt vom Gewicht subtrahiert.
Verhält sich beim Einsatz einer anderen Wägezelle das System entgegengesetzt, kann dies im Programmcode einfach angepasst werden.

// Temperaturkompensation
if ((TempOut != 999.99)){
  if (TempOut > Kalibriertemperatur) Gewicht = Gewicht-(fabs(TempOut-Kalibriertemperatur)*KorrekturwertGrammproGrad);
  if (TempOut < Kalibriertemperatur) Gewicht = Gewicht+(fabs(TempOut-Kalibriertemperatur)*KorrekturwertGrammproGrad);
}


Um eine genauere Temperaturkompensation zu ermöglichen, könnten unterschiedliche Korrekturwerte, abhängig von der Außentemperatur oder der Temperaturdifferenz von Außen- und Kalibriertemperatur, über eine entsprechende Abfrage variabel eingesetzt werden.
Zur Überprüfung der Temperaturkompensation sind die Messwerte der konfigurierten Stockwaage mit fixem Referenzgewicht eine weitere Zeit lang in gleicher Umgebung aufzuzeichnen.
Der Gewichtsverlauf sollte sich nun mit relativ geringen Abweichungen vom Referenzgewicht bewegen.

Quelle:
https://beelogger.de/?page_id=26
https://beelogger.de/?page_id=2924

https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide
https://github.com/bogde/HX711








http://www.4bees.at/documents/104949/5436325/HX711+Modul/3438d7f8-06a5-45eb-9b79-b6b96ec5fc2b





********************************************************I*

HX711 Load Cell Amplifier
DMS Strain Gauge  HX711

Interfacing Load Cell with Arduino using HX711

Dual Channel HX711 Weighing Pressure Sensor 24-bit Precision A/D Module For Arduino


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.


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.

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










https://maker.pro/arduino/projects/how-to-build-a-weight-measuring-system-with-an-arduino

Arduino & HX711 Load Cell Based Weighing Machine

In this project we will be “interfacing HX711 Load cell amplifier with Arduino” and 16*2 LCD for designing Arduino Weighing Machine using Load Cell HX711 .
This is a simple “Arduino Weight Measurement project”. The circuit is 100% calibrated.
Electronic weighing machine uses load cell to measure the weight produced by the load, here most load cells are follows the method of strain gauge, Which converts the pressure (force) into an electrical signal, these load cells have four strain gauges that are hooked up in a Wheatstone bridge formation.
For more detail information, circuit diagram and arduino hx711 source code visit: http://www.how2electronics.com/arduin...
Drop a like if you liked the video.
Don't forget to subscribe to our channel for more Electronics project and tutorials.
https://www.youtube.com/watch?v=GneNCD20Vk4


How to make a weighing scale with the HX711, a load cell and an Arduino
https://www.youtube.com/watch?v=S12Mp8gDJmI


Den Dehnungsmessstreifen in einer Viertel-Wheatstone-Brückenformation mit dem HX711 verwenden.
Im folgenden Bild sehen Sie eine Skizze der Verbindung.

Gauge Connections

Wägezellen basieren tatsächlich auf dem gleichen Prinzip, sie verwenden unterschiedliche Konfigurationen von Wheatstone-Brücken mit Dehnungsmessstreifen und das HX711-Modul verstärkt und diskretisiert nur die Potentialdifferenz, die in der Brücke durch die mechanische Verformung erzeugt wird.
Weitere Informationen hierzu finden Sie here 82.
https://www.hbm.com/en/7163/wheatstone-bridge-circuit/?utm_source=rb-community&utm_medium=forum&utm_campaign=hx711-and-a-single-strain-gauge

Weil Sie sagten, dass Sie mit dem Code zu kämpfen haben, schlage ich vor, dass Sie sich die verfügbaren Arduino-Beispiele ansehen.
Sie finden sie here 137 zusammen mit einem sehr schönen Tutorial.

Load Cell Amplifier Module HX711

Load Cell Amp

#include "HX711.h"

// HX711 circuit wiring
const 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

Load Cell Amplifier HX711 Breakout Hookup Guide

Arduino Example

The first thing you will want to work with is the calibration code "SparkFun_HX711_Calibration.ino" from the SparkFun examples.
/*
 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  2

HX711 scale;

float calibration_factor = -7050; //-7050 worked for my 440lb max scale setup

void 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://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide/all?utm_source=rb-community&utm_medium=forum&utm_campaign=hx711-and-a-single-strain-gauge

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

 ARDUINO Sketch   HX711.h

HX711 Arduino Library  2019-03-01

Library to interface the Avia Semiconductor HX711 ADC.

Author
Bogdan Necula
Website
https://github.com/bogde/HX711
HX711_Arduino_Library-0.7.2.zip
https://www.arduinolibraries.info/libraries/hx711-arduino-library

Schwerpunktwaage für Flugzeugmodelle nach FMT
http://www.rc-network.de/forum/showthread.php/720818-Digitale-3-Punkt-Schwerpunktwaage/page2



HX711.h fehlt im Sketch  mann sollte doch die HX711 library einbinden

https://github.com/bogde/HX711


/*
 * 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








HX711
Eine Arduino-Bibliothek zum Anschluss des 24-Bit-Analog-Digital-Wandlers (ADC) von Avia Semiconductor HX711 zum Lesen von Wägezellen / Waagen.
Es unterstützt die Architekturen atmelavr, espressif8266, espressif32, atmelsam, teensy und ststm32 durch entsprechende PlatformIO-Ziele.

Zusammenfassung

Blockierender Modus
Die Bibliothek wird normalerweise im Blockiermodus verwendet,
d.
H. Sie wartet, bis die Hardware verfügbar ist, bevor sie einen Lesevorgang zurückgibt.

#include "HX711.h"
HX711 loadcell;

// 1. HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

// 2. Adjustment settings
const long LOADCELL_OFFSET = 50682624;
const long LOADCELL_DIVIDER = 5895655;

// 3. Initialize library
loadcell.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
loadcell.set_scale(LOADCELL_DIVIDER);
loadcell.set_offset(LOADCELL_OFFSET);

// 4. Acquire reading
Serial.print("Weight: ");
Serial.println(loadcell.get_units(10), 2);


Nicht blockierender Modus
Es ist auch möglich, ein maximales Timeout festzulegen, um auf die Initialisierung der Hardware zu warten.
Dadurch wird das Programm nicht in einen Spinlock versetzt, wenn die Waage nicht angeschlossen ist, und wahrscheinlich werden auch Hardwarefehler berücksichtigt.


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



An Arduino library to interface the Avia Semiconductor HX711 24-Bit Analog-to-Digital Converter (ADC) for Weight Scales.
https://github.com/bogde/HX711

Quellcode /  Sketch

/**
*
* HX711 library for Arduino
* https://github.com/bogde/HX711
*
* MIT License
* (c) 2018 Bogdan Necula
*
**/
#ifndef HX711_h
#define HX711_h

#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

class HX711
{
private:
byte PD_SCK; // Power Down and Serial Clock Input Pin
byte DOUT; // Serial Data Output Pin
byte GAIN; // amplification factor
long OFFSET = 0; // used for tare weight
float SCALE = 1; // used to return weight in grams, kg, ounces, whatever

public:

HX711();

virtual ~HX711();

// Initialize library with data output pin, clock input pin and gain factor.
// Channel selection is made by passing the appropriate gain:
// - With a gain factor of 64 or 128, channel A is selected
// - With a gain factor of 32, channel B is selected
// The library default is "128" (Channel A).
void begin(byte dout, byte pd_sck, byte gain = 128);

// Check if HX711 is ready
// from the datasheet: When output data is not ready for retrieval, digital output pin DOUT is high. Serial clock
// input PD_SCK should be low. When DOUT goes to low, it indicates data is ready for retrieval.
bool is_ready();

// Wait for the HX711 to become ready
void wait_ready(unsigned long delay_ms = 0);
bool wait_ready_retry(int retries = 3, unsigned long delay_ms = 0);
bool wait_ready_timeout(unsigned long timeout = 1000, unsigned long delay_ms = 0);

// set the gain factor; takes effect only after a call to read()
// channel A can be set for a 128 or 64 gain; channel B has a fixed 32 gain
// depending on the parameter, the channel is also set to either A or B
void set_gain(byte gain = 128);

// waits for the chip to be ready and returns a reading
long read();

// returns an average reading; times = how many times to read
long read_average(byte times = 10);

// returns (read_average() - OFFSET), that is the current value without the tare weight; times = how many readings to do
double get_value(byte times = 1);

// returns get_value() divided by SCALE, that is the raw value divided by a value obtained via calibration
// times = how many readings to do
float get_units(byte times = 1);

// set the OFFSET value for tare weight; times = how many times to read the tare value
void tare(byte times = 10);

// set the SCALE value; this value is used to convert the raw data to "human readable" data (measure units)
void set_scale(float scale = 1.f);

// get the current SCALE
float get_scale();

// set OFFSET, the value that's subtracted from the actual reading (tare weight)
void set_offset(long offset = 0);

// get the current OFFSET
long get_offset();

// puts the chip into power down mode
void power_down();

// wakes up the chip after power down mode
void power_up();
};

#endif /* HX711_h */



https://github.com/bogde/HX711/blob/master/src/HX711.h




********************************************************I*
    Elektronische Waage mit HX711-Modul

Widerstands-Messbrücke mit 350 Ohm DMS (Dehnungsmessstreife)

10 kg Biegebalken-Sensoren  HT SENSOR TAL220   Load Cell Series

HT Sensor Technology Co. Lim.Product Numbers:TAL220 in China

http://www.htc-sensor.com/products/94.html


Im Fall des Wägesensors werden die vier Brückenwiderstände jeweils durch Dehnungsmessstreifen ersetzt.

Messverstärker HX711

Der HX711 enthält nicht nur die analogen Brückenverstärker, sondern auch einen hochauflösenden 24-bit-A/D-Wandler mit einem SPI-ähnlichen seriellem Interface zum Mikrocontroller. Für die Auswertung des Wägesensors nahezu ideal.

Das folgende Bild zeigt die prinzipielle Beschaltung aus dem Datenblatt:



Load Cell Amplifier - HX711 Wiegesensor 24 Bit
  • Betriebsspannung: 2,6 bis 5,5V
  • Auflösung            : 24-bit
  • Kanäle                : 2
  • Stromaufnahme    : < 1.5mA
  • Datenrate am Ausgang: wählbar 10SPS oder 80SPS
  • Abmessung         : 24x15.5x2,8mm
  • Gewicht              : 2g

Anschluss HX711 am ARDUINO UNO R3
HX711    Arduino UNO
GND      GND
DT         A1
SCK      A0
Vcc      5V

HX711                  Load Cell DMS Biegebalken
Rot                     E+
Schwarz             E-
Weiß                   A+
Grün (oder Gelb) A-
n.c.                    B-
n.c.                    B+




Es gibt von diversen Anbietern kleine Breakout-Boards mit der kompletten Beschaltung des HX711 zu kaufen, man muss also nicht selber löten.
Neben E-Bay und Amazon bieten Sparkfun, Adfruit, EXP-Tech und andere solche Breakout-Boards an, die fast alle die gleiche Schaltung aufweisen - welche sich recht stark am Datenblatt orientiert.
Manche der erhältlichen Boards weichen jedoch davon ab.
Auch neigen einige Plantinen zu einer größeren Toleranz der Messwerte, haben eine höhere Temperaturempfindlichkeit oder weisen größere Messfehler auf, wenn das Board zuvor abgeschaltet bzw. im Power-Down-Modus gewesen ist.
Das folgende Bild zeigt eine typische Beschaltung des HX711 und links unten ein Foto des Breakout-Boards von Sparkfun stellvertretend für alle anderen.






Das HX711-Board akzeptiert 5 Leitungen aus der Wägezelle.

Die Lötpunkte auf dem Breakout-Board sind schon mit den typischen Kabelfarben der Wägezellen beschriftet; RED (rot), BLK (schwarz), WHT (weiss), GRN (grün) und YLW (gelb). Diese Farben entsprechen der herkömmlichen Farbcodierung der Wägezellen, wobei der rote, schwarze, grüne und weiße Draht von dem Dehnungsmessstreifen stammen und die gelbe Litze eine optionale Masseleitung ist, die nicht mit den Dehnungsmessstreifen verbunden ist, aber Verbindung zum Metallkörper der Wägezelle hat. Manchmal gibt es anstelle einer gelben Leitung einen etwas stärkeren schwarzen Draht, eine Folie oder nicht isolierte Drähte, um die Signalleitungen abzuschirmen.

Die 4 Drähte, die aus der Wheatstone-Brücke auf der Wägezelle kommen, sind in der Regel:
positive Anregung (E+) bzw. VCC (rot)
negative Anregung (E-) bzw. GND (schwarz)
positiver Ausgang (O+, S+, A+) (weiß)
negativer Ausgang (O-, S-, A-) (grün oder blau)

Manche Wägezellen können leichte Variationen in der Farbcodierung der Leitungen haben, beispielsweise blau statt grün, gelb statt schwarz oder weiß usw. - insbesondere wenn es nur vier Drähte gibt, also die Abschirmung fehlt.
Liefert der HX711 entgegengesetzte Messwerte (z. B. sinkender Wert, wenn das Gewicht erhöht wird), müssen nur die Leitungen O+ und O- vertauscht werden.

Auf der Controllerseite werden die Signale
VDD (Stromversorgung des Digitalteils),
VCC (Stromversorgung des Analogteils),
DAT (Daten),
CLK (Takt)
GND (Masse) angeschlossen.
VCC, die analoge Spannungsversorgung und VDD, die digitale Versorgungsspannung, können in vielen Fällen miteinander verbunden werden.
Nur, wenn Ihr Mikrocontroller mit 3,3V versorgt wird, dann muss Vcc mit 5,0V und Vdd mit 3,3V verbunden werden.
Bei manchen Boards sind die Anschlüsse Vcc und Vdd schon auf dem Board durch eine Leiterbahn verbunden (hier müsste man bei 3,3V Controllerspannung die Leiterbahn unterbrechen), bei anderen Boards sind VCC und VDD getrennt und müssen ggf. verbunden werden.

Über einen Jumper am RATE-Eingang des HX711 kann die Datenrate eingestellt werden. Ist der Anschluss mit GND verbunden, beträgt die Datenrate 10 Messungen pro Sekunde, ist der RATE-Pin über einen Pullup-Widerstand mit Vcc verbunden, beträgt die Datenrate 80 Messungen pro Sekunde.
Das Signal ist dann aber wesentlich stärker mit Rauschen überlagert und somit nicht ganz so genau.


Software für den Arduino

Bei Sparkfun bzw. Github stehen neben einer HX711-Bibliothek auch Kalibrierungs- und Beispielprogramme für den Arduino bereit (siehe Links unten), die man sich herunterladen kann.
Hier sollen deshalb nur die verwendeten Programme besprochen werden, nicht jedoch die recht gut dokumentierte und übersichtliche Bibliothek.
Ist die Waagekonstruktion aufgebaut, stehen noch das Ermitteln des Taragewichts (das Gewicht der Wägekonstruktion) und die Kalibrierung an.
Für das Ermitteln des Tara kann man das ganz normale Mess-Programm verwenden. Oder man verzichtet ganz auf die Ermittlung eines genauen Tara-Gewichts.
Durch die Skalierung werden die Messwerte des HX711 in brauchbare Einheiten umgerechnet, beispielsweise in Gramm.
Dazu muss ein Kalibrierungsfaktor ermittelt werden, der dann im Messprogramm verwendet wird.
Dazu wird ein Extra-Programm verwendet, das beim Arduino interaktiv über den seriellen Monitor der Arduino-IDE kommuniziert.
Vor der Kalibrierung muss die Wägekonstruktion mehrmals stark belastet und wieder entlastet werden, damit sich die Mechanik setzen kann.
Bei manchen Wägezellen tritt auch eine gewisse Trägheit bei hohen, kurzzeitigen Lastwechseln auf, die in der Praxis selten vorkommen.
Man sollte also nach dem Belasten der Konstruktion genügend lange warten, bevor man mit der Kalibrierung beginnt.
Gegebenenfalls muss man nach einiger Zeit des Betriebs noch einmal nachkalibrieren.

Das Kalibrierungs-Programm

Bei Sparkfun bzw. Github gibt es zwar ein Kalibrierungsprogramm, jedo bezieht sich das auf amerikanische Gewichtseinheiten.
Deshalb wird hier das Programm von Thorsten Gurzan (https://beelogger.de) verwendet.
Das Programm zur Kalibrierung ist interaktiv und kommuniziert über den seriellen Monitor.
Der Ablauf wird im folgenden geschildert. Wer sich über die etwas umständliche Eingabe mit Zahl und 'Enter' wundern sollte: das liegt am Verhalten des seriellen Monitors.

Da das Programm aber selten eingesetzt wird, macht das nichts weiter aus. Nun zum Ablauf:
  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 genau 1 kg sind, sonst sind später alle Messwerte falsch.
  6. Es erfolgt die Ausgabe "Kalibriere" und danach "Pruefe Gewicht:"
  7. Bei erfolgreicher Kalibrierung sollte 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 Programmcode der Messprogramms zu hinterlegen.
Das Kalibrier-Programm erwartet den Anschluß des HX711 an den Pins 2 (DATA) und 3 (CLK).
Ist die Wägezelle an anderen Pins des Arduino angeschlossen, muss der Code entsprechend angepasst werden (Aufruf von HX711 scale(2, 3)).

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 HX711 Arduino Library:

https://github.com/bogde/HX711

Kalibrierprogramm
/*
 * (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()
  {}

Meßprogramm

/*  
Gewichtsdaten aller acht Waagen holen (Messung ueber HX711-Board)
und seriell ausgeben.

Zuvor Tara-Werte mit dem Kalibrierungsprogramm fuer Kanal 0 (D2, D3)
ermitteln und unten im Array Taragewicht eintragen.

Tara gemessen:
- ohne Gewicht <  -34000
- mit Rahmen   < -160000
- mit Rahmen und 1 kg < -188000

Achtung: China-Waage und deutsche Waage unterscheiden sich 
im Vorzeichen von Skalierung. 

Datenausgabe: eine Zeile, die mit '$' beginnt. Dann kommen 
NR_WEIGHTS Werte (long) in Gramm

Gegebenenfalls Bibliothek einbinden mittels: 
Sketch -> Bibliothek einbinden -> .ZIP-Bibliothek hinzufuegen
*/

#include <HX711.h> 

// Fuer Debugging Kommentar entfernen
// #define DEBUG

// Wahl des Boards: Arduino UNO/Nano oder Pro Mini 5V/16MHz
// Werte: 1 fuer 'UNO/NANO' oder 2 fuer 'MINI'
#define BOARD 1

// Maximalwert und Default fuer Gewicht in Gramm
#define WEIGHTMAX 999999L

// Minimalwert (unter 0 in Gramm), eventuell fehlt die Waage
#define WEIGHTMIN -1000L

// Zahl der Waagen
#define NR_WEIGHTS 8 

// Wartezeit fuer neue nach Messung nach grosser Abweichung zum vorherigen Wert (Sekunden)
#define REPEAT_DELAY 3

// Wartezeit nach jedem Messzyklus (Sekunden)
#define LOOP_DELAY 5

// Wartezeit fuer das Detektieren einer Waage (CLK == 0) in ms
// Output-Datenrate des HX711 ist 10/80 Hz
#define DETECT 200

// Neue Messung bei Abweichung von > ERROR_WEIGHT in Gramm
#define ERROR_WEIGHT 300L

// Voreingestellte Kalibrierwerte, vom Benutzer einzustellen 
// mit Kalibrierprogramm f. Kanal 0
long  Taragewicht[NR_WEIGHTS] = {-160942L, -160942L, -160942L, -160942L,
                                 -160942L, -160942L, -160942L, -160942L}; 

// Skalierung ist fix und wird bei Kal. nicht veraendert
float Skalierung[NR_WEIGHTS] = {-29.32, -29.32, -29.32, -29.32, 
                                -29.32, -29.32, -29.32, -29.32};

// Speichern des letzten Messwerts
long  LetztesGewicht[NR_WEIGHTS] =  {WEIGHTMAX, WEIGHTMAX, WEIGHTMAX, WEIGHTMAX, 
                                     WEIGHTMAX, WEIGHTMAX, WEIGHTMAX, WEIGHTMAX};
// aktueller Messwert
long  Gewicht[NR_WEIGHTS] = {0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L};

// welche Waagen sind ansprechbar (dynamisch ueberprueft)?
byte active_scale[NR_WEIGHTS] = {0, 0, 0, 0, 0, 0, 0, 0};

#if BOARD==1
  // Waagen-/Pin-Definition UNO, Nano: Reihenfolge: HX711(DATA,CLK)
  // Erst Digital-Ports D2, D3 usw., dann Analog-Ports als Digital-Ports
  // Digital-Ports 12, 13 sind ausgespart wg. angeschlossener LED
  HX711 Scale[NR_WEIGHTS] = {HX711(2,3), HX711(4,5), HX711(6,7), HX711(8,9),
                             HX711(10,11), HX711(A0,A1), HX711(A2,A3), HX711(A4,A5)};
#endif

#if BOARD==2 
  // Waagen-/Pin-Definition Pro Mini 5V/16MHz: Reihenfolge: HX711(DATA,CLK)
  // Statt D12,D13 oben hier A6,A7. A4, A5 ist I2C-Bus, deshalb fehlen sie
  HX711 Scale[NR_WEIGHTS] = {HX711(2,3), HX711(4,5), HX711(6,7), HX711(8,9),
                             HX711(10,11), HX711(A0,A1), HX711(A2,A3), HX711(A6,A7)};
#endif

// ========================Funktionen =========================

void check_scales()
  // Versuch, nicht angeschlossene Waagen zu erkennen
  // Es wird eine bestimmte Zeit gewartet, bis der Dateneingang
  // auf LOW geht. Bleibt er auf HIGH --> keine Waage.
  {
  int i, k;
  for(k = 0; k < NR_WEIGHTS; k++)
    {
    // DETECT Millisekunden auf Low warten
    for(i = 0; (! Scale[k].is_ready() && (i < DETECT)); i++) 
      delay(1);
    // Data nun LOW?
    active_scale[k] = Scale[k].is_ready();
    #ifdef DEBUG
      Serial.print("Detect ");  Serial.print(k);
      Serial.print(" ");
      Serial.println(active_scale[k]);
    #endif
    }
 }
 
void setup_scales()
  {
  // Defaultwerte fuer Tara und Skalierung setzen
  int k;
  for(k = 0; k < NR_WEIGHTS; k++)
    {
    Scale[k].set_offset(Taragewicht[k]); 
    Scale[k].set_scale(Skalierung[k]);
    }
  }

long get_scale_value(HX711 sc, long Letztes)  
  {
  // Messwert von der durch "sc" gegebenen HX711-Instanz auslesen
  // "Letztes" ist der zuletzt gemessene Wert (fuer Fehlererkennung)
  long Gew;                      

  Gew = sc.get_units(10);               
  #ifdef DEBUG
    Serial.print(" Messung a ");  Serial.print(Gew);
  #endif
  if (Gew < 0L) Gew = 0;            // kleiner neg. Wert z.B. durch Temperatur
  if (abs(Gew - Letztes) > ERROR_WEIGHT && Letztes != WEIGHTMAX) 
    {  // wiederholen, wenn vorheriger Wert stark abweicht
    delay(REPEAT_DELAY * 1000);
    Gew = sc.get_units(10);
    #ifdef DEBUG
      Serial.print(" Messung b ");  Serial.print(Gew);
    #endif
    if (Gew < WEIGHTMIN) Gew = -1;  // Fehlmessung
    else if (Gew < 0L) Gew = 0;     // kleiner neg. Wert z.B. durch Temperatur
    }
  return Gew;
  }

long temp_komp(long Gew) 
  {
  // Temperaturkompensation hier einfuegen
  return Gew;
  }

void read_scale_values() 
  // Messwert aller Waagen abrufen
  {
  int k;
  
  delay (50);
  for(k = 0; k < NR_WEIGHTS; k++)
    {
    #ifdef DEBUG
       Serial.print("Waage: "); Serial.print(k);
    #endif
    if (active_scale[k])  
      {
      LetztesGewicht[k] = Gewicht[k]; 
      Gewicht[k] = get_scale_value(Scale[k], LetztesGewicht[k]);
      Gewicht[k] = temp_komp(Gewicht[k]);
      }
    else
      Gewicht[k] = -1; 
    #ifdef DEBUG
       Serial.print("  Gewicht: "); Serial.print(Gewicht[k]);
       Serial.println();
    #endif
    }
  }

void output_scale_values()
  // Alle Waagen-Werte ausgeben (als Long in Gramm)
  {
  int i;

  // Vorspann: Newline und '$' als Startzeichen
  Serial.println();
  Serial.print('$');
  // dann die Werte durch Leerzeichen getrennt
  for (i = 0 ;i < NR_WEIGHTS; i++)
    {
    Serial.print(Gewicht[i]); 
    Serial.print(" ");
    }
  Serial.println();
  }

// =========================== Main ===========================
void setup() 
  // Initialisierung Schnittstelle und Waagen
  { 
  Serial.begin(9600); delay(1);
  #ifdef DEBUG
    Serial.println("Neustart ...");
  #endif
  pinMode(LED_BUILTIN, OUTPUT);

  // nachtraeglich Pullups an den Datenleitungen einschalten, 
  // damit sich aktive Waagen detektieren lassen
  // --> gelegentlich die HX711-Library anpassen
  digitalWrite(2, HIGH);
  digitalWrite(4, HIGH);
  digitalWrite(6, HIGH);
  digitalWrite(8, HIGH);
  digitalWrite(10, HIGH);
  digitalWrite(A0, HIGH);
  digitalWrite(A2, HIGH);
  #if BOARD==1
    digitalWrite(A4, HIGH);  // nur bei UNO, Nano
  #endif
  #if BOARD==2
    digitalWrite(A6, HIGH);  // nur bei Pro Mini 5V/16MHz
  #endif
  
  check_scales();
  setup_scales();
  }
 
void loop() 
  // In regelmaessigen Zeitabstaenden Gewicht ausgeben
  {
  int i;
  
  #ifdef DEBUG
    Serial.println("Start Messung ...");
  #endif
  digitalWrite(LED_BUILTIN, HIGH);
  read_scale_values();
  output_scale_values();
  digitalWrite(LED_BUILTIN, LOW);

  delay(LOOP_DELAY * 1000);
  }





https://github.com/bogde/HX711
https://github.com/bogde/HX711





Plattform Wägezellen von BOSCHE Wägetechnik

Plattform Wägezellen sind wie der Name schon sagt, für den Einsatz in Plattformwaagen besonders geeignet. Die Eigenschaften einer Wägezelle werden durch den sogenannten Federkörper bestimmt. Dieser Federkörper besteht aus Metall und wird unter der Einwirkung von Druckkraft verformt.






FUNKTIONEN VON PLATTFORM WÄGEZELLEN

Plattform Wägezellen sind wie der Name schon sagt, für den Einsatz in Plattformwaagen besonders geeignet.
Die Eigenschaften einer Wägezelle werden durch den sogenannten Federkörper bestimmt.
Dieser Federkörper besteht aus Metall und wird unter der Einwirkung von Druckkraft verformt.
Der Vorgang der Verformung und das Zurückkehren des Federkörpers in seine ursprüngliche Gestalt nach Entfernen der Last wird über einen Dehnungsmessstreifen registriert und in ein elektrisches Signal umgewandelt.
Plattform Wägezellen werden wie die meisten anderen Wägezellen in Gramm, Kilogramm oder Tonnen kalibriert.

EINSATZGEBIETE
Plattform Wägezellen findet man in Wägeeinrichtungen für kleine bis mittlere Lasten im Bereich bis zu 5 Tonnen.
Plattform Wägezellen werden in Plattformwaagen, Bandwagen, Abfüllwaagen oder Dosierwaagen eingesetzt.
Darüber hinaus sind sie auch zum Messen von Überlast bei Aufzügen oder zum Messen von Anpressdruck nutzbar.

TECHNISCHE DETAILS
Plattform Wägezellen erfüllen wie die meisten Wägezellen die hohen Anforderungen der Industrie bezüglich Robustheit.
Deshalb werden Wägezellen für gewöhnlich mit Schutzklassen ab IP 65 angeboten.
Plattform Wägezellen haben gegenüber anderer Wägezellen den Vorteil, dass sie auf Eckenlastigkeit hin optimiert und kalibriert sind.
Das bedeutet, dass die Plattform Wägezelle auch dann sehr genau arbeitet, wenn die Last auf einer Plattform nur auf einer Ecke liegt.
Im Datenblatt finden sich alle Angaben, die man zum Konstruieren einer Wägeeinrichtung mit Plattform Wägezellen benötigt.
Das sind unter anderem die Nennlast, der Mindestteilungswert zur Berechnung des maximalen Taragewichts und die Grenzlast.
Mit einer Plattform Wägezelle kann man sehr schnell eine Plattformwaage konstruieren.
Man benötigt eigentlich nur die Plattform Wägezelle und zwei Metallplatten, an denen die Wägezelle befestigt wird. Wägeeinrichtungen unterliegen in den meisten Fällen einer Eichpflicht.
Deshalb sind Plattform Wägezellen in der Regel eichbar.


https://www.bosche.eu/waagenkomponenten/waegezellen/plattform-waegezellen#weiter




Sparkfun: Beispielprogramme zum HX711
https://github.com/sparkfun/HX711-Load-Cell-Amplifier







Sparkfun: Breakout-Board      SparkFun Load Cell Amplifier - HX711
https://www.sparkfun.com/products/13879




Sparkfun: Grundlagen-Tutorial    des Biegebalken HT SENSOR  TAL220 
Load Cell 0,1kg Straight Bar  (TAL221)  sparkfun SEN-14727
Load Cell 0,5kg Straight Bar  (TAL221)  sparkfun SEN-14728
Load Cell  5kg Straight Bar  (TAL220B)  sparkfun SEN-14729
Load Cell 10kg Straight Bar  (TAL220)    sparkfun SEN-13329
Load Cell  200kg Straight Bar  S-Typ (TAS501)  sparkfun SEN-14282
https://learn.sparkfun.com/tutorials/getting-started-with-load-cells


https://learn.sparkfun.com/tutorials/load-cell-amplifier-hx711-breakout-hookup-guide



https://www.sparkfun.com/





700_d_fritz-x_Elektronische Waage mit Biegebalken & ARDUINO Load Cell Amp +++ § HX711-Board DMS-350R_1a.pdf

Datenblatt HX711  des AVIA  24-bit Analog-to-Digital Converter (ADC) for Weigh Scales
700_d_AVIA-x_HX711 24-bit Analog to Digotal Cobverter (ADC) for Weigh Scales - Datenblatt_1a.pdf







DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE





Untergeordnete Seiten (1): HX711 A-D-Wandler
Comments