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 16x2 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 g
Code-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.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.

I accept that my given data and my IP address is sent to a server in the USA only for the purpose of spam prevention through the Akismet program.More information on Akismet and GDPR.

The maximum upload file size: 10 MB. You can upload: image, document, text.