Die Waagen der Ohaus Navigator-Serie lassen sich optional mit verschiedenen Schnittstellen ausstatten. Für die RS-232- und USB-Schnittstelle müssen in der verwendeten Software die gleichen Schnittstellenparameter eingestellt sein wie im Menü der Waage, damit die Übertragung des Gewichts funktionieren kann.
Mit der Einführung der neuen hochauflösenden Navigator-Waagen (NV-123, NV223 und NV223) hat Ohaus die Standardwerte dieser Schnittstellenparameter geändert und an die restlichen Waagen von Ohaus angeglichen. Auch die weiteren Navigator-Waagen werden nun nach und nach mit der neuen Firmware ausgeliefert und erhalten damit die neuen Einstellungen.
Die folgende Tabelle zeigt die Unterschiede:
Neu
Alt
Baudrate
9600
2400
Datenbits
8
7
Parität
Keine
Keine
Stoppbits
1
2
Flusskontrolle
Keine
Keine
Diese Einstellung können im RS232 bzw. USB-Menü der Waage überprüft und geändert werden.
Als Beispiel für eine Software sehen Sie hier Screenshots aus Simple Data Logger (speichert Gewicht mit Datum und Uhrzeit in einer Datei) und HTerm (Terminal-Software, praktisch zum Testen der Kommunikation mit der Waage). Diese zeigen die neuen Schnittstellenparameter. Wie erwähnt müssen die Einstellungen der Software und Waage exakt übereinstimmen.
Software Simple Data Logger mit Einstellungen für Ohaus-WaagenHTerm mit Einstellungen für Ohaus-Waagen
In Simple Data Logger müssen Sie die Einstellungen nicht von Hand vornehmen, sondern können „Ohaus“ (für die neuen Schnittstellenparameter) oder „Ohaus SPU, TA, NV“ (alte Parameter) als Gerät auswählen und auf den Set default parameters for device-Knopf klicken.
Baudrate: Die Baudrate gibt die Übertragungsrate von Daten in Bits pro Sekunde an. Waagen arbeiten üblicherweise mit vergleichsweise niedrigen Baudraten von 1200 bis 9600. Diese sind für die Übertragung des Gewichts völlig ausreichend, es sei denn, Sie möchten zahlreiche Werte pro Sekunden oder zusätzliche Daten übertragen. Je höher die Baudrate, desto kürzer ist die maximal mögliche Länge der RS-232-Datenleitung.
Datenbits: Die Datenbits geben die Anzahl der Bits an, die pro Übertragungseinheit übertragen werden. Die meisten Geräte mit RS-232-Schnittstellen verwenden 8 Datenbits pro Übertragungseinheit.
Parität: Die Parität ist ein weiteres Bit, der zu den Datenbits hinzugefügt wird, um Fehler bei der Übertragung zu erkennen. Es gibt verschiedene Arten von Parität: gerade Parität, ungerade Parität und keine Parität.
Stoppbits: Die Stoppbits geben an, wie viele Bits am Ende jeder Übertragungseinheit übertragen werden, um das Ende der Übertragung anzuzeigen.
Flusskontrolle: Die Flusskontrolle kann verwendet werden, um die Übertragung von Daten zwischen dem Sender und dem Empfänger zu synchronisieren und zu verhindern, dass der Empfänger überflutet wird. Es gibt verschiedene Arten von Flusskontrolle, wie Hardware-Flusskontrolle und Software-Flusskontrolle.
Für die Ohaus Navigator-Waagen ist optional ein hochwertiger Transportkoffer verfügbar. Einer unserer Kunden hat uns gefragt, ob es möglich ist, die Waage zu benutzen, ohne sie aus dem Koffer zu nehmen.
Es ist nicht unmöglich, aber dafür ist der Transportkoffer nicht gedacht. Zum Schutz der Waage ist die Polsterung eng geschnitten und höher als die Waage. Bei Waagen mit rechteckiger Wägeplatte kann diese am Rand anstoßen, wodurch das Gewicht verfälscht wird:
Die Ohaus Navigator-Modelle mit runder Wägeplatte haben dieses Problem nicht. Allerdings sollten alle Waagen mit Hilfe der integrierten Libelle und verstellbaren Füße korrekt ausgerichtet werden. Dazu wird es ohnehin meistens notwendig sein, sie aus dem Koffer zu entnehmen.
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.
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:
Es wird in der ersten Zeile des 16×2 LCDs angezeigt.
In der zweiten Zeile erscheint ein Kapazitätsbalken, der die benutzte Kapazität proportional zur Höchstlast der Waage anzeigt.
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!
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 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
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 gconst 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:
Wir benötigen lediglich Pin 2 (TXD), auf dem die Waage die Daten sendet, sowie Pin 5 (Ground):
DE9M
MAX232
MAX232
Arduino
2
R1IN (13)
R1OUT (12)
RX1 (D19)
5
GND (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:
/*
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>// LCDconstint rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystallcd(rs, en, d4, d5, d6, d7);
// serial communication with the scaleconstint maxChars = 42; // Ohaus Navigator should not send more than 41 characters for each weight value, +1 for string terminatorchar receivedStr[maxChars];
int numCharsReceived = 0; // required in the loop to count received characters// check weighing with 3 LEDsconstfloat loLimit = 4990; // lower limit in gconstfloat hiLimit = 5010; // upper limit in gconstint pinHiLed = 50;
constint pinOkLed = 48;
constint pinLoLed = 46;
// capacity barconstint 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 flickeringvoiddisplayString(char str[]){
lcd.setCursor(0, 0);
int num = strlen(str);
for (int i = 0; i < 16; i++) { // 16 characters per rowif (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 / HIGHvoidcheckWeigh(float weight){
//check LOWif (weight < loLimit) {
digitalWrite(pinHiLed, LOW);
digitalWrite(pinOkLed, LOW);
digitalWrite(pinLoLed, HIGH);
return;
}
//check HIGHif (weight > hiLimit) {
digitalWrite(pinHiLed, HIGH);
digitalWrite(pinOkLed, LOW);
digitalWrite(pinLoLed, LOW);
return;
}
// must be OKdigitalWrite(pinHiLed, LOW);
digitalWrite(pinOkLed, HIGH);
digitalWrite(pinLoLed, LOW);
}
// capacity bar - note that it does not consider a possible tare weightvoidupdateBar(float weight){
lcd.setCursor(0, 1);
int num = round(weight / maxWeight * 16); // 16 segmentsfor (int i = 0; i < 16; i++) { // 16 characters per rowif (i < num)
lcd.write('=');
else lcd.write(" "); // fill remaining characters
}
}
voidsetup(){
// set up the LCD's number of columns and rows
lcd.begin(16, 2);
// initialize serial communication
Serial1.begin(9600);
// check weighing LEDspinMode(pinHiLed, OUTPUT);
pinMode(pinOkLed, OUTPUT);
pinMode(pinLoLed, OUTPUT);
}
voidloop(){
// read data from serial port 1 on Arduino Megawhile (Serial1.available() > 0) {
char c = Serial1.read(); // read one characterif (c == '\n' || numCharsReceived == maxChars) { // last character ('\n' terminator) found or max length reachedif (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.
Ü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).
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.