I. Vorwort:

 

Smart-Displays werden nach Markteinführung dieser Produkte umfangreich in verschiedenartigen Bereichen eingesetzt, z. B. Medizin, industrielle Steuerung und Automobilbranche. Einfach ausgedrückt handelt es sich um ein Display, das mit einem Mikrocontroller kombiniert ist, das komplexe Grafiken laden, einstellen, anzeigen und sogar eingeben kann, wobei das externe Gerät (der Host) interaktive Abläufe mittels einfacher Befehle ausführen kann, sodass es verschiedenartigen Anforderungen gerecht wird. Es lassen sich unterschiedliche Anwendungstypen anzeigen oder steuern.

Ein Smart-Display unterstützt vielfältige Kommunikationsschnittstellen. Zu den derzeit am häufigsten verwendeten Schnittstellen gehören CAN/CANopen, RS485/Modbus, wobei weitere Auswahlmöglichkeiten künftig zur Verfügung stehen werden. Unter ihnen ist RS485/Modbus ist eine gängige Kommunikationsschnittstelle in der Industrie und verschiedenartige RS485-Geräte lassen sich auf dem Markt zu angemessenen Preisen problemlos erwerben. Die Linienstruktur ist einfach, solange zwei Drahtleitungen (RS485_A/RS485_B) kommunizieren können, wobei die Kommunikationsschnittstelle üblicherweise in Form eines „seriellen Anschlusses“ vom Betriebssystem verfügbar gemacht wird. Zudem besitzt jede einzelne Plattform eine entsprechende Bibliothek mit Entwicklungsfunktionen. Überdies ist das Modbus-Protokoll leicht verständlich. Aus diesem Grund verwenden wir es nachstehend als Beispiel bei Experimenten und für unsere Erklärungen.

Dieser Artikel erklärt die Steuerung von Smart-Displays auf einfache bis in die Tiefe gehende Weise, erläutert ihre Steuerprinzipen und beschreibt abschließend, wie plattformübergreifende Anwendungen erstellt werden. Wir heißen Sie in der Welt der Smart-Displays willkommen, ganz gleich, ob Sie ein Experte für industrielle Geräte oder ein Heimwerker sind!

II. Anforderungen:

 

■Smart Display_RS485

Für den Anschlusstest ist ein Smart-Display erforderlich, das die RS485-Schnittstelle unterstützt.

■RS485-Dongle

Da ein Host, wie PC oder Raspberry Pi, normalerweise nicht mit einem RS485-Anschluss ausgerüstet ist, können wir ggf. auf unterschiedliche USB-zu-RS485-Dongle zurückgreifen.

 

■HOST-Gerät

Sobald die obigen Voraussetzungen erfüllt sind, können wir als Host eine Prüfstandumgebung zur Durchführung auswählen. Die einzige Bedingung für ein Hostgerät ist, dass es den seriellen Anschluss des Hosts lesen und darin schreiben kann, ganz gleich, ob es sich bei dem Betriebssystem um Windows, MacOS, verschiedenartige Linux-Versionen (einschließlich Raspbian für Raspberry Pi) handelt, oder die Plattform ein Einplatinencomputer, Arduino. usw ist.

Der Bequemlichkeit halber erstellen wir einen Einplatinencomputer mit integriertem Demo.set von RS485, der direkt als Hostgerät verwenden werden kann, siehe nachstehende Abbildung.

 

III. Einfacher Test für die Steuerschnittstelle:

 

■Steuercode beziehen

Um zu verstehen, wie ein Smart-Display mit einem Host kollaborieren kann, müssen wir zuallererst den Steuercode beziehen. Der einfachste Weg ist, ihn von GUI Builder für Smart-Displays zu erhalten. GUI Builder ist eine hervorragende Software zur Unterstützung von Smart-Displays. Mit ihrer Hilfe können wir die Nutzerschnittstelle ohne reale Gerätehardware erlernen, bedienen, entwickeln und anzeigen, wobei sich die Nutzerschnittstelle komplett ohne Schreiben eines Programms entwickeln lässt. Mit der WYSIWYG-Option kann die Nutzerschnittstelle durch Ziehen oder Anklicken von Schaltflächen oder Objekten erstellt werden. Zudem ist ein Simulator integriert, der den Quellcode mit Smart-Displays gemeinsam nutzt, womit gewährleistet wird, dass das Aussehen und das Verhalten völlig dem realen Gerät entspricht. Besser noch, es kostet nichts!

► Contact for Smart Display GUI Builder

 

Klicken Sie GUI Builder doppelt an, um die App unter dem Windows Betriebssystem auszuführen, und öffnen Sie ein Projekt. Wir entscheiden uns hier für das Smart-Display-RS485 5 Zoll, WL0F00050000FGDAASA00, mit Fahrzeug als Standardszenario, siehe unten. Geben Sie den Projektnamen ein und klicken Sie auf „Create“ (Erstellen), um ein Projekt zu erstellen. Haben Sie bereits zuvor ein Projekt erstellt, können Sie es im Menü auf der rechten Seite direkt auswählen.

 

Bei geöffnetem Projekt erst die Schnittstelle auswählen

 

 

Wählen Sie RS485 als Schnittstelle, wobei der RS485-Anschluss des Hostgeräts als tatsächlicher Anschluss für den RS485-Dongle dienen sollte Im Zweifelsfall können Sie den Namen des Anschlusses im Geräteadministrator überprüfen (ziehen Sie wiederholt den Stecker ab und prüfen Sie, ob er sich ausblendet oder welcher Anschluss angezeigt wird). Die Baudrate kann auf den Standardwert von 115200 eingestellt bleiben.

 

Allerdings gibt es noch kein Smart-Display-RS485-Gerät, was keine Rolle spielt, denn solange die Schnittstelle RS485 auswählt, kann der RS485-Anschluss im Moment ignoriert werden. Wir wenden uns jetzt dem Simulator zu, wofür wir in der Praxis kein Smart-Display-Gerät anschließen werden.

Klicken Sie zur Ausführung des Simulators auf „Simulator/Simulator with GUI“ (Simulator/Simulator mit GUI):

 

Hiernach sehen Sie den Simulationsbildschirm, die Kontrollelemente jedes einzelnen Objekts und die aufgezeichneten Kommunikationsdaten auf der rechten Seite des Bildschirms. Wenn Sie den Wert eines beliebigen Objekts ändern, können Sie den entsprechenden Befehlsinhalt sehen:

 

Für jede Aktion werden zwei Befehle angezeigt, TX und RX, denn das Displaygerät (sogar wenn es derzeit eigentlich nur ein Simulator ist) sendet nach Empfang eines Befehls denselben Befehl als Empfangsbestätigung zurück.

Wir zeichnen mehrere unterschiedliche Werte für verschiedenartige Objekte auf, sodass im nächsten Schritt das reale Gerät angesteuert werden kann.

■Drahtverbindung:

RS485 überträgt und empfängt differenzielle Signale, wofür selbst eine Masseleitung nicht erforderlich ist, solange diese zwei Drähte nicht miteinander verbunden werden können. Der Name der RS485-Signalleitung lautet A/B, auf den Sie achten müssen (A wird mit A und B wird mit B verbunden).

 

Wie bringt man einen Host dazu, Steuercodes von sich selbst zu übertragen? Solange er in einen seriellen Anschluss schreiben kann. Allerdings dürfen zwei Dinge nicht außer Acht gelassen werden, bevor der Test in Angriff genommen wird.

1. Die Namen der COM-Anschlüsse lauten in unterschiedlichen Betriebssystemen anders, demzufolge sie diese bitte vor dem Test überprüfen und bestätigen müssen. Beispiele sind in nachstehender Tabelle aufgeführt:

 

2. Eine Berechtigung für den COM-Anschluss ist in einige Betriebssystemen nicht standardmäßig erteilt. Sie muss eingestellt werden, bevor er genutzt werden kann. Lautet bei Linux/Ubuntu der Name des COM-Anschlusses z. B. „ttyUSB0“, führen Sie ihn einfach am Endgerät aus:

sudo chmod 666 /dev/ttyUSB0

 

Nachstehend werden zwei Testmethoden angeboten:

■Steuerung des seriellen Anschlusses am Endgerät

Verwenden Sie die Endgerät-Software des seriellen Anschlusses, die eine hexadezimale Eingabe unterstützt, und geben Sie nach der Verbindung den hexadezimalen Steuercode direkt ein:

 

Ist alles normal, sollten Sie sehen können, dass die Objekte des Geräts entsprechend unterschiedlicher Steuercodes agieren.

Mit dieser Methode wird jedoch nur getestet, ob die Verbindung erfolgreich ist; sie ist bei praktischer Anwendung nicht sonderlich zweckmäßig. Sollen optimale Ergebnisse erzielt werden, muss dies über das Programm geschehen. Und welche Sprache nimmt man? Wir können versuchsweise zuerst mit Python arbeiten, eine gängige plattformübergreifende Programmiersprache.

■Verwendung von Python

Folgende Programme werden mit Python 3 ausgeführt. Das Programm ist ziemlich einfach aufgebaut. Schreiben Sie einfach nur einmal pro Sekunde drei Sets von Steuercodes in den seriellen Anschluss, damit das Instrument am Gerät anfängt zu rotieren.
 

import serial from time import sleep """ The name of Com Port varies according to the operating system, For example: Raspberry Pi: /dev/ttyUSBn (e.g. /dev/ttyUSB0) Windows: COMn (e.g. COM22) """ # Raspberry Pi / Rasbian # COM_PORT = '/dev/ttyUSB0' COM_PORT = 'COM22' v000 = bytes.fromhex('7B06000600006251') v050 = bytes.fromhex('7B0600060032E384') v100 = bytes.fromhex('7B060006006463BA') ser = serial.Serial(COM_PORT, 115200) while True: ser.write(v000) sleep(1.0) ser.write(v050) sleep(1.0) ser.write(v100) sleep(1.0) ser.write(v050) sleep(1.0)

Der Python-Quellcode kann auf vielfältigen Plattformen ausgeführt werden, denn solange der Namen des seriellen Anschlusses korrekt ist, sollte er problemlos mit dem passenden Verbindungsprüfstand funktionieren.

Da diese starren Steuercodes des Beispiels nicht unbedingt auf praktische Anwendungen ausgerichtet sein müssen, müssen wir den Inhalt dieser Anweisungen verstehen, damit sie ganz zur Geltung kommen.

IV. Analyse der Steuercodes

 

■Vergleichsanalyse

Vergleichen Sie Befehle mit unterschiedlichen Werten für dasselbe Objekt:

Man sieht unschwer, dass der blaue Teil der Wert des Objekts ist, den wir einstellen.

Vergleichen Sie unterschiedliche Objekte, wobei derselbe Befehlswert verwendet wird:

Der blaue Teil bezieht sich offensichtlich auf eine Art von Index oder Adresse für das Objekt.

Hinsichtlich der Daten der letzten zwei Bytes gibt es anscheinend keine Regeln. Was bedeuten diese Meldungen also? Beachten Sie die nachstehende Erklärung.

■Analyse der Steuercodes

Beim Inhalt dieser 8 Byte handelt es sich in der Tat um die sogenannte Modbus-Meldung. Verdeutlichen Sie sich einfach anhand eines Bildes die Bedeutung der einzelnen Felder:

 

ID
Jedes Modbus-Gerät muss einen Identifizierungscode aufweisen. Der Identifizierungscode des Smart-Displays lautet 0x7B = 123

Fun(Funktionscode)
Der Funktionscode weist auf den Zweck dieser Meldung hin, „06“ steht hier z. B. für „Write Single Register“ (Schreiben im einzelnen Register), wobei auch ein Wert an der vorgegebenen Stelle geschrieben wird.

Register Address (Registeradresse)
Die Registeradresse ist das Ziel, in das geschrieben werden soll (nämlich die Adresse des Objekts).

Data (Daten)
Das, was geschrieben werden soll (nämlich der Wert des Objekts).

CRC
Mit dem Ergebnis der zyklischen Redundanzprüfung (CRC) in den ersten 6 Byte wird geprüft, ob während der Übertragung ein Fehler in den Daten aufgetreten ist.

Haben Sie eine Vorstellung davon? Wenn Sie mehr wissen möchten, müssen Sie anschauen, was Modbus ist.

V. Einführung in Modbus

 

■Modbus-Protokoll

Das Modbus-Protokoll ist eigentlich ein Datenformat. Es definiert hauptsächlich den Kommunikationsinhalt einer Master-Slave-Architektur. Da es sich hier nur um die Definition der Datenstruktur handelt, kann es über verschiedenartige reale Schnittstellen kommunizieren, z. B. RS232, RS422, RS485, und sogar über das Netzwerk.

Es gibt bereits viele Dokumente im Internet, mit denen Modbus unterrichtet und erklärt wird, sodass hierzu keine weiteren Details aufgeführt werden. Wenn Sie in der Tat bereits eine bestimmte Vorstellung haben, können Sie Modbus frei verwenden.

■Begriffsmodell

Modbus betrachtet die Datenübertragung als Zugriff auf ein „Register“. Jedes einzelne Gerät muss seinen eigenen Registertyp und seine Adresse für externe Bezugnahme festlegen. Bei der sogenannten Datenübertragung handelt es sich um einen Schreibvorgang in ein spezielles Register, wobei mit dem Lesen der Daten das Lesen des speziellen Registers gemeint ist, ein einfacher und klarer Vorgang. Zudem besteht der in jedem einzelnen Adressenregister gespeicherte Wert aus 16 Bit.

■Funktionscode

Entsprechend den Eigenschaften von Daten legt Modbus mehrere Methoden zum Lesen und Schreiben fest, die vom Funktionscode in der Meldung vorgegeben werden.

 

Für Steuerprogramme von Smart-Displays wird meistens „06“ verwendet: Write Single Register (schreibt einen 16-Bit-Wert) und Read Holding Registers (liest den Wert mehrerer Register).

■CRC

Die letzten 2 Byte sind anscheinend am rätselhaftesten, aber eigentlich nicht schwer zu entziffern. Es handelt sich hier zur Absicherung der Kommunikationsdaten nur um eine zyklische Redundanzprüfung (CRC). Es ist nicht erforderlich, dieses Prinzip eingehend zu studieren (es ist eigentlich nur eine Tabellensuche und ein Bit-Vorgang, bei dem abschließend ein 16-Bit-Prüfcode erhalten wird), solange wir verstehen, wie es verwendet wird.

VI. Steuerung von Smart-Display-Objekten

 

Wie bereits zuvor erwähnt, muss jedes einzelne Modbus-Protokoll den Typ und die Adresse des Registers festlegen. Wir werden dieses Thema jetzt besprechen.

■Registerklassifizierung

Smart-Display-Register lassen sich grob in drei Kategorien unterteilen:

1.)Geräteinformationen (z. B. Version, Gerätename usw.)
Verwendung von „04“: Read Input Register, die gelesen werden müssen. Diese Daten werden nur geändert, wenn die Firmware beim tatsächlichen Geräteanschluss aktualisiert wird, um die Parameter der Gerätemerkmale abzurufen.

2.)Objekteigenschaften (z. B. Art, Standort usw.)
Verwendung von „03“: Read Holding Register/16: Write Multiple Register, das gelesen und in das geschrieben werden muss. Diese Daten wirken sich auf das Aussehen von Objekten aus und ändern sich in der Regel nicht außerhalb der Designphase. Das Smart-Display muss zur Inhaltsänderung vorübergehend ausgeschaltet werden, bevor es aktualisiert werden kann.

3.)Objektwerte (Werte, die das Objekt repräsentieren, z. B. RPM, ein- oder ausgeschaltet, prozentualer Anteil usw., von Objekt zu Objekt variabel)
Dies ist das Element, das während des Ablaufs hauptsächlich geändert wird. Jedes Elements nutzt einen 16-Bit-Wert und ist demzufolge auf „06“ eingestellt: Write Single Register.

Es folgt eine organisierte Liste dieser Register:

■Input Registers

 

■Holding Registers

 

Frühe Smart-Displays unterstützen nur 10 Objekte mit einem Widget-ID-Bereich von 0 bis 9 (einschließlich). Die neue Firmwareversion wurde auf 64 erweitert, wobei sich allerdings die Adressiermethode geändert hat, die wir hier nicht besprechen werden.

Mit diesen Daten (zwar nicht vollständig, aber ausreichend zum aktuellen Zeitpunkt) können wir die Steueranweisungen verpacken und sie zur Steuerung an das Smart-Display senden. Wie verpackt und wie der CRC-Code hinzugefügt wird, wird in den folgenden Kapiteln erklärt.

VII. Nutzerschnittstelle

 

Damit sich das Smart-Display in der Praxis anwenden lässt, wird weiterhin eine geeignete Mensch-Maschine-Schnittstelle (insbesondere eine grafische Benutzeroberfläche, GUI) benötigt, um seine Leistungsfähigkeit zu maximieren. Aktuell stehen viele plattformübergreifende Plattformen zur GUI-Entwicklung zur Auswahl, wobei wir uns hier für Qt entschieden haben.

Viele Leute glauben, dass Qt nur eine GUI-Bibliothek ist; tatsächlich handelt es sich hierbei allerdings um ein ziemlich vollendetes Programmiergerüst für Entwicklungen. Wurde die Anwendung vollständig über ihre Klassenbibliothek implementiert, kann das Projekt mit geringfügigen Modifizierungen mühelos nach anderen Plattformen portiert werden (PC/Windows, Mac/MacOS, Raspberry Pi/Raspbian, Android, iOS, Embedded usw.). Das Programm ist eine Software mit Entwicklungstools, in die zu investieren sich zu ihrer Erlernung lohnt.

Die neuere Qt-Version unterstützt tatsächlich bereits die Modbus-Klassenbibliothek. Zur Veranschaulichung und, damit eine Neufassung in anderen Sprachen jedem ermöglicht wird, implementieren wir dieses Testprogramm jedoch ab den fundamentalsten Lese- und Schreibvorgängen für serielle Anschlüsse.

Neben der Bereitstellung der Funktion zur Wahl des seriellen Anschlusses und zur Übertragung des im vorherigen Beispiel verwendeten Steuercodes stellt dieses Beispiel darüber hinaus einen horizontalen Hebel in der Nutzerschnittstelle des App-Fensters zur Verfügung, mit dem der Wert des angegebenen Objekts eingestellt werden kann. Bei der Wahl von COM für den seriellen Anschluss dürfen Sie nicht vergessen, die konkrete Zahl einzutragen.

Die folgende Abbildung zeigt den Bildschirm zur Ausführung dieses Programms unter Raspberry Pi und Ubuntu. Das Programm bedarf keinerlei Modifizierung.

 

 

■CRC-Ablauf

Der CRC-Ablauf ist eigentlich nicht kompliziert. Er ähnelt wahrscheinlich den nachstehenden Codes für Qt:

QByteArray SetWidgetValue::calculateCRC(QByteArray data) { uint16_t crc = 0xFFFF; for(int idx = 0; idx < data.length(); idx++) { uint8_t i = (uint8_t)crc ^ data[idx]; crc >>= 8; crc ^= crcTable[i]; } QByteArray ba; ba.append(char(crc & 0xFF)); ba.append(char(crc >> 8)); return ba; }

The contents of crcTable[] are:

const uint16_t crcTable[] = { 0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241, 0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440, 0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40, 0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841, . . . 0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40, 0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41, 0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641, 0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040 };

Nicht jeder Code ist hier aufgelistet. GitHub stellt ausführliche Informationen bereit, die Nutzer selbst herunterladen können, sofern sie sich für die Programmierung interessieren. In diesem Artikel erklären wir nur den Ablauf mit dem Datenformat.

■Datenverpackung

Mit der folgenden Schlüsselfunktion wird der Steuercode gemäß der Nutzerschnittstelle berechnet und zum Smart-Display gesendet:

void SetWidgetValue::on_sbValue_valueChanged(int value) { int id = ui->edWidgetID->text().toInt(); sendWidgetValue(id, value); ui->lbValue->setText(QString::number(value)); } void SetWidgetValue::sendWidgetValue(int id, int value) { QByteArray msg; uint16_t addr = (uint16_t)(id * 100 + 6); msg.append(deviceID); msg.append(writeSingleRegister); msg.append((uint8_t)addr >> 8); msg.append((uint8_t)addr & 0xFF); msg.append((uint8_t)value >> 8); msg.append((uint8_t)value & 0xFF); QByteArray msgToSend = msg.append(calculateCRC(msg)); writeSerialPortData(msgToSend); }

Sind Sie bereits mit Qt vertraut, sollte es Ihnen nicht schwerfallen, den obigen Code zu verstehen. Sind Sie mit Qt nicht vertraut, nehmen Sie sich etwas Zeit und studieren Sie dieses Kit; einige der Konzepte sind eigentlich ziemlich gut und es lohnt sich, sie eingehender zu studieren. Nachdem Sie sich mit dem Kit vertraut gemacht haben, wird es bei der Entwicklung von plattformübergreifenden Anwendungen oder beim schnellen Prototyping eines Systems gute Dienste leisten.

VIII. Beispiel für Fortgeschrittene

 

Im vorherigen Beispiel wurde nur der Objektwert eingestellt. Es gibt ein umfassenderes Beispiel eines Anwendungsprogramms für Smart-Displaykonsolen, mit dem interessierte Leser mehr über dieses Thema erlernen können. Die nachstehende Abbildung zeigt den Bildschirm zur Ausführung unter Raspberry Pi:

 

Es gibt eine GitHub-URL am Ende dieses Artikels, auf die sich alle Personen gerne beziehen und gemeinsam studieren können.

IX. Abschluss

 

Wir erklärten jeden Schritt zur Steuerung von Smart-Displays und stellten auch eine Vielfalt an Steuermethoden zur Verfügung. Mit diesem Wissensstand und bei großem Einfallsreichtum glauben wir, dass verschiedenartige Funken emporsteigen und vielfältigere Produkte gefertigt werden können. Lasst uns zusammen eine bessere Zukunft mit Smart-Displays bauen!

X. Bezugsquellen

 

Serial Terminal Basics
https://learn.sparkfun.com/tutorials/terminal-basics/command-line-windows-mac-linux

Modbus
https://www.modbustools.com/modbus.html
https://www.modbusdriver.com/doc/mbusmaster.net/modbus.htm

XI. Sample source code

 

GettingStartedWithSmartDisplay
https://github.com/Smart-Display-Series/GettingStartedWithSmartDisplay.git

SmartDisplayConsole
https://github.com/Smart-Display-Series/SmartDisplayConsole.git