Visualisierung und Interaktion über die MATLAB®-GUI
Felix Kerner, 23.07.2026 – MATLAB-Startprozedur der MCU-Kommunikation
Callback-gesteuerter Gesamtaufbau
Die Startprozedur ist ereignisgesteuert aufgebaut. MATLAB® führt nicht alle Schritte in einem durchgehenden Funktionsaufruf aus, sondern wechselt abhängig vom erreichten Zustand zwischen drei seriellen Callback-Funktionen. Ein Callback wird jeweils ausgelöst, sobald eine durch den festgelegten Terminator abgeschlossene Datenzeile empfangen wurde.
- init_sim(): Prüfung und Identifikation des ausgewählten seriellen Ports.
- sim_initialisieren(): Schrittweise Initialisierung der Maschinensimulator-MCU über sim_iniFlag.
- sim_datenverarbeitung(): Übernahme nach Abschluss der Startprozedur und Auswertung nachfolgender Datenzeilen.
Der Callback des Buttons „SIM_MCU verbinden“ bereitet die serielle Kommunikation vor. Die eigentliche MCU-Identifikation erfolgt erst anhand einer Antwort auf einen gesendeten Identifikationsbefehl. Eine passende Portbezeichnung allein ist daher noch kein Nachweis dafür, dass die Maschinensimulator-MCU gefunden wurde.
Verbindungsaufbau über den Callback „Verbinden“
Nach Betätigen des Buttons „SIM_MCU verbinden“ erzeugt die App zunächst einen Vektor der aktuell verfügbaren seriellen Schnittstellen. Anschließend wird abhängig von der in systemFlag gespeicherten Betriebssystemkennung ein erster Port ausgewählt.
Windows: app.port_nummer wird zunächst auf 1 gesetzt. Der Wert bezeichnet den ersten Eintrag des Portvektors und nicht zwangsläufig die physische Schnittstelle COM1.
UNIX/macOS: Es wird der erste verfügbare Port ausgewählt, dessen Bezeichnung „/dev/tty.usbmodem“ enthält. Diese Zeichenfolge dient lediglich als Vorfilter für einen wahrscheinlichen USB-Serial-Port.
Linux oder unbekannte Systemkennung: In der derzeit beschriebenen Implementierung wird keine Verbindung aufgebaut.
Ist kein geeigneter Eintrag vorhanden, endet der Verbindungsversuch ohne Anlegen eines seriellen Objekts. Andernfalls wird der ausgewählte Port im nächsten Schritt getestet.
Konfiguration der seriellen Verbindung
Für den ausgewählten Port erzeugt MATLAB® das serielle Objekt app.MCU_SIM mit einer Übertragungsgeschwindigkeit von 115200 Baud. Danach wird „CR/LF“ als Zeilenende-Terminator konfiguriert und init_sim() als Callback für den Empfang einer vollständigen Datenzeile registriert. Abschließend sendet die App mit writeline() den Befehl „import ident“ an die MCU.
writeline() ergänzt den gesendeten Text um den für die Schnittstelle festgelegten Terminator. Auf der Empfangsseite bewirkt configureCallback(..., 'terminator', ...), dass MATLAB® erst nach Empfang einer vollständigen, abgeschlossenen Zeile in init_sim() wechselt.
Identifikation der Maschinensimulator-MCU in init_sim()
Bei jedem Aufruf liest init_sim() zunächst genau eine abgeschlossene Datenzeile über readline() ein. Ist die Protokollierung aktiviert, wird die empfangene Zeile mit Zeitstempel gespeichert. Anschließend wird der Inhalt der Zeile ausgewertet.
Behandlung der REPL-Ausgaben
Die MicroPython-REPL gibt neben fachlich relevanten Antworten auch den gesendeten Befehl als Echo und den Prompt „>>>“ aus. Diese Zeichenfolgen bilden keine eigenen fachlichen Zustände der Startprozedur. Enthält die eingelesene Zeile das Echo von „import ident“, sendet MATLAB® anschließend „ident.ident()“, damit die MCU ihre Kennung ausgibt. Eine Zeile mit „>>>“ wird ignoriert. Da der Prompt selbst üblicherweise nicht mit CR/LF abgeschlossen ist, kann er auch zusammen mit einer nachfolgenden Echozeile im Empfangspuffer erscheinen.
Erfolgreiche Identifikation
Enthält die Identifikationsantwort die Kennung „sim“ und ist app.sim_mcuFlag noch nicht gesetzt, wird der Port als Verbindung zur Maschinensimulator-MCU bestätigt. Die App kennzeichnet den Simulator als verbunden, verhindert einen erneuten parallelen Verbindungsaufbau und setzt den seriellen Callback auf sim_initialisieren(). Anschließend ruft MATLAB® sim_initialisieren() einmal direkt auf, um den ersten Initialisierungsschritt auszulösen. Der bloße Callback-Wechsel würde die Funktion noch nicht ausführen.
Prüfung weiterer Ports
Erst wenn die Antwort die ausgewählte MCU eindeutig nicht als Maschinensimulator identifiziert, wird der nächste Port geprüft. Unter Windows wird dazu der Index app.port_nummer erhöht. Unter UNIX/macOS wird der nächste verfügbare Port mit der Kennung „/dev/tty.usbmodem“ gewählt. Für jeden neuen Port werden das serielle Objekt, der Terminator und init_sim() erneut konfiguriert; danach beginnt die Identifikation wieder mit „import ident“. Wird der letzte vorhandene Port geprüft, ohne den Maschinensimulator zu identifizieren, versucht der bestehende Code, auf einen nicht vorhandenen Port zuzugreifen, wodurch ein Indexfehler entsteht.
MCU-Initialisierung in sim_initialisieren()
_Flowchart_1.png)
_Flowchart_2.png)
Die Funktion sim_initialisieren() bildet eine Zustandsfolge, deren aktueller Schritt in app.sim_iniFlag gespeichert ist. Jeder Zustand sendet genau einen REPL-Befehl. Die daraufhin von der MCU zurückgegebene, mit dem Terminator abgeschlossene Zeile löst den nächsten Aufruf derselben Callback-Funktion aus. Dadurch wird die Initialisierung schrittweise und in einer festgelegten Reihenfolge abgearbeitet.
Beim ersten direkten Aufruf startet sim_initialisieren() die zustandsbasierte Initialisierungsfolge. Dabei wird noch keine Zeile eingelesen. Die nachfolgenden Aufrufe erfolgen durch den seriellen Callback, sobald eine terminierte Antwort der MCU vorliegt. Diese Antwort wird eingelesen und bei aktiviertem Protokoll anschließend gespeichert. Danach wird über switch app.sim_iniFlag der zum aktuellen Zustand gehörende Initialisierungsschritt ausgeführt.
- Zustand 0: Das MicroPython-Modul maschinensimulator wird importiert.
- Zustände 1 bis 8: Die acht Potentiometer werden nacheinander auf den definierten Startwert 250 gesetzt.
- Zustände 9 bis 12: Die vier Füllstände beziehungsweise Kurzschlussschalter werden nacheinander ausgeschaltet.
- Zustand 13: Das Modul uart_lib wird importiert.
- Zustand 14: Das Modul token_lib wird importiert.
- Zustand 15: Der UARTHandler wird mit uart_id = 0 und einer Baudrate von 230400 initialisiert.
- Zustand 16: Der Callback wird auf sim_datenverarbeitung() umgestellt. Erst danach sendet MATLAB® den abschließenden Befehl „import machine“.
Die getrennten Zustände 13 und 14 stellen sicher, dass uart_lib und token_lib jeweils durch einen eigenen, rückmeldegestützten Initialisierungsschritt geladen werden. Der UARTHandler wird erst erzeugt, nachdem beide Module verfügbar sind.
Übergang zu sim_datenverarbeitung()
_Flowchart.png)
Der Abschlussbefehl „import machine“ hat neben dem Import eine wichtige Ablaufwirkung: Seine REPL-Rückgabe liefert die nächste terminierte Datenzeile und löst damit erstmals den bereits registrierten Callback sim_datenverarbeitung() aus. Ohne einen abschließenden REPL-Befehl würde der Callback-Wechsel allein noch keinen Funktionsaufruf verursachen.
sim_datenverarbeitung() liest die eingegangene Zeile ein. Wird darin das Echo von „import machine“ erkannt, meldet die App den Maschinensimulator als initialisiert. Technische REPL-Bestandteile wie „>>>“ werden aus den empfangenen Daten entfernt beziehungsweise ignoriert. Mit dieser Bestätigung ist die MATLAB®-Startprozedur beendet. Die anschließende Verarbeitung regulärer Mess-, Aktor- oder Tokendaten gehört zum laufenden Betrieb und liegt außerhalb des hier dokumentierten Ablaufs.
Erstellung des Texts mit Unterstützung von ChatGPT®.
Armin Rohnen, 20.05.2026 - Programmgerüst der MATLAB® Maschinensimulator / Wartungs - APP
Aufgrund der nichtlinearität der digitalen Potis und der Auswirkung der Schaltungstoleranzen auf den Platinen sind Kennlinien für die Übersetzung von phys. Wert der eingestellt werden soll zu Digitalwert für die Einstellung des jeweiligen Potis erforderlich. Die Ermittlung dieser Kennlinien erfordert den gelichzeitigen Betrieb von mindestens zwei MCUs an einem PC. Das ist mit Thonny nicht darstellbar. Da sich die gleiche Situation für die spätere Nutzung des Maschinensimulators ebenso ergeben wird und eine einfache Bedienung ermöglicht werden soll, ist die Entscheidung getroffen worden, dass der Maschinensimulator integraler Bestandteil der Wartungs-App wird.
Zum Zeitpunkt der Kennlinienermittlung lag noch kein Progarmmgerüst der Wartungs-App vor. Um jedoch nicht in weiteren Zeitverzug zu geraten, wurde im Zuge der Kennlinienermittlung für den Maschinensimulator das Programmgerüst für die Wartungs-App erstellt.
Um mit die Wartungs-App betreiben zu können und um mit dem Maschinensimulator arbeiten zu können, muss die MCU des Maschinensimulators via USB angeschlossen sein. Über den Button erfolgt der Verbindungsaufbau mit der Maschinensimulator MCU. Dieser Verbindungsaufbau ist bislang lediglich für das Betriebssystem UNIX /macOS realisiert. Für andere Betriebssysteme muss dies noch erfolgen. In der Initialisierung der Maschinensimulator MCU erfolgt auch nur jener Teil, welcher für die Bestimmung der Digitalwert-Kennlinien erforderlich ist. Insbesondere erfolgt noch nicht die UART-initialisierung und ebenso keine Weiterleitung der Token.
Wenn der Maschinensimulator verbunden ist, wird der Verbindungsaufbau zu einer Messplatine freigegeben und es ist möglich eine MCU-Verbindung mit einer Messplatine aus der Multi-MCU-Baureihe aufzubauen. Ist die Verbindung aufgebaut kann über den Button "Messwerte erfassen" Messwertdatensätze für die jeweils 8 Messkanäle erfasst und verarbeitet werden. Um diese Art der Messwerterfassung durchführen zu können ist auf der MCU der Messplatine das Python-Programm mwp_chanMesswerte.py erforderlich, was sich in der ZIP-Datei 20260516_Simulator_Wartungs_APP.zip auf der Wiki-Seite des Programmcodes befindet. Bei jedem erfassten Messdatensatz wird aus den ermittelten Spannungswerten über die logische phys. Umrechnung oder über die erforderliche Kennlinie aus dem Spannungswert auf den phys. Wert umgerechnet. Die Werte werden in der Messwerttabelle (rechte Tabelle) als Spannungswert in [mV] und im jeweiligen phys. Messwert ausgegeben. In der linken Tabelle kann der jeweilige Simulationswert eingegeben werden. Entweder als Digitalwert oder als phys. Wert. Im falle der phys. Werteeingabe wird über die ermittelte Kennlinie auf den erforderlichen Digitalwert umgerechnet und dieser wird dann auf dem Maschinensimulator eingestellt. Da die Digitalpotentiometer lediglich über eine 8-Bit-Auflösung verfügen, ist diese Einstellung recht grob und der gemessene Wert weicht vom gewünschten Einstellwert oft ab.
Die Kennlinienermittlung läuft automatisiert ab und dauert ca. 15 Min. Damit diese nicht versehentlich ausgelöst wird, ist sie über einen Switch zusätzlich verriegelt.
Für den Kommunikation mit dem Maschinensimulator und der Messwertplatine ist ein jeweils 4zeiliges Statusfeld angelegt. Hier werden die zugehörigen Statusmeldungen angezeigt.
Programmstuktur
function startupFcn(app)
Wird zum Start der App durchgeführt. Hier werden alle Voreinstellungen durchgeführt, es werden die erforderlichen Kennlinien eingelesen und es wird der "Trace" vorbereitet.
Es wird das Betriebssystem des ausführenden Host ermittelt. Allerdings erfolgt lediglich für "UNIX/macOS" eine Abarbeitung. Damit ist diese App für die Nutzung auf anderen betriebssystemen als "UNIX/macOS" noch anzupassen.
function SimulatorVerbindenButtonPushed(app, event)
Der Button Simulator Verbinden führt die Funktion SimulatorVerbindenButtonPushed aus. Es wird über den ersten freien USB-Port versucht die Verbindung zum Maschinensimulator aufzubauen. Dieser Teil des Programmcodes ist individuell für "UNIX/macOS" programmiert und muss für andere Betriebssysteme noch angepasst werden.
Zur Abarbeitung der ersten Daten vom Maschinensimulator wird die Funktion init_sim als ISR konfiguriert.
function init_sim(app, ~, ~)
Zur Indentifikation des Maschinensimulators wurde auf dieser MCU die Funktion ident aufgerufen. Diese gibt die Platinenkennung zurück und es kann entschieden werden ob der Port gewechselt werden muss oder tatsächlich der Maschinensimulator angeschlossen ist. Ist der Maschinensimulator angeschlossen, erfolgt die tatsächliche Initialisierung des Maschinensimulators in der Funktion sim_initialisieren.
function sim_initialisieren(app, ~, ~)
Für die Initialisierung des Maschinensimulators werden alle Digitalpotis auf Digitalwert 250 gestellt und alle Kurzschlüsse (Füllstandssimulationen) geöffnet.
Für das weitere Interrupthandling der eingehenden Daten wird das ISR auf die Funktion sim_datenverarbeitung umgestellt.
Als letzte Aktion in der Initialisierung wird auf der Maschinensimulator-MCU "import machine" durchegführt. Dies muss die letzte Aktion bleiben, da über die nachfolgende ISR Abarbeitung durch das Echo des Aufrufs die Betriebsbereitschaft erkannt wird. Weitere Initialisierungsschritte müssen vor diesem Aufruf eingefügt werden.
function sim_datenverarbeitung(app, ~, ~)
Die Funktion sim_datenverarbeitung übernimmt die eigentliche Abarbeitung der von der Maxchinensimulator gesendeten Daten.
Stand 20.05.2026 wird lediglich das Logging durchgeführt.
Die weitere Funktionalität muss noch hinzugefügt werden.
function KalibrierungVerbindenButtonPushed(app, event)
Der Button Espressomaschine/Messplatine (Kalibrierung) Verbinden führt die Funktion KalibrierungVerbindenButtonPushed aus. Es wird über den ersten freien USB-Port versucht die Verbindung zr Messwertplatine aufzubauen. Dieser Teil des Programmcodes ist individuell für "UNIX/macOS" programmiert und muss für andere Betriebssysteme noch angepasst werden.
Zur Abarbeitung der ersten Daten von der Messwertplatine wird die Funktion init_kal als ISR konfiguriert.
function init_kal(app, ~, ~)
Zur Indentifikation der Messwertplatine wurde auf dieser MCU die Funktion ident aufgerufen. Diese gibt die Platinenkennung zurück und es kann entschieden werden ob der Port gewechselt werden muss oder tatsächlich eine Messwertplatine angeschlossen ist. Ist eine Messwertplatine angeschlossen, erfolgt die tatsächliche Initialisierung der Messwertplatine in der Funktion kal_initialisieren.
function kal_initialisieren(app, ~, ~)
Für die Initialisierung der Messwertplatine wird die Anweisung "writeline(app.MCU_KAL, 'from mwp_chanMesswerte import mwp_chanMesswerte');" durchgeführt. Dazu muss isch auf der Messwertplatine die Datei mwp_chanMesswerte.py befinden.
Für das weitere Interrupthandling der eingehenden Daten wird das ISR auf die Funktion kal_datenverarbeitung umgestellt.
Als letzte Aktion in der Initialisierung wird auf der Messwertplatinen-MCU "import machine" durchegführt. Dies muss die letzte Aktion bleiben, da über die nachfolgende ISR Abarbeitung durch das Echo des Aufrufs die Betriebsbereitschaft erkannt wird. Weitere Initialisierungsschritte müssen vor diesem Aufruf eingefügt werden.
function MesswerteErfassenButtonPushed(app, event)
Der Button Messwerte Erfassen löst die Funktion MesswerteErfassenButtonPushed aus. Darin wird die Anweisung "writeline(app.MCU_KAL, 'mwp_chanMesswerte(0)');" ausgeführt, was die Messung von Messwert Kanal(0) auf der Messwertplatine auslöst. Ist die Messung abgeschlossen wird der Messwert an die APP zurück gesendet und über den ISR wird die Funktion kal_datenverarbeitung ausgeführt.
function kal_datenverarbeitung(app, ~, ~)
Die Funktion kal_datenverarbeitung übernimmt die Datenverarbeitung der von der Messwertplatine kommenden Daten. Ist dies ein Messwert der zu keiner Kalibrierung gehört wird der Messwert logisch und ohysikalisch verarbeitet und im entsprechenden Datenfeld ausgegeben. Es wird danach die Messung des nächsten Messwertkanals angestoßen.
Gehört der Messwert zu einer Kalibrierdurchführung, wird dieser in die zugehörige Stelle der Kalibriermatrix eingefügt und es wird die nächst folgende Kalibrierstufe ausgeführt. Zum Abschluss der Kalibrierung wird die Kalibriermatrix abgespeichert.
Armin Rohnen, 11.04.2024
In der Übergangsphase soll der Betriebsstart der Espressomaaschine von der MATLAB®-GUI ausgelöst werden.
Die aktuelle MATLAB®-GUI soll in eine komfortable Bedienoberfläche für Wartungs- und Einstellarbeiten überführt werden. Alle Tastenfunktionalitäten und die Vertikalhebelfunktionalität sollen über die Oberfläche durchgeführt werden können.Wie bisher soll jeder Aktor (Magnetventile, Pumpenleistung und Schrittmotorverstellungen) über die GUI ausgelöst werden können. Ebenso soll die bisherige Visualisierung der Messwerte und Schaltzustände erhalten bleiben. Dies allerdings mit einer geringeren Aktualisierungsrate. Vier Aktualisierungen je Sekunde werden als ausreichend angesehen.