mikrocontroller.net

Forum: PC-Programmierung Messen und Plotten von Sensordaten


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
Autor: PeachPii (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Guten Abend,
leider bin ich kein Programmierer, würde aber gerne ein Programm 
schreiben mit dem ich Sensordaten erfassen kann. Mir ist es eher wichtig 
zu wissen welche Möglichkeiten es gibt und was eurer Meinung nach am 
einfachsten zu realisieren ist.

Was ich möchte:
- Verschiedene Sensordaten über die serielle Schnittstelle eines 
Mikrocontrollers am Laptop erfassen.
- Die Daten in einem Plot live darstellen lassen.
- Während der Messung möchte ich z.B. die Drehzahl von Motoren, welche 
ich auch über die serielle Schnittstelle ansteure verändern, also z.B. 
mit einem Schieberegler oder einer einprogrammierten Funktion 
beschleunigen.
- Dann würde ich gerne alle Daten im Hintergrund aufzeichnen lassen, so 
dass ich diese z.B. als txt oder CSV Datei abspeichern kann, um diese in 
Excel auszuwerten.

Womit könnte ich das am besten realisieren? Ich erläutre im Folgenden 
Mal von welchen Möglichkeiten ich bisher gelesen habe und welche vor und 
Nachteile mir dabei aufgefallen sind.

LabView:
Für LabView habe ich noch eine Lizenz. Ich denke, dass man damit alles 
machen kann. Die Daten können geplottet und als tdms Datei exportiert 
werden. Außerdem stehen alle möglichen Bedienelemente zur Verfügung.

Man kann es kompilieren, aber vermutlich nicht auf jedem Rechner laufen 
lassen. Außerdem ist es nicht kostenlos und man immer Abhängig von NI.

Python:
Mit Python kann man glaube ich Sensordaten auslesen. Die Darstellung mit 
der Matplotlib geht auch. Der Vorteil bei der Matplotlib ist, dass man 
im Bedienfeld direkt das aktuelle Bild als Vektordatei abspeichern kann.

Ich glaube nicht, dass es so einfach ist daraus ein GUI zu basteln.

Qt:
Ich glaube das ist so eine Art Entwicklungsumgebung für 
Benutzeroberflächen. Leider ist mir nicht klar, ob das C++ ist oder 
Python, da ich dies schon im Zusammenhang mit C++ und Python (PyQt5) 
gelesen habe. Es gibt auf YouTube einige Beispiele mit Qt und Arduino, 
jedoch sind das C++ Beispiele. Ich denke das dies wahrscheinlich 
geeignet ist, jedoch kann ich nicht sagen, ob die Beispiele 1:1 auf PyQt 
übertragen werden können? Ansonsten gibt es einen Qt Designer und die 
Beispiele die ich gesehen habe, sahen echt gut aus.

Java:
Für Java habe ich eigentlich schon eine Fertige Anwendung gesehen, die 
genau das macht, was ich mir in etwa vorgestellt habe:
http://www.farrellf.com/TelemetryViewer/

wobei ich eben etwas haben möchte, was genau auf meine Anwendung 
zugeschnitten ist.

Matlab:
Geht denke ich auch, möchte ich aber ungern benutzen.


Processing / P5.js

Mit beiden habe ich schon viele Sachen gemacht. Mit Processing schon 
viel in Verbindung mit dem Arduino. P5.js lässt sich nicht so einfach 
für die serielle Schnittstelle einrichten leider.
Außerdem ist Processing nicht gut geeignet um z.B. herkömmliche Graphen 
zu plotten oder Daten zu exportieren.



Falls Jemand einen Tipp hat wie ich am besten so etwas in klein 
realisieren kann oder mir ein paar nützliche Links als Antwort anhängt 
mit deren Hilfe ich mir so etwas zusammen basteln kann, dann wäre ich 
sehr dankbar.
Natürlich werde ich noch viel Arbeit dort hineinstecken müssen, um mir 
das entsprechende Wissen anzueignen. Mir ist es jedoch erst einmal 
wichtig, dass es überhaupt klappt. Im Anschluss kann ich dann natürlich 
alles Schritt für Schritt verbessern.

Autor: Sven B. (scummos)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Kommt ein bisschen darauf an, wie wichtig dir die Live-Funktionalität 
ist, die mit matplotlib (Python) leider kaum realisierbar ist.

Mit C++/Qt5 kannst du eine Plot-Bibliothek wie Qwt oder QCustomPlot 
benutzen, das ist sehr schnell und man kann sehr schöne Darstellungen 
damit machen, aber der Aufwand ist immens viel höher als ein kleines 
Python-Skript zusammenzubauen.

Für Prototypen kann man sich finde ich auch fast überlegen, die Daten 
einfach nur mit Python in eine Datei zu schreiben, und alle 2 Sekunden 
in ein PDF zu exportieren ... ist halt super einfach zu machen und 
genügt oft.

Autor: Dr.Möbius (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
PeachPii schrieb:
> Für LabView habe ich noch eine Lizenz. Ich denke, dass man damit alles
> machen kann. Die Daten können geplottet und als tdms Datei exportiert
> werden. Außerdem stehen alle möglichen Bedienelemente zur Verfügung.

Daran hatte ich auch sofort gedacht. Man muss es natürlich schon können, 
jedoch ist LabView konfortabel was die Serielle angeht und auch das 
Plotten. Relativ einfach würde ich sagen.
Probleme könntest du bei der Datenübertragung bekommen, wie willst du 
die Übertragung gegen Bitfehler absichern, CRC ? Müsste natürlich in 
Labview und auf dem Arduino implementiert werden.

Autor: Dr.Möbius (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Du benötigst auf dem Zielrechner die LabView Runtime (ca 300MB 
Downloadfile)

Autor: Yalu X. (yalu) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
PeachPii schrieb:
> Python:
> Mit Python kann man glaube ich Sensordaten auslesen. Die Darstellung mit
> der Matplotlib geht auch. Der Vorteil bei der Matplotlib ist, dass man
> im Bedienfeld direkt das aktuelle Bild als Vektordatei abspeichern kann.
>
> Ich glaube nicht, dass es so einfach ist daraus ein GUI zu basteln.

Matplotlib bietet die Möglichkeit, GUI-Elemente auf einfache Weise
direkt in den Plot zu integrieren. Das sieht dann bspw. so aus:

  https://matplotlib.org/gallery/widgets/slider_demo.html

Sven B. schrieb:
> Kommt ein bisschen darauf an, wie wichtig dir die Live-Funktionalität
> ist, die mit matplotlib (Python) leider kaum realisierbar ist.

Wieso sollte das nicht gehen?

: Bearbeitet durch Moderator
Autor: Sven B. (scummos)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Yalu X. schrieb:
> Sven B. schrieb:
>> Kommt ein bisschen darauf an, wie wichtig dir die Live-Funktionalität
>> ist, die mit matplotlib (Python) leider kaum realisierbar ist.
>
> Wieso sollte das nicht gehen?

Weil es für mehr als ein paar Werte zu langsam ist und krasse Memory 
Leaks hat. In C++/Qt kann ich problemlos 50.000 Werte zehnmal pro 
Sekunde neu zeichnen, mit matplotlib bricht das nach kürzester Zeit 
auseinander, wenn es überhaupt funktioniert.

Autor: Walter T. (nicolas)
Datum:

Bewertung
1 lesenswert
nicht lesenswert
PeachPii schrieb:
> Matlab:
> Geht denke ich auch, möchte ich aber ungern benutzen.

Schade eigentlich. Für solche Anwendungsfälle hat mir die 
Arduino-Toolbox, mit der sich ein Ardino als interaktiv steuerbares 
Breakout-Board benutzen läßt, schon gute Dienste erwiesen.

Autor: Sebastian S. (amateur)
Datum:

Bewertung
-1 lesenswert
nicht lesenswert
Wenn Dein Dingsbums RS232 kann, solltest Du mal Excel (falls Du mit 
Windoof arbeitest) anwerfen.

Das speichert Dir die Daten und Du kannst die Anzeigeoptionen verwenden. 
Das Wie wird an hunderten Stellen im Netz erläutert.

Da die meisten das Programm haben, brauchst Du nur noch einen Wandler 
(RS232->USB). Die gibt es aber an jeder Ecke. Arbeitest Du mit einer 
Antiquität, hast Du eventuell sogar noch einen direkten Anschluss 
(9-Poliger SUB-D-Stecker) für eine serielle Schnittstelle.

: Bearbeitet durch User
Autor: Olaf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Qt:
> Ich glaube das ist so eine Art Entwicklungsumgebung für
> Benutzeroberflächen. Leider ist mir nicht klar, ob das C++ ist oder
> Python, da ich dies schon im Zusammenhang mit C++ und Python (PyQt5)
> gelesen habe.

Qt ist im Prinzip eine Programmiersprache die C++ ein kleines bisschen 
erweitert. Die Unterschiede sind aber IMHO relativ gering. Ausserdem ist 
es noch eine sehr grosse Klassenbibliothek. Es wird also sehr viel an 
Funktionalitaet mitgeliefert die du einfach so nutzen kannst.

Ausserdem gibt es wohl noch eine Pythonversion die Qt nutzt. Die Idee 
dahinter duerfte wohl sein die Klassenbibliothek von Qt zu nutzen und 
sich nicht der Anstrengung unterziehen zu muessen C++ zu lernen.

Wenn man noch kein C++ kann dann ist der Einstieg in Qt nicht mal eben 
so. Allerdings lohnt er sich weil man damit Programme fuer alle grossen 
Betriebssysteme entwickeln kann.

Olaf

Autor: Sven B. (scummos)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Olaf schrieb:
>> Qt:
>> Ich glaube das ist so eine Art Entwicklungsumgebung für
>> Benutzeroberflächen. Leider ist mir nicht klar, ob das C++ ist oder
>> Python, da ich dies schon im Zusammenhang mit C++ und Python (PyQt5)
>> gelesen habe.
>
> Qt ist im Prinzip eine Programmiersprache die C++ ein kleines bisschen
> erweitert.

Hm, nein. Qt ist eine C++-Bibliothek und keine Erweiterung der Sprache. 
C++-Code, der Qt verwendet, kann von jedem normalen, standardkonformen 
C++-Compiler übersetzt werden.

Was es gibt ist der MOC, der zusätzlichen Code automatisch generiert. 
Das ist aber keine Spracherweiterung, sondern ein Code-Generator. Bei 
anderen Bibliotheken wie glib schreibt man sich diesen Code von Hand, 
das könnte man bei Qt auch machen. Ist nur bequemer so.

Autor: Mathias M. (matjes)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich werfe noch electron in den Ring. Das ist im Prinzip ein Standalong 
Chrome Browser, der dann HTML5 als Programm ausführt und auch auf 
externe Schnittstellen und das Dateisystem und so zugreifen kann.
Pro: Kostenlos, open source, Plattformunabhängig und meiner Meinung nach 
relativ einfach und schnell zu entwickeln
Contra: Hello World ist >50MB groß, mittelmäßig schnell.

Ich hab damit kürzlich ein ähnliches Problem gelöst und war damit sehr 
zufrieden. Ich musste aber auch nicht mehrmals 50k Werte/s neu zeichnen, 
sondern nur ein paar.

Autor: Adlerküken (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
PeachPii schrieb:
> was eurer Meinung nach am
> einfachsten zu realisieren ist.

Evtl. das hier

Beitrag "Projekt: Virtuelle Instrumente an serielle Schnittstelle"

Autor: Olaf (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> Hm, nein. Qt ist eine C++-Bibliothek und keine Erweiterung der Sprache.
> C++-Code, der Qt verwendet, kann von jedem normalen, standardkonformen
> C++-Compiler übersetzt werden.

> Was es gibt ist der MOC, der zusätzlichen Code automatisch generiert.

Aehem, doch. :)

Ich verstehe es eher so das der MOC den Qt-Source in C++-Source 
umwandelt.

Wie konnte sonst dein normaler C++ Compiler

public slots:


übersetzen? Also im Prinzip das ganze slot-Konzept das die damals 
eingefuehrt haben?

Olaf

Autor: Sven B. (scummos)
Datum:

Bewertung
1 lesenswert
nicht lesenswert
Olaf schrieb:
> Ich verstehe es eher so das der MOC den Qt-Source in C++-Source
> umwandelt.
Dann verstehst du es falsch.

> Wie konnte sonst dein normaler C++ Compiler
>
> public slots:
Weil slots und Q_SLOTS defines auf leer sind und signals und Q_SIGNALS 
defines auf "public".
https://code.woboq.org/qt5/qtbase/src/corelib/kernel/qobjectdefs.h.html#_M/Q_SLOTS

> übersetzen? Also im Prinzip das ganze slot-Konzept das die damals
> eingefuehrt haben?
Das ist zusätzlicher Meta-Code, der generiert und zum Programm 
dazugelinkt wird. Dein Code wird dabei nicht verändert und kompiliert 
auch ohne den MOC-Code. (Er linkt u.U. nicht, aber das ist etwas 
anderes)

: Bearbeitet durch User
Autor: Yalu X. (yalu) (Moderator)
Datum:
Angehängte Dateien:

Bewertung
1 lesenswert
nicht lesenswert
Sven B. schrieb:
> Yalu X. schrieb:
>> Sven B. schrieb:
>>> Kommt ein bisschen darauf an, wie wichtig dir die Live-Funktionalität
>>> ist, die mit matplotlib (Python) leider kaum realisierbar ist.
>>
>> Wieso sollte das nicht gehen?
>
> Weil es für mehr als ein paar Werte zu langsam ist und krasse Memory
> Leaks hat. In C++/Qt kann ich problemlos 50.000 Werte zehnmal pro
> Sekunde neu zeichnen, mit matplotlib bricht das nach kürzester Zeit
> auseinander, wenn es überhaupt funktioniert.

Das angehängte Programm plottet auf einem schon betagten Laptop mit
einem i7-4910MQ (2.90GHz) 12 bis 13 Sinuskurven mit jeweils 1.000.000
Werte. Um die Geschwindigkeit mit deinem C++-Programm vergleichen zu
können, müsste man dieselben Daten und die gleiche Fenstergröße
verwenden. Aber dass Matplotlib für "mehr als ein paar Werte zu langsam"
ist, halte ich für etwas übertrieben.

Für die Darstellung des zeitlichen Verlaufs von Messdaten ist die Anzahl
der unterscheidbaren Datenpunkte ohnehin durch die horizontale Auflösung
des Bildschirms auf 1920 oder 3840 begrenzt. Zudem will der TE die Daten
über eine serielle Schnittstelle (vermutlich RS-232) einlesen, was wohl
die Hauptbremse der ganzen Angelegenheit darstellen wird.

Mit den Memory-Leaks scheinst du recht zu haben, auch wenn ich sie nicht
als "krass" bezeichnen würde. Für jede Aktualisierung der dargestellten
Kurve gehen ca. 1,5kB verloren, und das unabhängig von der Anzahl der
Datenpunkte. Damit kann man das Programm zwar stunden-, aber nicht
tagelang laufen lassen. Ich habe allerdings noch nicht herausfinden
können, ob es sich dabei um einen Bug in Matplotlib handelt, oder ob es
an meiner Unfähigkeit liegt, diese Bibliothek "richtig" anzuwenden.

Autor: Sven B. (scummos)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Yalu X. schrieb:
> Das angehängte Programm plottet auf einem schon betagten Laptop mit
> einem i7-4910MQ (2.90GHz) 12 bis 13 Sinuskurven mit jeweils 1.000.000
> Werte. Um die Geschwindigkeit mit deinem C++-Programm vergleichen zu
> können, müsste man dieselben Daten und die gleiche Fenstergröße
> verwenden. Aber dass Matplotlib für "mehr als ein paar Werte zu langsam"
> ist, halte ich für etwas übertrieben.

Das geht nur, weil die Daten extrem gutmütig sind und intern das 
Zeichnen optimiert wird. Plotte mal sin(10000*xdata), was ordentlich 
oszilliert (und einem rauschigen ADC-Sample-Chunk deutlich näher kommt), 
dann hast du nur noch 1 fps. Bei 100000*xdata wirft es eine Exception.

> Für die Darstellung des zeitlichen Verlaufs von Messdaten ist die Anzahl
> der unterscheidbaren Datenpunkte ohnehin durch die horizontale Auflösung
> des Bildschirms auf 1920 oder 3840 begrenzt.

Njaa, das stimmt nicht ganz, weil trotzdem alle Punkte für die korrekte 
Darstellung relevant sind wenn du keine Aliasing-Effekte haben willst.

> Zudem will der TE die Daten
> über eine serielle Schnittstelle (vermutlich RS-232) einlesen, was wohl
> die Hauptbremse der ganzen Angelegenheit darstellen wird.

Das ist natürlich gut möglich.

> Mit den Memory-Leaks scheinst du recht zu haben, auch wenn ich sie nicht
> als "krass" bezeichnen würde. Für jede Aktualisierung der dargestellten
> Kurve gehen ca. 1,5kB verloren, und das unabhängig von der Anzahl der
> Datenpunkte. Damit kann man das Programm zwar stunden-, aber nicht
> tagelang laufen lassen.

Ja, ungefähr so. Hat man dann noch mehrere Diagramme, ist es noch 
schneller vorbei.

> Ich habe allerdings noch nicht herausfinden
> können, ob es sich dabei um einen Bug in Matplotlib handelt, oder ob es
> an meiner Unfähigkeit liegt, diese Bibliothek "richtig" anzuwenden.

Mir geht's jedenfalls auch so, und ich kenne fähige auch Menschen die 
länger versucht haben das hinzubekommen und es nicht geschafft haben.

Autor: Yalu X. (yalu) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sven B. schrieb:
> Das geht nur, weil die Daten extrem gutmütig sind und intern das
> Zeichnen optimiert wird. Plotte mal sin(10000*xdata), was ordentlich
> oszilliert (und einem rauschigen ADC-Sample-Chunk deutlich näher kommt),
> dann hast du nur noch 1 fps. Bei 100000*xdata wirft es eine Exception.

Bei mir wird die Sache zwar langsam, bricht aber nicht ab.

>> Für die Darstellung des zeitlichen Verlaufs von Messdaten ist die Anzahl
>> der unterscheidbaren Datenpunkte ohnehin durch die horizontale Auflösung
>> des Bildschirms auf 1920 oder 3840 begrenzt.
>
> Njaa, das stimmt nicht ganz, weil trotzdem alle Punkte für die korrekte
> Darstellung relevant sind wenn du keine Aliasing-Effekte haben willst.

Es ist aber unsinnig, dieses Akkumulieren von Daten direkt auf dem
Ausgabemedium vorzunehmen. Auf einem realen Stiftplotter würde durch
eine solche Aktion das Papier in seine Bestandteile zerfallen :). Auf
dem Bildschirm geht zwar nichts kaputt, aber das unnötige hundertfache
Beschreiben immer wieder derselben Pixel kostet eben seine Zeit.

Viel effizienter ist es, die Daten vorab passend auszudünnen, aber
natürlich nicht einfach durch Herauspicken jedes k-ten Datenpunkts (das
gibt Aliasing), sondern durch die Bildung des Minimums und des Maximums
innerhalb eines Intervalls von k Punkten. Das geht recht fix und
entlastet die Grafikausgabe ungemein. Möglicherweise tun dies andere
Plotprogramme automatisch, es ist aber auch kein großer Aufwand, dies
selber zu programmieren.

Autor: Sven B. (scummos)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
Stimmt natürlich.

Insgesamt kann man es schon machen, ich hatte das vielleicht etwas 
überspitzt formuliert. Aber das Memory-Leak-Problem und die Performance 
machen es irgendwie nicht zur schönen Lösung.

Ich plotte z.B. im Moment viele Daten wie die im Anhang, das ist ein 
Interferogramm mit ca 2M Punkten. Mit QCustomPlot kann man darauf mit 
60fps herumzoomen (was auch wichtig ist), in matplotlib braucht jedes 
neue Zeichnen ca eine Sekunde, was es für interaktive Anwendungen kaum 
verwendbar macht.

Es kommt wie immer auf die Anwendung an. Ich denke aber, matplotlib ist 
für interaktive Anwendungen einfach nicht entworfen. Es kann zwar so ein 
bisschen was, aber an sich scheint mir der Fokus das Produzieren von 
qualtitativ hochwertigen Diagrammen für Publikationen. Darin ist es ja 
auch sehr gut.

Autor: PeachPii (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für die zahlreichen Antworten, dass war sehr hilfreich.
Am schönsten fände ich natürlich open source Software, um sich nicht 
abhängig zu machen von NI Software und Hardware. Das ist ähnlich wie bei 
Vector, da fällt jede Box mit min. tausend Euro ins Gewicht. 
Andererseits muss man natürlich gucken was man will.
Bei MATLAB war bei einem VErsuch die Ausgabe irgendwie viel zu langsam.
Bei LabView weiß ich, dass es definitiv geht und ich weiß auch, dass 
wenn ich einen Plot implementiere, ich die Achsen immer frei skalieren 
kann und immer einen Überblick darüber habe was meine Messgerößen gerade 
machen.

Ich werde es jetzt zuerst einmal mit LabView probieren. Ich möchte eh 
stationäre Werte aufnehmen. Dafür soll das Programm aber automatisch 
jeden Wert anfahren. Dafür möchte ich dann verschiedene Toleranzbereiche 
festlegen. Diese möchte ich aber bequem übers Menu dynamisch ändern 
können. Wenn meine Größe im Betrieb z.B es nicht in den Bereich schafft, 
möchte ich diesen ein wenig vergrößern. Im Anschluss bestimme ich dann 
über ein Eingabefeld nach wieviel Sekunden der Wert erfasst und über 
welchen Zeitraum dieser wie gemittelt wird und wie groß die Zeitschritte 
sind. Dies wird dann entsprechend in eine Datei zur späteren Auswertung 
gespeichert. Dabei kann ich dann immer noch festlegen welche Bereiche 
der Kurve z.B. linear sind, denn dort würde ich nur wenige Stützpunkte 
aufnehmen. In interessanteren Bereichen würde ich mehr Punkte aufnehmen 
und es feiner auflösen. Würde ich das per Hand programmieren, wäre ich 
vermutlich mit meinen begrenzten Fähigkeiten ewig dran, besonders mit Qt 
/ C++ :D

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.