Schlagwort: Ohaus Navigator

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).

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

Ü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):

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:

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.

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:

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

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.

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.

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