Aufzeichnung des Gewichts von zwei Waagen mit Kern BalanceConnection

In diesem Artikel zeigen wir Ihnen Schritt für Schritt, wie Sie mit der Software Kern BalanceConnection in regelmäßigen Intervallen das Gewicht von zwei Kern PNS-Waagen abrufen können. Die Gewichtswerte werden mit Datum und Uhrzeit in zwei separate Dateien geschrieben, die sich zur weiteren Verarbeitung problemlos in Excel oder anderen Programmen öffnen lassen.

Der hier gezeigte vereinfachte Vorgang erfordert eine individuelle Konfigurationsdatei (.config). Bei Bestellung der Waagen und BalanceConnection-Software über unseren Shop erstellen wir gerne eine solche Datei für Sie.

Vorbereitung der Waagen und Software

Verbinden Sie die Waagen mit den RS-232-Datenkabeln und den Schnittstellenwandlern auf USB mit einem PC. Der Treiber für den Schnittstellenwandler mit FTDI-Chip wird von Windows normalerweise automatisch installiert (andernfalls finden Sie ihn hier).

Die Kern BalanceConnection Software können Sie hier herunterladen. Nach dem Start haben Sie zunächst die Möglichkeit, Ihren Lizenzschlüssel einzugeben (alternativ können Sie die Software 10 Tage testen):

Eingabe Lizenzschlüssel Kern BalanceConnection Software

Danach erscheint die Programmoberfläche in der einfachen Ansicht. Klicken Sie auf die Schaltfläche unten rechts, um in den Expertenmodus zu wechseln:

Software Kern BalanceConnection auf Expertenmodus umstellen

Das Programm startet neu und sieht nun deutlich anders aus. Links unten unter Schnittstellen erscheinen die COM-Ports der Schnittstellenwandler als „USB Serial Port“. Auf unserem System handelt es sich um COM5 und COM10, die Nummern der COM-Ports werden allerdings auf Ihrem System andere sein (sie werden von Windows vergeben):

Kern BalanceConnection Expertenansicht

Konfigurationsdatei laden

Laden Sie die von uns bereitgestellte Konfigurationsdatei (.config) im Menü unter Einstellungen / Verwaltung / Einstellungen wiederherstellen:

Die Software startet ohne weitere Nachfrage neu (dies kann etwas dauern) und sollte nun wie unten gezeigt aussehen:

  1. Es sind zwei Geräte (Waagen) „PNS1“ und „PNS2“ angelegt.
  2. Diese sind den Schnittstellen COM1 und COM2 zugewiesen.
  3. Als Ausgabemethode ist die Dateiaufzeichnung in zwei separaten Dateien im Verzeichnis C:\Users\Public\Documents eingestellt.
  4. Zum Abfragen des Gewichts von der Waage sind Timer mit einem Intervall von 10 Sekunden definiert.

Waagen den richtigen COM Ports zuweisen

Aktuell sind die Waagen den Schnittstellen COM1 und COM2 zugeordnet, wir müssen sie aber mit den als „USB Serial Port“ aufgelisteten COM-Ports verbinden (auf unserem System COM5 und COM10):

Com Port - USB Serial Port

Mit einem Doppelklick auf COM1 gelangen Sie zu den Einstellungen. Ändern Sie im Tab RS-232 Eigenschaften den Anschluss auf den ersten „USB Serial Port“:

Klicken Sie auf Änderungen, um die Einstellungen zu übernehmen. Schließen Sie das Dialogfenster.

Wiederholen Sie den Vorgang für COM2 und wählen Sie entsprechend den zweiten „USB Serial Port“ aus.

In der Schnittstellen-Ansicht sollten nun die Waagen PNS1 und PNS2 je einem USB Serial Port zugewiesen sein:

Schnittstellen-Ansicht

Dateipfad ändern

Falls gewünscht, können Sie den Speicherort der Dateien wie hier beschrieben ändern. Andenfalls werden diese im Verzeichnis C:\Users\Public\Documents erzeugt.

Durch einen Doppelklick auf den ersten „Dateiaufzeichnung“-Eintrag gelangen Sie zu den Einstellungen. Klicken Sie im Tab Ausgabedatei auf den Dateipfad:

Sie können den Dateipfad nun direkt eingeben (z.B. indem Sie ihn aus dem Windows Datei-Explorer kopieren) oder über Durchsuchen den üblichen „Speichern-unter“-Dialog öffnen:

Tipp: Verwenden Sie die Dateiendung .csv, dies ermöglicht das Öffnen der Datei in Excel mittels Doppelklick.

Variable Dateinamen

Wenn Sie möchten, dass BalanceConnection variable Dateinamen verwendet, die z.B. das Datum enthalten, können Sie entsprechende Platzhalter über die Schaltflächen einfügen:

Passen Sie in diesem Fall auch die Einstellungen im vorherigen Dialog unter Sollten an Ihre Wünsche an.

Bestätigen Sie die Änderungen mit Änderungen übernehmen. Sie kehren nun zum vorherigen Dialog zurück, schließen Sie diesen auch mit einem Klick auf Änderungen übernehmen.

Wiederholen Sie den Vorgang für die zweite Dateiaufzeichnung (und somit für die zweite Waage).

Hinweis: In unserem Test wurden die Änderungen von BalanceConnection nicht sofort richtig dargestellt, es erschienen immer noch und die alten Dateipfade:

Um dies zu beheben, schließen Sie die Software (die Einstellungen werden automatisch gespeichert) und starten Sie sie erneut. Die Änderungen sind nun ersichtlich:

Timer konfigurieren / starten

Die von uns eingerichteten Timer rufen das Gewicht alle 10 Sekunden ab:

Wenn Sie dies ändern möchten, gelangen Sie über einen Doppelklick auf den Timer zu den Einstellungen. Ändern Sie die Bezeichnung und wechseln Sie in das Timer-Tab, um das Intervall für den Abruf des Gewichts von der Waage anzupassen:

Klicken Sie auf Änderungen übernehmen.

Abruf des Gewichts und Dateiaufzeichnung starten

Klicken Sie auf den ersten Timer und dann auf Aktiviert , um den Abruf des Gewichts von der Waage in dem eingestellten Intervall zu starten. Wiederholen Sie dies für den zweiten Timer:

Der Abruf des Gewichts und die Dateiaufzeichnung laufen nun:

Über die Aktiviert-Schaltfläche können Sie den Abruf des Gewichts und damit die Dateiaufzeichnung auch beenden.

Datenempfang testen

Um zu testen, ob das Gewicht von der Waage empfangen wird, markieren Sie eine Dateiaufzeichnung und klicken Sie auf die folgende Schaltfläche:

Es erscheint nun ein Fenster, in dem Sie das von der Waage gesendete Gewicht („Rohdaten“) und die für die Dateiaufzeichnung verwendeten Werte („analysiert“) sehen können:

Datei in Excel öffnen

Die erstellten Dateien lassen sich einfach durch einen Doppelklick in Excel öffnen:

Gewicht mit Datum und Uhrzeit in Excel

Vorsicht: Öffnen Sie die Datei nicht, während die Aufzeichnung noch läuft! Kern BalanceConnection kann sonst keine neuen Werte in die Datei schreiben, zeigt aber keine Fehlermeldung an. Sie können die Datei im schreibgeschützten Modus öffnen, Excel aktualisiert die Werte allerdings nicht automatisch.

Weitere Informationen

Gewicht in Intervallen erfassen – Waage Ohaus Defender 5000

Für manche Anwendungen ist es erforderlich, das Gewicht von einer Waage in bestimmten Intervallen an einen PC zu übertragen und aufzuzeichnen. Wir zeigen Ihnen in diesem Artikel zwei alternative Möglichkeiten, wie Sie dies mit Waagen mit dem Ohaus Defender 5000-Anzeigegerät und unserer Software Simple Data Logger erreichen können.

Vorbereitung

Unser System setzt sich wie folgt zusammen:

  1. Wägeplattform (in zahlreichen Größen und Kapazitäten von 6 kg bis 3 t erhältlich)
  2. Ohaus Defender 5000-Anzeigegerät mit RS-232-Schnittstelle
  3. RS-232-Datenkabel
  4. Schnittstellenwandler auf USB
  5. PC mit Software Simple Data Logger

Waage Ohaus Defender 5000 mit PC und Software

Für das Anzeigegerät sind optional weitere Schnittstellen verfügbar (z.B. Ethernet oder WiFi/Bluetooth), auf die wir hier nicht eingehen.

Wenn der Schnittstellenwandler zum ersten Mal an einem USB-Port angeschlossen wird, sollte Windows den Treiber automatisch installieren (falls nicht, kann er hier heruntergeladen werden).

Am PC erscheint danach ein neuer COM-Port mit der Bezeichnung „USB Serial Port“:
USB Serial Port

Wählen Sie diesen Port in Simple Data Logger zur Kommunikation mit der Waage aus (in diesem Beispiel COM30, an Ihrem PC wird es ein anderer Name sein). Als Gerät stellen Sie Ohaus ein, durch Drücken auf Set default parameters for device werden die Schnittstellenparameter (Baudrate, etc.) auf die richtigen Werte gesetzt:
Simple Data Logger Input Tab

Im Output-Tab wählen Sie die Datei aus, in die das Gewicht geschrieben werden soll. Durch Drücken auf Set values for German (Germany) werden Zeit und Datum zu jedem Wert hinzugefügt und das Zahlenformat des Gewichtswerts und des CSV-Trennzeichens so gesetzt, dass sich die erzeugte Datei später einfach in Excel öffnen lässt:
Simple Data Logger Output Tab

1. Möglichkeit: Intervallmodus der Waage nutzen

Wählen Sie im Menü der Waage den folgenden Eintrag aus: Communication > RS232 > Assignment. Ändern Sie die Einstellung von „Demand“ auf „Interval (seconds)“.

Es erscheint nun ein neuer Eintrag: Time. Geben Sie hier das gewünschte Intervall in Sekunden ein (der vorhandene Wert wird mit der ON/Clr-Taste gelöscht):
Intervall für Übertragung des Gewichts

Standardmäßig überträgt die Waage folgende Werte:

  1. den auf dem Display angezeigten Wert,
  2. das Bruttogewicht,
  3. das Nettogewicht,
  4. und das Taragewicht.

Wenn Sie alle diese vier Werte mit Simple Data Logger erfassen möchten, geben Sie im Process-Tab unter Combine bitte „4“ ein. So werden die Werte in einer Zeile aufgezeichnet (obwohl sie von der Waage in 4 Zeilen übertragen werden):
Process-tab 4 Gewichtswerte in eine Zeile schreiben

Falls Sie nur das angezeigte Gewicht übertragen und erfassen möchten, können Sie die Einstellung im Menü der Waage unter Communication > RS232 > Setup > Edit Template ändern. Ändern Sie Field 3 mit den Pfeiltasten (Softkeys) auf „End of Template“ (Field 1 und Field 2 bleiben unverändert):
Template zur Übertragung des Gewichts bearbeiten

In Simple Data Logger müssen Sie im Start-Tab nun nur noch mit Start die Verbindung zur Waage herstellen. Die empfangenen Gewichtswerte erscheinen im Event Log und werden in die CSV-Datei geschrieben:
Gewichtswerte im Intervallmodus

2. Möglichkeit: Polling-Funktion in Simple Data Logger mit MT-SICS verwenden

Im Menü der Waage müssen mit dieser Methode keine Änderungen vorgenommen werden. Statt den Intervallmodus der Waage zu verwenden, fordern wir das Gewicht mit einem Timer aus der Software an (Plus-Lizenz erforderlich). Damit wird das Template nicht anpassen müssen, benutzen wir einen MT-SICS-Befehl (das Format der Antwort ist standardisiert).

Falls Sie bereits Einstellungen an der Waage geändert haben, können Sie diese unter Communication > RS232 > Setup > Reset zurücksetzen.

Ändern Sie in Simple Data Logger im Input-Tab das Gerät (Device) auf „Mettler Toledo (MT-SICS)“:
Abruf des Gewichts mit MT-SICS

Aktivieren Sie im Control-Tab das Kästchen bei Enable polling. Geben Sie das gewünschte Intervall in Millisekunden bei Timer ein und klicken Sie auf Set default command for Mettler Toledo (MT-SICS):

Abruf des Gewichts mit Timer und MT-SICS
10000 ms = 10 Sekunden

Nachdem Sie im Start-Tab den Start-Button betätigt haben, sendet die Waage in dem eingestellten Intervall den Befehl „SI“ (send immediately) an die Waage. Diese Antwortet mit dem Gewicht im MT-SICS-Format (nur Nettogewicht):
Abruf des Gewichts und Antwort der Waage mit MT-SICS

Datei in Excel öffnen

Drücken Sie auf Stop. Die erzeugte CSV-Datei können Sie nun durch einen Doppelklick in Excel öffnen. Alle Werte werden im richtigen Format in eigenen Spalten angezeigt (die Datums-Spalte müssen sie lediglich etwas vergrößern):

Datum, Uhrzeit und Gewicht in Excel
Mit der ersten Methode erzeugt, daher 4 Gewichtswerte pro Zeile

Weitere Informationen

Software Simple Data Logger
Ohaus Defender 5000-Waage in unserem Shop

Arduino mit Waage Ohaus Navigator verbinden (via RS-232)

Serielle Schnittstellen: Arduino und Waage

Die Waagen aus der Ohaus Navigator-Serie bieten ein sehr gutes Preis-/Leistungsverhältnis und lassen sich mit verschiedenen Schnittstellen ausstatten, darunter RS232, USB Device und Ethernet.

Für die Übertragung des Gewichts an einen Arduino eignet sich die serielle RS232-Schnittstelle am besten, da alle Arduinos ebenfalls mit mindestens einer seriellen Schnittstelle ausgestattet sind.

Wir verwenden in diesem Projekt den Arduino Mega, der über insgesamt vier serielle Schnittstellen verfügt (Serial, Serial1, Serial2, Serial3). Die erste davon wird – wie bei anderen Arduinos – zur Kommunikation mit dem Computer verwendet. Möchte man den Arduino-Sketch häufig ändern, ist es vorteilhaft, wenn zur Kommunikation mit der Waage eine separate Schnittstelle verwendet werden kann (hier Serial1).

Vorsicht: Die seriellen Schnittstellen der Arduinos sind TTL-Schnittstellen und dürfen nicht direkt mit der RS232-Schnittstelle einer Waage verbunden werden! Die höhere Spannung der RS232-Schnittstelle kann den Arduino beschädigen. Darüber hinaus verwenden beide Schnittstellen eine genau umgekehrte Logik. Die Verbindung darf daher nur mit einem geeigneten Pegelkonverter erfolgen. Weitere Details finden Sie z.B. in diesem Artikel.

Ziel dieses Arduino-Waagen-Projekts

Das von der Waage gesendete Gewicht kann der Arduino für verschiedenste Zwecke nutzen. In diesem Beispielprojekt machen wir damit folgendes:

  1. Es wird in der ersten Zeile des 16×2 LCDs angezeigt.
  2. In der zweiten Zeile erscheint ein Kapazitätsbalken, der die benutzte Kapazität proportional zur Höchstlast der Waage anzeigt.
  3. Eine Kontrollwägefunktion vergleicht das übertragene Gewicht mit Grenzwerten, die im Code definiert werden und stellt das Ergebnis mit 3 LEDs dar.

Kurzes Video des kompletten Projekts

Arduino mit Waage Ohaus Navigator verbinden (via RS-232) - Beispielprojekt

Übertragungsmodus und Einstellungen der RS232-Schnittstelle der Waage

Standardmäßig ist die Ohaus Navigator-Waage so eingestellt, dass das Gewicht bei Drücken der Print-Taste über die Schnittstelle gesendet wird. Dies ist sinnvoll, wenn ein serieller Drucker angeschlossen ist oder das Gewicht in eine Tabellenkalkulation übertragen werden soll (z.B. mit unserer kostenlosen Software 232key). Für dieses Projekt benötigen wir hingegen die automatische kontinuierliche Übertragung („continuous transmission“).

Im Menü der Waage lässt sich das unter Print>A.Print>Cont einstellen. Die Waage sendet nun laufend das Gewicht mit ca. 10 Werten/s. Die kontinuierliche Übertragung lässt sich durch Drücken der Print-Taste unterbrechen (Prt.OFF) und wieder starten (Prt.OFF).

Bei der Gelegenheit setzen wir im rS232-Menü die bAUD-Rate auf 9600 und PAritY auf 8-none (Standardeinstellungen der Ohaus Navigator sind 2400 Baud und 7-even).

Wichtig: Die zur Kommunikation mit der Waage verwendete serielle Schnittstelle des Arduinos muss auf die gleichen Werte eingestellt sein!

Datenformat der Waage

Die Waage sendet ASCII-Zeichen, aber welche? Hier hilft ein Blick in das Handbuch für die optionale RS232-Schnittstelle (PDF):

Waage Ohaus Navigator Datenformat aus Bedienungsanleitung

Das Datenformat lässt sich auch durch Verbindung der Waage mit einem Computer ermitteln. Das kostenlose Terminal-Programm HTerm ist hierfür sehr nützlich:

Datenformat der Waage mit und ohne Nutzung der Tara-Funktion
Datenformat der Ohaus Navigator-Waage mit und ohne Nutzung der Tara-Funktion. Reihen in Rot sind die dezimalen ASCII-Codes der Zeichen.

Die Übertragung wird mit Carriage Return (\r) und Line Feed (\n) abgeschlossen. Anhand dieser Zeichen können wir in unserem Programm erkennen, dass ein Gewichtswert (eine Zeile) komplett empfangen wurde.

Das von der Ohaus Navigator-Waage verwendete Format eignet sich sehr gut, um es direkt auf dem Display anzuzeigen. Mit 16 Zeichen erscheinen alle wichtigen Daten (und bei Verwendung der Tara-Funktion sogar ein „N“ am Ende). Eine besondere Formatierung vor der Anzeige ist somit nicht notwendig.

Es hat zudem einen weiteren Vorteil: Das Gewicht lässt sich problemlos mit Hilfe der atof-Funktion in eine Zahl konvertieren. Das ist notwendig, damit wir den Kapazitätsbalken und die Kontrollwägefunktion implementieren können.

Arduino-Schaltung

Das Schaltbild sieht auf den ersten Blick kompliziert aus, dies liegt aber vor allem an dem LCD. Die Verbindung mit der Waage ist hingegen recht einfach. Die verschiedenen Gruppen sind unten beschrieben.

Schaltbild: Arduino Mega für Verbindung mit Waage Ohaus Navigator

Premium-Inhalt: Sie können hier unsere Fritzing-Datei (.fzz) mit Schaltbild und Schaltplan für 3,60 € kaufen und unser Blog unterstützen.

LCD für Gewichtsanzeige und Kapazitätsbalken

Im linken Bereich des Breadboards befindet sich das LCD, das wir im 4-Bit-Modus an den Arduino angebunden haben. Die am Arduino verwendeten Pins folgen dem LCD-Beispiel auf der Arduino-Website. Der 220 Ohm-Widerstand am VO-Pin des LCDs (Pin 3) steuert den Kontrast und muss ggf. angepasst werden.

Kontrollwäge-LEDs

In der Mitte befinden sich die drei LEDs für unsere Kontrollwägefunktion. Diese sind mit Pins 46, 48 und 50 verbunden.

Die LEDs zeigen an, ob das Gewicht innerhalb der Toleranz liegt (grüne LED), unter dem unteren Grenzwert (gelbe LED) oder über der oberen Grenzwert (rote LED). Die Grenzwerte werden in unserem Arduino Sketch definiert:

const float loLimit = 4990; // lower limit in g
const float hiLimit = 5010; // upper limit in gCode-Sprache: JavaScript (javascript)

MAX232 TTL/RS232-Wandler (RS232-Transceiver)

Wie erwähnt darf der Arduino nicht direkt mit der RS232-Schnittstelle der Waage verbunden werden. Unser Arduino Mega arbeitet mit 5V, wir haben  daher den klassischen MAX232 Pegelwandler verwendet, der sich im rechten Bereich der Steckplatine befindet.

Der MAX232 enthält zwei Sender und zwei Empfänger, wir benötigen für dieses Projekt aber nur einen einzigen Empfänger, der das eingehende RS232-Signal auf TTL (5V) umsetzt. Als weitere Elemente sind vier Kondensatoren für die Ladungspumpen (1uF) und ein Bypass-Kondensator für die Spannungsversorgung verbaut (10uF).

Als einfachere Alternative gibt es auch komplette Module wie dieses, die sich in einen Steckverbinder einbauen lassen:

DE9M-Steckverbinder

Damit sind wir bei dem letzten Element, dem Steckverbinder. Das (optionale) RS232-Modul der Ohaus Navigator-Waage ist mit einem fest verbundenen Kabel mit DE9F-Buchse ausgestattet (häufig wird die eigentlich falsche Bezeichnung DB9F verwendet). Wir brauchen also einen passenden Stecker und müssen uns zudem überlegen, welche Pins verbunden werden sollen.

Hier hilft wieder das Handbuch:

Waage Ohaus Navigator RS232 Pinout

Wir benötigen lediglich Pin 2 (TXD), auf dem die Waage die Daten sendet, sowie Pin 5 (Ground):

DE9MMAX232MAX232Arduino
2R1IN (13)R1OUT (12)RX1 (D19)
5GND (15)GND

So können wir Daten von der Waage empfangen, aber keine Daten von dem Arduino an die Waage senden. Für den gewählten Übertragungsmodus ist dies aber auch nicht notwendig.

Info: Eine bidirektionale Verbindung mit dieser Waage (für dieses Projekt nicht erforderlich) würde wie folgt aussehen:

DE9MMAX232MAX232Arduino
2R1IN (13)R1OUT (12)RX1 (D19)
3T1OUT (14)T1 INTX1 (D18)
5GND (15)GND

Programmcode (Arduino-Sketch)

Der Code ist auch auf GitHub verfügbar.

/*
 Serial communication (RS-232) with an Ohaus Navigator scale

 Demonstrates how an Arduino Mega 2560 can receive the weight from a scale with an RS-232 interface. The weight is used
 for different purposes:
 - Received data is displayed on a 16x2 LCD (top row).
 - A capacity bar is displayed on the bottom row (shows how much of the max. capacity of the scale is being used).
 - Three LEDs indicate whether the weight is below a lower limit (see const loLimit), between the lower and upper limit
 or above the upper Limit (const hiLimit). This can be useful for check weighing.

 This sketch is meant to be used with an Ohaus Navigator scale. Please change the following settings in the menu of the
 scale:
 Print>APrint>Cont (continuous auto-print)
 RS232>baud>9600
 RS232>parity>8 none

 Set the unit to gram (g).

 Please do not contact the author for help when using a different scale. Such messages will be ignored.

 WARNING! DO NOT CONNECT YOU ARDUINO DIRECTLY TO THE RS232 INTERFACE OF A SCALE! You have to use a MAX232 or similar
 signal converter.

 Created May 24, 2021 by Stephan Lechner

 This sketch uses the LCD example code from: http://www.arduino.cc/en/Tutorial/LiquidCrystalSerialDisplay
*/

#include <LiquidCrystal.h>

// LCD
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// serial communication with the scale
const int maxChars = 42; // Ohaus Navigator should not send more than 41 characters for each weight value, +1 for string terminator
char receivedStr[maxChars];
int numCharsReceived = 0;  // required in the loop to count received characters

// check weighing with 3 LEDs
const float loLimit = 4990; // lower limit in g
const float hiLimit = 5010; // upper limit in g
const int pinHiLed = 50;
const int pinOkLed = 48;
const int pinLoLed = 46;

// capacity bar
const int maxWeight = 6200; // depends on the model of your scale

// displays a String in the first row of the LCD
// does not use lcd.clear to prevent flickering
void displayString(char str[]) {
    lcd.setCursor(0, 0);
    int num = strlen(str);
    for (int i = 0; i < 16; i++) { // 16 characters per row
        if (i < num)
            lcd.write(str[i]);
        else lcd.write(" "); // fill remaining characters
    }
}

// check weighing logic, three LEDs are used to signal three possible states LOW / OK / HIGH
void checkWeigh(float weight) {
    //check LOW
    if (weight < loLimit) {
        digitalWrite(pinHiLed, LOW);
        digitalWrite(pinOkLed, LOW);
        digitalWrite(pinLoLed, HIGH);
        return;
    }
    //check HIGH
    if (weight > hiLimit) {
        digitalWrite(pinHiLed, HIGH);
        digitalWrite(pinOkLed, LOW);
        digitalWrite(pinLoLed, LOW);
        return;
    }
    // must be OK
    digitalWrite(pinHiLed, LOW);
    digitalWrite(pinOkLed, HIGH);
    digitalWrite(pinLoLed, LOW);
}

// capacity bar - note that it does not consider a possible tare weight
void updateBar(float weight) {
    lcd.setCursor(0, 1);
    int num = round(weight / maxWeight * 16); // 16 segments
    for (int i = 0; i < 16; i++) { // 16 characters per row
        if (i < num)
            lcd.write('=');
        else lcd.write(" "); // fill remaining characters
    }
}

void setup() {
    // set up the LCD's number of columns and rows
    lcd.begin(16, 2);

    // initialize serial communication
    Serial1.begin(9600);
    // check weighing LEDs
    pinMode(pinHiLed, OUTPUT);
    pinMode(pinOkLed, OUTPUT);
    pinMode(pinLoLed, OUTPUT);
}

void loop() {
    // read data from serial port 1 on Arduino Mega
    while (Serial1.available() > 0) {
        char c = Serial1.read(); // read one character
        if (c == '\n' || numCharsReceived == maxChars) { // last character ('\n' terminator) found or max length reached
            if (receivedStr[strlen(receivedStr) - 1] == '\r') { //if '\r' found
                receivedStr[strlen(receivedStr) - 1] = '\0'; // remove by overwriting with null terminator
            }
            displayString(receivedStr);
            float weight = atof(receivedStr); // convert weight string to float
            updateBar(weight); // update capacity bar
            checkWeigh(weight); // update check weighing LEDs
            receivedStr[0] = '\0'; // reset string by terminating at position 0
            numCharsReceived = 0;
        } else {
            // end not reached yet, add received character to string
            receivedStr[numCharsReceived] = c;
            receivedStr[numCharsReceived + 1] = '\0';
            numCharsReceived++;
        }
    }
}Code-Sprache: Arduino (arduino)

Funktionen

  • displayString – zeigt die empfangenen Daten in der ersten Displayzeile an.
  • updateBar – zeigt in der zweiten Displayzeile einen Kapazitätsbalken an. Die Höchstlast der Waage ist in der Konstante maxWeight definiert.
  • checkWeigh – vergleicht das Gewicht (float weight) mit den Konstanten loLimit und hiLimit und schaltet die mit den 3 LEDs verbundenen Ausgänge.

Im loop lesen wir die Schnittstelle Serial1 zeichenweise aus und fügen jedes Zeichen zu dem char-Array receivedStr[] hinzu. Sobald das New-Line-Zeichen (\n) gelesen wurde, wissen wir, dass wir eine Zeile komplett empfangen haben. Das zuvor übertragene und bereits in receivedStr[] gespeicherte Carriage-Return-Zeichen (\r) wir nun gelöscht, damit es nicht auf dem Display erscheint (nicht zwingend notwendig, sieht nur besser aus). Die weiteren empfangenen Zeichen werden zur Anzeige an displayString übergeben.

Als nächster Schritt erfolgt die Konvertierung in eine Gleitkommazahl (float) mit atof. Erst jetzt können wir mit dem Gewicht rechnen, was für updateBar und checkWeigh erforderlich ist.

Die Größe des receivedStr[]-Arrays ist so dimensioniert, dass Platz für die längste möglicherweise von der Waage übertragene Zeile und den String-Terminator ist. Streng genommen würden hierfür 41 Zeichen reichen, da wir das letzte von der Waage übertragene Zeichen (\n) nie zu dem Array hinzufügen. Im gewählten Übertragungsmodus (kontinuierliche Übertragung) sendet die Waage maximal sogar nur 21 Zeichen.

Hinweise zum Arduino-Skript

  • Statt nullterminierten Zeichenarrays könnte man auch den String-Datentyp verwenden.
  • Übertragungsfehler oder Fehler bei der Konvertierung des Gewichts in eine Zahl  werden nicht erkannt.
  • Der Kapazitätsbalken berücksichtigt kein möglicherweise vorhandenes Taragewicht.
  • Es kann schwierig sein, sich schnell ändernde Werte auf dem Display abzulesen (je nach Displaytyp und Reaktionszeit).

Das Programm ist somit sicher noch nicht perfekt. Um die Kommunikation mit der Waage und Möglichkeiten zur Verwendung des Gewichts zu demonstrieren, ist es aber hoffentlich ausreichend.

Was halten Sie von unserem Arduino-Beispiel?

Es kostet sehr viel Zeit, einen Artikel wie diesen zu erstellen. Über freundliche und hilfreiche Kommentare würden wir uns daher freuen. Bitte kommentieren Sie aber dieses konkrete Projekt mit dieser Waage (Ohaus Navigator).

Allgemeine Fragen zu Arduinos und zur Programmierung können Sie im Arduino-Forum stellen. Das Forum auf microcontroller.net hat ebenfalls eine aktive Community.

Individuelle Fragen, bei denen es um andere Waagen als die Ohaus Navigator geht, können wir leider nicht beantworten. Überprüfen Sie bitte bei Problemen die im Text erwähnten Punkte. Diese können sich je nach Waagen-Hersteller und Modell erheblich unterscheiden:

  • Übertragungsmodus der Waage.
  • Einstellung der Schnittstelle (Baudrate etc.).
  • Encoding und Format der von der Waage gesendeten Daten.
  • Pinbelegung der RS232-Schnittstelle (manche Waagen benötigen auch zusätzliche Handshake-Verbindungen).

Falls Sie Hilfe zur Kommunikation mit Ihrer Waage benötigen, wenden Sie sich bitte an Ihren Händler oder an den Waagen-Hersteller.

In Kürze werden wir weitere Arduino-Projekte mit anderen Waagen-Modellen veröffentlichen.