GUI für nodeMCU

[Moppi]

Hallo,

mit dem Titel war ich mir nicht ganz einig, ich hoffe der passt!

Ich bin jetzt etwas mutig und möchte mir Meinungen zu meinen Überlegungen einholen.

Noch nichts Genaues weiß man nicht. Aber ich versuche zu beschreiben, was ich will und traue mich auch, ein Bild dazu zu veröffentlichen.
Das Wesentliche kann man erkennen, Details nicht so, das ist gut. Bezeichnung / Arbeitstitel habe ich rausgelöscht, weil das noch nicht
geschützt ist (das ist etwas kostspielig), will aber den Namen, den ich seit 2012 verwende, auch nicht direkt verlieren.

Also erst mal das Bild:


Jetzt etwas Erklärung, was ich mir so überlegt habe:

Ich möchte eine Oberfläche für nodeMCU bauen, zum Programmieren. Das soll dann alles im Webbrowser laufen.
Aber nicht nur, um technische Abläufe zu programmieren, sondern auch rudimentäre grafische Oberflächen für Webbrowser.

Deshalb habe ich mich heute etwas mit meinen allesamt selbst programmierten Tools beschäftigt, die für so etwas tauglich sind.
Als ich alles so durchgeschaut habe, ist mir aufgefallen, dass im Prinzip nicht so viele Megabyte Daten notwendig sind.
D.h. vom Prinzip könnte ich alles auf ein nodeMCU drauf laden und von dort ausführen. Das einzige Manko wäre, dass dies
etwas langsam beim Laden wäre. Aber da müsste man mal sehen, wie das dann ich Echtzeit so aussieht, ob es wirklich brauchbar
ist oder die Ladezeiten einen dickeren Strich durch das Unternehmen machen.

Jedenfalls zeigt das Bild, worum es mir im wesentlichen geht. Ob ich das genau so für nodeMCU portieren würde, weiß ich noch nicht,
deshalb stelle ich das hier jetzt mal so vor.
Es existiert (unter Anderem) eine Möglichkeit Ablaufpläne zu erstellen, die sich auch untereinander verknüpfen lassen.
Dazu gibt es einen Debugger, also etwas, wo man sehen kann, was programmtechnisch abläuft. So dass man einen Plan auf Funktion
testen kann.
Rechts im Bild ist zu sehen, dass es eine Auswahl an Symbolen gibt und dass Eigenschaften änderbar sind. Die Symbole und deren
Funktion sind frei austauschbar, da könnte ich drauß machen, was ich wollte. Außer an der Größe, den Maßen würde ich nicht viel
ändern können.

Ich lasse das zunächst so stehen und warte auf Äußerungen dazu. Was ich beschrieben habe, wäre nur ein Teil dessen, was möglich wäre.
Das gesamte Projekt, was zurzeit auf einem von mir aufgesetztem Server läuft und im Webbrowser, hat weitaus mehr Funktionen
unter der Haube, als ich jetzt in Kürze darstellen könnte. Macht auch nicht so viel Sinn jetzt, weil ich den Umfang solcher Software
für nodeMCUs noch nicht kenne, das muss ich zunächst etwas abstecken. Deshalb warte ich hier auf Rückmeldungen, als Denkanstöße.



MfG

[HaWe]

sieht auf jeden Fall sehr beeindruckend aus!
Soll es generell dazu dienen, den ESP damit grafisch zu programmieren, ähnlich wie den Fischertechnik-Controller mit RoboPro oder Lego NXT/EV3 mit Scratch, NXT-G oder EV3-G, also als Ersatz für C++?

[Moppi]

Das könnte man machen. Theoretisch könnte man auch den gesamten Arduino-Code daraus generieren lassen.

Eigentlich wollte ich nur das einfache Erstellen von Webseiten, für Steuerungszwecke, auf dem nodeMCU ermöglichen.
Dann habe ich aber gesehen, dass noch viel mehr möglich wäre, wenn ich das für nodeMCU anpassen würde (also den Programmumfang abspecken - alle dann nicht notwendigen Funktionen in den Menüs rausnehmen etc. und notwendige Änderungen vornehmen).

- - - Aktualisiert - - -

Es existiert auch eine Skript-Sprache, mit der interne Programmabläufe erstellt und nachträglich hinzugefügt werden können (praktisch über die GUI-Oberfläche). Damit können auch diese Ablaufpläne ausgelesen und verarbeitet werden und vieles mehr.

[HaWe]

achso, zur Webseiten-Gestaltung...!
Das klingt super !!

[Moppi]

Zuerst werde ich mich auf Flussdiagramme konzentrieren.
Mal sehen, was da so die Grenzen sind, also inwieweit ich mein bisheriges Diagramm-Modell für das verwenden kann, was ich mir so in etwa vorstelle.
Z.Z. baue ich eine neue Oberfläche.

[Moppi]

Schön, dass ich mit dem Thema schon einmal begonnen habe, dann
kann ich gleich hier anknüpfen, da die Entwicklung nicht stehen
geblieben ist.


Stapelverarbeitung für Arduino und Co.


Man denkt immer wieder einmal über verschiedene Dinge nach.
So kam es gestern, dass ich wieder über die Geschichte mit
einer grafischen Oberfläche für nodeMCU nachgedacht habe.
Ich habe inzwischen damit angefangen - manchem wird es
vielleicht nicht entgangen sein - eine Stapelverarbeitung
für meine ATmega328P-PU, in Verbindung mit einem nodeMCU,
umzusetzen. Weg von der grafischen Oberfläche, die "alles"
möglich macht, hin zu dem, was ich zurzeit benötige.


Ich habe inzwischen einige Codezeilen, auch für nodeMCU ESP-12E,
geschrieben und eigentlich nicht mehr wirklich Lust, jedesmal
von vorn anzufangen, wenn ich nur mal "schnell" etwas
zusammenbauen und ausprobieren will. Also bin ich dazu
übergegangen, die Kontroller nur noch mit einer Firmware zu
versehen und diese zu ändern, sowie neu aufzuspielen, wenn
sich Hardwareschnittstellen ändern.
Meine Vorgehensweise sieht also so aus, dass ich eine
funktionierende Hardware baue, der am Ende nur die Steuerung
fehlt. So habe ich z.B. einen Kontroller für eine Ansteuerung
eines Motors. Hier muss ich softwareseitig so viel programmieren,
dass der Kontroller den Motor in jede Richtung drehen kann,
dass Odometriedaten erfasst werden und rudimentäre Grundfunktionen
(die auf jeden Fall notwendig oder wenigstens sinnvoll sind)
erstellt und auf den Kontroller, als Firmware, übertragen werden.
Dazu kommt noch die Kommunikation mit anderen Kontrollern, in
irgendeiner Form.
Was ich dann noch benötige ist eine simple Stapelverarbeitung. Um
die einzelnen Grundfunktionen des Kontrollers sinnvoll zu nutzen,
sowohl experimentell, als auch endgültig. Dazu gehören auch Befehle,
die nur der Auswertung dienen, so dass z.B. Werte verglichen und
geändert werden können und Befehle, die mit der Außenwelt
des Kontrollers direkt nichts zu tun haben, wie Vergleiche und
Sprungbefehle.


Meine Umsetzung ist nun die, dass jeder Kontroller, der flexibel
programmiert werden muss, diese Stapelverarbeitung in
die Firmware integriert bekommt. Der Mikrokontroller für
eine Motorsteuerung benötigt das nicht. Weil hier die Aufgaben
genau festgelegt sind und diese nicht mehr geändert werden müssen.
Ein übergeordneter Kontroller soll aber damit kommunizieren,
um aus einer einfachen Motoransteuerung eine sinnvolle Fahrt
zu machen, Daten zu sammeln und diese ggf. sichtbar zu machen,
indem die Daten zu einem nodeMCU transferiert und dort, über
WLAN, im Webbrowser sichtbar gemacht werden können. Dieser eine
übergeordnete Kontroller würde die Stapelverarbeitung bekommen
und wäre dann von außen, per WLAN und Webbrowser-Interface,
ansprechbar. Von einfachen Testszenarien, zum Analysieren bestimmter
Werte unter bestimmten Umständen, bis hin zu komplexen Aufgaben,
die auch - durch Ereignisse gesteuert - ausgeführt werden können.
Über die Nutzeroberfläche soll also die Programmierung und
Debugging durchgeführt werden.

Als Schnittstellen zur Übertragung der Programmdaten für
die Stapelverarbeitung habe ich derzeit I2C und serielle
Schnittstelle. Die Software für die Kontroller muss hierfür
angepasst werden.

Wenn alles gut verläuft, kann ich mir vorstellen, später nur
Projekte auf dieser Grundlage umzusetzen. Was dann eben so
aussehen könnte, dass ich Grundfunktionen der Firmware (vor allem
Hardwareschnittstellen) projektbedingt entferne, ändere oder
hinzufüge und diese dann auf den Zielkontroller aufspiele, inkl.
Stapelverarbeitungsmodul.


Also gestern dachte ich darüber nach und kam auf die Idee,
doch schon früher die 1GB-SD-Karte zu nutzen, die ich besitze.
Ich könnte auf dieser SD-Karte sämtliche Dateien für
das Webbrowser-Interface speichern und kann außerdem alle Daten
zu allen Kontrollern, verschiedener Projekte halten. Somit
könnte ich den Datenballast auf einem nodeMCU reduzieren und
dort vor allem nur die Stapelverarbeitungscodes unterbringen, die
auch notwendig sind.

Zurzeit überlege ich mir, wie die grafische Oberfläche gestaltet
sein soll. Hier will ich mir nicht zu viel vornehmen und mich
auf das Nötige beschränken. An dieser Stelle kann es hilfreich
sein, die Meinung und evtl. Vorschläge anderer User zu kennen,
um nicht am Ende irgendwann festzustellen, dass man dies oder
jenes hätte berücksichtigen sollen oder anders machen könnte.
Aus Erfahrung weiß ich, dass sich manche Sachen später nur
schwer ändern lassen.


So weit ...


Freundlichen Gruß!

[inka]

machst du den umbruch manuell? wozu denn das?

[Moppi]

Fragen zur Textformatierung bitte im Forum Offtopic-und-Community-Tratsch stellen!


Ich habe vor, einen Bereich in die Oberfläche einzubauen, der benutzerdefiniert gestaltet werden kann.
Er könnte dann eingeblendet und mit Inhalt (Buttons, Textfelder usw.) gefüllt werden.
Vornehmlich soll das für Buttons gedacht sein, damit eigene Scripte, die über die Oberfläche zusammengestellt wurden, aufgerufen werden können.


MfG

[inka]

hallo,

also es ist schon alles sehr theoretisch, was du da schreibst...
Am anfang hast du ein bild veröffentlicht:

https://www.roboternetz.de/community...8&d=1572611067

ist es dann - wenn's denn fertig ist - sowas wie eine komplexere, umfangreichere "programmieroberfläche" wie z. b. die arduino IDE? Oder sowas wie platformio für atom?

[Moppi]

hallo,

also es ist schon alles sehr theoretisch, was du da schreibst...

Ja, ich weiß. ist auch nicht einfach, etwas zu beschreiben, was zurzeit als diffuser Nebel in meinem Hirn herumspukt.

Am Anfang stand eine Idee, eine bestehende Anwendung umzufriemeln.
Habe ich nun gemacht. Wobei ich mir das, was ich jetzt für das Projekt brauche, aus der Anwendung herauspicke, bzw. alle anderen Funktionen entferne.
Was ich belassen will, habe ich oben aufgeführt.

Du hast das alte Bild aus dem ersten Beitrag angeführt. Im Blog habe ich ein aktuelleres Bild gepostet.
Da es auf dem Server vorhanden ist, kann ich es einfach hier nochmal tun:
Bild hier  

Hier kann man schon mehr erahnen und bekommt ein wenig einen Überblick.
"Platformio" kenne ich nicht. Habe ich mal am Rande gelesen, mehr Kontakt dazu hatte ich nicht.

Die Arduino-IDE ist eine Programmierumgebung für C-Quellcode, inkl. Compiler und Tools zum Hochladen auf einen µC.
Das will ich nicht nachbauen, das leistet auch die Benutzeroberfläche bisher nicht. Bisher deshalb, weil selbst das
aber auch möglich wäre - weit entfernt theoretisch machbar. Das ist aber nicht Sinn der Sache.

Bei dem, was ich baue, möchte ich mir etwas Komfort schaffen. So könnte ich Quelltextfragmente (Funktionen)
aus der Arduino-IDE, die ich dort ausprobiert habe, archivieren und mit Attributen versehen. Dazu ein Werkzeug in
Scriptsprache, das aus allen Fragmenten einen kompletten Quelltext erzeugen kann, den ich dann einfach kopieren könnte,
um ihn in der Arduino-IDE einzufügen und dort zu kompilieren. Das ist aber jetzt nicht Hauptaugenmerk. Zuerst möchte
ich komfortabel auf Funktionen, z.B. für das Prototype Car II, zugreifen können. Werte aus dem Gerät sichtbar machen,
wo man sonst zu LEDs oder Displays greifen würde. Ich möchte gerne Zugriff auf die Funktionen des Prototyps haben,
möglichst auf jede Einzelne. Wie programmiert man beispielsweise, dass so ein Gerät geradeaus fährt? - Man schreibt Code,
der die Encoderwerte auswertet, wo Bedingungen im Code programmiert sind, um bestimmte Reaktionen der Software auf
äußere Einflüsse zu erhalten. Dann kompiliert man den Code, lädt ihn auf den µC und probiert alles aus. Diese Hürden kann
ich umgehen, wenn ich über eine Oberfläche direkten Zugriff, auch programmtechnisch habe. Dazu habe ich mir schon
eine Ablaufsteuerung eingebaut, mit der es möglich ist, Funktionen des Gerätes einzeln anzusprechen - ich nenne es
Stapelverarbeitung. Diese Verarbeitungsstapel kann ich in den µC laden, wenn das Gerät in Betrieb ist. Wenn das Gerät
am Anfang einfach nur stillsteht, könnte ich über die Oberfläche schauen, welche Variablen (Werte) und Funktionen,
das Gerät anbietet (Ultraschallmessung Sensor 1 .. Sensor 2... , Motor 1 .. Motor 2 usw.). Dann kann ich über
die Benutzeroberfläche programmieren, den Code in das Gerät laden und ausführen lassen. Sofern es irgendwelche
Mitteilungen über Werte (oder andere Rückmeldungen) geben soll, kann ich die vom Gerät in die Benutzeroberfläche
übertragen und dort darstellen, sowie weiter verarbeiten. Möglich wäre sicher auch, Prorammabläufe nur über
die Oberfläche zu erstellen und dort auszuführen, so dass das Protoype Car II (jetzt als Beispiel) nur ferngesteuert wird,
damit nicht autonom wäre (Benutzeroberfläche geschlossen: Gerät tot).
Die Möglichkeiten, was ginge sind leider sehr vielfältig und zahlreich, so dass man kaum alles beschreiben kann.

Weil Du schriebst: "wenn's denn fertig ist" ...
Die Einzelteile sind im Grunde alle schon fertig, muss nur noch alles sinnvoll miteinander verbinden.
Alles, was ich oben aufführte (7 Punkte) ist fertig, funktioniert also bereits jetzt. Also das Werkzeug ist schon fertig.
Nun muss ich damit die passende Programmierung vornehmen, um das zu umzusetzen, was ich mir (oder andere sich)
vorstelle(n). Und dafür habe ich noch keinen richtigen Plan, was ich alles genau brauchen werde (programmieren muss),
weil ich keine Vorlage dafür habe. Deshalb ist vieles noch theoretisch. Aber noch ein Zeitpunkt, um das was noch folgt,
zu beinflussen, Ideen einzubringen oder Bedenken zu äußern.

Ich habe den Eindruck es wird nicht mehr so lange dauern, dass es "fertig" wird. Dann ist es das allerdings für dieses
Forum "Ideen zu geplanten eigenen Projekten" auch. Später würde ich das woanders fort führen.



MfG